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

   1 /*****************************************************************************
   2  * h264.c: h264/avc video packetizer
   3  *****************************************************************************
   4  * Copyright (C) 2001, 2002, 2006 the VideoLAN team
   5  * $Id$
   6  *
   7  * Authors: Laurent Aimar <fenrir@via.ecp.fr>
   8  *          Eric Petit <titer@videolan.org>
   9  *          Gildas Bazin <gbazin@videolan.org>
  10  *          Derk-Jan Hartman <hartman at videolan dot org>
  11  *
  12  * This program is free software; you can redistribute it and/or modify
  13  * it under the terms of the GNU General Public License as published by
  14  * the Free Software Foundation; either version 2 of the License, or
  15  * (at your option) any later version.
  16  *
  17  * This program is distributed in the hope that it will be useful,
  18  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  19  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20  * GNU General Public License for more details.
  21  *
  22  * You should have received a copy of the GNU General Public License
  23  * along with this program; if not, write to the Free Software
  24  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
  25  *****************************************************************************/
  26
  27 /*****************************************************************************
  28  * Preamble
  29  *****************************************************************************/
  30
  31 #ifdef HAVE_CONFIG_H
  32 # include "config.h"
  33 #endif
  34
  35 #include <vlc_common.h>
  36 #include <vlc_plugin.h>
  37 #include <vlc_sout.h>
  38 #include <vlc_codec.h>
  39 #include <vlc_block.h>
  40
  41 #include "vlc_block_helper.h"
  42 #include "vlc_bits.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_("H.264 video packetizer") );
  54     set_capability( "packetizer", 50 );
  55     set_callbacks( Open, Close );
  56 vlc_module_end();
  57
  58
  59 /****************************************************************************
  60  * Local prototypes
  61  ****************************************************************************/
  62 static block_t *Packetize( decoder_t *, block_t ** );
  63 static block_t *PacketizeAVC1( decoder_t *, block_t ** );
  64
  65 typedef struct
  66 {
  67     int i_nal_type;
  68     int i_nal_ref_idc;
  69
  70     int i_frame_type;
  71     int i_pic_parameter_set_id;
  72     int i_frame_num;
  73
  74     int i_field_pic_flag;
  75     int i_bottom_field_flag;
  76
  77     int i_idr_pic_id;
  78
  79     int i_pic_order_cnt_lsb;
  80     int i_delta_pic_order_cnt_bottom;
  81
  82     int i_delta_pic_order_cnt0;
  83     int i_delta_pic_order_cnt1;
  84 } slice_t;
  85
  86 #define SPS_MAX (32)
  87 #define PPS_MAX (256)
  88 struct decoder_sys_t
  89 {
  90     block_bytestream_t bytestream;
  91
  92     int     i_state;
  93     size_t  i_offset;
  94     uint8_t startcode[4];
  95
  96     bool    b_slice;
  97     block_t *p_frame;
  98
  99     bool   b_header;
 100     bool   b_sps;
 101     bool   b_pps;
 102     block_t *pp_sps[SPS_MAX];
 103     block_t *pp_pps[PPS_MAX];
 104
 105     /* avcC data */
 106     int i_avcC_length_size;
 107
 108     /* Useful values of the Sequence Parameter Set */
 109     int i_log2_max_frame_num;
 110     int b_frame_mbs_only;
 111     int i_pic_order_cnt_type;
 112     int i_delta_pic_order_always_zero_flag;
 113     int i_log2_max_pic_order_cnt_lsb;
 114
 115     /* Value from Picture Parameter Set */
 116     int i_pic_order_present_flag;
 117
 118     /* Useful values of the Slice Header */
 119     slice_t slice;
 120
 121     /* */
 122     mtime_t i_frame_pts;
 123     mtime_t i_frame_dts;
 124 };
 125
 126 enum
 127 {
 128     STATE_NOSYNC,
 129     STATE_NEXT_SYNC,
 130 };
 131
 132 enum nal_unit_type_e
 133 {
 134     NAL_UNKNOWN = 0,
 135     NAL_SLICE   = 1,
 136     NAL_SLICE_DPA   = 2,
 137     NAL_SLICE_DPB   = 3,
 138     NAL_SLICE_DPC   = 4,
 139     NAL_SLICE_IDR   = 5,    /* ref_idc != 0 */
 140     NAL_SEI         = 6,    /* ref_idc == 0 */
 141     NAL_SPS         = 7,
 142     NAL_PPS         = 8,
 143     NAL_AU_DELIMITER= 9
 144     /* ref_idc == 0 for 6,9,10,11,12 */
 145 };
 146
 147 enum nal_priority_e
 148 {
 149     NAL_PRIORITY_DISPOSABLE = 0,
 150     NAL_PRIORITY_LOW        = 1,
 151     NAL_PRIORITY_HIGH       = 2,
 152     NAL_PRIORITY_HIGHEST    = 3,
 153 };
 154
 155 static block_t *ParseNALBlock( decoder_t *, bool *pb_used_ts, block_t * );
 156
 157 static block_t *CreateAnnexbNAL( decoder_t *, const uint8_t *p, int );
 158
 159 static block_t *OutputPicture( decoder_t *p_dec );
 160 static void PutSPS( decoder_t *p_dec, block_t *p_frag );
 161 static void PutPPS( decoder_t *p_dec, block_t *p_frag );
 162 static void ParseSlice( decoder_t *p_dec, bool *pb_new_picture, slice_t *p_slice,
 163                         int i_nal_ref_idc, int i_nal_type, const block_t *p_frag );
 164
 165
 166 /*****************************************************************************
 167  * Open: probe the packetizer and return score
 168  * When opening after demux, the packetizer is only loaded AFTER the decoder
 169  * That means that what you set in fmt_out is ignored by the decoder in this special case
 170  *****************************************************************************/
 171 static int Open( vlc_object_t *p_this )
 172 {
 173     decoder_t     *p_dec = (decoder_t*)p_this;
 174     decoder_sys_t *p_sys;
 175     int i;
 176
 177     if( p_dec->fmt_in.i_codec != VLC_FOURCC( 'h', '2', '6', '4') &&
 178         p_dec->fmt_in.i_codec != VLC_FOURCC( 'H', '2', '6', '4') &&
 179         p_dec->fmt_in.i_codec != VLC_FOURCC( 'V', 'S', 'S', 'H') &&
 180         p_dec->fmt_in.i_codec != VLC_FOURCC( 'v', 's', 's', 'h') &&
 181         p_dec->fmt_in.i_codec != VLC_FOURCC( 'D', 'A', 'V', 'C') &&
 182         ( p_dec->fmt_in.i_codec != VLC_FOURCC( 'a', 'v', 'c', '1') ||
 183           p_dec->fmt_in.i_extra < 7 ) )
 184     {
 185         return VLC_EGENERIC;
 186     }
 187
 188     /* Allocate the memory needed to store the decoder's structure */
 189     if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
 190     {
 191         return VLC_ENOMEM;
 192     }
 193     p_sys->i_state = STATE_NOSYNC;
 194     p_sys->i_offset = 0;
 195     p_sys->startcode[0] = 0;
 196     p_sys->startcode[1] = 0;
 197     p_sys->startcode[2] = 0;
 198     p_sys->startcode[3] = 1;
 199     p_sys->bytestream = block_BytestreamInit();
 200     p_sys->b_slice = false;
 201     p_sys->p_frame = NULL;
 202     p_sys->b_header= false;
 203     p_sys->b_sps   = false;
 204     p_sys->b_pps   = false;
 205     for( i = 0; i < SPS_MAX; i++ )
 206         p_sys->pp_sps[i] = NULL;
 207     for( i = 0; i < PPS_MAX; i++ )
 208         p_sys->pp_pps[i] = NULL;
 209
 210     p_sys->slice.i_nal_type = -1;
 211     p_sys->slice.i_nal_ref_idc = -1;
 212     p_sys->slice.i_idr_pic_id = -1;
 213     p_sys->slice.i_frame_num = -1;
 214     p_sys->slice.i_frame_type = 0;
 215     p_sys->slice.i_pic_parameter_set_id = -1;
 216     p_sys->slice.i_field_pic_flag = 0;
 217     p_sys->slice.i_bottom_field_flag = -1;
 218     p_sys->slice.i_pic_order_cnt_lsb = -1;
 219     p_sys->slice.i_delta_pic_order_cnt_bottom = -1;
 220
 221     p_sys->i_frame_dts = -1;
 222     p_sys->i_frame_pts = -1;
 223
 224     /* Setup properties */
 225     es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
 226     p_dec->fmt_out.i_codec = VLC_FOURCC( 'h', '2', '6', '4' );
 227
 228     if( p_dec->fmt_in.i_codec == VLC_FOURCC( 'a', 'v', 'c', '1' ) )
 229     {
 230         /* This type of stream is produced by mp4 and matroska
 231          * when we want to store it in another streamformat, you need to convert
 232          * The fmt_in.p_extra should ALWAYS contain the avcC
 233          * The fmt_out.p_extra should contain all the SPS and PPS with 4 byte startcodes */
 234         uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4];
 235         int i_sps, i_pps;
 236         bool b_dummy;
 237         int i;
 238
 239         /* Parse avcC */
 240         p_sys->i_avcC_length_size = 1 + ((*p++)&0x03);
 241
 242         /* Read SPS */
 243         i_sps = (*p++)&0x1f;
 244         for( i = 0; i < i_sps; i++ )
 245         {
 246             uint16_t i_length = GetWBE( p ); p += 2;
 247             if( i_length >
 248                 (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p )
 249             {
 250                 return VLC_EGENERIC;
 251             }
 252             block_t *p_sps = CreateAnnexbNAL( p_dec, p, i_length );
 253             if( !p_sps )
 254                 return VLC_EGENERIC;
 255             ParseNALBlock( p_dec, &b_dummy, p_sps );
 256             p += i_length;
 257         }
 258         /* Read PPS */
 259         i_pps = *p++;
 260         for( i = 0; i < i_pps; i++ )
 261         {
 262             uint16_t i_length = GetWBE( p ); p += 2;
 263             if( i_length >
 264                 (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p )
 265             {
 266                 return VLC_EGENERIC;
 267             }
 268             block_t *p_pps = CreateAnnexbNAL( p_dec, p, i_length );
 269             if( !p_pps )
 270                 return VLC_EGENERIC;
 271             ParseNALBlock( p_dec, &b_dummy, p_pps );
 272             p += i_length;
 273         }
 274         msg_Dbg( p_dec, "avcC length size=%d, sps=%d, pps=%d",
 275                  p_sys->i_avcC_length_size, i_sps, i_pps );
 276
 277         if( !p_sys->b_sps || !p_sys->b_pps )
 278             return VLC_EGENERIC;
 279
 280         /* FIXME: FFMPEG isn't happy at all if you leave this */
 281         if( p_dec->fmt_out.i_extra > 0 )
 282             free( p_dec->fmt_out.p_extra );
 283         p_dec->fmt_out.i_extra = 0;
 284         p_dec->fmt_out.p_extra = NULL;
 285
 286         /* Set the new extradata */
 287         for( i = 0; i < SPS_MAX; i++ )
 288         {
 289             if( p_sys->pp_sps[i] )
 290                 p_dec->fmt_out.i_extra += p_sys->pp_sps[i]->i_buffer;
 291         }
 292         for( i = 0; i < PPS_MAX; i++ )
 293         {
 294             if( p_sys->pp_pps[i] )
 295                 p_dec->fmt_out.i_extra += p_sys->pp_pps[i]->i_buffer;
 296         }
 297         p_dec->fmt_out.p_extra = malloc( p_dec->fmt_out.i_extra );
 298         if( p_dec->fmt_out.p_extra )
 299         {
 300             uint8_t *p_dst = p_dec->fmt_out.p_extra;
 301
 302             for( i = 0; i < SPS_MAX; i++ )
 303             {
 304                 if( p_sys->pp_sps[i] )
 305                 {
 306                     memcpy( p_dst, p_sys->pp_sps[i]->p_buffer, p_sys->pp_sps[i]->i_buffer );
 307                     p_dst += p_sys->pp_sps[i]->i_buffer;
 308                 }
 309             }
 310             for( i = 0; i < PPS_MAX; i++ )
 311             {
 312                 if( p_sys->pp_pps[i] )
 313                 {
 314                     memcpy( p_dst, p_sys->pp_pps[i]->p_buffer, p_sys->pp_pps[i]->i_buffer );
 315                     p_dst += p_sys->pp_pps[i]->i_buffer;
 316                 }
 317             }
 318             p_sys->b_header = true;
 319         }
 320         else
 321         {
 322             p_dec->fmt_out.i_extra = 0;
 323         }
 324
 325         /* Set callback */
 326         p_dec->pf_packetize = PacketizeAVC1;
 327     }
 328     else
 329     {
 330         /* This type of stream contains data with 3 of 4 byte startcodes
 331          * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes
 332          * The fmt_out.p_extra should be the same */
 333
 334         /* Set callback */
 335         p_dec->pf_packetize = Packetize;
 336
 337         /* */
 338         if( p_dec->fmt_in.i_extra > 0 )
 339         {
 340             block_t *p_init = block_New( p_dec, p_dec->fmt_in.i_extra );
 341             block_t *p_pic;
 342
 343             memcpy( p_init->p_buffer, p_dec->fmt_in.p_extra,
 344                     p_dec->fmt_in.i_extra );
 345
 346             while( ( p_pic = Packetize( p_dec, &p_init ) ) )
 347             {
 348                 /* Should not occur because we should only receive SPS/PPS */
 349                 block_Release( p_pic );
 350             }
 351         }
 352     }
 353
 354     return VLC_SUCCESS;
 355 }
 356
 357 /*****************************************************************************
 358  * Close: clean up the packetizer
 359  *****************************************************************************/
 360 static void Close( vlc_object_t *p_this )
 361 {
 362     decoder_t *p_dec = (decoder_t*)p_this;
 363     decoder_sys_t *p_sys = p_dec->p_sys;
 364     int i;
 365
 366     if( p_sys->p_frame ) block_ChainRelease( p_sys->p_frame );
 367     for( i = 0; i < SPS_MAX; i++ )
 368     {
 369         if( p_sys->pp_sps[i] )
 370             block_Release( p_sys->pp_sps[i] );
 371     }
 372     for( i = 0; i < PPS_MAX; i++ )
 373     {
 374         if( p_sys->pp_pps[i] )
 375             block_Release( p_sys->pp_pps[i] );
 376     }
 377     block_BytestreamRelease( &p_sys->bytestream );
 378     free( p_sys );
 379 }
 380
 381 /****************************************************************************
 382  * Packetize: the whole thing
 383  * Search for the startcodes 3 or more bytes
 384  * Feed ParseNALBlock ALWAYS with 4 byte startcode prepended NALs
 385  ****************************************************************************/
 386 static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
 387 {
 388     decoder_sys_t *p_sys = p_dec->p_sys;
 389     block_t       *p_pic;
 390
 391     if( !pp_block || !*pp_block )
 392         return NULL;
 393
 394     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 395     {
 396         if( (*pp_block)->i_flags&BLOCK_FLAG_CORRUPTED )
 397         {
 398             p_sys->i_state = STATE_NOSYNC;
 399             block_BytestreamFlush( &p_sys->bytestream );
 400
 401             if( p_sys->p_frame )
 402                 block_ChainRelease( p_sys->p_frame );
 403             p_sys->p_frame = NULL;
 404             p_sys->slice.i_frame_type = 0;
 405             p_sys->b_slice = false;
 406         }
 407         block_Release( *pp_block );
 408         return NULL;
 409     }
 410
 411     block_BytestreamPush( &p_sys->bytestream, *pp_block );
 412
 413     for( ;; )
 414     {
 415         bool b_used_ts;
 416
 417         switch( p_sys->i_state )
 418         {
 419             case STATE_NOSYNC:
 420                 /* Skip until 3 byte startcode 0 0 1 */
 421                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
 422                       &p_sys->i_offset, p_sys->startcode+1, 3 ) == VLC_SUCCESS)
 423                 {
 424                     p_sys->i_state = STATE_NEXT_SYNC;
 425                 }
 426
 427                 if( p_sys->i_offset )
 428                 {
 429                     /* skip the data */
 430                     block_SkipBytes( &p_sys->bytestream, p_sys->i_offset );
 431                     p_sys->i_offset = 0;
 432                     block_BytestreamFlush( &p_sys->bytestream );
 433                 }
 434
 435                 if( p_sys->i_state != STATE_NEXT_SYNC )
 436                 {
 437                     /* Need more data */
 438                     return NULL;
 439                 }
 440
 441                 p_sys->i_offset = 1; /* To find next startcode */
 442
 443             case STATE_NEXT_SYNC:
 444                 /* Find the next 3 byte startcode 0 0 1*/
 445                 if( block_FindStartcodeFromOffset( &p_sys->bytestream,
 446                       &p_sys->i_offset, p_sys->startcode+1, 3 ) != VLC_SUCCESS)
 447                 {
 448                     /* Need more data */
 449                     return NULL;
 450                 }
 451                 block_BytestreamFlush( &p_sys->bytestream );
 452
 453                 /* Get the new fragment and set the pts/dts */
 454                 block_t *p_block_bytestream = p_sys->bytestream.p_block;
 455
 456                 p_pic = block_New( p_dec, p_sys->i_offset +1 );
 457                 p_pic->i_pts = p_block_bytestream->i_pts;
 458                 p_pic->i_dts = p_block_bytestream->i_dts;
 459
 460                 /* Force 4 byte startcode 0 0 0 1 */
 461                 p_pic->p_buffer[0] = 0;
 462
 463                 block_GetBytes( &p_sys->bytestream, &p_pic->p_buffer[1],
 464                                 p_pic->i_buffer-1 );
 465
 466                 /* Remove trailing 0 bytes */
 467                 while( p_pic->i_buffer && (!p_pic->p_buffer[p_pic->i_buffer-1] ) )
 468                     p_pic->i_buffer--;
 469                 p_sys->i_offset = 0;
 470
 471                 /* Parse the NAL */
 472                 p_pic = ParseNALBlock( p_dec, &b_used_ts, p_pic );
 473                 if( b_used_ts )
 474                 {
 475                     p_block_bytestream->i_dts = -1;
 476                     p_block_bytestream->i_pts = -1;
 477                 }
 478
 479                 if( !p_pic )
 480                 {
 481                     p_sys->i_state = STATE_NOSYNC;
 482                     break;
 483                 }
 484 #if 0
 485                 msg_Dbg( p_dec, "pts=%"PRId64" dts=%"PRId64,
 486                          p_pic->i_pts, p_pic->i_dts );
 487 #endif
 488
 489                 /* So p_block doesn't get re-added several times */
 490                 *pp_block = block_BytestreamPop( &p_sys->bytestream );
 491
 492                 p_sys->i_state = STATE_NOSYNC;
 493
 494                 return p_pic;
 495         }
 496     }
 497 }
 498
 499 /****************************************************************************
 500  * PacketizeAVC1: Takes VCL blocks of data and creates annexe B type NAL stream
 501  * Will always use 4 byte 0 0 0 1 startcodes
 502  * Will prepend a SPS and PPS before each keyframe
 503  ****************************************************************************/
 504 static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
 505 {
 506     decoder_sys_t *p_sys = p_dec->p_sys;
 507     block_t       *p_block;
 508     block_t       *p_ret = NULL;
 509     uint8_t       *p;
 510
 511     if( !pp_block || !*pp_block )
 512         return NULL;
 513     if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
 514     {
 515         block_Release( *pp_block );
 516         return NULL;
 517     }
 518
 519     p_block = *pp_block;
 520     *pp_block = NULL;
 521
 522     for( p = p_block->p_buffer; p < &p_block->p_buffer[p_block->i_buffer]; )
 523     {
 524         block_t *p_pic;
 525         bool b_dummy;
 526         int i_size = 0;
 527         int i;
 528
 529         for( i = 0; i < p_sys->i_avcC_length_size; i++ )
 530         {
 531             i_size = (i_size << 8) | (*p++);
 532         }
 533
 534         if( i_size <= 0 ||
 535             i_size > ( p_block->p_buffer + p_block->i_buffer - p ) )
 536         {
 537             msg_Err( p_dec, "Broken frame : size %d is too big", i_size );
 538             break;
 539         }
 540
 541         block_t *p_part = CreateAnnexbNAL( p_dec, p, i_size );
 542         if( !p_part )
 543             break;
 544
 545         p_part->i_dts = p_block->i_dts;
 546         p_part->i_pts = p_block->i_pts;
 547
 548         /* Parse the NAL */
 549         if( ( p_pic = ParseNALBlock( p_dec, &b_dummy, p_part ) ) )
 550         {
 551             block_ChainAppend( &p_ret, p_pic );
 552         }
 553         p += i_size;
 554     }
 555     block_Release( p_block );
 556
 557     return p_ret;
 558 }
 559
 560 /****************************************************************************
 561  * Helpers
 562  ****************************************************************************/
 563 static block_t *CreateAnnexbNAL( decoder_t *p_dec, const uint8_t *p, int i_size )
 564 {
 565     block_t *p_nal;
 566
 567     p_nal = block_New( p_dec, 4 + i_size );
 568     if( !p_nal ) return NULL;
 569
 570     /* Add start code */
 571     p_nal->p_buffer[0] = 0x00;
 572     p_nal->p_buffer[1] = 0x00;
 573     p_nal->p_buffer[2] = 0x00;
 574     p_nal->p_buffer[3] = 0x01;
 575
 576     /* Copy nalu */
 577     memcpy( &p_nal->p_buffer[4], p, i_size );
 578
 579     VLC_UNUSED(p_dec);
 580     return p_nal;
 581 }
 582
 583 static void CreateDecodedNAL( uint8_t **pp_ret, int *pi_ret,
 584                               const uint8_t *src, int i_src )
 585 {
 586     const uint8_t *end = &src[i_src];
 587     uint8_t *dst = malloc( i_src );
 588
 589     *pp_ret = dst;
 590
 591     if( dst )
 592     {
 593         while( src < end )
 594         {
 595             if( src < end - 3 && src[0] == 0x00 && src[1] == 0x00 &&
 596                 src[2] == 0x03 )
 597             {
 598                 *dst++ = 0x00;
 599                 *dst++ = 0x00;
 600
 601                 src += 3;
 602                 continue;
 603             }
 604             *dst++ = *src++;
 605         }
 606     }
 607     *pi_ret = dst - *pp_ret;
 608 }
 609
 610 static inline int bs_read_ue( bs_t *s )
 611 {
 612     int i = 0;
 613
 614     while( bs_read1( s ) == 0 && s->p < s->p_end && i < 32 )
 615     {
 616         i++;
 617     }
 618     return( ( 1 << i) - 1 + bs_read( s, i ) );
 619 }
 620
 621 static inline int bs_read_se( bs_t *s )
 622 {
 623     int val = bs_read_ue( s );
 624
 625     return val&0x01 ? (val+1)/2 : -(val/2);
 626 }
 627
 628 /*****************************************************************************
 629  * ParseNALBlock: parses annexB type NALs
 630  * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
 631  *****************************************************************************/
 632 static block_t *ParseNALBlock( decoder_t *p_dec, bool *pb_used_ts, block_t *p_frag )
 633 {
 634     decoder_sys_t *p_sys = p_dec->p_sys;
 635     block_t *p_pic = NULL;
 636
 637     const int i_nal_ref_idc = (p_frag->p_buffer[4] >> 5)&0x03;
 638     const int i_nal_type = p_frag->p_buffer[4]&0x1f;
 639     const mtime_t i_frag_dts = p_frag->i_dts;
 640     const mtime_t i_frag_pts = p_frag->i_pts;
 641
 642     if( p_sys->b_slice && ( !p_sys->b_sps || !p_sys->b_pps ) )
 643     {
 644         block_ChainRelease( p_sys->p_frame );
 645         msg_Warn( p_dec, "waiting for SPS/PPS" );
 646
 647         /* Reset context */
 648         p_sys->slice.i_frame_type = 0;
 649         p_sys->p_frame = NULL;
 650         p_sys->b_slice = false;
 651     }
 652
 653     if( ( !p_sys->b_sps || !p_sys->b_pps ) &&
 654         i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
 655     {
 656         p_sys->b_slice = true;
 657         /* Fragment will be discarded later on */
 658     }
 659     else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
 660     {
 661         slice_t slice;
 662         bool  b_new_picture;
 663
 664         ParseSlice( p_dec, &b_new_picture, &slice, i_nal_ref_idc, i_nal_type, p_frag );
 665
 666         /* */
 667         if( b_new_picture && p_sys->b_slice )
 668             p_pic = OutputPicture( p_dec );
 669
 670         /* */
 671         p_sys->slice = slice;
 672         p_sys->b_slice = true;
 673     }
 674     else if( i_nal_type == NAL_SPS )
 675     {
 676         if( p_sys->b_slice )
 677             p_pic = OutputPicture( p_dec );
 678
 679         PutSPS( p_dec, p_frag );
 680
 681         /* Do not append the SPS because we will insert it on keyframes */
 682         p_frag = NULL;
 683     }
 684     else if( i_nal_type == NAL_PPS )
 685     {
 686         if( p_sys->b_slice )
 687             p_pic = OutputPicture( p_dec );
 688
 689         PutPPS( p_dec, p_frag );
 690
 691         /* Do not append the PPS because we will insert it on keyframes */
 692         p_frag = NULL;
 693     }
 694     else if( i_nal_type == NAL_AU_DELIMITER ||
 695              i_nal_type == NAL_SEI ||
 696              ( i_nal_type >= 13 && i_nal_type <= 18 ) )
 697     {
 698         if( p_sys->b_slice )
 699             p_pic = OutputPicture( p_dec );
 700
 701         /* TODO parse SEI for CC support */
 702     }
 703
 704     /* Append the block */
 705     if( p_frag )
 706         block_ChainAppend( &p_sys->p_frame, p_frag );
 707
 708     *pb_used_ts = false;
 709     if( p_sys->i_frame_dts < 0 && p_sys->i_frame_pts < 0 )
 710     {
 711         p_sys->i_frame_dts = i_frag_dts;
 712         p_sys->i_frame_pts = i_frag_pts;
 713         *pb_used_ts = true;
 714     }
 715     return p_pic;
 716 }
 717
 718 static block_t *OutputPicture( decoder_t *p_dec )
 719 {
 720     decoder_sys_t *p_sys = p_dec->p_sys;
 721     block_t *p_pic;
 722
 723     if( !p_sys->b_header && p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I)
 724         return NULL;
 725
 726     if( p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I && p_sys->b_sps && p_sys->b_pps )
 727     {
 728         block_t *p_list = NULL;
 729         int i;
 730
 731         for( i = 0; i < SPS_MAX; i++ )
 732         {
 733             if( p_sys->pp_sps[i] )
 734                 block_ChainAppend( &p_list, block_Duplicate( p_sys->pp_sps[i] ) );
 735         }
 736         for( i = 0; i < PPS_MAX; i++ )
 737         {
 738             if( p_sys->pp_pps[i] )
 739                 block_ChainAppend( &p_list, block_Duplicate( p_sys->pp_pps[i] ) );
 740         }
 741         if( p_list )
 742             p_sys->b_header = true;
 743
 744         block_ChainAppend( &p_list, p_sys->p_frame );
 745         p_pic = block_ChainGather( p_list );
 746     }
 747     else
 748     {
 749         p_pic = block_ChainGather( p_sys->p_frame );
 750     }
 751     p_pic->i_dts = p_sys->i_frame_dts;
 752     p_pic->i_pts = p_sys->i_frame_pts;
 753     p_pic->i_length = 0;    /* FIXME */
 754     p_pic->i_flags |= p_sys->slice.i_frame_type;
 755
 756     p_sys->slice.i_frame_type = 0;
 757     p_sys->p_frame = NULL;
 758     p_sys->i_frame_dts = -1;
 759     p_sys->i_frame_pts = -1;
 760     p_sys->b_slice = false;
 761
 762     return p_pic;
 763 }
 764
 765 static void PutSPS( decoder_t *p_dec, block_t *p_frag )
 766 {
 767     decoder_sys_t *p_sys = p_dec->p_sys;
 768
 769     uint8_t *pb_dec = NULL;
 770     int     i_dec = 0;
 771     bs_t s;
 772     int i_tmp;
 773     int i_sps_id;
 774
 775     CreateDecodedNAL( &pb_dec, &i_dec, &p_frag->p_buffer[5],
 776                      p_frag->i_buffer - 5 );
 777
 778     bs_init( &s, pb_dec, i_dec );
 779     /* Skip profile(8), constraint_set012, reserver(5), level(8) */
 780     bs_skip( &s, 8 + 1+1+1 + 5 + 8 );
 781     /* sps id */
 782     i_sps_id = bs_read_ue( &s );
 783     if( i_sps_id >= SPS_MAX )
 784     {
 785         msg_Warn( p_dec, "invalid SPS (sps_id=%d)", i_sps_id );
 786         free( pb_dec );
 787         block_Release( p_frag );
 788         return;
 789     }
 790
 791     /* Skip i_log2_max_frame_num */
 792     p_sys->i_log2_max_frame_num = bs_read_ue( &s );
 793     if( p_sys->i_log2_max_frame_num > 12)
 794         p_sys->i_log2_max_frame_num = 12;
 795     /* Read poc_type */
 796     p_sys->i_pic_order_cnt_type = bs_read_ue( &s );
 797     if( p_sys->i_pic_order_cnt_type == 0 )
 798     {
 799         /* skip i_log2_max_poc_lsb */
 800         p_sys->i_log2_max_pic_order_cnt_lsb = bs_read_ue( &s );
 801         if( p_sys->i_log2_max_pic_order_cnt_lsb > 12 )
 802             p_sys->i_log2_max_pic_order_cnt_lsb = 12;
 803     }
 804     else if( p_sys->i_pic_order_cnt_type == 1 )
 805     {
 806         int i_cycle;
 807         /* skip b_delta_pic_order_always_zero */
 808         p_sys->i_delta_pic_order_always_zero_flag = bs_read( &s, 1 );
 809         /* skip i_offset_for_non_ref_pic */
 810         bs_read_se( &s );
 811         /* skip i_offset_for_top_to_bottom_field */
 812         bs_read_se( &s );
 813         /* read i_num_ref_frames_in_poc_cycle */
 814         i_cycle = bs_read_ue( &s );
 815         if( i_cycle > 256 ) i_cycle = 256;
 816         while( i_cycle > 0 )
 817         {
 818             /* skip i_offset_for_ref_frame */
 819             bs_read_se(&s );
 820             i_cycle--;
 821         }
 822     }
 823     /* i_num_ref_frames */
 824     bs_read_ue( &s );
 825     /* b_gaps_in_frame_num_value_allowed */
 826     bs_skip( &s, 1 );
 827
 828     /* Read size */
 829     p_dec->fmt_out.video.i_width  = 16 * ( bs_read_ue( &s ) + 1 );
 830     p_dec->fmt_out.video.i_height = 16 * ( bs_read_ue( &s ) + 1 );
 831
 832     /* b_frame_mbs_only */
 833     p_sys->b_frame_mbs_only = bs_read( &s, 1 );
 834     if( p_sys->b_frame_mbs_only == 0 )
 835     {
 836         bs_skip( &s, 1 );
 837     }
 838     /* b_direct8x8_inference */
 839     bs_skip( &s, 1 );
 840
 841     /* crop */
 842     i_tmp = bs_read( &s, 1 );
 843     if( i_tmp )
 844     {
 845         /* left */
 846         bs_read_ue( &s );
 847         /* right */
 848         bs_read_ue( &s );
 849         /* top */
 850         bs_read_ue( &s );
 851         /* bottom */
 852         bs_read_ue( &s );
 853     }
 854
 855     /* vui */
 856     i_tmp = bs_read( &s, 1 );
 857     if( i_tmp )
 858     {
 859         /* read the aspect ratio part if any FIXME check it */
 860         i_tmp = bs_read( &s, 1 );
 861         if( i_tmp )
 862         {
 863             static const struct { int w, h; } sar[17] =
 864             {
 865                 { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
 866                 { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
 867                 { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
 868                 { 64, 33 }, { 160,99 }, {  4,  3 }, {  3,  2 },
 869                 {  2,  1 },
 870             };
 871             int i_sar = bs_read( &s, 8 );
 872             int w, h;
 873
 874             if( i_sar < 17 )
 875             {
 876                 w = sar[i_sar].w;
 877                 h = sar[i_sar].h;
 878             }
 879             else if( i_sar == 255 )
 880             {
 881                 w = bs_read( &s, 16 );
 882                 h = bs_read( &s, 16 );
 883             }
 884             else
 885             {
 886                 w = 0;
 887                 h = 0;
 888             }
 889
 890             if( h != 0 )
 891                 p_dec->fmt_out.video.i_aspect = (int64_t)VOUT_ASPECT_FACTOR *
 892                         ( w * p_dec->fmt_out.video.i_width ) /
 893                         ( h * p_dec->fmt_out.video.i_height);
 894             else
 895                 p_dec->fmt_out.video.i_aspect = VOUT_ASPECT_FACTOR;
 896         }
 897     }
 898
 899     free( pb_dec );
 900
 901     /* We have a new SPS */
 902     if( !p_sys->b_sps )
 903         msg_Dbg( p_dec, "found NAL_SPS (sps_id=%d)", i_sps_id );
 904     p_sys->b_sps = true;
 905
 906     if( p_sys->pp_sps[i_sps_id] )
 907         block_Release( p_sys->pp_sps[i_sps_id] );
 908     p_sys->pp_sps[i_sps_id] = p_frag;
 909 }
 910
 911 static void PutPPS( decoder_t *p_dec, block_t *p_frag )
 912 {
 913     decoder_sys_t *p_sys = p_dec->p_sys;
 914     bs_t s;
 915     int i_pps_id;
 916     int i_sps_id;
 917
 918     bs_init( &s, &p_frag->p_buffer[5], p_frag->i_buffer - 5 );
 919     i_pps_id = bs_read_ue( &s ); // pps id
 920     i_sps_id = bs_read_ue( &s ); // sps id
 921     if( i_pps_id >= PPS_MAX || i_sps_id >= SPS_MAX )
 922     {
 923         msg_Warn( p_dec, "invalid PPS (pps_id=%d sps_id=%d)", i_pps_id, i_sps_id );
 924         block_Release( p_frag );
 925         return;
 926     }
 927     bs_skip( &s, 1 ); // entropy coding mode flag
 928     p_sys->i_pic_order_present_flag = bs_read( &s, 1 );
 929     /* TODO */
 930
 931     /* We have a new PPS */
 932     if( !p_sys->b_pps )
 933         msg_Dbg( p_dec, "found NAL_PPS (pps_id=%d sps_id=%d)", i_pps_id, i_sps_id );
 934     p_sys->b_pps = true;
 935
 936     if( p_sys->pp_pps[i_pps_id] )
 937         block_Release( p_sys->pp_pps[i_pps_id] );
 938     p_sys->pp_pps[i_pps_id] = p_frag;
 939 }
 940
 941 static void ParseSlice( decoder_t *p_dec, bool *pb_new_picture, slice_t *p_slice,
 942                         int i_nal_ref_idc, int i_nal_type, const block_t *p_frag )
 943 {
 944     decoder_sys_t *p_sys = p_dec->p_sys;
 945     uint8_t *pb_dec;
 946     int i_dec;
 947     int i_first_mb, i_slice_type;
 948     slice_t slice;
 949     bs_t s;
 950
 951     /* do not convert the whole frame */
 952     CreateDecodedNAL( &pb_dec, &i_dec, &p_frag->p_buffer[5],
 953                      __MIN( p_frag->i_buffer - 5, 60 ) );
 954     bs_init( &s, pb_dec, i_dec );
 955
 956     /* first_mb_in_slice */
 957     i_first_mb = bs_read_ue( &s );
 958
 959     /* slice_type */
 960     switch( (i_slice_type = bs_read_ue( &s )) )
 961     {
 962     case 0: case 5:
 963         slice.i_frame_type = BLOCK_FLAG_TYPE_P;
 964         break;
 965     case 1: case 6:
 966         slice.i_frame_type = BLOCK_FLAG_TYPE_B;
 967         break;
 968     case 2: case 7:
 969         slice.i_frame_type = BLOCK_FLAG_TYPE_I;
 970         break;
 971     case 3: case 8: /* SP */
 972         slice.i_frame_type = BLOCK_FLAG_TYPE_P;
 973         break;
 974     case 4: case 9:
 975         slice.i_frame_type = BLOCK_FLAG_TYPE_I;
 976         break;
 977     default:
 978         slice.i_frame_type = 0;
 979         break;
 980     }
 981
 982     /* */
 983     slice.i_nal_type = i_nal_type;
 984     slice.i_nal_ref_idc = i_nal_ref_idc;
 985
 986     slice.i_pic_parameter_set_id = bs_read_ue( &s );
 987     slice.i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );
 988
 989     slice.i_field_pic_flag = 0;
 990     slice.i_bottom_field_flag = -1;
 991     if( !p_sys->b_frame_mbs_only )
 992     {
 993         /* field_pic_flag */
 994         slice.i_field_pic_flag = bs_read( &s, 1 );
 995         if( slice.i_field_pic_flag )
 996             slice.i_bottom_field_flag = bs_read( &s, 1 );
 997     }
 998
 999     slice.i_idr_pic_id = p_sys->slice.i_idr_pic_id;
1000     if( slice.i_nal_type == NAL_SLICE_IDR )
1001         slice.i_idr_pic_id = bs_read_ue( &s );
1002
1003     slice.i_pic_order_cnt_lsb = -1;
1004     slice.i_delta_pic_order_cnt_bottom = -1;
1005     slice.i_delta_pic_order_cnt0 = 0;
1006     slice.i_delta_pic_order_cnt1 = 0;
1007     if( p_sys->i_pic_order_cnt_type == 0 )
1008     {
1009         slice.i_pic_order_cnt_lsb = bs_read( &s, p_sys->i_log2_max_pic_order_cnt_lsb + 4 );
1010         if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag )
1011             slice.i_delta_pic_order_cnt_bottom = bs_read_se( &s );
1012     }
1013     else if( (p_sys->i_pic_order_cnt_type == 1) &&
1014              (!p_sys->i_delta_pic_order_always_zero_flag) )
1015     {
1016         slice.i_delta_pic_order_cnt0 = bs_read_se( &s );
1017         if( p_sys->i_pic_order_present_flag && !slice.i_field_pic_flag )
1018             slice.i_delta_pic_order_cnt1 = bs_read_se( &s );
1019     }
1020     free( pb_dec );
1021
1022     /* Detection of the first VCL NAL unit of a primary coded picture
1023      * (cf. 7.4.1.2.4) */
1024     bool b_pic = false;
1025     if( slice.i_frame_num != p_sys->slice.i_frame_num ||
1026         slice.i_pic_parameter_set_id != p_sys->slice.i_pic_parameter_set_id ||
1027         slice.i_field_pic_flag != p_sys->slice.i_field_pic_flag ||
1028         slice.i_nal_ref_idc != p_sys->slice.i_nal_ref_idc )
1029         b_pic = true;
1030     if( (slice.i_bottom_field_flag != -1) &&
1031         (p_sys->slice.i_bottom_field_flag != -1) &&
1032         (slice.i_bottom_field_flag != p_sys->slice.i_bottom_field_flag) )
1033         b_pic = true;
1034     if( p_sys->i_pic_order_cnt_type == 0 &&
1035         ( slice.i_pic_order_cnt_lsb != p_sys->slice.i_pic_order_cnt_lsb ||
1036           slice.i_delta_pic_order_cnt_bottom != p_sys->slice.i_delta_pic_order_cnt_bottom ) )
1037         b_pic = true;
1038     else if( p_sys->i_pic_order_cnt_type == 1 &&
1039              ( slice.i_delta_pic_order_cnt0 != p_sys->slice.i_delta_pic_order_cnt0 ||
1040                slice.i_delta_pic_order_cnt1 != p_sys->slice.i_delta_pic_order_cnt1 ) )
1041         b_pic = true;
1042     if( ( slice.i_nal_type == NAL_SLICE_IDR || p_sys->slice.i_nal_type == NAL_SLICE_IDR ) &&
1043         ( slice.i_nal_type != p_sys->slice.i_nal_type || slice.i_idr_pic_id != p_sys->slice.i_idr_pic_id ) )
1044             b_pic = true;
1045
1046     /* */
1047     *pb_new_picture = b_pic;
1048     *p_slice = slice;
1049 }
1050
1051