git.sesse.net Git - vlc/blob - modules/packetizer/mpeg4video.c

   1 /*****************************************************************************
   2  * mpeg4video.c: mpeg 4 video packetizer
   3  *****************************************************************************
   4  * Copyright (C) 2001-2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Gildas Bazin <gbazin@videolan.org>
   8  *          Laurent Aimar <fenrir@via.ecp.fr>
   9  *          Eric Petit <titer@videolan.org>
  10  *
  11  * This program is free software; you can redistribute it and/or modify
  12  * it under the terms of the GNU General Public License as published by
  13  * the Free Software Foundation; either version 2 of the License, or
  14  * (at your option) any later version.
  15  *
  16  * This program is distributed in the hope that it will be useful,
  17  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  18  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  19  * GNU General Public License for more details.
  20  *
  21  * You should have received a copy of the GNU General Public License
  22  * along with this program; if not, write to the Free Software
  23  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  24  *****************************************************************************/
  25
  26 /*****************************************************************************
  27  * Preamble
  28  *****************************************************************************/
  29
  30 #ifdef HAVE_CONFIG_H
  31 # include "config.h"
  32 #endif
  33
  34 #include <vlc_common.h>
  35 #include <vlc_plugin.h>
  36 #include <vlc_sout.h>
  37 #include <vlc_codec.h>
  38 #include <vlc_block.h>
  39
  40 #include "vlc_bits.h"
  41 #include "vlc_block_helper.h"
  42 #include "packetizer_helper.h"
  43
  44 /*****************************************************************************
  45  * Module descriptor
  46  *****************************************************************************/
  47 static int  Open ( vlc_object_t * );
  48 static void Close( vlc_object_t * );
  49
  50 vlc_module_begin ()
  51     set_category( CAT_SOUT )
  52     set_subcategory( SUBCAT_SOUT_PACKETIZER )
  53     set_description( N_("MPEG4 video packetizer") )
  54     set_capability( "packetizer", 50 )
  55     set_callbacks( Open, Close )
  56 vlc_module_end ()
  57
  58 /****************************************************************************
  59  * Local prototypes
  60  ****************************************************************************/
  61 struct decoder_sys_t
  62 {
  63     /*
  64      * Input properties
  65      */
  66     packetizer_t packetizer;
  67
  68     /*
  69      * Common properties
  70      */
  71     mtime_t i_interpolated_pts;
  72     mtime_t i_interpolated_dts;
  73     mtime_t i_last_ref_pts;
  74     mtime_t i_last_time_ref;
  75     mtime_t i_time_ref;
  76     mtime_t i_last_time;
  77     mtime_t i_last_timeincr;
  78
  79     unsigned int i_flags;
  80
  81     int         i_fps_num;
  82     int         i_fps_den;
  83     int         i_last_incr;
  84     int         i_last_incr_diff;
  85
  86     bool  b_frame;
  87
  88     /* Current frame being built */
  89     block_t    *p_frame;
  90     block_t    **pp_last;
  91 };
  92
  93 static block_t *Packetize( decoder_t *, block_t ** );
  94
  95 static void PacketizeReset( void *p_private, bool b_broken );
  96 static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t * );
  97 static int PacketizeValidate( void *p_private, block_t * );
  98
  99 static block_t *ParseMPEGBlock( decoder_t *, block_t * );
 100 static int ParseVOL( decoder_t *, es_format_t *, uint8_t *, int );
 101 static int ParseVOP( decoder_t *, block_t * );
 102 static int vlc_log2( unsigned int );
 103
 104 #define VIDEO_OBJECT_MASK                       0x01f
 105 #define VIDEO_OBJECT_LAYER_MASK                 0x00f
 106
 107 #define VIDEO_OBJECT_START_CODE                 0x100
 108 #define VIDEO_OBJECT_LAYER_START_CODE           0x120
 109 #define VISUAL_OBJECT_SEQUENCE_START_CODE       0x1b0
 110 #define VISUAL_OBJECT_SEQUENCE_END_CODE         0x1b1
 111 #define USER_DATA_START_CODE                    0x1b2
 112 #define GROUP_OF_VOP_START_CODE                 0x1b3
 113 #define VIDEO_SESSION_ERROR_CODE                0x1b4
 114 #define VISUAL_OBJECT_START_CODE                0x1b5
 115 #define VOP_START_CODE                          0x1b6
 116 #define FACE_OBJECT_START_CODE                  0x1ba
 117 #define FACE_OBJECT_PLANE_START_CODE            0x1bb
 118 #define MESH_OBJECT_START_CODE                  0x1bc
 119 #define MESH_OBJECT_PLANE_START_CODE            0x1bd
 120 #define STILL_TEXTURE_OBJECT_START_CODE         0x1be
 121 #define TEXTURE_SPATIAL_LAYER_START_CODE        0x1bf
 122 #define TEXTURE_SNR_LAYER_START_CODE            0x1c0
 123
 124 static const uint8_t p_mp4v_startcode[3] = { 0x00, 0x00, 0x01 };
 125
 126 /*****************************************************************************
 127  * Open: probe the packetizer and return score
 128  *****************************************************************************/
 129 static int Open( vlc_object_t *p_this )
 130 {
 131     decoder_t     *p_dec = (decoder_t*)p_this;
 132     decoder_sys_t *p_sys;
 133
 134     if( p_dec->fmt_in.i_codec != VLC_CODEC_MP4V )
 135         return VLC_EGENERIC;
 136
 137     /* Allocate the memory needed to store the decoder's structure */
 138     if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
 139         return VLC_ENOMEM;
 140     memset( p_sys, 0, sizeof(decoder_sys_t) );
 141
 142     /* Misc init */
 143     packetizer_Init( &p_sys->packetizer,
 144                      p_mp4v_startcode, sizeof(p_mp4v_startcode),
 145                      NULL, 0,
 146                      PacketizeReset, PacketizeParse, PacketizeValidate, p_dec );
 147
 148     p_sys->p_frame = NULL;
 149     p_sys->pp_last = &p_sys->p_frame;
 150
 151     /* Setup properties */
 152     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 153     p_dec->fmt_out.i_codec = VLC_CODEC_MP4V;
 154
 155     if( p_dec->fmt_in.i_extra )
 156     {
 157         /* We have a vol */
 158         p_dec->fmt_out.i_extra = p_dec->fmt_in.i_extra;
 159         p_dec->fmt_out.p_extra = malloc( p_dec->fmt_in.i_extra );
 160         memcpy( p_dec->fmt_out.p_extra, p_dec->fmt_in.p_extra,
 161                 p_dec->fmt_in.i_extra );
 162
 163         msg_Dbg( p_dec, "opening with vol size: %d", p_dec->fmt_in.i_extra );
 164         ParseVOL( p_dec, &p_dec->fmt_out,
 165                   p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
 166     }
 167     else
 168     {
 169         /* No vol, we'll have to look for one later on */
 170         p_dec->fmt_out.i_extra = 0;
 171         p_dec->fmt_out.p_extra = 0;
 172     }
 173
 174     /* Set callback */
 175     p_dec->pf_packetize = Packetize;
 176
 177     return VLC_SUCCESS;
 178 }
 179
 180 /*****************************************************************************
 181  * Close: clean up the packetizer
 182  *****************************************************************************/
 183 static void Close( vlc_object_t *p_this )
 184 {
 185     decoder_t *p_dec = (decoder_t*)p_this;
 186     decoder_sys_t *p_sys = p_dec->p_sys;
 187
 188     packetizer_Clean( &p_sys->packetizer );
 189     if( p_sys->p_frame )
 190         block_ChainRelease( p_sys->p_frame );
 191     free( p_sys );
 192 }
 193
 194 /****************************************************************************
 195  * Packetize: the whole thing
 196  ****************************************************************************/
 197 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 198 {
 199     decoder_sys_t *p_sys = p_dec->p_sys;
 200
 201     return packetizer_Packetize( &p_sys->packetizer, pp_block );
 202 }
 203
 204 /*****************************************************************************
 205  * Helpers:
 206  *****************************************************************************/
 207 static void PacketizeReset( void *p_private, bool b_broken )
 208 {
 209     decoder_t *p_dec = p_private;
 210     decoder_sys_t *p_sys = p_dec->p_sys;
 211
 212     if( b_broken )
 213     {
 214         if( p_sys->p_frame )
 215             block_ChainRelease( p_sys->p_frame );
 216         p_sys->p_frame = NULL;
 217         p_sys->pp_last = &p_sys->p_frame;
 218     }
 219
 220     p_sys->i_interpolated_pts =
 221     p_sys->i_interpolated_dts =
 222     p_sys->i_last_ref_pts =
 223     p_sys->i_last_time_ref =
 224     p_sys->i_time_ref =
 225     p_sys->i_last_time =
 226     p_sys->i_last_timeincr = 0;
 227 }
 228
 229 static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t *p_block )
 230 {
 231     decoder_t *p_dec = p_private;
 232     const mtime_t i_dts = p_block->i_dts;
 233     const mtime_t i_pts = p_block->i_pts;
 234
 235     block_t *p_au = ParseMPEGBlock( p_dec, p_block );
 236
 237     *pb_ts_used = p_au &&  p_au->i_dts == i_dts && p_au->i_pts == i_pts;
 238
 239     return p_au;
 240 }
 241
 242
 243 static int PacketizeValidate( void *p_private, block_t *p_au )
 244 {
 245     decoder_t *p_dec = p_private;
 246     decoder_sys_t *p_sys = p_dec->p_sys;
 247
 248     /* We've just started the stream, wait for the first PTS.
 249      * We discard here so we can still get the sequence header. */
 250     if( p_sys->i_interpolated_pts <= 0 &&
 251         p_sys->i_interpolated_dts <= 0 )
 252     {
 253         msg_Dbg( p_dec, "need a starting pts/dts" );
 254         return VLC_EGENERIC;
 255     }
 256
 257     /* When starting the stream we can have the first frame with
 258      * a null DTS (i_interpolated_pts is initialized to 0) */
 259     if( !p_au->i_dts )
 260         p_au->i_dts = p_au->i_pts;
 261     return VLC_SUCCESS;
 262 }
 263
 264 /*****************************************************************************
 265  * ParseMPEGBlock: Re-assemble fragments into a block containing a picture
 266  *****************************************************************************/
 267 static block_t *ParseMPEGBlock( decoder_t *p_dec, block_t *p_frag )
 268 {
 269     decoder_sys_t *p_sys = p_dec->p_sys;
 270     block_t *p_pic = NULL;
 271
 272     if( p_frag->p_buffer[3] == 0xB0 || p_frag->p_buffer[3] == 0xB1 || p_frag->p_buffer[3] == 0xB2 )
 273     {   /* VOS and USERDATA */
 274 #if 0
 275         /* Remove VOS start/end code from the original stream */
 276         block_Release( p_frag );
 277 #else
 278         /* Append the block for now since ts/ps muxers rely on VOL
 279          * being present in the stream */
 280         block_ChainLastAppend( &p_sys->pp_last, p_frag );
 281 #endif
 282         return NULL;
 283     }
 284     if( p_frag->p_buffer[3] >= 0x20 && p_frag->p_buffer[3] <= 0x2f )
 285     {
 286         /* Copy the complete VOL */
 287         if( (size_t)p_dec->fmt_out.i_extra != p_frag->i_buffer )
 288         {
 289             p_dec->fmt_out.p_extra =
 290                 realloc( p_dec->fmt_out.p_extra, p_frag->i_buffer );
 291             p_dec->fmt_out.i_extra = p_frag->i_buffer;
 292         }
 293         memcpy( p_dec->fmt_out.p_extra, p_frag->p_buffer, p_frag->i_buffer );
 294         ParseVOL( p_dec, &p_dec->fmt_out,
 295                   p_dec->fmt_out.p_extra, p_dec->fmt_out.i_extra );
 296
 297 #if 0
 298         /* Remove from the original stream */
 299         block_Release( p_frag );
 300 #else
 301         /* Append the block for now since ts/ps muxers rely on VOL
 302          * being present in the stream */
 303         block_ChainLastAppend( &p_sys->pp_last, p_frag );
 304 #endif
 305         return NULL;
 306     }
 307     else
 308     {
 309         if( !p_dec->fmt_out.i_extra )
 310         {
 311             msg_Warn( p_dec, "waiting for VOL" );
 312             block_Release( p_frag );
 313             return NULL;
 314         }
 315
 316         /* Append the block */
 317         block_ChainLastAppend( &p_sys->pp_last, p_frag );
 318     }
 319
 320     if( p_frag->p_buffer[3] == 0xb6 &&
 321         ParseVOP( p_dec, p_frag ) == VLC_SUCCESS )
 322     {
 323         /* We are dealing with a VOP */
 324         p_pic = block_ChainGather( p_sys->p_frame );
 325         p_pic->i_flags = p_sys->i_flags;
 326         p_pic->i_pts = p_sys->i_interpolated_pts;
 327         p_pic->i_dts = p_sys->i_interpolated_dts;
 328
 329         /* Reset context */
 330         p_sys->p_frame = NULL;
 331         p_sys->pp_last = &p_sys->p_frame;
 332     }
 333
 334     return p_pic;
 335 }
 336
 337 /* ParseVOL:
 338  *  TODO:
 339  *      - support aspect ratio
 340  */
 341 static int ParseVOL( decoder_t *p_dec, es_format_t *fmt,
 342                      uint8_t *p_vol, int i_vol )
 343 {
 344     decoder_sys_t *p_sys = p_dec->p_sys;
 345     int i_vo_type, i_vo_ver_id, i_ar, i_shape;
 346     bs_t s;
 347
 348     for( ;; )
 349     {
 350         if( p_vol[0] == 0x00 && p_vol[1] == 0x00 && p_vol[2] == 0x01 &&
 351             p_vol[3] >= 0x20 && p_vol[3] <= 0x2f ) break;
 352
 353         p_vol++; i_vol--;
 354         if( i_vol <= 4 ) return VLC_EGENERIC;
 355     }
 356
 357     bs_init( &s, &p_vol[4], i_vol - 4 );
 358
 359     bs_skip( &s, 1 );   /* random access */
 360     i_vo_type = bs_read( &s, 8 );
 361     if( bs_read1( &s ) )
 362     {
 363         i_vo_ver_id = bs_read( &s, 4 );
 364         bs_skip( &s, 3 );
 365     }
 366     else
 367     {
 368         i_vo_ver_id = 1;
 369     }
 370     i_ar = bs_read( &s, 4 );
 371     if( i_ar == 0xf )
 372     {
 373         int i_ar_width, i_ar_height;
 374
 375         i_ar_width = bs_read( &s, 8 );
 376         i_ar_height= bs_read( &s, 8 );
 377     }
 378     if( bs_read1( &s ) )
 379     {
 380         int i_chroma_format;
 381         int i_low_delay;
 382
 383         /* vol control parameter */
 384         i_chroma_format = bs_read( &s, 2 );
 385         i_low_delay = bs_read1( &s );
 386
 387         if( bs_read1( &s ) )
 388         {
 389             bs_skip( &s, 16 );
 390             bs_skip( &s, 16 );
 391             bs_skip( &s, 16 );
 392             bs_skip( &s, 3 );
 393             bs_skip( &s, 11 );
 394             bs_skip( &s, 1 );
 395             bs_skip( &s, 16 );
 396         }
 397     }
 398     /* shape 0->RECT, 1->BIN, 2->BIN_ONLY, 3->GRAY */
 399     i_shape = bs_read( &s, 2 );
 400     if( i_shape == 3 && i_vo_ver_id != 1 )
 401     {
 402         bs_skip( &s, 4 );
 403     }
 404
 405     if( !bs_read1( &s ) ) return VLC_EGENERIC; /* Marker */
 406
 407     p_sys->i_fps_num = bs_read( &s, 16 ); /* Time increment resolution*/
 408     if( !p_sys->i_fps_num ) p_sys->i_fps_num = 1;
 409
 410     if( !bs_read1( &s ) ) return VLC_EGENERIC; /* Marker */
 411
 412     if( bs_read1( &s ) )
 413     {
 414         int i_time_increment_bits = vlc_log2( p_sys->i_fps_num - 1 ) + 1;
 415
 416         if( i_time_increment_bits < 1 ) i_time_increment_bits = 1;
 417
 418         p_sys->i_fps_den = bs_read( &s, i_time_increment_bits );
 419     }
 420     if( i_shape == 0 )
 421     {
 422         bs_skip( &s, 1 );
 423         fmt->video.i_width = bs_read( &s, 13 );
 424         bs_skip( &s, 1 );
 425         fmt->video.i_height= bs_read( &s, 13 );
 426         bs_skip( &s, 1 );
 427     }
 428
 429     return VLC_SUCCESS;
 430 }
 431
 432 static int ParseVOP( decoder_t *p_dec, block_t *p_vop )
 433 {
 434     decoder_sys_t *p_sys = p_dec->p_sys;
 435     int64_t i_time_increment, i_time_ref;
 436     int i_modulo_time_base = 0, i_time_increment_bits;
 437     bs_t s;
 438
 439     bs_init( &s, &p_vop->p_buffer[4], p_vop->i_buffer - 4 );
 440
 441     switch( bs_read( &s, 2 ) )
 442     {
 443     case 0:
 444         p_sys->i_flags = BLOCK_FLAG_TYPE_I;
 445         break;
 446     case 1:
 447         p_sys->i_flags = BLOCK_FLAG_TYPE_P;
 448         break;
 449     case 2:
 450         p_sys->i_flags = BLOCK_FLAG_TYPE_B;
 451         p_sys->b_frame = true;
 452         break;
 453     case 3: /* gni ? */
 454         p_sys->i_flags = BLOCK_FLAG_TYPE_PB;
 455         break;
 456     }
 457
 458     while( bs_read( &s, 1 ) ) i_modulo_time_base++;
 459     if( !bs_read1( &s ) ) return VLC_EGENERIC; /* Marker */
 460
 461     /* VOP time increment */
 462     i_time_increment_bits = vlc_log2(p_dec->p_sys->i_fps_num - 1) + 1;
 463     if( i_time_increment_bits < 1 ) i_time_increment_bits = 1;
 464     i_time_increment = bs_read( &s, i_time_increment_bits );
 465
 466     /* Interpolate PTS/DTS */
 467     if( !(p_sys->i_flags & BLOCK_FLAG_TYPE_B) )
 468     {
 469         p_sys->i_last_time_ref = p_sys->i_time_ref;
 470         p_sys->i_time_ref +=
 471             (i_modulo_time_base * p_dec->p_sys->i_fps_num);
 472         i_time_ref = p_sys->i_time_ref;
 473     }
 474     else
 475     {
 476         i_time_ref = p_sys->i_last_time_ref +
 477             (i_modulo_time_base * p_dec->p_sys->i_fps_num);
 478     }
 479
 480 #if 0
 481     msg_Err( p_dec, "interp pts/dts (%lli,%lli), pts/dts (%lli,%lli)",
 482              p_sys->i_interpolated_pts, p_sys->i_interpolated_dts,
 483              p_vop->i_pts, p_vop->i_dts );
 484 #endif
 485
 486     if( p_dec->p_sys->i_fps_num < 5 && /* Work-around buggy streams */
 487         p_dec->fmt_in.video.i_frame_rate > 0 &&
 488         p_dec->fmt_in.video.i_frame_rate_base > 0 )
 489     {
 490         p_sys->i_interpolated_pts += INT64_C(1000000) *
 491         p_dec->fmt_in.video.i_frame_rate_base /
 492         p_dec->fmt_in.video.i_frame_rate;
 493     }
 494     else if( p_dec->p_sys->i_fps_num )
 495         p_sys->i_interpolated_pts +=
 496             ( INT64_C(1000000) * (i_time_ref + i_time_increment -
 497               p_sys->i_last_time - p_sys->i_last_timeincr) /
 498               p_dec->p_sys->i_fps_num );
 499
 500     p_sys->i_last_time = i_time_ref;
 501     p_sys->i_last_timeincr = i_time_increment;
 502
 503     /* Correct interpolated dts when we receive a new pts/dts */
 504     if( p_vop->i_pts > 0 )
 505         p_sys->i_interpolated_pts = p_vop->i_pts;
 506     if( p_vop->i_dts > 0 )
 507         p_sys->i_interpolated_dts = p_vop->i_dts;
 508
 509     if( (p_sys->i_flags & BLOCK_FLAG_TYPE_B) || !p_sys->b_frame )
 510     {
 511         /* Trivial case (DTS == PTS) */
 512
 513         p_sys->i_interpolated_dts = p_sys->i_interpolated_pts;
 514
 515         if( p_vop->i_pts > 0 )
 516             p_sys->i_interpolated_dts = p_vop->i_pts;
 517         if( p_vop->i_dts > 0 )
 518             p_sys->i_interpolated_dts = p_vop->i_dts;
 519
 520         p_sys->i_interpolated_pts = p_sys->i_interpolated_dts;
 521     }
 522     else
 523     {
 524         if( p_sys->i_last_ref_pts > 0 )
 525             p_sys->i_interpolated_dts = p_sys->i_last_ref_pts;
 526
 527         p_sys->i_last_ref_pts = p_sys->i_interpolated_pts;
 528     }
 529
 530     return VLC_SUCCESS;
 531 }
 532
 533 /* look at ffmpeg av_log2 ;) */
 534 static int vlc_log2( unsigned int v )
 535 {
 536     int n = 0;
 537     static const int vlc_log2_table[16] =
 538     {
 539         0,0,1,1,2,2,2,2, 3,3,3,3,3,3,3,3
 540     };
 541
 542     if( v&0xffff0000 )
 543     {
 544         v >>= 16;
 545         n += 16;
 546     }
 547     if( v&0xff00 )
 548     {
 549         v >>= 8;
 550         n += 8;
 551     }
 552     if( v&0xf0 )
 553     {
 554         v >>= 4;
 555         n += 4;
 556     }
 557     n += vlc_log2_table[v];
 558
 559     return n;
 560 }