LCOV - code coverage report
Current view: top level - libavcodec - h264_refs.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 422 473 89.2 %
Date: 2017-12-15 18:13:28 Functions: 22 22 100.0 %

          Line data    Source code
       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       57602 : static void pic_as_field(H264Ref *pic, const int parity)
      41             : {
      42             :     int i;
      43      230408 :     for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) {
      44      172806 :         if (parity == PICT_BOTTOM_FIELD)
      45       82989 :             pic->data[i]   += pic->linesize[i];
      46      172806 :         pic->reference      = parity;
      47      172806 :         pic->linesize[i] *= 2;
      48             :     }
      49       57602 :     pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD];
      50       57602 : }
      51             : 
      52      185185 : static void ref_from_h264pic(H264Ref *dst, H264Picture *src)
      53             : {
      54      185185 :     memcpy(dst->data,     src->f->data,     sizeof(dst->data));
      55      185185 :     memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize));
      56      185185 :     dst->reference = src->reference;
      57      185185 :     dst->poc       = src->poc;
      58      185185 :     dst->pic_id    = src->pic_id;
      59      185185 :     dst->parent = src;
      60      185185 : }
      61             : 
      62      174633 : static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add)
      63             : {
      64      174633 :     int match = !!(src->reference & parity);
      65             : 
      66      174633 :     if (match) {
      67      174633 :         ref_from_h264pic(dest, src);
      68      174633 :         if (parity != PICT_FRAME) {
      69       56652 :             pic_as_field(dest, parity);
      70       56652 :             dest->pic_id *= 2;
      71       56652 :             dest->pic_id += id_add;
      72             :         }
      73             :     }
      74             : 
      75      174633 :     return match;
      76             : }
      77             : 
      78       84872 : static int build_def_list(H264Ref *def, int def_len,
      79             :                           H264Picture * const *in, int len, int is_long, int sel)
      80             : {
      81       84872 :     int  i[2] = { 0 };
      82       84872 :     int index = 0;
      83             : 
      84      359553 :     while (i[0] < len || i[1] < len) {
      85     1058700 :         while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel)))
      86      679082 :             i[0]++;
      87     1174589 :         while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3))))
      88      794971 :             i[1]++;
      89      189809 :         if (i[0] < len) {
      90      145261 :             av_assert0(index < def_len);
      91      145261 :             in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num;
      92      145261 :             split_field_copy(&def[index++], in[i[0]++], sel, 1);
      93             :         }
      94      189809 :         if (i[1] < len) {
      95       29372 :             av_assert0(index < def_len);
      96       29372 :             in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num;
      97       29372 :             split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0);
      98             :         }
      99             :     }
     100             : 
     101       84872 :     return index;
     102             : }
     103             : 
     104       44104 : static int add_sorted(H264Picture **sorted, H264Picture * const *src,
     105             :                       int len, int limit, int dir)
     106             : {
     107             :     int i, best_poc;
     108       44104 :     int out_i = 0;
     109             : 
     110             :     for (;;) {
     111      179048 :         best_poc = dir ? INT_MIN : INT_MAX;
     112             : 
     113      581076 :         for (i = 0; i < len; i++) {
     114      469500 :             const int poc = src[i]->poc;
     115      469500 :             if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) {
     116       78944 :                 best_poc      = poc;
     117       78944 :                 sorted[out_i] = src[i];
     118             :             }
     119             :         }
     120      111576 :         if (best_poc == (dir ? INT_MIN : INT_MAX))
     121       44104 :             break;
     122       67472 :         limit = sorted[out_i++]->poc - dir;
     123             :     }
     124       44104 :     return out_i;
     125             : }
     126             : 
     127      124703 : static int mismatches_ref(const H264Context *h, const H264Picture *pic)
     128             : {
     129      124703 :     const AVFrame *f = pic->f;
     130      249406 :     return (h->cur_pic_ptr->f->width  != f->width ||
     131      249406 :             h->cur_pic_ptr->f->height != f->height ||
     132      124703 :             h->cur_pic_ptr->f->format != f->format);
     133             : }
     134             : 
     135       31410 : static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl)
     136             : {
     137             :     int i, len;
     138             :     int j;
     139             : 
     140       31410 :     if (sl->slice_type_nos == AV_PICTURE_TYPE_B) {
     141             :         H264Picture *sorted[32];
     142             :         int cur_poc, list;
     143             :         int lens[2];
     144             : 
     145       11026 :         if (FIELD_PICTURE(h))
     146        4430 :             cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD];
     147             :         else
     148        6596 :             cur_poc = h->cur_pic_ptr->poc;
     149             : 
     150       33078 :         for (list = 0; list < 2; list++) {
     151       22052 :             len  = add_sorted(sorted,       h->short_ref, h->short_ref_count, cur_poc, 1 ^ list);
     152       22052 :             len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list);
     153       22052 :             av_assert0(len <= 32);
     154             : 
     155       22052 :             len  = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]),
     156             :                                   sorted, len, 0, h->picture_structure);
     157       44104 :             len += build_def_list(sl->ref_list[list] + len,
     158       22052 :                                   FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
     159       22052 :                                   h->long_ref, 16, 1, h->picture_structure);
     160       22052 :             av_assert0(len <= 32);
     161             : 
     162       22052 :             if (len < sl->ref_count[list])
     163           4 :                 memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len));
     164       22052 :             lens[list] = len;
     165             :         }
     166             : 
     167       11026 :         if (lens[0] == lens[1] && lens[1] > 1) {
     168       34490 :             for (i = 0; i < lens[0] &&
     169       11529 :                         sl->ref_list[0][i].parent->f->buf[0]->buffer ==
     170       15476 :                         sl->ref_list[1][i].parent->f->buf[0]->buffer; i++);
     171        9507 :             if (i == lens[0]) {
     172        1925 :                 FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]);
     173             :             }
     174             :         }
     175             :     } else {
     176       40768 :         len  = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]),
     177       20384 :                               h->short_ref, h->short_ref_count, 0, h->picture_structure);
     178       40768 :         len += build_def_list(sl->ref_list[0] + len,
     179       20384 :                               FF_ARRAY_ELEMS(sl->ref_list[0]) - len,
     180       20384 :                               h-> long_ref, 16, 1, h->picture_structure);
     181       20384 :         av_assert0(len <= 32);
     182             : 
     183       20384 :         if (len < sl->ref_count[0])
     184         779 :             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       73846 :     for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) {
     204      168613 :         for (i = 0; i < sl->ref_count[j]; i++) {
     205      126177 :             if (sl->ref_list[j][i].parent) {
     206      124703 :                 if (mismatches_ref(h, sl->ref_list[j][i].parent)) {
     207           0 :                     av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n");
     208           0 :                     memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i]));
     209             :                 }
     210             :             }
     211             :         }
     212             :     }
     213       69725 :     for (i = 0; i < sl->list_count; i++)
     214       38315 :         h->default_ref[i] = sl->ref_list[i][0];
     215       31410 : }
     216             : 
     217             : /**
     218             :  * print short term list
     219             :  */
     220       48199 : static void print_short_term(const H264Context *h)
     221             : {
     222             :     uint32_t i;
     223       48199 :     if (h->avctx->debug & FF_DEBUG_MMCO) {
     224           0 :         av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n");
     225           0 :         for (i = 0; i < h->short_ref_count; i++) {
     226           0 :             H264Picture *pic = h->short_ref[i];
     227           0 :             av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
     228           0 :                    i, pic->frame_num, pic->poc, pic->f->data[0]);
     229             :         }
     230             :     }
     231       48199 : }
     232             : 
     233             : /**
     234             :  * print long term list
     235             :  */
     236       48199 : static void print_long_term(const H264Context *h)
     237             : {
     238             :     uint32_t i;
     239       48199 :     if (h->avctx->debug & FF_DEBUG_MMCO) {
     240           0 :         av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n");
     241           0 :         for (i = 0; i < 16; i++) {
     242           0 :             H264Picture *pic = h->long_ref[i];
     243           0 :             if (pic) {
     244           0 :                 av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n",
     245           0 :                        i, pic->frame_num, pic->poc, pic->f->data[0]);
     246             :             }
     247             :         }
     248             :     }
     249       48199 : }
     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       24852 : static int pic_num_extract(const H264Context *h, int pic_num, int *structure)
     262             : {
     263       24852 :     *structure = h->picture_structure;
     264       24852 :     if (FIELD_PICTURE(h)) {
     265        3248 :         if (!(pic_num & 1))
     266             :             /* opposite field */
     267        1710 :             *structure ^= PICT_FRAME;
     268        3248 :         pic_num >>= 1;
     269             :     }
     270             : 
     271       24852 :     return pic_num;
     272             : }
     273             : 
     274        2364 : static void h264_fill_mbaff_ref_list(H264SliceContext *sl)
     275             : {
     276             :     int list, i, j;
     277        5496 :     for (list = 0; list < sl->list_count; list++) {
     278       11501 :         for (i = 0; i < sl->ref_count[list]; i++) {
     279        8369 :             H264Ref *frame = &sl->ref_list[list][i];
     280        8369 :             H264Ref *field = &sl->ref_list[list][16 + 2 * i];
     281             : 
     282        8369 :             field[0] = *frame;
     283             : 
     284       33476 :             for (j = 0; j < 3; j++)
     285       25107 :                 field[0].linesize[j] <<= 1;
     286        8369 :             field[0].reference = PICT_TOP_FIELD;
     287        8369 :             field[0].poc       = field[0].parent->field_poc[0];
     288             : 
     289        8369 :             field[1] = field[0];
     290             : 
     291       33476 :             for (j = 0; j < 3; j++)
     292       25107 :                 field[1].data[j] += frame->parent->f->linesize[j];
     293        8369 :             field[1].reference = PICT_BOTTOM_FIELD;
     294        8369 :             field[1].poc       = field[1].parent->field_poc[1];
     295             :         }
     296             :     }
     297        2364 : }
     298             : 
     299       31410 : int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl)
     300             : {
     301             :     int list, index, pic_structure;
     302             : 
     303       31410 :     print_short_term(h);
     304       31410 :     print_long_term(h);
     305             : 
     306       31410 :     h264_initialise_ref_list(h, sl);
     307             : 
     308       69725 :     for (list = 0; list < sl->list_count; list++) {
     309       38315 :         int pred = sl->curr_pic_num;
     310             : 
     311       48867 :         for (index = 0; index < sl->nb_ref_modifications[list]; index++) {
     312       10552 :             unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op;
     313       10552 :             unsigned int                          val = sl->ref_modifications[list][index].val;
     314             :             unsigned int pic_id;
     315             :             int i;
     316       10552 :             H264Picture *ref = NULL;
     317             : 
     318       10552 :             switch (modification_of_pic_nums_idc) {
     319        9989 :             case 0:
     320             :             case 1: {
     321        9989 :                 const unsigned int abs_diff_pic_num = val + 1;
     322             :                 int frame_num;
     323             : 
     324        9989 :                 if (abs_diff_pic_num > sl->max_pic_num) {
     325           0 :                     av_log(h->avctx, AV_LOG_ERROR,
     326             :                            "abs_diff_pic_num overflow\n");
     327           0 :                     return AVERROR_INVALIDDATA;
     328             :                 }
     329             : 
     330        9989 :                 if (modification_of_pic_nums_idc == 0)
     331        8190 :                     pred -= abs_diff_pic_num;
     332             :                 else
     333        1799 :                     pred += abs_diff_pic_num;
     334        9989 :                 pred &= sl->max_pic_num - 1;
     335             : 
     336        9989 :                 frame_num = pic_num_extract(h, pred, &pic_structure);
     337             : 
     338       34665 :                 for (i = h->short_ref_count - 1; i >= 0; i--) {
     339       34665 :                     ref = h->short_ref[i];
     340             :                     assert(ref->reference);
     341             :                     assert(!ref->long_ref);
     342       44654 :                     if (ref->frame_num == frame_num &&
     343        9989 :                         (ref->reference & pic_structure))
     344        9989 :                         break;
     345             :                 }
     346        9989 :                 if (i >= 0)
     347        9989 :                     ref->pic_id = pred;
     348        9989 :                 break;
     349             :             }
     350         563 :             case 2: {
     351             :                 int long_idx;
     352         563 :                 pic_id = val; // long_term_pic_idx
     353             : 
     354         563 :                 long_idx = pic_num_extract(h, pic_id, &pic_structure);
     355             : 
     356         563 :                 if (long_idx > 31U) {
     357           0 :                     av_log(h->avctx, AV_LOG_ERROR,
     358             :                            "long_term_pic_idx overflow\n");
     359           0 :                     return AVERROR_INVALIDDATA;
     360             :                 }
     361         563 :                 ref = h->long_ref[long_idx];
     362             :                 assert(!(ref && !ref->reference));
     363         563 :                 if (ref && (ref->reference & pic_structure)) {
     364         563 :                     ref->pic_id = pic_id;
     365             :                     assert(ref->long_ref);
     366         563 :                     i = 0;
     367             :                 } else {
     368           0 :                     i = -1;
     369             :                 }
     370         563 :                 break;
     371             :             }
     372           0 :             default:
     373           0 :                 av_assert0(0);
     374             :             }
     375             : 
     376       10552 :             if (i < 0) {
     377           0 :                 av_log(h->avctx, AV_LOG_ERROR,
     378             :                        "reference picture missing during reorder\n");
     379           0 :                 memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME
     380             :             } else {
     381       21472 :                 for (i = index; i + 1 < sl->ref_count[list]; i++) {
     382       32517 :                     if (sl->ref_list[list][i].parent &&
     383       28897 :                         ref->long_ref == sl->ref_list[list][i].parent->long_ref &&
     384       13479 :                         ref->pic_id   == sl->ref_list[list][i].pic_id)
     385        6179 :                         break;
     386             :                 }
     387       21472 :                 for (; i > index; i--) {
     388       10920 :                     sl->ref_list[list][i] = sl->ref_list[list][i - 1];
     389             :                 }
     390       10552 :                 ref_from_h264pic(&sl->ref_list[list][index], ref);
     391       10552 :                 if (FIELD_PICTURE(h)) {
     392         950 :                     pic_as_field(&sl->ref_list[list][index], pic_structure);
     393             :                 }
     394             :             }
     395             :         }
     396             :     }
     397       69725 :     for (list = 0; list < sl->list_count; list++) {
     398      164492 :         for (index = 0; index < sl->ref_count[list]; index++) {
     399      126177 :             if (   !sl->ref_list[list][index].parent
     400      126163 :                 || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) {
     401             :                 int i;
     402          14 :                 av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc);
     403         238 :                 for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++)
     404         224 :                     h->last_pocs[i] = INT_MIN;
     405          14 :                 if (h->default_ref[list].parent
     406          14 :                     && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3))
     407          14 :                     sl->ref_list[list][index] = h->default_ref[list];
     408             :                 else
     409           0 :                     return -1;
     410             :             }
     411      126177 :             av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0);
     412             :         }
     413             :     }
     414             : 
     415       31410 :     if (FRAME_MBAFF(h))
     416        2364 :         h264_fill_mbaff_ref_list(sl);
     417             : 
     418       31410 :     return 0;
     419             : }
     420             : 
     421       27373 : int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx)
     422             : {
     423             :     int list, index;
     424             : 
     425       27373 :     sl->nb_ref_modifications[0] = 0;
     426       27373 :     sl->nb_ref_modifications[1] = 0;
     427             : 
     428       65813 :     for (list = 0; list < sl->list_count; list++) {
     429       38443 :         if (!get_bits1(&sl->gb))    // ref_pic_list_modification_flag_l[01]
     430       35522 :             continue;
     431             : 
     432       13547 :         for (index = 0; ; index++) {
     433       13547 :             unsigned int op = get_ue_golomb_31(&sl->gb);
     434             : 
     435       13547 :             if (op == 3)
     436        2918 :                 break;
     437             : 
     438       10629 :             if (index >= sl->ref_count[list]) {
     439           2 :                 av_log(logctx, AV_LOG_ERROR, "reference count overflow\n");
     440           2 :                 return AVERROR_INVALIDDATA;
     441       10627 :             } else if (op > 2) {
     442           1 :                 av_log(logctx, AV_LOG_ERROR,
     443             :                        "illegal modification_of_pic_nums_idc %u\n",
     444             :                        op);
     445           1 :                 return AVERROR_INVALIDDATA;
     446             :             }
     447       10626 :             sl->ref_modifications[list][index].val = get_ue_golomb_long(&sl->gb);
     448       10626 :             sl->ref_modifications[list][index].op  = op;
     449       10626 :             sl->nb_ref_modifications[list]++;
     450             :         }
     451             :     }
     452             : 
     453       27370 :     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       16502 : static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask)
     468             : {
     469             :     int i;
     470       16502 :     if (pic->reference &= refmask) {
     471        1124 :         return 0;
     472             :     } else {
     473       30246 :         for(i = 0; h->delayed_pic[i]; i++)
     474       16049 :             if(pic == h->delayed_pic[i]){
     475        1181 :                 pic->reference = DELAYED_PIC_REF;
     476        1181 :                 break;
     477             :             }
     478       15378 :         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       43506 : static H264Picture *find_short(H264Context *h, int frame_num, int *idx)
     491             : {
     492             :     int i;
     493             : 
     494      195584 :     for (i = 0; i < h->short_ref_count; i++) {
     495      180199 :         H264Picture *pic = h->short_ref[i];
     496      180199 :         if (h->avctx->debug & FF_DEBUG_MMCO)
     497           0 :             av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic);
     498      180199 :         if (pic->frame_num == frame_num) {
     499       28121 :             *idx = i;
     500       28121 :             return pic;
     501             :         }
     502             :     }
     503       15385 :     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       13129 : static void remove_short_at_index(H264Context *h, int i)
     513             : {
     514             :     assert(i >= 0 && i < h->short_ref_count);
     515       13129 :     h->short_ref[i] = NULL;
     516       13129 :     if (--h->short_ref_count)
     517        9884 :         memmove(&h->short_ref[i], &h->short_ref[i + 1],
     518        9884 :                 (h->short_ref_count - i) * sizeof(H264Picture*));
     519       13129 : }
     520             : 
     521             : /**
     522             :  * @return the removed picture or NULL if an error occurs
     523             :  */
     524       29288 : static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask)
     525             : {
     526             :     H264Picture *pic;
     527             :     int i;
     528             : 
     529       29288 :     if (h->avctx->debug & FF_DEBUG_MMCO)
     530           0 :         av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count);
     531             : 
     532       29288 :     pic = find_short(h, frame_num, &i);
     533       29288 :     if (pic) {
     534       13932 :         if (unreference_pic(h, pic, ref_mask))
     535       12808 :             remove_short_at_index(h, i);
     536             :     }
     537             : 
     538       29288 :     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       37740 : static H264Picture *remove_long(H264Context *h, int i, int ref_mask)
     547             : {
     548             :     H264Picture *pic;
     549             : 
     550       37740 :     pic = h->long_ref[i];
     551       37740 :     if (pic) {
     552         341 :         if (unreference_pic(h, pic, ref_mask)) {
     553             :             assert(h->long_ref[i]->long_ref == 1);
     554         341 :             h->long_ref[i]->long_ref = 0;
     555         341 :             h->long_ref[i]           = NULL;
     556         341 :             h->long_ref_count--;
     557             :         }
     558             :     }
     559             : 
     560       37740 :     return pic;
     561             : }
     562             : 
     563        1937 : void ff_h264_remove_all_refs(H264Context *h)
     564             : {
     565             :     int i;
     566             : 
     567       32929 :     for (i = 0; i < 16; i++) {
     568       30992 :         remove_long(h, i, 0);
     569             :     }
     570             :     assert(h->long_ref_count == 0);
     571             : 
     572        1937 :     if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) {
     573         945 :         ff_h264_unref_picture(h, &h->last_pic_for_ec);
     574         945 :         ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]);
     575             :     }
     576             : 
     577        4166 :     for (i = 0; i < h->short_ref_count; i++) {
     578        2229 :         unreference_pic(h, h->short_ref[i], 0);
     579        2229 :         h->short_ref[i] = NULL;
     580             :     }
     581        1937 :     h->short_ref_count = 0;
     582             : 
     583        1937 :     memset(h->default_ref, 0, sizeof(h->default_ref));
     584        1937 : }
     585             : 
     586       14445 : static void generate_sliding_window_mmcos(H264Context *h)
     587             : {
     588       14445 :     MMCO *mmco = h->mmco;
     589       14445 :     int nb_mmco = 0;
     590             : 
     591       28874 :     if (h->short_ref_count &&
     592       26542 :         h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count &&
     593       14286 :         !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) {
     594       10984 :         mmco[0].opcode        = MMCO_SHORT2UNUSED;
     595       10984 :         mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num;
     596       10984 :         nb_mmco               = 1;
     597       10984 :         if (FIELD_PICTURE(h)) {
     598        1044 :             mmco[0].short_pic_num *= 2;
     599        1044 :             mmco[1].opcode         = MMCO_SHORT2UNUSED;
     600        1044 :             mmco[1].short_pic_num  = mmco[0].short_pic_num + 1;
     601        1044 :             nb_mmco                = 2;
     602             :         }
     603             :     }
     604             : 
     605       14445 :     h->nb_mmco = nb_mmco;
     606       14445 : }
     607             : 
     608       16789 : int ff_h264_execute_ref_pic_marking(H264Context *h)
     609             : {
     610       16789 :     MMCO *mmco = h->mmco;
     611             :     int mmco_count;
     612       16789 :     int i, av_uninit(j);
     613       16789 :     int pps_ref_count[2] = {0};
     614       16789 :     int current_ref_assigned = 0, err = 0;
     615       16789 :     H264Picture *av_uninit(pic);
     616             : 
     617       16789 :     if (!h->ps.sps) {
     618           0 :         av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n");
     619           0 :         err = AVERROR_INVALIDDATA;
     620           0 :         goto out;
     621             :     }
     622             : 
     623       16789 :     if (!h->explicit_ref_marking)
     624       14445 :         generate_sliding_window_mmcos(h);
     625       16789 :     mmco_count = h->nb_mmco;
     626             : 
     627       16789 :     if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0)
     628           0 :         av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n");
     629             : 
     630       31532 :     for (i = 0; i < mmco_count; i++) {
     631       14743 :         int av_uninit(structure), av_uninit(frame_num);
     632       14743 :         if (h->avctx->debug & FF_DEBUG_MMCO)
     633           0 :             av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode,
     634             :                    h->mmco[i].short_pic_num, h->mmco[i].long_arg);
     635             : 
     636       15610 :         if (mmco[i].opcode == MMCO_SHORT2UNUSED ||
     637         867 :             mmco[i].opcode == MMCO_SHORT2LONG) {
     638       14218 :             frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure);
     639       14218 :             pic       = find_short(h, frame_num, &j);
     640       14218 :             if (!pic) {
     641          50 :                 if (mmco[i].opcode != MMCO_SHORT2LONG ||
     642          42 :                     !h->long_ref[mmco[i].long_arg]    ||
     643          21 :                     h->long_ref[mmco[i].long_arg]->frame_num != frame_num) {
     644           8 :                     av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n");
     645           8 :                     err = AVERROR_INVALIDDATA;
     646             :                 }
     647          29 :                 continue;
     648             :             }
     649             :         }
     650             : 
     651       14714 :         switch (mmco[i].opcode) {
     652       13868 :         case MMCO_SHORT2UNUSED:
     653       13868 :             if (h->avctx->debug & FF_DEBUG_MMCO)
     654           0 :                 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n",
     655             :                        h->mmco[i].short_pic_num, h->short_ref_count);
     656       13868 :             remove_short(h, frame_num, structure ^ PICT_FRAME);
     657       13868 :             break;
     658         321 :         case MMCO_SHORT2LONG:
     659         321 :                 if (h->long_ref[mmco[i].long_arg] != pic)
     660         321 :                     remove_long(h, mmco[i].long_arg, 0);
     661             : 
     662         321 :                 remove_short_at_index(h, j);
     663         321 :                 h->long_ref[ mmco[i].long_arg ] = pic;
     664         321 :                 if (h->long_ref[mmco[i].long_arg]) {
     665         321 :                     h->long_ref[mmco[i].long_arg]->long_ref = 1;
     666         321 :                     h->long_ref_count++;
     667             :                 }
     668         321 :             break;
     669          82 :         case MMCO_LONG2UNUSED:
     670          82 :             j   = pic_num_extract(h, mmco[i].long_arg, &structure);
     671          82 :             pic = h->long_ref[j];
     672          82 :             if (pic) {
     673          82 :                 remove_long(h, j, structure ^ PICT_FRAME);
     674           0 :             } else if (h->avctx->debug & FF_DEBUG_MMCO)
     675           0 :                 av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n");
     676          82 :             break;
     677          20 :         case MMCO_LONG:
     678             :                     // Comment below left from previous code as it is an interesting note.
     679             :                     /* First field in pair is in short term list or
     680             :                      * at a different long term index.
     681             :                      * This is not allowed; see 7.4.3.3, notes 2 and 3.
     682             :                      * Report the problem and keep the pair where it is,
     683             :                      * and mark this field valid.
     684             :                      */
     685          20 :             if (h->short_ref[0] == h->cur_pic_ptr) {
     686           0 :                 av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n");
     687           0 :                 remove_short_at_index(h, 0);
     688             :             }
     689             : 
     690             :             /* make sure the current picture is not already assigned as a long ref */
     691          20 :             if (h->cur_pic_ptr->long_ref) {
     692           0 :                 for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) {
     693           0 :                     if (h->long_ref[j] == h->cur_pic_ptr) {
     694           0 :                         if (j != mmco[i].long_arg)
     695           0 :                             av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n");
     696           0 :                         remove_long(h, j, 0);
     697             :                     }
     698             :                 }
     699             :             }
     700             : 
     701          20 :             if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) {
     702          20 :                 av_assert0(!h->cur_pic_ptr->long_ref);
     703          20 :                 remove_long(h, mmco[i].long_arg, 0);
     704             : 
     705          20 :                 h->long_ref[mmco[i].long_arg]           = h->cur_pic_ptr;
     706          20 :                 h->long_ref[mmco[i].long_arg]->long_ref = 1;
     707          20 :                 h->long_ref_count++;
     708             :             }
     709             : 
     710          20 :             h->cur_pic_ptr->reference |= h->picture_structure;
     711          20 :             current_ref_assigned = 1;
     712          20 :             break;
     713         408 :         case MMCO_SET_MAX_LONG:
     714             :             assert(mmco[i].long_arg <= 16);
     715             :             // just remove the long term which index is greater than new max
     716        6493 :             for (j = mmco[i].long_arg; j < 16; j++) {
     717        6085 :                 remove_long(h, j, 0);
     718             :             }
     719         408 :             break;
     720          15 :         case MMCO_RESET:
     721          83 :             while (h->short_ref_count) {
     722          53 :                 remove_short(h, h->short_ref[0]->frame_num, 0);
     723             :             }
     724         255 :             for (j = 0; j < 16; j++) {
     725         240 :                 remove_long(h, j, 0);
     726             :             }
     727          15 :             h->poc.frame_num = h->cur_pic_ptr->frame_num = 0;
     728          15 :             h->mmco_reset = 1;
     729          15 :             h->cur_pic_ptr->mmco_reset = 1;
     730         255 :             for (j = 0; j < MAX_DELAYED_PIC_COUNT; j++)
     731         240 :                 h->last_pocs[j] = INT_MIN;
     732          15 :             break;
     733       14714 :         default: assert(0);
     734             :         }
     735             :     }
     736             : 
     737       16789 :     if (!current_ref_assigned) {
     738             :         /* Second field of complementary field pair; the first field of
     739             :          * which is already referenced. If short referenced, it
     740             :          * should be first entry in short_ref. If not, it must exist
     741             :          * in long_ref; trying to put it on the short list here is an
     742             :          * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
     743             :          */
     744       16769 :         if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) {
     745             :             /* Just mark the second field valid */
     746        1411 :             h->cur_pic_ptr->reference |= h->picture_structure;
     747       15358 :         } else if (h->cur_pic_ptr->long_ref) {
     748           0 :             av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference "
     749             :                                            "assignment for second field "
     750             :                                            "in complementary field pair "
     751             :                                            "(first field is long term)\n");
     752           0 :             err = AVERROR_INVALIDDATA;
     753             :         } else {
     754       15358 :             pic = remove_short(h, h->cur_pic_ptr->frame_num, 0);
     755       15358 :             if (pic) {
     756           2 :                 av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n");
     757           2 :                 err = AVERROR_INVALIDDATA;
     758             :             }
     759             : 
     760       15358 :             if (h->short_ref_count)
     761       11168 :                 memmove(&h->short_ref[1], &h->short_ref[0],
     762       11168 :                         h->short_ref_count * sizeof(H264Picture*));
     763             : 
     764       15358 :             h->short_ref[0] = h->cur_pic_ptr;
     765       15358 :             h->short_ref_count++;
     766       15358 :             h->cur_pic_ptr->reference |= h->picture_structure;
     767             :         }
     768             :     }
     769             : 
     770       16789 :     if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) {
     771             : 
     772             :         /* We have too many reference frames, probably due to corrupted
     773             :          * stream. Need to discard one frame. Prevents overrun of the
     774             :          * short_ref and long_ref buffers.
     775             :          */
     776           4 :         av_log(h->avctx, AV_LOG_ERROR,
     777             :                "number of reference frames (%d+%d) exceeds max (%d; probably "
     778             :                "corrupt input), discarding one\n",
     779           4 :                h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count);
     780           4 :         err = AVERROR_INVALIDDATA;
     781             : 
     782           4 :         if (h->long_ref_count && !h->short_ref_count) {
     783           0 :             for (i = 0; i < 16; ++i)
     784           0 :                 if (h->long_ref[i])
     785           0 :                     break;
     786             : 
     787             :             assert(i < 16);
     788           0 :             remove_long(h, i, 0);
     789             :         } else {
     790           4 :             pic = h->short_ref[h->short_ref_count - 1];
     791           4 :             remove_short(h, pic->frame_num, 0);
     792             :         }
     793             :     }
     794             : 
     795       91122 :     for (i = 0; i<h->short_ref_count; i++) {
     796       74333 :         pic = h->short_ref[i];
     797       74333 :         if (pic->invalid_gap) {
     798         155 :             int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num);
     799         155 :             if (d > h->ps.sps->ref_frame_count)
     800           5 :                 remove_short(h, pic->frame_num, 0);
     801             :         }
     802             :     }
     803             : 
     804       16789 :     print_short_term(h);
     805       16789 :     print_long_term(h);
     806             : 
     807     4314773 :     for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) {
     808     4297984 :         if (h->ps.pps_list[i]) {
     809       17066 :             const PPS *pps = (const PPS *)h->ps.pps_list[i]->data;
     810       17066 :             pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]);
     811       17066 :             pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]);
     812             :         }
     813             :     }
     814             : 
     815       16789 :     if (   err >= 0
     816       16783 :         && h->long_ref_count==0
     817       15739 :         && (   h->short_ref_count<=2
     818       10431 :             || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1)
     819        8130 :         && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point)
     820        6986 :         && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){
     821        2121 :         h->cur_pic_ptr->recovered |= 1;
     822        2121 :         if(!h->avctx->has_b_frames)
     823        1444 :             h->frame_recovered |= FRAME_RECOVERED_SEI;
     824             :     }
     825             : 
     826       32134 : out:
     827       16789 :     return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0;
     828             : }
     829             : 
     830       20721 : int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb,
     831             :                                    const H2645NAL *nal, void *logctx)
     832             : {
     833             :     int i;
     834       20721 :     MMCO *mmco = sl->mmco;
     835       20721 :     int nb_mmco = 0;
     836             : 
     837       20721 :     if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields
     838        1969 :         skip_bits1(gb); // broken_link
     839        1969 :         if (get_bits1(gb)) {
     840           2 :             mmco[0].opcode   = MMCO_LONG;
     841           2 :             mmco[0].long_arg = 0;
     842           2 :             nb_mmco          = 1;
     843             :         }
     844        1969 :         sl->explicit_ref_marking = 1;
     845             :     } else {
     846       18752 :         sl->explicit_ref_marking = get_bits1(gb);
     847       18752 :         if (sl->explicit_ref_marking) {
     848        5232 :             for (i = 0; i < MAX_MMCO_COUNT; i++) {
     849        5232 :                 MMCOOpcode opcode = get_ue_golomb_31(gb);
     850             : 
     851        5232 :                 mmco[i].opcode = opcode;
     852        5232 :                 if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) {
     853        5778 :                     mmco[i].short_pic_num =
     854        8667 :                         (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) &
     855        2889 :                             (sl->max_pic_num - 1);
     856             :                 }
     857        5232 :                 if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED ||
     858        4767 :                     opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) {
     859         876 :                     unsigned int long_arg = get_ue_golomb_31(gb);
     860         876 :                     if (long_arg >= 32 ||
     861           0 :                         (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG &&
     862           0 :                                              long_arg == 16) &&
     863           0 :                          !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) {
     864           0 :                         av_log(logctx, AV_LOG_ERROR,
     865             :                                "illegal long ref in memory management control "
     866             :                                "operation %d\n", opcode);
     867           0 :                         return -1;
     868             :                     }
     869         876 :                     mmco[i].long_arg = long_arg;
     870             :                 }
     871             : 
     872        5232 :                 if (opcode > (unsigned) MMCO_LONG) {
     873           1 :                     av_log(logctx, AV_LOG_ERROR,
     874             :                            "illegal memory management control operation %d\n",
     875             :                            opcode);
     876           1 :                     return -1;
     877             :                 }
     878        5231 :                 if (opcode == MMCO_END)
     879        1816 :                     break;
     880             :             }
     881        1816 :             nb_mmco = i;
     882             :         }
     883             :     }
     884             : 
     885       20720 :     sl->nb_mmco = nb_mmco;
     886             : 
     887       20720 :     return 0;
     888             : }

Generated by: LCOV version 1.13