modules/demux/pva.c

   1 /*****************************************************************************
   2  * pva.c: PVA demuxer
   3  *****************************************************************************
   4  * Copyright (C) 2004 VLC authors and VideoLAN
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *
   9  * This program is free software; you can redistribute it and/or modify it
  10  * under the terms of the GNU Lesser General Public License as published by
  11  * the Free Software Foundation; either version 2.1 of the License, or
  12  * (at your option) any later version.
  13  *
  14  * This program is distributed in the hope that it will be useful,
  15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  17  * GNU Lesser General Public License for more details.
  18  *
  19  * You should have received a copy of the GNU Lesser General Public License
  20  * along with this program; if not, write to the Free Software Foundation,
  21  * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  22  *****************************************************************************/
  23
  24 /*****************************************************************************
  25  * Preamble
  26  *****************************************************************************/
  27
  28 #ifdef HAVE_CONFIG_H
  29 # include "config.h"
  30 #endif
  31
  32 #include <vlc_common.h>
  33 #include <vlc_plugin.h>
  34 #include <vlc_demux.h>
  35
  36 #include "mpeg/pes.h"
  37
  38 /*****************************************************************************
  39  * Module descriptor
  40  *****************************************************************************/
  41 static int  Open    ( vlc_object_t * );
  42 static void Close  ( vlc_object_t * );
  43
  44 vlc_module_begin ()
  45     set_description( N_("PVA demuxer" ) )
  46     set_capability( "demux", 10 )
  47     set_category( CAT_INPUT )
  48     set_subcategory( SUBCAT_INPUT_DEMUX )
  49     set_callbacks( Open, Close )
  50     add_shortcut( "pva" )
  51 vlc_module_end ()
  52
  53 /*****************************************************************************
  54  * Local prototypes
  55  *****************************************************************************/
  56
  57 typedef struct
  58 {
  59     es_out_id_t *p_video;
  60     es_out_id_t *p_audio;
  61
  62     /* counter */
  63     int          i_vc;
  64     int          i_ac;
  65
  66     /* audio/video block */
  67     block_t     *p_pes; /* audio */
  68     block_t     *p_es;  /* video */
  69
  70     int64_t     b_pcr_audio;
  71 } demux_sys_t;
  72
  73 static int  Demux   ( demux_t *p_demux );
  74 static int  Control ( demux_t *p_demux, int i_query, va_list args );
  75
  76 static int  ReSynch ( demux_t * );
  77 static void ParsePES( demux_t * );
  78
  79 /*****************************************************************************
  80  * Open
  81  *****************************************************************************/
  82 static int Open( vlc_object_t *p_this )
  83 {
  84     demux_t     *p_demux = (demux_t*)p_this;
  85     demux_sys_t *p_sys;
  86     es_format_t  fmt;
  87     const uint8_t *p_peek;
  88
  89     if( vlc_stream_Peek( p_demux->s, &p_peek, 8 ) < 8 ) return VLC_EGENERIC;
  90     if( p_peek[0] != 'A' || p_peek[1] != 'V' || p_peek[4] != 0x55 )
  91     {
  92         /* In case we had forced this demuxer we try to resynch */
  93         if( !p_demux->obj.force || ReSynch( p_demux ) )
  94             return VLC_EGENERIC;
  95     }
  96
  97     p_sys = malloc( sizeof( demux_sys_t ) );
  98     if( unlikely(p_sys == NULL) )
  99         return VLC_ENOMEM;
 100
 101     /* Fill p_demux field */
 102     p_demux->pf_demux = Demux;
 103     p_demux->pf_control = Control;
 104     p_demux->p_sys = p_sys;
 105
 106     /* Register one audio and one video stream */
 107     es_format_Init( &fmt, AUDIO_ES, VLC_CODEC_MPGA );
 108     fmt.b_packetized = false;
 109     p_sys->p_audio = es_out_Add( p_demux->out, &fmt );
 110
 111     es_format_Init( &fmt, VIDEO_ES, VLC_CODEC_MPGV );
 112     fmt.b_packetized = false;
 113     p_sys->p_video = es_out_Add( p_demux->out, &fmt );
 114
 115     p_sys->i_vc    = -1;
 116     p_sys->i_ac    = -1;
 117     p_sys->p_pes   = NULL;
 118     p_sys->p_es    = NULL;
 119
 120     p_sys->b_pcr_audio = false;
 121
 122     return VLC_SUCCESS;
 123 }
 124
 125 /*****************************************************************************
 126  * Close
 127  *****************************************************************************/
 128 static void Close( vlc_object_t *p_this )
 129 {
 130     demux_t     *p_demux = (demux_t*)p_this;
 131     demux_sys_t *p_sys = p_demux->p_sys;
 132
 133     block_ChainRelease( p_sys->p_es );
 134     block_ChainRelease( p_sys->p_pes );
 135
 136     free( p_sys );
 137 }
 138
 139
 140 /*****************************************************************************
 141  * Demux:
 142  *****************************************************************************
 143  * See http://multimedia.cx/mirror/av_format_v1.pdf
 144  *****************************************************************************/
 145 static int Demux( demux_t *p_demux )
 146 {
 147     demux_sys_t *p_sys = p_demux->p_sys;
 148
 149     const uint8_t *p_peek;
 150     int         i_size;
 151     block_t     *p_frame;
 152     int64_t     i_pts;
 153     int         i_skip;
 154
 155     if( vlc_stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
 156     {
 157         msg_Warn( p_demux, "eof ?" );
 158         return VLC_DEMUXER_EOF;
 159     }
 160     if( p_peek[0] != 'A' || p_peek[1] != 'V' || p_peek[4] != 0x55 )
 161     {
 162         msg_Warn( p_demux, "lost synchro" );
 163         if( ReSynch( p_demux ) )
 164         {
 165             return VLC_DEMUXER_EGENERIC;
 166         }
 167         if( vlc_stream_Peek( p_demux->s, &p_peek, 8 ) < 8 )
 168         {
 169             msg_Warn( p_demux, "eof ?" );
 170             return VLC_DEMUXER_EOF;
 171         }
 172     }
 173
 174     i_size = GetWBE( &p_peek[6] );
 175     switch( p_peek[2] )
 176     {
 177         case 0x01:  /* VideoStream */
 178             if( p_sys->i_vc < 0 )
 179             {
 180                 msg_Dbg( p_demux, "first packet for video" );
 181             }
 182             else if( ((p_sys->i_vc + 1)&0xff) != p_peek[3] )
 183             {
 184                 msg_Dbg( p_demux, "packet lost (video)" );
 185                 if( p_sys->p_es )
 186                 {
 187                     block_ChainRelease( p_sys->p_es );
 188                     p_sys->p_es = NULL;
 189                 }
 190             }
 191             p_sys->i_vc = p_peek[3];
 192
 193             /* read the PTS and potential extra bytes TODO: make it a bit more optimised */
 194             i_pts = -1;
 195             i_skip = 8;
 196             if( p_peek[5]&0x10 )
 197             {
 198                 int i_pre = p_peek[5]&0x3;
 199
 200                 if( ( p_frame = vlc_stream_Block( p_demux->s, 8 + 4 + i_pre ) ) )
 201                 {
 202                     i_pts = GetDWBE( &p_frame->p_buffer[8] );
 203                     if( p_frame->i_buffer > 12 )
 204                     {
 205                         p_frame->p_buffer += 12;
 206                         p_frame->i_buffer -= 12;
 207                         block_ChainAppend( &p_sys->p_es, p_frame );
 208                     }
 209                     else
 210                     {
 211                         block_Release( p_frame );
 212                     }
 213                 }
 214                 i_size -= 4 + i_pre;
 215                 i_skip  = 0;
 216                 /* Set PCR */
 217                 if( ( p_frame = p_sys->p_es ) )
 218                 {
 219
 220                     if( p_frame->i_pts != VLC_TICK_INVALID && !p_sys->b_pcr_audio )
 221                     {
 222                         es_out_SetPCR( p_demux->out, p_frame->i_pts);
 223                     }
 224
 225                     p_frame = block_ChainGather( p_frame );
 226                     if( likely(p_frame) )
 227                         es_out_Send( p_demux->out, p_sys->p_video, p_frame );
 228
 229                     p_sys->p_es = NULL;
 230                 }
 231             }
 232
 233             if( ( p_frame = vlc_stream_Block( p_demux->s, i_size + i_skip ) ) )
 234             {
 235                 p_frame->p_buffer += i_skip;
 236                 p_frame->i_buffer -= i_skip;
 237                 if( i_pts >= 0 )
 238                     p_frame->i_pts = FROM_SCALE(i_pts);
 239                 block_ChainAppend( &p_sys->p_es, p_frame );
 240             }
 241             break;
 242
 243         case 0x02:  /* MainAudioStream */
 244             if( p_sys->i_ac < 0 )
 245             {
 246                 msg_Dbg( p_demux, "first packet for audio" );
 247             }
 248             else if( ((p_sys->i_ac + 1)&0xff) != p_peek[3] )
 249             {
 250                 msg_Dbg( p_demux, "packet lost (audio)" );
 251                 if( p_sys->p_pes )
 252                 {
 253                     block_ChainRelease( p_sys->p_pes );
 254                     p_sys->p_pes = NULL;
 255                 }
 256             }
 257             p_sys->i_ac = p_peek[3];
 258
 259             if( p_peek[5]&0x10 && p_sys->p_pes )
 260             {
 261                 ParsePES( p_demux );
 262             }
 263             if( ( p_frame = vlc_stream_Block( p_demux->s, i_size + 8 ) ) )
 264             {
 265                 p_frame->p_buffer += 8;
 266                 p_frame->i_buffer -= 8;
 267                 /* XXX this a hack, some streams aren't compliant and
 268                  * don't set pes_start flag */
 269                 if( p_sys->p_pes && p_frame->i_buffer > 4 &&
 270                     p_frame->p_buffer[0] == 0x00 &&
 271                     p_frame->p_buffer[1] == 0x00 &&
 272                     p_frame->p_buffer[2] == 0x01 )
 273                 {
 274                     ParsePES( p_demux );
 275                 }
 276                 block_ChainAppend( &p_sys->p_pes, p_frame );
 277             }
 278             break;
 279
 280         default:
 281             msg_Warn( p_demux, "unknown id=0x%x", p_peek[2] );
 282             if( vlc_stream_Read( p_demux->s, NULL, i_size + 8 ) < i_size + 8 )
 283                 return VLC_DEMUXER_EOF;
 284             break;
 285     }
 286     return VLC_DEMUXER_SUCCESS;
 287 }
 288
 289 /*****************************************************************************
 290  * Control:
 291  *****************************************************************************/
 292 static int Control( demux_t *p_demux, int i_query, va_list args )
 293 {
 294     /* demux_sys_t *p_sys = p_demux->p_sys; */
 295     double f, *pf;
 296     int64_t i64;
 297     switch( i_query )
 298     {
 299         case DEMUX_CAN_SEEK:
 300             return vlc_stream_vaControl( p_demux->s, i_query, args );
 301
 302         case DEMUX_GET_POSITION:
 303             if( ( i64 = stream_Size( p_demux->s ) ) > 0 )
 304             {
 305                 pf = va_arg( args, double * );
 306                 double current = vlc_stream_Tell( p_demux->s );
 307                 *pf = current / (double)i64;
 308                 return VLC_SUCCESS;
 309             }
 310             return VLC_EGENERIC;
 311
 312         case DEMUX_SET_POSITION:
 313             f = va_arg( args, double );
 314             i64 = stream_Size( p_demux->s );
 315
 316             if( vlc_stream_Seek( p_demux->s, (int64_t)(i64 * f) ) || ReSynch( p_demux ) )
 317             {
 318                 return VLC_EGENERIC;
 319             }
 320             return VLC_SUCCESS;
 321
 322 #if 0
 323         case DEMUX_GET_TIME:
 324             pi64 = va_arg( args, vlc_tick_t * );
 325             if( p_sys->i_time < 0 )
 326             {
 327                 *pi64 = 0;
 328                 return VLC_EGENERIC;
 329             }
 330             *pi64 = p_sys->i_time;
 331             return VLC_SUCCESS;
 332
 333 #if 0
 334         case DEMUX_GET_LENGTH:
 335             pi64 = va_arg( args, vlc_tick_t * );
 336             if( p_sys->i_mux_rate > 0 )
 337             {
 338                 *pi64 = vlc_tick_from_samples( stream_Size( p_demux->s ) / 50, p_sys->i_mux_rate);
 339                 return VLC_SUCCESS;
 340             }
 341             *pi64 = 0;
 342             return VLC_EGENERIC;
 343
 344 #endif
 345         case DEMUX_GET_FPS:
 346             pf = va_arg( args, double * );
 347             *pf = (double)1000000.0 / (double)p_sys->i_pcr_inc;
 348             return VLC_SUCCESS;
 349 #endif
 350         case DEMUX_CAN_PAUSE:
 351         case DEMUX_SET_PAUSE_STATE:
 352         case DEMUX_CAN_CONTROL_PACE:
 353         case DEMUX_GET_PTS_DELAY:
 354             return demux_vaControlHelper( p_demux->s, 0, -1, 0, 1, i_query, args );
 355
 356         case DEMUX_SET_TIME:
 357         default:
 358             return VLC_EGENERIC;
 359     }
 360 }
 361
 362 /*****************************************************************************
 363  * ReSynch:
 364  *****************************************************************************/
 365 static int ReSynch( demux_t *p_demux )
 366 {
 367     for( ;; )
 368     {
 369         const uint8_t *p_peek;
 370         int i_peek = vlc_stream_Peek( p_demux->s, &p_peek, 1024 );
 371         if( i_peek < 8 )
 372             break;
 373
 374         int i_skip = 0;
 375
 376         while( i_skip < i_peek - 5 )
 377         {
 378             if( p_peek[0] == 'A' && p_peek[1] == 'V' && p_peek[4] == 0x55 )
 379             {
 380                 if( i_skip > 0
 381                  && vlc_stream_Read( p_demux->s, NULL, i_skip ) < i_skip )
 382                     return VLC_EGENERIC;
 383                 return VLC_SUCCESS;
 384             }
 385             p_peek++;
 386             i_skip++;
 387         }
 388
 389         if( vlc_stream_Read( p_demux->s, NULL, i_skip ) < i_skip )
 390             break;
 391     }
 392
 393     return VLC_EGENERIC;
 394 }
 395
 396 static void ParsePES( demux_t *p_demux )
 397 {
 398     demux_sys_t *p_sys = p_demux->p_sys;
 399     block_t     *p_pes = p_sys->p_pes;
 400     uint8_t     hdr[30];
 401
 402     unsigned    i_skip;
 403     stime_t     i_dts = -1;
 404     stime_t     i_pts = -1;
 405
 406     p_sys->p_pes = NULL;
 407
 408     /* FIXME find real max size */
 409     block_ChainExtract( p_pes, hdr, 30 );
 410
 411     /* See §2.4.3.6 of ISO 13818-1 */
 412     if( hdr[0] != 0 || hdr[1] != 0 || hdr[2] != 1 )
 413     {
 414         msg_Warn( p_demux, "invalid hdr [0x%2.2x:%2.2x:%2.2x:%2.2x]",
 415                   hdr[0], hdr[1],hdr[2],hdr[3] );
 416         block_ChainRelease( p_pes );
 417         return;
 418     }
 419     // hdr[4] i_pes_size, 2 bytes
 420     // hdr[6] Marker -> original_or_copy
 421
 422     /* we assume mpeg2 PES */
 423     i_skip = hdr[8] + 9;
 424     if( hdr[7]&0x80 )    /* has pts */
 425     {
 426         i_pts = GetPESTimestamp( &hdr[9] );
 427
 428         if( hdr[7]&0x40 )    /* has dts */
 429         {
 430              i_dts = GetPESTimestamp( &hdr[14] );
 431         }
 432     }
 433
 434     p_pes = block_ChainGather( p_pes );
 435     if( unlikely(p_pes == NULL) )
 436         return;
 437     if( p_pes->i_buffer <= i_skip )
 438     {
 439         block_ChainRelease( p_pes );
 440         return;
 441     }
 442
 443     p_pes->i_buffer -= i_skip;
 444     p_pes->p_buffer += i_skip;
 445
 446     if( i_dts >= 0 )
 447         p_pes->i_dts = FROM_SCALE(i_dts);
 448     if( i_pts >= 0 )
 449         p_pes->i_pts = FROM_SCALE(i_pts);
 450
 451     /* Set PCR */
 452     if( p_pes->i_pts != VLC_TICK_INVALID )
 453     {
 454         es_out_SetPCR( p_demux->out, p_pes->i_pts);
 455         p_sys->b_pcr_audio = true;
 456     }
 457     es_out_Send( p_demux->out, p_sys->p_audio, p_pes );
 458 }
 459