Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * H.26L/H.264/AVC/JVT/14496-10/... decoder | ||
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 codec. | ||
25 | * @author Michael Niedermayer <michaelni@gmx.at> | ||
26 | */ | ||
27 | |||
28 | #define UNCHECKED_BITSTREAM_READER 1 | ||
29 | |||
30 | #include "config_components.h" | ||
31 | |||
32 | #include "libavutil/attributes.h" | ||
33 | #include "libavutil/avassert.h" | ||
34 | #include "libavutil/emms.h" | ||
35 | #include "libavutil/imgutils.h" | ||
36 | #include "libavutil/mem.h" | ||
37 | #include "libavutil/opt.h" | ||
38 | #include "libavutil/thread.h" | ||
39 | #include "libavutil/video_enc_params.h" | ||
40 | |||
41 | #include "codec_internal.h" | ||
42 | #include "internal.h" | ||
43 | #include "error_resilience.h" | ||
44 | #include "avcodec.h" | ||
45 | #include "h264.h" | ||
46 | #include "h264dec.h" | ||
47 | #include "h2645_parse.h" | ||
48 | #include "h264data.h" | ||
49 | #include "h264_ps.h" | ||
50 | #include "golomb.h" | ||
51 | #include "hwaccel_internal.h" | ||
52 | #include "hwconfig.h" | ||
53 | #include "mpegutils.h" | ||
54 | #include "profiles.h" | ||
55 | #include "rectangle.h" | ||
56 | #include "libavutil/refstruct.h" | ||
57 | #include "thread.h" | ||
58 | #include "threadframe.h" | ||
59 | |||
60 | const uint16_t ff_h264_mb_sizes[4] = { 256, 384, 512, 768 }; | ||
61 | |||
62 | 6687 | int avpriv_h264_has_num_reorder_frames(AVCodecContext *avctx) | |
63 | { | ||
64 | 6687 | H264Context *h = avctx->priv_data; | |
65 |
4/4✓ Branch 0 taken 6563 times.
✓ Branch 1 taken 124 times.
✓ Branch 2 taken 6437 times.
✓ Branch 3 taken 126 times.
|
6687 | return h && h->ps.sps ? h->ps.sps->num_reorder_frames : 0; |
66 | } | ||
67 | |||
68 | ✗ | static void h264_er_decode_mb(void *opaque, int ref, int mv_dir, int mv_type, | |
69 | int (*mv)[2][4][2], | ||
70 | int mb_x, int mb_y, int mb_intra, int mb_skipped) | ||
71 | { | ||
72 | ✗ | const H264Context *h = opaque; | |
73 | ✗ | H264SliceContext *sl = &h->slice_ctx[0]; | |
74 | |||
75 | ✗ | sl->mb_x = mb_x; | |
76 | ✗ | sl->mb_y = mb_y; | |
77 | ✗ | sl->mb_xy = mb_x + mb_y * h->mb_stride; | |
78 | ✗ | memset(sl->non_zero_count_cache, 0, sizeof(sl->non_zero_count_cache)); | |
79 | av_assert1(ref >= 0); | ||
80 | /* FIXME: It is possible albeit uncommon that slice references | ||
81 | * differ between slices. We take the easy approach and ignore | ||
82 | * it for now. If this turns out to have any relevance in | ||
83 | * practice then correct remapping should be added. */ | ||
84 | ✗ | if (ref >= sl->ref_count[0]) | |
85 | ✗ | ref = 0; | |
86 | ✗ | if (!sl->ref_list[0][ref].data[0]) { | |
87 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "Reference not available for error concealing\n"); | |
88 | ✗ | ref = 0; | |
89 | } | ||
90 | ✗ | if ((sl->ref_list[0][ref].reference&3) != 3) { | |
91 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "Reference invalid\n"); | |
92 | ✗ | return; | |
93 | } | ||
94 | ✗ | fill_rectangle(&h->cur_pic.ref_index[0][4 * sl->mb_xy], | |
95 | 2, 2, 2, ref, 1); | ||
96 | ✗ | fill_rectangle(&sl->ref_cache[0][scan8[0]], 4, 4, 8, ref, 1); | |
97 | ✗ | fill_rectangle(sl->mv_cache[0][scan8[0]], 4, 4, 8, | |
98 | ✗ | pack16to32((*mv)[0][0][0], (*mv)[0][0][1]), 4); | |
99 | ✗ | sl->mb_mbaff = | |
100 | ✗ | sl->mb_field_decoding_flag = 0; | |
101 | ✗ | ff_h264_hl_decode_mb(h, &h->slice_ctx[0]); | |
102 | } | ||
103 | |||
104 | 377552 | void ff_h264_draw_horiz_band(const H264Context *h, H264SliceContext *sl, | |
105 | int y, int height) | ||
106 | { | ||
107 | 377552 | AVCodecContext *avctx = h->avctx; | |
108 | 377552 | const AVFrame *src = h->cur_pic.f; | |
109 | const AVPixFmtDescriptor *desc; | ||
110 | int offset[AV_NUM_DATA_POINTERS]; | ||
111 | int vshift; | ||
112 | 377552 | const int field_pic = h->picture_structure != PICT_FRAME; | |
113 | |||
114 |
1/2✓ Branch 0 taken 377552 times.
✗ Branch 1 not taken.
|
377552 | if (!avctx->draw_horiz_band) |
115 | 377552 | return; | |
116 | |||
117 | ✗ | if (field_pic && h->first_field && !(avctx->slice_flags & SLICE_FLAG_ALLOW_FIELD)) | |
118 | ✗ | return; | |
119 | |||
120 | ✗ | if (field_pic) { | |
121 | ✗ | height <<= 1; | |
122 | ✗ | y <<= 1; | |
123 | } | ||
124 | |||
125 | ✗ | height = FFMIN(height, avctx->height - y); | |
126 | |||
127 | ✗ | desc = av_pix_fmt_desc_get(avctx->pix_fmt); | |
128 | ✗ | vshift = desc->log2_chroma_h; | |
129 | |||
130 | ✗ | offset[0] = y * src->linesize[0]; | |
131 | ✗ | offset[1] = | |
132 | ✗ | offset[2] = (y >> vshift) * src->linesize[1]; | |
133 | ✗ | for (int i = 3; i < AV_NUM_DATA_POINTERS; i++) | |
134 | ✗ | offset[i] = 0; | |
135 | |||
136 | ✗ | emms_c(); | |
137 | |||
138 | ✗ | avctx->draw_horiz_band(avctx, src, offset, | |
139 | ✗ | y, h->picture_structure, height); | |
140 | } | ||
141 | |||
142 | 1242 | void ff_h264_free_tables(H264Context *h) | |
143 | { | ||
144 | int i; | ||
145 | |||
146 | 1242 | av_freep(&h->intra4x4_pred_mode); | |
147 | 1242 | av_freep(&h->chroma_pred_mode_table); | |
148 | 1242 | av_freep(&h->cbp_table); | |
149 | 1242 | av_freep(&h->mvd_table[0]); | |
150 | 1242 | av_freep(&h->mvd_table[1]); | |
151 | 1242 | av_freep(&h->direct_table); | |
152 | 1242 | av_freep(&h->non_zero_count); | |
153 | 1242 | av_freep(&h->slice_table_base); | |
154 | 1242 | h->slice_table = NULL; | |
155 | 1242 | av_freep(&h->list_counts); | |
156 | |||
157 | 1242 | av_freep(&h->mb2b_xy); | |
158 | 1242 | av_freep(&h->mb2br_xy); | |
159 | |||
160 | 1242 | av_refstruct_pool_uninit(&h->qscale_table_pool); | |
161 | 1242 | av_refstruct_pool_uninit(&h->mb_type_pool); | |
162 | 1242 | av_refstruct_pool_uninit(&h->motion_val_pool); | |
163 | 1242 | av_refstruct_pool_uninit(&h->ref_index_pool); | |
164 | |||
165 | #if CONFIG_ERROR_RESILIENCE | ||
166 | 1242 | av_freep(&h->er.mb_index2xy); | |
167 | 1242 | av_freep(&h->er.error_status_table); | |
168 | 1242 | av_freep(&h->er.er_temp_buffer); | |
169 | 1242 | av_freep(&h->dc_val_base); | |
170 | #endif | ||
171 | |||
172 |
2/2✓ Branch 0 taken 1244 times.
✓ Branch 1 taken 1242 times.
|
2486 | for (i = 0; i < h->nb_slice_ctx; i++) { |
173 | 1244 | H264SliceContext *sl = &h->slice_ctx[i]; | |
174 | |||
175 | 1244 | av_freep(&sl->bipred_scratchpad); | |
176 | 1244 | av_freep(&sl->edge_emu_buffer); | |
177 | 1244 | av_freep(&sl->top_borders[0]); | |
178 | 1244 | av_freep(&sl->top_borders[1]); | |
179 | |||
180 | 1244 | sl->bipred_scratchpad_allocated = 0; | |
181 | 1244 | sl->edge_emu_buffer_allocated = 0; | |
182 | 1244 | sl->top_borders_allocated[0] = 0; | |
183 | 1244 | sl->top_borders_allocated[1] = 0; | |
184 | } | ||
185 | 1242 | } | |
186 | |||
187 | 613 | int ff_h264_alloc_tables(H264Context *h) | |
188 | { | ||
189 | 613 | ERContext *const er = &h->er; | |
190 | 613 | const int big_mb_num = h->mb_stride * (h->mb_height + 1); | |
191 | 613 | const int row_mb_num = 2*h->mb_stride*FFMAX(h->nb_slice_ctx, 1); | |
192 | 613 | const int st_size = big_mb_num + h->mb_stride; | |
193 | int x, y; | ||
194 | |||
195 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | if (!FF_ALLOCZ_TYPED_ARRAY(h->intra4x4_pred_mode, row_mb_num * 8) || |
196 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->non_zero_count, big_mb_num) || |
197 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->slice_table_base, st_size) || |
198 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->cbp_table, big_mb_num) || |
199 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->chroma_pred_mode_table, big_mb_num) || |
200 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[0], row_mb_num * 8) || |
201 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->mvd_table[1], row_mb_num * 8) || |
202 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->direct_table, big_mb_num * 4) || |
203 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->list_counts, big_mb_num) || |
204 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->mb2b_xy, big_mb_num) || |
205 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 613 times.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->mb2br_xy, big_mb_num)) |
206 | ✗ | return AVERROR(ENOMEM); | |
207 | 613 | h->slice_ctx[0].intra4x4_pred_mode = h->intra4x4_pred_mode; | |
208 | 613 | h->slice_ctx[0].mvd_table[0] = h->mvd_table[0]; | |
209 | 613 | h->slice_ctx[0].mvd_table[1] = h->mvd_table[1]; | |
210 | 613 | memset(h->slice_table_base, -1, | |
211 | st_size * sizeof(*h->slice_table_base)); | ||
212 | 613 | h->slice_table = h->slice_table_base + h->mb_stride * 2 + 1; | |
213 |
2/2✓ Branch 0 taken 15571 times.
✓ Branch 1 taken 613 times.
|
16184 | for (y = 0; y < h->mb_height; y++) |
214 |
2/2✓ Branch 0 taken 958532 times.
✓ Branch 1 taken 15571 times.
|
974103 | for (x = 0; x < h->mb_width; x++) { |
215 | 958532 | const int mb_xy = x + y * h->mb_stride; | |
216 | 958532 | const int b_xy = 4 * x + 4 * y * h->b_stride; | |
217 | |||
218 | 958532 | h->mb2b_xy[mb_xy] = b_xy; | |
219 | 958532 | h->mb2br_xy[mb_xy] = 8 * (FMO ? mb_xy : (mb_xy % (2 * h->mb_stride))); | |
220 | } | ||
221 | |||
222 | if (CONFIG_ERROR_RESILIENCE) { | ||
223 | 613 | const int er_size = h->mb_height * h->mb_stride * (4*sizeof(int) + 1); | |
224 | 613 | int mb_array_size = h->mb_height * h->mb_stride; | |
225 | 613 | int y_size = (2 * h->mb_width + 1) * (2 * h->mb_height + 1); | |
226 | 613 | int yc_size = y_size + 2 * big_mb_num; | |
227 | |||
228 | /* init ER */ | ||
229 | 613 | er->avctx = h->avctx; | |
230 | 613 | er->decode_mb = h264_er_decode_mb; | |
231 | 613 | er->opaque = h; | |
232 | 613 | er->quarter_sample = 1; | |
233 | |||
234 | 613 | er->mb_num = h->mb_num; | |
235 | 613 | er->mb_width = h->mb_width; | |
236 | 613 | er->mb_height = h->mb_height; | |
237 | 613 | er->mb_stride = h->mb_stride; | |
238 | 613 | er->b8_stride = h->mb_width * 2 + 1; | |
239 | |||
240 | // error resilience code looks cleaner with this | ||
241 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | if (!FF_ALLOCZ_TYPED_ARRAY(er->mb_index2xy, h->mb_num + 1) || |
242 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(er->error_status_table, mb_array_size) || |
243 |
1/2✓ Branch 1 taken 613 times.
✗ Branch 2 not taken.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(er->er_temp_buffer, er_size) || |
244 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 613 times.
|
613 | !FF_ALLOCZ_TYPED_ARRAY(h->dc_val_base, yc_size)) |
245 | ✗ | return AVERROR(ENOMEM); // ff_h264_free_tables will clean up for us | |
246 | |||
247 |
2/2✓ Branch 0 taken 15571 times.
✓ Branch 1 taken 613 times.
|
16184 | for (y = 0; y < h->mb_height; y++) |
248 |
2/2✓ Branch 0 taken 958532 times.
✓ Branch 1 taken 15571 times.
|
974103 | for (x = 0; x < h->mb_width; x++) |
249 | 958532 | er->mb_index2xy[x + y * h->mb_width] = x + y * h->mb_stride; | |
250 | |||
251 | 613 | er->mb_index2xy[h->mb_height * h->mb_width] = (h->mb_height - 1) * | |
252 | 613 | h->mb_stride + h->mb_width; | |
253 | 613 | er->dc_val[0] = h->dc_val_base + h->mb_width * 2 + 2; | |
254 | 613 | er->dc_val[1] = h->dc_val_base + y_size + h->mb_stride + 1; | |
255 | 613 | er->dc_val[2] = er->dc_val[1] + big_mb_num; | |
256 |
2/2✓ Branch 0 taken 5907699 times.
✓ Branch 1 taken 613 times.
|
5908312 | for (int i = 0; i < yc_size; i++) |
257 | 5907699 | h->dc_val_base[i] = 1024; | |
258 | } | ||
259 | |||
260 | 613 | return 0; | |
261 | } | ||
262 | |||
263 | /** | ||
264 | * Init slice context | ||
265 | */ | ||
266 | 614 | void ff_h264_slice_context_init(H264Context *h, H264SliceContext *sl) | |
267 | { | ||
268 | 614 | sl->ref_cache[0][scan8[5] + 1] = | |
269 | 614 | sl->ref_cache[0][scan8[7] + 1] = | |
270 | 614 | sl->ref_cache[0][scan8[13] + 1] = | |
271 | 614 | sl->ref_cache[1][scan8[5] + 1] = | |
272 | 614 | sl->ref_cache[1][scan8[7] + 1] = | |
273 | 614 | sl->ref_cache[1][scan8[13] + 1] = PART_NOT_AVAILABLE; | |
274 | |||
275 | 614 | sl->er = &h->er; | |
276 | 614 | } | |
277 | |||
278 | 23674 | static int h264_init_pic(H264Picture *pic) | |
279 | { | ||
280 | 23674 | pic->f = av_frame_alloc(); | |
281 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23674 times.
|
23674 | if (!pic->f) |
282 | ✗ | return AVERROR(ENOMEM); | |
283 | |||
284 | 23674 | pic->f_grain = av_frame_alloc(); | |
285 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 23674 times.
|
23674 | if (!pic->f_grain) |
286 | ✗ | return AVERROR(ENOMEM); | |
287 | |||
288 | 23674 | return 0; | |
289 | } | ||
290 | |||
291 | 623 | static int h264_init_context(AVCodecContext *avctx, H264Context *h) | |
292 | { | ||
293 | int i, ret; | ||
294 | |||
295 | 623 | h->avctx = avctx; | |
296 | 623 | h->cur_chroma_format_idc = -1; | |
297 | |||
298 | 623 | h->width_from_caller = avctx->width; | |
299 | 623 | h->height_from_caller = avctx->height; | |
300 | |||
301 | 623 | h->workaround_bugs = avctx->workaround_bugs; | |
302 | 623 | h->flags = avctx->flags; | |
303 | 623 | h->poc.prev_poc_msb = 1 << 16; | |
304 | 623 | h->recovery_frame = -1; | |
305 | 623 | h->frame_recovered = 0; | |
306 | 623 | h->poc.prev_frame_num = -1; | |
307 | 623 | h->sei.common.frame_packing.arrangement_cancel_flag = -1; | |
308 | 623 | h->sei.common.unregistered.x264_build = -1; | |
309 | |||
310 | 623 | h->next_outputed_poc = INT_MIN; | |
311 |
2/2✓ Branch 0 taken 9968 times.
✓ Branch 1 taken 623 times.
|
10591 | for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) |
312 | 9968 | h->last_pocs[i] = INT_MIN; | |
313 | |||
314 | 623 | ff_h264_sei_uninit(&h->sei); | |
315 | |||
316 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 605 times.
|
623 | if (avctx->active_thread_type & FF_THREAD_FRAME) { |
317 | 18 | h->decode_error_flags_pool = av_refstruct_pool_alloc(sizeof(atomic_int), 0); | |
318 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 18 times.
|
18 | if (!h->decode_error_flags_pool) |
319 | ✗ | return AVERROR(ENOMEM); | |
320 | } | ||
321 | |||
322 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 622 times.
|
623 | h->nb_slice_ctx = (avctx->active_thread_type & FF_THREAD_SLICE) ? avctx->thread_count : 1; |
323 | 623 | h->slice_ctx = av_calloc(h->nb_slice_ctx, sizeof(*h->slice_ctx)); | |
324 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 623 times.
|
623 | if (!h->slice_ctx) { |
325 | ✗ | h->nb_slice_ctx = 0; | |
326 | ✗ | return AVERROR(ENOMEM); | |
327 | } | ||
328 | |||
329 |
2/2✓ Branch 0 taken 22428 times.
✓ Branch 1 taken 623 times.
|
23051 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { |
330 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 22428 times.
|
22428 | if ((ret = h264_init_pic(&h->DPB[i])) < 0) |
331 | ✗ | return ret; | |
332 | } | ||
333 | |||
334 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 623 times.
|
623 | if ((ret = h264_init_pic(&h->cur_pic)) < 0) |
335 | ✗ | return ret; | |
336 | |||
337 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 623 times.
|
623 | if ((ret = h264_init_pic(&h->last_pic_for_ec)) < 0) |
338 | ✗ | return ret; | |
339 | |||
340 |
2/2✓ Branch 0 taken 624 times.
✓ Branch 1 taken 623 times.
|
1247 | for (i = 0; i < h->nb_slice_ctx; i++) |
341 | 624 | h->slice_ctx[i].h264 = h; | |
342 | |||
343 | 623 | return 0; | |
344 | } | ||
345 | |||
346 | 23674 | static void h264_free_pic(H264Context *h, H264Picture *pic) | |
347 | { | ||
348 | 23674 | ff_h264_unref_picture(pic); | |
349 | 23674 | av_frame_free(&pic->f); | |
350 | 23674 | av_frame_free(&pic->f_grain); | |
351 | 23674 | } | |
352 | |||
353 | 623 | static av_cold int h264_decode_end(AVCodecContext *avctx) | |
354 | { | ||
355 | 623 | H264Context *h = avctx->priv_data; | |
356 | int i; | ||
357 | |||
358 | 623 | ff_h264_remove_all_refs(h); | |
359 | 623 | ff_h264_free_tables(h); | |
360 | |||
361 |
2/2✓ Branch 0 taken 22428 times.
✓ Branch 1 taken 623 times.
|
23051 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) { |
362 | 22428 | h264_free_pic(h, &h->DPB[i]); | |
363 | } | ||
364 | 623 | memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); | |
365 | |||
366 | 623 | h->cur_pic_ptr = NULL; | |
367 | |||
368 | 623 | av_refstruct_pool_uninit(&h->decode_error_flags_pool); | |
369 | |||
370 | 623 | av_freep(&h->slice_ctx); | |
371 | 623 | h->nb_slice_ctx = 0; | |
372 | |||
373 | 623 | ff_h264_sei_uninit(&h->sei); | |
374 | 623 | ff_h264_ps_uninit(&h->ps); | |
375 | |||
376 | 623 | ff_h2645_packet_uninit(&h->pkt); | |
377 | |||
378 | 623 | h264_free_pic(h, &h->cur_pic); | |
379 | 623 | h264_free_pic(h, &h->last_pic_for_ec); | |
380 | |||
381 | 623 | return 0; | |
382 | } | ||
383 | |||
384 | static AVOnce h264_vlc_init = AV_ONCE_INIT; | ||
385 | |||
386 | 623 | static av_cold int h264_decode_init(AVCodecContext *avctx) | |
387 | { | ||
388 | 623 | H264Context *h = avctx->priv_data; | |
389 | int ret; | ||
390 | |||
391 | 623 | ret = h264_init_context(avctx, h); | |
392 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 623 times.
|
623 | if (ret < 0) |
393 | ✗ | return ret; | |
394 | |||
395 | 623 | ret = ff_thread_once(&h264_vlc_init, ff_h264_decode_init_vlc); | |
396 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 623 times.
|
623 | if (ret != 0) { |
397 | ✗ | av_log(avctx, AV_LOG_ERROR, "pthread_once has failed."); | |
398 | ✗ | return AVERROR_UNKNOWN; | |
399 | } | ||
400 | |||
401 |
2/2✓ Branch 0 taken 607 times.
✓ Branch 1 taken 16 times.
|
623 | if (!avctx->internal->is_copy) { |
402 |
3/4✓ Branch 0 taken 374 times.
✓ Branch 1 taken 233 times.
✓ Branch 2 taken 374 times.
✗ Branch 3 not taken.
|
607 | if (avctx->extradata_size > 0 && avctx->extradata) { |
403 | 374 | ret = ff_h264_decode_extradata(avctx->extradata, avctx->extradata_size, | |
404 | &h->ps, &h->is_avc, &h->nal_length_size, | ||
405 | avctx->err_recognition, avctx); | ||
406 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 374 times.
|
374 | if (ret < 0) { |
407 | ✗ | int explode = avctx->err_recognition & AV_EF_EXPLODE; | |
408 | ✗ | av_log(avctx, explode ? AV_LOG_ERROR: AV_LOG_WARNING, | |
409 | "Error decoding the extradata\n"); | ||
410 | ✗ | if (explode) { | |
411 | ✗ | return ret; | |
412 | } | ||
413 | ✗ | ret = 0; | |
414 | } | ||
415 | } | ||
416 | } | ||
417 | |||
418 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 623 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
623 | if (h->ps.sps && h->ps.sps->bitstream_restriction_flag && |
419 | ✗ | h->avctx->has_b_frames < h->ps.sps->num_reorder_frames) { | |
420 | ✗ | h->avctx->has_b_frames = h->ps.sps->num_reorder_frames; | |
421 | } | ||
422 | |||
423 | 623 | ff_h264_flush_change(h); | |
424 | |||
425 |
3/4✓ Branch 0 taken 623 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
✓ Branch 3 taken 622 times.
|
623 | if (h->enable_er < 0 && (avctx->active_thread_type & FF_THREAD_SLICE)) |
426 | 1 | h->enable_er = 0; | |
427 | |||
428 |
3/4✓ Branch 0 taken 622 times.
✓ Branch 1 taken 1 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 622 times.
|
623 | if (h->enable_er && (avctx->active_thread_type & FF_THREAD_SLICE)) { |
429 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
430 | "Error resilience with slice threads is enabled. It is unsafe and unsupported and may crash. " | ||
431 | "Use it at your own risk\n"); | ||
432 | } | ||
433 | |||
434 | 623 | return 0; | |
435 | } | ||
436 | |||
437 | /** | ||
438 | * instantaneous decoder refresh. | ||
439 | */ | ||
440 | 1735 | static void idr(H264Context *h) | |
441 | { | ||
442 | int i; | ||
443 | 1735 | ff_h264_remove_all_refs(h); | |
444 | 1735 | h->poc.prev_frame_num = | |
445 | 1735 | h->poc.prev_frame_num_offset = 0; | |
446 | 1735 | h->poc.prev_poc_msb = 1<<16; | |
447 | 1735 | h->poc.prev_poc_lsb = -1; | |
448 |
2/2✓ Branch 0 taken 27760 times.
✓ Branch 1 taken 1735 times.
|
29495 | for (i = 0; i < FF_ARRAY_ELEMS(h->last_pocs); i++) |
449 | 27760 | h->last_pocs[i] = INT_MIN; | |
450 | 1735 | } | |
451 | |||
452 | /* forget old pics after a seek */ | ||
453 | 637 | void ff_h264_flush_change(H264Context *h) | |
454 | { | ||
455 | int i, j; | ||
456 | |||
457 | 637 | h->next_outputed_poc = INT_MIN; | |
458 | 637 | h->prev_interlaced_frame = 1; | |
459 | 637 | idr(h); | |
460 | |||
461 | 637 | h->poc.prev_frame_num = -1; | |
462 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 637 times.
|
637 | if (h->cur_pic_ptr) { |
463 | ✗ | h->cur_pic_ptr->reference = 0; | |
464 | ✗ | for (j=i=0; h->delayed_pic[i]; i++) | |
465 | ✗ | if (h->delayed_pic[i] != h->cur_pic_ptr) | |
466 | ✗ | h->delayed_pic[j++] = h->delayed_pic[i]; | |
467 | ✗ | h->delayed_pic[j] = NULL; | |
468 | } | ||
469 | 637 | ff_h264_unref_picture(&h->last_pic_for_ec); | |
470 | |||
471 | 637 | h->first_field = 0; | |
472 | 637 | h->recovery_frame = -1; | |
473 | 637 | h->frame_recovered = 0; | |
474 | 637 | h->current_slice = 0; | |
475 | 637 | h->mmco_reset = 1; | |
476 | 637 | } | |
477 | |||
478 | 6 | static av_cold void h264_decode_flush(AVCodecContext *avctx) | |
479 | { | ||
480 | 6 | H264Context *h = avctx->priv_data; | |
481 | int i; | ||
482 | |||
483 | 6 | memset(h->delayed_pic, 0, sizeof(h->delayed_pic)); | |
484 | |||
485 | 6 | ff_h264_flush_change(h); | |
486 | 6 | ff_h264_sei_uninit(&h->sei); | |
487 | |||
488 |
2/2✓ Branch 0 taken 216 times.
✓ Branch 1 taken 6 times.
|
222 | for (i = 0; i < H264_MAX_PICTURE_COUNT; i++) |
489 | 216 | ff_h264_unref_picture(&h->DPB[i]); | |
490 | 6 | h->cur_pic_ptr = NULL; | |
491 | 6 | ff_h264_unref_picture(&h->cur_pic); | |
492 | |||
493 | 6 | h->mb_y = 0; | |
494 | 6 | h->non_gray = 0; | |
495 | |||
496 | 6 | ff_h264_free_tables(h); | |
497 | 6 | h->context_initialized = 0; | |
498 | |||
499 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
6 | if (FF_HW_HAS_CB(avctx, flush)) |
500 | ✗ | FF_HW_SIMPLE_CALL(avctx, flush); | |
501 | 6 | } | |
502 | |||
503 | 42 | static int get_last_needed_nal(H264Context *h) | |
504 | { | ||
505 | 42 | int nals_needed = 0; | |
506 | 42 | int slice_type = 0; | |
507 | 42 | int picture_intra_only = 1; | |
508 | 42 | int first_slice = 0; | |
509 | int i, ret; | ||
510 | |||
511 |
2/2✓ Branch 0 taken 44 times.
✓ Branch 1 taken 42 times.
|
86 | for (i = 0; i < h->pkt.nb_nals; i++) { |
512 | 44 | H2645NAL *nal = &h->pkt.nals[i]; | |
513 | GetBitContext gb; | ||
514 | |||
515 | /* packets can sometimes contain multiple PPS/SPS, | ||
516 | * e.g. two PAFF field pictures in one packet, or a demuxer | ||
517 | * which splits NALs strangely if so, when frame threading we | ||
518 | * can't start the next thread until we've read all of them */ | ||
519 |
2/3✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
✓ Branch 2 taken 2 times.
|
44 | switch (nal->type) { |
520 | ✗ | case H264_NAL_SPS: | |
521 | case H264_NAL_PPS: | ||
522 | ✗ | nals_needed = i; | |
523 | ✗ | break; | |
524 | 42 | case H264_NAL_DPA: | |
525 | case H264_NAL_IDR_SLICE: | ||
526 | case H264_NAL_SLICE: | ||
527 | 42 | ret = init_get_bits8(&gb, nal->data + 1, nal->size - 1); | |
528 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | if (ret < 0) { |
529 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "Invalid zero-sized VCL NAL unit\n"); | |
530 | ✗ | if (h->avctx->err_recognition & AV_EF_EXPLODE) | |
531 | ✗ | return ret; | |
532 | |||
533 | ✗ | break; | |
534 | } | ||
535 |
1/4✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
42 | if (!get_ue_golomb_long(&gb) || // first_mb_in_slice |
536 | ✗ | !first_slice || | |
537 | ✗ | first_slice != nal->type) | |
538 | 42 | nals_needed = i; | |
539 | 42 | slice_type = get_ue_golomb_31(&gb); | |
540 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 42 times.
|
42 | if (slice_type > 9) |
541 | ✗ | slice_type = 0; | |
542 |
1/2✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
|
42 | if (slice_type > 4) |
543 | 42 | slice_type -= 5; | |
544 | |||
545 | 42 | slice_type = ff_h264_golomb_to_pict_type[slice_type]; | |
546 | 42 | picture_intra_only &= (slice_type & 3) == AV_PICTURE_TYPE_I; | |
547 |
1/2✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
|
42 | if (!first_slice) |
548 | 42 | first_slice = nal->type; | |
549 | } | ||
550 | } | ||
551 | |||
552 | 42 | h->picture_intra_only = picture_intra_only; | |
553 | |||
554 | 42 | return nals_needed; | |
555 | } | ||
556 | |||
557 | ✗ | static void debug_green_metadata(const H264SEIGreenMetaData *gm, void *logctx) | |
558 | { | ||
559 | ✗ | av_log(logctx, AV_LOG_DEBUG, "Green Metadata Info SEI message\n"); | |
560 | ✗ | av_log(logctx, AV_LOG_DEBUG, " green_metadata_type: %d\n", gm->green_metadata_type); | |
561 | |||
562 | ✗ | if (gm->green_metadata_type == 0) { | |
563 | ✗ | av_log(logctx, AV_LOG_DEBUG, " green_metadata_period_type: %d\n", gm->period_type); | |
564 | |||
565 | ✗ | if (gm->period_type == 2) | |
566 | ✗ | av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_seconds: %d\n", gm->num_seconds); | |
567 | ✗ | else if (gm->period_type == 3) | |
568 | ✗ | av_log(logctx, AV_LOG_DEBUG, " green_metadata_num_pictures: %d\n", gm->num_pictures); | |
569 | |||
570 | ✗ | av_log(logctx, AV_LOG_DEBUG, " SEI GREEN Complexity Metrics: %f %f %f %f\n", | |
571 | ✗ | (float)gm->percent_non_zero_macroblocks/255, | |
572 | ✗ | (float)gm->percent_intra_coded_macroblocks/255, | |
573 | ✗ | (float)gm->percent_six_tap_filtering/255, | |
574 | ✗ | (float)gm->percent_alpha_point_deblocking_instance/255); | |
575 | |||
576 | ✗ | } else if (gm->green_metadata_type == 1) { | |
577 | ✗ | av_log(logctx, AV_LOG_DEBUG, " xsd_metric_type: %d\n", gm->xsd_metric_type); | |
578 | |||
579 | ✗ | if (gm->xsd_metric_type == 0) | |
580 | ✗ | av_log(logctx, AV_LOG_DEBUG, " xsd_metric_value: %f\n", | |
581 | ✗ | (float)gm->xsd_metric_value/100); | |
582 | } | ||
583 | ✗ | } | |
584 | |||
585 | 29269 | static int decode_nal_units(H264Context *h, AVBufferRef *buf_ref, | |
586 | const uint8_t *buf, int buf_size) | ||
587 | { | ||
588 | 29269 | AVCodecContext *const avctx = h->avctx; | |
589 | 29269 | int nals_needed = 0; ///< number of NALs that need decoding before the next frame thread starts | |
590 | 29269 | int idr_cleared=0; | |
591 | 29269 | int i, ret = 0; | |
592 | |||
593 | 29269 | h->has_slice = 0; | |
594 | 29269 | h->nal_unit_type= 0; | |
595 | |||
596 |
2/2✓ Branch 0 taken 28513 times.
✓ Branch 1 taken 756 times.
|
29269 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS)) { |
597 | 28513 | h->current_slice = 0; | |
598 |
2/2✓ Branch 0 taken 25126 times.
✓ Branch 1 taken 3387 times.
|
28513 | if (!h->first_field) { |
599 | 25126 | h->cur_pic_ptr = NULL; | |
600 | 25126 | ff_h264_sei_uninit(&h->sei); | |
601 | } | ||
602 | } | ||
603 | |||
604 |
2/2✓ Branch 0 taken 3188 times.
✓ Branch 1 taken 26081 times.
|
29269 | if (h->nal_length_size == 4) { |
605 |
2/6✓ Branch 0 taken 3188 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 3188 times.
✗ Branch 4 not taken.
✗ Branch 5 not taken.
|
3188 | if (buf_size > 8 && AV_RB32(buf) == 1 && AV_RB32(buf+5) > (unsigned)buf_size) { |
606 | ✗ | h->is_avc = 0; | |
607 |
3/6✓ Branch 0 taken 3188 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 3188 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 3188 times.
✗ Branch 5 not taken.
|
3188 | }else if(buf_size > 3 && AV_RB32(buf) > 1 && AV_RB32(buf) <= (unsigned)buf_size) |
608 | 3188 | h->is_avc = 1; | |
609 | } | ||
610 | |||
611 | 29269 | ret = ff_h2645_packet_split(&h->pkt, buf, buf_size, avctx, h->nal_length_size, | |
612 | 29269 | avctx->codec_id, !!h->is_avc * H2645_FLAG_IS_NALFF); | |
613 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 29268 times.
|
29269 | if (ret < 0) { |
614 | 1 | av_log(avctx, AV_LOG_ERROR, | |
615 | "Error splitting the input into NAL units.\n"); | ||
616 | 1 | return ret; | |
617 | } | ||
618 | |||
619 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 29226 times.
|
29268 | if (avctx->active_thread_type & FF_THREAD_FRAME) |
620 | 42 | nals_needed = get_last_needed_nal(h); | |
621 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29268 times.
|
29268 | if (nals_needed < 0) |
622 | ✗ | return nals_needed; | |
623 | |||
624 |
2/2✓ Branch 0 taken 51881 times.
✓ Branch 1 taken 29268 times.
|
81149 | for (i = 0; i < h->pkt.nb_nals; i++) { |
625 | 51881 | H2645NAL *nal = &h->pkt.nals[i]; | |
626 | int max_slice_ctx, err; | ||
627 | |||
628 |
2/2✓ Branch 0 taken 928 times.
✓ Branch 1 taken 50953 times.
|
51881 | if (avctx->skip_frame >= AVDISCARD_NONREF && |
629 |
4/4✓ Branch 0 taken 824 times.
✓ Branch 1 taken 104 times.
✓ Branch 2 taken 504 times.
✓ Branch 3 taken 320 times.
|
928 | nal->ref_idc == 0 && nal->type != H264_NAL_SEI) |
630 | 504 | continue; | |
631 | |||
632 | // FIXME these should stop being context-global variables | ||
633 | 51377 | h->nal_ref_idc = nal->ref_idc; | |
634 | 51377 | h->nal_unit_type = nal->type; | |
635 | |||
636 | 51377 | err = 0; | |
637 |
6/8✓ Branch 0 taken 2277 times.
✓ Branch 1 taken 35561 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2870 times.
✓ Branch 4 taken 1065 times.
✓ Branch 5 taken 6939 times.
✓ Branch 6 taken 2665 times.
✗ Branch 7 not taken.
|
51377 | switch (nal->type) { |
638 | 2277 | case H264_NAL_IDR_SLICE: | |
639 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2277 times.
|
2277 | if ((nal->data[1] & 0xFC) == 0x98) { |
640 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "Invalid inter IDR frame\n"); | |
641 | ✗ | h->next_outputed_poc = INT_MIN; | |
642 | ✗ | ret = -1; | |
643 | ✗ | goto end; | |
644 | } | ||
645 |
2/2✓ Branch 0 taken 1098 times.
✓ Branch 1 taken 1179 times.
|
2277 | if(!idr_cleared) { |
646 | 1098 | idr(h); // FIXME ensure we don't lose some frames if there is reordering | |
647 | } | ||
648 | 2277 | idr_cleared = 1; | |
649 | 2277 | h->has_recovery_point = 1; | |
650 | 37838 | case H264_NAL_SLICE: | |
651 | 37838 | h->has_slice = 1; | |
652 | |||
653 |
2/2✓ Branch 1 taken 167 times.
✓ Branch 2 taken 37671 times.
|
37838 | if ((err = ff_h264_queue_decode_slice(h, nal))) { |
654 | 167 | H264SliceContext *sl = h->slice_ctx + h->nb_slice_ctx_queued; | |
655 | 167 | sl->ref_count[0] = sl->ref_count[1] = 0; | |
656 | 167 | break; | |
657 | } | ||
658 | |||
659 |
2/2✓ Branch 0 taken 28417 times.
✓ Branch 1 taken 9254 times.
|
37671 | if (h->current_slice == 1) { |
660 |
3/4✓ Branch 0 taken 42 times.
✓ Branch 1 taken 28375 times.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
|
28417 | if (avctx->active_thread_type & FF_THREAD_FRAME && |
661 |
2/4✓ Branch 0 taken 42 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 42 times.
✗ Branch 3 not taken.
|
42 | i >= nals_needed && !h->setup_finished && h->cur_pic_ptr) { |
662 | 42 | ff_thread_finish_setup(avctx); | |
663 | 42 | h->setup_finished = 1; | |
664 | } | ||
665 | |||
666 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 28417 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
28417 | if (h->avctx->hwaccel && |
667 | ✗ | (ret = FF_HW_CALL(h->avctx, start_frame, buf_ref, | |
668 | buf, buf_size)) < 0) | ||
669 | ✗ | goto end; | |
670 | } | ||
671 | |||
672 |
1/2✓ Branch 0 taken 37671 times.
✗ Branch 1 not taken.
|
37671 | max_slice_ctx = avctx->hwaccel ? 1 : h->nb_slice_ctx; |
673 |
2/2✓ Branch 0 taken 36841 times.
✓ Branch 1 taken 830 times.
|
37671 | if (h->nb_slice_ctx_queued == max_slice_ctx) { |
674 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 36841 times.
|
36841 | if (h->avctx->hwaccel) { |
675 | ✗ | ret = FF_HW_CALL(avctx, decode_slice, nal->raw_data, nal->raw_size); | |
676 | ✗ | h->nb_slice_ctx_queued = 0; | |
677 | } else | ||
678 | 36841 | ret = ff_h264_execute_decode_slices(h); | |
679 |
3/4✓ Branch 0 taken 2 times.
✓ Branch 1 taken 36839 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 2 times.
|
36841 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
680 | ✗ | goto end; | |
681 | } | ||
682 | 37671 | break; | |
683 | ✗ | case H264_NAL_DPA: | |
684 | case H264_NAL_DPB: | ||
685 | case H264_NAL_DPC: | ||
686 | ✗ | avpriv_request_sample(avctx, "data partitioning"); | |
687 | ✗ | break; | |
688 | 2870 | case H264_NAL_SEI: | |
689 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2870 times.
|
2870 | if (h->setup_finished) { |
690 | ✗ | avpriv_request_sample(avctx, "Late SEI"); | |
691 | ✗ | break; | |
692 | } | ||
693 | 2870 | ret = ff_h264_sei_decode(&h->sei, &nal->gb, &h->ps, avctx); | |
694 |
4/4✓ Branch 0 taken 315 times.
✓ Branch 1 taken 2555 times.
✓ Branch 2 taken 29 times.
✓ Branch 3 taken 286 times.
|
2870 | h->has_recovery_point = h->has_recovery_point || h->sei.recovery_point.recovery_frame_cnt != -1; |
695 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2870 times.
|
2870 | if (avctx->debug & FF_DEBUG_GREEN_MD) |
696 | ✗ | debug_green_metadata(&h->sei.green_metadata, h->avctx); | |
697 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 2863 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
|
2870 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
698 | ✗ | goto end; | |
699 | 2870 | break; | |
700 | 1065 | case H264_NAL_SPS: { | |
701 | 1065 | GetBitContext tmp_gb = nal->gb; | |
702 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1065 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
1065 | if (FF_HW_HAS_CB(avctx, decode_params)) { |
703 | ✗ | ret = FF_HW_CALL(avctx, decode_params, | |
704 | nal->type, nal->raw_data, nal->raw_size); | ||
705 | ✗ | if (ret < 0) | |
706 | ✗ | goto end; | |
707 | } | ||
708 |
2/2✓ Branch 1 taken 1063 times.
✓ Branch 2 taken 2 times.
|
1065 | if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) |
709 | 1065 | break; | |
710 | 2 | av_log(h->avctx, AV_LOG_DEBUG, | |
711 | "SPS decoding failure, trying again with the complete NAL\n"); | ||
712 | 2 | init_get_bits8(&tmp_gb, nal->raw_data + 1, nal->raw_size - 1); | |
713 |
1/2✓ Branch 1 taken 2 times.
✗ Branch 2 not taken.
|
2 | if (ff_h264_decode_seq_parameter_set(&tmp_gb, avctx, &h->ps, 0) >= 0) |
714 | 2 | break; | |
715 | ✗ | ff_h264_decode_seq_parameter_set(&nal->gb, avctx, &h->ps, 1); | |
716 | ✗ | break; | |
717 | } | ||
718 | 6939 | case H264_NAL_PPS: | |
719 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 6939 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
6939 | if (FF_HW_HAS_CB(avctx, decode_params)) { |
720 | ✗ | ret = FF_HW_CALL(avctx, decode_params, | |
721 | nal->type, nal->raw_data, nal->raw_size); | ||
722 | ✗ | if (ret < 0) | |
723 | ✗ | goto end; | |
724 | } | ||
725 | 6939 | ret = ff_h264_decode_picture_parameter_set(&nal->gb, avctx, &h->ps, | |
726 | nal->size_bits); | ||
727 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 6932 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 7 times.
|
6939 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
728 | ✗ | goto end; | |
729 | 6939 | break; | |
730 | 2665 | case H264_NAL_AUD: | |
731 | case H264_NAL_END_SEQUENCE: | ||
732 | case H264_NAL_END_STREAM: | ||
733 | case H264_NAL_FILLER_DATA: | ||
734 | case H264_NAL_SPS_EXT: | ||
735 | case H264_NAL_AUXILIARY_SLICE: | ||
736 | 2665 | break; | |
737 | ✗ | default: | |
738 | ✗ | av_log(avctx, AV_LOG_DEBUG, "Unknown NAL code: %d (%d bits)\n", | |
739 | nal->type, nal->size_bits); | ||
740 | } | ||
741 | |||
742 |
3/4✓ Branch 0 taken 167 times.
✓ Branch 1 taken 51210 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 167 times.
|
51377 | if (err < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) { |
743 | ✗ | av_log(h->avctx, AV_LOG_ERROR, "decode_slice_header error\n"); | |
744 | ✗ | ret = err; | |
745 | ✗ | goto end; | |
746 | } | ||
747 | } | ||
748 | |||
749 | 29268 | ret = ff_h264_execute_decode_slices(h); | |
750 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 29268 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
29268 | if (ret < 0 && (h->avctx->err_recognition & AV_EF_EXPLODE)) |
751 | ✗ | goto end; | |
752 | |||
753 | // set decode_error_flags to allow users to detect concealed decoding errors | ||
754 |
4/6✓ Branch 0 taken 29268 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 2 times.
✓ Branch 3 taken 29266 times.
✓ Branch 4 taken 2 times.
✗ Branch 5 not taken.
|
29268 | if ((ret < 0 || h->er.error_occurred) && h->cur_pic_ptr) { |
755 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (h->cur_pic_ptr->decode_error_flags) { |
756 | /* Frame-threading in use */ | ||
757 | ✗ | atomic_int *decode_error = h->cur_pic_ptr->decode_error_flags; | |
758 | /* Using atomics here is not supposed to provide synchronisation; | ||
759 | * they are merely used to allow to set decode_error from both | ||
760 | * decoding threads in case of coded slices. */ | ||
761 | ✗ | atomic_fetch_or_explicit(decode_error, FF_DECODE_ERROR_DECODE_SLICES, | |
762 | memory_order_relaxed); | ||
763 | } else | ||
764 | 2 | h->cur_pic_ptr->f->decode_error_flags |= FF_DECODE_ERROR_DECODE_SLICES; | |
765 | } | ||
766 | |||
767 | 29268 | ret = 0; | |
768 | 29268 | end: | |
769 | |||
770 | #if CONFIG_ERROR_RESILIENCE | ||
771 | /* | ||
772 | * FIXME: Error handling code does not seem to support interlaced | ||
773 | * when slices span multiple rows | ||
774 | * The ff_er_add_slice calls don't work right for bottom | ||
775 | * fields; they cause massive erroneous error concealing | ||
776 | * Error marking covers both fields (top and bottom). | ||
777 | * This causes a mismatched s->error_count | ||
778 | * and a bad error table. Further, the error count goes to | ||
779 | * INT_MAX when called for bottom field, because mb_y is | ||
780 | * past end by one (callers fault) and resync_mb_y != 0 | ||
781 | * causes problems for the first MB line, too. | ||
782 | */ | ||
783 |
6/6✓ Branch 0 taken 22064 times.
✓ Branch 1 taken 7204 times.
✓ Branch 2 taken 22025 times.
✓ Branch 3 taken 39 times.
✓ Branch 4 taken 21275 times.
✓ Branch 5 taken 750 times.
|
29268 | if (!FIELD_PICTURE(h) && h->current_slice && h->enable_er) { |
784 | |||
785 | 21275 | H264SliceContext *sl = h->slice_ctx; | |
786 |
3/4✓ Branch 0 taken 513 times.
✓ Branch 1 taken 20762 times.
✓ Branch 2 taken 513 times.
✗ Branch 3 not taken.
|
21275 | int use_last_pic = h->last_pic_for_ec.f->buf[0] && !sl->ref_count[0]; |
787 | 21275 | int decode_error_flags = 0; | |
788 | |||
789 | 21275 | ff_h264_set_erpic(&h->er.cur_pic, h->cur_pic_ptr); | |
790 | |||
791 |
2/2✓ Branch 0 taken 513 times.
✓ Branch 1 taken 20762 times.
|
21275 | if (use_last_pic) { |
792 | 513 | ff_h264_set_erpic(&h->er.last_pic, &h->last_pic_for_ec); | |
793 | 513 | sl->ref_list[0][0].parent = &h->last_pic_for_ec; | |
794 | 513 | memcpy(sl->ref_list[0][0].data, h->last_pic_for_ec.f->data, sizeof(sl->ref_list[0][0].data)); | |
795 | 513 | memcpy(sl->ref_list[0][0].linesize, h->last_pic_for_ec.f->linesize, sizeof(sl->ref_list[0][0].linesize)); | |
796 | 513 | sl->ref_list[0][0].reference = h->last_pic_for_ec.reference; | |
797 |
2/2✓ Branch 0 taken 18777 times.
✓ Branch 1 taken 1985 times.
|
20762 | } else if (sl->ref_count[0]) { |
798 | 18777 | ff_h264_set_erpic(&h->er.last_pic, sl->ref_list[0][0].parent); | |
799 | } else | ||
800 | 1985 | ff_h264_set_erpic(&h->er.last_pic, NULL); | |
801 | |||
802 |
2/2✓ Branch 0 taken 18777 times.
✓ Branch 1 taken 2498 times.
|
21275 | if (sl->ref_count[1]) |
803 | 18777 | ff_h264_set_erpic(&h->er.next_pic, sl->ref_list[1][0].parent); | |
804 | |||
805 | 21275 | ff_er_frame_end(&h->er, &decode_error_flags); | |
806 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 21274 times.
|
21275 | if (decode_error_flags) { |
807 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (h->cur_pic_ptr->decode_error_flags) { |
808 | ✗ | atomic_int *decode_error = h->cur_pic_ptr->decode_error_flags; | |
809 | ✗ | atomic_fetch_or_explicit(decode_error, decode_error_flags, | |
810 | memory_order_relaxed); | ||
811 | } else | ||
812 | 1 | h->cur_pic_ptr->f->decode_error_flags |= decode_error_flags; | |
813 | } | ||
814 |
2/2✓ Branch 0 taken 513 times.
✓ Branch 1 taken 20762 times.
|
21275 | if (use_last_pic) |
815 | 513 | memset(&sl->ref_list[0][0], 0, sizeof(sl->ref_list[0][0])); | |
816 | } | ||
817 | #endif /* CONFIG_ERROR_RESILIENCE */ | ||
818 | /* clean up */ | ||
819 |
6/6✓ Branch 0 taken 28840 times.
✓ Branch 1 taken 428 times.
✓ Branch 2 taken 19152 times.
✓ Branch 3 taken 9688 times.
✓ Branch 4 taken 18986 times.
✓ Branch 5 taken 166 times.
|
29268 | if (h->cur_pic_ptr && !h->droppable && h->has_slice) { |
820 | 18986 | ff_thread_report_progress(&h->cur_pic_ptr->tf, INT_MAX, | |
821 | 18986 | h->picture_structure == PICT_BOTTOM_FIELD); | |
822 | } | ||
823 | |||
824 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 29268 times.
|
29268 | return (ret < 0) ? ret : buf_size; |
825 | } | ||
826 | |||
827 | 1 | static int h264_export_enc_params(AVFrame *f, const H264Picture *p) | |
828 | { | ||
829 | AVVideoEncParams *par; | ||
830 | 1 | unsigned int nb_mb = p->mb_height * p->mb_width; | |
831 | unsigned int x, y; | ||
832 | |||
833 | 1 | par = av_video_enc_params_create_side_data(f, AV_VIDEO_ENC_PARAMS_H264, nb_mb); | |
834 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (!par) |
835 | ✗ | return AVERROR(ENOMEM); | |
836 | |||
837 | 1 | par->qp = p->pps->init_qp; | |
838 | |||
839 | 1 | par->delta_qp[1][0] = p->pps->chroma_qp_index_offset[0]; | |
840 | 1 | par->delta_qp[1][1] = p->pps->chroma_qp_index_offset[0]; | |
841 | 1 | par->delta_qp[2][0] = p->pps->chroma_qp_index_offset[1]; | |
842 | 1 | par->delta_qp[2][1] = p->pps->chroma_qp_index_offset[1]; | |
843 | |||
844 |
2/2✓ Branch 0 taken 18 times.
✓ Branch 1 taken 1 times.
|
19 | for (y = 0; y < p->mb_height; y++) |
845 |
2/2✓ Branch 0 taken 396 times.
✓ Branch 1 taken 18 times.
|
414 | for (x = 0; x < p->mb_width; x++) { |
846 | 396 | const unsigned int block_idx = y * p->mb_width + x; | |
847 | 396 | const unsigned int mb_xy = y * p->mb_stride + x; | |
848 | 396 | AVVideoBlockParams *b = av_video_enc_params_block(par, block_idx); | |
849 | |||
850 | 396 | b->src_x = x * 16; | |
851 | 396 | b->src_y = y * 16; | |
852 | 396 | b->w = 16; | |
853 | 396 | b->h = 16; | |
854 | |||
855 | 396 | b->delta_qp = p->qscale_table[mb_xy] - par->qp; | |
856 | } | ||
857 | |||
858 | 1 | return 0; | |
859 | } | ||
860 | |||
861 | 24372 | static int output_frame(H264Context *h, AVFrame *dst, H264Picture *srcp) | |
862 | { | ||
863 | int ret; | ||
864 | |||
865 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
|
24372 | ret = av_frame_ref(dst, srcp->needs_fg ? srcp->f_grain : srcp->f); |
866 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
|
24372 | if (ret < 0) |
867 | ✗ | return ret; | |
868 | |||
869 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
24372 | if (srcp->needs_fg && (ret = av_frame_copy_props(dst, srcp->f)) < 0) |
870 | ✗ | return ret; | |
871 | |||
872 |
2/2✓ Branch 0 taken 42 times.
✓ Branch 1 taken 24330 times.
|
24372 | if (srcp->decode_error_flags) { |
873 | 42 | atomic_int *decode_error = srcp->decode_error_flags; | |
874 | /* The following is not supposed to provide synchronisation at all: | ||
875 | * given that srcp has already finished decoding, decode_error | ||
876 | * has already been set to its final value. */ | ||
877 | 42 | dst->decode_error_flags |= atomic_load_explicit(decode_error, memory_order_relaxed); | |
878 | } | ||
879 | |||
880 | 24372 | av_dict_set(&dst->metadata, "stereo_mode", ff_h264_sei_stereo_mode(&h->sei.common.frame_packing), 0); | |
881 | |||
882 |
2/2✓ Branch 0 taken 34 times.
✓ Branch 1 taken 24338 times.
|
24372 | if (srcp->sei_recovery_frame_cnt == 0) |
883 | 34 | dst->flags |= AV_FRAME_FLAG_KEY; | |
884 | |||
885 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 24371 times.
|
24372 | if (h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_VIDEO_ENC_PARAMS) { |
886 | 1 | ret = h264_export_enc_params(dst, srcp); | |
887 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | if (ret < 0) |
888 | ✗ | goto fail; | |
889 | } | ||
890 | |||
891 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | if (!(h->avctx->export_side_data & AV_CODEC_EXPORT_DATA_FILM_GRAIN)) |
892 | 24372 | av_frame_remove_side_data(dst, AV_FRAME_DATA_FILM_GRAIN_PARAMS); | |
893 | |||
894 | 24372 | return 0; | |
895 | ✗ | fail: | |
896 | ✗ | av_frame_unref(dst); | |
897 | ✗ | return ret; | |
898 | } | ||
899 | |||
900 | ✗ | static int is_avcc_extradata(const uint8_t *buf, int buf_size) | |
901 | { | ||
902 | ✗ | int cnt= buf[5]&0x1f; | |
903 | ✗ | const uint8_t *p= buf+6; | |
904 | ✗ | if (!cnt) | |
905 | ✗ | return 0; | |
906 | ✗ | while(cnt--){ | |
907 | ✗ | int nalsize= AV_RB16(p) + 2; | |
908 | ✗ | if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 7) | |
909 | ✗ | return 0; | |
910 | ✗ | p += nalsize; | |
911 | } | ||
912 | ✗ | cnt = *(p++); | |
913 | ✗ | if(!cnt) | |
914 | ✗ | return 0; | |
915 | ✗ | while(cnt--){ | |
916 | ✗ | int nalsize= AV_RB16(p) + 2; | |
917 | ✗ | if(nalsize > buf_size - (p-buf) || (p[2] & 0x9F) != 8) | |
918 | ✗ | return 0; | |
919 | ✗ | p += nalsize; | |
920 | } | ||
921 | ✗ | return 1; | |
922 | } | ||
923 | |||
924 | 24372 | static int finalize_frame(H264Context *h, AVFrame *dst, H264Picture *out, int *got_frame) | |
925 | { | ||
926 | int ret; | ||
927 | |||
928 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | if (((h->avctx->flags & AV_CODEC_FLAG_OUTPUT_CORRUPT) || |
929 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | (h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) || |
930 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | out->recovered)) { |
931 | |||
932 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
|
24372 | if (h->skip_gray > 0 && |
933 | ✗ | h->non_gray && out->gray && | |
934 | ✗ | !(h->avctx->flags2 & AV_CODEC_FLAG2_SHOW_ALL) | |
935 | ) | ||
936 | ✗ | return 0; | |
937 | |||
938 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | if (!h->avctx->hwaccel && |
939 |
1/2✓ Branch 0 taken 24372 times.
✗ Branch 1 not taken.
|
24372 | (out->field_poc[0] == INT_MAX || |
940 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
|
24372 | out->field_poc[1] == INT_MAX) |
941 | ) { | ||
942 | int p; | ||
943 | ✗ | AVFrame *f = out->f; | |
944 | ✗ | int field = out->field_poc[0] == INT_MAX; | |
945 | uint8_t *dst_data[4]; | ||
946 | int linesizes[4]; | ||
947 | const uint8_t *src_data[4]; | ||
948 | |||
949 | ✗ | av_log(h->avctx, AV_LOG_DEBUG, "Duplicating field %d to fill missing\n", field); | |
950 | |||
951 | ✗ | for (p = 0; p<4; p++) { | |
952 | ✗ | dst_data[p] = f->data[p] + (field^1)*f->linesize[p]; | |
953 | ✗ | src_data[p] = f->data[p] + field *f->linesize[p]; | |
954 | ✗ | linesizes[p] = 2*f->linesize[p]; | |
955 | } | ||
956 | |||
957 | ✗ | av_image_copy(dst_data, linesizes, src_data, linesizes, | |
958 | ✗ | f->format, f->width, f->height>>1); | |
959 | } | ||
960 | |||
961 | 24372 | ret = output_frame(h, dst, out); | |
962 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24372 times.
|
24372 | if (ret < 0) |
963 | ✗ | return ret; | |
964 | |||
965 | 24372 | *got_frame = 1; | |
966 | |||
967 | if (CONFIG_MPEGVIDEODEC) { | ||
968 | 24372 | ff_print_debug_info2(h->avctx, dst, | |
969 | 24372 | out->mb_type, | |
970 | 24372 | out->qscale_table, | |
971 | 24372 | out->motion_val, | |
972 | out->mb_width, out->mb_height, out->mb_stride, 1); | ||
973 | } | ||
974 | } | ||
975 | |||
976 | 24372 | return 0; | |
977 | } | ||
978 | |||
979 | 562 | static int send_next_delayed_frame(H264Context *h, AVFrame *dst_frame, | |
980 | int *got_frame, int buf_index) | ||
981 | { | ||
982 | int ret, i, out_idx; | ||
983 | H264Picture *out; | ||
984 | |||
985 | 562 | h->cur_pic_ptr = NULL; | |
986 | 562 | h->first_field = 0; | |
987 | |||
988 |
2/2✓ Branch 0 taken 280 times.
✓ Branch 1 taken 282 times.
|
1124 | while (h->delayed_pic[0]) { |
989 | 280 | out = h->delayed_pic[0]; | |
990 | 280 | out_idx = 0; | |
991 | 280 | for (i = 1; | |
992 | 1335 | h->delayed_pic[i] && | |
993 |
4/4✓ Branch 0 taken 531 times.
✓ Branch 1 taken 273 times.
✓ Branch 2 taken 524 times.
✓ Branch 3 taken 7 times.
|
804 | !(h->delayed_pic[i]->f->flags & AV_FRAME_FLAG_KEY) && |
994 |
1/2✓ Branch 0 taken 524 times.
✗ Branch 1 not taken.
|
524 | !h->delayed_pic[i]->mmco_reset; |
995 | 524 | i++) | |
996 |
2/2✓ Branch 0 taken 106 times.
✓ Branch 1 taken 418 times.
|
524 | if (h->delayed_pic[i]->poc < out->poc) { |
997 | 106 | out = h->delayed_pic[i]; | |
998 | 106 | out_idx = i; | |
999 | } | ||
1000 | |||
1001 |
2/2✓ Branch 0 taken 762 times.
✓ Branch 1 taken 280 times.
|
1042 | for (i = out_idx; h->delayed_pic[i]; i++) |
1002 | 762 | h->delayed_pic[i] = h->delayed_pic[i + 1]; | |
1003 | |||
1004 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 280 times.
|
280 | if (out) { |
1005 | 280 | h->frame_recovered |= out->recovered; | |
1006 | 280 | out->recovered |= h->frame_recovered & FRAME_RECOVERED_SEI; | |
1007 | |||
1008 | 280 | out->reference &= ~DELAYED_PIC_REF; | |
1009 | 280 | ret = finalize_frame(h, dst_frame, out, got_frame); | |
1010 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 280 times.
|
280 | if (ret < 0) |
1011 | ✗ | return ret; | |
1012 |
1/2✓ Branch 0 taken 280 times.
✗ Branch 1 not taken.
|
280 | if (*got_frame) |
1013 | 280 | break; | |
1014 | } | ||
1015 | } | ||
1016 | |||
1017 | 562 | return buf_index; | |
1018 | } | ||
1019 | |||
1020 | 29831 | static int h264_decode_frame(AVCodecContext *avctx, AVFrame *pict, | |
1021 | int *got_frame, AVPacket *avpkt) | ||
1022 | { | ||
1023 | 29831 | const uint8_t *buf = avpkt->data; | |
1024 | 29831 | int buf_size = avpkt->size; | |
1025 | 29831 | H264Context *h = avctx->priv_data; | |
1026 | int buf_index; | ||
1027 | int ret; | ||
1028 | |||
1029 | 29831 | h->flags = avctx->flags; | |
1030 | 29831 | h->setup_finished = 0; | |
1031 | 29831 | h->nb_slice_ctx_queued = 0; | |
1032 | |||
1033 | 29831 | ff_h264_unref_picture(&h->last_pic_for_ec); | |
1034 | |||
1035 | /* end of stream, output what is still in the buffers */ | ||
1036 |
2/2✓ Branch 0 taken 562 times.
✓ Branch 1 taken 29269 times.
|
29831 | if (buf_size == 0) |
1037 | 562 | return send_next_delayed_frame(h, pict, got_frame, 0); | |
1038 | |||
1039 |
2/2✓ Branch 1 taken 3 times.
✓ Branch 2 taken 29266 times.
|
29269 | if (av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, NULL)) { |
1040 | size_t side_size; | ||
1041 | 3 | uint8_t *side = av_packet_get_side_data(avpkt, AV_PKT_DATA_NEW_EXTRADATA, &side_size); | |
1042 | 3 | ff_h264_decode_extradata(side, side_size, | |
1043 | &h->ps, &h->is_avc, &h->nal_length_size, | ||
1044 | avctx->err_recognition, avctx); | ||
1045 | } | ||
1046 |
4/10✓ Branch 0 taken 3188 times.
✓ Branch 1 taken 26081 times.
✓ Branch 2 taken 3188 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 3188 times.
✗ Branch 6 not taken.
✗ Branch 7 not taken.
✗ Branch 8 not taken.
✗ Branch 9 not taken.
|
29269 | if (h->is_avc && buf_size >= 9 && buf[0]==1 && buf[2]==0 && (buf[4]&0xFC)==0xFC) { |
1047 | ✗ | if (is_avcc_extradata(buf, buf_size)) | |
1048 | ✗ | return ff_h264_decode_extradata(buf, buf_size, | |
1049 | &h->ps, &h->is_avc, &h->nal_length_size, | ||
1050 | avctx->err_recognition, avctx); | ||
1051 | } | ||
1052 | |||
1053 | 29269 | buf_index = decode_nal_units(h, avpkt->buf, buf, buf_size); | |
1054 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 29268 times.
|
29269 | if (buf_index < 0) |
1055 | 1 | return AVERROR_INVALIDDATA; | |
1056 | |||
1057 |
3/4✓ Branch 0 taken 428 times.
✓ Branch 1 taken 28840 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 428 times.
|
29268 | if (!h->cur_pic_ptr && h->nal_unit_type == H264_NAL_END_SEQUENCE) { |
1058 | ✗ | av_assert0(buf_index <= buf_size); | |
1059 | ✗ | return send_next_delayed_frame(h, pict, got_frame, buf_index); | |
1060 | } | ||
1061 | |||
1062 |
6/6✓ Branch 0 taken 28512 times.
✓ Branch 1 taken 756 times.
✓ Branch 2 taken 28086 times.
✓ Branch 3 taken 426 times.
✓ Branch 4 taken 164 times.
✓ Branch 5 taken 27922 times.
|
29268 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) && (!h->cur_pic_ptr || !h->has_slice)) { |
1063 |
3/4✓ Branch 0 taken 390 times.
✓ Branch 1 taken 200 times.
✓ Branch 2 taken 390 times.
✗ Branch 3 not taken.
|
590 | if (avctx->skip_frame >= AVDISCARD_NONREF || |
1064 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 390 times.
|
390 | buf_size >= 4 && !memcmp("Q264", buf, 4)) |
1065 | 200 | return buf_size; | |
1066 | 390 | av_log(avctx, AV_LOG_ERROR, "no frame!\n"); | |
1067 | 390 | return AVERROR_INVALIDDATA; | |
1068 | } | ||
1069 | |||
1070 |
2/2✓ Branch 0 taken 756 times.
✓ Branch 1 taken 27922 times.
|
28678 | if (!(avctx->flags2 & AV_CODEC_FLAG2_CHUNKS) || |
1071 |
4/4✓ Branch 0 taken 302 times.
✓ Branch 1 taken 454 times.
✓ Branch 2 taken 300 times.
✓ Branch 3 taken 2 times.
|
756 | (h->mb_y >= h->mb_height && h->mb_height)) { |
1072 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 28222 times.
|
28222 | if ((ret = ff_h264_field_end(h, &h->slice_ctx[0], 0)) < 0) |
1073 | ✗ | return ret; | |
1074 | |||
1075 | /* Wait for second field. */ | ||
1076 |
2/2✓ Branch 0 taken 24092 times.
✓ Branch 1 taken 4130 times.
|
28222 | if (h->next_output_pic) { |
1077 | 24092 | ret = finalize_frame(h, pict, h->next_output_pic, got_frame); | |
1078 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 24092 times.
|
24092 | if (ret < 0) |
1079 | ✗ | return ret; | |
1080 | } | ||
1081 | } | ||
1082 | |||
1083 |
3/4✓ Branch 0 taken 4586 times.
✓ Branch 1 taken 24092 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 4586 times.
|
28678 | av_assert0(pict->buf[0] || !*got_frame); |
1084 | |||
1085 | 28678 | ff_h264_unref_picture(&h->last_pic_for_ec); | |
1086 | |||
1087 | 28678 | return buf_size; | |
1088 | } | ||
1089 | |||
1090 | #define OFFSET(x) offsetof(H264Context, x) | ||
1091 | #define VD AV_OPT_FLAG_VIDEO_PARAM | AV_OPT_FLAG_DECODING_PARAM | ||
1092 | #define VDX VD | AV_OPT_FLAG_EXPORT | ||
1093 | static const AVOption h264_options[] = { | ||
1094 | { "is_avc", "is avc", OFFSET(is_avc), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VDX }, | ||
1095 | { "nal_length_size", "nal_length_size", OFFSET(nal_length_size), AV_OPT_TYPE_INT, {.i64 = 0}, 0, 4, VDX }, | ||
1096 | { "enable_er", "Enable error resilience on damaged frames (unsafe)", OFFSET(enable_er), AV_OPT_TYPE_BOOL, { .i64 = -1 }, -1, 1, VD }, | ||
1097 | { "x264_build", "Assume this x264 version if no x264 version found in any SEI", OFFSET(x264_build), AV_OPT_TYPE_INT, {.i64 = -1}, -1, INT_MAX, VD }, | ||
1098 | { "skip_gray", "Do not return gray gap frames", OFFSET(skip_gray), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, VD }, | ||
1099 | { "noref_gray", "Avoid using gray gap frames as references", OFFSET(noref_gray), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, VD }, | ||
1100 | { NULL }, | ||
1101 | }; | ||
1102 | |||
1103 | static const AVClass h264_class = { | ||
1104 | .class_name = "H264 Decoder", | ||
1105 | .item_name = av_default_item_name, | ||
1106 | .option = h264_options, | ||
1107 | .version = LIBAVUTIL_VERSION_INT, | ||
1108 | }; | ||
1109 | |||
1110 | const FFCodec ff_h264_decoder = { | ||
1111 | .p.name = "h264", | ||
1112 | CODEC_LONG_NAME("H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"), | ||
1113 | .p.type = AVMEDIA_TYPE_VIDEO, | ||
1114 | .p.id = AV_CODEC_ID_H264, | ||
1115 | .priv_data_size = sizeof(H264Context), | ||
1116 | .init = h264_decode_init, | ||
1117 | .close = h264_decode_end, | ||
1118 | FF_CODEC_DECODE_CB(h264_decode_frame), | ||
1119 | .p.capabilities = AV_CODEC_CAP_DR1 | | ||
1120 | AV_CODEC_CAP_DELAY | AV_CODEC_CAP_SLICE_THREADS | | ||
1121 | AV_CODEC_CAP_FRAME_THREADS, | ||
1122 | .hw_configs = (const AVCodecHWConfigInternal *const []) { | ||
1123 | #if CONFIG_H264_DXVA2_HWACCEL | ||
1124 | HWACCEL_DXVA2(h264), | ||
1125 | #endif | ||
1126 | #if CONFIG_H264_D3D11VA_HWACCEL | ||
1127 | HWACCEL_D3D11VA(h264), | ||
1128 | #endif | ||
1129 | #if CONFIG_H264_D3D11VA2_HWACCEL | ||
1130 | HWACCEL_D3D11VA2(h264), | ||
1131 | #endif | ||
1132 | #if CONFIG_H264_D3D12VA_HWACCEL | ||
1133 | HWACCEL_D3D12VA(h264), | ||
1134 | #endif | ||
1135 | #if CONFIG_H264_NVDEC_HWACCEL | ||
1136 | HWACCEL_NVDEC(h264), | ||
1137 | #endif | ||
1138 | #if CONFIG_H264_VAAPI_HWACCEL | ||
1139 | HWACCEL_VAAPI(h264), | ||
1140 | #endif | ||
1141 | #if CONFIG_H264_VDPAU_HWACCEL | ||
1142 | HWACCEL_VDPAU(h264), | ||
1143 | #endif | ||
1144 | #if CONFIG_H264_VIDEOTOOLBOX_HWACCEL | ||
1145 | HWACCEL_VIDEOTOOLBOX(h264), | ||
1146 | #endif | ||
1147 | #if CONFIG_H264_VULKAN_HWACCEL | ||
1148 | HWACCEL_VULKAN(h264), | ||
1149 | #endif | ||
1150 | NULL | ||
1151 | }, | ||
1152 | .caps_internal = FF_CODEC_CAP_EXPORTS_CROPPING | | ||
1153 | FF_CODEC_CAP_INIT_CLEANUP, | ||
1154 | .flush = h264_decode_flush, | ||
1155 | UPDATE_THREAD_CONTEXT(ff_h264_update_thread_context), | ||
1156 | UPDATE_THREAD_CONTEXT_FOR_USER(ff_h264_update_thread_context_for_user), | ||
1157 | .p.profiles = NULL_IF_CONFIG_SMALL(ff_h264_profiles), | ||
1158 | .p.priv_class = &h264_class, | ||
1159 | }; | ||
1160 |