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