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