2 * H.26L/H.264/AVC/JVT/14496-10/... reference picture handling
3 * Copyright (c) 2003 Michael Niedermayer <michaelni@gmx.at>
5 * This file is part of FFmpeg.
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.
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.
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
24 * H.264 / AVC / MPEG4 part10 reference picture handling.
25 * @author Michael Niedermayer <michaelni@gmx.at>
30 #include "libavutil/avassert.h"
35 #include "mpegutils.h"
39 #define COPY_PICTURE(dst, src) \
42 (dst)->f.extended_data = (dst)->f.data;\
43 (dst)->tf.f = &(dst)->f;\
47 static void pic_as_field(H264Picture
*pic
, const int parity
){
49 for (i
= 0; i
< 4; ++i
) {
50 if (parity
== PICT_BOTTOM_FIELD
)
51 pic
->f
.data
[i
] += pic
->f
.linesize
[i
];
52 pic
->reference
= parity
;
53 pic
->f
.linesize
[i
] *= 2;
55 pic
->poc
= pic
->field_poc
[parity
== PICT_BOTTOM_FIELD
];
58 static int split_field_copy(H264Picture
*dest
, H264Picture
*src
, int parity
, int id_add
)
60 int match
= !!(src
->reference
& parity
);
63 COPY_PICTURE(dest
, src
);
64 if (parity
!= PICT_FRAME
) {
65 pic_as_field(dest
, parity
);
67 dest
->pic_id
+= id_add
;
74 static int build_def_list(H264Picture
*def
, int def_len
,
75 H264Picture
**in
, int len
, int is_long
, int sel
)
80 while (i
[0] < len
|| i
[1] < len
) {
81 while (i
[0] < len
&& !(in
[i
[0]] && (in
[i
[0]]->reference
& sel
)))
83 while (i
[1] < len
&& !(in
[i
[1]] && (in
[i
[1]]->reference
& (sel
^ 3))))
86 av_assert0(index
< def_len
);
87 in
[i
[0]]->pic_id
= is_long
? i
[0] : in
[i
[0]]->frame_num
;
88 split_field_copy(&def
[index
++], in
[i
[0]++], sel
, 1);
91 av_assert0(index
< def_len
);
92 in
[i
[1]]->pic_id
= is_long
? i
[1] : in
[i
[1]]->frame_num
;
93 split_field_copy(&def
[index
++], in
[i
[1]++], sel
^ 3, 0);
100 static int add_sorted(H264Picture
**sorted
, H264Picture
**src
, int len
, int limit
, int dir
)
106 best_poc
= dir
? INT_MIN
: INT_MAX
;
108 for (i
= 0; i
< len
; i
++) {
109 const int poc
= src
[i
]->poc
;
110 if (((poc
> limit
) ^ dir
) && ((poc
< best_poc
) ^ dir
)) {
112 sorted
[out_i
] = src
[i
];
115 if (best_poc
== (dir
? INT_MIN
: INT_MAX
))
117 limit
= sorted
[out_i
++]->poc
- dir
;
122 int ff_h264_fill_default_ref_list(H264Context
*h
)
126 if (h
->slice_type_nos
== AV_PICTURE_TYPE_B
) {
127 H264Picture
*sorted
[32];
131 if (FIELD_PICTURE(h
))
132 cur_poc
= h
->cur_pic_ptr
->field_poc
[h
->picture_structure
== PICT_BOTTOM_FIELD
];
134 cur_poc
= h
->cur_pic_ptr
->poc
;
136 for (list
= 0; list
< 2; list
++) {
137 len
= add_sorted(sorted
, h
->short_ref
, h
->short_ref_count
, cur_poc
, 1 ^ list
);
138 len
+= add_sorted(sorted
+ len
, h
->short_ref
, h
->short_ref_count
, cur_poc
, 0 ^ list
);
139 av_assert0(len
<= 32);
141 len
= build_def_list(h
->default_ref_list
[list
], FF_ARRAY_ELEMS(h
->default_ref_list
[0]),
142 sorted
, len
, 0, h
->picture_structure
);
143 len
+= build_def_list(h
->default_ref_list
[list
] + len
,
144 FF_ARRAY_ELEMS(h
->default_ref_list
[0]) - len
,
145 h
->long_ref
, 16, 1, h
->picture_structure
);
146 av_assert0(len
<= 32);
148 if (len
< h
->ref_count
[list
])
149 memset(&h
->default_ref_list
[list
][len
], 0, sizeof(H264Picture
) * (h
->ref_count
[list
] - len
));
153 if (lens
[0] == lens
[1] && lens
[1] > 1) {
154 for (i
= 0; i
< lens
[0] &&
155 h
->default_ref_list
[0][i
].f
.buf
[0]->buffer
==
156 h
->default_ref_list
[1][i
].f
.buf
[0]->buffer
; i
++);
159 COPY_PICTURE(&tmp
, &h
->default_ref_list
[1][0]);
160 COPY_PICTURE(&h
->default_ref_list
[1][0], &h
->default_ref_list
[1][1]);
161 COPY_PICTURE(&h
->default_ref_list
[1][1], &tmp
);
165 len
= build_def_list(h
->default_ref_list
[0], FF_ARRAY_ELEMS(h
->default_ref_list
[0]),
166 h
->short_ref
, h
->short_ref_count
, 0, h
->picture_structure
);
167 len
+= build_def_list(h
->default_ref_list
[0] + len
,
168 FF_ARRAY_ELEMS(h
->default_ref_list
[0]) - len
,
169 h
-> long_ref
, 16, 1, h
->picture_structure
);
170 av_assert0(len
<= 32);
172 if (len
< h
->ref_count
[0])
173 memset(&h
->default_ref_list
[0][len
], 0, sizeof(H264Picture
) * (h
->ref_count
[0] - len
));
176 for (i
= 0; i
< h
->ref_count
[0]; i
++) {
177 tprintf(h
->avctx
, "List0: %s fn:%d 0x%p\n",
178 (h
->default_ref_list
[0][i
].long_ref
? "LT" : "ST"),
179 h
->default_ref_list
[0][i
].pic_id
,
180 h
->default_ref_list
[0][i
].f
.data
[0]);
182 if (h
->slice_type_nos
== AV_PICTURE_TYPE_B
) {
183 for (i
= 0; i
< h
->ref_count
[1]; i
++) {
184 tprintf(h
->avctx
, "List1: %s fn:%d 0x%p\n",
185 (h
->default_ref_list
[1][i
].long_ref
? "LT" : "ST"),
186 h
->default_ref_list
[1][i
].pic_id
,
187 h
->default_ref_list
[1][i
].f
.data
[0]);
194 static void print_short_term(H264Context
*h
);
195 static void print_long_term(H264Context
*h
);
198 * Extract structure information about the picture described by pic_num in
199 * the current decoding context (frame or field). Note that pic_num is
200 * picture number without wrapping (so, 0<=pic_num<max_pic_num).
201 * @param pic_num picture number for which to extract structure information
202 * @param structure one of PICT_XXX describing structure of picture
204 * @return frame number (short term) or long term index of picture
205 * described by pic_num
207 static int pic_num_extract(H264Context
*h
, int pic_num
, int *structure
)
209 *structure
= h
->picture_structure
;
210 if (FIELD_PICTURE(h
)) {
213 *structure
^= PICT_FRAME
;
220 int ff_h264_decode_ref_pic_list_reordering(H264Context
*h
)
222 int list
, index
, pic_structure
, i
;
227 for (list
= 0; list
< h
->list_count
; list
++) {
228 for (i
= 0; i
< h
->ref_count
[list
]; i
++)
229 COPY_PICTURE(&h
->ref_list
[list
][i
], &h
->default_ref_list
[list
][i
]);
231 if (get_bits1(&h
->gb
)) { // ref_pic_list_modification_flag_l[01]
232 int pred
= h
->curr_pic_num
;
234 for (index
= 0; ; index
++) {
235 unsigned int modification_of_pic_nums_idc
= get_ue_golomb_31(&h
->gb
);
238 H264Picture
*ref
= NULL
;
240 if (modification_of_pic_nums_idc
== 3)
243 if (index
>= h
->ref_count
[list
]) {
244 av_log(h
->avctx
, AV_LOG_ERROR
, "reference count overflow\n");
248 switch (modification_of_pic_nums_idc
) {
251 const unsigned int abs_diff_pic_num
= get_ue_golomb(&h
->gb
) + 1;
254 if (abs_diff_pic_num
> h
->max_pic_num
) {
255 av_log(h
->avctx
, AV_LOG_ERROR
,
256 "abs_diff_pic_num overflow\n");
257 return AVERROR_INVALIDDATA
;
260 if (modification_of_pic_nums_idc
== 0)
261 pred
-= abs_diff_pic_num
;
263 pred
+= abs_diff_pic_num
;
264 pred
&= h
->max_pic_num
- 1;
266 frame_num
= pic_num_extract(h
, pred
, &pic_structure
);
268 for (i
= h
->short_ref_count
- 1; i
>= 0; i
--) {
269 ref
= h
->short_ref
[i
];
270 assert(ref
->reference
);
271 assert(!ref
->long_ref
);
272 if (ref
->frame_num
== frame_num
&&
273 (ref
->reference
& pic_structure
))
282 pic_id
= get_ue_golomb(&h
->gb
); // long_term_pic_idx
284 long_idx
= pic_num_extract(h
, pic_id
, &pic_structure
);
287 av_log(h
->avctx
, AV_LOG_ERROR
,
288 "long_term_pic_idx overflow\n");
289 return AVERROR_INVALIDDATA
;
291 ref
= h
->long_ref
[long_idx
];
292 assert(!(ref
&& !ref
->reference
));
293 if (ref
&& (ref
->reference
& pic_structure
)) {
294 ref
->pic_id
= pic_id
;
295 assert(ref
->long_ref
);
303 av_log(h
->avctx
, AV_LOG_ERROR
,
304 "illegal modification_of_pic_nums_idc %u\n",
305 modification_of_pic_nums_idc
);
306 return AVERROR_INVALIDDATA
;
310 av_log(h
->avctx
, AV_LOG_ERROR
,
311 "reference picture missing during reorder\n");
312 memset(&h
->ref_list
[list
][index
], 0, sizeof(H264Picture
)); // FIXME
314 for (i
= index
; i
+ 1 < h
->ref_count
[list
]; i
++) {
315 if (ref
->long_ref
== h
->ref_list
[list
][i
].long_ref
&&
316 ref
->pic_id
== h
->ref_list
[list
][i
].pic_id
)
319 for (; i
> index
; i
--) {
320 COPY_PICTURE(&h
->ref_list
[list
][i
], &h
->ref_list
[list
][i
- 1]);
322 COPY_PICTURE(&h
->ref_list
[list
][index
], ref
);
323 if (FIELD_PICTURE(h
)) {
324 pic_as_field(&h
->ref_list
[list
][index
], pic_structure
);
330 for (list
= 0; list
< h
->list_count
; list
++) {
331 for (index
= 0; index
< h
->ref_count
[list
]; index
++) {
332 if ( !h
->ref_list
[list
][index
].f
.buf
[0]
333 || (!FIELD_PICTURE(h
) && (h
->ref_list
[list
][index
].reference
&3) != 3)) {
335 av_log(h
->avctx
, AV_LOG_ERROR
, "Missing reference picture, default is %d\n", h
->default_ref_list
[list
][0].poc
);
336 for (i
= 0; i
< FF_ARRAY_ELEMS(h
->last_pocs
); i
++)
337 h
->last_pocs
[i
] = INT_MIN
;
338 if (h
->default_ref_list
[list
][0].f
.buf
[0]
339 && !(!FIELD_PICTURE(h
) && (h
->default_ref_list
[list
][0].reference
&3) != 3))
340 COPY_PICTURE(&h
->ref_list
[list
][index
], &h
->default_ref_list
[list
][0]);
344 av_assert0(av_buffer_get_ref_count(h
->ref_list
[list
][index
].f
.buf
[0]) > 0);
351 void ff_h264_fill_mbaff_ref_list(H264Context
*h
)
354 for (list
= 0; list
< h
->list_count
; list
++) {
355 for (i
= 0; i
< h
->ref_count
[list
]; i
++) {
356 H264Picture
*frame
= &h
->ref_list
[list
][i
];
357 H264Picture
*field
= &h
->ref_list
[list
][16 + 2 * i
];
358 COPY_PICTURE(field
, frame
);
359 for (j
= 0; j
< 3; j
++)
360 field
[0].f
.linesize
[j
] <<= 1;
361 field
[0].reference
= PICT_TOP_FIELD
;
362 field
[0].poc
= field
[0].field_poc
[0];
363 COPY_PICTURE(field
+ 1, field
);
364 for (j
= 0; j
< 3; j
++)
365 field
[1].f
.data
[j
] += frame
->f
.linesize
[j
];
366 field
[1].reference
= PICT_BOTTOM_FIELD
;
367 field
[1].poc
= field
[1].field_poc
[1];
369 h
->luma_weight
[16 + 2 * i
][list
][0] = h
->luma_weight
[16 + 2 * i
+ 1][list
][0] = h
->luma_weight
[i
][list
][0];
370 h
->luma_weight
[16 + 2 * i
][list
][1] = h
->luma_weight
[16 + 2 * i
+ 1][list
][1] = h
->luma_weight
[i
][list
][1];
371 for (j
= 0; j
< 2; j
++) {
372 h
->chroma_weight
[16 + 2 * i
][list
][j
][0] = h
->chroma_weight
[16 + 2 * i
+ 1][list
][j
][0] = h
->chroma_weight
[i
][list
][j
][0];
373 h
->chroma_weight
[16 + 2 * i
][list
][j
][1] = h
->chroma_weight
[16 + 2 * i
+ 1][list
][j
][1] = h
->chroma_weight
[i
][list
][j
][1];
380 * Mark a picture as no longer needed for reference. The refmask
381 * argument allows unreferencing of individual fields or the whole frame.
382 * If the picture becomes entirely unreferenced, but is being held for
383 * display purposes, it is marked as such.
384 * @param refmask mask of fields to unreference; the mask is bitwise
385 * anded with the reference marking of pic
386 * @return non-zero if pic becomes entirely unreferenced (except possibly
387 * for display purposes) zero if one of the fields remains in
390 static inline int unreference_pic(H264Context
*h
, H264Picture
*pic
, int refmask
)
393 if (pic
->reference
&= refmask
) {
396 for(i
= 0; h
->delayed_pic
[i
]; i
++)
397 if(pic
== h
->delayed_pic
[i
]){
398 pic
->reference
= DELAYED_PIC_REF
;
406 * Find a H264Picture in the short term reference list by frame number.
407 * @param frame_num frame number to search for
408 * @param idx the index into h->short_ref where returned picture is found
409 * undefined if no picture found.
410 * @return pointer to the found picture, or NULL if no pic with the provided
411 * frame number is found
413 static H264Picture
*find_short(H264Context
*h
, int frame_num
, int *idx
)
417 for (i
= 0; i
< h
->short_ref_count
; i
++) {
418 H264Picture
*pic
= h
->short_ref
[i
];
419 if (h
->avctx
->debug
& FF_DEBUG_MMCO
)
420 av_log(h
->avctx
, AV_LOG_DEBUG
, "%d %d %p\n", i
, pic
->frame_num
, pic
);
421 if (pic
->frame_num
== frame_num
) {
430 * Remove a picture from the short term reference list by its index in
431 * that list. This does no checking on the provided index; it is assumed
432 * to be valid. Other list entries are shifted down.
433 * @param i index into h->short_ref of picture to remove.
435 static void remove_short_at_index(H264Context
*h
, int i
)
437 assert(i
>= 0 && i
< h
->short_ref_count
);
438 h
->short_ref
[i
] = NULL
;
439 if (--h
->short_ref_count
)
440 memmove(&h
->short_ref
[i
], &h
->short_ref
[i
+ 1],
441 (h
->short_ref_count
- i
) * sizeof(H264Picture
*));
446 * @return the removed picture or NULL if an error occurs
448 static H264Picture
*remove_short(H264Context
*h
, int frame_num
, int ref_mask
)
453 if (h
->avctx
->debug
& FF_DEBUG_MMCO
)
454 av_log(h
->avctx
, AV_LOG_DEBUG
, "remove short %d count %d\n", frame_num
, h
->short_ref_count
);
456 pic
= find_short(h
, frame_num
, &i
);
458 if (unreference_pic(h
, pic
, ref_mask
))
459 remove_short_at_index(h
, i
);
466 * Remove a picture from the long term reference list by its index in
468 * @return the removed picture or NULL if an error occurs
470 static H264Picture
*remove_long(H264Context
*h
, int i
, int ref_mask
)
474 pic
= h
->long_ref
[i
];
476 if (unreference_pic(h
, pic
, ref_mask
)) {
477 assert(h
->long_ref
[i
]->long_ref
== 1);
478 h
->long_ref
[i
]->long_ref
= 0;
479 h
->long_ref
[i
] = NULL
;
487 void ff_h264_remove_all_refs(H264Context
*h
)
491 for (i
= 0; i
< 16; i
++) {
492 remove_long(h
, i
, 0);
494 assert(h
->long_ref_count
== 0);
496 for (i
= 0; i
< h
->short_ref_count
; i
++) {
497 unreference_pic(h
, h
->short_ref
[i
], 0);
498 h
->short_ref
[i
] = NULL
;
500 h
->short_ref_count
= 0;
502 memset(h
->default_ref_list
, 0, sizeof(h
->default_ref_list
));
503 memset(h
->ref_list
, 0, sizeof(h
->ref_list
));
507 * print short term list
509 static void print_short_term(H264Context
*h
)
512 if (h
->avctx
->debug
& FF_DEBUG_MMCO
) {
513 av_log(h
->avctx
, AV_LOG_DEBUG
, "short term list:\n");
514 for (i
= 0; i
< h
->short_ref_count
; i
++) {
515 H264Picture
*pic
= h
->short_ref
[i
];
516 av_log(h
->avctx
, AV_LOG_DEBUG
, "%"PRIu32
" fn:%d poc:%d %p\n",
517 i
, pic
->frame_num
, pic
->poc
, pic
->f
.data
[0]);
523 * print long term list
525 static void print_long_term(H264Context
*h
)
528 if (h
->avctx
->debug
& FF_DEBUG_MMCO
) {
529 av_log(h
->avctx
, AV_LOG_DEBUG
, "long term list:\n");
530 for (i
= 0; i
< 16; i
++) {
531 H264Picture
*pic
= h
->long_ref
[i
];
533 av_log(h
->avctx
, AV_LOG_DEBUG
, "%"PRIu32
" fn:%d poc:%d %p\n",
534 i
, pic
->frame_num
, pic
->poc
, pic
->f
.data
[0]);
540 static int check_opcodes(MMCO
*mmco1
, MMCO
*mmco2
, int n_mmcos
)
544 for (i
= 0; i
< n_mmcos
; i
++) {
545 if (mmco1
[i
].opcode
!= mmco2
[i
].opcode
) {
546 av_log(NULL
, AV_LOG_ERROR
, "MMCO opcode [%d, %d] at %d mismatches between slices\n",
547 mmco1
[i
].opcode
, mmco2
[i
].opcode
, i
);
555 int ff_generate_sliding_window_mmcos(H264Context
*h
, int first_slice
)
557 MMCO mmco_temp
[MAX_MMCO_COUNT
], *mmco
= first_slice
? h
->mmco
: mmco_temp
;
558 int mmco_index
= 0, i
= 0;
560 if (h
->short_ref_count
&&
561 h
->long_ref_count
+ h
->short_ref_count
>= h
->sps
.ref_frame_count
&&
562 !(FIELD_PICTURE(h
) && !h
->first_field
&& h
->cur_pic_ptr
->reference
)) {
563 mmco
[0].opcode
= MMCO_SHORT2UNUSED
;
564 mmco
[0].short_pic_num
= h
->short_ref
[h
->short_ref_count
- 1]->frame_num
;
566 if (FIELD_PICTURE(h
)) {
567 mmco
[0].short_pic_num
*= 2;
568 mmco
[1].opcode
= MMCO_SHORT2UNUSED
;
569 mmco
[1].short_pic_num
= mmco
[0].short_pic_num
+ 1;
575 h
->mmco_index
= mmco_index
;
576 } else if (!first_slice
&& mmco_index
>= 0 &&
577 (mmco_index
!= h
->mmco_index
||
578 (i
= check_opcodes(h
->mmco
, mmco_temp
, mmco_index
)))) {
579 av_log(h
->avctx
, AV_LOG_ERROR
,
580 "Inconsistent MMCO state between slices [%d, %d]\n",
581 mmco_index
, h
->mmco_index
);
582 return AVERROR_INVALIDDATA
;
587 int ff_h264_execute_ref_pic_marking(H264Context
*h
, MMCO
*mmco
, int mmco_count
)
591 int current_ref_assigned
= 0, err
= 0;
592 H264Picture
*av_uninit(pic
);
594 if ((h
->avctx
->debug
& FF_DEBUG_MMCO
) && mmco_count
== 0)
595 av_log(h
->avctx
, AV_LOG_DEBUG
, "no mmco here\n");
597 for (i
= 0; i
< mmco_count
; i
++) {
598 int av_uninit(structure
), av_uninit(frame_num
);
599 if (h
->avctx
->debug
& FF_DEBUG_MMCO
)
600 av_log(h
->avctx
, AV_LOG_DEBUG
, "mmco:%d %d %d\n", h
->mmco
[i
].opcode
,
601 h
->mmco
[i
].short_pic_num
, h
->mmco
[i
].long_arg
);
603 if (mmco
[i
].opcode
== MMCO_SHORT2UNUSED
||
604 mmco
[i
].opcode
== MMCO_SHORT2LONG
) {
605 frame_num
= pic_num_extract(h
, mmco
[i
].short_pic_num
, &structure
);
606 pic
= find_short(h
, frame_num
, &j
);
608 if (mmco
[i
].opcode
!= MMCO_SHORT2LONG
||
609 !h
->long_ref
[mmco
[i
].long_arg
] ||
610 h
->long_ref
[mmco
[i
].long_arg
]->frame_num
!= frame_num
) {
611 av_log(h
->avctx
, h
->short_ref_count
? AV_LOG_ERROR
: AV_LOG_DEBUG
, "mmco: unref short failure\n");
612 err
= AVERROR_INVALIDDATA
;
618 switch (mmco
[i
].opcode
) {
619 case MMCO_SHORT2UNUSED
:
620 if (h
->avctx
->debug
& FF_DEBUG_MMCO
)
621 av_log(h
->avctx
, AV_LOG_DEBUG
, "mmco: unref short %d count %d\n",
622 h
->mmco
[i
].short_pic_num
, h
->short_ref_count
);
623 remove_short(h
, frame_num
, structure
^ PICT_FRAME
);
625 case MMCO_SHORT2LONG
:
626 if (h
->long_ref
[mmco
[i
].long_arg
] != pic
)
627 remove_long(h
, mmco
[i
].long_arg
, 0);
629 remove_short_at_index(h
, j
);
630 h
->long_ref
[ mmco
[i
].long_arg
] = pic
;
631 if (h
->long_ref
[mmco
[i
].long_arg
]) {
632 h
->long_ref
[mmco
[i
].long_arg
]->long_ref
= 1;
636 case MMCO_LONG2UNUSED
:
637 j
= pic_num_extract(h
, mmco
[i
].long_arg
, &structure
);
638 pic
= h
->long_ref
[j
];
640 remove_long(h
, j
, structure
^ PICT_FRAME
);
641 } else if (h
->avctx
->debug
& FF_DEBUG_MMCO
)
642 av_log(h
->avctx
, AV_LOG_DEBUG
, "mmco: unref long failure\n");
645 // Comment below left from previous code as it is an interresting note.
646 /* First field in pair is in short term list or
647 * at a different long term index.
648 * This is not allowed; see 7.4.3.3, notes 2 and 3.
649 * Report the problem and keep the pair where it is,
650 * and mark this field valid.
652 if (h
->short_ref
[0] == h
->cur_pic_ptr
) {
653 av_log(h
->avctx
, AV_LOG_ERROR
, "mmco: cannot assign current picture to short and long at the same time\n");
654 remove_short_at_index(h
, 0);
657 if (h
->long_ref
[mmco
[i
].long_arg
] != h
->cur_pic_ptr
) {
658 if (h
->cur_pic_ptr
->long_ref
) {
659 for(j
=0; j
<16; j
++) {
660 if(h
->long_ref
[j
] == h
->cur_pic_ptr
) {
661 remove_long(h
, j
, 0);
662 av_log(h
->avctx
, AV_LOG_ERROR
, "mmco: cannot assign current picture to 2 long term references\n");
666 av_assert0(!h
->cur_pic_ptr
->long_ref
);
667 remove_long(h
, mmco
[i
].long_arg
, 0);
669 h
->long_ref
[mmco
[i
].long_arg
] = h
->cur_pic_ptr
;
670 h
->long_ref
[mmco
[i
].long_arg
]->long_ref
= 1;
674 h
->cur_pic_ptr
->reference
|= h
->picture_structure
;
675 current_ref_assigned
= 1;
677 case MMCO_SET_MAX_LONG
:
678 assert(mmco
[i
].long_arg
<= 16);
679 // just remove the long term which index is greater than new max
680 for (j
= mmco
[i
].long_arg
; j
< 16; j
++) {
681 remove_long(h
, j
, 0);
685 while (h
->short_ref_count
) {
686 remove_short(h
, h
->short_ref
[0]->frame_num
, 0);
688 for (j
= 0; j
< 16; j
++) {
689 remove_long(h
, j
, 0);
691 h
->frame_num
= h
->cur_pic_ptr
->frame_num
= 0;
693 h
->cur_pic_ptr
->mmco_reset
= 1;
694 for (j
= 0; j
< MAX_DELAYED_PIC_COUNT
; j
++)
695 h
->last_pocs
[j
] = INT_MIN
;
701 if (!current_ref_assigned
) {
702 /* Second field of complementary field pair; the first field of
703 * which is already referenced. If short referenced, it
704 * should be first entry in short_ref. If not, it must exist
705 * in long_ref; trying to put it on the short list here is an
706 * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3).
708 if (h
->short_ref_count
&& h
->short_ref
[0] == h
->cur_pic_ptr
) {
709 /* Just mark the second field valid */
710 h
->cur_pic_ptr
->reference
= PICT_FRAME
;
711 } else if (h
->cur_pic_ptr
->long_ref
) {
712 av_log(h
->avctx
, AV_LOG_ERROR
, "illegal short term reference "
713 "assignment for second field "
714 "in complementary field pair "
715 "(first field is long term)\n");
716 err
= AVERROR_INVALIDDATA
;
718 pic
= remove_short(h
, h
->cur_pic_ptr
->frame_num
, 0);
720 av_log(h
->avctx
, AV_LOG_ERROR
, "illegal short term buffer state detected\n");
721 err
= AVERROR_INVALIDDATA
;
724 if (h
->short_ref_count
)
725 memmove(&h
->short_ref
[1], &h
->short_ref
[0],
726 h
->short_ref_count
* sizeof(H264Picture
*));
728 h
->short_ref
[0] = h
->cur_pic_ptr
;
729 h
->short_ref_count
++;
730 h
->cur_pic_ptr
->reference
|= h
->picture_structure
;
734 if (h
->long_ref_count
+ h
->short_ref_count
> FFMAX(h
->sps
.ref_frame_count
, 1)) {
736 /* We have too many reference frames, probably due to corrupted
737 * stream. Need to discard one frame. Prevents overrun of the
738 * short_ref and long_ref buffers.
740 av_log(h
->avctx
, AV_LOG_ERROR
,
741 "number of reference frames (%d+%d) exceeds max (%d; probably "
742 "corrupt input), discarding one\n",
743 h
->long_ref_count
, h
->short_ref_count
, h
->sps
.ref_frame_count
);
744 err
= AVERROR_INVALIDDATA
;
746 if (h
->long_ref_count
&& !h
->short_ref_count
) {
747 for (i
= 0; i
< 16; ++i
)
752 remove_long(h
, i
, 0);
754 pic
= h
->short_ref
[h
->short_ref_count
- 1];
755 remove_short(h
, pic
->frame_num
, 0);
759 for (i
= 0; i
<h
->short_ref_count
; i
++) {
760 pic
= h
->short_ref
[i
];
761 if (pic
->invalid_gap
) {
762 int d
= (h
->cur_pic_ptr
->frame_num
- pic
->frame_num
) & ((1 << h
->sps
.log2_max_frame_num
)-1);
763 if (d
> h
->sps
.ref_frame_count
)
764 remove_short(h
, pic
->frame_num
, 0);
772 for (i
= 0; i
< FF_ARRAY_ELEMS(h
->pps_buffers
); i
++)
773 pps_count
+= !!h
->pps_buffers
[i
];
776 && h
->long_ref_count
==0
777 && (h
->short_ref_count
<=2 || h
->pps
.ref_count
[0] <= 1 && h
->pps
.ref_count
[1] <= 1 && pps_count
== 1)
778 && h
->pps
.ref_count
[0]<=2 + (h
->picture_structure
!= PICT_FRAME
) + (2*!h
->has_recovery_point
)
779 && h
->cur_pic_ptr
->f
.pict_type
== AV_PICTURE_TYPE_I
){
780 h
->cur_pic_ptr
->recovered
|= 1;
781 if(!h
->avctx
->has_b_frames
)
782 h
->frame_recovered
|= FRAME_RECOVERED_SEI
;
785 return (h
->avctx
->err_recognition
& AV_EF_EXPLODE
) ? err
: 0;
788 int ff_h264_decode_ref_pic_marking(H264Context
*h
, GetBitContext
*gb
,
792 MMCO mmco_temp
[MAX_MMCO_COUNT
], *mmco
= mmco_temp
;
795 if (h
->nal_unit_type
== NAL_IDR_SLICE
) { // FIXME fields
796 skip_bits1(gb
); // broken_link
798 mmco
[0].opcode
= MMCO_LONG
;
799 mmco
[0].long_arg
= 0;
803 if (get_bits1(gb
)) { // adaptive_ref_pic_marking_mode_flag
804 for (i
= 0; i
< MAX_MMCO_COUNT
; i
++) {
805 MMCOOpcode opcode
= get_ue_golomb_31(gb
);
807 mmco
[i
].opcode
= opcode
;
808 if (opcode
== MMCO_SHORT2UNUSED
|| opcode
== MMCO_SHORT2LONG
) {
809 mmco
[i
].short_pic_num
=
810 (h
->curr_pic_num
- get_ue_golomb(gb
) - 1) &
811 (h
->max_pic_num
- 1);
813 if (mmco
[i
].short_pic_num
>= h
->short_ref_count
||
814 !h
->short_ref
[mmco
[i
].short_pic_num
]) {
815 av_log(s
->avctx
, AV_LOG_ERROR
,
816 "illegal short ref in memory management control "
817 "operation %d\n", mmco
);
822 if (opcode
== MMCO_SHORT2LONG
|| opcode
== MMCO_LONG2UNUSED
||
823 opcode
== MMCO_LONG
|| opcode
== MMCO_SET_MAX_LONG
) {
824 unsigned int long_arg
= get_ue_golomb_31(gb
);
825 if (long_arg
>= 32 ||
826 (long_arg
>= 16 && !(opcode
== MMCO_SET_MAX_LONG
&&
828 !(opcode
== MMCO_LONG2UNUSED
&& FIELD_PICTURE(h
)))) {
829 av_log(h
->avctx
, AV_LOG_ERROR
,
830 "illegal long ref in memory management control "
831 "operation %d\n", opcode
);
834 mmco
[i
].long_arg
= long_arg
;
837 if (opcode
> (unsigned) MMCO_LONG
) {
838 av_log(h
->avctx
, AV_LOG_ERROR
,
839 "illegal memory management control operation %d\n",
843 if (opcode
== MMCO_END
)
849 ret
= ff_generate_sliding_window_mmcos(h
, first_slice
);
850 if (ret
< 0 && h
->avctx
->err_recognition
& AV_EF_EXPLODE
)
857 if (first_slice
&& mmco_index
!= -1) {
858 memcpy(h
->mmco
, mmco_temp
, sizeof(h
->mmco
));
859 h
->mmco_index
= mmco_index
;
860 } else if (!first_slice
&& mmco_index
>= 0 &&
861 (mmco_index
!= h
->mmco_index
||
862 check_opcodes(h
->mmco
, mmco_temp
, mmco_index
))) {
863 av_log(h
->avctx
, AV_LOG_ERROR
,
864 "Inconsistent MMCO state between slices [%d, %d]\n",
865 mmco_index
, h
->mmco_index
);
866 return AVERROR_INVALIDDATA
;