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