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