h264dec.c 35.4 KB
Newer Older
1
/*
2
 * H.26L/H.264/AVC/JVT/14496-10/... decoder
3 4
 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
 *
5 6 7
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
8 9
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

22
/**
23
 * @file
24
 * H.264 / AVC / MPEG-4 part10 codec.
25 26 27
 * @author Michael Niedermayer <michaelni@gmx.at>
 */

28 29
#define UNCHECKED_BITSTREAM_READER 1

30
#include "libavutil/avassert.h"
31
#include "libavutil/display.h"
32
#include "libavutil/imgutils.h"
33
#include "libavutil/opt.h"
34
#include "libavutil/stereo3d.h"
35
#include "libavutil/timer.h"
36
#include "internal.h"
37
#include "bytestream.h"
38 39
#include "cabac.h"
#include "cabac_functions.h"
40
#include "error_resilience.h"
41
#include "avcodec.h"
42
#include "h264.h"
43
#include "h264dec.h"
44
#include "h2645_parse.h"
45
#include "h264data.h"
46
#include "h264chroma.h"
47
#include "h264_mvpred.h"
48
#include "h264_ps.h"
49
#include "golomb.h"
50
#include "hwaccel.h"
51
#include "mathops.h"
52
#include "me_cmp.h"
53
#include "mpegutils.h"
54
#include "profiles.h"
55
#include "rectangle.h"
56
#include "thread.h"
57

58 59
const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };

60 61 62
int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx)
{
    H264Context *h = avctx->priv_data;
63
    return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0;
64 65
}

66 67 68 69
static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type,
                              int (*mv)[2][4][2],
                              int mb_x, int mb_y, int mb_intra, int mb_skipped)
{
70
    H264Context *h = opaque;
71
    H264SliceContext *sl = &h->slice_ctx[0];
72

73 74
    sl->mb_x = mb_x;
    sl->mb_y = mb_y;
75
    sl->mb_xy = mb_x + mb_y * h->mb_stride;
76
    memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
77
    av_assert1(ref >= 0);
78 79 80 81
    /* FIXME: It is possible albeit uncommon that slice references
     * differ between slices. We take the easy approach and ignore
     * it for now. If this turns out to have any relevance in
     * practice then correct remapping should be added. */
82
    if (ref >= sl->ref_count[0])
83
        ref = 0;
84
    if (!sl->ref_list[0][ref].data[0]) {
85
        av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n");
86 87
        ref = 0;
    }
88
    if ((sl->ref_list[0][ref].reference&3) != 3) {
89
        av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n");
90 91
        return;
    }
92
    fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
93
                   2, 2, 2, ref, 1);
94 95
    fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
    fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
96
                   pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
97
    sl->mb_mbaff =
98
    sl->mb_field_decoding_flag = 0;
99
    ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
100 101
}

102
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
103
                             int y, int height)
104
{
105
    AVCodecContext *avctx = h->avctx;
106
    const AVFrame   *src  = h->cur_pic.f;
107 108
    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
    int vshift = desc->log2_chroma_h;
109 110 111
    const int field_pic = h->picture_structure != PICT_FRAME;
    if (field_pic) {
        height <<= 1;
112
        y      <<= 1;
113 114
    }

115
    height = FFMIN(height, avctx->height - y);
116

117 118
    if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
        return;
119 120 121 122 123

    if (avctx->draw_horiz_band) {
        int offset[AV_NUM_DATA_POINTERS];
        int i;

124 125 126
        offset[0] = y * src->linesize[0];
        offset[1] =
        offset[2] = (y >> vshift) * src->linesize[1];
127 128 129 130 131 132
        for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
            offset[i] = 0;

        emms_c();

        avctx->draw_horiz_band(avctx, src, offset,
133
                               y, h->picture_structure, height);
134 135 136
    }
}

137
void ff_h264_free_tables(H264Context *h)
138
{
139
    int i;
140

141
    av_freep(&h->intra4x4_pred_mode);
142 143
    av_freep(&h->chroma_pred_mode_table);
    av_freep(&h->cbp_table);
144 145
    av_freep(&h->mvd_table[0]);
    av_freep(&h->mvd_table[1]);
146
    av_freep(&h->direct_table);
147 148
    av_freep(&h->non_zero_count);
    av_freep(&h->slice_table_base);
149
    h->slice_table = NULL;
150
    av_freep(&h->list_counts);
151

152
    av_freep(&h->mb2b_xy);
153
    av_freep(&h->mb2br_xy);
154

155 156 157 158 159
    av_buffer_pool_uninit(&h->qscale_table_pool);
    av_buffer_pool_uninit(&h->mb_type_pool);
    av_buffer_pool_uninit(&h->motion_val_pool);
    av_buffer_pool_uninit(&h->ref_index_pool);

160 161 162
    for (i = 0; i < h->nb_slice_ctx; i++) {
        H264SliceContext *sl = &h->slice_ctx[i];

163 164 165 166 167
        av_freep(&sl->dc_val_base);
        av_freep(&sl->er.mb_index2xy);
        av_freep(&sl->er.error_status_table);
        av_freep(&sl->er.er_temp_buffer);

168 169
        av_freep(&sl->bipred_scratchpad);
        av_freep(&sl->edge_emu_buffer);
170 171
        av_freep(&sl->top_borders[0]);
        av_freep(&sl->top_borders[1]);
172 173 174

        sl->bipred_scratchpad_allocated = 0;
        sl->edge_emu_buffer_allocated   = 0;
175 176
        sl->top_borders_allocated[0]    = 0;
        sl->top_borders_allocated[1]    = 0;
177
    }
178 179
}

180 181
int ff_h264_alloc_tables(H264Context *h)
{
182
    const int big_mb_num = h->mb_stride * (h->mb_height + 1);
183
    const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1);
184
    int x, y;
185

186 187
    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
                      row_mb_num, 8 * sizeof(uint8_t), fail)
188 189
    h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;

190
    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
191
                      big_mb_num * 48 * sizeof(uint8_t), fail)
192 193 194
    FF_ALLOCZ_OR_GOTO(h->avctx, h->slice_table_base,
                      (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base), fail)
    FF_ALLOCZ_OR_GOTO(h->avctx, h->cbp_table,
195
                      big_mb_num * sizeof(uint16_t), fail)
196
    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
197
                      big_mb_num * sizeof(uint8_t), fail)
198 199 200 201
    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[0],
                      row_mb_num, 16 * sizeof(uint8_t), fail);
    FF_ALLOCZ_ARRAY_OR_GOTO(h->avctx, h->mvd_table[1],
                      row_mb_num, 16 * sizeof(uint8_t), fail);
202 203 204
    h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
    h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];

205
    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
206
                      4 * big_mb_num * sizeof(uint8_t), fail);
207
    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
208 209 210
                      big_mb_num * sizeof(uint8_t), fail)

    memset(h->slice_table_base, -1,
211 212
           (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
    h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
213

214
    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
215
                      big_mb_num * sizeof(uint32_t), fail);
216
    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
217
                      big_mb_num * sizeof(uint32_t), fail);
218 219 220
    for (y = 0; y < h->mb_height; y++)
        for (x = 0; x < h->mb_width; x++) {
            const int mb_xy = x + y * h->mb_stride;
221 222 223
            const int b_xy  = 4 * x + 4 * y * h->b_stride;

            h->mb2b_xy[mb_xy]  = b_xy;
224
            h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
225
        }
226

227
    return 0;
228

229
fail:
230
    ff_h264_free_tables(h);
231
    return AVERROR(ENOMEM);
232 233
}

234 235 236 237
/**
 * Init context
 * Allocate buffers which are not shared amongst multiple threads.
 */
238
int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
239
{
240
    ERContext *er = &sl->er;
241 242 243 244 245 246
    int mb_array_size = h->mb_height * h->mb_stride;
    int y_size  = (2 * h->mb_width + 1) * (2 * h->mb_height + 1);
    int c_size  = h->mb_stride * (h->mb_height + 1);
    int yc_size = y_size + 2   * c_size;
    int x, y, i;

247 248 249 250 251 252
    sl->ref_cache[0][scan8[5]  + 1] =
    sl->ref_cache[0][scan8[7]  + 1] =
    sl->ref_cache[0][scan8[13] + 1] =
    sl->ref_cache[1][scan8[5]  + 1] =
    sl->ref_cache[1][scan8[7]  + 1] =
    sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE;
253

254 255 256
    if (sl != h->slice_ctx) {
        memset(er, 0, sizeof(*er));
    } else
257
    if (CONFIG_ERROR_RESILIENCE) {
258

259 260 261 262 263 264 265 266 267 268 269
        /* init ER */
        er->avctx          = h->avctx;
        er->decode_mb      = h264_er_decode_mb;
        er->opaque         = h;
        er->quarter_sample = 1;

        er->mb_num      = h->mb_num;
        er->mb_width    = h->mb_width;
        er->mb_height   = h->mb_height;
        er->mb_stride   = h->mb_stride;
        er->b8_stride   = h->mb_width * 2 + 1;
270

271 272 273 274
        // error resilience code looks cleaner with this
        FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
                          (h->mb_num + 1) * sizeof(int), fail);

275 276 277
        for (y = 0; y < h->mb_height; y++)
            for (x = 0; x < h->mb_width; x++)
                er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride;
278

279
        er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
280
                                                      h->mb_stride + h->mb_width;
281

282 283
        FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
                          mb_array_size * sizeof(uint8_t), fail);
284

285
        FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
286
                         h->mb_height * h->mb_stride * (4*sizeof(int) + 1), fail);
287

288
        FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
289
                          yc_size * sizeof(int16_t), fail);
290 291
        er->dc_val[0] = sl->dc_val_base + h->mb_width * 2 + 2;
        er->dc_val[1] = sl->dc_val_base + y_size + h->mb_stride + 1;
292 293
        er->dc_val[2] = er->dc_val[1] + c_size;
        for (i = 0; i < yc_size; i++)
294
            sl->dc_val_base[i] = 1024;
295
    }
296

297
    return 0;
298

299
fail:
300
    return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
301 302
}

303
static int h264_init_context(AVCodecContext *avctx, H264Context *h)
304
{
305
    int i;
306

307
    h->avctx                 = avctx;
308
    h->cur_chroma_format_idc = -1;
309

310 311 312
    h->width_from_caller     = avctx->width;
    h->height_from_caller    = avctx->height;

313 314 315
    h->picture_structure     = PICT_FRAME;
    h->workaround_bugs       = avctx->workaround_bugs;
    h->flags                 = avctx->flags;
316
    h->poc.prev_poc_msb      = 1 << 16;
317 318
    h->recovery_frame        = -1;
    h->frame_recovered       = 0;
319
    h->poc.prev_frame_num    = -1;
320
    h->sei.frame_packing.arrangement_cancel_flag = -1;
321
    h->sei.unregistered.x264_build = -1;
322

323
    h->next_outputed_poc = INT_MIN;
324 325
    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
        h->last_pocs[i] = INT_MIN;
326

327
    ff_h264_sei_uninit(&h->sei);
328 329 330

    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;

331
    h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
332 333 334 335 336 337
    h->slice_ctx = av_mallocz_array(h->nb_slice_ctx, sizeof(*h->slice_ctx));
    if (!h->slice_ctx) {
        h->nb_slice_ctx = 0;
        return AVERROR(ENOMEM);
    }

338 339 340 341 342 343 344 345 346
    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
        h->DPB[i].f = av_frame_alloc();
        if (!h->DPB[i].f)
            return AVERROR(ENOMEM);
    }

    h->cur_pic.f = av_frame_alloc();
    if (!h->cur_pic.f)
        return AVERROR(ENOMEM);
347

348 349 350
    h->last_pic_for_ec.f = av_frame_alloc();
    if (!h->last_pic_for_ec.f)
        return AVERROR(ENOMEM);
351

352
    for (i = 0; i < h->nb_slice_ctx; i++)
353
        h->slice_ctx[i].h264 = h;
354

355 356 357
    return 0;
}

358 359 360 361 362
static av_cold int h264_decode_end(AVCodecContext *avctx)
{
    H264Context *h = avctx->priv_data;
    int i;

363
    ff_h264_remove_all_refs(h);
364 365 366 367 368 369
    ff_h264_free_tables(h);

    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
        ff_h264_unref_picture(h, &h->DPB[i]);
        av_frame_free(&h->DPB[i].f);
    }
370
    memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
371 372 373 374 375 376

    h->cur_pic_ptr = NULL;

    av_freep(&h->slice_ctx);
    h->nb_slice_ctx = 0;

377
    ff_h264_sei_uninit(&h->sei);
378
    ff_h264_ps_uninit(&h->ps);
379

380 381 382 383
    ff_h2645_packet_uninit(&h->pkt);

    ff_h264_unref_picture(h, &h->cur_pic);
    av_frame_free(&h->cur_pic.f);
384 385
    ff_h264_unref_picture(h, &h->last_pic_for_ec);
    av_frame_free(&h->last_pic_for_ec.f);
386 387 388 389

    return 0;
}

390 391
static AVOnce h264_vlc_init = AV_ONCE_INIT;

392
static av_cold int h264_decode_init(AVCodecContext *avctx)
393 394 395 396 397 398 399 400
{
    H264Context *h = avctx->priv_data;
    int ret;

    ret = h264_init_context(avctx, h);
    if (ret < 0)
        return ret;

401 402 403 404 405
    ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc);
    if (ret != 0) {
        av_log(avctx, AV_LOG_ERROR, "pthread_once has failed.");
        return AVERROR_UNKNOWN;
    }
406

James Almer's avatar
James Almer committed
407 408 409 410 411
    if (avctx->ticks_per_frame == 1) {
        if(h->avctx->time_base.den < INT_MAX/2) {
            h->avctx->time_base.den *= 2;
        } else
            h->avctx->time_base.num /= 2;
412
    }
413
    avctx->ticks_per_frame = 2;
414

415
    if (avctx->extradata_size > 0 && avctx->extradata) {
416 417 418
        ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
                                       &h->ps, &h->is_avc, &h->nal_length_size,
                                       avctx->err_recognition, avctx);
419
        if (ret < 0) {
420
            h264_decode_end(avctx);
421 422
            return ret;
        }
423
    }
424

425 426 427
    if (h->ps.sps && h->ps.sps->bitstream_restriction_flag &&
        h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) {
        h->avctx->has_b_frames = h->ps.sps->num_reorder_frames;
428
    }
429

430
    avctx->internal->allocate_progress = 1;
431

432
    ff_h264_flush_change(h);
433

434 435 436
    if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE))
        h->enable_er = 0;

437
    if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) {
438
        av_log(avctx, AV_LOG_WARNING,
439
               "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. "
440 441 442
               "Use it at your own risk\n");
    }

443
    return 0;
444 445
}

446
#if HAVE_THREADS
447 448 449
static int decode_init_thread_copy(AVCodecContext *avctx)
{
    H264Context *h = avctx->priv_data;
450
    int ret;
451

452 453
    if (!avctx->internal->is_copy)
        return 0;
454 455

    memset(h, 0, sizeof(*h));
456

457 458 459
    ret = h264_init_context(avctx, h);
    if (ret < 0)
        return ret;
460

461
    h->context_initialized = 0;
462

463 464
    return 0;
}
465
#endif
466

467
/**
Loic Le Loarer's avatar
Loic Le Loarer committed
468
 * instantaneous decoder refresh.
469
 */
470 471
static void idr(H264Context *h)
{
472
    int i;
473
    ff_h264_remove_all_refs(h);
474
    h->poc.prev_frame_num        =
475 476
    h->poc.prev_frame_num_offset = 0;
    h->poc.prev_poc_msb          = 1<<16;
477
    h->poc.prev_poc_lsb          = 0;
478 479
    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
        h->last_pocs[i] = INT_MIN;
480 481
}

482
/* forget old pics after a seek */
483
void ff_h264_flush_change(H264Context *h)
484
{
485 486
    int i, j;

487
    h->next_outputed_poc = INT_MIN;
488
    h->prev_interlaced_frame = 1;
489
    idr(h);
490

491
    h->poc.prev_frame_num = -1;
492
    if (h->cur_pic_ptr) {
493
        h->cur_pic_ptr->reference = 0;
494
        for (j=i=0; h->delayed_pic[i]; i++)
495
            if (h->delayed_pic[i] != h->cur_pic_ptr)
496 497 498
                h->delayed_pic[j++] = h->delayed_pic[i];
        h->delayed_pic[j] = NULL;
    }
499 500
    ff_h264_unref_picture(h, &h->last_pic_for_ec);

501
    h->first_field = 0;
502 503
    h->recovery_frame = -1;
    h->frame_recovered = 0;
504
    h->current_slice = 0;
505
    h->mmco_reset = 1;
506 507 508 509 510 511 512 513
}

/* forget old pics after a seek */
static void flush_dpb(AVCodecContext *avctx)
{
    H264Context *h = avctx->priv_data;
    int i;

514
    memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
515

516
    ff_h264_flush_change(h);
517
    ff_h264_sei_uninit(&h->sei);
518

519 520
    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
        ff_h264_unref_picture(h, &h->DPB[i]);
521
    h->cur_pic_ptr = NULL;
522
    ff_h264_unref_picture(h, &h->cur_pic);
523

524
    h->mb_y = 0;
525

526
    ff_h264_free_tables(h);
527
    h->context_initialized = 0;
528 529
}

530
static int get_last_needed_nal(H264Context *h)
531 532
{
    int nals_needed = 0;
533
    int first_slice = 0;
534
    int i, ret;
535

536 537
    for (i = 0; i < h->pkt.nb_nals; i++) {
        H2645NAL *nal = &h->pkt.nals[i];
538
        GetBitContext gb;
539 540 541 542 543

        /* packets can sometimes contain multiple PPS/SPS,
         * e.g. two PAFF field pictures in one packet, or a demuxer
         * which splits NALs strangely if so, when frame threading we
         * can't start the next thread until we've read all of them */
544
        switch (nal->type) {
545 546
        case H264_NAL_SPS:
        case H264_NAL_PPS:
547
            nals_needed = i;
548
            break;
549 550 551
        case H264_NAL_DPA:
        case H264_NAL_IDR_SLICE:
        case H264_NAL_SLICE:
552 553 554 555 556 557 558 559
            ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1);
            if (ret < 0) {
                av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n");
                if (h->avctx->err_recognition & AV_EF_EXPLODE)
                    return ret;

                break;
            }
560
            if (!get_ue_golomb_long(&gb) ||  // first_mb_in_slice
561
                !first_slice ||
562
                first_slice != nal->type)
563
                nals_needed = i;
564
            if (!first_slice)
565
                first_slice = nal->type;
566 567 568 569 570 571
        }
    }

    return nals_needed;
}

572
static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx)
573 574 575 576 577 578 579 580 581 582 583 584 585 586 587 588 589 590 591 592 593 594 595 596 597 598 599
{
    av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n");
    av_log(logctx, AV_LOG_DEBUG, "  green_metadata_type: %d\n", gm->green_metadata_type);

    if (gm->green_metadata_type == 0) {
        av_log(logctx, AV_LOG_DEBUG, "  green_metadata_period_type: %d\n", gm->period_type);

        if (gm->period_type == 2)
            av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_seconds: %d\n", gm->num_seconds);
        else if (gm->period_type == 3)
            av_log(logctx, AV_LOG_DEBUG, "  green_metadata_num_pictures: %d\n", gm->num_pictures);

        av_log(logctx, AV_LOG_DEBUG, "  SEI GREEN Complexity Metrics: %f %f %f %f\n",
               (float)gm->percent_non_zero_macroblocks/255,
               (float)gm->percent_intra_coded_macroblocks/255,
               (float)gm->percent_six_tap_filtering/255,
               (float)gm->percent_alpha_point_deblocking_instance/255);

    } else if (gm->green_metadata_type == 1) {
        av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_type: %d\n", gm->xsd_metric_type);

        if (gm->xsd_metric_type == 0)
            av_log(logctx, AV_LOG_DEBUG, "  xsd_metric_value: %f\n",
                   (float)gm->xsd_metric_value/100);
    }
}

600
static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
601
{
602
    AVCodecContext *const avctx = h->avctx;
603
    int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
604
    int idr_cleared=0;
605
    int i, ret = 0;
606

607
    h->has_slice = 0;
608 609
    h->nal_unit_type= 0;

610
    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
611
        h->current_slice = 0;
612
        if (!h->first_field) {
613
            h->cur_pic_ptr = NULL;
614 615
            ff_h264_sei_uninit(&h->sei);
        }
616 617
    }

618 619 620 621 622 623 624
    if (h->nal_length_size == 4) {
        if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) {
            h->is_avc = 0;
        }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size)
            h->is_avc = 1;
    }

625
    ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
626
                                h->nal_length_size, avctx->codec_id, avctx->flags2 & AV_CODEC_FLAG2_FAST);
627 628 629 630 631
    if (ret < 0) {
        av_log(avctx, AV_LOG_ERROR,
               "Error splitting the input into NAL units.\n");
        return ret;
    }
632

633
    if (avctx->active_thread_type & FF_THREAD_FRAME)
634
        nals_needed = get_last_needed_nal(h);
635 636
    if (nals_needed < 0)
        return nals_needed;
637

638 639
    for (i = 0; i < h->pkt.nb_nals; i++) {
        H2645NAL *nal = &h->pkt.nals[i];
640
        int max_slice_ctx, err;
641

642
        if (avctx->skip_frame >= AVDISCARD_NONREF &&
643
            nal->ref_idc == 0 && nal->type != H264_NAL_SEI)
644
            continue;
645

646 647 648
        // FIXME these should stop being context-global variables
        h->nal_ref_idc   = nal->ref_idc;
        h->nal_unit_type = nal->type;
649

650 651
        err = 0;
        switch (nal->type) {
652
        case H264_NAL_IDR_SLICE:
653 654 655 656 657 658 659 660 661 662 663
            if ((nal->data[1] & 0xFC) == 0x98) {
                av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n");
                h->next_outputed_poc = INT_MIN;
                ret = -1;
                goto end;
            }
            if(!idr_cleared) {
                idr(h); // FIXME ensure we don't lose some frames if there is reordering
            }
            idr_cleared = 1;
            h->has_recovery_point = 1;
664
        case H264_NAL_SLICE:
665
            h->has_slice = 1;
666

667 668 669
            if ((err = ff_h264_queue_decode_slice(h, nal))) {
                H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
                sl->ref_count[0] = sl->ref_count[1] = 0;
670
                break;
671
            }
672

673
            if (h->current_slice == 1) {
674
                if (avctx->active_thread_type & FF_THREAD_FRAME &&
675 676 677 678
                    i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) {
                    ff_thread_finish_setup(avctx);
                    h->setup_finished = 1;
                }
679

680
                if (h->avctx->hwaccel &&
681 682
                    (ret = h->avctx->hwaccel->start_frame(h->avctx, buf, buf_size)) < 0)
                    goto end;
683
            }
684

685 686
            max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx;
            if (h->nb_slice_ctx_queued == max_slice_ctx) {
687
                if (h->avctx->hwaccel) {
688
                    ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
689 690
                    h->nb_slice_ctx_queued = 0;
                } else
691 692 693
                    ret = ff_h264_execute_decode_slices(h);
                if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                    goto end;
694
            }
695
            break;
696 697 698
        case H264_NAL_DPA:
        case H264_NAL_DPB:
        case H264_NAL_DPC:
699 700
            avpriv_request_sample(avctx, "data partitioning");
            break;
701
        case H264_NAL_SEI:
702
            ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
703
            h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1;
704
            if (avctx->debug & FF_DEBUG_GREEN_MD)
705
                debug_green_metadata(&h->sei.green_metadata, h->avctx);
706 707 708
            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                goto end;
            break;
James Almer's avatar
James Almer committed
709
        case H264_NAL_SPS: {
710
            GetBitContext tmp_gb = nal->gb;
711 712 713 714 715 716 717 718
            if (avctx->hwaccel && avctx->hwaccel->decode_params) {
                ret = avctx->hwaccel->decode_params(avctx,
                                                    nal->type,
                                                    nal->raw_data,
                                                    nal->raw_size);
                if (ret < 0)
                    goto end;
            }
719
            if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
720
                break;
721 722
            av_log(h->avctx, AV_LOG_DEBUG,
                   "SPS decoding failure, trying again with the complete NAL\n");
723 724
            init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1);
            if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0)
725
                break;
726
            ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1);
727
            break;
728
        }
729
        case H264_NAL_PPS:
730 731 732 733 734 735 736 737
            if (avctx->hwaccel && avctx->hwaccel->decode_params) {
                ret = avctx->hwaccel->decode_params(avctx,
                                                    nal->type,
                                                    nal->raw_data,
                                                    nal->raw_size);
                if (ret < 0)
                    goto end;
            }
738 739
            ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
                                                       nal->size_bits);
740 741 742
            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
                goto end;
            break;
743 744 745 746 747 748
        case H264_NAL_AUD:
        case H264_NAL_END_SEQUENCE:
        case H264_NAL_END_STREAM:
        case H264_NAL_FILLER_DATA:
        case H264_NAL_SPS_EXT:
        case H264_NAL_AUXILIARY_SLICE:
749 750 751 752 753
            break;
        default:
            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
                   nal->type, nal->size_bits);
        }
754

755 756
        if (err < 0) {
            av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
757 758
        }
    }
759 760 761 762

    ret = ff_h264_execute_decode_slices(h);
    if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
        goto end;
763

764
    ret = 0;
765
end:
766 767 768 769 770 771 772 773 774 775 776 777 778 779

#if CONFIG_ERROR_RESILIENCE
    /*
     * FIXME: Error handling code does not seem to support interlaced
     * when slices span multiple rows
     * The ff_er_add_slice calls don't work right for bottom
     * fields; they cause massive erroneous error concealing
     * Error marking covers both fields (top and bottom).
     * This causes a mismatched s->error_count
     * and a bad error table. Further, the error count goes to
     * INT_MAX when called for bottom field, because mb_y is
     * past end by one (callers fault) and resync_mb_y != 0
     * causes problems for the first MB line, too.
     */
780 781 782 783
    if (!FIELD_PICTURE(h) && h->current_slice &&
        h->ps.sps == (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data &&
        h->enable_er) {

784
        H264SliceContext *sl = h->slice_ctx;
785 786 787 788 789 790 791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809
        int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0];

        ff_h264_set_erpic(&sl->er.cur_pic, h->cur_pic_ptr);

        if (use_last_pic) {
            ff_h264_set_erpic(&sl->er.last_pic, &h->last_pic_for_ec);
            sl->ref_list[0][0].parent = &h->last_pic_for_ec;
            memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data));
            memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize));
            sl->ref_list[0][0].reference = h->last_pic_for_ec.reference;
        } else if (sl->ref_count[0]) {
            ff_h264_set_erpic(&sl->er.last_pic, sl->ref_list[0][0].parent);
        } else
            ff_h264_set_erpic(&sl->er.last_pic, NULL);

        if (sl->ref_count[1])
            ff_h264_set_erpic(&sl->er.next_pic, sl->ref_list[1][0].parent);

        sl->er.ref_count = sl->ref_count[0];

        ff_er_frame_end(&sl->er);
        if (use_last_pic)
            memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0]));
    }
#endif /* CONFIG_ERROR_RESILIENCE */
810
    /* clean up */
811
    if (h->cur_pic_ptr && !h->droppable && h->has_slice) {
812
        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
813
                                  h->picture_structure == PICT_BOTTOM_FIELD);
814 815
    }

816
    return (ret < 0) ? ret : buf_size;
817 818 819
}

/**
820
 * Return the number of bytes consumed for building the current frame.
821
 */
822
static int get_consumed_bytes(int pos, int buf_size)
823 824
{
    if (pos == 0)
825
        pos = 1;        // avoid infinite loops (I doubt that is needed but...)
826
    if (pos + 10 > buf_size)
827
        pos = buf_size; // oops ;)
828

829
    return pos;
830 831
}

832
static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp)
833
{
834
    AVFrame *src = srcp->f;
835 836 837
    int ret;

    ret = av_frame_ref(dst, src);
838 839 840
    if (ret < 0)
        return ret;

841
    av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.frame_packing), 0);
842

843 844
    if (srcp->sei_recovery_frame_cnt == 0)
        dst->key_frame = 1;
845 846 847 848

    return 0;
}

849 850 851 852
static int is_extra(const uint8_t *buf, int buf_size)
{
    int cnt= buf[5]&0x1f;
    const uint8_t *p= buf+6;
853 854
    if (!cnt)
        return 0;
855 856
    while(cnt--){
        int nalsize= AV_RB16(p) + 2;
857
        if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7)
858 859 860 861 862 863 864 865
            return 0;
        p += nalsize;
    }
    cnt = *(p++);
    if(!cnt)
        return 0;
    while(cnt--){
        int nalsize= AV_RB16(p) + 2;
866
        if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8)
867 868 869 870 871 872
            return 0;
        p += nalsize;
    }
    return 1;
}

873 874 875 876 877 878 879 880 881 882 883 884 885 886 887 888 889 890 891 892 893 894 895 896 897 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
static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame)
{
    int ret;

    if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
         (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) ||
         out->recovered)) {

        if (!h->avctx->hwaccel &&
            (out->field_poc[0] == INT_MAX ||
             out->field_poc[1] == INT_MAX)
           ) {
            int p;
            AVFrame *f = out->f;
            int field = out->field_poc[0] == INT_MAX;
            uint8_t *dst_data[4];
            int linesizes[4];
            const uint8_t *src_data[4];

            av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field);

            for (p = 0; p<4; p++) {
                dst_data[p] = f->data[p] + (field^1)*f->linesize[p];
                src_data[p] = f->data[p] +  field   *f->linesize[p];
                linesizes[p] = 2*f->linesize[p];
            }

            av_image_copy(dst_data, linesizes, src_data, linesizes,
                          f->format, f->width, f->height>>1);
        }

        ret = output_frame(h, dst, out);
        if (ret < 0)
            return ret;

        *got_frame = 1;

        if (CONFIG_MPEGVIDEO) {
            ff_print_debug_info2(h->avctx, dst, NULL,
                                 out->mb_type,
                                 out->qscale_table,
                                 out->motion_val,
                                 NULL,
                                 h->mb_width, h->mb_height, h->mb_stride, 1);
        }
    }

    return 0;
}

923 924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939 940 941 942 943 944 945 946 947 948 949 950 951 952 953 954 955
static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame,
                                   int *got_frame, int buf_index)
{
    int ret, i, out_idx;
    H264Picture *out = h->delayed_pic[0];

    h->cur_pic_ptr = NULL;
    h->first_field = 0;

    out_idx = 0;
    for (i = 1;
         h->delayed_pic[i] &&
         !h->delayed_pic[i]->f->key_frame &&
         !h->delayed_pic[i]->mmco_reset;
         i++)
        if (h->delayed_pic[i]->poc < out->poc) {
            out     = h->delayed_pic[i];
            out_idx = i;
        }

    for (i = out_idx; h->delayed_pic[i]; i++)
        h->delayed_pic[i] = h->delayed_pic[i + 1];

    if (out) {
        out->reference &= ~DELAYED_PIC_REF;
        ret = finalize_frame(h, dst_frame, out, got_frame);
        if (ret < 0)
            return ret;
    }

    return buf_index;
}

956 957
static int h264_decode_frame(AVCodecContext *avctx, void *data,
                             int *got_frame, AVPacket *avpkt)
958
{
959
    const uint8_t *buf = avpkt->data;
960 961 962
    int buf_size       = avpkt->size;
    H264Context *h     = avctx->priv_data;
    AVFrame *pict      = data;
963
    int buf_index;
964
    int ret;
965

966
    h->flags = avctx->flags;
967
    h->setup_finished = 0;
968
    h->nb_slice_ctx_queued = 0;
969

970 971
    ff_h264_unref_picture(h, &h->last_pic_for_ec);

972
    /* end of stream, output what is still in the buffers */
973 974
    if (buf_size == 0)
        return send_next_delayed_frame(h, pict, got_frame, 0);
975

976 977 978 979
    if (h->is_avc && av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) {
        int side_size;
        uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size);
        if (is_extra(side, side_size))
980 981 982
            ff_h264_decode_extradata(side, side_size,
                                     &h->ps, &h->is_avc, &h->nal_length_size,
                                     avctx->err_recognition, avctx);
983
    }
984
    if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) {
985
        if (is_extra(buf, buf_size))
986 987 988
            return ff_h264_decode_extradata(buf, buf_size,
                                            &h->ps, &h->is_avc, &h->nal_length_size,
                                            avctx->err_recognition, avctx);
989
    }
990

991
    buf_index = decode_nal_units(h, buf, buf_size);
992
    if (buf_index < 0)
993
        return AVERROR_INVALIDDATA;
994

995
    if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) {
996
        av_assert0(buf_index <= buf_size);
997
        return send_next_delayed_frame(h, pict, got_frame, buf_index);
998 999
    }

1000
    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) {
1001 1002
        if (avctx->skip_frame >= AVDISCARD_NONREF ||
            buf_size >= 4 && !memcmp("Q264", buf, 4))
1003
            return buf_size;
1004
        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
1005
        return AVERROR_INVALIDDATA;
1006 1007
    }

1008
    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
1009
        (h->mb_y >= h->mb_height && h->mb_height)) {
wm4's avatar
wm4 committed
1010 1011
        if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0)
            return ret;
1012

1013
        /* Wait for second field. */
1014 1015
        if (h->next_output_pic) {
            ret = finalize_frame(h, pict, h->next_output_pic, got_frame);
1016
            if (ret < 0)
1017
                return ret;
1018
        }
1019 1020
    }

1021
    av_assert0(pict->buf[0] || !*got_frame);
1022

1023 1024
    ff_h264_unref_picture(h, &h->last_pic_for_ec);

1025
    return get_consumed_bytes(buf_index, buf_size);
1026 1027
}

1028 1029 1030
#define OFFSET(x) offsetof(H264Context, x)
#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
static const AVOption h264_options[] = {
1031 1032
    { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, 0 },
    { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, 0 },
1033
    { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD },
1034
    { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD },
1035 1036 1037 1038
    { NULL },
};

static const AVClass h264_class = {
1039
    .class_name = "H264 Decoder",
1040 1041 1042 1043 1044
    .item_name  = av_default_item_name,
    .option     = h264_options,
    .version    = LIBAVUTIL_VERSION_INT,
};

1045
AVCodec ff_h264_decoder = {
1046
    .name                  = "h264",
1047
    .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
1048
    .type                  = AVMEDIA_TYPE_VIDEO,
1049
    .id                    = AV_CODEC_ID_H264,
1050
    .priv_data_size        = sizeof(H264Context),
1051
    .init                  = h264_decode_init,
1052
    .close                 = h264_decode_end,
1053
    .decode                = h264_decode_frame,
1054 1055 1056
    .capabilities          = /*AV_CODEC_CAP_DRAW_HORIZ_BAND |*/ AV_CODEC_CAP_DR1 |
                             AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS |
                             AV_CODEC_CAP_FRAME_THREADS,
1057 1058 1059 1060 1061 1062 1063 1064 1065 1066 1067 1068 1069 1070 1071 1072 1073 1074 1075 1076 1077 1078 1079 1080
    .hw_configs            = (const AVCodecHWConfigInternal*[]) {
#if CONFIG_H264_DXVA2_HWACCEL
                               HWACCEL_DXVA2(h264),
#endif
#if CONFIG_H264_D3D11VA_HWACCEL
                               HWACCEL_D3D11VA(h264),
#endif
#if CONFIG_H264_D3D11VA2_HWACCEL
                               HWACCEL_D3D11VA2(h264),
#endif
#if CONFIG_H264_NVDEC_HWACCEL
                               HWACCEL_NVDEC(h264),
#endif
#if CONFIG_H264_VAAPI_HWACCEL
                               HWACCEL_VAAPI(h264),
#endif
#if CONFIG_H264_VDPAU_HWACCEL
                               HWACCEL_VDPAU(h264),
#endif
#if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
                               HWACCEL_VIDEOTOOLBOX(h264),
#endif
                               NULL
                           },
1081
    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE | FF_CODEC_CAP_EXPORTS_CROPPING,
1082
    .flush                 = flush_dpb,
1083
    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
1084
    .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
1085
    .profiles              = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
1086
    .priv_class            = &h264_class,
1087
};