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