h264.c 40.2 KB
Newer Older
1 2 3
/*****************************************************************************
 * h264.c: h264/avc video packetizer
 *****************************************************************************
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
4
 * Copyright (C) 2001, 2002, 2006 VLC authors and VideoLAN
5
 * $Id$
6 7 8
 *
 * Authors: Laurent Aimar <fenrir@via.ecp.fr>
 *          Eric Petit <titer@videolan.org>
9
 *          Gildas Bazin <gbazin@videolan.org>
10
 *          Derk-Jan Hartman <hartman at videolan dot org>
11
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
12 13 14
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation; either version 2.1 of the License, or
15 16 17 18
 * (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
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
19 20
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
 * GNU Lesser General Public License for more details.
21
 *
Jean-Baptiste Kempf's avatar
LGPL  
Jean-Baptiste Kempf committed
22 23 24
 * You should have received a copy of the GNU Lesser General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 51 Franklin Street, Fifth Floor, Boston MA 02110-1301, USA.
25 26 27 28 29 30
 *****************************************************************************/

/*****************************************************************************
 * Preamble
 *****************************************************************************/

31 32 33 34
#ifdef HAVE_CONFIG_H
# include "config.h"
#endif

35
#include <vlc_common.h>
36
#include <vlc_plugin.h>
Clément Stenac's avatar
Clément Stenac committed
37 38 39
#include <vlc_sout.h>
#include <vlc_codec.h>
#include <vlc_block.h>
40

41 42
#include <vlc_block_helper.h>
#include <vlc_bits.h>
43
#include "../codec/cc.h"
44
#include "../codec/h264_nal.h"
45
#include "packetizer_helper.h"
46
#include "../demux/mpeg/mpeg_parser_helpers.h"
47 48 49 50 51 52 53

/*****************************************************************************
 * Module descriptor
 *****************************************************************************/
static int  Open ( vlc_object_t * );
static void Close( vlc_object_t * );

54 55 56 57 58 59 60
vlc_module_begin ()
    set_category( CAT_SOUT )
    set_subcategory( SUBCAT_SOUT_PACKETIZER )
    set_description( N_("H.264 video packetizer") )
    set_capability( "packetizer", 50 )
    set_callbacks( Open, Close )
vlc_module_end ()
61 62 63 64 65


/****************************************************************************
 * Local prototypes
 ****************************************************************************/
66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86
typedef struct
{
    int i_nal_type;
    int i_nal_ref_idc;

    int i_frame_type;
    int i_pic_parameter_set_id;
    int i_frame_num;

    int i_field_pic_flag;
    int i_bottom_field_flag;

    int i_idr_pic_id;

    int i_pic_order_cnt_lsb;
    int i_delta_pic_order_cnt_bottom;

    int i_delta_pic_order_cnt0;
    int i_delta_pic_order_cnt1;
} slice_t;

87 88
#define SPS_MAX (32)
#define PPS_MAX (256)
89 90
struct decoder_sys_t
{
91 92
    /* */
    packetizer_t packetizer;
93

94
    /* */
95 96
    bool    b_slice;
    block_t *p_frame;
97 98
    bool    b_frame_sps;
    bool    b_frame_pps;
99

100
    bool   b_header;
101 102
    bool   b_sps;
    bool   b_pps;
103 104
    block_t *pp_sps[SPS_MAX];
    block_t *pp_pps[PPS_MAX];
105
    int    i_recovery_frames;  /* -1 = no recovery */
106 107 108

    /* avcC data */
    int i_avcC_length_size;
109 110 111 112

    /* Useful values of the Sequence Parameter Set */
    int i_log2_max_frame_num;
    int b_frame_mbs_only;
113 114 115 116 117 118
    int i_pic_order_cnt_type;
    int i_delta_pic_order_always_zero_flag;
    int i_log2_max_pic_order_cnt_lsb;

    /* Value from Picture Parameter Set */
    int i_pic_order_present_flag;
119

120 121 122 123 124 125 126 127 128 129 130
    /* VUI */
    bool b_timing_info_present_flag;
    uint32_t i_num_units_in_tick;
    uint32_t i_time_scale;
    bool b_fixed_frame_rate;
    bool b_pic_struct_present_flag;
    uint8_t i_pic_struct;
    bool b_cpb_dpb_delays_present_flag;
    uint8_t i_cpb_removal_delay_length_minus1;
    uint8_t i_dpb_output_delay_length_minus1;

131
    /* Useful values of the Slice Header */
132
    slice_t slice;
Laurent Aimar's avatar
Laurent Aimar committed
133 134 135 136

    /* */
    mtime_t i_frame_pts;
    mtime_t i_frame_dts;
137
    int     i_fields_dts;
138 139 140 141 142 143

    /* */
    uint32_t i_cc_flags;
    mtime_t i_cc_pts;
    mtime_t i_cc_dts;
    cc_data_t cc;
144 145

    cc_data_t cc_next;
146 147 148 149 150 151 152 153 154 155 156 157
};

enum nal_unit_type_e
{
    NAL_UNKNOWN = 0,
    NAL_SLICE   = 1,
    NAL_SLICE_DPA   = 2,
    NAL_SLICE_DPB   = 3,
    NAL_SLICE_DPC   = 4,
    NAL_SLICE_IDR   = 5,    /* ref_idc != 0 */
    NAL_SEI         = 6,    /* ref_idc == 0 */
    NAL_SPS         = 7,
158 159
    NAL_PPS         = 8,
    NAL_AU_DELIMITER= 9
160 161 162
    /* ref_idc == 0 for 6,9,10,11,12 */
};

163 164 165
/* Defined in H.264 annex D */
enum sei_type_e
{
166
    SEI_PIC_TIMING = 1,
167 168 169 170
    SEI_USER_DATA_REGISTERED = 4,
    SEI_RECOVERY_POINT = 6
};

171 172
#define BLOCK_FLAG_PRIVATE_AUD (1 << BLOCK_FLAG_PRIVATE_SHIFT)

173 174 175
static block_t *Packetize( decoder_t *, block_t ** );
static block_t *PacketizeAVC1( decoder_t *, block_t ** );
static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] );
176

177 178 179 180
static void PacketizeReset( void *p_private, bool b_broken );
static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t * );
static int PacketizeValidate( void *p_private, block_t * );

181
static block_t *ParseNALBlock( decoder_t *, bool *pb_ts_used, block_t * );
Laurent Aimar's avatar
Laurent Aimar committed
182
static block_t *CreateAnnexbNAL( decoder_t *, const uint8_t *p, int );
183

184 185 186 187 188
static block_t *OutputPicture( decoder_t *p_dec );
static void PutSPS( decoder_t *p_dec, block_t *p_frag );
static void PutPPS( decoder_t *p_dec, block_t *p_frag );
static void ParseSlice( decoder_t *p_dec, bool *pb_new_picture, slice_t *p_slice,
                        int i_nal_ref_idc, int i_nal_type, const block_t *p_frag );
189
static void ParseSei( decoder_t *, block_t * );
190 191


192 193
static const uint8_t p_h264_startcode[3] = { 0x00, 0x00, 0x01 };

194 195
/*****************************************************************************
 * Open: probe the packetizer and return score
196 197
 * When opening after demux, the packetizer is only loaded AFTER the decoder
 * That means that what you set in fmt_out is ignored by the decoder in this special case
198 199 200 201 202
 *****************************************************************************/
static int Open( vlc_object_t *p_this )
{
    decoder_t     *p_dec = (decoder_t*)p_this;
    decoder_sys_t *p_sys;
203
    int i;
204

205 206 207 208
    if( p_dec->fmt_in.i_codec != VLC_CODEC_H264 )
        return VLC_EGENERIC;
    if( p_dec->fmt_in.i_original_fourcc == VLC_FOURCC( 'a', 'v', 'c', '1') &&
        p_dec->fmt_in.i_extra < 7 )
209 210 211 212 213
        return VLC_EGENERIC;

    /* Allocate the memory needed to store the decoder's structure */
    if( ( p_dec->p_sys = p_sys = malloc( sizeof(decoder_sys_t) ) ) == NULL )
    {
214
        return VLC_ENOMEM;
215
    }
216 217 218

    packetizer_Init( &p_sys->packetizer,
                     p_h264_startcode, sizeof(p_h264_startcode),
219
                     p_h264_startcode, 1, 5,
220 221
                     PacketizeReset, PacketizeParse, PacketizeValidate, p_dec );

222
    p_sys->b_slice = false;
223
    p_sys->p_frame = NULL;
224 225 226
    p_sys->b_frame_sps = false;
    p_sys->b_frame_pps = false;

227
    p_sys->b_header= false;
228 229
    p_sys->b_sps   = false;
    p_sys->b_pps   = false;
230 231 232 233
    for( i = 0; i < SPS_MAX; i++ )
        p_sys->pp_sps[i] = NULL;
    for( i = 0; i < PPS_MAX; i++ )
        p_sys->pp_pps[i] = NULL;
234
    p_sys->i_recovery_frames = -1;
235

236 237 238 239 240 241 242 243 244 245
    p_sys->slice.i_nal_type = -1;
    p_sys->slice.i_nal_ref_idc = -1;
    p_sys->slice.i_idr_pic_id = -1;
    p_sys->slice.i_frame_num = -1;
    p_sys->slice.i_frame_type = 0;
    p_sys->slice.i_pic_parameter_set_id = -1;
    p_sys->slice.i_field_pic_flag = 0;
    p_sys->slice.i_bottom_field_flag = -1;
    p_sys->slice.i_pic_order_cnt_lsb = -1;
    p_sys->slice.i_delta_pic_order_cnt_bottom = -1;
246

247 248 249 250 251 252
    p_sys->b_timing_info_present_flag = false;
    p_sys->b_pic_struct_present_flag = false;
    p_sys->b_cpb_dpb_delays_present_flag = false;
    p_sys->i_cpb_removal_delay_length_minus1 = 0;
    p_sys->i_dpb_output_delay_length_minus1 = 0;

253 254
    p_sys->i_frame_dts = VLC_TS_INVALID;
    p_sys->i_frame_pts = VLC_TS_INVALID;
255
    p_sys->i_fields_dts = 0;
Laurent Aimar's avatar
Laurent Aimar committed
256

257 258
    /* Setup properties */
    es_format_Copy( &p_dec->fmt_out, &p_dec->fmt_in );
259
    p_dec->fmt_out.i_codec = VLC_CODEC_H264;
260

261
    if( p_dec->fmt_in.i_original_fourcc == VLC_FOURCC( 'a', 'v', 'c', '1' ) )
262
    {
263 264 265 266
        /* This type of stream is produced by mp4 and matroska
         * when we want to store it in another streamformat, you need to convert
         * The fmt_in.p_extra should ALWAYS contain the avcC
         * The fmt_out.p_extra should contain all the SPS and PPS with 4 byte startcodes */
267 268
        uint8_t *p = &((uint8_t*)p_dec->fmt_in.p_extra)[4];
        int i_sps, i_pps;
Laurent Aimar's avatar
Laurent Aimar committed
269
        bool b_dummy;
270 271 272 273 274 275 276 277 278
        int i;

        /* Parse avcC */
        p_sys->i_avcC_length_size = 1 + ((*p++)&0x03);

        /* Read SPS */
        i_sps = (*p++)&0x1f;
        for( i = 0; i < i_sps; i++ )
        {
279 280 281 282 283 284
            uint16_t i_length = GetWBE( p ); p += 2;
            if( i_length >
                (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p )
            {
                return VLC_EGENERIC;
            }
Laurent Aimar's avatar
Laurent Aimar committed
285
            block_t *p_sps = CreateAnnexbNAL( p_dec, p, i_length );
286 287
            if( !p_sps )
                return VLC_EGENERIC;
Laurent Aimar's avatar
Laurent Aimar committed
288
            ParseNALBlock( p_dec, &b_dummy, p_sps );
289
            p += i_length;
290 291 292 293 294
        }
        /* Read PPS */
        i_pps = *p++;
        for( i = 0; i < i_pps; i++ )
        {
295 296 297 298 299 300
            uint16_t i_length = GetWBE( p ); p += 2;
            if( i_length >
                (uint8_t*)p_dec->fmt_in.p_extra + p_dec->fmt_in.i_extra - p )
            {
                return VLC_EGENERIC;
            }
Laurent Aimar's avatar
Laurent Aimar committed
301
            block_t *p_pps = CreateAnnexbNAL( p_dec, p, i_length );
302 303
            if( !p_pps )
                return VLC_EGENERIC;
Laurent Aimar's avatar
Laurent Aimar committed
304
            ParseNALBlock( p_dec, &b_dummy, p_pps );
305
            p += i_length;
306
        }
307
        msg_Dbg( p_dec, "avcC length size=%d, sps=%d, pps=%d",
308 309
                 p_sys->i_avcC_length_size, i_sps, i_pps );

310
        if( !p_sys->b_sps || !p_sys->b_pps )
311 312
            return VLC_EGENERIC;

313
        /* FIXME: FFMPEG isn't happy at all if you leave this */
314 315
        if( p_dec->fmt_out.i_extra > 0 )
            free( p_dec->fmt_out.p_extra );
316 317
        p_dec->fmt_out.i_extra = 0;
        p_dec->fmt_out.p_extra = NULL;
318

319
        /* Set the new extradata */
320 321 322 323 324 325 326 327 328 329
        for( i = 0; i < SPS_MAX; i++ )
        {
            if( p_sys->pp_sps[i] )
                p_dec->fmt_out.i_extra += p_sys->pp_sps[i]->i_buffer;
        }
        for( i = 0; i < PPS_MAX; i++ )
        {
            if( p_sys->pp_pps[i] )
                p_dec->fmt_out.i_extra += p_sys->pp_pps[i]->i_buffer;
        }
330
        p_dec->fmt_out.p_extra = malloc( p_dec->fmt_out.i_extra );
331 332
        if( p_dec->fmt_out.p_extra )
        {
333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 348 349 350
            uint8_t *p_dst = p_dec->fmt_out.p_extra;

            for( i = 0; i < SPS_MAX; i++ )
            {
                if( p_sys->pp_sps[i] )
                {
                    memcpy( p_dst, p_sys->pp_sps[i]->p_buffer, p_sys->pp_sps[i]->i_buffer );
                    p_dst += p_sys->pp_sps[i]->i_buffer;
                }
            }
            for( i = 0; i < PPS_MAX; i++ )
            {
                if( p_sys->pp_pps[i] )
                {
                    memcpy( p_dst, p_sys->pp_pps[i]->p_buffer, p_sys->pp_pps[i]->i_buffer );
                    p_dst += p_sys->pp_pps[i]->i_buffer;
                }
            }
351
            p_sys->b_header = true;
352
        }
353 354 355 356
        else
        {
            p_dec->fmt_out.i_extra = 0;
        }
357

358 359
        /* Set callback */
        p_dec->pf_packetize = PacketizeAVC1;
360
        /* TODO CC ? */
361 362 363
    }
    else
    {
364
        /* This type of stream contains data with 3 of 4 byte startcodes
365 366
         * The fmt_in.p_extra MAY contain SPS/PPS with 4 byte startcodes
         * The fmt_out.p_extra should be the same */
367

368 369
        /* Set callback */
        p_dec->pf_packetize = Packetize;
370 371 372
        p_dec->pf_get_cc = GetCc;

        /* */
373 374
        p_sys->i_cc_pts = VLC_TS_INVALID;
        p_sys->i_cc_dts = VLC_TS_INVALID;
375 376
        p_sys->i_cc_flags = 0;
        cc_Init( &p_sys->cc );
377
        cc_Init( &p_sys->cc_next );
378 379 380

        /* */
        if( p_dec->fmt_in.i_extra > 0 )
381 382
            packetizer_Header( &p_sys->packetizer,
                               p_dec->fmt_in.p_extra, p_dec->fmt_in.i_extra );
383 384 385 386 387 388 389 390 391 392 393 394
    }

    return VLC_SUCCESS;
}

/*****************************************************************************
 * Close: clean up the packetizer
 *****************************************************************************/
static void Close( vlc_object_t *p_this )
{
    decoder_t *p_dec = (decoder_t*)p_this;
    decoder_sys_t *p_sys = p_dec->p_sys;
395
    int i;
396

397 398
    if( p_sys->p_frame )
        block_ChainRelease( p_sys->p_frame );
399 400 401 402 403 404 405 406 407 408
    for( i = 0; i < SPS_MAX; i++ )
    {
        if( p_sys->pp_sps[i] )
            block_Release( p_sys->pp_sps[i] );
    }
    for( i = 0; i < PPS_MAX; i++ )
    {
        if( p_sys->pp_pps[i] )
            block_Release( p_sys->pp_pps[i] );
    }
409 410
    packetizer_Clean( &p_sys->packetizer );

411
    if( p_dec->pf_get_cc )
412 413
    {
         cc_Exit( &p_sys->cc_next );
414
         cc_Exit( &p_sys->cc );
415
    }
416

417 418 419 420 421
    free( p_sys );
}

/****************************************************************************
 * Packetize: the whole thing
422 423
 * Search for the startcodes 3 or more bytes
 * Feed ParseNALBlock ALWAYS with 4 byte startcode prepended NALs
424 425 426 427 428
 ****************************************************************************/
static block_t *Packetize( decoder_t *p_dec, block_t **pp_block )
{
    decoder_sys_t *p_sys = p_dec->p_sys;

429
    return packetizer_Packetize( &p_sys->packetizer, pp_block );
430 431
}

432
/****************************************************************************
433 434
 * PacketizeAVC1: Takes VCL blocks of data and creates annexe B type NAL stream
 * Will always use 4 byte 0 0 0 1 startcodes
435
 * Will prepend a SPS and PPS before each keyframe
436 437 438 439 440 441 442 443
 ****************************************************************************/
static block_t *PacketizeAVC1( decoder_t *p_dec, block_t **pp_block )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    block_t       *p_block;
    block_t       *p_ret = NULL;
    uint8_t       *p;

444 445 446 447 448 449 450
    if( !pp_block || !*pp_block )
        return NULL;
    if( (*pp_block)->i_flags&(BLOCK_FLAG_DISCONTINUITY|BLOCK_FLAG_CORRUPTED) )
    {
        block_Release( *pp_block );
        return NULL;
    }
451 452 453 454 455 456 457

    p_block = *pp_block;
    *pp_block = NULL;

    for( p = p_block->p_buffer; p < &p_block->p_buffer[p_block->i_buffer]; )
    {
        block_t *p_pic;
Laurent Aimar's avatar
Laurent Aimar committed
458
        bool b_dummy;
459 460 461 462 463 464 465 466
        int i_size = 0;
        int i;

        for( i = 0; i < p_sys->i_avcC_length_size; i++ )
        {
            i_size = (i_size << 8) | (*p++);
        }

467
        if( i_size <= 0 ||
468
            i_size > ( p_block->p_buffer + p_block->i_buffer - p ) )
469
        {
470 471 472
            msg_Err( p_dec, "Broken frame : size %d is too big", i_size );
            break;
        }
473

Laurent Aimar's avatar
Laurent Aimar committed
474
        block_t *p_part = CreateAnnexbNAL( p_dec, p, i_size );
475 476
        if( !p_part )
            break;
Laurent Aimar's avatar
Laurent Aimar committed
477

478 479 480 481
        p_part->i_dts = p_block->i_dts;
        p_part->i_pts = p_block->i_pts;

        /* Parse the NAL */
Laurent Aimar's avatar
Laurent Aimar committed
482
        if( ( p_pic = ParseNALBlock( p_dec, &b_dummy, p_part ) ) )
483 484
        {
            block_ChainAppend( &p_ret, p_pic );
485 486 487
        }
        p += i_size;
    }
488
    block_Release( p_block );
489 490 491 492

    return p_ret;
}

493 494 495 496 497 498 499 500 501 502 503 504 505 506
/*****************************************************************************
 * GetCc:
 *****************************************************************************/
static block_t *GetCc( decoder_t *p_dec, bool pb_present[4] )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    block_t *p_cc;

    for( int i = 0; i < 4; i++ )
        pb_present[i] = p_sys->cc.pb_present[i];

    if( p_sys->cc.i_data <= 0 )
        return NULL;

507
    p_cc = block_Alloc( p_sys->cc.i_data);
508 509 510 511 512 513 514 515 516 517 518
    if( p_cc )
    {
        memcpy( p_cc->p_buffer, p_sys->cc.p_data, p_sys->cc.i_data );
        p_cc->i_dts =
        p_cc->i_pts = p_sys->cc.b_reorder ? p_sys->i_cc_pts : p_sys->i_cc_dts;
        p_cc->i_flags = ( p_sys->cc.b_reorder  ? p_sys->i_cc_flags : BLOCK_FLAG_TYPE_P ) & BLOCK_FLAG_TYPE_MASK;
    }
    cc_Flush( &p_sys->cc );
    return p_cc;
}

Laurent Aimar's avatar
Laurent Aimar committed
519 520 521
/****************************************************************************
 * Helpers
 ****************************************************************************/
522 523 524 525 526 527 528 529 530 531
static void PacketizeReset( void *p_private, bool b_broken )
{
    decoder_t *p_dec = p_private;
    decoder_sys_t *p_sys = p_dec->p_sys;

    if( b_broken )
    {
        if( p_sys->p_frame )
            block_ChainRelease( p_sys->p_frame );
        p_sys->p_frame = NULL;
532 533
        p_sys->b_frame_sps = false;
        p_sys->b_frame_pps = false;
534 535 536
        p_sys->slice.i_frame_type = 0;
        p_sys->b_slice = false;
    }
537 538
    p_sys->i_frame_pts = VLC_TS_INVALID;
    p_sys->i_frame_dts = VLC_TS_INVALID;
539 540 541 542 543 544
}
static block_t *PacketizeParse( void *p_private, bool *pb_ts_used, block_t *p_block )
{
    decoder_t *p_dec = p_private;

    /* Remove trailing 0 bytes */
545
    while( p_block->i_buffer > 5 && p_block->p_buffer[p_block->i_buffer-1] == 0x00 )
546 547 548 549 550 551 552 553 554 555 556
        p_block->i_buffer--;

    return ParseNALBlock( p_dec, pb_ts_used, p_block );
}
static int PacketizeValidate( void *p_private, block_t *p_au )
{
    VLC_UNUSED(p_private);
    VLC_UNUSED(p_au);
    return VLC_SUCCESS;
}

Laurent Aimar's avatar
Laurent Aimar committed
557
static block_t *CreateAnnexbNAL( decoder_t *p_dec, const uint8_t *p, int i_size )
558 559 560
{
    block_t *p_nal;

561
    p_nal = block_Alloc( 4 + i_size );
562
    if( !p_nal ) return NULL;
563

564 565 566
    /* Add start code */
    p_nal->p_buffer[0] = 0x00;
    p_nal->p_buffer[1] = 0x00;
567 568
    p_nal->p_buffer[2] = 0x00;
    p_nal->p_buffer[3] = 0x01;
569

570
    /* Copy nalu */
571
    memcpy( &p_nal->p_buffer[4], p, i_size );
572

573
    VLC_UNUSED(p_dec);
574 575 576
    return p_nal;
}

Laurent Aimar's avatar
Laurent Aimar committed
577
static void CreateDecodedNAL( uint8_t **pp_ret, int *pi_ret,
Laurent Aimar's avatar
Laurent Aimar committed
578
                              const uint8_t *src, int i_src )
579 580 581
{
    uint8_t *dst = malloc( i_src );

582 583
    *pp_ret = dst;

584
    if( dst )
585
        *pi_ret = nal_decode(src, dst, i_src);
586 587
}

588 589
/*****************************************************************************
 * ParseNALBlock: parses annexB type NALs
590
 * All p_frag blocks are required to start with 0 0 0 1 4-byte startcode
591
 *****************************************************************************/
592
static block_t *ParseNALBlock( decoder_t *p_dec, bool *pb_ts_used, block_t *p_frag )
593 594 595 596
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    block_t *p_pic = NULL;

597 598
    const int i_nal_ref_idc = (p_frag->p_buffer[4] >> 5)&0x03;
    const int i_nal_type = p_frag->p_buffer[4]&0x1f;
Laurent Aimar's avatar
Laurent Aimar committed
599 600
    const mtime_t i_frag_dts = p_frag->i_dts;
    const mtime_t i_frag_pts = p_frag->i_pts;
601

602
    if( p_sys->b_slice && ( !p_sys->b_sps || !p_sys->b_pps ) )
603
    {
604
        block_ChainRelease( p_sys->p_frame );
605
        msg_Warn( p_dec, "waiting for SPS/PPS" );
606

607
        /* Reset context */
608
        p_sys->slice.i_frame_type = 0;
609
        p_sys->p_frame = NULL;
610 611
        p_sys->b_frame_sps = false;
        p_sys->b_frame_pps = false;
612
        p_sys->b_slice = false;
613
        cc_Flush( &p_sys->cc_next );
614 615
    }

616
    if( ( !p_sys->b_sps || !p_sys->b_pps ) &&
617 618
        i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
    {
619
        p_sys->b_slice = true;
620 621 622
        /* Fragment will be discarded later on */
    }
    else if( i_nal_type >= NAL_SLICE && i_nal_type <= NAL_SLICE_IDR )
623
    {
624
        slice_t slice;
Laurent Aimar's avatar
Laurent Aimar committed
625
        bool  b_new_picture;
626

627
        ParseSlice( p_dec, &b_new_picture, &slice, i_nal_ref_idc, i_nal_type, p_frag );
628

629
        /* */
630 631
        if( b_new_picture && p_sys->b_slice )
            p_pic = OutputPicture( p_dec );
632 633 634

        /* */
        p_sys->slice = slice;
635 636 637 638 639
        p_sys->b_slice = true;
    }
    else if( i_nal_type == NAL_SPS )
    {
        if( p_sys->b_slice )
640
            p_pic = OutputPicture( p_dec );
641
        p_sys->b_frame_sps = true;
642

643
        PutSPS( p_dec, p_frag );
644

645
        /* Do not append the SPS because we will insert it on keyframes */
Laurent Aimar's avatar
Laurent Aimar committed
646
        p_frag = NULL;
647
    }
648
    else if( i_nal_type == NAL_PPS )
649
    {
650 651
        if( p_sys->b_slice )
            p_pic = OutputPicture( p_dec );
652
        p_sys->b_frame_pps = true;
653 654

        PutPPS( p_dec, p_frag );
655

656
        /* Do not append the PPS because we will insert it on keyframes */
Laurent Aimar's avatar
Laurent Aimar committed
657
        p_frag = NULL;
658 659 660 661 662
    }
    else if( i_nal_type == NAL_AU_DELIMITER ||
             i_nal_type == NAL_SEI ||
             ( i_nal_type >= 13 && i_nal_type <= 18 ) )
    {
663 664
        if( p_sys->b_slice )
            p_pic = OutputPicture( p_dec );
Laurent Aimar's avatar
Laurent Aimar committed
665

666
        /* Parse SEI for CC support */
667
        if( i_nal_type == NAL_SEI )
668
        {
669
            ParseSei( p_dec, p_frag );
670 671 672 673 674 675 676 677 678 679 680 681 682
        }
        else if( i_nal_type == NAL_AU_DELIMITER )
        {
            if( p_sys->p_frame && (p_sys->p_frame->i_flags & BLOCK_FLAG_PRIVATE_AUD) )
            {
                block_Release( p_frag );
                p_frag = NULL;
            }
            else
            {
                p_frag->i_flags |= BLOCK_FLAG_PRIVATE_AUD;
            }
        }
683 684
    }

685
    /* Append the block */
Laurent Aimar's avatar
Laurent Aimar committed
686 687
    if( p_frag )
        block_ChainAppend( &p_sys->p_frame, p_frag );
688

689
    *pb_ts_used = false;
690
    if( p_sys->i_frame_dts <= VLC_TS_INVALID &&
691
        p_sys->i_frame_pts <= VLC_TS_INVALID )
Laurent Aimar's avatar
Laurent Aimar committed
692 693 694
    {
        p_sys->i_frame_dts = i_frag_dts;
        p_sys->i_frame_pts = i_frag_pts;
695
        p_sys->i_fields_dts = 2;
696
        *pb_ts_used = true;
Laurent Aimar's avatar
Laurent Aimar committed
697
    }
698 699
    return p_pic;
}
700

701 702 703 704
static block_t *OutputPicture( decoder_t *p_dec )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    block_t *p_pic;
705

706 707 708 709 710 711 712 713 714 715 716 717
    if ( !p_sys->b_header && p_sys->i_recovery_frames != -1 )
    {
        if( p_sys->i_recovery_frames == 0 )
        {
            msg_Dbg( p_dec, "Recovery from SEI recovery point complete" );
            p_sys->b_header = true;
        }
        --p_sys->i_recovery_frames;
    }

    if( !p_sys->b_header && p_sys->i_recovery_frames == -1 &&
         p_sys->slice.i_frame_type != BLOCK_FLAG_TYPE_I)
718 719
        return NULL;

720 721 722 723
    const bool b_sps_pps_i = p_sys->slice.i_frame_type == BLOCK_FLAG_TYPE_I &&
                             p_sys->b_sps &&
                             p_sys->b_pps;
    if( b_sps_pps_i || p_sys->b_frame_sps || p_sys->b_frame_pps )
724
    {
725 726 727 728 729 730
        block_t *p_head = NULL;
        if( p_sys->p_frame->i_flags & BLOCK_FLAG_PRIVATE_AUD )
        {
            p_head = p_sys->p_frame;
            p_sys->p_frame = p_sys->p_frame->p_next;
        }
731

732
        block_t *p_list = NULL;
733
        for( int i = 0; i < SPS_MAX && (b_sps_pps_i || p_sys->b_frame_sps); i++ )
734 735 736 737
        {
            if( p_sys->pp_sps[i] )
                block_ChainAppend( &p_list, block_Duplicate( p_sys->pp_sps[i] ) );
        }
738
        for( int i = 0; i < PPS_MAX && (b_sps_pps_i || p_sys->b_frame_pps); i++ )
739 740 741 742
        {
            if( p_sys->pp_pps[i] )
                block_ChainAppend( &p_list, block_Duplicate( p_sys->pp_pps[i] ) );
        }
743
        if( b_sps_pps_i && p_list )
744
            p_sys->b_header = true;
Laurent Aimar's avatar
Laurent Aimar committed
745

746 747 748 749 750 751 752
        if( p_head )
            p_head->p_next = p_list;
        else
            p_head = p_list;
        block_ChainAppend( &p_head, p_sys->p_frame );

        p_pic = block_ChainGather( p_head );
753 754 755 756 757
    }
    else
    {
        p_pic = block_ChainGather( p_sys->p_frame );
    }
Laurent Aimar's avatar
Laurent Aimar committed
758 759
    p_pic->i_dts = p_sys->i_frame_dts;
    p_pic->i_pts = p_sys->i_frame_pts;
760 761
    p_pic->i_length = 0;    /* FIXME */
    p_pic->i_flags |= p_sys->slice.i_frame_type;
762
    p_pic->i_flags &= ~BLOCK_FLAG_PRIVATE_AUD;
763 764
    if( !p_sys->b_header )
        p_pic->i_flags |= BLOCK_FLAG_PREROLL;
765

766 767 768 769 770 771 772 773 774 775 776 777 778 779 780 781 782 783 784 785 786 787 788 789 790 791 792 793 794
    if( p_sys->b_frame_mbs_only == 0 && p_sys->b_pic_struct_present_flag )
    {
        switch( p_sys->i_pic_struct )
        {
        case 1:
            if( p_sys->i_fields_dts == 2 )
                p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
            else
                p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
            break;
        case 3:
        case 5:
            p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
            break;
        case 2:
            if( p_sys->i_fields_dts == 2 )
                p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
            else
                p_pic->i_flags |= BLOCK_FLAG_TOP_FIELD_FIRST;
            break;
        case 4:
        case 6:
            p_pic->i_flags |= BLOCK_FLAG_BOTTOM_FIELD_FIRST;
            break;
        default:
            break;
        }
    }

795 796 797 798 799 800
    p_sys->i_fields_dts -= (1 + p_sys->b_frame_mbs_only);
    if( p_sys->i_fields_dts <= 0 )
    {
        p_sys->i_frame_dts = VLC_TS_INVALID;
        p_sys->i_frame_pts = VLC_TS_INVALID;
    }
801
    else if( p_sys->b_timing_info_present_flag && p_sys->i_time_scale )
802 803 804 805 806
    {
        p_sys->i_frame_pts += CLOCK_FREQ * p_sys->i_num_units_in_tick / p_sys->i_time_scale;
    }
    else p_sys->i_frame_pts = VLC_TS_INVALID;

807 808
    p_sys->slice.i_frame_type = 0;
    p_sys->p_frame = NULL;
809 810
    p_sys->b_frame_sps = false;
    p_sys->b_frame_pps = false;
811 812
    p_sys->b_slice = false;

813 814 815 816 817
    /* CC */
    p_sys->i_cc_pts = p_pic->i_pts;
    p_sys->i_cc_dts = p_pic->i_dts;
    p_sys->i_cc_flags = p_pic->i_flags;

818 819 820
    p_sys->cc = p_sys->cc_next;
    cc_Flush( &p_sys->cc_next );

821 822
    return p_pic;
}
823

824 825 826
static void PutSPS( decoder_t *p_dec, block_t *p_frag )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
827

828
    uint8_t *pb_dec = NULL;
829 830 831
    int     i_dec = 0;
    bs_t s;
    int i_tmp;
832
    int i_sps_id;
833

834
    CreateDecodedNAL( &pb_dec, &i_dec, &p_frag->p_buffer[5],
835 836
                     p_frag->i_buffer - 5 );

837
    bs_init( &s, pb_dec, i_dec );
838
    int i_profile_idc = bs_read( &s, 8 );
839 840 841 842
    p_dec->fmt_out.i_profile = i_profile_idc;
    /* Skip constraint_set0123, reserved(4) */
    bs_skip( &s, 1+1+1+1 + 4 );
    p_dec->fmt_out.i_level = bs_read( &s, 8 );
843
    /* sps id */
844
    i_sps_id = bs_read_ue( &s );
845
    if( i_sps_id >= SPS_MAX || i_sps_id < 0 )
846 847 848 849 850 851 852
    {
        msg_Warn( p_dec, "invalid SPS (sps_id=%d)", i_sps_id );
        free( pb_dec );
        block_Release( p_frag );
        return;
    }

853 854 855 856
    if( i_profile_idc == PROFILE_H264_HIGH || i_profile_idc == PROFILE_H264_HIGH_10 ||
        i_profile_idc == PROFILE_H264_HIGH_422 || i_profile_idc == PROFILE_H264_HIGH_444_PREDICTIVE ||
        i_profile_idc ==  PROFILE_H264_CAVLC_INTRA || i_profile_idc ==  PROFILE_H264_SVC_BASELINE ||
        i_profile_idc ==  PROFILE_H264_SVC_HIGH )
857 858
    {
        /* chroma_format_idc */
Laurent Aimar's avatar
Laurent Aimar committed
859 860
        const int i_chroma_format_idc = bs_read_ue( &s );
        if( i_chroma_format_idc == 3 )
Rémi Denis-Courmont's avatar
Rémi Denis-Courmont committed
861
            bs_skip( &s, 1 ); /* separate_colour_plane_flag */
862 863 864 865 866 867 868 869 870 871
        /* bit_depth_luma_minus8 */
        bs_read_ue( &s );
        /* bit_depth_chroma_minus8 */
        bs_read_ue( &s );
        /* qpprime_y_zero_transform_bypass_flag */
        bs_skip( &s, 1 );
        /* seq_scaling_matrix_present_flag */
        i_tmp = bs_read( &s, 1 );
        if( i_tmp )
        {
Laurent Aimar's avatar
Laurent Aimar committed
872 873
            for( int i = 0; i < ((3 != i_chroma_format_idc) ? 8 : 12); i++ )
            {
874 875 876 877
                /* seq_scaling_list_present_flag[i] */
                i_tmp = bs_read( &s, 1 );
                if( !i_tmp )
                    continue;
Laurent Aimar's avatar
Laurent Aimar committed
878
                const int i_size_of_scaling_list = (i < 6 ) ? 16 : 64;
879 880 881
                /* scaling_list (...) */
                int i_lastscale = 8;
                int i_nextscale = 8;
Laurent Aimar's avatar
Laurent Aimar committed
882 883 884 885
                for( int j = 0; j < i_size_of_scaling_list; j++ )
                {
                    if( i_nextscale != 0 )
                    {
886
                        /* delta_scale */
887
                        i_tmp = bs_read_se( &s );
888 889 890 891 892 893 894 895 896 897
                        i_nextscale = ( i_lastscale + i_tmp + 256 ) % 256;
                        /* useDefaultScalingMatrixFlag = ... */
                    }
                    /* scalinglist[j] */
                    i_lastscale = ( i_nextscale == 0 ) ? i_lastscale : i_nextscale;
                }
            }
        }
    }

898 899 900 901 902 903 904 905 906 907 908 909 910 911 912 913 914 915 916 917 918 919 920 921 922 923
    /* Skip i_log2_max_frame_num */
    p_sys->i_log2_max_frame_num = bs_read_ue( &s );
    if( p_sys->i_log2_max_frame_num > 12)
        p_sys->i_log2_max_frame_num = 12;
    /* Read poc_type */
    p_sys->i_pic_order_cnt_type = bs_read_ue( &s );
    if( p_sys->i_pic_order_cnt_type == 0 )
    {
        /* skip i_log2_max_poc_lsb */
        p_sys->i_log2_max_pic_order_cnt_lsb = bs_read_ue( &s );
        if( p_sys->i_log2_max_pic_order_cnt_lsb > 12 )
            p_sys->i_log2_max_pic_order_cnt_lsb = 12;
    }
    else if( p_sys->i_pic_order_cnt_type == 1 )
    {
        int i_cycle;
        /* skip b_delta_pic_order_always_zero */
        p_sys->i_delta_pic_order_always_zero_flag = bs_read( &s, 1 );
        /* skip i_offset_for_non_ref_pic */
        bs_read_se( &s );
        /* skip i_offset_for_top_to_bottom_field */
        bs_read_se( &s );
        /* read i_num_ref_frames_in_poc_cycle */
        i_cycle = bs_read_ue( &s );
        if( i_cycle > 256 ) i_cycle = 256;
        while( i_cycle > 0 )
924
        {
925 926
            /* skip i_offset_for_ref_frame */
            bs_read_se(&s );
Laurent Aimar's avatar
Laurent Aimar committed
927
            i_cycle--;
928
        }
929 930 931 932 933 934 935 936 937 938 939 940
    }
    /* i_num_ref_frames */
    bs_read_ue( &s );
    /* b_gaps_in_frame_num_value_allowed */
    bs_skip( &s, 1 );

    /* Read size */
    p_dec->fmt_out.video.i_width  = 16 * ( bs_read_ue( &s ) + 1 );
    p_dec->fmt_out.video.i_height = 16 * ( bs_read_ue( &s ) + 1 );

    /* b_frame_mbs_only */
    p_sys->b_frame_mbs_only = bs_read( &s, 1 );
941
    p_dec->fmt_out.video.i_height *=  ( 2 - p_sys->b_frame_mbs_only );
942 943
    if( p_sys->b_frame_mbs_only == 0 )
    {
944
        bs_skip( &s, 1 );
945 946 947
    }
    /* b_direct8x8_inference */
    bs_skip( &s, 1 );
948

949 950 951 952 953 954 955 956 957 958 959 960 961
    /* crop */
    i_tmp = bs_read( &s, 1 );
    if( i_tmp )
    {
        /* left */
        bs_read_ue( &s );
        /* right */
        bs_read_ue( &s );
        /* top */
        bs_read_ue( &s );
        /* bottom */
        bs_read_ue( &s );
    }
962

963 964 965 966
    /* vui */
    i_tmp = bs_read( &s, 1 );
    if( i_tmp )
    {
967
        /* read the aspect ratio part if any */
968 969 970
        i_tmp = bs_read( &s, 1 );
        if( i_tmp )
        {
971
            static const struct { int w, h; } sar[17] =
972
            {
973 974 975
                { 0,   0 }, { 1,   1 }, { 12, 11 }, { 10, 11 },
                { 16, 11 }, { 40, 33 }, { 24, 11 }, { 20, 11 },
                { 32, 11 }, { 80, 33 }, { 18, 11 }, { 15, 11 },
976 977
                { 64, 33 }, { 160,99 }, {  4,  3 }, {  3,  2 },
                {  2,  1 },
978 979 980 981
            };
            int i_sar = bs_read( &s, 8 );
            int w, h;

982
            if( i_sar < 17 )
983 984 985 986
            {
                w = sar[i_sar].w;
                h = sar[i_sar].h;
            }
987
            else if( i_sar == 255 )
988 989 990
            {
                w = bs_read( &s, 16 );
                h = bs_read( &s, 16 );
991
            }
992 993 994 995 996
            else
            {
                w = 0;
                h = 0;
            }
997

998 999 1000 1001 1002
            if( w != 0 && h != 0 )
            {
                p_dec->fmt_out.video.i_sar_num = w;
                p_dec->fmt_out.video.i_sar_den = h;
            }
1003
            else
1004 1005 1006 1007
            {
                p_dec->fmt_out.video.i_sar_num = 1;
                p_dec->fmt_out.video.i_sar_den = 1;
            }
1008
        }
1009 1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056 1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073

        /* overscan */
        i_tmp = bs_read( &s, 1 );
        if ( i_tmp )
            bs_read( &s, 1 );

        /* video signal type */
        i_tmp = bs_read( &s, 1 );
        if( i_tmp )
        {
            bs_read( &s, 4 );
            /* colour desc */
            bs_read( &s, 1 );
            if ( i_tmp )
                bs_read( &s, 24 );
        }

        /* chroma loc info */
        i_tmp = bs_read( &s, 1 );
        if( i_tmp )
        {
            bs_read_ue( &s );
            bs_read_ue( &s );
        }

        /* timing info */
        p_sys->b_timing_info_present_flag = bs_read( &s, 1 );
        if( p_sys->b_timing_info_present_flag )
        {
            p_sys->i_num_units_in_tick = bs_read( &s, 32 );
            p_sys->i_time_scale = bs_read( &s, 32 );
            p_sys->b_fixed_frame_rate = bs_read( &s, 1 );
        }

        /* Nal hrd & VC1 hrd parameters */
        p_sys->b_cpb_dpb_delays_present_flag = false;
        for ( int i=0; i<2; i++ )
        {
            i_tmp = bs_read( &s, 1 );
            if( i_tmp )
            {
                p_sys->b_cpb_dpb_delays_present_flag = true;
                uint32_t count = bs_read_ue( &s ) + 1;
                bs_read( &s, 4 );
                bs_read( &s, 4 );
                for( uint32_t i=0; i<count; i++ )
                {
                    bs_read_ue( &s );
                    bs_read_ue( &s );
                    bs_read( &s, 1 );
                }
                bs_read( &s, 5 );
                p_sys->i_cpb_removal_delay_length_minus1 = bs_read( &s, 5 );
                p_sys->i_dpb_output_delay_length_minus1 = bs_read( &s, 5 );
                bs_read( &s, 5 );
            }
        }

        if( p_sys->b_cpb_dpb_delays_present_flag )
            bs_read( &s, 1 );

        /* pic struct info */
        p_sys->b_pic_struct_present_flag = bs_read( &s, 1 );

        /* + unparsed remains */
1074
    }
1075

1076
    free( pb_dec );
1077

1078
    /* We have a new SPS */
1079 1080 1081 1082
    if( !p_sys->b_sps )
        msg_Dbg( p_dec, "found NAL_SPS (sps_id=%d)", i_sps_id );
    p_sys->b_sps = true;

1083 1084 1085
    if( p_sys->pp_sps[i_sps_id] )
        block_Release( p_sys->pp_sps[i_sps_id] );
    p_sys->pp_sps[i_sps_id] = p_frag;
1086
}
1087

1088 1089 1090 1091
static void PutPPS( decoder_t *p_dec, block_t *p_frag )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    bs_t s;
1092 1093
    int i_pps_id;
    int i_sps_id;
1094

1095
    bs_init( &s, &p_frag->p_buffer[5], p_frag->i_buffer - 5 );
1096 1097 1098 1099 1100 1101 1102 1103
    i_pps_id = bs_read_ue( &s ); // pps id
    i_sps_id = bs_read_ue( &s ); // sps id
    if( i_pps_id >= PPS_MAX || i_sps_id >= SPS_MAX )
    {
        msg_Warn( p_dec, "invalid PPS (pps_id=%d sps_id=%d)", i_pps_id, i_sps_id );
        block_Release( p_frag );
        return;
    }
1104 1105
    bs_skip( &s, 1 ); // entropy coding mode flag
    p_sys->i_pic_order_present_flag = bs_read( &s, 1 );
1106
    /* TODO */
1107

1108
    /* We have a new PPS */
1109
    if( !p_sys->b_pps )
1110
        msg_Dbg( p_dec, "found NAL_PPS (pps_id=%d sps_id=%d)", i_pps_id, i_sps_id );
1111
    p_sys->b_pps = true;
1112

1113 1114 1115
    if( p_sys->pp_pps[i_pps_id] )
        block_Release( p_sys->pp_pps[i_pps_id] );
    p_sys->pp_pps[i_pps_id] = p_frag;
1116 1117 1118 1119 1120 1121 1122 1123
}

static void ParseSlice( decoder_t *p_dec, bool *pb_new_picture, slice_t *p_slice,
                        int i_nal_ref_idc, int i_nal_type, const block_t *p_frag )
{
    decoder_sys_t *p_sys = p_dec->p_sys;
    uint8_t *pb_dec;
    int i_dec;
Rafaël Carré's avatar
Rafaël Carré committed
1124
    int i_slice_type;
1125 1126
    slice_t slice;
    bs_t s;
Laurent Aimar's avatar
Laurent Aimar committed
1127

1128
    /* do not convert the whole frame */
Laurent Aimar's avatar
Laurent Aimar committed
1129
    CreateDecodedNAL( &pb_dec, &i_dec, &p_frag->p_buffer[5],
1130 1131
                     __MIN( p_frag->i_buffer - 5, 60 ) );
    bs_init( &s, pb_dec, i_dec );
1132

1133
    /* first_mb_in_slice */
Rafaël Carré's avatar
Rafaël Carré committed
1134
    /* int i_first_mb = */ bs_read_ue( &s );
1135

1136 1137 1138 1139 1140 1141 1142 1143 1144 1145 1146 1147 1148 1149 1150 1151 1152 1153 1154 1155 1156
    /* slice_type */
    switch( (i_slice_type = bs_read_ue( &s )) )
    {
    case 0: case 5:
        slice.i_frame_type = BLOCK_FLAG_TYPE_P;
        break;
    case 1: case 6:
        slice.i_frame_type = BLOCK_FLAG_TYPE_B;
        break;
    case 2: case 7:
        slice.i_frame_type = BLOCK_FLAG_TYPE_I;
        break;
    case 3: case 8: /* SP */
        slice.i_frame_type = BLOCK_FLAG_TYPE_P;
        break;
    case 4: case 9:
        slice.i_frame_type = BLOCK_FLAG_TYPE_I;
        break;
    default:
        slice.i_frame_type = 0;
        break;
1157
    }
1158 1159 1160 1161 1162 1163 1164 1165 1166 1167 1168

    /* */
    slice.i_nal_type = i_nal_type;
    slice.i_nal_ref_idc = i_nal_ref_idc;

    slice.i_pic_parameter_set_id = bs_read_ue( &s );
    slice.i_frame_num = bs_read( &s, p_sys->i_log2_max_frame_num + 4 );

    slice.i_field_pic_flag = 0;
    slice.i_bottom_field_flag = -1;
    if( !p_sys->b_frame_mbs_only )
1169
    {
1170 1171 1172 1173
        /* field_pic_flag */
        slice.i_field_pic_flag = bs_read( &s, 1 );
        if( slice.i_field_pic_flag )
            slice.i_bottom_field_flag = bs_read( &s, 1 );
1174 1175
    }

1176 1177 1178
    slice.i_idr_pic_id = p_sys->slice.i_idr_pic_id;
    if( slice.i_nal_type == NAL_SLICE_IDR )
        slice.i_idr_pic_id = bs_read_ue( &s );
1179

1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190 1191 1192 1193 1194 1195 1196 1197 1198 1199 1200 1201 1202 1203 1204 1205 1206 1207 1208 1209 1210 1211 1212 1213 1214 1215 1216 1217 1218 1219 1220 1221 1222 1223 1224 1225
    slice.i_pic_order_cnt_lsb = -1;
    slice.i_delta_pic_order_cnt_bottom = -1;
    slice.i_delta_pic_order_cnt0 = 0;
    slice.i_delta_pic_order_cnt1 = 0;
    if( p_sys->i_pic_order_cnt_type == 0 )
    {
        slice.i_pic_order_cnt_lsb = bs_read( &s, p_sys->i_log2_max_pic_order_cnt_lsb + 4 );
        if( p_sys->i_pic_order_present_flag && !s