Commit | Line | Data |
---|---|---|
2ba45a60 DM |
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 / MPEG4 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 "golomb.h" | |
35 | #include "mpegutils.h" | |
36 | ||
37 | #include <assert.h> | |
38 | ||
39 | #define COPY_PICTURE(dst, src) \ | |
40 | do {\ | |
41 | *(dst) = *(src);\ | |
42 | (dst)->f.extended_data = (dst)->f.data;\ | |
43 | (dst)->tf.f = &(dst)->f;\ | |
44 | } while (0) | |
45 | ||
46 | ||
47 | static void pic_as_field(H264Picture *pic, const int parity){ | |
48 | int i; | |
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; | |
54 | } | |
55 | pic->poc= pic->field_poc[parity == PICT_BOTTOM_FIELD]; | |
56 | } | |
57 | ||
58 | static int split_field_copy(H264Picture *dest, H264Picture *src, int parity, int id_add) | |
59 | { | |
60 | int match = !!(src->reference & parity); | |
61 | ||
62 | if (match) { | |
63 | COPY_PICTURE(dest, src); | |
64 | if (parity != PICT_FRAME) { | |
65 | pic_as_field(dest, parity); | |
66 | dest->pic_id *= 2; | |
67 | dest->pic_id += id_add; | |
68 | } | |
69 | } | |
70 | ||
71 | return match; | |
72 | } | |
73 | ||
74 | static int build_def_list(H264Picture *def, int def_len, | |
75 | H264Picture **in, int len, int is_long, int sel) | |
76 | { | |
77 | int i[2] = { 0 }; | |
78 | int index = 0; | |
79 | ||
80 | while (i[0] < len || i[1] < len) { | |
81 | while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel))) | |
82 | i[0]++; | |
83 | while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3)))) | |
84 | i[1]++; | |
85 | if (i[0] < len) { | |
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); | |
89 | } | |
90 | if (i[1] < len) { | |
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); | |
94 | } | |
95 | } | |
96 | ||
97 | return index; | |
98 | } | |
99 | ||
100 | static int add_sorted(H264Picture **sorted, H264Picture **src, int len, int limit, int dir) | |
101 | { | |
102 | int i, best_poc; | |
103 | int out_i = 0; | |
104 | ||
105 | for (;;) { | |
106 | best_poc = dir ? INT_MIN : INT_MAX; | |
107 | ||
108 | for (i = 0; i < len; i++) { | |
109 | const int poc = src[i]->poc; | |
110 | if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) { | |
111 | best_poc = poc; | |
112 | sorted[out_i] = src[i]; | |
113 | } | |
114 | } | |
115 | if (best_poc == (dir ? INT_MIN : INT_MAX)) | |
116 | break; | |
117 | limit = sorted[out_i++]->poc - dir; | |
118 | } | |
119 | return out_i; | |
120 | } | |
121 | ||
122 | int ff_h264_fill_default_ref_list(H264Context *h) | |
123 | { | |
124 | int i, len; | |
125 | ||
126 | if (h->slice_type_nos == AV_PICTURE_TYPE_B) { | |
127 | H264Picture *sorted[32]; | |
128 | int cur_poc, list; | |
129 | int lens[2]; | |
130 | ||
131 | if (FIELD_PICTURE(h)) | |
132 | cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; | |
133 | else | |
134 | cur_poc = h->cur_pic_ptr->poc; | |
135 | ||
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); | |
140 | ||
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); | |
147 | ||
148 | if (len < h->ref_count[list]) | |
149 | memset(&h->default_ref_list[list][len], 0, sizeof(H264Picture) * (h->ref_count[list] - len)); | |
150 | lens[list] = len; | |
151 | } | |
152 | ||
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++); | |
157 | if (i == lens[0]) { | |
158 | H264Picture tmp; | |
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); | |
162 | } | |
163 | } | |
164 | } else { | |
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); | |
171 | ||
172 | if (len < h->ref_count[0]) | |
173 | memset(&h->default_ref_list[0][len], 0, sizeof(H264Picture) * (h->ref_count[0] - len)); | |
174 | } | |
175 | #ifdef TRACE | |
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]); | |
181 | } | |
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]); | |
188 | } | |
189 | } | |
190 | #endif | |
191 | return 0; | |
192 | } | |
193 | ||
194 | static void print_short_term(H264Context *h); | |
195 | static void print_long_term(H264Context *h); | |
196 | ||
197 | /** | |
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 | |
203 | * with pic_num | |
204 | * @return frame number (short term) or long term index of picture | |
205 | * described by pic_num | |
206 | */ | |
207 | static int pic_num_extract(H264Context *h, int pic_num, int *structure) | |
208 | { | |
209 | *structure = h->picture_structure; | |
210 | if (FIELD_PICTURE(h)) { | |
211 | if (!(pic_num & 1)) | |
212 | /* opposite field */ | |
213 | *structure ^= PICT_FRAME; | |
214 | pic_num >>= 1; | |
215 | } | |
216 | ||
217 | return pic_num; | |
218 | } | |
219 | ||
220 | int ff_h264_decode_ref_pic_list_reordering(H264Context *h) | |
221 | { | |
222 | int list, index, pic_structure, i; | |
223 | ||
224 | print_short_term(h); | |
225 | print_long_term(h); | |
226 | ||
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]); | |
230 | ||
231 | if (get_bits1(&h->gb)) { // ref_pic_list_modification_flag_l[01] | |
232 | int pred = h->curr_pic_num; | |
233 | ||
234 | for (index = 0; ; index++) { | |
235 | unsigned int modification_of_pic_nums_idc = get_ue_golomb_31(&h->gb); | |
236 | unsigned int pic_id; | |
237 | int i; | |
238 | H264Picture *ref = NULL; | |
239 | ||
240 | if (modification_of_pic_nums_idc == 3) | |
241 | break; | |
242 | ||
243 | if (index >= h->ref_count[list]) { | |
244 | av_log(h->avctx, AV_LOG_ERROR, "reference count overflow\n"); | |
245 | return -1; | |
246 | } | |
247 | ||
248 | switch (modification_of_pic_nums_idc) { | |
249 | case 0: | |
250 | case 1: { | |
251 | const unsigned int abs_diff_pic_num = get_ue_golomb(&h->gb) + 1; | |
252 | int frame_num; | |
253 | ||
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; | |
258 | } | |
259 | ||
260 | if (modification_of_pic_nums_idc == 0) | |
261 | pred -= abs_diff_pic_num; | |
262 | else | |
263 | pred += abs_diff_pic_num; | |
264 | pred &= h->max_pic_num - 1; | |
265 | ||
266 | frame_num = pic_num_extract(h, pred, &pic_structure); | |
267 | ||
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)) | |
274 | break; | |
275 | } | |
276 | if (i >= 0) | |
277 | ref->pic_id = pred; | |
278 | break; | |
279 | } | |
280 | case 2: { | |
281 | int long_idx; | |
282 | pic_id = get_ue_golomb(&h->gb); // long_term_pic_idx | |
283 | ||
284 | long_idx = pic_num_extract(h, pic_id, &pic_structure); | |
285 | ||
286 | if (long_idx > 31) { | |
287 | av_log(h->avctx, AV_LOG_ERROR, | |
288 | "long_term_pic_idx overflow\n"); | |
289 | return AVERROR_INVALIDDATA; | |
290 | } | |
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); | |
296 | i = 0; | |
297 | } else { | |
298 | i = -1; | |
299 | } | |
300 | break; | |
301 | } | |
302 | default: | |
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; | |
307 | } | |
308 | ||
309 | if (i < 0) { | |
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 | |
313 | } else { | |
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) | |
317 | break; | |
318 | } | |
319 | for (; i > index; i--) { | |
320 | COPY_PICTURE(&h->ref_list[list][i], &h->ref_list[list][i - 1]); | |
321 | } | |
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); | |
325 | } | |
326 | } | |
327 | } | |
328 | } | |
329 | } | |
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)) { | |
334 | int i; | |
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]); | |
341 | else | |
342 | return -1; | |
343 | } | |
344 | av_assert0(av_buffer_get_ref_count(h->ref_list[list][index].f.buf[0]) > 0); | |
345 | } | |
346 | } | |
347 | ||
348 | return 0; | |
349 | } | |
350 | ||
351 | void ff_h264_fill_mbaff_ref_list(H264Context *h) | |
352 | { | |
353 | int list, i, j; | |
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]; | |
368 | ||
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]; | |
374 | } | |
375 | } | |
376 | } | |
377 | } | |
378 | ||
379 | /** | |
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 | |
388 | * reference | |
389 | */ | |
390 | static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask) | |
391 | { | |
392 | int i; | |
393 | if (pic->reference &= refmask) { | |
394 | return 0; | |
395 | } else { | |
396 | for(i = 0; h->delayed_pic[i]; i++) | |
397 | if(pic == h->delayed_pic[i]){ | |
398 | pic->reference = DELAYED_PIC_REF; | |
399 | break; | |
400 | } | |
401 | return 1; | |
402 | } | |
403 | } | |
404 | ||
405 | /** | |
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 | |
412 | */ | |
413 | static H264Picture *find_short(H264Context *h, int frame_num, int *idx) | |
414 | { | |
415 | int i; | |
416 | ||
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) { | |
422 | *idx = i; | |
423 | return pic; | |
424 | } | |
425 | } | |
426 | return NULL; | |
427 | } | |
428 | ||
429 | /** | |
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. | |
434 | */ | |
435 | static void remove_short_at_index(H264Context *h, int i) | |
436 | { | |
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*)); | |
442 | } | |
443 | ||
444 | /** | |
445 | * | |
446 | * @return the removed picture or NULL if an error occurs | |
447 | */ | |
448 | static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask) | |
449 | { | |
450 | H264Picture *pic; | |
451 | int i; | |
452 | ||
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); | |
455 | ||
456 | pic = find_short(h, frame_num, &i); | |
457 | if (pic) { | |
458 | if (unreference_pic(h, pic, ref_mask)) | |
459 | remove_short_at_index(h, i); | |
460 | } | |
461 | ||
462 | return pic; | |
463 | } | |
464 | ||
465 | /** | |
466 | * Remove a picture from the long term reference list by its index in | |
467 | * that list. | |
468 | * @return the removed picture or NULL if an error occurs | |
469 | */ | |
470 | static H264Picture *remove_long(H264Context *h, int i, int ref_mask) | |
471 | { | |
472 | H264Picture *pic; | |
473 | ||
474 | pic = h->long_ref[i]; | |
475 | if (pic) { | |
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; | |
480 | h->long_ref_count--; | |
481 | } | |
482 | } | |
483 | ||
484 | return pic; | |
485 | } | |
486 | ||
487 | void ff_h264_remove_all_refs(H264Context *h) | |
488 | { | |
489 | int i; | |
490 | ||
491 | for (i = 0; i < 16; i++) { | |
492 | remove_long(h, i, 0); | |
493 | } | |
494 | assert(h->long_ref_count == 0); | |
495 | ||
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; | |
499 | } | |
500 | h->short_ref_count = 0; | |
501 | ||
502 | memset(h->default_ref_list, 0, sizeof(h->default_ref_list)); | |
503 | memset(h->ref_list, 0, sizeof(h->ref_list)); | |
504 | } | |
505 | ||
506 | /** | |
507 | * print short term list | |
508 | */ | |
509 | static void print_short_term(H264Context *h) | |
510 | { | |
511 | uint32_t i; | |
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]); | |
518 | } | |
519 | } | |
520 | } | |
521 | ||
522 | /** | |
523 | * print long term list | |
524 | */ | |
525 | static void print_long_term(H264Context *h) | |
526 | { | |
527 | uint32_t i; | |
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]; | |
532 | if (pic) { | |
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]); | |
535 | } | |
536 | } | |
537 | } | |
538 | } | |
539 | ||
540 | static int check_opcodes(MMCO *mmco1, MMCO *mmco2, int n_mmcos) | |
541 | { | |
542 | int i; | |
543 | ||
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); | |
548 | return -1; | |
549 | } | |
550 | } | |
551 | ||
552 | return 0; | |
553 | } | |
554 | ||
555 | int ff_generate_sliding_window_mmcos(H264Context *h, int first_slice) | |
556 | { | |
557 | MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = first_slice ? h->mmco : mmco_temp; | |
558 | int mmco_index = 0, i = 0; | |
559 | ||
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; | |
565 | mmco_index = 1; | |
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; | |
570 | mmco_index = 2; | |
571 | } | |
572 | } | |
573 | ||
574 | if (first_slice) { | |
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; | |
583 | } | |
584 | return 0; | |
585 | } | |
586 | ||
587 | int ff_h264_execute_ref_pic_marking(H264Context *h, MMCO *mmco, int mmco_count) | |
588 | { | |
589 | int i, av_uninit(j); | |
590 | int pps_count; | |
591 | int current_ref_assigned = 0, err = 0; | |
592 | H264Picture *av_uninit(pic); | |
593 | ||
594 | if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0) | |
595 | av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n"); | |
596 | ||
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); | |
602 | ||
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); | |
607 | if (!pic) { | |
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; | |
613 | } | |
614 | continue; | |
615 | } | |
616 | } | |
617 | ||
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); | |
624 | break; | |
625 | case MMCO_SHORT2LONG: | |
626 | if (h->long_ref[mmco[i].long_arg] != pic) | |
627 | remove_long(h, mmco[i].long_arg, 0); | |
628 | ||
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; | |
633 | h->long_ref_count++; | |
634 | } | |
635 | break; | |
636 | case MMCO_LONG2UNUSED: | |
637 | j = pic_num_extract(h, mmco[i].long_arg, &structure); | |
638 | pic = h->long_ref[j]; | |
639 | if (pic) { | |
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"); | |
643 | break; | |
644 | case MMCO_LONG: | |
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. | |
651 | */ | |
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); | |
655 | } | |
656 | ||
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"); | |
663 | } | |
664 | } | |
665 | } | |
666 | av_assert0(!h->cur_pic_ptr->long_ref); | |
667 | remove_long(h, mmco[i].long_arg, 0); | |
668 | ||
669 | h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr; | |
670 | h->long_ref[mmco[i].long_arg]->long_ref = 1; | |
671 | h->long_ref_count++; | |
672 | } | |
673 | ||
674 | h->cur_pic_ptr->reference |= h->picture_structure; | |
675 | current_ref_assigned = 1; | |
676 | break; | |
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); | |
682 | } | |
683 | break; | |
684 | case MMCO_RESET: | |
685 | while (h->short_ref_count) { | |
686 | remove_short(h, h->short_ref[0]->frame_num, 0); | |
687 | } | |
688 | for (j = 0; j < 16; j++) { | |
689 | remove_long(h, j, 0); | |
690 | } | |
691 | h->frame_num = h->cur_pic_ptr->frame_num = 0; | |
692 | h->mmco_reset = 1; | |
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; | |
696 | break; | |
697 | default: assert(0); | |
698 | } | |
699 | } | |
700 | ||
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). | |
707 | */ | |
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; | |
717 | } else { | |
718 | pic = remove_short(h, h->cur_pic_ptr->frame_num, 0); | |
719 | if (pic) { | |
720 | av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); | |
721 | err = AVERROR_INVALIDDATA; | |
722 | } | |
723 | ||
724 | if (h->short_ref_count) | |
725 | memmove(&h->short_ref[1], &h->short_ref[0], | |
726 | h->short_ref_count * sizeof(H264Picture*)); | |
727 | ||
728 | h->short_ref[0] = h->cur_pic_ptr; | |
729 | h->short_ref_count++; | |
730 | h->cur_pic_ptr->reference |= h->picture_structure; | |
731 | } | |
732 | } | |
733 | ||
734 | if (h->long_ref_count + h->short_ref_count > FFMAX(h->sps.ref_frame_count, 1)) { | |
735 | ||
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. | |
739 | */ | |
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; | |
745 | ||
746 | if (h->long_ref_count && !h->short_ref_count) { | |
747 | for (i = 0; i < 16; ++i) | |
748 | if (h->long_ref[i]) | |
749 | break; | |
750 | ||
751 | assert(i < 16); | |
752 | remove_long(h, i, 0); | |
753 | } else { | |
754 | pic = h->short_ref[h->short_ref_count - 1]; | |
755 | remove_short(h, pic->frame_num, 0); | |
756 | } | |
757 | } | |
758 | ||
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); | |
765 | } | |
766 | } | |
767 | ||
768 | print_short_term(h); | |
769 | print_long_term(h); | |
770 | ||
771 | pps_count = 0; | |
772 | for (i = 0; i < FF_ARRAY_ELEMS(h->pps_buffers); i++) | |
773 | pps_count += !!h->pps_buffers[i]; | |
774 | ||
775 | if ( err >= 0 | |
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; | |
783 | } | |
784 | ||
785 | return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0; | |
786 | } | |
787 | ||
788 | int ff_h264_decode_ref_pic_marking(H264Context *h, GetBitContext *gb, | |
789 | int first_slice) | |
790 | { | |
791 | int i, ret; | |
792 | MMCO mmco_temp[MAX_MMCO_COUNT], *mmco = mmco_temp; | |
793 | int mmco_index = 0; | |
794 | ||
795 | if (h->nal_unit_type == NAL_IDR_SLICE) { // FIXME fields | |
796 | skip_bits1(gb); // broken_link | |
797 | if (get_bits1(gb)) { | |
798 | mmco[0].opcode = MMCO_LONG; | |
799 | mmco[0].long_arg = 0; | |
800 | mmco_index = 1; | |
801 | } | |
802 | } else { | |
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); | |
806 | ||
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); | |
812 | #if 0 | |
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); | |
818 | return -1; | |
819 | } | |
820 | #endif | |
821 | } | |
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 && | |
827 | long_arg == 16) && | |
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); | |
832 | return -1; | |
833 | } | |
834 | mmco[i].long_arg = long_arg; | |
835 | } | |
836 | ||
837 | if (opcode > (unsigned) MMCO_LONG) { | |
838 | av_log(h->avctx, AV_LOG_ERROR, | |
839 | "illegal memory management control operation %d\n", | |
840 | opcode); | |
841 | return -1; | |
842 | } | |
843 | if (opcode == MMCO_END) | |
844 | break; | |
845 | } | |
846 | mmco_index = i; | |
847 | } else { | |
848 | if (first_slice) { | |
849 | ret = ff_generate_sliding_window_mmcos(h, first_slice); | |
850 | if (ret < 0 && h->avctx->err_recognition & AV_EF_EXPLODE) | |
851 | return ret; | |
852 | } | |
853 | mmco_index = -1; | |
854 | } | |
855 | } | |
856 | ||
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; | |
867 | } | |
868 | ||
869 | return 0; | |
870 | } |