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 
1129  cur->f->interlaced_frame = 0;
1130  cur->f->repeat_pict = 0;
1131 
1132  /* Signal interlacing information externally. */
1133  /* Prioritize picture timing SEI information over used
1134  * decoding process if it exists. */
1135  if (h->sei.picture_timing.present) {
1137  h->avctx);
1138  if (ret < 0) {
1139  av_log(h->avctx, AV_LOG_ERROR, "Error processing a picture timing SEI\n");
1141  return ret;
1142  h->sei.picture_timing.present = 0;
1143  }
1144  }
1145 
1148  switch (pt->pic_struct) {
1150  break;
1153  cur->f->interlaced_frame = 1;
1154  break;
1157  if (FIELD_OR_MBAFF_PICTURE(h))
1158  cur->f->interlaced_frame = 1;
1159  else
1160  // try to flag soft telecine progressive
1162  break;
1165  /* Signal the possibility of telecined film externally
1166  * (pic_struct 5,6). From these hints, let the applications
1167  * decide if they apply deinterlacing. */
1168  cur->f->repeat_pict = 1;
1169  break;
1171  cur->f->repeat_pict = 2;
1172  break;
1174  cur->f->repeat_pict = 4;
1175  break;
1176  }
1177 
1178  if ((pt->ct_type & 3) &&
1180  cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
1181  } else {
1182  /* Derive interlacing flag from used decoding process. */
1184  }
1186 
1187  if (cur->field_poc[0] != cur->field_poc[1]) {
1188  /* Derive top_field_first from field pocs. */
1189  cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
1190  } else {
1192  /* Use picture timing SEI information. Even if it is a
1193  * information of a past frame, better than nothing. */
1196  cur->f->top_field_first = 1;
1197  else
1198  cur->f->top_field_first = 0;
1199  } else if (cur->f->interlaced_frame) {
1200  /* Default to top field first when pic_struct_present_flag
1201  * is not set but interlaced frame detected */
1202  cur->f->top_field_first = 1;
1203  } else {
1204  /* Most likely progressive */
1205  cur->f->top_field_first = 0;
1206  }
1207  }
1208 
1209  if (h->sei.frame_packing.present &&
1214  AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
1215  if (stereo) {
1216  switch (fp->arrangement_type) {
1218  stereo->type = AV_STEREO3D_CHECKERBOARD;
1219  break;
1221  stereo->type = AV_STEREO3D_COLUMNS;
1222  break;
1224  stereo->type = AV_STEREO3D_LINES;
1225  break;
1227  if (fp->quincunx_sampling_flag)
1229  else
1230  stereo->type = AV_STEREO3D_SIDEBYSIDE;
1231  break;
1233  stereo->type = AV_STEREO3D_TOPBOTTOM;
1234  break;
1236  stereo->type = AV_STEREO3D_FRAMESEQUENCE;
1237  break;
1238  case H264_SEI_FPA_TYPE_2D:
1239  stereo->type = AV_STEREO3D_2D;
1240  break;
1241  }
1242 
1243  if (fp->content_interpretation_type == 2)
1244  stereo->flags = AV_STEREO3D_FLAG_INVERT;
1245 
1248  stereo->view = AV_STEREO3D_VIEW_LEFT;
1249  else
1250  stereo->view = AV_STEREO3D_VIEW_RIGHT;
1251  }
1252  }
1253  }
1254 
1255  if (h->sei.display_orientation.present &&
1260  double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
1261  AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
1263  sizeof(int32_t) * 9);
1264  if (rotation) {
1265  av_display_rotation_set((int32_t *)rotation->data, angle);
1266  av_display_matrix_flip((int32_t *)rotation->data,
1267  o->hflip, o->vflip);
1268  }
1269  }
1270 
1271  if (h->sei.afd.present) {
1273  sizeof(uint8_t));
1274 
1275  if (sd) {
1277  h->sei.afd.present = 0;
1278  }
1279  }
1280 
1281  if (h->sei.a53_caption.buf_ref) {
1282  H264SEIA53Caption *a53 = &h->sei.a53_caption;
1283 
1285  if (!sd)
1286  av_buffer_unref(&a53->buf_ref);
1287  a53->buf_ref = NULL;
1288 
1290  }
1291 
1292  for (int i = 0; i < h->sei.unregistered.nb_buf_ref; i++) {
1293  H264SEIUnregistered *unreg = &h->sei.unregistered;
1294 
1295  if (unreg->buf_ref[i]) {
1298  unreg->buf_ref[i]);
1299  if (!sd)
1300  av_buffer_unref(&unreg->buf_ref[i]);
1301  unreg->buf_ref[i] = NULL;
1302  }
1303  }
1304  h->sei.unregistered.nb_buf_ref = 0;
1305 
1306  if (h->sei.picture_timing.timecode_cnt > 0) {
1307  uint32_t *tc_sd;
1308 
1309  AVFrameSideData *tcside = av_frame_new_side_data(cur->f,
1311  sizeof(uint32_t)*4);
1312  if (!tcside)
1313  return AVERROR(ENOMEM);
1314 
1315  tc_sd = (uint32_t*)tcside->data;
1316  tc_sd[0] = h->sei.picture_timing.timecode_cnt;
1317 
1318  for (int i = 0; i < tc_sd[0]; i++) {
1319  int drop = h->sei.picture_timing.timecode[i].dropframe;
1320  int hh = h->sei.picture_timing.timecode[i].hours;
1321  int mm = h->sei.picture_timing.timecode[i].minutes;
1322  int ss = h->sei.picture_timing.timecode[i].seconds;
1323  int ff = h->sei.picture_timing.timecode[i].frame;
1324 
1325  tc_sd[i + 1] = av_timecode_get_smpte(h->avctx->framerate, drop, hh, mm, ss, ff);
1326  }
1328  }
1329 
1330  return 0;
1331 }
1332 
1334 {
1335  const SPS *sps = h->ps.sps;
1336  H264Picture *out = h->cur_pic_ptr;
1337  H264Picture *cur = h->cur_pic_ptr;
1338  int i, pics, out_of_order, out_idx;
1339 
1340  cur->mmco_reset = h->mmco_reset;
1341  h->mmco_reset = 0;
1342 
1343  if (sps->bitstream_restriction_flag ||
1346  }
1347 
1348  for (i = 0; 1; i++) {
1349  if(i == MAX_DELAYED_PIC_COUNT || cur->poc < h->last_pocs[i]){
1350  if(i)
1351  h->last_pocs[i-1] = cur->poc;
1352  break;
1353  } else if(i) {
1354  h->last_pocs[i-1]= h->last_pocs[i];
1355  }
1356  }
1357  out_of_order = MAX_DELAYED_PIC_COUNT - i;
1358  if( cur->f->pict_type == AV_PICTURE_TYPE_B
1359  || (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))
1360  out_of_order = FFMAX(out_of_order, 1);
1361  if (out_of_order == MAX_DELAYED_PIC_COUNT) {
1362  av_log(h->avctx, AV_LOG_VERBOSE, "Invalid POC %d<%d\n", cur->poc, h->last_pocs[0]);
1363  for (i = 1; i < MAX_DELAYED_PIC_COUNT; i++)
1364  h->last_pocs[i] = INT_MIN;
1365  h->last_pocs[0] = cur->poc;
1366  cur->mmco_reset = 1;
1367  } else if(h->avctx->has_b_frames < out_of_order && !sps->bitstream_restriction_flag){
1368  int loglevel = h->avctx->frame_number > 1 ? AV_LOG_WARNING : AV_LOG_VERBOSE;
1369  av_log(h->avctx, loglevel, "Increasing reorder buffer to %d\n", out_of_order);
1370  h->avctx->has_b_frames = out_of_order;
1371  }
1372 
1373  pics = 0;
1374  while (h->delayed_pic[pics])
1375  pics++;
1376 
1378 
1379  h->delayed_pic[pics++] = cur;
1380  if (cur->reference == 0)
1381  cur->reference = DELAYED_PIC_REF;
1382 
1383  out = h->delayed_pic[0];
1384  out_idx = 0;
1385  for (i = 1; h->delayed_pic[i] &&
1386  !h->delayed_pic[i]->f->key_frame &&
1387  !h->delayed_pic[i]->mmco_reset;
1388  i++)
1389  if (h->delayed_pic[i]->poc < out->poc) {
1390  out = h->delayed_pic[i];
1391  out_idx = i;
1392  }
1393  if (h->avctx->has_b_frames == 0 &&
1394  (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset))
1395  h->next_outputed_poc = INT_MIN;
1396  out_of_order = out->poc < h->next_outputed_poc;
1397 
1398  if (out_of_order || pics > h->avctx->has_b_frames) {
1399  out->reference &= ~DELAYED_PIC_REF;
1400  for (i = out_idx; h->delayed_pic[i]; i++)
1401  h->delayed_pic[i] = h->delayed_pic[i + 1];
1402  }
1403  if (!out_of_order && pics > h->avctx->has_b_frames) {
1404  h->next_output_pic = out;
1405  if (out_idx == 0 && h->delayed_pic[0] && (h->delayed_pic[0]->f->key_frame || h->delayed_pic[0]->mmco_reset)) {
1406  h->next_outputed_poc = INT_MIN;
1407  } else
1408  h->next_outputed_poc = out->poc;
1409 
1410  if (out->recovered) {
1411  // We have reached an recovery point and all frames after it in
1412  // display order are "recovered".
1414  }
1416 
1417  if (!out->recovered) {
1418  if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
1420  h->next_output_pic = NULL;
1421  } else {
1422  out->f->flags |= AV_FRAME_FLAG_CORRUPT;
1423  }
1424  }
1425  } else {
1426  av_log(h->avctx, AV_LOG_DEBUG, "no picture %s\n", out_of_order ? "ooo" : "");
1427  }
1428 
1429  return 0;
1430 }
1431 
1432 /* This function is called right after decoding the slice header for a first
1433  * slice in a field (or a frame). It decides whether we are decoding a new frame
1434  * or a second field in a pair and does the necessary setup.
1435  */
1437  const H2645NAL *nal, int first_slice)
1438 {
1439  int i;
1440  const SPS *sps;
1441 
1442  int last_pic_structure, last_pic_droppable, ret;
1443 
1444  ret = h264_init_ps(h, sl, first_slice);
1445  if (ret < 0)
1446  return ret;
1447 
1448  sps = h->ps.sps;
1449 
1450  if (sps && sps->bitstream_restriction_flag &&
1451  h->avctx->has_b_frames < sps->num_reorder_frames) {
1453  }
1454 
1455  last_pic_droppable = h->droppable;
1456  last_pic_structure = h->picture_structure;
1457  h->droppable = (nal->ref_idc == 0);
1459 
1460  h->poc.frame_num = sl->frame_num;
1461  h->poc.poc_lsb = sl->poc_lsb;
1463  h->poc.delta_poc[0] = sl->delta_poc[0];
1464  h->poc.delta_poc[1] = sl->delta_poc[1];
1465 
1466  /* Shorten frame num gaps so we don't have to allocate reference
1467  * frames just to throw them away */
1468  if (h->poc.frame_num != h->poc.prev_frame_num) {
1469  int unwrap_prev_frame_num = h->poc.prev_frame_num;
1470  int max_frame_num = 1 << sps->log2_max_frame_num;
1471 
1472  if (unwrap_prev_frame_num > h->poc.frame_num)
1473  unwrap_prev_frame_num -= max_frame_num;
1474 
1475  if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
1476  unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
1477  if (unwrap_prev_frame_num < 0)
1478  unwrap_prev_frame_num += max_frame_num;
1479 
1480  h->poc.prev_frame_num = unwrap_prev_frame_num;
1481  }
1482  }
1483 
1484  /* See if we have a decoded first field looking for a pair...
1485  * Here, we're using that to see if we should mark previously
1486  * decode frames as "finished".
1487  * We have to do that before the "dummy" in-between frame allocation,
1488  * since that can modify h->cur_pic_ptr. */
1489  if (h->first_field) {
1490  int last_field = last_pic_structure == PICT_BOTTOM_FIELD;
1491  av_assert0(h->cur_pic_ptr);
1492  av_assert0(h->cur_pic_ptr->f->buf[0]);
1493  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1494 
1495  /* Mark old field/frame as completed */
1496  if (h->cur_pic_ptr->tf.owner[last_field] == h->avctx) {
1497  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, last_field);
1498  }
1499 
1500  /* figure out if we have a complementary field pair */
1501  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1502  /* Previous field is unmatched. Don't display it, but let it
1503  * remain for reference if marked as such. */
1504  if (last_pic_structure != PICT_FRAME) {
1506  last_pic_structure == PICT_TOP_FIELD);
1507  }
1508  } else {
1509  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1510  /* This and previous field were reference, but had
1511  * different frame_nums. Consider this field first in
1512  * pair. Throw away previous field except for reference
1513  * purposes. */
1514  if (last_pic_structure != PICT_FRAME) {
1516  last_pic_structure == PICT_TOP_FIELD);
1517  }
1518  } else {
1519  /* Second field in complementary pair */
1520  if (!((last_pic_structure == PICT_TOP_FIELD &&
1522  (last_pic_structure == PICT_BOTTOM_FIELD &&
1525  "Invalid field mode combination %d/%d\n",
1526  last_pic_structure, h->picture_structure);
1527  h->picture_structure = last_pic_structure;
1528  h->droppable = last_pic_droppable;
1529  return AVERROR_INVALIDDATA;
1530  } else if (last_pic_droppable != h->droppable) {
1532  "Found reference and non-reference fields in the same frame, which");
1533  h->picture_structure = last_pic_structure;
1534  h->droppable = last_pic_droppable;
1535  return AVERROR_PATCHWELCOME;
1536  }
1537  }
1538  }
1539  }
1540 
1541  while (h->poc.frame_num != h->poc.prev_frame_num && !h->first_field &&
1542  h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
1543  H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
1544  av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
1545  h->poc.frame_num, h->poc.prev_frame_num);
1547  for(i=0; i<FF_ARRAY_ELEMS(h->last_pocs); i++)
1548  h->last_pocs[i] = INT_MIN;
1549  ret = h264_frame_start(h);
1550  if (ret < 0) {
1551  h->first_field = 0;
1552  return ret;
1553  }
1554 
1555  h->poc.prev_frame_num++;
1556  h->poc.prev_frame_num %= 1 << sps->log2_max_frame_num;
1559  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
1560  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
1561 
1562  h->explicit_ref_marking = 0;
1564  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1565  return ret;
1566  /* Error concealment: If a ref is missing, copy the previous ref
1567  * in its place.
1568  * FIXME: Avoiding a memcpy would be nice, but ref handling makes
1569  * many assumptions about there being no actual duplicates.
1570  * FIXME: This does not copy padding for out-of-frame motion
1571  * vectors. Given we are concealing a lost frame, this probably
1572  * is not noticeable by comparison, but it should be fixed. */
1573  if (h->short_ref_count) {
1574  int c[4] = {
1575  1<<(h->ps.sps->bit_depth_luma-1),
1576  1<<(h->ps.sps->bit_depth_chroma-1),
1577  1<<(h->ps.sps->bit_depth_chroma-1),
1578  -1
1579  };
1580 
1581  if (prev &&
1582  h->short_ref[0]->f->width == prev->f->width &&
1583  h->short_ref[0]->f->height == prev->f->height &&
1584  h->short_ref[0]->f->format == prev->f->format) {
1585  ff_thread_await_progress(&prev->tf, INT_MAX, 0);
1586  if (prev->field_picture)
1587  ff_thread_await_progress(&prev->tf, INT_MAX, 1);
1588  av_image_copy(h->short_ref[0]->f->data,
1589  h->short_ref[0]->f->linesize,
1590  (const uint8_t **)prev->f->data,
1591  prev->f->linesize,
1592  prev->f->format,
1593  prev->f->width,
1594  prev->f->height);
1595  h->short_ref[0]->poc = prev->poc + 2;
1596  } else if (!h->frame_recovered && !h->avctx->hwaccel)
1597  ff_color_frame(h->short_ref[0]->f, c);
1598  h->short_ref[0]->frame_num = h->poc.prev_frame_num;
1599  }
1600  }
1601 
1602  /* See if we have a decoded first field looking for a pair...
1603  * We're using that to see whether to continue decoding in that
1604  * frame, or to allocate a new one. */
1605  if (h->first_field) {
1606  av_assert0(h->cur_pic_ptr);
1607  av_assert0(h->cur_pic_ptr->f->buf[0]);
1608  assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1609 
1610  /* figure out if we have a complementary field pair */
1611  if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1612  /* Previous field is unmatched. Don't display it, but let it
1613  * remain for reference if marked as such. */
1614  h->missing_fields ++;
1615  h->cur_pic_ptr = NULL;
1616  h->first_field = FIELD_PICTURE(h);
1617  } else {
1618  h->missing_fields = 0;
1619  if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1622  /* This and the previous field had different frame_nums.
1623  * Consider this field first in pair. Throw away previous
1624  * one except for reference purposes. */
1625  h->first_field = 1;
1626  h->cur_pic_ptr = NULL;
1627  } else if (h->cur_pic_ptr->reference & DELAYED_PIC_REF) {
1628  /* This frame was already output, we cannot draw into it
1629  * anymore.
1630  */
1631  h->first_field = 1;
1632  h->cur_pic_ptr = NULL;
1633  } else {
1634  /* Second field in complementary pair */
1635  h->first_field = 0;
1636  }
1637  }
1638  } else {
1639  /* Frame or first field in a potentially complementary pair */
1640  h->first_field = FIELD_PICTURE(h);
1641  }
1642 
1643  if (!FIELD_PICTURE(h) || h->first_field) {
1644  if (h264_frame_start(h) < 0) {
1645  h->first_field = 0;
1646  return AVERROR_INVALIDDATA;
1647  }
1648  } else {
1651  h->cur_pic_ptr->tf.owner[field] = h->avctx;
1652  }
1653  /* Some macroblocks can be accessed before they're available in case
1654  * of lost slices, MBAFF or threading. */
1655  if (FIELD_PICTURE(h)) {
1656  for(i = (h->picture_structure == PICT_BOTTOM_FIELD); i<h->mb_height; i++)
1657  memset(h->slice_table + i*h->mb_stride, -1, (h->mb_stride - (i+1==h->mb_height)) * sizeof(*h->slice_table));
1658  } else {
1659  memset(h->slice_table, -1,
1660  (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
1661  }
1662 
1664  h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
1665  if (ret < 0)
1666  return ret;
1667 
1668  memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
1669  h->nb_mmco = sl->nb_mmco;
1671 
1672  h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
1673 
1674  if (h->sei.recovery_point.recovery_frame_cnt >= 0) {
1675  const int sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
1676 
1677  if (h->poc.frame_num != sei_recovery_frame_cnt || sl->slice_type_nos != AV_PICTURE_TYPE_I)
1678  h->valid_recovery_point = 1;
1679 
1680  if ( h->recovery_frame < 0
1681  || av_mod_uintp2(h->recovery_frame - h->poc.frame_num, h->ps.sps->log2_max_frame_num) > sei_recovery_frame_cnt) {
1682  h->recovery_frame = av_mod_uintp2(h->poc.frame_num + sei_recovery_frame_cnt, h->ps.sps->log2_max_frame_num);
1683 
1684  if (!h->valid_recovery_point)
1685  h->recovery_frame = h->poc.frame_num;
1686  }
1687  }
1688 
1689  h->cur_pic_ptr->f->key_frame |= (nal->type == H264_NAL_IDR_SLICE);
1690 
1691  if (nal->type == H264_NAL_IDR_SLICE ||
1692  (h->recovery_frame == h->poc.frame_num && nal->ref_idc)) {
1693  h->recovery_frame = -1;
1694  h->cur_pic_ptr->recovered = 1;
1695  }
1696  // If we have an IDR, all frames after it in decoded order are
1697  // "recovered".
1698  if (nal->type == H264_NAL_IDR_SLICE)
1700 #if 1
1702 #else
1704 #endif
1705 
1706  /* Set the frame properties/side data. Only done for the second field in
1707  * field coded frames, since some SEI information is present for each field
1708  * and is merged by the SEI parsing code. */
1709  if (!FIELD_PICTURE(h) || !h->first_field || h->missing_fields > 1) {
1710  ret = h264_export_frame_props(h);
1711  if (ret < 0)
1712  return ret;
1713 
1714  ret = h264_select_output_frame(h);
1715  if (ret < 0)
1716  return ret;
1717  }
1718 
1719  return 0;
1720 }
1721 
1723  const H2645NAL *nal)
1724 {
1725  const SPS *sps;
1726  const PPS *pps;
1727  int ret;
1728  unsigned int slice_type, tmp, i;
1729  int field_pic_flag, bottom_field_flag;
1730  int first_slice = sl == h->slice_ctx && !h->current_slice;
1731  int picture_structure;
1732 
1733  if (first_slice)
1735 
1736  sl->first_mb_addr = get_ue_golomb_long(&sl->gb);
1737 
1738  slice_type = get_ue_golomb_31(&sl->gb);
1739  if (slice_type > 9) {
1741  "slice type %d too large at %d\n",
1742  slice_type, sl->first_mb_addr);
1743  return AVERROR_INVALIDDATA;
1744  }
1745  if (slice_type > 4) {
1746  slice_type -= 5;
1747  sl->slice_type_fixed = 1;
1748  } else
1749  sl->slice_type_fixed = 0;
1750 
1751  slice_type = ff_h264_golomb_to_pict_type[slice_type];
1752  sl->slice_type = slice_type;
1753  sl->slice_type_nos = slice_type & 3;
1754 
1755  if (nal->type == H264_NAL_IDR_SLICE &&
1757  av_log(h->avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
1758  return AVERROR_INVALIDDATA;
1759  }
1760 
1761  sl->pps_id = get_ue_golomb(&sl->gb);
1762  if (sl->pps_id >= MAX_PPS_COUNT) {
1763  av_log(h->avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
1764  return AVERROR_INVALIDDATA;
1765  }
1766  if (!h->ps.pps_list[sl->pps_id]) {
1768  "non-existing PPS %u referenced\n",
1769  sl->pps_id);
1770  return AVERROR_INVALIDDATA;
1771  }
1772  pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
1773  sps = pps->sps;
1774 
1775  sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
1776  if (!first_slice) {
1777  if (h->poc.frame_num != sl->frame_num) {
1778  av_log(h->avctx, AV_LOG_ERROR, "Frame num change from %d to %d\n",
1779  h->poc.frame_num, sl->frame_num);
1780  return AVERROR_INVALIDDATA;
1781  }
1782  }
1783 
1784  sl->mb_mbaff = 0;
1785 
1786  if (sps->frame_mbs_only_flag) {
1787  picture_structure = PICT_FRAME;
1788  } else {
1789  if (!sps->direct_8x8_inference_flag && slice_type == AV_PICTURE_TYPE_B) {
1790  av_log(h->avctx, AV_LOG_ERROR, "This stream was generated by a broken encoder, invalid 8x8 inference\n");
1791  return -1;
1792  }
1793  field_pic_flag = get_bits1(&sl->gb);
1794  if (field_pic_flag) {
1795  bottom_field_flag = get_bits1(&sl->gb);
1796  picture_structure = PICT_TOP_FIELD + bottom_field_flag;
1797  } else {
1798  picture_structure = PICT_FRAME;
1799  }
1800  }
1801  sl->picture_structure = picture_structure;
1802  sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
1803 
1804  if (picture_structure == PICT_FRAME) {
1805  sl->curr_pic_num = sl->frame_num;
1806  sl->max_pic_num = 1 << sps->log2_max_frame_num;
1807  } else {
1808  sl->curr_pic_num = 2 * sl->frame_num + 1;
1809  sl->max_pic_num = 1 << (sps->log2_max_frame_num + 1);
1810  }
1811 
1812  if (nal->type == H264_NAL_IDR_SLICE)
1813  get_ue_golomb_long(&sl->gb); /* idr_pic_id */
1814 
1815  if (sps->poc_type == 0) {
1816  sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
1817 
1818  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1819  sl->delta_poc_bottom = get_se_golomb(&sl->gb);
1820  }
1821 
1822  if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
1823  sl->delta_poc[0] = get_se_golomb(&sl->gb);
1824 
1825  if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1826  sl->delta_poc[1] = get_se_golomb(&sl->gb);
1827  }
1828 
1829  sl->redundant_pic_count = 0;
1830  if (pps->redundant_pic_cnt_present)
1831  sl->redundant_pic_count = get_ue_golomb(&sl->gb);
1832 
1833  if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
1834  sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
1835 
1837  &sl->gb, pps, sl->slice_type_nos,
1838  picture_structure, h->avctx);
1839  if (ret < 0)
1840  return ret;
1841 
1842  if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1844  if (ret < 0) {
1845  sl->ref_count[1] = sl->ref_count[0] = 0;
1846  return ret;
1847  }
1848  }
1849 
1850  sl->pwt.use_weight = 0;
1851  for (i = 0; i < 2; i++) {
1852  sl->pwt.luma_weight_flag[i] = 0;
1853  sl->pwt.chroma_weight_flag[i] = 0;
1854  }
1855  if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
1856  (pps->weighted_bipred_idc == 1 &&
1858  ret = ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
1859  sl->slice_type_nos, &sl->pwt,
1860  picture_structure, h->avctx);
1861  if (ret < 0)
1862  return ret;
1863  }
1864 
1865  sl->explicit_ref_marking = 0;
1866  if (nal->ref_idc) {
1867  ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, h->avctx);
1868  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1869  return AVERROR_INVALIDDATA;
1870  }
1871 
1872  if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
1873  tmp = get_ue_golomb_31(&sl->gb);
1874  if (tmp > 2) {
1875  av_log(h->avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
1876  return AVERROR_INVALIDDATA;
1877  }
1878  sl->cabac_init_idc = tmp;
1879  }
1880 
1881  sl->last_qscale_diff = 0;
1882  tmp = pps->init_qp + (unsigned)get_se_golomb(&sl->gb);
1883  if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
1884  av_log(h->avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
1885  return AVERROR_INVALIDDATA;
1886  }
1887  sl->qscale = tmp;
1888  sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
1889  sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
1890  // FIXME qscale / qp ... stuff
1891  if (sl->slice_type == AV_PICTURE_TYPE_SP)
1892  get_bits1(&sl->gb); /* sp_for_switch_flag */
1893  if (sl->slice_type == AV_PICTURE_TYPE_SP ||
1895  get_se_golomb(&sl->gb); /* slice_qs_delta */
1896 
1897  sl->deblocking_filter = 1;
1898  sl->slice_alpha_c0_offset = 0;
1899  sl->slice_beta_offset = 0;
1901  tmp = get_ue_golomb_31(&sl->gb);
1902  if (tmp > 2) {
1904  "deblocking_filter_idc %u out of range\n", tmp);
1905  return AVERROR_INVALIDDATA;
1906  }
1907  sl->deblocking_filter = tmp;
1908  if (sl->deblocking_filter < 2)
1909  sl->deblocking_filter ^= 1; // 1<->0
1910 
1911  if (sl->deblocking_filter) {
1912  int slice_alpha_c0_offset_div2 = get_se_golomb(&sl->gb);
1913  int slice_beta_offset_div2 = get_se_golomb(&sl->gb);
1914  if (slice_alpha_c0_offset_div2 > 6 ||
1915  slice_alpha_c0_offset_div2 < -6 ||
1916  slice_beta_offset_div2 > 6 ||
1917  slice_beta_offset_div2 < -6) {
1919  "deblocking filter parameters %d %d out of range\n",
1920  slice_alpha_c0_offset_div2, slice_beta_offset_div2);
1921  return AVERROR_INVALIDDATA;
1922  }
1923  sl->slice_alpha_c0_offset = slice_alpha_c0_offset_div2 * 2;
1924  sl->slice_beta_offset = slice_beta_offset_div2 * 2;
1925  }
1926  }
1927 
1928  return 0;
1929 }
1930 
1931 /* do all the per-slice initialization needed before we can start decoding the
1932  * actual MBs */
1934  const H2645NAL *nal)
1935 {
1936  int i, j, ret = 0;
1937 
1938  if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
1939  av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
1940  return AVERROR_INVALIDDATA;
1941  }
1942 
1943  av_assert1(h->mb_num == h->mb_width * h->mb_height);
1944  if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
1945  sl->first_mb_addr >= h->mb_num) {
1946  av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
1947  return AVERROR_INVALIDDATA;
1948  }
1949  sl->resync_mb_x = sl->mb_x = sl->first_mb_addr % h->mb_width;
1950  sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
1953  sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
1954  av_assert1(sl->mb_y < h->mb_height);
1955 
1956  ret = ff_h264_build_ref_list(h, sl);
1957  if (ret < 0)
1958  return ret;
1959 
1960  if (h->ps.pps->weighted_bipred_idc == 2 &&
1962  implicit_weight_table(h, sl, -1);
1963  if (FRAME_MBAFF(h)) {
1964  implicit_weight_table(h, sl, 0);
1965  implicit_weight_table(h, sl, 1);
1966  }
1967  }
1968 
1971  if (!h->setup_finished)
1973 
1974  if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
1982  nal->ref_idc == 0))
1983  sl->deblocking_filter = 0;
1984 
1985  if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
1986  if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1987  /* Cheat slightly for speed:
1988  * Do not bother to deblock across slices. */
1989  sl->deblocking_filter = 2;
1990  } else {
1991  h->postpone_filter = 1;
1992  }
1993  }
1994  sl->qp_thresh = 15 -
1996  FFMAX3(0,
1997  h->ps.pps->chroma_qp_index_offset[0],
1998  h->ps.pps->chroma_qp_index_offset[1]) +
1999  6 * (h->ps.sps->bit_depth_luma - 8);
2000 
2001  sl->slice_num = ++h->current_slice;
2002 
2003  if (sl->slice_num)
2004  h->slice_row[(sl->slice_num-1)&(MAX_SLICES-1)]= sl->resync_mb_y;
2005  if ( h->slice_row[sl->slice_num&(MAX_SLICES-1)] + 3 >= sl->resync_mb_y
2006  && h->slice_row[sl->slice_num&(MAX_SLICES-1)] <= sl->resync_mb_y
2007  && sl->slice_num >= MAX_SLICES) {
2008  //in case of ASO this check needs to be updated depending on how we decide to assign slice numbers in this case
2009  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);
2010  }
2011 
2012  for (j = 0; j < 2; j++) {
2013  int id_list[16];
2014  int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
2015  for (i = 0; i < 16; i++) {
2016  id_list[i] = 60;
2017  if (j < sl->list_count && i < sl->ref_count[j] &&
2018  sl->ref_list[j][i].parent->f->buf[0]) {
2019  int k;
2020  AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
2021  for (k = 0; k < h->short_ref_count; k++)
2022  if (h->short_ref[k]->f->buf[0]->buffer == buf) {
2023  id_list[i] = k;
2024  break;
2025  }
2026  for (k = 0; k < h->long_ref_count; k++)
2027  if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
2028  id_list[i] = h->short_ref_count + k;
2029  break;
2030  }
2031  }
2032  }
2033 
2034  ref2frm[0] =
2035  ref2frm[1] = -1;
2036  for (i = 0; i < 16; i++)
2037  ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
2038  ref2frm[18 + 0] =
2039  ref2frm[18 + 1] = -1;
2040  for (i = 16; i < 48; i++)
2041  ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
2042  (sl->ref_list[j][i].reference & 3);
2043  }
2044 
2045  if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
2047  "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",
2048  sl->slice_num,
2049  (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
2050  sl->mb_y * h->mb_width + sl->mb_x,
2052  sl->slice_type_fixed ? " fix" : "",
2053  nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
2054  h->poc.frame_num,
2055  h->cur_pic_ptr->field_poc[0],
2056  h->cur_pic_ptr->field_poc[1],
2057  sl->ref_count[0], sl->ref_count[1],
2058  sl->qscale,
2059  sl->deblocking_filter,
2061  sl->pwt.use_weight,
2062  sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
2063  sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
2064  }
2065 
2066  return 0;
2067 }
2068 
2070 {
2072  int first_slice = sl == h->slice_ctx && !h->current_slice;
2073  int ret;
2074 
2075  sl->gb = nal->gb;
2076 
2077  ret = h264_slice_header_parse(h, sl, nal);
2078  if (ret < 0)
2079  return ret;
2080 
2081  // discard redundant pictures
2082  if (sl->redundant_pic_count > 0) {
2083  sl->ref_count[0] = sl->ref_count[1] = 0;
2084  return 0;
2085  }
2086 
2087  if (sl->first_mb_addr == 0 || !h->current_slice) {
2088  if (h->setup_finished) {
2089  av_log(h->avctx, AV_LOG_ERROR, "Too many fields\n");
2090  return AVERROR_INVALIDDATA;
2091  }
2092  }
2093 
2094  if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
2095  if (h->current_slice) {
2096  // this slice starts a new field
2097  // first decode any pending queued slices
2098  if (h->nb_slice_ctx_queued) {
2099  H264SliceContext tmp_ctx;
2100 
2102  if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
2103  return ret;
2104 
2105  memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
2106  memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
2107  memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
2108  sl = h->slice_ctx;
2109  }
2110 
2111  if (h->cur_pic_ptr && FIELD_PICTURE(h) && h->first_field) {
2112  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2113  if (ret < 0)
2114  return ret;
2115  } else if (h->cur_pic_ptr && !FIELD_PICTURE(h) && !h->first_field && h->nal_unit_type == H264_NAL_IDR_SLICE) {
2116  av_log(h, AV_LOG_WARNING, "Broken frame packetizing\n");
2117  ret = ff_h264_field_end(h, h->slice_ctx, 1);
2118  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
2119  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
2120  h->cur_pic_ptr = NULL;
2121  if (ret < 0)
2122  return ret;
2123  } else
2124  return AVERROR_INVALIDDATA;
2125  }
2126 
2127  if (!h->first_field) {
2128  if (h->cur_pic_ptr && !h->droppable) {
2131  }
2132  h->cur_pic_ptr = NULL;
2133  }
2134  }
2135 
2136  if (!h->current_slice)
2137  av_assert0(sl == h->slice_ctx);
2138 
2139  if (h->current_slice == 0 && !h->first_field) {
2140  if (
2141  (h->avctx->skip_frame >= AVDISCARD_NONREF && !h->nal_ref_idc) ||
2145  h->avctx->skip_frame >= AVDISCARD_ALL) {
2146  return 0;
2147  }
2148  }
2149 
2150  if (!first_slice) {
2151  const PPS *pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
2152 
2153  if (h->ps.pps->sps_id != pps->sps_id ||
2154  h->ps.pps->transform_8x8_mode != pps->transform_8x8_mode /*||
2155  (h->setup_finished && h->ps.pps != pps)*/) {
2156  av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
2157  return AVERROR_INVALIDDATA;
2158  }
2159  if (h->ps.sps != pps->sps) {
2161  "SPS changed in the middle of the frame\n");
2162  return AVERROR_INVALIDDATA;
2163  }
2164  }
2165 
2166  if (h->current_slice == 0) {
2167  ret = h264_field_start(h, sl, nal, first_slice);
2168  if (ret < 0)
2169  return ret;
2170  } else {
2171  if (h->picture_structure != sl->picture_structure ||
2172  h->droppable != (nal->ref_idc == 0)) {
2174  "Changing field mode (%d -> %d) between slices is not allowed\n",
2176  return AVERROR_INVALIDDATA;
2177  } else if (!h->cur_pic_ptr) {
2179  "unset cur_pic_ptr on slice %d\n",
2180  h->current_slice + 1);
2181  return AVERROR_INVALIDDATA;
2182  }
2183  }
2184 
2185  ret = h264_slice_init(h, sl, nal);
2186  if (ret < 0)
2187  return ret;
2188 
2189  h->nb_slice_ctx_queued++;
2190 
2191  return 0;
2192 }
2193 
2195 {
2196  switch (sl->slice_type) {
2197  case AV_PICTURE_TYPE_P:
2198  return 0;
2199  case AV_PICTURE_TYPE_B:
2200  return 1;
2201  case AV_PICTURE_TYPE_I:
2202  return 2;
2203  case AV_PICTURE_TYPE_SP:
2204  return 3;
2205  case AV_PICTURE_TYPE_SI:
2206  return 4;
2207  default:
2208  return AVERROR_INVALIDDATA;
2209  }
2210 }
2211 
2213  H264SliceContext *sl,
2214  int mb_type, int top_xy,
2215  int left_xy[LEFT_MBS],
2216  int top_type,
2217  int left_type[LEFT_MBS],
2218  int mb_xy, int list)
2219 {
2220  int b_stride = h->b_stride;
2221  int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
2222  int8_t *ref_cache = &sl->ref_cache[list][scan8[0]];
2223  if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
2224  if (USES_LIST(top_type, list)) {
2225  const int b_xy = h->mb2b_xy[top_xy] + 3 * b_stride;
2226  const int b8_xy = 4 * top_xy + 2;
2227  const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2228  AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
2229  ref_cache[0 - 1 * 8] =
2230  ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
2231  ref_cache[2 - 1 * 8] =
2232  ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
2233  } else {
2234  AV_ZERO128(mv_dst - 1 * 8);
2235  AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2236  }
2237 
2238  if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
2239  if (USES_LIST(left_type[LTOP], list)) {
2240  const int b_xy = h->mb2b_xy[left_xy[LTOP]] + 3;
2241  const int b8_xy = 4 * left_xy[LTOP] + 1;
2242  const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2243  AV_COPY32(mv_dst - 1 + 0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
2244  AV_COPY32(mv_dst - 1 + 8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
2245  AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
2246  AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
2247  ref_cache[-1 + 0] =
2248  ref_cache[-1 + 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
2249  ref_cache[-1 + 16] =
2250  ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
2251  } else {
2252  AV_ZERO32(mv_dst - 1 + 0);
2253  AV_ZERO32(mv_dst - 1 + 8);
2254  AV_ZERO32(mv_dst - 1 + 16);
2255  AV_ZERO32(mv_dst - 1 + 24);
2256  ref_cache[-1 + 0] =
2257  ref_cache[-1 + 8] =
2258  ref_cache[-1 + 16] =
2259  ref_cache[-1 + 24] = LIST_NOT_USED;
2260  }
2261  }
2262  }
2263 
2264  if (!USES_LIST(mb_type, list)) {
2265  fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
2266  AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2267  AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2268  AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2269  AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2270  return;
2271  }
2272 
2273  {
2274  int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
2275  const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2276  uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
2277  uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
2278  AV_WN32A(&ref_cache[0 * 8], ref01);
2279  AV_WN32A(&ref_cache[1 * 8], ref01);
2280  AV_WN32A(&ref_cache[2 * 8], ref23);
2281  AV_WN32A(&ref_cache[3 * 8], ref23);
2282  }
2283 
2284  {
2285  int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
2286  AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
2287  AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
2288  AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
2289  AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
2290  }
2291 }
2292 
2293 /**
2294  * @return non zero if the loop filter can be skipped
2295  */
2296 static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
2297 {
2298  const int mb_xy = sl->mb_xy;
2299  int top_xy, left_xy[LEFT_MBS];
2300  int top_type, left_type[LEFT_MBS];
2301  uint8_t *nnz;
2302  uint8_t *nnz_cache;
2303 
2304  top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
2305 
2306  left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
2307  if (FRAME_MBAFF(h)) {
2308  const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
2309  const int curr_mb_field_flag = IS_INTERLACED(mb_type);
2310  if (sl->mb_y & 1) {
2311  if (left_mb_field_flag != curr_mb_field_flag)
2312  left_xy[LTOP] -= h->mb_stride;
2313  } else {
2314  if (curr_mb_field_flag)
2315  top_xy += h->mb_stride &
2316  (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
2317  if (left_mb_field_flag != curr_mb_field_flag)
2318  left_xy[LBOT] += h->mb_stride;
2319  }
2320  }
2321 
2322  sl->top_mb_xy = top_xy;
2323  sl->left_mb_xy[LTOP] = left_xy[LTOP];
2324  sl->left_mb_xy[LBOT] = left_xy[LBOT];
2325  {
2326  /* For sufficiently low qp, filtering wouldn't do anything.
2327  * This is a conservative estimate: could also check beta_offset
2328  * and more accurate chroma_qp. */
2329  int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
2330  int qp = h->cur_pic.qscale_table[mb_xy];
2331  if (qp <= qp_thresh &&
2332  (left_xy[LTOP] < 0 ||
2333  ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
2334  (top_xy < 0 ||
2335  ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
2336  if (!FRAME_MBAFF(h))
2337  return 1;
2338  if ((left_xy[LTOP] < 0 ||
2339  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
2340  (top_xy < h->mb_stride ||
2341  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
2342  return 1;
2343  }
2344  }
2345 
2346  top_type = h->cur_pic.mb_type[top_xy];
2347  left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
2348  left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
2349  if (sl->deblocking_filter == 2) {
2350  if (h->slice_table[top_xy] != sl->slice_num)
2351  top_type = 0;
2352  if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
2353  left_type[LTOP] = left_type[LBOT] = 0;
2354  } else {
2355  if (h->slice_table[top_xy] == 0xFFFF)
2356  top_type = 0;
2357  if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
2358  left_type[LTOP] = left_type[LBOT] = 0;
2359  }
2360  sl->top_type = top_type;
2361  sl->left_type[LTOP] = left_type[LTOP];
2362  sl->left_type[LBOT] = left_type[LBOT];
2363 
2364  if (IS_INTRA(mb_type))
2365  return 0;
2366 
2367  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2368  top_type, left_type, mb_xy, 0);
2369  if (sl->list_count == 2)
2370  fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2371  top_type, left_type, mb_xy, 1);
2372 
2373  nnz = h->non_zero_count[mb_xy];
2374  nnz_cache = sl->non_zero_count_cache;
2375  AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
2376  AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
2377  AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
2378  AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
2379  sl->cbp = h->cbp_table[mb_xy];
2380 
2381  if (top_type) {
2382  nnz = h->non_zero_count[top_xy];
2383  AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
2384  }
2385 
2386  if (left_type[LTOP]) {
2387  nnz = h->non_zero_count[left_xy[LTOP]];
2388  nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
2389  nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
2390  nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
2391  nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
2392  }
2393 
2394  /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
2395  * from what the loop filter needs */
2396  if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
2397  if (IS_8x8DCT(top_type)) {
2398  nnz_cache[4 + 8 * 0] =
2399  nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
2400  nnz_cache[6 + 8 * 0] =
2401  nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
2402  }
2403  if (IS_8x8DCT(left_type[LTOP])) {
2404  nnz_cache[3 + 8 * 1] =
2405  nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
2406  }
2407  if (IS_8x8DCT(left_type[LBOT])) {
2408  nnz_cache[3 + 8 * 3] =
2409  nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
2410  }
2411 
2412  if (IS_8x8DCT(mb_type)) {
2413  nnz_cache[scan8[0]] =
2414  nnz_cache[scan8[1]] =
2415  nnz_cache[scan8[2]] =
2416  nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
2417 
2418  nnz_cache[scan8[0 + 4]] =
2419  nnz_cache[scan8[1 + 4]] =
2420  nnz_cache[scan8[2 + 4]] =
2421  nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
2422 
2423  nnz_cache[scan8[0 + 8]] =
2424  nnz_cache[scan8[1 + 8]] =
2425  nnz_cache[scan8[2 + 8]] =
2426  nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
2427 
2428  nnz_cache[scan8[0 + 12]] =
2429  nnz_cache[scan8[1 + 12]] =
2430  nnz_cache[scan8[2 + 12]] =
2431  nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
2432  }
2433  }
2434 
2435  return 0;
2436 }
2437 
2438 static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
2439 {
2440  uint8_t *dest_y, *dest_cb, *dest_cr;
2441  int linesize, uvlinesize, mb_x, mb_y;
2442  const int end_mb_y = sl->mb_y + FRAME_MBAFF(h);
2443  const int old_slice_type = sl->slice_type;
2444  const int pixel_shift = h->pixel_shift;
2445  const int block_h = 16 >> h->chroma_y_shift;
2446 
2447  if (h->postpone_filter)
2448  return;
2449 
2450  if (sl->deblocking_filter) {
2451  for (mb_x = start_x; mb_x < end_x; mb_x++)
2452  for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
2453  int mb_xy, mb_type;
2454  mb_xy = sl->mb_xy = mb_x + mb_y * h->mb_stride;
2455  mb_type = h->cur_pic.mb_type[mb_xy];
2456 
2457  if (FRAME_MBAFF(h))
2458  sl->mb_mbaff =
2459  sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2460 
2461  sl->mb_x = mb_x;
2462  sl->mb_y = mb_y;
2463  dest_y = h->cur_pic.f->data[0] +
2464  ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
2465  dest_cb = h->cur_pic.f->data[1] +
2466  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2467  mb_y * sl->uvlinesize * block_h;
2468  dest_cr = h->cur_pic.f->data[2] +
2469  (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2470  mb_y * sl->uvlinesize * block_h;
2471  // FIXME simplify above
2472 
2473  if (MB_FIELD(sl)) {
2474  linesize = sl->mb_linesize = sl->linesize * 2;
2475  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
2476  if (mb_y & 1) { // FIXME move out of this function?
2477  dest_y -= sl->linesize * 15;
2478  dest_cb -= sl->uvlinesize * (block_h - 1);
2479  dest_cr -= sl->uvlinesize * (block_h - 1);
2480  }
2481  } else {
2482  linesize = sl->mb_linesize = sl->linesize;
2483  uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
2484  }
2485  backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
2486  uvlinesize, 0);
2487  if (fill_filter_caches(h, sl, mb_type))
2488  continue;
2489  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
2490  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
2491 
2492  if (FRAME_MBAFF(h)) {
2493  ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
2494  linesize, uvlinesize);
2495  } else {
2496  ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
2497  dest_cr, linesize, uvlinesize);
2498  }
2499  }
2500  }
2501  sl->slice_type = old_slice_type;
2502  sl->mb_x = end_x;
2503  sl->mb_y = end_mb_y - FRAME_MBAFF(h);
2504  sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
2505  sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
2506 }
2507 
2509 {
2510  const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
2511  int mb_type = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
2512  h->cur_pic.mb_type[mb_xy - 1] :
2513  (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
2514  h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
2515  sl->mb_mbaff = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2516 }
2517 
2518 /**
2519  * Draw edges and report progress for the last MB row.
2520  */
2522 {
2523  int top = 16 * (sl->mb_y >> FIELD_PICTURE(h));
2524  int pic_height = 16 * h->mb_height >> FIELD_PICTURE(h);
2525  int height = 16 << FRAME_MBAFF(h);
2526  int deblock_border = (16 + 4) << FRAME_MBAFF(h);
2527 
2528  if (sl->deblocking_filter) {
2529  if ((top + height) >= pic_height)
2530  height += deblock_border;
2531  top -= deblock_border;
2532  }
2533 
2534  if (top >= pic_height || (top + height) < 0)
2535  return;
2536 
2537  height = FFMIN(height, pic_height - top);
2538  if (top < 0) {
2539  height = top + height;
2540  top = 0;
2541  }
2542 
2543  ff_h264_draw_horiz_band(h, sl, top, height);
2544 
2545  if (h->droppable || sl->h264->slice_ctx[0].er.error_occurred)
2546  return;
2547 
2548  ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
2550 }
2551 
2553  int startx, int starty,
2554  int endx, int endy, int status)
2555 {
2556  if (!sl->h264->enable_er)
2557  return;
2558 
2559  if (CONFIG_ERROR_RESILIENCE) {
2560  ERContext *er = &sl->h264->slice_ctx[0].er;
2561 
2562  ff_er_add_slice(er, startx, starty, endx, endy, status);
2563  }
2564 }
2565 
2566 static int decode_slice(struct AVCodecContext *avctx, void *arg)
2567 {
2568  H264SliceContext *sl = arg;
2569  const H264Context *h = sl->h264;
2570  int lf_x_start = sl->mb_x;
2571  int orig_deblock = sl->deblocking_filter;
2572  int ret;
2573 
2574  sl->linesize = h->cur_pic_ptr->f->linesize[0];
2575  sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
2576 
2577  ret = alloc_scratch_buffers(sl, sl->linesize);
2578  if (ret < 0)
2579  return ret;
2580 
2581  sl->mb_skip_run = -1;
2582 
2583  av_assert0(h->block_offset[15] == (4 * ((scan8[15] - scan8[0]) & 7) << h->pixel_shift) + 4 * sl->linesize * ((scan8[15] - scan8[0]) >> 3));
2584 
2585  if (h->postpone_filter)
2586  sl->deblocking_filter = 0;
2587 
2588  sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
2589  (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
2590 
2592  const int start_i = av_clip(sl->resync_mb_x + sl->resync_mb_y * h->mb_width, 0, h->mb_num - 1);
2593  if (start_i) {
2594  int prev_status = h->slice_ctx[0].er.error_status_table[h->slice_ctx[0].er.mb_index2xy[start_i - 1]];
2595  prev_status &= ~ VP_START;
2596  if (prev_status != (ER_MV_END | ER_DC_END | ER_AC_END))
2597  h->slice_ctx[0].er.error_occurred = 1;
2598  }
2599  }
2600 
2601  if (h->ps.pps->cabac) {
2602  /* realign */
2603  align_get_bits(&sl->gb);
2604 
2605  /* init cabac */
2606  ret = ff_init_cabac_decoder(&sl->cabac,
2607  sl->gb.buffer + get_bits_count(&sl->gb) / 8,
2608  (get_bits_left(&sl->gb) + 7) / 8);
2609  if (ret < 0)
2610  return ret;
2611 
2613 
2614  for (;;) {
2615  int ret, eos;
2616  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2617  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2618  sl->next_slice_idx);
2619  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2620  sl->mb_y, ER_MB_ERROR);
2621  return AVERROR_INVALIDDATA;
2622  }
2623 
2624  ret = ff_h264_decode_mb_cabac(h, sl);
2625 
2626  if (ret >= 0)
2627  ff_h264_hl_decode_mb(h, sl);
2628 
2629  // FIXME optimal? or let mb_decode decode 16x32 ?
2630  if (ret >= 0 && FRAME_MBAFF(h)) {
2631  sl->mb_y++;
2632 
2633  ret = ff_h264_decode_mb_cabac(h, sl);
2634 
2635  if (ret >= 0)
2636  ff_h264_hl_decode_mb(h, sl);
2637  sl->mb_y--;
2638  }
2639  eos = get_cabac_terminate(&sl->cabac);
2640 
2641  if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
2642  sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
2643  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2644  sl->mb_y, ER_MB_END);
2645  if (sl->mb_x >= lf_x_start)
2646  loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
2647  goto finish;
2648  }
2649  if (sl->cabac.bytestream > sl->cabac.bytestream_end + 2 )
2650  av_log(h->avctx, AV_LOG_DEBUG, "bytestream overread %"PTRDIFF_SPECIFIER"\n", sl->cabac.bytestream_end - sl->cabac.bytestream);
2651  if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 4) {
2653  "error while decoding MB %d %d, bytestream %"PTRDIFF_SPECIFIER"\n",
2654  sl->mb_x, sl->mb_y,
2655  sl->cabac.bytestream_end - sl->cabac.bytestream);
2656  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2657  sl->mb_y, ER_MB_ERROR);
2658  return AVERROR_INVALIDDATA;
2659  }
2660 
2661  if (++sl->mb_x >= h->mb_width) {
2662  loop_filter(h, sl, lf_x_start, sl->mb_x);
2663  sl->mb_x = lf_x_start = 0;
2664  decode_finish_row(h, sl);
2665  ++sl->mb_y;
2666  if (FIELD_OR_MBAFF_PICTURE(h)) {
2667  ++sl->mb_y;
2668  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2670  }
2671  }
2672 
2673  if (eos || sl->mb_y >= h->mb_height) {
2674  ff_tlog(h->avctx, "slice end %d %d\n",
2675  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2676  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2677  sl->mb_y, ER_MB_END);
2678  if (sl->mb_x > lf_x_start)
2679  loop_filter(h, sl, lf_x_start, sl->mb_x);
2680  goto finish;
2681  }
2682  }
2683  } else {
2684  for (;;) {
2685  int ret;
2686 
2687  if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2688  av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2689  sl->next_slice_idx);
2690  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2691  sl->mb_y, ER_MB_ERROR);
2692  return AVERROR_INVALIDDATA;
2693  }
2694 
2695  ret = ff_h264_decode_mb_cavlc(h, sl);
2696 
2697  if (ret >= 0)
2698  ff_h264_hl_decode_mb(h, sl);
2699 
2700  // FIXME optimal? or let mb_decode decode 16x32 ?
2701  if (ret >= 0 && FRAME_MBAFF(h)) {
2702  sl->mb_y++;
2703  ret = ff_h264_decode_mb_cavlc(h, sl);
2704 
2705  if (ret >= 0)
2706  ff_h264_hl_decode_mb(h, sl);
2707  sl->mb_y--;
2708  }
2709 
2710  if (ret < 0) {
2712  "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
2713  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2714  sl->mb_y, ER_MB_ERROR);
2715  return ret;
2716  }
2717 
2718  if (++sl->mb_x >= h->mb_width) {
2719  loop_filter(h, sl, lf_x_start, sl->mb_x);
2720  sl->mb_x = lf_x_start = 0;
2721  decode_finish_row(h, sl);
2722  ++sl->mb_y;
2723  if (FIELD_OR_MBAFF_PICTURE(h)) {
2724  ++sl->mb_y;
2725  if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2727  }
2728  if (sl->mb_y >= h->mb_height) {
2729  ff_tlog(h->avctx, "slice end %d %d\n",
2730  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2731 
2732  if ( get_bits_left(&sl->gb) == 0
2733  || get_bits_left(&sl->gb) > 0 && !(h->avctx->err_recognition & AV_EF_AGGRESSIVE)) {
2734  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2735  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2736 
2737  goto finish;
2738  } else {
2739  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2740  sl->mb_x, sl->mb_y, ER_MB_END);
2741 
2742  return AVERROR_INVALIDDATA;
2743  }
2744  }
2745  }
2746 
2747  if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
2748  ff_tlog(h->avctx, "slice end %d %d\n",
2749  get_bits_count(&sl->gb), sl->gb.size_in_bits);
2750 
2751  if (get_bits_left(&sl->gb) == 0) {
2752  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2753  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2754  if (sl->mb_x > lf_x_start)
2755  loop_filter(h, sl, lf_x_start, sl->mb_x);
2756 
2757  goto finish;
2758  } else {
2759  er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2760  sl->mb_y, ER_MB_ERROR);
2761 
2762  return AVERROR_INVALIDDATA;
2763  }
2764  }
2765  }
2766  }
2767 
2768 finish:
2769  sl->deblocking_filter = orig_deblock;
2770  return 0;
2771 }
2772 
2773 /**
2774  * Call decode_slice() for each context.
2775  *
2776  * @param h h264 master context
2777  */
2779 {
2780  AVCodecContext *const avctx = h->avctx;
2781  H264SliceContext *sl;
2782  int context_count = h->nb_slice_ctx_queued;
2783  int ret = 0;
2784  int i, j;
2785 
2786  h->slice_ctx[0].next_slice_idx = INT_MAX;
2787 
2788  if (h->avctx->hwaccel || context_count < 1)
2789  return 0;
2790 
2791  av_assert0(context_count && h->slice_ctx[context_count - 1].mb_y < h->mb_height);
2792 
2793  if (context_count == 1) {
2794 
2795  h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
2796  h->postpone_filter = 0;
2797 
2798  ret = decode_slice(avctx, &h->slice_ctx[0]);
2799  h->mb_y = h->slice_ctx[0].mb_y;
2800  if (ret < 0)
2801  goto finish;
2802  } else {
2803  av_assert0(context_count > 0);
2804  for (i = 0; i < context_count; i++) {
2805  int next_slice_idx = h->mb_width * h->mb_height;
2806  int slice_idx;
2807 
2808  sl = &h->slice_ctx[i];
2809  if (CONFIG_ERROR_RESILIENCE) {
2810  sl->er.error_count = 0;
2811  }
2812 
2813  /* make sure none of those slices overlap */
2814  slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
2815  for (j = 0; j < context_count; j++) {
2816  H264SliceContext *sl2 = &h->slice_ctx[j];
2817  int slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
2818 
2819  if (i == j || slice_idx2 < slice_idx)
2820  continue;
2821  next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
2822  }
2823  sl->next_slice_idx = next_slice_idx;
2824  }
2825 
2826  avctx->execute(avctx, decode_slice, h->slice_ctx,
2827  NULL, context_count, sizeof(h->slice_ctx[0]));
2828 
2829  /* pull back stuff from slices to master context */
2830  sl = &h->slice_ctx[context_count - 1];
2831  h->mb_y = sl->mb_y;
2832  if (CONFIG_ERROR_RESILIENCE) {
2833  for (i = 1; i < context_count; i++)
2835  }
2836 
2837  if (h->postpone_filter) {
2838  h->postpone_filter = 0;
2839 
2840  for (i = 0; i < context_count; i++) {
2841  int y_end, x_end;
2842 
2843  sl = &h->slice_ctx[i];
2844  y_end = FFMIN(sl->mb_y + 1, h->mb_height);
2845  x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
2846 
2847  for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
2848  sl->mb_y = j;
2849  loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
2850  j == y_end - 1 ? x_end : h->mb_width);
2851  }
2852  }
2853  }
2854  }
2855 
2856 finish:
2857  h->nb_slice_ctx_queued = 0;
2858  return ret;
2859 }
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:2069
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
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:239
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:2521
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:2778
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:61
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:413
#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:120
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
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:2296
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:2194
#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:387
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:1436
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:2552
#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:695
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
#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:1333
#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:105
#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:120
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:1722
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
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:727
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:276
#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:275
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:1933
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:239
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:2508
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:84
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:2212
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:337
#define ER_AC_END
static int decode_slice(struct AVCodecContext *avctx, void *arg)
Definition: h264_slice.c:2566
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:2438
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:406
#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 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