h264dec: track the last seen value of x264_build
[ffmpeg.git] / libavcodec / h264_slice.c
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 Libav.
6  *
7  * Libav 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  * Libav 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 Libav; 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 "libavutil/timer.h"
33 #include "internal.h"
34 #include "cabac.h"
35 #include "cabac_functions.h"
36 #include "error_resilience.h"
37 #include "golomb_legacy.h"
38 #include "avcodec.h"
39 #include "h264.h"
40 #include "h264dec.h"
41 #include "h264data.h"
42 #include "h264chroma.h"
43 #include "h264_mvpred.h"
44 #include "h264_ps.h"
45 #include "mathops.h"
46 #include "mpegutils.h"
47 #include "rectangle.h"
48 #include "thread.h"
49
50 static const uint8_t field_scan[16] = {
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] = {
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] = {
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] = {
97     0 + 0 * 8, 1 + 1 * 8, 1 + 2 * 8, 2 + 2 * 8,
98     4 + 1 * 8, 0 + 5 * 8, 3 + 3 * 8, 7 + 0 * 8,
99     3 + 4 * 8, 1 + 7 * 8, 5 + 3 * 8, 6 + 3 * 8,
100     2 + 7 * 8, 6 + 4 * 8, 5 + 6 * 8, 7 + 5 * 8,
101     1 + 0 * 8, 2 + 0 * 8, 0 + 3 * 8, 3 + 1 * 8,
102     3 + 2 * 8, 0 + 6 * 8, 4 + 2 * 8, 6 + 1 * 8,
103     2 + 5 * 8, 2 + 6 * 8, 6 + 2 * 8, 5 + 4 * 8,
104     3 + 7 * 8, 7 + 3 * 8, 4 + 7 * 8, 7 + 6 * 8,
105     0 + 1 * 8, 3 + 0 * 8, 0 + 4 * 8, 4 + 0 * 8,
106     2 + 3 * 8, 1 + 5 * 8, 5 + 1 * 8, 5 + 2 * 8,
107     1 + 6 * 8, 3 + 5 * 8, 7 + 1 * 8, 4 + 5 * 8,
108     4 + 6 * 8, 7 + 4 * 8, 5 + 7 * 8, 6 + 7 * 8,
109     0 + 2 * 8, 2 + 1 * 8, 1 + 3 * 8, 5 + 0 * 8,
110     1 + 4 * 8, 2 + 4 * 8, 6 + 0 * 8, 4 + 3 * 8,
111     0 + 7 * 8, 4 + 4 * 8, 7 + 2 * 8, 3 + 6 * 8,
112     5 + 5 * 8, 6 + 5 * 8, 6 + 6 * 8, 7 + 7 * 8,
113 };
114
115 static void release_unused_pictures(H264Context *h, int remove_current)
116 {
117     int i;
118
119     /* release non reference frames */
120     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
121         if (h->DPB[i].f->buf[0] && !h->DPB[i].reference &&
122             (remove_current || &h->DPB[i] != h->cur_pic_ptr)) {
123             ff_h264_unref_picture(h, &h->DPB[i]);
124         }
125     }
126 }
127
128 static int alloc_scratch_buffers(H264SliceContext *sl, int linesize)
129 {
130     const H264Context *h = sl->h264;
131     int alloc_size = FFALIGN(FFABS(linesize) + 32, 32);
132
133     av_fast_malloc(&sl->bipred_scratchpad, &sl->bipred_scratchpad_allocated, 16 * 6 * alloc_size);
134     // edge emu needs blocksize + filter length - 1
135     // (= 21x21 for  H.264)
136     av_fast_malloc(&sl->edge_emu_buffer, &sl->edge_emu_buffer_allocated, alloc_size * 2 * 21);
137
138     av_fast_malloc(&sl->top_borders[0], &sl->top_borders_allocated[0],
139                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
140     av_fast_malloc(&sl->top_borders[1], &sl->top_borders_allocated[1],
141                    h->mb_width * 16 * 3 * sizeof(uint8_t) * 2);
142
143     if (!sl->bipred_scratchpad || !sl->edge_emu_buffer ||
144         !sl->top_borders[0]    || !sl->top_borders[1]) {
145         av_freep(&sl->bipred_scratchpad);
146         av_freep(&sl->edge_emu_buffer);
147         av_freep(&sl->top_borders[0]);
148         av_freep(&sl->top_borders[1]);
149
150         sl->bipred_scratchpad_allocated = 0;
151         sl->edge_emu_buffer_allocated   = 0;
152         sl->top_borders_allocated[0]    = 0;
153         sl->top_borders_allocated[1]    = 0;
154         return AVERROR(ENOMEM);
155     }
156
157     return 0;
158 }
159
160 static int init_table_pools(H264Context *h)
161 {
162     const int big_mb_num    = h->mb_stride * (h->mb_height + 1) + 1;
163     const int mb_array_size = h->mb_stride * h->mb_height;
164     const int b4_stride     = h->mb_width * 4 + 1;
165     const int b4_array_size = b4_stride * h->mb_height * 4;
166
167     h->qscale_table_pool = av_buffer_pool_init(big_mb_num + h->mb_stride,
168                                                av_buffer_allocz);
169     h->mb_type_pool      = av_buffer_pool_init((big_mb_num + h->mb_stride) *
170                                                sizeof(uint32_t), av_buffer_allocz);
171     h->motion_val_pool   = av_buffer_pool_init(2 * (b4_array_size + 4) *
172                                                sizeof(int16_t), av_buffer_allocz);
173     h->ref_index_pool    = av_buffer_pool_init(4 * mb_array_size, av_buffer_allocz);
174
175     if (!h->qscale_table_pool || !h->mb_type_pool || !h->motion_val_pool ||
176         !h->ref_index_pool) {
177         av_buffer_pool_uninit(&h->qscale_table_pool);
178         av_buffer_pool_uninit(&h->mb_type_pool);
179         av_buffer_pool_uninit(&h->motion_val_pool);
180         av_buffer_pool_uninit(&h->ref_index_pool);
181         return AVERROR(ENOMEM);
182     }
183
184     return 0;
185 }
186
187 static int alloc_picture(H264Context *h, H264Picture *pic)
188 {
189     int i, ret = 0;
190
191     av_assert0(!pic->f->data[0]);
192
193     pic->tf.f = pic->f;
194     ret = ff_thread_get_buffer(h->avctx, &pic->tf, pic->reference ?
195                                                    AV_GET_BUFFER_FLAG_REF : 0);
196     if (ret < 0)
197         goto fail;
198
199     if (h->avctx->hwaccel) {
200         const AVHWAccel *hwaccel = h->avctx->hwaccel;
201         av_assert0(!pic->hwaccel_picture_private);
202         if (hwaccel->frame_priv_data_size) {
203             pic->hwaccel_priv_buf = av_buffer_allocz(hwaccel->frame_priv_data_size);
204             if (!pic->hwaccel_priv_buf)
205                 return AVERROR(ENOMEM);
206             pic->hwaccel_picture_private = pic->hwaccel_priv_buf->data;
207         }
208     }
209
210     if (!h->qscale_table_pool) {
211         ret = init_table_pools(h);
212         if (ret < 0)
213             goto fail;
214     }
215
216     pic->qscale_table_buf = av_buffer_pool_get(h->qscale_table_pool);
217     pic->mb_type_buf      = av_buffer_pool_get(h->mb_type_pool);
218     if (!pic->qscale_table_buf || !pic->mb_type_buf)
219         goto fail;
220
221     pic->mb_type      = (uint32_t*)pic->mb_type_buf->data + 2 * h->mb_stride + 1;
222     pic->qscale_table = pic->qscale_table_buf->data + 2 * h->mb_stride + 1;
223
224     for (i = 0; i < 2; i++) {
225         pic->motion_val_buf[i] = av_buffer_pool_get(h->motion_val_pool);
226         pic->ref_index_buf[i]  = av_buffer_pool_get(h->ref_index_pool);
227         if (!pic->motion_val_buf[i] || !pic->ref_index_buf[i])
228             goto fail;
229
230         pic->motion_val[i] = (int16_t (*)[2])pic->motion_val_buf[i]->data + 4;
231         pic->ref_index[i]  = pic->ref_index_buf[i]->data;
232     }
233
234     return 0;
235 fail:
236     ff_h264_unref_picture(h, pic);
237     return (ret < 0) ? ret : AVERROR(ENOMEM);
238 }
239
240 static inline int pic_is_unused(H264Context *h, H264Picture *pic)
241 {
242     if (!pic->f->buf[0])
243         return 1;
244     return 0;
245 }
246
247 static int find_unused_picture(H264Context *h)
248 {
249     int i;
250
251     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
252         if (pic_is_unused(h, &h->DPB[i]))
253             break;
254     }
255     if (i == H264_MAX_PICTURE_COUNT)
256         return AVERROR_INVALIDDATA;
257
258     return i;
259 }
260
261 static int initialize_cur_frame(H264Context *h)
262 {
263     H264Picture *cur;
264     int ret;
265
266     release_unused_pictures(h, 1);
267     ff_h264_unref_picture(h, &h->cur_pic);
268     h->cur_pic_ptr = NULL;
269
270     ret = find_unused_picture(h);
271     if (ret < 0) {
272         av_log(h->avctx, AV_LOG_ERROR, "no frame buffer available\n");
273         return ret;
274     }
275     cur = &h->DPB[ret];
276
277     ret = alloc_picture(h, cur);
278     if (ret < 0)
279         return ret;
280
281     ret = ff_h264_ref_picture(h, &h->cur_pic, cur);
282     if (ret < 0)
283         return ret;
284     h->cur_pic_ptr = cur;
285
286     return 0;
287 }
288
289 #define IN_RANGE(a, b, size) (((a) >= (b)) && ((a) < ((b) + (size))))
290
291 #define REBASE_PICTURE(pic, new_ctx, old_ctx)             \
292     ((pic && pic >= old_ctx->DPB &&                       \
293       pic < old_ctx->DPB + H264_MAX_PICTURE_COUNT) ?          \
294      &new_ctx->DPB[pic - old_ctx->DPB] : NULL)
295
296 static void copy_picture_range(H264Picture **to, H264Picture **from, int count,
297                                H264Context *new_base,
298                                H264Context *old_base)
299 {
300     int i;
301
302     for (i = 0; i < count; i++) {
303         assert((IN_RANGE(from[i], old_base, sizeof(*old_base)) ||
304                 IN_RANGE(from[i], old_base->DPB,
305                          sizeof(H264Picture) * H264_MAX_PICTURE_COUNT) ||
306                 !from[i]));
307         to[i] = REBASE_PICTURE(from[i], new_base, old_base);
308     }
309 }
310
311 static int h264_slice_header_init(H264Context *h);
312
313 int ff_h264_update_thread_context(AVCodecContext *dst,
314                                   const AVCodecContext *src)
315 {
316     H264Context *h = dst->priv_data, *h1 = src->priv_data;
317     int inited = h->context_initialized, err = 0;
318     int need_reinit = 0;
319     int i, ret;
320
321     if (dst == src || !h1->context_initialized)
322         return 0;
323
324     if (!h1->ps.sps)
325         return AVERROR_INVALIDDATA;
326
327     if (inited &&
328         (h->width                 != h1->width                 ||
329          h->height                != h1->height                ||
330          h->mb_width              != h1->mb_width              ||
331          h->mb_height             != h1->mb_height             ||
332          !h->ps.sps                                            ||
333          h->ps.sps->bit_depth_luma    != h1->ps.sps->bit_depth_luma    ||
334          h->ps.sps->chroma_format_idc != h1->ps.sps->chroma_format_idc ||
335          h->ps.sps->colorspace        != h1->ps.sps->colorspace)) {
336         need_reinit = 1;
337     }
338
339     // SPS/PPS
340     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.sps_list); i++) {
341         av_buffer_unref(&h->ps.sps_list[i]);
342         if (h1->ps.sps_list[i]) {
343             h->ps.sps_list[i] = av_buffer_ref(h1->ps.sps_list[i]);
344             if (!h->ps.sps_list[i])
345                 return AVERROR(ENOMEM);
346         }
347     }
348     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
349         av_buffer_unref(&h->ps.pps_list[i]);
350         if (h1->ps.pps_list[i]) {
351             h->ps.pps_list[i] = av_buffer_ref(h1->ps.pps_list[i]);
352             if (!h->ps.pps_list[i])
353                 return AVERROR(ENOMEM);
354         }
355     }
356
357     h->ps.sps = h1->ps.sps;
358
359     if (need_reinit || !inited) {
360         h->width     = h1->width;
361         h->height    = h1->height;
362         h->mb_height = h1->mb_height;
363         h->mb_width  = h1->mb_width;
364         h->mb_num    = h1->mb_num;
365         h->mb_stride = h1->mb_stride;
366         h->b_stride  = h1->b_stride;
367
368         if ((err = h264_slice_header_init(h)) < 0) {
369             av_log(h->avctx, AV_LOG_ERROR, "h264_slice_header_init() failed");
370             return err;
371         }
372
373         /* copy block_offset since frame_start may not be called */
374         memcpy(h->block_offset, h1->block_offset, sizeof(h->block_offset));
375     }
376
377     h->avctx->coded_height  = h1->avctx->coded_height;
378     h->avctx->coded_width   = h1->avctx->coded_width;
379     h->avctx->width         = h1->avctx->width;
380     h->avctx->height        = h1->avctx->height;
381     h->width_from_caller    = h1->width_from_caller;
382     h->height_from_caller   = h1->height_from_caller;
383     h->coded_picture_number = h1->coded_picture_number;
384     h->first_field          = h1->first_field;
385     h->picture_structure    = h1->picture_structure;
386     h->mb_aff_frame         = h1->mb_aff_frame;
387     h->droppable            = h1->droppable;
388
389     for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) {
390         ff_h264_unref_picture(h, &h->DPB[i]);
391         if (h1->DPB[i].f->buf[0] &&
392             (ret = ff_h264_ref_picture(h, &h->DPB[i], &h1->DPB[i])) < 0)
393             return ret;
394     }
395
396     h->cur_pic_ptr = REBASE_PICTURE(h1->cur_pic_ptr, h, h1);
397     ff_h264_unref_picture(h, &h->cur_pic);
398     if (h1->cur_pic.f->buf[0]) {
399         ret = ff_h264_ref_picture(h, &h->cur_pic, &h1->cur_pic);
400         if (ret < 0)
401             return ret;
402     }
403
404     h->enable_er       = h1->enable_er;
405     h->workaround_bugs = h1->workaround_bugs;
406     h->x264_build      = h1->x264_build;
407     h->droppable       = h1->droppable;
408
409     // extradata/NAL handling
410     h->is_avc = h1->is_avc;
411     h->nal_length_size = h1->nal_length_size;
412
413     memcpy(&h->poc,        &h1->poc,        sizeof(h->poc));
414
415     memcpy(h->short_ref,   h1->short_ref,   sizeof(h->short_ref));
416     memcpy(h->long_ref,    h1->long_ref,    sizeof(h->long_ref));
417     memcpy(h->delayed_pic, h1->delayed_pic, sizeof(h->delayed_pic));
418     memcpy(h->last_pocs,   h1->last_pocs,   sizeof(h->last_pocs));
419
420     h->next_outputed_poc = h1->next_outputed_poc;
421
422     memcpy(h->mmco, h1->mmco, sizeof(h->mmco));
423     h->nb_mmco         = h1->nb_mmco;
424     h->mmco_reset      = h1->mmco_reset;
425     h->explicit_ref_marking = h1->explicit_ref_marking;
426     h->long_ref_count  = h1->long_ref_count;
427     h->short_ref_count = h1->short_ref_count;
428
429     copy_picture_range(h->short_ref, h1->short_ref, 32, h, h1);
430     copy_picture_range(h->long_ref, h1->long_ref, 32, h, h1);
431     copy_picture_range(h->delayed_pic, h1->delayed_pic,
432                        MAX_DELAYED_PIC_COUNT + 2, h, h1);
433
434     if (!h->cur_pic_ptr)
435         return 0;
436
437     if (!h->droppable) {
438         err = ff_h264_execute_ref_pic_marking(h);
439         h->poc.prev_poc_msb = h->poc.poc_msb;
440         h->poc.prev_poc_lsb = h->poc.poc_lsb;
441     }
442     h->poc.prev_frame_num_offset = h->poc.frame_num_offset;
443     h->poc.prev_frame_num        = h->poc.frame_num;
444
445     h->recovery_frame        = h1->recovery_frame;
446     h->frame_recovered       = h1->frame_recovered;
447
448     return err;
449 }
450
451 static int h264_frame_start(H264Context *h)
452 {
453     H264Picture *pic;
454     int i, ret;
455     const int pixel_shift = h->pixel_shift;
456
457     ret = initialize_cur_frame(h);
458     if (ret < 0)
459         return ret;
460
461     pic = h->cur_pic_ptr;
462     pic->reference              = h->droppable ? 0 : h->picture_structure;
463     pic->f->coded_picture_number = h->coded_picture_number++;
464     pic->field_picture          = h->picture_structure != PICT_FRAME;
465     pic->frame_num               = h->poc.frame_num;
466     /*
467      * Zero key_frame here; IDR markings per slice in frame or fields are ORed
468      * in later.
469      * See decode_nal_units().
470      */
471     pic->f->key_frame = 0;
472     pic->mmco_reset  = 0;
473     pic->recovered   = 0;
474
475     pic->f->pict_type = h->slice_ctx[0].slice_type;
476
477     pic->f->crop_left   = h->crop_left;
478     pic->f->crop_right  = h->crop_right;
479     pic->f->crop_top    = h->crop_top;
480     pic->f->crop_bottom = h->crop_bottom;
481
482     if (CONFIG_ERROR_RESILIENCE && h->enable_er)
483         ff_er_frame_start(&h->slice_ctx[0].er);
484
485     for (i = 0; i < 16; i++) {
486         h->block_offset[i]           = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
487         h->block_offset[48 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[0] * ((scan8[i] - scan8[0]) >> 3);
488     }
489     for (i = 0; i < 16; i++) {
490         h->block_offset[16 + i]      =
491         h->block_offset[32 + i]      = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 4 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
492         h->block_offset[48 + 16 + i] =
493         h->block_offset[48 + 32 + i] = (4 * ((scan8[i] - scan8[0]) & 7) << pixel_shift) + 8 * pic->f->linesize[1] * ((scan8[i] - scan8[0]) >> 3);
494     }
495
496     /* Some macroblocks can be accessed before they're available in case
497      * of lost slices, MBAFF or threading. */
498     memset(h->slice_table, -1,
499            (h->mb_height * h->mb_stride - 1) * sizeof(*h->slice_table));
500
501     /* We mark the current picture as non-reference after allocating it, so
502      * that if we break out due to an error it can be released automatically
503      * in the next ff_mpv_frame_start().
504      */
505     h->cur_pic_ptr->reference = 0;
506
507     h->cur_pic_ptr->field_poc[0] = h->cur_pic_ptr->field_poc[1] = INT_MAX;
508
509     h->postpone_filter = 0;
510
511     h->mb_aff_frame = h->ps.sps->mb_aff && (h->picture_structure == PICT_FRAME);
512
513     if (h->sei.unregistered.x264_build >= 0)
514         h->x264_build = h->sei.unregistered.x264_build;
515
516     assert(h->cur_pic_ptr->long_ref == 0);
517
518     return 0;
519 }
520
521 static av_always_inline void backup_mb_border(const H264Context *h, H264SliceContext *sl,
522                                               uint8_t *src_y,
523                                               uint8_t *src_cb, uint8_t *src_cr,
524                                               int linesize, int uvlinesize,
525                                               int simple)
526 {
527     uint8_t *top_border;
528     int top_idx = 1;
529     const int pixel_shift = h->pixel_shift;
530     int chroma444 = CHROMA444(h);
531     int chroma422 = CHROMA422(h);
532
533     src_y  -= linesize;
534     src_cb -= uvlinesize;
535     src_cr -= uvlinesize;
536
537     if (!simple && FRAME_MBAFF(h)) {
538         if (sl->mb_y & 1) {
539             if (!MB_MBAFF(sl)) {
540                 top_border = sl->top_borders[0][sl->mb_x];
541                 AV_COPY128(top_border, src_y + 15 * linesize);
542                 if (pixel_shift)
543                     AV_COPY128(top_border + 16, src_y + 15 * linesize + 16);
544                 if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
545                     if (chroma444) {
546                         if (pixel_shift) {
547                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
548                             AV_COPY128(top_border + 48, src_cb + 15 * uvlinesize + 16);
549                             AV_COPY128(top_border + 64, src_cr + 15 * uvlinesize);
550                             AV_COPY128(top_border + 80, src_cr + 15 * uvlinesize + 16);
551                         } else {
552                             AV_COPY128(top_border + 16, src_cb + 15 * uvlinesize);
553                             AV_COPY128(top_border + 32, src_cr + 15 * uvlinesize);
554                         }
555                     } else if (chroma422) {
556                         if (pixel_shift) {
557                             AV_COPY128(top_border + 32, src_cb + 15 * uvlinesize);
558                             AV_COPY128(top_border + 48, src_cr + 15 * uvlinesize);
559                         } else {
560                             AV_COPY64(top_border + 16, src_cb + 15 * uvlinesize);
561                             AV_COPY64(top_border + 24, src_cr + 15 * uvlinesize);
562                         }
563                     } else {
564                         if (pixel_shift) {
565                             AV_COPY128(top_border + 32, src_cb + 7 * uvlinesize);
566                             AV_COPY128(top_border + 48, src_cr + 7 * uvlinesize);
567                         } else {
568                             AV_COPY64(top_border + 16, src_cb + 7 * uvlinesize);
569                             AV_COPY64(top_border + 24, src_cr + 7 * uvlinesize);
570                         }
571                     }
572                 }
573             }
574         } else if (MB_MBAFF(sl)) {
575             top_idx = 0;
576         } else
577             return;
578     }
579
580     top_border = sl->top_borders[top_idx][sl->mb_x];
581     /* There are two lines saved, the line above the top macroblock
582      * of a pair, and the line above the bottom macroblock. */
583     AV_COPY128(top_border, src_y + 16 * linesize);
584     if (pixel_shift)
585         AV_COPY128(top_border + 16, src_y + 16 * linesize + 16);
586
587     if (simple || !CONFIG_GRAY || !(h->flags & AV_CODEC_FLAG_GRAY)) {
588         if (chroma444) {
589             if (pixel_shift) {
590                 AV_COPY128(top_border + 32, src_cb + 16 * linesize);
591                 AV_COPY128(top_border + 48, src_cb + 16 * linesize + 16);
592                 AV_COPY128(top_border + 64, src_cr + 16 * linesize);
593                 AV_COPY128(top_border + 80, src_cr + 16 * linesize + 16);
594             } else {
595                 AV_COPY128(top_border + 16, src_cb + 16 * linesize);
596                 AV_COPY128(top_border + 32, src_cr + 16 * linesize);
597             }
598         } else if (chroma422) {
599             if (pixel_shift) {
600                 AV_COPY128(top_border + 32, src_cb + 16 * uvlinesize);
601                 AV_COPY128(top_border + 48, src_cr + 16 * uvlinesize);
602             } else {
603                 AV_COPY64(top_border + 16, src_cb + 16 * uvlinesize);
604                 AV_COPY64(top_border + 24, src_cr + 16 * uvlinesize);
605             }
606         } else {
607             if (pixel_shift) {
608                 AV_COPY128(top_border + 32, src_cb + 8 * uvlinesize);
609                 AV_COPY128(top_border + 48, src_cr + 8 * uvlinesize);
610             } else {
611                 AV_COPY64(top_border + 16, src_cb + 8 * uvlinesize);
612                 AV_COPY64(top_border + 24, src_cr + 8 * uvlinesize);
613             }
614         }
615     }
616 }
617
618 /**
619  * Initialize implicit_weight table.
620  * @param field  0/1 initialize the weight for interlaced MBAFF
621  *                -1 initializes the rest
622  */
623 static void implicit_weight_table(const H264Context *h, H264SliceContext *sl, int field)
624 {
625     int ref0, ref1, i, cur_poc, ref_start, ref_count0, ref_count1;
626
627     for (i = 0; i < 2; i++) {
628         sl->pwt.luma_weight_flag[i]   = 0;
629         sl->pwt.chroma_weight_flag[i] = 0;
630     }
631
632     if (field < 0) {
633         if (h->picture_structure == PICT_FRAME) {
634             cur_poc = h->cur_pic_ptr->poc;
635         } else {
636             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure - 1];
637         }
638         if (sl->ref_count[0] == 1 && sl->ref_count[1] == 1 && !FRAME_MBAFF(h) &&
639             sl->ref_list[0][0].poc + sl->ref_list[1][0].poc == 2 * cur_poc) {
640             sl->pwt.use_weight        = 0;
641             sl->pwt.use_weight_chroma = 0;
642             return;
643         }
644         ref_start  = 0;
645         ref_count0 = sl->ref_count[0];
646         ref_count1 = sl->ref_count[1];
647     } else {
648         cur_poc    = h->cur_pic_ptr->field_poc[field];
649         ref_start  = 16;
650         ref_count0 = 16 + 2 * sl->ref_count[0];
651         ref_count1 = 16 + 2 * sl->ref_count[1];
652     }
653
654     sl->pwt.use_weight               = 2;
655     sl->pwt.use_weight_chroma        = 2;
656     sl->pwt.luma_log2_weight_denom   = 5;
657     sl->pwt.chroma_log2_weight_denom = 5;
658
659     for (ref0 = ref_start; ref0 < ref_count0; ref0++) {
660         int poc0 = sl->ref_list[0][ref0].poc;
661         for (ref1 = ref_start; ref1 < ref_count1; ref1++) {
662             int w = 32;
663             if (!sl->ref_list[0][ref0].parent->long_ref && !sl->ref_list[1][ref1].parent->long_ref) {
664                 int poc1 = sl->ref_list[1][ref1].poc;
665                 int td   = av_clip_int8(poc1 - poc0);
666                 if (td) {
667                     int tb = av_clip_int8(cur_poc - poc0);
668                     int tx = (16384 + (FFABS(td) >> 1)) / td;
669                     int dist_scale_factor = (tb * tx + 32) >> 8;
670                     if (dist_scale_factor >= -64 && dist_scale_factor <= 128)
671                         w = 64 - dist_scale_factor;
672                 }
673             }
674             if (field < 0) {
675                 sl->pwt.implicit_weight[ref0][ref1][0] =
676                 sl->pwt.implicit_weight[ref0][ref1][1] = w;
677             } else {
678                 sl->pwt.implicit_weight[ref0][ref1][field] = w;
679             }
680         }
681     }
682 }
683
684 /**
685  * initialize scan tables
686  */
687 static void init_scan_tables(H264Context *h)
688 {
689     int i;
690     for (i = 0; i < 16; i++) {
691 #define TRANSPOSE(x) (x >> 2) | ((x << 2) & 0xF)
692         h->zigzag_scan[i] = TRANSPOSE(ff_zigzag_scan[i]);
693         h->field_scan[i]  = TRANSPOSE(field_scan[i]);
694 #undef TRANSPOSE
695     }
696     for (i = 0; i < 64; i++) {
697 #define TRANSPOSE(x) (x >> 3) | ((x & 7) << 3)
698         h->zigzag_scan8x8[i]       = TRANSPOSE(ff_zigzag_direct[i]);
699         h->zigzag_scan8x8_cavlc[i] = TRANSPOSE(zigzag_scan8x8_cavlc[i]);
700         h->field_scan8x8[i]        = TRANSPOSE(field_scan8x8[i]);
701         h->field_scan8x8_cavlc[i]  = TRANSPOSE(field_scan8x8_cavlc[i]);
702 #undef TRANSPOSE
703     }
704     if (h->ps.sps->transform_bypass) { // FIXME same ugly
705         h->zigzag_scan_q0          = ff_zigzag_scan;
706         h->zigzag_scan8x8_q0       = ff_zigzag_direct;
707         h->zigzag_scan8x8_cavlc_q0 = zigzag_scan8x8_cavlc;
708         h->field_scan_q0           = field_scan;
709         h->field_scan8x8_q0        = field_scan8x8;
710         h->field_scan8x8_cavlc_q0  = field_scan8x8_cavlc;
711     } else {
712         h->zigzag_scan_q0          = h->zigzag_scan;
713         h->zigzag_scan8x8_q0       = h->zigzag_scan8x8;
714         h->zigzag_scan8x8_cavlc_q0 = h->zigzag_scan8x8_cavlc;
715         h->field_scan_q0           = h->field_scan;
716         h->field_scan8x8_q0        = h->field_scan8x8;
717         h->field_scan8x8_cavlc_q0  = h->field_scan8x8_cavlc;
718     }
719 }
720
721 static enum AVPixelFormat get_pixel_format(H264Context *h)
722 {
723 #define HWACCEL_MAX (CONFIG_H264_DXVA2_HWACCEL + \
724                      (CONFIG_H264_D3D11VA_HWACCEL * 2) + \
725                      CONFIG_H264_VAAPI_HWACCEL + \
726                      (CONFIG_H264_VDA_HWACCEL * 2) + \
727                      CONFIG_H264_VDPAU_HWACCEL)
728     enum AVPixelFormat pix_fmts[HWACCEL_MAX + 2], *fmt = pix_fmts;
729     const enum AVPixelFormat *choices = pix_fmts;
730
731     switch (h->ps.sps->bit_depth_luma) {
732     case 9:
733         if (CHROMA444(h)) {
734             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
735                 *fmt++ = AV_PIX_FMT_GBRP9;
736             } else
737                 *fmt++ = AV_PIX_FMT_YUV444P9;
738         } else if (CHROMA422(h))
739             *fmt++ = AV_PIX_FMT_YUV422P9;
740         else
741             *fmt++ = AV_PIX_FMT_YUV420P9;
742         break;
743     case 10:
744         if (CHROMA444(h)) {
745             if (h->avctx->colorspace == AVCOL_SPC_RGB) {
746                 *fmt++ = AV_PIX_FMT_GBRP10;
747             } else
748                 *fmt++ = AV_PIX_FMT_YUV444P10;
749         } else if (CHROMA422(h))
750             *fmt++ = AV_PIX_FMT_YUV422P10;
751         else
752             *fmt++ = AV_PIX_FMT_YUV420P10;
753         break;
754     case 8:
755 #if CONFIG_H264_VDPAU_HWACCEL
756         *fmt++ = AV_PIX_FMT_VDPAU;
757 #endif
758         if (CHROMA444(h)) {
759             if (h->avctx->colorspace == AVCOL_SPC_RGB)
760                 *fmt++ = AV_PIX_FMT_GBRP;
761             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
762                 *fmt++ = AV_PIX_FMT_YUVJ444P;
763             else
764                 *fmt++ = AV_PIX_FMT_YUV444P;
765         } else if (CHROMA422(h)) {
766             if (h->avctx->color_range == AVCOL_RANGE_JPEG)
767                 *fmt++ = AV_PIX_FMT_YUVJ422P;
768             else
769                 *fmt++ = AV_PIX_FMT_YUV422P;
770         } else {
771 #if CONFIG_H264_DXVA2_HWACCEL
772             *fmt++ = AV_PIX_FMT_DXVA2_VLD;
773 #endif
774 #if CONFIG_H264_D3D11VA_HWACCEL
775             *fmt++ = AV_PIX_FMT_D3D11VA_VLD;
776             *fmt++ = AV_PIX_FMT_D3D11;
777 #endif
778 #if CONFIG_H264_VAAPI_HWACCEL
779             *fmt++ = AV_PIX_FMT_VAAPI;
780 #endif
781 #if CONFIG_H264_VDA_HWACCEL
782             *fmt++ = AV_PIX_FMT_VDA_VLD;
783             *fmt++ = AV_PIX_FMT_VDA;
784 #endif
785             if (h->avctx->codec->pix_fmts)
786                 choices = h->avctx->codec->pix_fmts;
787             else if (h->avctx->color_range == AVCOL_RANGE_JPEG)
788                 *fmt++ = AV_PIX_FMT_YUVJ420P;
789             else
790                 *fmt++ = AV_PIX_FMT_YUV420P;
791         }
792         break;
793     default:
794         av_log(h->avctx, AV_LOG_ERROR,
795                "Unsupported bit depth %d\n", h->ps.sps->bit_depth_luma);
796         return AVERROR_INVALIDDATA;
797     }
798
799     *fmt = AV_PIX_FMT_NONE;
800
801     return ff_get_format(h->avctx, choices);
802 }
803
804 /* export coded and cropped frame dimensions to AVCodecContext */
805 static int init_dimensions(H264Context *h)
806 {
807     SPS *sps = h->ps.sps;
808     int cr = sps->crop_right;
809     int cl = sps->crop_left;
810     int ct = sps->crop_top;
811     int cb = sps->crop_bottom;
812     int width  = h->width  - (cr + cl);
813     int height = h->height - (ct + cb);
814
815     /* handle container cropping */
816     if (h->width_from_caller > 0 && h->height_from_caller > 0     &&
817         !sps->crop_top && !sps->crop_left                         &&
818         FFALIGN(h->width_from_caller,  16) == FFALIGN(width,  16) &&
819         FFALIGN(h->height_from_caller, 16) == FFALIGN(height, 16)) {
820         width  = h->width_from_caller;
821         height = h->height_from_caller;
822         cl = 0;
823         ct = 0;
824         cr = h->width - width;
825         cb = h->height - height;
826     } else {
827         h->width_from_caller  = 0;
828         h->height_from_caller = 0;
829     }
830
831     h->avctx->coded_width  = h->width;
832     h->avctx->coded_height = h->height;
833     h->avctx->width        = width;
834     h->avctx->height       = height;
835     h->crop_right          = cr;
836     h->crop_left           = cl;
837     h->crop_top            = ct;
838     h->crop_bottom         = cb;
839
840     return 0;
841 }
842
843 static int h264_slice_header_init(H264Context *h)
844 {
845     const SPS *sps = h->ps.sps;
846     int i, ret;
847
848     ff_set_sar(h->avctx, sps->sar);
849     av_pix_fmt_get_chroma_sub_sample(h->avctx->pix_fmt,
850                                      &h->chroma_x_shift, &h->chroma_y_shift);
851
852     if (sps->timing_info_present_flag) {
853         int64_t den = sps->time_scale;
854         if (h->x264_build < 44U)
855             den *= 2;
856         av_reduce(&h->avctx->framerate.den, &h->avctx->framerate.num,
857                   sps->num_units_in_tick, den, 1 << 30);
858     }
859
860     ff_h264_free_tables(h);
861
862     h->first_field           = 0;
863     h->prev_interlaced_frame = 1;
864
865     init_scan_tables(h);
866     ret = ff_h264_alloc_tables(h);
867     if (ret < 0) {
868         av_log(h->avctx, AV_LOG_ERROR, "Could not allocate memory\n");
869         return ret;
870     }
871
872     if (sps->bit_depth_luma < 8 || sps->bit_depth_luma > 10) {
873         av_log(h->avctx, AV_LOG_ERROR, "Unsupported bit depth %d\n",
874                sps->bit_depth_luma);
875         return AVERROR_INVALIDDATA;
876     }
877
878     h->avctx->bits_per_raw_sample = sps->bit_depth_luma;
879     h->pixel_shift                = sps->bit_depth_luma > 8;
880     h->chroma_format_idc          = sps->chroma_format_idc;
881     h->bit_depth_luma             = sps->bit_depth_luma;
882
883     ff_h264dsp_init(&h->h264dsp, sps->bit_depth_luma,
884                     sps->chroma_format_idc);
885     ff_h264chroma_init(&h->h264chroma, sps->bit_depth_chroma);
886     ff_h264qpel_init(&h->h264qpel, sps->bit_depth_luma);
887     ff_h264_pred_init(&h->hpc, h->avctx->codec_id, sps->bit_depth_luma,
888                       sps->chroma_format_idc);
889     ff_videodsp_init(&h->vdsp, sps->bit_depth_luma);
890
891     if (!HAVE_THREADS || !(h->avctx->active_thread_type & FF_THREAD_SLICE)) {
892         ret = ff_h264_slice_context_init(h, &h->slice_ctx[0]);
893         if (ret < 0) {
894             av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
895             return ret;
896         }
897     } else {
898         for (i = 0; i < h->nb_slice_ctx; i++) {
899             H264SliceContext *sl = &h->slice_ctx[i];
900
901             sl->h264               = h;
902             sl->intra4x4_pred_mode = h->intra4x4_pred_mode + i * 8 * 2 * h->mb_stride;
903             sl->mvd_table[0]       = h->mvd_table[0]       + i * 8 * 2 * h->mb_stride;
904             sl->mvd_table[1]       = h->mvd_table[1]       + i * 8 * 2 * h->mb_stride;
905
906             if ((ret = ff_h264_slice_context_init(h, sl)) < 0) {
907                 av_log(h->avctx, AV_LOG_ERROR, "context_init() failed.\n");
908                 return ret;
909             }
910         }
911     }
912
913     h->context_initialized = 1;
914
915     return 0;
916 }
917
918 static int h264_init_ps(H264Context *h, const H264SliceContext *sl)
919 {
920     const SPS *sps;
921     int needs_reinit = 0, ret;
922
923     h->ps.pps = (const PPS*)h->ps.pps_list[sl->pps_id]->data;
924     if (h->ps.sps != (const SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data) {
925         h->ps.sps = (SPS*)h->ps.sps_list[h->ps.pps->sps_id]->data;
926
927         if (h->bit_depth_luma    != h->ps.sps->bit_depth_luma ||
928             h->chroma_format_idc != h->ps.sps->chroma_format_idc)
929             needs_reinit         = 1;
930     }
931     sps = h->ps.sps;
932
933     h->avctx->profile = ff_h264_get_profile(sps);
934     h->avctx->level   = sps->level_idc;
935     h->avctx->refs    = sps->ref_frame_count;
936
937     if (h->mb_width  != sps->mb_width ||
938         h->mb_height != sps->mb_height)
939         needs_reinit = 1;
940
941     h->mb_width  = sps->mb_width;
942     h->mb_height = sps->mb_height;
943     h->mb_num    = h->mb_width * h->mb_height;
944     h->mb_stride = h->mb_width + 1;
945
946     h->b_stride = h->mb_width * 4;
947
948     h->chroma_y_shift = sps->chroma_format_idc <= 1; // 400 uses yuv420p
949
950     h->width  = 16 * h->mb_width;
951     h->height = 16 * h->mb_height;
952
953     ret = init_dimensions(h);
954     if (ret < 0)
955         return ret;
956
957     if (sps->video_signal_type_present_flag) {
958         h->avctx->color_range = sps->full_range ? AVCOL_RANGE_JPEG
959             : AVCOL_RANGE_MPEG;
960         if (sps->colour_description_present_flag) {
961             if (h->avctx->colorspace != sps->colorspace)
962                 needs_reinit = 1;
963             h->avctx->color_primaries = sps->color_primaries;
964             h->avctx->color_trc       = sps->color_trc;
965             h->avctx->colorspace      = sps->colorspace;
966         }
967     }
968
969     if (!h->context_initialized || needs_reinit) {
970         h->context_initialized = 0;
971         if (sl != h->slice_ctx) {
972             av_log(h->avctx, AV_LOG_ERROR,
973                    "changing width %d -> %d / height %d -> %d on "
974                    "slice %d\n",
975                    h->width, h->avctx->coded_width,
976                    h->height, h->avctx->coded_height,
977                    h->current_slice + 1);
978             return AVERROR_INVALIDDATA;
979         }
980
981         ff_h264_flush_change(h);
982
983         if ((ret = get_pixel_format(h)) < 0)
984             return ret;
985         h->avctx->pix_fmt = ret;
986
987         av_log(h->avctx, AV_LOG_VERBOSE, "Reinit context to %dx%d, "
988                "pix_fmt: %d\n", h->width, h->height, h->avctx->pix_fmt);
989
990         if ((ret = h264_slice_header_init(h)) < 0) {
991             av_log(h->avctx, AV_LOG_ERROR,
992                    "h264_slice_header_init() failed\n");
993             return ret;
994         }
995     }
996
997     return 0;
998 }
999
1000 static int h264_export_frame_props(H264Context *h)
1001 {
1002     const SPS *sps = h->ps.sps;
1003     H264Picture *cur = h->cur_pic_ptr;
1004
1005     cur->f->interlaced_frame = 0;
1006     cur->f->repeat_pict      = 0;
1007
1008     /* Signal interlacing information externally. */
1009     /* Prioritize picture timing SEI information over used
1010      * decoding process if it exists. */
1011
1012     if (sps->pic_struct_present_flag && h->sei.picture_timing.present) {
1013         H264SEIPictureTiming *pt = &h->sei.picture_timing;
1014         switch (pt->pic_struct) {
1015         case H264_SEI_PIC_STRUCT_FRAME:
1016             break;
1017         case H264_SEI_PIC_STRUCT_TOP_FIELD:
1018         case H264_SEI_PIC_STRUCT_BOTTOM_FIELD:
1019             cur->f->interlaced_frame = 1;
1020             break;
1021         case H264_SEI_PIC_STRUCT_TOP_BOTTOM:
1022         case H264_SEI_PIC_STRUCT_BOTTOM_TOP:
1023             if (FIELD_OR_MBAFF_PICTURE(h))
1024                 cur->f->interlaced_frame = 1;
1025             else
1026                 // try to flag soft telecine progressive
1027                 cur->f->interlaced_frame = h->prev_interlaced_frame;
1028             break;
1029         case H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP:
1030         case H264_SEI_PIC_STRUCT_BOTTOM_TOP_BOTTOM:
1031             /* Signal the possibility of telecined film externally
1032              * (pic_struct 5,6). From these hints, let the applications
1033              * decide if they apply deinterlacing. */
1034             cur->f->repeat_pict = 1;
1035             break;
1036         case H264_SEI_PIC_STRUCT_FRAME_DOUBLING:
1037             cur->f->repeat_pict = 2;
1038             break;
1039         case H264_SEI_PIC_STRUCT_FRAME_TRIPLING:
1040             cur->f->repeat_pict = 4;
1041             break;
1042         }
1043
1044         if ((pt->ct_type & 3) &&
1045             pt->pic_struct <= H264_SEI_PIC_STRUCT_BOTTOM_TOP)
1046             cur->f->interlaced_frame = (pt->ct_type & (1 << 1)) != 0;
1047     } else {
1048         /* Derive interlacing flag from used decoding process. */
1049         cur->f->interlaced_frame = FIELD_OR_MBAFF_PICTURE(h);
1050     }
1051     h->prev_interlaced_frame = cur->f->interlaced_frame;
1052
1053     if (cur->field_poc[0] != cur->field_poc[1]) {
1054         /* Derive top_field_first from field pocs. */
1055         cur->f->top_field_first = cur->field_poc[0] < cur->field_poc[1];
1056     } else {
1057         if (cur->f->interlaced_frame ||
1058             (sps->pic_struct_present_flag && h->sei.picture_timing.present)) {
1059             /* Use picture timing SEI information. Even if it is a
1060              * information of a past frame, better than nothing. */
1061             if (h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM ||
1062                 h->sei.picture_timing.pic_struct == H264_SEI_PIC_STRUCT_TOP_BOTTOM_TOP)
1063                 cur->f->top_field_first = 1;
1064             else
1065                 cur->f->top_field_first = 0;
1066         } else {
1067             /* Most likely progressive */
1068             cur->f->top_field_first = 0;
1069         }
1070     }
1071
1072     if (h->sei.frame_packing.present &&
1073         h->sei.frame_packing.arrangement_type >= 0 &&
1074         h->sei.frame_packing.arrangement_type <= 6 &&
1075         h->sei.frame_packing.content_interpretation_type > 0 &&
1076         h->sei.frame_packing.content_interpretation_type < 3) {
1077         H264SEIFramePacking *fp = &h->sei.frame_packing;
1078         AVStereo3D *stereo = av_stereo3d_create_side_data(cur->f);
1079         if (!stereo)
1080             return AVERROR(ENOMEM);
1081
1082         switch (fp->arrangement_type) {
1083         case 0:
1084             stereo->type = AV_STEREO3D_CHECKERBOARD;
1085             break;
1086         case 1:
1087             stereo->type = AV_STEREO3D_COLUMNS;
1088             break;
1089         case 2:
1090             stereo->type = AV_STEREO3D_LINES;
1091             break;
1092         case 3:
1093             if (fp->quincunx_subsampling)
1094                 stereo->type = AV_STEREO3D_SIDEBYSIDE_QUINCUNX;
1095             else
1096                 stereo->type = AV_STEREO3D_SIDEBYSIDE;
1097             break;
1098         case 4:
1099             stereo->type = AV_STEREO3D_TOPBOTTOM;
1100             break;
1101         case 5:
1102             stereo->type = AV_STEREO3D_FRAMESEQUENCE;
1103             break;
1104         case 6:
1105             stereo->type = AV_STEREO3D_2D;
1106             break;
1107         }
1108
1109         if (fp->content_interpretation_type == 2)
1110             stereo->flags = AV_STEREO3D_FLAG_INVERT;
1111     }
1112
1113     if (h->sei.display_orientation.present &&
1114         (h->sei.display_orientation.anticlockwise_rotation ||
1115          h->sei.display_orientation.hflip ||
1116          h->sei.display_orientation.vflip)) {
1117         H264SEIDisplayOrientation *o = &h->sei.display_orientation;
1118         double angle = o->anticlockwise_rotation * 360 / (double) (1 << 16);
1119         AVFrameSideData *rotation = av_frame_new_side_data(cur->f,
1120                                                            AV_FRAME_DATA_DISPLAYMATRIX,
1121                                                            sizeof(int32_t) * 9);
1122         if (!rotation)
1123             return AVERROR(ENOMEM);
1124
1125         av_display_rotation_set((int32_t *)rotation->data, angle);
1126         av_display_matrix_flip((int32_t *)rotation->data,
1127                                o->hflip, o->vflip);
1128     }
1129
1130     if (h->sei.afd.present) {
1131         AVFrameSideData *sd = av_frame_new_side_data(cur->f, AV_FRAME_DATA_AFD,
1132                                                      sizeof(uint8_t));
1133         if (!sd)
1134             return AVERROR(ENOMEM);
1135
1136         *sd->data = h->sei.afd.active_format_description;
1137         h->sei.afd.present = 0;
1138     }
1139
1140     if (h->sei.a53_caption.a53_caption) {
1141         H264SEIA53Caption *a53 = &h->sei.a53_caption;
1142         AVFrameSideData *sd = av_frame_new_side_data(cur->f,
1143                                                      AV_FRAME_DATA_A53_CC,
1144                                                      a53->a53_caption_size);
1145         if (!sd)
1146             return AVERROR(ENOMEM);
1147
1148         memcpy(sd->data, a53->a53_caption, a53->a53_caption_size);
1149         av_freep(&a53->a53_caption);
1150         a53->a53_caption_size = 0;
1151     }
1152
1153     return 0;
1154 }
1155
1156 static int h264_select_output_frame(H264Context *h)
1157 {
1158     const SPS *sps = h->ps.sps;
1159     H264Picture *out = h->cur_pic_ptr;
1160     H264Picture *cur = h->cur_pic_ptr;
1161     int i, pics, out_of_order, out_idx;
1162     int invalid = 0, cnt = 0;
1163     int ret;
1164
1165     if (sps->bitstream_restriction_flag ||
1166         h->avctx->strict_std_compliance >= FF_COMPLIANCE_NORMAL) {
1167         h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, sps->num_reorder_frames);
1168     }
1169
1170     pics = 0;
1171     while (h->delayed_pic[pics])
1172         pics++;
1173
1174     assert(pics <= MAX_DELAYED_PIC_COUNT);
1175
1176     h->delayed_pic[pics++] = cur;
1177     if (cur->reference == 0)
1178         cur->reference = DELAYED_PIC_REF;
1179
1180     /* Frame reordering. This code takes pictures from coding order and sorts
1181      * them by their incremental POC value into display order. It supports POC
1182      * gaps, MMCO reset codes and random resets.
1183      * A "display group" can start either with a IDR frame (f.key_frame = 1),
1184      * and/or can be closed down with a MMCO reset code. In sequences where
1185      * there is no delay, we can't detect that (since the frame was already
1186      * output to the user), so we also set h->mmco_reset to detect the MMCO
1187      * reset code.
1188      * FIXME: if we detect insufficient delays (as per h->avctx->has_b_frames),
1189      * we increase the delay between input and output. All frames affected by
1190      * the lag (e.g. those that should have been output before another frame
1191      * that we already returned to the user) will be dropped. This is a bug
1192      * that we will fix later. */
1193     for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++) {
1194         cnt     += out->poc < h->last_pocs[i];
1195         invalid += out->poc == INT_MIN;
1196     }
1197     if (!h->mmco_reset && !cur->f->key_frame &&
1198         cnt + invalid == MAX_DELAYED_PIC_COUNT && cnt > 0) {
1199         h->mmco_reset = 2;
1200         if (pics > 1)
1201             h->delayed_pic[pics - 2]->mmco_reset = 2;
1202     }
1203     if (h->mmco_reset || cur->f->key_frame) {
1204         for (i = 0; i < MAX_DELAYED_PIC_COUNT; i++)
1205             h->last_pocs[i] = INT_MIN;
1206         cnt     = 0;
1207         invalid = MAX_DELAYED_PIC_COUNT;
1208     }
1209     out     = h->delayed_pic[0];
1210     out_idx = 0;
1211     for (i = 1; i < MAX_DELAYED_PIC_COUNT &&
1212                 h->delayed_pic[i] &&
1213                 !h->delayed_pic[i - 1]->mmco_reset &&
1214                 !h->delayed_pic[i]->f->key_frame;
1215          i++)
1216         if (h->delayed_pic[i]->poc < out->poc) {
1217             out     = h->delayed_pic[i];
1218             out_idx = i;
1219         }
1220     if (h->avctx->has_b_frames == 0 &&
1221         (h->delayed_pic[0]->f->key_frame || h->mmco_reset))
1222         h->next_outputed_poc = INT_MIN;
1223     out_of_order = !out->f->key_frame && !h->mmco_reset &&
1224                    (out->poc < h->next_outputed_poc);
1225
1226     if (sps->bitstream_restriction_flag &&
1227         h->avctx->has_b_frames >= sps->num_reorder_frames) {
1228     } else if (out_of_order && pics - 1 == h->avctx->has_b_frames &&
1229                h->avctx->has_b_frames < MAX_DELAYED_PIC_COUNT) {
1230         if (invalid + cnt < MAX_DELAYED_PIC_COUNT) {
1231             h->avctx->has_b_frames = FFMAX(h->avctx->has_b_frames, cnt);
1232         }
1233     } else if (!h->avctx->has_b_frames &&
1234                ((h->next_outputed_poc != INT_MIN &&
1235                  out->poc > h->next_outputed_poc + 2) ||
1236                 cur->f->pict_type == AV_PICTURE_TYPE_B)) {
1237         h->avctx->has_b_frames++;
1238     }
1239
1240     if (pics > h->avctx->has_b_frames) {
1241         out->reference &= ~DELAYED_PIC_REF;
1242         for (i = out_idx; h->delayed_pic[i]; i++)
1243             h->delayed_pic[i] = h->delayed_pic[i + 1];
1244     }
1245     memmove(h->last_pocs, &h->last_pocs[1],
1246             sizeof(*h->last_pocs) * (MAX_DELAYED_PIC_COUNT - 1));
1247     h->last_pocs[MAX_DELAYED_PIC_COUNT - 1] = cur->poc;
1248     if (!out_of_order && pics > h->avctx->has_b_frames) {
1249         av_frame_unref(h->output_frame);
1250         ret = av_frame_ref(h->output_frame, out->f);
1251         if (ret < 0)
1252             return ret;
1253
1254         if (out->recovered) {
1255             // We have reached an recovery point and all frames after it in
1256             // display order are "recovered".
1257             h->frame_recovered |= FRAME_RECOVERED_SEI;
1258         }
1259         out->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_SEI);
1260
1261         if (!out->recovered) {
1262             if (!(h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT))
1263                 av_frame_unref(h->output_frame);
1264             else
1265                 h->output_frame->flags |= AV_FRAME_FLAG_CORRUPT;
1266         }
1267
1268         if (out->mmco_reset) {
1269             if (out_idx > 0) {
1270                 h->next_outputed_poc                    = out->poc;
1271                 h->delayed_pic[out_idx - 1]->mmco_reset = out->mmco_reset;
1272             } else {
1273                 h->next_outputed_poc = INT_MIN;
1274             }
1275         } else {
1276             if (out_idx == 0 && pics > 1 && h->delayed_pic[0]->f->key_frame) {
1277                 h->next_outputed_poc = INT_MIN;
1278             } else {
1279                 h->next_outputed_poc = out->poc;
1280             }
1281         }
1282         h->mmco_reset = 0;
1283     } else {
1284         av_log(h->avctx, AV_LOG_DEBUG, "no picture\n");
1285     }
1286
1287     return 0;
1288 }
1289
1290 /* This function is called right after decoding the slice header for a first
1291  * slice in a field (or a frame). It decides whether we are decoding a new frame
1292  * or a second field in a pair and does the necessary setup.
1293  */
1294 static int h264_field_start(H264Context *h, const H264SliceContext *sl,
1295                             const H2645NAL *nal)
1296 {
1297     const SPS *sps;
1298
1299     int last_pic_structure, last_pic_droppable, ret;
1300
1301     ret = h264_init_ps(h, sl);
1302     if (ret < 0)
1303         return ret;
1304
1305     sps = h->ps.sps;
1306
1307     last_pic_droppable   = h->droppable;
1308     last_pic_structure   = h->picture_structure;
1309     h->droppable         = (nal->ref_idc == 0);
1310     h->picture_structure = sl->picture_structure;
1311
1312     h->poc.frame_num        = sl->frame_num;
1313     h->poc.poc_lsb          = sl->poc_lsb;
1314     h->poc.delta_poc_bottom = sl->delta_poc_bottom;
1315     h->poc.delta_poc[0]     = sl->delta_poc[0];
1316     h->poc.delta_poc[1]     = sl->delta_poc[1];
1317
1318     /* Shorten frame num gaps so we don't have to allocate reference
1319      * frames just to throw them away */
1320     if (h->poc.frame_num != h->poc.prev_frame_num) {
1321         int unwrap_prev_frame_num = h->poc.prev_frame_num;
1322         int max_frame_num         = 1 << sps->log2_max_frame_num;
1323
1324         if (unwrap_prev_frame_num > h->poc.frame_num)
1325             unwrap_prev_frame_num -= max_frame_num;
1326
1327         if ((h->poc.frame_num - unwrap_prev_frame_num) > sps->ref_frame_count) {
1328             unwrap_prev_frame_num = (h->poc.frame_num - sps->ref_frame_count) - 1;
1329             if (unwrap_prev_frame_num < 0)
1330                 unwrap_prev_frame_num += max_frame_num;
1331
1332             h->poc.prev_frame_num = unwrap_prev_frame_num;
1333         }
1334     }
1335
1336     /* See if we have a decoded first field looking for a pair...
1337      * Here, we're using that to see if we should mark previously
1338      * decode frames as "finished".
1339      * We have to do that before the "dummy" in-between frame allocation,
1340      * since that can modify s->current_picture_ptr. */
1341     if (h->first_field) {
1342         assert(h->cur_pic_ptr);
1343         assert(h->cur_pic_ptr->f->buf[0]);
1344         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1345
1346         /* figure out if we have a complementary field pair */
1347         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1348             /* Previous field is unmatched. Don't display it, but let it
1349              * remain for reference if marked as such. */
1350             if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {
1351                 ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1352                                           last_pic_structure == PICT_TOP_FIELD);
1353             }
1354         } else {
1355             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1356                 /* This and previous field were reference, but had
1357                  * different frame_nums. Consider this field first in
1358                  * pair. Throw away previous field except for reference
1359                  * purposes. */
1360                 if (!last_pic_droppable && last_pic_structure != PICT_FRAME) {
1361                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1362                                               last_pic_structure == PICT_TOP_FIELD);
1363                 }
1364             } else {
1365                 /* Second field in complementary pair */
1366                 if (!((last_pic_structure   == PICT_TOP_FIELD &&
1367                        h->picture_structure == PICT_BOTTOM_FIELD) ||
1368                       (last_pic_structure   == PICT_BOTTOM_FIELD &&
1369                        h->picture_structure == PICT_TOP_FIELD))) {
1370                     av_log(h->avctx, AV_LOG_ERROR,
1371                            "Invalid field mode combination %d/%d\n",
1372                            last_pic_structure, h->picture_structure);
1373                     h->picture_structure = last_pic_structure;
1374                     h->droppable         = last_pic_droppable;
1375                     return AVERROR_INVALIDDATA;
1376                 } else if (last_pic_droppable != h->droppable) {
1377                     avpriv_request_sample(h->avctx,
1378                                           "Found reference and non-reference fields in the same frame, which");
1379                     h->picture_structure = last_pic_structure;
1380                     h->droppable         = last_pic_droppable;
1381                     return AVERROR_PATCHWELCOME;
1382                 }
1383             }
1384         }
1385     }
1386
1387     while (h->poc.frame_num != h->poc.prev_frame_num &&
1388            h->poc.frame_num != (h->poc.prev_frame_num + 1) % (1 << sps->log2_max_frame_num)) {
1389         H264Picture *prev = h->short_ref_count ? h->short_ref[0] : NULL;
1390         av_log(h->avctx, AV_LOG_DEBUG, "Frame num gap %d %d\n",
1391                h->poc.frame_num, h->poc.prev_frame_num);
1392         ret = initialize_cur_frame(h);
1393         if (ret < 0) {
1394             h->first_field = 0;
1395             return ret;
1396         }
1397
1398         h->poc.prev_frame_num++;
1399         h->poc.prev_frame_num        %= 1 << sps->log2_max_frame_num;
1400         h->cur_pic_ptr->frame_num = h->poc.prev_frame_num;
1401         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 0);
1402         ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, 1);
1403
1404         h->explicit_ref_marking = 0;
1405         ret = ff_h264_execute_ref_pic_marking(h);
1406         if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1407             return ret;
1408         /* Error concealment: If a ref is missing, copy the previous ref
1409          * in its place.
1410          * FIXME: Avoiding a memcpy would be nice, but ref handling makes
1411          * many assumptions about there being no actual duplicates.
1412          * FIXME: This does not copy padding for out-of-frame motion
1413          * vectors.  Given we are concealing a lost frame, this probably
1414          * is not noticeable by comparison, but it should be fixed. */
1415         if (h->short_ref_count) {
1416             if (prev &&
1417                 h->short_ref[0]->f->width == prev->f->width &&
1418                 h->short_ref[0]->f->height == prev->f->height &&
1419                 h->short_ref[0]->f->format == prev->f->format) {
1420                 ff_thread_await_progress(&prev->tf, INT_MAX, 0);
1421                 if (prev->field_picture)
1422                     ff_thread_await_progress(&prev->tf, INT_MAX, 1);
1423                 av_image_copy(h->short_ref[0]->f->data,
1424                               h->short_ref[0]->f->linesize,
1425                               (const uint8_t **)prev->f->data,
1426                               prev->f->linesize,
1427                               prev->f->format,
1428                               h->mb_width  * 16,
1429                               h->mb_height * 16);
1430                 h->short_ref[0]->poc = prev->poc + 2;
1431             }
1432             h->short_ref[0]->frame_num = h->poc.prev_frame_num;
1433         }
1434     }
1435
1436     /* See if we have a decoded first field looking for a pair...
1437      * We're using that to see whether to continue decoding in that
1438      * frame, or to allocate a new one. */
1439     if (h->first_field) {
1440         assert(h->cur_pic_ptr);
1441         assert(h->cur_pic_ptr->f->buf[0]);
1442         assert(h->cur_pic_ptr->reference != DELAYED_PIC_REF);
1443
1444         /* figure out if we have a complementary field pair */
1445         if (!FIELD_PICTURE(h) || h->picture_structure == last_pic_structure) {
1446             /* Previous field is unmatched. Don't display it, but let it
1447              * remain for reference if marked as such. */
1448             h->cur_pic_ptr = NULL;
1449             h->first_field = FIELD_PICTURE(h);
1450         } else {
1451             if (h->cur_pic_ptr->frame_num != h->poc.frame_num) {
1452                 /* This and the previous field had different frame_nums.
1453                  * Consider this field first in pair. Throw away previous
1454                  * one except for reference purposes. */
1455                 h->first_field = 1;
1456                 h->cur_pic_ptr = NULL;
1457             } else {
1458                 /* Second field in complementary pair */
1459                 h->first_field = 0;
1460             }
1461         }
1462     } else {
1463         /* Frame or first field in a potentially complementary pair */
1464         h->first_field = FIELD_PICTURE(h);
1465     }
1466
1467     if (!FIELD_PICTURE(h) || h->first_field) {
1468         if (h264_frame_start(h) < 0) {
1469             h->first_field = 0;
1470             return AVERROR_INVALIDDATA;
1471         }
1472     } else {
1473         release_unused_pictures(h, 0);
1474     }
1475
1476     ff_h264_init_poc(h->cur_pic_ptr->field_poc, &h->cur_pic_ptr->poc,
1477                      h->ps.sps, &h->poc, h->picture_structure, nal->ref_idc);
1478
1479     memcpy(h->mmco, sl->mmco, sl->nb_mmco * sizeof(*h->mmco));
1480     h->nb_mmco = sl->nb_mmco;
1481     h->explicit_ref_marking = sl->explicit_ref_marking;
1482
1483     h->picture_idr = nal->type == H264_NAL_IDR_SLICE;
1484
1485     if (h->sei.recovery_point.recovery_frame_cnt >= 0 && h->recovery_frame < 0) {
1486         h->recovery_frame = (h->poc.frame_num + h->sei.recovery_point.recovery_frame_cnt) &
1487                             ((1 << h->ps.sps->log2_max_frame_num) - 1);
1488     }
1489
1490     h->cur_pic_ptr->f->key_frame |= (nal->type == H264_NAL_IDR_SLICE) ||
1491                                     (h->sei.recovery_point.recovery_frame_cnt >= 0);
1492
1493     if (nal->type == H264_NAL_IDR_SLICE || h->recovery_frame == h->poc.frame_num) {
1494         h->recovery_frame         = -1;
1495         h->cur_pic_ptr->recovered = 1;
1496     }
1497     // If we have an IDR, all frames after it in decoded order are
1498     // "recovered".
1499     if (nal->type == H264_NAL_IDR_SLICE)
1500         h->frame_recovered |= FRAME_RECOVERED_IDR;
1501     h->cur_pic_ptr->recovered |= !!(h->frame_recovered & FRAME_RECOVERED_IDR);
1502
1503     /* Set the frame properties/side data. Only done for the second field in
1504      * field coded frames, since some SEI information is present for each field
1505      * and is merged by the SEI parsing code. */
1506     if (!FIELD_PICTURE(h) || !h->first_field) {
1507         ret = h264_export_frame_props(h);
1508         if (ret < 0)
1509             return ret;
1510
1511         ret = h264_select_output_frame(h);
1512         if (ret < 0)
1513             return ret;
1514     }
1515
1516     if (h->avctx->hwaccel) {
1517         ret = h->avctx->hwaccel->start_frame(h->avctx, NULL, 0);
1518         if (ret < 0)
1519             return ret;
1520     }
1521
1522     return 0;
1523 }
1524
1525 static int h264_slice_header_parse(H264SliceContext *sl, const H2645NAL *nal,
1526                                    const H264ParamSets *ps, AVCodecContext *avctx)
1527 {
1528     const SPS *sps;
1529     const PPS *pps;
1530     int ret;
1531     unsigned int slice_type, tmp, i;
1532     int field_pic_flag, bottom_field_flag, picture_structure;
1533
1534     sl->first_mb_addr = get_ue_golomb(&sl->gb);
1535
1536     slice_type = get_ue_golomb_31(&sl->gb);
1537     if (slice_type > 9) {
1538         av_log(avctx, AV_LOG_ERROR,
1539                "slice type %d too large at %d\n",
1540                slice_type, sl->first_mb_addr);
1541         return AVERROR_INVALIDDATA;
1542     }
1543     if (slice_type > 4) {
1544         slice_type -= 5;
1545         sl->slice_type_fixed = 1;
1546     } else
1547         sl->slice_type_fixed = 0;
1548
1549     slice_type         = ff_h264_golomb_to_pict_type[slice_type];
1550     sl->slice_type     = slice_type;
1551     sl->slice_type_nos = slice_type & 3;
1552
1553     if (nal->type  == H264_NAL_IDR_SLICE &&
1554         sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1555         av_log(avctx, AV_LOG_ERROR, "A non-intra slice in an IDR NAL unit.\n");
1556         return AVERROR_INVALIDDATA;
1557     }
1558
1559     sl->pps_id = get_ue_golomb(&sl->gb);
1560     if (sl->pps_id >= MAX_PPS_COUNT) {
1561         av_log(avctx, AV_LOG_ERROR, "pps_id %u out of range\n", sl->pps_id);
1562         return AVERROR_INVALIDDATA;
1563     }
1564     if (!ps->pps_list[sl->pps_id]) {
1565         av_log(avctx, AV_LOG_ERROR,
1566                "non-existing PPS %u referenced\n",
1567                sl->pps_id);
1568         return AVERROR_INVALIDDATA;
1569     }
1570     pps = (const PPS*)ps->pps_list[sl->pps_id]->data;
1571
1572     if (!ps->sps_list[pps->sps_id]) {
1573         av_log(avctx, AV_LOG_ERROR,
1574                "non-existing SPS %u referenced\n", pps->sps_id);
1575         return AVERROR_INVALIDDATA;
1576     }
1577     sps = (const SPS*)ps->sps_list[pps->sps_id]->data;
1578
1579     sl->frame_num = get_bits(&sl->gb, sps->log2_max_frame_num);
1580
1581     sl->mb_mbaff       = 0;
1582
1583     if (sps->frame_mbs_only_flag) {
1584         picture_structure = PICT_FRAME;
1585     } else {
1586         field_pic_flag = get_bits1(&sl->gb);
1587         if (field_pic_flag) {
1588             bottom_field_flag = get_bits1(&sl->gb);
1589             picture_structure = PICT_TOP_FIELD + bottom_field_flag;
1590         } else {
1591             picture_structure = PICT_FRAME;
1592         }
1593     }
1594     sl->picture_structure      = picture_structure;
1595     sl->mb_field_decoding_flag = picture_structure != PICT_FRAME;
1596
1597     if (picture_structure == PICT_FRAME) {
1598         sl->curr_pic_num = sl->frame_num;
1599         sl->max_pic_num  = 1 << sps->log2_max_frame_num;
1600     } else {
1601         sl->curr_pic_num = 2 * sl->frame_num + 1;
1602         sl->max_pic_num  = 1 << (sps->log2_max_frame_num + 1);
1603     }
1604
1605     if (nal->type == H264_NAL_IDR_SLICE)
1606         get_ue_golomb(&sl->gb); /* idr_pic_id */
1607
1608     if (sps->poc_type == 0) {
1609         sl->poc_lsb = get_bits(&sl->gb, sps->log2_max_poc_lsb);
1610
1611         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1612             sl->delta_poc_bottom = get_se_golomb(&sl->gb);
1613     }
1614
1615     if (sps->poc_type == 1 && !sps->delta_pic_order_always_zero_flag) {
1616         sl->delta_poc[0] = get_se_golomb(&sl->gb);
1617
1618         if (pps->pic_order_present == 1 && picture_structure == PICT_FRAME)
1619             sl->delta_poc[1] = get_se_golomb(&sl->gb);
1620     }
1621
1622     sl->redundant_pic_count = 0;
1623     if (pps->redundant_pic_cnt_present)
1624         sl->redundant_pic_count = get_ue_golomb(&sl->gb);
1625
1626     if (sl->slice_type_nos == AV_PICTURE_TYPE_B)
1627         sl->direct_spatial_mv_pred = get_bits1(&sl->gb);
1628
1629     ret = ff_h264_parse_ref_count(&sl->list_count, sl->ref_count,
1630                                   &sl->gb, pps, sl->slice_type_nos,
1631                                   picture_structure);
1632     if (ret < 0)
1633         return ret;
1634
1635     if (sl->slice_type_nos != AV_PICTURE_TYPE_I) {
1636        ret = ff_h264_decode_ref_pic_list_reordering(sl, avctx);
1637        if (ret < 0) {
1638            sl->ref_count[1] = sl->ref_count[0] = 0;
1639            return ret;
1640        }
1641     }
1642
1643     sl->pwt.use_weight = 0;
1644     for (i = 0; i < 2; i++) {
1645         sl->pwt.luma_weight_flag[i]   = 0;
1646         sl->pwt.chroma_weight_flag[i] = 0;
1647     }
1648     if ((pps->weighted_pred && sl->slice_type_nos == AV_PICTURE_TYPE_P) ||
1649         (pps->weighted_bipred_idc == 1 &&
1650          sl->slice_type_nos == AV_PICTURE_TYPE_B))
1651         ff_h264_pred_weight_table(&sl->gb, sps, sl->ref_count,
1652                                   sl->slice_type_nos, &sl->pwt);
1653
1654     sl->explicit_ref_marking = 0;
1655     if (nal->ref_idc) {
1656         ret = ff_h264_decode_ref_pic_marking(sl, &sl->gb, nal, avctx);
1657         if (ret < 0 && (avctx->err_recognition & AV_EF_EXPLODE))
1658             return AVERROR_INVALIDDATA;
1659     }
1660
1661     if (sl->slice_type_nos != AV_PICTURE_TYPE_I && pps->cabac) {
1662         tmp = get_ue_golomb_31(&sl->gb);
1663         if (tmp > 2) {
1664             av_log(avctx, AV_LOG_ERROR, "cabac_init_idc %u overflow\n", tmp);
1665             return AVERROR_INVALIDDATA;
1666         }
1667         sl->cabac_init_idc = tmp;
1668     }
1669
1670     sl->last_qscale_diff = 0;
1671     tmp = pps->init_qp + get_se_golomb(&sl->gb);
1672     if (tmp > 51 + 6 * (sps->bit_depth_luma - 8)) {
1673         av_log(avctx, AV_LOG_ERROR, "QP %u out of range\n", tmp);
1674         return AVERROR_INVALIDDATA;
1675     }
1676     sl->qscale       = tmp;
1677     sl->chroma_qp[0] = get_chroma_qp(pps, 0, sl->qscale);
1678     sl->chroma_qp[1] = get_chroma_qp(pps, 1, sl->qscale);
1679     // FIXME qscale / qp ... stuff
1680     if (sl->slice_type == AV_PICTURE_TYPE_SP)
1681         get_bits1(&sl->gb); /* sp_for_switch_flag */
1682     if (sl->slice_type == AV_PICTURE_TYPE_SP ||
1683         sl->slice_type == AV_PICTURE_TYPE_SI)
1684         get_se_golomb(&sl->gb); /* slice_qs_delta */
1685
1686     sl->deblocking_filter     = 1;
1687     sl->slice_alpha_c0_offset = 0;
1688     sl->slice_beta_offset     = 0;
1689     if (pps->deblocking_filter_parameters_present) {
1690         tmp = get_ue_golomb_31(&sl->gb);
1691         if (tmp > 2) {
1692             av_log(avctx, AV_LOG_ERROR,
1693                    "deblocking_filter_idc %u out of range\n", tmp);
1694             return AVERROR_INVALIDDATA;
1695         }
1696         sl->deblocking_filter = tmp;
1697         if (sl->deblocking_filter < 2)
1698             sl->deblocking_filter ^= 1;  // 1<->0
1699
1700         if (sl->deblocking_filter) {
1701             sl->slice_alpha_c0_offset = get_se_golomb(&sl->gb) * 2;
1702             sl->slice_beta_offset     = get_se_golomb(&sl->gb) * 2;
1703             if (sl->slice_alpha_c0_offset >  12 ||
1704                 sl->slice_alpha_c0_offset < -12 ||
1705                 sl->slice_beta_offset >  12     ||
1706                 sl->slice_beta_offset < -12) {
1707                 av_log(avctx, AV_LOG_ERROR,
1708                        "deblocking filter parameters %d %d out of range\n",
1709                        sl->slice_alpha_c0_offset, sl->slice_beta_offset);
1710                 return AVERROR_INVALIDDATA;
1711             }
1712         }
1713     }
1714
1715     return 0;
1716 }
1717
1718 /* do all the per-slice initialization needed before we can start decoding the
1719  * actual MBs */
1720 static int h264_slice_init(H264Context *h, H264SliceContext *sl,
1721                            const H2645NAL *nal)
1722 {
1723     int i, j, ret = 0;
1724
1725     if (h->current_slice > 0) {
1726         if (h->ps.pps != (const PPS*)h->ps.pps_list[sl->pps_id]->data) {
1727             av_log(h->avctx, AV_LOG_ERROR, "PPS changed between slices\n");
1728             return AVERROR_INVALIDDATA;
1729         }
1730
1731         if (h->picture_structure != sl->picture_structure ||
1732             h->droppable         != (nal->ref_idc == 0)) {
1733             av_log(h->avctx, AV_LOG_ERROR,
1734                    "Changing field mode (%d -> %d) between slices is not allowed\n",
1735                    h->picture_structure, sl->picture_structure);
1736             return AVERROR_INVALIDDATA;
1737         } else if (!h->cur_pic_ptr) {
1738             av_log(h->avctx, AV_LOG_ERROR,
1739                    "unset cur_pic_ptr on slice %d\n",
1740                    h->current_slice + 1);
1741             return AVERROR_INVALIDDATA;
1742         }
1743     }
1744
1745     if (h->picture_idr && nal->type != H264_NAL_IDR_SLICE) {
1746         av_log(h->avctx, AV_LOG_ERROR, "Invalid mix of IDR and non-IDR slices\n");
1747         return AVERROR_INVALIDDATA;
1748     }
1749
1750     assert(h->mb_num == h->mb_width * h->mb_height);
1751     if (sl->first_mb_addr << FIELD_OR_MBAFF_PICTURE(h) >= h->mb_num ||
1752         sl->first_mb_addr >= h->mb_num) {
1753         av_log(h->avctx, AV_LOG_ERROR, "first_mb_in_slice overflow\n");
1754         return AVERROR_INVALIDDATA;
1755     }
1756     sl->resync_mb_x = sl->mb_x =  sl->first_mb_addr % h->mb_width;
1757     sl->resync_mb_y = sl->mb_y = (sl->first_mb_addr / h->mb_width) <<
1758                                  FIELD_OR_MBAFF_PICTURE(h);
1759     if (h->picture_structure == PICT_BOTTOM_FIELD)
1760         sl->resync_mb_y = sl->mb_y = sl->mb_y + 1;
1761     assert(sl->mb_y < h->mb_height);
1762
1763     ret = ff_h264_build_ref_list(h, sl);
1764     if (ret < 0)
1765         return ret;
1766
1767     if (h->ps.pps->weighted_bipred_idc == 2 &&
1768         sl->slice_type_nos == AV_PICTURE_TYPE_B) {
1769         implicit_weight_table(h, sl, -1);
1770         if (FRAME_MBAFF(h)) {
1771             implicit_weight_table(h, sl, 0);
1772             implicit_weight_table(h, sl, 1);
1773         }
1774     }
1775
1776     if (sl->slice_type_nos == AV_PICTURE_TYPE_B && !sl->direct_spatial_mv_pred)
1777         ff_h264_direct_dist_scale_factor(h, sl);
1778     ff_h264_direct_ref_list_init(h, sl);
1779
1780     if (h->avctx->skip_loop_filter >= AVDISCARD_ALL ||
1781         (h->avctx->skip_loop_filter >= AVDISCARD_NONKEY &&
1782          sl->slice_type_nos != AV_PICTURE_TYPE_I) ||
1783         (h->avctx->skip_loop_filter >= AVDISCARD_BIDIR  &&
1784          sl->slice_type_nos == AV_PICTURE_TYPE_B) ||
1785         (h->avctx->skip_loop_filter >= AVDISCARD_NONREF &&
1786          nal->ref_idc == 0))
1787         sl->deblocking_filter = 0;
1788
1789     if (sl->deblocking_filter == 1 && h->nb_slice_ctx > 1) {
1790         if (h->avctx->flags2 & AV_CODEC_FLAG2_FAST) {
1791             /* Cheat slightly for speed:
1792              * Do not bother to deblock across slices. */
1793             sl->deblocking_filter = 2;
1794         } else {
1795             h->postpone_filter = 1;
1796         }
1797     }
1798     sl->qp_thresh = 15 -
1799                    FFMIN(sl->slice_alpha_c0_offset, sl->slice_beta_offset) -
1800                    FFMAX3(0,
1801                           h->ps.pps->chroma_qp_index_offset[0],
1802                           h->ps.pps->chroma_qp_index_offset[1]) +
1803                    6 * (h->ps.sps->bit_depth_luma - 8);
1804
1805     sl->slice_num       = ++h->current_slice;
1806     if (sl->slice_num >= MAX_SLICES) {
1807         av_log(h->avctx, AV_LOG_ERROR,
1808                "Too many slices, increase MAX_SLICES and recompile\n");
1809     }
1810
1811     for (j = 0; j < 2; j++) {
1812         int id_list[16];
1813         int *ref2frm = h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][j];
1814         for (i = 0; i < 16; i++) {
1815             id_list[i] = 60;
1816             if (j < sl->list_count && i < sl->ref_count[j] &&
1817                 sl->ref_list[j][i].parent->f->buf[0]) {
1818                 int k;
1819                 AVBuffer *buf = sl->ref_list[j][i].parent->f->buf[0]->buffer;
1820                 for (k = 0; k < h->short_ref_count; k++)
1821                     if (h->short_ref[k]->f->buf[0]->buffer == buf) {
1822                         id_list[i] = k;
1823                         break;
1824                     }
1825                 for (k = 0; k < h->long_ref_count; k++)
1826                     if (h->long_ref[k] && h->long_ref[k]->f->buf[0]->buffer == buf) {
1827                         id_list[i] = h->short_ref_count + k;
1828                         break;
1829                     }
1830             }
1831         }
1832
1833         ref2frm[0] =
1834         ref2frm[1] = -1;
1835         for (i = 0; i < 16; i++)
1836             ref2frm[i + 2] = 4 * id_list[i] + (sl->ref_list[j][i].reference & 3);
1837         ref2frm[18 + 0] =
1838         ref2frm[18 + 1] = -1;
1839         for (i = 16; i < 48; i++)
1840             ref2frm[i + 4] = 4 * id_list[(i - 16) >> 1] +
1841                              (sl->ref_list[j][i].reference & 3);
1842     }
1843
1844     if (h->avctx->debug & FF_DEBUG_PICT_INFO) {
1845         av_log(h->avctx, AV_LOG_DEBUG,
1846                "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",
1847                sl->slice_num,
1848                (h->picture_structure == PICT_FRAME ? "F" : h->picture_structure == PICT_TOP_FIELD ? "T" : "B"),
1849                sl->mb_y * h->mb_width + sl->mb_x,
1850                av_get_picture_type_char(sl->slice_type),
1851                sl->slice_type_fixed ? " fix" : "",
1852                nal->type == H264_NAL_IDR_SLICE ? " IDR" : "",
1853                h->poc.frame_num,
1854                h->cur_pic_ptr->field_poc[0],
1855                h->cur_pic_ptr->field_poc[1],
1856                sl->ref_count[0], sl->ref_count[1],
1857                sl->qscale,
1858                sl->deblocking_filter,
1859                sl->slice_alpha_c0_offset, sl->slice_beta_offset,
1860                sl->pwt.use_weight,
1861                sl->pwt.use_weight == 1 && sl->pwt.use_weight_chroma ? "c" : "",
1862                sl->slice_type == AV_PICTURE_TYPE_B ? (sl->direct_spatial_mv_pred ? "SPAT" : "TEMP") : "");
1863     }
1864
1865     return 0;
1866 }
1867
1868 int ff_h264_queue_decode_slice(H264Context *h, const H2645NAL *nal)
1869 {
1870     H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued;
1871     int ret;
1872
1873     sl->gb = nal->gb;
1874
1875     ret = h264_slice_header_parse(sl, nal, &h->ps, h->avctx);
1876     if (ret < 0)
1877         return ret;
1878
1879     // discard redundant pictures
1880     if (sl->redundant_pic_count > 0)
1881         return 0;
1882
1883     if (!h->setup_finished) {
1884         if (sl->first_mb_addr == 0) { // FIXME better field boundary detection
1885             // this slice starts a new field
1886             // first decode any pending queued slices
1887             if (h->nb_slice_ctx_queued) {
1888                 H264SliceContext tmp_ctx;
1889
1890                 ret = ff_h264_execute_decode_slices(h);
1891                 if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE))
1892                     return ret;
1893
1894                 memcpy(&tmp_ctx, h->slice_ctx, sizeof(tmp_ctx));
1895                 memcpy(h->slice_ctx, sl, sizeof(tmp_ctx));
1896                 memcpy(sl, &tmp_ctx, sizeof(tmp_ctx));
1897                 sl = h->slice_ctx;
1898             }
1899
1900             if (h->field_started)
1901                 ff_h264_field_end(h, sl, 1);
1902
1903             h->current_slice = 0;
1904             if (!h->first_field) {
1905                 if (h->cur_pic_ptr && !h->droppable) {
1906                     ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX,
1907                                               h->picture_structure == PICT_BOTTOM_FIELD);
1908                 }
1909                 h->cur_pic_ptr = NULL;
1910             }
1911         }
1912
1913         if (h->current_slice == 0) {
1914             ret = h264_field_start(h, sl, nal);
1915             if (ret < 0)
1916                 return ret;
1917             h->field_started = 1;
1918         }
1919     }
1920
1921     ret = h264_slice_init(h, sl, nal);
1922     if (ret < 0)
1923         return ret;
1924
1925     if ((h->avctx->skip_frame < AVDISCARD_NONREF || nal->ref_idc) &&
1926         (h->avctx->skip_frame < AVDISCARD_BIDIR  ||
1927          sl->slice_type_nos != AV_PICTURE_TYPE_B) &&
1928         (h->avctx->skip_frame < AVDISCARD_NONKEY ||
1929          h->cur_pic_ptr->f->key_frame) &&
1930         h->avctx->skip_frame < AVDISCARD_ALL) {
1931         h->nb_slice_ctx_queued++;
1932     }
1933
1934     return 0;
1935 }
1936
1937 int ff_h264_get_slice_type(const H264SliceContext *sl)
1938 {
1939     switch (sl->slice_type) {
1940     case AV_PICTURE_TYPE_P:
1941         return 0;
1942     case AV_PICTURE_TYPE_B:
1943         return 1;
1944     case AV_PICTURE_TYPE_I:
1945         return 2;
1946     case AV_PICTURE_TYPE_SP:
1947         return 3;
1948     case AV_PICTURE_TYPE_SI:
1949         return 4;
1950     default:
1951         return AVERROR_INVALIDDATA;
1952     }
1953 }
1954
1955 static av_always_inline void fill_filter_caches_inter(const H264Context *h,
1956                                                       H264SliceContext *sl,
1957                                                       int mb_type, int top_xy,
1958                                                       int left_xy[LEFT_MBS],
1959                                                       int top_type,
1960                                                       int left_type[LEFT_MBS],
1961                                                       int mb_xy, int list)
1962 {
1963     int b_stride = h->b_stride;
1964     int16_t(*mv_dst)[2] = &sl->mv_cache[list][scan8[0]];
1965     int8_t *ref_cache   = &sl->ref_cache[list][scan8[0]];
1966     if (IS_INTER(mb_type) || IS_DIRECT(mb_type)) {
1967         if (USES_LIST(top_type, list)) {
1968             const int b_xy  = h->mb2b_xy[top_xy] + 3 * b_stride;
1969             const int b8_xy = 4 * top_xy + 2;
1970             const int *ref2frm = &h->ref2frm[h->slice_table[top_xy] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
1971             AV_COPY128(mv_dst - 1 * 8, h->cur_pic.motion_val[list][b_xy + 0]);
1972             ref_cache[0 - 1 * 8] =
1973             ref_cache[1 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 0]];
1974             ref_cache[2 - 1 * 8] =
1975             ref_cache[3 - 1 * 8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 1]];
1976         } else {
1977             AV_ZERO128(mv_dst - 1 * 8);
1978             AV_WN32A(&ref_cache[0 - 1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
1979         }
1980
1981         if (!IS_INTERLACED(mb_type ^ left_type[LTOP])) {
1982             if (USES_LIST(left_type[LTOP], list)) {
1983                 const int b_xy  = h->mb2b_xy[left_xy[LTOP]] + 3;
1984                 const int b8_xy = 4 * left_xy[LTOP] + 1;
1985                 const int *ref2frm = &h->ref2frm[h->slice_table[left_xy[LTOP]] & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
1986                 AV_COPY32(mv_dst - 1 +  0, h->cur_pic.motion_val[list][b_xy + b_stride * 0]);
1987                 AV_COPY32(mv_dst - 1 +  8, h->cur_pic.motion_val[list][b_xy + b_stride * 1]);
1988                 AV_COPY32(mv_dst - 1 + 16, h->cur_pic.motion_val[list][b_xy + b_stride * 2]);
1989                 AV_COPY32(mv_dst - 1 + 24, h->cur_pic.motion_val[list][b_xy + b_stride * 3]);
1990                 ref_cache[-1 +  0] =
1991                 ref_cache[-1 +  8] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 0]];
1992                 ref_cache[-1 + 16] =
1993                 ref_cache[-1 + 24] = ref2frm[h->cur_pic.ref_index[list][b8_xy + 2 * 1]];
1994             } else {
1995                 AV_ZERO32(mv_dst - 1 +  0);
1996                 AV_ZERO32(mv_dst - 1 +  8);
1997                 AV_ZERO32(mv_dst - 1 + 16);
1998                 AV_ZERO32(mv_dst - 1 + 24);
1999                 ref_cache[-1 +  0] =
2000                 ref_cache[-1 +  8] =
2001                 ref_cache[-1 + 16] =
2002                 ref_cache[-1 + 24] = LIST_NOT_USED;
2003             }
2004         }
2005     }
2006
2007     if (!USES_LIST(mb_type, list)) {
2008         fill_rectangle(mv_dst, 4, 4, 8, pack16to32(0, 0), 4);
2009         AV_WN32A(&ref_cache[0 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2010         AV_WN32A(&ref_cache[1 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2011         AV_WN32A(&ref_cache[2 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2012         AV_WN32A(&ref_cache[3 * 8], ((LIST_NOT_USED) & 0xFF) * 0x01010101u);
2013         return;
2014     }
2015
2016     {
2017         int8_t *ref = &h->cur_pic.ref_index[list][4 * mb_xy];
2018         const int *ref2frm = &h->ref2frm[sl->slice_num & (MAX_SLICES - 1)][list][(MB_MBAFF(sl) ? 20 : 2)];
2019         uint32_t ref01 = (pack16to32(ref2frm[ref[0]], ref2frm[ref[1]]) & 0x00FF00FF) * 0x0101;
2020         uint32_t ref23 = (pack16to32(ref2frm[ref[2]], ref2frm[ref[3]]) & 0x00FF00FF) * 0x0101;
2021         AV_WN32A(&ref_cache[0 * 8], ref01);
2022         AV_WN32A(&ref_cache[1 * 8], ref01);
2023         AV_WN32A(&ref_cache[2 * 8], ref23);
2024         AV_WN32A(&ref_cache[3 * 8], ref23);
2025     }
2026
2027     {
2028         int16_t(*mv_src)[2] = &h->cur_pic.motion_val[list][4 * sl->mb_x + 4 * sl->mb_y * b_stride];
2029         AV_COPY128(mv_dst + 8 * 0, mv_src + 0 * b_stride);
2030         AV_COPY128(mv_dst + 8 * 1, mv_src + 1 * b_stride);
2031         AV_COPY128(mv_dst + 8 * 2, mv_src + 2 * b_stride);
2032         AV_COPY128(mv_dst + 8 * 3, mv_src + 3 * b_stride);
2033     }
2034 }
2035
2036 /**
2037  * @return non zero if the loop filter can be skipped
2038  */
2039 static int fill_filter_caches(const H264Context *h, H264SliceContext *sl, int mb_type)
2040 {
2041     const int mb_xy = sl->mb_xy;
2042     int top_xy, left_xy[LEFT_MBS];
2043     int top_type, left_type[LEFT_MBS];
2044     uint8_t *nnz;
2045     uint8_t *nnz_cache;
2046
2047     top_xy = mb_xy - (h->mb_stride << MB_FIELD(sl));
2048
2049     left_xy[LBOT] = left_xy[LTOP] = mb_xy - 1;
2050     if (FRAME_MBAFF(h)) {
2051         const int left_mb_field_flag = IS_INTERLACED(h->cur_pic.mb_type[mb_xy - 1]);
2052         const int curr_mb_field_flag = IS_INTERLACED(mb_type);
2053         if (sl->mb_y & 1) {
2054             if (left_mb_field_flag != curr_mb_field_flag)
2055                 left_xy[LTOP] -= h->mb_stride;
2056         } else {
2057             if (curr_mb_field_flag)
2058                 top_xy += h->mb_stride &
2059                           (((h->cur_pic.mb_type[top_xy] >> 7) & 1) - 1);
2060             if (left_mb_field_flag != curr_mb_field_flag)
2061                 left_xy[LBOT] += h->mb_stride;
2062         }
2063     }
2064
2065     sl->top_mb_xy        = top_xy;
2066     sl->left_mb_xy[LTOP] = left_xy[LTOP];
2067     sl->left_mb_xy[LBOT] = left_xy[LBOT];
2068     {
2069         /* For sufficiently low qp, filtering wouldn't do anything.
2070          * This is a conservative estimate: could also check beta_offset
2071          * and more accurate chroma_qp. */
2072         int qp_thresh = sl->qp_thresh; // FIXME strictly we should store qp_thresh for each mb of a slice
2073         int qp        = h->cur_pic.qscale_table[mb_xy];
2074         if (qp <= qp_thresh &&
2075             (left_xy[LTOP] < 0 ||
2076              ((qp + h->cur_pic.qscale_table[left_xy[LTOP]] + 1) >> 1) <= qp_thresh) &&
2077             (top_xy < 0 ||
2078              ((qp + h->cur_pic.qscale_table[top_xy] + 1) >> 1) <= qp_thresh)) {
2079             if (!FRAME_MBAFF(h))
2080                 return 1;
2081             if ((left_xy[LTOP] < 0 ||
2082                  ((qp + h->cur_pic.qscale_table[left_xy[LBOT]] + 1) >> 1) <= qp_thresh) &&
2083                 (top_xy < h->mb_stride ||
2084                  ((qp + h->cur_pic.qscale_table[top_xy - h->mb_stride] + 1) >> 1) <= qp_thresh))
2085                 return 1;
2086         }
2087     }
2088
2089     top_type        = h->cur_pic.mb_type[top_xy];
2090     left_type[LTOP] = h->cur_pic.mb_type[left_xy[LTOP]];
2091     left_type[LBOT] = h->cur_pic.mb_type[left_xy[LBOT]];
2092     if (sl->deblocking_filter == 2) {
2093         if (h->slice_table[top_xy] != sl->slice_num)
2094             top_type = 0;
2095         if (h->slice_table[left_xy[LBOT]] != sl->slice_num)
2096             left_type[LTOP] = left_type[LBOT] = 0;
2097     } else {
2098         if (h->slice_table[top_xy] == 0xFFFF)
2099             top_type = 0;
2100         if (h->slice_table[left_xy[LBOT]] == 0xFFFF)
2101             left_type[LTOP] = left_type[LBOT] = 0;
2102     }
2103     sl->top_type        = top_type;
2104     sl->left_type[LTOP] = left_type[LTOP];
2105     sl->left_type[LBOT] = left_type[LBOT];
2106
2107     if (IS_INTRA(mb_type))
2108         return 0;
2109
2110     fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2111                              top_type, left_type, mb_xy, 0);
2112     if (sl->list_count == 2)
2113         fill_filter_caches_inter(h, sl, mb_type, top_xy, left_xy,
2114                                  top_type, left_type, mb_xy, 1);
2115
2116     nnz       = h->non_zero_count[mb_xy];
2117     nnz_cache = sl->non_zero_count_cache;
2118     AV_COPY32(&nnz_cache[4 + 8 * 1], &nnz[0]);
2119     AV_COPY32(&nnz_cache[4 + 8 * 2], &nnz[4]);
2120     AV_COPY32(&nnz_cache[4 + 8 * 3], &nnz[8]);
2121     AV_COPY32(&nnz_cache[4 + 8 * 4], &nnz[12]);
2122     sl->cbp = h->cbp_table[mb_xy];
2123
2124     if (top_type) {
2125         nnz = h->non_zero_count[top_xy];
2126         AV_COPY32(&nnz_cache[4 + 8 * 0], &nnz[3 * 4]);
2127     }
2128
2129     if (left_type[LTOP]) {
2130         nnz = h->non_zero_count[left_xy[LTOP]];
2131         nnz_cache[3 + 8 * 1] = nnz[3 + 0 * 4];
2132         nnz_cache[3 + 8 * 2] = nnz[3 + 1 * 4];
2133         nnz_cache[3 + 8 * 3] = nnz[3 + 2 * 4];
2134         nnz_cache[3 + 8 * 4] = nnz[3 + 3 * 4];
2135     }
2136
2137     /* CAVLC 8x8dct requires NNZ values for residual decoding that differ
2138      * from what the loop filter needs */
2139     if (!CABAC(h) && h->ps.pps->transform_8x8_mode) {
2140         if (IS_8x8DCT(top_type)) {
2141             nnz_cache[4 + 8 * 0] =
2142             nnz_cache[5 + 8 * 0] = (h->cbp_table[top_xy] & 0x4000) >> 12;
2143             nnz_cache[6 + 8 * 0] =
2144             nnz_cache[7 + 8 * 0] = (h->cbp_table[top_xy] & 0x8000) >> 12;
2145         }
2146         if (IS_8x8DCT(left_type[LTOP])) {
2147             nnz_cache[3 + 8 * 1] =
2148             nnz_cache[3 + 8 * 2] = (h->cbp_table[left_xy[LTOP]] & 0x2000) >> 12; // FIXME check MBAFF
2149         }
2150         if (IS_8x8DCT(left_type[LBOT])) {
2151             nnz_cache[3 + 8 * 3] =
2152             nnz_cache[3 + 8 * 4] = (h->cbp_table[left_xy[LBOT]] & 0x8000) >> 12; // FIXME check MBAFF
2153         }
2154
2155         if (IS_8x8DCT(mb_type)) {
2156             nnz_cache[scan8[0]] =
2157             nnz_cache[scan8[1]] =
2158             nnz_cache[scan8[2]] =
2159             nnz_cache[scan8[3]] = (sl->cbp & 0x1000) >> 12;
2160
2161             nnz_cache[scan8[0 + 4]] =
2162             nnz_cache[scan8[1 + 4]] =
2163             nnz_cache[scan8[2 + 4]] =
2164             nnz_cache[scan8[3 + 4]] = (sl->cbp & 0x2000) >> 12;
2165
2166             nnz_cache[scan8[0 + 8]] =
2167             nnz_cache[scan8[1 + 8]] =
2168             nnz_cache[scan8[2 + 8]] =
2169             nnz_cache[scan8[3 + 8]] = (sl->cbp & 0x4000) >> 12;
2170
2171             nnz_cache[scan8[0 + 12]] =
2172             nnz_cache[scan8[1 + 12]] =
2173             nnz_cache[scan8[2 + 12]] =
2174             nnz_cache[scan8[3 + 12]] = (sl->cbp & 0x8000) >> 12;
2175         }
2176     }
2177
2178     return 0;
2179 }
2180
2181 static void loop_filter(const H264Context *h, H264SliceContext *sl, int start_x, int end_x)
2182 {
2183     uint8_t *dest_y, *dest_cb, *dest_cr;
2184     int linesize, uvlinesize, mb_x, mb_y;
2185     const int end_mb_y       = sl->mb_y + FRAME_MBAFF(h);
2186     const int old_slice_type = sl->slice_type;
2187     const int pixel_shift    = h->pixel_shift;
2188     const int block_h        = 16 >> h->chroma_y_shift;
2189
2190     if (h->postpone_filter)
2191         return;
2192
2193     if (sl->deblocking_filter) {
2194         for (mb_x = start_x; mb_x < end_x; mb_x++)
2195             for (mb_y = end_mb_y - FRAME_MBAFF(h); mb_y <= end_mb_y; mb_y++) {
2196                 int mb_xy, mb_type;
2197                 mb_xy         = sl->mb_xy = mb_x + mb_y * h->mb_stride;
2198                 mb_type       = h->cur_pic.mb_type[mb_xy];
2199
2200                 if (FRAME_MBAFF(h))
2201                     sl->mb_mbaff               =
2202                     sl->mb_field_decoding_flag = !!IS_INTERLACED(mb_type);
2203
2204                 sl->mb_x = mb_x;
2205                 sl->mb_y = mb_y;
2206                 dest_y  = h->cur_pic.f->data[0] +
2207                           ((mb_x << pixel_shift) + mb_y * sl->linesize) * 16;
2208                 dest_cb = h->cur_pic.f->data[1] +
2209                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2210                           mb_y * sl->uvlinesize * block_h;
2211                 dest_cr = h->cur_pic.f->data[2] +
2212                           (mb_x << pixel_shift) * (8 << CHROMA444(h)) +
2213                           mb_y * sl->uvlinesize * block_h;
2214                 // FIXME simplify above
2215
2216                 if (MB_FIELD(sl)) {
2217                     linesize   = sl->mb_linesize   = sl->linesize   * 2;
2218                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize * 2;
2219                     if (mb_y & 1) { // FIXME move out of this function?
2220                         dest_y  -= sl->linesize   * 15;
2221                         dest_cb -= sl->uvlinesize * (block_h - 1);
2222                         dest_cr -= sl->uvlinesize * (block_h - 1);
2223                     }
2224                 } else {
2225                     linesize   = sl->mb_linesize   = sl->linesize;
2226                     uvlinesize = sl->mb_uvlinesize = sl->uvlinesize;
2227                 }
2228                 backup_mb_border(h, sl, dest_y, dest_cb, dest_cr, linesize,
2229                                  uvlinesize, 0);
2230                 if (fill_filter_caches(h, sl, mb_type))
2231                     continue;
2232                 sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, h->cur_pic.qscale_table[mb_xy]);
2233                 sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, h->cur_pic.qscale_table[mb_xy]);
2234
2235                 if (FRAME_MBAFF(h)) {
2236                     ff_h264_filter_mb(h, sl, mb_x, mb_y, dest_y, dest_cb, dest_cr,
2237                                       linesize, uvlinesize);
2238                 } else {
2239                     ff_h264_filter_mb_fast(h, sl, mb_x, mb_y, dest_y, dest_cb,
2240                                            dest_cr, linesize, uvlinesize);
2241                 }
2242             }
2243     }
2244     sl->slice_type  = old_slice_type;
2245     sl->mb_x         = end_x;
2246     sl->mb_y         = end_mb_y - FRAME_MBAFF(h);
2247     sl->chroma_qp[0] = get_chroma_qp(h->ps.pps, 0, sl->qscale);
2248     sl->chroma_qp[1] = get_chroma_qp(h->ps.pps, 1, sl->qscale);
2249 }
2250
2251 static void predict_field_decoding_flag(const H264Context *h, H264SliceContext *sl)
2252 {
2253     const int mb_xy = sl->mb_x + sl->mb_y * h->mb_stride;
2254     int mb_type     = (h->slice_table[mb_xy - 1] == sl->slice_num) ?
2255                       h->cur_pic.mb_type[mb_xy - 1] :
2256                       (h->slice_table[mb_xy - h->mb_stride] == sl->slice_num) ?
2257                       h->cur_pic.mb_type[mb_xy - h->mb_stride] : 0;
2258     sl->mb_mbaff    = sl->mb_field_decoding_flag = IS_INTERLACED(mb_type) ? 1 : 0;
2259 }
2260
2261 /**
2262  * Draw edges and report progress for the last MB row.
2263  */
2264 static void decode_finish_row(const H264Context *h, H264SliceContext *sl)
2265 {
2266     int top            = 16 * (sl->mb_y      >> FIELD_PICTURE(h));
2267     int pic_height     = 16 *  h->mb_height >> FIELD_PICTURE(h);
2268     int height         =  16      << FRAME_MBAFF(h);
2269     int deblock_border = (16 + 4) << FRAME_MBAFF(h);
2270
2271     if (sl->deblocking_filter) {
2272         if ((top + height) >= pic_height)
2273             height += deblock_border;
2274         top -= deblock_border;
2275     }
2276
2277     if (top >= pic_height || (top + height) < 0)
2278         return;
2279
2280     height = FFMIN(height, pic_height - top);
2281     if (top < 0) {
2282         height = top + height;
2283         top    = 0;
2284     }
2285
2286     ff_h264_draw_horiz_band(h, sl, top, height);
2287
2288     if (h->droppable)
2289         return;
2290
2291     ff_thread_report_progress(&h->cur_pic_ptr->tf, top + height - 1,
2292                               h->picture_structure == PICT_BOTTOM_FIELD);
2293 }
2294
2295 static void er_add_slice(H264SliceContext *sl,
2296                          int startx, int starty,
2297                          int endx, int endy, int status)
2298 {
2299 #if CONFIG_ERROR_RESILIENCE
2300     ERContext *er = &sl->er;
2301
2302     if (!sl->h264->enable_er)
2303         return;
2304
2305     er->ref_count = sl->ref_count[0];
2306     ff_er_add_slice(er, startx, starty, endx, endy, status);
2307 #endif
2308 }
2309
2310 static int decode_slice(struct AVCodecContext *avctx, void *arg)
2311 {
2312     H264SliceContext *sl = arg;
2313     const H264Context *h = sl->h264;
2314     int lf_x_start = sl->mb_x;
2315     int orig_deblock = sl->deblocking_filter;
2316     int ret;
2317
2318     sl->linesize   = h->cur_pic_ptr->f->linesize[0];
2319     sl->uvlinesize = h->cur_pic_ptr->f->linesize[1];
2320
2321     ret = alloc_scratch_buffers(sl, sl->linesize);
2322     if (ret < 0)
2323         return ret;
2324
2325     sl->mb_skip_run = -1;
2326
2327     if (h->postpone_filter)
2328         sl->deblocking_filter = 0;
2329
2330     sl->is_complex = FRAME_MBAFF(h) || h->picture_structure != PICT_FRAME ||
2331                      (CONFIG_GRAY && (h->flags & AV_CODEC_FLAG_GRAY));
2332
2333     if (h->ps.pps->cabac) {
2334         /* realign */
2335         align_get_bits(&sl->gb);
2336
2337         /* init cabac */
2338         ff_init_cabac_decoder(&sl->cabac,
2339                               sl->gb.buffer + get_bits_count(&sl->gb) / 8,
2340                               (get_bits_left(&sl->gb) + 7) / 8);
2341
2342         ff_h264_init_cabac_states(h, sl);
2343
2344         for (;;) {
2345             // START_TIMER
2346             int ret, eos;
2347
2348             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2349                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2350                        sl->next_slice_idx);
2351                 return AVERROR_INVALIDDATA;
2352             }
2353
2354             ret = ff_h264_decode_mb_cabac(h, sl);
2355             // STOP_TIMER("decode_mb_cabac")
2356
2357             if (ret >= 0)
2358                 ff_h264_hl_decode_mb(h, sl);
2359
2360             // FIXME optimal? or let mb_decode decode 16x32 ?
2361             if (ret >= 0 && FRAME_MBAFF(h)) {
2362                 sl->mb_y++;
2363
2364                 ret = ff_h264_decode_mb_cabac(h, sl);
2365
2366                 if (ret >= 0)
2367                     ff_h264_hl_decode_mb(h, sl);
2368                 sl->mb_y--;
2369             }
2370             eos = get_cabac_terminate(&sl->cabac);
2371
2372             if ((h->workaround_bugs & FF_BUG_TRUNCATED) &&
2373                 sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
2374                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2375                              sl->mb_y, ER_MB_END);
2376                 if (sl->mb_x >= lf_x_start)
2377                     loop_filter(h, sl, lf_x_start, sl->mb_x + 1);
2378                 goto finish;
2379             }
2380             if (ret < 0 || sl->cabac.bytestream > sl->cabac.bytestream_end + 2) {
2381                 av_log(h->avctx, AV_LOG_ERROR,
2382                        "error while decoding MB %d %d, bytestream %td\n",
2383                        sl->mb_x, sl->mb_y,
2384                        sl->cabac.bytestream_end - sl->cabac.bytestream);
2385                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2386                              sl->mb_y, ER_MB_ERROR);
2387                 return AVERROR_INVALIDDATA;
2388             }
2389
2390             if (++sl->mb_x >= h->mb_width) {
2391                 loop_filter(h, sl, lf_x_start, sl->mb_x);
2392                 sl->mb_x = lf_x_start = 0;
2393                 decode_finish_row(h, sl);
2394                 ++sl->mb_y;
2395                 if (FIELD_OR_MBAFF_PICTURE(h)) {
2396                     ++sl->mb_y;
2397                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2398                         predict_field_decoding_flag(h, sl);
2399                 }
2400             }
2401
2402             if (eos || sl->mb_y >= h->mb_height) {
2403                 ff_tlog(h->avctx, "slice end %d %d\n",
2404                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
2405                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x - 1,
2406                              sl->mb_y, ER_MB_END);
2407                 if (sl->mb_x > lf_x_start)
2408                     loop_filter(h, sl, lf_x_start, sl->mb_x);
2409                 goto finish;
2410             }
2411         }
2412     } else {
2413         for (;;) {
2414             int ret;
2415
2416             if (sl->mb_x + sl->mb_y * h->mb_width >= sl->next_slice_idx) {
2417                 av_log(h->avctx, AV_LOG_ERROR, "Slice overlaps with next at %d\n",
2418                        sl->next_slice_idx);
2419                 return AVERROR_INVALIDDATA;
2420             }
2421
2422             ret = ff_h264_decode_mb_cavlc(h, sl);
2423
2424             if (ret >= 0)
2425                 ff_h264_hl_decode_mb(h, sl);
2426
2427             // FIXME optimal? or let mb_decode decode 16x32 ?
2428             if (ret >= 0 && FRAME_MBAFF(h)) {
2429                 sl->mb_y++;
2430                 ret = ff_h264_decode_mb_cavlc(h, sl);
2431
2432                 if (ret >= 0)
2433                     ff_h264_hl_decode_mb(h, sl);
2434                 sl->mb_y--;
2435             }
2436
2437             if (ret < 0) {
2438                 av_log(h->avctx, AV_LOG_ERROR,
2439                        "error while decoding MB %d %d\n", sl->mb_x, sl->mb_y);
2440                 er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2441                              sl->mb_y, ER_MB_ERROR);
2442                 return ret;
2443             }
2444
2445             if (++sl->mb_x >= h->mb_width) {
2446                 loop_filter(h, sl, lf_x_start, sl->mb_x);
2447                 sl->mb_x = lf_x_start = 0;
2448                 decode_finish_row(h, sl);
2449                 ++sl->mb_y;
2450                 if (FIELD_OR_MBAFF_PICTURE(h)) {
2451                     ++sl->mb_y;
2452                     if (FRAME_MBAFF(h) && sl->mb_y < h->mb_height)
2453                         predict_field_decoding_flag(h, sl);
2454                 }
2455                 if (sl->mb_y >= h->mb_height) {
2456                     ff_tlog(h->avctx, "slice end %d %d\n",
2457                             get_bits_count(&sl->gb), sl->gb.size_in_bits);
2458
2459                     if (get_bits_left(&sl->gb) == 0) {
2460                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2461                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
2462
2463                         goto finish;
2464                     } else {
2465                         er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2466                                      sl->mb_x - 1, sl->mb_y, ER_MB_END);
2467
2468                         return AVERROR_INVALIDDATA;
2469                     }
2470                 }
2471             }
2472
2473             if (get_bits_left(&sl->gb) <= 0 && sl->mb_skip_run <= 0) {
2474                 ff_tlog(h->avctx, "slice end %d %d\n",
2475                         get_bits_count(&sl->gb), sl->gb.size_in_bits);
2476
2477                 if (get_bits_left(&sl->gb) == 0) {
2478                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y,
2479                                  sl->mb_x - 1, sl->mb_y, ER_MB_END);
2480                     if (sl->mb_x > lf_x_start)
2481                         loop_filter(h, sl, lf_x_start, sl->mb_x);
2482
2483                     goto finish;
2484                 } else {
2485                     er_add_slice(sl, sl->resync_mb_x, sl->resync_mb_y, sl->mb_x,
2486                                  sl->mb_y, ER_MB_ERROR);
2487
2488                     return AVERROR_INVALIDDATA;
2489                 }
2490             }
2491         }
2492     }
2493
2494 finish:
2495     sl->deblocking_filter = orig_deblock;
2496     return 0;
2497 }
2498
2499 /**
2500  * Call decode_slice() for each context.
2501  *
2502  * @param h h264 master context
2503  */
2504 int ff_h264_execute_decode_slices(H264Context *h)
2505 {
2506     AVCodecContext *const avctx = h->avctx;
2507     H264SliceContext *sl;
2508     int context_count = h->nb_slice_ctx_queued;
2509     int ret = 0;
2510     int i, j;
2511
2512     if (h->avctx->hwaccel || context_count < 1)
2513         return 0;
2514     if (context_count == 1) {
2515
2516         h->slice_ctx[0].next_slice_idx = h->mb_width * h->mb_height;
2517         h->postpone_filter = 0;
2518
2519         ret = decode_slice(avctx, &h->slice_ctx[0]);
2520         h->mb_y = h->slice_ctx[0].mb_y;
2521         if (ret < 0)
2522             goto finish;
2523     } else {
2524         for (i = 0; i < context_count; i++) {
2525             int next_slice_idx = h->mb_width * h->mb_height;
2526             int slice_idx;
2527
2528             sl                 = &h->slice_ctx[i];
2529             sl->er.error_count = 0;
2530
2531             /* make sure none of those slices overlap */
2532             slice_idx = sl->mb_y * h->mb_width + sl->mb_x;
2533             for (j = 0; j < context_count; j++) {
2534                 H264SliceContext *sl2 = &h->slice_ctx[j];
2535                 int        slice_idx2 = sl2->mb_y * h->mb_width + sl2->mb_x;
2536
2537                 if (i == j || slice_idx2 < slice_idx)
2538                     continue;
2539                 next_slice_idx = FFMIN(next_slice_idx, slice_idx2);
2540             }
2541             sl->next_slice_idx = next_slice_idx;
2542         }
2543
2544         avctx->execute(avctx, decode_slice, h->slice_ctx,
2545                        NULL, context_count, sizeof(h->slice_ctx[0]));
2546
2547         /* pull back stuff from slices to master context */
2548         sl                   = &h->slice_ctx[context_count - 1];
2549         h->mb_y              = sl->mb_y;
2550         for (i = 1; i < context_count; i++)
2551             h->slice_ctx[0].er.error_count += h->slice_ctx[i].er.error_count;
2552
2553         if (h->postpone_filter) {
2554             h->postpone_filter = 0;
2555
2556             for (i = 0; i < context_count; i++) {
2557                 int y_end, x_end;
2558
2559                 sl = &h->slice_ctx[i];
2560                 y_end = FFMIN(sl->mb_y + 1, h->mb_height);
2561                 x_end = (sl->mb_y >= h->mb_height) ? h->mb_width : sl->mb_x;
2562
2563                 for (j = sl->resync_mb_y; j < y_end; j += 1 + FIELD_OR_MBAFF_PICTURE(h)) {
2564                     sl->mb_y = j;
2565                     loop_filter(h, sl, j > sl->resync_mb_y ? 0 : sl->resync_mb_x,
2566                                 j == y_end - 1 ? x_end : h->mb_width);
2567                 }
2568             }
2569         }
2570     }
2571
2572 finish:
2573     h->nb_slice_ctx_queued = 0;
2574     return ret;
2575 }