h264: rename h264.[ch] to h264dec.[ch]
authorAnton Khirnov <anton@khirnov.net>
Wed, 18 May 2016 07:02:39 +0000 (09:02 +0200)
committerAnton Khirnov <anton@khirnov.net>
Tue, 21 Jun 2016 09:11:26 +0000 (11:11 +0200)
This is more consistent with the naming of other decoders.

34 files changed:
libavcodec/Makefile
libavcodec/dxva2_h264.c
libavcodec/h264.c [deleted file]
libavcodec/h264.h [deleted file]
libavcodec/h264_cabac.c
libavcodec/h264_cavlc.c
libavcodec/h264_direct.c
libavcodec/h264_loopfilter.c
libavcodec/h264_mb.c
libavcodec/h264_mc_template.c
libavcodec/h264_mvpred.h
libavcodec/h264_parse.c
libavcodec/h264_parser.c
libavcodec/h264_picture.c
libavcodec/h264_ps.c
libavcodec/h264_refs.c
libavcodec/h264_sei.c
libavcodec/h264_slice.c
libavcodec/h264data.c
libavcodec/h264data.h
libavcodec/h264dec.c [new file with mode: 0644]
libavcodec/h264dec.h [new file with mode: 0644]
libavcodec/h264idct_template.c
libavcodec/omx.c
libavcodec/ppc/h264dsp.c
libavcodec/qsvenc_h264.c
libavcodec/svq3.c
libavcodec/vaapi.c
libavcodec/vaapi_encode_h264.c
libavcodec/vaapi_h264.c
libavcodec/vda_h264.c
libavcodec/vdpau.c
libavcodec/vdpau_h264.c
libavcodec/x86/h264_qpel.c

index 1f2096c..622e100 100644 (file)
@@ -249,7 +249,7 @@ OBJS-$(CONFIG_H263_DECODER)            += h263dec.o h263.o ituh263dec.o        \
                                           intelh263dec.o h263data.o
 OBJS-$(CONFIG_H263_ENCODER)            += mpeg4videoenc.o mpeg4video.o  \
                                           h263.o ituh263enc.o flvenc.o h263data.o
-OBJS-$(CONFIG_H264_DECODER)            += h264.o h264_cabac.o h264_cavlc.o \
+OBJS-$(CONFIG_H264_DECODER)            += h264dec.o h264_cabac.o h264_cavlc.o \
                                           h264_direct.o h264_loopfilter.o  \
                                           h264_mb.o h264_picture.o h264_ps.o \
                                           h264_refs.o h264_sei.o \
index e2e987d..c2ff15b 100644 (file)
@@ -20,7 +20,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "mpegutils.h"
 
diff --git a/libavcodec/h264.c b/libavcodec/h264.c
deleted file mode 100644 (file)
index 7949ee6..0000000
+++ /dev/null
@@ -1,982 +0,0 @@
-/*
- * H.26L/H.264/AVC/JVT/14496-10/... decoder
- * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of Libav.
- *
- * Libav 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 (at your option) any later version.
- *
- * Libav is distributed in the hope that it will be useful,
- * 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
- * License along with Libav; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * H.264 / AVC / MPEG-4 part10 codec.
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#include "libavutil/display.h"
-#include "libavutil/imgutils.h"
-#include "libavutil/opt.h"
-#include "libavutil/stereo3d.h"
-#include "libavutil/timer.h"
-#include "internal.h"
-#include "bytestream.h"
-#include "cabac.h"
-#include "cabac_functions.h"
-#include "error_resilience.h"
-#include "avcodec.h"
-#include "h264.h"
-#include "h2645_parse.h"
-#include "h264data.h"
-#include "h264chroma.h"
-#include "h264_mvpred.h"
-#include "golomb.h"
-#include "mathops.h"
-#include "me_cmp.h"
-#include "mpegutils.h"
-#include "profiles.h"
-#include "rectangle.h"
-#include "thread.h"
-
-#include <assert.h>
-
-const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
-
-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)
-{
-    H264Context *h = opaque;
-    H264SliceContext *sl = &h->slice_ctx[0];
-
-    sl->mb_x = mb_x;
-    sl->mb_y = mb_y;
-    sl->mb_xy = mb_x + mb_y * h->mb_stride;
-    memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
-    assert(ref >= 0);
-    /* 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. */
-    if (ref >= sl->ref_count[0])
-        ref = 0;
-    fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
-                   2, 2, 2, ref, 1);
-    fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
-    fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
-                   pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
-    assert(!FRAME_MBAFF(h));
-    ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
-}
-
-void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
-                             int y, int height)
-{
-    AVCodecContext *avctx = h->avctx;
-    const AVFrame   *src  = h->cur_pic.f;
-    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
-    int vshift = desc->log2_chroma_h;
-    const int field_pic = h->picture_structure != PICT_FRAME;
-    if (field_pic) {
-        height <<= 1;
-        y      <<= 1;
-    }
-
-    height = FFMIN(height, avctx->height - y);
-
-    if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
-        return;
-
-    if (avctx->draw_horiz_band) {
-        int offset[AV_NUM_DATA_POINTERS];
-        int i;
-
-        offset[0] = y * src->linesize[0];
-        offset[1] =
-        offset[2] = (y >> vshift) * src->linesize[1];
-        for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
-            offset[i] = 0;
-
-        emms_c();
-
-        avctx->draw_horiz_band(avctx, src, offset,
-                               y, h->picture_structure, height);
-    }
-}
-
-void ff_h264_free_tables(H264Context *h)
-{
-    int i;
-
-    av_freep(&h->intra4x4_pred_mode);
-    av_freep(&h->chroma_pred_mode_table);
-    av_freep(&h->cbp_table);
-    av_freep(&h->mvd_table[0]);
-    av_freep(&h->mvd_table[1]);
-    av_freep(&h->direct_table);
-    av_freep(&h->non_zero_count);
-    av_freep(&h->slice_table_base);
-    h->slice_table = NULL;
-    av_freep(&h->list_counts);
-
-    av_freep(&h->mb2b_xy);
-    av_freep(&h->mb2br_xy);
-
-    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);
-
-    for (i = 0; i < h->nb_slice_ctx; i++) {
-        H264SliceContext *sl = &h->slice_ctx[i];
-
-        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);
-
-        av_freep(&sl->bipred_scratchpad);
-        av_freep(&sl->edge_emu_buffer);
-        av_freep(&sl->top_borders[0]);
-        av_freep(&sl->top_borders[1]);
-
-        sl->bipred_scratchpad_allocated = 0;
-        sl->edge_emu_buffer_allocated   = 0;
-        sl->top_borders_allocated[0]    = 0;
-        sl->top_borders_allocated[1]    = 0;
-    }
-}
-
-int ff_h264_alloc_tables(H264Context *h)
-{
-    const int big_mb_num = h->mb_stride * (h->mb_height + 1);
-    const int row_mb_num = h->mb_stride * 2 * h->nb_slice_ctx;
-    int x, y;
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
-                      row_mb_num * 8 * sizeof(uint8_t), fail)
-    h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
-                      big_mb_num * 48 * sizeof(uint8_t), fail)
-    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,
-                      big_mb_num * sizeof(uint16_t), fail)
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
-                      big_mb_num * sizeof(uint8_t), fail)
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[0],
-                      16 * row_mb_num * sizeof(uint8_t), fail);
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[1],
-                      16 * row_mb_num * sizeof(uint8_t), fail);
-    h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
-    h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
-                      4 * big_mb_num * sizeof(uint8_t), fail);
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
-                      big_mb_num * sizeof(uint8_t), fail)
-
-    memset(h->slice_table_base, -1,
-           (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
-    h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
-
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
-                      big_mb_num * sizeof(uint32_t), fail);
-    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
-                      big_mb_num * sizeof(uint32_t), fail);
-    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;
-            const int b_xy  = 4 * x + 4 * y * h->b_stride;
-
-            h->mb2b_xy[mb_xy]  = b_xy;
-            h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
-        }
-
-    return 0;
-
-fail:
-    ff_h264_free_tables(h);
-    return AVERROR(ENOMEM);
-}
-
-/**
- * Init context
- * Allocate buffers which are not shared amongst multiple threads.
- */
-int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
-{
-    ERContext *er = &sl->er;
-    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;
-
-    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;
-
-    if (CONFIG_ERROR_RESILIENCE) {
-        /* 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;
-
-        // error resilience code looks cleaner with this
-        FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
-                          (h->mb_num + 1) * sizeof(int), fail);
-
-        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;
-
-        er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
-                                                      h->mb_stride + h->mb_width;
-
-        FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
-                          mb_array_size * sizeof(uint8_t), fail);
-
-        FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
-                         h->mb_height * h->mb_stride, fail);
-
-        FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
-                          yc_size * sizeof(int16_t), fail);
-        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;
-        er->dc_val[2] = er->dc_val[1] + c_size;
-        for (i = 0; i < yc_size; i++)
-            sl->dc_val_base[i] = 1024;
-    }
-
-    return 0;
-
-fail:
-    return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
-}
-
-static int h264_init_context(AVCodecContext *avctx, H264Context *h)
-{
-    int i;
-
-    h->avctx                 = avctx;
-
-    h->picture_structure     = PICT_FRAME;
-    h->workaround_bugs       = avctx->workaround_bugs;
-    h->flags                 = avctx->flags;
-    h->poc.prev_poc_msb      = 1 << 16;
-    h->recovery_frame        = -1;
-    h->frame_recovered       = 0;
-
-    h->next_outputed_poc = INT_MIN;
-    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
-        h->last_pocs[i] = INT_MIN;
-
-    ff_h264_sei_uninit(&h->sei);
-
-    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
-
-    h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
-    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);
-    }
-
-    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);
-
-    for (i = 0; i < h->nb_slice_ctx; i++)
-        h->slice_ctx[i].h264 = h;
-
-    return 0;
-}
-
-static av_cold int h264_decode_end(AVCodecContext *avctx)
-{
-    H264Context *h = avctx->priv_data;
-    int i;
-
-    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);
-    }
-
-    h->cur_pic_ptr = NULL;
-
-    av_freep(&h->slice_ctx);
-    h->nb_slice_ctx = 0;
-
-    for (i = 0; i < MAX_SPS_COUNT; i++)
-        av_buffer_unref(&h->ps.sps_list[i]);
-
-    for (i = 0; i < MAX_PPS_COUNT; i++)
-        av_buffer_unref(&h->ps.pps_list[i]);
-
-    ff_h2645_packet_uninit(&h->pkt);
-
-    ff_h264_unref_picture(h, &h->cur_pic);
-    av_frame_free(&h->cur_pic.f);
-
-    return 0;
-}
-
-static AVOnce h264_vlc_init = AV_ONCE_INIT;
-
-av_cold int ff_h264_decode_init(AVCodecContext *avctx)
-{
-    H264Context *h = avctx->priv_data;
-    int ret;
-
-    ret = h264_init_context(avctx, h);
-    if (ret < 0)
-        return ret;
-
-    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;
-    }
-
-    if (avctx->codec_id == AV_CODEC_ID_H264) {
-        if (avctx->ticks_per_frame == 1)
-            h->avctx->framerate.num *= 2;
-        avctx->ticks_per_frame = 2;
-    }
-
-    if (avctx->extradata_size > 0 && avctx->extradata) {
-       ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
-                                      &h->ps, &h->is_avc, &h->nal_length_size,
-                                      avctx->err_recognition, avctx);
-       if (ret < 0) {
-           h264_decode_end(avctx);
-           return ret;
-       }
-    }
-
-    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;
-    }
-
-    avctx->internal->allocate_progress = 1;
-
-    if (h->enable_er) {
-        av_log(avctx, AV_LOG_WARNING,
-               "Error resilience is enabled. It is unsafe and unsupported and may crash. "
-               "Use it at your own risk\n");
-    }
-
-    return 0;
-}
-
-static int decode_init_thread_copy(AVCodecContext *avctx)
-{
-    H264Context *h = avctx->priv_data;
-    int ret;
-
-    if (!avctx->internal->is_copy)
-        return 0;
-
-    memset(h, 0, sizeof(*h));
-
-    ret = h264_init_context(avctx, h);
-    if (ret < 0)
-        return ret;
-
-    h->context_initialized = 0;
-
-    return 0;
-}
-
-/**
- * Run setup operations that must be run after slice header decoding.
- * This includes finding the next displayed frame.
- *
- * @param h h264 master context
- * @param setup_finished enough NALs have been read that we can call
- * ff_thread_finish_setup()
- */
-static void decode_postinit(H264Context *h, int setup_finished)
-{
-    const SPS *sps = h->ps.sps;
-    H264Picture *out = h->cur_pic_ptr;
-    H264Picture *cur = h->cur_pic_ptr;
-    int i, pics, out_of_order, out_idx;
-    int invalid = 0, cnt = 0;
-
-    if (h->next_output_pic)
-        return;
-
-    if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
-        /* FIXME: if we have two PAFF fields in one packet, we can't start
-         * the next thread here. If we have one field per packet, we can.
-         * The check in decode_nal_units() is not good enough to find this
-         * yet, so we assume the worst for now. */
-        // if (setup_finished)
-        //    ff_thread_finish_setup(h->avctx);
-        return;
-    }
-
-    // FIXME do something with unavailable reference frames
-
-    /* Sort B-frames into display order */
-    if (sps->bitstream_restriction_flag ||
-        h->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
-        h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
-    }
-
-    pics = 0;
-    while (h->delayed_pic[pics])
-        pics++;
-
-    assert(pics <= MAX_DELAYED_PIC_COUNT);
-
-    h->delayed_pic[pics++] = cur;
-    if (cur->reference == 0)
-        cur->reference = DELAYED_PIC_REF;
-
-    /* Frame reordering. This code takes pictures from coding order and sorts
-     * them by their incremental POC value into display order. It supports POC
-     * gaps, MMCO reset codes and random resets.
-     * A "display group" can start either with a IDR frame (f.key_frame = 1),
-     * and/or can be closed down with a MMCO reset code. In sequences where
-     * there is no delay, we can't detect that (since the frame was already
-     * output to the user), so we also set h->mmco_reset to detect the MMCO
-     * reset code.
-     * FIXME: if we detect insufficient delays (as per h->avctx->has_b_frames),
-     * we increase the delay between input and output. All frames affected by
-     * the lag (e.g. those that should have been output before another frame
-     * that we already returned to the user) will be dropped. This is a bug
-     * that we will fix later. */
-    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
-        cnt     += out->poc < h->last_pocs[i];
-        invalid += out->poc == INT_MIN;
-    }
-    if (!h->mmco_reset && !cur->f->key_frame &&
-        cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
-        h->mmco_reset = 2;
-        if (pics > 1)
-            h->delayed_pic[pics - 2]->mmco_reset = 2;
-    }
-    if (h->mmco_reset || cur->f->key_frame) {
-        for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
-            h->last_pocs[i] = INT_MIN;
-        cnt     = 0;
-        invalid = MAX_DELAYED_PIC_COUNT;
-    }
-    out     = h->delayed_pic[0];
-    out_idx = 0;
-    for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
-                h->delayed_pic[i] &&
-                !h->delayed_pic[i - 1]->mmco_reset &&
-                !h->delayed_pic[i]->f->key_frame;
-         i++)
-        if (h->delayed_pic[i]->poc < out->poc) {
-            out     = h->delayed_pic[i];
-            out_idx = i;
-        }
-    if (h->avctx->has_b_frames == 0 &&
-        (h->delayed_pic[0]->f->key_frame || h->mmco_reset))
-        h->next_outputed_poc = INT_MIN;
-    out_of_order = !out->f->key_frame && !h->mmco_reset &&
-                   (out->poc < h->next_outputed_poc);
-
-    if (sps->bitstream_restriction_flag &&
-        h->avctx->has_b_frames >= sps->num_reorder_frames) {
-    } else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
-               h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
-        if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
-            h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
-        }
-    } else if (!h->avctx->has_b_frames &&
-               ((h->next_outputed_poc != INT_MIN &&
-                 out->poc > h->next_outputed_poc + 2) ||
-                cur->f->pict_type == AV_PICTURE_TYPE_B)) {
-        h->avctx->has_b_frames++;
-    }
-
-    if (pics > h->avctx->has_b_frames) {
-        out->reference &= ~DELAYED_PIC_REF;
-        for (i = out_idx; h->delayed_pic[i]; i++)
-            h->delayed_pic[i] = h->delayed_pic[i + 1];
-    }
-    memmove(h->last_pocs, &h->last_pocs[1],
-            sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
-    h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
-    if (!out_of_order && pics > h->avctx->has_b_frames) {
-        h->next_output_pic = out;
-        if (out->mmco_reset) {
-            if (out_idx > 0) {
-                h->next_outputed_poc                    = out->poc;
-                h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
-            } else {
-                h->next_outputed_poc = INT_MIN;
-            }
-        } else {
-            if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f->key_frame) {
-                h->next_outputed_poc = INT_MIN;
-            } else {
-                h->next_outputed_poc = out->poc;
-            }
-        }
-        h->mmco_reset = 0;
-    } else {
-        av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
-    }
-
-    if (h->next_output_pic) {
-        if (h->next_output_pic->recovered) {
-            // We have reached an recovery point and all frames after it in
-            // display order are "recovered".
-            h->frame_recovered |= FRAME_RECOVERED_SEI;
-        }
-        h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
-    }
-
-    if (setup_finished && !h->avctx->hwaccel) {
-        ff_thread_finish_setup(h->avctx);
-
-        if (h->avctx->active_thread_type & FF_THREAD_FRAME)
-            h->setup_finished = 1;
-    }
-}
-
-/**
- * instantaneous decoder refresh.
- */
-static void idr(H264Context *h)
-{
-    ff_h264_remove_all_refs(h);
-    h->poc.prev_frame_num        =
-    h->poc.prev_frame_num_offset =
-    h->poc.prev_poc_msb          =
-    h->poc.prev_poc_lsb          = 0;
-}
-
-/* forget old pics after a seek */
-void ff_h264_flush_change(H264Context *h)
-{
-    int i;
-    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
-        h->last_pocs[i] = INT_MIN;
-    h->next_outputed_poc = INT_MIN;
-    h->prev_interlaced_frame = 1;
-    idr(h);
-    if (h->cur_pic_ptr)
-        h->cur_pic_ptr->reference = 0;
-    h->first_field = 0;
-    ff_h264_sei_uninit(&h->sei);
-    h->recovery_frame = -1;
-    h->frame_recovered = 0;
-}
-
-/* forget old pics after a seek */
-static void flush_dpb(AVCodecContext *avctx)
-{
-    H264Context *h = avctx->priv_data;
-    int i;
-
-    memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
-
-    ff_h264_flush_change(h);
-
-    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
-        ff_h264_unref_picture(h, &h->DPB[i]);
-    h->cur_pic_ptr = NULL;
-    ff_h264_unref_picture(h, &h->cur_pic);
-
-    h->mb_y = 0;
-
-    ff_h264_free_tables(h);
-    h->context_initialized = 0;
-}
-
-static int get_last_needed_nal(H264Context *h)
-{
-    int nals_needed = 0;
-    int i;
-
-    for (i = 0; i < h->pkt.nb_nals; i++) {
-        H2645NAL *nal = &h->pkt.nals[i];
-        GetBitContext gb;
-
-        /* 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 */
-        switch (nal->type) {
-        case NAL_SPS:
-        case NAL_PPS:
-            nals_needed = i;
-            break;
-        case NAL_DPA:
-        case NAL_IDR_SLICE:
-        case NAL_SLICE:
-            init_get_bits(&gb, nal->data + 1, (nal->size - 1) * 8);
-            if (!get_ue_golomb(&gb))
-                nals_needed = i;
-        }
-    }
-
-    return nals_needed;
-}
-
-static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
-{
-    AVCodecContext *const avctx = h->avctx;
-    unsigned context_count = 0;
-    int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
-    int i, ret = 0;
-
-    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
-        h->current_slice = 0;
-        if (!h->first_field)
-            h->cur_pic_ptr = NULL;
-        ff_h264_sei_uninit(&h->sei);
-    }
-
-    ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
-                                h->nal_length_size, avctx->codec_id);
-    if (ret < 0) {
-        av_log(avctx, AV_LOG_ERROR,
-               "Error splitting the input into NAL units.\n");
-        return ret;
-    }
-
-    if (avctx->active_thread_type & FF_THREAD_FRAME)
-        nals_needed = get_last_needed_nal(h);
-
-    for (i = 0; i < h->pkt.nb_nals; i++) {
-        H2645NAL *nal = &h->pkt.nals[i];
-        H264SliceContext *sl = &h->slice_ctx[context_count];
-        int err;
-
-        if (avctx->skip_frame >= AVDISCARD_NONREF &&
-            nal->ref_idc == 0 && nal->type != NAL_SEI)
-            continue;
-
-        // FIXME these should stop being context-global variables
-        h->nal_ref_idc   = nal->ref_idc;
-        h->nal_unit_type = nal->type;
-
-        err = 0;
-        switch (nal->type) {
-        case NAL_IDR_SLICE:
-            if (nal->type != NAL_IDR_SLICE) {
-                av_log(h->avctx, AV_LOG_ERROR,
-                       "Invalid mix of idr and non-idr slices\n");
-                ret = -1;
-                goto end;
-            }
-            idr(h); // FIXME ensure we don't lose some frames if there is reordering
-        case NAL_SLICE:
-            sl->gb = nal->gb;
-
-            if ((err = ff_h264_decode_slice_header(h, sl, nal)))
-                break;
-
-            if (h->sei.recovery_point.recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
-                h->recovery_frame = (h->poc.frame_num + h->sei.recovery_point.recovery_frame_cnt) &
-                                    ((1 << h->ps.sps->log2_max_frame_num) - 1);
-            }
-
-            h->cur_pic_ptr->f->key_frame |=
-                (nal->type == NAL_IDR_SLICE) || (h->sei.recovery_point.recovery_frame_cnt >= 0);
-
-            if (nal->type == NAL_IDR_SLICE || h->recovery_frame == h->poc.frame_num) {
-                h->recovery_frame         = -1;
-                h->cur_pic_ptr->recovered = 1;
-            }
-            // If we have an IDR, all frames after it in decoded order are
-            // "recovered".
-            if (nal->type == NAL_IDR_SLICE)
-                h->frame_recovered |= FRAME_RECOVERED_IDR;
-            h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
-
-            if (h->current_slice == 1) {
-                if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS))
-                    decode_postinit(h, i >= nals_needed);
-
-                if (h->avctx->hwaccel &&
-                    (ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0)) < 0)
-                    return ret;
-            }
-
-            if (sl->redundant_pic_count == 0 &&
-                (avctx->skip_frame < AVDISCARD_NONREF || nal->ref_idc) &&
-                (avctx->skip_frame < AVDISCARD_BIDIR  ||
-                 sl->slice_type_nos != AV_PICTURE_TYPE_B) &&
-                (avctx->skip_frame < AVDISCARD_NONKEY ||
-                 h->cur_pic_ptr->f->key_frame) &&
-                avctx->skip_frame < AVDISCARD_ALL) {
-                if (avctx->hwaccel) {
-                    ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
-                    if (ret < 0)
-                        return ret;
-                } else
-                    context_count++;
-            }
-            break;
-        case NAL_DPA:
-        case NAL_DPB:
-        case NAL_DPC:
-            avpriv_request_sample(avctx, "data partitioning");
-            ret = AVERROR(ENOSYS);
-            goto end;
-            break;
-        case NAL_SEI:
-            ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
-            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                goto end;
-            break;
-        case NAL_SPS:
-            ret = ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps);
-            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                goto end;
-            break;
-        case NAL_PPS:
-            ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
-                                                       nal->size_bits);
-            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                goto end;
-            break;
-        case NAL_AUD:
-        case NAL_END_SEQUENCE:
-        case NAL_END_STREAM:
-        case NAL_FILLER_DATA:
-        case NAL_SPS_EXT:
-        case NAL_AUXILIARY_SLICE:
-            break;
-        default:
-            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
-                   nal->type, nal->size_bits);
-        }
-
-        if (context_count == h->nb_slice_ctx) {
-            ret = ff_h264_execute_decode_slices(h, context_count);
-            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-                goto end;
-            context_count = 0;
-        }
-
-        if (err < 0) {
-            av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
-            sl->ref_count[0] = sl->ref_count[1] = sl->list_count = 0;
-        }
-    }
-    if (context_count) {
-        ret = ff_h264_execute_decode_slices(h, context_count);
-        if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
-            goto end;
-    }
-
-    ret = 0;
-end:
-    /* clean up */
-    if (h->cur_pic_ptr && !h->droppable) {
-        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
-                                  h->picture_structure == PICT_BOTTOM_FIELD);
-    }
-
-    return (ret < 0) ? ret : buf_size;
-}
-
-/**
- * Return the number of bytes consumed for building the current frame.
- */
-static int get_consumed_bytes(int pos, int buf_size)
-{
-    if (pos == 0)
-        pos = 1;        // avoid infinite loops (I doubt that is needed but...)
-    if (pos + 10 > buf_size)
-        pos = buf_size; // oops ;)
-
-    return pos;
-}
-
-static int output_frame(H264Context *h, AVFrame *dst, AVFrame *src)
-{
-    int i;
-    int ret = av_frame_ref(dst, src);
-    if (ret < 0)
-        return ret;
-
-    if (!h->ps.sps || !h->ps.sps->crop)
-        return 0;
-
-    for (i = 0; i < 3; i++) {
-        int hshift = (i > 0) ? h->chroma_x_shift : 0;
-        int vshift = (i > 0) ? h->chroma_y_shift : 0;
-        int off    = ((h->ps.sps->crop_left >> hshift) << h->pixel_shift) +
-                     (h->ps.sps->crop_top >> vshift) * dst->linesize[i];
-        dst->data[i] += off;
-    }
-    return 0;
-}
-
-static int h264_decode_frame(AVCodecContext *avctx, void *data,
-                             int *got_frame, AVPacket *avpkt)
-{
-    const uint8_t *buf = avpkt->data;
-    int buf_size       = avpkt->size;
-    H264Context *h     = avctx->priv_data;
-    AVFrame *pict      = data;
-    int buf_index      = 0;
-    int ret;
-    const uint8_t *new_extradata;
-    int new_extradata_size;
-
-    h->flags = avctx->flags;
-    h->setup_finished = 0;
-
-    /* end of stream, output what is still in the buffers */
-out:
-    if (buf_size == 0) {
-        H264Picture *out;
-        int i, out_idx;
-
-        h->cur_pic_ptr = NULL;
-
-        // FIXME factorize this with the output code below
-        out     = h->delayed_pic[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) {
-            ret = output_frame(h, pict, out->f);
-            if (ret < 0)
-                return ret;
-            *got_frame = 1;
-        }
-
-        return buf_index;
-    }
-
-    new_extradata_size = 0;
-    new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
-                                            &new_extradata_size);
-    if (new_extradata_size > 0 && new_extradata) {
-        ret = ff_h264_decode_extradata(new_extradata, new_extradata_size,
-                                       &h->ps, &h->is_avc, &h->nal_length_size,
-                                       avctx->err_recognition, avctx);
-        if (ret < 0)
-            return ret;
-    }
-
-    buf_index = decode_nal_units(h, buf, buf_size);
-    if (buf_index < 0)
-        return AVERROR_INVALIDDATA;
-
-    if (!h->cur_pic_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
-        buf_size = 0;
-        goto out;
-    }
-
-    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && !h->cur_pic_ptr) {
-        if (avctx->skip_frame >= AVDISCARD_NONREF)
-            return 0;
-        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
-        return AVERROR_INVALIDDATA;
-    }
-
-    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
-        (h->mb_y >= h->mb_height && h->mb_height)) {
-        if (avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)
-            decode_postinit(h, 1);
-
-        ff_h264_field_end(h, &h->slice_ctx[0], 0);
-
-        *got_frame = 0;
-        if (h->next_output_pic && ((avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
-                                   h->next_output_pic->recovered)) {
-            if (!h->next_output_pic->recovered)
-                h->next_output_pic->f->flags |= AV_FRAME_FLAG_CORRUPT;
-
-            ret = output_frame(h, pict, h->next_output_pic->f);
-            if (ret < 0)
-                return ret;
-            *got_frame = 1;
-        }
-    }
-
-    assert(pict->buf[0] || !*got_frame);
-
-    return get_consumed_bytes(buf_index, buf_size);
-}
-
-#define OFFSET(x) offsetof(H264Context, x)
-#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
-static const AVOption h264_options[] = {
-    { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
-    { NULL },
-};
-
-static const AVClass h264_class = {
-    .class_name = "h264",
-    .item_name  = av_default_item_name,
-    .option     = h264_options,
-    .version    = LIBAVUTIL_VERSION_INT,
-};
-
-AVCodec ff_h264_decoder = {
-    .name                  = "h264",
-    .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
-    .type                  = AVMEDIA_TYPE_VIDEO,
-    .id                    = AV_CODEC_ID_H264,
-    .priv_data_size        = sizeof(H264Context),
-    .init                  = ff_h264_decode_init,
-    .close                 = h264_decode_end,
-    .decode                = h264_decode_frame,
-    .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,
-    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
-    .flush                 = flush_dpb,
-    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
-    .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
-    .profiles              = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
-    .priv_class            = &h264_class,
-};
diff --git a/libavcodec/h264.h b/libavcodec/h264.h
deleted file mode 100644 (file)
index 398a283..0000000
+++ /dev/null
@@ -1,938 +0,0 @@
-/*
- * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
- * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
- *
- * This file is part of Libav.
- *
- * Libav 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 (at your option) any later version.
- *
- * Libav is distributed in the hope that it will be useful,
- * 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
- * License along with Libav; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- */
-
-/**
- * @file
- * H.264 / AVC / MPEG-4 part10 codec.
- * @author Michael Niedermayer <michaelni@gmx.at>
- */
-
-#ifndef AVCODEC_H264_H
-#define AVCODEC_H264_H
-
-#include "libavutil/buffer.h"
-#include "libavutil/intreadwrite.h"
-#include "libavutil/thread.h"
-
-#include "cabac.h"
-#include "error_resilience.h"
-#include "h264_parse.h"
-#include "h264_sei.h"
-#include "h2645_parse.h"
-#include "h264chroma.h"
-#include "h264dsp.h"
-#include "h264pred.h"
-#include "h264qpel.h"
-#include "internal.h"
-#include "mpegutils.h"
-#include "parser.h"
-#include "qpeldsp.h"
-#include "rectangle.h"
-#include "videodsp.h"
-
-#define H264_MAX_PICTURE_COUNT 32
-
-#define MAX_SPS_COUNT          32
-#define MAX_PPS_COUNT         256
-
-#define MAX_MMCO_COUNT         66
-
-#define MAX_DELAYED_PIC_COUNT  16
-
-/* Compiling in interlaced support reduces the speed
- * of progressive decoding by about 2%. */
-#define ALLOW_INTERLACE
-
-#define FMO 0
-
-/**
- * The maximum number of slices supported by the decoder.
- * must be a power of 2
- */
-#define MAX_SLICES 32
-
-#ifdef ALLOW_INTERLACE
-#define MB_MBAFF(h)    h->mb_mbaff
-#define MB_FIELD(h)    h->mb_field_decoding_flag
-#define FRAME_MBAFF(h) h->mb_aff_frame
-#define FIELD_PICTURE(h) (h->picture_structure != PICT_FRAME)
-#define LEFT_MBS 2
-#define LTOP     0
-#define LBOT     1
-#define LEFT(i)  (i)
-#else
-#define MB_MBAFF(h)      0
-#define MB_FIELD(h)      0
-#define FRAME_MBAFF(h)   0
-#define FIELD_PICTURE(h) 0
-#undef  IS_INTERLACED
-#define IS_INTERLACED(mb_type) 0
-#define LEFT_MBS 1
-#define LTOP     0
-#define LBOT     0
-#define LEFT(i)  0
-#endif
-#define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
-
-#ifndef CABAC
-#define CABAC(h) h->ps.pps->cabac
-#endif
-
-#define CHROMA422(h) (h->ps.sps->chroma_format_idc == 2)
-#define CHROMA444(h) (h->ps.sps->chroma_format_idc == 3)
-
-#define EXTENDED_SAR       255
-
-#define MB_TYPE_REF0       MB_TYPE_ACPRED // dirty but it fits in 16 bit
-#define MB_TYPE_8x8DCT     0x01000000
-#define IS_REF0(a)         ((a) & MB_TYPE_REF0)
-#define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
-
-#define QP_MAX_NUM (51 + 2 * 6)           // The maximum supported qp
-
-/* NAL unit types */
-enum {
-    NAL_SLICE           = 1,
-    NAL_DPA             = 2,
-    NAL_DPB             = 3,
-    NAL_DPC             = 4,
-    NAL_IDR_SLICE       = 5,
-    NAL_SEI             = 6,
-    NAL_SPS             = 7,
-    NAL_PPS             = 8,
-    NAL_AUD             = 9,
-    NAL_END_SEQUENCE    = 10,
-    NAL_END_STREAM      = 11,
-    NAL_FILLER_DATA     = 12,
-    NAL_SPS_EXT         = 13,
-    NAL_AUXILIARY_SLICE = 19,
-};
-
-/**
- * Sequence parameter set
- */
-typedef struct SPS {
-    unsigned int sps_id;
-    int profile_idc;
-    int level_idc;
-    int chroma_format_idc;
-    int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
-    int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
-    int poc_type;                      ///< pic_order_cnt_type
-    int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
-    int delta_pic_order_always_zero_flag;
-    int offset_for_non_ref_pic;
-    int offset_for_top_to_bottom_field;
-    int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
-    int ref_frame_count;               ///< num_ref_frames
-    int gaps_in_frame_num_allowed_flag;
-    int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
-    int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
-    int frame_mbs_only_flag;
-    int mb_aff;                        ///< mb_adaptive_frame_field_flag
-    int direct_8x8_inference_flag;
-    int crop;                          ///< frame_cropping_flag
-
-    /* those 4 are already in luma samples */
-    unsigned int crop_left;            ///< frame_cropping_rect_left_offset
-    unsigned int crop_right;           ///< frame_cropping_rect_right_offset
-    unsigned int crop_top;             ///< frame_cropping_rect_top_offset
-    unsigned int crop_bottom;          ///< frame_cropping_rect_bottom_offset
-    int vui_parameters_present_flag;
-    AVRational sar;
-    int video_signal_type_present_flag;
-    int full_range;
-    int colour_description_present_flag;
-    enum AVColorPrimaries color_primaries;
-    enum AVColorTransferCharacteristic color_trc;
-    enum AVColorSpace colorspace;
-    int timing_info_present_flag;
-    uint32_t num_units_in_tick;
-    uint32_t time_scale;
-    int fixed_frame_rate_flag;
-    short offset_for_ref_frame[256]; // FIXME dyn aloc?
-    int bitstream_restriction_flag;
-    int num_reorder_frames;
-    int scaling_matrix_present;
-    uint8_t scaling_matrix4[6][16];
-    uint8_t scaling_matrix8[6][64];
-    int nal_hrd_parameters_present_flag;
-    int vcl_hrd_parameters_present_flag;
-    int pic_struct_present_flag;
-    int time_offset_length;
-    int cpb_cnt;                          ///< See H.264 E.1.2
-    int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 + 1
-    int cpb_removal_delay_length;         ///< cpb_removal_delay_length_minus1 + 1
-    int dpb_output_delay_length;          ///< dpb_output_delay_length_minus1 + 1
-    int bit_depth_luma;                   ///< bit_depth_luma_minus8 + 8
-    int bit_depth_chroma;                 ///< bit_depth_chroma_minus8 + 8
-    int residual_color_transform_flag;    ///< residual_colour_transform_flag
-    int constraint_set_flags;             ///< constraint_set[0-3]_flag
-} SPS;
-
-/**
- * Picture parameter set
- */
-typedef struct PPS {
-    unsigned int sps_id;
-    int cabac;                  ///< entropy_coding_mode_flag
-    int pic_order_present;      ///< pic_order_present_flag
-    int slice_group_count;      ///< num_slice_groups_minus1 + 1
-    int mb_slice_group_map_type;
-    unsigned int ref_count[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
-    int weighted_pred;          ///< weighted_pred_flag
-    int weighted_bipred_idc;
-    int init_qp;                ///< pic_init_qp_minus26 + 26
-    int init_qs;                ///< pic_init_qs_minus26 + 26
-    int chroma_qp_index_offset[2];
-    int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
-    int constrained_intra_pred;     ///< constrained_intra_pred_flag
-    int redundant_pic_cnt_present;  ///< redundant_pic_cnt_present_flag
-    int transform_8x8_mode;         ///< transform_8x8_mode_flag
-    uint8_t scaling_matrix4[6][16];
-    uint8_t scaling_matrix8[6][64];
-    uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
-    int chroma_qp_diff;
-
-    uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16];
-    uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
-    uint32_t(*dequant4_coeff[6])[16];
-    uint32_t(*dequant8_coeff[6])[64];
-} PPS;
-
-typedef struct H264ParamSets {
-    AVBufferRef *sps_list[MAX_SPS_COUNT];
-    AVBufferRef *pps_list[MAX_PPS_COUNT];
-
-    /* currently active parameters sets */
-    const PPS *pps;
-    // FIXME this should properly be const
-    SPS *sps;
-} H264ParamSets;
-
-/**
- * Memory management control operation opcode.
- */
-typedef enum MMCOOpcode {
-    MMCO_END = 0,
-    MMCO_SHORT2UNUSED,
-    MMCO_LONG2UNUSED,
-    MMCO_SHORT2LONG,
-    MMCO_SET_MAX_LONG,
-    MMCO_RESET,
-    MMCO_LONG,
-} MMCOOpcode;
-
-/**
- * Memory management control operation.
- */
-typedef struct MMCO {
-    MMCOOpcode opcode;
-    int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
-    int long_arg;       ///< index, pic_num, or num long refs depending on opcode
-} MMCO;
-
-typedef struct H264Picture {
-    AVFrame *f;
-    ThreadFrame tf;
-
-    AVBufferRef *qscale_table_buf;
-    int8_t *qscale_table;
-
-    AVBufferRef *motion_val_buf[2];
-    int16_t (*motion_val[2])[2];
-
-    AVBufferRef *mb_type_buf;
-    uint32_t *mb_type;
-
-    AVBufferRef *hwaccel_priv_buf;
-    void *hwaccel_picture_private; ///< hardware accelerator private data
-
-    AVBufferRef *ref_index_buf[2];
-    int8_t *ref_index[2];
-
-    int field_poc[2];       ///< top/bottom POC
-    int poc;                ///< frame POC
-    int frame_num;          ///< frame_num (raw frame_num from slice header)
-    int mmco_reset;         /**< MMCO_RESET set this 1. Reordering code must
-                                 not mix pictures before and after MMCO_RESET. */
-    int pic_id;             /**< pic_num (short -> no wrap version of pic_num,
-                                 pic_num & max_pic_num; long -> long_pic_num) */
-    int long_ref;           ///< 1->long term reference 0->short term reference
-    int ref_poc[2][2][32];  ///< POCs of the frames used as reference (FIXME need per slice)
-    int ref_count[2][2];    ///< number of entries in ref_poc         (FIXME need per slice)
-    int mbaff;              ///< 1 -> MBAFF frame 0-> not MBAFF
-    int field_picture;      ///< whether or not picture was encoded in separate fields
-
-    int reference;
-    int recovered;          ///< picture at IDR or recovery point + recovery count
-} H264Picture;
-
-typedef struct H264Ref {
-    uint8_t *data[3];
-    int linesize[3];
-
-    int reference;
-    int poc;
-    int pic_id;
-
-    H264Picture *parent;
-} H264Ref;
-
-typedef struct H264SliceContext {
-    struct H264Context *h264;
-    GetBitContext gb;
-    ERContext er;
-
-    int slice_num;
-    int slice_type;
-    int slice_type_nos;         ///< S free slice type (SI/SP are remapped to I/P)
-    int slice_type_fixed;
-
-    int qscale;
-    int chroma_qp[2];   // QPc
-    int qp_thresh;      ///< QP threshold to skip loopfilter
-    int last_qscale_diff;
-
-    // deblock
-    int deblocking_filter;          ///< disable_deblocking_filter_idc with 1 <-> 0
-    int slice_alpha_c0_offset;
-    int slice_beta_offset;
-
-    H264PredWeightTable pwt;
-
-    int prev_mb_skipped;
-    int next_mb_skipped;
-
-    int chroma_pred_mode;
-    int intra16x16_pred_mode;
-
-    int8_t intra4x4_pred_mode_cache[5 * 8];
-    int8_t(*intra4x4_pred_mode);
-
-    int topleft_mb_xy;
-    int top_mb_xy;
-    int topright_mb_xy;
-    int left_mb_xy[LEFT_MBS];
-
-    int topleft_type;
-    int top_type;
-    int topright_type;
-    int left_type[LEFT_MBS];
-
-    const uint8_t *left_block;
-    int topleft_partition;
-
-    unsigned int topleft_samples_available;
-    unsigned int top_samples_available;
-    unsigned int topright_samples_available;
-    unsigned int left_samples_available;
-
-    ptrdiff_t linesize, uvlinesize;
-    ptrdiff_t mb_linesize;  ///< may be equal to s->linesize or s->linesize * 2, for mbaff
-    ptrdiff_t mb_uvlinesize;
-
-    int mb_x, mb_y;
-    int mb_xy;
-    int resync_mb_x;
-    int resync_mb_y;
-    unsigned int first_mb_addr;
-    // index of the first MB of the next slice
-    int next_slice_idx;
-    int mb_skip_run;
-    int is_complex;
-
-    int picture_structure;
-    int mb_field_decoding_flag;
-    int mb_mbaff;               ///< mb_aff_frame && mb_field_decoding_flag
-
-    int redundant_pic_count;
-
-    /**
-     * number of neighbors (top and/or left) that used 8x8 dct
-     */
-    int neighbor_transform_size;
-
-    int direct_spatial_mv_pred;
-    int col_parity;
-    int col_fieldoff;
-
-    int cbp;
-    int top_cbp;
-    int left_cbp;
-
-    int dist_scale_factor[32];
-    int dist_scale_factor_field[2][32];
-    int map_col_to_list0[2][16 + 32];
-    int map_col_to_list0_field[2][2][16 + 32];
-
-    /**
-     * num_ref_idx_l0/1_active_minus1 + 1
-     */
-    unsigned int ref_count[2];          ///< counts frames or fields, depending on current mb mode
-    unsigned int list_count;
-    H264Ref ref_list[2][48];        /**< 0..15: frame refs, 16..47: mbaff field refs.
-                                         *   Reordered version of default_ref_list
-                                         *   according to picture reordering in slice header */
-    struct {
-        uint8_t op;
-        uint8_t val;
-    } ref_modifications[2][32];
-    int nb_ref_modifications[2];
-
-    unsigned int pps_id;
-
-    const uint8_t *intra_pcm_ptr;
-    int16_t *dc_val_base;
-
-    uint8_t *bipred_scratchpad;
-    uint8_t *edge_emu_buffer;
-    uint8_t (*top_borders[2])[(16 * 3) * 2];
-    int bipred_scratchpad_allocated;
-    int edge_emu_buffer_allocated;
-    int top_borders_allocated[2];
-
-    /**
-     * non zero coeff count cache.
-     * is 64 if not available.
-     */
-    DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
-
-    /**
-     * Motion vector cache.
-     */
-    DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
-    DECLARE_ALIGNED(8,  int8_t, ref_cache)[2][5 * 8];
-    DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
-    uint8_t direct_cache[5 * 8];
-
-    DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
-
-    ///< as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
-    DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
-    DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
-    ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either
-    ///< check that i is not too large or ensure that there is some unused stuff after mb
-    int16_t mb_padding[256 * 2];
-
-    uint8_t (*mvd_table[2])[2];
-
-    /**
-     * Cabac
-     */
-    CABACContext cabac;
-    uint8_t cabac_state[1024];
-    int cabac_init_idc;
-
-    MMCO mmco[MAX_MMCO_COUNT];
-    int  nb_mmco;
-    int explicit_ref_marking;
-
-    int frame_num;
-    int poc_lsb;
-    int delta_poc_bottom;
-    int delta_poc[2];
-    int curr_pic_num;
-    int max_pic_num;
-} H264SliceContext;
-
-/**
- * H264Context
- */
-typedef struct H264Context {
-    const AVClass *class;
-    AVCodecContext *avctx;
-    VideoDSPContext vdsp;
-    H264DSPContext h264dsp;
-    H264ChromaContext h264chroma;
-    H264QpelContext h264qpel;
-
-    H264Picture DPB[H264_MAX_PICTURE_COUNT];
-    H264Picture *cur_pic_ptr;
-    H264Picture cur_pic;
-
-    H264SliceContext *slice_ctx;
-    int            nb_slice_ctx;
-
-    H2645Packet pkt;
-
-    int pixel_shift;    ///< 0 for 8-bit H.264, 1 for high-bit-depth H.264
-
-    /* coded dimensions -- 16 * mb w/h */
-    int width, height;
-    int chroma_x_shift, chroma_y_shift;
-
-    int droppable;
-    int coded_picture_number;
-
-    int context_initialized;
-    int flags;
-    int workaround_bugs;
-    /* Set when slice threading is used and at least one slice uses deblocking
-     * mode 1 (i.e. across slice boundaries). Then we disable the loop filter
-     * during normal MB decoding and execute it serially at the end.
-     */
-    int postpone_filter;
-
-    int8_t(*intra4x4_pred_mode);
-    H264PredContext hpc;
-
-    uint8_t (*non_zero_count)[48];
-
-#define LIST_NOT_USED -1 // FIXME rename?
-#define PART_NOT_AVAILABLE -2
-
-    /**
-     * block_offset[ 0..23] for frame macroblocks
-     * block_offset[24..47] for field macroblocks
-     */
-    int block_offset[2 * (16 * 3)];
-
-    uint32_t *mb2b_xy;  // FIXME are these 4 a good idea?
-    uint32_t *mb2br_xy;
-    int b_stride;       // FIXME use s->b4_stride
-
-    uint16_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1
-
-    // interlacing specific flags
-    int mb_aff_frame;
-    int picture_structure;
-    int first_field;
-
-    uint8_t *list_counts;               ///< Array of list_count per MB specifying the slice type
-
-    /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
-    uint16_t *cbp_table;
-
-    /* chroma_pred_mode for i4x4 or i16x16, else 0 */
-    uint8_t *chroma_pred_mode_table;
-    uint8_t (*mvd_table[2])[2];
-    uint8_t *direct_table;
-
-    uint8_t zigzag_scan[16];
-    uint8_t zigzag_scan8x8[64];
-    uint8_t zigzag_scan8x8_cavlc[64];
-    uint8_t field_scan[16];
-    uint8_t field_scan8x8[64];
-    uint8_t field_scan8x8_cavlc[64];
-    const uint8_t *zigzag_scan_q0;
-    const uint8_t *zigzag_scan8x8_q0;
-    const uint8_t *zigzag_scan8x8_cavlc_q0;
-    const uint8_t *field_scan_q0;
-    const uint8_t *field_scan8x8_q0;
-    const uint8_t *field_scan8x8_cavlc_q0;
-
-    int mb_y;
-    int mb_height, mb_width;
-    int mb_stride;
-    int mb_num;
-
-    // =============================================================
-    // Things below are not used in the MB or more inner code
-
-    int nal_ref_idc;
-    int nal_unit_type;
-
-    /**
-     * Used to parse AVC variant of H.264
-     */
-    int is_avc;           ///< this flag is != 0 if codec is avc1
-    int nal_length_size;  ///< Number of bytes used for nal length (1, 2 or 4)
-
-    int bit_depth_luma;         ///< luma bit depth from sps to detect changes
-    int chroma_format_idc;      ///< chroma format from sps to detect changes
-
-    H264ParamSets ps;
-
-    uint16_t *slice_table_base;
-
-    H264POCContext poc;
-
-    H264Picture *short_ref[32];
-    H264Picture *long_ref[32];
-    H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
-    int last_pocs[MAX_DELAYED_PIC_COUNT];
-    H264Picture *next_output_pic;
-    int next_outputed_poc;
-
-    /**
-     * memory management control operations buffer.
-     */
-    MMCO mmco[MAX_MMCO_COUNT];
-    int  nb_mmco;
-    int mmco_reset;
-    int explicit_ref_marking;
-
-    int long_ref_count;     ///< number of actual long term references
-    int short_ref_count;    ///< number of actual short term references
-
-    /**
-     * @name Members for slice based multithreading
-     * @{
-     */
-    /**
-     * current slice number, used to initialize slice_num of each thread/context
-     */
-    int current_slice;
-
-    /** @} */
-
-    /**
-     * Complement sei_pic_struct
-     * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
-     * However, soft telecined frames may have these values.
-     * This is used in an attempt to flag soft telecine progressive.
-     */
-    int prev_interlaced_frame;
-
-    /**
-     * recovery_frame is the frame_num at which the next frame should
-     * be fully constructed.
-     *
-     * Set to -1 when not expecting a recovery point.
-     */
-    int recovery_frame;
-
-/**
- * We have seen an IDR, so all the following frames in coded order are correctly
- * decodable.
- */
-#define FRAME_RECOVERED_IDR  (1 << 0)
-/**
- * Sufficient number of frames have been decoded since a SEI recovery point,
- * so all the following frames in presentation order are correct.
- */
-#define FRAME_RECOVERED_SEI  (1 << 1)
-
-    int frame_recovered;    ///< Initial frame has been completely recovered
-
-    /* for frame threading, this is set to 1
-     * after finish_setup() has been called, so we cannot modify
-     * some context properties (which are supposed to stay constant between
-     * slices) anymore */
-    int setup_finished;
-
-    int enable_er;
-
-    H264SEIContext sei;
-
-    AVBufferPool *qscale_table_pool;
-    AVBufferPool *mb_type_pool;
-    AVBufferPool *motion_val_pool;
-    AVBufferPool *ref_index_pool;
-    int ref2frm[MAX_SLICES][2][64];     ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
-} H264Context;
-
-extern const uint16_t ff_h264_mb_sizes[4];
-
-/**
- * Decode SPS
- */
-int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
-                                     H264ParamSets *ps);
-
-/**
- * Decode PPS
- */
-int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
-                                         H264ParamSets *ps, int bit_length);
-
-/**
- * Reconstruct bitstream slice_type.
- */
-int ff_h264_get_slice_type(const H264SliceContext *sl);
-
-/**
- * Allocate tables.
- * needs width/height
- */
-int ff_h264_alloc_tables(H264Context *h);
-
-int ff_h264_decode_ref_pic_list_reordering(const H264Context *h, H264SliceContext *sl);
-int ff_h264_build_ref_list(const H264Context *h, H264SliceContext *sl);
-void ff_h264_remove_all_refs(H264Context *h);
-
-/**
- * Execute the reference picture marking (memory management control operations).
- */
-int ff_h264_execute_ref_pic_marking(H264Context *h);
-
-int ff_h264_decode_ref_pic_marking(const H264Context *h, H264SliceContext *sl,
-                                   GetBitContext *gb);
-
-void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl);
-int ff_h264_decode_init(AVCodecContext *avctx);
-void ff_h264_decode_init_vlc(void);
-
-/**
- * Decode a macroblock
- * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
- */
-int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl);
-
-/**
- * Decode a CABAC coded macroblock
- * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
- */
-int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl);
-
-void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl);
-
-void ff_h264_init_dequant_tables(H264Context *h);
-
-void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl);
-void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl);
-void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl,
-                                int *mb_type);
-
-void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
-                            uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
-                            unsigned int linesize, unsigned int uvlinesize);
-void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
-                       uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
-                       unsigned int linesize, unsigned int uvlinesize);
-
-/*
- * o-o o-o
- *  / / /
- * o-o o-o
- *  ,---'
- * o-o o-o
- *  / / /
- * o-o o-o
- */
-
-/* Scan8 organization:
- *    0 1 2 3 4 5 6 7
- * 0  DY    y y y y y
- * 1        y Y Y Y Y
- * 2        y Y Y Y Y
- * 3        y Y Y Y Y
- * 4        y Y Y Y Y
- * 5  DU    u u u u u
- * 6        u U U U U
- * 7        u U U U U
- * 8        u U U U U
- * 9        u U U U U
- * 10 DV    v v v v v
- * 11       v V V V V
- * 12       v V V V V
- * 13       v V V V V
- * 14       v V V V V
- * DY/DU/DV are for luma/chroma DC.
- */
-
-#define LUMA_DC_BLOCK_INDEX   48
-#define CHROMA_DC_BLOCK_INDEX 49
-
-// This table must be here because scan8[constant] must be known at compiletime
-static const uint8_t scan8[16 * 3 + 3] = {
-    4 +  1 * 8, 5 +  1 * 8, 4 +  2 * 8, 5 +  2 * 8,
-    6 +  1 * 8, 7 +  1 * 8, 6 +  2 * 8, 7 +  2 * 8,
-    4 +  3 * 8, 5 +  3 * 8, 4 +  4 * 8, 5 +  4 * 8,
-    6 +  3 * 8, 7 +  3 * 8, 6 +  4 * 8, 7 +  4 * 8,
-    4 +  6 * 8, 5 +  6 * 8, 4 +  7 * 8, 5 +  7 * 8,
-    6 +  6 * 8, 7 +  6 * 8, 6 +  7 * 8, 7 +  7 * 8,
-    4 +  8 * 8, 5 +  8 * 8, 4 +  9 * 8, 5 +  9 * 8,
-    6 +  8 * 8, 7 +  8 * 8, 6 +  9 * 8, 7 +  9 * 8,
-    4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
-    6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
-    4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
-    6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
-    0 +  0 * 8, 0 +  5 * 8, 0 + 10 * 8
-};
-
-static av_always_inline uint32_t pack16to32(int a, int b)
-{
-#if HAVE_BIGENDIAN
-    return (b & 0xFFFF) + (a << 16);
-#else
-    return (a & 0xFFFF) + (b << 16);
-#endif
-}
-
-static av_always_inline uint16_t pack8to16(int a, int b)
-{
-#if HAVE_BIGENDIAN
-    return (b & 0xFF) + (a << 8);
-#else
-    return (a & 0xFF) + (b << 8);
-#endif
-}
-
-/**
- * Get the chroma qp.
- */
-static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
-{
-    return pps->chroma_qp_table[t][qscale];
-}
-
-/**
- * Get the predicted intra4x4 prediction mode.
- */
-static av_always_inline int pred_intra_mode(const H264Context *h,
-                                            H264SliceContext *sl, int n)
-{
-    const int index8 = scan8[n];
-    const int left   = sl->intra4x4_pred_mode_cache[index8 - 1];
-    const int top    = sl->intra4x4_pred_mode_cache[index8 - 8];
-    const int min    = FFMIN(left, top);
-
-    ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min);
-
-    if (min < 0)
-        return DC_PRED;
-    else
-        return min;
-}
-
-static av_always_inline void write_back_intra_pred_mode(const H264Context *h,
-                                                        H264SliceContext *sl)
-{
-    int8_t *i4x4       = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
-    int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
-
-    AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
-    i4x4[4] = i4x4_cache[7 + 8 * 3];
-    i4x4[5] = i4x4_cache[7 + 8 * 2];
-    i4x4[6] = i4x4_cache[7 + 8 * 1];
-}
-
-static av_always_inline void write_back_non_zero_count(const H264Context *h,
-                                                       H264SliceContext *sl)
-{
-    const int mb_xy    = sl->mb_xy;
-    uint8_t *nnz       = h->non_zero_count[mb_xy];
-    uint8_t *nnz_cache = sl->non_zero_count_cache;
-
-    AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
-    AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
-    AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
-    AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
-    AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
-    AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
-    AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
-    AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
-
-    if (!h->chroma_y_shift) {
-        AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
-        AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
-        AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
-        AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
-    }
-}
-
-static av_always_inline void write_back_motion_list(const H264Context *h,
-                                                    H264SliceContext *sl,
-                                                    int b_stride,
-                                                    int b_xy, int b8_xy,
-                                                    int mb_type, int list)
-{
-    int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy];
-    int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]];
-    AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
-    AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
-    AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
-    AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
-    if (CABAC(h)) {
-        uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy
-                                                        : h->mb2br_xy[sl->mb_xy]];
-        uint8_t(*mvd_src)[2]  = &sl->mvd_cache[list][scan8[0]];
-        if (IS_SKIP(mb_type)) {
-            AV_ZERO128(mvd_dst);
-        } else {
-            AV_COPY64(mvd_dst, mvd_src + 8 * 3);
-            AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
-            AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
-            AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
-        }
-    }
-
-    {
-        int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy];
-        int8_t *ref_cache = sl->ref_cache[list];
-        ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
-        ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
-        ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
-        ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
-    }
-}
-
-static av_always_inline void write_back_motion(const H264Context *h,
-                                               H264SliceContext *sl,
-                                               int mb_type)
-{
-    const int b_stride      = h->b_stride;
-    const int b_xy  = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy
-    const int b8_xy = 4 * sl->mb_xy;
-
-    if (USES_LIST(mb_type, 0)) {
-        write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0);
-    } else {
-        fill_rectangle(&h->cur_pic.ref_index[0][b8_xy],
-                       2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
-    }
-    if (USES_LIST(mb_type, 1))
-        write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
-
-    if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
-        if (IS_8X8(mb_type)) {
-            uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy];
-            direct_table[1] = sl->sub_mb_type[1] >> 1;
-            direct_table[2] = sl->sub_mb_type[2] >> 1;
-            direct_table[3] = sl->sub_mb_type[3] >> 1;
-        }
-    }
-}
-
-static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
-{
-    if (h->ps.sps->direct_8x8_inference_flag)
-        return !(AV_RN64A(sl->sub_mb_type) &
-                 ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) *
-                  0x0001000100010001ULL));
-    else
-        return !(AV_RN64A(sl->sub_mb_type) &
-                 ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2) *
-                  0x0001000100010001ULL));
-}
-
-int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
-
-int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src);
-void ff_h264_unref_picture(H264Context *h, H264Picture *pic);
-
-int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl);
-
-void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height);
-
-int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
-                                const H2645NAL *nal);
-int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count);
-int ff_h264_update_thread_context(AVCodecContext *dst,
-                                  const AVCodecContext *src);
-
-void ff_h264_flush_change(H264Context *h);
-
-void ff_h264_free_tables(H264Context *h);
-
-#endif /* AVCODEC_H264_H */
index 783bc0f..203803f 100644 (file)
@@ -35,7 +35,7 @@
 #include "cabac_functions.h"
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "h264_mvpred.h"
 #include "mpegutils.h"
index dabd61c..4fa2de0 100644 (file)
@@ -29,7 +29,7 @@
 
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264_mvpred.h"
 #include "h264data.h"
 #include "golomb.h"
index 177ec10..d0d16e9 100644 (file)
@@ -27,7 +27,7 @@
 
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegutils.h"
 #include "rectangle.h"
 #include "thread.h"
index 2bac17a..71334e9 100644 (file)
@@ -29,7 +29,7 @@
 #include "libavutil/intreadwrite.h"
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mathops.h"
 #include "mpegutils.h"
 #include "rectangle.h"
index 6f3c719..55bf1c3 100644 (file)
@@ -31,7 +31,7 @@
 #include "libavutil/common.h"
 #include "libavutil/intreadwrite.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "qpeldsp.h"
 #include "thread.h"
 
index 0c8a925..7e6f62f 100644 (file)
@@ -19,7 +19,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "h264.h"
+#include "h264dec.h"
 
 #undef MCFUNC
 
index e9d2b62..83b1ea6 100644 (file)
@@ -30,7 +30,7 @@
 
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegutils.h"
 
 #include <assert.h>
index 052e8e4..be75b05 100644 (file)
@@ -19,7 +19,7 @@
 #include "bytestream.h"
 #include "get_bits.h"
 #include "golomb.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264_parse.h"
 
 int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps,
index b86bf2b..c474183 100644 (file)
@@ -36,7 +36,7 @@
 
 #include "get_bits.h"
 #include "golomb.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264_sei.h"
 #include "h264data.h"
 #include "internal.h"
index cd7ff82..e22852a 100644 (file)
@@ -33,7 +33,7 @@
 #include "cabac_functions.h"
 #include "error_resilience.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "h264chroma.h"
 #include "h264_mvpred.h"
index 8d567ca..9b39992 100644 (file)
@@ -31,7 +31,7 @@
 #include "internal.h"
 #include "mathops.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "golomb.h"
 
index f7b7211..d6dee7a 100644 (file)
@@ -29,7 +29,7 @@
 
 #include "internal.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "golomb.h"
 #include "mpegutils.h"
 
index 0e3952d..380e86c 100644 (file)
@@ -28,7 +28,7 @@
 #include "avcodec.h"
 #include "get_bits.h"
 #include "golomb.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264_sei.h"
 #include "internal.h"
 
index 6a89a41..d49c619 100644 (file)
@@ -35,7 +35,7 @@
 #include "cabac_functions.h"
 #include "error_resilience.h"
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "h264chroma.h"
 #include "h264_mvpred.h"
index 79c5b57..a2a4a47 100644 (file)
@@ -31,7 +31,7 @@
 #include "libavutil/avutil.h"
 
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 
 const uint8_t ff_h264_golomb_to_pict_type[5] = {
index ab96f08..f1284e6 100644 (file)
@@ -21,7 +21,7 @@
 
 #include <stdint.h>
 
-#include "h264.h"
+#include "h264dec.h"
 
 extern const uint8_t ff_h264_golomb_to_pict_type[5];
 extern const uint8_t ff_h264_golomb_to_intra4x4_cbp[48];
diff --git a/libavcodec/h264dec.c b/libavcodec/h264dec.c
new file mode 100644 (file)
index 0000000..6eb2da8
--- /dev/null
@@ -0,0 +1,982 @@
+/*
+ * H.26L/H.264/AVC/JVT/14496-10/... decoder
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of Libav.
+ *
+ * Libav 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 (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * 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
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * H.264 / AVC / MPEG-4 part10 codec.
+ * @author Michael Niedermayer <michaelni@gmx.at>
+ */
+
+#include "libavutil/display.h"
+#include "libavutil/imgutils.h"
+#include "libavutil/opt.h"
+#include "libavutil/stereo3d.h"
+#include "libavutil/timer.h"
+#include "internal.h"
+#include "bytestream.h"
+#include "cabac.h"
+#include "cabac_functions.h"
+#include "error_resilience.h"
+#include "avcodec.h"
+#include "h264dec.h"
+#include "h2645_parse.h"
+#include "h264data.h"
+#include "h264chroma.h"
+#include "h264_mvpred.h"
+#include "golomb.h"
+#include "mathops.h"
+#include "me_cmp.h"
+#include "mpegutils.h"
+#include "profiles.h"
+#include "rectangle.h"
+#include "thread.h"
+
+#include <assert.h>
+
+const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 };
+
+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)
+{
+    H264Context *h = opaque;
+    H264SliceContext *sl = &h->slice_ctx[0];
+
+    sl->mb_x = mb_x;
+    sl->mb_y = mb_y;
+    sl->mb_xy = mb_x + mb_y * h->mb_stride;
+    memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache));
+    assert(ref >= 0);
+    /* 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. */
+    if (ref >= sl->ref_count[0])
+        ref = 0;
+    fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy],
+                   2, 2, 2, ref, 1);
+    fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1);
+    fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8,
+                   pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4);
+    assert(!FRAME_MBAFF(h));
+    ff_h264_hl_decode_mb(h, &h->slice_ctx[0]);
+}
+
+void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl,
+                             int y, int height)
+{
+    AVCodecContext *avctx = h->avctx;
+    const AVFrame   *src  = h->cur_pic.f;
+    const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(avctx->pix_fmt);
+    int vshift = desc->log2_chroma_h;
+    const int field_pic = h->picture_structure != PICT_FRAME;
+    if (field_pic) {
+        height <<= 1;
+        y      <<= 1;
+    }
+
+    height = FFMIN(height, avctx->height - y);
+
+    if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD))
+        return;
+
+    if (avctx->draw_horiz_band) {
+        int offset[AV_NUM_DATA_POINTERS];
+        int i;
+
+        offset[0] = y * src->linesize[0];
+        offset[1] =
+        offset[2] = (y >> vshift) * src->linesize[1];
+        for (i = 3; i < AV_NUM_DATA_POINTERS; i++)
+            offset[i] = 0;
+
+        emms_c();
+
+        avctx->draw_horiz_band(avctx, src, offset,
+                               y, h->picture_structure, height);
+    }
+}
+
+void ff_h264_free_tables(H264Context *h)
+{
+    int i;
+
+    av_freep(&h->intra4x4_pred_mode);
+    av_freep(&h->chroma_pred_mode_table);
+    av_freep(&h->cbp_table);
+    av_freep(&h->mvd_table[0]);
+    av_freep(&h->mvd_table[1]);
+    av_freep(&h->direct_table);
+    av_freep(&h->non_zero_count);
+    av_freep(&h->slice_table_base);
+    h->slice_table = NULL;
+    av_freep(&h->list_counts);
+
+    av_freep(&h->mb2b_xy);
+    av_freep(&h->mb2br_xy);
+
+    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);
+
+    for (i = 0; i < h->nb_slice_ctx; i++) {
+        H264SliceContext *sl = &h->slice_ctx[i];
+
+        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);
+
+        av_freep(&sl->bipred_scratchpad);
+        av_freep(&sl->edge_emu_buffer);
+        av_freep(&sl->top_borders[0]);
+        av_freep(&sl->top_borders[1]);
+
+        sl->bipred_scratchpad_allocated = 0;
+        sl->edge_emu_buffer_allocated   = 0;
+        sl->top_borders_allocated[0]    = 0;
+        sl->top_borders_allocated[1]    = 0;
+    }
+}
+
+int ff_h264_alloc_tables(H264Context *h)
+{
+    const int big_mb_num = h->mb_stride * (h->mb_height + 1);
+    const int row_mb_num = h->mb_stride * 2 * h->nb_slice_ctx;
+    int x, y;
+
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->intra4x4_pred_mode,
+                      row_mb_num * 8 * sizeof(uint8_t), fail)
+    h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode;
+
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->non_zero_count,
+                      big_mb_num * 48 * sizeof(uint8_t), fail)
+    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,
+                      big_mb_num * sizeof(uint16_t), fail)
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->chroma_pred_mode_table,
+                      big_mb_num * sizeof(uint8_t), fail)
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[0],
+                      16 * row_mb_num * sizeof(uint8_t), fail);
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mvd_table[1],
+                      16 * row_mb_num * sizeof(uint8_t), fail);
+    h->slice_ctx[0].mvd_table[0] = h->mvd_table[0];
+    h->slice_ctx[0].mvd_table[1] = h->mvd_table[1];
+
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->direct_table,
+                      4 * big_mb_num * sizeof(uint8_t), fail);
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->list_counts,
+                      big_mb_num * sizeof(uint8_t), fail)
+
+    memset(h->slice_table_base, -1,
+           (big_mb_num + h->mb_stride) * sizeof(*h->slice_table_base));
+    h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1;
+
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2b_xy,
+                      big_mb_num * sizeof(uint32_t), fail);
+    FF_ALLOCZ_OR_GOTO(h->avctx, h->mb2br_xy,
+                      big_mb_num * sizeof(uint32_t), fail);
+    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;
+            const int b_xy  = 4 * x + 4 * y * h->b_stride;
+
+            h->mb2b_xy[mb_xy]  = b_xy;
+            h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride)));
+        }
+
+    return 0;
+
+fail:
+    ff_h264_free_tables(h);
+    return AVERROR(ENOMEM);
+}
+
+/**
+ * Init context
+ * Allocate buffers which are not shared amongst multiple threads.
+ */
+int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
+{
+    ERContext *er = &sl->er;
+    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;
+
+    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;
+
+    if (CONFIG_ERROR_RESILIENCE) {
+        /* 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;
+
+        // error resilience code looks cleaner with this
+        FF_ALLOCZ_OR_GOTO(h->avctx, er->mb_index2xy,
+                          (h->mb_num + 1) * sizeof(int), fail);
+
+        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;
+
+        er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) *
+                                                      h->mb_stride + h->mb_width;
+
+        FF_ALLOCZ_OR_GOTO(h->avctx, er->error_status_table,
+                          mb_array_size * sizeof(uint8_t), fail);
+
+        FF_ALLOC_OR_GOTO(h->avctx, er->er_temp_buffer,
+                         h->mb_height * h->mb_stride, fail);
+
+        FF_ALLOCZ_OR_GOTO(h->avctx, sl->dc_val_base,
+                          yc_size * sizeof(int16_t), fail);
+        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;
+        er->dc_val[2] = er->dc_val[1] + c_size;
+        for (i = 0; i < yc_size; i++)
+            sl->dc_val_base[i] = 1024;
+    }
+
+    return 0;
+
+fail:
+    return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us
+}
+
+static int h264_init_context(AVCodecContext *avctx, H264Context *h)
+{
+    int i;
+
+    h->avctx                 = avctx;
+
+    h->picture_structure     = PICT_FRAME;
+    h->workaround_bugs       = avctx->workaround_bugs;
+    h->flags                 = avctx->flags;
+    h->poc.prev_poc_msb      = 1 << 16;
+    h->recovery_frame        = -1;
+    h->frame_recovered       = 0;
+
+    h->next_outputed_poc = INT_MIN;
+    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
+        h->last_pocs[i] = INT_MIN;
+
+    ff_h264_sei_uninit(&h->sei);
+
+    avctx->chroma_sample_location = AVCHROMA_LOC_LEFT;
+
+    h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1;
+    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);
+    }
+
+    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);
+
+    for (i = 0; i < h->nb_slice_ctx; i++)
+        h->slice_ctx[i].h264 = h;
+
+    return 0;
+}
+
+static av_cold int h264_decode_end(AVCodecContext *avctx)
+{
+    H264Context *h = avctx->priv_data;
+    int i;
+
+    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);
+    }
+
+    h->cur_pic_ptr = NULL;
+
+    av_freep(&h->slice_ctx);
+    h->nb_slice_ctx = 0;
+
+    for (i = 0; i < MAX_SPS_COUNT; i++)
+        av_buffer_unref(&h->ps.sps_list[i]);
+
+    for (i = 0; i < MAX_PPS_COUNT; i++)
+        av_buffer_unref(&h->ps.pps_list[i]);
+
+    ff_h2645_packet_uninit(&h->pkt);
+
+    ff_h264_unref_picture(h, &h->cur_pic);
+    av_frame_free(&h->cur_pic.f);
+
+    return 0;
+}
+
+static AVOnce h264_vlc_init = AV_ONCE_INIT;
+
+av_cold int ff_h264_decode_init(AVCodecContext *avctx)
+{
+    H264Context *h = avctx->priv_data;
+    int ret;
+
+    ret = h264_init_context(avctx, h);
+    if (ret < 0)
+        return ret;
+
+    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;
+    }
+
+    if (avctx->codec_id == AV_CODEC_ID_H264) {
+        if (avctx->ticks_per_frame == 1)
+            h->avctx->framerate.num *= 2;
+        avctx->ticks_per_frame = 2;
+    }
+
+    if (avctx->extradata_size > 0 && avctx->extradata) {
+       ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size,
+                                      &h->ps, &h->is_avc, &h->nal_length_size,
+                                      avctx->err_recognition, avctx);
+       if (ret < 0) {
+           h264_decode_end(avctx);
+           return ret;
+       }
+    }
+
+    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;
+    }
+
+    avctx->internal->allocate_progress = 1;
+
+    if (h->enable_er) {
+        av_log(avctx, AV_LOG_WARNING,
+               "Error resilience is enabled. It is unsafe and unsupported and may crash. "
+               "Use it at your own risk\n");
+    }
+
+    return 0;
+}
+
+static int decode_init_thread_copy(AVCodecContext *avctx)
+{
+    H264Context *h = avctx->priv_data;
+    int ret;
+
+    if (!avctx->internal->is_copy)
+        return 0;
+
+    memset(h, 0, sizeof(*h));
+
+    ret = h264_init_context(avctx, h);
+    if (ret < 0)
+        return ret;
+
+    h->context_initialized = 0;
+
+    return 0;
+}
+
+/**
+ * Run setup operations that must be run after slice header decoding.
+ * This includes finding the next displayed frame.
+ *
+ * @param h h264 master context
+ * @param setup_finished enough NALs have been read that we can call
+ * ff_thread_finish_setup()
+ */
+static void decode_postinit(H264Context *h, int setup_finished)
+{
+    const SPS *sps = h->ps.sps;
+    H264Picture *out = h->cur_pic_ptr;
+    H264Picture *cur = h->cur_pic_ptr;
+    int i, pics, out_of_order, out_idx;
+    int invalid = 0, cnt = 0;
+
+    if (h->next_output_pic)
+        return;
+
+    if (cur->field_poc[0] == INT_MAX || cur->field_poc[1] == INT_MAX) {
+        /* FIXME: if we have two PAFF fields in one packet, we can't start
+         * the next thread here. If we have one field per packet, we can.
+         * The check in decode_nal_units() is not good enough to find this
+         * yet, so we assume the worst for now. */
+        // if (setup_finished)
+        //    ff_thread_finish_setup(h->avctx);
+        return;
+    }
+
+    // FIXME do something with unavailable reference frames
+
+    /* Sort B-frames into display order */
+    if (sps->bitstream_restriction_flag ||
+        h->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
+        h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
+    }
+
+    pics = 0;
+    while (h->delayed_pic[pics])
+        pics++;
+
+    assert(pics <= MAX_DELAYED_PIC_COUNT);
+
+    h->delayed_pic[pics++] = cur;
+    if (cur->reference == 0)
+        cur->reference = DELAYED_PIC_REF;
+
+    /* Frame reordering. This code takes pictures from coding order and sorts
+     * them by their incremental POC value into display order. It supports POC
+     * gaps, MMCO reset codes and random resets.
+     * A "display group" can start either with a IDR frame (f.key_frame = 1),
+     * and/or can be closed down with a MMCO reset code. In sequences where
+     * there is no delay, we can't detect that (since the frame was already
+     * output to the user), so we also set h->mmco_reset to detect the MMCO
+     * reset code.
+     * FIXME: if we detect insufficient delays (as per h->avctx->has_b_frames),
+     * we increase the delay between input and output. All frames affected by
+     * the lag (e.g. those that should have been output before another frame
+     * that we already returned to the user) will be dropped. This is a bug
+     * that we will fix later. */
+    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
+        cnt     += out->poc < h->last_pocs[i];
+        invalid += out->poc == INT_MIN;
+    }
+    if (!h->mmco_reset && !cur->f->key_frame &&
+        cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
+        h->mmco_reset = 2;
+        if (pics > 1)
+            h->delayed_pic[pics - 2]->mmco_reset = 2;
+    }
+    if (h->mmco_reset || cur->f->key_frame) {
+        for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
+            h->last_pocs[i] = INT_MIN;
+        cnt     = 0;
+        invalid = MAX_DELAYED_PIC_COUNT;
+    }
+    out     = h->delayed_pic[0];
+    out_idx = 0;
+    for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
+                h->delayed_pic[i] &&
+                !h->delayed_pic[i - 1]->mmco_reset &&
+                !h->delayed_pic[i]->f->key_frame;
+         i++)
+        if (h->delayed_pic[i]->poc < out->poc) {
+            out     = h->delayed_pic[i];
+            out_idx = i;
+        }
+    if (h->avctx->has_b_frames == 0 &&
+        (h->delayed_pic[0]->f->key_frame || h->mmco_reset))
+        h->next_outputed_poc = INT_MIN;
+    out_of_order = !out->f->key_frame && !h->mmco_reset &&
+                   (out->poc < h->next_outputed_poc);
+
+    if (sps->bitstream_restriction_flag &&
+        h->avctx->has_b_frames >= sps->num_reorder_frames) {
+    } else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
+               h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
+        if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
+            h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
+        }
+    } else if (!h->avctx->has_b_frames &&
+               ((h->next_outputed_poc != INT_MIN &&
+                 out->poc > h->next_outputed_poc + 2) ||
+                cur->f->pict_type == AV_PICTURE_TYPE_B)) {
+        h->avctx->has_b_frames++;
+    }
+
+    if (pics > h->avctx->has_b_frames) {
+        out->reference &= ~DELAYED_PIC_REF;
+        for (i = out_idx; h->delayed_pic[i]; i++)
+            h->delayed_pic[i] = h->delayed_pic[i + 1];
+    }
+    memmove(h->last_pocs, &h->last_pocs[1],
+            sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
+    h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
+    if (!out_of_order && pics > h->avctx->has_b_frames) {
+        h->next_output_pic = out;
+        if (out->mmco_reset) {
+            if (out_idx > 0) {
+                h->next_outputed_poc                    = out->poc;
+                h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
+            } else {
+                h->next_outputed_poc = INT_MIN;
+            }
+        } else {
+            if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f->key_frame) {
+                h->next_outputed_poc = INT_MIN;
+            } else {
+                h->next_outputed_poc = out->poc;
+            }
+        }
+        h->mmco_reset = 0;
+    } else {
+        av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
+    }
+
+    if (h->next_output_pic) {
+        if (h->next_output_pic->recovered) {
+            // We have reached an recovery point and all frames after it in
+            // display order are "recovered".
+            h->frame_recovered |= FRAME_RECOVERED_SEI;
+        }
+        h->next_output_pic->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
+    }
+
+    if (setup_finished && !h->avctx->hwaccel) {
+        ff_thread_finish_setup(h->avctx);
+
+        if (h->avctx->active_thread_type & FF_THREAD_FRAME)
+            h->setup_finished = 1;
+    }
+}
+
+/**
+ * instantaneous decoder refresh.
+ */
+static void idr(H264Context *h)
+{
+    ff_h264_remove_all_refs(h);
+    h->poc.prev_frame_num        =
+    h->poc.prev_frame_num_offset =
+    h->poc.prev_poc_msb          =
+    h->poc.prev_poc_lsb          = 0;
+}
+
+/* forget old pics after a seek */
+void ff_h264_flush_change(H264Context *h)
+{
+    int i;
+    for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
+        h->last_pocs[i] = INT_MIN;
+    h->next_outputed_poc = INT_MIN;
+    h->prev_interlaced_frame = 1;
+    idr(h);
+    if (h->cur_pic_ptr)
+        h->cur_pic_ptr->reference = 0;
+    h->first_field = 0;
+    ff_h264_sei_uninit(&h->sei);
+    h->recovery_frame = -1;
+    h->frame_recovered = 0;
+}
+
+/* forget old pics after a seek */
+static void flush_dpb(AVCodecContext *avctx)
+{
+    H264Context *h = avctx->priv_data;
+    int i;
+
+    memset(h->delayed_pic, 0, sizeof(h->delayed_pic));
+
+    ff_h264_flush_change(h);
+
+    for (i = 0; i < H264_MAX_PICTURE_COUNT; i++)
+        ff_h264_unref_picture(h, &h->DPB[i]);
+    h->cur_pic_ptr = NULL;
+    ff_h264_unref_picture(h, &h->cur_pic);
+
+    h->mb_y = 0;
+
+    ff_h264_free_tables(h);
+    h->context_initialized = 0;
+}
+
+static int get_last_needed_nal(H264Context *h)
+{
+    int nals_needed = 0;
+    int i;
+
+    for (i = 0; i < h->pkt.nb_nals; i++) {
+        H2645NAL *nal = &h->pkt.nals[i];
+        GetBitContext gb;
+
+        /* 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 */
+        switch (nal->type) {
+        case NAL_SPS:
+        case NAL_PPS:
+            nals_needed = i;
+            break;
+        case NAL_DPA:
+        case NAL_IDR_SLICE:
+        case NAL_SLICE:
+            init_get_bits(&gb, nal->data + 1, (nal->size - 1) * 8);
+            if (!get_ue_golomb(&gb))
+                nals_needed = i;
+        }
+    }
+
+    return nals_needed;
+}
+
+static int decode_nal_units(H264Context *h, const uint8_t *buf, int buf_size)
+{
+    AVCodecContext *const avctx = h->avctx;
+    unsigned context_count = 0;
+    int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts
+    int i, ret = 0;
+
+    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) {
+        h->current_slice = 0;
+        if (!h->first_field)
+            h->cur_pic_ptr = NULL;
+        ff_h264_sei_uninit(&h->sei);
+    }
+
+    ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->is_avc,
+                                h->nal_length_size, avctx->codec_id);
+    if (ret < 0) {
+        av_log(avctx, AV_LOG_ERROR,
+               "Error splitting the input into NAL units.\n");
+        return ret;
+    }
+
+    if (avctx->active_thread_type & FF_THREAD_FRAME)
+        nals_needed = get_last_needed_nal(h);
+
+    for (i = 0; i < h->pkt.nb_nals; i++) {
+        H2645NAL *nal = &h->pkt.nals[i];
+        H264SliceContext *sl = &h->slice_ctx[context_count];
+        int err;
+
+        if (avctx->skip_frame >= AVDISCARD_NONREF &&
+            nal->ref_idc == 0 && nal->type != NAL_SEI)
+            continue;
+
+        // FIXME these should stop being context-global variables
+        h->nal_ref_idc   = nal->ref_idc;
+        h->nal_unit_type = nal->type;
+
+        err = 0;
+        switch (nal->type) {
+        case NAL_IDR_SLICE:
+            if (nal->type != NAL_IDR_SLICE) {
+                av_log(h->avctx, AV_LOG_ERROR,
+                       "Invalid mix of idr and non-idr slices\n");
+                ret = -1;
+                goto end;
+            }
+            idr(h); // FIXME ensure we don't lose some frames if there is reordering
+        case NAL_SLICE:
+            sl->gb = nal->gb;
+
+            if ((err = ff_h264_decode_slice_header(h, sl, nal)))
+                break;
+
+            if (h->sei.recovery_point.recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
+                h->recovery_frame = (h->poc.frame_num + h->sei.recovery_point.recovery_frame_cnt) &
+                                    ((1 << h->ps.sps->log2_max_frame_num) - 1);
+            }
+
+            h->cur_pic_ptr->f->key_frame |=
+                (nal->type == NAL_IDR_SLICE) || (h->sei.recovery_point.recovery_frame_cnt >= 0);
+
+            if (nal->type == NAL_IDR_SLICE || h->recovery_frame == h->poc.frame_num) {
+                h->recovery_frame         = -1;
+                h->cur_pic_ptr->recovered = 1;
+            }
+            // If we have an IDR, all frames after it in decoded order are
+            // "recovered".
+            if (nal->type == NAL_IDR_SLICE)
+                h->frame_recovered |= FRAME_RECOVERED_IDR;
+            h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
+
+            if (h->current_slice == 1) {
+                if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS))
+                    decode_postinit(h, i >= nals_needed);
+
+                if (h->avctx->hwaccel &&
+                    (ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0)) < 0)
+                    return ret;
+            }
+
+            if (sl->redundant_pic_count == 0 &&
+                (avctx->skip_frame < AVDISCARD_NONREF || nal->ref_idc) &&
+                (avctx->skip_frame < AVDISCARD_BIDIR  ||
+                 sl->slice_type_nos != AV_PICTURE_TYPE_B) &&
+                (avctx->skip_frame < AVDISCARD_NONKEY ||
+                 h->cur_pic_ptr->f->key_frame) &&
+                avctx->skip_frame < AVDISCARD_ALL) {
+                if (avctx->hwaccel) {
+                    ret = avctx->hwaccel->decode_slice(avctx, nal->raw_data, nal->raw_size);
+                    if (ret < 0)
+                        return ret;
+                } else
+                    context_count++;
+            }
+            break;
+        case NAL_DPA:
+        case NAL_DPB:
+        case NAL_DPC:
+            avpriv_request_sample(avctx, "data partitioning");
+            ret = AVERROR(ENOSYS);
+            goto end;
+            break;
+        case NAL_SEI:
+            ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx);
+            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                goto end;
+            break;
+        case NAL_SPS:
+            ret = ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps);
+            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                goto end;
+            break;
+        case NAL_PPS:
+            ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps,
+                                                       nal->size_bits);
+            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                goto end;
+            break;
+        case NAL_AUD:
+        case NAL_END_SEQUENCE:
+        case NAL_END_STREAM:
+        case NAL_FILLER_DATA:
+        case NAL_SPS_EXT:
+        case NAL_AUXILIARY_SLICE:
+            break;
+        default:
+            av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n",
+                   nal->type, nal->size_bits);
+        }
+
+        if (context_count == h->nb_slice_ctx) {
+            ret = ff_h264_execute_decode_slices(h, context_count);
+            if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+                goto end;
+            context_count = 0;
+        }
+
+        if (err < 0) {
+            av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n");
+            sl->ref_count[0] = sl->ref_count[1] = sl->list_count = 0;
+        }
+    }
+    if (context_count) {
+        ret = ff_h264_execute_decode_slices(h, context_count);
+        if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
+            goto end;
+    }
+
+    ret = 0;
+end:
+    /* clean up */
+    if (h->cur_pic_ptr && !h->droppable) {
+        ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
+                                  h->picture_structure == PICT_BOTTOM_FIELD);
+    }
+
+    return (ret < 0) ? ret : buf_size;
+}
+
+/**
+ * Return the number of bytes consumed for building the current frame.
+ */
+static int get_consumed_bytes(int pos, int buf_size)
+{
+    if (pos == 0)
+        pos = 1;        // avoid infinite loops (I doubt that is needed but...)
+    if (pos + 10 > buf_size)
+        pos = buf_size; // oops ;)
+
+    return pos;
+}
+
+static int output_frame(H264Context *h, AVFrame *dst, AVFrame *src)
+{
+    int i;
+    int ret = av_frame_ref(dst, src);
+    if (ret < 0)
+        return ret;
+
+    if (!h->ps.sps || !h->ps.sps->crop)
+        return 0;
+
+    for (i = 0; i < 3; i++) {
+        int hshift = (i > 0) ? h->chroma_x_shift : 0;
+        int vshift = (i > 0) ? h->chroma_y_shift : 0;
+        int off    = ((h->ps.sps->crop_left >> hshift) << h->pixel_shift) +
+                     (h->ps.sps->crop_top >> vshift) * dst->linesize[i];
+        dst->data[i] += off;
+    }
+    return 0;
+}
+
+static int h264_decode_frame(AVCodecContext *avctx, void *data,
+                             int *got_frame, AVPacket *avpkt)
+{
+    const uint8_t *buf = avpkt->data;
+    int buf_size       = avpkt->size;
+    H264Context *h     = avctx->priv_data;
+    AVFrame *pict      = data;
+    int buf_index      = 0;
+    int ret;
+    const uint8_t *new_extradata;
+    int new_extradata_size;
+
+    h->flags = avctx->flags;
+    h->setup_finished = 0;
+
+    /* end of stream, output what is still in the buffers */
+out:
+    if (buf_size == 0) {
+        H264Picture *out;
+        int i, out_idx;
+
+        h->cur_pic_ptr = NULL;
+
+        // FIXME factorize this with the output code below
+        out     = h->delayed_pic[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) {
+            ret = output_frame(h, pict, out->f);
+            if (ret < 0)
+                return ret;
+            *got_frame = 1;
+        }
+
+        return buf_index;
+    }
+
+    new_extradata_size = 0;
+    new_extradata = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA,
+                                            &new_extradata_size);
+    if (new_extradata_size > 0 && new_extradata) {
+        ret = ff_h264_decode_extradata(new_extradata, new_extradata_size,
+                                       &h->ps, &h->is_avc, &h->nal_length_size,
+                                       avctx->err_recognition, avctx);
+        if (ret < 0)
+            return ret;
+    }
+
+    buf_index = decode_nal_units(h, buf, buf_size);
+    if (buf_index < 0)
+        return AVERROR_INVALIDDATA;
+
+    if (!h->cur_pic_ptr && h->nal_unit_type == NAL_END_SEQUENCE) {
+        buf_size = 0;
+        goto out;
+    }
+
+    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && !h->cur_pic_ptr) {
+        if (avctx->skip_frame >= AVDISCARD_NONREF)
+            return 0;
+        av_log(avctx, AV_LOG_ERROR, "no frame!\n");
+        return AVERROR_INVALIDDATA;
+    }
+
+    if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) ||
+        (h->mb_y >= h->mb_height && h->mb_height)) {
+        if (avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)
+            decode_postinit(h, 1);
+
+        ff_h264_field_end(h, &h->slice_ctx[0], 0);
+
+        *got_frame = 0;
+        if (h->next_output_pic && ((avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) ||
+                                   h->next_output_pic->recovered)) {
+            if (!h->next_output_pic->recovered)
+                h->next_output_pic->f->flags |= AV_FRAME_FLAG_CORRUPT;
+
+            ret = output_frame(h, pict, h->next_output_pic->f);
+            if (ret < 0)
+                return ret;
+            *got_frame = 1;
+        }
+    }
+
+    assert(pict->buf[0] || !*got_frame);
+
+    return get_consumed_bytes(buf_index, buf_size);
+}
+
+#define OFFSET(x) offsetof(H264Context, x)
+#define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM
+static const AVOption h264_options[] = {
+    { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_INT, { .i64 = 0 }, 0, 1, VD },
+    { NULL },
+};
+
+static const AVClass h264_class = {
+    .class_name = "h264",
+    .item_name  = av_default_item_name,
+    .option     = h264_options,
+    .version    = LIBAVUTIL_VERSION_INT,
+};
+
+AVCodec ff_h264_decoder = {
+    .name                  = "h264",
+    .long_name             = NULL_IF_CONFIG_SMALL("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
+    .type                  = AVMEDIA_TYPE_VIDEO,
+    .id                    = AV_CODEC_ID_H264,
+    .priv_data_size        = sizeof(H264Context),
+    .init                  = ff_h264_decode_init,
+    .close                 = h264_decode_end,
+    .decode                = h264_decode_frame,
+    .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,
+    .caps_internal         = FF_CODEC_CAP_INIT_THREADSAFE,
+    .flush                 = flush_dpb,
+    .init_thread_copy      = ONLY_IF_THREADS_ENABLED(decode_init_thread_copy),
+    .update_thread_context = ONLY_IF_THREADS_ENABLED(ff_h264_update_thread_context),
+    .profiles              = NULL_IF_CONFIG_SMALL(ff_h264_profiles),
+    .priv_class            = &h264_class,
+};
diff --git a/libavcodec/h264dec.h b/libavcodec/h264dec.h
new file mode 100644 (file)
index 0000000..300077d
--- /dev/null
@@ -0,0 +1,938 @@
+/*
+ * H.26L/H.264/AVC/JVT/14496-10/... encoder/decoder
+ * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
+ *
+ * This file is part of Libav.
+ *
+ * Libav 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 (at your option) any later version.
+ *
+ * Libav is distributed in the hope that it will be useful,
+ * 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
+ * License along with Libav; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
+ */
+
+/**
+ * @file
+ * H.264 / AVC / MPEG-4 part10 codec.
+ * @author Michael Niedermayer <michaelni@gmx.at>
+ */
+
+#ifndef AVCODEC_H264DEC_H
+#define AVCODEC_H264DEC_H
+
+#include "libavutil/buffer.h"
+#include "libavutil/intreadwrite.h"
+#include "libavutil/thread.h"
+
+#include "cabac.h"
+#include "error_resilience.h"
+#include "h264_parse.h"
+#include "h264_sei.h"
+#include "h2645_parse.h"
+#include "h264chroma.h"
+#include "h264dsp.h"
+#include "h264pred.h"
+#include "h264qpel.h"
+#include "internal.h"
+#include "mpegutils.h"
+#include "parser.h"
+#include "qpeldsp.h"
+#include "rectangle.h"
+#include "videodsp.h"
+
+#define H264_MAX_PICTURE_COUNT 32
+
+#define MAX_SPS_COUNT          32
+#define MAX_PPS_COUNT         256
+
+#define MAX_MMCO_COUNT         66
+
+#define MAX_DELAYED_PIC_COUNT  16
+
+/* Compiling in interlaced support reduces the speed
+ * of progressive decoding by about 2%. */
+#define ALLOW_INTERLACE
+
+#define FMO 0
+
+/**
+ * The maximum number of slices supported by the decoder.
+ * must be a power of 2
+ */
+#define MAX_SLICES 32
+
+#ifdef ALLOW_INTERLACE
+#define MB_MBAFF(h)    h->mb_mbaff
+#define MB_FIELD(h)    h->mb_field_decoding_flag
+#define FRAME_MBAFF(h) h->mb_aff_frame
+#define FIELD_PICTURE(h) (h->picture_structure != PICT_FRAME)
+#define LEFT_MBS 2
+#define LTOP     0
+#define LBOT     1
+#define LEFT(i)  (i)
+#else
+#define MB_MBAFF(h)      0
+#define MB_FIELD(h)      0
+#define FRAME_MBAFF(h)   0
+#define FIELD_PICTURE(h) 0
+#undef  IS_INTERLACED
+#define IS_INTERLACED(mb_type) 0
+#define LEFT_MBS 1
+#define LTOP     0
+#define LBOT     0
+#define LEFT(i)  0
+#endif
+#define FIELD_OR_MBAFF_PICTURE(h) (FRAME_MBAFF(h) || FIELD_PICTURE(h))
+
+#ifndef CABAC
+#define CABAC(h) h->ps.pps->cabac
+#endif
+
+#define CHROMA422(h) (h->ps.sps->chroma_format_idc == 2)
+#define CHROMA444(h) (h->ps.sps->chroma_format_idc == 3)
+
+#define EXTENDED_SAR       255
+
+#define MB_TYPE_REF0       MB_TYPE_ACPRED // dirty but it fits in 16 bit
+#define MB_TYPE_8x8DCT     0x01000000
+#define IS_REF0(a)         ((a) & MB_TYPE_REF0)
+#define IS_8x8DCT(a)       ((a) & MB_TYPE_8x8DCT)
+
+#define QP_MAX_NUM (51 + 2 * 6)           // The maximum supported qp
+
+/* NAL unit types */
+enum {
+    NAL_SLICE           = 1,
+    NAL_DPA             = 2,
+    NAL_DPB             = 3,
+    NAL_DPC             = 4,
+    NAL_IDR_SLICE       = 5,
+    NAL_SEI             = 6,
+    NAL_SPS             = 7,
+    NAL_PPS             = 8,
+    NAL_AUD             = 9,
+    NAL_END_SEQUENCE    = 10,
+    NAL_END_STREAM      = 11,
+    NAL_FILLER_DATA     = 12,
+    NAL_SPS_EXT         = 13,
+    NAL_AUXILIARY_SLICE = 19,
+};
+
+/**
+ * Sequence parameter set
+ */
+typedef struct SPS {
+    unsigned int sps_id;
+    int profile_idc;
+    int level_idc;
+    int chroma_format_idc;
+    int transform_bypass;              ///< qpprime_y_zero_transform_bypass_flag
+    int log2_max_frame_num;            ///< log2_max_frame_num_minus4 + 4
+    int poc_type;                      ///< pic_order_cnt_type
+    int log2_max_poc_lsb;              ///< log2_max_pic_order_cnt_lsb_minus4
+    int delta_pic_order_always_zero_flag;
+    int offset_for_non_ref_pic;
+    int offset_for_top_to_bottom_field;
+    int poc_cycle_length;              ///< num_ref_frames_in_pic_order_cnt_cycle
+    int ref_frame_count;               ///< num_ref_frames
+    int gaps_in_frame_num_allowed_flag;
+    int mb_width;                      ///< pic_width_in_mbs_minus1 + 1
+    int mb_height;                     ///< pic_height_in_map_units_minus1 + 1
+    int frame_mbs_only_flag;
+    int mb_aff;                        ///< mb_adaptive_frame_field_flag
+    int direct_8x8_inference_flag;
+    int crop;                          ///< frame_cropping_flag
+
+    /* those 4 are already in luma samples */
+    unsigned int crop_left;            ///< frame_cropping_rect_left_offset
+    unsigned int crop_right;           ///< frame_cropping_rect_right_offset
+    unsigned int crop_top;             ///< frame_cropping_rect_top_offset
+    unsigned int crop_bottom;          ///< frame_cropping_rect_bottom_offset
+    int vui_parameters_present_flag;
+    AVRational sar;
+    int video_signal_type_present_flag;
+    int full_range;
+    int colour_description_present_flag;
+    enum AVColorPrimaries color_primaries;
+    enum AVColorTransferCharacteristic color_trc;
+    enum AVColorSpace colorspace;
+    int timing_info_present_flag;
+    uint32_t num_units_in_tick;
+    uint32_t time_scale;
+    int fixed_frame_rate_flag;
+    short offset_for_ref_frame[256]; // FIXME dyn aloc?
+    int bitstream_restriction_flag;
+    int num_reorder_frames;
+    int scaling_matrix_present;
+    uint8_t scaling_matrix4[6][16];
+    uint8_t scaling_matrix8[6][64];
+    int nal_hrd_parameters_present_flag;
+    int vcl_hrd_parameters_present_flag;
+    int pic_struct_present_flag;
+    int time_offset_length;
+    int cpb_cnt;                          ///< See H.264 E.1.2
+    int initial_cpb_removal_delay_length; ///< initial_cpb_removal_delay_length_minus1 + 1
+    int cpb_removal_delay_length;         ///< cpb_removal_delay_length_minus1 + 1
+    int dpb_output_delay_length;          ///< dpb_output_delay_length_minus1 + 1
+    int bit_depth_luma;                   ///< bit_depth_luma_minus8 + 8
+    int bit_depth_chroma;                 ///< bit_depth_chroma_minus8 + 8
+    int residual_color_transform_flag;    ///< residual_colour_transform_flag
+    int constraint_set_flags;             ///< constraint_set[0-3]_flag
+} SPS;
+
+/**
+ * Picture parameter set
+ */
+typedef struct PPS {
+    unsigned int sps_id;
+    int cabac;                  ///< entropy_coding_mode_flag
+    int pic_order_present;      ///< pic_order_present_flag
+    int slice_group_count;      ///< num_slice_groups_minus1 + 1
+    int mb_slice_group_map_type;
+    unsigned int ref_count[2];  ///< num_ref_idx_l0/1_active_minus1 + 1
+    int weighted_pred;          ///< weighted_pred_flag
+    int weighted_bipred_idc;
+    int init_qp;                ///< pic_init_qp_minus26 + 26
+    int init_qs;                ///< pic_init_qs_minus26 + 26
+    int chroma_qp_index_offset[2];
+    int deblocking_filter_parameters_present; ///< deblocking_filter_parameters_present_flag
+    int constrained_intra_pred;     ///< constrained_intra_pred_flag
+    int redundant_pic_cnt_present;  ///< redundant_pic_cnt_present_flag
+    int transform_8x8_mode;         ///< transform_8x8_mode_flag
+    uint8_t scaling_matrix4[6][16];
+    uint8_t scaling_matrix8[6][64];
+    uint8_t chroma_qp_table[2][64]; ///< pre-scaled (with chroma_qp_index_offset) version of qp_table
+    int chroma_qp_diff;
+
+    uint32_t dequant4_buffer[6][QP_MAX_NUM + 1][16];
+    uint32_t dequant8_buffer[6][QP_MAX_NUM + 1][64];
+    uint32_t(*dequant4_coeff[6])[16];
+    uint32_t(*dequant8_coeff[6])[64];
+} PPS;
+
+typedef struct H264ParamSets {
+    AVBufferRef *sps_list[MAX_SPS_COUNT];
+    AVBufferRef *pps_list[MAX_PPS_COUNT];
+
+    /* currently active parameters sets */
+    const PPS *pps;
+    // FIXME this should properly be const
+    SPS *sps;
+} H264ParamSets;
+
+/**
+ * Memory management control operation opcode.
+ */
+typedef enum MMCOOpcode {
+    MMCO_END = 0,
+    MMCO_SHORT2UNUSED,
+    MMCO_LONG2UNUSED,
+    MMCO_SHORT2LONG,
+    MMCO_SET_MAX_LONG,
+    MMCO_RESET,
+    MMCO_LONG,
+} MMCOOpcode;
+
+/**
+ * Memory management control operation.
+ */
+typedef struct MMCO {
+    MMCOOpcode opcode;
+    int short_pic_num;  ///< pic_num without wrapping (pic_num & max_pic_num)
+    int long_arg;       ///< index, pic_num, or num long refs depending on opcode
+} MMCO;
+
+typedef struct H264Picture {
+    AVFrame *f;
+    ThreadFrame tf;
+
+    AVBufferRef *qscale_table_buf;
+    int8_t *qscale_table;
+
+    AVBufferRef *motion_val_buf[2];
+    int16_t (*motion_val[2])[2];
+
+    AVBufferRef *mb_type_buf;
+    uint32_t *mb_type;
+
+    AVBufferRef *hwaccel_priv_buf;
+    void *hwaccel_picture_private; ///< hardware accelerator private data
+
+    AVBufferRef *ref_index_buf[2];
+    int8_t *ref_index[2];
+
+    int field_poc[2];       ///< top/bottom POC
+    int poc;                ///< frame POC
+    int frame_num;          ///< frame_num (raw frame_num from slice header)
+    int mmco_reset;         /**< MMCO_RESET set this 1. Reordering code must
+                                 not mix pictures before and after MMCO_RESET. */
+    int pic_id;             /**< pic_num (short -> no wrap version of pic_num,
+                                 pic_num & max_pic_num; long -> long_pic_num) */
+    int long_ref;           ///< 1->long term reference 0->short term reference
+    int ref_poc[2][2][32];  ///< POCs of the frames used as reference (FIXME need per slice)
+    int ref_count[2][2];    ///< number of entries in ref_poc         (FIXME need per slice)
+    int mbaff;              ///< 1 -> MBAFF frame 0-> not MBAFF
+    int field_picture;      ///< whether or not picture was encoded in separate fields
+
+    int reference;
+    int recovered;          ///< picture at IDR or recovery point + recovery count
+} H264Picture;
+
+typedef struct H264Ref {
+    uint8_t *data[3];
+    int linesize[3];
+
+    int reference;
+    int poc;
+    int pic_id;
+
+    H264Picture *parent;
+} H264Ref;
+
+typedef struct H264SliceContext {
+    struct H264Context *h264;
+    GetBitContext gb;
+    ERContext er;
+
+    int slice_num;
+    int slice_type;
+    int slice_type_nos;         ///< S free slice type (SI/SP are remapped to I/P)
+    int slice_type_fixed;
+
+    int qscale;
+    int chroma_qp[2];   // QPc
+    int qp_thresh;      ///< QP threshold to skip loopfilter
+    int last_qscale_diff;
+
+    // deblock
+    int deblocking_filter;          ///< disable_deblocking_filter_idc with 1 <-> 0
+    int slice_alpha_c0_offset;
+    int slice_beta_offset;
+
+    H264PredWeightTable pwt;
+
+    int prev_mb_skipped;
+    int next_mb_skipped;
+
+    int chroma_pred_mode;
+    int intra16x16_pred_mode;
+
+    int8_t intra4x4_pred_mode_cache[5 * 8];
+    int8_t(*intra4x4_pred_mode);
+
+    int topleft_mb_xy;
+    int top_mb_xy;
+    int topright_mb_xy;
+    int left_mb_xy[LEFT_MBS];
+
+    int topleft_type;
+    int top_type;
+    int topright_type;
+    int left_type[LEFT_MBS];
+
+    const uint8_t *left_block;
+    int topleft_partition;
+
+    unsigned int topleft_samples_available;
+    unsigned int top_samples_available;
+    unsigned int topright_samples_available;
+    unsigned int left_samples_available;
+
+    ptrdiff_t linesize, uvlinesize;
+    ptrdiff_t mb_linesize;  ///< may be equal to s->linesize or s->linesize * 2, for mbaff
+    ptrdiff_t mb_uvlinesize;
+
+    int mb_x, mb_y;
+    int mb_xy;
+    int resync_mb_x;
+    int resync_mb_y;
+    unsigned int first_mb_addr;
+    // index of the first MB of the next slice
+    int next_slice_idx;
+    int mb_skip_run;
+    int is_complex;
+
+    int picture_structure;
+    int mb_field_decoding_flag;
+    int mb_mbaff;               ///< mb_aff_frame && mb_field_decoding_flag
+
+    int redundant_pic_count;
+
+    /**
+     * number of neighbors (top and/or left) that used 8x8 dct
+     */
+    int neighbor_transform_size;
+
+    int direct_spatial_mv_pred;
+    int col_parity;
+    int col_fieldoff;
+
+    int cbp;
+    int top_cbp;
+    int left_cbp;
+
+    int dist_scale_factor[32];
+    int dist_scale_factor_field[2][32];
+    int map_col_to_list0[2][16 + 32];
+    int map_col_to_list0_field[2][2][16 + 32];
+
+    /**
+     * num_ref_idx_l0/1_active_minus1 + 1
+     */
+    unsigned int ref_count[2];          ///< counts frames or fields, depending on current mb mode
+    unsigned int list_count;
+    H264Ref ref_list[2][48];        /**< 0..15: frame refs, 16..47: mbaff field refs.
+                                         *   Reordered version of default_ref_list
+                                         *   according to picture reordering in slice header */
+    struct {
+        uint8_t op;
+        uint8_t val;
+    } ref_modifications[2][32];
+    int nb_ref_modifications[2];
+
+    unsigned int pps_id;
+
+    const uint8_t *intra_pcm_ptr;
+    int16_t *dc_val_base;
+
+    uint8_t *bipred_scratchpad;
+    uint8_t *edge_emu_buffer;
+    uint8_t (*top_borders[2])[(16 * 3) * 2];
+    int bipred_scratchpad_allocated;
+    int edge_emu_buffer_allocated;
+    int top_borders_allocated[2];
+
+    /**
+     * non zero coeff count cache.
+     * is 64 if not available.
+     */
+    DECLARE_ALIGNED(8, uint8_t, non_zero_count_cache)[15 * 8];
+
+    /**
+     * Motion vector cache.
+     */
+    DECLARE_ALIGNED(16, int16_t, mv_cache)[2][5 * 8][2];
+    DECLARE_ALIGNED(8,  int8_t, ref_cache)[2][5 * 8];
+    DECLARE_ALIGNED(16, uint8_t, mvd_cache)[2][5 * 8][2];
+    uint8_t direct_cache[5 * 8];
+
+    DECLARE_ALIGNED(8, uint16_t, sub_mb_type)[4];
+
+    ///< as a DCT coefficient is int32_t in high depth, we need to reserve twice the space.
+    DECLARE_ALIGNED(16, int16_t, mb)[16 * 48 * 2];
+    DECLARE_ALIGNED(16, int16_t, mb_luma_dc)[3][16 * 2];
+    ///< as mb is addressed by scantable[i] and scantable is uint8_t we can either
+    ///< check that i is not too large or ensure that there is some unused stuff after mb
+    int16_t mb_padding[256 * 2];
+
+    uint8_t (*mvd_table[2])[2];
+
+    /**
+     * Cabac
+     */
+    CABACContext cabac;
+    uint8_t cabac_state[1024];
+    int cabac_init_idc;
+
+    MMCO mmco[MAX_MMCO_COUNT];
+    int  nb_mmco;
+    int explicit_ref_marking;
+
+    int frame_num;
+    int poc_lsb;
+    int delta_poc_bottom;
+    int delta_poc[2];
+    int curr_pic_num;
+    int max_pic_num;
+} H264SliceContext;
+
+/**
+ * H264Context
+ */
+typedef struct H264Context {
+    const AVClass *class;
+    AVCodecContext *avctx;
+    VideoDSPContext vdsp;
+    H264DSPContext h264dsp;
+    H264ChromaContext h264chroma;
+    H264QpelContext h264qpel;
+
+    H264Picture DPB[H264_MAX_PICTURE_COUNT];
+    H264Picture *cur_pic_ptr;
+    H264Picture cur_pic;
+
+    H264SliceContext *slice_ctx;
+    int            nb_slice_ctx;
+
+    H2645Packet pkt;
+
+    int pixel_shift;    ///< 0 for 8-bit H.264, 1 for high-bit-depth H.264
+
+    /* coded dimensions -- 16 * mb w/h */
+    int width, height;
+    int chroma_x_shift, chroma_y_shift;
+
+    int droppable;
+    int coded_picture_number;
+
+    int context_initialized;
+    int flags;
+    int workaround_bugs;
+    /* Set when slice threading is used and at least one slice uses deblocking
+     * mode 1 (i.e. across slice boundaries). Then we disable the loop filter
+     * during normal MB decoding and execute it serially at the end.
+     */
+    int postpone_filter;
+
+    int8_t(*intra4x4_pred_mode);
+    H264PredContext hpc;
+
+    uint8_t (*non_zero_count)[48];
+
+#define LIST_NOT_USED -1 // FIXME rename?
+#define PART_NOT_AVAILABLE -2
+
+    /**
+     * block_offset[ 0..23] for frame macroblocks
+     * block_offset[24..47] for field macroblocks
+     */
+    int block_offset[2 * (16 * 3)];
+
+    uint32_t *mb2b_xy;  // FIXME are these 4 a good idea?
+    uint32_t *mb2br_xy;
+    int b_stride;       // FIXME use s->b4_stride
+
+    uint16_t *slice_table;      ///< slice_table_base + 2*mb_stride + 1
+
+    // interlacing specific flags
+    int mb_aff_frame;
+    int picture_structure;
+    int first_field;
+
+    uint8_t *list_counts;               ///< Array of list_count per MB specifying the slice type
+
+    /* 0x100 -> non null luma_dc, 0x80/0x40 -> non null chroma_dc (cb/cr), 0x?0 -> chroma_cbp(0, 1, 2), 0x0? luma_cbp */
+    uint16_t *cbp_table;
+
+    /* chroma_pred_mode for i4x4 or i16x16, else 0 */
+    uint8_t *chroma_pred_mode_table;
+    uint8_t (*mvd_table[2])[2];
+    uint8_t *direct_table;
+
+    uint8_t zigzag_scan[16];
+    uint8_t zigzag_scan8x8[64];
+    uint8_t zigzag_scan8x8_cavlc[64];
+    uint8_t field_scan[16];
+    uint8_t field_scan8x8[64];
+    uint8_t field_scan8x8_cavlc[64];
+    const uint8_t *zigzag_scan_q0;
+    const uint8_t *zigzag_scan8x8_q0;
+    const uint8_t *zigzag_scan8x8_cavlc_q0;
+    const uint8_t *field_scan_q0;
+    const uint8_t *field_scan8x8_q0;
+    const uint8_t *field_scan8x8_cavlc_q0;
+
+    int mb_y;
+    int mb_height, mb_width;
+    int mb_stride;
+    int mb_num;
+
+    // =============================================================
+    // Things below are not used in the MB or more inner code
+
+    int nal_ref_idc;
+    int nal_unit_type;
+
+    /**
+     * Used to parse AVC variant of H.264
+     */
+    int is_avc;           ///< this flag is != 0 if codec is avc1
+    int nal_length_size;  ///< Number of bytes used for nal length (1, 2 or 4)
+
+    int bit_depth_luma;         ///< luma bit depth from sps to detect changes
+    int chroma_format_idc;      ///< chroma format from sps to detect changes
+
+    H264ParamSets ps;
+
+    uint16_t *slice_table_base;
+
+    H264POCContext poc;
+
+    H264Picture *short_ref[32];
+    H264Picture *long_ref[32];
+    H264Picture *delayed_pic[MAX_DELAYED_PIC_COUNT + 2]; // FIXME size?
+    int last_pocs[MAX_DELAYED_PIC_COUNT];
+    H264Picture *next_output_pic;
+    int next_outputed_poc;
+
+    /**
+     * memory management control operations buffer.
+     */
+    MMCO mmco[MAX_MMCO_COUNT];
+    int  nb_mmco;
+    int mmco_reset;
+    int explicit_ref_marking;
+
+    int long_ref_count;     ///< number of actual long term references
+    int short_ref_count;    ///< number of actual short term references
+
+    /**
+     * @name Members for slice based multithreading
+     * @{
+     */
+    /**
+     * current slice number, used to initialize slice_num of each thread/context
+     */
+    int current_slice;
+
+    /** @} */
+
+    /**
+     * Complement sei_pic_struct
+     * SEI_PIC_STRUCT_TOP_BOTTOM and SEI_PIC_STRUCT_BOTTOM_TOP indicate interlaced frames.
+     * However, soft telecined frames may have these values.
+     * This is used in an attempt to flag soft telecine progressive.
+     */
+    int prev_interlaced_frame;
+
+    /**
+     * recovery_frame is the frame_num at which the next frame should
+     * be fully constructed.
+     *
+     * Set to -1 when not expecting a recovery point.
+     */
+    int recovery_frame;
+
+/**
+ * We have seen an IDR, so all the following frames in coded order are correctly
+ * decodable.
+ */
+#define FRAME_RECOVERED_IDR  (1 << 0)
+/**
+ * Sufficient number of frames have been decoded since a SEI recovery point,
+ * so all the following frames in presentation order are correct.
+ */
+#define FRAME_RECOVERED_SEI  (1 << 1)
+
+    int frame_recovered;    ///< Initial frame has been completely recovered
+
+    /* for frame threading, this is set to 1
+     * after finish_setup() has been called, so we cannot modify
+     * some context properties (which are supposed to stay constant between
+     * slices) anymore */
+    int setup_finished;
+
+    int enable_er;
+
+    H264SEIContext sei;
+
+    AVBufferPool *qscale_table_pool;
+    AVBufferPool *mb_type_pool;
+    AVBufferPool *motion_val_pool;
+    AVBufferPool *ref_index_pool;
+    int ref2frm[MAX_SLICES][2][64];     ///< reference to frame number lists, used in the loop filter, the first 2 are for -2,-1
+} H264Context;
+
+extern const uint16_t ff_h264_mb_sizes[4];
+
+/**
+ * Decode SPS
+ */
+int ff_h264_decode_seq_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+                                     H264ParamSets *ps);
+
+/**
+ * Decode PPS
+ */
+int ff_h264_decode_picture_parameter_set(GetBitContext *gb, AVCodecContext *avctx,
+                                         H264ParamSets *ps, int bit_length);
+
+/**
+ * Reconstruct bitstream slice_type.
+ */
+int ff_h264_get_slice_type(const H264SliceContext *sl);
+
+/**
+ * Allocate tables.
+ * needs width/height
+ */
+int ff_h264_alloc_tables(H264Context *h);
+
+int ff_h264_decode_ref_pic_list_reordering(const H264Context *h, H264SliceContext *sl);
+int ff_h264_build_ref_list(const H264Context *h, H264SliceContext *sl);
+void ff_h264_remove_all_refs(H264Context *h);
+
+/**
+ * Execute the reference picture marking (memory management control operations).
+ */
+int ff_h264_execute_ref_pic_marking(H264Context *h);
+
+int ff_h264_decode_ref_pic_marking(const H264Context *h, H264SliceContext *sl,
+                                   GetBitContext *gb);
+
+void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl);
+int ff_h264_decode_init(AVCodecContext *avctx);
+void ff_h264_decode_init_vlc(void);
+
+/**
+ * Decode a macroblock
+ * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
+ */
+int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl);
+
+/**
+ * Decode a CABAC coded macroblock
+ * @return 0 if OK, ER_AC_ERROR / ER_DC_ERROR / ER_MV_ERROR on error
+ */
+int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl);
+
+void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl);
+
+void ff_h264_init_dequant_tables(H264Context *h);
+
+void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl);
+void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl);
+void ff_h264_pred_direct_motion(const H264Context *const h, H264SliceContext *sl,
+                                int *mb_type);
+
+void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
+                            uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
+                            unsigned int linesize, unsigned int uvlinesize);
+void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y,
+                       uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr,
+                       unsigned int linesize, unsigned int uvlinesize);
+
+/*
+ * o-o o-o
+ *  / / /
+ * o-o o-o
+ *  ,---'
+ * o-o o-o
+ *  / / /
+ * o-o o-o
+ */
+
+/* Scan8 organization:
+ *    0 1 2 3 4 5 6 7
+ * 0  DY    y y y y y
+ * 1        y Y Y Y Y
+ * 2        y Y Y Y Y
+ * 3        y Y Y Y Y
+ * 4        y Y Y Y Y
+ * 5  DU    u u u u u
+ * 6        u U U U U
+ * 7        u U U U U
+ * 8        u U U U U
+ * 9        u U U U U
+ * 10 DV    v v v v v
+ * 11       v V V V V
+ * 12       v V V V V
+ * 13       v V V V V
+ * 14       v V V V V
+ * DY/DU/DV are for luma/chroma DC.
+ */
+
+#define LUMA_DC_BLOCK_INDEX   48
+#define CHROMA_DC_BLOCK_INDEX 49
+
+// This table must be here because scan8[constant] must be known at compiletime
+static const uint8_t scan8[16 * 3 + 3] = {
+    4 +  1 * 8, 5 +  1 * 8, 4 +  2 * 8, 5 +  2 * 8,
+    6 +  1 * 8, 7 +  1 * 8, 6 +  2 * 8, 7 +  2 * 8,
+    4 +  3 * 8, 5 +  3 * 8, 4 +  4 * 8, 5 +  4 * 8,
+    6 +  3 * 8, 7 +  3 * 8, 6 +  4 * 8, 7 +  4 * 8,
+    4 +  6 * 8, 5 +  6 * 8, 4 +  7 * 8, 5 +  7 * 8,
+    6 +  6 * 8, 7 +  6 * 8, 6 +  7 * 8, 7 +  7 * 8,
+    4 +  8 * 8, 5 +  8 * 8, 4 +  9 * 8, 5 +  9 * 8,
+    6 +  8 * 8, 7 +  8 * 8, 6 +  9 * 8, 7 +  9 * 8,
+    4 + 11 * 8, 5 + 11 * 8, 4 + 12 * 8, 5 + 12 * 8,
+    6 + 11 * 8, 7 + 11 * 8, 6 + 12 * 8, 7 + 12 * 8,
+    4 + 13 * 8, 5 + 13 * 8, 4 + 14 * 8, 5 + 14 * 8,
+    6 + 13 * 8, 7 + 13 * 8, 6 + 14 * 8, 7 + 14 * 8,
+    0 +  0 * 8, 0 +  5 * 8, 0 + 10 * 8
+};
+
+static av_always_inline uint32_t pack16to32(int a, int b)
+{
+#if HAVE_BIGENDIAN
+    return (b & 0xFFFF) + (a << 16);
+#else
+    return (a & 0xFFFF) + (b << 16);
+#endif
+}
+
+static av_always_inline uint16_t pack8to16(int a, int b)
+{
+#if HAVE_BIGENDIAN
+    return (b & 0xFF) + (a << 8);
+#else
+    return (a & 0xFF) + (b << 8);
+#endif
+}
+
+/**
+ * Get the chroma qp.
+ */
+static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
+{
+    return pps->chroma_qp_table[t][qscale];
+}
+
+/**
+ * Get the predicted intra4x4 prediction mode.
+ */
+static av_always_inline int pred_intra_mode(const H264Context *h,
+                                            H264SliceContext *sl, int n)
+{
+    const int index8 = scan8[n];
+    const int left   = sl->intra4x4_pred_mode_cache[index8 - 1];
+    const int top    = sl->intra4x4_pred_mode_cache[index8 - 8];
+    const int min    = FFMIN(left, top);
+
+    ff_tlog(h->avctx, "mode:%d %d min:%d\n", left, top, min);
+
+    if (min < 0)
+        return DC_PRED;
+    else
+        return min;
+}
+
+static av_always_inline void write_back_intra_pred_mode(const H264Context *h,
+                                                        H264SliceContext *sl)
+{
+    int8_t *i4x4       = sl->intra4x4_pred_mode + h->mb2br_xy[sl->mb_xy];
+    int8_t *i4x4_cache = sl->intra4x4_pred_mode_cache;
+
+    AV_COPY32(i4x4, i4x4_cache + 4 + 8 * 4);
+    i4x4[4] = i4x4_cache[7 + 8 * 3];
+    i4x4[5] = i4x4_cache[7 + 8 * 2];
+    i4x4[6] = i4x4_cache[7 + 8 * 1];
+}
+
+static av_always_inline void write_back_non_zero_count(const H264Context *h,
+                                                       H264SliceContext *sl)
+{
+    const int mb_xy    = sl->mb_xy;
+    uint8_t *nnz       = h->non_zero_count[mb_xy];
+    uint8_t *nnz_cache = sl->non_zero_count_cache;
+
+    AV_COPY32(&nnz[ 0], &nnz_cache[4 + 8 * 1]);
+    AV_COPY32(&nnz[ 4], &nnz_cache[4 + 8 * 2]);
+    AV_COPY32(&nnz[ 8], &nnz_cache[4 + 8 * 3]);
+    AV_COPY32(&nnz[12], &nnz_cache[4 + 8 * 4]);
+    AV_COPY32(&nnz[16], &nnz_cache[4 + 8 * 6]);
+    AV_COPY32(&nnz[20], &nnz_cache[4 + 8 * 7]);
+    AV_COPY32(&nnz[32], &nnz_cache[4 + 8 * 11]);
+    AV_COPY32(&nnz[36], &nnz_cache[4 + 8 * 12]);
+
+    if (!h->chroma_y_shift) {
+        AV_COPY32(&nnz[24], &nnz_cache[4 + 8 * 8]);
+        AV_COPY32(&nnz[28], &nnz_cache[4 + 8 * 9]);
+        AV_COPY32(&nnz[40], &nnz_cache[4 + 8 * 13]);
+        AV_COPY32(&nnz[44], &nnz_cache[4 + 8 * 14]);
+    }
+}
+
+static av_always_inline void write_back_motion_list(const H264Context *h,
+                                                    H264SliceContext *sl,
+                                                    int b_stride,
+                                                    int b_xy, int b8_xy,
+                                                    int mb_type, int list)
+{
+    int16_t(*mv_dst)[2] = &h->cur_pic.motion_val[list][b_xy];
+    int16_t(*mv_src)[2] = &sl->mv_cache[list][scan8[0]];
+    AV_COPY128(mv_dst + 0 * b_stride, mv_src + 8 * 0);
+    AV_COPY128(mv_dst + 1 * b_stride, mv_src + 8 * 1);
+    AV_COPY128(mv_dst + 2 * b_stride, mv_src + 8 * 2);
+    AV_COPY128(mv_dst + 3 * b_stride, mv_src + 8 * 3);
+    if (CABAC(h)) {
+        uint8_t (*mvd_dst)[2] = &sl->mvd_table[list][FMO ? 8 * sl->mb_xy
+                                                        : h->mb2br_xy[sl->mb_xy]];
+        uint8_t(*mvd_src)[2]  = &sl->mvd_cache[list][scan8[0]];
+        if (IS_SKIP(mb_type)) {
+            AV_ZERO128(mvd_dst);
+        } else {
+            AV_COPY64(mvd_dst, mvd_src + 8 * 3);
+            AV_COPY16(mvd_dst + 3 + 3, mvd_src + 3 + 8 * 0);
+            AV_COPY16(mvd_dst + 3 + 2, mvd_src + 3 + 8 * 1);
+            AV_COPY16(mvd_dst + 3 + 1, mvd_src + 3 + 8 * 2);
+        }
+    }
+
+    {
+        int8_t *ref_index = &h->cur_pic.ref_index[list][b8_xy];
+        int8_t *ref_cache = sl->ref_cache[list];
+        ref_index[0 + 0 * 2] = ref_cache[scan8[0]];
+        ref_index[1 + 0 * 2] = ref_cache[scan8[4]];
+        ref_index[0 + 1 * 2] = ref_cache[scan8[8]];
+        ref_index[1 + 1 * 2] = ref_cache[scan8[12]];
+    }
+}
+
+static av_always_inline void write_back_motion(const H264Context *h,
+                                               H264SliceContext *sl,
+                                               int mb_type)
+{
+    const int b_stride      = h->b_stride;
+    const int b_xy  = 4 * sl->mb_x + 4 * sl->mb_y * h->b_stride; // try mb2b(8)_xy
+    const int b8_xy = 4 * sl->mb_xy;
+
+    if (USES_LIST(mb_type, 0)) {
+        write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 0);
+    } else {
+        fill_rectangle(&h->cur_pic.ref_index[0][b8_xy],
+                       2, 2, 2, (uint8_t)LIST_NOT_USED, 1);
+    }
+    if (USES_LIST(mb_type, 1))
+        write_back_motion_list(h, sl, b_stride, b_xy, b8_xy, mb_type, 1);
+
+    if (sl->slice_type_nos == AV_PICTURE_TYPE_B && CABAC(h)) {
+        if (IS_8X8(mb_type)) {
+            uint8_t *direct_table = &h->direct_table[4 * sl->mb_xy];
+            direct_table[1] = sl->sub_mb_type[1] >> 1;
+            direct_table[2] = sl->sub_mb_type[2] >> 1;
+            direct_table[3] = sl->sub_mb_type[3] >> 1;
+        }
+    }
+}
+
+static av_always_inline int get_dct8x8_allowed(const H264Context *h, H264SliceContext *sl)
+{
+    if (h->ps.sps->direct_8x8_inference_flag)
+        return !(AV_RN64A(sl->sub_mb_type) &
+                 ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8) *
+                  0x0001000100010001ULL));
+    else
+        return !(AV_RN64A(sl->sub_mb_type) &
+                 ((MB_TYPE_16x8 | MB_TYPE_8x16 | MB_TYPE_8x8 | MB_TYPE_DIRECT2) *
+                  0x0001000100010001ULL));
+}
+
+int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup);
+
+int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src);
+void ff_h264_unref_picture(H264Context *h, H264Picture *pic);
+
+int ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl);
+
+void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height);
+
+int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl,
+                                const H2645NAL *nal);
+int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count);
+int ff_h264_update_thread_context(AVCodecContext *dst,
+                                  const AVCodecContext *src);
+
+void ff_h264_flush_change(H264Context *h);
+
+void ff_h264_free_tables(H264Context *h);
+
+#endif /* AVCODEC_H264DEC_H */
index 83c2a95..08a71cd 100644 (file)
@@ -27,7 +27,7 @@
 
 #include "bit_depth_template.c"
 #include "libavutil/common.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264idct.h"
 
 void FUNCC(ff_h264_idct_add)(uint8_t *_dst, int16_t *_block, int stride)
index 961ff86..d556a20 100644 (file)
@@ -41,7 +41,7 @@
 #include "libavutil/opt.h"
 
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "internal.h"
 
 #ifdef OMX_SKIP64BIT
index ce514e3..0538dbc 100644 (file)
@@ -31,7 +31,7 @@
 #include "libavutil/ppc/types_altivec.h"
 #include "libavutil/ppc/util_altivec.h"
 
-#include "libavcodec/h264.h"
+#include "libavcodec/h264dec.h"
 #include "libavcodec/h264dsp.h"
 
 #if HAVE_ALTIVEC && HAVE_BIGENDIAN
index 7f4fb81..035f9c6 100644 (file)
@@ -30,7 +30,7 @@
 
 #include "avcodec.h"
 #include "internal.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "qsv.h"
 #include "qsv_internal.h"
 #include "qsvenc.h"
index 9dc1fb5..bf68389 100644 (file)
@@ -46,7 +46,7 @@
 #include "internal.h"
 #include "avcodec.h"
 #include "mpegutils.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264data.h"
 #include "golomb.h"
 #include "hpeldsp.h"
index 094692e..d2aafac 100644 (file)
@@ -21,7 +21,7 @@
  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
  */
 
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegvideo.h"
 #include "vaapi_internal.h"
 
index a288980..95450f8 100644 (file)
@@ -25,7 +25,7 @@
 #include "libavutil/pixfmt.h"
 
 #include "avcodec.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "h264_sei.h"
 #include "internal.h"
 #include "vaapi_encode.h"
index 0925985..cd32bbb 100644 (file)
@@ -21,7 +21,7 @@
  */
 
 #include "vaapi_internal.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegutils.h"
 
 /**
index 8ae9792..037715d 100644 (file)
@@ -25,7 +25,7 @@
 #include <CoreFoundation/CFString.h>
 
 #include "libavutil/avutil.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "internal.h"
 #include "vda.h"
 #include "vda_internal.h"
index b778439..f638d20 100644 (file)
@@ -25,7 +25,7 @@
 
 #include "avcodec.h"
 #include "internal.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "vc1.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
index c34e323..34dc630 100644 (file)
@@ -25,7 +25,7 @@
 
 #include "avcodec.h"
 #include "internal.h"
-#include "h264.h"
+#include "h264dec.h"
 #include "mpegutils.h"
 #include "vdpau.h"
 #include "vdpau_internal.h"
index 76d2ab0..541ebb2 100644 (file)
@@ -23,7 +23,7 @@
 #include "libavutil/cpu.h"
 #include "libavutil/x86/asm.h"
 #include "libavutil/x86/cpu.h"
-#include "libavcodec/h264.h"
+#include "libavcodec/h264dec.h"
 #include "libavcodec/h264qpel.h"
 #include "libavcodec/pixels.h"
 #include "fpel.h"