FFmpeg
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 / MPEG-4 part10 codec.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27 
28 #include "config_components.h"
29 
30 #include "libavutil/avassert.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/pixdesc.h"
33 #include "libavutil/timecode.h"
34 #include "decode.h"
35 #include "cabac.h"
36 #include "cabac_functions.h"
37 #include "error_resilience.h"
38 #include "avcodec.h"
39 #include "h264.h"
40 #include "h264dec.h"
41 #include "h264data.h"
42 #include "h264chroma.h"
43 #include "h264_ps.h"
44 #include "golomb.h"
45 #include "mathops.h"
46 #include "mpegutils.h"
47 #include "rectangle.h"
48 #include "libavutil/refstruct.h"
49 #include "thread.h"
50 #include "threadframe.h"
51 
52 static const uint8_t field_scan[16+1] = {
53  0 + 0 * 4, 0 + 1 * 4, 1 + 0 * 4, 0 + 2 * 4,
54  0 + 3 * 4, 1 + 1 * 4, 1 + 2 * 4, 1 + 3 * 4,
55  2 + 0 * 4, 2 + 1 * 4, 2 + 2 * 4, 2 + 3 * 4,
56  3 + 0 * 4, 3 + 1 * 4, 3 + 2 * 4, 3 + 3 * 4,
57 };
58 
59 static const uint8_t field_scan8x8[64+1] = {
60  0 + 0 * 8, 0 + 1 * 8, 0 + 2 * 8, 1 + 0 * 8,
61  1 + 1 * 8, 0 + 3 * 8, 0 + 4 * 8, 1 + 2 * 8,
62  2 + 0 * 8, 1 + 3 * 8, 0 + 5 * 8, 0 + 6 * 8,
63  0 + 7 * 8, 1 + 4 * 8, 2 + 1 * 8, 3 + 0 * 8,
64  2 + 2 * 8, 1 + 5 * 8, 1 + 6 * 8, 1 + 7 * 8,
65  2 + 3 * 8, 3 + 1 * 8, 4 + 0 * 8, 3 + 2 * 8,
66  2 + 4 * 8, 2 + 5 * 8, 2 + 6 * 8, 2 + 7 * 8,
67  3 + 3 * 8, 4 + 1 * 8, 5 + 0 * 8, 4 + 2 * 8,
68  3 + 4 * 8, 3 + 5 * 8, 3 + 6 * 8, 3 + 7 * 8,
69  4 + 3 * 8, 5 + 1 * 8, 6 + 0 * 8, 5 + 2 * 8,
70  4 + 4 * 8, 4 + 5 * 8, 4 + 6 * 8, 4 + 7 * 8,
71  5 + 3 * 8, 6 + 1 * 8, 6 + 2 * 8, 5 + 4 * 8,
72  5 + 5 * 8, 5 + 6 * 8, 5 + 7 * 8, 6 + 3 * 8,
73  7 + 0 * 8, 7 + 1 * 8, 6 + 4 * 8, 6 + 5 * 8,
74  6 + 6 * 8, 6 + 7 * 8, 7 + 2 * 8, 7 + 3 * 8,
75  7 + 4 * 8, 7 + 5 * 8, 7 + 6 * 8, 7 + 7 * 8,
76 };
77 
78 static const uint8_t field_scan8x8_cavlc[64+1] = {
79  0 + 0 * 8, 1 + 1 * 8, 2 + 0 * 8, 0 + 7 * 8,
80  2 + 2 * 8, 2 + 3 * 8, 2 + 4 * 8, 3 + 3 * 8,
81  3 + 4 * 8, 4 + 3 * 8, 4 + 4 * 8, 5 + 3 * 8,
82  5 + 5 * 8, 7 + 0 * 8, 6 + 6 * 8, 7 + 4 * 8,
83  0 + 1 * 8, 0 + 3 * 8, 1 + 3 * 8, 1 + 4 * 8,
84  1 + 5 * 8, 3 + 1 * 8, 2 + 5 * 8, 4 + 1 * 8,
85  3 + 5 * 8, 5 + 1 * 8, 4 + 5 * 8, 6 + 1 * 8,
86  5 + 6 * 8, 7 + 1 * 8, 6 + 7 * 8, 7 + 5 * 8,
87  0 + 2 * 8, 0 + 4 * 8, 0 + 5 * 8, 2 + 1 * 8,
88  1 + 6 * 8, 4 + 0 * 8, 2 + 6 * 8, 5 + 0 * 8,
89  3 + 6 * 8, 6 + 0 * 8, 4 + 6 * 8, 6 + 2 * 8,
90  5 + 7 * 8, 6 + 4 * 8, 7 + 2 * 8, 7 + 6 * 8,
91  1 + 0 * 8, 1 + 2 * 8, 0 + 6 * 8, 3 + 0 * 8,
92  1 + 7 * 8, 3 + 2 * 8, 2 + 7 * 8, 4 + 2 * 8,
93  3 + 7 * 8, 5 + 2 * 8, 4 + 7 * 8, 5 + 4 * 8,
94  6 + 3 * 8, 6 + 5 * 8, 7 + 3 * 8, 7 + 7 * 8,
95 };
96 
97 // zigzag_scan8x8_cavlc[i] = zigzag_scan8x8[(i/4) + 16*(i%4)]
98 static const uint8_t zigzag_scan8x8_cavlc[64+1] = {
99  0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
100  4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
101  3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
102  2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
103  1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
104  3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
105  2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
106  3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
107  0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
108  2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
109  1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
110  4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
111  0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
112  1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
113  0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
114  5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
115 };
116 
117 static void release_unused_pictures(H264Context *h, int remove_current)
118 {
119  int i;
120 
121  /* release non reference frames */
122  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
123  if (h->DPB[i].f->buf[0] && !h->DPB[i].reference &&
124  (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {
125  ff_h264_unref_picture(&h->DPB[i]);
126  }
127  }
128 }
129 
130 static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
131 {
132  const H264Context *h = sl->h264;
133  int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
134 
135  av_fast_malloc(&sl->bipred_scratchpad, &sl->bipred_scratchpad_allocated, 16 * 6 * alloc_size);
136  // edge emu needs blocksize + filter length - 1
137  // (= 21x21 for H.264)
138  av_fast_malloc(&sl->edge_emu_buffer, &sl->edge_emu_buffer_allocated, alloc_size * 2 * 21);
139 
140  av_fast_mallocz(&sl->top_borders[0], &sl->top_borders_allocated[0],
141  h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
142  av_fast_mallocz(&sl->top_borders[1], &sl->top_borders_allocated[1],
143  h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
144 
145  if (!sl->bipred_scratchpad || !sl->edge_emu_buffer ||
146  !sl->top_borders[0] || !sl->top_borders[1]) {
147  av_freep(&sl->bipred_scratchpad);
148  av_freep(&sl->edge_emu_buffer);
149  av_freep(&sl->top_borders[0]);
150  av_freep(&sl->top_borders[1]);
151 
152  sl->bipred_scratchpad_allocated = 0;
153  sl->edge_emu_buffer_allocated = 0;
154  sl->top_borders_allocated[0] = 0;
155  sl->top_borders_allocated[1] = 0;
156  return AVERROR(ENOMEM);
157  }
158 
159  return 0;
160 }
161 
162 static int init_table_pools(H264Context *h)
163 {
164  const int big_mb_num = h->mb_stride * (h->mb_height + 1) + 1;
165  const int mb_array_size = h->mb_stride * h->mb_height;
166  const int b4_stride = h->mb_width * 4 + 1;
167  const int b4_array_size = b4_stride * h->mb_height * 4;
168 
169  h->qscale_table_pool = av_refstruct_pool_alloc(big_mb_num + h->mb_stride, 0);
170  h->mb_type_pool = av_refstruct_pool_alloc((big_mb_num + h->mb_stride) *
171  sizeof(uint32_t), 0);
172  h->motion_val_pool = av_refstruct_pool_alloc(2 * (b4_array_size + 4) *
173  sizeof(int16_t), 0);
174  h->ref_index_pool = av_refstruct_pool_alloc(4 * mb_array_size, 0);
175 
176  if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
177  !h->ref_index_pool) {
178  av_refstruct_pool_uninit(&h->qscale_table_pool);
179  av_refstruct_pool_uninit(&h->mb_type_pool);
180  av_refstruct_pool_uninit(&h->motion_val_pool);
181  av_refstruct_pool_uninit(&h->ref_index_pool);
182  return AVERROR(ENOMEM);
183  }
184 
185  return 0;
186 }
187 
188 static int alloc_picture(H264Context *h, H264Picture *pic)
189 {
190  int i, ret = 0;
191 
192  av_assert0(!pic->f->data[0]);
193 
194  if (h->sei.common.itut_t35.lcevc) {
195  ret = ff_frame_new_side_data_from_buf(h->avctx, pic->f, AV_FRAME_DATA_LCEVC, &h->sei.common.itut_t35.lcevc);
196  if (ret < 0)
197  return ret;
198  }
199 
200  pic->tf.f = pic->f;
201  ret = ff_thread_get_ext_buffer(h->avctx, &pic->tf,
202  pic->reference ? AV_GET_BUFFER_FLAG_REF : 0);
203  if (ret < 0)
204  goto fail;
205 
206  if (pic->needs_fg) {
207  pic->f_grain->format = pic->f->format;
208  pic->f_grain->width = pic->f->width;
209  pic->f_grain->height = pic->f->height;
210  ret = ff_thread_get_buffer(h->avctx, pic->f_grain, 0);
211  if (ret < 0)
212  goto fail;
213  }
214 
215  ret = ff_hwaccel_frame_priv_alloc(h->avctx, &pic->hwaccel_picture_private);
216  if (ret < 0)
217  goto fail;
218 
219  if (h->decode_error_flags_pool) {
220  pic->decode_error_flags = av_refstruct_pool_get(h->decode_error_flags_pool);
221  if (!pic->decode_error_flags)
222  goto fail;
223  atomic_init(pic->decode_error_flags, 0);
224  }
225 
226  if (CONFIG_GRAY && !h->avctx->hwaccel && h->flags & AV_CODEC_FLAG_GRAY && pic->f->data[2]) {
227  int h_chroma_shift, v_chroma_shift;
228  av_pix_fmt_get_chroma_sub_sample(pic->f->format,
229  &h_chroma_shift, &v_chroma_shift);
230 
231  for(i=0; i<AV_CEIL_RSHIFT(pic->f->height, v_chroma_shift); i++) {
232  memset(pic->f->data[1] + pic->f->linesize[1]*i,
233  0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
234  memset(pic->f->data[2] + pic->f->linesize[2]*i,
235  0x80, AV_CEIL_RSHIFT(pic->f->width, h_chroma_shift));
236  }
237  }
238 
239  if (!h->qscale_table_pool) {
240  ret = init_table_pools(h);
241  if (ret < 0)
242  goto fail;
243  }
244 
245  pic->qscale_table_base = av_refstruct_pool_get(h->qscale_table_pool);
246  pic->mb_type_base = av_refstruct_pool_get(h->mb_type_pool);
247  if (!pic->qscale_table_base || !pic->mb_type_base)
248  goto fail;
249 
250  pic->mb_type = pic->mb_type_base + 2 * h->mb_stride + 1;
251  pic->qscale_table = pic->qscale_table_base + 2 * h->mb_stride + 1;
252 
253  for (i = 0; i < 2; i++) {
254  pic->motion_val_base[i] = av_refstruct_pool_get(h->motion_val_pool);
255  pic->ref_index[i] = av_refstruct_pool_get(h->ref_index_pool);
256  if (!pic->motion_val_base[i] || !pic->ref_index[i])
257  goto fail;
258 
259  pic->motion_val[i] = pic->motion_val_base[i] + 4;
260  }
261 
262  pic->pps = av_refstruct_ref_c(h->ps.pps);
263 
264  pic->mb_width = h->mb_width;
265  pic->mb_height = h->mb_height;
266  pic->mb_stride = h->mb_stride;
267 
268  return 0;
269 fail:
270  ff_h264_unref_picture(pic);
271  return (ret < 0) ? ret : AVERROR(ENOMEM);
272 }
273 
274 static int find_unused_picture(const H264Context *h)
275 {
276  int i;
277 
278  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
279  if (!h->DPB[i].f->buf[0])
280  return i;
281  }
282  return AVERROR_INVALIDDATA;
283 }
284 
285 
286 #define IN_RANGE(a, b, size) (((void*)(a) >= (void*)(b)) && ((void*)(a) < (void*)((b) + (size))))
287 
288 #define REBASE_PICTURE(pic, new_ctx, old_ctx) \
289  (((pic) && (pic) >= (old_ctx)->DPB && \
290  (pic) < (old_ctx)->DPB + H264_MAX_PICTURE_COUNT) ? \
291  &(new_ctx)->DPB[(pic) - (old_ctx)->DPB] : NULL)
292 
293 static void copy_picture_range(H264Picture **to, H264Picture *const *from, int count,
294  H264Context *new_base, const H264Context *old_base)
295 {
296  int i;
297 
298  for (i = 0; i < count; i++) {
299  av_assert1(!from[i] ||
300  IN_RANGE(from[i], old_base, 1) ||
301  IN_RANGE(from[i], old_base->DPB, H264_MAX_PICTURE_COUNT));
302  to[i] = REBASE_PICTURE(from[i], new_base, old_base);
303  }
304 }
305 
306 static void color_frame(AVFrame *frame, const int c[4])
307 {
308  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
309 
310  av_assert0(desc->flags & AV_PIX_FMT_FLAG_PLANAR);
311 
312  for (int p = 0; p < desc->nb_components; p++) {
313  uint8_t *dst = frame->data[p];
314  int is_chroma = p == 1 || p == 2;
315  int bytes = is_chroma ? AV_CEIL_RSHIFT(frame->width, desc->log2_chroma_w) : frame->width;
316  int height = is_chroma ? AV_CEIL_RSHIFT(frame->height, desc->log2_chroma_h) : frame->height;
317  if (desc->comp[0].depth >= 9) {
318  if (bytes >= 1)
319  ((uint16_t*)dst)[0] = c[p];
320  if (bytes >= 2)
321  av_memcpy_backptr(dst + 2, 2, 2 * (bytes - 1));
322  dst += frame->linesize[p];
323  for (int y = 1; y < height; y++) {
324  memcpy(dst, frame->data[p], 2*bytes);
325  dst += frame->linesize[p];
326  }
327  } else {
328  for (int y = 0; y < height; y++) {
329  memset(dst, c[p], bytes);
330  dst += frame->linesize[p];
331  }
332  }
333  }
334 }
335 
336 static int h264_slice_header_init(H264Context *h);
337 
338 int ff_h264_update_thread_context(AVCodecContext *dst,
339  const AVCodecContext *src)
340 {
341  H264Context *h = dst->priv_data, *h1 = src->priv_data;
342  int inited = h->context_initialized, err = 0;
343  int need_reinit = 0;
344  int i, ret;
345 
346  if (dst == src)
347  return 0;
348 
349  if (inited && !h1->ps.sps)
350  return AVERROR_INVALIDDATA;
351 
352  if (inited &&
353  (h->width != h1->width ||
354  h->height != h1->height ||
355  h->mb_width != h1->mb_width ||
356  h->mb_height != h1->mb_height ||
357  !h->ps.sps ||
358  h->ps.sps->bit_depth_luma != h1->ps.sps->bit_depth_luma ||
359  h->ps.sps->chroma_format_idc != h1->ps.sps->chroma_format_idc ||
360  h->ps.sps->vui.matrix_coeffs != h1->ps.sps->vui.matrix_coeffs)) {
361  need_reinit = 1;
362  }
363 
364  /* copy block_offset since frame_start may not be called */
365  memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
366 
367  // SPS/PPS
368  for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++)
369  av_refstruct_replace(&h->ps.sps_list[i], h1->ps.sps_list[i]);
370  for (int i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++)
371  av_refstruct_replace(&h->ps.pps_list[i], h1->ps.pps_list[i]);
372 
373  av_refstruct_replace(&h->ps.pps, h1->ps.pps);
374  h->ps.sps = h1->ps.sps;
375 
376  if (need_reinit || !inited) {
377  h->width = h1->width;
378  h->height = h1->height;
379  h->mb_height = h1->mb_height;
380  h->mb_width = h1->mb_width;
381  h->mb_num = h1->mb_num;
382  h->mb_stride = h1->mb_stride;
383  h->b_stride = h1->b_stride;
384  h->x264_build = h1->x264_build;
385 
386  if (h->context_initialized || h1->context_initialized) {
387  if ((err = h264_slice_header_init(h)) < 0) {
388  av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
389  return err;
390  }
391  }
392 
393  /* copy block_offset since frame_start may not be called */
394  memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
395  }
396 
397  h->width_from_caller = h1->width_from_caller;
398  h->height_from_caller = h1->height_from_caller;
399  h->first_field = h1->first_field;
400  h->picture_structure = h1->picture_structure;
401  h->mb_aff_frame = h1->mb_aff_frame;
402  h->droppable = h1->droppable;
403 
404  for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
405  ret = ff_h264_replace_picture(&h->DPB[i], &h1->DPB[i]);
406  if (ret < 0)
407  return ret;
408  }
409 
410  h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
411  ret = ff_h264_replace_picture(&h->cur_pic, &h1->cur_pic);
412  if (ret < 0)
413  return ret;
414 
415  h->enable_er = h1->enable_er;
416  h->workaround_bugs = h1->workaround_bugs;
417  h->droppable = h1->droppable;
418 
419  // extradata/NAL handling
420  h->is_avc = h1->is_avc;
421  h->nal_length_size = h1->nal_length_size;
422 
423  memcpy(&h->poc, &h1->poc, sizeof(h->poc));
424 
425  memcpy(h->short_ref, h1->short_ref, sizeof(h->short_ref));
426  memcpy(h->long_ref, h1->long_ref, sizeof(h->long_ref));
427  memcpy(h->delayed_pic, h1->delayed_pic, sizeof(h->delayed_pic));
428  memcpy(h->last_pocs, h1->last_pocs, sizeof(h->last_pocs));
429 
430  h->next_output_pic = h1->next_output_pic;
431  h->next_outputed_poc = h1->next_outputed_poc;
432  h->poc_offset = h1->poc_offset;
433 
434  memcpy(h->mmco, h1->mmco, sizeof(h->mmco));
435  h->nb_mmco = h1->nb_mmco;
436  h->mmco_reset = h1->mmco_reset;
437  h->explicit_ref_marking = h1->explicit_ref_marking;
438  h->long_ref_count = h1->long_ref_count;
439  h->short_ref_count = h1->short_ref_count;
440 
441  copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
442  copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
443  copy_picture_range(h->delayed_pic, h1->delayed_pic,
444  FF_ARRAY_ELEMS(h->delayed_pic), h, h1);
445 
446  h->frame_recovered = h1->frame_recovered;
447 
448  ret = ff_h2645_sei_ctx_replace(&h->sei.common, &h1->sei.common);
449  if (ret < 0)
450  return ret;
451 
452  h->sei.common.unregistered.x264_build = h1->sei.common.unregistered.x264_build;
453 
454  if (!h->cur_pic_ptr)
455  return 0;
456 
457  if (!h->droppable) {
458  err = ff_h264_execute_ref_pic_marking(h);
459  h->poc.prev_poc_msb = h->poc.poc_msb;
460  h->poc.prev_poc_lsb = h->poc.poc_lsb;
461  }
462  h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
463  h->poc.prev_frame_num = h->poc.frame_num;
464 
465  h->recovery_frame = h1->recovery_frame;
466  h->non_gray = h1->non_gray;
467 
468  return err;
469 }
470 
471 int ff_h264_update_thread_context_for_user(AVCodecContext *dst,
472  const AVCodecContext *src)
473 {
474  H264Context *h = dst->priv_data;
475  const H264Context *h1 = src->priv_data;
476 
477  h->is_avc = h1->is_avc;
478  h->nal_length_size = h1->nal_length_size;
479 
480  return 0;
481 }
482 
483 static int h264_frame_start(H264Context *h)
484 {
485  H264Picture *pic;
486  int i, ret;
487  const int pixel_shift = h->pixel_shift;
488 
489  if (!ff_thread_can_start_frame(h->avctx)) {
490  av_log(h->avctx, AV_LOG_ERROR, "Attempt to start a frame outside SETUP state\n");
491  return AVERROR_BUG;
492  }
493 
494  release_unused_pictures(h, 1);
495  h->cur_pic_ptr = NULL;
496 
497  i = find_unused_picture(h);
498  if (i < 0) {
499  av_log(h->avctx, AV_LOG_ERROR, "no frame buffer available\n");
500  return i;
501  }
502  pic = &h->DPB[i];
503 
504  pic->reference = h->droppable ? 0 : h->picture_structure;
505  pic->field_picture = h->picture_structure != PICT_FRAME;
506  pic->frame_num = h->poc.frame_num;
507  /*
508  * Zero key_frame here; IDR markings per slice in frame or fields are ORed
509  * in later.
510  * See decode_nal_units().
511  */
512  pic->f->flags &= ~AV_FRAME_FLAG_KEY;
513  pic->mmco_reset = 0;
514  pic->recovered = 0;
515  pic->invalid_gap = 0;
516  pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
517 
518  pic->f->pict_type = h->slice_ctx[0].slice_type;
519 
520  pic->f->crop_left = h->crop_left;
521  pic->f->crop_right = h->crop_right;
522  pic->f->crop_top = h->crop_top;
523  pic->f->crop_bottom = h->crop_bottom;
524 
525  pic->needs_fg =
526  h->sei.common.film_grain_characteristics &&
527  h->sei.common.film_grain_characteristics->present &&
528  !h->avctx->hwaccel &&
529  !(h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN);
530 
531  if ((ret = alloc_picture(h, pic)) < 0)
532  return ret;
533 
534  h->cur_pic_ptr = pic;
535  ff_h264_unref_picture(&h->cur_pic);
536  if (CONFIG_ERROR_RESILIENCE) {
537  ff_h264_set_erpic(&h->er.cur_pic, NULL);
538  }
539 
540  if ((ret = ff_h264_ref_picture(&h->cur_pic, h->cur_pic_ptr)) < 0)
541  return ret;
542 
543  for (i = 0; i < h->nb_slice_ctx; i++) {
544  h->slice_ctx[i].linesize = h->cur_pic_ptr->f->linesize[0];
545  h->slice_ctx[i].uvlinesize = h->cur_pic_ptr->f->linesize[1];
546  }
547 
548  if (CONFIG_ERROR_RESILIENCE && h->enable_er) {
549  ff_er_frame_start(&h->er);
550  ff_h264_set_erpic(&h->er.last_pic, NULL);
551  ff_h264_set_erpic(&h->er.next_pic, NULL);
552  }
553 
554  for (i = 0; i < 16; i++) {
555  h->block_offset[i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
556  h->block_offset[48 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
557  }
558  for (i = 0; i < 16; i++) {
559  h->block_offset[16 + i] =
560  h->block_offset[32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
561  h->block_offset[48 + 16 + i] =
562  h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
563  }
564 
565  /* We mark the current picture as non-reference after allocating it, so
566  * that if we break out due to an error it can be released automatically
567  * in the next ff_mpv_frame_start().
568  */
569  h->cur_pic_ptr->reference = 0;
570 
571  h->cur_pic_ptr->field_poc[0] = h->cur_pic_ptr->field_poc[1] = INT_MAX;
572 
573  h->next_output_pic = NULL;
574 
575  h->postpone_filter = 0;
576 
577  h->mb_aff_frame = h->ps.sps->mb_aff && (h->picture_structure == PICT_FRAME);
578 
579  if (h->sei.common.unregistered.x264_build >= 0)
580  h->x264_build = h->sei.common.unregistered.x264_build;
581 
582  assert(h->cur_pic_ptr->long_ref == 0);
583 
584  return 0;
585 }
586 
587 static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
588  const uint8_t *src_y,
589  const uint8_t *src_cb, const uint8_t *src_cr,
590  int linesize, int uvlinesize,
591  int simple)
592 {
593  uint8_t *top_border;
594  int top_idx = 1;
595  const int pixel_shift = h->pixel_shift;
596  int chroma444 = CHROMA444(h);
597  int chroma422 = CHROMA422(h);
598 
599  src_y -= linesize;
600  src_cb -= uvlinesize;
601  src_cr -= uvlinesize;
602 
603  if (!simple && FRAME_MBAFF(h)) {
604  if (sl->mb_y & 1) {
605  if (!MB_MBAFF(sl)) {
606  top_border = sl->top_borders[0][sl->mb_x];
607  AV_COPY128(top_border, src_y + 15 * linesize);
608  if (pixel_shift)
609  AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
610  if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
611  if (chroma444) {
612  if (pixel_shift) {
613  AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
614  AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
615  AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
616  AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
617  } else {
618  AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
619  AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
620  }
621  } else if (chroma422) {
622  if (pixel_shift) {
623  AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
624  AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
625  } else {
626  AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
627  AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
628  }
629  } else {
630  if (pixel_shift) {
631  AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
632  AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
633  } else {
634  AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
635  AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
636  }
637  }
638  }
639  }
640  } else if (MB_MBAFF(sl)) {
641  top_idx = 0;
642  } else
643  return;
644  }
645 
646  top_border = sl->top_borders[top_idx][sl->mb_x];
647  /* There are two lines saved, the line above the top macroblock
648  * of a pair, and the line above the bottom macroblock. */
649  AV_COPY128(top_border, src_y + 16 * linesize);
650  if (pixel_shift)
651  AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
652 
653  if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
654  if (chroma444) {
655  if (pixel_shift) {
656  AV_COPY128(top_border + 32, src_cb + 16 * linesize);
657  AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
658  AV_COPY128(top_border + 64, src_cr + 16 * linesize);
659  AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
660  } else {
661  AV_COPY128(top_border + 16, src_cb + 16 * linesize);
662  AV_COPY128(top_border + 32, src_cr + 16 * linesize);
663  }
664  } else if (chroma422) {
665  if (pixel_shift) {
666  AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
667  AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
668  } else {
669  AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
670  AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
671  }
672  } else {
673  if (pixel_shift) {
674  AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
675  AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
676  } else {
677  AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
678  AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
679  }
680  }
681  }
682 }
683 
684 /**
685  * Initialize implicit_weight table.
686  * @param field 0/1 initialize the weight for interlaced MBAFF
687  * -1 initializes the rest
688  */
689 static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
690 {
691  int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
692 
693  for (i = 0; i < 2; i++) {
694  sl->pwt.luma_weight_flag[i] = 0;
695  sl->pwt.chroma_weight_flag[i] = 0;
696  }
697 
698  if (field < 0) {
699  if (h->picture_structure == PICT_FRAME) {
700  cur_poc = h->cur_pic_ptr->poc;
701  } else {
702  cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
703  }
704  if (sl->ref_count[0] == 1 && sl->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
705  sl->ref_list[0][0].poc + (int64_t)sl->ref_list[1][0].poc == 2LL * cur_poc) {
706  sl->pwt.use_weight = 0;
707  sl->pwt.use_weight_chroma = 0;
708  return;
709  }
710  ref_start = 0;
711  ref_count0 = sl->ref_count[0];
712  ref_count1 = sl->ref_count[1];
713  } else {
714  cur_poc = h->cur_pic_ptr->field_poc[field];
715  ref_start = 16;
716  ref_count0 = 16 + 2 * sl->ref_count[0];
717  ref_count1 = 16 + 2 * sl->ref_count[1];
718  }
719 
720  sl->pwt.use_weight = 2;
721  sl->pwt.use_weight_chroma = 2;
722  sl->pwt.luma_log2_weight_denom = 5;
723  sl->pwt.chroma_log2_weight_denom = 5;
724 
725  for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
726  int64_t poc0 = sl->ref_list[0][ref0].poc;
727  for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
728  int w = 32;
729  if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
730  int poc1 = sl->ref_list[1][ref1].poc;
731  int td = av_clip_int8(poc1 - poc0);
732  if (td) {
733  int tb = av_clip_int8(cur_poc - poc0);
734  int tx = (16384 + (FFABS(td) >> 1)) / td;
735  int dist_scale_factor = (tb * tx + 32) >> 8;
736  if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
737  w = 64 - dist_scale_factor;
738  }
739  }
740  if (field < 0) {
741  sl->pwt.implicit_weight[ref0][ref1][0] =
742  sl->pwt.implicit_weight[ref0][ref1][1] = w;
743  } else {
744  sl->pwt.implicit_weight[ref0][ref1][field] = w;
745  }
746  }
747  }
748 }
749 
750 /**
751  * initialize scan tables
752  */
753 static void init_scan_tables(H264Context *h)
754 {
755  int i;
756  for (i = 0; i < 16; i++) {
757 #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
758  h->zigzag_scan[i] = TRANSPOSE(ff_zigzag_scan[i]);
759  h->field_scan[i] = TRANSPOSE(field_scan[i]);
760 #undef TRANSPOSE
761  }
762  for (i = 0; i < 64; i++) {
763 #define TRANSPOSE(x) ((x) >> 3) | (((x) & 7) << 3)
764  h->zigzag_scan8x8[i] = TRANSPOSE(ff_zigzag_direct[i]);
765  h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
766  h->field_scan8x8[i] = TRANSPOSE(field_scan8x8[i]);
767  h->field_scan8x8_cavlc[i] = TRANSPOSE(field_scan8x8_cavlc[i]);
768 #undef TRANSPOSE
769  }
770  if (h->ps.sps->transform_bypass) { // FIXME same ugly
771  memcpy(h->zigzag_scan_q0 , ff_zigzag_scan , sizeof(h->zigzag_scan_q0 ));
772  memcpy(h->zigzag_scan8x8_q0 , ff_zigzag_direct , sizeof(h->zigzag_scan8x8_q0 ));
773  memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
774  memcpy(h->field_scan_q0 , field_scan , sizeof(h->field_scan_q0 ));
775  memcpy(h->field_scan8x8_q0 , field_scan8x8 , sizeof(h->field_scan8x8_q0 ));
776  memcpy(h->field_scan8x8_cavlc_q0 , field_scan8x8_cavlc , sizeof(h->field_scan8x8_cavlc_q0 ));
777  } else {
778  memcpy(h->zigzag_scan_q0 , h->zigzag_scan , sizeof(h->zigzag_scan_q0 ));
779  memcpy(h->zigzag_scan8x8_q0 , h->zigzag_scan8x8 , sizeof(h->zigzag_scan8x8_q0 ));
780  memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_q0));
781  memcpy(h->field_scan_q0 , h->field_scan , sizeof(h->field_scan_q0 ));
782  memcpy(h->field_scan8x8_q0 , h->field_scan8x8 , sizeof(h->field_scan8x8_q0 ));
783  memcpy(h->field_scan8x8_cavlc_q0 , h->field_scan8x8_cavlc , sizeof(h->field_scan8x8_cavlc_q0 ));
784  }
785 }
786 
787 static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
788 {
789 #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
790  (CONFIG_H264_D3D11VA_HWACCEL * 2) + \
791  CONFIG_H264_D3D12VA_HWACCEL + \
792  CONFIG_H264_NVDEC_HWACCEL + \
793  CONFIG_H264_VAAPI_HWACCEL + \
794  CONFIG_H264_VIDEOTOOLBOX_HWACCEL + \
795  CONFIG_H264_VDPAU_HWACCEL + \
796  CONFIG_H264_VULKAN_HWACCEL)
797  enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
798 
799  switch (h->ps.sps->bit_depth_luma) {
800  case 9:
801  if (CHROMA444(h)) {
802  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
803  *fmt++ = AV_PIX_FMT_GBRP9;
804  } else
805  *fmt++ = AV_PIX_FMT_YUV444P9;
806  } else if (CHROMA422(h))
807  *fmt++ = AV_PIX_FMT_YUV422P9;
808  else
809  *fmt++ = AV_PIX_FMT_YUV420P9;
810  break;
811  case 10:
812 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
813  if (h->avctx->colorspace != AVCOL_SPC_RGB)
814  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
815 #endif
816 #if CONFIG_H264_VULKAN_HWACCEL
817  *fmt++ = AV_PIX_FMT_VULKAN;
818 #endif
819 #if CONFIG_H264_NVDEC_HWACCEL
820  *fmt++ = AV_PIX_FMT_CUDA;
821 #endif
822  if (CHROMA444(h)) {
823  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
824  *fmt++ = AV_PIX_FMT_GBRP10;
825  } else
826  *fmt++ = AV_PIX_FMT_YUV444P10;
827  } else if (CHROMA422(h))
828  *fmt++ = AV_PIX_FMT_YUV422P10;
829  else {
830 #if CONFIG_H264_VAAPI_HWACCEL
831  // Just add as candidate. Whether VAProfileH264High10 usable or
832  // not is decided by vaapi_decode_make_config() defined in FFmpeg
833  // and vaQueryCodingProfile() defined in libva.
834  *fmt++ = AV_PIX_FMT_VAAPI;
835 #endif
836  *fmt++ = AV_PIX_FMT_YUV420P10;
837  }
838  break;
839  case 12:
840 #if CONFIG_H264_VULKAN_HWACCEL
841  *fmt++ = AV_PIX_FMT_VULKAN;
842 #endif
843  if (CHROMA444(h)) {
844  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
845  *fmt++ = AV_PIX_FMT_GBRP12;
846  } else
847  *fmt++ = AV_PIX_FMT_YUV444P12;
848  } else if (CHROMA422(h))
849  *fmt++ = AV_PIX_FMT_YUV422P12;
850  else
851  *fmt++ = AV_PIX_FMT_YUV420P12;
852  break;
853  case 14:
854  if (CHROMA444(h)) {
855  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
856  *fmt++ = AV_PIX_FMT_GBRP14;
857  } else
858  *fmt++ = AV_PIX_FMT_YUV444P14;
859  } else if (CHROMA422(h))
860  *fmt++ = AV_PIX_FMT_YUV422P14;
861  else
862  *fmt++ = AV_PIX_FMT_YUV420P14;
863  break;
864  case 8:
865 #if CONFIG_H264_VDPAU_HWACCEL
866  *fmt++ = AV_PIX_FMT_VDPAU;
867 #endif
868 #if CONFIG_H264_VULKAN_HWACCEL
869  *fmt++ = AV_PIX_FMT_VULKAN;
870 #endif
871 #if CONFIG_H264_NVDEC_HWACCEL
872  *fmt++ = AV_PIX_FMT_CUDA;
873 #endif
874 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
875  if (h->avctx->colorspace != AVCOL_SPC_RGB)
876  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
877 #endif
878  if (CHROMA444(h)) {
879  if (h->avctx->colorspace == AVCOL_SPC_RGB)
880  *fmt++ = AV_PIX_FMT_GBRP;
881  else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
882  *fmt++ = AV_PIX_FMT_YUVJ444P;
883  else
884  *fmt++ = AV_PIX_FMT_YUV444P;
885  } else if (CHROMA422(h)) {
886  if (h->avctx->color_range == AVCOL_RANGE_JPEG)
887  *fmt++ = AV_PIX_FMT_YUVJ422P;
888  else
889  *fmt++ = AV_PIX_FMT_YUV422P;
890  } else {
891 #if CONFIG_H264_DXVA2_HWACCEL
892  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
893 #endif
894 #if CONFIG_H264_D3D11VA_HWACCEL
895  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
896  *fmt++ = AV_PIX_FMT_D3D11;
897 #endif
898 #if CONFIG_H264_D3D12VA_HWACCEL
899  *fmt++ = AV_PIX_FMT_D3D12;
900 #endif
901 #if CONFIG_H264_VAAPI_HWACCEL
902  *fmt++ = AV_PIX_FMT_VAAPI;
903 #endif
904  if (h->avctx->color_range == AVCOL_RANGE_JPEG)
905  *fmt++ = AV_PIX_FMT_YUVJ420P;
906  else
907  *fmt++ = AV_PIX_FMT_YUV420P;
908  }
909  break;
910  default:
911  av_log(h->avctx, AV_LOG_ERROR,
912  "Unsupported bit depth %d\n", h->ps.sps->bit_depth_luma);
913  return AVERROR_INVALIDDATA;
914  }
915 
916  *fmt = AV_PIX_FMT_NONE;
917 
918  for (int i = 0; pix_fmts[i] != AV_PIX_FMT_NONE; i++)
919  if (pix_fmts[i] == h->avctx->pix_fmt && !force_callback)
920  return pix_fmts[i];
921  return ff_get_format(h->avctx, pix_fmts);
922 }
923 
924 /* export coded and cropped frame dimensions to AVCodecContext */
925 static void init_dimensions(H264Context *h)
926 {
927  const SPS *sps = h->ps.sps;
928  int cr = sps->crop_right;
929  int cl = sps->crop_left;
930  int ct = sps->crop_top;
931  int cb = sps->crop_bottom;
932  int width = h->width - (cr + cl);
933  int height = h->height - (ct + cb);
934  av_assert0(sps->crop_right + sps->crop_left < (unsigned)h->width);
935  av_assert0(sps->crop_top + sps->crop_bottom < (unsigned)h->height);
936 
937  /* handle container cropping */
938  if (h->width_from_caller > 0 && h->height_from_caller > 0 &&
939  !sps->crop_top && !sps->crop_left &&
940  FFALIGN(h->width_from_caller, 16) == FFALIGN(width, 16) &&
941  FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16) &&
942  h->width_from_caller <= width &&
943  h->height_from_caller <= height) {
944  width = h->width_from_caller;
945  height = h->height_from_caller;
946  cl = 0;
947  ct = 0;
948  cr = h->width - width;
949  cb = h->height - height;
950  } else {
951  h->width_from_caller = 0;
952  h->height_from_caller = 0;
953  }
954 
955  h->avctx->coded_width = h->width;
956  h->avctx->coded_height = h->height;
957  h->avctx->width = width;
958  h->avctx->height = height;
959  h->crop_right = cr;
960  h->crop_left = cl;
961  h->crop_top = ct;
962  h->crop_bottom = cb;
963 }
964 
965 static int h264_slice_header_init(H264Context *h)
966 {
967  const SPS *sps = h->ps.sps;
968  int i, ret;
969 
970  if (!sps) {
971  ret = AVERROR_INVALIDDATA;
972  goto fail;
973  }
974 
975  ff_set_sar(h->avctx, sps->vui.sar);
976  av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
977  &h->chroma_x_shift, &h->chroma_y_shift);
978 
979  if (sps->timing_info_present_flag) {
980  int64_t den = sps->time_scale;
981  if (h->x264_build < 44U)
982  den *= 2;
983  av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
984  sps->num_units_in_tick * 2, den, 1 << 30);
985  }
986 
987  ff_h264_free_tables(h);
988 
989  h->first_field = 0;
990  h->prev_interlaced_frame = 1;
991 
992  init_scan_tables(h);
993  ret = ff_h264_alloc_tables(h);
994  if (ret < 0) {
995  av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
996  goto fail;
997  }
998 
999  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
1000  sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13
1001  ) {
1002  av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
1003  sps->bit_depth_luma);
1004  ret = AVERROR_INVALIDDATA;
1005  goto fail;
1006  }
1007 
1008  h->cur_bit_depth_luma =
1009  h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
1010  h->cur_chroma_format_idc = sps->chroma_format_idc;
1011  h->pixel_shift = sps->bit_depth_luma > 8;
1012  h->chroma_format_idc = sps->chroma_format_idc;
1013  h->bit_depth_luma = sps->bit_depth_luma;
1014 
1015  ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
1016  sps->chroma_format_idc);
1017  ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
1018  ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
1019  ff_h264_pred_init(&h->hpc, AV_CODEC_ID_H264, sps->bit_depth_luma,
1020  sps->chroma_format_idc);
1021  ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
1022 
1023  if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
1024  ff_h264_slice_context_init(h, &h->slice_ctx[0]);
1025  } else {
1026  for (i = 0; i < h->nb_slice_ctx; i++) {
1027  H264SliceContext *sl = &h->slice_ctx[i];
1028 
1029  sl->h264 = h;
1030  sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
1031  sl->mvd_table[0] = h->mvd_table[0] + i * 8 * 2 * h->mb_stride;
1032  sl->mvd_table[1] = h->mvd_table[1] + i * 8 * 2 * h->mb_stride;
1033 
1034  ff_h264_slice_context_init(h, sl);
1035  }
1036  }
1037 
1038  h->context_initialized = 1;
1039 
1040  return 0;
1041 fail:
1042  ff_h264_free_tables(h);
1043  h->context_initialized = 0;
1044  return ret;
1045 }
1046 
1047 static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
1048 {
1049  switch (a) {
1050  case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
1051  case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
1052  case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
1053  default:
1054  return a;
1055  }
1056 }
1057 
1058 static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
1059 {
1060  const SPS *sps;
1061  int needs_reinit = 0, must_reinit, ret;
1062 
1063  if (first_slice)
1064  av_refstruct_replace(&h->ps.pps, h->ps.pps_list[sl->pps_id]);
1065 
1066  if (h->ps.sps != h->ps.pps->sps) {
1067  h->ps.sps = h->ps.pps->sps;
1068 
1069  if (h->mb_width != h->ps.sps->mb_width ||
1070  h->mb_height != h->ps.sps->mb_height ||
1071  h->cur_bit_depth_luma != h->ps.sps->bit_depth_luma ||
1072  h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
1073  )
1074  needs_reinit = 1;
1075 
1076  if (h->bit_depth_luma != h->ps.sps->bit_depth_luma ||
1077  h->chroma_format_idc != h->ps.sps->chroma_format_idc)
1078  needs_reinit = 1;
1079  }
1080  sps = h->ps.sps;
1081 
1082  must_reinit = (h->context_initialized &&
1083  ( 16*sps->mb_width != h->avctx->coded_width
1084  || 16*sps->mb_height != h->avctx->coded_height
1085  || h->cur_bit_depth_luma != sps->bit_depth_luma
1086  || h->cur_chroma_format_idc != sps->chroma_format_idc
1087  || h->mb_width != sps->mb_width
1088  || h->mb_height != sps->mb_height
1089  ));
1090  if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
1091  || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
1092  must_reinit = 1;
1093 
1094  if (first_slice && av_cmp_q(sps->vui.sar, h->avctx->sample_aspect_ratio))
1095  must_reinit = 1;
1096 
1097  if (!h->setup_finished) {
1098  h->avctx->profile = ff_h264_get_profile(sps);
1099  h->avctx->level = sps->level_idc;
1100  h->avctx->refs = sps->ref_frame_count;
1101 
1102  h->mb_width = sps->mb_width;
1103  h->mb_height = sps->mb_height;
1104  h->mb_num = h->mb_width * h->mb_height;
1105  h->mb_stride = h->mb_width + 1;
1106 
1107  h->b_stride = h->mb_width * 4;
1108 
1109  h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p
1110 
1111  h->width = 16 * h->mb_width;
1112  h->height = 16 * h->mb_height;
1113 
1114  init_dimensions(h);
1115 
1116  if (sps->vui.video_signal_type_present_flag) {
1117  h->avctx->color_range = sps->vui.video_full_range_flag > 0 ? AVCOL_RANGE_JPEG
1118  : AVCOL_RANGE_MPEG;
1119  if (sps->vui.colour_description_present_flag) {
1120  if (h->avctx->colorspace != sps->vui.matrix_coeffs)
1121  needs_reinit = 1;
1122  h->avctx->color_primaries = sps->vui.colour_primaries;
1123  h->avctx->color_trc = sps->vui.transfer_characteristics;
1124  h->avctx->colorspace = sps->vui.matrix_coeffs;
1125  }
1126  }
1127 
1128  if (h->sei.common.alternative_transfer.present &&
1129  av_color_transfer_name(h->sei.common.alternative_transfer.preferred_transfer_characteristics) &&
1130  h->sei.common.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
1131  h->avctx->color_trc = h->sei.common.alternative_transfer.preferred_transfer_characteristics;
1132  }
1133  }
1134  h->avctx->chroma_sample_location = sps->vui.chroma_location;
1135 
1136  if (!h->context_initialized || must_reinit || needs_reinit) {
1137  int flush_changes = h->context_initialized;
1138  h->context_initialized = 0;
1139  if (sl != h->slice_ctx) {
1140  av_log(h->avctx, AV_LOG_ERROR,
1141  "changing width %d -> %d / height %d -> %d on "
1142  "slice %d\n",
1143  h->width, h->avctx->coded_width,
1144  h->height, h->avctx->coded_height,
1145  h->current_slice + 1);
1146  return AVERROR_INVALIDDATA;
1147  }
1148 
1149  av_assert1(first_slice);
1150 
1151  if (flush_changes)
1152  ff_h264_flush_change(h);
1153 
1154  if ((ret = get_pixel_format(h, must_reinit || needs_reinit)) < 0)
1155  return ret;
1156  h->avctx->pix_fmt = ret;
1157 
1158  av_log(h->avctx, AV_LOG_VERBOSE, "Reinit context to %dx%d, "
1159  "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
1160 
1161  if ((ret = h264_slice_header_init(h)) < 0) {
1162  av_log(h->avctx, AV_LOG_ERROR,
1163  "h264_slice_header_init() failed\n");
1164  return ret;
1165  }
1166  }
1167 
1168  return 0;
1169 }
1170 
1171 static int h264_export_frame_props(H264Context *h)
1172 {
1173  const SPS *sps = h->ps.sps;
1174  H264Picture *cur = h->cur_pic_ptr;
1175  AVFrame *out = cur->f;
1176  int interlaced_frame = 0, top_field_first = 0;
1177  int ret;
1178 
1179  out->flags &= ~AV_FRAME_FLAG_INTERLACED;
1180  out->repeat_pict = 0;
1181 
1182  /* Signal interlacing information externally. */
1183  /* Prioritize picture timing SEI information over used
1184  * decoding process if it exists. */
1185  if (h->sei.picture_timing.present) {
1186  int ret = ff_h264_sei_process_picture_timing(&h->sei.picture_timing, sps,
1187  h->avctx);
1188  if (ret < 0) {
1189  av_log(h->avctx, AV_LOG_ERROR, "Error processing a picture timing SEI\n");
1190  if (h->avctx->err_recognition & AV_EF_EXPLODE)
1191  return ret;
1192  h->sei.picture_timing.present = 0;
1193  }
1194  }
1195 
1196  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1197  const H264SEIPictureTiming *pt = &h->sei.picture_timing;
1198  switch (pt->pic_struct) {
1199  case H264_SEI_PIC_STRUCT_FRAME:
1200  break;
1201  case H264_SEI_PIC_STRUCT_TOP_FIELD:
1202  case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
1203  interlaced_frame = 1;
1204  break;
1205  case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
1206  case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
1207  if (FIELD_OR_MBAFF_PICTURE(h))
1208  interlaced_frame = 1;
1209  else
1210  // try to flag soft telecine progressive
1211  interlaced_frame = !!h->prev_interlaced_frame;
1212  break;
1213  case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
1214  case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
1215  /* Signal the possibility of telecined film externally
1216  * (pic_struct 5,6). From these hints, let the applications
1217  * decide if they apply deinterlacing. */
1218  out->repeat_pict = 1;
1219  break;
1220  case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
1221  out->repeat_pict = 2;
1222  break;
1223  case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
1224  out->repeat_pict = 4;
1225  break;
1226  }
1227 
1228  if ((pt->ct_type & 3) &&
1229  pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
1230  interlaced_frame = ((pt->ct_type & (1 << 1)) != 0);
1231  } else {
1232  /* Derive interlacing flag from used decoding process. */
1233  interlaced_frame = !!FIELD_OR_MBAFF_PICTURE(h);
1234  }
1235  h->prev_interlaced_frame = interlaced_frame;
1236 
1237  if (cur->field_poc[0] != cur->field_poc[1]) {
1238  /* Derive top_field_first from field pocs. */
1239  top_field_first = (cur->field_poc[0] < cur->field_poc[1]);
1240  } else {
1241  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1242  /* Use picture timing SEI information. Even if it is a
1243  * information of a past frame, better than nothing. */
1244  if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
1245  h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
1246  top_field_first = 1;
1247  } else if (interlaced_frame) {
1248  /* Default to top field first when pic_struct_present_flag
1249  * is not set but interlaced frame detected */
1250  top_field_first = 1;
1251  } // else
1252  /* Most likely progressive */
1253  }
1254 
1255  out->flags |= (AV_FRAME_FLAG_INTERLACED * interlaced_frame) |
1256  (AV_FRAME_FLAG_TOP_FIELD_FIRST * top_field_first);
1257 
1258  ret = ff_h2645_sei_to_frame(out, &h->sei.common, AV_CODEC_ID_H264, h->avctx,
1259  &sps->vui, sps->bit_depth_luma, sps->bit_depth_chroma,
1260  cur->poc + (unsigned)(h->poc_offset << 5));
1261  if (ret < 0)
1262  return ret;
1263 
1264  if (h->sei.picture_timing.timecode_cnt > 0) {
1265  uint32_t *tc_sd;
1266  char tcbuf[AV_TIMECODE_STR_SIZE];
1267  AVFrameSideData *tcside;
1268  ret = ff_frame_new_side_data(h->avctx, out, AV_FRAME_DATA_S12M_TIMECODE,
1269  sizeof(uint32_t)*4, &tcside);
1270  if (ret < 0)
1271  return ret;
1272 
1273  if (tcside) {
1274  tc_sd = (uint32_t*)tcside->data;
1275  tc_sd[0] = h->sei.picture_timing.timecode_cnt;
1276 
1277  for (int i = 0; i < tc_sd[0]; i++) {
1278  int drop = h->sei.picture_timing.timecode[i].dropframe;
1279  int hh = h->sei.picture_timing.timecode[i].hours;
1280  int mm = h->sei.picture_timing.timecode[i].minutes;
1281  int ss = h->sei.picture_timing.timecode[i].seconds;
1282  int ff = h->sei.picture_timing.timecode[i].frame;
1283 
1284  tc_sd[i + 1] = av_timecode_get_smpte(h->avctx->framerate, drop, hh, mm, ss, ff);
1285  av_timecode_make_smpte_tc_string2(tcbuf, h->avctx->framerate, tc_sd[i + 1], 0, 0);
1286  av_dict_set(&out->metadata, "timecode", tcbuf, 0);
1287  }
1288  }
1289  h->sei.picture_timing.timecode_cnt = 0;
1290  }
1291 
1292  return 0;
1293 }
1294 
1295 static int h264_select_output_frame(H264Context *h)
1296 {
1297  const SPS *sps = h->ps.sps;
1298  H264Picture *out = h->cur_pic_ptr;
1299  H264Picture *cur = h->cur_pic_ptr;
1300  int i, pics, out_of_order, out_idx;
1301 
1302  cur->mmco_reset = h->mmco_reset;
1303  h->mmco_reset = 0;
1304 
1305  if (sps->bitstream_restriction_flag ||
1306  h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
1307  h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
1308  }
1309 
1310  for (i = 0; 1; i++) {
1311  if(i == H264_MAX_DPB_FRAMES || cur->poc < h->last_pocs[i]){
1312  if(i)
1313  h->last_pocs[i-1] = cur->poc;
1314  break;
1315  } else if(i) {
1316  h->last_pocs[i-1]= h->last_pocs[i];
1317  }
1318  }
1319  out_of_order = H264_MAX_DPB_FRAMES - i;
1320  if( cur->f->pict_type == AV_PICTURE_TYPE_B
1321  || (h->last_pocs[H264_MAX_DPB_FRAMES-2] > INT_MIN && h->last_pocs[H264_MAX_DPB_FRAMES-1] - (int64_t)h->last_pocs[H264_MAX_DPB_FRAMES-2] > 2))
1322  out_of_order = FFMAX(out_of_order, 1);
1323  if (out_of_order == H264_MAX_DPB_FRAMES) {
1324  av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
1325  for (i = 1; i < H264_MAX_DPB_FRAMES; i++)
1326  h->last_pocs[i] = INT_MIN;
1327  h->last_pocs[0] = cur->poc;
1328  cur->mmco_reset = 1;
1329  } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
1330  int loglevel = h->avctx->frame_num > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
1331  av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
1332  h->avctx->has_b_frames = out_of_order;
1333  }
1334 
1335  pics = 0;
1336  while (h->delayed_pic[pics])
1337  pics++;
1338 
1339  av_assert0(pics <= H264_MAX_DPB_FRAMES);
1340 
1341  h->delayed_pic[pics++] = cur;
1342  if (cur->reference == 0)
1343  cur->reference = DELAYED_PIC_REF;
1344 
1345  out = h->delayed_pic[0];
1346  out_idx = 0;
1347  for (i = 1; h->delayed_pic[i] &&
1348  !(h->delayed_pic[i]->f->flags & AV_FRAME_FLAG_KEY) &&
1349  !h->delayed_pic[i]->mmco_reset;
1350  i++)
1351  if (h->delayed_pic[i]->poc < out->poc) {
1352  out = h->delayed_pic[i];
1353  out_idx = i;
1354  }
1355  if (h->avctx->has_b_frames == 0 &&
1356  ((h->delayed_pic[0]->f->flags & AV_FRAME_FLAG_KEY) || h->delayed_pic[0]->mmco_reset))
1357  h->next_outputed_poc = INT_MIN;
1358  out_of_order = out->poc < h->next_outputed_poc;
1359 
1360  if (out_of_order || pics > h->avctx->has_b_frames) {
1361  out->reference &= ~DELAYED_PIC_REF;
1362  for (i = out_idx; h->delayed_pic[i]; i++)
1363  h->delayed_pic[i] = h->delayed_pic[i + 1];
1364  }
1365  if (!out_of_order && pics > h->avctx->has_b_frames) {
1366  h->next_output_pic = out;
1367  if (out_idx == 0 && h->delayed_pic[0] && ((h->delayed_pic[0]->f->flags & AV_FRAME_FLAG_KEY) || h->delayed_pic[0]->mmco_reset)) {
1368  h->next_outputed_poc = INT_MIN;
1369  } else
1370  h->next_outputed_poc = out->poc;
1371 
1372  // We have reached an recovery point and all frames after it in
1373  // display order are "recovered".
1374  h->frame_recovered |= out->recovered;
1375 
1376  out->recovered |= h->frame_recovered & FRAME_RECOVERED_SEI;
1377 
1378  if (!out->recovered) {
1379  if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
1380  !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
1381  h->next_output_pic = NULL;
1382  } else {
1383  out->f->flags |= AV_FRAME_FLAG_CORRUPT;
1384  }
1385  }
1386  } else {
1387  av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
1388  }
1389 
1390  return 0;
1391 }
1392 
1393 /* This function is called right after decoding the slice header for a first
1394  * slice in a field (or a frame). It decides whether we are decoding a new frame
1395  * or a second field in a pair and does the necessary setup.
1396  */
1397 static int h264_field_start(H264Context *h, const H264SliceContext *sl,
1398  const H2645NAL *nal, int first_slice)
1399 {
1400  int i;
1401  const SPS *sps;
1402 
1403  int last_pic_structure, last_pic_droppable, ret;
1404 
1405  ret = h264_init_ps(h, sl, first_slice);
1406  if (ret < 0)
1407  return ret;
1408 
1409  sps = h->ps.sps;
1410 
1411  if (sps->bitstream_restriction_flag &&
1412  h->avctx->has_b_frames < sps->num_reorder_frames) {
1413  h->avctx->has_b_frames = sps->num_reorder_frames;
1414  }
1415 
1416  last_pic_droppable = h->droppable;
1417  last_pic_structure = h->picture_structure;
1418  h->droppable = (nal->ref_idc == 0);
1419  h->picture_structure = sl->picture_structure;
1420 
1421  h->poc.frame_num = sl->frame_num;
1422  h->poc.poc_lsb = sl->poc_lsb;
1423  h->poc.delta_poc_bottom = sl->delta_poc_bottom;
1424  h->poc.delta_poc[0] = sl->delta_poc[0];
1425  h->poc.delta_poc[1] = sl->delta_poc[1];
1426 
1427  if (nal->type == H264_NAL_IDR_SLICE)
1428  h->poc_offset = sl->idr_pic_id;
1429  else if (h->picture_intra_only)
1430  h->poc_offset = 0;
1431 
1432  /* Shorten frame num gaps so we don't have to allocate reference
1433  * frames just to throw them away */
1434  if (h->poc.frame_num != h->poc.prev_frame_num) {
1435  int unwrap_prev_frame_num = h->poc.prev_frame_num;
1436  int max_frame_num = 1 << sps->log2_max_frame_num;
1437 
1438  if (unwrap_prev_frame_num > h->poc.frame_num)
1439  unwrap_prev_frame_num -= max_frame_num;
1440 
1441  if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
1442  unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
1443  if (unwrap_prev_frame_num < 0)
1444  unwrap_prev_frame_num += max_frame_num;
1445 
1446  h->poc.prev_frame_num = unwrap_prev_frame_num;
1447  }
1448  }
1449 
1450  /* See if we have a decoded first field looking for a pair...
1451  * Here, we're using that to see if we should mark previously
1452  * decode frames as "finished".
1453  * We have to do that before the "dummy" in-between frame allocation,
1454  * since that can modify h->cur_pic_ptr. */
1455  if (h->first_field) {
1456  int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
1457  av_assert0(h->cur_pic_ptr);
1458  av_assert0(h->cur_pic_ptr->f->buf[0]);
1459  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1460 
1461  /* Mark old field/frame as completed */
1462  if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
1463  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
1464  }
1465 
1466  /* figure out if we have a complementary field pair */
1467  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1468  /* Previous field is unmatched. Don't display it, but let it
1469  * remain for reference if marked as such. */
1470  if (last_pic_structure != PICT_FRAME) {
1471  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1472  last_pic_structure == PICT_TOP_FIELD);
1473  }
1474  } else {
1475  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1476  /* This and previous field were reference, but had
1477  * different frame_nums. Consider this field first in
1478  * pair. Throw away previous field except for reference
1479  * purposes. */
1480  if (last_pic_structure != PICT_FRAME) {
1481  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1482  last_pic_structure == PICT_TOP_FIELD);
1483  }
1484  } else {
1485  /* Second field in complementary pair */
1486  if (!((last_pic_structure == PICT_TOP_FIELD &&
1487  h->picture_structure == PICT_BOTTOM_FIELD) ||
1488  (last_pic_structure == PICT_BOTTOM_FIELD &&
1489  h->picture_structure == PICT_TOP_FIELD))) {
1490  av_log(h->avctx, AV_LOG_ERROR,
1491  "Invalid field mode combination %d/%d\n",
1492  last_pic_structure, h->picture_structure);
1493  h->picture_structure = last_pic_structure;
1494  h->droppable = last_pic_droppable;
1495  return AVERROR_INVALIDDATA;
1496  } else if (last_pic_droppable != h->droppable) {
1497  avpriv_request_sample(h->avctx,
1498  "Found reference and non-reference fields in the same frame, which");
1499  h->picture_structure = last_pic_structure;
1500  h->droppable = last_pic_droppable;
1501  return AVERROR_PATCHWELCOME;
1502  }
1503  }
1504  }
1505  }
1506 
1507  while (h->poc.frame_num != h->poc.prev_frame_num && !h->first_field &&
1508  h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
1509  const H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
1510  av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
1511  h->poc.frame_num, h->poc.prev_frame_num);
1512  if (!sps->gaps_in_frame_num_allowed_flag)
1513  for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
1514  h->last_pocs[i] = INT_MIN;
1515  ret = h264_frame_start(h);
1516  if (ret < 0) {
1517  h->first_field = 0;
1518  return ret;
1519  }
1520 
1521  h->poc.prev_frame_num++;
1522  h->poc.prev_frame_num %= 1 << sps->log2_max_frame_num;
1523  h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
1524  h->cur_pic_ptr->invalid_gap = !sps->gaps_in_frame_num_allowed_flag;
1525  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
1526  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
1527 
1528  h->explicit_ref_marking = 0;
1529  ret = ff_h264_execute_ref_pic_marking(h);
1530  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1531  return ret;
1532  /* Error concealment: If a ref is missing, copy the previous ref
1533  * in its place.
1534  * FIXME: Avoiding a memcpy would be nice, but ref handling makes
1535  * many assumptions about there being no actual duplicates.
1536  * FIXME: This does not copy padding for out-of-frame motion
1537  * vectors. Given we are concealing a lost frame, this probably
1538  * is not noticeable by comparison, but it should be fixed. */
1539  if (h->short_ref_count) {
1540  int c[4] = {
1541  1<<(h->ps.sps->bit_depth_luma-1),
1542  1<<(h->ps.sps->bit_depth_chroma-1),
1543  1<<(h->ps.sps->bit_depth_chroma-1),
1544  -1
1545  };
1546 
1547  if (prev &&
1548  h->short_ref[0]->f->width == prev->f->width &&
1549  h->short_ref[0]->f->height == prev->f->height &&
1550  h->short_ref[0]->f->format == prev->f->format) {
1551  ff_thread_await_progress(&prev->tf, INT_MAX, 0);
1552  if (prev->field_picture)
1553  ff_thread_await_progress(&prev->tf, INT_MAX, 1);
1554  ff_thread_release_ext_buffer(&h->short_ref[0]->tf);
1555  h->short_ref[0]->tf.f = h->short_ref[0]->f;
1556  ret = ff_thread_ref_frame(&h->short_ref[0]->tf, &prev->tf);
1557  if (ret < 0)
1558  return ret;
1559  h->short_ref[0]->poc = prev->poc + 2U;
1560  h->short_ref[0]->gray = prev->gray;
1561  ff_thread_report_progress(&h->short_ref[0]->tf, INT_MAX, 0);
1562  if (h->short_ref[0]->field_picture)
1563  ff_thread_report_progress(&h->short_ref[0]->tf, INT_MAX, 1);
1564  } else if (!h->frame_recovered) {
1565  if (!h->avctx->hwaccel)
1566  color_frame(h->short_ref[0]->f, c);
1567  h->short_ref[0]->gray = 1;
1568  }
1569  h->short_ref[0]->frame_num = h->poc.prev_frame_num;
1570  }
1571  }
1572 
1573  /* See if we have a decoded first field looking for a pair...
1574  * We're using that to see whether to continue decoding in that
1575  * frame, or to allocate a new one. */
1576  if (h->first_field) {
1577  av_assert0(h->cur_pic_ptr);
1578  av_assert0(h->cur_pic_ptr->f->buf[0]);
1579  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1580 
1581  /* figure out if we have a complementary field pair */
1582  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1583  /* Previous field is unmatched. Don't display it, but let it
1584  * remain for reference if marked as such. */
1585  h->missing_fields ++;
1586  h->cur_pic_ptr = NULL;
1587  h->first_field = FIELD_PICTURE(h);
1588  } else {
1589  h->missing_fields = 0;
1590  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1591  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1592  h->picture_structure==PICT_BOTTOM_FIELD);
1593  /* This and the previous field had different frame_nums.
1594  * Consider this field first in pair. Throw away previous
1595  * one except for reference purposes. */
1596  h->first_field = 1;
1597  h->cur_pic_ptr = NULL;
1598  } else if (h->cur_pic_ptr->reference & DELAYED_PIC_REF) {
1599  /* This frame was already output, we cannot draw into it
1600  * anymore.
1601  */
1602  h->first_field = 1;
1603  h->cur_pic_ptr = NULL;
1604  } else {
1605  /* Second field in complementary pair */
1606  h->first_field = 0;
1607  }
1608  }
1609  } else {
1610  /* Frame or first field in a potentially complementary pair */
1611  h->first_field = FIELD_PICTURE(h);
1612  }
1613 
1614  if (!FIELD_PICTURE(h) || h->first_field) {
1615  if (h264_frame_start(h) < 0) {
1616  h->first_field = 0;
1617  return AVERROR_INVALIDDATA;
1618  }
1619  } else {
1620  int field = h->picture_structure == PICT_BOTTOM_FIELD;
1621  release_unused_pictures(h, 0);
1622  h->cur_pic_ptr->tf.owner[field] = h->avctx;
1623  }
1624  /* Some macroblocks can be accessed before they're available in case
1625  * of lost slices, MBAFF or threading. */
1626  if (FIELD_PICTURE(h)) {
1627  for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
1628  memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
1629  } else {
1630  memset(h->slice_table, -1,
1631  (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
1632  }
1633 
1634  ret = ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
1635  h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
1636  if (ret < 0)
1637  return ret;
1638 
1639  memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
1640  h->nb_mmco = sl->nb_mmco;
1641  h->explicit_ref_marking = sl->explicit_ref_marking;
1642 
1643  h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
1644 
1645  if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
1646  const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
1647 
1648  if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
1649  h->valid_recovery_point = 1;
1650 
1651  if ( h->recovery_frame < 0
1652  || av_zero_extend(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
1653  h->recovery_frame = av_zero_extend(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
1654 
1655  if (!h->valid_recovery_point)
1656  h->recovery_frame = h->poc.frame_num;
1657  }
1658  }
1659 
1660  h->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_KEY * !!(nal->type == H264_NAL_IDR_SLICE);
1661 
1662  if (nal->type == H264_NAL_IDR_SLICE) {
1663  h->cur_pic_ptr->recovered |= FRAME_RECOVERED_IDR;
1664  // If we have an IDR, all frames after it in decoded order are
1665  // "recovered".
1666  h->frame_recovered |= FRAME_RECOVERED_IDR;
1667  }
1668 
1669  if (h->recovery_frame == h->poc.frame_num && nal->ref_idc) {
1670  h->recovery_frame = -1;
1671  h->cur_pic_ptr->recovered |= FRAME_RECOVERED_SEI;
1672  }
1673 
1674 #if 1
1675  h->cur_pic_ptr->recovered |= h->frame_recovered;
1676 #else
1677  h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
1678 #endif
1679 
1680  /* Set the frame properties/side data. Only done for the second field in
1681  * field coded frames, since some SEI information is present for each field
1682  * and is merged by the SEI parsing code. */
1683  if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
1684  ret = h264_export_frame_props(h);
1685  if (ret < 0)
1686  return ret;
1687 
1688  ret = h264_select_output_frame(h);
1689  if (ret < 0)
1690  return ret;
1691  }
1692 
1693  return 0;
1694 }
1695 
1696 static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
1697  const H2645NAL *nal)
1698 {
1699  const SPS *sps;
1700  const PPS *pps;
1701  int ret;
1702  unsigned int slice_type, tmp, i;
1703  int field_pic_flag, bottom_field_flag;
1704  int first_slice = sl == h->slice_ctx && !h->current_slice;
1705  int picture_structure;
1706 
1707  if (first_slice)
1708  av_assert0(!h->setup_finished);
1709 
1710  sl->first_mb_addr = get_ue_golomb_long(&sl->gb);
1711 
1712  slice_type = get_ue_golomb_31(&sl->gb);
1713  if (slice_type > 9) {
1714  av_log(h->avctx, AV_LOG_ERROR,
1715  "slice type %d too large at %d\n",
1716  slice_type, sl->first_mb_addr);
1717  return AVERROR_INVALIDDATA;
1718  }
1719  if (slice_type > 4) {
1720  slice_type -= 5;
1721  sl->slice_type_fixed = 1;
1722  } else
1723  sl->slice_type_fixed = 0;
1724 
1725  slice_type = ff_h264_golomb_to_pict_type[slice_type];
1726  sl->slice_type = slice_type;
1727  sl->slice_type_nos = slice_type & 3;
1728 
1729  if (nal->type == H264_NAL_IDR_SLICE &&
1730  sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1731  av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
1732  return AVERROR_INVALIDDATA;
1733  }
1734 
1735  sl->pps_id = get_ue_golomb(&sl->gb);
1736  if (sl->pps_id >= MAX_PPS_COUNT) {
1737  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
1738  return AVERROR_INVALIDDATA;
1739  }
1740  if (!h->ps.pps_list[sl->pps_id]) {
1741  av_log(h->avctx, AV_LOG_ERROR,
1742  "non-existing PPS %u referenced\n",
1743  sl->pps_id);
1744  return AVERROR_INVALIDDATA;
1745  }
1746  pps = h->ps.pps_list[sl->pps_id];
1747  sps = pps->sps;
1748 
1749  sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
1750  if (!first_slice) {
1751  if (h->poc.frame_num != sl->frame_num) {
1752  av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
1753  h->poc.frame_num, sl->frame_num);
1754  return AVERROR_INVALIDDATA;
1755  }
1756  }
1757 
1758  sl->mb_mbaff = 0;
1759 
1760  if (sps->frame_mbs_only_flag) {
1761  picture_structure = PICT_FRAME;
1762  } else {
1763  if (!sps->direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
1764  av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
1765  return -1;
1766  }
1767  field_pic_flag = get_bits1(&sl->gb);
1768  if (field_pic_flag) {
1769  bottom_field_flag = get_bits1(&sl->gb);
1770  picture_structure = PICT_TOP_FIELD + bottom_field_flag;
1771  } else {
1772  picture_structure = PICT_FRAME;
1773  }
1774  }
1775  sl->picture_structure = picture_structure;
1776  sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
1777 
1778  if (picture_structure == PICT_FRAME) {
1779  sl->curr_pic_num = sl->frame_num;
1780  sl->max_pic_num = 1 << sps->log2_max_frame_num;
1781  } else {
1782  sl->curr_pic_num = 2 * sl->frame_num + 1;
1783  sl->max_pic_num = 1 << (sps->log2_max_frame_num + 1);
1784  }
1785 
1786  if (nal->type == H264_NAL_IDR_SLICE) {
1787  unsigned idr_pic_id = get_ue_golomb_long(&sl->gb);
1788  if (idr_pic_id < 65536) {
1789  sl->idr_pic_id = idr_pic_id;
1790  } else
1791  av_log(h->avctx, AV_LOG_WARNING, "idr_pic_id is invalid\n");
1792  }
1793 
1794  sl->poc_lsb = 0;
1795  sl->delta_poc_bottom = 0;
1796  if (sps->poc_type == 0) {
1797  sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
1798 
1799  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1800  sl->delta_poc_bottom = get_se_golomb(&sl->gb);
1801  }
1802 
1803  sl->delta_poc[0] = sl->delta_poc[1] = 0;
1804  if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
1805  sl->delta_poc[0] = get_se_golomb(&sl->gb);
1806 
1807  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1808  sl->delta_poc[1] = get_se_golomb(&sl->gb);
1809  }
1810 
1811  sl->redundant_pic_count = 0;
1812  if (pps->redundant_pic_cnt_present)
1813  sl->redundant_pic_count = get_ue_golomb(&sl->gb);
1814 
1815  if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
1816  sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
1817 
1818  ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
1819  &sl->gb, pps, sl->slice_type_nos,
1820  picture_structure, h->avctx);
1821  if (ret < 0)
1822  return ret;
1823 
1824  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1825  ret = ff_h264_decode_ref_pic_list_reordering(sl, h->avctx);
1826  if (ret < 0) {
1827  sl->ref_count[1] = sl->ref_count[0] = 0;
1828  return ret;
1829  }
1830  }
1831 
1832  sl->pwt.use_weight = 0;
1833  for (i = 0; i < 2; i++) {
1834  sl->pwt.luma_weight_flag[i] = 0;
1835  sl->pwt.chroma_weight_flag[i] = 0;
1836  }
1837  if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
1838  (pps->weighted_bipred_idc == 1 &&
1839  sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
1840  ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
1841  sl->slice_type_nos, &sl->pwt,
1842  picture_structure, h->avctx);
1843  if (ret < 0)
1844  return ret;
1845  }
1846 
1847  sl->explicit_ref_marking = 0;
1848  if (nal->ref_idc) {
1849  ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx);
1850  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1851  return AVERROR_INVALIDDATA;
1852  }
1853 
1854  if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
1855  tmp = get_ue_golomb_31(&sl->gb);
1856  if (tmp > 2) {
1857  av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
1858  return AVERROR_INVALIDDATA;
1859  }
1860  sl->cabac_init_idc = tmp;
1861  }
1862 
1863  sl->last_qscale_diff = 0;
1864  tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
1865  if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
1866  av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
1867  return AVERROR_INVALIDDATA;
1868  }
1869  sl->qscale = tmp;
1870  sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
1871  sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
1872  // FIXME qscale / qp ... stuff
1873  if (sl->slice_type == AV_PICTURE_TYPE_SP)
1874  get_bits1(&sl->gb); /* sp_for_switch_flag */
1875  if (sl->slice_type == AV_PICTURE_TYPE_SP ||
1876  sl->slice_type == AV_PICTURE_TYPE_SI)
1877  get_se_golomb(&sl->gb); /* slice_qs_delta */
1878 
1879  sl->deblocking_filter = 1;
1880  sl->slice_alpha_c0_offset = 0;
1881  sl->slice_beta_offset = 0;
1882  if (pps->deblocking_filter_parameters_present) {
1883  tmp = get_ue_golomb_31(&sl->gb);
1884  if (tmp > 2) {
1885  av_log(h->avctx, AV_LOG_ERROR,
1886  "deblocking_filter_idc %u out of range\n", tmp);
1887  return AVERROR_INVALIDDATA;
1888  }
1889  sl->deblocking_filter = tmp;
1890  if (sl->deblocking_filter < 2)
1891  sl->deblocking_filter ^= 1; // 1<->0
1892 
1893  if (sl->deblocking_filter) {
1894  int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
1895  int slice_beta_offset_div2 = get_se_golomb(&sl->gb);
1896  if (slice_alpha_c0_offset_div2 > 6 ||
1897  slice_alpha_c0_offset_div2 < -6 ||
1898  slice_beta_offset_div2 > 6 ||
1899  slice_beta_offset_div2 < -6) {
1900  av_log(h->avctx, AV_LOG_ERROR,
1901  "deblocking filter parameters %d %d out of range\n",
1902  slice_alpha_c0_offset_div2, slice_beta_offset_div2);
1903  return AVERROR_INVALIDDATA;
1904  }
1905  sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
1906  sl->slice_beta_offset = slice_beta_offset_div2 * 2;
1907  }
1908  }
1909 
1910  return 0;
1911 }
1912 
1913 /* do all the per-slice initialization needed before we can start decoding the
1914  * actual MBs */
1915 static int h264_slice_init(H264Context *h, H264SliceContext *sl,
1916  const H2645NAL *nal)
1917 {
1918  int i, j, ret = 0;
1919 
1920  if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
1921  av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
1922  return AVERROR_INVALIDDATA;
1923  }
1924 
1925  av_assert1(h->mb_num == h->mb_width * h->mb_height);
1926  if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
1927  sl->first_mb_addr >= h->mb_num) {
1928  av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
1929  return AVERROR_INVALIDDATA;
1930  }
1931  sl->resync_mb_x = sl->mb_x = sl->first_mb_addr % h->mb_width;
1932  sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
1933  FIELD_OR_MBAFF_PICTURE(h);
1934  if (h->picture_structure == PICT_BOTTOM_FIELD)
1935  sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
1936  av_assert1(sl->mb_y < h->mb_height);
1937 
1938  ret = ff_h264_build_ref_list(h, sl);
1939  if (ret < 0)
1940  return ret;
1941 
1942  if (h->ps.pps->weighted_bipred_idc == 2 &&
1943  sl->slice_type_nos == AV_PICTURE_TYPE_B) {
1944  implicit_weight_table(h, sl, -1);
1945  if (FRAME_MBAFF(h)) {
1946  implicit_weight_table(h, sl, 0);
1947  implicit_weight_table(h, sl, 1);
1948  }
1949  }
1950 
1951  if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
1952  ff_h264_direct_dist_scale_factor(h, sl);
1953  ff_h264_direct_ref_list_init(h, sl);
1954 
1955  if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
1956  (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
1957  h->nal_unit_type != H264_NAL_IDR_SLICE) ||
1958  (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
1959  sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
1960  (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&
1961  sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
1962  (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
1963  nal->ref_idc == 0))
1964  sl->deblocking_filter = 0;
1965 
1966  if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
1967  if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1968  /* Cheat slightly for speed:
1969  * Do not bother to deblock across slices. */
1970  sl->deblocking_filter = 2;
1971  } else {
1972  h->postpone_filter = 1;
1973  }
1974  }
1975  sl->qp_thresh = 15 -
1976  FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
1977  FFMAX3(0,
1978  h->ps.pps->chroma_qp_index_offset[0],
1979  h->ps.pps->chroma_qp_index_offset[1]) +
1980  6 * (h->ps.sps->bit_depth_luma - 8);
1981 
1982  // slice_table is uint16_t initialized to 0xFFFF as a sentinel.
1983  if (h->current_slice >= 0xFFFE) {
1984  av_log(h->avctx, AV_LOG_ERROR, "Too many slices (%d)\n", h->current_slice + 1);
1985  return AVERROR_PATCHWELCOME;
1986  }
1987 
1988  sl->slice_num = ++h->current_slice;
1989 
1990  if (sl->slice_num)
1991  h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
1992  if ( h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
1993  && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
1994  && sl->slice_num >= MAX_SLICES) {
1995  //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
1996  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);
1997  }
1998 
1999  for (j = 0; j < 2; j++) {
2000  int id_list[16];
2001  int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
2002  for (i = 0; i < 16; i++) {
2003  id_list[i] = 60;
2004  if (j < sl->list_count && i < sl->ref_count[j] &&
2005  sl->ref_list[j][i].parent->f->buf[0]) {
2006  int k;
2007  const AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
2008  for (k = 0; k < h->short_ref_count; k++)
2009  if (h->short_ref[k]->f->buf[0]->buffer == buf) {
2010  id_list[i] = k;
2011  break;
2012  }
2013  for (k = 0; k < h->long_ref_count; k++)
2014  if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
2015  id_list[i] = h->short_ref_count + k;
2016  break;
2017  }
2018  }
2019  }
2020 
2021  ref2frm[0] =
2022  ref2frm[1] = -1;
2023  for (i = 0; i < 16; i++)
2024  ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
2025  ref2frm[18 + 0] =
2026  ref2frm[18 + 1] = -1;
2027  for (i = 16; i < 48; i++)
2028  ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
2029  (sl->ref_list[j][i].reference & 3);
2030  }
2031 
2032  if (sl->slice_type_nos == AV_PICTURE_TYPE_I) {
2033  h->cur_pic_ptr->gray = 0;
2034  h->non_gray = 1;
2035  } else {
2036  int gray = 0;
2037  for (j = 0; j < sl->list_count; j++) {
2038  for (i = 0; i < sl->ref_count[j]; i++) {
2039  gray |= sl->ref_list[j][i].parent->gray;
2040  }
2041  }
2042  h->cur_pic_ptr->gray = gray;
2043  }
2044 
2045  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
2046  av_log(h->avctx, AV_LOG_DEBUG,
2047  "slice:%d %c mb:%d %c%s%s frame:%d poc:%d/%d ref:%d/%d qp:%d loop:%d:%d:%d weight:%d%s %s\n",
2048  sl->slice_num,
2049  (h->picture_structure == PICT_FRAME ? 'F' : h->picture_structure == PICT_TOP_FIELD ? 'T' : 'B'),
2050  sl->mb_y * h->mb_width + sl->mb_x,
2051  av_get_picture_type_char(sl->slice_type),
2052  sl->slice_type_fixed ? " fix" : "",
2053  nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
2054  h->poc.frame_num,
2055  h->cur_pic_ptr->field_poc[0],
2056  h->cur_pic_ptr->field_poc[1],
2057  sl->ref_count[0], sl->ref_count[1],
2058  sl->qscale,
2059  sl->deblocking_filter,
2060  sl->slice_alpha_c0_offset, sl->slice_beta_offset,
2061  sl->pwt.use_weight,
2062  sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
2063  sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
2064  }
2065 
2066  return 0;
2067 }
2068 
2069 int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
2070 {
2071  H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
2072  int first_slice = sl == h->slice_ctx && !h->current_slice;
2073  int ret;
2074 
2075  sl->gb = nal->gb;
2076 
2077  ret = h264_slice_header_parse(h, sl, nal);
2078  if (ret < 0)
2079  return ret;
2080 
2081  // discard redundant pictures
2082  if (sl->redundant_pic_count > 0) {
2083  sl->ref_count[0] = sl->ref_count[1] = 0;
2084  return 0;
2085  }
2086 
2087  if (sl->first_mb_addr == 0 || !h->current_slice) {
2088  if (h->setup_finished) {
2089  av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
2090  return AVERROR_INVALIDDATA;
2091  }
2092  }
2093 
2094  if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
2095  if (h->current_slice) {
2096  // this slice starts a new field
2097  // first decode any pending queued slices
2098  if (h->nb_slice_ctx_queued) {
2099  H264SliceContext tmp_ctx;
2100 
2101  ret = ff_h264_execute_decode_slices(h);
2102  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
2103  return ret;
2104 
2105  memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
2106  memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
2107  memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
2108  sl = h->slice_ctx;
2109  }
2110 
2111  if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
2112  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2113  if (ret < 0)
2114  return ret;
2115  } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type == H264_NAL_IDR_SLICE) {
2116  av_log(h->avctx, AV_LOG_WARNING, "Broken frame packetizing\n");
2117  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2118  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
2119  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
2120  h->cur_pic_ptr = NULL;
2121  if (ret < 0)
2122  return ret;
2123  } else
2124  return AVERROR_INVALIDDATA;
2125  }
2126 
2127  if (!h->first_field) {
2128  if (h->cur_pic_ptr && !h->droppable) {
2129  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
2130  h->picture_structure == PICT_BOTTOM_FIELD);
2131  }
2132  h->cur_pic_ptr = NULL;
2133  }
2134  }
2135 
2136  if (!h->current_slice)
2137  av_assert0(sl == h->slice_ctx);
2138 
2139  if (h->current_slice == 0 && !h->first_field) {
2140  if (
2141  (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
2142  (h->avctx->skip_frame >= AVDISCARD_BIDIR && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
2143  (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
2144  (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
2145  h->avctx->skip_frame >= AVDISCARD_ALL) {
2146  return 0;
2147  }
2148  }
2149 
2150  if (!first_slice) {
2151  const PPS *pps = h->ps.pps_list[sl->pps_id];
2152 
2153  if (h->ps.pps->sps_id != pps->sps_id ||
2154  h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
2155  (h->setup_finished && h->ps.pps != pps)*/) {
2156  av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
2157  return AVERROR_INVALIDDATA;
2158  }
2159  if (h->ps.sps != pps->sps) {
2160  av_log(h->avctx, AV_LOG_ERROR,
2161  "SPS changed in the middle of the frame\n");
2162  return AVERROR_INVALIDDATA;
2163  }
2164  }
2165 
2166  if (h->current_slice == 0) {
2167  ret = h264_field_start(h, sl, nal, first_slice);
2168  if (ret < 0)
2169  return ret;
2170  } else {
2171  if (h->picture_structure != sl->picture_structure ||
2172  h->droppable != (nal->ref_idc == 0)) {
2173  av_log(h->avctx, AV_LOG_ERROR,
2174  "Changing field mode (%d -> %d) between slices is not allowed\n",
2175  h->picture_structure, sl->picture_structure);
2176  return AVERROR_INVALIDDATA;
2177  } else if (!h->cur_pic_ptr) {
2178  av_log(h->avctx, AV_LOG_ERROR,
2179  "unset cur_pic_ptr on slice %d\n",
2180  h->current_slice + 1);
2181  return AVERROR_INVALIDDATA;
2182  }
2183  }
2184 
2185  ret = h264_slice_init(h, sl, nal);
2186  if (ret < 0)
2187  return ret;
2188 
2189  h->nb_slice_ctx_queued++;
2190 
2191  return 0;
2192 }
2193 
2194 int ff_h264_get_slice_type(const H264SliceContext *sl)
2195 {
2196  switch (sl->slice_type) {
2197  case AV_PICTURE_TYPE_P:
2198  return 0;
2199  case AV_PICTURE_TYPE_B:
2200  return 1;
2201  case AV_PICTURE_TYPE_I:
2202  return 2;
2203  case AV_PICTURE_TYPE_SP:
2204  return 3;
2205  case AV_PICTURE_TYPE_SI:
2206  return 4;
2207  default:
2208  return AVERROR_INVALIDDATA;
2209  }
2210 }
2211 
2212 static av_always_inline void fill_filter_caches_inter(const H264Context *h,
2213  H264SliceContext *sl,
2214  int mb_type, int top_xy,
2215  const int left_xy[LEFT_MBS],
2216  int top_type,
2217  const int left_type[LEFT_MBS],
2218  int mb_xy, int list)
2219 {
2220  int b_stride = h->b_stride;
2221  int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
2222  int8_t *ref_cache = &sl->ref_cache[list][scan8[0]];
2223  if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
2224  if (USES_LIST(top_type, list)) {
2225  const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;
2226  const int b8_xy = 4 * top_xy + 2;
2227  const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2228  AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
2229  ref_cache[0 - 1 * 8] =
2230  ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
2231  ref_cache[2 - 1 * 8] =
2232  ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
2233  } else {
2234  AV_ZERO128(mv_dst - 1 * 8);
2235  AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2236  }
2237 
2238  if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
2239  if (USES_LIST(left_type[LTOP], list)) {
2240  const int b_xy = h->mb2b_xy[left_xy[LTOP]] + 3;
2241  const int b8_xy = 4 * left_xy[LTOP] + 1;
2242  const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2243  AV_COPY32(mv_dst - 1 + 0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
2244  AV_COPY32(mv_dst - 1 + 8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
2245  AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
2246  AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
2247  ref_cache[-1 + 0] =
2248  ref_cache[-1 + 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
2249  ref_cache[-1 + 16] =
2250  ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
2251  } else {
2252  AV_ZERO32(mv_dst - 1 + 0);
2253  AV_ZERO32(mv_dst - 1 + 8);
2254  AV_ZERO32(mv_dst - 1 + 16);
2255  AV_ZERO32(mv_dst - 1 + 24);
2256  ref_cache[-1 + 0] =
2257  ref_cache[-1 + 8] =
2258  ref_cache[-1 + 16] =
2259  ref_cache[-1 + 24] = LIST_NOT_USED;
2260  }
2261  }
2262  }
2263 
2264  if (!USES_LIST(mb_type, list)) {
2265  fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
2266  AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2267  AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2268  AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2269  AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2270  return;
2271  }
2272 
2273  {
2274  const int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
2275  const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2276  uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
2277  uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
2278  AV_WN32A(&ref_cache[0 * 8], ref01);
2279  AV_WN32A(&ref_cache[1 * 8], ref01);
2280  AV_WN32A(&ref_cache[2 * 8], ref23);
2281  AV_WN32A(&ref_cache[3 * 8], ref23);
2282  }
2283 
2284  {
2285  int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
2286  AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
2287  AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
2288  AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
2289  AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
2290  }
2291 }
2292 
2293 /**
2294  * @return non zero if the loop filter can be skipped
2295  */
2296 static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
2297 {
2298  const int mb_xy = sl->mb_xy;
2299  int top_xy, left_xy[LEFT_MBS];
2300  int top_type, left_type[LEFT_MBS];
2301  const uint8_t *nnz;
2302  uint8_t *nnz_cache;
2303 
2304  top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
2305 
2306  left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
2307  if (FRAME_MBAFF(h)) {
2308  const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
2309  const int curr_mb_field_flag = IS_INTERLACED(mb_type);
2310  if (sl->mb_y & 1) {
2311  if (left_mb_field_flag != curr_mb_field_flag)
2312  left_xy[LTOP] -= h->mb_stride;
2313  } else {
2314  if (curr_mb_field_flag)
2315  top_xy += h->mb_stride &
2316  (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
2317  if (left_mb_field_flag != curr_mb_field_flag)
2318  left_xy[LBOT] += h->mb_stride;
2319  }
2320  }
2321 
2322  sl->top_mb_xy = top_xy;
2323  sl->left_mb_xy[LTOP] = left_xy[LTOP];
2324  sl->left_mb_xy[LBOT] = left_xy[LBOT];
2325  {
2326  /* For sufficiently low qp, filtering wouldn't do anything.
2327  * This is a conservative estimate: could also check beta_offset
2328  * and more accurate chroma_qp. */
2329  int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
2330  int qp = h->cur_pic.qscale_table[mb_xy];
2331  if (qp <= qp_thresh &&
2332  (left_xy[LTOP] < 0 ||
2333  ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
2334  (top_xy < 0 ||
2335  ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
2336  if (!FRAME_MBAFF(h))
2337  return 1;
2338  if ((left_xy[LTOP] < 0 ||
2339  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
2340  (top_xy < h->mb_stride ||
2341  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
2342  return 1;
2343  }
2344  }
2345 
2346  top_type = h->cur_pic.mb_type[top_xy];
2347  left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
2348  left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
2349  if (sl->deblocking_filter == 2) {
2350  if (h->slice_table[top_xy] != sl->slice_num)
2351  top_type = 0;
2352  if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
2353  left_type[LTOP] = left_type[LBOT] = 0;
2354  } else {
2355  if (h->slice_table[top_xy] == 0xFFFF)
2356  top_type = 0;
2357  if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
2358  left_type[LTOP] = left_type[LBOT] = 0;
2359  }
2360  sl->top_type = top_type;
2361  sl->left_type[LTOP] = left_type[LTOP];
2362  sl->left_type[LBOT] = left_type[LBOT];
2363 
2364  if (IS_INTRA(mb_type))
2365  return 0;
2366 
2367  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2368  top_type, left_type, mb_xy, 0);
2369  if (sl->list_count == 2)
2370  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2371  top_type, left_type, mb_xy, 1);
2372 
2373  nnz = h->non_zero_count[mb_xy];
2374  nnz_cache = sl->non_zero_count_cache;
2375  AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
2376  AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
2377  AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
2378  AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
2379  sl->cbp = h->cbp_table[mb_xy];
2380 
2381  if (top_type) {
2382  nnz = h->non_zero_count[top_xy];
2383  AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
2384  }
2385 
2386  if (left_type[LTOP]) {
2387  nnz = h->non_zero_count[left_xy[LTOP]];
2388  nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
2389  nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
2390  nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
2391  nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
2392  }
2393 
2394  /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
2395  * from what the loop filter needs */
2396  if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
2397  if (IS_8x8DCT(top_type)) {
2398  nnz_cache[4 + 8 * 0] =
2399  nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
2400  nnz_cache[6 + 8 * 0] =
2401  nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
2402  }
2403  if (IS_8x8DCT(left_type[LTOP])) {
2404  nnz_cache[3 + 8 * 1] =
2405  nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
2406  }
2407  if (IS_8x8DCT(left_type[LBOT])) {
2408  nnz_cache[3 + 8 * 3] =
2409  nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
2410  }
2411 
2412  if (IS_8x8DCT(mb_type)) {
2413  nnz_cache[scan8[0]] =
2414  nnz_cache[scan8[1]] =
2415  nnz_cache[scan8[2]] =
2416  nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
2417 
2418  nnz_cache[scan8[0 + 4]] =
2419  nnz_cache[scan8[1 + 4]] =
2420  nnz_cache[scan8[2 + 4]] =
2421  nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
2422 
2423  nnz_cache[scan8[0 + 8]] =
2424  nnz_cache[scan8[1 + 8]] =
2425  nnz_cache[scan8[2 + 8]] =
2426  nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
2427 
2428  nnz_cache[scan8[0 + 12]] =
2429  nnz_cache[scan8[1 + 12]] =
2430  nnz_cache[scan8[2 + 12]] =
2431  nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
2432  }
2433  }
2434 
2435  return 0;
2436 }
2437 
2438 static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
2439 {
2440  uint8_t *dest_y, *dest_cb, *dest_cr;
2441  int linesize, uvlinesize, mb_x, mb_y;
2442  const int end_mb_y = sl->mb_y + FRAME_MBAFF(h);
2443  const int old_slice_type = sl->slice_type;
2444  const int pixel_shift = h->pixel_shift;
2445  const int block_h = 16 >> h->chroma_y_shift;
2446 
2447  if (h->postpone_filter)
2448  return;
2449 
2450  if (sl->deblocking_filter) {
2451  for (mb_x = start_x; mb_x < end_x; mb_x++)
2452  for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
2453  int mb_xy, mb_type;
2454  mb_xy = sl->mb_xy = mb_x + mb_y * h->mb_stride;
2455  mb_type = h->cur_pic.mb_type[mb_xy];
2456 
2457  if (FRAME_MBAFF(h))
2458  sl->mb_mbaff =
2459  sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2460 
2461  sl->mb_x = mb_x;
2462  sl->mb_y = mb_y;
2463  dest_y = h->cur_pic.f->data[0] +
2464  ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
2465  dest_cb = h->cur_pic.f->data[1] +
2466  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2467  mb_y * sl->uvlinesize * block_h;
2468  dest_cr = h->cur_pic.f->data[2] +
2469  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2470  mb_y * sl->uvlinesize * block_h;
2471  // FIXME simplify above
2472 
2473  if (MB_FIELD(sl)) {
2474  linesize = sl->mb_linesize = sl->linesize * 2;
2475  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
2476  if (mb_y & 1) { // FIXME move out of this function?
2477  dest_y -= sl->linesize * 15;
2478  dest_cb -= sl->uvlinesize * (block_h - 1);
2479  dest_cr -= sl->uvlinesize * (block_h - 1);
2480  }
2481  } else {
2482  linesize = sl->mb_linesize = sl->linesize;
2483  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
2484  }
2485  backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
2486  uvlinesize, 0);
2487  if (fill_filter_caches(h, sl, mb_type))
2488  continue;
2489  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
2490  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
2491 
2492  if (FRAME_MBAFF(h)) {
2493  ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
2494  linesize, uvlinesize);
2495  } else {
2496  ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
2497  dest_cr, linesize, uvlinesize);
2498  }
2499  }
2500  }
2501  sl->slice_type = old_slice_type;
2502  sl->mb_x = end_x;
2503  sl->mb_y = end_mb_y - FRAME_MBAFF(h);
2504  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
2505  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
2506 }
2507 
2508 static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
2509 {
2510  const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
2511  int mb_type = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
2512  h->cur_pic.mb_type[mb_xy - 1] :
2513  (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
2514  h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
2515  sl->mb_mbaff = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2516 }
2517 
2518 /**
2519  * Draw edges and report progress for the last MB row.
2520  */
2521 static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
2522 {
2523  int top = 16 * (sl->mb_y >> FIELD_PICTURE(h));
2524  int pic_height = 16 * h->mb_height >> FIELD_PICTURE(h);
2525  int height = 16 << FRAME_MBAFF(h);
2526  int deblock_border = (16 + 4) << FRAME_MBAFF(h);
2527 
2528  if (sl->deblocking_filter) {
2529  if ((top + height) >= pic_height)
2530  height += deblock_border;
2531  top -= deblock_border;
2532  }
2533 
2534  if (top >= pic_height || (top + height) < 0)
2535  return;
2536 
2537  height = FFMIN(height, pic_height - top);
2538  if (top < 0) {
2539  height = top + height;
2540  top = 0;
2541  }
2542 
2543  ff_h264_draw_horiz_band(h, sl, top, height);
2544 
2545  if (h->droppable || h->er.error_occurred)
2546  return;
2547 
2548  ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
2549  h->picture_structure == PICT_BOTTOM_FIELD);
2550 }
2551 
2552 static void er_add_slice(H264SliceContext *sl,
2553  int startx, int starty,
2554  int endx, int endy, int status)
2555 {
2556  if (!sl->h264->enable_er)
2557  return;
2558 
2559  if (CONFIG_ERROR_RESILIENCE) {
2560  ff_er_add_slice(sl->er, startx, starty, endx, endy, status);
2561  }
2562 }
2563 
2564 static int decode_slice(struct AVCodecContext *avctx, void *arg)
2565 {
2566  H264SliceContext *sl = arg;
2567  const H264Context *h = sl->h264;
2568  int lf_x_start = sl->mb_x;
2569  int orig_deblock = sl->deblocking_filter;
2570  int ret;
2571 
2572  sl->linesize = h->cur_pic_ptr->f->linesize[0];
2573  sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
2574 
2575  ret = alloc_scratch_buffers(sl, sl->linesize);
2576  if (ret < 0)
2577  return ret;
2578 
2579  sl->mb_skip_run = -1;
2580 
2581  av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
2582 
2583  if (h->postpone_filter)
2584  sl->deblocking_filter = 0;
2585 
2586  sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
2587  (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
2588 
2589  if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && sl->er->error_status_table) {
2590  const int start_i = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
2591  if (start_i) {
2592  int prev_status = sl->er->error_status_table[sl->er->mb_index2xy[start_i - 1]];
2593  prev_status &= ~ VP_START;
2594  if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
2595  sl->er->error_occurred = 1;
2596  }
2597  }
2598 
2599  if (h->ps.pps->cabac) {
2600  /* realign */
2601  align_get_bits(&sl->gb);
2602 
2603  /* init cabac */
2604  ret = ff_init_cabac_decoder(&sl->cabac,
2605  sl->gb.buffer + get_bits_count(&sl->gb) / 8,
2606  (get_bits_left(&sl->gb) + 7) / 8);
2607  if (ret < 0)
2608  return ret;
2609 
2610  ff_h264_init_cabac_states(h, sl);
2611 
2612  for (;;) {
2613  int ret, eos;
2614  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2615  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2616  sl->next_slice_idx);
2617  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2618  sl->mb_y, ER_MB_ERROR);
2619  return AVERROR_INVALIDDATA;
2620  }
2621 
2622  ret = ff_h264_decode_mb_cabac(h, sl);
2623 
2624  if (ret >= 0)
2625  ff_h264_hl_decode_mb(h, sl);
2626 
2627  // FIXME optimal? or let mb_decode decode 16x32 ?
2628  if (ret >= 0 && FRAME_MBAFF(h)) {
2629  sl->mb_y++;
2630 
2631  ret = ff_h264_decode_mb_cabac(h, sl);
2632 
2633  if (ret >= 0)
2634  ff_h264_hl_decode_mb(h, sl);
2635  sl->mb_y--;
2636  }
2637  eos = get_cabac_terminate(&sl->cabac);
2638 
2639  if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
2640  sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
2641  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2642  sl->mb_y, ER_MB_END);
2643  if (sl->mb_x >= lf_x_start)
2644  loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
2645  goto finish;
2646  }
2647  if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
2648  av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %td\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
2649  if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
2650  av_log(h->avctx, AV_LOG_ERROR,
2651  "error while decoding MB %d %d, bytestream %td\n",
2652  sl->mb_x, sl->mb_y,
2653  sl->cabac.bytestream_end - sl->cabac.bytestream);
2654  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2655  sl->mb_y, ER_MB_ERROR);
2656  return AVERROR_INVALIDDATA;
2657  }
2658 
2659  if (++sl->mb_x >= h->mb_width) {
2660  loop_filter(h, sl, lf_x_start, sl->mb_x);
2661  sl->mb_x = lf_x_start = 0;
2662  decode_finish_row(h, sl);
2663  ++sl->mb_y;
2664  if (FIELD_OR_MBAFF_PICTURE(h)) {
2665  ++sl->mb_y;
2666  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2667  predict_field_decoding_flag(h, sl);
2668  }
2669  }
2670 
2671  if (eos || sl->mb_y >= h->mb_height) {
2672  ff_tlog(h->avctx, "slice end %d %d\n",
2673  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2674  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2675  sl->mb_y, ER_MB_END);
2676  if (sl->mb_x > lf_x_start)
2677  loop_filter(h, sl, lf_x_start, sl->mb_x);
2678  goto finish;
2679  }
2680  }
2681  } else {
2682  for (;;) {
2683  int ret;
2684 
2685  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2686  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2687  sl->next_slice_idx);
2688  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2689  sl->mb_y, ER_MB_ERROR);
2690  return AVERROR_INVALIDDATA;
2691  }
2692 
2693  ret = ff_h264_decode_mb_cavlc(h, sl);
2694 
2695  if (ret >= 0)
2696  ff_h264_hl_decode_mb(h, sl);
2697 
2698  // FIXME optimal? or let mb_decode decode 16x32 ?
2699  if (ret >= 0 && FRAME_MBAFF(h)) {
2700  sl->mb_y++;
2701  ret = ff_h264_decode_mb_cavlc(h, sl);
2702 
2703  if (ret >= 0)
2704  ff_h264_hl_decode_mb(h, sl);
2705  sl->mb_y--;
2706  }
2707 
2708  if (ret < 0) {
2709  av_log(h->avctx, AV_LOG_ERROR,
2710  "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
2711  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2712  sl->mb_y, ER_MB_ERROR);
2713  return ret;
2714  }
2715 
2716  if (++sl->mb_x >= h->mb_width) {
2717  loop_filter(h, sl, lf_x_start, sl->mb_x);
2718  sl->mb_x = lf_x_start = 0;
2719  decode_finish_row(h, sl);
2720  ++sl->mb_y;
2721  if (FIELD_OR_MBAFF_PICTURE(h)) {
2722  ++sl->mb_y;
2723  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2724  predict_field_decoding_flag(h, sl);
2725  }
2726  if (sl->mb_y >= h->mb_height) {
2727  ff_tlog(h->avctx, "slice end %d %d\n",
2728  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2729 
2730  if ( get_bits_left(&sl->gb) == 0
2731  || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
2732  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2733  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2734 
2735  goto finish;
2736  } else {
2737  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2738  sl->mb_x, sl->mb_y, ER_MB_END);
2739 
2740  return AVERROR_INVALIDDATA;
2741  }
2742  }
2743  }
2744 
2745  if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
2746  ff_tlog(h->avctx, "slice end %d %d\n",
2747  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2748 
2749  if (get_bits_left(&sl->gb) == 0) {
2750  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2751  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2752  if (sl->mb_x > lf_x_start)
2753  loop_filter(h, sl, lf_x_start, sl->mb_x);
2754 
2755  goto finish;
2756  } else {
2757  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2758  sl->mb_y, ER_MB_ERROR);
2759 
2760  return AVERROR_INVALIDDATA;
2761  }
2762  }
2763  }
2764  }
2765 
2766 finish:
2767  sl->deblocking_filter = orig_deblock;
2768  return 0;
2769 }
2770 
2771 /**
2772  * Call decode_slice() for each context.
2773  *
2774  * @param h h264 master context
2775  */
2776 int ff_h264_execute_decode_slices(H264Context *h)
2777 {
2778  AVCodecContext *const avctx = h->avctx;
2779  H264SliceContext *sl;
2780  int context_count = h->nb_slice_ctx_queued;
2781  int ret = 0;
2782  int i, j;
2783 
2784  h->slice_ctx[0].next_slice_idx = INT_MAX;
2785 
2786  if (h->avctx->hwaccel || context_count < 1)
2787  return 0;
2788 
2789  av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
2790 
2791  if (context_count == 1) {
2792 
2793  h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
2794  h->postpone_filter = 0;
2795 
2796  ret = decode_slice(avctx, &h->slice_ctx[0]);
2797  h->mb_y = h->slice_ctx[0].mb_y;
2798  if (ret < 0)
2799  goto finish;
2800  } else {
2801  av_assert0(context_count > 0);
2802  for (i = 0; i < context_count; i++) {
2803  int next_slice_idx = h->mb_width * h->mb_height;
2804  int slice_idx;
2805 
2806  sl = &h->slice_ctx[i];
2807 
2808  /* make sure none of those slices overlap */
2809  slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
2810  for (j = 0; j < context_count; j++) {
2811  H264SliceContext *sl2 = &h->slice_ctx[j];
2812  int slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
2813 
2814  if (i == j || slice_idx2 < slice_idx)
2815  continue;
2816  next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
2817  }
2818  sl->next_slice_idx = next_slice_idx;
2819  }
2820 
2821  avctx->execute(avctx, decode_slice, h->slice_ctx,
2822  NULL, context_count, sizeof(h->slice_ctx[0]));
2823 
2824  /* pull back stuff from slices to master context */
2825  sl = &h->slice_ctx[context_count - 1];
2826  h->mb_y = sl->mb_y;
2827 
2828  if (h->postpone_filter) {
2829  h->postpone_filter = 0;
2830 
2831  for (i = 0; i < context_count; i++) {
2832  int y_end, x_end;
2833 
2834  sl = &h->slice_ctx[i];
2835  y_end = FFMIN(sl->mb_y + 1, h->mb_height);
2836  x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
2837 
2838  for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
2839  sl->mb_y = j;
2840  loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
2841  j == y_end - 1 ? x_end : h->mb_width);
2842  }
2843  }
2844  }
2845  }
2846 
2847 finish:
2848  h->nb_slice_ctx_queued = 0;
2849  return ret;
2850 }
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:33
er_add_slice
static void er_add_slice(H264SliceContext *sl, int startx, int starty, int endx, int endy, int status)
Definition: h264_slice.c:2552
ff_h264_filter_mb_fast
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
Definition: h264_loopfilter.c:416
h264_slice_header_init
static int h264_slice_header_init(H264Context *h)
Definition: h264_slice.c:965
implicit_weight_table
static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
Initialize implicit_weight table.
Definition: h264_slice.c:689
H264SliceContext::mb_xy
int mb_xy
Definition: h264dec.h:232
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:216
AV_TIMECODE_STR_SIZE
#define AV_TIMECODE_STR_SIZE
Definition: timecode.h:33
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
H264SliceContext::ref_cache
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:300
ff_h264_free_tables
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:142
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: defs.h:51
av_clip
#define av_clip
Definition: common.h:100
h264_init_ps
static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
Definition: h264_slice.c:1058
H264SliceContext::max_pic_num
int max_pic_num
Definition: h264dec.h:332
H264SliceContext::nb_mmco
int nb_mmco
Definition: h264dec.h:323
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:688
CHROMA422
#define CHROMA422(h)
Definition: h264dec.h:89
FF_BUG_TRUNCATED
#define FF_BUG_TRUNCATED
Definition: avcodec.h:1359
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
cabac.h
H264Picture::poc
int poc
frame POC
Definition: h264dec.h:133
h264_export_frame_props
static int h264_export_frame_props(H264Context *h)
Definition: h264_slice.c:1171
H264Picture::f
AVFrame * f
Definition: h264dec.h:113
ff_get_format
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Select the (possibly hardware accelerated) pixel format.
Definition: decode.c:1221
out
static FILE * out
Definition: movenc.c:55
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:247
av_clip_int8
#define av_clip_int8
Definition: common.h:109
zigzag_scan8x8_cavlc
static const uint8_t zigzag_scan8x8_cavlc[64+1]
Definition: h264_slice.c:98
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3456
ff_h264_ref_picture
int ff_h264_ref_picture(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:108
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:1008
ff_h2645_sei_to_frame
int ff_h2645_sei_to_frame(AVFrame *frame, H2645SEI *sei, enum AVCodecID codec_id, AVCodecContext *avctx, const H2645VUI *vui, unsigned bit_depth_luma, unsigned bit_depth_chroma, int seed)
Definition: h2645_sei.c:518
H264Picture::ref_index
int8_t * ref_index[2]
RefStruct reference.
Definition: h264dec.h:130
int64_t
long long int64_t
Definition: coverity.c:34
HWACCEL_MAX
#define HWACCEL_MAX
MB_MBAFF
#define MB_MBAFF(h)
Definition: h264dec.h:62
H264SliceContext::mvd_table
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:313
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:254
H264_SEI_PIC_STRUCT_TOP_BOTTOM
@ H264_SEI_PIC_STRUCT_TOP_BOTTOM
3: top field, bottom field, in that order
Definition: h264_sei.h:35
color_frame
static void color_frame(AVFrame *frame, const int c[4])
Definition: h264_slice.c:306
H264Picture::pps
const PPS * pps
Definition: h264dec.h:156
AV_FRAME_DATA_S12M_TIMECODE
@ AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:152
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:112
ff_h264_slice_context_init
void ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl)
Init slice context.
Definition: h264dec.c:264
ERContext::mb_index2xy
int * mb_index2xy
Definition: error_resilience.h:60
predict_field_decoding_flag
static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
Definition: h264_slice.c:2508
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:459
pixdesc.h
AVFrame::width
int width
Definition: frame.h:531
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:777
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:53
ff_h264_update_thread_context
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:338
alloc_scratch_buffers
static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
Definition: h264_slice.c:130
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:669
FRAME_RECOVERED_IDR
#define FRAME_RECOVERED_IDR
We have seen an IDR, so all the following frames in coded order are correctly decodable.
Definition: h264dec.h:522
decode_finish_row
static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
Draw edges and report progress for the last MB row.
Definition: h264_slice.c:2521
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:268
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: defs.h:59
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:539
ff_er_frame_start
void ff_er_frame_start(ERContext *s)
Definition: error_resilience.c:812
H264Picture::qscale_table
int8_t * qscale_table
Definition: h264dec.h:119
H264SliceContext::left_mb_xy
int left_mb_xy[LEFT_MBS]
Definition: h264dec.h:212
AV_PIX_FMT_D3D11VA_VLD
@ AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:254
H264PredWeightTable::use_weight_chroma
int use_weight_chroma
Definition: h264_parse.h:71
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:226
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:32
AVCOL_SPC_RGB
@ AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB), YZX and ST 428-1
Definition: pixfmt.h:701
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:534
ff_h264_update_thread_context_for_user
int ff_h264_update_thread_context_for_user(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:471
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:840
get_cabac_terminate
static av_unused int get_cabac_terminate(CABACContext *c)
Definition: cabac_functions.h:187
find_unused_picture
static int find_unused_picture(const H264Context *h)
Definition: h264_slice.c:274
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:703
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
ff_h264_pred_weight_table
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)
Definition: h264_parse.c:30
FRAME_RECOVERED_SEI
#define FRAME_RECOVERED_SEI
Sufficient number of frames have been decoded since a SEI recovery point, so all the following frames...
Definition: h264dec.h:527
H264SliceContext::is_complex
int is_complex
Definition: h264dec.h:239
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:33
ff_h264_decode_ref_pic_list_reordering
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:431
mpegutils.h
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:636
H264Picture::invalid_gap
int invalid_gap
Definition: h264dec.h:152
av_timecode_get_smpte
uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)
Convert sei info to SMPTE 12M binary representation.
Definition: timecode.c:70
thread.h
ThreadFrame::f
AVFrame * f
Definition: threadframe.h:28
AV_PIX_FMT_VULKAN
@ AV_PIX_FMT_VULKAN
Vulkan hardware images.
Definition: pixfmt.h:379
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1393
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:480
H264SliceContext::mb_x
int mb_x
Definition: h264dec.h:231
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:687
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:134
av_always_inline
#define av_always_inline
Definition: attributes.h:76
H264SliceContext::next_slice_idx
int next_slice_idx
Definition: h264dec.h:237
H264SliceContext
Definition: h264dec.h:178
golomb.h
exp golomb vlc stuff
MB_FIELD
#define MB_FIELD(sl)
Definition: h264dec.h:63
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:337
ff_h264_filter_mb
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
Definition: h264_loopfilter.c:716
H264SliceContext::mv_cache
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:299
AV_CODEC_FLAG_OUTPUT_CORRUPT
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
Definition: avcodec.h:221
USES_LIST
#define USES_LIST(a, list)
Definition: h264dec.h:101
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:560
finish
static void finish(void)
Definition: movenc.c:374
get_chroma_qp
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:672
H264Picture::mmco_reset
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:135
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:558
timecode.h
h264_select_output_frame
static int h264_select_output_frame(H264Context *h)
Definition: h264_slice.c:1295
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:537
CABACContext::bytestream
const uint8_t * bytestream
Definition: cabac.h:45
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:3484
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:39
H264Picture::mb_stride
int mb_stride
Definition: h264dec.h:159
IN_RANGE
#define IN_RANGE(a, b, size)
Definition: h264_slice.c:286
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264_parse.h:40
ff_h264_flush_change
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:451
ff_h264qpel_init
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:50
MAX_SLICES
#define MAX_SLICES
Definition: d3d12va_hevc.c:33
ff_h264_sei_process_picture_timing
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)
Parse the contents of a picture timing message given an active SPS.
Definition: h264_sei.c:63
h264_frame_start
static int h264_frame_start(H264Context *h)
Definition: h264_slice.c:483
H264SliceContext::deblocking_filter
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:194
H264PredWeightTable::luma_log2_weight_denom
int luma_log2_weight_denom
Definition: h264_parse.h:72
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:202
H264Picture::f_grain
AVFrame * f_grain
Definition: h264dec.h:116
H264SliceContext::picture_structure
int picture_structure
Definition: h264dec.h:241
ff_h264_golomb_to_pict_type
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
release_unused_pictures
static void release_unused_pictures(H264Context *h, int remove_current)
Definition: h264_slice.c:117
H264PredWeightTable::use_weight
int use_weight
Definition: h264_parse.h:70
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
H264SliceContext::direct_spatial_mv_pred
int direct_spatial_mv_pred
Definition: h264dec.h:252
H264SliceContext::slice_num
int slice_num
Definition: h264dec.h:183
pack16to32
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264_parse.h:127
refstruct.h
ff_frame_new_side_data_from_buf
int ff_frame_new_side_data_from_buf(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef **buf)
Similar to ff_frame_new_side_data, but using an existing buffer ref.
Definition: decode.c:2214
non_j_pixfmt
static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
Definition: h264_slice.c:1047
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:542
ff_h264_init_cabac_states
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
Definition: h264_cabac.c:1262
ff_h264_hl_decode_mb
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:800
avassert.h
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:210
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:674
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:629
av_memcpy_backptr
void av_memcpy_backptr(uint8_t *dst, int back, int cnt)
Overlapping memcpy() implementation.
Definition: mem.c:447
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
H264Picture::qscale_table_base
int8_t * qscale_table_base
RefStruct reference.
Definition: h264dec.h:118
ff_h264_queue_decode_slice
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2069
H264Context::DPB
H264Picture DPB[H264_MAX_PICTURE_COUNT]
Definition: h264dec.h:346
ff_hwaccel_frame_priv_alloc
int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private)
Allocate a hwaccel frame private data if the provided avctx uses a hwaccel method that needs it.
Definition: decode.c:2328
AV_PIX_FMT_DXVA2_VLD
@ AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer.
Definition: pixfmt.h:134
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:73
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:60
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:662
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:415
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:65
ff_thread_get_buffer
int ff_thread_get_buffer(AVCodecContext *avctx, AVFrame *f, int flags)
Wrapper around get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1044
ff_h264_execute_ref_pic_marking
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:610
ff_h264_decode_ref_pic_marking
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:832
from
const char * from
Definition: jacosubdec.c:64
h264_slice_header_parse
static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
Definition: h264_slice.c:1696
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:42
H264PredWeightTable::chroma_weight_flag
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Definition: h264_parse.h:75
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:296
h264data.h
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:536
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:231
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:31
decode.h
field_scan8x8_cavlc
static const uint8_t field_scan8x8_cavlc[64+1]
Definition: h264_slice.c:78
H264SliceContext::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264dec.h:195
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
AVFrame::crop_right
size_t crop_right
Definition: frame.h:785
AV_PIX_FMT_YUV420P
@ AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:73
backup_mb_border
static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl, const uint8_t *src_y, const uint8_t *src_cb, const uint8_t *src_cr, int linesize, int uvlinesize, int simple)
Definition: h264_slice.c:587
H264SliceContext::slice_type
int slice_type
Definition: h264dec.h:184
H264SliceContext::resync_mb_x
int resync_mb_x
Definition: h264dec.h:233
H264Picture::sei_recovery_frame_cnt
int sei_recovery_frame_cnt
Definition: h264dec.h:153
AVDISCARD_BIDIR
@ AVDISCARD_BIDIR
discard all bidirectional frames
Definition: defs.h:229
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:79
tmp
static uint8_t tmp[40]
Definition: aes_ctr.c:52
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
H264Context::enable_er
int enable_er
Definition: h264dec.h:564
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:104
H264SliceContext::curr_pic_num
int curr_pic_num
Definition: h264dec.h:331
ff_thread_ref_frame
int ff_thread_ref_frame(ThreadFrame *dst, const ThreadFrame *src)
Definition: utils.c:854
arg
const char * arg
Definition: jacosubdec.c:65
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:232
threadframe.h
fail
#define fail
Definition: test.h:478
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:110
alloc_picture
static int alloc_picture(H264Context *h, H264Picture *pic)
Definition: h264_slice.c:188
NULL
#define NULL
Definition: coverity.c:32
AV_COPY128
#define AV_COPY128(d, s)
Definition: intreadwrite.h:642
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:64
AV_COPY64
#define AV_COPY64(d, s)
Definition: intreadwrite.h:638
H264SliceContext::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: h264dec.h:284
H264Picture::mb_type_base
uint32_t * mb_type_base
RefStruct reference.
Definition: h264dec.h:124
ff_thread_await_progress
void ff_thread_await_progress(const ThreadFrame *f, int n, int field)
Wait for earlier decoding threads to finish reference pictures.
Definition: pthread_frame.c:652
SPS
Sequence parameter set.
Definition: h264_ps.h:44
H264Ref::parent
const H264Picture * parent
Definition: h264dec.h:175
TRANSPOSE
#define TRANSPOSE(x)
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:36
ff_h264_decode_mb_cabac
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cabac.c:1920
AV_PICTURE_TYPE_SI
@ AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:282
H264SliceContext::chroma_qp
int chroma_qp[2]
Definition: h264dec.h:189
AV_CODEC_FLAG2_FAST
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:337
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:391
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:278
PPS
Picture parameter set.
Definition: h264_ps.h:110
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:562
ff_thread_release_ext_buffer
void ff_thread_release_ext_buffer(ThreadFrame *f)
Unref a ThreadFrame.
Definition: pthread_frame.c:1073
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:106
mathops.h
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:25
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:77
av_refstruct_pool_get
void * av_refstruct_pool_get(AVRefStructPool *pool)
Get an object from the pool, reusing an old one from the pool when available.
Definition: refstruct.c:297
H264Picture::mb_height
int mb_height
Definition: h264dec.h:158
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
AV_PIX_FMT_D3D12
@ AV_PIX_FMT_D3D12
Hardware surfaces for Direct3D 12.
Definition: pixfmt.h:440
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:540
H264SliceContext::qscale
int qscale
Definition: h264dec.h:188
get_pixel_format
static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
Definition: h264_slice.c:787
fill_filter_caches
static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_slice.c:2296
ERContext::error_occurred
int error_occurred
Definition: error_resilience.h:67
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:670
init_scan_tables
static void init_scan_tables(H264Context *h)
initialize scan tables
Definition: h264_slice.c:753
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:557
H264SliceContext::top_borders_allocated
int top_borders_allocated[2]
Definition: h264dec.h:288
AV_PICTURE_TYPE_SP
@ AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:283
FIELD_OR_MBAFF_PICTURE
#define FIELD_OR_MBAFF_PICTURE(h)
Definition: h264dec.h:82
H264SliceContext::mb_skip_run
int mb_skip_run
Definition: h264dec.h:238
h264_ps.h
init_dimensions
static void init_dimensions(H264Context *h)
Definition: h264_slice.c:925
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
H264SliceContext::top_type
int top_type
Definition: h264dec.h:215
AVFrame::crop_bottom
size_t crop_bottom
Definition: frame.h:783
H264SliceContext::resync_mb_y
int resync_mb_y
Definition: h264dec.h:234
H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM
@ H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM
6: bottom field, top field, bottom field repeated, in that order
Definition: h264_sei.h:38
DELAYED_PIC_REF
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output.
Definition: diracdec.c:69
H264SEIPictureTiming
Definition: h264_sei.h:54
H264SliceContext::cabac
CABACContext cabac
Cabac.
Definition: h264dec.h:318
H264SliceContext::redundant_pic_count
int redundant_pic_count
Definition: h264dec.h:245
AVFrame::crop_left
size_t crop_left
Definition: frame.h:784
IS_INTRA
#define IS_INTRA(x, y)
AVDISCARD_NONKEY
@ AVDISCARD_NONKEY
discard all frames except keyframes
Definition: defs.h:231
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:551
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:148
to
const char * to
Definition: webvttdec.c:35
H264Picture::reference
int reference
Definition: h264dec.h:150
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:302
CABAC
#define CABAC(h)
Definition: h264_cabac.c:28
LEFT_MBS
#define LEFT_MBS
Definition: h264dec.h:66
height
#define height
Definition: dsp.h:89
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:87
rectangle.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h264.c:63
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:424
H264SliceContext::mb_uvlinesize
ptrdiff_t mb_uvlinesize
Definition: h264dec.h:229
VP_START
#define VP_START
current MB is the first after a resync marker
Definition: error_resilience.h:28
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:544
H264SliceContext::pwt
H264PredWeightTable pwt
Definition: h264dec.h:198
AV_FRAME_DATA_LCEVC
@ AV_FRAME_DATA_LCEVC
Raw LCEVC payload data, as a uint8_t array, with NAL emulation bytes intact.
Definition: frame.h:236
H264Picture::tf
ThreadFrame tf
Definition: h264dec.h:114
H264Picture::mb_type
uint32_t * mb_type
Definition: h264dec.h:125
H264Picture::decode_error_flags
atomic_int * decode_error_flags
RefStruct reference; its pointee is shared between decoding threads.
Definition: h264dec.h:162
ff_h264_decode_mb_cavlc
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:665
H264_SEI_PIC_STRUCT_BOTTOM_TOP
@ H264_SEI_PIC_STRUCT_BOTTOM_TOP
4: bottom field, top field, in that order
Definition: h264_sei.h:36
H264Picture::recovered
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:151
H264SliceContext::top_mb_xy
int top_mb_xy
Definition: h264dec.h:210
H264SliceContext::qp_thresh
int qp_thresh
QP threshold to skip loopfilter.
Definition: h264dec.h:190
ff_frame_new_side_data
int ff_frame_new_side_data(const AVCodecContext *avctx, AVFrame *frame, enum AVFrameSideDataType type, size_t size, AVFrameSideData **psd)
Wrapper around av_frame_new_side_data, which rejects side data overridden by the demuxer.
Definition: decode.c:2176
H264Picture::gray
int gray
Definition: h264dec.h:164
H2645NAL
Definition: h2645_parse.h:34
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:546
H264SliceContext::top_borders
uint8_t(*[2] top_borders)[(16 *3) *2]
Definition: h264dec.h:285
AVFrameSideData::data
uint8_t * data
Definition: frame.h:316
h264chroma.h
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1591
H264SliceContext::cbp
int cbp
Definition: h264dec.h:256
gray
The official guide to swscale for confused that consecutive non overlapping rectangles of slice_bottom special converter These generally are unscaled converters of common like for each output line the vertical scaler pulls lines from a ring buffer When the ring buffer does not contain the wanted then it is pulled from the input slice through the input converter and horizontal scaler The result is also stored in the ring buffer to serve future vertical scaler requests When no more output can be generated because lines from a future slice would be then all remaining lines in the current slice are horizontally scaled and put in the ring buffer[This is done for luma and chroma, each with possibly different numbers of lines per picture.] Input to YUV Converter When the input to the main path is not planar bits per component YUV or bit gray
Definition: swscale.txt:52
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:546
H264SliceContext::left_type
int left_type[LEFT_MBS]
Definition: h264dec.h:217
ff_h264_direct_ref_list_init
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:120
H264SliceContext::mb_y
int mb_y
Definition: h264dec.h:231
H264PredWeightTable::implicit_weight
int implicit_weight[48][48][2]
Definition: h264_parse.h:79
decode_slice
static int decode_slice(struct AVCodecContext *avctx, void *arg)
Definition: h264_slice.c:2564
H264SliceContext::explicit_ref_marking
int explicit_ref_marking
Definition: h264dec.h:324
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
pt
int pt
Definition: rtp.c:35
H264SliceContext::uvlinesize
ptrdiff_t uvlinesize
Definition: h264dec.h:227
AVBufferRef::buffer
AVBuffer * buffer
Definition: buffer.h:83
AV_PIX_FMT_D3D11
@ AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:336
H264SliceContext::slice_type_nos
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:185
H264SliceContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264dec.h:329
copy_picture_range
static void copy_picture_range(H264Picture **to, H264Picture *const *from, int count, H264Context *new_base, const H264Context *old_base)
Definition: h264_slice.c:293
av_zero_extend
#define av_zero_extend
Definition: common.h:151
AV_PIX_FMT_VAAPI
@ AV_PIX_FMT_VAAPI
Hardware acceleration through VA-API, data[3] contains a VASurfaceID.
Definition: pixfmt.h:126
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264dec.h:64
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:78
H264_SEI_PIC_STRUCT_FRAME
@ H264_SEI_PIC_STRUCT_FRAME
0: frame
Definition: h264_sei.h:32
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
@ H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:40
field_scan
static const uint8_t field_scan[16+1]
Definition: h264_slice.c:52
loop_filter
static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
Definition: h264_slice.c:2438
ff_init_cabac_decoder
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:162
H264SliceContext::mb_mbaff
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:243
field_scan8x8
static const uint8_t field_scan8x8[64+1]
Definition: h264_slice.c:59
AV_PIX_FMT_VDPAU
@ AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:194
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
AV_PIX_FMT_VIDEOTOOLBOX
@ AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:305
LIST_NOT_USED
#define LIST_NOT_USED
Definition: h264dec.h:395
H264Picture::field_picture
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:143
h264dec.h
H264SliceContext::poc_lsb
int poc_lsb
Definition: h264dec.h:328
H264SliceContext::first_mb_addr
unsigned int first_mb_addr
Definition: h264dec.h:235
ff_h264_direct_dist_scale_factor
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:61
H264Picture::needs_fg
int needs_fg
whether picture needs film grain synthesis (see f_grain)
Definition: h264dec.h:154
AVBuffer
A reference counted buffer type.
Definition: buffer_internal.h:38
H264Context
H264Context.
Definition: h264dec.h:338
AVDISCARD_NONINTRA
@ AVDISCARD_NONINTRA
discard all non intra frames
Definition: defs.h:230
av_timecode_make_smpte_tc_string2
char * av_timecode_make_smpte_tc_string2(char *buf, AVRational rate, uint32_t tcsmpte, int prevent_df, int skip_field)
Get the timecode string from the SMPTE timecode format.
Definition: timecode.c:131
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:364
AV_FRAME_FLAG_CORRUPT
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
Definition: frame.h:670
H264_SEI_PIC_STRUCT_FRAME_DOUBLING
@ H264_SEI_PIC_STRUCT_FRAME_DOUBLING
7: frame doubling
Definition: h264_sei.h:39
nal
static int FUNC() nal(CodedBitstreamContext *ctx, RWContext *rw, LCEVCRawNAL *current, int nal_unit_type)
Definition: cbs_lcevc_syntax_template.c:657
H264SliceContext::frame_num
int frame_num
Definition: h264dec.h:326
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:559
ff_h264_execute_decode_slices
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2776
H264SliceContext::mb_linesize
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
Definition: h264dec.h:228
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:58
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
cabac_functions.h
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:634
ff_h264_replace_picture
int ff_h264_replace_picture(H264Picture *dst, const H264Picture *src)
Definition: h264_picture.c:135
ff_h264_parse_ref_count
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)
Definition: h264_parse.c:222
ff_h264_alloc_tables
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:187
ff_thread_get_ext_buffer
int ff_thread_get_ext_buffer(AVCodecContext *avctx, ThreadFrame *f, int flags)
Wrapper around ff_get_buffer() for frame-multithreaded codecs.
Definition: pthread_frame.c:1052
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:682
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:760
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:538
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:269
avcodec.h
H264SliceContext::h264
const struct H264Context * h264
Definition: h264dec.h:179
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
ff_h264dsp_init
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:66
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:137
ret
ret
Definition: filter_design.txt:187
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder/muxer should not do as an error
Definition: defs.h:56
ff_h264_init_poc
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
Definition: h264_parse.c:280
ff_h264_get_profile
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:533
frame
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
Definition: filter_design.txt:265
h264_field_start
static int h264_field_start(H264Context *h, const H264SliceContext *sl, const H2645NAL *nal, int first_slice)
Definition: h264_slice.c:1397
H264SliceContext::last_qscale_diff
int last_qscale_diff
Definition: h264dec.h:191
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:560
av_refstruct_pool_alloc
AVRefStructPool * av_refstruct_pool_alloc(size_t size, unsigned flags)
Equivalent to av_refstruct_pool_alloc(size, flags, NULL, NULL, NULL, NULL, NULL)
Definition: refstruct.c:335
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:543
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:548
H264SliceContext::pps_id
unsigned int pps_id
Definition: h264dec.h:279
H264SliceContext::linesize
ptrdiff_t linesize
Definition: h264dec.h:227
H264SliceContext::slice_beta_offset
int slice_beta_offset
Definition: h264dec.h:196
AVCodecContext
main external API structure.
Definition: avcodec.h:443
AVFrame::height
int height
Definition: frame.h:531
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
status
ov_status_e status
Definition: dnn_backend_openvino.c:100
ff_h264_build_ref_list
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:292
H264Picture::motion_val_base
int16_t(*[2] motion_val_base)[2]
RefStruct reference.
Definition: h264dec.h:121
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:1609
av_refstruct_ref_c
const void * av_refstruct_ref_c(const void *obj)
Analog of av_refstruct_ref(), but for constant objects.
Definition: refstruct.c:149
H264SliceContext::bipred_scratchpad
uint8_t * bipred_scratchpad
Definition: h264dec.h:283
ff_h264_pred_init
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
Definition: h264pred.c:437
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:132
AV_PICTURE_TYPE_B
@ AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:280
H264SliceContext::mmco
MMCO mmco[H264_MAX_MMCO_COUNT]
Definition: h264dec.h:322
av_refstruct_replace
void av_refstruct_replace(void *dstp, const void *src)
Ensure *dstp refers to the same object as src.
Definition: refstruct.c:160
error_resilience.h
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
H264Picture::mb_width
int mb_width
Definition: h264dec.h:158
ff_h264_unref_picture
void ff_h264_unref_picture(H264Picture *pic)
Definition: h264_picture.c:39
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:828
H264Picture
Definition: h264dec.h:112
ERContext::error_status_table
uint8_t * error_status_table
Definition: error_resilience.h:68
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:117
AV_PIX_FMT_FLAG_PLANAR
#define AV_PIX_FMT_FLAG_PLANAR
At least one pixel component is not in the first data plane.
Definition: pixdesc.h:132
pps
uint64_t pps
Definition: dovi_rpuenc.c:36
h264_slice_init
static int h264_slice_init(H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
Definition: h264_slice.c:1915
Windows::Graphics::DirectX::Direct3D11::p
IDirect3DDxgiInterfaceAccess _COM_Outptr_ void ** p
Definition: vsrc_gfxcapture_winrt.hpp:53
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:43
ff_h264_field_end
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:189
CABACContext::bytestream_end
const uint8_t * bytestream_end
Definition: cabac.h:46
AV_PIX_FMT_YUV444P
@ AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:78
init_table_pools
static int init_table_pools(H264Context *h)
Definition: h264_slice.c:162
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:270
LBOT
#define LBOT
Definition: h264dec.h:68
H264SliceContext::non_zero_count_cache
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:294
AV_PIX_FMT_GBRP
@ AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:165
desc
const char * desc
Definition: libsvtav1.c:83
AV_PICTURE_TYPE_P
@ AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:279
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:73
AV_PIX_FMT_YUV422P
@ AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:77
mem.h
H264_MAX_DPB_FRAMES
@ H264_MAX_DPB_FRAMES
Definition: h264.h:76
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:104
H264Context::nal_length_size
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: h264dec.h:455
ff_h2645_sei_ctx_replace
int ff_h2645_sei_ctx_replace(H2645SEI *dst, const H2645SEI *src)
Definition: h2645_sei.c:320
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:37
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:37
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:314
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
w
uint8_t w
Definition: llvidencdsp.c:39
H264SliceContext::er
ERContext * er
Definition: h264dec.h:181
H264_SEI_PIC_STRUCT_BOTTOM_FIELD
@ H264_SEI_PIC_STRUCT_BOTTOM_FIELD
2: bottom field
Definition: h264_sei.h:34
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
RefStruct reference for hardware accelerator private data.
Definition: h264dec.h:128
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:34
H264_NAL_IDR_SLICE
@ H264_NAL_IDR_SLICE
Definition: h264.h:39
H264SliceContext::idr_pic_id
int idr_pic_id
Definition: h264dec.h:327
av_refstruct_pool_uninit
static void av_refstruct_pool_uninit(AVRefStructPool **poolp)
Mark the pool as being available for freeing.
Definition: refstruct.h:292
fill_filter_caches_inter
static av_always_inline void fill_filter_caches_inter(const H264Context *h, H264SliceContext *sl, int mb_type, int top_xy, const int left_xy[LEFT_MBS], int top_type, const int left_type[LEFT_MBS], int mb_xy, int list)
Definition: h264_slice.c:2212
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:78
ff_tlog
#define ff_tlog(a,...)
Definition: tableprint_vlc.h:29
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:248
AVFrame::crop_top
size_t crop_top
Definition: frame.h:782
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:180
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:86
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:557
H264SliceContext::intra4x4_pred_mode
int8_t * intra4x4_pred_mode
Definition: h264dec.h:207
FFMAX3
#define FFMAX3(a, b, c)
Definition: macros.h:48
LTOP
#define LTOP
Definition: h264dec.h:67
h264.h
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, a positive or negative value, which is typically indicating the size in bytes of each pict...
Definition: frame.h:504
H264SliceContext::edge_emu_buffer_allocated
int edge_emu_buffer_allocated
Definition: h264dec.h:287
REBASE_PICTURE
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
Definition: h264_slice.c:288
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
CHROMA444
#define CHROMA444(h)
Definition: h264dec.h:90
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
ff_h264_get_slice_type
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2194
h
h
Definition: vp9dsp_template.c:2070
H264SliceContext::cabac_init_idc
int cabac_init_idc
Definition: h264dec.h:320
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:549
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:74
H264_MAX_PICTURE_COUNT
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:47
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:32
H264SliceContext::bipred_scratchpad_allocated
int bipred_scratchpad_allocated
Definition: h264dec.h:286
atomic_init
#define atomic_init(obj, value)
Definition: stdatomic.h:33
width
#define width
Definition: dsp.h:89
AVDISCARD_NONREF
@ AVDISCARD_NONREF
discard all non reference
Definition: defs.h:228
H264SliceContext::slice_type_fixed
int slice_type_fixed
Definition: h264dec.h:186
H264Ref::poc
int poc
Definition: h264dec.h:172
IS_8x8DCT
#define IS_8x8DCT(a)
Definition: h264dec.h:93
H264_SEI_PIC_STRUCT_TOP_FIELD
@ H264_SEI_PIC_STRUCT_TOP_FIELD
1: top field
Definition: h264_sei.h:33
H264SliceContext::delta_poc
int delta_poc[2]
Definition: h264dec.h:330
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:3823
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:139
H264Ref::reference
int reference
Definition: h264dec.h:171
src
#define src
Definition: vp8dsp.c:248
H264Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:122
AV_CODEC_EXPORT_DATA_FILM_GRAIN
#define AV_CODEC_EXPORT_DATA_FILM_GRAIN
Decoding only.
Definition: avcodec.h:404
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:547
H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP
@ H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP
5: top field, bottom field, top field repeated, in that order
Definition: h264_sei.h:37
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3376
H264SliceContext::mb_field_decoding_flag
int mb_field_decoding_flag
Definition: h264dec.h:242
ff_h264_set_erpic
void ff_h264_set_erpic(ERPicture *dst, const H264Picture *src)
Definition: h264_picture.c:166
H264Context::is_avc
int is_avc
Used to parse AVC variant of H.264.
Definition: h264dec.h:454
Generated on Mon Jun 8 2026 19:22:40 for FFmpeg by   doxygen 1.8.17