avcodec/h264_slice: Fix overflow in slice offset
[ffmpeg.git] / libavcodec / h264_refs.c
1 /*
2  * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
3  * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21
22 /**
23  * @file
24  * H.264 / AVC / MPEG-4 part10  reference picture handling.
25  * @author Michael Niedermayer <michaelni@gmx.at>
26  */
27
28 #include <inttypes.h>
29
30 #include "libavutil/avassert.h"
31 #include "internal.h"
32 #include "avcodec.h"
33 #include "h264.h"
34 #include "h264dec.h"
35 #include "golomb.h"
36 #include "mpegutils.h"
37
38 #include <assert.h>
39
40 static void pic_as_field(H264Ref *pic, const int parity)
41 {
42     int i;
43     for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) {
44         if (parity == PICT_BOTTOM_FIELD)
45             pic->data[i]   += pic->linesize[i];
46         pic->reference      = parity;
47         pic->linesize[i] *= 2;
48     }
49     pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD];
50 }
51
52 static void ref_from_h264pic(H264Ref *dst, H264Picture *src)
53 {
54     memcpy(dst->data,     src->f->data,     sizeof(dst->data));
55     memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize));
56     dst->reference = src->reference;
57     dst->poc       = src->poc;
58     dst->pic_id    = src->pic_id;
59     dst->parent = src;
60 }
61
62 static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)
63 {
64     int match = !!(src->reference & parity);
65
66     if (match) {
67         ref_from_h264pic(dest, src);
68         if (parity != PICT_FRAME) {
69             pic_as_field(dest, parity);
70             dest->pic_id *= 2;
71             dest->pic_id += id_add;
72         }
73     }
74
75     return match;
76 }
77
78 static int build_def_list(H264Ref *def, int def_len,
79                           H264Picture * const *in, int len, int is_long, int sel)
80 {
81     int  i[2] = { 0 };
82     int index = 0;
83
84     while (i[0] < len || i[1] < len) {
85         while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
86             i[0]++;
87         while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
88             i[1]++;
89         if (i[0] < len) {
90             av_assert0(index < def_len);
91             in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
92             split_field_copy(&def[index++], in[i[0]++], sel, 1);
93         }
94         if (i[1] < len) {
95             av_assert0(index < def_len);
96             in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
97             split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
98         }
99     }
100
101     return index;
102 }
103
104 static int add_sorted(H264Picture **sorted, H264Picture * const *src,
105                       int len, int limit, int dir)
106 {
107     int i, best_poc;
108     int out_i = 0;
109
110     for (;;) {
111         best_poc = dir ? INT_MIN : INT_MAX;
112
113         for (i = 0; i < len; i++) {
114             const int poc = src[i]->poc;
115             if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {
116                 best_poc      = poc;
117                 sorted[out_i] = src[i];
118             }
119         }
120         if (best_poc == (dir ? INT_MIN : INT_MAX))
121             break;
122         limit = sorted[out_i++]->poc - dir;
123     }
124     return out_i;
125 }
126
127 static int mismatches_ref(const H264Context *h, const H264Picture *pic)
128 {
129     const AVFrame *f = pic->f;
130     return (h->cur_pic_ptr->f->width  != f->width ||
131             h->cur_pic_ptr->f->height != f->height ||
132             h->cur_pic_ptr->f->format != f->format);
133 }
134
135 static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
136 {
137     int i, len;
138     int j;
139
140     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
141         H264Picture *sorted[32];
142         int cur_poc, list;
143         int lens[2];
144
145         if (FIELD_PICTURE(h))
146             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];
147         else
148             cur_poc = h->cur_pic_ptr->poc;
149
150         for (list = 0; list < 2; list++) {
151             len  = add_sorted(sorted,       h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
152             len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
153             av_assert0(len <= 32);
154
155             len  = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),
156                                   sorted, len, 0, h->picture_structure);
157             len += build_def_list(sl->ref_list[list] + len,
158                                   FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
159                                   h->long_ref, 16, 1, h->picture_structure);
160             av_assert0(len <= 32);
161
162             if (len < sl->ref_count[list])
163                 memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));
164             lens[list] = len;
165         }
166
167         if (lens[0] == lens[1] && lens[1] > 1) {
168             for (i = 0; i < lens[0] &&
169                         sl->ref_list[0][i].parent->f->buf[0]->buffer ==
170                         sl->ref_list[1][i].parent->f->buf[0]->buffer; i++);
171             if (i == lens[0]) {
172                 FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]);
173             }
174         }
175     } else {
176         len  = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]),
177                               h->short_ref, h->short_ref_count, 0, h->picture_structure);
178         len += build_def_list(sl->ref_list[0] + len,
179                               FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
180                               h-> long_ref, 16, 1, h->picture_structure);
181         av_assert0(len <= 32);
182
183         if (len < sl->ref_count[0])
184             memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len));
185     }
186 #ifdef TRACE
187     for (i = 0; i < sl->ref_count[0]; i++) {
188         ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n",
189                 (sl->ref_list[0][i].parent ? (sl->ref_list[0][i].parent->long_ref ? "LT" : "ST") : "??"),
190                 sl->ref_list[0][i].pic_id,
191                 sl->ref_list[0][i].data[0]);
192     }
193     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
194         for (i = 0; i < sl->ref_count[1]; i++) {
195             ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n",
196                     (sl->ref_list[1][i].parent ? (sl->ref_list[1][i].parent->long_ref ? "LT" : "ST") : "??"),
197                     sl->ref_list[1][i].pic_id,
198                     sl->ref_list[1][i].data[0]);
199         }
200     }
201 #endif
202
203     for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {
204         for (i = 0; i < sl->ref_count[j]; i++) {
205             if (sl->ref_list[j][i].parent) {
206                 if (mismatches_ref(h, sl->ref_list[j][i].parent)) {
207                     av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");
208                     memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));
209                 }
210             }
211         }
212     }
213     for (i = 0; i < sl->list_count; i++)
214         h->default_ref[i] = sl->ref_list[i][0];
215 }
216
217 /**
218  * print short term list
219  */
220 static void print_short_term(const H264Context *h)
221 {
222     uint32_t i;
223     if (h->avctx->debug & FF_DEBUG_MMCO) {
224         av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");
225         for (i = 0; i < h->short_ref_count; i++) {
226             H264Picture *pic = h->short_ref[i];
227             av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
228                    i, pic->frame_num, pic->poc, pic->f->data[0]);
229         }
230     }
231 }
232
233 /**
234  * print long term list
235  */
236 static void print_long_term(const H264Context *h)
237 {
238     uint32_t i;
239     if (h->avctx->debug & FF_DEBUG_MMCO) {
240         av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");
241         for (i = 0; i < 16; i++) {
242             H264Picture *pic = h->long_ref[i];
243             if (pic) {
244                 av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
245                        i, pic->frame_num, pic->poc, pic->f->data[0]);
246             }
247         }
248     }
249 }
250
251 /**
252  * Extract structure information about the picture described by pic_num in
253  * the current decoding context (frame or field). Note that pic_num is
254  * picture number without wrapping (so, 0<=pic_num<max_pic_num).
255  * @param pic_num picture number for which to extract structure information
256  * @param structure one of PICT_XXX describing structure of picture
257  *                      with pic_num
258  * @return frame number (short term) or long term index of picture
259  *         described by pic_num
260  */
261 static int pic_num_extract(const H264Context *h, int pic_num, int *structure)
262 {
263     *structure = h->picture_structure;
264     if (FIELD_PICTURE(h)) {
265         if (!(pic_num & 1))
266             /* opposite field */
267             *structure ^= PICT_FRAME;
268         pic_num >>= 1;
269     }
270
271     return pic_num;
272 }
273
274 static void h264_fill_mbaff_ref_list(H264SliceContext *sl)
275 {
276     int list, i, j;
277     for (list = 0; list < sl->list_count; list++) {
278         for (i = 0; i < sl->ref_count[list]; i++) {
279             H264Ref *frame = &sl->ref_list[list][i];
280             H264Ref *field = &sl->ref_list[list][16 + 2 * i];
281
282             field[0] = *frame;
283
284             for (j = 0; j < 3; j++)
285                 field[0].linesize[j] <<= 1;
286             field[0].reference = PICT_TOP_FIELD;
287             field[0].poc       = field[0].parent->field_poc[0];
288
289             field[1] = field[0];
290
291             for (j = 0; j < 3; j++)
292                 field[1].data[j] += frame->parent->f->linesize[j];
293             field[1].reference = PICT_BOTTOM_FIELD;
294             field[1].poc       = field[1].parent->field_poc[1];
295         }
296     }
297 }
298
299 int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
300 {
301     int list, index, pic_structure;
302
303     print_short_term(h);
304     print_long_term(h);
305
306     h264_initialise_ref_list(h, sl);
307
308     for (list = 0; list < sl->list_count; list++) {
309         int pred = sl->curr_pic_num;
310
311         for (index = 0; index < sl->nb_ref_modifications[list]; index++) {
312             unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op;
313             unsigned int                          val = sl->ref_modifications[list][index].val;
314             unsigned int pic_id;
315             int i;
316             H264Picture *ref = NULL;
317
318             switch (modification_of_pic_nums_idc) {
319             case 0:
320             case 1: {
321                 const unsigned int abs_diff_pic_num = val + 1;
322                 int frame_num;
323
324                 if (abs_diff_pic_num > sl->max_pic_num) {
325                     av_log(h->avctx, AV_LOG_ERROR,
326                            "abs_diff_pic_num overflow\n");
327                     return AVERROR_INVALIDDATA;
328                 }
329
330                 if (modification_of_pic_nums_idc == 0)
331                     pred -= abs_diff_pic_num;
332                 else
333                     pred += abs_diff_pic_num;
334                 pred &= sl->max_pic_num - 1;
335
336                 frame_num = pic_num_extract(h, pred, &pic_structure);
337
338                 for (i = h->short_ref_count - 1; i >= 0; i--) {
339                     ref = h->short_ref[i];
340                     assert(ref->reference);
341                     assert(!ref->long_ref);
342                     if (ref->frame_num == frame_num &&
343                         (ref->reference & pic_structure))
344                         break;
345                 }
346                 if (i >= 0)
347                     ref->pic_id = pred;
348                 break;
349             }
350             case 2: {
351                 int long_idx;
352                 pic_id = val; // long_term_pic_idx
353
354                 long_idx = pic_num_extract(h, pic_id, &pic_structure);
355
356                 if (long_idx > 31U) {
357                     av_log(h->avctx, AV_LOG_ERROR,
358                            "long_term_pic_idx overflow\n");
359                     return AVERROR_INVALIDDATA;
360                 }
361                 ref = h->long_ref[long_idx];
362                 assert(!(ref && !ref->reference));
363                 if (ref && (ref->reference & pic_structure)) {
364                     ref->pic_id = pic_id;
365                     assert(ref->long_ref);
366                     i = 0;
367                 } else {
368                     i = -1;
369                 }
370                 break;
371             }
372             default:
373                 av_assert0(0);
374             }
375
376             if (i < 0) {
377                 av_log(h->avctx, AV_LOG_ERROR,
378                        "reference picture missing during reorder\n");
379                 memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME
380             } else {
381                 for (i = index; i + 1 < sl->ref_count[list]; i++) {
382                     if (sl->ref_list[list][i].parent &&
383                         ref->long_ref == sl->ref_list[list][i].parent->long_ref &&
384                         ref->pic_id   == sl->ref_list[list][i].pic_id)
385                         break;
386                 }
387                 for (; i > index; i--) {
388                     sl->ref_list[list][i] = sl->ref_list[list][i - 1];
389                 }
390                 ref_from_h264pic(&sl->ref_list[list][index], ref);
391                 if (FIELD_PICTURE(h)) {
392                     pic_as_field(&sl->ref_list[list][index], pic_structure);
393                 }
394             }
395         }
396     }
397     for (list = 0; list < sl->list_count; list++) {
398         for (index = 0; index < sl->ref_count[list]; index++) {
399             if (   !sl->ref_list[list][index].parent
400                 || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
401                 int i;
402                 av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);
403                 for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
404                     h->last_pocs[i] = INT_MIN;
405                 if (h->default_ref[list].parent
406                     && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
407                     sl->ref_list[list][index] = h->default_ref[list];
408                 else
409                     return -1;
410             }
411             av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
412         }
413     }
414
415     if (FRAME_MBAFF(h))
416         h264_fill_mbaff_ref_list(sl);
417
418     return 0;
419 }
420
421 int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
422 {
423     int list, index;
424
425     sl->nb_ref_modifications[0] = 0;
426     sl->nb_ref_modifications[1] = 0;
427
428     for (list = 0; list < sl->list_count; list++) {
429         if (!get_bits1(&sl->gb))    // ref_pic_list_modification_flag_l[01]
430             continue;
431
432         for (index = 0; ; index++) {
433             unsigned int op = get_ue_golomb_31(&sl->gb);
434
435             if (op == 3)
436                 break;
437
438             if (index >= sl->ref_count[list]) {
439                 av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
440                 return AVERROR_INVALIDDATA;
441             } else if (op > 2) {
442                 av_log(logctx, AV_LOG_ERROR,
443                        "illegal modification_of_pic_nums_idc %u\n",
444                        op);
445                 return AVERROR_INVALIDDATA;
446             }
447             sl->ref_modifications[list][index].val = get_ue_golomb_long(&sl->gb);
448             sl->ref_modifications[list][index].op  = op;
449             sl->nb_ref_modifications[list]++;
450         }
451     }
452
453     return 0;
454 }
455
456 /**
457  * Mark a picture as no longer needed for reference. The refmask
458  * argument allows unreferencing of individual fields or the whole frame.
459  * If the picture becomes entirely unreferenced, but is being held for
460  * display purposes, it is marked as such.
461  * @param refmask mask of fields to unreference; the mask is bitwise
462  *                anded with the reference marking of pic
463  * @return non-zero if pic becomes entirely unreferenced (except possibly
464  *         for display purposes) zero if one of the fields remains in
465  *         reference
466  */
467 static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
468 {
469     int i;
470     if (pic->reference &= refmask) {
471         return 0;
472     } else {
473         for(i = 0; h->delayed_pic[i]; i++)
474             if(pic == h->delayed_pic[i]){
475                 pic->reference = DELAYED_PIC_REF;
476                 break;
477             }
478         return 1;
479     }
480 }
481
482 /**
483  * Find a H264Picture in the short term reference list by frame number.
484  * @param frame_num frame number to search for
485  * @param idx the index into h->short_ref where returned picture is found
486  *            undefined if no picture found.
487  * @return pointer to the found picture, or NULL if no pic with the provided
488  *                 frame number is found
489  */
490 static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
491 {
492     int i;
493
494     for (i = 0; i < h->short_ref_count; i++) {
495         H264Picture *pic = h->short_ref[i];
496         if (h->avctx->debug & FF_DEBUG_MMCO)
497             av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
498         if (pic->frame_num == frame_num) {
499             *idx = i;
500             return pic;
501         }
502     }
503     return NULL;
504 }
505
506 /**
507  * Remove a picture from the short term reference list by its index in
508  * that list.  This does no checking on the provided index; it is assumed
509  * to be valid. Other list entries are shifted down.
510  * @param i index into h->short_ref of picture to remove.
511  */
512 static void remove_short_at_index(H264Context *h, int i)
513 {
514     assert(i >= 0 && i < h->short_ref_count);
515     h->short_ref[i] = NULL;
516     if (--h->short_ref_count)
517         memmove(&h->short_ref[i], &h->short_ref[i + 1],
518                 (h->short_ref_count - i) * sizeof(H264Picture*));
519 }
520
521 /**
522  * @return the removed picture or NULL if an error occurs
523  */
524 static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
525 {
526     H264Picture *pic;
527     int i;
528
529     if (h->avctx->debug & FF_DEBUG_MMCO)
530         av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
531
532     pic = find_short(h, frame_num, &i);
533     if (pic) {
534         if (unreference_pic(h, pic, ref_mask))
535             remove_short_at_index(h, i);
536     }
537
538     return pic;
539 }
540
541 /**
542  * Remove a picture from the long term reference list by its index in
543  * that list.
544  * @return the removed picture or NULL if an error occurs
545  */
546 static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
547 {
548     H264Picture *pic;
549
550     pic = h->long_ref[i];
551     if (pic) {
552         if (unreference_pic(h, pic, ref_mask)) {
553             assert(h->long_ref[i]->long_ref == 1);
554             h->long_ref[i]->long_ref = 0;
555             h->long_ref[i]           = NULL;
556             h->long_ref_count--;
557         }
558     }
559
560     return pic;
561 }
562
563 void ff_h264_remove_all_refs(H264Context *h)
564 {
565     int i;
566
567     for (i = 0; i < 16; i++) {
568         remove_long(h, i, 0);
569     }
570     assert(h->long_ref_count == 0);
571
572     if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
573         ff_h264_unref_picture(h, &h->last_pic_for_ec);
574         ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
575     }
576
577     for (i = 0; i < h->short_ref_count; i++) {
578         unreference_pic(h, h->short_ref[i], 0);
579         h->short_ref[i] = NULL;
580     }
581     h->short_ref_count = 0;
582
583     memset(h->default_ref, 0, sizeof(h->default_ref));
584 }
585
586 static void generate_sliding_window_mmcos(H264Context *h)
587 {
588     MMCO *mmco = h->mmco;
589     int nb_mmco = 0;
590
591     if (h->short_ref_count &&
592         h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&
593         !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
594         mmco[0].opcode        = MMCO_SHORT2UNUSED;
595         mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
596         nb_mmco               = 1;
597         if (FIELD_PICTURE(h)) {
598             mmco[0].short_pic_num *= 2;
599             mmco[1].opcode         = MMCO_SHORT2UNUSED;
600             mmco[1].short_pic_num  = mmco[0].short_pic_num + 1;
601             nb_mmco                = 2;
602         }
603     }
604
605     h->nb_mmco = nb_mmco;
606 }
607
608 int ff_h264_execute_ref_pic_marking(H264Context *h)
609 {
610     MMCO *mmco = h->mmco;
611     int mmco_count;
612     int i, av_uninit(j);
613     int pps_ref_count[2] = {0};
614     int current_ref_assigned = 0, err = 0;
615     H264Picture *av_uninit(pic);
616
617     if (!h->explicit_ref_marking)
618         generate_sliding_window_mmcos(h);
619     mmco_count = h->nb_mmco;
620
621     if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
622         av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
623
624     for (i = 0; i < mmco_count; i++) {
625         int av_uninit(structure), av_uninit(frame_num);
626         if (h->avctx->debug & FF_DEBUG_MMCO)
627             av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
628                    h->mmco[i].short_pic_num, h->mmco[i].long_arg);
629
630         if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
631             mmco[i].opcode == MMCO_SHORT2LONG) {
632             frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
633             pic       = find_short(h, frame_num, &j);
634             if (!pic) {
635                 if (mmco[i].opcode != MMCO_SHORT2LONG ||
636                     !h->long_ref[mmco[i].long_arg]    ||
637                     h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
638                     av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
639                     err = AVERROR_INVALIDDATA;
640                 }
641                 continue;
642             }
643         }
644
645         switch (mmco[i].opcode) {
646         case MMCO_SHORT2UNUSED:
647             if (h->avctx->debug & FF_DEBUG_MMCO)
648                 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
649                        h->mmco[i].short_pic_num, h->short_ref_count);
650             remove_short(h, frame_num, structure ^ PICT_FRAME);
651             break;
652         case MMCO_SHORT2LONG:
653                 if (h->long_ref[mmco[i].long_arg] != pic)
654                     remove_long(h, mmco[i].long_arg, 0);
655
656                 remove_short_at_index(h, j);
657                 h->long_ref[ mmco[i].long_arg ] = pic;
658                 if (h->long_ref[mmco[i].long_arg]) {
659                     h->long_ref[mmco[i].long_arg]->long_ref = 1;
660                     h->long_ref_count++;
661                 }
662             break;
663         case MMCO_LONG2UNUSED:
664             j   = pic_num_extract(h, mmco[i].long_arg, &structure);
665             pic = h->long_ref[j];
666             if (pic) {
667                 remove_long(h, j, structure ^ PICT_FRAME);
668             } else if (h->avctx->debug & FF_DEBUG_MMCO)
669                 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
670             break;
671         case MMCO_LONG:
672                     // Comment below left from previous code as it is an interesting note.
673                     /* First field in pair is in short term list or
674                      * at a different long term index.
675                      * This is not allowed; see 7.4.3.3, notes 2 and 3.
676                      * Report the problem and keep the pair where it is,
677                      * and mark this field valid.
678                      */
679             if (h->short_ref[0] == h->cur_pic_ptr) {
680                 av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
681                 remove_short_at_index(h, 0);
682             }
683
684             /* make sure the current picture is not already assigned as a long ref */
685             if (h->cur_pic_ptr->long_ref) {
686                 for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
687                     if (h->long_ref[j] == h->cur_pic_ptr) {
688                         if (j != mmco[i].long_arg)
689                             av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
690                         remove_long(h, j, 0);
691                     }
692                 }
693             }
694
695             if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
696                 av_assert0(!h->cur_pic_ptr->long_ref);
697                 remove_long(h, mmco[i].long_arg, 0);
698
699                 h->long_ref[mmco[i].long_arg]           = h->cur_pic_ptr;
700                 h->long_ref[mmco[i].long_arg]->long_ref = 1;
701                 h->long_ref_count++;
702             }
703
704             h->cur_pic_ptr->reference |= h->picture_structure;
705             current_ref_assigned = 1;
706             break;
707         case MMCO_SET_MAX_LONG:
708             assert(mmco[i].long_arg <= 16);
709             // just remove the long term which index is greater than new max
710             for (j = mmco[i].long_arg; j < 16; j++) {
711                 remove_long(h, j, 0);
712             }
713             break;
714         case MMCO_RESET:
715             while (h->short_ref_count) {
716                 remove_short(h, h->short_ref[0]->frame_num, 0);
717             }
718             for (j = 0; j < 16; j++) {
719                 remove_long(h, j, 0);
720             }
721             h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
722             h->mmco_reset = 1;
723             h->cur_pic_ptr->mmco_reset = 1;
724             for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
725                 h->last_pocs[j] = INT_MIN;
726             break;
727         default: assert(0);
728         }
729     }
730
731     if (!current_ref_assigned) {
732         /* Second field of complementary field pair; the first field of
733          * which is already referenced. If short referenced, it
734          * should be first entry in short_ref. If not, it must exist
735          * in long_ref; trying to put it on the short list here is an
736          * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
737          */
738         if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
739             /* Just mark the second field valid */
740             h->cur_pic_ptr->reference |= h->picture_structure;
741         } else if (h->cur_pic_ptr->long_ref) {
742             av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
743                                            "assignment for second field "
744                                            "in complementary field pair "
745                                            "(first field is long term)\n");
746             err = AVERROR_INVALIDDATA;
747         } else {
748             pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
749             if (pic) {
750                 av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
751                 err = AVERROR_INVALIDDATA;
752             }
753
754             if (h->short_ref_count)
755                 memmove(&h->short_ref[1], &h->short_ref[0],
756                         h->short_ref_count * sizeof(H264Picture*));
757
758             h->short_ref[0] = h->cur_pic_ptr;
759             h->short_ref_count++;
760             h->cur_pic_ptr->reference |= h->picture_structure;
761         }
762     }
763
764     if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
765
766         /* We have too many reference frames, probably due to corrupted
767          * stream. Need to discard one frame. Prevents overrun of the
768          * short_ref and long_ref buffers.
769          */
770         av_log(h->avctx, AV_LOG_ERROR,
771                "number of reference frames (%d+%d) exceeds max (%d; probably "
772                "corrupt input), discarding one\n",
773                h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
774         err = AVERROR_INVALIDDATA;
775
776         if (h->long_ref_count && !h->short_ref_count) {
777             for (i = 0; i < 16; ++i)
778                 if (h->long_ref[i])
779                     break;
780
781             assert(i < 16);
782             remove_long(h, i, 0);
783         } else {
784             pic = h->short_ref[h->short_ref_count - 1];
785             remove_short(h, pic->frame_num, 0);
786         }
787     }
788
789     for (i = 0; i<h->short_ref_count; i++) {
790         pic = h->short_ref[i];
791         if (pic->invalid_gap) {
792             int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
793             if (d > h->ps.sps->ref_frame_count)
794                 remove_short(h, pic->frame_num, 0);
795         }
796     }
797
798     print_short_term(h);
799     print_long_term(h);
800
801     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
802         if (h->ps.pps_list[i]) {
803             const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
804             pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
805             pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
806         }
807     }
808
809     if (   err >= 0
810         && h->long_ref_count==0
811         && (   h->short_ref_count<=2
812             || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
813         && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
814         && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){
815         h->cur_pic_ptr->recovered |= 1;
816         if(!h->avctx->has_b_frames)
817             h->frame_recovered |= FRAME_RECOVERED_SEI;
818     }
819
820     return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
821 }
822
823 int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
824                                    const H2645NAL *nal, void *logctx)
825 {
826     int i;
827     MMCO *mmco = sl->mmco;
828     int nb_mmco = 0;
829
830     if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
831         skip_bits1(gb); // broken_link
832         if (get_bits1(gb)) {
833             mmco[0].opcode   = MMCO_LONG;
834             mmco[0].long_arg = 0;
835             nb_mmco          = 1;
836         }
837         sl->explicit_ref_marking = 1;
838     } else {
839         sl->explicit_ref_marking = get_bits1(gb);
840         if (sl->explicit_ref_marking) {
841             for (i = 0; i < MAX_MMCO_COUNT; i++) {
842                 MMCOOpcode opcode = get_ue_golomb_31(gb);
843
844                 mmco[i].opcode = opcode;
845                 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
846                     mmco[i].short_pic_num =
847                         (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
848                             (sl->max_pic_num - 1);
849                 }
850                 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
851                     opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
852                     unsigned int long_arg = get_ue_golomb_31(gb);
853                     if (long_arg >= 32 ||
854                         (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
855                                              long_arg == 16) &&
856                          !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
857                         av_log(logctx, AV_LOG_ERROR,
858                                "illegal long ref in memory management control "
859                                "operation %d\n", opcode);
860                         return -1;
861                     }
862                     mmco[i].long_arg = long_arg;
863                 }
864
865                 if (opcode > (unsigned) MMCO_LONG) {
866                     av_log(logctx, AV_LOG_ERROR,
867                            "illegal memory management control operation %d\n",
868                            opcode);
869                     return -1;
870                 }
871                 if (opcode == MMCO_END)
872                     break;
873             }
874             nb_mmco = i;
875         }
876     }
877
878     sl->nb_mmco = nb_mmco;
879
880     return 0;
881 }