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