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