Line | Branch | Exec | Source |
---|---|---|---|
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 "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 | 62793 | static void pic_as_field(H264Ref *pic, const int parity) | |
40 | { | ||
41 | int i; | ||
42 |
2/2✓ Branch 0 taken 188379 times.
✓ Branch 1 taken 62793 times.
|
251172 | for (i = 0; i < FF_ARRAY_ELEMS(pic->data); ++i) { |
43 |
2/2✓ Branch 0 taken 90192 times.
✓ Branch 1 taken 98187 times.
|
188379 | if (parity == PICT_BOTTOM_FIELD) |
44 | 90192 | pic->data[i] += pic->linesize[i]; | |
45 | 188379 | pic->reference = parity; | |
46 | 188379 | pic->linesize[i] *= 2; | |
47 | } | ||
48 | 62793 | pic->poc = pic->parent->field_poc[parity == PICT_BOTTOM_FIELD]; | |
49 | 62793 | } | |
50 | |||
51 | 206465 | static void ref_from_h264pic(H264Ref *dst, H264Picture *src) | |
52 | { | ||
53 | 206465 | memcpy(dst->data, src->f->data, sizeof(dst->data)); | |
54 | 206465 | memcpy(dst->linesize, src->f->linesize, sizeof(dst->linesize)); | |
55 | 206465 | dst->reference = src->reference; | |
56 | 206465 | dst->poc = src->poc; | |
57 | 206465 | dst->pic_id = src->pic_id; | |
58 | 206465 | dst->parent = src; | |
59 | 206465 | } | |
60 | |||
61 | 193979 | static int split_field_copy(H264Ref *dest, H264Picture *src, int parity, int id_add) | |
62 | { | ||
63 | 193979 | int match = !!(src->reference & parity); | |
64 | |||
65 |
1/2✓ Branch 0 taken 193979 times.
✗ Branch 1 not taken.
|
193979 | if (match) { |
66 | 193979 | ref_from_h264pic(dest, src); | |
67 |
2/2✓ Branch 0 taken 61440 times.
✓ Branch 1 taken 132539 times.
|
193979 | if (parity != PICT_FRAME) { |
68 | 61440 | pic_as_field(dest, parity); | |
69 | 61440 | dest->pic_id *= 2; | |
70 | 61440 | dest->pic_id += id_add; | |
71 | } | ||
72 | } | ||
73 | |||
74 | 193979 | return match; | |
75 | } | ||
76 | |||
77 | 97118 | static int build_def_list(H264Ref *def, int def_len, | |
78 | H264Picture * const *in, int len, int is_long, int sel) | ||
79 | { | ||
80 | 97118 | int i[2] = { 0 }; | |
81 | 97118 | int index = 0; | |
82 | |||
83 |
4/4✓ Branch 0 taken 211371 times.
✓ Branch 1 taken 98798 times.
✓ Branch 2 taken 1680 times.
✓ Branch 3 taken 97118 times.
|
407287 | while (i[0] < len || i[1] < len) { |
84 |
6/6✓ Branch 0 taken 939430 times.
✓ Branch 1 taken 50921 times.
✓ Branch 2 taken 774938 times.
✓ Branch 3 taken 164492 times.
✓ Branch 4 taken 2362 times.
✓ Branch 5 taken 162130 times.
|
990351 | while (i[0] < len && !(in[i[0]] && (in[i[0]]->reference & sel))) |
85 | 777300 | i[0]++; | |
86 |
6/6✓ Branch 0 taken 939430 times.
✓ Branch 1 taken 181202 times.
✓ Branch 2 taken 774938 times.
✓ Branch 3 taken 164492 times.
✓ Branch 4 taken 132643 times.
✓ Branch 5 taken 31849 times.
|
1120632 | while (i[1] < len && !(in[i[1]] && (in[i[1]]->reference & (sel ^ 3)))) |
87 | 907581 | i[1]++; | |
88 |
2/2✓ Branch 0 taken 162130 times.
✓ Branch 1 taken 50921 times.
|
213051 | if (i[0] < len) { |
89 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 162130 times.
|
162130 | av_assert0(index < def_len); |
90 |
2/2✓ Branch 0 taken 2006 times.
✓ Branch 1 taken 160124 times.
|
162130 | in[i[0]]->pic_id = is_long ? i[0] : in[i[0]]->frame_num; |
91 | 162130 | split_field_copy(&def[index++], in[i[0]++], sel, 1); | |
92 | } | ||
93 |
2/2✓ Branch 0 taken 181202 times.
✓ Branch 1 taken 31849 times.
|
213051 | if (i[1] < len) { |
94 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 31849 times.
|
31849 | av_assert0(index < def_len); |
95 |
2/2✓ Branch 0 taken 577 times.
✓ Branch 1 taken 31272 times.
|
31849 | in[i[1]]->pic_id = is_long ? i[1] : in[i[1]]->frame_num; |
96 | 31849 | split_field_copy(&def[index++], in[i[1]++], sel ^ 3, 0); | |
97 | } | ||
98 | } | ||
99 | |||
100 | 97118 | return index; | |
101 | } | ||
102 | |||
103 | 50264 | static int add_sorted(H264Picture **sorted, H264Picture * const *src, | |
104 | int len, int limit, int dir) | ||
105 | { | ||
106 | int i, best_poc; | ||
107 | 50264 | int out_i = 0; | |
108 | |||
109 | for (;;) { | ||
110 |
2/2✓ Branch 0 taken 69240 times.
✓ Branch 1 taken 57772 times.
|
127012 | best_poc = dir ? INT_MIN : INT_MAX; |
111 | |||
112 |
2/2✓ Branch 0 taken 517160 times.
✓ Branch 1 taken 127012 times.
|
644172 | for (i = 0; i < len; i++) { |
113 | 517160 | const int poc = src[i]->poc; | |
114 |
4/4✓ Branch 0 taken 151136 times.
✓ Branch 1 taken 366024 times.
✓ Branch 2 taken 88836 times.
✓ Branch 3 taken 62300 times.
|
517160 | if (((poc > limit) ^ dir) && ((poc < best_poc) ^ dir)) { |
115 | 88836 | best_poc = poc; | |
116 | 88836 | sorted[out_i] = src[i]; | |
117 | } | ||
118 | } | ||
119 |
4/4✓ Branch 0 taken 69240 times.
✓ Branch 1 taken 57772 times.
✓ Branch 2 taken 50264 times.
✓ Branch 3 taken 76748 times.
|
127012 | if (best_poc == (dir ? INT_MIN : INT_MAX)) |
120 | 50264 | break; | |
121 | 76748 | limit = sorted[out_i++]->poc - dir; | |
122 | } | ||
123 | 50264 | return out_i; | |
124 | } | ||
125 | |||
126 | 149472 | static int mismatches_ref(const H264Context *h, const H264Picture *pic) | |
127 | { | ||
128 | 149472 | const AVFrame *f = pic->f; | |
129 | 298944 | return (h->cur_pic_ptr->f->width != f->width || | |
130 |
2/4✓ Branch 0 taken 149472 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 149472 times.
✗ Branch 3 not taken.
|
298944 | h->cur_pic_ptr->f->height != f->height || |
131 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 149472 times.
|
149472 | h->cur_pic_ptr->f->format != f->format); |
132 | } | ||
133 | |||
134 | 35993 | static void h264_initialise_ref_list(H264Context *h, H264SliceContext *sl) | |
135 | { | ||
136 | int i, len; | ||
137 | int j; | ||
138 | |||
139 |
2/2✓ Branch 0 taken 12566 times.
✓ Branch 1 taken 23427 times.
|
35993 | if (sl->slice_type_nos == AV_PICTURE_TYPE_B) { |
140 | H264Picture *sorted[32]; | ||
141 | int cur_poc, list; | ||
142 | int lens[2]; | ||
143 | |||
144 |
2/2✓ Branch 0 taken 4807 times.
✓ Branch 1 taken 7759 times.
|
12566 | if (FIELD_PICTURE(h)) |
145 | 4807 | cur_poc = h->cur_pic_ptr->field_poc[h->picture_structure == PICT_BOTTOM_FIELD]; | |
146 | else | ||
147 | 7759 | cur_poc = h->cur_pic_ptr->poc; | |
148 | |||
149 |
2/2✓ Branch 0 taken 25132 times.
✓ Branch 1 taken 12566 times.
|
37698 | for (list = 0; list < 2; list++) { |
150 | 25132 | len = add_sorted(sorted, h->short_ref, h->short_ref_count, cur_poc, 1 ^ list); | |
151 | 25132 | len += add_sorted(sorted + len, h->short_ref, h->short_ref_count, cur_poc, 0 ^ list); | |
152 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 25132 times.
|
25132 | av_assert0(len <= 32); |
153 | |||
154 | 25132 | len = build_def_list(sl->ref_list[list], FF_ARRAY_ELEMS(sl->ref_list[0]), | |
155 | sorted, len, 0, h->picture_structure); | ||
156 | 50264 | len += build_def_list(sl->ref_list[list] + len, | |
157 | 25132 | FF_ARRAY_ELEMS(sl->ref_list[0]) - len, | |
158 | 25132 | h->long_ref, 16, 1, h->picture_structure); | |
159 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 25132 times.
|
25132 | av_assert0(len <= 32); |
160 | |||
161 |
2/2✓ Branch 0 taken 4 times.
✓ Branch 1 taken 25128 times.
|
25132 | if (len < sl->ref_count[list]) |
162 | 4 | memset(&sl->ref_list[list][len], 0, sizeof(H264Ref) * (sl->ref_count[list] - len)); | |
163 | 25132 | lens[list] = len; | |
164 | } | ||
165 | |||
166 |
3/4✓ Branch 0 taken 12566 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 11047 times.
✓ Branch 3 taken 1519 times.
|
12566 | if (lens[0] == lens[1] && lens[1] > 1) { |
167 |
2/2✓ Branch 0 taken 13084 times.
✓ Branch 1 taken 1926 times.
|
15010 | for (i = 0; i < lens[0] && |
168 | 13084 | sl->ref_list[0][i].parent->f->buf[0]->buffer == | |
169 |
2/2✓ Branch 0 taken 3963 times.
✓ Branch 1 taken 9121 times.
|
13084 | sl->ref_list[1][i].parent->f->buf[0]->buffer; i++); |
170 |
2/2✓ Branch 0 taken 1926 times.
✓ Branch 1 taken 9121 times.
|
11047 | if (i == lens[0]) { |
171 | 1926 | FFSWAP(H264Ref, sl->ref_list[1][0], sl->ref_list[1][1]); | |
172 | } | ||
173 | } | ||
174 | } else { | ||
175 | 23427 | len = build_def_list(sl->ref_list[0], FF_ARRAY_ELEMS(sl->ref_list[0]), | |
176 | 23427 | h->short_ref, h->short_ref_count, 0, h->picture_structure); | |
177 | 46854 | len += build_def_list(sl->ref_list[0] + len, | |
178 | 23427 | FF_ARRAY_ELEMS(sl->ref_list[0]) - len, | |
179 | 23427 | h-> long_ref, 16, 1, h->picture_structure); | |
180 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23427 times.
|
23427 | av_assert0(len <= 32); |
181 | |||
182 |
2/2✓ Branch 0 taken 904 times.
✓ Branch 1 taken 22523 times.
|
23427 | if (len < sl->ref_count[0]) |
183 | 904 | memset(&sl->ref_list[0][len], 0, sizeof(H264Ref) * (sl->ref_count[0] - len)); | |
184 | } | ||
185 | #ifdef TRACE | ||
186 | for (i = 0; i < sl->ref_count[0]; i++) { | ||
187 | ff_tlog(h->avctx, "List0: %s fn:%d 0x%p\n", | ||
188 | (sl->ref_list[0][i].parent ? (sl->ref_list[0][i].parent->long_ref ? "LT" : "ST") : "??"), | ||
189 | sl->ref_list[0][i].pic_id, | ||
190 | sl->ref_list[0][i].data[0]); | ||
191 | } | ||
192 | if (sl->slice_type_nos == AV_PICTURE_TYPE_B) { | ||
193 | for (i = 0; i < sl->ref_count[1]; i++) { | ||
194 | ff_tlog(h->avctx, "List1: %s fn:%d 0x%p\n", | ||
195 | (sl->ref_list[1][i].parent ? (sl->ref_list[1][i].parent->long_ref ? "LT" : "ST") : "??"), | ||
196 | sl->ref_list[1][i].pic_id, | ||
197 | sl->ref_list[1][i].data[0]); | ||
198 | } | ||
199 | } | ||
200 | #endif | ||
201 | |||
202 |
4/4✓ Branch 0 taken 37698 times.
✓ Branch 1 taken 46854 times.
✓ Branch 2 taken 48559 times.
✓ Branch 3 taken 35993 times.
|
84552 | for (j = 0; j<1+(sl->slice_type_nos == AV_PICTURE_TYPE_B); j++) { |
203 |
2/2✓ Branch 0 taken 138585 times.
✓ Branch 1 taken 48559 times.
|
187144 | for (i = 0; i < sl->ref_count[j]; i++) { |
204 |
2/2✓ Branch 0 taken 136986 times.
✓ Branch 1 taken 1599 times.
|
138585 | if (sl->ref_list[j][i].parent) { |
205 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 136986 times.
|
136986 | if (mismatches_ref(h, sl->ref_list[j][i].parent)) { |
206 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "Discarding mismatching reference\n"); | |
207 | ✗ | memset(&sl->ref_list[j][i], 0, sizeof(sl->ref_list[j][i])); | |
208 | } | ||
209 | } | ||
210 | } | ||
211 | } | ||
212 |
2/2✓ Branch 0 taken 44111 times.
✓ Branch 1 taken 35993 times.
|
80104 | for (i = 0; i < sl->list_count; i++) |
213 | 44111 | h->default_ref[i] = sl->ref_list[i][0]; | |
214 | 35993 | } | |
215 | |||
216 | /** | ||
217 | * print short term list | ||
218 | */ | ||
219 | 54321 | static void print_short_term(const H264Context *h) | |
220 | { | ||
221 | uint32_t i; | ||
222 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54321 times.
|
54321 | if (h->avctx->debug & FF_DEBUG_MMCO) { |
223 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "short term list:\n"); | |
224 | ✗ | for (i = 0; i < h->short_ref_count; i++) { | |
225 | ✗ | H264Picture *pic = h->short_ref[i]; | |
226 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n", | |
227 | ✗ | i, pic->frame_num, pic->poc, pic->f->data[0]); | |
228 | } | ||
229 | } | ||
230 | 54321 | } | |
231 | |||
232 | /** | ||
233 | * print long term list | ||
234 | */ | ||
235 | 54321 | static void print_long_term(const H264Context *h) | |
236 | { | ||
237 | uint32_t i; | ||
238 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 54321 times.
|
54321 | if (h->avctx->debug & FF_DEBUG_MMCO) { |
239 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "long term list:\n"); | |
240 | ✗ | for (i = 0; i < 16; i++) { | |
241 | ✗ | H264Picture *pic = h->long_ref[i]; | |
242 | ✗ | if (pic) { | |
243 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "%"PRIu32" fn:%d poc:%d %p\n", | |
244 | ✗ | i, pic->frame_num, pic->poc, pic->f->data[0]); | |
245 | } | ||
246 | } | ||
247 | } | ||
248 | 54321 | } | |
249 | |||
250 | /** | ||
251 | * Extract structure information about the picture described by pic_num in | ||
252 | * the current decoding context (frame or field). Note that pic_num is | ||
253 | * picture number without wrapping (so, 0<=pic_num<max_pic_num). | ||
254 | * @param pic_num picture number for which to extract structure information | ||
255 | * @param structure one of PICT_XXX describing structure of picture | ||
256 | * with pic_num | ||
257 | * @return frame number (short term) or long term index of picture | ||
258 | * described by pic_num | ||
259 | */ | ||
260 | 28113 | static int pic_num_extract(const H264Context *h, int pic_num, int *structure) | |
261 | { | ||
262 | 28113 | *structure = h->picture_structure; | |
263 |
2/2✓ Branch 0 taken 3781 times.
✓ Branch 1 taken 24332 times.
|
28113 | if (FIELD_PICTURE(h)) { |
264 |
2/2✓ Branch 0 taken 2004 times.
✓ Branch 1 taken 1777 times.
|
3781 | if (!(pic_num & 1)) |
265 | /* opposite field */ | ||
266 | 2004 | *structure ^= PICT_FRAME; | |
267 | 3781 | pic_num >>= 1; | |
268 | } | ||
269 | |||
270 | 28113 | return pic_num; | |
271 | } | ||
272 | |||
273 | 4970 | static void h264_fill_mbaff_ref_list(H264SliceContext *sl) | |
274 | { | ||
275 | int list, i, j; | ||
276 |
2/2✓ Branch 0 taken 6666 times.
✓ Branch 1 taken 4970 times.
|
11636 | for (list = 0; list < sl->list_count; list++) { |
277 |
2/2✓ Branch 0 taken 16029 times.
✓ Branch 1 taken 6666 times.
|
22695 | for (i = 0; i < sl->ref_count[list]; i++) { |
278 | 16029 | H264Ref *frame = &sl->ref_list[list][i]; | |
279 | 16029 | H264Ref *field = &sl->ref_list[list][16 + 2 * i]; | |
280 | |||
281 | 16029 | field[0] = *frame; | |
282 | |||
283 |
2/2✓ Branch 0 taken 48087 times.
✓ Branch 1 taken 16029 times.
|
64116 | for (j = 0; j < 3; j++) |
284 | 48087 | field[0].linesize[j] <<= 1; | |
285 | 16029 | field[0].reference = PICT_TOP_FIELD; | |
286 | 16029 | field[0].poc = field[0].parent->field_poc[0]; | |
287 | |||
288 | 16029 | field[1] = field[0]; | |
289 | |||
290 |
2/2✓ Branch 0 taken 48087 times.
✓ Branch 1 taken 16029 times.
|
64116 | for (j = 0; j < 3; j++) |
291 | 48087 | field[1].data[j] += frame->parent->f->linesize[j]; | |
292 | 16029 | field[1].reference = PICT_BOTTOM_FIELD; | |
293 | 16029 | field[1].poc = field[1].parent->field_poc[1]; | |
294 | } | ||
295 | } | ||
296 | 4970 | } | |
297 | |||
298 | 35993 | int ff_h264_build_ref_list(H264Context *h, H264SliceContext *sl) | |
299 | { | ||
300 | int list, index, pic_structure; | ||
301 | |||
302 | 35993 | print_short_term(h); | |
303 | 35993 | print_long_term(h); | |
304 | |||
305 | 35993 | h264_initialise_ref_list(h, sl); | |
306 | |||
307 |
2/2✓ Branch 0 taken 44111 times.
✓ Branch 1 taken 35993 times.
|
80104 | for (list = 0; list < sl->list_count; list++) { |
308 | 44111 | int pred = sl->curr_pic_num; | |
309 | |||
310 |
2/2✓ Branch 0 taken 12486 times.
✓ Branch 1 taken 44111 times.
|
56597 | for (index = 0; index < sl->nb_ref_modifications[list]; index++) { |
311 | 12486 | unsigned int modification_of_pic_nums_idc = sl->ref_modifications[list][index].op; | |
312 | 12486 | unsigned int val = sl->ref_modifications[list][index].val; | |
313 | unsigned int pic_id; | ||
314 | int i; | ||
315 | 12486 | H264Picture *ref = NULL; | |
316 | |||
317 |
2/3✓ Branch 0 taken 11923 times.
✓ Branch 1 taken 563 times.
✗ Branch 2 not taken.
|
12486 | switch (modification_of_pic_nums_idc) { |
318 | 11923 | case 0: | |
319 | case 1: { | ||
320 | 11923 | const unsigned int abs_diff_pic_num = val + 1; | |
321 | int frame_num; | ||
322 | |||
323 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 11923 times.
|
11923 | if (abs_diff_pic_num > sl->max_pic_num) { |
324 | ✗ | av_log(h->avctx, AV_LOG_ERROR, | |
325 | "abs_diff_pic_num overflow\n"); | ||
326 | ✗ | return AVERROR_INVALIDDATA; | |
327 | } | ||
328 | |||
329 |
2/2✓ Branch 0 taken 9735 times.
✓ Branch 1 taken 2188 times.
|
11923 | if (modification_of_pic_nums_idc == 0) |
330 | 9735 | pred -= abs_diff_pic_num; | |
331 | else | ||
332 | 2188 | pred += abs_diff_pic_num; | |
333 | 11923 | pred &= sl->max_pic_num - 1; | |
334 | |||
335 | 11923 | frame_num = pic_num_extract(h, pred, &pic_structure); | |
336 | |||
337 |
1/2✓ Branch 0 taken 38695 times.
✗ Branch 1 not taken.
|
38695 | for (i = h->short_ref_count - 1; i >= 0; i--) { |
338 | 38695 | ref = h->short_ref[i]; | |
339 | assert(ref->reference); | ||
340 | assert(!ref->long_ref); | ||
341 |
2/2✓ Branch 0 taken 11923 times.
✓ Branch 1 taken 26772 times.
|
38695 | if (ref->frame_num == frame_num && |
342 |
1/2✓ Branch 0 taken 11923 times.
✗ Branch 1 not taken.
|
11923 | (ref->reference & pic_structure)) |
343 | 11923 | break; | |
344 | } | ||
345 |
1/2✓ Branch 0 taken 11923 times.
✗ Branch 1 not taken.
|
11923 | if (i >= 0) |
346 | 11923 | ref->pic_id = pred; | |
347 | 11923 | break; | |
348 | } | ||
349 | 563 | case 2: { | |
350 | int long_idx; | ||
351 | 563 | pic_id = val; // long_term_pic_idx | |
352 | |||
353 | 563 | long_idx = pic_num_extract(h, pic_id, &pic_structure); | |
354 | |||
355 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 563 times.
|
563 | if (long_idx > 31U) { |
356 | ✗ | av_log(h->avctx, AV_LOG_ERROR, | |
357 | "long_term_pic_idx overflow\n"); | ||
358 | ✗ | return AVERROR_INVALIDDATA; | |
359 | } | ||
360 | 563 | ref = h->long_ref[long_idx]; | |
361 | assert(!(ref && !ref->reference)); | ||
362 |
2/4✓ Branch 0 taken 563 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 563 times.
✗ Branch 3 not taken.
|
563 | if (ref && (ref->reference & pic_structure)) { |
363 | 563 | ref->pic_id = pic_id; | |
364 | assert(ref->long_ref); | ||
365 | 563 | i = 0; | |
366 | } else { | ||
367 | ✗ | i = -1; | |
368 | } | ||
369 | 563 | break; | |
370 | } | ||
371 | ✗ | default: | |
372 | ✗ | av_assert0(0); | |
373 | } | ||
374 | |||
375 |
2/4✓ Branch 0 taken 12486 times.
✗ Branch 1 not taken.
✗ Branch 3 not taken.
✓ Branch 4 taken 12486 times.
|
12486 | if (i < 0 || mismatches_ref(h, ref)) { |
376 | ✗ | av_log(h->avctx, AV_LOG_ERROR, | |
377 | i < 0 ? "reference picture missing during reorder\n" : | ||
378 | "mismatching reference\n" | ||
379 | ); | ||
380 | ✗ | memset(&sl->ref_list[list][index], 0, sizeof(sl->ref_list[0][0])); // FIXME | |
381 | } else { | ||
382 |
2/2✓ Branch 0 taken 19197 times.
✓ Branch 1 taken 5221 times.
|
24418 | for (i = index; i + 1 < sl->ref_count[list]; i++) { |
383 |
2/2✓ Branch 0 taken 17516 times.
✓ Branch 1 taken 1681 times.
|
19197 | if (sl->ref_list[list][i].parent && |
384 |
2/2✓ Branch 0 taken 15577 times.
✓ Branch 1 taken 1939 times.
|
17516 | ref->long_ref == sl->ref_list[list][i].parent->long_ref && |
385 |
2/2✓ Branch 0 taken 7265 times.
✓ Branch 1 taken 8312 times.
|
15577 | ref->pic_id == sl->ref_list[list][i].pic_id) |
386 | 7265 | break; | |
387 | } | ||
388 |
2/2✓ Branch 0 taken 11932 times.
✓ Branch 1 taken 12486 times.
|
24418 | for (; i > index; i--) { |
389 | 11932 | sl->ref_list[list][i] = sl->ref_list[list][i - 1]; | |
390 | } | ||
391 | 12486 | ref_from_h264pic(&sl->ref_list[list][index], ref); | |
392 |
2/2✓ Branch 0 taken 1353 times.
✓ Branch 1 taken 11133 times.
|
12486 | if (FIELD_PICTURE(h)) { |
393 | 1353 | pic_as_field(&sl->ref_list[list][index], pic_structure); | |
394 | } | ||
395 | } | ||
396 | } | ||
397 | } | ||
398 |
2/2✓ Branch 0 taken 44111 times.
✓ Branch 1 taken 35993 times.
|
80104 | for (list = 0; list < sl->list_count; list++) { |
399 |
2/2✓ Branch 0 taken 138585 times.
✓ Branch 1 taken 44111 times.
|
182696 | for (index = 0; index < sl->ref_count[list]; index++) { |
400 |
2/2✓ Branch 0 taken 138571 times.
✓ Branch 1 taken 14 times.
|
138585 | if ( !sl->ref_list[list][index].parent |
401 |
3/4✓ Branch 0 taken 97385 times.
✓ Branch 1 taken 41186 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 97385 times.
|
138571 | || (!FIELD_PICTURE(h) && (sl->ref_list[list][index].reference&3) != 3)) { |
402 | int i; | ||
403 | 14 | av_log(h->avctx, AV_LOG_ERROR, "Missing reference picture, default is %d\n", h->default_ref[list].poc); | |
404 |
2/2✓ Branch 0 taken 224 times.
✓ Branch 1 taken 14 times.
|
238 | for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) |
405 | 224 | h->last_pocs[i] = INT_MIN; | |
406 |
1/2✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
|
14 | if (h->default_ref[list].parent |
407 |
2/4✓ Branch 0 taken 14 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 14 times.
✗ Branch 3 not taken.
|
14 | && !(!FIELD_PICTURE(h) && (h->default_ref[list].reference&3) != 3)) |
408 | 14 | sl->ref_list[list][index] = h->default_ref[list]; | |
409 | else | ||
410 | ✗ | return -1; | |
411 | } | ||
412 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 138585 times.
|
138585 | av_assert0(av_buffer_get_ref_count(sl->ref_list[list][index].parent->f->buf[0]) > 0); |
413 | } | ||
414 | } | ||
415 | |||
416 |
2/2✓ Branch 0 taken 4970 times.
✓ Branch 1 taken 31023 times.
|
35993 | if (FRAME_MBAFF(h)) |
417 | 4970 | h264_fill_mbaff_ref_list(sl); | |
418 | |||
419 | 35993 | return 0; | |
420 | } | ||
421 | |||
422 | 31625 | int ff_h264_decode_ref_pic_list_reordering(H264SliceContext *sl, void *logctx) | |
423 | { | ||
424 | int list, index; | ||
425 | |||
426 | 31625 | sl->nb_ref_modifications[0] = 0; | |
427 | 31625 | sl->nb_ref_modifications[1] = 0; | |
428 | |||
429 |
2/2✓ Branch 0 taken 44235 times.
✓ Branch 1 taken 31625 times.
|
75860 | for (list = 0; list < sl->list_count; list++) { |
430 |
2/2✓ Branch 1 taken 40683 times.
✓ Branch 2 taken 3552 times.
|
44235 | if (!get_bits1(&sl->gb)) // ref_pic_list_modification_flag_l[01] |
431 | 40683 | continue; | |
432 | |||
433 | 3552 | for (index = 0; ; index++) { | |
434 | 16110 | unsigned int op = get_ue_golomb_31(&sl->gb); | |
435 | |||
436 |
2/2✓ Branch 0 taken 3552 times.
✓ Branch 1 taken 12558 times.
|
16110 | if (op == 3) |
437 | 3552 | break; | |
438 | |||
439 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12558 times.
|
12558 | if (index >= sl->ref_count[list]) { |
440 | ✗ | av_log(logctx, AV_LOG_ERROR, "reference count overflow\n"); | |
441 | ✗ | return AVERROR_INVALIDDATA; | |
442 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 12558 times.
|
12558 | } else if (op > 2) { |
443 | ✗ | av_log(logctx, AV_LOG_ERROR, | |
444 | "illegal modification_of_pic_nums_idc %u\n", | ||
445 | op); | ||
446 | ✗ | return AVERROR_INVALIDDATA; | |
447 | } | ||
448 | 12558 | sl->ref_modifications[list][index].val = get_ue_golomb_long(&sl->gb); | |
449 | 12558 | sl->ref_modifications[list][index].op = op; | |
450 | 12558 | sl->nb_ref_modifications[list]++; | |
451 | } | ||
452 | } | ||
453 | |||
454 | 31625 | return 0; | |
455 | } | ||
456 | |||
457 | /** | ||
458 | * Mark a picture as no longer needed for reference. The refmask | ||
459 | * argument allows unreferencing of individual fields or the whole frame. | ||
460 | * If the picture becomes entirely unreferenced, but is being held for | ||
461 | * display purposes, it is marked as such. | ||
462 | * @param refmask mask of fields to unreference; the mask is bitwise | ||
463 | * anded with the reference marking of pic | ||
464 | * @return non-zero if pic becomes entirely unreferenced (except possibly | ||
465 | * for display purposes) zero if one of the fields remains in | ||
466 | * reference | ||
467 | */ | ||
468 | 18083 | static inline int unreference_pic(H264Context *h, H264Picture *pic, int refmask) | |
469 | { | ||
470 | int i; | ||
471 |
2/2✓ Branch 0 taken 1182 times.
✓ Branch 1 taken 16901 times.
|
18083 | if (pic->reference &= refmask) { |
472 | 1182 | return 0; | |
473 | } else { | ||
474 |
2/2✓ Branch 0 taken 18378 times.
✓ Branch 1 taken 15483 times.
|
33861 | for(i = 0; h->delayed_pic[i]; i++) |
475 |
2/2✓ Branch 0 taken 1418 times.
✓ Branch 1 taken 16960 times.
|
18378 | if(pic == h->delayed_pic[i]){ |
476 | 1418 | pic->reference = DELAYED_PIC_REF; | |
477 | 1418 | break; | |
478 | } | ||
479 | 16901 | return 1; | |
480 | } | ||
481 | } | ||
482 | |||
483 | /** | ||
484 | * Find a H264Picture in the short term reference list by frame number. | ||
485 | * @param frame_num frame number to search for | ||
486 | * @param idx the index into h->short_ref where returned picture is found | ||
487 | * undefined if no picture found. | ||
488 | * @return pointer to the found picture, or NULL if no pic with the provided | ||
489 | * frame number is found | ||
490 | */ | ||
491 | 47635 | static H264Picture *find_short(H264Context *h, int frame_num, int *idx) | |
492 | { | ||
493 | int i; | ||
494 | |||
495 |
2/2✓ Branch 0 taken 190842 times.
✓ Branch 1 taken 16875 times.
|
207717 | for (i = 0; i < h->short_ref_count; i++) { |
496 | 190842 | H264Picture *pic = h->short_ref[i]; | |
497 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 190842 times.
|
190842 | if (h->avctx->debug & FF_DEBUG_MMCO) |
498 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "%d %d %p\n", i, pic->frame_num, pic); | |
499 |
2/2✓ Branch 0 taken 30760 times.
✓ Branch 1 taken 160082 times.
|
190842 | if (pic->frame_num == frame_num) { |
500 | 30760 | *idx = i; | |
501 | 30760 | return pic; | |
502 | } | ||
503 | } | ||
504 | 16875 | return NULL; | |
505 | } | ||
506 | |||
507 | /** | ||
508 | * Remove a picture from the short term reference list by its index in | ||
509 | * that list. This does no checking on the provided index; it is assumed | ||
510 | * to be valid. Other list entries are shifted down. | ||
511 | * @param i index into h->short_ref of picture to remove. | ||
512 | */ | ||
513 | 14397 | static void remove_short_at_index(H264Context *h, int i) | |
514 | { | ||
515 | assert(i >= 0 && i < h->short_ref_count); | ||
516 | 14397 | h->short_ref[i] = NULL; | |
517 |
2/2✓ Branch 0 taken 10872 times.
✓ Branch 1 taken 3525 times.
|
14397 | if (--h->short_ref_count) |
518 | 10872 | memmove(&h->short_ref[i], &h->short_ref[i + 1], | |
519 | 10872 | (h->short_ref_count - i) * sizeof(H264Picture*)); | |
520 | 14397 | } | |
521 | |||
522 | /** | ||
523 | * @return the removed picture or NULL if an error occurs | ||
524 | */ | ||
525 | 32090 | static H264Picture *remove_short(H264Context *h, int frame_num, int ref_mask) | |
526 | { | ||
527 | H264Picture *pic; | ||
528 | int i; | ||
529 | |||
530 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 32090 times.
|
32090 | if (h->avctx->debug & FF_DEBUG_MMCO) |
531 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "remove short %d count %d\n", frame_num, h->short_ref_count); | |
532 | |||
533 | 32090 | pic = find_short(h, frame_num, &i); | |
534 |
2/2✓ Branch 0 taken 15258 times.
✓ Branch 1 taken 16832 times.
|
32090 | if (pic) { |
535 |
2/2✓ Branch 1 taken 14076 times.
✓ Branch 2 taken 1182 times.
|
15258 | if (unreference_pic(h, pic, ref_mask)) |
536 | 14076 | remove_short_at_index(h, i); | |
537 | } | ||
538 | |||
539 | 32090 | return pic; | |
540 | } | ||
541 | |||
542 | /** | ||
543 | * Remove a picture from the long term reference list by its index in | ||
544 | * that list. | ||
545 | * @return the removed picture or NULL if an error occurs | ||
546 | */ | ||
547 | 43007 | static H264Picture *remove_long(H264Context *h, int i, int ref_mask) | |
548 | { | ||
549 | H264Picture *pic; | ||
550 | |||
551 | 43007 | pic = h->long_ref[i]; | |
552 |
2/2✓ Branch 0 taken 342 times.
✓ Branch 1 taken 42665 times.
|
43007 | if (pic) { |
553 |
1/2✓ Branch 1 taken 342 times.
✗ Branch 2 not taken.
|
342 | if (unreference_pic(h, pic, ref_mask)) { |
554 | assert(h->long_ref[i]->long_ref == 1); | ||
555 | 342 | h->long_ref[i]->long_ref = 0; | |
556 | 342 | h->long_ref[i] = NULL; | |
557 | 342 | h->long_ref_count--; | |
558 | } | ||
559 | } | ||
560 | |||
561 | 43007 | return pic; | |
562 | } | ||
563 | |||
564 | 2267 | void ff_h264_remove_all_refs(H264Context *h) | |
565 | { | ||
566 | int i; | ||
567 | |||
568 |
2/2✓ Branch 0 taken 36272 times.
✓ Branch 1 taken 2267 times.
|
38539 | for (i = 0; i < 16; i++) { |
569 | 36272 | remove_long(h, i, 0); | |
570 | } | ||
571 | assert(h->long_ref_count == 0); | ||
572 | |||
573 |
3/4✓ Branch 0 taken 1100 times.
✓ Branch 1 taken 1167 times.
✓ Branch 2 taken 1100 times.
✗ Branch 3 not taken.
|
2267 | if (h->short_ref_count && !h->last_pic_for_ec.f->data[0]) { |
574 | 1100 | ff_h264_unref_picture(h, &h->last_pic_for_ec); | |
575 | 1100 | ff_h264_ref_picture(h, &h->last_pic_for_ec, h->short_ref[0]); | |
576 | } | ||
577 | |||
578 |
2/2✓ Branch 0 taken 2483 times.
✓ Branch 1 taken 2267 times.
|
4750 | for (i = 0; i < h->short_ref_count; i++) { |
579 | 2483 | unreference_pic(h, h->short_ref[i], 0); | |
580 | 2483 | h->short_ref[i] = NULL; | |
581 | } | ||
582 | 2267 | h->short_ref_count = 0; | |
583 | |||
584 | 2267 | memset(h->default_ref, 0, sizeof(h->default_ref)); | |
585 | 2267 | } | |
586 | |||
587 | 15698 | static void generate_sliding_window_mmcos(H264Context *h) | |
588 | { | ||
589 | 15698 | MMCO *mmco = h->mmco; | |
590 | 15698 | int nb_mmco = 0; | |
591 | |||
592 |
2/2✓ Branch 0 taken 15670 times.
✓ Branch 1 taken 28 times.
|
15698 | if (h->short_ref_count && |
593 |
2/2✓ Branch 0 taken 13183 times.
✓ Branch 1 taken 2487 times.
|
15670 | h->long_ref_count + h->short_ref_count >= h->ps.sps->ref_frame_count && |
594 |
5/6✓ Branch 0 taken 2223 times.
✓ Branch 1 taken 10960 times.
✓ Branch 2 taken 1179 times.
✓ Branch 3 taken 1044 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 1179 times.
|
13183 | !(FIELD_PICTURE(h) && !h->first_field && h->cur_pic_ptr->reference)) { |
595 | 12004 | mmco[0].opcode = MMCO_SHORT2UNUSED; | |
596 | 12004 | mmco[0].short_pic_num = h->short_ref[h->short_ref_count - 1]->frame_num; | |
597 | 12004 | nb_mmco = 1; | |
598 |
2/2✓ Branch 0 taken 1044 times.
✓ Branch 1 taken 10960 times.
|
12004 | if (FIELD_PICTURE(h)) { |
599 | 1044 | mmco[0].short_pic_num *= 2; | |
600 | 1044 | mmco[1].opcode = MMCO_SHORT2UNUSED; | |
601 | 1044 | mmco[1].short_pic_num = mmco[0].short_pic_num + 1; | |
602 | 1044 | nb_mmco = 2; | |
603 | } | ||
604 | } | ||
605 | |||
606 | 15698 | h->nb_mmco = nb_mmco; | |
607 | 15698 | } | |
608 | |||
609 | 18328 | int ff_h264_execute_ref_pic_marking(H264Context *h) | |
610 | { | ||
611 | 18328 | MMCO *mmco = h->mmco; | |
612 | int mmco_count; | ||
613 | 18328 | int i, av_uninit(j); | |
614 | 18328 | int pps_ref_count[2] = {0}; | |
615 | 18328 | int current_ref_assigned = 0, err = 0; | |
616 | 18328 | H264Picture *av_uninit(pic); | |
617 | |||
618 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18328 times.
|
18328 | if (!h->ps.sps) { |
619 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "SPS is unset\n"); | |
620 | ✗ | err = AVERROR_INVALIDDATA; | |
621 | ✗ | goto out; | |
622 | } | ||
623 | |||
624 |
2/2✓ Branch 0 taken 15698 times.
✓ Branch 1 taken 2630 times.
|
18328 | if (!h->explicit_ref_marking) |
625 | 15698 | generate_sliding_window_mmcos(h); | |
626 | 18328 | mmco_count = h->nb_mmco; | |
627 | |||
628 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 18328 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
18328 | if ((h->avctx->debug & FF_DEBUG_MMCO) && mmco_count == 0) |
629 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "no mmco here\n"); | |
630 | |||
631 |
2/2✓ Branch 0 taken 16070 times.
✓ Branch 1 taken 18328 times.
|
34398 | for (i = 0; i < mmco_count; i++) { |
632 | 16070 | int av_uninit(structure), av_uninit(frame_num); | |
633 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16070 times.
|
16070 | if (h->avctx->debug & FF_DEBUG_MMCO) |
634 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "mmco:%d %d %d\n", h->mmco[i].opcode, | |
635 | h->mmco[i].short_pic_num, h->mmco[i].long_arg); | ||
636 | |||
637 |
2/2✓ Branch 0 taken 867 times.
✓ Branch 1 taken 15203 times.
|
16070 | if (mmco[i].opcode == MMCO_SHORT2UNUSED || |
638 |
2/2✓ Branch 0 taken 342 times.
✓ Branch 1 taken 525 times.
|
867 | mmco[i].opcode == MMCO_SHORT2LONG) { |
639 | 15545 | frame_num = pic_num_extract(h, mmco[i].short_pic_num, &structure); | |
640 | 15545 | pic = find_short(h, frame_num, &j); | |
641 |
2/2✓ Branch 0 taken 43 times.
✓ Branch 1 taken 15502 times.
|
15545 | if (!pic) { |
642 |
2/2✓ Branch 0 taken 21 times.
✓ Branch 1 taken 22 times.
|
43 | if (mmco[i].opcode != MMCO_SHORT2LONG || |
643 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | !h->long_ref[mmco[i].long_arg] || |
644 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | h->long_ref[mmco[i].long_arg]->frame_num != frame_num) { |
645 |
1/2✓ Branch 0 taken 22 times.
✗ Branch 1 not taken.
|
22 | av_log(h->avctx, h->short_ref_count ? AV_LOG_ERROR : AV_LOG_DEBUG, "mmco: unref short failure\n"); |
646 | 22 | err = AVERROR_INVALIDDATA; | |
647 | } | ||
648 | 43 | continue; | |
649 | } | ||
650 | } | ||
651 | |||
652 |
6/7✓ Branch 0 taken 15181 times.
✓ Branch 1 taken 321 times.
✓ Branch 2 taken 82 times.
✓ Branch 3 taken 21 times.
✓ Branch 4 taken 407 times.
✓ Branch 5 taken 15 times.
✗ Branch 6 not taken.
|
16027 | switch (mmco[i].opcode) { |
653 | 15181 | case MMCO_SHORT2UNUSED: | |
654 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 15181 times.
|
15181 | if (h->avctx->debug & FF_DEBUG_MMCO) |
655 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref short %d count %d\n", | |
656 | h->mmco[i].short_pic_num, h->short_ref_count); | ||
657 | 15181 | remove_short(h, frame_num, structure ^ PICT_FRAME); | |
658 | 15181 | break; | |
659 | 321 | case MMCO_SHORT2LONG: | |
660 |
1/2✓ Branch 0 taken 321 times.
✗ Branch 1 not taken.
|
321 | if (h->long_ref[mmco[i].long_arg] != pic) |
661 | 321 | remove_long(h, mmco[i].long_arg, 0); | |
662 | |||
663 | 321 | remove_short_at_index(h, j); | |
664 | 321 | h->long_ref[ mmco[i].long_arg ] = pic; | |
665 |
1/2✓ Branch 0 taken 321 times.
✗ Branch 1 not taken.
|
321 | if (h->long_ref[mmco[i].long_arg]) { |
666 | 321 | h->long_ref[mmco[i].long_arg]->long_ref = 1; | |
667 | 321 | h->long_ref_count++; | |
668 | } | ||
669 | 321 | break; | |
670 | 82 | case MMCO_LONG2UNUSED: | |
671 | 82 | j = pic_num_extract(h, mmco[i].long_arg, &structure); | |
672 | 82 | pic = h->long_ref[j]; | |
673 |
1/2✓ Branch 0 taken 82 times.
✗ Branch 1 not taken.
|
82 | if (pic) { |
674 | 82 | remove_long(h, j, structure ^ PICT_FRAME); | |
675 | ✗ | } else if (h->avctx->debug & FF_DEBUG_MMCO) | |
676 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "mmco: unref long failure\n"); | |
677 | 82 | break; | |
678 | 21 | case MMCO_LONG: | |
679 | // Comment below left from previous code as it is an interesting note. | ||
680 | /* First field in pair is in short term list or | ||
681 | * at a different long term index. | ||
682 | * This is not allowed; see 7.4.3.3, notes 2 and 3. | ||
683 | * Report the problem and keep the pair where it is, | ||
684 | * and mark this field valid. | ||
685 | */ | ||
686 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | if (h->short_ref[0] == h->cur_pic_ptr) { |
687 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to short and long at the same time\n"); | |
688 | ✗ | remove_short_at_index(h, 0); | |
689 | } | ||
690 | |||
691 | /* make sure the current picture is not already assigned as a long ref */ | ||
692 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | if (h->cur_pic_ptr->long_ref) { |
693 | ✗ | for (j = 0; j < FF_ARRAY_ELEMS(h->long_ref); j++) { | |
694 | ✗ | if (h->long_ref[j] == h->cur_pic_ptr) { | |
695 | ✗ | if (j != mmco[i].long_arg) | |
696 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "mmco: cannot assign current picture to 2 long term references\n"); | |
697 | ✗ | remove_long(h, j, 0); | |
698 | } | ||
699 | } | ||
700 | } | ||
701 | |||
702 |
1/2✓ Branch 0 taken 21 times.
✗ Branch 1 not taken.
|
21 | if (h->long_ref[mmco[i].long_arg] != h->cur_pic_ptr) { |
703 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 21 times.
|
21 | av_assert0(!h->cur_pic_ptr->long_ref); |
704 | 21 | remove_long(h, mmco[i].long_arg, 0); | |
705 | |||
706 | 21 | h->long_ref[mmco[i].long_arg] = h->cur_pic_ptr; | |
707 | 21 | h->long_ref[mmco[i].long_arg]->long_ref = 1; | |
708 | 21 | h->long_ref_count++; | |
709 | } | ||
710 | |||
711 | 21 | h->cur_pic_ptr->reference |= h->picture_structure; | |
712 | 21 | current_ref_assigned = 1; | |
713 | 21 | break; | |
714 | 407 | case MMCO_SET_MAX_LONG: | |
715 | assert(mmco[i].long_arg <= 16); | ||
716 | // just remove the long term which index is greater than new max | ||
717 |
2/2✓ Branch 0 taken 6071 times.
✓ Branch 1 taken 407 times.
|
6478 | for (j = mmco[i].long_arg; j < 16; j++) { |
718 | 6071 | remove_long(h, j, 0); | |
719 | } | ||
720 | 407 | break; | |
721 | 15 | case MMCO_RESET: | |
722 |
2/2✓ Branch 0 taken 53 times.
✓ Branch 1 taken 15 times.
|
68 | while (h->short_ref_count) { |
723 | 53 | remove_short(h, h->short_ref[0]->frame_num, 0); | |
724 | } | ||
725 |
2/2✓ Branch 0 taken 240 times.
✓ Branch 1 taken 15 times.
|
255 | for (j = 0; j < 16; j++) { |
726 | 240 | remove_long(h, j, 0); | |
727 | } | ||
728 | 15 | h->poc.frame_num = h->cur_pic_ptr->frame_num = 0; | |
729 | 15 | h->mmco_reset = 1; | |
730 | 15 | h->cur_pic_ptr->mmco_reset = 1; | |
731 |
2/2✓ Branch 0 taken 240 times.
✓ Branch 1 taken 15 times.
|
255 | for (j = 0; j < FF_ARRAY_ELEMS(h->last_pocs); j++) |
732 | 240 | h->last_pocs[j] = INT_MIN; | |
733 | 15 | break; | |
734 | ✗ | default: av_assert0(0); | |
735 | } | ||
736 | } | ||
737 | |||
738 |
2/2✓ Branch 0 taken 18307 times.
✓ Branch 1 taken 21 times.
|
18328 | if (!current_ref_assigned) { |
739 | /* Second field of complementary field pair; the first field of | ||
740 | * which is already referenced. If short referenced, it | ||
741 | * should be first entry in short_ref. If not, it must exist | ||
742 | * in long_ref; trying to put it on the short list here is an | ||
743 | * error in the encoded bit stream (ref: 7.4.3.3, NOTE 2 and 3). | ||
744 | */ | ||
745 |
4/4✓ Branch 0 taken 13698 times.
✓ Branch 1 taken 4609 times.
✓ Branch 2 taken 1475 times.
✓ Branch 3 taken 12223 times.
|
18307 | if (h->short_ref_count && h->short_ref[0] == h->cur_pic_ptr) { |
746 | /* Just mark the second field valid */ | ||
747 | 1475 | h->cur_pic_ptr->reference |= h->picture_structure; | |
748 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16832 times.
|
16832 | } else if (h->cur_pic_ptr->long_ref) { |
749 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "illegal short term reference " | |
750 | "assignment for second field " | ||
751 | "in complementary field pair " | ||
752 | "(first field is long term)\n"); | ||
753 | ✗ | err = AVERROR_INVALIDDATA; | |
754 | } else { | ||
755 | 16832 | pic = remove_short(h, h->cur_pic_ptr->frame_num, 0); | |
756 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 16832 times.
|
16832 | if (pic) { |
757 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "illegal short term buffer state detected\n"); | |
758 | ✗ | err = AVERROR_INVALIDDATA; | |
759 | } | ||
760 | |||
761 |
2/2✓ Branch 0 taken 12223 times.
✓ Branch 1 taken 4609 times.
|
16832 | if (h->short_ref_count) |
762 | 12223 | memmove(&h->short_ref[1], &h->short_ref[0], | |
763 | 12223 | h->short_ref_count * sizeof(H264Picture*)); | |
764 | |||
765 | 16832 | h->short_ref[0] = h->cur_pic_ptr; | |
766 | 16832 | h->short_ref_count++; | |
767 | 16832 | h->cur_pic_ptr->reference |= h->picture_structure; | |
768 | } | ||
769 | } | ||
770 | |||
771 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 18317 times.
|
18328 | if (h->long_ref_count + h->short_ref_count > FFMAX(h->ps.sps->ref_frame_count, 1)) { |
772 | |||
773 | /* We have too many reference frames, probably due to corrupted | ||
774 | * stream. Need to discard one frame. Prevents overrun of the | ||
775 | * short_ref and long_ref buffers. | ||
776 | */ | ||
777 | 11 | av_log(h->avctx, AV_LOG_ERROR, | |
778 | "number of reference frames (%d+%d) exceeds max (%d; probably " | ||
779 | "corrupt input), discarding one\n", | ||
780 | 11 | h->long_ref_count, h->short_ref_count, h->ps.sps->ref_frame_count); | |
781 | 11 | err = AVERROR_INVALIDDATA; | |
782 | |||
783 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 11 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
11 | if (h->long_ref_count && !h->short_ref_count) { |
784 | ✗ | for (i = 0; i < 16; ++i) | |
785 | ✗ | if (h->long_ref[i]) | |
786 | ✗ | break; | |
787 | |||
788 | assert(i < 16); | ||
789 | ✗ | remove_long(h, i, 0); | |
790 | } else { | ||
791 | 11 | pic = h->short_ref[h->short_ref_count - 1]; | |
792 | 11 | remove_short(h, pic->frame_num, 0); | |
793 | } | ||
794 | } | ||
795 | |||
796 |
2/2✓ Branch 0 taken 78748 times.
✓ Branch 1 taken 18328 times.
|
97076 | for (i = 0; i<h->short_ref_count; i++) { |
797 | 78748 | pic = h->short_ref[i]; | |
798 |
2/2✓ Branch 0 taken 326 times.
✓ Branch 1 taken 78422 times.
|
78748 | if (pic->invalid_gap) { |
799 | 326 | int d = av_mod_uintp2(h->cur_pic_ptr->frame_num - pic->frame_num, h->ps.sps->log2_max_frame_num); | |
800 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 313 times.
|
326 | if (d > h->ps.sps->ref_frame_count) |
801 | 13 | remove_short(h, pic->frame_num, 0); | |
802 | } | ||
803 | } | ||
804 | |||
805 | 18328 | print_short_term(h); | |
806 | 18328 | print_long_term(h); | |
807 | |||
808 |
2/2✓ Branch 0 taken 4691968 times.
✓ Branch 1 taken 18328 times.
|
4710296 | for (i = 0; i < FF_ARRAY_ELEMS(h->ps.pps_list); i++) { |
809 |
2/2✓ Branch 0 taken 18591 times.
✓ Branch 1 taken 4673377 times.
|
4691968 | if (h->ps.pps_list[i]) { |
810 | 18591 | const PPS *pps = (const PPS *)h->ps.pps_list[i]->data; | |
811 | 18591 | pps_ref_count[0] = FFMAX(pps_ref_count[0], pps->ref_count[0]); | |
812 | 18591 | pps_ref_count[1] = FFMAX(pps_ref_count[1], pps->ref_count[1]); | |
813 | } | ||
814 | } | ||
815 | |||
816 | // Detect unmarked random access points | ||
817 |
2/2✓ Branch 0 taken 11 times.
✓ Branch 1 taken 18317 times.
|
18328 | if ( err >= 0 |
818 |
2/2✓ Branch 0 taken 1045 times.
✓ Branch 1 taken 17272 times.
|
18317 | && h->long_ref_count==0 |
819 |
2/2✓ Branch 0 taken 10060 times.
✓ Branch 1 taken 7212 times.
|
17272 | && ( h->short_ref_count<=2 |
820 |
6/6✓ Branch 0 taken 1664 times.
✓ Branch 1 taken 8396 times.
✓ Branch 2 taken 1643 times.
✓ Branch 3 taken 21 times.
✓ Branch 4 taken 739 times.
✓ Branch 5 taken 904 times.
|
10060 | || pps_ref_count[0] <= 2 && pps_ref_count[1] <= 1 && h->avctx->has_b_frames |
821 |
5/6✓ Branch 0 taken 787 times.
✓ Branch 1 taken 8369 times.
✓ Branch 2 taken 8451 times.
✓ Branch 3 taken 705 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 705 times.
|
9156 | || pps_ref_count[0] <= 1 + (h->picture_structure != PICT_FRAME) && pps_ref_count[1] <= 1) |
822 |
6/6✓ Branch 0 taken 2397 times.
✓ Branch 1 taken 6424 times.
✓ Branch 2 taken 20 times.
✓ Branch 3 taken 8801 times.
✓ Branch 4 taken 1189 times.
✓ Branch 5 taken 7632 times.
|
8821 | && pps_ref_count[0]<=2 + (h->picture_structure != PICT_FRAME) + (2*!h->has_recovery_point) |
823 |
2/2✓ Branch 0 taken 5370 times.
✓ Branch 1 taken 2262 times.
|
7632 | && h->cur_pic_ptr->f->pict_type == AV_PICTURE_TYPE_I){ |
824 | 2262 | h->cur_pic_ptr->recovered |= 1; | |
825 |
2/2✓ Branch 0 taken 729 times.
✓ Branch 1 taken 1533 times.
|
2262 | if(!h->avctx->has_b_frames) |
826 | 1533 | h->frame_recovered |= FRAME_RECOVERED_SEI; | |
827 | } | ||
828 | |||
829 | 16795 | out: | |
830 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18328 times.
|
18328 | return (h->avctx->err_recognition & AV_EF_EXPLODE) ? err : 0; |
831 | } | ||
832 | |||
833 | 24123 | int ff_h264_decode_ref_pic_marking(H264SliceContext *sl, GetBitContext *gb, | |
834 | const H2645NAL *nal, void *logctx) | ||
835 | { | ||
836 | int i; | ||
837 | 24123 | MMCO *mmco = sl->mmco; | |
838 | 24123 | int nb_mmco = 0; | |
839 | |||
840 |
2/2✓ Branch 0 taken 2240 times.
✓ Branch 1 taken 21883 times.
|
24123 | if (nal->type == H264_NAL_IDR_SLICE) { // FIXME fields |
841 | 2240 | skip_bits1(gb); // broken_link | |
842 |
2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 2237 times.
|
2240 | if (get_bits1(gb)) { |
843 | 3 | mmco[0].opcode = MMCO_LONG; | |
844 | 3 | mmco[0].long_arg = 0; | |
845 | 3 | nb_mmco = 1; | |
846 | } | ||
847 | 2240 | sl->explicit_ref_marking = 1; | |
848 | } else { | ||
849 | 21883 | sl->explicit_ref_marking = get_bits1(gb); | |
850 |
2/2✓ Branch 0 taken 2320 times.
✓ Branch 1 taken 19563 times.
|
21883 | if (sl->explicit_ref_marking) { |
851 |
1/2✓ Branch 0 taken 6722 times.
✗ Branch 1 not taken.
|
6722 | for (i = 0; i < FF_ARRAY_ELEMS(sl->mmco); i++) { |
852 | 6722 | MMCOOpcode opcode = get_ue_golomb_31(gb); | |
853 | |||
854 | 6722 | mmco[i].opcode = opcode; | |
855 |
4/4✓ Branch 0 taken 3210 times.
✓ Branch 1 taken 3512 times.
✓ Branch 2 taken 365 times.
✓ Branch 3 taken 2845 times.
|
6722 | if (opcode == MMCO_SHORT2UNUSED || opcode == MMCO_SHORT2LONG) { |
856 | 3877 | mmco[i].short_pic_num = | |
857 | 3877 | (sl->curr_pic_num - get_ue_golomb_long(gb) - 1) & | |
858 | 3877 | (sl->max_pic_num - 1); | |
859 | } | ||
860 |
6/6✓ Branch 0 taken 6357 times.
✓ Branch 1 taken 365 times.
✓ Branch 2 taken 6275 times.
✓ Branch 3 taken 82 times.
✓ Branch 4 taken 6257 times.
✓ Branch 5 taken 18 times.
|
6722 | if (opcode == MMCO_SHORT2LONG || opcode == MMCO_LONG2UNUSED || |
861 |
2/2✓ Branch 0 taken 410 times.
✓ Branch 1 taken 5847 times.
|
6257 | opcode == MMCO_LONG || opcode == MMCO_SET_MAX_LONG) { |
862 | 875 | unsigned int long_arg = get_ue_golomb_31(gb); | |
863 |
2/4✓ Branch 0 taken 875 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 875 times.
|
875 | if (long_arg >= 32 || |
864 | ✗ | (long_arg >= 16 && !(opcode == MMCO_SET_MAX_LONG && | |
865 | ✗ | long_arg == 16) && | |
866 | ✗ | !(opcode == MMCO_LONG2UNUSED && FIELD_PICTURE(sl)))) { | |
867 | ✗ | av_log(logctx, AV_LOG_ERROR, | |
868 | "illegal long ref in memory management control " | ||
869 | "operation %d\n", opcode); | ||
870 | ✗ | sl->nb_mmco = i; | |
871 | ✗ | return -1; | |
872 | } | ||
873 | 875 | mmco[i].long_arg = long_arg; | |
874 | } | ||
875 | |||
876 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6722 times.
|
6722 | if (opcode > (unsigned) MMCO_LONG) { |
877 | ✗ | av_log(logctx, AV_LOG_ERROR, | |
878 | "illegal memory management control operation %d\n", | ||
879 | opcode); | ||
880 | ✗ | sl->nb_mmco = i; | |
881 | ✗ | return -1; | |
882 | } | ||
883 |
2/2✓ Branch 0 taken 2320 times.
✓ Branch 1 taken 4402 times.
|
6722 | if (opcode == MMCO_END) |
884 | 2320 | break; | |
885 | } | ||
886 | 2320 | nb_mmco = i; | |
887 | } | ||
888 | } | ||
889 | |||
890 | 24123 | sl->nb_mmco = nb_mmco; | |
891 | |||
892 | 24123 | return 0; | |
893 | } | ||
894 |