LCOV - code coverage report
Current view: top level - libavcodec - h264_slice.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 1210 1668 72.5 %
Date: 2018-02-24 18:00:47 Functions: 28 31 90.3 %

          Line data    Source code
       1             : /*
       2             :  * H.26L/H.264/AVC/JVT/14496-10/... decoder
       3             :  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
       4             :  *
       5             :  * This file is part of FFmpeg.
       6             :  *
       7             :  * FFmpeg is free software; you can redistribute it and/or
       8             :  * modify it under the terms of the GNU Lesser General Public
       9             :  * License as published by the Free Software Foundation; either
      10             :  * version 2.1 of the License, or (at your option) any later version.
      11             :  *
      12             :  * FFmpeg is distributed in the hope that it will be useful,
      13             :  * but WITHOUT ANY WARRANTY; without even the implied warranty of
      14             :  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
      15             :  * Lesser General Public License for more details.
      16             :  *
      17             :  * You should have received a copy of the GNU Lesser General Public
      18             :  * License along with FFmpeg; if not, write to the Free Software
      19             :  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
      20             :  */
      21             : 
      22             : /**
      23             :  * @file
      24             :  * H.264 / AVC / MPEG-4 part10 codec.
      25             :  * @author Michael Niedermayer <michaelni@gmx.at>
      26             :  */
      27             : 
      28             : #include "libavutil/avassert.h"
      29             : #include "libavutil/display.h"
      30             : #include "libavutil/imgutils.h"
      31             : #include "libavutil/stereo3d.h"
      32             : #include "libavutil/timer.h"
      33             : #include "internal.h"
      34             : #include "cabac.h"
      35             : #include "cabac_functions.h"
      36             : #include "error_resilience.h"
      37             : #include "avcodec.h"
      38             : #include "h264.h"
      39             : #include "h264dec.h"
      40             : #include "h264data.h"
      41             : #include "h264chroma.h"
      42             : #include "h264_mvpred.h"
      43             : #include "h264_ps.h"
      44             : #include "golomb.h"
      45             : #include "mathops.h"
      46             : #include "mpegutils.h"
      47             : #include "mpegvideo.h"
      48             : #include "rectangle.h"
      49             : #include "thread.h"
      50             : 
      51             : static const uint8_t field_scan[16+1] = {
      52             :     0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
      53             :     0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
      54             :     2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
      55             :     3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
      56             : };
      57             : 
      58             : static const uint8_t field_scan8x8[64+1] = {
      59             :     0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
      60             :     1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
      61             :     2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
      62             :     0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
      63             :     2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
      64             :     2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
      65             :     2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
      66             :     3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
      67             :     3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
      68             :     4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
      69             :     4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
      70             :     5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
      71             :     5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
      72             :     7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
      73             :     6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
      74             :     7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
      75             : };
      76             : 
      77             : static const uint8_t field_scan8x8_cavlc[64+1] = {
      78             :     0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
      79             :     2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
      80             :     3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
      81             :     5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
      82             :     0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
      83             :     1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
      84             :     3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
      85             :     5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
      86             :     0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
      87             :     1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
      88             :     3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
      89             :     5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
      90             :     1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
      91             :     1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
      92             :     3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
      93             :     6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
      94             : };
      95             : 
      96             : // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
      97             : static const uint8_t zigzag_scan8x8_cavlc[64+1] = {
      98             :     0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
      99             :     4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
     100             :     3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
     101             :     2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
     102             :     1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
     103             :     3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
     104             :     2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
     105             :     3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
     106             :     0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
     107             :     2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
     108             :     1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
     109             :     4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
     110             :     0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
     111             :     1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
     112             :     0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
     113             :     5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
     114             : };
     115             : 
     116       25723 : static void release_unused_pictures(H264Context *h, int remove_current)
     117             : {
     118             :     int i;
     119             : 
     120             :     /* release non reference frames */
     121      951751 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     122      926028 :         if (h->DPB[i].f->buf[0] && !h->DPB[i].reference &&
     123        2480 :             (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {
     124       20528 :             ff_h264_unref_picture(h, &h->DPB[i]);
     125             :         }
     126             :     }
     127       25723 : }
     128             : 
     129       31407 : static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
     130             : {
     131       31407 :     const H264Context *h = sl->h264;
     132       31407 :     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
     133             : 
     134       31407 :     av_fast_malloc(&sl->bipred_scratchpad, &sl->bipred_scratchpad_allocated, 16 * 6 * alloc_size);
     135             :     // edge emu needs blocksize + filter length - 1
     136             :     // (= 21x21 for  H.264)
     137       31407 :     av_fast_malloc(&sl->edge_emu_buffer, &sl->edge_emu_buffer_allocated, alloc_size * 2 * 21);
     138             : 
     139       31407 :     av_fast_mallocz(&sl->top_borders[0], &sl->top_borders_allocated[0],
     140       31407 :                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
     141       31407 :     av_fast_mallocz(&sl->top_borders[1], &sl->top_borders_allocated[1],
     142       31407 :                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
     143             : 
     144       62814 :     if (!sl->bipred_scratchpad || !sl->edge_emu_buffer ||
     145       62814 :         !sl->top_borders[0]    || !sl->top_borders[1]) {
     146           0 :         av_freep(&sl->bipred_scratchpad);
     147           0 :         av_freep(&sl->edge_emu_buffer);
     148           0 :         av_freep(&sl->top_borders[0]);
     149           0 :         av_freep(&sl->top_borders[1]);
     150             : 
     151           0 :         sl->bipred_scratchpad_allocated = 0;
     152           0 :         sl->edge_emu_buffer_allocated   = 0;
     153           0 :         sl->top_borders_allocated[0]    = 0;
     154           0 :         sl->top_borders_allocated[1]    = 0;
     155           0 :         return AVERROR(ENOMEM);
     156             :     }
     157             : 
     158       31407 :     return 0;
     159             : }
     160             : 
     161         505 : static int init_table_pools(H264Context *h)
     162             : {
     163         505 :     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
     164         505 :     const int mb_array_size = h->mb_stride * h->mb_height;
     165         505 :     const int b4_stride     = h->mb_width * 4 + 1;
     166         505 :     const int b4_array_size = b4_stride * h->mb_height * 4;
     167             : 
     168         505 :     h->qscale_table_pool = av_buffer_pool_init(big_mb_num + h->mb_stride,
     169             :                                                av_buffer_allocz);
     170         505 :     h->mb_type_pool      = av_buffer_pool_init((big_mb_num + h->mb_stride) *
     171             :                                                sizeof(uint32_t), av_buffer_allocz);
     172         505 :     h->motion_val_pool   = av_buffer_pool_init(2 * (b4_array_size + 4) *
     173             :                                                sizeof(int16_t), av_buffer_allocz);
     174         505 :     h->ref_index_pool    = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz);
     175             : 
     176        1010 :     if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
     177         505 :         !h->ref_index_pool) {
     178           0 :         av_buffer_pool_uninit(&h->qscale_table_pool);
     179           0 :         av_buffer_pool_uninit(&h->mb_type_pool);
     180           0 :         av_buffer_pool_uninit(&h->motion_val_pool);
     181           0 :         av_buffer_pool_uninit(&h->ref_index_pool);
     182           0 :         return AVERROR(ENOMEM);
     183             :     }
     184             : 
     185         505 :     return 0;
     186             : }
     187             : 
     188       22489 : static int alloc_picture(H264Context *h, H264Picture *pic)
     189             : {
     190       22489 :     int i, ret = 0;
     191             : 
     192       22489 :     av_assert0(!pic->f->data[0]);
     193             : 
     194       22489 :     pic->tf.f = pic->f;
     195       22489 :     ret = ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ?
     196             :                                                    AV_GET_BUFFER_FLAG_REF : 0);
     197       22489 :     if (ret < 0)
     198           0 :         goto fail;
     199             : 
     200       22489 :     if (h->avctx->hwaccel) {
     201           0 :         const AVHWAccel *hwaccel = h->avctx->hwaccel;
     202           0 :         av_assert0(!pic->hwaccel_picture_private);
     203           0 :         if (hwaccel->frame_priv_data_size) {
     204           0 :             pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
     205           0 :             if (!pic->hwaccel_priv_buf)
     206           0 :                 return AVERROR(ENOMEM);
     207           0 :             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
     208             :         }
     209             :     }
     210             :     if (CONFIG_GRAY && !h->avctx->hwaccel && h->flags & AV_CODEC_FLAG_GRAY && pic->f->data[2]) {
     211             :         int h_chroma_shift, v_chroma_shift;
     212             :         av_pix_fmt_get_chroma_sub_sample(pic->f->format,
     213             :                                          &h_chroma_shift, &v_chroma_shift);
     214             : 
     215             :         for(i=0; i<AV_CEIL_RSHIFT(pic->f->height, v_chroma_shift); i++) {
     216             :             memset(pic->f->data[1] + pic->f->linesize[1]*i,
     217             :                    0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
     218             :             memset(pic->f->data[2] + pic->f->linesize[2]*i,
     219             :                    0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
     220             :         }
     221             :     }
     222             : 
     223       22489 :     if (!h->qscale_table_pool) {
     224         505 :         ret = init_table_pools(h);
     225         505 :         if (ret < 0)
     226           0 :             goto fail;
     227             :     }
     228             : 
     229       22489 :     pic->qscale_table_buf = av_buffer_pool_get(h->qscale_table_pool);
     230       22489 :     pic->mb_type_buf      = av_buffer_pool_get(h->mb_type_pool);
     231       22489 :     if (!pic->qscale_table_buf || !pic->mb_type_buf)
     232             :         goto fail;
     233             : 
     234       22489 :     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
     235       22489 :     pic->qscale_table = pic->qscale_table_buf->data + 2 * h->mb_stride + 1;
     236             : 
     237       67467 :     for (i = 0; i < 2; i++) {
     238       44978 :         pic->motion_val_buf[i] = av_buffer_pool_get(h->motion_val_pool);
     239       44978 :         pic->ref_index_buf[i]  = av_buffer_pool_get(h->ref_index_pool);
     240       89956 :         if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
     241             :             goto fail;
     242             : 
     243       44978 :         pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
     244       44978 :         pic->ref_index[i]  = pic->ref_index_buf[i]->data;
     245             :     }
     246             : 
     247       22489 :     return 0;
     248           0 : fail:
     249           0 :     ff_h264_unref_picture(h, pic);
     250           0 :     return (ret < 0) ? ret : AVERROR(ENOMEM);
     251             : }
     252             : 
     253       22489 : static int find_unused_picture(H264Context *h)
     254             : {
     255             :     int i;
     256             : 
     257       80112 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     258       80112 :         if (!h->DPB[i].f->buf[0])
     259       22489 :             return i;
     260             :     }
     261           0 :     return AVERROR_INVALIDDATA;
     262             : }
     263             : 
     264             : 
     265             : #define IN_RANGE(a, b, size) (((void*)(a) >= (void*)(b)) && ((void*)(a) < (void*)((b) + (size))))
     266             : 
     267             : #define REBASE_PICTURE(pic, new_ctx, old_ctx)             \
     268             :     (((pic) && (pic) >= (old_ctx)->DPB &&                       \
     269             :       (pic) < (old_ctx)->DPB + H264_MAX_PICTURE_COUNT) ?          \
     270             :      &(new_ctx)->DPB[(pic) - (old_ctx)->DPB] : NULL)
     271             : 
     272           0 : static void copy_picture_range(H264Picture **to, H264Picture **from, int count,
     273             :                                H264Context *new_base,
     274             :                                H264Context *old_base)
     275             : {
     276             :     int i;
     277             : 
     278           0 :     for (i = 0; i < count; i++) {
     279             :         av_assert1(!from[i] ||
     280             :                    IN_RANGE(from[i], old_base, 1) ||
     281             :                    IN_RANGE(from[i], old_base->DPB, H264_MAX_PICTURE_COUNT));
     282           0 :         to[i] = REBASE_PICTURE(from[i], new_base, old_base);
     283             :     }
     284           0 : }
     285             : 
     286             : static int h264_slice_header_init(H264Context *h);
     287             : 
     288           0 : int ff_h264_update_thread_context(AVCodecContext *dst,
     289             :                                   const AVCodecContext *src)
     290             : {
     291           0 :     H264Context *h = dst->priv_data, *h1 = src->priv_data;
     292           0 :     int inited = h->context_initialized, err = 0;
     293           0 :     int need_reinit = 0;
     294             :     int i, ret;
     295             : 
     296           0 :     if (dst == src)
     297           0 :         return 0;
     298             : 
     299             :     // We can't fail if SPS isn't set at it breaks current skip_frame code
     300             :     //if (!h1->ps.sps)
     301             :     //    return AVERROR_INVALIDDATA;
     302             : 
     303           0 :     if (inited &&
     304           0 :         (h->width                 != h1->width                 ||
     305           0 :          h->height                != h1->height                ||
     306           0 :          h->mb_width              != h1->mb_width              ||
     307           0 :          h->mb_height             != h1->mb_height             ||
     308           0 :          !h->ps.sps                                            ||
     309           0 :          h->ps.sps->bit_depth_luma    != h1->ps.sps->bit_depth_luma    ||
     310           0 :          h->ps.sps->chroma_format_idc != h1->ps.sps->chroma_format_idc ||
     311           0 :          h->ps.sps->colorspace        != h1->ps.sps->colorspace)) {
     312           0 :         need_reinit = 1;
     313             :     }
     314             : 
     315             :     /* copy block_offset since frame_start may not be called */
     316           0 :     memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
     317             : 
     318             :     // SPS/PPS
     319           0 :     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++) {
     320           0 :         av_buffer_unref(&h->ps.sps_list[i]);
     321           0 :         if (h1->ps.sps_list[i]) {
     322           0 :             h->ps.sps_list[i] = av_buffer_ref(h1->ps.sps_list[i]);
     323           0 :             if (!h->ps.sps_list[i])
     324           0 :                 return AVERROR(ENOMEM);
     325             :         }
     326             :     }
     327           0 :     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
     328           0 :         av_buffer_unref(&h->ps.pps_list[i]);
     329           0 :         if (h1->ps.pps_list[i]) {
     330           0 :             h->ps.pps_list[i] = av_buffer_ref(h1->ps.pps_list[i]);
     331           0 :             if (!h->ps.pps_list[i])
     332           0 :                 return AVERROR(ENOMEM);
     333             :         }
     334             :     }
     335             : 
     336           0 :     av_buffer_unref(&h->ps.pps_ref);
     337           0 :     av_buffer_unref(&h->ps.sps_ref);
     338           0 :     h->ps.pps = NULL;
     339           0 :     h->ps.sps = NULL;
     340           0 :     if (h1->ps.pps_ref) {
     341           0 :         h->ps.pps_ref = av_buffer_ref(h1->ps.pps_ref);
     342           0 :         if (!h->ps.pps_ref)
     343           0 :             return AVERROR(ENOMEM);
     344           0 :         h->ps.pps = (const PPS*)h->ps.pps_ref->data;
     345             :     }
     346           0 :     if (h1->ps.sps_ref) {
     347           0 :         h->ps.sps_ref = av_buffer_ref(h1->ps.sps_ref);
     348           0 :         if (!h->ps.sps_ref)
     349           0 :             return AVERROR(ENOMEM);
     350           0 :         h->ps.sps = (const SPS*)h->ps.sps_ref->data;
     351             :     }
     352             : 
     353           0 :     if (need_reinit || !inited) {
     354           0 :         h->width     = h1->width;
     355           0 :         h->height    = h1->height;
     356           0 :         h->mb_height = h1->mb_height;
     357           0 :         h->mb_width  = h1->mb_width;
     358           0 :         h->mb_num    = h1->mb_num;
     359           0 :         h->mb_stride = h1->mb_stride;
     360           0 :         h->b_stride  = h1->b_stride;
     361             : 
     362           0 :         if (h->context_initialized || h1->context_initialized) {
     363           0 :             if ((err = h264_slice_header_init(h)) < 0) {
     364           0 :                 av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
     365           0 :                 return err;
     366             :             }
     367             :         }
     368             : 
     369             :         /* copy block_offset since frame_start may not be called */
     370           0 :         memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
     371             :     }
     372             : 
     373           0 :     h->avctx->coded_height  = h1->avctx->coded_height;
     374           0 :     h->avctx->coded_width   = h1->avctx->coded_width;
     375           0 :     h->avctx->width         = h1->avctx->width;
     376           0 :     h->avctx->height        = h1->avctx->height;
     377           0 :     h->width_from_caller    = h1->width_from_caller;
     378           0 :     h->height_from_caller   = h1->height_from_caller;
     379           0 :     h->coded_picture_number = h1->coded_picture_number;
     380           0 :     h->first_field          = h1->first_field;
     381           0 :     h->picture_structure    = h1->picture_structure;
     382           0 :     h->mb_aff_frame         = h1->mb_aff_frame;
     383           0 :     h->droppable            = h1->droppable;
     384             : 
     385           0 :     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
     386           0 :         ff_h264_unref_picture(h, &h->DPB[i]);
     387           0 :         if (h1->DPB[i].f->buf[0] &&
     388           0 :             (ret = ff_h264_ref_picture(h, &h->DPB[i], &h1->DPB[i])) < 0)
     389           0 :             return ret;
     390             :     }
     391             : 
     392           0 :     h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
     393           0 :     ff_h264_unref_picture(h, &h->cur_pic);
     394           0 :     if (h1->cur_pic.f->buf[0]) {
     395           0 :         ret = ff_h264_ref_picture(h, &h->cur_pic, &h1->cur_pic);
     396           0 :         if (ret < 0)
     397           0 :             return ret;
     398             :     }
     399             : 
     400           0 :     h->enable_er       = h1->enable_er;
     401           0 :     h->workaround_bugs = h1->workaround_bugs;
     402           0 :     h->x264_build      = h1->x264_build;
     403           0 :     h->droppable       = h1->droppable;
     404             : 
     405             :     // extradata/NAL handling
     406           0 :     h->is_avc = h1->is_avc;
     407           0 :     h->nal_length_size = h1->nal_length_size;
     408             : 
     409           0 :     memcpy(&h->poc,        &h1->poc,        sizeof(h->poc));
     410             : 
     411           0 :     memcpy(h->short_ref,   h1->short_ref,   sizeof(h->short_ref));
     412           0 :     memcpy(h->long_ref,    h1->long_ref,    sizeof(h->long_ref));
     413           0 :     memcpy(h->delayed_pic, h1->delayed_pic, sizeof(h->delayed_pic));
     414           0 :     memcpy(h->last_pocs,   h1->last_pocs,   sizeof(h->last_pocs));
     415             : 
     416           0 :     h->next_output_pic   = h1->next_output_pic;
     417           0 :     h->next_outputed_poc = h1->next_outputed_poc;
     418             : 
     419           0 :     memcpy(h->mmco, h1->mmco, sizeof(h->mmco));
     420           0 :     h->nb_mmco         = h1->nb_mmco;
     421           0 :     h->mmco_reset      = h1->mmco_reset;
     422           0 :     h->explicit_ref_marking = h1->explicit_ref_marking;
     423           0 :     h->long_ref_count  = h1->long_ref_count;
     424           0 :     h->short_ref_count = h1->short_ref_count;
     425             : 
     426           0 :     copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
     427           0 :     copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
     428           0 :     copy_picture_range(h->delayed_pic, h1->delayed_pic,
     429             :                        MAX_DELAYED_PIC_COUNT + 2, h, h1);
     430             : 
     431           0 :     h->frame_recovered       = h1->frame_recovered;
     432             : 
     433           0 :     if (!h->cur_pic_ptr)
     434           0 :         return 0;
     435             : 
     436           0 :     if (!h->droppable) {
     437           0 :         err = ff_h264_execute_ref_pic_marking(h);
     438           0 :         h->poc.prev_poc_msb = h->poc.poc_msb;
     439           0 :         h->poc.prev_poc_lsb = h->poc.poc_lsb;
     440             :     }
     441           0 :     h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
     442           0 :     h->poc.prev_frame_num        = h->poc.frame_num;
     443             : 
     444           0 :     h->recovery_frame        = h1->recovery_frame;
     445             : 
     446           0 :     return err;
     447             : }
     448             : 
     449       22489 : static int h264_frame_start(H264Context *h)
     450             : {
     451             :     H264Picture *pic;
     452             :     int i, ret;
     453       22489 :     const int pixel_shift = h->pixel_shift;
     454       67467 :     int c[4] = {
     455       22489 :         1<<(h->ps.sps->bit_depth_luma-1),
     456       22489 :         1<<(h->ps.sps->bit_depth_chroma-1),
     457       22489 :         1<<(h->ps.sps->bit_depth_chroma-1),
     458             :         -1
     459             :     };
     460             : 
     461       22489 :     if (!ff_thread_can_start_frame(h->avctx)) {
     462           0 :         av_log(h->avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
     463           0 :         return -1;
     464             :     }
     465             : 
     466       22489 :     release_unused_pictures(h, 1);
     467       22489 :     h->cur_pic_ptr = NULL;
     468             : 
     469       22489 :     i = find_unused_picture(h);
     470       22489 :     if (i < 0) {
     471           0 :         av_log(h->avctx, AV_LOG_ERROR, "no frame buffer available\n");
     472           0 :         return i;
     473             :     }
     474       22489 :     pic = &h->DPB[i];
     475             : 
     476       22489 :     pic->reference              = h->droppable ? 0 : h->picture_structure;
     477       22489 :     pic->f->coded_picture_number = h->coded_picture_number++;
     478       22489 :     pic->field_picture          = h->picture_structure != PICT_FRAME;
     479       22489 :     pic->frame_num               = h->poc.frame_num;
     480             :     /*
     481             :      * Zero key_frame here; IDR markings per slice in frame or fields are ORed
     482             :      * in later.
     483             :      * See decode_nal_units().
     484             :      */
     485       22489 :     pic->f->key_frame = 0;
     486       22489 :     pic->mmco_reset  = 0;
     487       22489 :     pic->recovered   = 0;
     488       22489 :     pic->invalid_gap = 0;
     489       22489 :     pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
     490             : 
     491       22489 :     pic->f->pict_type = h->slice_ctx[0].slice_type;
     492             : 
     493       22489 :     pic->f->crop_left   = h->crop_left;
     494       22489 :     pic->f->crop_right  = h->crop_right;
     495       22489 :     pic->f->crop_top    = h->crop_top;
     496       22489 :     pic->f->crop_bottom = h->crop_bottom;
     497             : 
     498       22489 :     if ((ret = alloc_picture(h, pic)) < 0)
     499           0 :         return ret;
     500       22489 :     if(!h->frame_recovered && !h->avctx->hwaccel)
     501         608 :         ff_color_frame(pic->f, c);
     502             : 
     503       22489 :     h->cur_pic_ptr = pic;
     504       22489 :     ff_h264_unref_picture(h, &h->cur_pic);
     505             :     if (CONFIG_ERROR_RESILIENCE) {
     506       22489 :         ff_h264_set_erpic(&h->slice_ctx[0].er.cur_pic, NULL);
     507             :     }
     508             : 
     509       22489 :     if ((ret = ff_h264_ref_picture(h, &h->cur_pic, h->cur_pic_ptr)) < 0)
     510           0 :         return ret;
     511             : 
     512       44978 :     for (i = 0; i < h->nb_slice_ctx; i++) {
     513       22489 :         h->slice_ctx[i].linesize   = h->cur_pic_ptr->f->linesize[0];
     514       22489 :         h->slice_ctx[i].uvlinesize = h->cur_pic_ptr->f->linesize[1];
     515             :     }
     516             : 
     517       22489 :     if (CONFIG_ERROR_RESILIENCE && h->enable_er) {
     518       22489 :         ff_er_frame_start(&h->slice_ctx[0].er);
     519       22489 :         ff_h264_set_erpic(&h->slice_ctx[0].er.last_pic, NULL);
     520       22489 :         ff_h264_set_erpic(&h->slice_ctx[0].er.next_pic, NULL);
     521             :     }
     522             : 
     523      382313 :     for (i = 0; i < 16; i++) {
     524      359824 :         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
     525      359824 :         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
     526             :     }
     527      382313 :     for (i = 0; i < 16; i++) {
     528      719648 :         h->block_offset[16 + i]      =
     529      719648 :         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
     530      719648 :         h->block_offset[48 + 16 + i] =
     531      719648 :         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
     532             :     }
     533             : 
     534             :     /* We mark the current picture as non-reference after allocating it, so
     535             :      * that if we break out due to an error it can be released automatically
     536             :      * in the next ff_mpv_frame_start().
     537             :      */
     538       22489 :     h->cur_pic_ptr->reference = 0;
     539             : 
     540       22489 :     h->cur_pic_ptr->field_poc[0] = h->cur_pic_ptr->field_poc[1] = INT_MAX;
     541             : 
     542       22489 :     h->next_output_pic = NULL;
     543             : 
     544       22489 :     h->postpone_filter = 0;
     545             : 
     546       22489 :     h->mb_aff_frame = h->ps.sps->mb_aff && (h->picture_structure == PICT_FRAME);
     547             : 
     548       22489 :     if (h->sei.unregistered.x264_build >= 0)
     549        1215 :         h->x264_build = h->sei.unregistered.x264_build;
     550             : 
     551             :     assert(h->cur_pic_ptr->long_ref == 0);
     552             : 
     553       22489 :     return 0;
     554             : }
     555             : 
     556    10341544 : static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
     557             :                                               uint8_t *src_y,
     558             :                                               uint8_t *src_cb, uint8_t *src_cr,
     559             :                                               int linesize, int uvlinesize,
     560             :                                               int simple)
     561             : {
     562             :     uint8_t *top_border;
     563    10341544 :     int top_idx = 1;
     564    10341544 :     const int pixel_shift = h->pixel_shift;
     565    10341544 :     int chroma444 = CHROMA444(h);
     566    10341544 :     int chroma422 = CHROMA422(h);
     567             : 
     568    10341544 :     src_y  -= linesize;
     569    10341544 :     src_cb -= uvlinesize;
     570    10341544 :     src_cr -= uvlinesize;
     571             : 
     572    10341544 :     if (!simple && FRAME_MBAFF(h)) {
     573     1576140 :         if (sl->mb_y & 1) {
     574      788070 :             if (!MB_MBAFF(sl)) {
     575      546813 :                 top_border = sl->top_borders[0][sl->mb_x];
     576      546813 :                 AV_COPY128(top_border, src_y + 15 * linesize);
     577      546813 :                 if (pixel_shift)
     578      213139 :                     AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
     579             :                 if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     580      546813 :                     if (chroma444) {
     581           0 :                         if (pixel_shift) {
     582           0 :                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
     583           0 :                             AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
     584           0 :                             AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
     585           0 :                             AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
     586             :                         } else {
     587           0 :                             AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
     588           0 :                             AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
     589             :                         }
     590      546813 :                     } else if (chroma422) {
     591      106510 :                         if (pixel_shift) {
     592      106510 :                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
     593      106510 :                             AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
     594             :                         } else {
     595           0 :                             AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
     596           0 :                             AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
     597             :                         }
     598             :                     } else {
     599      440303 :                         if (pixel_shift) {
     600      106629 :                             AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
     601      106629 :                             AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
     602             :                         } else {
     603      333674 :                             AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
     604      333674 :                             AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
     605             :                         }
     606             :                     }
     607             :                 }
     608             :             }
     609      788070 :         } else if (MB_MBAFF(sl)) {
     610      241257 :             top_idx = 0;
     611             :         } else
     612      546813 :             return;
     613             :     }
     614             : 
     615     9794731 :     top_border = sl->top_borders[top_idx][sl->mb_x];
     616             :     /* There are two lines saved, the line above the top macroblock
     617             :      * of a pair, and the line above the bottom macroblock. */
     618     9794731 :     AV_COPY128(top_border, src_y + 16 * linesize);
     619     9794731 :     if (pixel_shift)
     620     1300901 :         AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
     621             : 
     622             :     if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
     623     9794731 :         if (chroma444) {
     624       36120 :             if (pixel_shift) {
     625       19800 :                 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
     626       19800 :                 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
     627       19800 :                 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
     628       19800 :                 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
     629             :             } else {
     630       16320 :                 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
     631       16320 :                 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
     632             :             }
     633     9758611 :         } else if (chroma422) {
     634      588635 :             if (pixel_shift) {
     635      584675 :                 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
     636      584675 :                 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
     637             :             } else {
     638        3960 :                 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
     639        3960 :                 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
     640             :             }
     641             :         } else {
     642     9169976 :             if (pixel_shift) {
     643      696426 :                 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
     644      696426 :                 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
     645             :             } else {
     646     8473550 :                 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
     647     8473550 :                 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
     648             :             }
     649             :         }
     650             :     }
     651             : }
     652             : 
     653             : /**
     654             :  * Initialize implicit_weight table.
     655             :  * @param field  0/1 initialize the weight for interlaced MBAFF
     656             :  *                -1 initializes the rest
     657             :  */
     658         754 : static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
     659             : {
     660             :     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
     661             : 
     662        2262 :     for (i = 0; i < 2; i++) {
     663        1508 :         sl->pwt.luma_weight_flag[i]   = 0;
     664        1508 :         sl->pwt.chroma_weight_flag[i] = 0;
     665             :     }
     666             : 
     667         754 :     if (field < 0) {
     668         732 :         if (h->picture_structure == PICT_FRAME) {
     669         732 :             cur_poc = h->cur_pic_ptr->poc;
     670             :         } else {
     671           0 :             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
     672             :         }
     673         827 :         if (sl->ref_count[0] == 1 && sl->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
     674          95 :             sl->ref_list[0][0].poc + (int64_t)sl->ref_list[1][0].poc == 2 * cur_poc) {
     675          33 :             sl->pwt.use_weight        = 0;
     676          33 :             sl->pwt.use_weight_chroma = 0;
     677          33 :             return;
     678             :         }
     679         699 :         ref_start  = 0;
     680         699 :         ref_count0 = sl->ref_count[0];
     681         699 :         ref_count1 = sl->ref_count[1];
     682             :     } else {
     683          22 :         cur_poc    = h->cur_pic_ptr->field_poc[field];
     684          22 :         ref_start  = 16;
     685          22 :         ref_count0 = 16 + 2 * sl->ref_count[0];
     686          22 :         ref_count1 = 16 + 2 * sl->ref_count[1];
     687             :     }
     688             : 
     689         721 :     sl->pwt.use_weight               = 2;
     690         721 :     sl->pwt.use_weight_chroma        = 2;
     691         721 :     sl->pwt.luma_log2_weight_denom   = 5;
     692         721 :     sl->pwt.chroma_log2_weight_denom = 5;
     693             : 
     694        3772 :     for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
     695        3051 :         int64_t poc0 = sl->ref_list[0][ref0].poc;
     696        7124 :         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
     697        4073 :             int w = 32;
     698        4073 :             if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
     699        4073 :                 int poc1 = sl->ref_list[1][ref1].poc;
     700        4073 :                 int td   = av_clip_int8(poc1 - poc0);
     701        4073 :                 if (td) {
     702        4007 :                     int tb = av_clip_int8(cur_poc - poc0);
     703        4007 :                     int tx = (16384 + (FFABS(td) >> 1)) / td;
     704        4007 :                     int dist_scale_factor = (tb * tx + 32) >> 8;
     705        4007 :                     if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
     706        4004 :                         w = 64 - dist_scale_factor;
     707             :                 }
     708             :             }
     709        4073 :             if (field < 0) {
     710        3841 :                 sl->pwt.implicit_weight[ref0][ref1][0] =
     711        3841 :                 sl->pwt.implicit_weight[ref0][ref1][1] = w;
     712             :             } else {
     713         232 :                 sl->pwt.implicit_weight[ref0][ref1][field] = w;
     714             :             }
     715             :         }
     716             :     }
     717             : }
     718             : 
     719             : /**
     720             :  * initialize scan tables
     721             :  */
     722         505 : static void init_scan_tables(H264Context *h)
     723             : {
     724             :     int i;
     725        8585 :     for (i = 0; i < 16; i++) {
     726             : #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
     727        8080 :         h->zigzag_scan[i] = TRANSPOSE(ff_zigzag_scan[i]);
     728        8080 :         h->field_scan[i]  = TRANSPOSE(field_scan[i]);
     729             : #undef TRANSPOSE
     730             :     }
     731       32825 :     for (i = 0; i < 64; i++) {
     732             : #define TRANSPOSE(x) ((x) >> 3) | (((x) & 7) << 3)
     733       32320 :         h->zigzag_scan8x8[i]       = TRANSPOSE(ff_zigzag_direct[i]);
     734       32320 :         h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
     735       32320 :         h->field_scan8x8[i]        = TRANSPOSE(field_scan8x8[i]);
     736       32320 :         h->field_scan8x8_cavlc[i]  = TRANSPOSE(field_scan8x8_cavlc[i]);
     737             : #undef TRANSPOSE
     738             :     }
     739         505 :     if (h->ps.sps->transform_bypass) { // FIXME same ugly
     740          12 :         memcpy(h->zigzag_scan_q0          , ff_zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
     741          12 :         memcpy(h->zigzag_scan8x8_q0       , ff_zigzag_direct        , sizeof(h->zigzag_scan8x8_q0      ));
     742          12 :         memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc    , sizeof(h->zigzag_scan8x8_cavlc_q0));
     743          12 :         memcpy(h->field_scan_q0           , field_scan              , sizeof(h->field_scan_q0          ));
     744          12 :         memcpy(h->field_scan8x8_q0        , field_scan8x8           , sizeof(h->field_scan8x8_q0       ));
     745          12 :         memcpy(h->field_scan8x8_cavlc_q0  , field_scan8x8_cavlc     , sizeof(h->field_scan8x8_cavlc_q0 ));
     746             :     } else {
     747         493 :         memcpy(h->zigzag_scan_q0          , h->zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
     748         493 :         memcpy(h->zigzag_scan8x8_q0       , h->zigzag_scan8x8       , sizeof(h->zigzag_scan8x8_q0      ));
     749         493 :         memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
     750         493 :         memcpy(h->field_scan_q0           , h->field_scan           , sizeof(h->field_scan_q0          ));
     751         493 :         memcpy(h->field_scan8x8_q0        , h->field_scan8x8        , sizeof(h->field_scan8x8_q0       ));
     752         493 :         memcpy(h->field_scan8x8_cavlc_q0  , h->field_scan8x8_cavlc  , sizeof(h->field_scan8x8_cavlc_q0 ));
     753             :     }
     754         505 : }
     755             : 
     756       25332 : static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
     757             : {
     758             : #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
     759             :                      (CONFIG_H264_D3D11VA_HWACCEL * 2) + \
     760             :                      CONFIG_H264_NVDEC_HWACCEL + \
     761             :                      CONFIG_H264_VAAPI_HWACCEL + \
     762             :                      CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \
     763             :                      CONFIG_H264_VDPAU_HWACCEL)
     764       25332 :     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
     765       25332 :     const enum AVPixelFormat *choices = pix_fmts;
     766             :     int i;
     767             : 
     768       25332 :     switch (h->ps.sps->bit_depth_luma) {
     769         155 :     case 9:
     770         155 :         if (CHROMA444(h)) {
     771           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     772           0 :                 *fmt++ = AV_PIX_FMT_GBRP9;
     773             :             } else
     774           0 :                 *fmt++ = AV_PIX_FMT_YUV444P9;
     775         155 :         } else if (CHROMA422(h))
     776          52 :             *fmt++ = AV_PIX_FMT_YUV422P9;
     777             :         else
     778         103 :             *fmt++ = AV_PIX_FMT_YUV420P9;
     779         155 :         break;
     780         355 :     case 10:
     781         355 :         if (CHROMA444(h)) {
     782          51 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     783           0 :                 *fmt++ = AV_PIX_FMT_GBRP10;
     784             :             } else
     785          51 :                 *fmt++ = AV_PIX_FMT_YUV444P10;
     786         304 :         } else if (CHROMA422(h))
     787         164 :             *fmt++ = AV_PIX_FMT_YUV422P10;
     788             :         else
     789         140 :             *fmt++ = AV_PIX_FMT_YUV420P10;
     790         355 :         break;
     791           0 :     case 12:
     792           0 :         if (CHROMA444(h)) {
     793           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     794           0 :                 *fmt++ = AV_PIX_FMT_GBRP12;
     795             :             } else
     796           0 :                 *fmt++ = AV_PIX_FMT_YUV444P12;
     797           0 :         } else if (CHROMA422(h))
     798           0 :             *fmt++ = AV_PIX_FMT_YUV422P12;
     799             :         else
     800           0 :             *fmt++ = AV_PIX_FMT_YUV420P12;
     801           0 :         break;
     802           0 :     case 14:
     803           0 :         if (CHROMA444(h)) {
     804           0 :             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
     805           0 :                 *fmt++ = AV_PIX_FMT_GBRP14;
     806             :             } else
     807           0 :                 *fmt++ = AV_PIX_FMT_YUV444P14;
     808           0 :         } else if (CHROMA422(h))
     809           0 :             *fmt++ = AV_PIX_FMT_YUV422P14;
     810             :         else
     811           0 :             *fmt++ = AV_PIX_FMT_YUV420P14;
     812           0 :         break;
     813       24822 :     case 8:
     814             : #if CONFIG_H264_VDPAU_HWACCEL
     815             :         *fmt++ = AV_PIX_FMT_VDPAU;
     816             : #endif
     817             : #if CONFIG_H264_NVDEC_HWACCEL
     818       24822 :         *fmt++ = AV_PIX_FMT_CUDA;
     819             : #endif
     820       24822 :         if (CHROMA444(h)) {
     821         397 :             if (h->avctx->colorspace == AVCOL_SPC_RGB)
     822           0 :                 *fmt++ = AV_PIX_FMT_GBRP;
     823         397 :             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     824           0 :                 *fmt++ = AV_PIX_FMT_YUVJ444P;
     825             :             else
     826         397 :                 *fmt++ = AV_PIX_FMT_YUV444P;
     827       24425 :         } else if (CHROMA422(h)) {
     828          22 :             if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     829           0 :                 *fmt++ = AV_PIX_FMT_YUVJ422P;
     830             :             else
     831          22 :                 *fmt++ = AV_PIX_FMT_YUV422P;
     832             :         } else {
     833             : #if CONFIG_H264_DXVA2_HWACCEL
     834             :             *fmt++ = AV_PIX_FMT_DXVA2_VLD;
     835             : #endif
     836             : #if CONFIG_H264_D3D11VA_HWACCEL
     837             :             *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
     838             :             *fmt++ = AV_PIX_FMT_D3D11;
     839             : #endif
     840             : #if CONFIG_H264_VAAPI_HWACCEL
     841             :             *fmt++ = AV_PIX_FMT_VAAPI;
     842             : #endif
     843             : #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
     844             :             *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
     845             : #endif
     846       24403 :             if (h->avctx->codec->pix_fmts)
     847           0 :                 choices = h->avctx->codec->pix_fmts;
     848       24403 :             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
     849           3 :                 *fmt++ = AV_PIX_FMT_YUVJ420P;
     850             :             else
     851       24400 :                 *fmt++ = AV_PIX_FMT_YUV420P;
     852             :         }
     853       24822 :         break;
     854           0 :     default:
     855           0 :         av_log(h->avctx, AV_LOG_ERROR,
     856           0 :                "Unsupported bit depth %d\n", h->ps.sps->bit_depth_luma);
     857           0 :         return AVERROR_INVALIDDATA;
     858             :     }
     859             : 
     860       25332 :     *fmt = AV_PIX_FMT_NONE;
     861             : 
     862       50662 :     for (i=0; choices[i] != AV_PIX_FMT_NONE; i++)
     863       50154 :         if (choices[i] == h->avctx->pix_fmt && !force_callback)
     864       24824 :             return choices[i];
     865         508 :     return ff_thread_get_format(h->avctx, choices);
     866             : }
     867             : 
     868             : /* export coded and cropped frame dimensions to AVCodecContext */
     869       25097 : static int init_dimensions(H264Context *h)
     870             : {
     871       25097 :     const SPS *sps = (const SPS*)h->ps.sps;
     872       25097 :     int cr = sps->crop_right;
     873       25097 :     int cl = sps->crop_left;
     874       25097 :     int ct = sps->crop_top;
     875       25097 :     int cb = sps->crop_bottom;
     876       25097 :     int width  = h->width  - (cr + cl);
     877       25097 :     int height = h->height - (ct + cb);
     878       25097 :     av_assert0(sps->crop_right + sps->crop_left < (unsigned)h->width);
     879       25097 :     av_assert0(sps->crop_top + sps->crop_bottom < (unsigned)h->height);
     880             : 
     881             :     /* handle container cropping */
     882       48014 :     if (h->width_from_caller > 0 && h->height_from_caller > 0     &&
     883       68749 :         !sps->crop_top && !sps->crop_left                         &&
     884       45827 :         FFALIGN(h->width_from_caller,  16) == FFALIGN(width,  16) &&
     885       45822 :         FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16) &&
     886       45822 :         h->width_from_caller  <= width &&
     887       22911 :         h->height_from_caller <= height) {
     888       22910 :         width  = h->width_from_caller;
     889       22910 :         height = h->height_from_caller;
     890       22910 :         cl = 0;
     891       22910 :         ct = 0;
     892       22910 :         cr = h->width - width;
     893       22910 :         cb = h->height - height;
     894             :     } else {
     895        2187 :         h->width_from_caller  = 0;
     896        2187 :         h->height_from_caller = 0;
     897             :     }
     898             : 
     899       25097 :     h->avctx->coded_width  = h->width;
     900       25097 :     h->avctx->coded_height = h->height;
     901       25097 :     h->avctx->width        = width;
     902       25097 :     h->avctx->height       = height;
     903       25097 :     h->crop_right          = cr;
     904       25097 :     h->crop_left           = cl;
     905       25097 :     h->crop_top            = ct;
     906       25097 :     h->crop_bottom         = cb;
     907             : 
     908       25097 :     return 0;
     909             : }
     910             : 
     911         505 : static int h264_slice_header_init(H264Context *h)
     912             : {
     913         505 :     const SPS *sps = h->ps.sps;
     914             :     int i, ret;
     915             : 
     916         505 :     ff_set_sar(h->avctx, sps->sar);
     917         505 :     av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
     918             :                                      &h->chroma_x_shift, &h->chroma_y_shift);
     919             : 
     920         505 :     if (sps->timing_info_present_flag) {
     921         103 :         int64_t den = sps->time_scale;
     922         103 :         if (h->x264_build < 44U)
     923           0 :             den *= 2;
     924         103 :         av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
     925         103 :                   sps->num_units_in_tick * h->avctx->ticks_per_frame, den, 1 << 30);
     926             :     }
     927             : 
     928         505 :     ff_h264_free_tables(h);
     929             : 
     930         505 :     h->first_field           = 0;
     931         505 :     h->prev_interlaced_frame = 1;
     932             : 
     933         505 :     init_scan_tables(h);
     934         505 :     ret = ff_h264_alloc_tables(h);
     935         505 :     if (ret < 0) {
     936           0 :         av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
     937           0 :         goto fail;
     938             :     }
     939             : 
     940        1010 :     if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
     941        1010 :         sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13
     942             :     ) {
     943           0 :         av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
     944             :                sps->bit_depth_luma);
     945           0 :         ret = AVERROR_INVALIDDATA;
     946           0 :         goto fail;
     947             :     }
     948             : 
     949         505 :     h->cur_bit_depth_luma         =
     950         505 :     h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
     951         505 :     h->cur_chroma_format_idc      = sps->chroma_format_idc;
     952         505 :     h->pixel_shift                = sps->bit_depth_luma > 8;
     953         505 :     h->chroma_format_idc          = sps->chroma_format_idc;
     954         505 :     h->bit_depth_luma             = sps->bit_depth_luma;
     955             : 
     956         505 :     ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
     957             :                     sps->chroma_format_idc);
     958         505 :     ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
     959         505 :     ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
     960         505 :     ff_h264_pred_init(&h->hpc, h->avctx->codec_id, sps->bit_depth_luma,
     961             :                       sps->chroma_format_idc);
     962         505 :     ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
     963             : 
     964         505 :     if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
     965         505 :         ret = ff_h264_slice_context_init(h, &h->slice_ctx[0]);
     966         505 :         if (ret < 0) {
     967           0 :             av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
     968           0 :             goto fail;
     969             :         }
     970             :     } else {
     971           0 :         for (i = 0; i < h->nb_slice_ctx; i++) {
     972           0 :             H264SliceContext *sl = &h->slice_ctx[i];
     973             : 
     974           0 :             sl->h264               = h;
     975           0 :             sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
     976           0 :             sl->mvd_table[0]       = h->mvd_table[0]       + i * 8 * 2 * h->mb_stride;
     977           0 :             sl->mvd_table[1]       = h->mvd_table[1]       + i * 8 * 2 * h->mb_stride;
     978             : 
     979           0 :             if ((ret = ff_h264_slice_context_init(h, sl)) < 0) {
     980           0 :                 av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
     981           0 :                 goto fail;
     982             :             }
     983             :         }
     984             :     }
     985             : 
     986         505 :     h->context_initialized = 1;
     987             : 
     988         505 :     return 0;
     989           0 : fail:
     990           0 :     ff_h264_free_tables(h);
     991           0 :     h->context_initialized = 0;
     992           0 :     return ret;
     993             : }
     994             : 
     995       49654 : static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
     996             : {
     997       49654 :     switch (a) {
     998           2 :     case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
     999           0 :     case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
    1000           0 :     case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
    1001       49652 :     default:
    1002       49652 :         return a;
    1003             :     }
    1004             : }
    1005             : 
    1006       25097 : static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
    1007             : {
    1008             :     const SPS *sps;
    1009       25097 :     int needs_reinit = 0, must_reinit, ret;
    1010             : 
    1011       25097 :     if (first_slice) {
    1012       24904 :         av_buffer_unref(&h->ps.pps_ref);
    1013       24904 :         h->ps.pps = NULL;
    1014       24904 :         h->ps.pps_ref = av_buffer_ref(h->ps.pps_list[sl->pps_id]);
    1015       24904 :         if (!h->ps.pps_ref)
    1016           0 :             return AVERROR(ENOMEM);
    1017       24904 :         h->ps.pps = (const PPS*)h->ps.pps_ref->data;
    1018             :     }
    1019             : 
    1020       25097 :     if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
    1021         510 :         av_buffer_unref(&h->ps.sps_ref);
    1022         510 :         h->ps.sps = NULL;
    1023         510 :         h->ps.sps_ref = av_buffer_ref(h->ps.sps_list[h->ps.pps->sps_id]);
    1024         510 :         if (!h->ps.sps_ref)
    1025           0 :             return AVERROR(ENOMEM);
    1026         510 :         h->ps.sps = (const SPS*)h->ps.sps_ref->data;
    1027             : 
    1028         517 :         if (h->mb_width  != h->ps.sps->mb_width ||
    1029          14 :             h->mb_height != h->ps.sps->mb_height ||
    1030          13 :             h->cur_bit_depth_luma    != h->ps.sps->bit_depth_luma ||
    1031           6 :             h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
    1032             :         )
    1033         505 :             needs_reinit = 1;
    1034             : 
    1035         519 :         if (h->bit_depth_luma    != h->ps.sps->bit_depth_luma ||
    1036           9 :             h->chroma_format_idc != h->ps.sps->chroma_format_idc)
    1037         502 :             needs_reinit         = 1;
    1038             :     }
    1039       25097 :     sps = h->ps.sps;
    1040             : 
    1041       49701 :     must_reinit = (h->context_initialized &&
    1042       24598 :                     (   16*sps->mb_width != h->avctx->coded_width
    1043       24594 :                      || 16*sps->mb_height != h->avctx->coded_height
    1044       24594 :                      || h->cur_bit_depth_luma    != sps->bit_depth_luma
    1045       24593 :                      || h->cur_chroma_format_idc != sps->chroma_format_idc
    1046       24592 :                      || h->mb_width  != sps->mb_width
    1047       24592 :                      || h->mb_height != sps->mb_height
    1048             :                     ));
    1049       25097 :     if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
    1050       24827 :         || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
    1051         273 :         must_reinit = 1;
    1052             : 
    1053       25097 :     if (first_slice && av_cmp_q(sps->sar, h->avctx->sample_aspect_ratio))
    1054          37 :         must_reinit = 1;
    1055             : 
    1056       25097 :     if (!h->setup_finished) {
    1057       25097 :         h->avctx->profile = ff_h264_get_profile(sps);
    1058       25097 :         h->avctx->level   = sps->level_idc;
    1059       25097 :         h->avctx->refs    = sps->ref_frame_count;
    1060             : 
    1061       25097 :         h->mb_width  = sps->mb_width;
    1062       25097 :         h->mb_height = sps->mb_height;
    1063       25097 :         h->mb_num    = h->mb_width * h->mb_height;
    1064       25097 :         h->mb_stride = h->mb_width + 1;
    1065             : 
    1066       25097 :         h->b_stride = h->mb_width * 4;
    1067             : 
    1068       25097 :         h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p
    1069             : 
    1070       25097 :         h->width  = 16 * h->mb_width;
    1071       25097 :         h->height = 16 * h->mb_height;
    1072             : 
    1073       25097 :         ret = init_dimensions(h);
    1074       25097 :         if (ret < 0)
    1075           0 :             return ret;
    1076             : 
    1077       25097 :         if (sps->video_signal_type_present_flag) {
    1078        1338 :             h->avctx->color_range = sps->full_range > 0 ? AVCOL_RANGE_JPEG
    1079         669 :                                                         : AVCOL_RANGE_MPEG;
    1080         669 :             if (sps->colour_description_present_flag) {
    1081         571 :                 if (h->avctx->colorspace != sps->colorspace)
    1082          14 :                     needs_reinit = 1;
    1083         571 :                 h->avctx->color_primaries = sps->color_primaries;
    1084         571 :                 h->avctx->color_trc       = sps->color_trc;
    1085         571 :                 h->avctx->colorspace      = sps->colorspace;
    1086             :             }
    1087             :         }
    1088             :     }
    1089             : 
    1090       25097 :     if (!h->context_initialized || must_reinit || needs_reinit) {
    1091         505 :         int flush_changes = h->context_initialized;
    1092         505 :         h->context_initialized = 0;
    1093         505 :         if (sl != h->slice_ctx) {
    1094           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1095             :                    "changing width %d -> %d / height %d -> %d on "
    1096             :                    "slice %d\n",
    1097           0 :                    h->width, h->avctx->coded_width,
    1098           0 :                    h->height, h->avctx->coded_height,
    1099           0 :                    h->current_slice + 1);
    1100           0 :             return AVERROR_INVALIDDATA;
    1101             :         }
    1102             : 
    1103             :         av_assert1(first_slice);
    1104             : 
    1105         505 :         if (flush_changes)
    1106           6 :             ff_h264_flush_change(h);
    1107             : 
    1108         505 :         if ((ret = get_pixel_format(h, 1)) < 0)
    1109           0 :             return ret;
    1110         505 :         h->avctx->pix_fmt = ret;
    1111             : 
    1112         505 :         av_log(h->avctx, AV_LOG_VERBOSE, "Reinit context to %dx%d, "
    1113         505 :                "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
    1114             : 
    1115         505 :         if ((ret = h264_slice_header_init(h)) < 0) {
    1116           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1117             :                    "h264_slice_header_init() failed\n");
    1118           0 :             return ret;
    1119             :         }
    1120             :     }
    1121             : 
    1122       25097 :     return 0;
    1123             : }
    1124             : 
    1125       21860 : static int h264_export_frame_props(H264Context *h)
    1126             : {
    1127       21860 :     const SPS *sps = h->ps.sps;
    1128       21860 :     H264Picture *cur = h->cur_pic_ptr;
    1129             : 
    1130       21860 :     cur->f->interlaced_frame = 0;
    1131       21860 :     cur->f->repeat_pict      = 0;
    1132             : 
    1133             :     /* Signal interlacing information externally. */
    1134             :     /* Prioritize picture timing SEI information over used
    1135             :      * decoding process if it exists. */
    1136             : 
    1137       22234 :     if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
    1138         374 :         H264SEIPictureTiming *pt = &h->sei.picture_timing;
    1139         374 :         switch (pt->pic_struct) {
    1140          21 :         case H264_SEI_PIC_STRUCT_FRAME:
    1141          21 :             break;
    1142         248 :         case H264_SEI_PIC_STRUCT_TOP_FIELD:
    1143             :         case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
    1144         248 :             cur->f->interlaced_frame = 1;
    1145         248 :             break;
    1146         102 :         case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
    1147             :         case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
    1148         102 :             if (FIELD_OR_MBAFF_PICTURE(h))
    1149          98 :                 cur->f->interlaced_frame = 1;
    1150             :             else
    1151             :                 // try to flag soft telecine progressive
    1152           4 :                 cur->f->interlaced_frame = h->prev_interlaced_frame;
    1153         102 :             break;
    1154           3 :         case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
    1155             :         case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
    1156             :             /* Signal the possibility of telecined film externally
    1157             :              * (pic_struct 5,6). From these hints, let the applications
    1158             :              * decide if they apply deinterlacing. */
    1159           3 :             cur->f->repeat_pict = 1;
    1160           3 :             break;
    1161           0 :         case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
    1162           0 :             cur->f->repeat_pict = 2;
    1163           0 :             break;
    1164           0 :         case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
    1165           0 :             cur->f->repeat_pict = 4;
    1166           0 :             break;
    1167             :         }
    1168             : 
    1169         560 :         if ((pt->ct_type & 3) &&
    1170         186 :             pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
    1171         186 :             cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
    1172             :     } else {
    1173             :         /* Derive interlacing flag from used decoding process. */
    1174       21486 :         cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
    1175             :     }
    1176       21860 :     h->prev_interlaced_frame = cur->f->interlaced_frame;
    1177             : 
    1178       21860 :     if (cur->field_poc[0] != cur->field_poc[1]) {
    1179             :         /* Derive top_field_first from field pocs. */
    1180        2569 :         cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
    1181             :     } else {
    1182       19291 :         if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
    1183             :             /* Use picture timing SEI information. Even if it is a
    1184             :              * information of a past frame, better than nothing. */
    1185          83 :             if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
    1186          27 :                 h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
    1187           3 :                 cur->f->top_field_first = 1;
    1188             :             else
    1189          25 :                 cur->f->top_field_first = 0;
    1190       19263 :         } else if (cur->f->interlaced_frame) {
    1191             :             /* Default to top field first when pic_struct_present_flag
    1192             :              * is not set but interlaced frame detected */
    1193        2554 :             cur->f->top_field_first = 1;
    1194             :         } else {
    1195             :             /* Most likely progressive */
    1196       16709 :             cur->f->top_field_first = 0;
    1197             :         }
    1198             :     }
    1199             : 
    1200       21860 :     if (h->sei.frame_packing.present &&
    1201           0 :         h->sei.frame_packing.arrangement_type <= 6 &&
    1202           0 :         h->sei.frame_packing.content_interpretation_type > 0 &&
    1203           0 :         h->sei.frame_packing.content_interpretation_type < 3) {
    1204           0 :         H264SEIFramePacking *fp = &h->sei.frame_packing;
    1205           0 :         AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
    1206           0 :         if (stereo) {
    1207           0 :         switch (fp->arrangement_type) {
    1208           0 :         case H264_SEI_FPA_TYPE_CHECKERBOARD:
    1209           0 :             stereo->type = AV_STEREO3D_CHECKERBOARD;
    1210           0 :             break;
    1211           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN:
    1212           0 :             stereo->type = AV_STEREO3D_COLUMNS;
    1213           0 :             break;
    1214           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_ROW:
    1215           0 :             stereo->type = AV_STEREO3D_LINES;
    1216           0 :             break;
    1217           0 :         case H264_SEI_FPA_TYPE_SIDE_BY_SIDE:
    1218           0 :             if (fp->quincunx_sampling_flag)
    1219           0 :                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
    1220             :             else
    1221           0 :                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
    1222           0 :             break;
    1223           0 :         case H264_SEI_FPA_TYPE_TOP_BOTTOM:
    1224           0 :             stereo->type = AV_STEREO3D_TOPBOTTOM;
    1225           0 :             break;
    1226           0 :         case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
    1227           0 :             stereo->type = AV_STEREO3D_FRAMESEQUENCE;
    1228           0 :             break;
    1229           0 :         case H264_SEI_FPA_TYPE_2D:
    1230           0 :             stereo->type = AV_STEREO3D_2D;
    1231           0 :             break;
    1232             :         }
    1233             : 
    1234           0 :         if (fp->content_interpretation_type == 2)
    1235           0 :             stereo->flags = AV_STEREO3D_FLAG_INVERT;
    1236             : 
    1237           0 :         if (fp->arrangement_type == H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL) {
    1238           0 :             if (fp->current_frame_is_frame0_flag)
    1239           0 :                 stereo->view = AV_STEREO3D_VIEW_LEFT;
    1240             :             else
    1241           0 :                 stereo->view = AV_STEREO3D_VIEW_RIGHT;
    1242             :         }
    1243             :         }
    1244             :     }
    1245             : 
    1246       21860 :     if (h->sei.display_orientation.present &&
    1247           0 :         (h->sei.display_orientation.anticlockwise_rotation ||
    1248           0 :          h->sei.display_orientation.hflip ||
    1249           0 :          h->sei.display_orientation.vflip)) {
    1250           0 :         H264SEIDisplayOrientation *o = &h->sei.display_orientation;
    1251           0 :         double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
    1252           0 :         AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
    1253             :                                                            AV_FRAME_DATA_DISPLAYMATRIX,
    1254             :                                                            sizeof(int32_t) * 9);
    1255           0 :         if (rotation) {
    1256           0 :             av_display_rotation_set((int32_t *)rotation->data, angle);
    1257           0 :             av_display_matrix_flip((int32_t *)rotation->data,
    1258             :                                    o->hflip, o->vflip);
    1259             :         }
    1260             :     }
    1261             : 
    1262       21860 :     if (h->sei.afd.present) {
    1263         136 :         AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
    1264             :                                                      sizeof(uint8_t));
    1265             : 
    1266         136 :         if (sd) {
    1267         136 :             *sd->data = h->sei.afd.active_format_description;
    1268         136 :             h->sei.afd.present = 0;
    1269             :         }
    1270             :     }
    1271             : 
    1272       21860 :     if (h->sei.a53_caption.a53_caption) {
    1273           0 :         H264SEIA53Caption *a53 = &h->sei.a53_caption;
    1274           0 :         AVFrameSideData *sd = av_frame_new_side_data(cur->f,
    1275             :                                                      AV_FRAME_DATA_A53_CC,
    1276             :                                                      a53->a53_caption_size);
    1277           0 :         if (sd)
    1278           0 :             memcpy(sd->data, a53->a53_caption, a53->a53_caption_size);
    1279           0 :         av_freep(&a53->a53_caption);
    1280           0 :         a53->a53_caption_size = 0;
    1281           0 :         h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
    1282             :     }
    1283             : 
    1284       21860 :     if (h->sei.alternative_transfer.present &&
    1285           0 :         av_color_transfer_name(h->sei.alternative_transfer.preferred_transfer_characteristics) &&
    1286           0 :         h->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
    1287           0 :         h->avctx->color_trc = cur->f->color_trc = h->sei.alternative_transfer.preferred_transfer_characteristics;
    1288             :     }
    1289             : 
    1290       21860 :     return 0;
    1291             : }
    1292             : 
    1293       21860 : static int h264_select_output_frame(H264Context *h)
    1294             : {
    1295       21860 :     const SPS *sps = h->ps.sps;
    1296       21860 :     H264Picture *out = h->cur_pic_ptr;
    1297       21860 :     H264Picture *cur = h->cur_pic_ptr;
    1298             :     int i, pics, out_of_order, out_idx;
    1299             : 
    1300       21860 :     cur->mmco_reset = h->mmco_reset;
    1301       21860 :     h->mmco_reset = 0;
    1302             : 
    1303       41052 :     if (sps->bitstream_restriction_flag ||
    1304       19192 :         h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
    1305        2668 :         h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
    1306             :     }
    1307             : 
    1308      357606 :     for (i = 0; 1; i++) {
    1309      693352 :         if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
    1310       21860 :             if(i)
    1311       21860 :                 h->last_pocs[i-1] = cur->poc;
    1312       21860 :             break;
    1313      335746 :         } else if(i) {
    1314      313886 :             h->last_pocs[i-1]= h->last_pocs[i];
    1315             :         }
    1316             :     }
    1317       21860 :     out_of_order = MAX_DELAYED_PIC_COUNT - i;
    1318       21860 :     if(   cur->f->pict_type == AV_PICTURE_TYPE_B
    1319       14641 :        || (h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > INT_MIN && h->last_pocs[MAX_DELAYED_PIC_COUNT-1] - h->last_pocs[MAX_DELAYED_PIC_COUNT-2] > 2))
    1320       11704 :         out_of_order = FFMAX(out_of_order, 1);
    1321       21860 :     if (out_of_order == MAX_DELAYED_PIC_COUNT) {
    1322           0 :         av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
    1323           0 :         for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
    1324           0 :             h->last_pocs[i] = INT_MIN;
    1325           0 :         h->last_pocs[0] = cur->poc;
    1326           0 :         cur->mmco_reset = 1;
    1327       21860 :     } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
    1328         131 :         int loglevel = h->avctx->frame_number > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
    1329         131 :         av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
    1330         131 :         h->avctx->has_b_frames = out_of_order;
    1331             :     }
    1332             : 
    1333       21860 :     pics = 0;
    1334       71956 :     while (h->delayed_pic[pics])
    1335       28236 :         pics++;
    1336             : 
    1337       21860 :     av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
    1338             : 
    1339       21860 :     h->delayed_pic[pics++] = cur;
    1340       21860 :     if (cur->reference == 0)
    1341       20449 :         cur->reference = DELAYED_PIC_REF;
    1342             : 
    1343       21860 :     out     = h->delayed_pic[0];
    1344       21860 :     out_idx = 0;
    1345       94836 :     for (i = 1; h->delayed_pic[i] &&
    1346       51203 :                 !h->delayed_pic[i]->f->key_frame &&
    1347       25421 :                 !h->delayed_pic[i]->mmco_reset;
    1348       25334 :          i++)
    1349       25334 :         if (h->delayed_pic[i]->poc < out->poc) {
    1350        9336 :             out     = h->delayed_pic[i];
    1351        9336 :             out_idx = i;
    1352             :         }
    1353       30856 :     if (h->avctx->has_b_frames == 0 &&
    1354       17287 :         (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset))
    1355         711 :         h->next_outputed_poc = INT_MIN;
    1356       21860 :     out_of_order = out->poc < h->next_outputed_poc;
    1357             : 
    1358       21860 :     if (out_of_order || pics > h->avctx->has_b_frames) {
    1359       21402 :         out->reference &= ~DELAYED_PIC_REF;
    1360       56616 :         for (i = out_idx; h->delayed_pic[i]; i++)
    1361       35214 :             h->delayed_pic[i] = h->delayed_pic[i + 1];
    1362             :     }
    1363       21860 :     if (!out_of_order && pics > h->avctx->has_b_frames) {
    1364       21151 :         h->next_output_pic = out;
    1365       21151 :         if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset)) {
    1366          86 :             h->next_outputed_poc = INT_MIN;
    1367             :         } else
    1368       21065 :             h->next_outputed_poc = out->poc;
    1369             : 
    1370       21151 :         if (out->recovered) {
    1371             :             // We have reached an recovery point and all frames after it in
    1372             :             // display order are "recovered".
    1373       21089 :             h->frame_recovered |= FRAME_RECOVERED_SEI;
    1374             :         }
    1375       21151 :         out->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
    1376             : 
    1377       42302 :         if (!out->recovered) {
    1378         114 :             if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
    1379          57 :                 !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
    1380          57 :                 h->next_output_pic = NULL;
    1381             :             } else {
    1382           0 :                 out->f->flags |= AV_FRAME_FLAG_CORRUPT;
    1383             :             }
    1384             :         }
    1385             :     } else {
    1386         709 :         av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
    1387             :     }
    1388             : 
    1389       21860 :     return 0;
    1390             : }
    1391             : 
    1392             : /* This function is called right after decoding the slice header for a first
    1393             :  * slice in a field (or a frame). It decides whether we are decoding a new frame
    1394             :  * or a second field in a pair and does the necessary setup.
    1395             :  */
    1396       25097 : static int h264_field_start(H264Context *h, const H264SliceContext *sl,
    1397             :                             const H2645NAL *nal, int first_slice)
    1398             : {
    1399             :     int i;
    1400             :     const SPS *sps;
    1401             : 
    1402             :     int last_pic_structure, last_pic_droppable, ret;
    1403             : 
    1404       25097 :     ret = h264_init_ps(h, sl, first_slice);
    1405       25097 :     if (ret < 0)
    1406           0 :         return ret;
    1407             : 
    1408       25097 :     sps = h->ps.sps;
    1409             : 
    1410       25097 :     last_pic_droppable   = h->droppable;
    1411       25097 :     last_pic_structure   = h->picture_structure;
    1412       25097 :     h->droppable         = (nal->ref_idc == 0);
    1413       25097 :     h->picture_structure = sl->picture_structure;
    1414             : 
    1415       25097 :     h->poc.frame_num        = sl->frame_num;
    1416       25097 :     h->poc.poc_lsb          = sl->poc_lsb;
    1417       25097 :     h->poc.delta_poc_bottom = sl->delta_poc_bottom;
    1418       25097 :     h->poc.delta_poc[0]     = sl->delta_poc[0];
    1419       25097 :     h->poc.delta_poc[1]     = sl->delta_poc[1];
    1420             : 
    1421             :     /* Shorten frame num gaps so we don't have to allocate reference
    1422             :      * frames just to throw them away */
    1423       25097 :     if (h->poc.frame_num != h->poc.prev_frame_num) {
    1424       14000 :         int unwrap_prev_frame_num = h->poc.prev_frame_num;
    1425       14000 :         int max_frame_num         = 1 << sps->log2_max_frame_num;
    1426             : 
    1427       14000 :         if (unwrap_prev_frame_num > h->poc.frame_num)
    1428         113 :             unwrap_prev_frame_num -= max_frame_num;
    1429             : 
    1430       14000 :         if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
    1431          53 :             unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
    1432          53 :             if (unwrap_prev_frame_num < 0)
    1433           2 :                 unwrap_prev_frame_num += max_frame_num;
    1434             : 
    1435          53 :             h->poc.prev_frame_num = unwrap_prev_frame_num;
    1436             :         }
    1437             :     }
    1438             : 
    1439             :     /* See if we have a decoded first field looking for a pair...
    1440             :      * Here, we're using that to see if we should mark previously
    1441             :      * decode frames as "finished".
    1442             :      * We have to do that before the "dummy" in-between frame allocation,
    1443             :      * since that can modify h->cur_pic_ptr. */
    1444       25097 :     if (h->first_field) {
    1445        3234 :         int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
    1446        3234 :         av_assert0(h->cur_pic_ptr);
    1447        3234 :         av_assert0(h->cur_pic_ptr->f->buf[0]);
    1448             :         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
    1449             : 
    1450             :         /* Mark old field/frame as completed */
    1451        3234 :         if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
    1452        3234 :             ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
    1453             :         }
    1454             : 
    1455             :         /* figure out if we have a complementary field pair */
    1456        3234 :         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
    1457             :             /* Previous field is unmatched. Don't display it, but let it
    1458             :              * remain for reference if marked as such. */
    1459           0 :             if (last_pic_structure != PICT_FRAME) {
    1460           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1461             :                                           last_pic_structure == PICT_TOP_FIELD);
    1462             :             }
    1463             :         } else {
    1464        3234 :             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
    1465             :                 /* This and previous field were reference, but had
    1466             :                  * different frame_nums. Consider this field first in
    1467             :                  * pair. Throw away previous field except for reference
    1468             :                  * purposes. */
    1469           0 :                 if (last_pic_structure != PICT_FRAME) {
    1470           0 :                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1471             :                                               last_pic_structure == PICT_TOP_FIELD);
    1472             :                 }
    1473             :             } else {
    1474             :                 /* Second field in complementary pair */
    1475        6460 :                 if (!((last_pic_structure   == PICT_TOP_FIELD &&
    1476        3226 :                        h->picture_structure == PICT_BOTTOM_FIELD) ||
    1477           8 :                       (last_pic_structure   == PICT_BOTTOM_FIELD &&
    1478           8 :                        h->picture_structure == PICT_TOP_FIELD))) {
    1479           0 :                     av_log(h->avctx, AV_LOG_ERROR,
    1480             :                            "Invalid field mode combination %d/%d\n",
    1481             :                            last_pic_structure, h->picture_structure);
    1482           0 :                     h->picture_structure = last_pic_structure;
    1483           0 :                     h->droppable         = last_pic_droppable;
    1484           0 :                     return AVERROR_INVALIDDATA;
    1485        3234 :                 } else if (last_pic_droppable != h->droppable) {
    1486           0 :                     avpriv_request_sample(h->avctx,
    1487             :                                           "Found reference and non-reference fields in the same frame, which");
    1488           0 :                     h->picture_structure = last_pic_structure;
    1489           0 :                     h->droppable         = last_pic_droppable;
    1490           0 :                     return AVERROR_PATCHWELCOME;
    1491             :                 }
    1492             :             }
    1493             :         }
    1494             :     }
    1495             : 
    1496       65446 :     while (h->poc.frame_num != h->poc.prev_frame_num && !h->first_field &&
    1497       14626 :            h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
    1498         626 :         H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
    1499         626 :         av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
    1500             :                h->poc.frame_num, h->poc.prev_frame_num);
    1501         626 :         if (!sps->gaps_in_frame_num_allowed_flag)
    1502         833 :             for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
    1503         784 :                 h->last_pocs[i] = INT_MIN;
    1504         626 :         ret = h264_frame_start(h);
    1505         626 :         if (ret < 0) {
    1506           0 :             h->first_field = 0;
    1507           0 :             return ret;
    1508             :         }
    1509             : 
    1510         626 :         h->poc.prev_frame_num++;
    1511         626 :         h->poc.prev_frame_num        %= 1 << sps->log2_max_frame_num;
    1512         626 :         h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
    1513         626 :         h->cur_pic_ptr->invalid_gap = !sps->gaps_in_frame_num_allowed_flag;
    1514         626 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
    1515         626 :         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
    1516             : 
    1517         626 :         h->explicit_ref_marking = 0;
    1518         626 :         ret = ff_h264_execute_ref_pic_marking(h);
    1519         626 :         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    1520           0 :             return ret;
    1521             :         /* Error concealment: If a ref is missing, copy the previous ref
    1522             :          * in its place.
    1523             :          * FIXME: Avoiding a memcpy would be nice, but ref handling makes
    1524             :          * many assumptions about there being no actual duplicates.
    1525             :          * FIXME: This does not copy padding for out-of-frame motion
    1526             :          * vectors.  Given we are concealing a lost frame, this probably
    1527             :          * is not noticeable by comparison, but it should be fixed. */
    1528         626 :         if (h->short_ref_count) {
    1529        1238 :             if (prev &&
    1530        1224 :                 h->short_ref[0]->f->width == prev->f->width &&
    1531        1224 :                 h->short_ref[0]->f->height == prev->f->height &&
    1532         612 :                 h->short_ref[0]->f->format == prev->f->format) {
    1533         612 :                 ff_thread_await_progress(&prev->tf, INT_MAX, 0);
    1534         612 :                 if (prev->field_picture)
    1535          14 :                     ff_thread_await_progress(&prev->tf, INT_MAX, 1);
    1536        1836 :                 av_image_copy(h->short_ref[0]->f->data,
    1537         612 :                               h->short_ref[0]->f->linesize,
    1538         612 :                               (const uint8_t **)prev->f->data,
    1539         612 :                               prev->f->linesize,
    1540         612 :                               prev->f->format,
    1541         612 :                               prev->f->width,
    1542         612 :                               prev->f->height);
    1543         612 :                 h->short_ref[0]->poc = prev->poc + 2;
    1544             :             }
    1545         626 :             h->short_ref[0]->frame_num = h->poc.prev_frame_num;
    1546             :         }
    1547             :     }
    1548             : 
    1549             :     /* See if we have a decoded first field looking for a pair...
    1550             :      * We're using that to see whether to continue decoding in that
    1551             :      * frame, or to allocate a new one. */
    1552       25097 :     if (h->first_field) {
    1553        3234 :         av_assert0(h->cur_pic_ptr);
    1554        3234 :         av_assert0(h->cur_pic_ptr->f->buf[0]);
    1555             :         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
    1556             : 
    1557             :         /* figure out if we have a complementary field pair */
    1558        3234 :         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
    1559             :             /* Previous field is unmatched. Don't display it, but let it
    1560             :              * remain for reference if marked as such. */
    1561           0 :             h->missing_fields ++;
    1562           0 :             h->cur_pic_ptr = NULL;
    1563           0 :             h->first_field = FIELD_PICTURE(h);
    1564             :         } else {
    1565        3234 :             h->missing_fields = 0;
    1566        3234 :             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
    1567           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    1568           0 :                                           h->picture_structure==PICT_BOTTOM_FIELD);
    1569             :                 /* This and the previous field had different frame_nums.
    1570             :                  * Consider this field first in pair. Throw away previous
    1571             :                  * one except for reference purposes. */
    1572           0 :                 h->first_field = 1;
    1573           0 :                 h->cur_pic_ptr = NULL;
    1574        3234 :             } else if (h->cur_pic_ptr->reference & DELAYED_PIC_REF) {
    1575             :                 /* This frame was already output, we cannot draw into it
    1576             :                  * anymore.
    1577             :                  */
    1578           0 :                 h->first_field = 1;
    1579           0 :                 h->cur_pic_ptr = NULL;
    1580             :             } else {
    1581             :                 /* Second field in complementary pair */
    1582        3234 :                 h->first_field = 0;
    1583             :             }
    1584             :         }
    1585             :     } else {
    1586             :         /* Frame or first field in a potentially complementary pair */
    1587       21863 :         h->first_field = FIELD_PICTURE(h);
    1588             :     }
    1589             : 
    1590       25097 :     if (!FIELD_PICTURE(h) || h->first_field) {
    1591       43726 :         if (h264_frame_start(h) < 0) {
    1592           0 :             h->first_field = 0;
    1593           0 :             return AVERROR_INVALIDDATA;
    1594             :         }
    1595             :     } else {
    1596        3234 :         int field = h->picture_structure == PICT_BOTTOM_FIELD;
    1597        3234 :         release_unused_pictures(h, 0);
    1598        3234 :         h->cur_pic_ptr->tf.owner[field] = h->avctx;
    1599             :     }
    1600             :     /* Some macroblocks can be accessed before they're available in case
    1601             :     * of lost slices, MBAFF or threading. */
    1602       25097 :     if (FIELD_PICTURE(h)) {
    1603      157337 :         for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
    1604      150866 :             memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
    1605             :     } else {
    1606       18626 :         memset(h->slice_table, -1,
    1607       18626 :             (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
    1608             :     }
    1609             : 
    1610       25097 :     ret = ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
    1611             :                      h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
    1612       25097 :     if (ret < 0)
    1613           0 :         return ret;
    1614             : 
    1615       25097 :     memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
    1616       25097 :     h->nb_mmco = sl->nb_mmco;
    1617       25097 :     h->explicit_ref_marking = sl->explicit_ref_marking;
    1618             : 
    1619       25097 :     h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
    1620             : 
    1621       25097 :     if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
    1622          39 :         const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
    1623             : 
    1624          39 :         if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
    1625          26 :             h->valid_recovery_point = 1;
    1626             : 
    1627          39 :         if (   h->recovery_frame < 0
    1628           1 :             || av_mod_uintp2(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
    1629          38 :             h->recovery_frame = av_mod_uintp2(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
    1630             : 
    1631          38 :             if (!h->valid_recovery_point)
    1632           6 :                 h->recovery_frame = h->poc.frame_num;
    1633             :         }
    1634             :     }
    1635             : 
    1636       25097 :     h->cur_pic_ptr->f->key_frame |= (nal->type == H264_NAL_IDR_SLICE);
    1637             : 
    1638       49260 :     if (nal->type == H264_NAL_IDR_SLICE ||
    1639       24192 :         (h->recovery_frame == h->poc.frame_num && nal->ref_idc)) {
    1640         961 :         h->recovery_frame         = -1;
    1641         961 :         h->cur_pic_ptr->recovered = 1;
    1642             :     }
    1643             :     // If we have an IDR, all frames after it in decoded order are
    1644             :     // "recovered".
    1645       25097 :     if (nal->type == H264_NAL_IDR_SLICE)
    1646         934 :         h->frame_recovered |= FRAME_RECOVERED_IDR;
    1647             : #if 1
    1648       25097 :     h->cur_pic_ptr->recovered |= h->frame_recovered;
    1649             : #else
    1650             :     h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
    1651             : #endif
    1652             : 
    1653             :     /* Set the frame properties/side data. Only done for the second field in
    1654             :      * field coded frames, since some SEI information is present for each field
    1655             :      * and is merged by the SEI parsing code. */
    1656       25097 :     if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
    1657       21860 :         ret = h264_export_frame_props(h);
    1658       21860 :         if (ret < 0)
    1659           0 :             return ret;
    1660             : 
    1661       21860 :         ret = h264_select_output_frame(h);
    1662       21860 :         if (ret < 0)
    1663           0 :             return ret;
    1664             :     }
    1665             : 
    1666       25097 :     return 0;
    1667             : }
    1668             : 
    1669       31511 : static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
    1670             :                                    const H2645NAL *nal)
    1671             : {
    1672             :     const SPS *sps;
    1673             :     const PPS *pps;
    1674             :     int ret;
    1675             :     unsigned int slice_type, tmp, i;
    1676             :     int field_pic_flag, bottom_field_flag;
    1677       31511 :     int first_slice = sl == h->slice_ctx && !h->current_slice;
    1678             :     int picture_structure;
    1679             : 
    1680       31511 :     if (first_slice)
    1681       25007 :         av_assert0(!h->setup_finished);
    1682             : 
    1683       31511 :     sl->first_mb_addr = get_ue_golomb_long(&sl->gb);
    1684             : 
    1685       31511 :     slice_type = get_ue_golomb_31(&sl->gb);
    1686       31511 :     if (slice_type > 9) {
    1687           0 :         av_log(h->avctx, AV_LOG_ERROR,
    1688             :                "slice type %d too large at %d\n",
    1689             :                slice_type, sl->first_mb_addr);
    1690           0 :         return AVERROR_INVALIDDATA;
    1691             :     }
    1692       31511 :     if (slice_type > 4) {
    1693       19245 :         slice_type -= 5;
    1694       19245 :         sl->slice_type_fixed = 1;
    1695             :     } else
    1696       12266 :         sl->slice_type_fixed = 0;
    1697             : 
    1698       31511 :     slice_type         = ff_h264_golomb_to_pict_type[slice_type];
    1699       31511 :     sl->slice_type     = slice_type;
    1700       31511 :     sl->slice_type_nos = slice_type & 3;
    1701             : 
    1702       33483 :     if (nal->type  == H264_NAL_IDR_SLICE &&
    1703        1972 :         sl->slice_type_nos != AV_PICTURE_TYPE_I) {
    1704           0 :         av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
    1705           0 :         return AVERROR_INVALIDDATA;
    1706             :     }
    1707             : 
    1708       31511 :     sl->pps_id = get_ue_golomb(&sl->gb);
    1709       31511 :     if (sl->pps_id >= MAX_PPS_COUNT) {
    1710           0 :         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
    1711           0 :         return AVERROR_INVALIDDATA;
    1712             :     }
    1713       31511 :     if (!h->ps.pps_list[sl->pps_id]) {
    1714          16 :         av_log(h->avctx, AV_LOG_ERROR,
    1715             :                "non-existing PPS %u referenced\n",
    1716             :                sl->pps_id);
    1717          16 :         return AVERROR_INVALIDDATA;
    1718             :     }
    1719       31495 :     pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
    1720             : 
    1721       31495 :     if (!h->ps.sps_list[pps->sps_id]) {
    1722           0 :         av_log(h->avctx, AV_LOG_ERROR,
    1723             :                "non-existing SPS %u referenced\n", pps->sps_id);
    1724           0 :         return AVERROR_INVALIDDATA;
    1725             :     }
    1726       31495 :     sps = (const SPS*)h->ps.sps_list[pps->sps_id]->data;
    1727             : 
    1728       31495 :     sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
    1729       31495 :     if (!first_slice) {
    1730        6503 :         if (h->poc.frame_num != sl->frame_num) {
    1731           0 :             av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
    1732             :                    h->poc.frame_num, sl->frame_num);
    1733           0 :             return AVERROR_INVALIDDATA;
    1734             :         }
    1735             :     }
    1736             : 
    1737       31495 :     sl->mb_mbaff       = 0;
    1738             : 
    1739       31495 :     if (sps->frame_mbs_only_flag) {
    1740       20156 :         picture_structure = PICT_FRAME;
    1741             :     } else {
    1742       11339 :         if (!sps->direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
    1743           0 :             av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
    1744           0 :             return -1;
    1745             :         }
    1746       11339 :         field_pic_flag = get_bits1(&sl->gb);
    1747       11339 :         if (field_pic_flag) {
    1748        8478 :             bottom_field_flag = get_bits1(&sl->gb);
    1749        8478 :             picture_structure = PICT_TOP_FIELD + bottom_field_flag;
    1750             :         } else {
    1751        2861 :             picture_structure = PICT_FRAME;
    1752             :         }
    1753             :     }
    1754       31495 :     sl->picture_structure      = picture_structure;
    1755       31495 :     sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
    1756             : 
    1757       31495 :     if (picture_structure == PICT_FRAME) {
    1758       23017 :         sl->curr_pic_num = sl->frame_num;
    1759       23017 :         sl->max_pic_num  = 1 << sps->log2_max_frame_num;
    1760             :     } else {
    1761        8478 :         sl->curr_pic_num = 2 * sl->frame_num + 1;
    1762        8478 :         sl->max_pic_num  = 1 << (sps->log2_max_frame_num + 1);
    1763             :     }
    1764             : 
    1765       31495 :     if (nal->type == H264_NAL_IDR_SLICE)
    1766        1972 :         get_ue_golomb_long(&sl->gb); /* idr_pic_id */
    1767             : 
    1768       31495 :     if (sps->poc_type == 0) {
    1769       24481 :         sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
    1770             : 
    1771       24481 :         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
    1772        3426 :             sl->delta_poc_bottom = get_se_golomb(&sl->gb);
    1773             :     }
    1774             : 
    1775       31495 :     if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
    1776        2849 :         sl->delta_poc[0] = get_se_golomb(&sl->gb);
    1777             : 
    1778        2849 :         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
    1779         453 :             sl->delta_poc[1] = get_se_golomb(&sl->gb);
    1780             :     }
    1781             : 
    1782       31495 :     sl->redundant_pic_count = 0;
    1783       31495 :     if (pps->redundant_pic_cnt_present)
    1784           8 :         sl->redundant_pic_count = get_ue_golomb(&sl->gb);
    1785             : 
    1786       31495 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
    1787       11070 :         sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
    1788             : 
    1789       31495 :     ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
    1790             :                                   &sl->gb, pps, sl->slice_type_nos,
    1791       31495 :                                   picture_structure, h->avctx);
    1792       31495 :     if (ret < 0)
    1793           4 :         return ret;
    1794             : 
    1795       31491 :     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
    1796       27367 :        ret = ff_h264_decode_ref_pic_list_reordering(sl, h->avctx);
    1797       27367 :        if (ret < 0) {
    1798           3 :            sl->ref_count[1] = sl->ref_count[0] = 0;
    1799           3 :            return ret;
    1800             :        }
    1801             :     }
    1802             : 
    1803       31488 :     sl->pwt.use_weight = 0;
    1804       94464 :     for (i = 0; i < 2; i++) {
    1805       62976 :         sl->pwt.luma_weight_flag[i]   = 0;
    1806       62976 :         sl->pwt.chroma_weight_flag[i] = 0;
    1807             :     }
    1808       61721 :     if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
    1809       30520 :         (pps->weighted_bipred_idc == 1 &&
    1810         287 :          sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
    1811        1533 :         ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
    1812             :                                   sl->slice_type_nos, &sl->pwt,
    1813        1533 :                                   picture_structure, h->avctx);
    1814        1533 :         if (ret < 0)
    1815           0 :             return ret;
    1816             :     }
    1817             : 
    1818       31488 :     sl->explicit_ref_marking = 0;
    1819       31488 :     if (nal->ref_idc) {
    1820       20718 :         ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx);
    1821       20718 :         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    1822           0 :             return AVERROR_INVALIDDATA;
    1823             :     }
    1824             : 
    1825       31488 :     if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
    1826       13224 :         tmp = get_ue_golomb_31(&sl->gb);
    1827       13224 :         if (tmp > 2) {
    1828           0 :             av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
    1829           0 :             return AVERROR_INVALIDDATA;
    1830             :         }
    1831       13224 :         sl->cabac_init_idc = tmp;
    1832             :     }
    1833             : 
    1834       31488 :     sl->last_qscale_diff = 0;
    1835       31488 :     tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
    1836       31488 :     if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
    1837           0 :         av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
    1838           0 :         return AVERROR_INVALIDDATA;
    1839             :     }
    1840       31488 :     sl->qscale       = tmp;
    1841       31488 :     sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
    1842       31488 :     sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
    1843             :     // FIXME qscale / qp ... stuff
    1844       31488 :     if (sl->slice_type == AV_PICTURE_TYPE_SP)
    1845           0 :         get_bits1(&sl->gb); /* sp_for_switch_flag */
    1846       62976 :     if (sl->slice_type == AV_PICTURE_TYPE_SP ||
    1847       31488 :         sl->slice_type == AV_PICTURE_TYPE_SI)
    1848           0 :         get_se_golomb(&sl->gb); /* slice_qs_delta */
    1849             : 
    1850       31488 :     sl->deblocking_filter     = 1;
    1851       31488 :     sl->slice_alpha_c0_offset = 0;
    1852       31488 :     sl->slice_beta_offset     = 0;
    1853       31488 :     if (pps->deblocking_filter_parameters_present) {
    1854       17226 :         tmp = get_ue_golomb_31(&sl->gb);
    1855       17226 :         if (tmp > 2) {
    1856           0 :             av_log(h->avctx, AV_LOG_ERROR,
    1857             :                    "deblocking_filter_idc %u out of range\n", tmp);
    1858           0 :             return AVERROR_INVALIDDATA;
    1859             :         }
    1860       17226 :         sl->deblocking_filter = tmp;
    1861       17226 :         if (sl->deblocking_filter < 2)
    1862       17129 :             sl->deblocking_filter ^= 1;  // 1<->0
    1863             : 
    1864       17226 :         if (sl->deblocking_filter) {
    1865       10291 :             int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
    1866       10291 :             int slice_beta_offset_div2     = get_se_golomb(&sl->gb);
    1867       10291 :             if (slice_alpha_c0_offset_div2 >  6 ||
    1868       10291 :                 slice_alpha_c0_offset_div2 < -6 ||
    1869       10291 :                 slice_beta_offset_div2 >  6     ||
    1870             :                 slice_beta_offset_div2 < -6) {
    1871           0 :                 av_log(h->avctx, AV_LOG_ERROR,
    1872             :                        "deblocking filter parameters %d %d out of range\n",
    1873             :                        slice_alpha_c0_offset_div2, slice_beta_offset_div2);
    1874           0 :                 return AVERROR_INVALIDDATA;
    1875             :             }
    1876       10291 :             sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
    1877       10291 :             sl->slice_beta_offset     = slice_beta_offset_div2 * 2;
    1878             :         }
    1879             :     }
    1880             : 
    1881       31488 :     return 0;
    1882             : }
    1883             : 
    1884             : /* do all the per-slice initialization needed before we can start decoding the
    1885             :  * actual MBs */
    1886       31407 : static int h264_slice_init(H264Context *h, H264SliceContext *sl,
    1887             :                            const H2645NAL *nal)
    1888             : {
    1889       31407 :     int i, j, ret = 0;
    1890             : 
    1891       31407 :     if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
    1892           0 :         av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
    1893           0 :         return AVERROR_INVALIDDATA;
    1894             :     }
    1895             : 
    1896             :     av_assert1(h->mb_num == h->mb_width * h->mb_height);
    1897       62814 :     if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
    1898       31407 :         sl->first_mb_addr >= h->mb_num) {
    1899           0 :         av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
    1900           0 :         return AVERROR_INVALIDDATA;
    1901             :     }
    1902       31407 :     sl->resync_mb_x = sl->mb_x =  sl->first_mb_addr % h->mb_width;
    1903       62814 :     sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
    1904       31407 :                                  FIELD_OR_MBAFF_PICTURE(h);
    1905       31407 :     if (h->picture_structure == PICT_BOTTOM_FIELD)
    1906        4197 :         sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
    1907             :     av_assert1(sl->mb_y < h->mb_height);
    1908             : 
    1909       31407 :     ret = ff_h264_build_ref_list(h, sl);
    1910       31407 :     if (ret < 0)
    1911           0 :         return ret;
    1912             : 
    1913       32587 :     if (h->ps.pps->weighted_bipred_idc == 2 &&
    1914        1180 :         sl->slice_type_nos == AV_PICTURE_TYPE_B) {
    1915         732 :         implicit_weight_table(h, sl, -1);
    1916         732 :         if (FRAME_MBAFF(h)) {
    1917          11 :             implicit_weight_table(h, sl, 0);
    1918          11 :             implicit_weight_table(h, sl, 1);
    1919             :         }
    1920             :     }
    1921             : 
    1922       31407 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
    1923        7703 :         ff_h264_direct_dist_scale_factor(h, sl);
    1924       31407 :     if (!h->setup_finished)
    1925       31407 :         ff_h264_direct_ref_list_init(h, sl);
    1926             : 
    1927       62814 :     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
    1928       31407 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
    1929       31407 :          h->nal_unit_type != H264_NAL_IDR_SLICE) ||
    1930       31407 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
    1931       31407 :          sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
    1932       31407 :         (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR  &&
    1933       31407 :          sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
    1934       31407 :         (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
    1935           0 :          nal->ref_idc == 0))
    1936           0 :         sl->deblocking_filter = 0;
    1937             : 
    1938       31407 :     if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
    1939           0 :         if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
    1940             :             /* Cheat slightly for speed:
    1941             :              * Do not bother to deblock across slices. */
    1942           0 :             sl->deblocking_filter = 2;
    1943             :         } else {
    1944           0 :             h->postpone_filter = 1;
    1945             :         }
    1946             :     }
    1947       62814 :     sl->qp_thresh = 15 -
    1948       62814 :                    FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
    1949       31407 :                    FFMAX3(0,
    1950             :                           h->ps.pps->chroma_qp_index_offset[0],
    1951       31407 :                           h->ps.pps->chroma_qp_index_offset[1]) +
    1952       31407 :                    6 * (h->ps.sps->bit_depth_luma - 8);
    1953             : 
    1954       31407 :     sl->slice_num       = ++h->current_slice;
    1955             : 
    1956       31407 :     if (sl->slice_num)
    1957       31407 :         h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
    1958       31407 :     if (   h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
    1959       29345 :         && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
    1960       23326 :         && sl->slice_num >= MAX_SLICES) {
    1961             :         //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
    1962           0 :         av_log(h->avctx, AV_LOG_WARNING, "Possibly too many slices (%d >= %d), increase MAX_SLICES and recompile if there are artifacts\n", sl->slice_num, MAX_SLICES);
    1963             :     }
    1964             : 
    1965       94221 :     for (j = 0; j < 2; j++) {
    1966             :         int id_list[16];
    1967       62814 :         int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
    1968     1067838 :         for (i = 0; i < 16; i++) {
    1969     1005024 :             id_list[i] = 60;
    1970     1131193 :             if (j < sl->list_count && i < sl->ref_count[j] &&
    1971      126169 :                 sl->ref_list[j][i].parent->f->buf[0]) {
    1972             :                 int k;
    1973      126169 :                 AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
    1974      445635 :                 for (k = 0; k < h->short_ref_count; k++)
    1975      443686 :                     if (h->short_ref[k]->f->buf[0]->buffer == buf) {
    1976      124220 :                         id_list[i] = k;
    1977      124220 :                         break;
    1978             :                     }
    1979      136285 :                 for (k = 0; k < h->long_ref_count; k++)
    1980       11870 :                     if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
    1981        1754 :                         id_list[i] = h->short_ref_count + k;
    1982        1754 :                         break;
    1983             :                     }
    1984             :             }
    1985             :         }
    1986             : 
    1987       62814 :         ref2frm[0] =
    1988       62814 :         ref2frm[1] = -1;
    1989     1067838 :         for (i = 0; i < 16; i++)
    1990     1005024 :             ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
    1991      125628 :         ref2frm[18 + 0] =
    1992      125628 :         ref2frm[18 + 1] = -1;
    1993     2072862 :         for (i = 16; i < 48; i++)
    1994     4020096 :             ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
    1995     2010048 :                              (sl->ref_list[j][i].reference & 3);
    1996             :     }
    1997             : 
    1998       31407 :     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
    1999           0 :         av_log(h->avctx, AV_LOG_DEBUG,
    2000             :                "slice:%d %s mb:%d %c%s%s frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
    2001             :                sl->slice_num,
    2002           0 :                (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
    2003           0 :                sl->mb_y * h->mb_width + sl->mb_x,
    2004           0 :                av_get_picture_type_char(sl->slice_type),
    2005           0 :                sl->slice_type_fixed ? " fix" : "",
    2006           0 :                nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
    2007             :                h->poc.frame_num,
    2008           0 :                h->cur_pic_ptr->field_poc[0],
    2009           0 :                h->cur_pic_ptr->field_poc[1],
    2010             :                sl->ref_count[0], sl->ref_count[1],
    2011             :                sl->qscale,
    2012             :                sl->deblocking_filter,
    2013             :                sl->slice_alpha_c0_offset, sl->slice_beta_offset,
    2014             :                sl->pwt.use_weight,
    2015           0 :                sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
    2016           0 :                sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
    2017             :     }
    2018             : 
    2019       31407 :     return 0;
    2020             : }
    2021             : 
    2022       31511 : int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
    2023             : {
    2024       31511 :     H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
    2025       31511 :     int first_slice = sl == h->slice_ctx && !h->current_slice;
    2026             :     int ret;
    2027             : 
    2028       31511 :     sl->gb = nal->gb;
    2029             : 
    2030       31511 :     ret = h264_slice_header_parse(h, sl, nal);
    2031       31511 :     if (ret < 0)
    2032          23 :         return ret;
    2033             : 
    2034             :     // discard redundant pictures
    2035       31488 :     if (sl->redundant_pic_count > 0) {
    2036           1 :         sl->ref_count[0] = sl->ref_count[1] = 0;
    2037           1 :         return 0;
    2038             :     }
    2039             : 
    2040       31487 :     if (sl->first_mb_addr == 0 || !h->current_slice) {
    2041       25177 :         if (h->setup_finished) {
    2042           0 :             av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
    2043           0 :             return AVERROR_INVALIDDATA;
    2044             :         }
    2045             :     }
    2046             : 
    2047       31487 :     if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
    2048       25174 :         if (h->current_slice) {
    2049             :             // this slice starts a new field
    2050             :             // first decode any pending queued slices
    2051         193 :             if (h->nb_slice_ctx_queued) {
    2052             :                 H264SliceContext tmp_ctx;
    2053             : 
    2054           0 :                 ret = ff_h264_execute_decode_slices(h);
    2055           0 :                 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
    2056           0 :                     return ret;
    2057             : 
    2058           0 :                 memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
    2059           0 :                 memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
    2060           0 :                 memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
    2061           0 :                 sl = h->slice_ctx;
    2062             :             }
    2063             : 
    2064         193 :             if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
    2065         193 :                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
    2066         386 :                 if (ret < 0)
    2067           0 :                     return ret;
    2068           0 :             } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type  == H264_NAL_IDR_SLICE) {
    2069           0 :                 av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
    2070           0 :                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
    2071           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
    2072           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
    2073           0 :                 h->cur_pic_ptr = NULL;
    2074           0 :                 if (ret < 0)
    2075           0 :                     return ret;
    2076             :             } else
    2077           0 :                 return AVERROR_INVALIDDATA;
    2078             :         }
    2079             : 
    2080       25174 :         if (!h->first_field) {
    2081       21940 :             if (h->cur_pic_ptr && !h->droppable) {
    2082           0 :                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
    2083           0 :                                           h->picture_structure == PICT_BOTTOM_FIELD);
    2084             :             }
    2085       21940 :             h->cur_pic_ptr = NULL;
    2086             :         }
    2087             :     }
    2088             : 
    2089       31487 :     if (!h->current_slice)
    2090       25177 :         av_assert0(sl == h->slice_ctx);
    2091             : 
    2092       31487 :     if (h->current_slice == 0 && !h->first_field) {
    2093       21943 :         if (
    2094       43970 :             (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
    2095       43926 :             (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
    2096       43802 :             (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
    2097       43728 :             (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
    2098       21863 :             h->avctx->skip_frame >= AVDISCARD_ALL) {
    2099          80 :             return 0;
    2100             :         }
    2101             :     }
    2102             : 
    2103       31407 :     if (!first_slice) {
    2104        6503 :         const PPS *pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
    2105             : 
    2106       13006 :         if (h->ps.pps->sps_id != pps->sps_id ||
    2107        6503 :             h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
    2108             :             (h->setup_finished && h->ps.pps != pps)*/) {
    2109           0 :             av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
    2110           0 :             return AVERROR_INVALIDDATA;
    2111             :         }
    2112        6503 :         if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
    2113           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2114             :                "SPS changed in the middle of the frame\n");
    2115           0 :             return AVERROR_INVALIDDATA;
    2116             :         }
    2117             :     }
    2118             : 
    2119       31407 :     if (h->current_slice == 0) {
    2120       25097 :         ret = h264_field_start(h, sl, nal, first_slice);
    2121       25097 :         if (ret < 0)
    2122           0 :             return ret;
    2123             :     } else {
    2124       12620 :         if (h->picture_structure != sl->picture_structure ||
    2125        6310 :             h->droppable         != (nal->ref_idc == 0)) {
    2126           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2127             :                    "Changing field mode (%d -> %d) between slices is not allowed\n",
    2128             :                    h->picture_structure, sl->picture_structure);
    2129           0 :             return AVERROR_INVALIDDATA;
    2130        6310 :         } else if (!h->cur_pic_ptr) {
    2131           0 :             av_log(h->avctx, AV_LOG_ERROR,
    2132             :                    "unset cur_pic_ptr on slice %d\n",
    2133           0 :                    h->current_slice + 1);
    2134           0 :             return AVERROR_INVALIDDATA;
    2135             :         }
    2136             :     }
    2137             : 
    2138       31407 :     ret = h264_slice_init(h, sl, nal);
    2139       31407 :     if (ret < 0)
    2140           0 :         return ret;
    2141             : 
    2142       31407 :     h->nb_slice_ctx_queued++;
    2143             : 
    2144       31407 :     return 0;
    2145             : }
    2146             : 
    2147           0 : int ff_h264_get_slice_type(const H264SliceContext *sl)
    2148             : {
    2149           0 :     switch (sl->slice_type) {
    2150           0 :     case AV_PICTURE_TYPE_P:
    2151           0 :         return 0;
    2152           0 :     case AV_PICTURE_TYPE_B:
    2153           0 :         return 1;
    2154           0 :     case AV_PICTURE_TYPE_I:
    2155           0 :         return 2;
    2156           0 :     case AV_PICTURE_TYPE_SP:
    2157           0 :         return 3;
    2158           0 :     case AV_PICTURE_TYPE_SI:
    2159           0 :         return 4;
    2160           0 :     default:
    2161           0 :         return AVERROR_INVALIDDATA;
    2162             :     }
    2163             : }
    2164             : 
    2165    10225875 : static av_always_inline void fill_filter_caches_inter(const H264Context *h,
    2166             :                                                       H264SliceContext *sl,
    2167             :                                                       int mb_type, int top_xy,
    2168             :                                                       int left_xy[LEFT_MBS],
    2169             :                                                       int top_type,
    2170             :                                                       int left_type[LEFT_MBS],
    2171             :                                                       int mb_xy, int list)
    2172             : {
    2173    10225875 :     int b_stride = h->b_stride;
    2174    10225875 :     int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
    2175    10225875 :     int8_t *ref_cache   = &sl->ref_cache[list][scan8[0]];
    2176    10225875 :     if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
    2177    10225875 :         if (USES_LIST(top_type, list)) {
    2178     8136424 :             const int b_xy  = h->mb2b_xy[top_xy] + 3 * b_stride;
    2179     8136424 :             const int b8_xy = 4 * top_xy + 2;
    2180     8136424 :             const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2181     8136424 :             AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
    2182    16272848 :             ref_cache[0 - 1 * 8] =
    2183    16272848 :             ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
    2184    16272848 :             ref_cache[2 - 1 * 8] =
    2185    16272848 :             ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
    2186             :         } else {
    2187     2089451 :             AV_ZERO128(mv_dst - 1 * 8);
    2188     2089451 :             AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2189             :         }
    2190             : 
    2191    10225875 :         if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
    2192     9826284 :             if (USES_LIST(left_type[LTOP], list)) {
    2193     8121296 :                 const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
    2194     8121296 :                 const int b8_xy = 4 * left_xy[LTOP] + 1;
    2195     8121296 :                 const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2196     8121296 :                 AV_COPY32(mv_dst - 1 +  0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
    2197     8121296 :                 AV_COPY32(mv_dst - 1 +  8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
    2198     8121296 :                 AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
    2199     8121296 :                 AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
    2200    16242592 :                 ref_cache[-1 +  0] =
    2201    16242592 :                 ref_cache[-1 +  8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
    2202    16242592 :                 ref_cache[-1 + 16] =
    2203    16242592 :                 ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
    2204             :             } else {
    2205     1704988 :                 AV_ZERO32(mv_dst - 1 +  0);
    2206     1704988 :                 AV_ZERO32(mv_dst - 1 +  8);
    2207     1704988 :                 AV_ZERO32(mv_dst - 1 + 16);
    2208     1704988 :                 AV_ZERO32(mv_dst - 1 + 24);
    2209     3409976 :                 ref_cache[-1 +  0] =
    2210     5114964 :                 ref_cache[-1 +  8] =
    2211     5114964 :                 ref_cache[-1 + 16] =
    2212     3409976 :                 ref_cache[-1 + 24] = LIST_NOT_USED;
    2213             :             }
    2214             :         }
    2215             :     }
    2216             : 
    2217    10225875 :     if (!USES_LIST(mb_type, list)) {
    2218     1187477 :         fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
    2219     1187477 :         AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2220     1187477 :         AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2221     1187477 :         AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2222     1187477 :         AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
    2223     1187477 :         return;
    2224             :     }
    2225             : 
    2226             :     {
    2227     9038398 :         int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
    2228     9038398 :         const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
    2229     9038398 :         uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
    2230     9038398 :         uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
    2231     9038398 :         AV_WN32A(&ref_cache[0 * 8], ref01);
    2232     9038398 :         AV_WN32A(&ref_cache[1 * 8], ref01);
    2233     9038398 :         AV_WN32A(&ref_cache[2 * 8], ref23);
    2234     9038398 :         AV_WN32A(&ref_cache[3 * 8], ref23);
    2235             :     }
    2236             : 
    2237             :     {
    2238     9038398 :         int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
    2239     9038398 :         AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
    2240     9038398 :         AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
    2241     9038398 :         AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
    2242     9038398 :         AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
    2243             :     }
    2244             : }
    2245             : 
    2246             : /**
    2247             :  * @return non zero if the loop filter can be skipped
    2248             :  */
    2249    10341544 : static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
    2250             : {
    2251    10341544 :     const int mb_xy = sl->mb_xy;
    2252             :     int top_xy, left_xy[LEFT_MBS];
    2253             :     int top_type, left_type[LEFT_MBS];
    2254             :     uint8_t *nnz;
    2255             :     uint8_t *nnz_cache;
    2256             : 
    2257    10341544 :     top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
    2258             : 
    2259    10341544 :     left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
    2260    10341544 :     if (FRAME_MBAFF(h)) {
    2261     1576140 :         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
    2262     1576140 :         const int curr_mb_field_flag = IS_INTERLACED(mb_type);
    2263     1576140 :         if (sl->mb_y & 1) {
    2264      788070 :             if (left_mb_field_flag != curr_mb_field_flag)
    2265      189266 :                 left_xy[LTOP] -= h->mb_stride;
    2266             :         } else {
    2267      788070 :             if (curr_mb_field_flag)
    2268      482514 :                 top_xy += h->mb_stride &
    2269      241257 :                           (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
    2270      788070 :             if (left_mb_field_flag != curr_mb_field_flag)
    2271      189266 :                 left_xy[LBOT] += h->mb_stride;
    2272             :         }
    2273             :     }
    2274             : 
    2275    10341544 :     sl->top_mb_xy        = top_xy;
    2276    10341544 :     sl->left_mb_xy[LTOP] = left_xy[LTOP];
    2277    10341544 :     sl->left_mb_xy[LBOT] = left_xy[LBOT];
    2278             :     {
    2279             :         /* For sufficiently low qp, filtering wouldn't do anything.
    2280             :          * This is a conservative estimate: could also check beta_offset
    2281             :          * and more accurate chroma_qp. */
    2282    10341544 :         int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
    2283    10341544 :         int qp        = h->cur_pic.qscale_table[mb_xy];
    2284    11329610 :         if (qp <= qp_thresh &&
    2285     1975340 :             (left_xy[LTOP] < 0 ||
    2286     1911539 :              ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
    2287      885102 :             (top_xy < 0 ||
    2288      885102 :              ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
    2289      859312 :             if (!FRAME_MBAFF(h))
    2290      636867 :                 return 1;
    2291      444796 :             if ((left_xy[LTOP] < 0 ||
    2292      444391 :                  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
    2293      429509 :                 (top_xy < h->mb_stride ||
    2294      207469 :                  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
    2295      205646 :                 return 1;
    2296             :         }
    2297             :     }
    2298             : 
    2299     9499031 :     top_type        = h->cur_pic.mb_type[top_xy];
    2300     9499031 :     left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
    2301     9499031 :     left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
    2302     9499031 :     if (sl->deblocking_filter == 2) {
    2303      232380 :         if (h->slice_table[top_xy] != sl->slice_num)
    2304        3990 :             top_type = 0;
    2305      232380 :         if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
    2306        3056 :             left_type[LTOP] = left_type[LBOT] = 0;
    2307             :     } else {
    2308     9266651 :         if (h->slice_table[top_xy] == 0xFFFF)
    2309      443553 :             top_type = 0;
    2310     9266651 :         if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
    2311      285522 :             left_type[LTOP] = left_type[LBOT] = 0;
    2312             :     }
    2313     9499031 :     sl->top_type        = top_type;
    2314     9499031 :     sl->left_type[LTOP] = left_type[LTOP];
    2315     9499031 :     sl->left_type[LBOT] = left_type[LBOT];
    2316             : 
    2317     9499031 :     if (IS_INTRA(mb_type))
    2318     2812263 :         return 0;
    2319             : 
    2320     6686768 :     fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
    2321             :                              top_type, left_type, mb_xy, 0);
    2322     6686768 :     if (sl->list_count == 2)
    2323     3539107 :         fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
    2324             :                                  top_type, left_type, mb_xy, 1);
    2325             : 
    2326     6686768 :     nnz       = h->non_zero_count[mb_xy];
    2327     6686768 :     nnz_cache = sl->non_zero_count_cache;
    2328     6686768 :     AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
    2329     6686768 :     AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
    2330     6686768 :     AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
    2331     6686768 :     AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
    2332     6686768 :     sl->cbp = h->cbp_table[mb_xy];
    2333             : 
    2334     6686768 :     if (top_type) {
    2335     6336563 :         nnz = h->non_zero_count[top_xy];
    2336     6336563 :         AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
    2337             :     }
    2338             : 
    2339     6686768 :     if (left_type[LTOP]) {
    2340     6452094 :         nnz = h->non_zero_count[left_xy[LTOP]];
    2341     6452094 :         nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
    2342     6452094 :         nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
    2343     6452094 :         nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
    2344     6452094 :         nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
    2345             :     }
    2346             : 
    2347             :     /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
    2348             :      * from what the loop filter needs */
    2349     6686768 :     if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
    2350      246512 :         if (IS_8x8DCT(top_type)) {
    2351      215760 :             nnz_cache[4 + 8 * 0] =
    2352      215760 :             nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
    2353      215760 :             nnz_cache[6 + 8 * 0] =
    2354      215760 :             nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
    2355             :         }
    2356      246512 :         if (IS_8x8DCT(left_type[LTOP])) {
    2357      220912 :             nnz_cache[3 + 8 * 1] =
    2358      220912 :             nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
    2359             :         }
    2360      246512 :         if (IS_8x8DCT(left_type[LBOT])) {
    2361      221112 :             nnz_cache[3 + 8 * 3] =
    2362      221112 :             nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
    2363             :         }
    2364             : 
    2365      246512 :         if (IS_8x8DCT(mb_type)) {
    2366      209846 :             nnz_cache[scan8[0]] =
    2367      314769 :             nnz_cache[scan8[1]] =
    2368      314769 :             nnz_cache[scan8[2]] =
    2369      209846 :             nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
    2370             : 
    2371      209846 :             nnz_cache[scan8[0 + 4]] =
    2372      314769 :             nnz_cache[scan8[1 + 4]] =
    2373      314769 :             nnz_cache[scan8[2 + 4]] =
    2374      209846 :             nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
    2375             : 
    2376      209846 :             nnz_cache[scan8[0 + 8]] =
    2377      314769 :             nnz_cache[scan8[1 + 8]] =
    2378      314769 :             nnz_cache[scan8[2 + 8]] =
    2379      209846 :             nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
    2380             : 
    2381      209846 :             nnz_cache[scan8[0 + 12]] =
    2382      314769 :             nnz_cache[scan8[1 + 12]] =
    2383      314769 :             nnz_cache[scan8[2 + 12]] =
    2384      209846 :             nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
    2385             :         }
    2386             :     }
    2387             : 
    2388     6686768 :     return 0;
    2389             : }
    2390             : 
    2391      349296 : static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
    2392             : {
    2393             :     uint8_t *dest_y, *dest_cb, *dest_cr;
    2394             :     int linesize, uvlinesize, mb_x, mb_y;
    2395      349296 :     const int end_mb_y       = sl->mb_y + FRAME_MBAFF(h);
    2396      349296 :     const int old_slice_type = sl->slice_type;
    2397      349296 :     const int pixel_shift    = h->pixel_shift;
    2398      349296 :     const int block_h        = 16 >> h->chroma_y_shift;
    2399             : 
    2400      349296 :     if (h->postpone_filter)
    2401           0 :         return;
    2402             : 
    2403      349296 :     if (sl->deblocking_filter) {
    2404     9833608 :         for (mb_x = start_x; mb_x < end_x; mb_x++)
    2405    19895018 :             for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
    2406             :                 int mb_xy, mb_type;
    2407    10341544 :                 mb_xy         = sl->mb_xy = mb_x + mb_y * h->mb_stride;
    2408    10341544 :                 mb_type       = h->cur_pic.mb_type[mb_xy];
    2409             : 
    2410    10341544 :                 if (FRAME_MBAFF(h))
    2411     1576140 :                     sl->mb_mbaff               =
    2412     1576140 :                     sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
    2413             : 
    2414    10341544 :                 sl->mb_x = mb_x;
    2415    10341544 :                 sl->mb_y = mb_y;
    2416    20683088 :                 dest_y  = h->cur_pic.f->data[0] +
    2417    10341544 :                           ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
    2418    20683088 :                 dest_cb = h->cur_pic.f->data[1] +
    2419    20683088 :                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
    2420    10341544 :                           mb_y * sl->uvlinesize * block_h;
    2421    20683088 :                 dest_cr = h->cur_pic.f->data[2] +
    2422    20683088 :                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
    2423    10341544 :                           mb_y * sl->uvlinesize * block_h;
    2424             :                 // FIXME simplify above
    2425             : 
    2426    10341544 :                 if (MB_FIELD(sl)) {
    2427     3606600 :                     linesize   = sl->mb_linesize   = sl->linesize   * 2;
    2428     3606600 :                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
    2429     3606600 :                     if (mb_y & 1) { // FIXME move out of this function?
    2430     1802625 :                         dest_y  -= sl->linesize   * 15;
    2431     1802625 :                         dest_cb -= sl->uvlinesize * (block_h - 1);
    2432     1802625 :                         dest_cr -= sl->uvlinesize * (block_h - 1);
    2433             :                     }
    2434             :                 } else {
    2435     6734944 :                     linesize   = sl->mb_linesize   = sl->linesize;
    2436     6734944 :                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
    2437             :                 }
    2438    10341544 :                 backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
    2439             :                                  uvlinesize, 0);
    2440    10341544 :                 if (fill_filter_caches(h, sl, mb_type))
    2441      842513 :                     continue;
    2442     9499031 :                 sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
    2443     9499031 :                 sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
    2444             : 
    2445     9499031 :                 if (FRAME_MBAFF(h)) {
    2446     1370494 :                     ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
    2447             :                                       linesize, uvlinesize);
    2448             :                 } else {
    2449     8128537 :                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
    2450             :                                            dest_cr, linesize, uvlinesize);
    2451             :                 }
    2452             :             }
    2453             :     }
    2454      349296 :     sl->slice_type  = old_slice_type;
    2455      349296 :     sl->mb_x         = end_x;
    2456      349296 :     sl->mb_y         = end_mb_y - FRAME_MBAFF(h);
    2457      349296 :     sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
    2458      349296 :     sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
    2459             : }
    2460             : 
    2461       18076 : static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
    2462             : {
    2463       18076 :     const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
    2464       36152 :     int mb_type     = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
    2465       54092 :                       h->cur_pic.mb_type[mb_xy - 1] :
    2466       18076 :                       (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
    2467       17940 :                       h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
    2468       18076 :     sl->mb_mbaff    = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
    2469       18076 : }
    2470             : 
    2471             : /**
    2472             :  * Draw edges and report progress for the last MB row.
    2473             :  */
    2474      345201 : static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
    2475             : {
    2476      345201 :     int top            = 16 * (sl->mb_y      >> FIELD_PICTURE(h));
    2477      345201 :     int pic_height     = 16 *  h->mb_height >> FIELD_PICTURE(h);
    2478      345201 :     int height         =  16      << FRAME_MBAFF(h);
    2479      345201 :     int deblock_border = (16 + 4) << FRAME_MBAFF(h);
    2480             : 
    2481      345201 :     if (sl->deblocking_filter) {
    2482      277051 :         if ((top + height) >= pic_height)
    2483       19510 :             height += deblock_border;
    2484      277051 :         top -= deblock_border;
    2485             :     }
    2486             : 
    2487      345201 :     if (top >= pic_height || (top + height) < 0)
    2488       19519 :         return;
    2489             : 
    2490      325682 :     height = FFMIN(height, pic_height - top);
    2491      325682 :     if (top < 0) {
    2492       19515 :         height = top + height;
    2493       19515 :         top    = 0;
    2494             :     }
    2495             : 
    2496      325682 :     ff_h264_draw_horiz_band(h, sl, top, height);
    2497             : 
    2498      325682 :     if (h->droppable || sl->h264->slice_ctx[0].er.error_occurred)
    2499      118239 :         return;
    2500             : 
    2501      207443 :     ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
    2502      207443 :                               h->picture_structure == PICT_BOTTOM_FIELD);
    2503             : }
    2504             : 
    2505       31407 : static void er_add_slice(H264SliceContext *sl,
    2506             :                          int startx, int starty,
    2507             :                          int endx, int endy, int status)
    2508             : {
    2509       31407 :     if (!sl->h264->enable_er)
    2510           0 :         return;
    2511             : 
    2512             :     if (CONFIG_ERROR_RESILIENCE) {
    2513       31407 :         ERContext *er = &sl->h264->slice_ctx[0].er;
    2514             : 
    2515       31407 :         ff_er_add_slice(er, startx, starty, endx, endy, status);
    2516             :     }
    2517             : }
    2518             : 
    2519       31407 : static int decode_slice(struct AVCodecContext *avctx, void *arg)
    2520             : {
    2521       31407 :     H264SliceContext *sl = arg;
    2522       31407 :     const H264Context *h = sl->h264;
    2523       31407 :     int lf_x_start = sl->mb_x;
    2524       31407 :     int orig_deblock = sl->deblocking_filter;
    2525             :     int ret;
    2526             : 
    2527       31407 :     sl->linesize   = h->cur_pic_ptr->f->linesize[0];
    2528       31407 :     sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
    2529             : 
    2530       31407 :     ret = alloc_scratch_buffers(sl, sl->linesize);
    2531       31407 :     if (ret < 0)
    2532           0 :         return ret;
    2533             : 
    2534       31407 :     sl->mb_skip_run = -1;
    2535             : 
    2536       31407 :     av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
    2537             : 
    2538       31407 :     if (h->postpone_filter)
    2539           0 :         sl->deblocking_filter = 0;
    2540             : 
    2541       31407 :     sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
    2542             :                      (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
    2543             : 
    2544       31407 :     if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && h->slice_ctx[0].er.error_status_table) {
    2545       23009 :         const int start_i  = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
    2546       23009 :         if (start_i) {
    2547        4386 :             int prev_status = h->slice_ctx[0].er.error_status_table[h->slice_ctx[0].er.mb_index2xy[start_i - 1]];
    2548        4386 :             prev_status &= ~ VP_START;
    2549        4386 :             if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
    2550          13 :                 h->slice_ctx[0].er.error_occurred = 1;
    2551             :         }
    2552             :     }
    2553             : 
    2554       31407 :     if (h->ps.pps->cabac) {
    2555             :         /* realign */
    2556       15487 :         align_get_bits(&sl->gb);
    2557             : 
    2558             :         /* init cabac */
    2559       30974 :         ret = ff_init_cabac_decoder(&sl->cabac,
    2560       15487 :                               sl->gb.buffer + get_bits_count(&sl->gb) / 8,
    2561       15487 :                               (get_bits_left(&sl->gb) + 7) / 8);
    2562       15487 :         if (ret < 0)
    2563           0 :             return ret;
    2564             : 
    2565       15487 :         ff_h264_init_cabac_states(h, sl);
    2566             : 
    2567     7389839 :         for (;;) {
    2568             :             // START_TIMER
    2569             :             int ret, eos;
    2570     7405326 :             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
    2571           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
    2572             :                        sl->next_slice_idx);
    2573           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2574             :                              sl->mb_y, ER_MB_ERROR);
    2575           0 :                 return AVERROR_INVALIDDATA;
    2576             :             }
    2577             : 
    2578     7405326 :             ret = ff_h264_decode_mb_cabac(h, sl);
    2579             :             // STOP_TIMER("decode_mb_cabac")
    2580             : 
    2581     7405326 :             if (ret >= 0)
    2582     7405326 :                 ff_h264_hl_decode_mb(h, sl);
    2583             : 
    2584             :             // FIXME optimal? or let mb_decode decode 16x32 ?
    2585     7405326 :             if (ret >= 0 && FRAME_MBAFF(h)) {
    2586      679722 :                 sl->mb_y++;
    2587             : 
    2588      679722 :                 ret = ff_h264_decode_mb_cabac(h, sl);
    2589             : 
    2590      679722 :                 if (ret >= 0)
    2591      679722 :                     ff_h264_hl_decode_mb(h, sl);
    2592      679722 :                 sl->mb_y--;
    2593             :             }
    2594     7405326 :             eos = get_cabac_terminate(&sl->cabac);
    2595             : 
    2596     7405326 :             if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
    2597           0 :                 sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
    2598           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
    2599             :                              sl->mb_y, ER_MB_END);
    2600           0 :                 if (sl->mb_x >= lf_x_start)
    2601           0 :                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
    2602           0 :                 goto finish;
    2603             :             }
    2604     7405326 :             if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
    2605           1 :                 av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
    2606     7405326 :             if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
    2607           2 :                 av_log(h->avctx, AV_LOG_ERROR,
    2608             :                        "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
    2609             :                        sl->mb_x, sl->mb_y,
    2610           2 :                        sl->cabac.bytestream_end - sl->cabac.bytestream);
    2611           1 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2612             :                              sl->mb_y, ER_MB_ERROR);
    2613           1 :                 return AVERROR_INVALIDDATA;
    2614             :             }
    2615             : 
    2616     7405325 :             if (++sl->mb_x >= h->mb_width) {
    2617      192736 :                 loop_filter(h, sl, lf_x_start, sl->mb_x);
    2618      192736 :                 sl->mb_x = lf_x_start = 0;
    2619      192736 :                 decode_finish_row(h, sl);
    2620      192736 :                 ++sl->mb_y;
    2621      192736 :                 if (FIELD_OR_MBAFF_PICTURE(h)) {
    2622       64653 :                     ++sl->mb_y;
    2623       64653 :                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
    2624       13098 :                         predict_field_decoding_flag(h, sl);
    2625             :                 }
    2626             :             }
    2627             : 
    2628     7405325 :             if (eos || sl->mb_y >= h->mb_height) {
    2629             :                 ff_tlog(h->avctx, "slice end %d %d\n",
    2630             :                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2631       15486 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
    2632             :                              sl->mb_y, ER_MB_END);
    2633       15486 :                 if (sl->mb_x > lf_x_start)
    2634        1382 :                     loop_filter(h, sl, lf_x_start, sl->mb_x);
    2635       15486 :                 goto finish;
    2636             :             }
    2637             :         }
    2638             :     } else {
    2639     4073197 :         for (;;) {
    2640             :             int ret;
    2641             : 
    2642     4089117 :             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
    2643           0 :                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
    2644             :                        sl->next_slice_idx);
    2645           0 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2646             :                              sl->mb_y, ER_MB_ERROR);
    2647           0 :                 return AVERROR_INVALIDDATA;
    2648             :             }
    2649             : 
    2650     4089117 :             ret = ff_h264_decode_mb_cavlc(h, sl);
    2651             : 
    2652     4089117 :             if (ret >= 0)
    2653     4089103 :                 ff_h264_hl_decode_mb(h, sl);
    2654             : 
    2655             :             // FIXME optimal? or let mb_decode decode 16x32 ?
    2656     4089117 :             if (ret >= 0 && FRAME_MBAFF(h)) {
    2657      254472 :                 sl->mb_y++;
    2658      254472 :                 ret = ff_h264_decode_mb_cavlc(h, sl);
    2659             : 
    2660      254472 :                 if (ret >= 0)
    2661      254472 :                     ff_h264_hl_decode_mb(h, sl);
    2662      254472 :                 sl->mb_y--;
    2663             :             }
    2664             : 
    2665     4089117 :             if (ret < 0) {
    2666          14 :                 av_log(h->avctx, AV_LOG_ERROR,
    2667             :                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
    2668          14 :                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2669             :                              sl->mb_y, ER_MB_ERROR);
    2670          14 :                 return ret;
    2671             :             }
    2672             : 
    2673     4089103 :             if (++sl->mb_x >= h->mb_width) {
    2674      152465 :                 loop_filter(h, sl, lf_x_start, sl->mb_x);
    2675      152465 :                 sl->mb_x = lf_x_start = 0;
    2676      152465 :                 decode_finish_row(h, sl);
    2677      152465 :                 ++sl->mb_y;
    2678      152465 :                 if (FIELD_OR_MBAFF_PICTURE(h)) {
    2679       32147 :                     ++sl->mb_y;
    2680       32147 :                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
    2681        4978 :                         predict_field_decoding_flag(h, sl);
    2682             :                 }
    2683      152465 :                 if (sl->mb_y >= h->mb_height) {
    2684             :                     ff_tlog(h->avctx, "slice end %d %d\n",
    2685             :                             get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2686             : 
    2687       12328 :                     if (   get_bits_left(&sl->gb) == 0
    2688           0 :                         || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
    2689       24656 :                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2690       12328 :                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
    2691             : 
    2692       12328 :                         goto finish;
    2693             :                     } else {
    2694           0 :                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2695             :                                      sl->mb_x, sl->mb_y, ER_MB_END);
    2696             : 
    2697           0 :                         return AVERROR_INVALIDDATA;
    2698             :                     }
    2699             :                 }
    2700             :             }
    2701             : 
    2702     4076775 :             if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
    2703             :                 ff_tlog(h->avctx, "slice end %d %d\n",
    2704             :                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
    2705             : 
    2706        3578 :                 if (get_bits_left(&sl->gb) == 0) {
    2707        7154 :                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
    2708        3577 :                                  sl->mb_x - 1, sl->mb_y, ER_MB_END);
    2709        3577 :                     if (sl->mb_x > lf_x_start)
    2710        2713 :                         loop_filter(h, sl, lf_x_start, sl->mb_x);
    2711             : 
    2712        3577 :                     goto finish;
    2713             :                 } else {
    2714           1 :                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
    2715             :                                  sl->mb_y, ER_MB_ERROR);
    2716             : 
    2717           1 :                     return AVERROR_INVALIDDATA;
    2718             :                 }
    2719             :             }
    2720             :         }
    2721             :     }
    2722             : 
    2723       31391 : finish:
    2724       31391 :     sl->deblocking_filter = orig_deblock;
    2725       31391 :     return 0;
    2726             : }
    2727             : 
    2728             : /**
    2729             :  * Call decode_slice() for each context.
    2730             :  *
    2731             :  * @param h h264 master context
    2732             :  */
    2733       56845 : int ff_h264_execute_decode_slices(H264Context *h)
    2734             : {
    2735       56845 :     AVCodecContext *const avctx = h->avctx;
    2736             :     H264SliceContext *sl;
    2737       56845 :     int context_count = h->nb_slice_ctx_queued;
    2738       56845 :     int ret = 0;
    2739             :     int i, j;
    2740             : 
    2741       56845 :     h->slice_ctx[0].next_slice_idx = INT_MAX;
    2742             : 
    2743       56845 :     if (h->avctx->hwaccel || context_count < 1)
    2744       25438 :         return 0;
    2745             : 
    2746       31407 :     av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
    2747             : 
    2748       31407 :     if (context_count == 1) {
    2749             : 
    2750       31407 :         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
    2751       31407 :         h->postpone_filter = 0;
    2752             : 
    2753       31407 :         ret = decode_slice(avctx, &h->slice_ctx[0]);
    2754       31407 :         h->mb_y = h->slice_ctx[0].mb_y;
    2755       31407 :         if (ret < 0)
    2756          16 :             goto finish;
    2757             :     } else {
    2758           0 :         av_assert0(context_count > 0);
    2759           0 :         for (i = 0; i < context_count; i++) {
    2760           0 :             int next_slice_idx = h->mb_width * h->mb_height;
    2761             :             int slice_idx;
    2762             : 
    2763           0 :             sl                 = &h->slice_ctx[i];
    2764             :             if (CONFIG_ERROR_RESILIENCE) {
    2765           0 :                 sl->er.error_count = 0;
    2766             :             }
    2767             : 
    2768             :             /* make sure none of those slices overlap */
    2769           0 :             slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
    2770           0 :             for (j = 0; j < context_count; j++) {
    2771           0 :                 H264SliceContext *sl2 = &h->slice_ctx[j];
    2772           0 :                 int        slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
    2773             : 
    2774           0 :                 if (i == j || slice_idx2 < slice_idx)
    2775           0 :                     continue;
    2776           0 :                 next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
    2777             :             }
    2778           0 :             sl->next_slice_idx = next_slice_idx;
    2779             :         }
    2780             : 
    2781           0 :         avctx->execute(avctx, decode_slice, h->slice_ctx,
    2782             :                        NULL, context_count, sizeof(h->slice_ctx[0]));
    2783             : 
    2784             :         /* pull back stuff from slices to master context */
    2785           0 :         sl                   = &h->slice_ctx[context_count - 1];
    2786           0 :         h->mb_y              = sl->mb_y;
    2787             :         if (CONFIG_ERROR_RESILIENCE) {
    2788           0 :             for (i = 1; i < context_count; i++)
    2789           0 :                 h->slice_ctx[0].er.error_count += h->slice_ctx[i].er.error_count;
    2790             :         }
    2791             : 
    2792           0 :         if (h->postpone_filter) {
    2793           0 :             h->postpone_filter = 0;
    2794             : 
    2795           0 :             for (i = 0; i < context_count; i++) {
    2796             :                 int y_end, x_end;
    2797             : 
    2798           0 :                 sl = &h->slice_ctx[i];
    2799           0 :                 y_end = FFMIN(sl->mb_y + 1, h->mb_height);
    2800           0 :                 x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
    2801             : 
    2802           0 :                 for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
    2803           0 :                     sl->mb_y = j;
    2804           0 :                     loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
    2805           0 :                                 j == y_end - 1 ? x_end : h->mb_width);
    2806             :                 }
    2807             :             }
    2808             :         }
    2809             :     }
    2810             : 
    2811           0 : finish:
    2812       31407 :     h->nb_slice_ctx_queued = 0;
    2813       31407 :     return ret;
    2814             : }

Generated by: LCOV version 1.13