* ps.* : new PS demuxer (still incomplete)

 * dvdnav.c: begin of a dvdnav plugin. It's more to test that to be a real
 plugin for now. (a lot of design problems are raised with it).

modules/demux/ps.c

+/*****************************************************************************
+ * ps.c
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id: ps.c,v 1.1 2004/01/17 22:32:50 fenrir Exp $
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+/*****************************************************************************
+ * Preamble
+ *****************************************************************************/
+#include <stdlib.h>                                      /* malloc(), free() */
+
+#include <vlc/vlc.h>
+#include <vlc/input.h>
+
+#include "ps.h"
+
+/* TODO:
+ *  - re-add pre-scanning.
+ *  - ...
+ */
+
+/*****************************************************************************
+ * Module descriptor
+ *****************************************************************************/
+static int  Open    ( vlc_object_t * );
+static void Close  ( vlc_object_t * );
+
+vlc_module_begin();
+    set_description( "PS demuxer" );
+    set_capability( "demux2", 0 );
+    set_callbacks( Open, Close );
+    add_shortcut( "ps2" );
+vlc_module_end();
+
+/*****************************************************************************
+ * Local prototypes
+ *****************************************************************************/
+
+struct demux_sys_t
+{
+    ps_track_t   tk[PS_TK_COUNT];
+
+    int64_t     i_scr;
+    int         i_mux_rate;
+};
+
+static int Demux  ( demux_t *p_demux );
+static int Control( demux_t *p_demux, int i_query, va_list args );
+
+static int      ps_pkt_resynch( stream_t *, uint32_t *pi_code );
+static block_t *ps_pkt_read   ( stream_t *, uint32_t i_code );
+
+/*****************************************************************************
+ * Open
+ *****************************************************************************/
+static int Open( vlc_object_t *p_this )
+{
+    demux_t     *p_demux = (demux_t*)p_this;
+    demux_sys_t *p_sys;
+
+    uint8_t     *p_peek;
+
+    if( stream_Peek( p_demux->s, &p_peek, 4 ) < 4 )
+    {
+        msg_Err( p_demux, "cannot peek" );
+        return VLC_EGENERIC;
+    }
+
+    if( p_peek[0] != 0 || p_peek[1] != 0 || p_peek[2] != 1 || p_peek[3] < 0xb9 )
+    {
+        msg_Warn( p_demux, "this does not look like an MPEG PS stream, continuing anyway" );
+    }
+
+    /* Fill p_demux field */
+    p_demux->pf_demux = Demux;
+    p_demux->pf_control = Control;
+    p_demux->p_sys = p_sys = malloc( sizeof( demux_sys_t ) );
+
+    /* Init p_sys */
+    p_sys->i_mux_rate = 0;
+    p_sys->i_scr      = -1;
+
+    ps_track_init( p_sys->tk );
+
+    /* TODO prescanning of ES */
+
+    return VLC_SUCCESS;
+}
+
+/*****************************************************************************
+ * Close
+ *****************************************************************************/
+static void Close( vlc_object_t *p_this )
+{
+    demux_t     *p_demux = (demux_t*)p_this;
+    demux_sys_t *p_sys = p_demux->p_sys;
+
+    free( p_sys );
+}
+
+/*****************************************************************************
+ * Demux:
+ *****************************************************************************/
+static int Demux( demux_t *p_demux )
+{
+    demux_sys_t *p_sys = p_demux->p_sys;
+    int i_ret;
+    uint32_t i_code;
+    block_t  *p_pkt;
+
+    i_ret = ps_pkt_resynch( p_demux->s, &i_code );
+    if( i_ret < 0 )
+    {
+        return 0;
+    }
+    else if( i_ret == 0 )
+    {
+        msg_Warn( p_demux, "garbage at input" );
+        return 1;
+    }
+
+    if( ( p_pkt = ps_pkt_read( p_demux->s, i_code ) ) == NULL )
+    {
+        return 0;
+    }
+
+    switch( i_code )
+    {
+        case 0x1b9:
+            block_Release( p_pkt );
+            break;
+        case 0x1ba:
+        {
+            int i_mux_rate;
+
+            if( !ps_pkt_parse_pack( p_pkt, &p_sys->i_scr, &i_mux_rate ) )
+            {
+                es_out_Control( p_demux->out, ES_OUT_SET_PCR, p_sys->i_scr );
+                if( i_mux_rate > 0 )
+                {
+                    p_sys->i_mux_rate = i_mux_rate;
+                }
+            }
+            block_Release( p_pkt );
+            break;
+        }
+        case 0x1bb:
+            if( !ps_pkt_parse_system( p_pkt, p_sys->tk ) )
+            {
+                int i;
+                for( i = 0; i < PS_TK_COUNT; i++ )
+                {
+                    ps_track_t *tk = &p_sys->tk[i];
+
+                    if( tk->b_seen && !tk->es && tk->fmt.i_cat != UNKNOWN_ES )
+                    {
+                        tk->es = es_out_Add( p_demux->out, &tk->fmt );
+                    }
+                }
+            }
+            block_Release( p_pkt );
+            break;
+        case 0x1bc:
+            /* TODO PSM */
+            block_Release( p_pkt );
+            break;
+
+        default:
+        {
+            int        i_id = ps_pkt_id( p_pkt );
+            if( i_id >= 0xc0 )
+            {
+                ps_track_t *tk = &p_sys->tk[PS_ID_TO_TK(i_id)];
+
+                if( !tk->b_seen )
+                {
+                    if( !ps_track_fill( tk, i_id ) )
+                    {
+                        tk->es = es_out_Add( p_demux->out, &tk->fmt );
+                    }
+                    tk->b_seen = VLC_TRUE;
+                }
+                if( tk->b_seen && tk->es && !ps_pkt_parse_pes( p_pkt, tk->i_skip ) )
+                {
+                    es_out_Send( p_demux->out, tk->es, p_pkt );
+                }
+                else
+                {
+                    block_Release( p_pkt );
+                }
+            }
+            else
+            {
+                block_Release( p_pkt );
+            }
+            break;
+        }
+    }
+    return 1;
+}
+
+/*****************************************************************************
+ * Control:
+ *****************************************************************************/
+static int Control( demux_t *p_demux, int i_query, va_list args )
+{
+    demux_sys_t *p_sys = p_demux->p_sys;
+    double f, *pf;
+    int64_t i64, *pi64;
+
+    switch( i_query )
+    {
+        case DEMUX_GET_POSITION:
+            pf = (double*) va_arg( args, double* );
+            i64 = stream_Size( p_demux->s );
+            if( i64 > 0 )
+            {
+                *pf = (double)stream_Tell( p_demux->s ) / (double)i64;
+            }
+            else
+            {
+                *pf = 0.0;
+            }
+            return VLC_SUCCESS;
+        case DEMUX_SET_POSITION:
+            f = (double) va_arg( args, double );
+            i64 = stream_Size( p_demux->s );
+
+            es_out_Control( p_demux->out, ES_OUT_RESET_PCR );
+
+            return stream_Seek( p_demux->s, (int64_t)(i64 * f) );
+
+        case DEMUX_GET_TIME:
+            pi64 = (int64_t*)va_arg( args, int64_t * );
+            if( p_sys->i_mux_rate > 0 )
+            {
+                *pi64 = (int64_t)1000000 * ( stream_Tell( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
+                return VLC_SUCCESS;
+            }
+            *pi64 = 0;
+            return VLC_EGENERIC;
+
+        case DEMUX_GET_LENGTH:
+            pi64 = (int64_t*)va_arg( args, int64_t * );
+            if( p_sys->i_mux_rate > 0 )
+            {
+                *pi64 = (int64_t)1000000 * ( stream_Size( p_demux->s ) / 50 ) / p_sys->i_mux_rate;
+                return VLC_SUCCESS;
+            }
+            *pi64 = 0;
+            return VLC_EGENERIC;
+
+        case DEMUX_SET_TIME:
+        case DEMUX_GET_FPS:
+        default:
+            return VLC_EGENERIC;
+    }
+}
+
+/*****************************************************************************
+ * Divers:
+ *****************************************************************************/
+
+/* PSResynch: resynch on a systeme starcode
+ *  It doesn't skip more than 512 bytes
+ *  -1 -> error, 0 -> not synch, 1 -> ok
+ */
+static int ps_pkt_resynch( stream_t *s, uint32_t *pi_code )
+{
+    uint8_t *p_peek;
+    int     i_peek;
+    int     i_skip;
+
+    if( stream_Peek( s, &p_peek, 4 ) < 4 )
+    {
+        return -1;
+    }
+    if( p_peek[0] == 0 && p_peek[1] == 0 && p_peek[2] == 1 && p_peek[3] >= 0xb9 )
+    {
+        *pi_code = 0x100 | p_peek[3];
+        return 1;
+    }
+
+    if( ( i_peek = stream_Peek( s, &p_peek, 512 ) ) < 4 )
+    {
+        return -1;
+    }
+    i_skip = 0;
+
+    for( ;; )
+    {
+        if( i_peek < 4 )
+        {
+            break;
+        }
+        if( p_peek[0] == 0 && p_peek[1] == 0 && p_peek[2] == 1 && p_peek[3] >= 0xb9 )
+        {
+            *pi_code = 0x100 | p_peek[3];
+            return stream_Read( s, NULL, i_skip ) == i_skip ? 1 : -1;
+        }
+
+        p_peek++;
+        i_peek--;
+        i_skip++;
+    }
+    return stream_Read( s, NULL, i_skip ) == i_skip ? 0 : -1;
+}
+
+static block_t *ps_pkt_read( stream_t *s, uint32_t i_code )
+{
+    uint8_t *p_peek;
+    int      i_peek = stream_Peek( s, &p_peek, 14 );
+    int      i_size = ps_pkt_size( p_peek, i_peek );
+
+    if( i_size > 0 )
+    {
+        return  stream_Block( s, i_size );
+    }
+    return NULL;
+}

modules/demux/ps.h

+/*****************************************************************************
+ * ps.h: Program Stream demuxer helper
+ *****************************************************************************
+ * Copyright (C) 2004 VideoLAN
+ * $Id: ps.h,v 1.1 2004/01/17 22:32:50 fenrir Exp $
+ *
+ * Authors: Laurent Aimar <fenrir@via.ecp.fr>
+ *
+ * This program is free software; you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation; either version 2 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111, USA.
+ *****************************************************************************/
+
+#define PS_TK_COUNT (512 - 0xc0)
+#define PS_ID_TO_TK( id ) ((id) <= 0xff ? (id) - 0xc0 : ((id)&0xff) + (256 - 0xc0))
+
+typedef struct
+{
+    vlc_bool_t  b_seen;
+    int         i_skip;
+    es_out_id_t *es;
+    es_format_t fmt;
+} ps_track_t;
+
+/* Init a set of track */
+static inline void ps_track_init( ps_track_t tk[PS_TK_COUNT] )
+{
+    int i;
+    for( i = 0; i < PS_TK_COUNT; i++ )
+    {
+        tk[i].b_seen = VLC_FALSE;
+        tk[i].i_skip = 0;
+        tk[i].es     = NULL;
+        es_format_Init( &tk[i].fmt, UNKNOWN_ES, 0 );
+    }
+}
+
+/* From id fill i_skip and es_format_t */
+static inline int ps_track_fill( ps_track_t *tk, int i_id )
+{
+    tk->i_skip = 0;
+    if( ( i_id&0xff00 ) == 0xbd00 )
+    {
+        if( ( i_id&0xf8 ) == 0x88 )
+        {
+            es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'd', 't', 's', ' ' ) );
+            tk->i_skip = 1;
+        }
+        else if( ( i_id&0xf0 ) == 0x80 )
+        {
+            es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'a', '5', '2', ' ' ) );
+            tk->i_skip = 4;
+        }
+        else if( ( i_id&0xe0 ) == 0x20 )
+        {
+            es_format_Init( &tk->fmt, SPU_ES, VLC_FOURCC( 's', 'p', 'u', ' ' ) );
+            tk->i_skip = 1;
+        }
+        else if( ( i_id&0xf0 ) == 0xa0 )
+        {
+            es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'l', 'p', 'c', 'm' ) );
+            tk->i_skip = 1;
+        }
+        else
+        {
+            es_format_Init( &tk->fmt, UNKNOWN_ES, 0 );
+            return VLC_EGENERIC;
+        }
+    }
+    else
+    {
+        if( ( i_id&0xf0 ) == 0xe0 )
+        {
+            es_format_Init( &tk->fmt, VIDEO_ES, VLC_FOURCC( 'm', 'p', 'g', 'v' ) );
+        }
+        else if( ( i_id&0xe0 ) == 0xc0 )
+        {
+            es_format_Init( &tk->fmt, AUDIO_ES, VLC_FOURCC( 'm', 'p', 'g', 'a' ) );
+        }
+        else
+        {
+            es_format_Init( &tk->fmt, UNKNOWN_ES, 0 );
+            return VLC_EGENERIC;
+        }
+    }
+    return VLC_SUCCESS;
+}
+
+/* return the id of a PES (should be valid) */
+static inline int ps_pkt_id( block_t *p_pkt )
+{
+    if( p_pkt->p_buffer[3] == 0xbd &&
+        p_pkt->i_buffer >= 9 &&
+        p_pkt->i_buffer >= 9 + p_pkt->p_buffer[8] )
+    {
+        return 0xbd00 | p_pkt->p_buffer[9+p_pkt->p_buffer[8]];
+    }
+    return p_pkt->p_buffer[3];
+}
+
+/* return the size of the next packet
+ * XXX you need to give him at least 14 bytes (and it need to start as a
+ * valid packet) */
+static inline int ps_pkt_size( uint8_t *p, int i_peek )
+{
+    if( p[3] == 0xb9 && i_peek >= 4 )
+    {
+        return 4;
+    }
+    else if( p[3] == 0xba )
+    {
+        if( (p[4] >> 6) == 0x01 && i_peek >= 14 )
+        {
+            return 14 + (p[13]&0x07);
+        }
+        else if( (p[4] >> 4) == 0x02 && i_peek >= 12 )
+        {
+            return 12;
+        }
+        return -1;
+    }
+    else if( i_peek >= 6 )
+    {
+        return 6 + ((p[4]<<8) | p[5] );
+    }
+    return -1;
+}
+
+/* parse a PACK PES */
+static inline int ps_pkt_parse_pack( block_t *p_pkt, int64_t *pi_scr, int *pi_mux_rate )
+{
+    uint8_t *p = p_pkt->p_buffer;
+    if( p_pkt->i_buffer >= 14 && (p[4] >> 6) == 0x01 )
+    {
+        *pi_scr =((((int64_t)p[4]&0x38) << 27 )|
+                  (((int64_t)p[4]&0x03) << 28 )|
+                   ((int64_t)p[5] << 20 )|
+                  (((int64_t)p[6]&0xf8) << 12 )|
+                  (((int64_t)p[6]&0x03) << 13 )|
+                   ((int64_t)p[7] << 5 )|
+                   ((int64_t)p[8] >> 3 )) * 100 / 9;
+
+        *pi_mux_rate = ( p[10] << 14 )|( p[11] << 6 )|( p[12] >> 2);
+    }
+    else if( p_pkt->i_buffer >= 12 && (p[4] >> 4) == 0x02 )
+    {
+        *pi_scr =((((int64_t)p[4]&0x0e) << 29 )|
+                   ((int64_t)p[5] << 22 )|
+                  (((int64_t)p[6]&0xfe) << 14 )|
+                   ((int64_t)p[7] <<  7 )|
+                   ((int64_t)p[8] >> 1 )) * 100 / 9;
+
+        *pi_mux_rate = ( ( p[9]&0x7f )<< 15 )|( p[10] << 7 )|( p[11] >> 1);
+    }
+    else
+    {
+        return VLC_EGENERIC;
+    }
+    return VLC_SUCCESS;
+}
+
+/* Parse a SYSTEM PES */
+static inline int ps_pkt_parse_system( block_t *p_pkt, ps_track_t tk[PS_TK_COUNT] )
+{
+    uint8_t *p = &p_pkt->p_buffer[6 + 3 + 1 + 1 + 1];
+
+    while( p < &p_pkt->p_buffer[p_pkt->i_buffer] )
+    {
+        /* msg_Dbg( p_demux, "   SYSTEM_START_CODE: id=0x%x", p[0] ); */
+        if( p[0] != 0xbd )
+        {
+            int i_id = p[0];
+            int i_tk = PS_ID_TO_TK( i_id );
+
+            if( !tk[i_tk].b_seen )
+            {
+                if( !ps_track_fill( &tk[i_tk], i_id ) )
+                {
+                    tk[i_tk].b_seen = VLC_TRUE;
+                }
+            }
+            p += 2;
+        }
+        p++;
+    }
+    return VLC_SUCCESS;
+}
+
+/* Parse a PES (and skip i_skip_extra in the payload) */
+static inline int ps_pkt_parse_pes( block_t *p_pes, int i_skip_extra )
+{
+    uint8_t header[30];
+    int     i_skip  = 0;
+
+    memcpy( header, p_pes->p_buffer, __MIN( p_pes->i_buffer, 30 ) );
+
+    switch( header[3] )
+    {
+        case 0xBC:  /* Program stream map */
+        case 0xBE:  /* Padding */
+        case 0xBF:  /* Private stream 2 */
+        case 0xB0:  /* ECM */
+        case 0xB1:  /* EMM */
+        case 0xFF:  /* Program stream directory */
+        case 0xF2:  /* DSMCC stream */
+        case 0xF8:  /* ITU-T H.222.1 type E stream */
+            i_skip = 6;
+            break;
+
+        default:
+            if( ( header[6]&0xC0 ) == 0x80 )
+            {
+                /* mpeg2 PES */
+                i_skip = header[8] + 9;
+
+                if( header[7]&0x80 )    /* has pts */
+                {
+                    p_pes->i_pts = ((mtime_t)(header[ 9]&0x0e ) << 29)|
+                                    (mtime_t)(header[10] << 22)|
+                                   ((mtime_t)(header[11]&0xfe) << 14)|
+                                    (mtime_t)(header[12] << 7)|
+                                    (mtime_t)(header[12] >> 1);
+
+                    if( header[7]&0x40 )    /* has dts */
+                    {
+                         p_pes->i_dts = ((mtime_t)(header[13]&0x0e ) << 29)|
+                                         (mtime_t)(header[14] << 22)|
+                                        ((mtime_t)(header[15]&0xfe) << 14)|
+                                         (mtime_t)(header[16] << 7)|
+                                         (mtime_t)(header[17] >> 1);
+                    }
+                }
+            }
+            else
+            {
+                i_skip = 6;
+                while( i_skip < 23 && header[i_skip] == 0xff )
+                {
+                    i_skip++;
+                }
+                if( i_skip == 23 )
+                {
+                    /* msg_Err( p_demux, "too much MPEG-1 stuffing" ); */
+                    return VLC_EGENERIC;
+                }
+                if( ( header[i_skip] & 0xC0 ) == 0x40 )
+                {
+                    i_skip += 2;
+                }
+
+                if(  header[i_skip]&0x20 )
+                {
+                     p_pes->i_pts = ((mtime_t)(header[i_skip]&0x0e ) << 29)|
+                                     (mtime_t)(header[i_skip+1] << 22)|
+                                    ((mtime_t)(header[i_skip+2]&0xfe) << 14)|
+                                     (mtime_t)(header[i_skip+3] << 7)|
+                                     (mtime_t)(header[i_skip+4] >> 1);
+
+                    if( header[i_skip]&0x10 )    /* has dts */
+                    {
+                         p_pes->i_dts = ((mtime_t)(header[i_skip+5]&0x0e ) << 29)|
+                                         (mtime_t)(header[i_skip+6] << 22)|
+                                        ((mtime_t)(header[i_skip+7]&0xfe) << 14)|
+                                         (mtime_t)(header[i_skip+8] << 7)|
+                                         (mtime_t)(header[i_skip+9] >> 1);
+                         i_skip += 10;
+                    }
+                    else
+                    {
+                        i_skip += 5;
+                    }
+                }
+                else
+                {
+                    i_skip += 1;
+                }
+            }
+    }
+
+    i_skip += i_skip_extra;
+
+    if( p_pes->i_buffer <= i_skip )
+    {
+        return VLC_EGENERIC;
+    }
+
+    p_pes->p_buffer += i_skip;
+    p_pes->i_buffer -= i_skip;
+
+    p_pes->i_dts = 100 * p_pes->i_dts / 9;
+    p_pes->i_pts = 100 * p_pes->i_pts / 9;
+
+    return VLC_SUCCESS;
+}