Line | Branch | Exec | Source |
---|---|---|---|
1 | /* | ||
2 | * generic decoding-related code | ||
3 | * | ||
4 | * This file is part of FFmpeg. | ||
5 | * | ||
6 | * FFmpeg is free software; you can redistribute it and/or | ||
7 | * modify it under the terms of the GNU Lesser General Public | ||
8 | * License as published by the Free Software Foundation; either | ||
9 | * version 2.1 of the License, or (at your option) any later version. | ||
10 | * | ||
11 | * FFmpeg is distributed in the hope that it will be useful, | ||
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of | ||
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | ||
14 | * Lesser General Public License for more details. | ||
15 | * | ||
16 | * You should have received a copy of the GNU Lesser General Public | ||
17 | * License along with FFmpeg; if not, write to the Free Software | ||
18 | * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA | ||
19 | */ | ||
20 | |||
21 | #include <stdint.h> | ||
22 | #include <string.h> | ||
23 | |||
24 | #include "config.h" | ||
25 | |||
26 | #if CONFIG_ICONV | ||
27 | # include <iconv.h> | ||
28 | #endif | ||
29 | |||
30 | #include "libavutil/avassert.h" | ||
31 | #include "libavutil/avstring.h" | ||
32 | #include "libavutil/bprint.h" | ||
33 | #include "libavutil/channel_layout.h" | ||
34 | #include "libavutil/common.h" | ||
35 | #include "libavutil/emms.h" | ||
36 | #include "libavutil/fifo.h" | ||
37 | #include "libavutil/frame.h" | ||
38 | #include "libavutil/hwcontext.h" | ||
39 | #include "libavutil/imgutils.h" | ||
40 | #include "libavutil/internal.h" | ||
41 | #include "libavutil/intmath.h" | ||
42 | #include "libavutil/opt.h" | ||
43 | |||
44 | #include "avcodec.h" | ||
45 | #include "avcodec_internal.h" | ||
46 | #include "bytestream.h" | ||
47 | #include "bsf.h" | ||
48 | #include "codec_internal.h" | ||
49 | #include "decode.h" | ||
50 | #include "hwaccel_internal.h" | ||
51 | #include "hwconfig.h" | ||
52 | #include "internal.h" | ||
53 | #include "packet_internal.h" | ||
54 | #include "thread.h" | ||
55 | |||
56 | typedef struct DecodeContext { | ||
57 | AVCodecInternal avci; | ||
58 | |||
59 | /* to prevent infinite loop on errors when draining */ | ||
60 | int nb_draining_errors; | ||
61 | |||
62 | /** | ||
63 | * The caller has submitted a NULL packet on input. | ||
64 | */ | ||
65 | int draining_started; | ||
66 | } DecodeContext; | ||
67 | |||
68 | 1202492 | static DecodeContext *decode_ctx(AVCodecInternal *avci) | |
69 | { | ||
70 | 1202492 | return (DecodeContext *)avci; | |
71 | } | ||
72 | |||
73 | 397127 | static int apply_param_change(AVCodecContext *avctx, const AVPacket *avpkt) | |
74 | { | ||
75 | int ret; | ||
76 | size_t size; | ||
77 | const uint8_t *data; | ||
78 | uint32_t flags; | ||
79 | int64_t val; | ||
80 | |||
81 | 397127 | data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size); | |
82 |
2/2✓ Branch 0 taken 397125 times.
✓ Branch 1 taken 2 times.
|
397127 | if (!data) |
83 | 397125 | return 0; | |
84 | |||
85 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) { |
86 | ✗ | av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter " | |
87 | "changes, but PARAM_CHANGE side data was sent to it.\n"); | ||
88 | ✗ | ret = AVERROR(EINVAL); | |
89 | ✗ | goto fail2; | |
90 | } | ||
91 | |||
92 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (size < 4) |
93 | ✗ | goto fail; | |
94 | |||
95 | 2 | flags = bytestream_get_le32(&data); | |
96 | 2 | size -= 4; | |
97 | |||
98 | #if FF_API_OLD_CHANNEL_LAYOUT | ||
99 | FF_DISABLE_DEPRECATION_WARNINGS | ||
100 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) { |
101 | ✗ | if (size < 4) | |
102 | ✗ | goto fail; | |
103 | ✗ | val = bytestream_get_le32(&data); | |
104 | ✗ | if (val <= 0 || val > INT_MAX) { | |
105 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid channel count"); | |
106 | ✗ | ret = AVERROR_INVALIDDATA; | |
107 | ✗ | goto fail2; | |
108 | } | ||
109 | ✗ | av_channel_layout_uninit(&avctx->ch_layout); | |
110 | ✗ | avctx->ch_layout.nb_channels = val; | |
111 | ✗ | avctx->ch_layout.order = AV_CHANNEL_ORDER_UNSPEC; | |
112 | ✗ | size -= 4; | |
113 | } | ||
114 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) { |
115 | ✗ | if (size < 8) | |
116 | ✗ | goto fail; | |
117 | ✗ | av_channel_layout_uninit(&avctx->ch_layout); | |
118 | ✗ | ret = av_channel_layout_from_mask(&avctx->ch_layout, bytestream_get_le64(&data)); | |
119 | ✗ | if (ret < 0) | |
120 | ✗ | goto fail2; | |
121 | ✗ | size -= 8; | |
122 | } | ||
123 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (flags & (AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT | |
124 | AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT)) { | ||
125 | ✗ | avctx->channels = avctx->ch_layout.nb_channels; | |
126 | ✗ | avctx->channel_layout = (avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) ? | |
127 | ✗ | avctx->ch_layout.u.mask : 0; | |
128 | } | ||
129 | FF_ENABLE_DEPRECATION_WARNINGS | ||
130 | #endif | ||
131 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) { |
132 | ✗ | if (size < 4) | |
133 | ✗ | goto fail; | |
134 | ✗ | val = bytestream_get_le32(&data); | |
135 | ✗ | if (val <= 0 || val > INT_MAX) { | |
136 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid sample rate"); | |
137 | ✗ | ret = AVERROR_INVALIDDATA; | |
138 | ✗ | goto fail2; | |
139 | } | ||
140 | ✗ | avctx->sample_rate = val; | |
141 | ✗ | size -= 4; | |
142 | } | ||
143 |
1/2✓ Branch 0 taken 2 times.
✗ Branch 1 not taken.
|
2 | if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) { |
144 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (size < 8) |
145 | ✗ | goto fail; | |
146 | 2 | avctx->width = bytestream_get_le32(&data); | |
147 | 2 | avctx->height = bytestream_get_le32(&data); | |
148 | 2 | size -= 8; | |
149 | 2 | ret = ff_set_dimensions(avctx, avctx->width, avctx->height); | |
150 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2 times.
|
2 | if (ret < 0) |
151 | ✗ | goto fail2; | |
152 | } | ||
153 | |||
154 | 2 | return 0; | |
155 | ✗ | fail: | |
156 | ✗ | av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n"); | |
157 | ✗ | ret = AVERROR_INVALIDDATA; | |
158 | ✗ | fail2: | |
159 | ✗ | if (ret < 0) { | |
160 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n"); | |
161 | ✗ | if (avctx->err_recognition & AV_EF_EXPLODE) | |
162 | ✗ | return ret; | |
163 | } | ||
164 | ✗ | return 0; | |
165 | } | ||
166 | |||
167 | 397127 | static int extract_packet_props(AVCodecInternal *avci, const AVPacket *pkt) | |
168 | { | ||
169 | 397127 | int ret = 0; | |
170 | |||
171 | 397127 | av_packet_unref(avci->last_pkt_props); | |
172 |
1/2✓ Branch 0 taken 397127 times.
✗ Branch 1 not taken.
|
397127 | if (pkt) { |
173 | 397127 | ret = av_packet_copy_props(avci->last_pkt_props, pkt); | |
174 | #if FF_API_FRAME_PKT | ||
175 |
1/2✓ Branch 0 taken 397127 times.
✗ Branch 1 not taken.
|
397127 | if (!ret) |
176 | 397127 | avci->last_pkt_props->stream_index = pkt->size; // Needed for ff_decode_frame_props(). | |
177 | #endif | ||
178 | } | ||
179 | 397127 | return ret; | |
180 | } | ||
181 | |||
182 | 14217 | static int decode_bsfs_init(AVCodecContext *avctx) | |
183 | { | ||
184 | 14217 | AVCodecInternal *avci = avctx->internal; | |
185 | 14217 | const FFCodec *const codec = ffcodec(avctx->codec); | |
186 | int ret; | ||
187 | |||
188 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (avci->bsf) |
189 | ✗ | return 0; | |
190 | |||
191 | 14217 | ret = av_bsf_list_parse_str(codec->bsfs, &avci->bsf); | |
192 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (ret < 0) { |
193 | ✗ | av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", codec->bsfs, av_err2str(ret)); | |
194 | ✗ | if (ret != AVERROR(ENOMEM)) | |
195 | ✗ | ret = AVERROR_BUG; | |
196 | ✗ | goto fail; | |
197 | } | ||
198 | |||
199 | /* We do not currently have an API for passing the input timebase into decoders, | ||
200 | * but no filters used here should actually need it. | ||
201 | * So we make up some plausible-looking number (the MPEG 90kHz timebase) */ | ||
202 | 14217 | avci->bsf->time_base_in = (AVRational){ 1, 90000 }; | |
203 | 14217 | ret = avcodec_parameters_from_context(avci->bsf->par_in, avctx); | |
204 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (ret < 0) |
205 | ✗ | goto fail; | |
206 | |||
207 | 14217 | ret = av_bsf_init(avci->bsf); | |
208 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (ret < 0) |
209 | ✗ | goto fail; | |
210 | |||
211 | 14217 | return 0; | |
212 | ✗ | fail: | |
213 | ✗ | av_bsf_free(&avci->bsf); | |
214 | ✗ | return ret; | |
215 | } | ||
216 | |||
217 | 1202348 | static int decode_get_packet(AVCodecContext *avctx, AVPacket *pkt) | |
218 | { | ||
219 | 1202348 | AVCodecInternal *avci = avctx->internal; | |
220 | int ret; | ||
221 | |||
222 | 1202348 | ret = av_bsf_receive_packet(avci->bsf, pkt); | |
223 |
2/2✓ Branch 0 taken 6435 times.
✓ Branch 1 taken 1195913 times.
|
1202348 | if (ret == AVERROR_EOF) |
224 | 6435 | avci->draining = 1; | |
225 |
2/2✓ Branch 0 taken 805221 times.
✓ Branch 1 taken 397127 times.
|
1202348 | if (ret < 0) |
226 | 805221 | return ret; | |
227 | |||
228 |
1/2✓ Branch 1 taken 397127 times.
✗ Branch 2 not taken.
|
397127 | if (!(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) { |
229 | 397127 | ret = extract_packet_props(avctx->internal, pkt); | |
230 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 397127 times.
|
397127 | if (ret < 0) |
231 | ✗ | goto finish; | |
232 | } | ||
233 | |||
234 | 397127 | ret = apply_param_change(avctx, pkt); | |
235 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 397127 times.
|
397127 | if (ret < 0) |
236 | ✗ | goto finish; | |
237 | |||
238 | 397127 | return 0; | |
239 | ✗ | finish: | |
240 | ✗ | av_packet_unref(pkt); | |
241 | ✗ | return ret; | |
242 | } | ||
243 | |||
244 | 798867 | int ff_decode_get_packet(AVCodecContext *avctx, AVPacket *pkt) | |
245 | { | ||
246 | 798867 | AVCodecInternal *avci = avctx->internal; | |
247 | 798867 | DecodeContext *dc = decode_ctx(avci); | |
248 | |||
249 |
2/2✓ Branch 0 taken 798850 times.
✓ Branch 1 taken 17 times.
|
798867 | if (avci->draining) |
250 | 17 | return AVERROR_EOF; | |
251 | |||
252 | 403498 | while (1) { | |
253 | 1202348 | int ret = decode_get_packet(avctx, pkt); | |
254 |
2/2✓ Branch 0 taken 798786 times.
✓ Branch 1 taken 403562 times.
|
1202348 | if (ret == AVERROR(EAGAIN) && |
255 |
5/6✓ Branch 0 taken 401723 times.
✓ Branch 1 taken 397063 times.
✓ Branch 2 taken 401723 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 6435 times.
✓ Branch 5 taken 395288 times.
|
798786 | (!AVPACKET_IS_EMPTY(avci->buffer_pkt) || dc->draining_started)) { |
256 | 403498 | ret = av_bsf_send_packet(avci->bsf, avci->buffer_pkt); | |
257 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 403498 times.
|
403498 | if (ret < 0) { |
258 | ✗ | av_packet_unref(avci->buffer_pkt); | |
259 | ✗ | return ret; | |
260 | } | ||
261 | |||
262 | 403498 | continue; | |
263 | } | ||
264 | |||
265 | 798850 | return ret; | |
266 | } | ||
267 | } | ||
268 | |||
269 | /** | ||
270 | * Attempt to guess proper monotonic timestamps for decoded video frames | ||
271 | * which might have incorrect times. Input timestamps may wrap around, in | ||
272 | * which case the output will as well. | ||
273 | * | ||
274 | * @param pts the pts field of the decoded AVPacket, as passed through | ||
275 | * AVFrame.pts | ||
276 | * @param dts the dts field of the decoded AVPacket | ||
277 | * @return one of the input values, may be AV_NOPTS_VALUE | ||
278 | */ | ||
279 | 415618 | static int64_t guess_correct_pts(AVCodecContext *ctx, | |
280 | int64_t reordered_pts, int64_t dts) | ||
281 | { | ||
282 | 415618 | int64_t pts = AV_NOPTS_VALUE; | |
283 | |||
284 |
2/2✓ Branch 0 taken 351345 times.
✓ Branch 1 taken 64273 times.
|
415618 | if (dts != AV_NOPTS_VALUE) { |
285 | 351345 | ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts; | |
286 | 351345 | ctx->pts_correction_last_dts = dts; | |
287 |
2/2✓ Branch 0 taken 360 times.
✓ Branch 1 taken 63913 times.
|
64273 | } else if (reordered_pts != AV_NOPTS_VALUE) |
288 | 360 | ctx->pts_correction_last_dts = reordered_pts; | |
289 | |||
290 |
2/2✓ Branch 0 taken 349772 times.
✓ Branch 1 taken 65846 times.
|
415618 | if (reordered_pts != AV_NOPTS_VALUE) { |
291 | 349772 | ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts; | |
292 | 349772 | ctx->pts_correction_last_pts = reordered_pts; | |
293 |
2/2✓ Branch 0 taken 1933 times.
✓ Branch 1 taken 63913 times.
|
65846 | } else if(dts != AV_NOPTS_VALUE) |
294 | 1933 | ctx->pts_correction_last_pts = dts; | |
295 | |||
296 |
4/4✓ Branch 0 taken 566 times.
✓ Branch 1 taken 415052 times.
✓ Branch 2 taken 10 times.
✓ Branch 3 taken 556 times.
|
415618 | if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE) |
297 |
2/2✓ Branch 0 taken 349216 times.
✓ Branch 1 taken 65846 times.
|
415062 | && reordered_pts != AV_NOPTS_VALUE) |
298 | 349216 | pts = reordered_pts; | |
299 | else | ||
300 | 66402 | pts = dts; | |
301 | |||
302 | 415618 | return pts; | |
303 | } | ||
304 | |||
305 | 303387 | static int discard_samples(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples) | |
306 | { | ||
307 | 303387 | AVCodecInternal *avci = avctx->internal; | |
308 | AVFrameSideData *side; | ||
309 | 303387 | uint32_t discard_padding = 0; | |
310 | 303387 | uint8_t skip_reason = 0; | |
311 | 303387 | uint8_t discard_reason = 0; | |
312 | |||
313 | 303387 | side = av_frame_get_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES); | |
314 |
3/4✓ Branch 0 taken 112 times.
✓ Branch 1 taken 303275 times.
✓ Branch 2 taken 112 times.
✗ Branch 3 not taken.
|
303387 | if (side && side->size >= 10) { |
315 | 112 | avci->skip_samples = AV_RL32(side->data); | |
316 | 112 | avci->skip_samples = FFMAX(0, avci->skip_samples); | |
317 | 112 | discard_padding = AV_RL32(side->data + 4); | |
318 | 112 | av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n", | |
319 | avci->skip_samples, (int)discard_padding); | ||
320 | 112 | skip_reason = AV_RL8(side->data + 8); | |
321 | 112 | discard_reason = AV_RL8(side->data + 9); | |
322 | } | ||
323 | |||
324 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 303387 times.
|
303387 | if ((avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) { |
325 | ✗ | if (!side && (avci->skip_samples || discard_padding)) | |
326 | ✗ | side = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10); | |
327 | ✗ | if (side && (avci->skip_samples || discard_padding)) { | |
328 | ✗ | AV_WL32(side->data, avci->skip_samples); | |
329 | ✗ | AV_WL32(side->data + 4, discard_padding); | |
330 | ✗ | AV_WL8(side->data + 8, skip_reason); | |
331 | ✗ | AV_WL8(side->data + 9, discard_reason); | |
332 | ✗ | avci->skip_samples = 0; | |
333 | } | ||
334 | ✗ | return 0; | |
335 | } | ||
336 | 303387 | av_frame_remove_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES); | |
337 | |||
338 |
2/2✓ Branch 0 taken 20 times.
✓ Branch 1 taken 303367 times.
|
303387 | if ((frame->flags & AV_FRAME_FLAG_DISCARD)) { |
339 | 20 | avci->skip_samples = FFMAX(0, avci->skip_samples - frame->nb_samples); | |
340 | 20 | *discarded_samples += frame->nb_samples; | |
341 | 20 | return AVERROR(EAGAIN); | |
342 | } | ||
343 | |||
344 |
2/2✓ Branch 0 taken 213 times.
✓ Branch 1 taken 303154 times.
|
303367 | if (avci->skip_samples > 0) { |
345 |
2/2✓ Branch 0 taken 150 times.
✓ Branch 1 taken 63 times.
|
213 | if (frame->nb_samples <= avci->skip_samples){ |
346 | 150 | *discarded_samples += frame->nb_samples; | |
347 | 150 | avci->skip_samples -= frame->nb_samples; | |
348 | 150 | av_log(avctx, AV_LOG_DEBUG, "skip whole frame, skip left: %d\n", | |
349 | avci->skip_samples); | ||
350 | 150 | return AVERROR(EAGAIN); | |
351 | } else { | ||
352 | 63 | av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples, | |
353 | 63 | frame->nb_samples - avci->skip_samples, avctx->ch_layout.nb_channels, frame->format); | |
354 |
2/4✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 63 times.
✗ Branch 3 not taken.
|
126 | if (avctx->pkt_timebase.num && avctx->sample_rate) { |
355 | 63 | int64_t diff_ts = av_rescale_q(avci->skip_samples, | |
356 | 63 | (AVRational){1, avctx->sample_rate}, | |
357 | avctx->pkt_timebase); | ||
358 |
1/2✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
|
63 | if (frame->pts != AV_NOPTS_VALUE) |
359 | 63 | frame->pts += diff_ts; | |
360 |
1/2✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
|
63 | if (frame->pkt_dts != AV_NOPTS_VALUE) |
361 | 63 | frame->pkt_dts += diff_ts; | |
362 |
1/2✓ Branch 0 taken 63 times.
✗ Branch 1 not taken.
|
63 | if (frame->duration >= diff_ts) |
363 | 63 | frame->duration -= diff_ts; | |
364 | } else | ||
365 | ✗ | av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n"); | |
366 | |||
367 | 63 | av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n", | |
368 | avci->skip_samples, frame->nb_samples); | ||
369 | 63 | *discarded_samples += avci->skip_samples; | |
370 | 63 | frame->nb_samples -= avci->skip_samples; | |
371 | 63 | avci->skip_samples = 0; | |
372 | } | ||
373 | } | ||
374 | |||
375 |
3/4✓ Branch 0 taken 7 times.
✓ Branch 1 taken 303210 times.
✓ Branch 2 taken 7 times.
✗ Branch 3 not taken.
|
303217 | if (discard_padding > 0 && discard_padding <= frame->nb_samples) { |
376 |
2/2✓ Branch 0 taken 2 times.
✓ Branch 1 taken 5 times.
|
7 | if (discard_padding == frame->nb_samples) { |
377 | 2 | *discarded_samples += frame->nb_samples; | |
378 | 2 | return AVERROR(EAGAIN); | |
379 | } else { | ||
380 |
2/4✓ Branch 0 taken 5 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 5 times.
✗ Branch 3 not taken.
|
5 | if (avctx->pkt_timebase.num && avctx->sample_rate) { |
381 | 5 | int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding, | |
382 | 5 | (AVRational){1, avctx->sample_rate}, | |
383 | avctx->pkt_timebase); | ||
384 | 5 | frame->duration = diff_ts; | |
385 | } else | ||
386 | ✗ | av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n"); | |
387 | |||
388 | 5 | av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n", | |
389 | (int)discard_padding, frame->nb_samples); | ||
390 | 5 | frame->nb_samples -= discard_padding; | |
391 | } | ||
392 | } | ||
393 | |||
394 | 303215 | return 0; | |
395 | } | ||
396 | |||
397 | /* | ||
398 | * The core of the receive_frame_wrapper for the decoders implementing | ||
399 | * the simple API. Certain decoders might consume partial packets without | ||
400 | * returning any output, so this function needs to be called in a loop until it | ||
401 | * returns EAGAIN. | ||
402 | **/ | ||
403 | 826542 | static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples) | |
404 | { | ||
405 | 826542 | AVCodecInternal *avci = avctx->internal; | |
406 | 826542 | AVPacket *const pkt = avci->in_pkt; | |
407 | 826542 | const FFCodec *const codec = ffcodec(avctx->codec); | |
408 | int got_frame, consumed; | ||
409 | int ret; | ||
410 | |||
411 |
4/4✓ Branch 0 taken 797676 times.
✓ Branch 1 taken 28866 times.
✓ Branch 2 taken 796188 times.
✓ Branch 3 taken 1488 times.
|
826542 | if (!pkt->data && !avci->draining) { |
412 | 796188 | av_packet_unref(pkt); | |
413 | 796188 | ret = ff_decode_get_packet(avctx, pkt); | |
414 |
4/4✓ Branch 0 taken 400569 times.
✓ Branch 1 taken 395619 times.
✓ Branch 2 taken 394158 times.
✓ Branch 3 taken 6411 times.
|
796188 | if (ret < 0 && ret != AVERROR_EOF) |
415 | 394158 | return ret; | |
416 | } | ||
417 | |||
418 | // Some codecs (at least wma lossless) will crash when feeding drain packets | ||
419 | // after EOF was signaled. | ||
420 |
2/2✓ Branch 0 taken 707 times.
✓ Branch 1 taken 431677 times.
|
432384 | if (avci->draining_done) |
421 | 707 | return AVERROR_EOF; | |
422 | |||
423 |
2/2✓ Branch 0 taken 7192 times.
✓ Branch 1 taken 424485 times.
|
431677 | if (!pkt->data && |
424 |
2/2✓ Branch 0 taken 5745 times.
✓ Branch 1 taken 1447 times.
|
7192 | !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY || |
425 |
2/2✓ Branch 0 taken 5704 times.
✓ Branch 1 taken 41 times.
|
5745 | avctx->active_thread_type & FF_THREAD_FRAME)) |
426 | 5704 | return AVERROR_EOF; | |
427 | |||
428 | 425973 | got_frame = 0; | |
429 | |||
430 |
2/2✓ Branch 0 taken 611 times.
✓ Branch 1 taken 425362 times.
|
425973 | if (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME) { |
431 | 611 | consumed = ff_thread_decode_frame(avctx, frame, &got_frame, pkt); | |
432 | } else { | ||
433 | 425362 | consumed = codec->cb.decode(avctx, frame, &got_frame, pkt); | |
434 | |||
435 |
1/2✓ Branch 0 taken 425362 times.
✗ Branch 1 not taken.
|
425362 | if (!(codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS)) |
436 | 425362 | frame->pkt_dts = pkt->dts; | |
437 |
2/2✓ Branch 0 taken 122846 times.
✓ Branch 1 taken 302516 times.
|
425362 | if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) { |
438 | #if FF_API_FRAME_PKT | ||
439 | FF_DISABLE_DEPRECATION_WARNINGS | ||
440 |
2/2✓ Branch 0 taken 90118 times.
✓ Branch 1 taken 32728 times.
|
122846 | if(!avctx->has_b_frames) |
441 | 90118 | frame->pkt_pos = pkt->pos; | |
442 | FF_ENABLE_DEPRECATION_WARNINGS | ||
443 | #endif | ||
444 | } | ||
445 | } | ||
446 | 425973 | emms_c(); | |
447 | |||
448 |
2/2✓ Branch 0 taken 122985 times.
✓ Branch 1 taken 302988 times.
|
425973 | if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) { |
449 |
2/2✓ Branch 0 taken 180 times.
✓ Branch 1 taken 112390 times.
|
235555 | ret = (!got_frame || frame->flags & AV_FRAME_FLAG_DISCARD) |
450 | ? AVERROR(EAGAIN) | ||
451 |
2/2✓ Branch 0 taken 112570 times.
✓ Branch 1 taken 10415 times.
|
235555 | : 0; |
452 |
1/2✓ Branch 0 taken 302988 times.
✗ Branch 1 not taken.
|
302988 | } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) { |
453 | 302988 | ret = !got_frame ? AVERROR(EAGAIN) | |
454 |
2/2✓ Branch 0 taken 301578 times.
✓ Branch 1 taken 1410 times.
|
302988 | : discard_samples(avctx, frame, discarded_samples); |
455 | } | ||
456 | |||
457 |
2/2✓ Branch 0 taken 12177 times.
✓ Branch 1 taken 413796 times.
|
425973 | if (ret == AVERROR(EAGAIN)) |
458 | 12177 | av_frame_unref(frame); | |
459 | |||
460 | // FF_CODEC_CB_TYPE_DECODE decoders must not return AVERROR EAGAIN | ||
461 | // code later will add AVERROR(EAGAIN) to a pointer | ||
462 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 425973 times.
|
425973 | av_assert0(consumed != AVERROR(EAGAIN)); |
463 |
2/2✓ Branch 0 taken 664 times.
✓ Branch 1 taken 425309 times.
|
425973 | if (consumed < 0) |
464 | 664 | ret = consumed; | |
465 |
4/4✓ Branch 0 taken 425309 times.
✓ Branch 1 taken 664 times.
✓ Branch 2 taken 122353 times.
✓ Branch 3 taken 302956 times.
|
425973 | if (consumed >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO) |
466 | 122353 | consumed = pkt->size; | |
467 | |||
468 |
2/2✓ Branch 0 taken 413796 times.
✓ Branch 1 taken 12177 times.
|
425973 | if (!ret) |
469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 413796 times.
|
413796 | av_assert0(frame->buf[0]); |
470 |
2/2✓ Branch 0 taken 11513 times.
✓ Branch 1 taken 414460 times.
|
425973 | if (ret == AVERROR(EAGAIN)) |
471 | 11513 | ret = 0; | |
472 | |||
473 | /* do not stop draining when got_frame != 0 or ret < 0 */ | ||
474 |
4/4✓ Branch 0 taken 1488 times.
✓ Branch 1 taken 424485 times.
✓ Branch 2 taken 708 times.
✓ Branch 3 taken 780 times.
|
425973 | if (avci->draining && !got_frame) { |
475 |
2/2✓ Branch 0 taken 1 times.
✓ Branch 1 taken 707 times.
|
708 | if (ret < 0) { |
476 | /* prevent infinite loop if a decoder wrongly always return error on draining */ | ||
477 | /* reasonable nb_errors_max = maximum b frames + thread count */ | ||
478 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1 times.
|
1 | int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ? |
479 | ✗ | avctx->thread_count : 1); | |
480 | |||
481 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 1 times.
|
1 | if (decode_ctx(avci)->nb_draining_errors++ >= nb_errors_max) { |
482 | ✗ | av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. " | |
483 | "Stop draining and force EOF.\n"); | ||
484 | ✗ | avci->draining_done = 1; | |
485 | ✗ | ret = AVERROR_BUG; | |
486 | } | ||
487 | } else { | ||
488 | 707 | avci->draining_done = 1; | |
489 | } | ||
490 | } | ||
491 | |||
492 |
4/4✓ Branch 0 taken 29541 times.
✓ Branch 1 taken 396432 times.
✓ Branch 2 taken 664 times.
✓ Branch 3 taken 28877 times.
|
425973 | if (consumed >= pkt->size || ret < 0) { |
493 | 397096 | av_packet_unref(pkt); | |
494 | } else { | ||
495 | 28877 | pkt->data += consumed; | |
496 | 28877 | pkt->size -= consumed; | |
497 | 28877 | pkt->pts = AV_NOPTS_VALUE; | |
498 | 28877 | pkt->dts = AV_NOPTS_VALUE; | |
499 |
1/2✓ Branch 0 taken 28877 times.
✗ Branch 1 not taken.
|
28877 | if (!(codec->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) { |
500 | #if FF_API_FRAME_PKT | ||
501 | // See extract_packet_props() comment. | ||
502 | 28877 | avci->last_pkt_props->stream_index = avci->last_pkt_props->stream_index - consumed; | |
503 | #endif | ||
504 | 28877 | avci->last_pkt_props->pts = AV_NOPTS_VALUE; | |
505 | 28877 | avci->last_pkt_props->dts = AV_NOPTS_VALUE; | |
506 | } | ||
507 | } | ||
508 | |||
509 | 425973 | return ret; | |
510 | } | ||
511 | |||
512 | #if CONFIG_LCMS2 | ||
513 | static int detect_colorspace(AVCodecContext *avctx, AVFrame *frame) | ||
514 | { | ||
515 | AVCodecInternal *avci = avctx->internal; | ||
516 | enum AVColorTransferCharacteristic trc; | ||
517 | AVColorPrimariesDesc coeffs; | ||
518 | enum AVColorPrimaries prim; | ||
519 | cmsHPROFILE profile; | ||
520 | AVFrameSideData *sd; | ||
521 | int ret; | ||
522 | if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES)) | ||
523 | return 0; | ||
524 | |||
525 | sd = av_frame_get_side_data(frame, AV_FRAME_DATA_ICC_PROFILE); | ||
526 | if (!sd || !sd->size) | ||
527 | return 0; | ||
528 | |||
529 | if (!avci->icc.avctx) { | ||
530 | ret = ff_icc_context_init(&avci->icc, avctx); | ||
531 | if (ret < 0) | ||
532 | return ret; | ||
533 | } | ||
534 | |||
535 | profile = cmsOpenProfileFromMemTHR(avci->icc.ctx, sd->data, sd->size); | ||
536 | if (!profile) | ||
537 | return AVERROR_INVALIDDATA; | ||
538 | |||
539 | ret = ff_icc_profile_read_primaries(&avci->icc, profile, &coeffs); | ||
540 | if (!ret) | ||
541 | ret = ff_icc_profile_detect_transfer(&avci->icc, profile, &trc); | ||
542 | cmsCloseProfile(profile); | ||
543 | if (ret < 0) | ||
544 | return ret; | ||
545 | |||
546 | prim = av_csp_primaries_id_from_desc(&coeffs); | ||
547 | if (prim != AVCOL_PRI_UNSPECIFIED) | ||
548 | frame->color_primaries = prim; | ||
549 | if (trc != AVCOL_TRC_UNSPECIFIED) | ||
550 | frame->color_trc = trc; | ||
551 | return 0; | ||
552 | } | ||
553 | #else /* !CONFIG_LCMS2 */ | ||
554 | 818392 | static int detect_colorspace(av_unused AVCodecContext *c, av_unused AVFrame *f) | |
555 | { | ||
556 | 818392 | return 0; | |
557 | } | ||
558 | #endif | ||
559 | |||
560 | 833279 | static int fill_frame_props(const AVCodecContext *avctx, AVFrame *frame) | |
561 | { | ||
562 | int ret; | ||
563 | |||
564 |
2/2✓ Branch 0 taken 529244 times.
✓ Branch 1 taken 304035 times.
|
833279 | if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED) |
565 | 529244 | frame->color_primaries = avctx->color_primaries; | |
566 |
2/2✓ Branch 0 taken 528883 times.
✓ Branch 1 taken 304396 times.
|
833279 | if (frame->color_trc == AVCOL_TRC_UNSPECIFIED) |
567 | 528883 | frame->color_trc = avctx->color_trc; | |
568 |
2/2✓ Branch 0 taken 523473 times.
✓ Branch 1 taken 309806 times.
|
833279 | if (frame->colorspace == AVCOL_SPC_UNSPECIFIED) |
569 | 523473 | frame->colorspace = avctx->colorspace; | |
570 |
2/2✓ Branch 0 taken 806155 times.
✓ Branch 1 taken 27124 times.
|
833279 | if (frame->color_range == AVCOL_RANGE_UNSPECIFIED) |
571 | 806155 | frame->color_range = avctx->color_range; | |
572 |
2/2✓ Branch 0 taken 807078 times.
✓ Branch 1 taken 26201 times.
|
833279 | if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED) |
573 | 807078 | frame->chroma_location = avctx->chroma_sample_location; | |
574 | |||
575 |
2/2✓ Branch 0 taken 226623 times.
✓ Branch 1 taken 606656 times.
|
833279 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
576 |
2/2✓ Branch 0 taken 213421 times.
✓ Branch 1 taken 13202 times.
|
226623 | if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio; |
577 |
2/2✓ Branch 0 taken 107477 times.
✓ Branch 1 taken 119146 times.
|
226623 | if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt; |
578 |
1/2✓ Branch 0 taken 606656 times.
✗ Branch 1 not taken.
|
606656 | } else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) { |
579 |
2/2✓ Branch 0 taken 303417 times.
✓ Branch 1 taken 303239 times.
|
606656 | if (frame->format == AV_SAMPLE_FMT_NONE) |
580 | 303417 | frame->format = avctx->sample_fmt; | |
581 |
2/2✓ Branch 0 taken 303417 times.
✓ Branch 1 taken 303239 times.
|
606656 | if (!frame->ch_layout.nb_channels) { |
582 | 303417 | ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout); | |
583 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 303417 times.
|
303417 | if (ret < 0) |
584 | ✗ | return ret; | |
585 | } | ||
586 | #if FF_API_OLD_CHANNEL_LAYOUT | ||
587 | FF_DISABLE_DEPRECATION_WARNINGS | ||
588 |
2/2✓ Branch 0 taken 306205 times.
✓ Branch 1 taken 300451 times.
|
606656 | if (!frame->channel_layout) |
589 | 306205 | frame->channel_layout = avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE ? | |
590 |
2/2✓ Branch 0 taken 300675 times.
✓ Branch 1 taken 5530 times.
|
306205 | avctx->ch_layout.u.mask : 0; |
591 |
2/2✓ Branch 0 taken 303441 times.
✓ Branch 1 taken 303215 times.
|
606656 | if (!frame->channels) |
592 | 303441 | frame->channels = avctx->ch_layout.nb_channels; | |
593 | FF_ENABLE_DEPRECATION_WARNINGS | ||
594 | #endif | ||
595 |
2/2✓ Branch 0 taken 303446 times.
✓ Branch 1 taken 303210 times.
|
606656 | if (!frame->sample_rate) |
596 | 303446 | frame->sample_rate = avctx->sample_rate; | |
597 | } | ||
598 | |||
599 | 833279 | return 0; | |
600 | } | ||
601 | |||
602 | 815029 | static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame) | |
603 | { | ||
604 | int ret; | ||
605 | 815029 | int64_t discarded_samples = 0; | |
606 | |||
607 |
2/2✓ Branch 0 taken 826542 times.
✓ Branch 1 taken 413796 times.
|
1240338 | while (!frame->buf[0]) { |
608 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 826542 times.
|
826542 | if (discarded_samples > avctx->max_samples) |
609 | ✗ | return AVERROR(EAGAIN); | |
610 | 826542 | ret = decode_simple_internal(avctx, frame, &discarded_samples); | |
611 |
2/2✓ Branch 0 taken 401233 times.
✓ Branch 1 taken 425309 times.
|
826542 | if (ret < 0) |
612 | 401233 | return ret; | |
613 | } | ||
614 | |||
615 | 413796 | return 0; | |
616 | } | ||
617 | |||
618 | 818392 | static int decode_receive_frame_internal(AVCodecContext *avctx, AVFrame *frame) | |
619 | { | ||
620 | 818392 | AVCodecInternal *avci = avctx->internal; | |
621 | 818392 | const FFCodec *const codec = ffcodec(avctx->codec); | |
622 | int ret, ok; | ||
623 | |||
624 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 818392 times.
|
818392 | av_assert0(!frame->buf[0]); |
625 | |||
626 |
2/2✓ Branch 0 taken 3363 times.
✓ Branch 1 taken 815029 times.
|
818392 | if (codec->cb_type == FF_CODEC_CB_TYPE_RECEIVE_FRAME) { |
627 | 3363 | ret = codec->cb.receive_frame(avctx, frame); | |
628 | 3363 | emms_c(); | |
629 |
2/2✓ Branch 0 taken 1822 times.
✓ Branch 1 taken 1541 times.
|
3363 | if (!ret) { |
630 |
2/2✓ Branch 0 taken 13 times.
✓ Branch 1 taken 1809 times.
|
1822 | if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) |
631 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 13 times.
|
13 | ret = (frame->flags & AV_FRAME_FLAG_DISCARD) ? AVERROR(EAGAIN) : 0; |
632 |
1/2✓ Branch 0 taken 1809 times.
✗ Branch 1 not taken.
|
1809 | else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) { |
633 | 1809 | int64_t discarded_samples = 0; | |
634 | 1809 | ret = discard_samples(avctx, frame, &discarded_samples); | |
635 | } | ||
636 | } | ||
637 | } else | ||
638 | 815029 | ret = decode_simple_receive_frame(avctx, frame); | |
639 | |||
640 |
2/2✓ Branch 0 taken 6435 times.
✓ Branch 1 taken 811957 times.
|
818392 | if (ret == AVERROR_EOF) |
641 | 6435 | avci->draining_done = 1; | |
642 | |||
643 | /* preserve ret */ | ||
644 | 818392 | ok = detect_colorspace(avctx, frame); | |
645 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 818392 times.
|
818392 | if (ok < 0) { |
646 | ✗ | av_frame_unref(frame); | |
647 | ✗ | return ok; | |
648 | } | ||
649 | |||
650 |
2/2✓ Branch 0 taken 415618 times.
✓ Branch 1 taken 402774 times.
|
818392 | if (!ret) { |
651 |
2/2✓ Branch 0 taken 112403 times.
✓ Branch 1 taken 303215 times.
|
415618 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
652 |
2/2✓ Branch 0 taken 22792 times.
✓ Branch 1 taken 89611 times.
|
112403 | if (!frame->width) |
653 | 22792 | frame->width = avctx->width; | |
654 |
2/2✓ Branch 0 taken 22792 times.
✓ Branch 1 taken 89611 times.
|
112403 | if (!frame->height) |
655 | 22792 | frame->height = avctx->height; | |
656 | } else | ||
657 | 303215 | frame->flags |= AV_FRAME_FLAG_KEY; | |
658 | |||
659 | 415618 | ret = fill_frame_props(avctx, frame); | |
660 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 415618 times.
|
415618 | if (ret < 0) { |
661 | ✗ | av_frame_unref(frame); | |
662 | ✗ | return ret; | |
663 | } | ||
664 | |||
665 | #if FF_API_FRAME_KEY | ||
666 | FF_DISABLE_DEPRECATION_WARNINGS | ||
667 | 415618 | frame->key_frame = !!(frame->flags & AV_FRAME_FLAG_KEY); | |
668 | FF_ENABLE_DEPRECATION_WARNINGS | ||
669 | #endif | ||
670 | #if FF_API_INTERLACED_FRAME | ||
671 | FF_DISABLE_DEPRECATION_WARNINGS | ||
672 | 415618 | frame->interlaced_frame = !!(frame->flags & AV_FRAME_FLAG_INTERLACED); | |
673 | 415618 | frame->top_field_first = !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST); | |
674 | FF_ENABLE_DEPRECATION_WARNINGS | ||
675 | #endif | ||
676 | 415618 | frame->best_effort_timestamp = guess_correct_pts(avctx, | |
677 | frame->pts, | ||
678 | frame->pkt_dts); | ||
679 | |||
680 | #if FF_API_PKT_DURATION | ||
681 | FF_DISABLE_DEPRECATION_WARNINGS | ||
682 | 415618 | frame->pkt_duration = frame->duration; | |
683 | FF_ENABLE_DEPRECATION_WARNINGS | ||
684 | #endif | ||
685 | |||
686 | /* the only case where decode data is not set should be decoders | ||
687 | * that do not call ff_get_buffer() */ | ||
688 |
4/6✓ Branch 0 taken 392117 times.
✓ Branch 1 taken 23501 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 392117 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 23501 times.
|
415618 | av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) || |
689 | !(avctx->codec->capabilities & AV_CODEC_CAP_DR1)); | ||
690 | |||
691 |
2/2✓ Branch 0 taken 392117 times.
✓ Branch 1 taken 23501 times.
|
415618 | if (frame->private_ref) { |
692 | 392117 | FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data; | |
693 | |||
694 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 392117 times.
|
392117 | if (fdd->post_process) { |
695 | ✗ | ret = fdd->post_process(avctx, frame); | |
696 | ✗ | if (ret < 0) { | |
697 | ✗ | av_frame_unref(frame); | |
698 | ✗ | return ret; | |
699 | } | ||
700 | } | ||
701 | } | ||
702 | } | ||
703 | |||
704 | /* free the per-frame decode data */ | ||
705 | 818392 | av_buffer_unref(&frame->private_ref); | |
706 | |||
707 | 818392 | return ret; | |
708 | } | ||
709 | |||
710 | 403524 | int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt) | |
711 | { | ||
712 | 403524 | AVCodecInternal *avci = avctx->internal; | |
713 | 403524 | DecodeContext *dc = decode_ctx(avci); | |
714 | int ret; | ||
715 | |||
716 |
2/4✓ Branch 1 taken 403524 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 403524 times.
|
403524 | if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec)) |
717 | ✗ | return AVERROR(EINVAL); | |
718 | |||
719 |
2/2✓ Branch 0 taken 26 times.
✓ Branch 1 taken 403498 times.
|
403524 | if (dc->draining_started) |
720 | 26 | return AVERROR_EOF; | |
721 | |||
722 |
5/6✓ Branch 0 taken 397174 times.
✓ Branch 1 taken 6324 times.
✓ Branch 2 taken 111 times.
✓ Branch 3 taken 397063 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 111 times.
|
403498 | if (avpkt && !avpkt->size && avpkt->data) |
723 | ✗ | return AVERROR(EINVAL); | |
724 | |||
725 |
5/6✓ Branch 0 taken 397174 times.
✓ Branch 1 taken 6324 times.
✓ Branch 2 taken 111 times.
✓ Branch 3 taken 397063 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 111 times.
|
403498 | if (avpkt && (avpkt->data || avpkt->side_data_elems)) { |
726 |
2/4✓ Branch 0 taken 397063 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 397063 times.
|
397063 | if (!AVPACKET_IS_EMPTY(avci->buffer_pkt)) |
727 | ✗ | return AVERROR(EAGAIN); | |
728 | 397063 | ret = av_packet_ref(avci->buffer_pkt, avpkt); | |
729 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 397063 times.
|
397063 | if (ret < 0) |
730 | ✗ | return ret; | |
731 | } else | ||
732 | 6435 | dc->draining_started = 1; | |
733 | |||
734 |
3/4✓ Branch 0 taken 403498 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 397063 times.
✓ Branch 3 taken 6435 times.
|
403498 | if (!avci->buffer_frame->buf[0] && !dc->draining_started) { |
735 | 397063 | ret = decode_receive_frame_internal(avctx, avci->buffer_frame); | |
736 |
5/6✓ Branch 0 taken 10556 times.
✓ Branch 1 taken 386507 times.
✓ Branch 2 taken 1044 times.
✓ Branch 3 taken 9512 times.
✓ Branch 4 taken 1044 times.
✗ Branch 5 not taken.
|
397063 | if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) |
737 | 1044 | return ret; | |
738 | } | ||
739 | |||
740 | 402454 | return 0; | |
741 | } | ||
742 | |||
743 | 112403 | static int apply_cropping(AVCodecContext *avctx, AVFrame *frame) | |
744 | { | ||
745 | /* make sure we are noisy about decoders returning invalid cropping data */ | ||
746 |
1/2✓ Branch 0 taken 112403 times.
✗ Branch 1 not taken.
|
112403 | if (frame->crop_left >= INT_MAX - frame->crop_right || |
747 |
1/2✓ Branch 0 taken 112403 times.
✗ Branch 1 not taken.
|
112403 | frame->crop_top >= INT_MAX - frame->crop_bottom || |
748 |
1/2✓ Branch 0 taken 112403 times.
✗ Branch 1 not taken.
|
112403 | (frame->crop_left + frame->crop_right) >= frame->width || |
749 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112403 times.
|
112403 | (frame->crop_top + frame->crop_bottom) >= frame->height) { |
750 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
751 | "Invalid cropping information set by a decoder: " | ||
752 | "%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" " | ||
753 | "(frame size %dx%d). This is a bug, please report it\n", | ||
754 | frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom, | ||
755 | frame->width, frame->height); | ||
756 | ✗ | frame->crop_left = 0; | |
757 | ✗ | frame->crop_right = 0; | |
758 | ✗ | frame->crop_top = 0; | |
759 | ✗ | frame->crop_bottom = 0; | |
760 | ✗ | return 0; | |
761 | } | ||
762 | |||
763 |
2/2✓ Branch 0 taken 54 times.
✓ Branch 1 taken 112349 times.
|
112403 | if (!avctx->apply_cropping) |
764 | 54 | return 0; | |
765 | |||
766 | 112349 | return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ? | |
767 | AV_FRAME_CROP_UNALIGNED : 0); | ||
768 | } | ||
769 | |||
770 | // make sure frames returned to the caller are valid | ||
771 | 415618 | static int frame_validate(AVCodecContext *avctx, AVFrame *frame) | |
772 | { | ||
773 |
2/4✓ Branch 0 taken 415618 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 415618 times.
|
415618 | if (!frame->buf[0] || frame->format < 0) |
774 | ✗ | goto fail; | |
775 | |||
776 |
2/3✓ Branch 0 taken 112403 times.
✓ Branch 1 taken 303215 times.
✗ Branch 2 not taken.
|
415618 | switch (avctx->codec_type) { |
777 | 112403 | case AVMEDIA_TYPE_VIDEO: | |
778 |
2/4✓ Branch 0 taken 112403 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 112403 times.
|
112403 | if (frame->width <= 0 || frame->height <= 0) |
779 | ✗ | goto fail; | |
780 | 112403 | break; | |
781 | 303215 | case AVMEDIA_TYPE_AUDIO: | |
782 |
1/2✓ Branch 1 taken 303215 times.
✗ Branch 2 not taken.
|
303215 | if (!av_channel_layout_check(&frame->ch_layout) || |
783 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 303215 times.
|
303215 | frame->sample_rate <= 0) |
784 | ✗ | goto fail; | |
785 | |||
786 | 303215 | break; | |
787 | ✗ | default: av_assert0(0); | |
788 | } | ||
789 | |||
790 | 415618 | return 0; | |
791 | ✗ | fail: | |
792 | ✗ | av_log(avctx, AV_LOG_ERROR, "An invalid frame was output by a decoder. " | |
793 | "This is a bug, please report it.\n"); | ||
794 | ✗ | return AVERROR_BUG; | |
795 | } | ||
796 | |||
797 | 807836 | int ff_decode_receive_frame(AVCodecContext *avctx, AVFrame *frame) | |
798 | { | ||
799 | 807836 | AVCodecInternal *avci = avctx->internal; | |
800 | int ret; | ||
801 | |||
802 |
2/4✓ Branch 1 taken 807836 times.
✗ Branch 2 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 807836 times.
|
807836 | if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec)) |
803 | ✗ | return AVERROR(EINVAL); | |
804 | |||
805 |
2/2✓ Branch 0 taken 386507 times.
✓ Branch 1 taken 421329 times.
|
807836 | if (avci->buffer_frame->buf[0]) { |
806 | 386507 | av_frame_move_ref(frame, avci->buffer_frame); | |
807 | } else { | ||
808 | 421329 | ret = decode_receive_frame_internal(avctx, frame); | |
809 |
2/2✓ Branch 0 taken 392218 times.
✓ Branch 1 taken 29111 times.
|
421329 | if (ret < 0) |
810 | 392218 | return ret; | |
811 | } | ||
812 | |||
813 | 415618 | ret = frame_validate(avctx, frame); | |
814 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 415618 times.
|
415618 | if (ret < 0) |
815 | ✗ | goto fail; | |
816 | |||
817 |
2/2✓ Branch 0 taken 112403 times.
✓ Branch 1 taken 303215 times.
|
415618 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
818 | 112403 | ret = apply_cropping(avctx, frame); | |
819 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 112403 times.
|
112403 | if (ret < 0) |
820 | ✗ | goto fail; | |
821 | } | ||
822 | |||
823 | 415618 | avctx->frame_num++; | |
824 | #if FF_API_AVCTX_FRAME_NUMBER | ||
825 | FF_DISABLE_DEPRECATION_WARNINGS | ||
826 | 415618 | avctx->frame_number = avctx->frame_num; | |
827 | FF_ENABLE_DEPRECATION_WARNINGS | ||
828 | #endif | ||
829 | |||
830 | #if FF_API_DROPCHANGED | ||
831 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 415618 times.
|
415618 | if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) { |
832 | |||
833 | ✗ | if (avctx->frame_num == 1) { | |
834 | ✗ | avci->initial_format = frame->format; | |
835 | ✗ | switch(avctx->codec_type) { | |
836 | ✗ | case AVMEDIA_TYPE_VIDEO: | |
837 | ✗ | avci->initial_width = frame->width; | |
838 | ✗ | avci->initial_height = frame->height; | |
839 | ✗ | break; | |
840 | ✗ | case AVMEDIA_TYPE_AUDIO: | |
841 | ✗ | avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate : | |
842 | avctx->sample_rate; | ||
843 | ✗ | ret = av_channel_layout_copy(&avci->initial_ch_layout, &frame->ch_layout); | |
844 | ✗ | if (ret < 0) | |
845 | ✗ | goto fail; | |
846 | ✗ | break; | |
847 | } | ||
848 | } | ||
849 | |||
850 | ✗ | if (avctx->frame_num > 1) { | |
851 | ✗ | int changed = avci->initial_format != frame->format; | |
852 | |||
853 | ✗ | switch(avctx->codec_type) { | |
854 | ✗ | case AVMEDIA_TYPE_VIDEO: | |
855 | ✗ | changed |= avci->initial_width != frame->width || | |
856 | ✗ | avci->initial_height != frame->height; | |
857 | ✗ | break; | |
858 | ✗ | case AVMEDIA_TYPE_AUDIO: | |
859 | ✗ | changed |= avci->initial_sample_rate != frame->sample_rate || | |
860 | ✗ | avci->initial_sample_rate != avctx->sample_rate || | |
861 | ✗ | av_channel_layout_compare(&avci->initial_ch_layout, &frame->ch_layout); | |
862 | ✗ | break; | |
863 | } | ||
864 | |||
865 | ✗ | if (changed) { | |
866 | ✗ | avci->changed_frames_dropped++; | |
867 | ✗ | av_log(avctx, AV_LOG_INFO, "dropped changed frame #%"PRId64" pts %"PRId64 | |
868 | " drop count: %d \n", | ||
869 | avctx->frame_num, frame->pts, | ||
870 | avci->changed_frames_dropped); | ||
871 | ✗ | ret = AVERROR_INPUT_CHANGED; | |
872 | ✗ | goto fail; | |
873 | } | ||
874 | } | ||
875 | } | ||
876 | #endif | ||
877 | 415618 | return 0; | |
878 | ✗ | fail: | |
879 | ✗ | av_frame_unref(frame); | |
880 | ✗ | return ret; | |
881 | } | ||
882 | |||
883 | 1709 | static void get_subtitle_defaults(AVSubtitle *sub) | |
884 | { | ||
885 | 1709 | memset(sub, 0, sizeof(*sub)); | |
886 | 1709 | sub->pts = AV_NOPTS_VALUE; | |
887 | 1709 | } | |
888 | |||
889 | #define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */ | ||
890 | 1675 | static int recode_subtitle(AVCodecContext *avctx, const AVPacket **outpkt, | |
891 | const AVPacket *inpkt, AVPacket *buf_pkt) | ||
892 | { | ||
893 | #if CONFIG_ICONV | ||
894 | 1675 | iconv_t cd = (iconv_t)-1; | |
895 | 1675 | int ret = 0; | |
896 | char *inb, *outb; | ||
897 | size_t inl, outl; | ||
898 | #endif | ||
899 | |||
900 |
3/4✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1582 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
|
1675 | if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) { |
901 | 1582 | *outpkt = inpkt; | |
902 | 1582 | return 0; | |
903 | } | ||
904 | |||
905 | #if CONFIG_ICONV | ||
906 | 93 | inb = inpkt->data; | |
907 | 93 | inl = inpkt->size; | |
908 | |||
909 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) { |
910 | ✗ | av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n"); | |
911 | ✗ | return AVERROR(ERANGE); | |
912 | } | ||
913 | |||
914 | 93 | cd = iconv_open("UTF-8", avctx->sub_charenc); | |
915 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | av_assert0(cd != (iconv_t)-1); |
916 | |||
917 | 93 | ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES); | |
918 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | if (ret < 0) |
919 | ✗ | goto end; | |
920 | 93 | ret = av_packet_copy_props(buf_pkt, inpkt); | |
921 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | if (ret < 0) |
922 | ✗ | goto end; | |
923 | 93 | outb = buf_pkt->data; | |
924 | 93 | outl = buf_pkt->size; | |
925 | |||
926 |
2/4✓ Branch 1 taken 93 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
✗ Branch 4 not taken.
|
186 | if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 || |
927 | 93 | iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 || | |
928 |
2/4✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 93 times.
|
93 | outl >= buf_pkt->size || inl != 0) { |
929 | ✗ | ret = FFMIN(AVERROR(errno), -1); | |
930 | ✗ | av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" " | |
931 | ✗ | "from %s to UTF-8\n", inpkt->data, avctx->sub_charenc); | |
932 | ✗ | goto end; | |
933 | } | ||
934 | 93 | buf_pkt->size -= outl; | |
935 | 93 | memset(buf_pkt->data + buf_pkt->size, 0, outl); | |
936 | 93 | *outpkt = buf_pkt; | |
937 | |||
938 | 93 | ret = 0; | |
939 | 93 | end: | |
940 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 93 times.
|
93 | if (ret < 0) |
941 | ✗ | av_packet_unref(buf_pkt); | |
942 |
1/2✓ Branch 0 taken 93 times.
✗ Branch 1 not taken.
|
93 | if (cd != (iconv_t)-1) |
943 | 93 | iconv_close(cd); | |
944 | 93 | return ret; | |
945 | #else | ||
946 | av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv"); | ||
947 | return AVERROR(EINVAL); | ||
948 | #endif | ||
949 | } | ||
950 | |||
951 | 700 | static int utf8_check(const uint8_t *str) | |
952 | { | ||
953 | const uint8_t *byte; | ||
954 | uint32_t codepoint, min; | ||
955 | |||
956 |
2/2✓ Branch 0 taken 61067 times.
✓ Branch 1 taken 700 times.
|
61767 | while (*str) { |
957 | 61067 | byte = str; | |
958 |
5/8✓ Branch 0 taken 61067 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 61067 times.
✗ Branch 4 not taken.
✓ Branch 5 taken 2794 times.
✓ Branch 6 taken 2794 times.
✓ Branch 7 taken 61067 times.
|
63861 | GET_UTF8(codepoint, *(byte++), return 0;); |
959 |
4/4✓ Branch 0 taken 2089 times.
✓ Branch 1 taken 58978 times.
✓ Branch 2 taken 705 times.
✓ Branch 3 taken 1384 times.
|
61772 | min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 : |
960 | 705 | 1 << (5 * (byte - str) - 4); | |
961 |
3/6✓ Branch 0 taken 61067 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 61067 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 61067 times.
✗ Branch 5 not taken.
|
61067 | if (codepoint < min || codepoint >= 0x110000 || |
962 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 61067 times.
|
61067 | codepoint == 0xFFFE /* BOM */ || |
963 | ✗ | codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */) | |
964 | ✗ | return 0; | |
965 | 61067 | str = byte; | |
966 | } | ||
967 | 700 | return 1; | |
968 | } | ||
969 | |||
970 | 1709 | int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, | |
971 | int *got_sub_ptr, const AVPacket *avpkt) | ||
972 | { | ||
973 | 1709 | int ret = 0; | |
974 | |||
975 |
3/4✓ Branch 0 taken 40 times.
✓ Branch 1 taken 1669 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 40 times.
|
1709 | if (!avpkt->data && avpkt->size) { |
976 | ✗ | av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n"); | |
977 | ✗ | return AVERROR(EINVAL); | |
978 | } | ||
979 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1709 times.
|
1709 | if (!avctx->codec) |
980 | ✗ | return AVERROR(EINVAL); | |
981 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1709 times.
|
1709 | if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) { |
982 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n"); | |
983 | ✗ | return AVERROR(EINVAL); | |
984 | } | ||
985 | |||
986 | 1709 | *got_sub_ptr = 0; | |
987 | 1709 | get_subtitle_defaults(sub); | |
988 | |||
989 |
4/4✓ Branch 0 taken 857 times.
✓ Branch 1 taken 852 times.
✓ Branch 2 taken 823 times.
✓ Branch 3 taken 34 times.
|
1709 | if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) { |
990 | 1675 | AVCodecInternal *avci = avctx->internal; | |
991 | const AVPacket *pkt; | ||
992 | |||
993 | 1675 | ret = recode_subtitle(avctx, &pkt, avpkt, avci->buffer_pkt); | |
994 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1675 times.
|
1675 | if (ret < 0) |
995 | 79 | return ret; | |
996 | |||
997 |
3/4✓ Branch 0 taken 1675 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 1665 times.
✓ Branch 3 taken 10 times.
|
1675 | if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE) |
998 | 1665 | sub->pts = av_rescale_q(avpkt->pts, | |
999 | 1665 | avctx->pkt_timebase, AV_TIME_BASE_Q); | |
1000 | 1675 | ret = ffcodec(avctx->codec)->cb.decode_sub(avctx, sub, got_sub_ptr, pkt); | |
1001 |
2/2✓ Branch 0 taken 93 times.
✓ Branch 1 taken 1582 times.
|
1675 | if (pkt == avci->buffer_pkt) // did we recode? |
1002 | 93 | av_packet_unref(avci->buffer_pkt); | |
1003 |
2/2✓ Branch 0 taken 79 times.
✓ Branch 1 taken 1596 times.
|
1675 | if (ret < 0) { |
1004 | 79 | *got_sub_ptr = 0; | |
1005 | 79 | avsubtitle_free(sub); | |
1006 | 79 | return ret; | |
1007 | } | ||
1008 | av_assert1(!sub->num_rects || *got_sub_ptr); | ||
1009 | |||
1010 |
6/6✓ Branch 0 taken 826 times.
✓ Branch 1 taken 770 times.
✓ Branch 2 taken 580 times.
✓ Branch 3 taken 246 times.
✓ Branch 4 taken 528 times.
✓ Branch 5 taken 52 times.
|
1596 | if (sub->num_rects && !sub->end_display_time && avpkt->duration && |
1011 |
1/2✓ Branch 0 taken 528 times.
✗ Branch 1 not taken.
|
528 | avctx->pkt_timebase.num) { |
1012 | 528 | AVRational ms = { 1, 1000 }; | |
1013 | 528 | sub->end_display_time = av_rescale_q(avpkt->duration, | |
1014 | avctx->pkt_timebase, ms); | ||
1015 | } | ||
1016 | |||
1017 |
2/2✓ Branch 0 taken 156 times.
✓ Branch 1 taken 1440 times.
|
1596 | if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) |
1018 | 156 | sub->format = 0; | |
1019 |
1/2✓ Branch 0 taken 1440 times.
✗ Branch 1 not taken.
|
1440 | else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB) |
1020 | 1440 | sub->format = 1; | |
1021 | |||
1022 |
2/2✓ Branch 0 taken 859 times.
✓ Branch 1 taken 1596 times.
|
2455 | for (unsigned i = 0; i < sub->num_rects; i++) { |
1023 |
1/2✓ Branch 0 taken 859 times.
✗ Branch 1 not taken.
|
859 | if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_IGNORE && |
1024 |
3/4✓ Branch 0 taken 700 times.
✓ Branch 1 taken 159 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 700 times.
|
859 | sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) { |
1025 | ✗ | av_log(avctx, AV_LOG_ERROR, | |
1026 | "Invalid UTF-8 in decoded subtitles text; " | ||
1027 | "maybe missing -sub_charenc option\n"); | ||
1028 | ✗ | avsubtitle_free(sub); | |
1029 | ✗ | *got_sub_ptr = 0; | |
1030 | ✗ | return AVERROR_INVALIDDATA; | |
1031 | } | ||
1032 | } | ||
1033 | |||
1034 |
2/2✓ Branch 0 taken 835 times.
✓ Branch 1 taken 761 times.
|
1596 | if (*got_sub_ptr) |
1035 | 835 | avctx->frame_num++; | |
1036 | #if FF_API_AVCTX_FRAME_NUMBER | ||
1037 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1038 | 1596 | avctx->frame_number = avctx->frame_num; | |
1039 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1040 | #endif | ||
1041 | } | ||
1042 | |||
1043 | 1630 | return ret; | |
1044 | } | ||
1045 | |||
1046 | 1685 | enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx, | |
1047 | const enum AVPixelFormat *fmt) | ||
1048 | { | ||
1049 | const AVPixFmtDescriptor *desc; | ||
1050 | const AVCodecHWConfig *config; | ||
1051 | int i, n; | ||
1052 | |||
1053 | // If a device was supplied when the codec was opened, assume that the | ||
1054 | // user wants to use it. | ||
1055 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 1685 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
1685 | if (avctx->hw_device_ctx && ffcodec(avctx->codec)->hw_configs) { |
1056 | ✗ | AVHWDeviceContext *device_ctx = | |
1057 | ✗ | (AVHWDeviceContext*)avctx->hw_device_ctx->data; | |
1058 | ✗ | for (i = 0;; i++) { | |
1059 | ✗ | config = &ffcodec(avctx->codec)->hw_configs[i]->public; | |
1060 | ✗ | if (!config) | |
1061 | ✗ | break; | |
1062 | ✗ | if (!(config->methods & | |
1063 | AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)) | ||
1064 | ✗ | continue; | |
1065 | ✗ | if (device_ctx->type != config->device_type) | |
1066 | ✗ | continue; | |
1067 | ✗ | for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) { | |
1068 | ✗ | if (config->pix_fmt == fmt[n]) | |
1069 | ✗ | return fmt[n]; | |
1070 | } | ||
1071 | } | ||
1072 | } | ||
1073 | // No device or other setup, so we have to choose from things which | ||
1074 | // don't any other external information. | ||
1075 | |||
1076 | // If the last element of the list is a software format, choose it | ||
1077 | // (this should be best software format if any exist). | ||
1078 |
2/2✓ Branch 0 taken 4344 times.
✓ Branch 1 taken 1685 times.
|
6029 | for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++); |
1079 | 1685 | desc = av_pix_fmt_desc_get(fmt[n - 1]); | |
1080 |
1/2✓ Branch 0 taken 1685 times.
✗ Branch 1 not taken.
|
1685 | if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL)) |
1081 | 1685 | return fmt[n - 1]; | |
1082 | |||
1083 | // Finally, traverse the list in order and choose the first entry | ||
1084 | // with no external dependencies (if there is no hardware configuration | ||
1085 | // information available then this just picks the first entry). | ||
1086 | ✗ | for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) { | |
1087 | ✗ | for (i = 0;; i++) { | |
1088 | ✗ | config = avcodec_get_hw_config(avctx->codec, i); | |
1089 | ✗ | if (!config) | |
1090 | ✗ | break; | |
1091 | ✗ | if (config->pix_fmt == fmt[n]) | |
1092 | ✗ | break; | |
1093 | } | ||
1094 | ✗ | if (!config) { | |
1095 | // No specific config available, so the decoder must be able | ||
1096 | // to handle this format without any additional setup. | ||
1097 | ✗ | return fmt[n]; | |
1098 | } | ||
1099 | ✗ | if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) { | |
1100 | // Usable with only internal setup. | ||
1101 | ✗ | return fmt[n]; | |
1102 | } | ||
1103 | } | ||
1104 | |||
1105 | // Nothing is usable, give up. | ||
1106 | ✗ | return AV_PIX_FMT_NONE; | |
1107 | } | ||
1108 | |||
1109 | ✗ | int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx, | |
1110 | enum AVHWDeviceType dev_type) | ||
1111 | { | ||
1112 | AVHWDeviceContext *device_ctx; | ||
1113 | AVHWFramesContext *frames_ctx; | ||
1114 | int ret; | ||
1115 | |||
1116 | ✗ | if (!avctx->hwaccel) | |
1117 | ✗ | return AVERROR(ENOSYS); | |
1118 | |||
1119 | ✗ | if (avctx->hw_frames_ctx) | |
1120 | ✗ | return 0; | |
1121 | ✗ | if (!avctx->hw_device_ctx) { | |
1122 | ✗ | av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is " | |
1123 | "required for hardware accelerated decoding.\n"); | ||
1124 | ✗ | return AVERROR(EINVAL); | |
1125 | } | ||
1126 | |||
1127 | ✗ | device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data; | |
1128 | ✗ | if (device_ctx->type != dev_type) { | |
1129 | ✗ | av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware " | |
1130 | "decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type), | ||
1131 | av_hwdevice_get_type_name(device_ctx->type)); | ||
1132 | ✗ | return AVERROR(EINVAL); | |
1133 | } | ||
1134 | |||
1135 | ✗ | ret = avcodec_get_hw_frames_parameters(avctx, | |
1136 | avctx->hw_device_ctx, | ||
1137 | ✗ | avctx->hwaccel->pix_fmt, | |
1138 | &avctx->hw_frames_ctx); | ||
1139 | ✗ | if (ret < 0) | |
1140 | ✗ | return ret; | |
1141 | |||
1142 | ✗ | frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data; | |
1143 | |||
1144 | |||
1145 | ✗ | if (frames_ctx->initial_pool_size) { | |
1146 | // We guarantee 4 base work surfaces. The function above guarantees 1 | ||
1147 | // (the absolute minimum), so add the missing count. | ||
1148 | ✗ | frames_ctx->initial_pool_size += 3; | |
1149 | } | ||
1150 | |||
1151 | ✗ | ret = av_hwframe_ctx_init(avctx->hw_frames_ctx); | |
1152 | ✗ | if (ret < 0) { | |
1153 | ✗ | av_buffer_unref(&avctx->hw_frames_ctx); | |
1154 | ✗ | return ret; | |
1155 | } | ||
1156 | |||
1157 | ✗ | return 0; | |
1158 | } | ||
1159 | |||
1160 | ✗ | int avcodec_get_hw_frames_parameters(AVCodecContext *avctx, | |
1161 | AVBufferRef *device_ref, | ||
1162 | enum AVPixelFormat hw_pix_fmt, | ||
1163 | AVBufferRef **out_frames_ref) | ||
1164 | { | ||
1165 | ✗ | AVBufferRef *frames_ref = NULL; | |
1166 | const AVCodecHWConfigInternal *hw_config; | ||
1167 | const FFHWAccel *hwa; | ||
1168 | int i, ret; | ||
1169 | |||
1170 | ✗ | for (i = 0;; i++) { | |
1171 | ✗ | hw_config = ffcodec(avctx->codec)->hw_configs[i]; | |
1172 | ✗ | if (!hw_config) | |
1173 | ✗ | return AVERROR(ENOENT); | |
1174 | ✗ | if (hw_config->public.pix_fmt == hw_pix_fmt) | |
1175 | ✗ | break; | |
1176 | } | ||
1177 | |||
1178 | ✗ | hwa = hw_config->hwaccel; | |
1179 | ✗ | if (!hwa || !hwa->frame_params) | |
1180 | ✗ | return AVERROR(ENOENT); | |
1181 | |||
1182 | ✗ | frames_ref = av_hwframe_ctx_alloc(device_ref); | |
1183 | ✗ | if (!frames_ref) | |
1184 | ✗ | return AVERROR(ENOMEM); | |
1185 | |||
1186 | ✗ | if (!avctx->internal->hwaccel_priv_data) { | |
1187 | ✗ | avctx->internal->hwaccel_priv_data = | |
1188 | ✗ | av_mallocz(hwa->priv_data_size); | |
1189 | ✗ | if (!avctx->internal->hwaccel_priv_data) { | |
1190 | ✗ | av_buffer_unref(&frames_ref); | |
1191 | ✗ | return AVERROR(ENOMEM); | |
1192 | } | ||
1193 | } | ||
1194 | |||
1195 | ✗ | ret = hwa->frame_params(avctx, frames_ref); | |
1196 | ✗ | if (ret >= 0) { | |
1197 | ✗ | AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data; | |
1198 | |||
1199 | ✗ | if (frames_ctx->initial_pool_size) { | |
1200 | // If the user has requested that extra output surfaces be | ||
1201 | // available then add them here. | ||
1202 | ✗ | if (avctx->extra_hw_frames > 0) | |
1203 | ✗ | frames_ctx->initial_pool_size += avctx->extra_hw_frames; | |
1204 | |||
1205 | // If frame threading is enabled then an extra surface per thread | ||
1206 | // is also required. | ||
1207 | ✗ | if (avctx->active_thread_type & FF_THREAD_FRAME) | |
1208 | ✗ | frames_ctx->initial_pool_size += avctx->thread_count; | |
1209 | } | ||
1210 | |||
1211 | ✗ | *out_frames_ref = frames_ref; | |
1212 | } else { | ||
1213 | ✗ | av_buffer_unref(&frames_ref); | |
1214 | } | ||
1215 | ✗ | return ret; | |
1216 | } | ||
1217 | |||
1218 | ✗ | static int hwaccel_init(AVCodecContext *avctx, | |
1219 | const FFHWAccel *hwaccel) | ||
1220 | { | ||
1221 | int err; | ||
1222 | |||
1223 | ✗ | if (hwaccel->p.capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL && | |
1224 | ✗ | avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) { | |
1225 | ✗ | av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n", | |
1226 | ✗ | hwaccel->p.name); | |
1227 | ✗ | return AVERROR_PATCHWELCOME; | |
1228 | } | ||
1229 | |||
1230 | ✗ | if (!avctx->internal->hwaccel_priv_data && hwaccel->priv_data_size) { | |
1231 | ✗ | avctx->internal->hwaccel_priv_data = | |
1232 | ✗ | av_mallocz(hwaccel->priv_data_size); | |
1233 | ✗ | if (!avctx->internal->hwaccel_priv_data) | |
1234 | ✗ | return AVERROR(ENOMEM); | |
1235 | } | ||
1236 | |||
1237 | ✗ | avctx->hwaccel = &hwaccel->p; | |
1238 | ✗ | if (hwaccel->init) { | |
1239 | ✗ | err = hwaccel->init(avctx); | |
1240 | ✗ | if (err < 0) { | |
1241 | ✗ | av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: " | |
1242 | "hwaccel initialisation returned error.\n", | ||
1243 | ✗ | av_get_pix_fmt_name(hwaccel->p.pix_fmt)); | |
1244 | ✗ | av_freep(&avctx->internal->hwaccel_priv_data); | |
1245 | ✗ | avctx->hwaccel = NULL; | |
1246 | ✗ | return err; | |
1247 | } | ||
1248 | } | ||
1249 | |||
1250 | ✗ | return 0; | |
1251 | } | ||
1252 | |||
1253 | 35833 | void ff_hwaccel_uninit(AVCodecContext *avctx) | |
1254 | { | ||
1255 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 35833 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
|
35833 | if (FF_HW_HAS_CB(avctx, uninit)) |
1256 | ✗ | FF_HW_SIMPLE_CALL(avctx, uninit); | |
1257 | |||
1258 | 35833 | av_freep(&avctx->internal->hwaccel_priv_data); | |
1259 | |||
1260 | 35833 | avctx->hwaccel = NULL; | |
1261 | |||
1262 | 35833 | av_buffer_unref(&avctx->hw_frames_ctx); | |
1263 | 35833 | } | |
1264 | |||
1265 | 2665 | int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt) | |
1266 | { | ||
1267 | const AVPixFmtDescriptor *desc; | ||
1268 | enum AVPixelFormat *choices; | ||
1269 | enum AVPixelFormat ret, user_choice; | ||
1270 | const AVCodecHWConfigInternal *hw_config; | ||
1271 | const AVCodecHWConfig *config; | ||
1272 | int i, n, err; | ||
1273 | |||
1274 | // Find end of list. | ||
1275 |
2/2✓ Branch 0 taken 6989 times.
✓ Branch 1 taken 2665 times.
|
9654 | for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++); |
1276 | // Must contain at least one entry. | ||
1277 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2665 times.
|
2665 | av_assert0(n >= 1); |
1278 | // If a software format is available, it must be the last entry. | ||
1279 | 2665 | desc = av_pix_fmt_desc_get(fmt[n - 1]); | |
1280 |
1/2✓ Branch 0 taken 2665 times.
✗ Branch 1 not taken.
|
2665 | if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) { |
1281 | // No software format is available. | ||
1282 | } else { | ||
1283 | 2665 | avctx->sw_pix_fmt = fmt[n - 1]; | |
1284 | } | ||
1285 | |||
1286 | 2665 | choices = av_memdup(fmt, (n + 1) * sizeof(*choices)); | |
1287 |
1/2✓ Branch 0 taken 2665 times.
✗ Branch 1 not taken.
|
2665 | if (!choices) |
1288 | ✗ | return AV_PIX_FMT_NONE; | |
1289 | |||
1290 | for (;;) { | ||
1291 | // Remove the previous hwaccel, if there was one. | ||
1292 | 2665 | ff_hwaccel_uninit(avctx); | |
1293 | |||
1294 | 2665 | user_choice = avctx->get_format(avctx, choices); | |
1295 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2665 times.
|
2665 | if (user_choice == AV_PIX_FMT_NONE) { |
1296 | // Explicitly chose nothing, give up. | ||
1297 | ✗ | ret = AV_PIX_FMT_NONE; | |
1298 | ✗ | break; | |
1299 | } | ||
1300 | |||
1301 | 2665 | desc = av_pix_fmt_desc_get(user_choice); | |
1302 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2665 times.
|
2665 | if (!desc) { |
1303 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid format returned by " | |
1304 | "get_format() callback.\n"); | ||
1305 | ✗ | ret = AV_PIX_FMT_NONE; | |
1306 | ✗ | break; | |
1307 | } | ||
1308 | 2665 | av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n", | |
1309 | 2665 | desc->name); | |
1310 | |||
1311 |
1/2✓ Branch 0 taken 6989 times.
✗ Branch 1 not taken.
|
6989 | for (i = 0; i < n; i++) { |
1312 |
2/2✓ Branch 0 taken 2665 times.
✓ Branch 1 taken 4324 times.
|
6989 | if (choices[i] == user_choice) |
1313 | 2665 | break; | |
1314 | } | ||
1315 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2665 times.
|
2665 | if (i == n) { |
1316 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): " | |
1317 | ✗ | "%s not in possible list.\n", desc->name); | |
1318 | ✗ | ret = AV_PIX_FMT_NONE; | |
1319 | ✗ | break; | |
1320 | } | ||
1321 | |||
1322 |
2/2✓ Branch 1 taken 2541 times.
✓ Branch 2 taken 124 times.
|
2665 | if (ffcodec(avctx->codec)->hw_configs) { |
1323 | 2541 | for (i = 0;; i++) { | |
1324 | 7053 | hw_config = ffcodec(avctx->codec)->hw_configs[i]; | |
1325 |
2/2✓ Branch 0 taken 2541 times.
✓ Branch 1 taken 4512 times.
|
7053 | if (!hw_config) |
1326 | 2541 | break; | |
1327 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 4512 times.
|
4512 | if (hw_config->public.pix_fmt == user_choice) |
1328 | ✗ | break; | |
1329 | } | ||
1330 | } else { | ||
1331 | 124 | hw_config = NULL; | |
1332 | } | ||
1333 | |||
1334 |
1/2✓ Branch 0 taken 2665 times.
✗ Branch 1 not taken.
|
2665 | if (!hw_config) { |
1335 | // No config available, so no extra setup required. | ||
1336 | 2665 | ret = user_choice; | |
1337 | 2665 | break; | |
1338 | } | ||
1339 | ✗ | config = &hw_config->public; | |
1340 | |||
1341 | ✗ | if (config->methods & | |
1342 | ✗ | AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX && | |
1343 | ✗ | avctx->hw_frames_ctx) { | |
1344 | ✗ | const AVHWFramesContext *frames_ctx = | |
1345 | ✗ | (AVHWFramesContext*)avctx->hw_frames_ctx->data; | |
1346 | ✗ | if (frames_ctx->format != user_choice) { | |
1347 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: " | |
1348 | "does not match the format of the provided frames " | ||
1349 | ✗ | "context.\n", desc->name); | |
1350 | ✗ | goto try_again; | |
1351 | } | ||
1352 | ✗ | } else if (config->methods & | |
1353 | ✗ | AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX && | |
1354 | ✗ | avctx->hw_device_ctx) { | |
1355 | ✗ | const AVHWDeviceContext *device_ctx = | |
1356 | ✗ | (AVHWDeviceContext*)avctx->hw_device_ctx->data; | |
1357 | ✗ | if (device_ctx->type != config->device_type) { | |
1358 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: " | |
1359 | "does not match the type of the provided device " | ||
1360 | ✗ | "context.\n", desc->name); | |
1361 | ✗ | goto try_again; | |
1362 | } | ||
1363 | ✗ | } else if (config->methods & | |
1364 | AV_CODEC_HW_CONFIG_METHOD_INTERNAL) { | ||
1365 | // Internal-only setup, no additional configuration. | ||
1366 | ✗ | } else if (config->methods & | |
1367 | AV_CODEC_HW_CONFIG_METHOD_AD_HOC) { | ||
1368 | // Some ad-hoc configuration we can't see and can't check. | ||
1369 | } else { | ||
1370 | ✗ | av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: " | |
1371 | ✗ | "missing configuration.\n", desc->name); | |
1372 | ✗ | goto try_again; | |
1373 | } | ||
1374 | ✗ | if (hw_config->hwaccel) { | |
1375 | ✗ | av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel " | |
1376 | ✗ | "initialisation.\n", desc->name); | |
1377 | ✗ | err = hwaccel_init(avctx, hw_config->hwaccel); | |
1378 | ✗ | if (err < 0) | |
1379 | ✗ | goto try_again; | |
1380 | } | ||
1381 | ✗ | ret = user_choice; | |
1382 | ✗ | break; | |
1383 | |||
1384 | ✗ | try_again: | |
1385 | ✗ | av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying " | |
1386 | ✗ | "get_format() without it.\n", desc->name); | |
1387 | ✗ | for (i = 0; i < n; i++) { | |
1388 | ✗ | if (choices[i] == user_choice) | |
1389 | ✗ | break; | |
1390 | } | ||
1391 | ✗ | for (; i + 1 < n; i++) | |
1392 | ✗ | choices[i] = choices[i + 1]; | |
1393 | ✗ | --n; | |
1394 | } | ||
1395 | |||
1396 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 2665 times.
|
2665 | if (ret < 0) |
1397 | ✗ | ff_hwaccel_uninit(avctx); | |
1398 | |||
1399 | 2665 | av_freep(&choices); | |
1400 | 2665 | return ret; | |
1401 | } | ||
1402 | |||
1403 | 417661 | static int add_metadata_from_side_data(const AVPacket *avpkt, AVFrame *frame) | |
1404 | { | ||
1405 | size_t size; | ||
1406 | const uint8_t *side_metadata; | ||
1407 | |||
1408 | 417661 | AVDictionary **frame_md = &frame->metadata; | |
1409 | |||
1410 | 417661 | side_metadata = av_packet_get_side_data(avpkt, | |
1411 | AV_PKT_DATA_STRINGS_METADATA, &size); | ||
1412 | 417661 | return av_packet_unpack_dictionary(side_metadata, size, frame_md); | |
1413 | } | ||
1414 | |||
1415 | 417661 | int ff_decode_frame_props_from_pkt(const AVCodecContext *avctx, | |
1416 | AVFrame *frame, const AVPacket *pkt) | ||
1417 | { | ||
1418 | static const struct { | ||
1419 | enum AVPacketSideDataType packet; | ||
1420 | enum AVFrameSideDataType frame; | ||
1421 | } sd[] = { | ||
1422 | { AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN }, | ||
1423 | { AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX }, | ||
1424 | { AV_PKT_DATA_SPHERICAL, AV_FRAME_DATA_SPHERICAL }, | ||
1425 | { AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D }, | ||
1426 | { AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE }, | ||
1427 | { AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA }, | ||
1428 | { AV_PKT_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL }, | ||
1429 | { AV_PKT_DATA_A53_CC, AV_FRAME_DATA_A53_CC }, | ||
1430 | { AV_PKT_DATA_AFD, AV_FRAME_DATA_AFD }, | ||
1431 | { AV_PKT_DATA_ICC_PROFILE, AV_FRAME_DATA_ICC_PROFILE }, | ||
1432 | { AV_PKT_DATA_S12M_TIMECODE, AV_FRAME_DATA_S12M_TIMECODE }, | ||
1433 | { AV_PKT_DATA_DYNAMIC_HDR10_PLUS, AV_FRAME_DATA_DYNAMIC_HDR_PLUS }, | ||
1434 | { AV_PKT_DATA_SKIP_SAMPLES, AV_FRAME_DATA_SKIP_SAMPLES }, | ||
1435 | }; | ||
1436 | |||
1437 | 417661 | frame->pts = pkt->pts; | |
1438 | 417661 | frame->duration = pkt->duration; | |
1439 | #if FF_API_FRAME_PKT | ||
1440 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1441 | 417661 | frame->pkt_pos = pkt->pos; | |
1442 | 417661 | frame->pkt_size = pkt->size; | |
1443 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1444 | #endif | ||
1445 | |||
1446 |
2/2✓ Branch 0 taken 5429593 times.
✓ Branch 1 taken 417661 times.
|
5847254 | for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) { |
1447 | size_t size; | ||
1448 | 5429593 | uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size); | |
1449 |
2/2✓ Branch 0 taken 329 times.
✓ Branch 1 taken 5429264 times.
|
5429593 | if (packet_sd) { |
1450 | 329 | AVFrameSideData *frame_sd = av_frame_new_side_data(frame, | |
1451 | 329 | sd[i].frame, | |
1452 | size); | ||
1453 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 329 times.
|
329 | if (!frame_sd) |
1454 | ✗ | return AVERROR(ENOMEM); | |
1455 | |||
1456 | 329 | memcpy(frame_sd->data, packet_sd, size); | |
1457 | } | ||
1458 | } | ||
1459 | 417661 | add_metadata_from_side_data(pkt, frame); | |
1460 | |||
1461 |
2/2✓ Branch 0 taken 202 times.
✓ Branch 1 taken 417459 times.
|
417661 | if (pkt->flags & AV_PKT_FLAG_DISCARD) { |
1462 | 202 | frame->flags |= AV_FRAME_FLAG_DISCARD; | |
1463 | } else { | ||
1464 | 417459 | frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD); | |
1465 | } | ||
1466 | |||
1467 |
2/2✓ Branch 0 taken 3155 times.
✓ Branch 1 taken 414506 times.
|
417661 | if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) { |
1468 | 3155 | int ret = av_buffer_replace(&frame->opaque_ref, pkt->opaque_ref); | |
1469 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 3155 times.
|
3155 | if (ret < 0) |
1470 | ✗ | return ret; | |
1471 | 3155 | frame->opaque = pkt->opaque; | |
1472 | } | ||
1473 | |||
1474 | 417661 | return 0; | |
1475 | } | ||
1476 | |||
1477 | 417661 | int ff_decode_frame_props(AVCodecContext *avctx, AVFrame *frame) | |
1478 | { | ||
1479 | int ret; | ||
1480 | |||
1481 |
1/2✓ Branch 1 taken 417661 times.
✗ Branch 2 not taken.
|
417661 | if (!(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_SETS_FRAME_PROPS)) { |
1482 | 417661 | const AVPacket *pkt = avctx->internal->last_pkt_props; | |
1483 | |||
1484 | 417661 | ret = ff_decode_frame_props_from_pkt(avctx, frame, pkt); | |
1485 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 417661 times.
|
417661 | if (ret < 0) |
1486 | ✗ | return ret; | |
1487 | #if FF_API_FRAME_PKT | ||
1488 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1489 | 417661 | frame->pkt_size = pkt->stream_index; | |
1490 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1491 | #endif | ||
1492 | } | ||
1493 | #if FF_API_REORDERED_OPAQUE | ||
1494 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1495 | 417661 | frame->reordered_opaque = avctx->reordered_opaque; | |
1496 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1497 | #endif | ||
1498 | |||
1499 | 417661 | ret = fill_frame_props(avctx, frame); | |
1500 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 417661 times.
|
417661 | if (ret < 0) |
1501 | ✗ | return ret; | |
1502 | |||
1503 |
2/2✓ Branch 0 taken 114220 times.
✓ Branch 1 taken 303441 times.
|
417661 | switch (avctx->codec->type) { |
1504 | 114220 | case AVMEDIA_TYPE_VIDEO: | |
1505 |
4/6✓ Branch 0 taken 91428 times.
✓ Branch 1 taken 22792 times.
✓ Branch 2 taken 91428 times.
✗ Branch 3 not taken.
✗ Branch 4 not taken.
✓ Branch 5 taken 91428 times.
|
205648 | if (frame->width && frame->height && |
1506 | 91428 | av_image_check_sar(frame->width, frame->height, | |
1507 | frame->sample_aspect_ratio) < 0) { | ||
1508 | ✗ | av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n", | |
1509 | frame->sample_aspect_ratio.num, | ||
1510 | frame->sample_aspect_ratio.den); | ||
1511 | ✗ | frame->sample_aspect_ratio = (AVRational){ 0, 1 }; | |
1512 | } | ||
1513 | 114220 | break; | |
1514 | } | ||
1515 | 417661 | return 0; | |
1516 | } | ||
1517 | |||
1518 | 388134 | static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame) | |
1519 | { | ||
1520 |
2/2✓ Branch 0 taken 84693 times.
✓ Branch 1 taken 303441 times.
|
388134 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
1521 | int i; | ||
1522 | 84693 | int num_planes = av_pix_fmt_count_planes(frame->format); | |
1523 | 84693 | const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format); | |
1524 |
1/2✓ Branch 0 taken 84693 times.
✗ Branch 1 not taken.
|
84693 | int flags = desc ? desc->flags : 0; |
1525 |
4/4✓ Branch 0 taken 8263 times.
✓ Branch 1 taken 76430 times.
✓ Branch 2 taken 2021 times.
✓ Branch 3 taken 6242 times.
|
84693 | if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL)) |
1526 | 2021 | num_planes = 2; | |
1527 |
2/2✓ Branch 0 taken 240463 times.
✓ Branch 1 taken 84693 times.
|
325156 | for (i = 0; i < num_planes; i++) { |
1528 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 240463 times.
|
240463 | av_assert0(frame->data[i]); |
1529 | } | ||
1530 | // For formats without data like hwaccel allow unused pointers to be non-NULL. | ||
1531 |
3/4✓ Branch 0 taken 521774 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 437081 times.
✓ Branch 3 taken 84693 times.
|
521774 | for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) { |
1532 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 437081 times.
|
437081 | if (frame->data[i]) |
1533 | ✗ | av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n"); | |
1534 | 437081 | frame->data[i] = NULL; | |
1535 | } | ||
1536 | } | ||
1537 | 388134 | } | |
1538 | |||
1539 | 388134 | static void decode_data_free(void *opaque, uint8_t *data) | |
1540 | { | ||
1541 | 388134 | FrameDecodeData *fdd = (FrameDecodeData*)data; | |
1542 | |||
1543 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (fdd->post_process_opaque_free) |
1544 | ✗ | fdd->post_process_opaque_free(fdd->post_process_opaque); | |
1545 | |||
1546 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (fdd->hwaccel_priv_free) |
1547 | ✗ | fdd->hwaccel_priv_free(fdd->hwaccel_priv); | |
1548 | |||
1549 | 388134 | av_freep(&fdd); | |
1550 | 388134 | } | |
1551 | |||
1552 | 388134 | int ff_attach_decode_data(AVFrame *frame) | |
1553 | { | ||
1554 | AVBufferRef *fdd_buf; | ||
1555 | FrameDecodeData *fdd; | ||
1556 | |||
1557 | av_assert1(!frame->private_ref); | ||
1558 | 388134 | av_buffer_unref(&frame->private_ref); | |
1559 | |||
1560 | 388134 | fdd = av_mallocz(sizeof(*fdd)); | |
1561 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (!fdd) |
1562 | ✗ | return AVERROR(ENOMEM); | |
1563 | |||
1564 | 388134 | fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free, | |
1565 | NULL, AV_BUFFER_FLAG_READONLY); | ||
1566 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (!fdd_buf) { |
1567 | ✗ | av_freep(&fdd); | |
1568 | ✗ | return AVERROR(ENOMEM); | |
1569 | } | ||
1570 | |||
1571 | 388134 | frame->private_ref = fdd_buf; | |
1572 | |||
1573 | 388134 | return 0; | |
1574 | } | ||
1575 | |||
1576 | 388134 | int ff_get_buffer(AVCodecContext *avctx, AVFrame *frame, int flags) | |
1577 | { | ||
1578 | 388134 | const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel); | |
1579 | 388134 | int override_dimensions = 1; | |
1580 | int ret; | ||
1581 | |||
1582 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 388134 times.
|
388134 | av_assert0(av_codec_is_decoder(avctx->codec)); |
1583 | |||
1584 |
2/2✓ Branch 0 taken 84693 times.
✓ Branch 1 taken 303441 times.
|
388134 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) { |
1585 |
2/4✓ Branch 0 taken 84693 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84693 times.
✗ Branch 3 not taken.
|
169386 | if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN || |
1586 |
1/2✗ Branch 1 not taken.
✓ Branch 2 taken 84693 times.
|
169386 | (ret = av_image_check_size2(FFALIGN(avctx->width, STRIDE_ALIGN), avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx)) < 0 || avctx->pix_fmt<0) { |
1587 | ✗ | av_log(avctx, AV_LOG_ERROR, "video_get_buffer: image parameters invalid\n"); | |
1588 | ✗ | ret = AVERROR(EINVAL); | |
1589 | ✗ | goto fail; | |
1590 | } | ||
1591 | |||
1592 |
3/4✓ Branch 0 taken 729 times.
✓ Branch 1 taken 83964 times.
✗ Branch 2 not taken.
✓ Branch 3 taken 729 times.
|
84693 | if (frame->width <= 0 || frame->height <= 0) { |
1593 | 83964 | frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres)); | |
1594 | 83964 | frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres)); | |
1595 | 83964 | override_dimensions = 0; | |
1596 | } | ||
1597 | |||
1598 |
4/8✓ Branch 0 taken 84693 times.
✗ Branch 1 not taken.
✓ Branch 2 taken 84693 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 84693 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 84693 times.
|
84693 | if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) { |
1599 | ✗ | av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n"); | |
1600 | ✗ | ret = AVERROR(EINVAL); | |
1601 | ✗ | goto fail; | |
1602 | } | ||
1603 |
1/2✓ Branch 0 taken 303441 times.
✗ Branch 1 not taken.
|
303441 | } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) { |
1604 | #if FF_API_OLD_CHANNEL_LAYOUT | ||
1605 | FF_DISABLE_DEPRECATION_WARNINGS | ||
1606 | /* compat layer for old-style get_buffer() implementations */ | ||
1607 | 303441 | avctx->channels = avctx->ch_layout.nb_channels; | |
1608 | 606882 | avctx->channel_layout = (avctx->ch_layout.order == AV_CHANNEL_ORDER_NATIVE) ? | |
1609 |
2/2✓ Branch 0 taken 300675 times.
✓ Branch 1 taken 2766 times.
|
303441 | avctx->ch_layout.u.mask : 0; |
1610 | FF_ENABLE_DEPRECATION_WARNINGS | ||
1611 | #endif | ||
1612 | |||
1613 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 303441 times.
|
303441 | if (frame->nb_samples * (int64_t)avctx->ch_layout.nb_channels > avctx->max_samples) { |
1614 | ✗ | av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples); | |
1615 | ✗ | ret = AVERROR(EINVAL); | |
1616 | ✗ | goto fail; | |
1617 | } | ||
1618 | } | ||
1619 | 388134 | ret = ff_decode_frame_props(avctx, frame); | |
1620 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (ret < 0) |
1621 | ✗ | goto fail; | |
1622 | |||
1623 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (hwaccel) { |
1624 | ✗ | if (hwaccel->alloc_frame) { | |
1625 | ✗ | ret = hwaccel->alloc_frame(avctx, frame); | |
1626 | ✗ | goto end; | |
1627 | } | ||
1628 | } else | ||
1629 | 388134 | avctx->sw_pix_fmt = avctx->pix_fmt; | |
1630 | |||
1631 | 388134 | ret = avctx->get_buffer2(avctx, frame, flags); | |
1632 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (ret < 0) |
1633 | ✗ | goto fail; | |
1634 | |||
1635 | 388134 | validate_avframe_allocation(avctx, frame); | |
1636 | |||
1637 | 388134 | ret = ff_attach_decode_data(frame); | |
1638 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (ret < 0) |
1639 | ✗ | goto fail; | |
1640 | |||
1641 | 388134 | end: | |
1642 |
4/4✓ Branch 0 taken 303441 times.
✓ Branch 1 taken 84693 times.
✓ Branch 2 taken 729 times.
✓ Branch 3 taken 83964 times.
|
388134 | if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions && |
1643 |
2/2✓ Branch 1 taken 33839 times.
✓ Branch 2 taken 50125 times.
|
83964 | !(ffcodec(avctx->codec)->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) { |
1644 | 50125 | frame->width = avctx->width; | |
1645 | 50125 | frame->height = avctx->height; | |
1646 | } | ||
1647 | |||
1648 | 338009 | fail: | |
1649 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 388134 times.
|
388134 | if (ret < 0) { |
1650 | ✗ | av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n"); | |
1651 | ✗ | av_frame_unref(frame); | |
1652 | } | ||
1653 | |||
1654 | 388134 | return ret; | |
1655 | } | ||
1656 | |||
1657 | 7702 | static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags) | |
1658 | { | ||
1659 | AVFrame *tmp; | ||
1660 | int ret; | ||
1661 | |||
1662 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7702 times.
|
7702 | av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO); |
1663 | |||
1664 |
5/8✓ Branch 0 taken 7553 times.
✓ Branch 1 taken 149 times.
✓ Branch 2 taken 7553 times.
✗ Branch 3 not taken.
✓ Branch 4 taken 7553 times.
✗ Branch 5 not taken.
✗ Branch 6 not taken.
✓ Branch 7 taken 7553 times.
|
7702 | if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) { |
1665 | ✗ | av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n", | |
1666 | ✗ | frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt)); | |
1667 | ✗ | av_frame_unref(frame); | |
1668 | } | ||
1669 | |||
1670 |
2/2✓ Branch 0 taken 149 times.
✓ Branch 1 taken 7553 times.
|
7702 | if (!frame->data[0]) |
1671 | 149 | return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF); | |
1672 | |||
1673 |
4/4✓ Branch 0 taken 7552 times.
✓ Branch 1 taken 1 times.
✓ Branch 3 taken 5916 times.
✓ Branch 4 taken 1636 times.
|
7553 | if ((flags & FF_REGET_BUFFER_FLAG_READONLY) || av_frame_is_writable(frame)) |
1674 | 5917 | return ff_decode_frame_props(avctx, frame); | |
1675 | |||
1676 | 1636 | tmp = av_frame_alloc(); | |
1677 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1636 times.
|
1636 | if (!tmp) |
1678 | ✗ | return AVERROR(ENOMEM); | |
1679 | |||
1680 | 1636 | av_frame_move_ref(tmp, frame); | |
1681 | |||
1682 | 1636 | ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF); | |
1683 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1636 times.
|
1636 | if (ret < 0) { |
1684 | ✗ | av_frame_free(&tmp); | |
1685 | ✗ | return ret; | |
1686 | } | ||
1687 | |||
1688 | 1636 | av_frame_copy(frame, tmp); | |
1689 | 1636 | av_frame_free(&tmp); | |
1690 | |||
1691 | 1636 | return 0; | |
1692 | } | ||
1693 | |||
1694 | 7702 | int ff_reget_buffer(AVCodecContext *avctx, AVFrame *frame, int flags) | |
1695 | { | ||
1696 | 7702 | int ret = reget_buffer_internal(avctx, frame, flags); | |
1697 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 7702 times.
|
7702 | if (ret < 0) |
1698 | ✗ | av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n"); | |
1699 | 7702 | return ret; | |
1700 | } | ||
1701 | |||
1702 | 14217 | int ff_decode_preinit(AVCodecContext *avctx) | |
1703 | { | ||
1704 | 14217 | AVCodecInternal *avci = avctx->internal; | |
1705 | 14217 | int ret = 0; | |
1706 | |||
1707 | /* if the decoder init function was already called previously, | ||
1708 | * free the already allocated subtitle_header before overwriting it */ | ||
1709 | 14217 | av_freep(&avctx->subtitle_header); | |
1710 | |||
1711 |
2/4✓ Branch 0 taken 14217 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14217 times.
|
14217 | if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) { |
1712 | ✗ | av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n", | |
1713 | ✗ | avctx->codec->max_lowres); | |
1714 | ✗ | avctx->lowres = avctx->codec->max_lowres; | |
1715 | } | ||
1716 |
2/2✓ Branch 0 taken 6 times.
✓ Branch 1 taken 14211 times.
|
14217 | if (avctx->sub_charenc) { |
1717 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) { |
1718 | ✗ | av_log(avctx, AV_LOG_ERROR, "Character encoding is only " | |
1719 | "supported with subtitles codecs\n"); | ||
1720 | ✗ | return AVERROR(EINVAL); | |
1721 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | } else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) { |
1722 | ✗ | av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, " | |
1723 | "subtitles character encoding will be ignored\n", | ||
1724 | ✗ | avctx->codec_descriptor->name); | |
1725 | ✗ | avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING; | |
1726 | } else { | ||
1727 | /* input character encoding is set for a text based subtitle | ||
1728 | * codec at this point */ | ||
1729 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC) |
1730 | 6 | avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER; | |
1731 | |||
1732 |
1/2✓ Branch 0 taken 6 times.
✗ Branch 1 not taken.
|
6 | if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) { |
1733 | #if CONFIG_ICONV | ||
1734 | 6 | iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc); | |
1735 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 6 times.
|
6 | if (cd == (iconv_t)-1) { |
1736 | ✗ | ret = AVERROR(errno); | |
1737 | ✗ | av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context " | |
1738 | "with input character encoding \"%s\"\n", avctx->sub_charenc); | ||
1739 | ✗ | return ret; | |
1740 | } | ||
1741 | 6 | iconv_close(cd); | |
1742 | #else | ||
1743 | av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles " | ||
1744 | "conversion needs a libavcodec built with iconv support " | ||
1745 | "for this codec\n"); | ||
1746 | return AVERROR(ENOSYS); | ||
1747 | #endif | ||
1748 | } | ||
1749 | } | ||
1750 | } | ||
1751 | |||
1752 | 14217 | avctx->pts_correction_num_faulty_pts = | |
1753 | 14217 | avctx->pts_correction_num_faulty_dts = 0; | |
1754 | 14217 | avctx->pts_correction_last_pts = | |
1755 | 14217 | avctx->pts_correction_last_dts = INT64_MIN; | |
1756 | |||
1757 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY |
1758 | ✗ | && avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO) | |
1759 | ✗ | av_log(avctx, AV_LOG_WARNING, | |
1760 | "gray decoding requested but not enabled at configuration time\n"); | ||
1761 |
2/2✓ Branch 0 taken 5 times.
✓ Branch 1 taken 14212 times.
|
14217 | if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) { |
1762 | 5 | avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS; | |
1763 | } | ||
1764 | |||
1765 | 14217 | avci->in_pkt = av_packet_alloc(); | |
1766 | 14217 | avci->last_pkt_props = av_packet_alloc(); | |
1767 |
2/4✓ Branch 0 taken 14217 times.
✗ Branch 1 not taken.
✗ Branch 2 not taken.
✓ Branch 3 taken 14217 times.
|
14217 | if (!avci->in_pkt || !avci->last_pkt_props) |
1768 | ✗ | return AVERROR(ENOMEM); | |
1769 | |||
1770 | 14217 | ret = decode_bsfs_init(avctx); | |
1771 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (ret < 0) |
1772 | ✗ | return ret; | |
1773 | |||
1774 | #if FF_API_DROPCHANGED | ||
1775 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 14217 times.
|
14217 | if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) |
1776 | ✗ | av_log(avctx, AV_LOG_WARNING, "The dropchanged flag is deprecated.\n"); | |
1777 | #endif | ||
1778 | |||
1779 | 14217 | return 0; | |
1780 | } | ||
1781 | |||
1782 | 1663 | int ff_copy_palette(void *dst, const AVPacket *src, void *logctx) | |
1783 | { | ||
1784 | size_t size; | ||
1785 | 1663 | const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size); | |
1786 | |||
1787 |
3/4✓ Branch 0 taken 32 times.
✓ Branch 1 taken 1631 times.
✓ Branch 2 taken 32 times.
✗ Branch 3 not taken.
|
1663 | if (pal && size == AVPALETTE_SIZE) { |
1788 | 32 | memcpy(dst, pal, AVPALETTE_SIZE); | |
1789 | 32 | return 1; | |
1790 |
1/2✗ Branch 0 not taken.
✓ Branch 1 taken 1631 times.
|
1631 | } else if (pal) { |
1791 | ✗ | av_log(logctx, AV_LOG_ERROR, | |
1792 | "Palette size %"SIZE_SPECIFIER" is wrong\n", size); | ||
1793 | } | ||
1794 | 1631 | return 0; | |
1795 | } | ||
1796 | |||
1797 | 57557 | int ff_hwaccel_frame_priv_alloc(AVCodecContext *avctx, void **hwaccel_picture_private, | |
1798 | AVBufferRef **hwaccel_priv_buf) | ||
1799 | { | ||
1800 | 57557 | const FFHWAccel *hwaccel = ffhwaccel(avctx->hwaccel); | |
1801 | AVBufferRef *ref; | ||
1802 | AVHWFramesContext *frames_ctx; | ||
1803 | uint8_t *data; | ||
1804 | |||
1805 |
1/4✗ Branch 0 not taken.
✓ Branch 1 taken 57557 times.
✗ Branch 2 not taken.
✗ Branch 3 not taken.
|
57557 | if (!hwaccel || !hwaccel->frame_priv_data_size) |
1806 | 57557 | return 0; | |
1807 | |||
1808 | ✗ | av_assert0(!*hwaccel_picture_private); | |
1809 | ✗ | data = av_mallocz(hwaccel->frame_priv_data_size); | |
1810 | ✗ | if (!data) | |
1811 | ✗ | return AVERROR(ENOMEM); | |
1812 | |||
1813 | ✗ | frames_ctx = (AVHWFramesContext *)avctx->hw_frames_ctx->data; | |
1814 | |||
1815 | ✗ | ref = av_buffer_create(data, hwaccel->frame_priv_data_size, | |
1816 | ✗ | hwaccel->free_frame_priv, | |
1817 | ✗ | frames_ctx->device_ctx, 0); | |
1818 | ✗ | if (!ref) { | |
1819 | ✗ | av_free(data); | |
1820 | ✗ | return AVERROR(ENOMEM); | |
1821 | } | ||
1822 | |||
1823 | ✗ | *hwaccel_priv_buf = ref; | |
1824 | ✗ | *hwaccel_picture_private = ref->data; | |
1825 | |||
1826 | ✗ | return 0; | |
1827 | } | ||
1828 | |||
1829 | 100 | void ff_decode_flush_buffers(AVCodecContext *avctx) | |
1830 | { | ||
1831 | 100 | AVCodecInternal *avci = avctx->internal; | |
1832 | 100 | DecodeContext *dc = decode_ctx(avci); | |
1833 | |||
1834 | 100 | av_packet_unref(avci->last_pkt_props); | |
1835 | 100 | av_packet_unref(avci->in_pkt); | |
1836 | |||
1837 | 100 | avctx->pts_correction_last_pts = | |
1838 | 100 | avctx->pts_correction_last_dts = INT64_MIN; | |
1839 | |||
1840 | 100 | av_bsf_flush(avci->bsf); | |
1841 | |||
1842 | 100 | dc->nb_draining_errors = 0; | |
1843 | 100 | dc->draining_started = 0; | |
1844 | 100 | } | |
1845 | |||
1846 | 14293 | AVCodecInternal *ff_decode_internal_alloc(void) | |
1847 | { | ||
1848 | 14293 | return av_mallocz(sizeof(DecodeContext)); | |
1849 | } | ||
1850 |