PageRenderTime 91ms CodeModel.GetById 20ms app.highlight 62ms RepoModel.GetById 1ms app.codeStats 1ms

/libavcodec/h264_refs.c

http://github.com/FFmpeg/FFmpeg
C | 894 lines | 693 code | 105 blank | 96 comment | 227 complexity | 97ec62259517337d421fce9bed337184 MD5 | raw file
  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
 40static 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
 52static 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
 62static 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
 78static 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
104static 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
127static 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
135static 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 */
220static 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 */
236static 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 */
261static 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
274static 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
299int 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 || mismatches_ref(h, ref)) {
377                av_log(h->avctx, AV_LOG_ERROR,
378                       i < 0 ? "reference picture missing during reorder\n" :
379                               "mismatching reference\n"
380                      );
381                memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME
382            } else {
383                for (i = index; i + 1 < sl->ref_count[list]; i++) {
384                    if (sl->ref_list[list][i].parent &&
385                        ref->long_ref == sl->ref_list[list][i].parent->long_ref &&
386                        ref->pic_id   == sl->ref_list[list][i].pic_id)
387                        break;
388                }
389                for (; i > index; i--) {
390                    sl->ref_list[list][i] = sl->ref_list[list][i - 1];
391                }
392                ref_from_h264pic(&sl->ref_list[list][index], ref);
393                if (FIELD_PICTURE(h)) {
394                    pic_as_field(&sl->ref_list[list][index], pic_structure);
395                }
396            }
397        }
398    }
399    for (list = 0; list < sl->list_count; list++) {
400        for (index = 0; index < sl->ref_count[list]; index++) {
401            if (   !sl->ref_list[list][index].parent
402                || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
403                int i;
404                av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);
405                for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
406                    h->last_pocs[i] = INT_MIN;
407                if (h->default_ref[list].parent
408                    && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
409                    sl->ref_list[list][index] = h->default_ref[list];
410                else
411                    return -1;
412            }
413            av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
414        }
415    }
416
417    if (FRAME_MBAFF(h))
418        h264_fill_mbaff_ref_list(sl);
419
420    return 0;
421}
422
423int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
424{
425    int list, index;
426
427    sl->nb_ref_modifications[0] = 0;
428    sl->nb_ref_modifications[1] = 0;
429
430    for (list = 0; list < sl->list_count; list++) {
431        if (!get_bits1(&sl->gb))    // ref_pic_list_modification_flag_l[01]
432            continue;
433
434        for (index = 0; ; index++) {
435            unsigned int op = get_ue_golomb_31(&sl->gb);
436
437            if (op == 3)
438                break;
439
440            if (index >= sl->ref_count[list]) {
441                av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
442                return AVERROR_INVALIDDATA;
443            } else if (op > 2) {
444                av_log(logctx, AV_LOG_ERROR,
445                       "illegal modification_of_pic_nums_idc %u\n",
446                       op);
447                return AVERROR_INVALIDDATA;
448            }
449            sl->ref_modifications[list][index].val = get_ue_golomb_long(&sl->gb);
450            sl->ref_modifications[list][index].op  = op;
451            sl->nb_ref_modifications[list]++;
452        }
453    }
454
455    return 0;
456}
457
458/**
459 * Mark a picture as no longer needed for reference. The refmask
460 * argument allows unreferencing of individual fields or the whole frame.
461 * If the picture becomes entirely unreferenced, but is being held for
462 * display purposes, it is marked as such.
463 * @param refmask mask of fields to unreference; the mask is bitwise
464 *                anded with the reference marking of pic
465 * @return non-zero if pic becomes entirely unreferenced (except possibly
466 *         for display purposes) zero if one of the fields remains in
467 *         reference
468 */
469static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
470{
471    int i;
472    if (pic->reference &= refmask) {
473        return 0;
474    } else {
475        for(i = 0; h->delayed_pic[i]; i++)
476            if(pic == h->delayed_pic[i]){
477                pic->reference = DELAYED_PIC_REF;
478                break;
479            }
480        return 1;
481    }
482}
483
484/**
485 * Find a H264Picture in the short term reference list by frame number.
486 * @param frame_num frame number to search for
487 * @param idx the index into h->short_ref where returned picture is found
488 *            undefined if no picture found.
489 * @return pointer to the found picture, or NULL if no pic with the provided
490 *                 frame number is found
491 */
492static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
493{
494    int i;
495
496    for (i = 0; i < h->short_ref_count; i++) {
497        H264Picture *pic = h->short_ref[i];
498        if (h->avctx->debug & FF_DEBUG_MMCO)
499            av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
500        if (pic->frame_num == frame_num) {
501            *idx = i;
502            return pic;
503        }
504    }
505    return NULL;
506}
507
508/**
509 * Remove a picture from the short term reference list by its index in
510 * that list.  This does no checking on the provided index; it is assumed
511 * to be valid. Other list entries are shifted down.
512 * @param i index into h->short_ref of picture to remove.
513 */
514static void remove_short_at_index(H264Context *h, int i)
515{
516    assert(i >= 0 && i < h->short_ref_count);
517    h->short_ref[i] = NULL;
518    if (--h->short_ref_count)
519        memmove(&h->short_ref[i], &h->short_ref[i + 1],
520                (h->short_ref_count - i) * sizeof(H264Picture*));
521}
522
523/**
524 * @return the removed picture or NULL if an error occurs
525 */
526static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
527{
528    H264Picture *pic;
529    int i;
530
531    if (h->avctx->debug & FF_DEBUG_MMCO)
532        av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
533
534    pic = find_short(h, frame_num, &i);
535    if (pic) {
536        if (unreference_pic(h, pic, ref_mask))
537            remove_short_at_index(h, i);
538    }
539
540    return pic;
541}
542
543/**
544 * Remove a picture from the long term reference list by its index in
545 * that list.
546 * @return the removed picture or NULL if an error occurs
547 */
548static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
549{
550    H264Picture *pic;
551
552    pic = h->long_ref[i];
553    if (pic) {
554        if (unreference_pic(h, pic, ref_mask)) {
555            assert(h->long_ref[i]->long_ref == 1);
556            h->long_ref[i]->long_ref = 0;
557            h->long_ref[i]           = NULL;
558            h->long_ref_count--;
559        }
560    }
561
562    return pic;
563}
564
565void ff_h264_remove_all_refs(H264Context *h)
566{
567    int i;
568
569    for (i = 0; i < 16; i++) {
570        remove_long(h, i, 0);
571    }
572    assert(h->long_ref_count == 0);
573
574    if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
575        ff_h264_unref_picture(h, &h->last_pic_for_ec);
576        ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
577    }
578
579    for (i = 0; i < h->short_ref_count; i++) {
580        unreference_pic(h, h->short_ref[i], 0);
581        h->short_ref[i] = NULL;
582    }
583    h->short_ref_count = 0;
584
585    memset(h->default_ref, 0, sizeof(h->default_ref));
586}
587
588static void generate_sliding_window_mmcos(H264Context *h)
589{
590    MMCO *mmco = h->mmco;
591    int nb_mmco = 0;
592
593    if (h->short_ref_count &&
594        h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&
595        !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
596        mmco[0].opcode        = MMCO_SHORT2UNUSED;
597        mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
598        nb_mmco               = 1;
599        if (FIELD_PICTURE(h)) {
600            mmco[0].short_pic_num *= 2;
601            mmco[1].opcode         = MMCO_SHORT2UNUSED;
602            mmco[1].short_pic_num  = mmco[0].short_pic_num + 1;
603            nb_mmco                = 2;
604        }
605    }
606
607    h->nb_mmco = nb_mmco;
608}
609
610int ff_h264_execute_ref_pic_marking(H264Context *h)
611{
612    MMCO *mmco = h->mmco;
613    int mmco_count;
614    int i, av_uninit(j);
615    int pps_ref_count[2] = {0};
616    int current_ref_assigned = 0, err = 0;
617    H264Picture *av_uninit(pic);
618
619    if (!h->ps.sps) {
620        av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");
621        err = AVERROR_INVALIDDATA;
622        goto out;
623    }
624
625    if (!h->explicit_ref_marking)
626        generate_sliding_window_mmcos(h);
627    mmco_count = h->nb_mmco;
628
629    if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
630        av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
631
632    for (i = 0; i < mmco_count; i++) {
633        int av_uninit(structure), av_uninit(frame_num);
634        if (h->avctx->debug & FF_DEBUG_MMCO)
635            av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
636                   h->mmco[i].short_pic_num, h->mmco[i].long_arg);
637
638        if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
639            mmco[i].opcode == MMCO_SHORT2LONG) {
640            frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
641            pic       = find_short(h, frame_num, &j);
642            if (!pic) {
643                if (mmco[i].opcode != MMCO_SHORT2LONG ||
644                    !h->long_ref[mmco[i].long_arg]    ||
645                    h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
646                    av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
647                    err = AVERROR_INVALIDDATA;
648                }
649                continue;
650            }
651        }
652
653        switch (mmco[i].opcode) {
654        case MMCO_SHORT2UNUSED:
655            if (h->avctx->debug & FF_DEBUG_MMCO)
656                av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
657                       h->mmco[i].short_pic_num, h->short_ref_count);
658            remove_short(h, frame_num, structure ^ PICT_FRAME);
659            break;
660        case MMCO_SHORT2LONG:
661                if (h->long_ref[mmco[i].long_arg] != pic)
662                    remove_long(h, mmco[i].long_arg, 0);
663
664                remove_short_at_index(h, j);
665                h->long_ref[ mmco[i].long_arg ] = pic;
666                if (h->long_ref[mmco[i].long_arg]) {
667                    h->long_ref[mmco[i].long_arg]->long_ref = 1;
668                    h->long_ref_count++;
669                }
670            break;
671        case MMCO_LONG2UNUSED:
672            j   = pic_num_extract(h, mmco[i].long_arg, &structure);
673            pic = h->long_ref[j];
674            if (pic) {
675                remove_long(h, j, structure ^ PICT_FRAME);
676            } else if (h->avctx->debug & FF_DEBUG_MMCO)
677                av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
678            break;
679        case MMCO_LONG:
680                    // Comment below left from previous code as it is an interesting note.
681                    /* First field in pair is in short term list or
682                     * at a different long term index.
683                     * This is not allowed; see 7.4.3.3, notes 2 and 3.
684                     * Report the problem and keep the pair where it is,
685                     * and mark this field valid.
686                     */
687            if (h->short_ref[0] == h->cur_pic_ptr) {
688                av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
689                remove_short_at_index(h, 0);
690            }
691
692            /* make sure the current picture is not already assigned as a long ref */
693            if (h->cur_pic_ptr->long_ref) {
694                for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
695                    if (h->long_ref[j] == h->cur_pic_ptr) {
696                        if (j != mmco[i].long_arg)
697                            av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
698                        remove_long(h, j, 0);
699                    }
700                }
701            }
702
703            if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
704                av_assert0(!h->cur_pic_ptr->long_ref);
705                remove_long(h, mmco[i].long_arg, 0);
706
707                h->long_ref[mmco[i].long_arg]           = h->cur_pic_ptr;
708                h->long_ref[mmco[i].long_arg]->long_ref = 1;
709                h->long_ref_count++;
710            }
711
712            h->cur_pic_ptr->reference |= h->picture_structure;
713            current_ref_assigned = 1;
714            break;
715        case MMCO_SET_MAX_LONG:
716            assert(mmco[i].long_arg <= 16);
717            // just remove the long term which index is greater than new max
718            for (j = mmco[i].long_arg; j < 16; j++) {
719                remove_long(h, j, 0);
720            }
721            break;
722        case MMCO_RESET:
723            while (h->short_ref_count) {
724                remove_short(h, h->short_ref[0]->frame_num, 0);
725            }
726            for (j = 0; j < 16; j++) {
727                remove_long(h, j, 0);
728            }
729            h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
730            h->mmco_reset = 1;
731            h->cur_pic_ptr->mmco_reset = 1;
732            for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
733                h->last_pocs[j] = INT_MIN;
734            break;
735        default: av_assert0(0);
736        }
737    }
738
739    if (!current_ref_assigned) {
740        /* Second field of complementary field pair; the first field of
741         * which is already referenced. If short referenced, it
742         * should be first entry in short_ref. If not, it must exist
743         * in long_ref; trying to put it on the short list here is an
744         * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
745         */
746        if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
747            /* Just mark the second field valid */
748            h->cur_pic_ptr->reference |= h->picture_structure;
749        } else if (h->cur_pic_ptr->long_ref) {
750            av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
751                                           "assignment for second field "
752                                           "in complementary field pair "
753                                           "(first field is long term)\n");
754            err = AVERROR_INVALIDDATA;
755        } else {
756            pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
757            if (pic) {
758                av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
759                err = AVERROR_INVALIDDATA;
760            }
761
762            if (h->short_ref_count)
763                memmove(&h->short_ref[1], &h->short_ref[0],
764                        h->short_ref_count * sizeof(H264Picture*));
765
766            h->short_ref[0] = h->cur_pic_ptr;
767            h->short_ref_count++;
768            h->cur_pic_ptr->reference |= h->picture_structure;
769        }
770    }
771
772    if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
773
774        /* We have too many reference frames, probably due to corrupted
775         * stream. Need to discard one frame. Prevents overrun of the
776         * short_ref and long_ref buffers.
777         */
778        av_log(h->avctx, AV_LOG_ERROR,
779               "number of reference frames (%d+%d) exceeds max (%d; probably "
780               "corrupt input), discarding one\n",
781               h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
782        err = AVERROR_INVALIDDATA;
783
784        if (h->long_ref_count && !h->short_ref_count) {
785            for (i = 0; i < 16; ++i)
786                if (h->long_ref[i])
787                    break;
788
789            assert(i < 16);
790            remove_long(h, i, 0);
791        } else {
792            pic = h->short_ref[h->short_ref_count - 1];
793            remove_short(h, pic->frame_num, 0);
794        }
795    }
796
797    for (i = 0; i<h->short_ref_count; i++) {
798        pic = h->short_ref[i];
799        if (pic->invalid_gap) {
800            int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
801            if (d > h->ps.sps->ref_frame_count)
802                remove_short(h, pic->frame_num, 0);
803        }
804    }
805
806    print_short_term(h);
807    print_long_term(h);
808
809    for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
810        if (h->ps.pps_list[i]) {
811            const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
812            pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
813            pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
814        }
815    }
816
817    // Detect unmarked random access points
818    if (   err >= 0
819        && h->long_ref_count==0
820        && (   h->short_ref_count<=2
821            || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames
822            || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
823        && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
824        && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){
825        h->cur_pic_ptr->recovered |= 1;
826        if(!h->avctx->has_b_frames)
827            h->frame_recovered |= FRAME_RECOVERED_SEI;
828    }
829
830out:
831    return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
832}
833
834int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
835                                   const H2645NAL *nal, void *logctx)
836{
837    int i;
838    MMCO *mmco = sl->mmco;
839    int nb_mmco = 0;
840
841    if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
842        skip_bits1(gb); // broken_link
843        if (get_bits1(gb)) {
844            mmco[0].opcode   = MMCO_LONG;
845            mmco[0].long_arg = 0;
846            nb_mmco          = 1;
847        }
848        sl->explicit_ref_marking = 1;
849    } else {
850        sl->explicit_ref_marking = get_bits1(gb);
851        if (sl->explicit_ref_marking) {
852            for (i = 0; i < MAX_MMCO_COUNT; i++) {
853                MMCOOpcode opcode = get_ue_golomb_31(gb);
854
855                mmco[i].opcode = opcode;
856                if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
857                    mmco[i].short_pic_num =
858                        (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
859                            (sl->max_pic_num - 1);
860                }
861                if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
862                    opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
863                    unsigned int long_arg = get_ue_golomb_31(gb);
864                    if (long_arg >= 32 ||
865                        (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
866                                             long_arg == 16) &&
867                         !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
868                        av_log(logctx, AV_LOG_ERROR,
869                               "illegal long ref in memory management control "
870                               "operation %d\n", opcode);
871                        sl->nb_mmco = i;
872                        return -1;
873                    }
874                    mmco[i].long_arg = long_arg;
875                }
876
877                if (opcode > (unsigned) MMCO_LONG) {
878                    av_log(logctx, AV_LOG_ERROR,
879                           "illegal memory management control operation %d\n",
880                           opcode);
881                    sl->nb_mmco = i;
882                    return -1;
883                }
884                if (opcode == MMCO_END)
885                    break;
886            }
887            nb_mmco = i;
888        }
889    }
890
891    sl->nb_mmco = nb_mmco;
892
893    return 0;
894}