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