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 
138  av_fast_mallocz(&sl->top_borders[0], &sl->top_borders_allocated[0],
139  h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
140  av_fast_mallocz(&sl->top_borders[1], &sl->top_borders_allocated[1],
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]) {
145  av_freep(&sl->bipred_scratchpad);
146  av_freep(&sl->edge_emu_buffer);
147  av_freep(&sl->top_borders[0]);
148  av_freep(&sl->top_borders[1]);
149 
150  sl->bipred_scratchpad_allocated = 0;
151  sl->edge_emu_buffer_allocated = 0;
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 
160 static int init_table_pools(H264Context *h)
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,
168  av_buffer_allocz);
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) {
177  av_buffer_pool_uninit(&h->qscale_table_pool);
178  av_buffer_pool_uninit(&h->mb_type_pool);
179  av_buffer_pool_uninit(&h->motion_val_pool);
180  av_buffer_pool_uninit(&h->ref_index_pool);
181  return AVERROR(ENOMEM);
182  }
183 
184  return 0;
185 }
186 
187 static int alloc_picture(H264Context *h, H264Picture *pic)
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 ?
195  AV_GET_BUFFER_FLAG_REF : 0);
196  if (ret < 0)
197  goto fail;
198 
199  if (h->avctx->hwaccel) {
200  const AVHWAccel *hwaccel = h->avctx->hwaccel;
201  av_assert0(!pic->hwaccel_picture_private);
202  if (hwaccel->frame_priv_data_size) {
203  pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
204  if (!pic->hwaccel_priv_buf)
205  return AVERROR(ENOMEM);
206  pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
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;
211  av_pix_fmt_get_chroma_sub_sample(pic->f->format,
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 
228  pic->qscale_table_buf = av_buffer_pool_get(h->qscale_table_pool);
229  pic->mb_type_buf = av_buffer_pool_get(h->mb_type_pool);
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++) {
237  pic->motion_val_buf[i] = av_buffer_pool_get(h->motion_val_pool);
238  pic->ref_index_buf[i] = av_buffer_pool_get(h->ref_index_pool);
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 
261 static int find_unused_picture(H264Context *h)
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 
280 static void copy_picture_range(H264Picture **to, H264Picture **from, int count,
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 
294 static int h264_slice_header_init(H264Context *h);
295 
296 int ff_h264_update_thread_context(AVCodecContext *dst,
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 
344  av_buffer_unref(&h->ps.pps_ref);
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);
396  ff_h264_unref_picture(h, &h->cur_pic);
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 
435  av_buffer_unref(&h->sei.a53_caption.buf_ref);
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) {
446  err = ff_h264_execute_ref_pic_marking(h);
447  h->poc.prev_poc_msb = h->poc.poc_msb;
448  h->poc.prev_poc_lsb = h->poc.poc_lsb;
449  }
450  h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
451  h->poc.prev_frame_num = h->poc.frame_num;
452 
453  h->recovery_frame = h1->recovery_frame;
454 
455  return err;
456 }
457 
458 static int h264_frame_start(H264Context *h)
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 
469  release_unused_pictures(h, 1);
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;
480  pic->f->coded_picture_number = h->coded_picture_number++;
481  pic->field_picture = h->picture_structure != PICT_FRAME;
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;
492  pic->sei_recovery_frame_cnt = h->sei.recovery_point.recovery_frame_cnt;
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;
505  ff_h264_unref_picture(h, &h->cur_pic);
506  if (CONFIG_ERROR_RESILIENCE) {
507  ff_h264_set_erpic(&h->slice_ctx[0].er.cur_pic, NULL);
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) {
519  ff_er_frame_start(&h->slice_ctx[0].er);
520  ff_h264_set_erpic(&h->slice_ctx[0].er.last_pic, NULL);
521  ff_h264_set_erpic(&h->slice_ctx[0].er.next_pic, NULL);
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 
547  h->mb_aff_frame = h->ps.sps->mb_aff && (h->picture_structure == PICT_FRAME);
548 
549  if (h->sei.unregistered.x264_build >= 0)
550  h->x264_build = h->sei.unregistered.x264_build;
551 
552  assert(h->cur_pic_ptr->long_ref == 0);
553 
554  return 0;
555 }
556 
557 static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
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  */
659 static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
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;
693  sl->pwt.chroma_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  */
723 static void init_scan_tables(H264Context *h)
724 {
725  int i;
726  for (i = 0; i < 16; i++) {
727 #define TRANSPOSE(x) ((x) >> 2) | (((x) << 2) & 0xF)
728  h->zigzag_scan[i] = TRANSPOSE(ff_zigzag_scan[i]);
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)
734  h->zigzag_scan8x8[i] = TRANSPOSE(ff_zigzag_direct[i]);
735  h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
736  h->field_scan8x8[i] = TRANSPOSE(field_scan8x8[i]);
737  h->field_scan8x8_cavlc[i] = TRANSPOSE(field_scan8x8_cavlc[i]);
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 ));
743  memcpy(h->zigzag_scan8x8_cavlc_q0 , zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_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 ));
746  memcpy(h->field_scan8x8_cavlc_q0 , field_scan8x8_cavlc , sizeof(h->field_scan8x8_cavlc_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 ));
750  memcpy(h->zigzag_scan8x8_cavlc_q0 , h->zigzag_scan8x8_cavlc , sizeof(h->zigzag_scan8x8_cavlc_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 ));
753  memcpy(h->field_scan8x8_cavlc_q0 , h->field_scan8x8_cavlc , sizeof(h->field_scan8x8_cavlc_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)) {
829  if (h->avctx->color_range == AVCOL_RANGE_JPEG)
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:
856  av_log(h->avctx, AV_LOG_ERROR,
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 */
870 static void init_dimensions(H264Context *h)
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) {
889  width = h->width_from_caller;
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 
910 static int h264_slice_header_init(H264Context *h)
911 {
912  const SPS *sps = h->ps.sps;
913  int i, ret;
914 
915  ff_set_sar(h->avctx, sps->sar);
916  av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
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;
923  av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
924  sps->num_units_in_tick * h->avctx->ticks_per_frame, den, 1 << 30);
925  }
926 
927  ff_h264_free_tables(h);
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 =
949  h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
950  h->cur_chroma_format_idc = sps->chroma_format_idc;
951  h->pixel_shift = sps->bit_depth_luma > 8;
952  h->chroma_format_idc = sps->chroma_format_idc;
953  h->bit_depth_luma = sps->bit_depth_luma;
954 
955  ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
956  sps->chroma_format_idc);
957  ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
958  ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
959  ff_h264_pred_init(&h->hpc, h->avctx->codec_id, sps->bit_depth_luma,
960  sps->chroma_format_idc);
961  ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
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:
989  ff_h264_free_tables(h);
990  h->context_initialized = 0;
991  return ret;
992 }
993 
994 static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
995 {
996  switch (a) {
997  case AV_PIX_FMT_YUVJ420P: return AV_PIX_FMT_YUV420P;
998  case AV_PIX_FMT_YUVJ422P: return AV_PIX_FMT_YUV422P;
999  case AV_PIX_FMT_YUVJ444P: return AV_PIX_FMT_YUV444P;
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 ||
1024  h->cur_bit_depth_luma != h->ps.sps->bit_depth_luma ||
1025  h->cur_chroma_format_idc != h->ps.sps->chroma_format_idc
1026  )
1027  needs_reinit = 1;
1028 
1029  if (h->bit_depth_luma != h->ps.sps->bit_depth_luma ||
1030  h->chroma_format_idc != h->ps.sps->chroma_format_idc)
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
1039  || h->cur_chroma_format_idc != sps->chroma_format_idc
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
1044  || (non_j_pixfmt(h->avctx->pix_fmt) != non_j_pixfmt(get_pixel_format(h, 0))))
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;
1072  if (sps->colour_description_present_flag) {
1073  if (h->avctx->colorspace != sps->colorspace)
1074  needs_reinit = 1;
1075  h->avctx->color_primaries = sps->color_primaries;
1076  h->avctx->color_trc = sps->color_trc;
1077  h->avctx->colorspace = sps->colorspace;
1078  }
1079  }
1080 
1081  if (h->sei.alternative_transfer.present &&
1082  av_color_transfer_name(h->sei.alternative_transfer.preferred_transfer_characteristics) &&
1083  h->sei.alternative_transfer.preferred_transfer_characteristics != AVCOL_TRC_UNSPECIFIED) {
1084  h->avctx->color_trc = h->sei.alternative_transfer.preferred_transfer_characteristics;
1085  }
1086  }
1087  h->avctx->chroma_sample_location = sps->chroma_location;
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) {
1093  av_log(h->avctx, AV_LOG_ERROR,
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)
1105  ff_h264_flush_change(h);
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) {
1115  av_log(h->avctx, AV_LOG_ERROR,
1116  "h264_slice_header_init() failed\n");
1117  return ret;
1118  }
1119  }
1120 
1121  return 0;
1122 }
1123 
1124 static int h264_export_frame_props(H264Context *h)
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) {
1136  int ret = ff_h264_sei_process_picture_timing(&h->sei.picture_timing, sps,
1137  h->avctx);
1138  if (ret < 0) {
1139  av_log(h->avctx, AV_LOG_ERROR, "Error processing a picture timing SEI\n");
1140  if (h->avctx->err_recognition & AV_EF_EXPLODE)
1141  return ret;
1142  h->sei.picture_timing.present = 0;
1143  }
1144  }
1145 
1146  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1147  H264SEIPictureTiming *pt = &h->sei.picture_timing;
1148  switch (pt->pic_struct) {
1149  case H264_SEI_PIC_STRUCT_FRAME:
1150  break;
1151  case H264_SEI_PIC_STRUCT_TOP_FIELD:
1152  case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
1153  cur->f->interlaced_frame = 1;
1154  break;
1155  case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
1156  case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
1157  if (FIELD_OR_MBAFF_PICTURE(h))
1158  cur->f->interlaced_frame = 1;
1159  else
1160  // try to flag soft telecine progressive
1161  cur->f->interlaced_frame = h->prev_interlaced_frame;
1162  break;
1163  case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
1164  case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
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;
1170  case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
1171  cur->f->repeat_pict = 2;
1172  break;
1173  case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
1174  cur->f->repeat_pict = 4;
1175  break;
1176  }
1177 
1178  if ((pt->ct_type & 3) &&
1179  pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
1180  cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
1181  } else {
1182  /* Derive interlacing flag from used decoding process. */
1183  cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
1184  }
1185  h->prev_interlaced_frame = cur->f->interlaced_frame;
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 {
1191  if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1192  /* Use picture timing SEI information. Even if it is a
1193  * information of a past frame, better than nothing. */
1194  if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
1195  h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
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 &&
1210  h->sei.frame_packing.arrangement_type <= 6 &&
1211  h->sei.frame_packing.content_interpretation_type > 0 &&
1212  h->sei.frame_packing.content_interpretation_type < 3) {
1213  H264SEIFramePacking *fp = &h->sei.frame_packing;
1214  AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
1215  if (stereo) {
1216  switch (fp->arrangement_type) {
1217  case H264_SEI_FPA_TYPE_CHECKERBOARD:
1218  stereo->type = AV_STEREO3D_CHECKERBOARD;
1219  break;
1220  case H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN:
1221  stereo->type = AV_STEREO3D_COLUMNS;
1222  break;
1223  case H264_SEI_FPA_TYPE_INTERLEAVE_ROW:
1224  stereo->type = AV_STEREO3D_LINES;
1225  break;
1226  case H264_SEI_FPA_TYPE_SIDE_BY_SIDE:
1227  if (fp->quincunx_sampling_flag)
1228  stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
1229  else
1230  stereo->type = AV_STEREO3D_SIDEBYSIDE;
1231  break;
1232  case H264_SEI_FPA_TYPE_TOP_BOTTOM:
1233  stereo->type = AV_STEREO3D_TOPBOTTOM;
1234  break;
1235  case H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL:
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 
1246  if (fp->arrangement_type == H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL) {
1247  if (fp->current_frame_is_frame0_flag)
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 &&
1256  (h->sei.display_orientation.anticlockwise_rotation ||
1257  h->sei.display_orientation.hflip ||
1258  h->sei.display_orientation.vflip)) {
1259  H264SEIDisplayOrientation *o = &h->sei.display_orientation;
1260  double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
1261  AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
1262  AV_FRAME_DATA_DISPLAYMATRIX,
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) {
1272  AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
1273  sizeof(uint8_t));
1274 
1275  if (sd) {
1276  *sd->data = h->sei.afd.active_format_description;
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 
1284  AVFrameSideData *sd = av_frame_new_side_data_from_buf(cur->f, AV_FRAME_DATA_A53_CC, a53->buf_ref);
1285  if (!sd)
1286  av_buffer_unref(&a53->buf_ref);
1287  a53->buf_ref = NULL;
1288 
1289  h->avctx->properties |= FF_CODEC_PROPERTY_CLOSED_CAPTIONS;
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]) {
1296  AVFrameSideData *sd = av_frame_new_side_data_from_buf(cur->f,
1297  AV_FRAME_DATA_SEI_UNREGISTERED,
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,
1310  AV_FRAME_DATA_S12M_TIMECODE,
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  }
1327  h->sei.picture_timing.timecode_cnt = 0;
1328  }
1329 
1330  return 0;
1331 }
1332 
1333 static int h264_select_output_frame(H264Context *h)
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 ||
1344  h->avctx->strict_std_compliance >= FF_COMPLIANCE_STRICT) {
1345  h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
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 
1377  av_assert0(pics <= MAX_DELAYED_PIC_COUNT);
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".
1413  h->frame_recovered |= FRAME_RECOVERED_SEI;
1414  }
1415  out->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
1416 
1417  if (!out->recovered) {
1418  if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) &&
1419  !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL)) {
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  */
1436 static int h264_field_start(H264Context *h, const H264SliceContext *sl,
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) {
1452  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);
1458  h->picture_structure = sl->picture_structure;
1459 
1460  h->poc.frame_num = sl->frame_num;
1461  h->poc.poc_lsb = sl->poc_lsb;
1462  h->poc.delta_poc_bottom = sl->delta_poc_bottom;
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) {
1505  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
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) {
1515  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1516  last_pic_structure == PICT_TOP_FIELD);
1517  }
1518  } else {
1519  /* Second field in complementary pair */
1520  if (!((last_pic_structure == PICT_TOP_FIELD &&
1521  h->picture_structure == PICT_BOTTOM_FIELD) ||
1522  (last_pic_structure == PICT_BOTTOM_FIELD &&
1523  h->picture_structure == PICT_TOP_FIELD))) {
1524  av_log(h->avctx, AV_LOG_ERROR,
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) {
1531  avpriv_request_sample(h->avctx,
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);
1546  if (!sps->gaps_in_frame_num_allowed_flag)
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;
1557  h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
1558  h->cur_pic_ptr->invalid_gap = !sps->gaps_in_frame_num_allowed_flag;
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;
1563  ret = ff_h264_execute_ref_pic_marking(h);
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) {
1620  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1621  h->picture_structure==PICT_BOTTOM_FIELD);
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 {
1649  int field = h->picture_structure == PICT_BOTTOM_FIELD;
1650  release_unused_pictures(h, 0);
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 
1663  ret = ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
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;
1670  h->explicit_ref_marking = sl->explicit_ref_marking;
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)
1699  h->frame_recovered |= FRAME_RECOVERED_IDR;
1700 #if 1
1701  h->cur_pic_ptr->recovered |= h->frame_recovered;
1702 #else
1703  h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
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 
1722 static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl,
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)
1734  av_assert0(!h->setup_finished);
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) {
1740  av_log(h->avctx, AV_LOG_ERROR,
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 &&
1756  sl->slice_type_nos != AV_PICTURE_TYPE_I) {
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]) {
1767  av_log(h->avctx, AV_LOG_ERROR,
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 
1836  ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
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) {
1843  ret = ff_h264_decode_ref_pic_list_reordering(sl, h->avctx);
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 &&
1857  sl->slice_type_nos == AV_PICTURE_TYPE_B)) {
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 ||
1894  sl->slice_type == AV_PICTURE_TYPE_SI)
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;
1900  if (pps->deblocking_filter_parameters_present) {
1901  tmp = get_ue_golomb_31(&sl->gb);
1902  if (tmp > 2) {
1903  av_log(h->avctx, AV_LOG_ERROR,
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) {
1918  av_log(h->avctx, AV_LOG_ERROR,
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 */
1933 static int h264_slice_init(H264Context *h, H264SliceContext *sl,
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) <<
1951  FIELD_OR_MBAFF_PICTURE(h);
1952  if (h->picture_structure == PICT_BOTTOM_FIELD)
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 &&
1961  sl->slice_type_nos == AV_PICTURE_TYPE_B) {
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 
1969  if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
1970  ff_h264_direct_dist_scale_factor(h, sl);
1971  if (!h->setup_finished)
1972  ff_h264_direct_ref_list_init(h, sl);
1973 
1974  if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
1975  (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
1976  h->nal_unit_type != H264_NAL_IDR_SLICE) ||
1977  (h->avctx->skip_loop_filter >= AVDISCARD_NONINTRA &&
1978  sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
1979  (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR &&
1980  sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
1981  (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
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 -
1995  FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
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) {
2046  av_log(h->avctx, AV_LOG_DEBUG,
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,
2051  av_get_picture_type_char(sl->slice_type),
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,
2060  sl->slice_alpha_c0_offset, sl->slice_beta_offset,
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 
2069 int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
2070 {
2071  H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
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 
2101  ret = ff_h264_execute_decode_slices(h);
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) {
2129  ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
2130  h->picture_structure == PICT_BOTTOM_FIELD);
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) ||
2142  (h->avctx->skip_frame >= AVDISCARD_BIDIR && sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
2143  (h->avctx->skip_frame >= AVDISCARD_NONINTRA && sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
2144  (h->avctx->skip_frame >= AVDISCARD_NONKEY && h->nal_unit_type != H264_NAL_IDR_SLICE && h->sei.recovery_point.recovery_frame_cnt < 0) ||
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) {
2160  av_log(h->avctx, AV_LOG_ERROR,
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)) {
2173  av_log(h->avctx, AV_LOG_ERROR,
2174  "Changing field mode (%d -> %d) between slices is not allowed\n",
2175  h->picture_structure, sl->picture_structure);
2176  return AVERROR_INVALIDDATA;
2177  } else if (!h->cur_pic_ptr) {
2178  av_log(h->avctx, AV_LOG_ERROR,
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 
2194 int ff_h264_get_slice_type(const H264SliceContext *sl)
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 
2212 static av_always_inline void fill_filter_caches_inter(const H264Context *h,
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 
2508 static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
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  */
2521 static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
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,
2549  h->picture_structure == PICT_BOTTOM_FIELD);
2550 }
2551 
2552 static void er_add_slice(H264SliceContext *sl,
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 
2591  if (!(h->avctx->active_thread_type & FF_THREAD_SLICE) && h->picture_structure == PICT_FRAME && h->slice_ctx[0].er.error_status_table) {
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 
2612  ff_h264_init_cabac_states(h, sl);
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) {
2652  av_log(h->avctx, AV_LOG_ERROR,
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)
2669  predict_field_decoding_flag(h, sl);
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) {
2711  av_log(h->avctx, AV_LOG_ERROR,
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)
2726  predict_field_decoding_flag(h, sl);
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  */
2778 int ff_h264_execute_decode_slices(H264Context *h)
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++)
2834  h->slice_ctx[0].er.error_count += h->slice_ctx[i].er.error_count;
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 }
SPS::chroma_format_idc
int chroma_format_idc
Definition: h264_ps.h:48
AV_STEREO3D_FLAG_INVERT
#define AV_STEREO3D_FLAG_INVERT
Inverted views, Right/Bottom represents the left view.
Definition: stereo3d.h:167
SPS::video_signal_type_present_flag
int video_signal_type_present_flag
Definition: h264_ps.h:74
H264SliceContext::h264
struct H264Context * h264
Definition: h264dec.h:184
AV_EF_AGGRESSIVE
#define AV_EF_AGGRESSIVE
consider things that a sane encoder should not do as an error
Definition: avcodec.h:1671
ff_tlog
#define ff_tlog(ctx,...)
Definition: internal.h:86
ff_videodsp_init
av_cold void ff_videodsp_init(VideoDSPContext *ctx, int bpc)
Definition: videodsp.c:38
NULL
#define NULL
Definition: coverity.c:32
ff_thread_can_start_frame
int ff_thread_can_start_frame(AVCodecContext *avctx)
Definition: pthread_frame.c:906
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:535
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:2069
AVDISCARD_NONKEY
discard all frames except keyframes
Definition: avcodec.h:235
init_dimensions
static void init_dimensions(H264Context *h)
Definition: h264_slice.c:870
H264Context::nb_mmco
int nb_mmco
Definition: h264dec.h:480
H264Context::workaround_bugs
int workaround_bugs
Definition: h264dec.h:373
H264Picture::long_ref
int long_ref
1->long term reference 0->short term reference
Definition: h264dec.h:154
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
H264Picture::sei_recovery_frame_cnt
int sei_recovery_frame_cnt
Definition: h264dec.h:163
ff_h264_queue_decode_slice
int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
Submit a slice for decoding.
Definition: h264_slice.c:2069
H264Context::poc
H264POCContext poc
Definition: h264dec.h:466
H264Context::mb_num
int mb_num
Definition: h264dec.h:443
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it...
Definition: buffer.c:125
H264Context::mb_aff_frame
int mb_aff_frame
Definition: h264dec.h:412
H264SEIRecoveryPoint::recovery_frame_cnt
int recovery_frame_cnt
recovery_frame_cnt
Definition: h264_sei.h:141
h
h
Definition: vp9dsp_template.c:2038
H264SliceContext::mv_cache
int16_t mv_cache[2][5 *8][2]
Motion vector cache.
Definition: h264dec.h:305
AVStereo3D::view
enum AVStereo3DView view
Determines which views are packed.
Definition: stereo3d.h:190
AV_PIX_FMT_YUV444P14
#define AV_PIX_FMT_YUV444P14
Definition: pixfmt.h:409
get_se_golomb
static int get_se_golomb(GetBitContext *gb)
read signed exp golomb code.
Definition: golomb.h:239
H264SliceContext::edge_emu_buffer_allocated
int edge_emu_buffer_allocated
Definition: h264dec.h:293
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:714
decode_finish_row
static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
Draw edges and report progress for the last MB row.
Definition: h264_slice.c:2521
H264Context::first_field
int first_field
Definition: h264dec.h:414
H264Context::field_scan8x8_q0
uint8_t field_scan8x8_q0[64]
Definition: h264dec.h:437
ret
ret
Definition: filter_design.txt:187
AV_PIX_FMT_YUV444P
planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
Definition: pixfmt.h:71
imgutils.h
misc image utilities
get_bits
static unsigned int get_bits(GetBitContext *s, int n)
Read 1-25 bits.
Definition: get_bits.h:379
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:200
ER_MB_END
#define ER_MB_END
Definition: error_resilience.h:39
ThreadFrame::f
AVFrame * f
Definition: thread.h:35
PPS::weighted_bipred_idc
int weighted_bipred_idc
Definition: h264_ps.h:119
ff_h264_build_ref_list
int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
Definition: h264_refs.c:299
H264SliceContext::left_mb_xy
int left_mb_xy[LEFT_MBS]
Definition: h264dec.h:217
PPS::chroma_qp_index_offset
int chroma_qp_index_offset[2]
Definition: h264_ps.h:122
H264ParamSets::sps_list
AVBufferRef * sps_list[MAX_SPS_COUNT]
Definition: h264_ps.h:144
CABACContext::bytestream_end
const uint8_t * bytestream_end
Definition: cabac.h:49
get_chroma_qp
static av_always_inline int get_chroma_qp(const PPS *pps, int t, int qscale)
Get the chroma qp.
Definition: h264dec.h:687
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:499
AV_PIX_FMT_VIDEOTOOLBOX
hardware decoding through Videotoolbox
Definition: pixfmt.h:282
H264Context::h264chroma
H264ChromaContext h264chroma
Definition: h264dec.h:348
H264Context::cbp_table
uint16_t * cbp_table
Definition: h264dec.h:419
H264PredWeightTable::luma_weight_flag
int luma_weight_flag[2]
7.4.3.2 luma_weight_lX_flag
Definition: h264_parse.h:35
H264Context::mmco
MMCO mmco[MAX_MMCO_COUNT]
memory management control operations buffer.
Definition: h264dec.h:479
implicit_weight_table
static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
Initialize implicit_weight table.
Definition: h264_slice.c:659
avpriv_request_sample
#define avpriv_request_sample(...)
Definition: tableprint_vlc.h:39
SPS
Sequence parameter set.
Definition: h264_ps.h:44
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:1161
H264Context::mb_y
int mb_y
Definition: h264dec.h:440
H264Context::coded_picture_number
int coded_picture_number
Definition: h264dec.h:369
SPS::bitstream_restriction_flag
int bitstream_restriction_flag
Definition: h264_ps.h:87
AV_PIX_FMT_GBRP
planar GBR 4:4:4 24bpp
Definition: pixfmt.h:168
H264SEIContext::alternative_transfer
H264SEIAlternativeTransfer alternative_transfer
Definition: h264_sei.h:194
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FRAME_DATA_S12M_TIMECODE
Timecode which conforms to SMPTE ST 12-1.
Definition: frame.h:168
H264Picture::mb_type_buf
AVBufferRef * mb_type_buf
Definition: h264dec.h:138
AVFrame::repeat_pict
int repeat_pict
When decoding, this signals how much the picture must be delayed.
Definition: frame.h:450
H264SliceContext::bipred_scratchpad_allocated
int bipred_scratchpad_allocated
Definition: h264dec.h:292
AV_STEREO3D_SIDEBYSIDE_QUINCUNX
Views are next to each other, but when upscaling apply a checkerboard pattern.
Definition: stereo3d.h:117
DELAYED_PIC_REF
#define DELAYED_PIC_REF
Value of Picture.reference when Picture is not a reference picture, but is held for delayed output...
Definition: diracdec.c:67
AV_STEREO3D_VIEW_RIGHT
Frame contains only the right view.
Definition: stereo3d.h:161
AV_PIX_FMT_GBRP10
#define AV_PIX_FMT_GBRP10
Definition: pixfmt.h:415
VP_START
#define VP_START
< current MB is the first after a resync marker
Definition: error_resilience.h:30
H264Context::mb_type_pool
AVBufferPool * mb_type_pool
Definition: h264dec.h:556
ff_h264_init_poc
int ff_h264_init_poc(int pic_field_poc[2], int *pic_poc, const SPS *sps, H264POCContext *pc, int picture_structure, int nal_ref_idc)
Definition: h264_parse.c:277
H264Context::chroma_x_shift
int chroma_x_shift
Definition: h264dec.h:366
GetBitContext::buffer
const uint8_t * buffer
Definition: get_bits.h:62
PPS
Picture parameter set.
Definition: h264_ps.h:111
AVCodecContext::sample_aspect_ratio
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
H264Picture::motion_val
int16_t(*[2] motion_val)[2]
Definition: h264dec.h:136
H264Context::flags
int flags
Definition: h264dec.h:372
ff_h264_flush_change
void ff_h264_flush_change(H264Context *h)
Definition: h264dec.c:439
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:36
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:736
SPS::frame_mbs_only_flag
int frame_mbs_only_flag
Definition: h264_ps.h:62
H264Context::mb_height
int mb_height
Definition: h264dec.h:441
H264Context::delayed_pic
H264Picture * delayed_pic[MAX_DELAYED_PIC_COUNT+2]
Definition: h264dec.h:471
H264Context::is_avc
int is_avc
Used to parse AVC variant of H.264.
Definition: h264dec.h:456
ff_h264_pred_init
av_cold void ff_h264_pred_init(H264PredContext *h, int codec_id, const int bit_depth, int chroma_format_idc)
Set the intra prediction function pointers.
Definition: h264pred.c:411
H264Context::ref_index_pool
AVBufferPool * ref_index_pool
Definition: h264dec.h:558
H264Context::height_from_caller
int height_from_caller
Definition: h264dec.h:549
H264Context::zigzag_scan8x8_cavlc
uint8_t zigzag_scan8x8_cavlc[64]
Definition: h264dec.h:429
AV_PIX_FMT_YUV420P12
#define AV_PIX_FMT_YUV420P12
Definition: pixfmt.h:403
ff_h264chroma_init
av_cold void ff_h264chroma_init(H264ChromaContext *c, int bit_depth)
Definition: h264chroma.c:41
ERContext::last_pic
ERPicture last_pic
Definition: error_resilience.h:74
H264SEIContext::display_orientation
H264SEIDisplayOrientation display_orientation
Definition: h264_sei.h:192
mpegvideo.h
mpegvideo header.
H264SEIFramePacking::current_frame_is_frame0_flag
int current_frame_is_frame0_flag
Definition: h264_sei.h:157
H264SliceContext::next_slice_idx
int next_slice_idx
Definition: h264dec.h:242
zigzag_scan8x8_cavlc
static const uint8_t zigzag_scan8x8_cavlc[64+1]
Definition: h264_slice.c:96
H264_SEI_PIC_STRUCT_FRAME_DOUBLING
7: frame doubling
Definition: h264_sei.h:54
H264Context
H264Context.
Definition: h264dec.h:343
AVDISCARD_NONINTRA
discard all non intra frames
Definition: avcodec.h:234
AVDISCARD_ALL
discard all
Definition: avcodec.h:236
H264Picture::f
AVFrame * f
Definition: h264dec.h:129
H264Picture::pps
const PPS * pps
Definition: h264dec.h:166
AV_STEREO3D_SIDEBYSIDE
Views are next to each other.
Definition: stereo3d.h:67
AVFrame::crop_bottom
size_t crop_bottom
Definition: frame.h:669
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1757
SPS::num_units_in_tick
uint32_t num_units_in_tick
Definition: h264_ps.h:83
field_scan
static const uint8_t field_scan[16+1]
Definition: h264_slice.c:50
AVCodecContext::hwaccel
const struct AVHWAccel * hwaccel
Hardware accelerator in use.
Definition: avcodec.h:1690
ff_thread_await_progress
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before ff_thread_await_progress() has been called on them.reget_buffer() and buffer age optimizations no longer work.*The contents of buffers must not be written to after ff_thread_report_progress() has been called on them.This includes draw_edges().Porting codecs to frame threading
H264Context::long_ref
H264Picture * long_ref[32]
Definition: h264dec.h:470
AVCodecContext::profile
int profile
profile
Definition: avcodec.h:1859
H264Context::picture_structure
int picture_structure
Definition: h264dec.h:413
AVCOL_SPC_RGB
order of coefficients is actually GBR, also IEC 61966-2-1 (sRGB)
Definition: pixfmt.h:513
AV_WN32A
#define AV_WN32A(p, v)
Definition: intreadwrite.h:538
AV_COPY32
#define AV_COPY32(d, s)
Definition: intreadwrite.h:601
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:65
H264SliceContext::ref_count
unsigned int ref_count[2]
num_ref_idx_l0/1_active_minus1 + 1
Definition: h264dec.h:273
IN_RANGE
#define IN_RANGE(a, b, size)
Definition: h264_slice.c:273
H264_SEI_PIC_STRUCT_FRAME
0: frame
Definition: h264_sei.h:47
REBASE_PICTURE
#define REBASE_PICTURE(pic, new_ctx, old_ctx)
Definition: h264_slice.c:275
H264SliceContext::mmco
MMCO mmco[MAX_MMCO_COUNT]
Definition: h264dec.h:328
av_display_rotation_set
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
AV_STEREO3D_VIEW_LEFT
Frame contains only the left view.
Definition: stereo3d.h:156
ff_h264_update_thread_context
int ff_h264_update_thread_context(AVCodecContext *dst, const AVCodecContext *src)
Definition: h264_slice.c:296
AV_PICTURE_TYPE_SI
Switching Intra.
Definition: avutil.h:278
H264Context::setup_finished
int setup_finished
Definition: h264dec.h:540
AVCodecContext::skip_frame
enum AVDiscard skip_frame
Skip decoding for selected frames.
Definition: avcodec.h:2004
ff_h264_execute_decode_slices
int ff_h264_execute_decode_slices(H264Context *h)
Call decode_slice() for each context.
Definition: h264_slice.c:2778
H264Context::sei
H264SEIContext sei
Definition: h264dec.h:553
H264SEIA53Caption::buf_ref
AVBufferRef * buf_ref
Definition: h264_sei.h:124
ff_h264_sei_process_picture_timing
int ff_h264_sei_process_picture_timing(H264SEIPictureTiming *h, const SPS *sps, void *logctx)
Parse the contents of a picture timing message given an active SPS.
Definition: h264_sei.c:61
SPS::crop_top
unsigned int crop_top
frame_cropping_rect_top_offset
Definition: h264_ps.h:70
USES_LIST
#define USES_LIST(a, list)
Definition: mpegutils.h:99
ff_color_frame
void ff_color_frame(AVFrame *frame, const int color[4])
Definition: utils.c:413
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
CABACContext::bytestream
const uint8_t * bytestream
Definition: cabac.h:48
H264Context::ref2frm
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
PPS::deblocking_filter_parameters_present
int deblocking_filter_parameters_present
deblocking_filter_parameters_present_flag
Definition: h264_ps.h:123
cb
static double cb(void *priv, double x, double y)
Definition: vf_geq.c:215
H264ParamSets::pps
const PPS * pps
Definition: h264_ps.h:149
H264_SEI_PIC_STRUCT_BOTTOM_TOP
4: bottom field, top field, in that order
Definition: h264_sei.h:51
non_j_pixfmt
static enum AVPixelFormat non_j_pixfmt(enum AVPixelFormat a)
Definition: h264_slice.c:994
uint8_t
uint8_t
Definition: audio_convert.c:194
SPS::full_range
int full_range
Definition: h264_ps.h:75
SPS::crop_left
unsigned int crop_left
frame_cropping_rect_left_offset
Definition: h264_ps.h:68
SPS::gaps_in_frame_num_allowed_flag
int gaps_in_frame_num_allowed_flag
Definition: h264_ps.h:58
MB_MBAFF
#define MB_MBAFF(h)
Definition: h264dec.h:71
H264SliceContext::slice_alpha_c0_offset
int slice_alpha_c0_offset
Definition: h264dec.h:200
AVStereo3D
Stereo 3D type: this structure describes how two videos are packed within a single video surface...
Definition: stereo3d.h:176
H264Ref::poc
int poc
Definition: h264dec.h:177
ff_h264_set_erpic
void ff_h264_set_erpic(ERPicture *dst, H264Picture *src)
Definition: h264_picture.c:136
H264Picture::field_picture
int field_picture
whether or not picture was encoded in separate fields
Definition: h264dec.h:158
SPS::bit_depth_chroma
int bit_depth_chroma
bit_depth_chroma_minus8 + 8
Definition: h264_ps.h:101
ff_h264_hl_decode_mb
void ff_h264_hl_decode_mb(const H264Context *h, H264SliceContext *sl)
Definition: h264_mb.c:799
FF_DEBUG_PICT_INFO
#define FF_DEBUG_PICT_INFO
Definition: avcodec.h:1612
AVFrame::crop_left
size_t crop_left
Definition: frame.h:670
SPS::color_primaries
enum AVColorPrimaries color_primaries
Definition: h264_ps.h:77
H264Picture::poc
int poc
frame POC
Definition: h264dec.h:148
H264POCContext::frame_num_offset
int frame_num_offset
for POC type 2
Definition: h264_parse.h:51
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
H264PredWeightTable::chroma_weight_flag
int chroma_weight_flag[2]
7.4.3.2 chroma_weight_lX_flag
Definition: h264_parse.h:36
H264_SEI_FPA_TYPE_INTERLEAVE_COLUMN
Definition: h264_sei.h:63
thread.h
Multithreading support functions.
ER_MB_ERROR
#define ER_MB_ERROR
Definition: error_resilience.h:38
PPS::cabac
int cabac
entropy_coding_mode_flag
Definition: h264_ps.h:113
MB_FIELD
#define MB_FIELD(sl)
Definition: h264dec.h:72
from
const char * from
Definition: jacosubdec.c:65
SPS::crop_right
unsigned int crop_right
frame_cropping_rect_right_offset
Definition: h264_ps.h:69
AV_PIX_FMT_GBRP9
#define AV_PIX_FMT_GBRP9
Definition: pixfmt.h:414
H264SliceContext::top_borders
uint8_t(*[2] top_borders)[(16 *3)*2]
Definition: h264dec.h:291
H264Picture::invalid_gap
int invalid_gap
Definition: h264dec.h:162
ERContext::cur_pic
ERPicture cur_pic
Definition: error_resilience.h:73
H264Context::frame_recovered
int frame_recovered
Initial frame has been completely recovered.
Definition: h264dec.h:530
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:214
H264Context::height
int height
Definition: h264dec.h:365
H264_SEI_FPA_TYPE_INTERLEAVE_ROW
Definition: h264_sei.h:64
PICT_BOTTOM_FIELD
#define PICT_BOTTOM_FIELD
Definition: mpegutils.h:38
height
#define height
MAX_PPS_COUNT
#define MAX_PPS_COUNT
Definition: h264_ps.h:38
pt
int pt
Definition: rtp.c:35
SPS::transform_bypass
int transform_bypass
qpprime_y_zero_transform_bypass_flag
Definition: h264_ps.h:49
finish
static void finish(void)
Definition: movenc.c:345
H264_SEI_PIC_STRUCT_FRAME_TRIPLING
8: frame tripling
Definition: h264_sei.h:55
get_bits_count
static int get_bits_count(const GetBitContext *s)
Definition: get_bits.h:219
ff_h264_filter_mb
void ff_h264_filter_mb(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
Definition: h264_loopfilter.c:718
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:79
ER_MV_END
#define ER_MV_END
Definition: error_resilience.h:36
ff_set_sar
int ff_set_sar(AVCodecContext *avctx, AVRational sar)
Check that the provided sample aspect ratio is valid and set it on the codec context.
Definition: utils.c:120
PPS::redundant_pic_cnt_present
int redundant_pic_cnt_present
redundant_pic_cnt_present_flag
Definition: h264_ps.h:125
H264SliceContext::picture_structure
int picture_structure
Definition: h264dec.h:246
H264Context::chroma_y_shift
int chroma_y_shift
Definition: h264dec.h:366
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:210
AVFrame::interlaced_frame
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:455
AV_STEREO3D_2D
Video is not stereoscopic (and metadata has to be there).
Definition: stereo3d.h:55
H264_SEI_PIC_STRUCT_TOP_FIELD
1: top field
Definition: h264_sei.h:48
H264Picture::qscale_table_buf
AVBufferRef * qscale_table_buf
Definition: h264dec.h:132
h264_export_frame_props
static int h264_export_frame_props(H264Context *h)
Definition: h264_slice.c:1124
av_reduce
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AV_PIX_FMT_YUV422P12
#define AV_PIX_FMT_YUV422P12
Definition: pixfmt.h:404
H264Ref::parent
H264Picture * parent
Definition: h264dec.h:180
FRAME_RECOVERED_SEI
#define FRAME_RECOVERED_SEI
Sufficient number of frames have been decoded since a SEI recovery point, so all the following frames...
Definition: h264dec.h:528
H264SEIContext::afd
H264SEIAFD afd
Definition: h264_sei.h:186
AV_CODEC_FLAG_GRAY
#define AV_CODEC_FLAG_GRAY
Only decode/encode grayscale.
Definition: avcodec.h:308
H264Picture::recovered
int recovered
picture at IDR or recovery point + recovery count
Definition: h264dec.h:161
AV_FRAME_DATA_AFD
Active Format Description data consisting of a single byte as specified in ETSI TS 101 154 using AVAc...
Definition: frame.h:89
AV_COPY64
#define AV_COPY64(d, s)
Definition: intreadwrite.h:605
H264_SEI_PIC_STRUCT_BOTTOM_FIELD
2: bottom field
Definition: h264_sei.h:49
ff_h264_decode_ref_pic_list_reordering
int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
Definition: h264_refs.c:423
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1168
FFALIGN
#define FFALIGN(x, a)
Definition: macros.h:48
H264SliceContext::chroma_qp
int chroma_qp[2]
Definition: h264dec.h:194
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
H264Context::last_pocs
int last_pocs[MAX_DELAYED_PIC_COUNT]
Definition: h264dec.h:472
to
const char * to
Definition: webvttdec.c:34
ff_h264_direct_ref_list_init
void ff_h264_direct_ref_list_init(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:121
H264Context::width
int width
Definition: h264dec.h:365
h264_frame_start
static int h264_frame_start(H264Context *h)
Definition: h264_slice.c:458
h264.h
H.264 common definitions.
ff_h264_draw_horiz_band
void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, int y, int height)
Definition: h264dec.c:103
U
#define U(x)
Definition: vp56_arith.h:37
src
#define src
Definition: vp8dsp.c:254
H264SEIPictureTiming::timecode_cnt
int timecode_cnt
Number of timecode in use.
Definition: h264_sei.h:115
HWACCEL_MAX
#define HWACCEL_MAX
get_bits_left
static int get_bits_left(GetBitContext *gb)
Definition: get_bits.h:849
h264_ps.h
H.264 parameter set handling.
H264Context::DPB
H264Picture DPB[H264_MAX_PICTURE_COUNT]
Definition: h264dec.h:351
SPS::color_trc
enum AVColorTransferCharacteristic color_trc
Definition: h264_ps.h:78
SPS::mb_aff
int mb_aff
mb_adaptive_frame_field_flag
Definition: h264_ps.h:63
H264Context::hpc
H264PredContext hpc
Definition: h264dec.h:392
H264PredWeightTable::chroma_log2_weight_denom
int chroma_log2_weight_denom
Definition: h264_parse.h:34
AVFrame::width
int width
Definition: frame.h:366
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:194
AVCodecContext::has_b_frames
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:816
td
#define td
Definition: regdef.h:70
AVStereo3D::flags
int flags
Additional information about the frame packing.
Definition: stereo3d.h:185
get_ue_golomb
static int get_ue_golomb(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to 8190.
Definition: golomb.h:55
alloc_scratch_buffers
static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
Definition: h264_slice.c:128
SPS::poc_type
int poc_type
pic_order_cnt_type
Definition: h264_ps.h:51
ff_er_add_slice
void ff_er_add_slice(ERContext *s, int startx, int starty, int endx, int endy, int status)
Add a slice.
Definition: error_resilience.c:830
H264Context::context_initialized
int context_initialized
Definition: h264dec.h:371
PTRDIFF_SPECIFIER
#define PTRDIFF_SPECIFIER
Definition: internal.h:228
H264SliceContext::er
ERContext er
Definition: h264dec.h:186
H264Context::nal_unit_type
int nal_unit_type
Definition: h264dec.h:449
ff_h264_decode_ref_pic_marking
int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, const H2645NAL *nal, void *logctx)
Definition: h264_refs.c:834
ff_h264_get_profile
int ff_h264_get_profile(const SPS *sps)
Compute profile from profile_idc and constraint_set?_flags.
Definition: h264_parse.c:529
SPS::num_reorder_frames
int num_reorder_frames
Definition: h264_ps.h:88
AVDISCARD_BIDIR
discard all bidirectional frames
Definition: avcodec.h:233
H264SEIFramePacking::arrangement_type
H264_SEI_FpaType arrangement_type
Definition: h264_sei.h:153
H264Picture::hwaccel_picture_private
void * hwaccel_picture_private
hardware accelerator private data
Definition: h264dec.h:142
field
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this field
Definition: writing_filters.txt:78
av_pix_fmt_get_chroma_sub_sample
int av_pix_fmt_get_chroma_sub_sample(enum AVPixelFormat pix_fmt, int *h_shift, int *v_shift)
Utility function to access log2_chroma_w log2_chroma_h from the pixel format AVPixFmtDescriptor.
Definition: pixdesc.c:2601
display.h
Display matrix.
AV_STEREO3D_LINES
Views are packed per line, as if interlaced.
Definition: stereo3d.h:129
AVCodecContext::active_thread_type
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:1804
field_scan8x8
static const uint8_t field_scan8x8[64+1]
Definition: h264_slice.c:57
ff_zigzag_scan
const uint8_t ff_zigzag_scan[16+1]
Definition: mathtables.c:109
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:215
AV_FRAME_DATA_A53_CC
ATSC A53 Part 4 Closed Captions.
Definition: frame.h:58
FIELD_PICTURE
#define FIELD_PICTURE(h)
Definition: h264dec.h:74
H264Context::picture_idr
int picture_idr
Definition: h264dec.h:384
arg
const char * arg
Definition: jacosubdec.c:66
H264SliceContext::deblocking_filter
int deblocking_filter
disable_deblocking_filter_idc with 1 <-> 0
Definition: h264dec.h:199
H264Context::mvd_table
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:423
H264Context::prev_interlaced_frame
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
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:606
fill_filter_caches
static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
Definition: h264_slice.c:2296
H264Picture::tf
ThreadFrame tf
Definition: h264dec.h:130
avassert.h
simple assert() macros that are a bit more flexible than ISO C assert().
PPS::weighted_pred
int weighted_pred
weighted_pred_flag
Definition: h264_ps.h:118
PICT_TOP_FIELD
#define PICT_TOP_FIELD
Definition: mpegutils.h:37
H264Context::h264qpel
H264QpelContext h264qpel
Definition: h264dec.h:349
AV_PIX_FMT_YUV444P10
#define AV_PIX_FMT_YUV444P10
Definition: pixfmt.h:402
H264SliceContext::direct_spatial_mv_pred
int direct_spatial_mv_pred
Definition: h264dec.h:257
H264SEIContext::unregistered
H264SEIUnregistered unregistered
Definition: h264_sei.h:188
H264Picture::frame_num
int frame_num
frame_num (raw frame_num from slice header)
Definition: h264dec.h:149
ff_h264_golomb_to_pict_type
const uint8_t ff_h264_golomb_to_pict_type[5]
Definition: h264data.c:37
MAX_SLICES
#define MAX_SLICES
Definition: dxva2_hevc.c:29
H264Context::valid_recovery_point
int valid_recovery_point
Are the SEI recovery points looking valid.
Definition: h264dec.h:509
count
GLsizei count
Definition: opengl_enc.c:108
ff_h264_get_slice_type
int ff_h264_get_slice_type(const H264SliceContext *sl)
Reconstruct bitstream slice_type.
Definition: h264_slice.c:2194
FFMAX
#define FFMAX(a, b)
Definition: common.h:94
H264_SEI_FPA_TYPE_2D
Definition: h264_sei.h:68
fail
#define fail()
Definition: checkasm.h:123
H264SEIAFD::active_format_description
uint8_t active_format_description
Definition: h264_sei.h:120
SPS::delta_pic_order_always_zero_flag
int delta_pic_order_always_zero_flag
Definition: h264_ps.h:53
av_image_copy
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
ERContext::mb_index2xy
int * mb_index2xy
Definition: error_resilience.h:58
H264SliceContext::slice_type_nos
int slice_type_nos
S free slice type (SI/SP are remapped to I/P)
Definition: h264dec.h:190
H264Context::zigzag_scan8x8
uint8_t zigzag_scan8x8[64]
Definition: h264dec.h:428
H264Picture::hwaccel_priv_buf
AVBufferRef * hwaccel_priv_buf
Definition: h264dec.h:141
AV_PIX_FMT_YUV422P
planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
Definition: pixfmt.h:70
av_stereo3d_create_side_data
AVStereo3D * av_stereo3d_create_side_data(AVFrame *frame)
Allocate a complete AVFrameSideData and add it to the frame.
Definition: stereo3d.c:33
H264Context::crop_bottom
int crop_bottom
Definition: h264dec.h:389
ERContext::error_status_table
uint8_t * error_status_table
Definition: error_resilience.h:66
ff_thread_get_buffer
the pkt_dts and pkt_pts fields in AVFrame will work as usual Restrictions on codec whose streams don t reset across will not work because their bitstreams cannot be decoded in parallel *The contents of buffers must not be read before as well as code calling up to before the decode process starts Call have so the codec calls ff_thread_report set FF_CODEC_CAP_ALLOCATE_PROGRESS in AVCodec caps_internal and use ff_thread_get_buffer() to allocate frames.The frames must then be freed with ff_thread_release_buffer().Otherwise decode directly into the user-supplied frames.Call ff_thread_report_progress() after some part of the current picture has decoded.A good place to put this is where draw_horiz_band() is called-add this if it isn't called anywhere
AVFrame::crop_top
size_t crop_top
Definition: frame.h:668
AV_STEREO3D_FRAMESEQUENCE
Views are alternated temporally.
Definition: stereo3d.h:92
av_fast_malloc
void av_fast_malloc(void *ptr, unsigned int *size, size_t min_size)
Allocate a buffer, reusing the given one if large enough.
Definition: mem.c:502
ff_h264_parse_ref_count
int ff_h264_parse_ref_count(int *plist_count, int ref_count[2], GetBitContext *gb, const PPS *pps, int slice_type_nos, int picture_structure, void *logctx)
Definition: h264_parse.c:219
H264Context::nal_length_size
int nal_length_size
Number of bytes used for nal length (1, 2 or 4)
Definition: h264dec.h:457
rectangle.h
useful rectangle filling function
AV_PIX_FMT_YUV422P9
#define AV_PIX_FMT_YUV422P9
Definition: pixfmt.h:397
AVCodecContext::refs
int refs
number of reference frames
Definition: avcodec.h:1114
H264POCContext::prev_poc_msb
int prev_poc_msb
poc_msb of the last reference pic for POC type 0
Definition: h264_parse.h:49
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
H264Picture::motion_val_buf
AVBufferRef * motion_val_buf[2]
Definition: h264dec.h:135
SPS::ref_frame_count
int ref_frame_count
num_ref_frames
Definition: h264_ps.h:57
AVCodec::pix_fmts
enum AVPixelFormat * pix_fmts
array of supported pixel formats, or NULL if unknown, array is terminated by -1
Definition: codec.h:211
AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:274
AVFrame::pict_type
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:391
AVFrame::flags
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:545
H264SEIPictureTiming::pic_struct
H264_SEI_PicStructType pic_struct
Definition: h264_sei.h:88
AVCodecContext::err_recognition
int err_recognition
Error recognition; may misdetect some more or less valid parts as errors.
Definition: avcodec.h:1655
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
H264Context::x264_build
int x264_build
Definition: h264dec.h:374
H264SEIPictureTiming::ct_type
int ct_type
Bit set of clock types for fields/frames in picture timing SEI message.
Definition: h264_sei.h:95
av_fast_mallocz
void av_fast_mallocz(void *ptr, unsigned int *size, size_t min_size)
Allocate and clear a buffer, reusing the given one if large enough.
Definition: mem.c:507
FFMIN
#define FFMIN(a, b)
Definition: common.h:96
H264Context::slice_table
uint16_t * slice_table
slice_table_base + 2*mb_stride + 1
Definition: h264dec.h:409
copy_picture_range
static void copy_picture_range(H264Picture **to, H264Picture **from, int count, H264Context *new_base, H264Context *old_base)
Definition: h264_slice.c:280
h264_field_start
static int h264_field_start(H264Context *h, const H264SliceContext *sl, const H2645NAL *nal, int first_slice)
Definition: h264_slice.c:1436
H264Context::field_scan8x8_cavlc
uint8_t field_scan8x8_cavlc[64]
Definition: h264dec.h:432
IS_DIRECT
#define IS_DIRECT(a)
Definition: mpegutils.h:84
H264SliceContext::cabac
CABACContext cabac
Cabac.
Definition: h264dec.h:324
SPS::colour_description_present_flag
int colour_description_present_flag
Definition: h264_ps.h:76
H264SliceContext::first_mb_addr
unsigned int first_mb_addr
Definition: h264dec.h:240
H264Picture::reference
int reference
Definition: h264dec.h:160
er_add_slice
static void er_add_slice(H264SliceContext *sl, int startx, int starty, int endx, int endy, int status)
Definition: h264_slice.c:2552
LEFT_MBS
#define LEFT_MBS
Definition: h264dec.h:75
AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:78
SPS::sar
AVRational sar
Definition: h264_ps.h:73
width
#define width
av_frame_new_side_data_from_buf
AVFrameSideData * av_frame_new_side_data_from_buf(AVFrame *frame, enum AVFrameSideDataType type, AVBufferRef *buf)
Add a new side data to a frame from an existing AVBufferRef.
Definition: frame.c:695
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:699
H264SliceContext::redundant_pic_count
int redundant_pic_count
Definition: h264dec.h:250
H264Context::nb_slice_ctx
int nb_slice_ctx
Definition: h264dec.h:357
w
uint8_t w
Definition: llviddspenc.c:38
H264SliceContext::pwt
H264PredWeightTable pwt
Definition: h264dec.h:203
H264Context::long_ref_count
int long_ref_count
number of actual long term references
Definition: h264dec.h:484
ER_DC_END
#define ER_DC_END
Definition: error_resilience.h:35
H264Picture::mb_type
uint32_t * mb_type
Definition: h264dec.h:139
AV_FRAME_FLAG_CORRUPT
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
Definition: frame.h:533
ff_thread_report_progress
void ff_thread_report_progress(ThreadFrame *f, int n, int field)
Notify later decoding threads when part of their reference picture is ready.
Definition: pthread_frame.c:568
h264_init_ps
static int h264_init_ps(H264Context *h, const H264SliceContext *sl, int first_slice)
Definition: h264_slice.c:1005
GetBitContext::size_in_bits
int size_in_bits
Definition: get_bits.h:68
int32_t
int32_t
Definition: audio_convert.c:194
ff_init_cabac_decoder
int ff_init_cabac_decoder(CABACContext *c, const uint8_t *buf, int buf_size)
Definition: cabac.c:176
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:1140
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
FF_THREAD_SLICE
#define FF_THREAD_SLICE
Decode more than one part of a single frame at once.
Definition: avcodec.h:1797
cabac_functions.h
Context Adaptive Binary Arithmetic Coder inline functions.
AVCodecContext::level
int level
level
Definition: avcodec.h:1982
PPS::init_qp
int init_qp
pic_init_qp_minus26 + 26
Definition: h264_ps.h:120
h264dec.h
H.264 / AVC / MPEG-4 part10 codec.
SPS::chroma_location
enum AVChromaLocation chroma_location
Definition: h264_ps.h:80
H264Context::mmco_reset
int mmco_reset
Definition: h264dec.h:481
H264Context::slice_ctx
H264SliceContext * slice_ctx
Definition: h264dec.h:356
SPS::direct_8x8_inference_flag
int direct_8x8_inference_flag
Definition: h264_ps.h:64
h264_select_output_frame
static int h264_select_output_frame(H264Context *h)
Definition: h264_slice.c:1333
AV_EF_EXPLODE
#define AV_EF_EXPLODE
abort decoding on minor error detection
Definition: avcodec.h:1666
H264Ref::reference
int reference
Definition: h264dec.h:176
AVCodecContext::ticks_per_frame
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:658
H264SliceContext::top_borders_allocated
int top_borders_allocated[2]
Definition: h264dec.h:294
fill_rectangle
static void fill_rectangle(int x, int y, int w, int h)
Definition: ffplay.c:831
FIELD_OR_MBAFF_PICTURE
#define FIELD_OR_MBAFF_PICTURE(h)
Definition: h264dec.h:91
H2645NAL::ref_idc
int ref_idc
H.264 only, nal_ref_idc.
Definition: h2645_parse.h:70
init_scan_tables
static void init_scan_tables(H264Context *h)
initialize scan tables
Definition: h264_slice.c:723
get_cabac_terminate
static int av_unused get_cabac_terminate(CABACContext *c)
Definition: cabac_functions.h:181
H264SEIFramePacking::quincunx_sampling_flag
int quincunx_sampling_flag
Definition: h264_sei.h:156
AV_PIX_FMT_YUV444P9
#define AV_PIX_FMT_YUV444P9
Definition: pixfmt.h:398
AV_PIX_FMT_GBRP14
#define AV_PIX_FMT_GBRP14
Definition: pixfmt.h:417
AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:235
H2645NAL::type
int type
NAL unit type.
Definition: h2645_parse.h:52
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
AVCOL_RANGE_JPEG
the normal 2^n-1 "JPEG" YUV ranges
Definition: pixfmt.h:538
init_table_pools
static int init_table_pools(H264Context *h)
Definition: h264_slice.c:160
H264SliceContext::edge_emu_buffer
uint8_t * edge_emu_buffer
Definition: h264dec.h:290
if
if(ret)
Definition: filter_design.txt:179
get_ue_golomb_long
static unsigned get_ue_golomb_long(GetBitContext *gb)
Read an unsigned Exp-Golomb code in the range 0 to UINT32_MAX-1.
Definition: golomb.h:105
AVERROR_PATCHWELCOME
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
PPS::pic_order_present
int pic_order_present
pic_order_present_flag
Definition: h264_ps.h:114
H264Context::zigzag_scan_q0
uint8_t zigzag_scan_q0[16]
Definition: h264dec.h:433
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:381
H264Context::bit_depth_luma
int bit_depth_luma
luma bit depth from sps to detect changes
Definition: h264dec.h:459
H264Context::chroma_format_idc
int chroma_format_idc
chroma format from sps to detect changes
Definition: h264dec.h:460
H264Context::vdsp
VideoDSPContext vdsp
Definition: h264dec.h:346
SPS::timing_info_present_flag
int timing_info_present_flag
Definition: h264_ps.h:82
AVFrame::coded_picture_number
int coded_picture_number
picture number in bitstream order
Definition: frame.h:422
AVStereo3D::type
enum AVStereo3DType type
How views are packed within the video.
Definition: stereo3d.h:180
H264Context::mb_stride
int mb_stride
Definition: h264dec.h:442
AV_STEREO3D_CHECKERBOARD
Views are packed in a checkerboard-like structure per pixel.
Definition: stereo3d.h:104
H264Context::postpone_filter
int postpone_filter
Definition: h264dec.h:379
IS_INTERLACED
#define IS_INTERLACED(a)
Definition: mpegutils.h:83
H264Context::avctx
AVCodecContext * avctx
Definition: h264dec.h:345
H264Context::zigzag_scan8x8_q0
uint8_t zigzag_scan8x8_q0[64]
Definition: h264dec.h:434
AV_PIX_FMT_YUV420P14
#define AV_PIX_FMT_YUV420P14
Definition: pixfmt.h:407
H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP
5: top field, bottom field, top field repeated, in that order
Definition: h264_sei.h:52
avcodec.h
Libavcodec external API header.
MAX_DELAYED_PIC_COUNT
#define MAX_DELAYED_PIC_COUNT
Definition: h264dec.h:56
AV_STEREO3D_TOPBOTTOM
Views are on top of each other.
Definition: stereo3d.h:79
H264SliceContext::last_qscale_diff
int last_qscale_diff
Definition: h264dec.h:196
AV_FRAME_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: frame.h:84
H264ParamSets::pps_list
AVBufferRef * pps_list[MAX_PPS_COUNT]
Definition: h264_ps.h:145
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:536
get_ue_golomb_31
static int get_ue_golomb_31(GetBitContext *gb)
read unsigned exp golomb code, constraint to a max of 31.
Definition: golomb.h:120
H264Context::crop_left
int crop_left
Definition: h264dec.h:386
H264POCContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264_parse.h:46
ERContext::next_pic
ERPicture next_pic
Definition: error_resilience.h:75
AVFrame::linesize
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:339
H264Context::short_ref
H264Picture * short_ref[32]
Definition: h264dec.h:469
H264Context::next_outputed_poc
int next_outputed_poc
Definition: h264dec.h:474
ff_h264_decode_mb_cabac
int ff_h264_decode_mb_cabac(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cabac.c:1911
H264Context::explicit_ref_marking
int explicit_ref_marking
Definition: h264dec.h:482
AV_CODEC_FLAG2_FAST
#define AV_CODEC_FLAG2_FAST
Allow non spec compliant speedup tricks.
Definition: avcodec.h:348
H264Picture::field_poc
int field_poc[2]
top/bottom POC
Definition: h264dec.h:147
AVCodecContext::debug
int debug
debug
Definition: avcodec.h:1611
error_resilience.h
H264Context::recovery_frame
int recovery_frame
recovery_frame is the frame_num at which the next frame should be fully constructed.
Definition: h264dec.h:517
AVCodecContext
main external API structure.
Definition: avcodec.h:526
AV_FRAME_DATA_SEI_UNREGISTERED
User data unregistered metadata associated with a video frame.
Definition: frame.h:194
H264SliceContext::qp_thresh
int qp_thresh
QP threshold to skip loopfilter.
Definition: h264dec.h:195
H264SliceContext::explicit_ref_marking
int explicit_ref_marking
Definition: h264dec.h:330
list
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining list
Definition: filter_design.txt:23
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:89
H264SEIPictureTiming::timecode
H264SEITimeCode timecode[3]
Maximum three timecodes in a pic_timing SEI.
Definition: h264_sei.h:110
fp
#define fp
Definition: regdef.h:44
AVFrameSideData::data
uint8_t * data
Definition: frame.h:216
H264Picture::mb_height
int mb_height
Definition: h264dec.h:168
h264_slice_header_parse
static int h264_slice_header_parse(const H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
Definition: h264_slice.c:1722
H264SEIContext::a53_caption
H264SEIA53Caption a53_caption
Definition: h264_sei.h:187
H264PredWeightTable::implicit_weight
int implicit_weight[48][48][2]
Definition: h264_parse.h:40
AVFrame::crop_right
size_t crop_right
Definition: frame.h:671
H264Picture::qscale_table
int8_t * qscale_table
Definition: h264dec.h:133
scan8
static const uint8_t scan8[16 *3+3]
Definition: h264dec.h:650
CABAC
#define CABAC(h)
Definition: h264_cabac.c:28
av_buffer_allocz
AVBufferRef * av_buffer_allocz(int size)
Same as av_buffer_alloc(), except the returned buffer will be initialized to zero.
Definition: buffer.c:83
AVBufferRef::buffer
AVBuffer * buffer
Definition: buffer.h:82
field_scan8x8_cavlc
static const uint8_t field_scan8x8_cavlc[64+1]
Definition: h264_slice.c:76
get_bits1
static unsigned int get_bits1(GetBitContext *s)
Definition: get_bits.h:498
AV_PIX_FMT_YUV420P10
#define AV_PIX_FMT_YUV420P10
Definition: pixfmt.h:399
ThreadFrame::owner
AVCodecContext * owner[2]
Definition: thread.h:36
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:714
AV_PICTURE_TYPE_SP
Switching Predicted.
Definition: avutil.h:279
H264POCContext::prev_frame_num
int prev_frame_num
frame_num of the last pic for POC type 1/2
Definition: h264_parse.h:53
FF_CODEC_PROPERTY_CLOSED_CAPTIONS
#define FF_CODEC_PROPERTY_CLOSED_CAPTIONS
Definition: avcodec.h:2193
pps
static int FUNC() pps(CodedBitstreamContext *ctx, RWContext *rw, H264RawPPS *current)
Definition: cbs_h264_syntax_template.c:404
av_frame_new_side_data
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
H264SliceContext::non_zero_count_cache
uint8_t non_zero_count_cache[15 *8]
non zero coeff count cache.
Definition: h264dec.h:300
av_buffer_pool_uninit
void av_buffer_pool_uninit(AVBufferPool **ppool)
Mark the pool as being available for freeing.
Definition: buffer.c:276
FRAME_MBAFF
#define FRAME_MBAFF(h)
Definition: h264dec.h:73
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:1154
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:1147
LBOT
#define LBOT
Definition: h264dec.h:77
AV_PIX_FMT_VDPAU
HW acceleration through VDPAU, Picture.data[3] contains a VdpVideoSurface.
Definition: pixfmt.h:197
pack16to32
static av_always_inline uint32_t pack16to32(unsigned a, unsigned b)
Definition: h264dec.h:666
H264Picture::ref_index
int8_t * ref_index[2]
Definition: h264dec.h:145
ff_h264_ref_picture
int ff_h264_ref_picture(H264Context *h, H264Picture *dst, H264Picture *src)
Definition: h264_picture.c:66
AVBuffer
A reference counted buffer type.
Definition: buffer_internal.h:33
H264Context::pixel_shift
int pixel_shift
0 for 8-bit H.264, 1 for high-bit-depth H.264
Definition: h264dec.h:362
status
they must not be accessed directly The fifo field contains the frames that are queued in the input for processing by the filter The status_in and status_out fields contains the queued status(EOF or error) of the link
H264Picture::mmco_reset
int mmco_reset
MMCO_RESET set this 1.
Definition: h264dec.h:150
H264SEIFramePacking::content_interpretation_type
int content_interpretation_type
Definition: h264_sei.h:155
H264Context::cur_pic_ptr
H264Picture * cur_pic_ptr
Definition: h264dec.h:352
LIST_NOT_USED
#define LIST_NOT_USED
Definition: h264dec.h:396
ff_zigzag_direct
const uint8_t ff_zigzag_direct[64]
Definition: mathtables.c:98
H264SliceContext::mb_uvlinesize
ptrdiff_t mb_uvlinesize
Definition: h264dec.h:234
h264_slice_header_init
static int h264_slice_header_init(H264Context *h)
Definition: h264_slice.c:910
sps
static int FUNC() sps(CodedBitstreamContext *ctx, RWContext *rw, H264RawSPS *current)
Definition: cbs_h264_syntax_template.c:260
H264SliceContext::mb_mbaff
int mb_mbaff
mb_aff_frame && mb_field_decoding_flag
Definition: h264dec.h:248
ff_thread_get_format
enum AVPixelFormat ff_thread_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
Wrapper around get_format() for frame-multithreaded codecs.
Definition: pthread_frame.c:972
H264Context::enable_er
int enable_er
Definition: h264dec.h:551
H264_SEI_FPA_TYPE_SIDE_BY_SIDE
Definition: h264_sei.h:65
AV_PIX_FMT_YUV420P9
#define AV_PIX_FMT_YUV420P9
Definition: pixfmt.h:396
IS_INTER
#define IS_INTER(a)
Definition: mpegutils.h:79
FF_COMPLIANCE_STRICT
#define FF_COMPLIANCE_STRICT
Strictly conform to all the things in the spec no matter what consequences.
Definition: avcodec.h:1591
H264ParamSets::sps
const SPS * sps
Definition: h264_ps.h:150
PPS::sps_id
unsigned int sps_id
Definition: h264_ps.h:112
TRANSPOSE
#define TRANSPOSE(x)
H264SEIContext::picture_timing
H264SEIPictureTiming picture_timing
Definition: h264_sei.h:185
H264Context::width_from_caller
int width_from_caller
Definition: h264dec.h:548
SPS::log2_max_poc_lsb
int log2_max_poc_lsb
log2_max_pic_order_cnt_lsb_minus4
Definition: h264_ps.h:52
H264SEIContext::recovery_point
H264SEIRecoveryPoint recovery_point
Definition: h264_sei.h:189
H264SliceContext::mb_linesize
ptrdiff_t mb_linesize
may be equal to s->linesize or s->linesize * 2, for mbaff
Definition: h264dec.h:233
AV_PIX_FMT_DXVA2_VLD
HW decoding through DXVA2, Picture.data[3] contains a LPDIRECT3DSURFACE9 pointer. ...
Definition: pixfmt.h:137
H264Context::slice_row
int16_t slice_row[MAX_SLICES]
to detect when MAX_SLICES is too low
Definition: h264dec.h:544
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:275
H264_SEI_PIC_STRUCT_TOP_BOTTOM
3: top field, bottom field, in that order
Definition: h264_sei.h:50
alloc_picture
static int alloc_picture(H264Context *h, H264Picture *pic)
Definition: h264_slice.c:187
H264SliceContext::linesize
ptrdiff_t linesize
Definition: h264dec.h:232
H264Context::block_offset
int block_offset[2 *(16 *3)]
block_offset[ 0..23] for frame macroblocks block_offset[24..47] for field macroblocks ...
Definition: h264dec.h:403
SPS::time_scale
uint32_t time_scale
Definition: h264_ps.h:84
AV_PIX_FMT_YUV422P14
#define AV_PIX_FMT_YUV422P14
Definition: pixfmt.h:408
AV_PIX_FMT_GBRP12
#define AV_PIX_FMT_GBRP12
Definition: pixfmt.h:416
PPS::transform_8x8_mode
int transform_8x8_mode
transform_8x8_mode_flag
Definition: h264_ps.h:126
H264SliceContext::uvlinesize
ptrdiff_t uvlinesize
Definition: h264dec.h:232
AV_PIX_FMT_YUV422P10
#define AV_PIX_FMT_YUV422P10
Definition: pixfmt.h:400
h264_slice_init
static int h264_slice_init(H264Context *h, H264SliceContext *sl, const H2645NAL *nal)
Definition: h264_slice.c:1933
SPS::pic_struct_present_flag
int pic_struct_present_flag
Definition: h264_ps.h:94
CHROMA444
#define CHROMA444(h)
Definition: h264dec.h:99
H264SliceContext::list_count
unsigned int list_count
Definition: h264dec.h:274
H264Context::zigzag_scan
uint8_t zigzag_scan[16]
Definition: h264dec.h:427
AV_PIX_FMT_YUV444P12
#define AV_PIX_FMT_YUV444P12
Definition: pixfmt.h:406
AVFrame::data
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:322
H264Picture::pps_buf
AVBufferRef * pps_buf
Definition: h264dec.h:165
H264POCContext::prev_poc_lsb
int prev_poc_lsb
poc_lsb of the last reference pic for POC type 0
Definition: h264_parse.h:50
release_unused_pictures
static void release_unused_pictures(H264Context *h, int remove_current)
Definition: h264_slice.c:115
ff_h264_alloc_tables
int ff_h264_alloc_tables(H264Context *h)
Allocate tables.
Definition: h264dec.c:181
AV_ZERO128
#define AV_ZERO128(d)
Definition: intreadwrite.h:637
AV_PIX_FMT_D3D11
Hardware surfaces for Direct3D11.
Definition: pixfmt.h:313
AVCOL_RANGE_MPEG
the normal 219*2^(n-8) "MPEG" YUV ranges
Definition: pixfmt.h:537
H264Picture::mb_stride
int mb_stride
Definition: h264dec.h:169
H264SliceContext::left_type
int left_type[LEFT_MBS]
Definition: h264dec.h:222
av_cmp_q
static int av_cmp_q(AVRational a, AVRational b)
Compare two rationals.
Definition: rational.h:89
H264Context::nb_slice_ctx_queued
int nb_slice_ctx_queued
Definition: h264dec.h:358
AVDISCARD_NONREF
discard all non reference
Definition: avcodec.h:232
ff_h264_field_end
int ff_h264_field_end(H264Context *h, H264SliceContext *sl, int in_setup)
Definition: h264_picture.c:159
H264Context::qscale_table_pool
AVBufferPool * qscale_table_pool
Definition: h264dec.h:555
H264Context::next_output_pic
H264Picture * next_output_pic
Definition: h264dec.h:473
H264_SEI_FPA_TYPE_CHECKERBOARD
Definition: h264_sei.h:62
SPS::mb_height
int mb_height
Definition: h264_ps.h:61
H264Context::motion_val_pool
AVBufferPool * motion_val_pool
Definition: h264dec.h:557
AV_PIX_FMT_YUV420P
planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
Definition: pixfmt.h:66
H264SliceContext::delta_poc_bottom
int delta_poc_bottom
Definition: h264dec.h:334
IS_8x8DCT
#define IS_8x8DCT(a)
Definition: h264dec.h:104
internal.h
common internal api header.
av_buffer_pool_init
AVBufferPool * av_buffer_pool_init(int size, AVBufferRef *(*alloc)(int size))
Allocate and initialize a buffer pool.
Definition: buffer.c:239
ref
static int ref[MAX_W *MAX_W]
Definition: jpeg2000dwt.c:107
AV_COPY128
#define AV_COPY128(d, s)
Definition: intreadwrite.h:609
get_pixel_format
static enum AVPixelFormat get_pixel_format(H264Context *h, int force_callback)
Definition: h264_slice.c:757
H264ParamSets::pps_ref
AVBufferRef * pps_ref
Definition: h264_ps.h:147
SPS::log2_max_frame_num
int log2_max_frame_num
log2_max_frame_num_minus4 + 4
Definition: h264_ps.h:50
H264Context::missing_fields
int missing_fields
Definition: h264dec.h:534
av_color_transfer_name
const char * av_color_transfer_name(enum AVColorTransferCharacteristic transfer)
Definition: pixdesc.c:2942
H264Context::ps
H264ParamSets ps
Definition: h264dec.h:462
H264SEIContext::frame_packing
H264SEIFramePacking frame_packing
Definition: h264_sei.h:191
h264_mvpred.h
H.264 / AVC / MPEG-4 part10 motion vector prediction.
av_buffer_ref
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
AV_PICTURE_TYPE_B
Bi-dir predicted.
Definition: avutil.h:276
AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:80
stereo3d.h
Stereoscopic video.
AV_STEREO3D_COLUMNS
Views are packed per column.
Definition: stereo3d.h:141
H264Context::cur_chroma_format_idc
int cur_chroma_format_idc
Definition: h264dec.h:542
H264SliceContext::intra4x4_pred_mode
int8_t * intra4x4_pred_mode
Definition: h264dec.h:212
AVCodecContext::properties
unsigned properties
Properties of the stream that gets decoded.
Definition: avcodec.h:2191
AVCodecContext::skip_loop_filter
enum AVDiscard skip_loop_filter
Skip loop filtering for selected frames.
Definition: avcodec.h:1990
AVRational::den
int den
Denominator.
Definition: rational.h:60
predict_field_decoding_flag
static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
Definition: h264_slice.c:2508
ff_h264_decode_mb_cavlc
int ff_h264_decode_mb_cavlc(const H264Context *h, H264SliceContext *sl)
Decode a macroblock.
Definition: h264_cavlc.c:702
H2645NAL::gb
GetBitContext gb
Definition: h2645_parse.h:47
SPS::bit_depth_luma
int bit_depth_luma
bit_depth_luma_minus8 + 8
Definition: h264_ps.h:100
H264SEIUnregistered::buf_ref
AVBufferRef ** buf_ref
Definition: h264_sei.h:129
IS_INTRA
#define IS_INTRA(x, y)
H264SEIAFD::present
int present
Definition: h264_sei.h:119
H264POCContext::delta_poc
int delta_poc[2]
Definition: h264_parse.h:47
av_timecode_get_smpte
uint32_t av_timecode_get_smpte(AVRational rate, int drop, int hh, int mm, int ss, int ff)
Convert sei info to SMPTE 12M binary representation.
Definition: timecode.c:84
ff_h264_free_tables
void ff_h264_free_tables(H264Context *h)
Definition: h264dec.c:138
AVCodecContext::priv_data
void * priv_data
Definition: avcodec.h:553
LTOP
#define LTOP
Definition: h264dec.h:76
PICT_FRAME
#define PICT_FRAME
Definition: mpegutils.h:39
backup_mb_border
static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl, uint8_t *src_y, uint8_t *src_cb, uint8_t *src_cr, int linesize, int uvlinesize, int simple)
Definition: h264_slice.c:557
H264Context::zigzag_scan8x8_cavlc_q0
uint8_t zigzag_scan8x8_cavlc_q0[64]
Definition: h264dec.h:435
H264SliceContext::ref_cache
int8_t ref_cache[2][5 *8]
Definition: h264dec.h:306
AV_CODEC_FLAG_OUTPUT_CORRUPT
#define AV_CODEC_FLAG_OUTPUT_CORRUPT
Output even those frames that might be corrupted.
Definition: avcodec.h:283
H264SliceContext::pps_id
unsigned int pps_id
Definition: h264dec.h:284
AVFrame::top_field_first
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:460
AVHWAccel::frame_priv_data_size
int frame_priv_data_size
Size of per-frame hardware accelerator private data.
Definition: avcodec.h:2520
H264_SEI_FPA_TYPE_TOP_BOTTOM
Definition: h264_sei.h:66
CHROMA422
#define CHROMA422(h)
Definition: h264dec.h:98
FF_BUG_TRUNCATED
#define FF_BUG_TRUNCATED
Definition: avcodec.h:1574
H264Context::cur_pic
H264Picture cur_pic
Definition: h264dec.h:353
AVFrame::key_frame
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:386
AV_ZERO32
#define AV_ZERO32(d)
Definition: intreadwrite.h:629
H264Context::mb_width
int mb_width
Definition: h264dec.h:441
find_unused_picture
static int find_unused_picture(H264Context *h)
Definition: h264_slice.c:261
H264Context::current_slice
int current_slice
current slice number, used to initialize slice_num of each thread/context
Definition: h264dec.h:494
ff_h264_execute_ref_pic_marking
int ff_h264_execute_ref_pic_marking(H264Context *h)
Execute the reference picture marking (memory management control operations).
Definition: h264_refs.c:610
align_get_bits
static const uint8_t * align_get_bits(GetBitContext *s)
Definition: get_bits.h:693
ff_h264_pred_weight_table
int ff_h264_pred_weight_table(GetBitContext *gb, const SPS *sps, const int *ref_count, int slice_type_nos, H264PredWeightTable *pwt, int picture_structure, void *logctx)
Definition: h264_parse.c:27
SPS::mb_width
int mb_width
pic_width_in_mbs_minus1 + 1
Definition: h264_ps.h:59
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:613
H264Context::mb2b_xy
uint32_t * mb2b_xy
Definition: h264dec.h:405
H264SliceContext::ref_list
H264Ref ref_list[2][48]
0..15: frame refs, 16..47: mbaff field refs.
Definition: h264dec.h:275
H264Context::field_scan8x8_cavlc_q0
uint8_t field_scan8x8_cavlc_q0[64]
Definition: h264dec.h:438
H264Context::cur_bit_depth_luma
int cur_bit_depth_luma
Definition: h264dec.h:543
H264Context::crop_top
int crop_top
Definition: h264dec.h:388
ERContext::error_count
atomic_int error_count
Definition: error_resilience.h:64
H264Picture::ref_index_buf
AVBufferRef * ref_index_buf[2]
Definition: h264dec.h:144
ff_h264dsp_init
av_cold void ff_h264dsp_init(H264DSPContext *c, const int bit_depth, const int chroma_format_idc)
Definition: h264dsp.c:67
AVCodecContext::frame_number
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1217
H264Context::h264dsp
H264DSPContext h264dsp
Definition: h264dec.h:347
ff_er_frame_start
void ff_er_frame_start(ERContext *s)
Definition: error_resilience.c:797
AVFrame::height
int height
Definition: frame.h:366
AV_CODEC_FLAG2_SHOW_ALL
#define AV_CODEC_FLAG2_SHOW_ALL
Show all frames before the first keyframe.
Definition: avcodec.h:376
out
FILE * out
Definition: movenc.c:54
H264SliceContext::mvd_table
uint8_t(*[2] mvd_table)[2]
Definition: h264dec.h:319
H264Context::field_scan8x8
uint8_t field_scan8x8[64]
Definition: h264dec.h:431
H264SliceContext::slice_type_fixed
int slice_type_fixed
Definition: h264dec.h:191
fill_filter_caches_inter
static av_always_inline void fill_filter_caches_inter(const H264Context *h, H264SliceContext *sl, int mb_type, int top_xy, int left_xy[LEFT_MBS], int top_type, int left_type[LEFT_MBS], int mb_xy, int list)
Definition: h264_slice.c:2212
H264Picture::mb_width
int mb_width
Definition: h264dec.h:168
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
PPS::sps
const SPS * sps
Definition: h264_ps.h:140
H264POCContext::prev_frame_num_offset
int prev_frame_num_offset
for POC type 2
Definition: h264_parse.h:52
av_always_inline
#define av_always_inline
Definition: attributes.h:45
H264_SEI_FPA_TYPE_INTERLEAVE_TEMPORAL
Definition: h264_sei.h:67
AV_PIX_FMT_D3D11VA_VLD
HW decoding through Direct3D11 via old API, Picture.data[3] contains a ID3D11VideoDecoderOutputView p...
Definition: pixfmt.h:229
H264SliceContext::slice_beta_offset
int slice_beta_offset
Definition: h264dec.h:201
H264Context::intra4x4_pred_mode
int8_t * intra4x4_pred_mode
Definition: h264dec.h:391
av_buffer_pool_get
AVBufferRef * av_buffer_pool_get(AVBufferPool *pool)
Allocate a new AVBuffer, reusing an old buffer from the pool when available.
Definition: buffer.c:337
ER_AC_END
#define ER_AC_END
Definition: error_resilience.h:34
decode_slice
static int decode_slice(struct AVCodecContext *avctx, void *arg)
Definition: h264_slice.c:2566
H264SliceContext::delta_poc
int delta_poc[2]
Definition: h264dec.h:335
ff_h264_direct_dist_scale_factor
void ff_h264_direct_dist_scale_factor(const H264Context *const h, H264SliceContext *sl)
Definition: h264_direct.c:62
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:2489
ff_h264_slice_context_init
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
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
cr
static double cr(void *priv, double x, double y)
Definition: vf_geq.c:216
H264Context::field_scan_q0
uint8_t field_scan_q0[16]
Definition: h264dec.h:436
H264SliceContext::mb_field_decoding_flag
int mb_field_decoding_flag
Definition: h264dec.h:247
H264Context::non_zero_count
uint8_t(* non_zero_count)[48]
Definition: h264dec.h:394
loop_filter
static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
Definition: h264_slice.c:2438
AVCodecContext::execute
int(* execute)(struct AVCodecContext *c, int(*func)(struct AVCodecContext *c2, void *arg), void *arg2, int *ret, int count, int size)
The codec may call this to execute several independent things.
Definition: avcodec.h:1825
SPS::crop_bottom
unsigned int crop_bottom
frame_cropping_rect_bottom_offset
Definition: h264_ps.h:71
golomb.h
exp golomb vlc stuff
H264SliceContext::bipred_scratchpad
uint8_t * bipred_scratchpad
Definition: h264dec.h:289
ff_h264_unref_picture
void ff_h264_unref_picture(H264Context *h, H264Picture *pic)
Definition: h264_picture.c:44
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
ff_h264qpel_init
av_cold void ff_h264qpel_init(H264QpelContext *c, int bit_depth)
Definition: h264qpel.c:49
AV_GET_BUFFER_FLAG_REF
#define AV_GET_BUFFER_FLAG_REF
The decoder will keep a reference to the frame and may reuse it later.
Definition: avcodec.h:509
H264Context::droppable
int droppable
Definition: h264dec.h:368
SPS::level_idc
int level_idc
Definition: h264_ps.h:47
AVCodecContext::strict_std_compliance
int strict_std_compliance
strictly follow the standard (MPEG-4, ...).
Definition: avcodec.h:1589
H264Context::crop_right
int crop_right
Definition: h264dec.h:387
ff_h264_filter_mb_fast
void ff_h264_filter_mb_fast(const H264Context *h, H264SliceContext *sl, int mb_x, int mb_y, uint8_t *img_y, uint8_t *img_cb, uint8_t *img_cr, unsigned int linesize, unsigned int uvlinesize)
Definition: h264_loopfilter.c:418
H264Context::nal_ref_idc
int nal_ref_idc
Definition: h264dec.h:448
H264SliceContext::gb
GetBitContext gb
Definition: h264dec.h:185
H264Context::field_scan
uint8_t field_scan[16]
Definition: h264dec.h:430
H264SliceContext::cabac_init_idc
int cabac_init_idc
Definition: h264dec.h:326
FRAME_RECOVERED_IDR
#define FRAME_RECOVERED_IDR
We have seen an IDR, so all the following frames in coded order are correctly decodable.
Definition: h264dec.h:523
for
for(j=16;j >0;--j)
Definition: h264pred_template.c:469
H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM
6: bottom field, top field, bottom field repeated, in that order
Definition: h264_sei.h:53
i
int i
Definition: input.c:406
FFMAX3
#define FFMAX3(a, b, c)
Definition: common.h:95
H264Context::b_stride
int b_stride
Definition: h264dec.h:407
AV_PICTURE_TYPE_P
Predicted.
Definition: avutil.h:275
tb
#define tb
Definition: regdef.h:68
cabac.h
Context Adaptive Binary Arithmetic Coder.
H264_MAX_PICTURE_COUNT
#define H264_MAX_PICTURE_COUNT
Definition: h264dec.h:52
AV_CEIL_RSHIFT
#define AV_CEIL_RSHIFT(a, b)
Definition: common.h:58
ff_h264_init_cabac_states
void ff_h264_init_cabac_states(const H264Context *h, H264SliceContext *sl)
Definition: h264_cabac.c:1262
H264Context::short_ref_count
int short_ref_count
number of actual short term references
Definition: h264dec.h:485
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:26
SPS::colorspace
enum AVColorSpace colorspace
Definition: h264_ps.h:79
Generated on Thu Jul 9 2020 19:21:43 for FFmpeg by   doxygen 1.8.11