Subversion Repositories Kolibri OS

Rev

Blame | Last modification | View Log | RSS feed

  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 / MPEG4 part10 codec.
  25.  * @author Michael Niedermayer <michaelni@gmx.at>
  26.  */
  27.  
  28. #include "libavutil/avassert.h"
  29. #include "libavutil/imgutils.h"
  30. #include "libavutil/timer.h"
  31. #include "internal.h"
  32. #include "cabac.h"
  33. #include "cabac_functions.h"
  34. #include "error_resilience.h"
  35. #include "avcodec.h"
  36. #include "h264.h"
  37. #include "h264data.h"
  38. #include "h264chroma.h"
  39. #include "h264_mvpred.h"
  40. #include "golomb.h"
  41. #include "mathops.h"
  42. #include "mpegutils.h"
  43. #include "rectangle.h"
  44. #include "thread.h"
  45.  
  46.  
  47. static const uint8_t rem6[QP_MAX_NUM + 1] = {
  48.     0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
  49.     3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
  50.     0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2,
  51.     3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5, 0, 1, 2, 3, 4, 5,
  52.     0, 1, 2, 3,
  53. };
  54.  
  55. static const uint8_t div6[QP_MAX_NUM + 1] = {
  56.     0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 3,  3,  3,
  57.     3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 5, 6, 6, 6, 6,  6,  6,
  58.     7, 7, 7, 7, 7, 7, 8, 8, 8, 8, 8, 8, 9, 9, 9, 9, 9, 9, 10, 10, 10,
  59.    10,10,10,11,11,11,11,11,11,12,12,12,12,12,12,13,13,13, 13, 13, 13,
  60.    14,14,14,14,
  61. };
  62.  
  63. static const uint8_t field_scan[16+1] = {
  64.     0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
  65.     0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
  66.     2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
  67.     3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
  68. };
  69.  
  70. static const uint8_t field_scan8x8[64+1] = {
  71.     0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
  72.     1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
  73.     2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
  74.     0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
  75.     2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
  76.     2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
  77.     2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
  78.     3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
  79.     3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
  80.     4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
  81.     4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
  82.     5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
  83.     5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
  84.     7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
  85.     6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
  86.     7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
  87. };
  88.  
  89. static const uint8_t field_scan8x8_cavlc[64+1] = {
  90.     0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
  91.     2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
  92.     3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
  93.     5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
  94.     0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
  95.     1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
  96.     3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
  97.     5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
  98.     0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
  99.     1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
  100.     3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
  101.     5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
  102.     1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
  103.     1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
  104.     3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
  105.     6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
  106. };
  107.  
  108. // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
  109. static const uint8_t zigzag_scan8x8_cavlc[64+1] = {
  110.     0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
  111.     4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
  112.     3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
  113.     2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
  114.     1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
  115.     3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
  116.     2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
  117.     3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
  118.     0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
  119.     2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
  120.     1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
  121.     4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
  122.     0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
  123.     1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
  124.     0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
  125.     5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
  126. };
  127.  
  128. static const uint8_t dequant4_coeff_init[6][3] = {
  129.     { 10, 13, 16 },
  130.     { 11, 14, 18 },
  131.     { 13, 16, 20 },
  132.     { 14, 18, 23 },
  133.     { 16, 20, 25 },
  134.     { 18, 23, 29 },
  135. };
  136.  
  137. static const uint8_t dequant8_coeff_init_scan[16] = {
  138.     0, 3, 4, 3, 3, 1, 5, 1, 4, 5, 2, 5, 3, 1, 5, 1
  139. };
  140.  
  141. static const uint8_t dequant8_coeff_init[6][6] = {
  142.     { 20, 18, 32, 19, 25, 24 },
  143.     { 22, 19, 35, 21, 28, 26 },
  144.     { 26, 23, 42, 24, 33, 31 },
  145.     { 28, 25, 45, 26, 35, 33 },
  146.     { 32, 28, 51, 30, 40, 38 },
  147.     { 36, 32, 58, 34, 46, 43 },
  148. };
  149.  
  150.  
  151. static void release_unused_pictures(H264Context *h, int remove_current)
  152. {
  153.     int i;
  154.  
  155.     /* release non reference frames */
  156.     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
  157.         if (h->DPB[i].f->buf[0] && !h->DPB[i].reference &&
  158.             (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {
  159.             ff_h264_unref_picture(h, &h->DPB[i]);
  160.         }
  161.     }
  162. }
  163.  
  164. static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
  165. {
  166.     const H264Context *h = sl->h264;
  167.     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
  168.  
  169.     av_fast_malloc(&sl->bipred_scratchpad, &sl->bipred_scratchpad_allocated, 16 * 6 * alloc_size);
  170.     // edge emu needs blocksize + filter length - 1
  171.     // (= 21x21 for  h264)
  172.     av_fast_malloc(&sl->edge_emu_buffer, &sl->edge_emu_buffer_allocated, alloc_size * 2 * 21);
  173.  
  174.     av_fast_malloc(&sl->top_borders[0], &sl->top_borders_allocated[0],
  175.                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
  176.     av_fast_malloc(&sl->top_borders[1], &sl->top_borders_allocated[1],
  177.                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
  178.  
  179.     if (!sl->bipred_scratchpad || !sl->edge_emu_buffer ||
  180.         !sl->top_borders[0]    || !sl->top_borders[1]) {
  181.         av_freep(&sl->bipred_scratchpad);
  182.         av_freep(&sl->edge_emu_buffer);
  183.         av_freep(&sl->top_borders[0]);
  184.         av_freep(&sl->top_borders[1]);
  185.  
  186.         sl->bipred_scratchpad_allocated = 0;
  187.         sl->edge_emu_buffer_allocated   = 0;
  188.         sl->top_borders_allocated[0]    = 0;
  189.         sl->top_borders_allocated[1]    = 0;
  190.         return AVERROR(ENOMEM);
  191.     }
  192.  
  193.     return 0;
  194. }
  195.  
  196. static int init_table_pools(H264Context *h)
  197. {
  198.     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
  199.     const int mb_array_size = h->mb_stride * h->mb_height;
  200.     const int b4_stride     = h->mb_width * 4 + 1;
  201.     const int b4_array_size = b4_stride * h->mb_height * 4;
  202.  
  203.     h->qscale_table_pool = av_buffer_pool_init(big_mb_num + h->mb_stride,
  204.                                                av_buffer_allocz);
  205.     h->mb_type_pool      = av_buffer_pool_init((big_mb_num + h->mb_stride) *
  206.                                                sizeof(uint32_t), av_buffer_allocz);
  207.     h->motion_val_pool   = av_buffer_pool_init(2 * (b4_array_size + 4) *
  208.                                                sizeof(int16_t), av_buffer_allocz);
  209.     h->ref_index_pool    = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz);
  210.  
  211.     if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
  212.         !h->ref_index_pool) {
  213.         av_buffer_pool_uninit(&h->qscale_table_pool);
  214.         av_buffer_pool_uninit(&h->mb_type_pool);
  215.         av_buffer_pool_uninit(&h->motion_val_pool);
  216.         av_buffer_pool_uninit(&h->ref_index_pool);
  217.         return AVERROR(ENOMEM);
  218.     }
  219.  
  220.     return 0;
  221. }
  222.  
  223. static int alloc_picture(H264Context *h, H264Picture *pic)
  224. {
  225.     int i, ret = 0;
  226.  
  227.     av_assert0(!pic->f->data[0]);
  228.  
  229.     pic->tf.f = pic->f;
  230.     ret = ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ?
  231.                                                    AV_GET_BUFFER_FLAG_REF : 0);
  232.     if (ret < 0)
  233.         goto fail;
  234.  
  235.     pic->crop     = h->sps.crop;
  236.     pic->crop_top = h->sps.crop_top;
  237.     pic->crop_left= h->sps.crop_left;
  238.  
  239.     if (h->avctx->hwaccel) {
  240.         const AVHWAccel *hwaccel = h->avctx->hwaccel;
  241.         av_assert0(!pic->hwaccel_picture_private);
  242.         if (hwaccel->frame_priv_data_size) {
  243.             pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
  244.             if (!pic->hwaccel_priv_buf)
  245.                 return AVERROR(ENOMEM);
  246.             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
  247.         }
  248.     }
  249.     if (CONFIG_GRAY && !h->avctx->hwaccel && h->flags & AV_CODEC_FLAG_GRAY && pic->f->data[2]) {
  250.         int h_chroma_shift, v_chroma_shift;
  251.         av_pix_fmt_get_chroma_sub_sample(pic->f->format,
  252.                                          &h_chroma_shift, &v_chroma_shift);
  253.  
  254.         for(i=0; i<FF_CEIL_RSHIFT(pic->f->height, v_chroma_shift); i++) {
  255.             memset(pic->f->data[1] + pic->f->linesize[1]*i,
  256.                    0x80, FF_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
  257.             memset(pic->f->data[2] + pic->f->linesize[2]*i,
  258.                    0x80, FF_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
  259.         }
  260.     }
  261.  
  262.     if (!h->qscale_table_pool) {
  263.         ret = init_table_pools(h);
  264.         if (ret < 0)
  265.             goto fail;
  266.     }
  267.  
  268.     pic->qscale_table_buf = av_buffer_pool_get(h->qscale_table_pool);
  269.     pic->mb_type_buf      = av_buffer_pool_get(h->mb_type_pool);
  270.     if (!pic->qscale_table_buf || !pic->mb_type_buf)
  271.         goto fail;
  272.  
  273.     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
  274.     pic->qscale_table = pic->qscale_table_buf->data + 2 * h->mb_stride + 1;
  275.  
  276.     for (i = 0; i < 2; i++) {
  277.         pic->motion_val_buf[i] = av_buffer_pool_get(h->motion_val_pool);
  278.         pic->ref_index_buf[i]  = av_buffer_pool_get(h->ref_index_pool);
  279.         if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
  280.             goto fail;
  281.  
  282.         pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
  283.         pic->ref_index[i]  = pic->ref_index_buf[i]->data;
  284.     }
  285.  
  286.     return 0;
  287. fail:
  288.     ff_h264_unref_picture(h, pic);
  289.     return (ret < 0) ? ret : AVERROR(ENOMEM);
  290. }
  291.  
  292. static inline int pic_is_unused(H264Context *h, H264Picture *pic)
  293. {
  294.     if (!pic->f->buf[0])
  295.         return 1;
  296.     return 0;
  297. }
  298.  
  299. static int find_unused_picture(H264Context *h)
  300. {
  301.     int i;
  302.  
  303.     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
  304.         if (pic_is_unused(h, &h->DPB[i]))
  305.             break;
  306.     }
  307.     if (i == H264_MAX_PICTURE_COUNT)
  308.         return AVERROR_INVALIDDATA;
  309.  
  310.     return i;
  311. }
  312.  
  313.  
  314. static void init_dequant8_coeff_table(H264Context *h)
  315. {
  316.     int i, j, q, x;
  317.     const int max_qp = 51 + 6 * (h->sps.bit_depth_luma - 8);
  318.  
  319.     for (i = 0; i < 6; i++) {
  320.         h->dequant8_coeff[i] = h->dequant8_buffer[i];
  321.         for (j = 0; j < i; j++)
  322.             if (!memcmp(h->pps.scaling_matrix8[j], h->pps.scaling_matrix8[i],
  323.                         64 * sizeof(uint8_t))) {
  324.                 h->dequant8_coeff[i] = h->dequant8_buffer[j];
  325.                 break;
  326.             }
  327.         if (j < i)
  328.             continue;
  329.  
  330.         for (q = 0; q < max_qp + 1; q++) {
  331.             int shift = div6[q];
  332.             int idx   = rem6[q];
  333.             for (x = 0; x < 64; x++)
  334.                 h->dequant8_coeff[i][q][(x >> 3) | ((x & 7) << 3)] =
  335.                     ((uint32_t)dequant8_coeff_init[idx][dequant8_coeff_init_scan[((x >> 1) & 12) | (x & 3)]] *
  336.                      h->pps.scaling_matrix8[i][x]) << shift;
  337.         }
  338.     }
  339. }
  340.  
  341. static void init_dequant4_coeff_table(H264Context *h)
  342. {
  343.     int i, j, q, x;
  344.     const int max_qp = 51 + 6 * (h->sps.bit_depth_luma - 8);
  345.     for (i = 0; i < 6; i++) {
  346.         h->dequant4_coeff[i] = h->dequant4_buffer[i];
  347.         for (j = 0; j < i; j++)
  348.             if (!memcmp(h->pps.scaling_matrix4[j], h->pps.scaling_matrix4[i],
  349.                         16 * sizeof(uint8_t))) {
  350.                 h->dequant4_coeff[i] = h->dequant4_buffer[j];
  351.                 break;
  352.             }
  353.         if (j < i)
  354.             continue;
  355.  
  356.         for (q = 0; q < max_qp + 1; q++) {
  357.             int shift = div6[q] + 2;
  358.             int idx   = rem6[q];
  359.             for (x = 0; x < 16; x++)
  360.                 h->dequant4_coeff[i][q][(x >> 2) | ((x << 2) & 0xF)] =
  361.                     ((uint32_t)dequant4_coeff_init[idx][(x & 1) + ((x >> 2) & 1)] *
  362.                      h->pps.scaling_matrix4[i][x]) << shift;
  363.         }
  364.     }
  365. }
  366.  
  367. void ff_h264_init_dequant_tables(H264Context *h)
  368. {
  369.     int i, x;
  370.     init_dequant4_coeff_table(h);
  371.     memset(h->dequant8_coeff, 0, sizeof(h->dequant8_coeff));
  372.  
  373.     if (h->pps.transform_8x8_mode)
  374.         init_dequant8_coeff_table(h);
  375.     if (h->sps.transform_bypass) {
  376.         for (i = 0; i < 6; i++)
  377.             for (x = 0; x < 16; x++)
  378.                 h->dequant4_coeff[i][0][x] = 1 << 6;
  379.         if (h->pps.transform_8x8_mode)
  380.             for (i = 0; i < 6; i++)
  381.                 for (x = 0; x < 64; x++)
  382.                     h->dequant8_coeff[i][0][x] = 1 << 6;
  383.     }
  384. }
  385.  
  386. #define IN_RANGE(a, b, size) (((void*)(a) >= (void*)(b)) && ((void*)(a) < (void*)((b) + (size))))
  387.  
  388. #define REBASE_PICTURE(pic, new_ctx, old_ctx)             \
  389.     (((pic) && (pic) >= (old_ctx)->DPB &&                       \
  390.       (pic) < (old_ctx)->DPB + H264_MAX_PICTURE_COUNT) ?          \
  391.      &(new_ctx)->DPB[(pic) - (old_ctx)->DPB] : NULL)
  392.  
  393. static void copy_picture_range(H264Picture **to, H264Picture **from, int count,
  394.                                H264Context *new_base,
  395.                                H264Context *old_base)
  396. {
  397.     int i;
  398.  
  399.     for (i = 0; i < count; i++) {
  400.         av_assert1(!from[i] ||
  401.                    IN_RANGE(from[i], old_base, 1) ||
  402.                    IN_RANGE(from[i], old_base->DPB, H264_MAX_PICTURE_COUNT));
  403.         to[i] = REBASE_PICTURE(from[i], new_base, old_base);
  404.     }
  405. }
  406.  
  407. static int copy_parameter_set(void **to, void **from, int count, int size)
  408. {
  409.     int i;
  410.  
  411.     for (i = 0; i < count; i++) {
  412.         if (to[i] && !from[i]) {
  413.             av_freep(&to[i]);
  414.         } else if (from[i] && !to[i]) {
  415.             to[i] = av_malloc(size);
  416.             if (!to[i])
  417.                 return AVERROR(ENOMEM);
  418.         }
  419.  
  420.         if (from[i])
  421.             memcpy(to[i], from[i], size);
  422.     }
  423.  
  424.     return 0;
  425. }
  426.  
  427. #define copy_fields(to, from, start_field, end_field)                   \
  428.     memcpy(&(to)->start_field, &(from)->start_field,                        \
  429.            (char *)&(to)->end_field - (char *)&(to)->start_field)
  430.  
  431. static int h264_slice_header_init(H264Context *h);
  432.  
  433. int ff_h264_update_thread_context(AVCodecContext *dst,
  434.                                   const AVCodecContext *src)
  435. {
  436.     H264Context *h = dst->priv_data, *h1 = src->priv_data;
  437.     int inited = h->context_initialized, err = 0;
  438.     int need_reinit = 0;
  439.     int i, ret;
  440.  
  441.     if (dst == src)
  442.         return 0;
  443.  
  444.     if (inited &&
  445.         (h->width                 != h1->width                 ||
  446.          h->height                != h1->height                ||
  447.          h->mb_width              != h1->mb_width              ||
  448.          h->mb_height             != h1->mb_height             ||
  449.          h->sps.bit_depth_luma    != h1->sps.bit_depth_luma    ||
  450.          h->sps.chroma_format_idc != h1->sps.chroma_format_idc ||
  451.          h->sps.colorspace        != h1->sps.colorspace)) {
  452.  
  453.         need_reinit = 1;
  454.     }
  455.  
  456.     /* copy block_offset since frame_start may not be called */
  457.     memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
  458.  
  459.     // SPS/PPS
  460.     if ((ret = copy_parameter_set((void **)h->sps_buffers,
  461.                                   (void **)h1->sps_buffers,
  462.                                   MAX_SPS_COUNT, sizeof(SPS))) < 0)
  463.         return ret;
  464.     h->sps = h1->sps;
  465.     if ((ret = copy_parameter_set((void **)h->pps_buffers,
  466.                                   (void **)h1->pps_buffers,
  467.                                   MAX_PPS_COUNT, sizeof(PPS))) < 0)
  468.         return ret;
  469.     h->pps = h1->pps;
  470.  
  471.     if (need_reinit || !inited) {
  472.         h->width     = h1->width;
  473.         h->height    = h1->height;
  474.         h->mb_height = h1->mb_height;
  475.         h->mb_width  = h1->mb_width;
  476.         h->mb_num    = h1->mb_num;
  477.         h->mb_stride = h1->mb_stride;
  478.         h->b_stride  = h1->b_stride;
  479.  
  480.         if (h->context_initialized || h1->context_initialized) {
  481.             if ((err = h264_slice_header_init(h)) < 0) {
  482.                 av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
  483.                 return err;
  484.             }
  485.         }
  486.         /* copy block_offset since frame_start may not be called */
  487.         memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
  488.     }
  489.  
  490.     h->avctx->coded_height  = h1->avctx->coded_height;
  491.     h->avctx->coded_width   = h1->avctx->coded_width;
  492.     h->avctx->width         = h1->avctx->width;
  493.     h->avctx->height        = h1->avctx->height;
  494.     h->coded_picture_number = h1->coded_picture_number;
  495.     h->first_field          = h1->first_field;
  496.     h->picture_structure    = h1->picture_structure;
  497.     h->droppable            = h1->droppable;
  498.     h->low_delay            = h1->low_delay;
  499.     h->backup_width         = h1->backup_width;
  500.     h->backup_height        = h1->backup_height;
  501.     h->backup_pix_fmt       = h1->backup_pix_fmt;
  502.  
  503.     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
  504.         ff_h264_unref_picture(h, &h->DPB[i]);
  505.         if (h1->DPB[i].f->buf[0] &&
  506.             (ret = ff_h264_ref_picture(h, &h->DPB[i], &h1->DPB[i])) < 0)
  507.             return ret;
  508.     }
  509.  
  510.     h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
  511.     ff_h264_unref_picture(h, &h->cur_pic);
  512.     if (h1->cur_pic.f->buf[0]) {
  513.         ret = ff_h264_ref_picture(h, &h->cur_pic, &h1->cur_pic);
  514.         if (ret < 0)
  515.             return ret;
  516.     }
  517.  
  518.     h->enable_er       = h1->enable_er;
  519.     h->workaround_bugs = h1->workaround_bugs;
  520.     h->low_delay       = h1->low_delay;
  521.     h->droppable       = h1->droppable;
  522.  
  523.     // extradata/NAL handling
  524.     h->is_avc = h1->is_avc;
  525.     h->nal_length_size = h1->nal_length_size;
  526.     h->x264_build      = h1->x264_build;
  527.  
  528.     // Dequantization matrices
  529.     // FIXME these are big - can they be only copied when PPS changes?
  530.     copy_fields(h, h1, dequant4_buffer, dequant4_coeff);
  531.  
  532.     for (i = 0; i < 6; i++)
  533.         h->dequant4_coeff[i] = h->dequant4_buffer[0] +
  534.                                (h1->dequant4_coeff[i] - h1->dequant4_buffer[0]);
  535.  
  536.     for (i = 0; i < 6; i++)
  537.         h->dequant8_coeff[i] = h->dequant8_buffer[0] +
  538.                                (h1->dequant8_coeff[i] - h1->dequant8_buffer[0]);
  539.  
  540.     h->dequant_coeff_pps = h1->dequant_coeff_pps;
  541.  
  542.     // POC timing
  543.     copy_fields(h, h1, poc_lsb, default_ref_list);
  544.  
  545.     // reference lists
  546.     copy_fields(h, h1, short_ref, current_slice);
  547.  
  548.     copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
  549.     copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
  550.     copy_picture_range(h->delayed_pic, h1->delayed_pic,
  551.                        MAX_DELAYED_PIC_COUNT + 2, h, h1);
  552.  
  553.     h->frame_recovered       = h1->frame_recovered;
  554.  
  555.     if (!h->cur_pic_ptr)
  556.         return 0;
  557.  
  558.     if (!h->droppable) {
  559.         err = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  560.         h->prev_poc_msb = h->poc_msb;
  561.         h->prev_poc_lsb = h->poc_lsb;
  562.     }
  563.     h->prev_frame_num_offset = h->frame_num_offset;
  564.     h->prev_frame_num        = h->frame_num;
  565.  
  566.     h->recovery_frame        = h1->recovery_frame;
  567.  
  568.     return err;
  569. }
  570.  
  571. static int h264_frame_start(H264Context *h)
  572. {
  573.     H264Picture *pic;
  574.     int i, ret;
  575.     const int pixel_shift = h->pixel_shift;
  576.     int c[4] = {
  577.         1<<(h->sps.bit_depth_luma-1),
  578.         1<<(h->sps.bit_depth_chroma-1),
  579.         1<<(h->sps.bit_depth_chroma-1),
  580.         -1
  581.     };
  582.  
  583.     if (!ff_thread_can_start_frame(h->avctx)) {
  584.         av_log(h->avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
  585.         return -1;
  586.     }
  587.  
  588.     release_unused_pictures(h, 1);
  589.     h->cur_pic_ptr = NULL;
  590.  
  591.     i = find_unused_picture(h);
  592.     if (i < 0) {
  593.         av_log(h->avctx, AV_LOG_ERROR, "no frame buffer available\n");
  594.         return i;
  595.     }
  596.     pic = &h->DPB[i];
  597.  
  598.     pic->reference              = h->droppable ? 0 : h->picture_structure;
  599.     pic->f->coded_picture_number = h->coded_picture_number++;
  600.     pic->field_picture          = h->picture_structure != PICT_FRAME;
  601.  
  602.     /*
  603.      * Zero key_frame here; IDR markings per slice in frame or fields are ORed
  604.      * in later.
  605.      * See decode_nal_units().
  606.      */
  607.     pic->f->key_frame = 0;
  608.     pic->mmco_reset  = 0;
  609.     pic->recovered   = 0;
  610.     pic->invalid_gap = 0;
  611.     pic->sei_recovery_frame_cnt = h->sei_recovery_frame_cnt;
  612.  
  613.     if ((ret = alloc_picture(h, pic)) < 0)
  614.         return ret;
  615.     if(!h->frame_recovered && !h->avctx->hwaccel
  616. #if FF_API_CAP_VDPAU
  617.        && !(h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU)
  618. #endif
  619.        )
  620.         avpriv_color_frame(pic->f, c);
  621.  
  622.     h->cur_pic_ptr = pic;
  623.     ff_h264_unref_picture(h, &h->cur_pic);
  624.     if (CONFIG_ERROR_RESILIENCE) {
  625.         ff_h264_set_erpic(&h->slice_ctx[0].er.cur_pic, NULL);
  626.     }
  627.  
  628.     if ((ret = ff_h264_ref_picture(h, &h->cur_pic, h->cur_pic_ptr)) < 0)
  629.         return ret;
  630.  
  631.     for (i = 0; i < h->nb_slice_ctx; i++) {
  632.         h->slice_ctx[i].linesize   = h->cur_pic_ptr->f->linesize[0];
  633.         h->slice_ctx[i].uvlinesize = h->cur_pic_ptr->f->linesize[1];
  634.     }
  635.  
  636.     if (CONFIG_ERROR_RESILIENCE && h->enable_er) {
  637.         ff_er_frame_start(&h->slice_ctx[0].er);
  638.         ff_h264_set_erpic(&h->slice_ctx[0].er.last_pic, NULL);
  639.         ff_h264_set_erpic(&h->slice_ctx[0].er.next_pic, NULL);
  640.     }
  641.  
  642.     for (i = 0; i < 16; i++) {
  643.         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
  644.         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
  645.     }
  646.     for (i = 0; i < 16; i++) {
  647.         h->block_offset[16 + i]      =
  648.         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
  649.         h->block_offset[48 + 16 + i] =
  650.         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
  651.     }
  652.  
  653.     /* We mark the current picture as non-reference after allocating it, so
  654.      * that if we break out due to an error it can be released automatically
  655.      * in the next ff_mpv_frame_start().
  656.      */
  657.     h->cur_pic_ptr->reference = 0;
  658.  
  659.     h->cur_pic_ptr->field_poc[0] = h->cur_pic_ptr->field_poc[1] = INT_MAX;
  660.  
  661.     h->next_output_pic = NULL;
  662.  
  663.     assert(h->cur_pic_ptr->long_ref == 0);
  664.  
  665.     return 0;
  666. }
  667.  
  668. static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
  669.                                               uint8_t *src_y,
  670.                                               uint8_t *src_cb, uint8_t *src_cr,
  671.                                               int linesize, int uvlinesize,
  672.                                               int simple)
  673. {
  674.     uint8_t *top_border;
  675.     int top_idx = 1;
  676.     const int pixel_shift = h->pixel_shift;
  677.     int chroma444 = CHROMA444(h);
  678.     int chroma422 = CHROMA422(h);
  679.  
  680.     src_y  -= linesize;
  681.     src_cb -= uvlinesize;
  682.     src_cr -= uvlinesize;
  683.  
  684.     if (!simple && FRAME_MBAFF(h)) {
  685.         if (sl->mb_y & 1) {
  686.             if (!MB_MBAFF(sl)) {
  687.                 top_border = sl->top_borders[0][sl->mb_x];
  688.                 AV_COPY128(top_border, src_y + 15 * linesize);
  689.                 if (pixel_shift)
  690.                     AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
  691.                 if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
  692.                     if (chroma444) {
  693.                         if (pixel_shift) {
  694.                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
  695.                             AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
  696.                             AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
  697.                             AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
  698.                         } else {
  699.                             AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
  700.                             AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
  701.                         }
  702.                     } else if (chroma422) {
  703.                         if (pixel_shift) {
  704.                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
  705.                             AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
  706.                         } else {
  707.                             AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
  708.                             AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
  709.                         }
  710.                     } else {
  711.                         if (pixel_shift) {
  712.                             AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
  713.                             AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
  714.                         } else {
  715.                             AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
  716.                             AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
  717.                         }
  718.                     }
  719.                 }
  720.             }
  721.         } else if (MB_MBAFF(sl)) {
  722.             top_idx = 0;
  723.         } else
  724.             return;
  725.     }
  726.  
  727.     top_border = sl->top_borders[top_idx][sl->mb_x];
  728.     /* There are two lines saved, the line above the top macroblock
  729.      * of a pair, and the line above the bottom macroblock. */
  730.     AV_COPY128(top_border, src_y + 16 * linesize);
  731.     if (pixel_shift)
  732.         AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
  733.  
  734.     if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
  735.         if (chroma444) {
  736.             if (pixel_shift) {
  737.                 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
  738.                 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
  739.                 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
  740.                 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
  741.             } else {
  742.                 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
  743.                 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
  744.             }
  745.         } else if (chroma422) {
  746.             if (pixel_shift) {
  747.                 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
  748.                 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
  749.             } else {
  750.                 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
  751.                 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
  752.             }
  753.         } else {
  754.             if (pixel_shift) {
  755.                 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
  756.                 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
  757.             } else {
  758.                 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
  759.                 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
  760.             }
  761.         }
  762.     }
  763. }
  764.  
  765. /**
  766.  * Initialize implicit_weight table.
  767.  * @param field  0/1 initialize the weight for interlaced MBAFF
  768.  *                -1 initializes the rest
  769.  */
  770. static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
  771. {
  772.     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
  773.  
  774.     for (i = 0; i < 2; i++) {
  775.         sl->luma_weight_flag[i]   = 0;
  776.         sl->chroma_weight_flag[i] = 0;
  777.     }
  778.  
  779.     if (field < 0) {
  780.         if (h->picture_structure == PICT_FRAME) {
  781.             cur_poc = h->cur_pic_ptr->poc;
  782.         } else {
  783.             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
  784.         }
  785.         if (sl->ref_count[0] == 1 && sl->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
  786.             sl->ref_list[0][0].poc + (int64_t)sl->ref_list[1][0].poc == 2 * cur_poc) {
  787.             sl->use_weight        = 0;
  788.             sl->use_weight_chroma = 0;
  789.             return;
  790.         }
  791.         ref_start  = 0;
  792.         ref_count0 = sl->ref_count[0];
  793.         ref_count1 = sl->ref_count[1];
  794.     } else {
  795.         cur_poc    = h->cur_pic_ptr->field_poc[field];
  796.         ref_start  = 16;
  797.         ref_count0 = 16 + 2 * sl->ref_count[0];
  798.         ref_count1 = 16 + 2 * sl->ref_count[1];
  799.     }
  800.  
  801.     sl->use_weight               = 2;
  802.     sl->use_weight_chroma        = 2;
  803.     sl->luma_log2_weight_denom   = 5;
  804.     sl->chroma_log2_weight_denom = 5;
  805.  
  806.     for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
  807.         int64_t poc0 = sl->ref_list[0][ref0].poc;
  808.         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
  809.             int w = 32;
  810.             if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
  811.                 int poc1 = sl->ref_list[1][ref1].poc;
  812.                 int td   = av_clip_int8(poc1 - poc0);
  813.                 if (td) {
  814.                     int tb = av_clip_int8(cur_poc - poc0);
  815.                     int tx = (16384 + (FFABS(td) >> 1)) / td;
  816.                     int dist_scale_factor = (tb * tx + 32) >> 8;
  817.                     if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
  818.                         w = 64 - dist_scale_factor;
  819.                 }
  820.             }
  821.             if (field < 0) {
  822.                 sl->implicit_weight[ref0][ref1][0] =
  823.                 sl->implicit_weight[ref0][ref1][1] = w;
  824.             } else {
  825.                 sl->implicit_weight[ref0][ref1][field] = w;
  826.             }
  827.         }
  828.     }
  829. }
  830.  
  831. /**
  832.  * initialize scan tables
  833.  */
  834. static void init_scan_tables(H264Context *h)
  835. {
  836.     int i;
  837.     for (i = 0; i < 16; i++) {
  838. #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
  839.         h->zigzag_scan[i] = TRANSPOSE(zigzag_scan[i]);
  840.         h->field_scan[i]  = TRANSPOSE(field_scan[i]);
  841. #undef TRANSPOSE
  842.     }
  843.     for (i = 0; i < 64; i++) {
  844. #define TRANSPOSE(x) ((x) >> 3) | (((x) & 7) << 3)
  845.         h->zigzag_scan8x8[i]       = TRANSPOSE(ff_zigzag_direct[i]);
  846.         h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
  847.         h->field_scan8x8[i]        = TRANSPOSE(field_scan8x8[i]);
  848.         h->field_scan8x8_cavlc[i]  = TRANSPOSE(field_scan8x8_cavlc[i]);
  849. #undef TRANSPOSE
  850.     }
  851.     if (h->sps.transform_bypass) { // FIXME same ugly
  852.         memcpy(h->zigzag_scan_q0          , zigzag_scan             , sizeof(h->zigzag_scan_q0         ));
  853.         memcpy(h->zigzag_scan8x8_q0       , ff_zigzag_direct        , sizeof(h->zigzag_scan8x8_q0      ));
  854.         memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc    , sizeof(h->zigzag_scan8x8_cavlc_q0));
  855.         memcpy(h->field_scan_q0           , field_scan              , sizeof(h->field_scan_q0          ));
  856.         memcpy(h->field_scan8x8_q0        , field_scan8x8           , sizeof(h->field_scan8x8_q0       ));
  857.         memcpy(h->field_scan8x8_cavlc_q0  , field_scan8x8_cavlc     , sizeof(h->field_scan8x8_cavlc_q0 ));
  858.     } else {
  859.         memcpy(h->zigzag_scan_q0          , h->zigzag_scan          , sizeof(h->zigzag_scan_q0         ));
  860.         memcpy(h->zigzag_scan8x8_q0       , h->zigzag_scan8x8       , sizeof(h->zigzag_scan8x8_q0      ));
  861.         memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
  862.         memcpy(h->field_scan_q0           , h->field_scan           , sizeof(h->field_scan_q0          ));
  863.         memcpy(h->field_scan8x8_q0        , h->field_scan8x8        , sizeof(h->field_scan8x8_q0       ));
  864.         memcpy(h->field_scan8x8_cavlc_q0  , h->field_scan8x8_cavlc  , sizeof(h->field_scan8x8_cavlc_q0 ));
  865.     }
  866. }
  867.  
  868. static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
  869. {
  870. #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
  871.                      CONFIG_H264_D3D11VA_HWACCEL + \
  872.                      CONFIG_H264_VAAPI_HWACCEL + \
  873.                      (CONFIG_H264_VDA_HWACCEL * 2) + \
  874.                      CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \
  875.                      CONFIG_H264_VDPAU_HWACCEL)
  876.     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
  877.     const enum AVPixelFormat *choices = pix_fmts;
  878.     int i;
  879.  
  880.     switch (h->sps.bit_depth_luma) {
  881.     case 9:
  882.         if (CHROMA444(h)) {
  883.             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
  884.                 *fmt++ = AV_PIX_FMT_GBRP9;
  885.             } else
  886.                 *fmt++ = AV_PIX_FMT_YUV444P9;
  887.         } else if (CHROMA422(h))
  888.             *fmt++ = AV_PIX_FMT_YUV422P9;
  889.         else
  890.             *fmt++ = AV_PIX_FMT_YUV420P9;
  891.         break;
  892.     case 10:
  893.         if (CHROMA444(h)) {
  894.             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
  895.                 *fmt++ = AV_PIX_FMT_GBRP10;
  896.             } else
  897.                 *fmt++ = AV_PIX_FMT_YUV444P10;
  898.         } else if (CHROMA422(h))
  899.             *fmt++ = AV_PIX_FMT_YUV422P10;
  900.         else
  901.             *fmt++ = AV_PIX_FMT_YUV420P10;
  902.         break;
  903.     case 12:
  904.         if (CHROMA444(h)) {
  905.             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
  906.                 *fmt++ = AV_PIX_FMT_GBRP12;
  907.             } else
  908.                 *fmt++ = AV_PIX_FMT_YUV444P12;
  909.         } else if (CHROMA422(h))
  910.             *fmt++ = AV_PIX_FMT_YUV422P12;
  911.         else
  912.             *fmt++ = AV_PIX_FMT_YUV420P12;
  913.         break;
  914.     case 14:
  915.         if (CHROMA444(h)) {
  916.             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
  917.                 *fmt++ = AV_PIX_FMT_GBRP14;
  918.             } else
  919.                 *fmt++ = AV_PIX_FMT_YUV444P14;
  920.         } else if (CHROMA422(h))
  921.             *fmt++ = AV_PIX_FMT_YUV422P14;
  922.         else
  923.             *fmt++ = AV_PIX_FMT_YUV420P14;
  924.         break;
  925.     case 8:
  926. #if CONFIG_H264_VDPAU_HWACCEL
  927.         *fmt++ = AV_PIX_FMT_VDPAU;
  928. #endif
  929.         if (CHROMA444(h)) {
  930.             if (h->avctx->colorspace == AVCOL_SPC_RGB)
  931.                 *fmt++ = AV_PIX_FMT_GBRP;
  932.             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
  933.                 *fmt++ = AV_PIX_FMT_YUVJ444P;
  934.             else
  935.                 *fmt++ = AV_PIX_FMT_YUV444P;
  936.         } else if (CHROMA422(h)) {
  937.             if (h->avctx->color_range == AVCOL_RANGE_JPEG)
  938.                 *fmt++ = AV_PIX_FMT_YUVJ422P;
  939.             else
  940.                 *fmt++ = AV_PIX_FMT_YUV422P;
  941.         } else {
  942. #if CONFIG_H264_DXVA2_HWACCEL
  943.             *fmt++ = AV_PIX_FMT_DXVA2_VLD;
  944. #endif
  945. #if CONFIG_H264_D3D11VA_HWACCEL
  946.             *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
  947. #endif
  948. #if CONFIG_H264_VAAPI_HWACCEL
  949.             *fmt++ = AV_PIX_FMT_VAAPI;
  950. #endif
  951. #if CONFIG_H264_VDA_HWACCEL
  952.             *fmt++ = AV_PIX_FMT_VDA_VLD;
  953.             *fmt++ = AV_PIX_FMT_VDA;
  954. #endif
  955. #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
  956.             *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
  957. #endif
  958.             if (h->avctx->codec->pix_fmts)
  959.                 choices = h->avctx->codec->pix_fmts;
  960.             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
  961.                 *fmt++ = AV_PIX_FMT_YUVJ420P;
  962.             else
  963.                 *fmt++ = AV_PIX_FMT_YUV420P;
  964.         }
  965.         break;
  966.     default:
  967.         av_log(h->avctx, AV_LOG_ERROR,
  968.                "Unsupported bit depth %d\n", h->sps.bit_depth_luma);
  969.         return AVERROR_INVALIDDATA;
  970.     }
  971.  
  972.     *fmt = AV_PIX_FMT_NONE;
  973.  
  974.     for (i=0; choices[i] != AV_PIX_FMT_NONE; i++)
  975.         if (choices[i] == h->avctx->pix_fmt && !force_callback)
  976.             return choices[i];
  977.     return ff_thread_get_format(h->avctx, choices);
  978. }
  979.  
  980. /* export coded and cropped frame dimensions to AVCodecContext */
  981. static int init_dimensions(H264Context *h)
  982. {
  983.     int width  = h->width  - (h->sps.crop_right + h->sps.crop_left);
  984.     int height = h->height - (h->sps.crop_top   + h->sps.crop_bottom);
  985.     av_assert0(h->sps.crop_right + h->sps.crop_left < (unsigned)h->width);
  986.     av_assert0(h->sps.crop_top + h->sps.crop_bottom < (unsigned)h->height);
  987.  
  988.     /* handle container cropping */
  989.     if (FFALIGN(h->avctx->width,  16) == FFALIGN(width,  16) &&
  990.         FFALIGN(h->avctx->height, 16) == FFALIGN(height, 16) &&
  991.         h->avctx->width  <= width &&
  992.         h->avctx->height <= height
  993.     ) {
  994.         width  = h->avctx->width;
  995.         height = h->avctx->height;
  996.     }
  997.  
  998.     if (width <= 0 || height <= 0) {
  999.         av_log(h->avctx, AV_LOG_ERROR, "Invalid cropped dimensions: %dx%d.\n",
  1000.                width, height);
  1001.         if (h->avctx->err_recognition & AV_EF_EXPLODE)
  1002.             return AVERROR_INVALIDDATA;
  1003.  
  1004.         av_log(h->avctx, AV_LOG_WARNING, "Ignoring cropping information.\n");
  1005.         h->sps.crop_bottom =
  1006.         h->sps.crop_top    =
  1007.         h->sps.crop_right  =
  1008.         h->sps.crop_left   =
  1009.         h->sps.crop        = 0;
  1010.  
  1011.         width  = h->width;
  1012.         height = h->height;
  1013.     }
  1014.  
  1015.     h->avctx->coded_width  = h->width;
  1016.     h->avctx->coded_height = h->height;
  1017.     h->avctx->width        = width;
  1018.     h->avctx->height       = height;
  1019.  
  1020.     return 0;
  1021. }
  1022.  
  1023. static int h264_slice_header_init(H264Context *h)
  1024. {
  1025.     int nb_slices = (HAVE_THREADS &&
  1026.                      h->avctx->active_thread_type & FF_THREAD_SLICE) ?
  1027.                     h->avctx->thread_count : 1;
  1028.     int i, ret;
  1029.  
  1030.     ff_set_sar(h->avctx, h->sps.sar);
  1031.     av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
  1032.                                      &h->chroma_x_shift, &h->chroma_y_shift);
  1033.  
  1034.     if (h->sps.timing_info_present_flag) {
  1035.         int64_t den = h->sps.time_scale;
  1036.         if (h->x264_build < 44U)
  1037.             den *= 2;
  1038.         av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
  1039.                   h->sps.num_units_in_tick * h->avctx->ticks_per_frame, den, 1 << 30);
  1040.     }
  1041.  
  1042.     ff_h264_free_tables(h);
  1043.  
  1044.     h->first_field           = 0;
  1045.     h->prev_interlaced_frame = 1;
  1046.  
  1047.     init_scan_tables(h);
  1048.     ret = ff_h264_alloc_tables(h);
  1049.     if (ret < 0) {
  1050.         av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
  1051.         goto fail;
  1052.     }
  1053.  
  1054. #if FF_API_CAP_VDPAU
  1055.     if (h->avctx->codec &&
  1056.         h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU &&
  1057.         (h->sps.bit_depth_luma != 8 || h->sps.chroma_format_idc > 1)) {
  1058.         av_log(h->avctx, AV_LOG_ERROR,
  1059.                 "VDPAU decoding does not support video colorspace.\n");
  1060.         ret = AVERROR_INVALIDDATA;
  1061.         goto fail;
  1062.     }
  1063. #endif
  1064.  
  1065.     if (h->sps.bit_depth_luma < 8 || h->sps.bit_depth_luma > 14 ||
  1066.         h->sps.bit_depth_luma == 11 || h->sps.bit_depth_luma == 13
  1067.     ) {
  1068.         av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
  1069.                h->sps.bit_depth_luma);
  1070.         ret = AVERROR_INVALIDDATA;
  1071.         goto fail;
  1072.     }
  1073.  
  1074.     h->cur_bit_depth_luma         =
  1075.     h->avctx->bits_per_raw_sample = h->sps.bit_depth_luma;
  1076.     h->cur_chroma_format_idc      = h->sps.chroma_format_idc;
  1077.     h->pixel_shift                = h->sps.bit_depth_luma > 8;
  1078.     h->chroma_format_idc          = h->sps.chroma_format_idc;
  1079.     h->bit_depth_luma             = h->sps.bit_depth_luma;
  1080.  
  1081.     ff_h264dsp_init(&h->h264dsp, h->sps.bit_depth_luma,
  1082.                     h->sps.chroma_format_idc);
  1083.     ff_h264chroma_init(&h->h264chroma, h->sps.bit_depth_chroma);
  1084.     ff_h264qpel_init(&h->h264qpel, h->sps.bit_depth_luma);
  1085.     ff_h264_pred_init(&h->hpc, h->avctx->codec_id, h->sps.bit_depth_luma,
  1086.                       h->sps.chroma_format_idc);
  1087.     ff_videodsp_init(&h->vdsp, h->sps.bit_depth_luma);
  1088.  
  1089.     if (nb_slices > H264_MAX_THREADS || (nb_slices > h->mb_height && h->mb_height)) {
  1090.         int max_slices;
  1091.         if (h->mb_height)
  1092.             max_slices = FFMIN(H264_MAX_THREADS, h->mb_height);
  1093.         else
  1094.             max_slices = H264_MAX_THREADS;
  1095.         av_log(h->avctx, AV_LOG_WARNING, "too many threads/slices %d,"
  1096.                " reducing to %d\n", nb_slices, max_slices);
  1097.         nb_slices = max_slices;
  1098.     }
  1099.     h->slice_context_count = nb_slices;
  1100.     h->max_contexts = FFMIN(h->max_contexts, nb_slices);
  1101.  
  1102.     if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
  1103.         ret = ff_h264_slice_context_init(h, &h->slice_ctx[0]);
  1104.         if (ret < 0) {
  1105.             av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
  1106.             goto fail;
  1107.         }
  1108.     } else {
  1109.         for (i = 0; i < h->slice_context_count; i++) {
  1110.             H264SliceContext *sl = &h->slice_ctx[i];
  1111.  
  1112.             sl->h264               = h;
  1113.             sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
  1114.             sl->mvd_table[0]       = h->mvd_table[0]       + i * 8 * 2 * h->mb_stride;
  1115.             sl->mvd_table[1]       = h->mvd_table[1]       + i * 8 * 2 * h->mb_stride;
  1116.  
  1117.             if ((ret = ff_h264_slice_context_init(h, sl)) < 0) {
  1118.                 av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
  1119.                 goto fail;
  1120.             }
  1121.         }
  1122.     }
  1123.  
  1124.     h->context_initialized = 1;
  1125.  
  1126.     return 0;
  1127. fail:
  1128.     ff_h264_free_tables(h);
  1129.     h->context_initialized = 0;
  1130.     return ret;
  1131. }
  1132.  
  1133. static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
  1134. {
  1135.     switch (a) {
  1136.     case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
  1137.     case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
  1138.     case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
  1139.     default:
  1140.         return a;
  1141.     }
  1142. }
  1143.  
  1144. /**
  1145.  * Decode a slice header.
  1146.  * This will (re)intialize the decoder and call h264_frame_start() as needed.
  1147.  *
  1148.  * @param h h264context
  1149.  *
  1150.  * @return 0 if okay, <0 if an error occurred, 1 if decoding must not be multithreaded
  1151.  */
  1152. int ff_h264_decode_slice_header(H264Context *h, H264SliceContext *sl)
  1153. {
  1154.     unsigned int first_mb_in_slice;
  1155.     unsigned int pps_id;
  1156.     int ret;
  1157.     unsigned int slice_type, tmp, i, j;
  1158.     int last_pic_structure, last_pic_droppable;
  1159.     int must_reinit;
  1160.     int needs_reinit = 0;
  1161.     int field_pic_flag, bottom_field_flag;
  1162.     int first_slice = sl == h->slice_ctx && !h->current_slice;
  1163.     int frame_num, droppable, picture_structure;
  1164.     int mb_aff_frame, last_mb_aff_frame;
  1165.     PPS *pps;
  1166.  
  1167.     if (first_slice)
  1168.         av_assert0(!h->setup_finished);
  1169.  
  1170.     h->qpel_put = h->h264qpel.put_h264_qpel_pixels_tab;
  1171.     h->qpel_avg = h->h264qpel.avg_h264_qpel_pixels_tab;
  1172.  
  1173.     first_mb_in_slice = get_ue_golomb_long(&sl->gb);
  1174.  
  1175.     if (first_mb_in_slice == 0) { // FIXME better field boundary detection
  1176.         if (h->current_slice) {
  1177.             if (h->setup_finished) {
  1178.                 av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
  1179.                 return AVERROR_INVALIDDATA;
  1180.             }
  1181.             if (h->max_contexts > 1) {
  1182.                 if (!h->single_decode_warning) {
  1183.                     av_log(h->avctx, AV_LOG_WARNING, "Cannot decode multiple access units as slice threads\n");
  1184.                     h->single_decode_warning = 1;
  1185.                 }
  1186.                 h->max_contexts = 1;
  1187.                 return SLICE_SINGLETHREAD;
  1188.             }
  1189.  
  1190.             if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
  1191.                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
  1192.                 h->current_slice = 0;
  1193.                 if (ret < 0)
  1194.                     return ret;
  1195.             } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type  == NAL_IDR_SLICE) {
  1196.                 av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
  1197.                 ret = ff_h264_field_end(h, h->slice_ctx, 1);
  1198.                 h->current_slice = 0;
  1199.                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
  1200.                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
  1201.                 h->cur_pic_ptr = NULL;
  1202.                 if (ret < 0)
  1203.                     return ret;
  1204.             } else
  1205.                 return AVERROR_INVALIDDATA;
  1206.         }
  1207.  
  1208.         if (!h->first_field) {
  1209.             if (h->cur_pic_ptr && !h->droppable) {
  1210.                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
  1211.                                           h->picture_structure == PICT_BOTTOM_FIELD);
  1212.             }
  1213.             h->cur_pic_ptr = NULL;
  1214.         }
  1215.     }
  1216.  
  1217.     slice_type = get_ue_golomb_31(&sl->gb);
  1218.     if (slice_type > 9) {
  1219.         av_log(h->avctx, AV_LOG_ERROR,
  1220.                "slice type %d too large at %d\n",
  1221.                slice_type, first_mb_in_slice);
  1222.         return AVERROR_INVALIDDATA;
  1223.     }
  1224.     if (slice_type > 4) {
  1225.         slice_type -= 5;
  1226.         sl->slice_type_fixed = 1;
  1227.     } else
  1228.         sl->slice_type_fixed = 0;
  1229.  
  1230.     slice_type = golomb_to_pict_type[slice_type];
  1231.  
  1232.     sl->slice_type     = slice_type;
  1233.     sl->slice_type_nos = slice_type & 3;
  1234.  
  1235.     if (h->nal_unit_type  == NAL_IDR_SLICE &&
  1236.         sl->slice_type_nos != AV_PICTURE_TYPE_I) {
  1237.         av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
  1238.         return AVERROR_INVALIDDATA;
  1239.     }
  1240.  
  1241.     if (h->current_slice == 0 && !h->first_field) {
  1242.         if (
  1243.             (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
  1244.             (h->avctx->skip_frame >= AVDISCARD_BIDIR  && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
  1245.             (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
  1246.             (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != NAL_IDR_SLICE && h->sei_recovery_frame_cnt < 0) ||
  1247.             h->avctx->skip_frame >= AVDISCARD_ALL) {
  1248.             return SLICE_SKIPED;
  1249.         }
  1250.     }
  1251.  
  1252.     // to make a few old functions happy, it's wrong though
  1253.     if (!h->setup_finished)
  1254.         h->pict_type = sl->slice_type;
  1255.  
  1256.     pps_id = get_ue_golomb(&sl->gb);
  1257.     if (pps_id >= MAX_PPS_COUNT) {
  1258.         av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", pps_id);
  1259.         return AVERROR_INVALIDDATA;
  1260.     }
  1261.     if (!h->pps_buffers[pps_id]) {
  1262.         av_log(h->avctx, AV_LOG_ERROR,
  1263.                "non-existing PPS %u referenced\n",
  1264.                pps_id);
  1265.         return AVERROR_INVALIDDATA;
  1266.     }
  1267.     if (h->au_pps_id >= 0 && pps_id != h->au_pps_id) {
  1268.         av_log(h->avctx, AV_LOG_ERROR,
  1269.                "PPS change from %d to %d forbidden\n",
  1270.                h->au_pps_id, pps_id);
  1271.         return AVERROR_INVALIDDATA;
  1272.     }
  1273.  
  1274.     pps = h->pps_buffers[pps_id];
  1275.  
  1276.     if (!h->sps_buffers[pps->sps_id]) {
  1277.         av_log(h->avctx, AV_LOG_ERROR,
  1278.                "non-existing SPS %u referenced\n",
  1279.                h->pps.sps_id);
  1280.         return AVERROR_INVALIDDATA;
  1281.     }
  1282.  
  1283.     if (first_slice) {
  1284.         h->pps = *h->pps_buffers[pps_id];
  1285.     } else if (h->setup_finished && h->dequant_coeff_pps != pps_id) {
  1286.         av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
  1287.         return AVERROR_INVALIDDATA;
  1288.     }
  1289.  
  1290.     if (pps->sps_id != h->sps.sps_id ||
  1291.         pps->sps_id != h->current_sps_id ||
  1292.         h->sps_buffers[pps->sps_id]->new) {
  1293.  
  1294.         if (!first_slice) {
  1295.             av_log(h->avctx, AV_LOG_ERROR,
  1296.                "SPS changed in the middle of the frame\n");
  1297.             return AVERROR_INVALIDDATA;
  1298.         }
  1299.  
  1300.         h->sps = *h->sps_buffers[h->pps.sps_id];
  1301.  
  1302.         if (h->mb_width  != h->sps.mb_width ||
  1303.             h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) ||
  1304.             h->cur_bit_depth_luma    != h->sps.bit_depth_luma ||
  1305.             h->cur_chroma_format_idc != h->sps.chroma_format_idc
  1306.         )
  1307.             needs_reinit = 1;
  1308.  
  1309.         if (h->bit_depth_luma    != h->sps.bit_depth_luma ||
  1310.             h->chroma_format_idc != h->sps.chroma_format_idc)
  1311.             needs_reinit         = 1;
  1312.  
  1313.         if (h->flags & AV_CODEC_FLAG_LOW_DELAY ||
  1314.             (h->sps.bitstream_restriction_flag &&
  1315.              !h->sps.num_reorder_frames)) {
  1316.             if (h->avctx->has_b_frames > 1 || h->delayed_pic[0])
  1317.                 av_log(h->avctx, AV_LOG_WARNING, "Delayed frames seen. "
  1318.                        "Reenabling low delay requires a codec flush.\n");
  1319.             else
  1320.                 h->low_delay = 1;
  1321.         }
  1322.  
  1323.         if (h->avctx->has_b_frames < 2)
  1324.             h->avctx->has_b_frames = !h->low_delay;
  1325.  
  1326.     }
  1327.  
  1328.     must_reinit = (h->context_initialized &&
  1329.                     (   16*h->sps.mb_width != h->avctx->coded_width
  1330.                      || 16*h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag) != h->avctx->coded_height
  1331.                      || h->cur_bit_depth_luma    != h->sps.bit_depth_luma
  1332.                      || h->cur_chroma_format_idc != h->sps.chroma_format_idc
  1333.                      || h->mb_width  != h->sps.mb_width
  1334.                      || h->mb_height != h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag)
  1335.                     ));
  1336.     if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
  1337.         || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
  1338.         must_reinit = 1;
  1339.  
  1340.     if (first_slice && av_cmp_q(h->sps.sar, h->avctx->sample_aspect_ratio))
  1341.         must_reinit = 1;
  1342.  
  1343.     if (!h->setup_finished) {
  1344.         h->avctx->profile = ff_h264_get_profile(&h->sps);
  1345.         h->avctx->level   = h->sps.level_idc;
  1346.         h->avctx->refs    = h->sps.ref_frame_count;
  1347.  
  1348.         h->mb_width  = h->sps.mb_width;
  1349.         h->mb_height = h->sps.mb_height * (2 - h->sps.frame_mbs_only_flag);
  1350.         h->mb_num    = h->mb_width * h->mb_height;
  1351.         h->mb_stride = h->mb_width + 1;
  1352.  
  1353.         h->b_stride = h->mb_width * 4;
  1354.  
  1355.         h->chroma_y_shift = h->sps.chroma_format_idc <= 1; // 400 uses yuv420p
  1356.  
  1357.         h->width  = 16 * h->mb_width;
  1358.         h->height = 16 * h->mb_height;
  1359.  
  1360.         ret = init_dimensions(h);
  1361.         if (ret < 0)
  1362.             return ret;
  1363.  
  1364.         if (h->sps.video_signal_type_present_flag) {
  1365.             h->avctx->color_range = h->sps.full_range>0 ? AVCOL_RANGE_JPEG
  1366.                                                         : AVCOL_RANGE_MPEG;
  1367.             if (h->sps.colour_description_present_flag) {
  1368.                 if (h->avctx->colorspace != h->sps.colorspace)
  1369.                     needs_reinit = 1;
  1370.                 h->avctx->color_primaries = h->sps.color_primaries;
  1371.                 h->avctx->color_trc       = h->sps.color_trc;
  1372.                 h->avctx->colorspace      = h->sps.colorspace;
  1373.             }
  1374.         }
  1375.     }
  1376.  
  1377.     if (h->context_initialized &&
  1378.         (must_reinit || needs_reinit)) {
  1379.         h->context_initialized = 0;
  1380.         if (sl != h->slice_ctx) {
  1381.             av_log(h->avctx, AV_LOG_ERROR,
  1382.                    "changing width %d -> %d / height %d -> %d on "
  1383.                    "slice %d\n",
  1384.                    h->width, h->avctx->coded_width,
  1385.                    h->height, h->avctx->coded_height,
  1386.                    h->current_slice + 1);
  1387.             return AVERROR_INVALIDDATA;
  1388.         }
  1389.  
  1390.         av_assert1(first_slice);
  1391.  
  1392.         ff_h264_flush_change(h);
  1393.  
  1394.         if ((ret = get_pixel_format(h, 1)) < 0)
  1395.             return ret;
  1396.         h->avctx->pix_fmt = ret;
  1397.  
  1398.         av_log(h->avctx, AV_LOG_INFO, "Reinit context to %dx%d, "
  1399.                "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
  1400.  
  1401.         if ((ret = h264_slice_header_init(h)) < 0) {
  1402.             av_log(h->avctx, AV_LOG_ERROR,
  1403.                    "h264_slice_header_init() failed\n");
  1404.             return ret;
  1405.         }
  1406.     }
  1407.     if (!h->context_initialized) {
  1408.         if (sl != h->slice_ctx) {
  1409.             av_log(h->avctx, AV_LOG_ERROR,
  1410.                    "Cannot (re-)initialize context during parallel decoding.\n");
  1411.             return AVERROR_PATCHWELCOME;
  1412.         }
  1413.  
  1414.         if ((ret = get_pixel_format(h, 1)) < 0)
  1415.             return ret;
  1416.         h->avctx->pix_fmt = ret;
  1417.  
  1418.         if ((ret = h264_slice_header_init(h)) < 0) {
  1419.             av_log(h->avctx, AV_LOG_ERROR,
  1420.                    "h264_slice_header_init() failed\n");
  1421.             return ret;
  1422.         }
  1423.     }
  1424.  
  1425.     if (first_slice && h->dequant_coeff_pps != pps_id) {
  1426.         h->dequant_coeff_pps = pps_id;
  1427.         ff_h264_init_dequant_tables(h);
  1428.     }
  1429.  
  1430.     frame_num = get_bits(&sl->gb, h->sps.log2_max_frame_num);
  1431.     if (!first_slice) {
  1432.         if (h->frame_num != frame_num) {
  1433.             av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
  1434.                    h->frame_num, frame_num);
  1435.             return AVERROR_INVALIDDATA;
  1436.         }
  1437.     }
  1438.  
  1439.     if (!h->setup_finished)
  1440.         h->frame_num = frame_num;
  1441.  
  1442.     sl->mb_mbaff       = 0;
  1443.     mb_aff_frame       = 0;
  1444.     last_mb_aff_frame  = h->mb_aff_frame;
  1445.     last_pic_structure = h->picture_structure;
  1446.     last_pic_droppable = h->droppable;
  1447.  
  1448.     droppable = h->nal_ref_idc == 0;
  1449.     if (h->sps.frame_mbs_only_flag) {
  1450.         picture_structure = PICT_FRAME;
  1451.     } else {
  1452.         if (!h->sps.direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
  1453.             av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
  1454.             return -1;
  1455.         }
  1456.         field_pic_flag = get_bits1(&sl->gb);
  1457.  
  1458.         if (field_pic_flag) {
  1459.             bottom_field_flag = get_bits1(&sl->gb);
  1460.             picture_structure = PICT_TOP_FIELD + bottom_field_flag;
  1461.         } else {
  1462.             picture_structure = PICT_FRAME;
  1463.             mb_aff_frame      = h->sps.mb_aff;
  1464.         }
  1465.     }
  1466.  
  1467.     if (h->current_slice) {
  1468.         if (last_pic_structure != picture_structure ||
  1469.             last_pic_droppable != droppable ||
  1470.             last_mb_aff_frame  != mb_aff_frame) {
  1471.             av_log(h->avctx, AV_LOG_ERROR,
  1472.                    "Changing field mode (%d -> %d) between slices is not allowed\n",
  1473.                    last_pic_structure, h->picture_structure);
  1474.             return AVERROR_INVALIDDATA;
  1475.         } else if (!h->cur_pic_ptr) {
  1476.             av_log(h->avctx, AV_LOG_ERROR,
  1477.                    "unset cur_pic_ptr on slice %d\n",
  1478.                    h->current_slice + 1);
  1479.             return AVERROR_INVALIDDATA;
  1480.         }
  1481.     }
  1482.  
  1483.     h->picture_structure = picture_structure;
  1484.     if (!h->setup_finished) {
  1485.         h->droppable         = droppable;
  1486.         h->picture_structure = picture_structure;
  1487.         h->mb_aff_frame      = mb_aff_frame;
  1488.     }
  1489.     sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
  1490.  
  1491.     if (h->current_slice == 0) {
  1492.         /* Shorten frame num gaps so we don't have to allocate reference
  1493.          * frames just to throw them away */
  1494.         if (h->frame_num != h->prev_frame_num) {
  1495.             int unwrap_prev_frame_num = h->prev_frame_num;
  1496.             int max_frame_num         = 1 << h->sps.log2_max_frame_num;
  1497.  
  1498.             if (unwrap_prev_frame_num > h->frame_num)
  1499.                 unwrap_prev_frame_num -= max_frame_num;
  1500.  
  1501.             if ((h->frame_num - unwrap_prev_frame_num) > h->sps.ref_frame_count) {
  1502.                 unwrap_prev_frame_num = (h->frame_num - h->sps.ref_frame_count) - 1;
  1503.                 if (unwrap_prev_frame_num < 0)
  1504.                     unwrap_prev_frame_num += max_frame_num;
  1505.  
  1506.                 h->prev_frame_num = unwrap_prev_frame_num;
  1507.             }
  1508.         }
  1509.  
  1510.         /* See if we have a decoded first field looking for a pair...
  1511.          * Here, we're using that to see if we should mark previously
  1512.          * decode frames as "finished".
  1513.          * We have to do that before the "dummy" in-between frame allocation,
  1514.          * since that can modify h->cur_pic_ptr. */
  1515.         if (h->first_field) {
  1516.             av_assert0(h->cur_pic_ptr);
  1517.             av_assert0(h->cur_pic_ptr->f->buf[0]);
  1518.             assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
  1519.  
  1520.             /* Mark old field/frame as completed */
  1521.             if (h->cur_pic_ptr->tf.owner == h->avctx) {
  1522.                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
  1523.                                           last_pic_structure == PICT_BOTTOM_FIELD);
  1524.             }
  1525.  
  1526.             /* figure out if we have a complementary field pair */
  1527.             if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
  1528.                 /* Previous field is unmatched. Don't display it, but let it
  1529.                  * remain for reference if marked as such. */
  1530.                 if (last_pic_structure != PICT_FRAME) {
  1531.                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
  1532.                                               last_pic_structure == PICT_TOP_FIELD);
  1533.                 }
  1534.             } else {
  1535.                 if (h->cur_pic_ptr->frame_num != h->frame_num) {
  1536.                     /* This and previous field were reference, but had
  1537.                      * different frame_nums. Consider this field first in
  1538.                      * pair. Throw away previous field except for reference
  1539.                      * purposes. */
  1540.                     if (last_pic_structure != PICT_FRAME) {
  1541.                         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
  1542.                                                   last_pic_structure == PICT_TOP_FIELD);
  1543.                     }
  1544.                 } else {
  1545.                     /* Second field in complementary pair */
  1546.                     if (!((last_pic_structure   == PICT_TOP_FIELD &&
  1547.                            h->picture_structure == PICT_BOTTOM_FIELD) ||
  1548.                           (last_pic_structure   == PICT_BOTTOM_FIELD &&
  1549.                            h->picture_structure == PICT_TOP_FIELD))) {
  1550.                         av_log(h->avctx, AV_LOG_ERROR,
  1551.                                "Invalid field mode combination %d/%d\n",
  1552.                                last_pic_structure, h->picture_structure);
  1553.                         h->picture_structure = last_pic_structure;
  1554.                         h->droppable         = last_pic_droppable;
  1555.                         return AVERROR_INVALIDDATA;
  1556.                     } else if (last_pic_droppable != h->droppable) {
  1557.                         avpriv_request_sample(h->avctx,
  1558.                                               "Found reference and non-reference fields in the same frame, which");
  1559.                         h->picture_structure = last_pic_structure;
  1560.                         h->droppable         = last_pic_droppable;
  1561.                         return AVERROR_PATCHWELCOME;
  1562.                     }
  1563.                 }
  1564.             }
  1565.         }
  1566.  
  1567.         while (h->frame_num != h->prev_frame_num && !h->first_field &&
  1568.                h->frame_num != (h->prev_frame_num + 1) % (1 << h->sps.log2_max_frame_num)) {
  1569.             H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
  1570.             av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
  1571.                    h->frame_num, h->prev_frame_num);
  1572.             if (!h->sps.gaps_in_frame_num_allowed_flag)
  1573.                 for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
  1574.                     h->last_pocs[i] = INT_MIN;
  1575.             ret = h264_frame_start(h);
  1576.             if (ret < 0) {
  1577.                 h->first_field = 0;
  1578.                 return ret;
  1579.             }
  1580.  
  1581.             h->prev_frame_num++;
  1582.             h->prev_frame_num        %= 1 << h->sps.log2_max_frame_num;
  1583.             h->cur_pic_ptr->frame_num = h->prev_frame_num;
  1584.             h->cur_pic_ptr->invalid_gap = !h->sps.gaps_in_frame_num_allowed_flag;
  1585.             ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
  1586.             ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
  1587.             ret = ff_generate_sliding_window_mmcos(h, 1);
  1588.             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  1589.                 return ret;
  1590.             ret = ff_h264_execute_ref_pic_marking(h, h->mmco, h->mmco_index);
  1591.             if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  1592.                 return ret;
  1593.             /* Error concealment: If a ref is missing, copy the previous ref
  1594.              * in its place.
  1595.              * FIXME: Avoiding a memcpy would be nice, but ref handling makes
  1596.              * many assumptions about there being no actual duplicates.
  1597.              * FIXME: This does not copy padding for out-of-frame motion
  1598.              * vectors.  Given we are concealing a lost frame, this probably
  1599.              * is not noticeable by comparison, but it should be fixed. */
  1600.             if (h->short_ref_count) {
  1601.                 if (prev &&
  1602.                     h->short_ref[0]->f->width == prev->f->width &&
  1603.                     h->short_ref[0]->f->height == prev->f->height &&
  1604.                     h->short_ref[0]->f->format == prev->f->format) {
  1605.                     av_image_copy(h->short_ref[0]->f->data,
  1606.                                   h->short_ref[0]->f->linesize,
  1607.                                   (const uint8_t **)prev->f->data,
  1608.                                   prev->f->linesize,
  1609.                                   prev->f->format,
  1610.                                   prev->f->width,
  1611.                                   prev->f->height);
  1612.                     h->short_ref[0]->poc = prev->poc + 2;
  1613.                 }
  1614.                 h->short_ref[0]->frame_num = h->prev_frame_num;
  1615.             }
  1616.         }
  1617.  
  1618.         /* See if we have a decoded first field looking for a pair...
  1619.          * We're using that to see whether to continue decoding in that
  1620.          * frame, or to allocate a new one. */
  1621.         if (h->first_field) {
  1622.             av_assert0(h->cur_pic_ptr);
  1623.             av_assert0(h->cur_pic_ptr->f->buf[0]);
  1624.             assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
  1625.  
  1626.             /* figure out if we have a complementary field pair */
  1627.             if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
  1628.                 /* Previous field is unmatched. Don't display it, but let it
  1629.                  * remain for reference if marked as such. */
  1630.                 h->missing_fields ++;
  1631.                 h->cur_pic_ptr = NULL;
  1632.                 h->first_field = FIELD_PICTURE(h);
  1633.             } else {
  1634.                 h->missing_fields = 0;
  1635.                 if (h->cur_pic_ptr->frame_num != h->frame_num) {
  1636.                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
  1637.                                               h->picture_structure==PICT_BOTTOM_FIELD);
  1638.                     /* This and the previous field had different frame_nums.
  1639.                      * Consider this field first in pair. Throw away previous
  1640.                      * one except for reference purposes. */
  1641.                     h->first_field = 1;
  1642.                     h->cur_pic_ptr = NULL;
  1643.                 } else {
  1644.                     /* Second field in complementary pair */
  1645.                     h->first_field = 0;
  1646.                 }
  1647.             }
  1648.         } else {
  1649.             /* Frame or first field in a potentially complementary pair */
  1650.             h->first_field = FIELD_PICTURE(h);
  1651.         }
  1652.  
  1653.         if (!FIELD_PICTURE(h) || h->first_field) {
  1654.             if (h264_frame_start(h) < 0) {
  1655.                 h->first_field = 0;
  1656.                 return AVERROR_INVALIDDATA;
  1657.             }
  1658.         } else {
  1659.             release_unused_pictures(h, 0);
  1660.         }
  1661.         /* Some macroblocks can be accessed before they're available in case
  1662.         * of lost slices, MBAFF or threading. */
  1663.         if (FIELD_PICTURE(h)) {
  1664.             for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
  1665.                 memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
  1666.         } else {
  1667.             memset(h->slice_table, -1,
  1668.                 (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
  1669.         }
  1670.         h->last_slice_type = -1;
  1671.     }
  1672.  
  1673.     if (!h->setup_finished)
  1674.         h->cur_pic_ptr->frame_num = h->frame_num; // FIXME frame_num cleanup
  1675.  
  1676.     av_assert1(h->mb_num == h->mb_width * h->mb_height);
  1677.     if (first_mb_in_slice << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
  1678.         first_mb_in_slice >= h->mb_num) {
  1679.         av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
  1680.         return AVERROR_INVALIDDATA;
  1681.     }
  1682.     sl->resync_mb_x = sl->mb_x =  first_mb_in_slice % h->mb_width;
  1683.     sl->resync_mb_y = sl->mb_y = (first_mb_in_slice / h->mb_width) <<
  1684.                                  FIELD_OR_MBAFF_PICTURE(h);
  1685.     if (h->picture_structure == PICT_BOTTOM_FIELD)
  1686.         sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
  1687.     av_assert1(sl->mb_y < h->mb_height);
  1688.  
  1689.     if (h->picture_structure == PICT_FRAME) {
  1690.         h->curr_pic_num = h->frame_num;
  1691.         h->max_pic_num  = 1 << h->sps.log2_max_frame_num;
  1692.     } else {
  1693.         h->curr_pic_num = 2 * h->frame_num + 1;
  1694.         h->max_pic_num  = 1 << (h->sps.log2_max_frame_num + 1);
  1695.     }
  1696.  
  1697.     if (h->nal_unit_type == NAL_IDR_SLICE)
  1698.         get_ue_golomb(&sl->gb); /* idr_pic_id */
  1699.  
  1700.     if (h->sps.poc_type == 0) {
  1701.         int poc_lsb = get_bits(&sl->gb, h->sps.log2_max_poc_lsb);
  1702.  
  1703.         if (!h->setup_finished)
  1704.             h->poc_lsb = poc_lsb;
  1705.  
  1706.         if (h->pps.pic_order_present == 1 && h->picture_structure == PICT_FRAME) {
  1707.             int delta_poc_bottom = get_se_golomb(&sl->gb);
  1708.             if (!h->setup_finished)
  1709.                 h->delta_poc_bottom = delta_poc_bottom;
  1710.         }
  1711.     }
  1712.  
  1713.     if (h->sps.poc_type == 1 && !h->sps.delta_pic_order_always_zero_flag) {
  1714.         int delta_poc = get_se_golomb(&sl->gb);
  1715.  
  1716.         if (!h->setup_finished)
  1717.             h->delta_poc[0] = delta_poc;
  1718.  
  1719.         if (h->pps.pic_order_present == 1 && h->picture_structure == PICT_FRAME) {
  1720.             delta_poc = get_se_golomb(&sl->gb);
  1721.  
  1722.             if (!h->setup_finished)
  1723.                 h->delta_poc[1] = delta_poc;
  1724.         }
  1725.     }
  1726.  
  1727.     if (!h->setup_finished)
  1728.         ff_init_poc(h, h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc);
  1729.  
  1730.     if (h->pps.redundant_pic_cnt_present)
  1731.         sl->redundant_pic_count = get_ue_golomb(&sl->gb);
  1732.  
  1733.     ret = ff_set_ref_count(h, sl);
  1734.     if (ret < 0)
  1735.         return ret;
  1736.  
  1737.     if (slice_type != AV_PICTURE_TYPE_I &&
  1738.         (h->current_slice == 0 ||
  1739.          slice_type != h->last_slice_type ||
  1740.          memcmp(h->last_ref_count, sl->ref_count, sizeof(sl->ref_count)))) {
  1741.  
  1742.         ff_h264_fill_default_ref_list(h, sl);
  1743.     }
  1744.  
  1745.     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
  1746.        ret = ff_h264_decode_ref_pic_list_reordering(h, sl);
  1747.        if (ret < 0) {
  1748.            sl->ref_count[1] = sl->ref_count[0] = 0;
  1749.            return ret;
  1750.        }
  1751.     }
  1752.  
  1753.     if ((h->pps.weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
  1754.         (h->pps.weighted_bipred_idc == 1 &&
  1755.          sl->slice_type_nos == AV_PICTURE_TYPE_B))
  1756.         ff_pred_weight_table(h, sl);
  1757.     else if (h->pps.weighted_bipred_idc == 2 &&
  1758.              sl->slice_type_nos == AV_PICTURE_TYPE_B) {
  1759.         implicit_weight_table(h, sl, -1);
  1760.     } else {
  1761.         sl->use_weight = 0;
  1762.         for (i = 0; i < 2; i++) {
  1763.             sl->luma_weight_flag[i]   = 0;
  1764.             sl->chroma_weight_flag[i] = 0;
  1765.         }
  1766.     }
  1767.  
  1768.     // If frame-mt is enabled, only update mmco tables for the first slice
  1769.     // in a field. Subsequent slices can temporarily clobber h->mmco_index
  1770.     // or h->mmco, which will cause ref list mix-ups and decoding errors
  1771.     // further down the line. This may break decoding if the first slice is
  1772.     // corrupt, thus we only do this if frame-mt is enabled.
  1773.     if (h->nal_ref_idc) {
  1774.         ret = ff_h264_decode_ref_pic_marking(h, &sl->gb,
  1775.                                              !(h->avctx->active_thread_type & FF_THREAD_FRAME) ||
  1776.                                              h->current_slice == 0);
  1777.         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
  1778.             return AVERROR_INVALIDDATA;
  1779.     }
  1780.  
  1781.     if (FRAME_MBAFF(h)) {
  1782.         ff_h264_fill_mbaff_ref_list(h, sl);
  1783.  
  1784.         if (h->pps.weighted_bipred_idc == 2 && sl->slice_type_nos == AV_PICTURE_TYPE_B) {
  1785.             implicit_weight_table(h, sl, 0);
  1786.             implicit_weight_table(h, sl, 1);
  1787.         }
  1788.     }
  1789.  
  1790.     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
  1791.         ff_h264_direct_dist_scale_factor(h, sl);
  1792.     ff_h264_direct_ref_list_init(h, sl);
  1793.  
  1794.     if (sl->slice_type_nos != AV_PICTURE_TYPE_I && h->pps.cabac) {
  1795.         tmp = get_ue_golomb_31(&sl->gb);
  1796.         if (tmp > 2) {
  1797.             av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
  1798.             return AVERROR_INVALIDDATA;
  1799.         }
  1800.         sl->cabac_init_idc = tmp;
  1801.     }
  1802.  
  1803.     sl->last_qscale_diff = 0;
  1804.     tmp = h->pps.init_qp + get_se_golomb(&sl->gb);
  1805.     if (tmp > 51 + 6 * (h->sps.bit_depth_luma - 8)) {
  1806.         av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
  1807.         return AVERROR_INVALIDDATA;
  1808.     }
  1809.     sl->qscale       = tmp;
  1810.     sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
  1811.     sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
  1812.     // FIXME qscale / qp ... stuff
  1813.     if (sl->slice_type == AV_PICTURE_TYPE_SP)
  1814.         get_bits1(&sl->gb); /* sp_for_switch_flag */
  1815.     if (sl->slice_type == AV_PICTURE_TYPE_SP ||
  1816.         sl->slice_type == AV_PICTURE_TYPE_SI)
  1817.         get_se_golomb(&sl->gb); /* slice_qs_delta */
  1818.  
  1819.     sl->deblocking_filter     = 1;
  1820.     sl->slice_alpha_c0_offset = 0;
  1821.     sl->slice_beta_offset     = 0;
  1822.     if (h->pps.deblocking_filter_parameters_present) {
  1823.         tmp = get_ue_golomb_31(&sl->gb);
  1824.         if (tmp > 2) {
  1825.             av_log(h->avctx, AV_LOG_ERROR,
  1826.                    "deblocking_filter_idc %u out of range\n", tmp);
  1827.             return AVERROR_INVALIDDATA;
  1828.         }
  1829.         sl->deblocking_filter = tmp;
  1830.         if (sl->deblocking_filter < 2)
  1831.             sl->deblocking_filter ^= 1;  // 1<->0
  1832.  
  1833.         if (sl->deblocking_filter) {
  1834.             sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;
  1835.             sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;
  1836.             if (sl->slice_alpha_c0_offset >  12 ||
  1837.                 sl->slice_alpha_c0_offset < -12 ||
  1838.                 sl->slice_beta_offset >  12     ||
  1839.                 sl->slice_beta_offset < -12) {
  1840.                 av_log(h->avctx, AV_LOG_ERROR,
  1841.                        "deblocking filter parameters %d %d out of range\n",
  1842.                        sl->slice_alpha_c0_offset, sl->slice_beta_offset);
  1843.                 return AVERROR_INVALIDDATA;
  1844.             }
  1845.         }
  1846.     }
  1847.  
  1848.     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
  1849.         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
  1850.          h->nal_unit_type != NAL_IDR_SLICE) ||
  1851.         (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
  1852.          sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
  1853.         (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR  &&
  1854.          sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
  1855.         (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
  1856.          h->nal_ref_idc == 0))
  1857.         sl->deblocking_filter = 0;
  1858.  
  1859.     if (sl->deblocking_filter == 1 && h->max_contexts > 1) {
  1860.         if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
  1861.             /* Cheat slightly for speed:
  1862.              * Do not bother to deblock across slices. */
  1863.             sl->deblocking_filter = 2;
  1864.         } else {
  1865.             h->max_contexts = 1;
  1866.             if (!h->single_decode_warning) {
  1867.                 av_log(h->avctx, AV_LOG_INFO,
  1868.                        "Cannot parallelize slice decoding with deblocking filter type 1, decoding such frames in sequential order\n"
  1869.                        "To parallelize slice decoding you need video encoded with disable_deblocking_filter_idc set to 2 (deblock only edges that do not cross slices).\n"
  1870.                        "Setting the flags2 libavcodec option to +fast (-flags2 +fast) will disable deblocking across slices and enable parallel slice decoding "
  1871.                        "but will generate non-standard-compliant output.\n");
  1872.                 h->single_decode_warning = 1;
  1873.             }
  1874.             if (sl != h->slice_ctx) {
  1875.                 av_log(h->avctx, AV_LOG_ERROR,
  1876.                        "Deblocking switched inside frame.\n");
  1877.                 return SLICE_SINGLETHREAD;
  1878.             }
  1879.         }
  1880.     }
  1881.     sl->qp_thresh = 15 -
  1882.                    FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
  1883.                    FFMAX3(0,
  1884.                           h->pps.chroma_qp_index_offset[0],
  1885.                           h->pps.chroma_qp_index_offset[1]) +
  1886.                    6 * (h->sps.bit_depth_luma - 8);
  1887.  
  1888.     h->last_slice_type = slice_type;
  1889.     memcpy(h->last_ref_count, sl->ref_count, sizeof(h->last_ref_count));
  1890.     sl->slice_num       = ++h->current_slice;
  1891.  
  1892.     if (sl->slice_num)
  1893.         h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
  1894.     if (   h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
  1895.         && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
  1896.         && sl->slice_num >= MAX_SLICES) {
  1897.         //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
  1898.         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);
  1899.     }
  1900.  
  1901.     for (j = 0; j < 2; j++) {
  1902.         int id_list[16];
  1903.         int *ref2frm = sl->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
  1904.         for (i = 0; i < 16; i++) {
  1905.             id_list[i] = 60;
  1906.             if (j < sl->list_count && i < sl->ref_count[j] &&
  1907.                 sl->ref_list[j][i].parent->f->buf[0]) {
  1908.                 int k;
  1909.                 AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
  1910.                 for (k = 0; k < h->short_ref_count; k++)
  1911.                     if (h->short_ref[k]->f->buf[0]->buffer == buf) {
  1912.                         id_list[i] = k;
  1913.                         break;
  1914.                     }
  1915.                 for (k = 0; k < h->long_ref_count; k++)
  1916.                     if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
  1917.                         id_list[i] = h->short_ref_count + k;
  1918.                         break;
  1919.                     }
  1920.             }
  1921.         }
  1922.  
  1923.         ref2frm[0] =
  1924.         ref2frm[1] = -1;
  1925.         for (i = 0; i < 16; i++)
  1926.             ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
  1927.         ref2frm[18 + 0] =
  1928.         ref2frm[18 + 1] = -1;
  1929.         for (i = 16; i < 48; i++)
  1930.             ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
  1931.                              (sl->ref_list[j][i].reference & 3);
  1932.     }
  1933.  
  1934.     h->au_pps_id = pps_id;
  1935.     h->sps.new =
  1936.     h->sps_buffers[h->pps.sps_id]->new = 0;
  1937.     h->current_sps_id = h->pps.sps_id;
  1938.  
  1939.     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
  1940.         av_log(h->avctx, AV_LOG_DEBUG,
  1941.                "slice:%d %s mb:%d %c%s%s pps:%u frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
  1942.                sl->slice_num,
  1943.                (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
  1944.                first_mb_in_slice,
  1945.                av_get_picture_type_char(sl->slice_type),
  1946.                sl->slice_type_fixed ? " fix" : "",
  1947.                h->nal_unit_type == NAL_IDR_SLICE ? " IDR" : "",
  1948.                pps_id, h->frame_num,
  1949.                h->cur_pic_ptr->field_poc[0],
  1950.                h->cur_pic_ptr->field_poc[1],
  1951.                sl->ref_count[0], sl->ref_count[1],
  1952.                sl->qscale,
  1953.                sl->deblocking_filter,
  1954.                sl->slice_alpha_c0_offset, sl->slice_beta_offset,
  1955.                sl->use_weight,
  1956.                sl->use_weight == 1 && sl->use_weight_chroma ? "c" : "",
  1957.                sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
  1958.     }
  1959.  
  1960.     return 0;
  1961. }
  1962.  
  1963. int ff_h264_get_slice_type(const H264SliceContext *sl)
  1964. {
  1965.     switch (sl->slice_type) {
  1966.     case AV_PICTURE_TYPE_P:
  1967.         return 0;
  1968.     case AV_PICTURE_TYPE_B:
  1969.         return 1;
  1970.     case AV_PICTURE_TYPE_I:
  1971.         return 2;
  1972.     case AV_PICTURE_TYPE_SP:
  1973.         return 3;
  1974.     case AV_PICTURE_TYPE_SI:
  1975.         return 4;
  1976.     default:
  1977.         return AVERROR_INVALIDDATA;
  1978.     }
  1979. }
  1980.  
  1981. static av_always_inline void fill_filter_caches_inter(const H264Context *h,
  1982.                                                       H264SliceContext *sl,
  1983.                                                       int mb_type, int top_xy,
  1984.                                                       int left_xy[LEFT_MBS],
  1985.                                                       int top_type,
  1986.                                                       int left_type[LEFT_MBS],
  1987.                                                       int mb_xy, int list)
  1988. {
  1989.     int b_stride = h->b_stride;
  1990.     int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
  1991.     int8_t *ref_cache   = &sl->ref_cache[list][scan8[0]];
  1992.     if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
  1993.         if (USES_LIST(top_type, list)) {
  1994.             const int b_xy  = h->mb2b_xy[top_xy] + 3 * b_stride;
  1995.             const int b8_xy = 4 * top_xy + 2;
  1996.             int *ref2frm = sl->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list] + (MB_MBAFF(sl) ? 20 : 2);
  1997.             AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
  1998.             ref_cache[0 - 1 * 8] =
  1999.             ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
  2000.             ref_cache[2 - 1 * 8] =
  2001.             ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
  2002.         } else {
  2003.             AV_ZERO128(mv_dst - 1 * 8);
  2004.             AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
  2005.         }
  2006.  
  2007.         if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
  2008.             if (USES_LIST(left_type[LTOP], list)) {
  2009.                 const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
  2010.                 const int b8_xy = 4 * left_xy[LTOP] + 1;
  2011.                 int *ref2frm = sl->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list] + (MB_MBAFF(sl) ? 20 : 2);
  2012.                 AV_COPY32(mv_dst - 1 +  0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
  2013.                 AV_COPY32(mv_dst - 1 +  8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
  2014.                 AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
  2015.                 AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
  2016.                 ref_cache[-1 +  0] =
  2017.                 ref_cache[-1 +  8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
  2018.                 ref_cache[-1 + 16] =
  2019.                 ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
  2020.             } else {
  2021.                 AV_ZERO32(mv_dst - 1 +  0);
  2022.                 AV_ZERO32(mv_dst - 1 +  8);
  2023.                 AV_ZERO32(mv_dst - 1 + 16);
  2024.                 AV_ZERO32(mv_dst - 1 + 24);
  2025.                 ref_cache[-1 +  0] =
  2026.                 ref_cache[-1 +  8] =
  2027.                 ref_cache[-1 + 16] =
  2028.                 ref_cache[-1 + 24] = LIST_NOT_USED;
  2029.             }
  2030.         }
  2031.     }
  2032.  
  2033.     if (!USES_LIST(mb_type, list)) {
  2034.         fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
  2035.         AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
  2036.         AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
  2037.         AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
  2038.         AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
  2039.         return;
  2040.     }
  2041.  
  2042.     {
  2043.         int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
  2044.         int *ref2frm = sl->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list] + (MB_MBAFF(sl) ? 20 : 2);
  2045.         uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
  2046.         uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
  2047.         AV_WN32A(&ref_cache[0 * 8], ref01);
  2048.         AV_WN32A(&ref_cache[1 * 8], ref01);
  2049.         AV_WN32A(&ref_cache[2 * 8], ref23);
  2050.         AV_WN32A(&ref_cache[3 * 8], ref23);
  2051.     }
  2052.  
  2053.     {
  2054.         int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
  2055.         AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
  2056.         AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
  2057.         AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
  2058.         AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
  2059.     }
  2060. }
  2061.  
  2062. /**
  2063.  *
  2064.  * @return non zero if the loop filter can be skipped
  2065.  */
  2066. static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
  2067. {
  2068.     const int mb_xy = sl->mb_xy;
  2069.     int top_xy, left_xy[LEFT_MBS];
  2070.     int top_type, left_type[LEFT_MBS];
  2071.     uint8_t *nnz;
  2072.     uint8_t *nnz_cache;
  2073.  
  2074.     top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
  2075.  
  2076.     /* Wow, what a mess, why didn't they simplify the interlacing & intra
  2077.      * stuff, I can't imagine that these complex rules are worth it. */
  2078.  
  2079.     left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
  2080.     if (FRAME_MBAFF(h)) {
  2081.         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
  2082.         const int curr_mb_field_flag = IS_INTERLACED(mb_type);
  2083.         if (sl->mb_y & 1) {
  2084.             if (left_mb_field_flag != curr_mb_field_flag)
  2085.                 left_xy[LTOP] -= h->mb_stride;
  2086.         } else {
  2087.             if (curr_mb_field_flag)
  2088.                 top_xy += h->mb_stride &
  2089.                           (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
  2090.             if (left_mb_field_flag != curr_mb_field_flag)
  2091.                 left_xy[LBOT] += h->mb_stride;
  2092.         }
  2093.     }
  2094.  
  2095.     sl->top_mb_xy        = top_xy;
  2096.     sl->left_mb_xy[LTOP] = left_xy[LTOP];
  2097.     sl->left_mb_xy[LBOT] = left_xy[LBOT];
  2098.     {
  2099.         /* For sufficiently low qp, filtering wouldn't do anything.
  2100.          * This is a conservative estimate: could also check beta_offset
  2101.          * and more accurate chroma_qp. */
  2102.         int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
  2103.         int qp        = h->cur_pic.qscale_table[mb_xy];
  2104.         if (qp <= qp_thresh &&
  2105.             (left_xy[LTOP] < 0 ||
  2106.              ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
  2107.             (top_xy < 0 ||
  2108.              ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
  2109.             if (!FRAME_MBAFF(h))
  2110.                 return 1;
  2111.             if ((left_xy[LTOP] < 0 ||
  2112.                  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
  2113.                 (top_xy < h->mb_stride ||
  2114.                  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
  2115.                 return 1;
  2116.         }
  2117.     }
  2118.  
  2119.     top_type        = h->cur_pic.mb_type[top_xy];
  2120.     left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
  2121.     left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
  2122.     if (sl->deblocking_filter == 2) {
  2123.         if (h->slice_table[top_xy] != sl->slice_num)
  2124.             top_type = 0;
  2125.         if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
  2126.             left_type[LTOP] = left_type[LBOT] = 0;
  2127.     } else {
  2128.         if (h->slice_table[top_xy] == 0xFFFF)
  2129.             top_type = 0;
  2130.         if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
  2131.             left_type[LTOP] = left_type[LBOT] = 0;
  2132.     }
  2133.     sl->top_type        = top_type;
  2134.     sl->left_type[LTOP] = left_type[LTOP];
  2135.     sl->left_type[LBOT] = left_type[LBOT];
  2136.  
  2137.     if (IS_INTRA(mb_type))
  2138.         return 0;
  2139.  
  2140.     fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
  2141.                              top_type, left_type, mb_xy, 0);
  2142.     if (sl->list_count == 2)
  2143.         fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
  2144.                                  top_type, left_type, mb_xy, 1);
  2145.  
  2146.     nnz       = h->non_zero_count[mb_xy];
  2147.     nnz_cache = sl->non_zero_count_cache;
  2148.     AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
  2149.     AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
  2150.     AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
  2151.     AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
  2152.     sl->cbp = h->cbp_table[mb_xy];
  2153.  
  2154.     if (top_type) {
  2155.         nnz = h->non_zero_count[top_xy];
  2156.         AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
  2157.     }
  2158.  
  2159.     if (left_type[LTOP]) {
  2160.         nnz = h->non_zero_count[left_xy[LTOP]];
  2161.         nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
  2162.         nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
  2163.         nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
  2164.         nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
  2165.     }
  2166.  
  2167.     /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
  2168.      * from what the loop filter needs */
  2169.     if (!CABAC(h) && h->pps.transform_8x8_mode) {
  2170.         if (IS_8x8DCT(top_type)) {
  2171.             nnz_cache[4 + 8 * 0] =
  2172.             nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
  2173.             nnz_cache[6 + 8 * 0] =
  2174.             nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
  2175.         }
  2176.         if (IS_8x8DCT(left_type[LTOP])) {
  2177.             nnz_cache[3 + 8 * 1] =
  2178.             nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
  2179.         }
  2180.         if (IS_8x8DCT(left_type[LBOT])) {
  2181.             nnz_cache[3 + 8 * 3] =
  2182.             nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
  2183.         }
  2184.  
  2185.         if (IS_8x8DCT(mb_type)) {
  2186.             nnz_cache[scan8[0]] =
  2187.             nnz_cache[scan8[1]] =
  2188.             nnz_cache[scan8[2]] =
  2189.             nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
  2190.  
  2191.             nnz_cache[scan8[0 + 4]] =
  2192.             nnz_cache[scan8[1 + 4]] =
  2193.             nnz_cache[scan8[2 + 4]] =
  2194.             nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
  2195.  
  2196.             nnz_cache[scan8[0 + 8]] =
  2197.             nnz_cache[scan8[1 + 8]] =
  2198.             nnz_cache[scan8[2 + 8]] =
  2199.             nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
  2200.  
  2201.             nnz_cache[scan8[0 + 12]] =
  2202.             nnz_cache[scan8[1 + 12]] =
  2203.             nnz_cache[scan8[2 + 12]] =
  2204.             nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
  2205.         }
  2206.     }
  2207.  
  2208.     return 0;
  2209. }
  2210.  
  2211. static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
  2212. {
  2213.     uint8_t *dest_y, *dest_cb, *dest_cr;
  2214.     int linesize, uvlinesize, mb_x, mb_y;
  2215.     const int end_mb_y       = sl->mb_y + FRAME_MBAFF(h);
  2216.     const int old_slice_type = sl->slice_type;
  2217.     const int pixel_shift    = h->pixel_shift;
  2218.     const int block_h        = 16 >> h->chroma_y_shift;
  2219.  
  2220.     if (sl->deblocking_filter) {
  2221.         for (mb_x = start_x; mb_x < end_x; mb_x++)
  2222.             for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
  2223.                 int mb_xy, mb_type;
  2224.                 mb_xy         = sl->mb_xy = mb_x + mb_y * h->mb_stride;
  2225.                 sl->slice_num = h->slice_table[mb_xy];
  2226.                 mb_type       = h->cur_pic.mb_type[mb_xy];
  2227.                 sl->list_count = h->list_counts[mb_xy];
  2228.  
  2229.                 if (FRAME_MBAFF(h))
  2230.                     sl->mb_mbaff               =
  2231.                     sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
  2232.  
  2233.                 sl->mb_x = mb_x;
  2234.                 sl->mb_y = mb_y;
  2235.                 dest_y  = h->cur_pic.f->data[0] +
  2236.                           ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
  2237.                 dest_cb = h->cur_pic.f->data[1] +
  2238.                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
  2239.                           mb_y * sl->uvlinesize * block_h;
  2240.                 dest_cr = h->cur_pic.f->data[2] +
  2241.                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
  2242.                           mb_y * sl->uvlinesize * block_h;
  2243.                 // FIXME simplify above
  2244.  
  2245.                 if (MB_FIELD(sl)) {
  2246.                     linesize   = sl->mb_linesize   = sl->linesize   * 2;
  2247.                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
  2248.                     if (mb_y & 1) { // FIXME move out of this function?
  2249.                         dest_y  -= sl->linesize   * 15;
  2250.                         dest_cb -= sl->uvlinesize * (block_h - 1);
  2251.                         dest_cr -= sl->uvlinesize * (block_h - 1);
  2252.                     }
  2253.                 } else {
  2254.                     linesize   = sl->mb_linesize   = sl->linesize;
  2255.                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
  2256.                 }
  2257.                 backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
  2258.                                  uvlinesize, 0);
  2259.                 if (fill_filter_caches(h, sl, mb_type))
  2260.                     continue;
  2261.                 sl->chroma_qp[0] = get_chroma_qp(h, 0, h->cur_pic.qscale_table[mb_xy]);
  2262.                 sl->chroma_qp[1] = get_chroma_qp(h, 1, h->cur_pic.qscale_table[mb_xy]);
  2263.  
  2264.                 if (FRAME_MBAFF(h)) {
  2265.                     ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
  2266.                                       linesize, uvlinesize);
  2267.                 } else {
  2268.                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
  2269.                                            dest_cr, linesize, uvlinesize);
  2270.                 }
  2271.             }
  2272.     }
  2273.     sl->slice_type  = old_slice_type;
  2274.     sl->mb_x         = end_x;
  2275.     sl->mb_y         = end_mb_y - FRAME_MBAFF(h);
  2276.     sl->chroma_qp[0] = get_chroma_qp(h, 0, sl->qscale);
  2277.     sl->chroma_qp[1] = get_chroma_qp(h, 1, sl->qscale);
  2278. }
  2279.  
  2280. static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
  2281. {
  2282.     const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
  2283.     int mb_type     = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
  2284.                       h->cur_pic.mb_type[mb_xy - 1] :
  2285.                       (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
  2286.                       h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
  2287.     sl->mb_mbaff    = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
  2288. }
  2289.  
  2290. /**
  2291.  * Draw edges and report progress for the last MB row.
  2292.  */
  2293. static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
  2294. {
  2295.     int top            = 16 * (sl->mb_y      >> FIELD_PICTURE(h));
  2296.     int pic_height     = 16 *  h->mb_height >> FIELD_PICTURE(h);
  2297.     int height         =  16      << FRAME_MBAFF(h);
  2298.     int deblock_border = (16 + 4) << FRAME_MBAFF(h);
  2299.  
  2300.     if (sl->deblocking_filter) {
  2301.         if ((top + height) >= pic_height)
  2302.             height += deblock_border;
  2303.         top -= deblock_border;
  2304.     }
  2305.  
  2306.     if (top >= pic_height || (top + height) < 0)
  2307.         return;
  2308.  
  2309.     height = FFMIN(height, pic_height - top);
  2310.     if (top < 0) {
  2311.         height = top + height;
  2312.         top    = 0;
  2313.     }
  2314.  
  2315.     ff_h264_draw_horiz_band(h, sl, top, height);
  2316.  
  2317.     if (h->droppable || sl->h264->slice_ctx[0].er.error_occurred)
  2318.         return;
  2319.  
  2320.     ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
  2321.                               h->picture_structure == PICT_BOTTOM_FIELD);
  2322. }
  2323.  
  2324. static void er_add_slice(H264SliceContext *sl,
  2325.                          int startx, int starty,
  2326.                          int endx, int endy, int status)
  2327. {
  2328.     if (!sl->h264->enable_er)
  2329.         return;
  2330.  
  2331.     if (CONFIG_ERROR_RESILIENCE) {
  2332.         ERContext *er = &sl->h264->slice_ctx[0].er;
  2333.  
  2334.         ff_er_add_slice(er, startx, starty, endx, endy, status);
  2335.     }
  2336. }
  2337.  
  2338. static int decode_slice(struct AVCodecContext *avctx, void *arg)
  2339. {
  2340.     H264SliceContext *sl = arg;
  2341.     const H264Context *h = sl->h264;
  2342.     int lf_x_start = sl->mb_x;
  2343.     int ret;
  2344.  
  2345.     sl->linesize   = h->cur_pic_ptr->f->linesize[0];
  2346.     sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
  2347.  
  2348.     ret = alloc_scratch_buffers(sl, sl->linesize);
  2349.     if (ret < 0)
  2350.         return ret;
  2351.  
  2352.     sl->mb_skip_run = -1;
  2353.  
  2354.     av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
  2355.  
  2356.     sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
  2357.                      avctx->codec_id != AV_CODEC_ID_H264 ||
  2358.                      (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
  2359.  
  2360.     if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && h->slice_ctx[0].er.error_status_table) {
  2361.         const int start_i  = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
  2362.         if (start_i) {
  2363.             int prev_status = h->slice_ctx[0].er.error_status_table[h->slice_ctx[0].er.mb_index2xy[start_i - 1]];
  2364.             prev_status &= ~ VP_START;
  2365.             if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
  2366.                 h->slice_ctx[0].er.error_occurred = 1;
  2367.         }
  2368.     }
  2369.  
  2370.     if (h->pps.cabac) {
  2371.         /* realign */
  2372.         align_get_bits(&sl->gb);
  2373.  
  2374.         /* init cabac */
  2375.         ret = ff_init_cabac_decoder(&sl->cabac,
  2376.                               sl->gb.buffer + get_bits_count(&sl->gb) / 8,
  2377.                               (get_bits_left(&sl->gb) + 7) / 8);
  2378.         if (ret < 0)
  2379.             return ret;
  2380.  
  2381.         ff_h264_init_cabac_states(h, sl);
  2382.  
  2383.         for (;;) {
  2384.             // START_TIMER
  2385.             int ret, eos;
  2386.             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
  2387.                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
  2388.                        sl->next_slice_idx);
  2389.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
  2390.                              sl->mb_y, ER_MB_ERROR);
  2391.                 return AVERROR_INVALIDDATA;
  2392.             }
  2393.  
  2394.             ret = ff_h264_decode_mb_cabac(h, sl);
  2395.             // STOP_TIMER("decode_mb_cabac")
  2396.  
  2397.             if (ret >= 0)
  2398.                 ff_h264_hl_decode_mb(h, sl);
  2399.  
  2400.             // FIXME optimal? or let mb_decode decode 16x32 ?
  2401.             if (ret >= 0 && FRAME_MBAFF(h)) {
  2402.                 sl->mb_y++;
  2403.  
  2404.                 ret = ff_h264_decode_mb_cabac(h, sl);
  2405.  
  2406.                 if (ret >= 0)
  2407.                     ff_h264_hl_decode_mb(h, sl);
  2408.                 sl->mb_y--;
  2409.             }
  2410.             eos = get_cabac_terminate(&sl->cabac);
  2411.  
  2412.             if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
  2413.                 sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
  2414.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
  2415.                              sl->mb_y, ER_MB_END);
  2416.                 if (sl->mb_x >= lf_x_start)
  2417.                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
  2418.                 return 0;
  2419.             }
  2420.             if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
  2421.                 av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
  2422.             if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
  2423.                 av_log(h->avctx, AV_LOG_ERROR,
  2424.                        "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
  2425.                        sl->mb_x, sl->mb_y,
  2426.                        sl->cabac.bytestream_end - sl->cabac.bytestream);
  2427.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
  2428.                              sl->mb_y, ER_MB_ERROR);
  2429.                 return AVERROR_INVALIDDATA;
  2430.             }
  2431.  
  2432.             if (++sl->mb_x >= h->mb_width) {
  2433.                 loop_filter(h, sl, lf_x_start, sl->mb_x);
  2434.                 sl->mb_x = lf_x_start = 0;
  2435.                 decode_finish_row(h, sl);
  2436.                 ++sl->mb_y;
  2437.                 if (FIELD_OR_MBAFF_PICTURE(h)) {
  2438.                     ++sl->mb_y;
  2439.                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
  2440.                         predict_field_decoding_flag(h, sl);
  2441.                 }
  2442.             }
  2443.  
  2444.             if (eos || sl->mb_y >= h->mb_height) {
  2445.                 ff_tlog(h->avctx, "slice end %d %d\n",
  2446.                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
  2447.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
  2448.                              sl->mb_y, ER_MB_END);
  2449.                 if (sl->mb_x > lf_x_start)
  2450.                     loop_filter(h, sl, lf_x_start, sl->mb_x);
  2451.                 return 0;
  2452.             }
  2453.         }
  2454.     } else {
  2455.         for (;;) {
  2456.             int ret;
  2457.  
  2458.             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
  2459.                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
  2460.                        sl->next_slice_idx);
  2461.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
  2462.                              sl->mb_y, ER_MB_ERROR);
  2463.                 return AVERROR_INVALIDDATA;
  2464.             }
  2465.  
  2466.             ret = ff_h264_decode_mb_cavlc(h, sl);
  2467.  
  2468.             if (ret >= 0)
  2469.                 ff_h264_hl_decode_mb(h, sl);
  2470.  
  2471.             // FIXME optimal? or let mb_decode decode 16x32 ?
  2472.             if (ret >= 0 && FRAME_MBAFF(h)) {
  2473.                 sl->mb_y++;
  2474.                 ret = ff_h264_decode_mb_cavlc(h, sl);
  2475.  
  2476.                 if (ret >= 0)
  2477.                     ff_h264_hl_decode_mb(h, sl);
  2478.                 sl->mb_y--;
  2479.             }
  2480.  
  2481.             if (ret < 0) {
  2482.                 av_log(h->avctx, AV_LOG_ERROR,
  2483.                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
  2484.                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
  2485.                              sl->mb_y, ER_MB_ERROR);
  2486.                 return ret;
  2487.             }
  2488.  
  2489.             if (++sl->mb_x >= h->mb_width) {
  2490.                 loop_filter(h, sl, lf_x_start, sl->mb_x);
  2491.                 sl->mb_x = lf_x_start = 0;
  2492.                 decode_finish_row(h, sl);
  2493.                 ++sl->mb_y;
  2494.                 if (FIELD_OR_MBAFF_PICTURE(h)) {
  2495.                     ++sl->mb_y;
  2496.                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
  2497.                         predict_field_decoding_flag(h, sl);
  2498.                 }
  2499.                 if (sl->mb_y >= h->mb_height) {
  2500.                     ff_tlog(h->avctx, "slice end %d %d\n",
  2501.                             get_bits_count(&sl->gb), sl->gb.size_in_bits);
  2502.  
  2503.                     if (   get_bits_left(&sl->gb) == 0
  2504.                         || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
  2505.                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
  2506.                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
  2507.  
  2508.                         return 0;
  2509.                     } else {
  2510.                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
  2511.                                      sl->mb_x, sl->mb_y, ER_MB_END);
  2512.  
  2513.                         return AVERROR_INVALIDDATA;
  2514.                     }
  2515.                 }
  2516.             }
  2517.  
  2518.             if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
  2519.                 ff_tlog(h->avctx, "slice end %d %d\n",
  2520.                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
  2521.  
  2522.                 if (get_bits_left(&sl->gb) == 0) {
  2523.                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
  2524.                                  sl->mb_x - 1, sl->mb_y, ER_MB_END);
  2525.                     if (sl->mb_x > lf_x_start)
  2526.                         loop_filter(h, sl, lf_x_start, sl->mb_x);
  2527.  
  2528.                     return 0;
  2529.                 } else {
  2530.                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
  2531.                                  sl->mb_y, ER_MB_ERROR);
  2532.  
  2533.                     return AVERROR_INVALIDDATA;
  2534.                 }
  2535.             }
  2536.         }
  2537.     }
  2538. }
  2539.  
  2540. /**
  2541.  * Call decode_slice() for each context.
  2542.  *
  2543.  * @param h h264 master context
  2544.  * @param context_count number of contexts to execute
  2545.  */
  2546. int ff_h264_execute_decode_slices(H264Context *h, unsigned context_count)
  2547. {
  2548.     AVCodecContext *const avctx = h->avctx;
  2549.     H264SliceContext *sl;
  2550.     int i, j;
  2551.  
  2552.     av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
  2553.  
  2554.     h->slice_ctx[0].next_slice_idx = INT_MAX;
  2555.  
  2556.     if (h->avctx->hwaccel
  2557. #if FF_API_CAP_VDPAU
  2558.         || h->avctx->codec->capabilities & AV_CODEC_CAP_HWACCEL_VDPAU
  2559. #endif
  2560.         )
  2561.         return 0;
  2562.     if (context_count == 1) {
  2563.         int ret;
  2564.  
  2565.         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
  2566.  
  2567.         ret = decode_slice(avctx, &h->slice_ctx[0]);
  2568.         h->mb_y = h->slice_ctx[0].mb_y;
  2569.         return ret;
  2570.     } else {
  2571.         av_assert0(context_count > 0);
  2572.         for (i = 0; i < context_count; i++) {
  2573.             int next_slice_idx = h->mb_width * h->mb_height;
  2574.             int slice_idx;
  2575.  
  2576.             sl                 = &h->slice_ctx[i];
  2577.             if (CONFIG_ERROR_RESILIENCE) {
  2578.                 sl->er.error_count = 0;
  2579.             }
  2580.  
  2581.             /* make sure none of those slices overlap */
  2582.             slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
  2583.             for (j = 0; j < context_count; j++) {
  2584.                 H264SliceContext *sl2 = &h->slice_ctx[j];
  2585.                 int        slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
  2586.  
  2587.                 if (i == j || slice_idx2 < slice_idx)
  2588.                     continue;
  2589.                 next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
  2590.             }
  2591.             sl->next_slice_idx = next_slice_idx;
  2592.         }
  2593.  
  2594.         avctx->execute(avctx, decode_slice, h->slice_ctx,
  2595.                        NULL, context_count, sizeof(h->slice_ctx[0]));
  2596.  
  2597.         /* pull back stuff from slices to master context */
  2598.         sl                   = &h->slice_ctx[context_count - 1];
  2599.         h->mb_y              = sl->mb_y;
  2600.         if (CONFIG_ERROR_RESILIENCE) {
  2601.             for (i = 1; i < context_count; i++)
  2602.                 h->slice_ctx[0].er.error_count += h->slice_ctx[i].er.error_count;
  2603.         }
  2604.     }
  2605.  
  2606.     return 0;
  2607. }
  2608.