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 (CHROMA444(h)) {
812  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
813  *fmt++ = AV_PIX_FMT_GBRP10;
814  } else
815  *fmt++ = AV_PIX_FMT_YUV444P10;
816  } else if (CHROMA422(h))
817  *fmt++ = AV_PIX_FMT_YUV422P10;
818  else {
819 #if CONFIG_H264_VAAPI_HWACCEL
820  // Just add as candidate. Whether VAProfileH264High10 usable or
821  // not is decided by vaapi_decode_make_config() defined in FFmpeg
822  // and vaQueryCodingProfile() defined in libva.
823  *fmt++ = AV_PIX_FMT_VAAPI;
824 #endif
825  *fmt++ = AV_PIX_FMT_YUV420P10;
826  }
827  break;
828  case 12:
829 #if CONFIG_H264_VULKAN_HWACCEL
830  *fmt++ = AV_PIX_FMT_VULKAN;
831 #endif
832  if (CHROMA444(h)) {
833  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
834  *fmt++ = AV_PIX_FMT_GBRP12;
835  } else
836  *fmt++ = AV_PIX_FMT_YUV444P12;
837  } else if (CHROMA422(h))
838  *fmt++ = AV_PIX_FMT_YUV422P12;
839  else
840  *fmt++ = AV_PIX_FMT_YUV420P12;
841  break;
842  case 14:
843  if (CHROMA444(h)) {
844  if (h->avctx->colorspace == AVCOL_SPC_RGB) {
845  *fmt++ = AV_PIX_FMT_GBRP14;
846  } else
847  *fmt++ = AV_PIX_FMT_YUV444P14;
848  } else if (CHROMA422(h))
849  *fmt++ = AV_PIX_FMT_YUV422P14;
850  else
851  *fmt++ = AV_PIX_FMT_YUV420P14;
852  break;
853  case 8:
854 #if CONFIG_H264_VDPAU_HWACCEL
855  *fmt++ = AV_PIX_FMT_VDPAU;
856 #endif
857 #if CONFIG_H264_VULKAN_HWACCEL
858  *fmt++ = AV_PIX_FMT_VULKAN;
859 #endif
860 #if CONFIG_H264_NVDEC_HWACCEL
861  *fmt++ = AV_PIX_FMT_CUDA;
862 #endif
863 #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL
864  if (h->avctx->colorspace != AVCOL_SPC_RGB)
865  *fmt++ = AV_PIX_FMT_VIDEOTOOLBOX;
866 #endif
867  if (CHROMA444(h)) {
868  if (h->avctx->colorspace == AVCOL_SPC_RGB)
869  *fmt++ = AV_PIX_FMT_GBRP;
870  else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
871  *fmt++ = AV_PIX_FMT_YUVJ444P;
872  else
873  *fmt++ = AV_PIX_FMT_YUV444P;
874  } else if (CHROMA422(h)) {
875  if (h->avctx->color_range == AVCOL_RANGE_JPEG)
876  *fmt++ = AV_PIX_FMT_YUVJ422P;
877  else
878  *fmt++ = AV_PIX_FMT_YUV422P;
879  } else {
880 #if CONFIG_H264_DXVA2_HWACCEL
881  *fmt++ = AV_PIX_FMT_DXVA2_VLD;
882 #endif
883 #if CONFIG_H264_D3D11VA_HWACCEL
884  *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
885  *fmt++ = AV_PIX_FMT_D3D11;
886 #endif
887 #if CONFIG_H264_D3D12VA_HWACCEL
888  *fmt++ = AV_PIX_FMT_D3D12;
889 #endif
890 #if CONFIG_H264_VAAPI_HWACCEL
891  *fmt++ = AV_PIX_FMT_VAAPI;
892 #endif
893  if (h->avctx->color_range == AVCOL_RANGE_JPEG)
894  *fmt++ = AV_PIX_FMT_YUVJ420P;
895  else
896  *fmt++ = AV_PIX_FMT_YUV420P;
897  }
898  break;
899  default:
900  av_log(h->avctx, AV_LOG_ERROR,
901  "Unsupported bit depth %d\n", h->ps.sps->bit_depth_luma);
902  return AVERROR_INVALIDDATA;
903  }
904 
905  *fmt = AV_PIX_FMT_NONE;
906 
907  for (int i = 0; pix_fmts[i] != AV_PIX_FMT_NONE; i++)
908  if (pix_fmts[i] == h->avctx->pix_fmt && !force_callback)
909  return pix_fmts[i];
910  return ff_get_format(h->avctx, pix_fmts);
911 }
912 
913 /* export coded and cropped frame dimensions to AVCodecContext */
914 static void init_dimensions(H264Context *h)
915 {
916  const SPS *sps = h->ps.sps;
917  int cr = sps->crop_right;
918  int cl = sps->crop_left;
919  int ct = sps->crop_top;
920  int cb = sps->crop_bottom;
921  int width = h->width - (cr + cl);
922  int height = h->height - (ct + cb);
923  av_assert0(sps->crop_right + sps->crop_left < (unsigned)h->width);
924  av_assert0(sps->crop_top + sps->crop_bottom < (unsigned)h->height);
925 
926  /* handle container cropping */
927  if (h->width_from_caller > 0 && h->height_from_caller > 0 &&
928  !sps->crop_top && !sps->crop_left &&
929  FFALIGN(h->width_from_caller, 16) == FFALIGN(width, 16) &&
930  FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16) &&
931  h->width_from_caller <= width &&
932  h->height_from_caller <= height) {
933  width = h->width_from_caller;
934  height = h->height_from_caller;
935  cl = 0;
936  ct = 0;
937  cr = h->width - width;
938  cb = h->height - height;
939  } else {
940  h->width_from_caller = 0;
941  h->height_from_caller = 0;
942  }
943 
944  h->avctx->coded_width = h->width;
945  h->avctx->coded_height = h->height;
946  h->avctx->width = width;
947  h->avctx->height = height;
948  h->crop_right = cr;
949  h->crop_left = cl;
950  h->crop_top = ct;
951  h->crop_bottom = cb;
952 }
953 
954 static int h264_slice_header_init(H264Context *h)
955 {
956  const SPS *sps = h->ps.sps;
957  int i, ret;
958 
959  if (!sps) {
960  ret = AVERROR_INVALIDDATA;
961  goto fail;
962  }
963 
964  ff_set_sar(h->avctx, sps->vui.sar);
965  av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
966  &h->chroma_x_shift, &h->chroma_y_shift);
967 
968  if (sps->timing_info_present_flag) {
969  int64_t den = sps->time_scale;
970  if (h->x264_build < 44U)
971  den *= 2;
972  av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
973  sps->num_units_in_tick * 2, den, 1 << 30);
974  }
975 
976  ff_h264_free_tables(h);
977 
978  h->first_field = 0;
979  h->prev_interlaced_frame = 1;
980 
981  init_scan_tables(h);
982  ret = ff_h264_alloc_tables(h);
983  if (ret < 0) {
984  av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
985  goto fail;
986  }
987 
988  if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 14 ||
989  sps->bit_depth_luma == 11 || sps->bit_depth_luma == 13
990  ) {
991  av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
992  sps->bit_depth_luma);
993  ret = AVERROR_INVALIDDATA;
994  goto fail;
995  }
996 
997  h->cur_bit_depth_luma =
998  h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
999  h->cur_chroma_format_idc = sps->chroma_format_idc;
1000  h->pixel_shift = sps->bit_depth_luma > 8;
1001  h->chroma_format_idc = sps->chroma_format_idc;
1002  h->bit_depth_luma = sps->bit_depth_luma;
1003 
1004  ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
1005  sps->chroma_format_idc);
1006  ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
1007  ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
1008  ff_h264_pred_init(&h->hpc, AV_CODEC_ID_H264, sps->bit_depth_luma,
1009  sps->chroma_format_idc);
1010  ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
1011 
1012  if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
1013  ff_h264_slice_context_init(h, &h->slice_ctx[0]);
1014  } else {
1015  for (i = 0; i < h->nb_slice_ctx; i++) {
1016  H264SliceContext *sl = &h->slice_ctx[i];
1017 
1018  sl->h264 = h;
1019  sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
1020  sl->mvd_table[0] = h->mvd_table[0] + i * 8 * 2 * h->mb_stride;
1021  sl->mvd_table[1] = h->mvd_table[1] + i * 8 * 2 * h->mb_stride;
1022 
1023  ff_h264_slice_context_init(h, sl);
1024  }
1025  }
1026 
1027  h->context_initialized = 1;
1028 
1029  return 0;
1030 fail:
1031  ff_h264_free_tables(h);
1032  h->context_initialized = 0;
1033  return ret;
1034 }
1035 
1036 static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
1037 {
1038  switch (a) {
1039  case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
1040  case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
1041  case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
1042  default:
1043  return a;
1044  }
1045 }
1046 
1047 static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
1048 {
1049  const SPS *sps;
1050  int needs_reinit = 0, must_reinit, ret;
1051 
1052  if (first_slice)
1053  av_refstruct_replace(&h->ps.pps, h->ps.pps_list[sl->pps_id]);
1054 
1055  if (h->ps.sps != h->ps.pps->sps) {
1056  h->ps.sps = h->ps.pps->sps;
1057 
1058  if (h->mb_width != h->ps.sps->mb_width ||
1059  h->mb_height != h->ps.sps->mb_height ||
1060  h->cur_bit_depth_luma != h->ps.sps->bit_depth_luma ||
1061  h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
1062  )
1063  needs_reinit = 1;
1064 
1065  if (h->bit_depth_luma != h->ps.sps->bit_depth_luma ||
1066  h->chroma_format_idc != h->ps.sps->chroma_format_idc)
1067  needs_reinit = 1;
1068  }
1069  sps = h->ps.sps;
1070 
1071  must_reinit = (h->context_initialized &&
1072  ( 16*sps->mb_width != h->avctx->coded_width
1073  || 16*sps->mb_height != h->avctx->coded_height
1074  || h->cur_bit_depth_luma != sps->bit_depth_luma
1075  || h->cur_chroma_format_idc != sps->chroma_format_idc
1076  || h->mb_width != sps->mb_width
1077  || h->mb_height != sps->mb_height
1078  ));
1079  if (h->avctx->pix_fmt == AV_PIX_FMT_NONE
1080  || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
1081  must_reinit = 1;
1082 
1083  if (first_slice && av_cmp_q(sps->vui.sar, h->avctx->sample_aspect_ratio))
1084  must_reinit = 1;
1085 
1086  if (!h->setup_finished) {
1087  h->avctx->profile = ff_h264_get_profile(sps);
1088  h->avctx->level = sps->level_idc;
1089  h->avctx->refs = sps->ref_frame_count;
1090 
1091  h->mb_width = sps->mb_width;
1092  h->mb_height = sps->mb_height;
1093  h->mb_num = h->mb_width * h->mb_height;
1094  h->mb_stride = h->mb_width + 1;
1095 
1096  h->b_stride = h->mb_width * 4;
1097 
1098  h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p
1099 
1100  h->width = 16 * h->mb_width;
1101  h->height = 16 * h->mb_height;
1102 
1103  init_dimensions(h);
1104 
1105  if (sps->vui.video_signal_type_present_flag) {
1106  h->avctx->color_range = sps->vui.video_full_range_flag > 0 ? AVCOL_RANGE_JPEG
1107  : AVCOL_RANGE_MPEG;
1108  if (sps->vui.colour_description_present_flag) {
1109  if (h->avctx->colorspace != sps->vui.matrix_coeffs)
1110  needs_reinit = 1;
1111  h->avctx->color_primaries = sps->vui.colour_primaries;
1112  h->avctx->color_trc = sps->vui.transfer_characteristics;
1113  h->avctx->colorspace = sps->vui.matrix_coeffs;
1114  }
1115  }
1116 
1117  if (h->sei.common.alternative_transfer.present &&
1118  av_color_transfer_name(h->sei.common.alternative_transfer.preferred_transfer_characteristics) &&
1119  h->sei.common.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
1120  h->avctx->color_trc = h->sei.common.alternative_transfer.preferred_transfer_characteristics;
1121  }
1122  }
1123  h->avctx->chroma_sample_location = sps->vui.chroma_location;
1124 
1125  if (!h->context_initialized || must_reinit || needs_reinit) {
1126  int flush_changes = h->context_initialized;
1127  h->context_initialized = 0;
1128  if (sl != h->slice_ctx) {
1129  av_log(h->avctx, AV_LOG_ERROR,
1130  "changing width %d -> %d / height %d -> %d on "
1131  "slice %d\n",
1132  h->width, h->avctx->coded_width,
1133  h->height, h->avctx->coded_height,
1134  h->current_slice + 1);
1135  return AVERROR_INVALIDDATA;
1136  }
1137 
1138  av_assert1(first_slice);
1139 
1140  if (flush_changes)
1141  ff_h264_flush_change(h);
1142 
1143  if ((ret = get_pixel_format(h, 1)) < 0)
1144  return ret;
1145  h->avctx->pix_fmt = ret;
1146 
1147  av_log(h->avctx, AV_LOG_VERBOSE, "Reinit context to %dx%d, "
1148  "pix_fmt: %s\n", h->width, h->height, av_get_pix_fmt_name(h->avctx->pix_fmt));
1149 
1150  if ((ret = h264_slice_header_init(h)) < 0) {
1151  av_log(h->avctx, AV_LOG_ERROR,
1152  "h264_slice_header_init() failed\n");
1153  return ret;
1154  }
1155  }
1156 
1157  return 0;
1158 }
1159 
1160 static int h264_export_frame_props(H264Context *h)
1161 {
1162  const SPS *sps = h->ps.sps;
1163  H264Picture *cur = h->cur_pic_ptr;
1164  AVFrame *out = cur->f;
1165  int interlaced_frame = 0, top_field_first = 0;
1166  int ret;
1167 
1168  out->flags &= ~AV_FRAME_FLAG_INTERLACED;
1169  out->repeat_pict = 0;
1170 
1171  /* Signal interlacing information externally. */
1172  /* Prioritize picture timing SEI information over used
1173  * decoding process if it exists. */
1174  if (h->sei.picture_timing.present) {
1175  int ret = ff_h264_sei_process_picture_timing(&h->sei.picture_timing, sps,
1176  h->avctx);
1177  if (ret < 0) {
1178  av_log(h->avctx, AV_LOG_ERROR, "Error processing a picture timing SEI\n");
1179  if (h->avctx->err_recognition & AV_EF_EXPLODE)
1180  return ret;
1181  h->sei.picture_timing.present = 0;
1182  }
1183  }
1184 
1185  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1186  const H264SEIPictureTiming *pt = &h->sei.picture_timing;
1187  switch (pt->pic_struct) {
1188  case H264_SEI_PIC_STRUCT_FRAME:
1189  break;
1190  case H264_SEI_PIC_STRUCT_TOP_FIELD:
1191  case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
1192  interlaced_frame = 1;
1193  break;
1194  case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
1195  case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
1196  if (FIELD_OR_MBAFF_PICTURE(h))
1197  interlaced_frame = 1;
1198  else
1199  // try to flag soft telecine progressive
1200  interlaced_frame = !!h->prev_interlaced_frame;
1201  break;
1202  case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
1203  case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
1204  /* Signal the possibility of telecined film externally
1205  * (pic_struct 5,6). From these hints, let the applications
1206  * decide if they apply deinterlacing. */
1207  out->repeat_pict = 1;
1208  break;
1209  case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
1210  out->repeat_pict = 2;
1211  break;
1212  case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
1213  out->repeat_pict = 4;
1214  break;
1215  }
1216 
1217  if ((pt->ct_type & 3) &&
1218  pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
1219  interlaced_frame = ((pt->ct_type & (1 << 1)) != 0);
1220  } else {
1221  /* Derive interlacing flag from used decoding process. */
1222  interlaced_frame = !!FIELD_OR_MBAFF_PICTURE(h);
1223  }
1224  h->prev_interlaced_frame = interlaced_frame;
1225 
1226  if (cur->field_poc[0] != cur->field_poc[1]) {
1227  /* Derive top_field_first from field pocs. */
1228  top_field_first = (cur->field_poc[0] < cur->field_poc[1]);
1229  } else {
1230  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1231  /* Use picture timing SEI information. Even if it is a
1232  * information of a past frame, better than nothing. */
1233  if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
1234  h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
1235  top_field_first = 1;
1236  } else if (interlaced_frame) {
1237  /* Default to top field first when pic_struct_present_flag
1238  * is not set but interlaced frame detected */
1239  top_field_first = 1;
1240  } // else
1241  /* Most likely progressive */
1242  }
1243 
1244  out->flags |= (AV_FRAME_FLAG_INTERLACED * interlaced_frame) |
1245  (AV_FRAME_FLAG_TOP_FIELD_FIRST * top_field_first);
1246 
1247  ret = ff_h2645_sei_to_frame(out, &h->sei.common, AV_CODEC_ID_H264, h->avctx,
1248  &sps->vui, sps->bit_depth_luma, sps->bit_depth_chroma,
1249  cur->poc + (unsigned)(h->poc_offset << 5));
1250  if (ret < 0)
1251  return ret;
1252 
1253  if (h->sei.picture_timing.timecode_cnt > 0) {
1254  uint32_t *tc_sd;
1255  char tcbuf[AV_TIMECODE_STR_SIZE];
1256  AVFrameSideData *tcside;
1257  ret = ff_frame_new_side_data(h->avctx, out, AV_FRAME_DATA_S12M_TIMECODE,
1258  sizeof(uint32_t)*4, &tcside);
1259  if (ret < 0)
1260  return ret;
1261 
1262  if (tcside) {
1263  tc_sd = (uint32_t*)tcside->data;
1264  tc_sd[0] = h->sei.picture_timing.timecode_cnt;
1265 
1266  for (int i = 0; i < tc_sd[0]; i++) {
1267  int drop = h->sei.picture_timing.timecode[i].dropframe;
1268  int hh = h->sei.picture_timing.timecode[i].hours;
1269  int mm = h->sei.picture_timing.timecode[i].minutes;
1270  int ss = h->sei.picture_timing.timecode[i].seconds;
1271  int ff = h->sei.picture_timing.timecode[i].frame;
1272 
1273  tc_sd[i + 1] = av_timecode_get_smpte(h->avctx->framerate, drop, hh, mm, ss, ff);
1274  av_timecode_make_smpte_tc_string2(tcbuf, h->avctx->framerate, tc_sd[i + 1], 0, 0);
1275  av_dict_set(&out->metadata, "timecode", tcbuf, 0);
1276  }
1277  }
1278  h->sei.picture_timing.timecode_cnt = 0;
1279  }
1280 
1281  return 0;
1282 }
1283 
1284 static int h264_select_output_frame(H264Context *h)
1285 {
1286  const SPS *sps = h->ps.sps;
1287  H264Picture *out = h->cur_pic_ptr;
1288  H264Picture *cur = h->cur_pic_ptr;
1289  int i, pics, out_of_order, out_idx;
1290 
1291  cur->mmco_reset = h->mmco_reset;
1292  h->mmco_reset = 0;
1293 
1294  if (sps->bitstream_restriction_flag ||
1295  h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
1296  h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
1297  }
1298 
1299  for (i = 0; 1; i++) {
1300  if(i == H264_MAX_DPB_FRAMES || cur->poc < h->last_pocs[i]){
1301  if(i)
1302  h->last_pocs[i-1] = cur->poc;
1303  break;
1304  } else if(i) {
1305  h->last_pocs[i-1]= h->last_pocs[i];
1306  }
1307  }
1308  out_of_order = H264_MAX_DPB_FRAMES - i;
1309  if( cur->f->pict_type == AV_PICTURE_TYPE_B
1310  || (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))
1311  out_of_order = FFMAX(out_of_order, 1);
1312  if (out_of_order == H264_MAX_DPB_FRAMES) {
1313  av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
1314  for (i = 1; i < H264_MAX_DPB_FRAMES; i++)
1315  h->last_pocs[i] = INT_MIN;
1316  h->last_pocs[0] = cur->poc;
1317  cur->mmco_reset = 1;
1318  } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
1319  int loglevel = h->avctx->frame_num > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
1320  av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
1321  h->avctx->has_b_frames = out_of_order;
1322  }
1323 
1324  pics = 0;
1325  while (h->delayed_pic[pics])
1326  pics++;
1327 
1328  av_assert0(pics <= H264_MAX_DPB_FRAMES);
1329 
1330  h->delayed_pic[pics++] = cur;
1331  if (cur->reference == 0)
1332  cur->reference = DELAYED_PIC_REF;
1333 
1334  out = h->delayed_pic[0];
1335  out_idx = 0;
1336  for (i = 1; h->delayed_pic[i] &&
1337  !(h->delayed_pic[i]->f->flags & AV_FRAME_FLAG_KEY) &&
1338  !h->delayed_pic[i]->mmco_reset;
1339  i++)
1340  if (h->delayed_pic[i]->poc < out->poc) {
1341  out = h->delayed_pic[i];
1342  out_idx = i;
1343  }
1344  if (h->avctx->has_b_frames == 0 &&
1345  ((h->delayed_pic[0]->f->flags & AV_FRAME_FLAG_KEY) || h->delayed_pic[0]->mmco_reset))
1346  h->next_outputed_poc = INT_MIN;
1347  out_of_order = out->poc < h->next_outputed_poc;
1348 
1349  if (out_of_order || pics > h->avctx->has_b_frames) {
1350  out->reference &= ~DELAYED_PIC_REF;
1351  for (i = out_idx; h->delayed_pic[i]; i++)
1352  h->delayed_pic[i] = h->delayed_pic[i + 1];
1353  }
1354  if (!out_of_order && pics > h->avctx->has_b_frames) {
1355  h->next_output_pic = out;
1356  if (out_idx == 0 && h->delayed_pic[0] && ((h->delayed_pic[0]->f->flags & AV_FRAME_FLAG_KEY) || h->delayed_pic[0]->mmco_reset)) {
1357  h->next_outputed_poc = INT_MIN;
1358  } else
1359  h->next_outputed_poc = out->poc;
1360 
1361  // We have reached an recovery point and all frames after it in
1362  // display order are "recovered".
1363  h->frame_recovered |= out->recovered;
1364 
1365  out->recovered |= h->frame_recovered & FRAME_RECOVERED_SEI;
1366 
1367  if (!out->recovered) {
1368  if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
1369  !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
1370  h->next_output_pic = NULL;
1371  } else {
1372  out->f->flags |= AV_FRAME_FLAG_CORRUPT;
1373  }
1374  }
1375  } else {
1376  av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
1377  }
1378 
1379  return 0;
1380 }
1381 
1382 /* This function is called right after decoding the slice header for a first
1383  * slice in a field (or a frame). It decides whether we are decoding a new frame
1384  * or a second field in a pair and does the necessary setup.
1385  */
1386 static int h264_field_start(H264Context *h, const H264SliceContext *sl,
1387  const H2645NAL *nal, int first_slice)
1388 {
1389  int i;
1390  const SPS *sps;
1391 
1392  int last_pic_structure, last_pic_droppable, ret;
1393 
1394  ret = h264_init_ps(h, sl, first_slice);
1395  if (ret < 0)
1396  return ret;
1397 
1398  sps = h->ps.sps;
1399 
1400  if (sps->bitstream_restriction_flag &&
1401  h->avctx->has_b_frames < sps->num_reorder_frames) {
1402  h->avctx->has_b_frames = sps->num_reorder_frames;
1403  }
1404 
1405  last_pic_droppable = h->droppable;
1406  last_pic_structure = h->picture_structure;
1407  h->droppable = (nal->ref_idc == 0);
1408  h->picture_structure = sl->picture_structure;
1409 
1410  h->poc.frame_num = sl->frame_num;
1411  h->poc.poc_lsb = sl->poc_lsb;
1412  h->poc.delta_poc_bottom = sl->delta_poc_bottom;
1413  h->poc.delta_poc[0] = sl->delta_poc[0];
1414  h->poc.delta_poc[1] = sl->delta_poc[1];
1415 
1416  if (nal->type == H264_NAL_IDR_SLICE)
1417  h->poc_offset = sl->idr_pic_id;
1418  else if (h->picture_intra_only)
1419  h->poc_offset = 0;
1420 
1421  /* Shorten frame num gaps so we don't have to allocate reference
1422  * frames just to throw them away */
1423  if (h->poc.frame_num != h->poc.prev_frame_num) {
1424  int unwrap_prev_frame_num = h->poc.prev_frame_num;
1425  int max_frame_num = 1 << sps->log2_max_frame_num;
1426 
1427  if (unwrap_prev_frame_num > h->poc.frame_num)
1428  unwrap_prev_frame_num -= max_frame_num;
1429 
1430  if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
1431  unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
1432  if (unwrap_prev_frame_num < 0)
1433  unwrap_prev_frame_num += max_frame_num;
1434 
1435  h->poc.prev_frame_num = unwrap_prev_frame_num;
1436  }
1437  }
1438 
1439  /* See if we have a decoded first field looking for a pair...
1440  * Here, we're using that to see if we should mark previously
1441  * decode frames as "finished".
1442  * We have to do that before the "dummy" in-between frame allocation,
1443  * since that can modify h->cur_pic_ptr. */
1444  if (h->first_field) {
1445  int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
1446  av_assert0(h->cur_pic_ptr);
1447  av_assert0(h->cur_pic_ptr->f->buf[0]);
1448  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1449 
1450  /* Mark old field/frame as completed */
1451  if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
1452  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
1453  }
1454 
1455  /* figure out if we have a complementary field pair */
1456  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1457  /* Previous field is unmatched. Don't display it, but let it
1458  * remain for reference if marked as such. */
1459  if (last_pic_structure != PICT_FRAME) {
1460  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1461  last_pic_structure == PICT_TOP_FIELD);
1462  }
1463  } else {
1464  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1465  /* This and previous field were reference, but had
1466  * different frame_nums. Consider this field first in
1467  * pair. Throw away previous field except for reference
1468  * purposes. */
1469  if (last_pic_structure != PICT_FRAME) {
1470  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1471  last_pic_structure == PICT_TOP_FIELD);
1472  }
1473  } else {
1474  /* Second field in complementary pair */
1475  if (!((last_pic_structure == PICT_TOP_FIELD &&
1476  h->picture_structure == PICT_BOTTOM_FIELD) ||
1477  (last_pic_structure == PICT_BOTTOM_FIELD &&
1478  h->picture_structure == PICT_TOP_FIELD))) {
1479  av_log(h->avctx, AV_LOG_ERROR,
1480  "Invalid field mode combination %d/%d\n",
1481  last_pic_structure, h->picture_structure);
1482  h->picture_structure = last_pic_structure;
1483  h->droppable = last_pic_droppable;
1484  return AVERROR_INVALIDDATA;
1485  } else if (last_pic_droppable != h->droppable) {
1486  avpriv_request_sample(h->avctx,
1487  "Found reference and non-reference fields in the same frame, which");
1488  h->picture_structure = last_pic_structure;
1489  h->droppable = last_pic_droppable;
1490  return AVERROR_PATCHWELCOME;
1491  }
1492  }
1493  }
1494  }
1495 
1496  while (h->poc.frame_num != h->poc.prev_frame_num && !h->first_field &&
1497  h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
1498  const H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
1499  av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
1500  h->poc.frame_num, h->poc.prev_frame_num);
1501  if (!sps->gaps_in_frame_num_allowed_flag)
1502  for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
1503  h->last_pocs[i] = INT_MIN;
1504  ret = h264_frame_start(h);
1505  if (ret < 0) {
1506  h->first_field = 0;
1507  return ret;
1508  }
1509 
1510  h->poc.prev_frame_num++;
1511  h->poc.prev_frame_num %= 1 << sps->log2_max_frame_num;
1512  h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
1513  h->cur_pic_ptr->invalid_gap = !sps->gaps_in_frame_num_allowed_flag;
1514  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
1515  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
1516 
1517  h->explicit_ref_marking = 0;
1518  ret = ff_h264_execute_ref_pic_marking(h);
1519  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1520  return ret;
1521  /* Error concealment: If a ref is missing, copy the previous ref
1522  * in its place.
1523  * FIXME: Avoiding a memcpy would be nice, but ref handling makes
1524  * many assumptions about there being no actual duplicates.
1525  * FIXME: This does not copy padding for out-of-frame motion
1526  * vectors. Given we are concealing a lost frame, this probably
1527  * is not noticeable by comparison, but it should be fixed. */
1528  if (h->short_ref_count) {
1529  int c[4] = {
1530  1<<(h->ps.sps->bit_depth_luma-1),
1531  1<<(h->ps.sps->bit_depth_chroma-1),
1532  1<<(h->ps.sps->bit_depth_chroma-1),
1533  -1
1534  };
1535 
1536  if (prev &&
1537  h->short_ref[0]->f->width == prev->f->width &&
1538  h->short_ref[0]->f->height == prev->f->height &&
1539  h->short_ref[0]->f->format == prev->f->format) {
1540  ff_thread_await_progress(&prev->tf, INT_MAX, 0);
1541  if (prev->field_picture)
1542  ff_thread_await_progress(&prev->tf, INT_MAX, 1);
1543  ff_thread_release_ext_buffer(&h->short_ref[0]->tf);
1544  h->short_ref[0]->tf.f = h->short_ref[0]->f;
1545  ret = ff_thread_ref_frame(&h->short_ref[0]->tf, &prev->tf);
1546  if (ret < 0)
1547  return ret;
1548  h->short_ref[0]->poc = prev->poc + 2U;
1549  h->short_ref[0]->gray = prev->gray;
1550  ff_thread_report_progress(&h->short_ref[0]->tf, INT_MAX, 0);
1551  if (h->short_ref[0]->field_picture)
1552  ff_thread_report_progress(&h->short_ref[0]->tf, INT_MAX, 1);
1553  } else if (!h->frame_recovered) {
1554  if (!h->avctx->hwaccel)
1555  color_frame(h->short_ref[0]->f, c);
1556  h->short_ref[0]->gray = 1;
1557  }
1558  h->short_ref[0]->frame_num = h->poc.prev_frame_num;
1559  }
1560  }
1561 
1562  /* See if we have a decoded first field looking for a pair...
1563  * We're using that to see whether to continue decoding in that
1564  * frame, or to allocate a new one. */
1565  if (h->first_field) {
1566  av_assert0(h->cur_pic_ptr);
1567  av_assert0(h->cur_pic_ptr->f->buf[0]);
1568  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1569 
1570  /* figure out if we have a complementary field pair */
1571  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1572  /* Previous field is unmatched. Don't display it, but let it
1573  * remain for reference if marked as such. */
1574  h->missing_fields ++;
1575  h->cur_pic_ptr = NULL;
1576  h->first_field = FIELD_PICTURE(h);
1577  } else {
1578  h->missing_fields = 0;
1579  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1580  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1581  h->picture_structure==PICT_BOTTOM_FIELD);
1582  /* This and the previous field had different frame_nums.
1583  * Consider this field first in pair. Throw away previous
1584  * one except for reference purposes. */
1585  h->first_field = 1;
1586  h->cur_pic_ptr = NULL;
1587  } else if (h->cur_pic_ptr->reference & DELAYED_PIC_REF) {
1588  /* This frame was already output, we cannot draw into it
1589  * anymore.
1590  */
1591  h->first_field = 1;
1592  h->cur_pic_ptr = NULL;
1593  } else {
1594  /* Second field in complementary pair */
1595  h->first_field = 0;
1596  }
1597  }
1598  } else {
1599  /* Frame or first field in a potentially complementary pair */
1600  h->first_field = FIELD_PICTURE(h);
1601  }
1602 
1603  if (!FIELD_PICTURE(h) || h->first_field) {
1604  if (h264_frame_start(h) < 0) {
1605  h->first_field = 0;
1606  return AVERROR_INVALIDDATA;
1607  }
1608  } else {
1609  int field = h->picture_structure == PICT_BOTTOM_FIELD;
1610  release_unused_pictures(h, 0);
1611  h->cur_pic_ptr->tf.owner[field] = h->avctx;
1612  }
1613  /* Some macroblocks can be accessed before they're available in case
1614  * of lost slices, MBAFF or threading. */
1615  if (FIELD_PICTURE(h)) {
1616  for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
1617  memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
1618  } else {
1619  memset(h->slice_table, -1,
1620  (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
1621  }
1622 
1623  ret = ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
1624  h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
1625  if (ret < 0)
1626  return ret;
1627 
1628  memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
1629  h->nb_mmco = sl->nb_mmco;
1630  h->explicit_ref_marking = sl->explicit_ref_marking;
1631 
1632  h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
1633 
1634  if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
1635  const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
1636 
1637  if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
1638  h->valid_recovery_point = 1;
1639 
1640  if ( h->recovery_frame < 0
1641  || av_zero_extend(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
1642  h->recovery_frame = av_zero_extend(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
1643 
1644  if (!h->valid_recovery_point)
1645  h->recovery_frame = h->poc.frame_num;
1646  }
1647  }
1648 
1649  h->cur_pic_ptr->f->flags |= AV_FRAME_FLAG_KEY * !!(nal->type == H264_NAL_IDR_SLICE);
1650 
1651  if (nal->type == H264_NAL_IDR_SLICE) {
1652  h->cur_pic_ptr->recovered |= FRAME_RECOVERED_IDR;
1653  // If we have an IDR, all frames after it in decoded order are
1654  // "recovered".
1655  h->frame_recovered |= FRAME_RECOVERED_IDR;
1656  }
1657 
1658  if (h->recovery_frame == h->poc.frame_num && nal->ref_idc) {
1659  h->recovery_frame = -1;
1660  h->cur_pic_ptr->recovered |= FRAME_RECOVERED_SEI;
1661  }
1662 
1663 #if 1
1664  h->cur_pic_ptr->recovered |= h->frame_recovered;
1665 #else
1666  h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
1667 #endif
1668 
1669  /* Set the frame properties/side data. Only done for the second field in
1670  * field coded frames, since some SEI information is present for each field
1671  * and is merged by the SEI parsing code. */
1672  if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
1673  ret = h264_export_frame_props(h);
1674  if (ret < 0)
1675  return ret;
1676 
1677  ret = h264_select_output_frame(h);
1678  if (ret < 0)
1679  return ret;
1680  }
1681 
1682  return 0;
1683 }
1684 
1685 static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
1686  const H2645NAL *nal)
1687 {
1688  const SPS *sps;
1689  const PPS *pps;
1690  int ret;
1691  unsigned int slice_type, tmp, i;
1692  int field_pic_flag, bottom_field_flag;
1693  int first_slice = sl == h->slice_ctx && !h->current_slice;
1694  int picture_structure;
1695 
1696  if (first_slice)
1697  av_assert0(!h->setup_finished);
1698 
1699  sl->first_mb_addr = get_ue_golomb_long(&sl->gb);
1700 
1701  slice_type = get_ue_golomb_31(&sl->gb);
1702  if (slice_type > 9) {
1703  av_log(h->avctx, AV_LOG_ERROR,
1704  "slice type %d too large at %d\n",
1705  slice_type, sl->first_mb_addr);
1706  return AVERROR_INVALIDDATA;
1707  }
1708  if (slice_type > 4) {
1709  slice_type -= 5;
1710  sl->slice_type_fixed = 1;
1711  } else
1712  sl->slice_type_fixed = 0;
1713 
1714  slice_type = ff_h264_golomb_to_pict_type[slice_type];
1715  sl->slice_type = slice_type;
1716  sl->slice_type_nos = slice_type & 3;
1717 
1718  if (nal->type == H264_NAL_IDR_SLICE &&
1719  sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1720  av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
1721  return AVERROR_INVALIDDATA;
1722  }
1723 
1724  sl->pps_id = get_ue_golomb(&sl->gb);
1725  if (sl->pps_id >= MAX_PPS_COUNT) {
1726  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
1727  return AVERROR_INVALIDDATA;
1728  }
1729  if (!h->ps.pps_list[sl->pps_id]) {
1730  av_log(h->avctx, AV_LOG_ERROR,
1731  "non-existing PPS %u referenced\n",
1732  sl->pps_id);
1733  return AVERROR_INVALIDDATA;
1734  }
1735  pps = h->ps.pps_list[sl->pps_id];
1736  sps = pps->sps;
1737 
1738  sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
1739  if (!first_slice) {
1740  if (h->poc.frame_num != sl->frame_num) {
1741  av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
1742  h->poc.frame_num, sl->frame_num);
1743  return AVERROR_INVALIDDATA;
1744  }
1745  }
1746 
1747  sl->mb_mbaff = 0;
1748 
1749  if (sps->frame_mbs_only_flag) {
1750  picture_structure = PICT_FRAME;
1751  } else {
1752  if (!sps->direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
1753  av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
1754  return -1;
1755  }
1756  field_pic_flag = get_bits1(&sl->gb);
1757  if (field_pic_flag) {
1758  bottom_field_flag = get_bits1(&sl->gb);
1759  picture_structure = PICT_TOP_FIELD + bottom_field_flag;
1760  } else {
1761  picture_structure = PICT_FRAME;
1762  }
1763  }
1764  sl->picture_structure = picture_structure;
1765  sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
1766 
1767  if (picture_structure == PICT_FRAME) {
1768  sl->curr_pic_num = sl->frame_num;
1769  sl->max_pic_num = 1 << sps->log2_max_frame_num;
1770  } else {
1771  sl->curr_pic_num = 2 * sl->frame_num + 1;
1772  sl->max_pic_num = 1 << (sps->log2_max_frame_num + 1);
1773  }
1774 
1775  if (nal->type == H264_NAL_IDR_SLICE) {
1776  unsigned idr_pic_id = get_ue_golomb_long(&sl->gb);
1777  if (idr_pic_id < 65536) {
1778  sl->idr_pic_id = idr_pic_id;
1779  } else
1780  av_log(h->avctx, AV_LOG_WARNING, "idr_pic_id is invalid\n");
1781  }
1782 
1783  sl->poc_lsb = 0;
1784  sl->delta_poc_bottom = 0;
1785  if (sps->poc_type == 0) {
1786  sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
1787 
1788  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1789  sl->delta_poc_bottom = get_se_golomb(&sl->gb);
1790  }
1791 
1792  sl->delta_poc[0] = sl->delta_poc[1] = 0;
1793  if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
1794  sl->delta_poc[0] = get_se_golomb(&sl->gb);
1795 
1796  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1797  sl->delta_poc[1] = get_se_golomb(&sl->gb);
1798  }
1799 
1800  sl->redundant_pic_count = 0;
1801  if (pps->redundant_pic_cnt_present)
1802  sl->redundant_pic_count = get_ue_golomb(&sl->gb);
1803 
1804  if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
1805  sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
1806 
1807  ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
1808  &sl->gb, pps, sl->slice_type_nos,
1809  picture_structure, h->avctx);
1810  if (ret < 0)
1811  return ret;
1812 
1813  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1814  ret = ff_h264_decode_ref_pic_list_reordering(sl, h->avctx);
1815  if (ret < 0) {
1816  sl->ref_count[1] = sl->ref_count[0] = 0;
1817  return ret;
1818  }
1819  }
1820 
1821  sl->pwt.use_weight = 0;
1822  for (i = 0; i < 2; i++) {
1823  sl->pwt.luma_weight_flag[i] = 0;
1824  sl->pwt.chroma_weight_flag[i] = 0;
1825  }
1826  if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
1827  (pps->weighted_bipred_idc == 1 &&
1828  sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
1829  ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
1830  sl->slice_type_nos, &sl->pwt,
1831  picture_structure, h->avctx);
1832  if (ret < 0)
1833  return ret;
1834  }
1835 
1836  sl->explicit_ref_marking = 0;
1837  if (nal->ref_idc) {
1838  ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx);
1839  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1840  return AVERROR_INVALIDDATA;
1841  }
1842 
1843  if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
1844  tmp = get_ue_golomb_31(&sl->gb);
1845  if (tmp > 2) {
1846  av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
1847  return AVERROR_INVALIDDATA;
1848  }
1849  sl->cabac_init_idc = tmp;
1850  }
1851 
1852  sl->last_qscale_diff = 0;
1853  tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
1854  if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
1855  av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
1856  return AVERROR_INVALIDDATA;
1857  }
1858  sl->qscale = tmp;
1859  sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
1860  sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
1861  // FIXME qscale / qp ... stuff
1862  if (sl->slice_type == AV_PICTURE_TYPE_SP)
1863  get_bits1(&sl->gb); /* sp_for_switch_flag */
1864  if (sl->slice_type == AV_PICTURE_TYPE_SP ||
1865  sl->slice_type == AV_PICTURE_TYPE_SI)
1866  get_se_golomb(&sl->gb); /* slice_qs_delta */
1867 
1868  sl->deblocking_filter = 1;
1869  sl->slice_alpha_c0_offset = 0;
1870  sl->slice_beta_offset = 0;
1871  if (pps->deblocking_filter_parameters_present) {
1872  tmp = get_ue_golomb_31(&sl->gb);
1873  if (tmp > 2) {
1874  av_log(h->avctx, AV_LOG_ERROR,
1875  "deblocking_filter_idc %u out of range\n", tmp);
1876  return AVERROR_INVALIDDATA;
1877  }
1878  sl->deblocking_filter = tmp;
1879  if (sl->deblocking_filter < 2)
1880  sl->deblocking_filter ^= 1; // 1<->0
1881 
1882  if (sl->deblocking_filter) {
1883  int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
1884  int slice_beta_offset_div2 = get_se_golomb(&sl->gb);
1885  if (slice_alpha_c0_offset_div2 > 6 ||
1886  slice_alpha_c0_offset_div2 < -6 ||
1887  slice_beta_offset_div2 > 6 ||
1888  slice_beta_offset_div2 < -6) {
1889  av_log(h->avctx, AV_LOG_ERROR,
1890  "deblocking filter parameters %d %d out of range\n",
1891  slice_alpha_c0_offset_div2, slice_beta_offset_div2);
1892  return AVERROR_INVALIDDATA;
1893  }
1894  sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
1895  sl->slice_beta_offset = slice_beta_offset_div2 * 2;
1896  }
1897  }
1898 
1899  return 0;
1900 }
1901 
1902 /* do all the per-slice initialization needed before we can start decoding the
1903  * actual MBs */
1904 static int h264_slice_init(H264Context *h, H264SliceContext *sl,
1905  const H2645NAL *nal)
1906 {
1907  int i, j, ret = 0;
1908 
1909  if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
1910  av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
1911  return AVERROR_INVALIDDATA;
1912  }
1913 
1914  av_assert1(h->mb_num == h->mb_width * h->mb_height);
1915  if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
1916  sl->first_mb_addr >= h->mb_num) {
1917  av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
1918  return AVERROR_INVALIDDATA;
1919  }
1920  sl->resync_mb_x = sl->mb_x = sl->first_mb_addr % h->mb_width;
1921  sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
1922  FIELD_OR_MBAFF_PICTURE(h);
1923  if (h->picture_structure == PICT_BOTTOM_FIELD)
1924  sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
1925  av_assert1(sl->mb_y < h->mb_height);
1926 
1927  ret = ff_h264_build_ref_list(h, sl);
1928  if (ret < 0)
1929  return ret;
1930 
1931  if (h->ps.pps->weighted_bipred_idc == 2 &&
1932  sl->slice_type_nos == AV_PICTURE_TYPE_B) {
1933  implicit_weight_table(h, sl, -1);
1934  if (FRAME_MBAFF(h)) {
1935  implicit_weight_table(h, sl, 0);
1936  implicit_weight_table(h, sl, 1);
1937  }
1938  }
1939 
1940  if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
1941  ff_h264_direct_dist_scale_factor(h, sl);
1942  if (!h->setup_finished)
1943  ff_h264_direct_ref_list_init(h, sl);
1944 
1945  if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
1946  (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
1947  h->nal_unit_type != H264_NAL_IDR_SLICE) ||
1948  (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
1949  sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
1950  (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&
1951  sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
1952  (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
1953  nal->ref_idc == 0))
1954  sl->deblocking_filter = 0;
1955 
1956  if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
1957  if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1958  /* Cheat slightly for speed:
1959  * Do not bother to deblock across slices. */
1960  sl->deblocking_filter = 2;
1961  } else {
1962  h->postpone_filter = 1;
1963  }
1964  }
1965  sl->qp_thresh = 15 -
1966  FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
1967  FFMAX3(0,
1968  h->ps.pps->chroma_qp_index_offset[0],
1969  h->ps.pps->chroma_qp_index_offset[1]) +
1970  6 * (h->ps.sps->bit_depth_luma - 8);
1971 
1972  sl->slice_num = ++h->current_slice;
1973 
1974  if (sl->slice_num)
1975  h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
1976  if ( h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
1977  && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
1978  && sl->slice_num >= MAX_SLICES) {
1979  //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
1980  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);
1981  }
1982 
1983  for (j = 0; j < 2; j++) {
1984  int id_list[16];
1985  int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
1986  for (i = 0; i < 16; i++) {
1987  id_list[i] = 60;
1988  if (j < sl->list_count && i < sl->ref_count[j] &&
1989  sl->ref_list[j][i].parent->f->buf[0]) {
1990  int k;
1991  const AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
1992  for (k = 0; k < h->short_ref_count; k++)
1993  if (h->short_ref[k]->f->buf[0]->buffer == buf) {
1994  id_list[i] = k;
1995  break;
1996  }
1997  for (k = 0; k < h->long_ref_count; k++)
1998  if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
1999  id_list[i] = h->short_ref_count + k;
2000  break;
2001  }
2002  }
2003  }
2004 
2005  ref2frm[0] =
2006  ref2frm[1] = -1;
2007  for (i = 0; i < 16; i++)
2008  ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
2009  ref2frm[18 + 0] =
2010  ref2frm[18 + 1] = -1;
2011  for (i = 16; i < 48; i++)
2012  ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
2013  (sl->ref_list[j][i].reference & 3);
2014  }
2015 
2016  if (sl->slice_type_nos == AV_PICTURE_TYPE_I) {
2017  h->cur_pic_ptr->gray = 0;
2018  h->non_gray = 1;
2019  } else {
2020  int gray = 0;
2021  for (j = 0; j < sl->list_count; j++) {
2022  for (i = 0; i < sl->ref_count[j]; i++) {
2023  gray |= sl->ref_list[j][i].parent->gray;
2024  }
2025  }
2026  h->cur_pic_ptr->gray = gray;
2027  }
2028 
2029  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
2030  av_log(h->avctx, AV_LOG_DEBUG,
2031  "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",
2032  sl->slice_num,
2033  (h->picture_structure == PICT_FRAME ? 'F' : h->picture_structure == PICT_TOP_FIELD ? 'T' : 'B'),
2034  sl->mb_y * h->mb_width + sl->mb_x,
2035  av_get_picture_type_char(sl->slice_type),
2036  sl->slice_type_fixed ? " fix" : "",
2037  nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
2038  h->poc.frame_num,
2039  h->cur_pic_ptr->field_poc[0],
2040  h->cur_pic_ptr->field_poc[1],
2041  sl->ref_count[0], sl->ref_count[1],
2042  sl->qscale,
2043  sl->deblocking_filter,
2044  sl->slice_alpha_c0_offset, sl->slice_beta_offset,
2045  sl->pwt.use_weight,
2046  sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
2047  sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
2048  }
2049 
2050  return 0;
2051 }
2052 
2053 int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
2054 {
2055  H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
2056  int first_slice = sl == h->slice_ctx && !h->current_slice;
2057  int ret;
2058 
2059  sl->gb = nal->gb;
2060 
2061  ret = h264_slice_header_parse(h, sl, nal);
2062  if (ret < 0)
2063  return ret;
2064 
2065  // discard redundant pictures
2066  if (sl->redundant_pic_count > 0) {
2067  sl->ref_count[0] = sl->ref_count[1] = 0;
2068  return 0;
2069  }
2070 
2071  if (sl->first_mb_addr == 0 || !h->current_slice) {
2072  if (h->setup_finished) {
2073  av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
2074  return AVERROR_INVALIDDATA;
2075  }
2076  }
2077 
2078  if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
2079  if (h->current_slice) {
2080  // this slice starts a new field
2081  // first decode any pending queued slices
2082  if (h->nb_slice_ctx_queued) {
2083  H264SliceContext tmp_ctx;
2084 
2085  ret = ff_h264_execute_decode_slices(h);
2086  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
2087  return ret;
2088 
2089  memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
2090  memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
2091  memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
2092  sl = h->slice_ctx;
2093  }
2094 
2095  if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
2096  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2097  if (ret < 0)
2098  return ret;
2099  } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type == H264_NAL_IDR_SLICE) {
2100  av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
2101  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2102  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
2103  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
2104  h->cur_pic_ptr = NULL;
2105  if (ret < 0)
2106  return ret;
2107  } else
2108  return AVERROR_INVALIDDATA;
2109  }
2110 
2111  if (!h->first_field) {
2112  if (h->cur_pic_ptr && !h->droppable) {
2113  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
2114  h->picture_structure == PICT_BOTTOM_FIELD);
2115  }
2116  h->cur_pic_ptr = NULL;
2117  }
2118  }
2119 
2120  if (!h->current_slice)
2121  av_assert0(sl == h->slice_ctx);
2122 
2123  if (h->current_slice == 0 && !h->first_field) {
2124  if (
2125  (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
2126  (h->avctx->skip_frame >= AVDISCARD_BIDIR && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
2127  (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
2128  (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
2129  h->avctx->skip_frame >= AVDISCARD_ALL) {
2130  return 0;
2131  }
2132  }
2133 
2134  if (!first_slice) {
2135  const PPS *pps = h->ps.pps_list[sl->pps_id];
2136 
2137  if (h->ps.pps->sps_id != pps->sps_id ||
2138  h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
2139  (h->setup_finished && h->ps.pps != pps)*/) {
2140  av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
2141  return AVERROR_INVALIDDATA;
2142  }
2143  if (h->ps.sps != pps->sps) {
2144  av_log(h->avctx, AV_LOG_ERROR,
2145  "SPS changed in the middle of the frame\n");
2146  return AVERROR_INVALIDDATA;
2147  }
2148  }
2149 
2150  if (h->current_slice == 0) {
2151  ret = h264_field_start(h, sl, nal, first_slice);
2152  if (ret < 0)
2153  return ret;
2154  } else {
2155  if (h->picture_structure != sl->picture_structure ||
2156  h->droppable != (nal->ref_idc == 0)) {
2157  av_log(h->avctx, AV_LOG_ERROR,
2158  "Changing field mode (%d -> %d) between slices is not allowed\n",
2159  h->picture_structure, sl->picture_structure);
2160  return AVERROR_INVALIDDATA;
2161  } else if (!h->cur_pic_ptr) {
2162  av_log(h->avctx, AV_LOG_ERROR,
2163  "unset cur_pic_ptr on slice %d\n",
2164  h->current_slice + 1);
2165  return AVERROR_INVALIDDATA;
2166  }
2167  }
2168 
2169  ret = h264_slice_init(h, sl, nal);
2170  if (ret < 0)
2171  return ret;
2172 
2173  h->nb_slice_ctx_queued++;
2174 
2175  return 0;
2176 }
2177 
2178 int ff_h264_get_slice_type(const H264SliceContext *sl)
2179 {
2180  switch (sl->slice_type) {
2181  case AV_PICTURE_TYPE_P:
2182  return 0;
2183  case AV_PICTURE_TYPE_B:
2184  return 1;
2185  case AV_PICTURE_TYPE_I:
2186  return 2;
2187  case AV_PICTURE_TYPE_SP:
2188  return 3;
2189  case AV_PICTURE_TYPE_SI:
2190  return 4;
2191  default:
2192  return AVERROR_INVALIDDATA;
2193  }
2194 }
2195 
2196 static av_always_inline void fill_filter_caches_inter(const H264Context *h,
2197  H264SliceContext *sl,
2198  int mb_type, int top_xy,
2199  const int left_xy[LEFT_MBS],
2200  int top_type,
2201  const int left_type[LEFT_MBS],
2202  int mb_xy, int list)
2203 {
2204  int b_stride = h->b_stride;
2205  int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
2206  int8_t *ref_cache = &sl->ref_cache[list][scan8[0]];
2207  if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
2208  if (USES_LIST(top_type, list)) {
2209  const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;
2210  const int b8_xy = 4 * top_xy + 2;
2211  const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2212  AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
2213  ref_cache[0 - 1 * 8] =
2214  ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
2215  ref_cache[2 - 1 * 8] =
2216  ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
2217  } else {
2218  AV_ZERO128(mv_dst - 1 * 8);
2219  AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2220  }
2221 
2222  if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
2223  if (USES_LIST(left_type[LTOP], list)) {
2224  const int b_xy = h->mb2b_xy[left_xy[LTOP]] + 3;
2225  const int b8_xy = 4 * left_xy[LTOP] + 1;
2226  const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2227  AV_COPY32(mv_dst - 1 + 0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
2228  AV_COPY32(mv_dst - 1 + 8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
2229  AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
2230  AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
2231  ref_cache[-1 + 0] =
2232  ref_cache[-1 + 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
2233  ref_cache[-1 + 16] =
2234  ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
2235  } else {
2236  AV_ZERO32(mv_dst - 1 + 0);
2237  AV_ZERO32(mv_dst - 1 + 8);
2238  AV_ZERO32(mv_dst - 1 + 16);
2239  AV_ZERO32(mv_dst - 1 + 24);
2240  ref_cache[-1 + 0] =
2241  ref_cache[-1 + 8] =
2242  ref_cache[-1 + 16] =
2243  ref_cache[-1 + 24] = LIST_NOT_USED;
2244  }
2245  }
2246  }
2247 
2248  if (!USES_LIST(mb_type, list)) {
2249  fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
2250  AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2251  AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2252  AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2253  AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2254  return;
2255  }
2256 
2257  {
2258  const int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
2259  const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2260  uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
2261  uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
2262  AV_WN32A(&ref_cache[0 * 8], ref01);
2263  AV_WN32A(&ref_cache[1 * 8], ref01);
2264  AV_WN32A(&ref_cache[2 * 8], ref23);
2265  AV_WN32A(&ref_cache[3 * 8], ref23);
2266  }
2267 
2268  {
2269  int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
2270  AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
2271  AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
2272  AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
2273  AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
2274  }
2275 }
2276 
2277 /**
2278  * @return non zero if the loop filter can be skipped
2279  */
2280 static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
2281 {
2282  const int mb_xy = sl->mb_xy;
2283  int top_xy, left_xy[LEFT_MBS];
2284  int top_type, left_type[LEFT_MBS];
2285  const uint8_t *nnz;
2286  uint8_t *nnz_cache;
2287 
2288  top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
2289 
2290  left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
2291  if (FRAME_MBAFF(h)) {
2292  const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
2293  const int curr_mb_field_flag = IS_INTERLACED(mb_type);
2294  if (sl->mb_y & 1) {
2295  if (left_mb_field_flag != curr_mb_field_flag)
2296  left_xy[LTOP] -= h->mb_stride;
2297  } else {
2298  if (curr_mb_field_flag)
2299  top_xy += h->mb_stride &
2300  (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
2301  if (left_mb_field_flag != curr_mb_field_flag)
2302  left_xy[LBOT] += h->mb_stride;
2303  }
2304  }
2305 
2306  sl->top_mb_xy = top_xy;
2307  sl->left_mb_xy[LTOP] = left_xy[LTOP];
2308  sl->left_mb_xy[LBOT] = left_xy[LBOT];
2309  {
2310  /* For sufficiently low qp, filtering wouldn't do anything.
2311  * This is a conservative estimate: could also check beta_offset
2312  * and more accurate chroma_qp. */
2313  int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
2314  int qp = h->cur_pic.qscale_table[mb_xy];
2315  if (qp <= qp_thresh &&
2316  (left_xy[LTOP] < 0 ||
2317  ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
2318  (top_xy < 0 ||
2319  ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
2320  if (!FRAME_MBAFF(h))
2321  return 1;
2322  if ((left_xy[LTOP] < 0 ||
2323  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
2324  (top_xy < h->mb_stride ||
2325  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
2326  return 1;
2327  }
2328  }
2329 
2330  top_type = h->cur_pic.mb_type[top_xy];
2331  left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
2332  left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
2333  if (sl->deblocking_filter == 2) {
2334  if (h->slice_table[top_xy] != sl->slice_num)
2335  top_type = 0;
2336  if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
2337  left_type[LTOP] = left_type[LBOT] = 0;
2338  } else {
2339  if (h->slice_table[top_xy] == 0xFFFF)
2340  top_type = 0;
2341  if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
2342  left_type[LTOP] = left_type[LBOT] = 0;
2343  }
2344  sl->top_type = top_type;
2345  sl->left_type[LTOP] = left_type[LTOP];
2346  sl->left_type[LBOT] = left_type[LBOT];
2347 
2348  if (IS_INTRA(mb_type))
2349  return 0;
2350 
2351  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2352  top_type, left_type, mb_xy, 0);
2353  if (sl->list_count == 2)
2354  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2355  top_type, left_type, mb_xy, 1);
2356 
2357  nnz = h->non_zero_count[mb_xy];
2358  nnz_cache = sl->non_zero_count_cache;
2359  AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
2360  AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
2361  AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
2362  AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
2363  sl->cbp = h->cbp_table[mb_xy];
2364 
2365  if (top_type) {
2366  nnz = h->non_zero_count[top_xy];
2367  AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
2368  }
2369 
2370  if (left_type[LTOP]) {
2371  nnz = h->non_zero_count[left_xy[LTOP]];
2372  nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
2373  nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
2374  nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
2375  nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
2376  }
2377 
2378  /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
2379  * from what the loop filter needs */
2380  if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
2381  if (IS_8x8DCT(top_type)) {
2382  nnz_cache[4 + 8 * 0] =
2383  nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
2384  nnz_cache[6 + 8 * 0] =
2385  nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
2386  }
2387  if (IS_8x8DCT(left_type[LTOP])) {
2388  nnz_cache[3 + 8 * 1] =
2389  nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
2390  }
2391  if (IS_8x8DCT(left_type[LBOT])) {
2392  nnz_cache[3 + 8 * 3] =
2393  nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
2394  }
2395 
2396  if (IS_8x8DCT(mb_type)) {
2397  nnz_cache[scan8[0]] =
2398  nnz_cache[scan8[1]] =
2399  nnz_cache[scan8[2]] =
2400  nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
2401 
2402  nnz_cache[scan8[0 + 4]] =
2403  nnz_cache[scan8[1 + 4]] =
2404  nnz_cache[scan8[2 + 4]] =
2405  nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
2406 
2407  nnz_cache[scan8[0 + 8]] =
2408  nnz_cache[scan8[1 + 8]] =
2409  nnz_cache[scan8[2 + 8]] =
2410  nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
2411 
2412  nnz_cache[scan8[0 + 12]] =
2413  nnz_cache[scan8[1 + 12]] =
2414  nnz_cache[scan8[2 + 12]] =
2415  nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
2416  }
2417  }
2418 
2419  return 0;
2420 }
2421 
2422 static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
2423 {
2424  uint8_t *dest_y, *dest_cb, *dest_cr;
2425  int linesize, uvlinesize, mb_x, mb_y;
2426  const int end_mb_y = sl->mb_y + FRAME_MBAFF(h);
2427  const int old_slice_type = sl->slice_type;
2428  const int pixel_shift = h->pixel_shift;
2429  const int block_h = 16 >> h->chroma_y_shift;
2430 
2431  if (h->postpone_filter)
2432  return;
2433 
2434  if (sl->deblocking_filter) {
2435  for (mb_x = start_x; mb_x < end_x; mb_x++)
2436  for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
2437  int mb_xy, mb_type;
2438  mb_xy = sl->mb_xy = mb_x + mb_y * h->mb_stride;
2439  mb_type = h->cur_pic.mb_type[mb_xy];
2440 
2441  if (FRAME_MBAFF(h))
2442  sl->mb_mbaff =
2443  sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2444 
2445  sl->mb_x = mb_x;
2446  sl->mb_y = mb_y;
2447  dest_y = h->cur_pic.f->data[0] +
2448  ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
2449  dest_cb = h->cur_pic.f->data[1] +
2450  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2451  mb_y * sl->uvlinesize * block_h;
2452  dest_cr = h->cur_pic.f->data[2] +
2453  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2454  mb_y * sl->uvlinesize * block_h;
2455  // FIXME simplify above
2456 
2457  if (MB_FIELD(sl)) {
2458  linesize = sl->mb_linesize = sl->linesize * 2;
2459  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
2460  if (mb_y & 1) { // FIXME move out of this function?
2461  dest_y -= sl->linesize * 15;
2462  dest_cb -= sl->uvlinesize * (block_h - 1);
2463  dest_cr -= sl->uvlinesize * (block_h - 1);
2464  }
2465  } else {
2466  linesize = sl->mb_linesize = sl->linesize;
2467  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
2468  }
2469  backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
2470  uvlinesize, 0);
2471  if (fill_filter_caches(h, sl, mb_type))
2472  continue;
2473  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
2474  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
2475 
2476  if (FRAME_MBAFF(h)) {
2477  ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
2478  linesize, uvlinesize);
2479  } else {
2480  ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
2481  dest_cr, linesize, uvlinesize);
2482  }
2483  }
2484  }
2485  sl->slice_type = old_slice_type;
2486  sl->mb_x = end_x;
2487  sl->mb_y = end_mb_y - FRAME_MBAFF(h);
2488  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
2489  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
2490 }
2491 
2492 static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
2493 {
2494  const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
2495  int mb_type = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
2496  h->cur_pic.mb_type[mb_xy - 1] :
2497  (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
2498  h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
2499  sl->mb_mbaff = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2500 }
2501 
2502 /**
2503  * Draw edges and report progress for the last MB row.
2504  */
2505 static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
2506 {
2507  int top = 16 * (sl->mb_y >> FIELD_PICTURE(h));
2508  int pic_height = 16 * h->mb_height >> FIELD_PICTURE(h);
2509  int height = 16 << FRAME_MBAFF(h);
2510  int deblock_border = (16 + 4) << FRAME_MBAFF(h);
2511 
2512  if (sl->deblocking_filter) {
2513  if ((top + height) >= pic_height)
2514  height += deblock_border;
2515  top -= deblock_border;
2516  }
2517 
2518  if (top >= pic_height || (top + height) < 0)
2519  return;
2520 
2521  height = FFMIN(height, pic_height - top);
2522  if (top < 0) {
2523  height = top + height;
2524  top = 0;
2525  }
2526 
2527  ff_h264_draw_horiz_band(h, sl, top, height);
2528 
2529  if (h->droppable || h->er.error_occurred)
2530  return;
2531 
2532  ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
2533  h->picture_structure == PICT_BOTTOM_FIELD);
2534 }
2535 
2536 static void er_add_slice(H264SliceContext *sl,
2537  int startx, int starty,
2538  int endx, int endy, int status)
2539 {
2540  if (!sl->h264->enable_er)
2541  return;
2542 
2543  if (CONFIG_ERROR_RESILIENCE) {
2544  ff_er_add_slice(sl->er, startx, starty, endx, endy, status);
2545  }
2546 }
2547 
2548 static int decode_slice(struct AVCodecContext *avctx, void *arg)
2549 {
2550  H264SliceContext *sl = arg;
2551  const H264Context *h = sl->h264;
2552  int lf_x_start = sl->mb_x;
2553  int orig_deblock = sl->deblocking_filter;
2554  int ret;
2555 
2556  sl->linesize = h->cur_pic_ptr->f->linesize[0];
2557  sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
2558 
2559  ret = alloc_scratch_buffers(sl, sl->linesize);
2560  if (ret < 0)
2561  return ret;
2562 
2563  sl->mb_skip_run = -1;
2564 
2565  av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
2566 
2567  if (h->postpone_filter)
2568  sl->deblocking_filter = 0;
2569 
2570  sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
2571  (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
2572 
2573  if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && sl->er->error_status_table) {
2574  const int start_i = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
2575  if (start_i) {
2576  int prev_status = sl->er->error_status_table[sl->er->mb_index2xy[start_i - 1]];
2577  prev_status &= ~ VP_START;
2578  if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
2579  sl->er->error_occurred = 1;
2580  }
2581  }
2582 
2583  if (h->ps.pps->cabac) {
2584  /* realign */
2585  align_get_bits(&sl->gb);
2586 
2587  /* init cabac */
2588  ret = ff_init_cabac_decoder(&sl->cabac,
2589  sl->gb.buffer + get_bits_count(&sl->gb) / 8,
2590  (get_bits_left(&sl->gb) + 7) / 8);
2591  if (ret < 0)
2592  return ret;
2593 
2594  ff_h264_init_cabac_states(h, sl);
2595 
2596  for (;;) {
2597  int ret, eos;
2598  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2599  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2600  sl->next_slice_idx);
2601  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2602  sl->mb_y, ER_MB_ERROR);
2603  return AVERROR_INVALIDDATA;
2604  }
2605 
2606  ret = ff_h264_decode_mb_cabac(h, sl);
2607 
2608  if (ret >= 0)
2609  ff_h264_hl_decode_mb(h, sl);
2610 
2611  // FIXME optimal? or let mb_decode decode 16x32 ?
2612  if (ret >= 0 && FRAME_MBAFF(h)) {
2613  sl->mb_y++;
2614 
2615  ret = ff_h264_decode_mb_cabac(h, sl);
2616 
2617  if (ret >= 0)
2618  ff_h264_hl_decode_mb(h, sl);
2619  sl->mb_y--;
2620  }
2621  eos = get_cabac_terminate(&sl->cabac);
2622 
2623  if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
2624  sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
2625  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2626  sl->mb_y, ER_MB_END);
2627  if (sl->mb_x >= lf_x_start)
2628  loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
2629  goto finish;
2630  }
2631  if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
2632  av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
2633  if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
2634  av_log(h->avctx, AV_LOG_ERROR,
2635  "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
2636  sl->mb_x, sl->mb_y,
2637  sl->cabac.bytestream_end - sl->cabac.bytestream);
2638  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2639  sl->mb_y, ER_MB_ERROR);
2640  return AVERROR_INVALIDDATA;
2641  }
2642 
2643  if (++sl->mb_x >= h->mb_width) {
2644  loop_filter(h, sl, lf_x_start, sl->mb_x);
2645  sl->mb_x = lf_x_start = 0;
2646  decode_finish_row(h, sl);
2647  ++sl->mb_y;
2648  if (FIELD_OR_MBAFF_PICTURE(h)) {
2649  ++sl->mb_y;
2650  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2651  predict_field_decoding_flag(h, sl);
2652  }
2653  }
2654 
2655  if (eos || sl->mb_y >= h->mb_height) {
2656  ff_tlog(h->avctx, "slice end %d %d\n",
2657  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2658  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2659  sl->mb_y, ER_MB_END);
2660  if (sl->mb_x > lf_x_start)
2661  loop_filter(h, sl, lf_x_start, sl->mb_x);
2662  goto finish;
2663  }
2664  }
2665  } else {
2666  for (;;) {
2667  int ret;
2668 
2669  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2670  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2671  sl->next_slice_idx);
2672  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2673  sl->mb_y, ER_MB_ERROR);
2674  return AVERROR_INVALIDDATA;
2675  }
2676 
2677  ret = ff_h264_decode_mb_cavlc(h, sl);
2678 
2679  if (ret >= 0)
2680  ff_h264_hl_decode_mb(h, sl);
2681 
2682  // FIXME optimal? or let mb_decode decode 16x32 ?
2683  if (ret >= 0 && FRAME_MBAFF(h)) {
2684  sl->mb_y++;
2685  ret = ff_h264_decode_mb_cavlc(h, sl);
2686 
2687  if (ret >= 0)
2688  ff_h264_hl_decode_mb(h, sl);
2689  sl->mb_y--;
2690  }
2691 
2692  if (ret < 0) {
2693  av_log(h->avctx, AV_LOG_ERROR,
2694  "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
2695  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2696  sl->mb_y, ER_MB_ERROR);
2697  return ret;
2698  }
2699 
2700  if (++sl->mb_x >= h->mb_width) {
2701  loop_filter(h, sl, lf_x_start, sl->mb_x);
2702  sl->mb_x = lf_x_start = 0;
2703  decode_finish_row(h, sl);
2704  ++sl->mb_y;
2705  if (FIELD_OR_MBAFF_PICTURE(h)) {
2706  ++sl->mb_y;
2707  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2708  predict_field_decoding_flag(h, sl);
2709  }
2710  if (sl->mb_y >= h->mb_height) {
2711  ff_tlog(h->avctx, "slice end %d %d\n",
2712  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2713 
2714  if ( get_bits_left(&sl->gb) == 0
2715  || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
2716  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2717  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2718 
2719  goto finish;
2720  } else {
2721  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2722  sl->mb_x, sl->mb_y, ER_MB_END);
2723 
2724  return AVERROR_INVALIDDATA;
2725  }
2726  }
2727  }
2728 
2729  if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
2730  ff_tlog(h->avctx, "slice end %d %d\n",
2731  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2732 
2733  if (get_bits_left(&sl->gb) == 0) {
2734  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2735  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2736  if (sl->mb_x > lf_x_start)
2737  loop_filter(h, sl, lf_x_start, sl->mb_x);
2738 
2739  goto finish;
2740  } else {
2741  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2742  sl->mb_y, ER_MB_ERROR);
2743 
2744  return AVERROR_INVALIDDATA;
2745  }
2746  }
2747  }
2748  }
2749 
2750 finish:
2751  sl->deblocking_filter = orig_deblock;
2752  return 0;
2753 }
2754 
2755 /**
2756  * Call decode_slice() for each context.
2757  *
2758  * @param h h264 master context
2759  */
2760 int ff_h264_execute_decode_slices(H264Context *h)
2761 {
2762  AVCodecContext *const avctx = h->avctx;
2763  H264SliceContext *sl;
2764  int context_count = h->nb_slice_ctx_queued;
2765  int ret = 0;
2766  int i, j;
2767 
2768  h->slice_ctx[0].next_slice_idx = INT_MAX;
2769 
2770  if (h->avctx->hwaccel || context_count < 1)
2771  return 0;
2772 
2773  av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
2774 
2775  if (context_count == 1) {
2776 
2777  h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
2778  h->postpone_filter = 0;
2779 
2780  ret = decode_slice(avctx, &h->slice_ctx[0]);
2781  h->mb_y = h->slice_ctx[0].mb_y;
2782  if (ret < 0)
2783  goto finish;
2784  } else {
2785  av_assert0(context_count > 0);
2786  for (i = 0; i < context_count; i++) {
2787  int next_slice_idx = h->mb_width * h->mb_height;
2788  int slice_idx;
2789 
2790  sl = &h->slice_ctx[i];
2791 
2792  /* make sure none of those slices overlap */
2793  slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
2794  for (j = 0; j < context_count; j++) {
2795  H264SliceContext *sl2 = &h->slice_ctx[j];
2796  int slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
2797 
2798  if (i == j || slice_idx2 < slice_idx)
2799  continue;
2800  next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
2801  }
2802  sl->next_slice_idx = next_slice_idx;
2803  }
2804 
2805  avctx->execute(avctx, decode_slice, h->slice_ctx,
2806  NULL, context_count, sizeof(h->slice_ctx[0]));
2807 
2808  /* pull back stuff from slices to master context */
2809  sl = &h->slice_ctx[context_count - 1];
2810  h->mb_y = sl->mb_y;
2811 
2812  if (h->postpone_filter) {
2813  h->postpone_filter = 0;
2814 
2815  for (i = 0; i < context_count; i++) {
2816  int y_end, x_end;
2817 
2818  sl = &h->slice_ctx[i];
2819  y_end = FFMIN(sl->mb_y + 1, h->mb_height);
2820  x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
2821 
2822  for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
2823  sl->mb_y = j;
2824  loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
2825  j == y_end - 1 ? x_end : h->mb_width);
2826  }
2827  }
2828  }
2829  }
2830 
2831 finish:
2832  h->nb_slice_ctx_queued = 0;
2833  return ret;
2834 }
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:2536
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:954
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:1047
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:1160
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:3170
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:1013
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:2492
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:403
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVFrame::width
int width
Definition: frame.h:475
w
uint8_t w
Definition: llviddspenc.c:38
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
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:614
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:2505
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:502
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:641
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:675
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:616
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:424
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:667
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:520
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:518
timecode.h
h264_select_output_frame
static int h264_select_output_frame(H264Context *h)
Definition: h264_slice.c:1284
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:500
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:3198
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:1036
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:505
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:654
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:627
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:2053
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:1049
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:1685
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:499
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:783
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:650
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:1078
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:503
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:2280
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:517
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:914
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:781
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:782
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:505
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:425
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:507
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:509
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:490
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:2548
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:2422
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:650
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:519
ff_h264_execute_decode_slices
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2760
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:1057
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:662
AVCOL_RANGE_MPEG
@ AVCOL_RANGE_MPEG
Narrow or limited range content.
Definition: pixfmt.h:700
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:501
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:1386
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:506
U
#define U(x)
Definition: vpx_arith.h:37
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:511
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:475
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:1904
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:2196
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:780
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:448
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:2178
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:512
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:3525
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:510
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:3090
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 Wed Dec 25 2024 19:21:39 for FFmpeg by   doxygen 1.8.17