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