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