Permalink
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Jan 17, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Mar 1, 2021
Mar 1, 2021
Apr 25, 2020
Apr 25, 2020
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Sep 25, 2020
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
May 1, 2017
Oct 26, 2016
Apr 22, 2017
Oct 26, 2016
Oct 26, 2016
Apr 22, 2017
Apr 7, 2017
Oct 26, 2016
Jun 14, 2017
Apr 7, 2017
Jan 6, 2020
Apr 7, 2017
Apr 7, 2017
Oct 26, 2016
Apr 7, 2017
Apr 7, 2017
Apr 7, 2017
Apr 7, 2017
Apr 7, 2017
Apr 22, 2017
Apr 22, 2017
Oct 26, 2016
Apr 22, 2017
Oct 26, 2016
May 1, 2017
Apr 28, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Sep 25, 2020
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Dec 13, 2020
Oct 13, 2017
Nov 10, 2017
Oct 26, 2016
Oct 26, 2016
Nov 12, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Dec 18, 2016
May 8, 2017
Dec 18, 2016
Jul 22, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Dec 18, 2016
Oct 26, 2016
Apr 14, 2019
Apr 14, 2019
Oct 26, 2016
Jan 25, 2021
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Nov 9, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Nov 12, 2016
Nov 12, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Mar 4, 2021
Apr 7, 2017
Mar 4, 2021
Apr 7, 2017
Mar 4, 2021
Mar 4, 2021
Apr 7, 2017
Apr 7, 2017
Mar 4, 2021
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Apr 7, 2017
Mar 4, 2021
Mar 4, 2021
Mar 4, 2021
Mar 4, 2021
Mar 4, 2021
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 19, 2017
Oct 19, 2017
Oct 25, 2017
Oct 25, 2017
Oct 19, 2017
Jan 29, 2018
Jan 29, 2018
Oct 19, 2017
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Apr 7, 2017
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Oct 25, 2017
Oct 26, 2016
Jan 17, 2017
Oct 26, 2016
Jan 17, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Jul 13, 2020
Oct 26, 2016
Jul 13, 2020
Apr 7, 2017
Oct 26, 2016
Jan 17, 2017
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Oct 26, 2016
Jun 22, 2017
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Mar 1, 2021
Oct 26, 2016
Oct 26, 2016
Mar 12, 2021
Oct 26, 2016
Mar 12, 2021
Oct 26, 2016
Apr 7, 2017
Apr 22, 2017
Apr 7, 2017
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Apr 7, 2017
Oct 26, 2016
Oct 13, 2017
Nov 10, 2017
Oct 13, 2017
Apr 7, 2017
Oct 13, 2020
Apr 7, 2017
Sep 25, 2019
Oct 26, 2016
Oct 26, 2016
Oct 26, 2016
Oct 13, 2017
Oct 26, 2016
Dec 18, 2016
Oct 26, 2016
May 29, 2020
Aug 30, 2019
Oct 26, 2016
Apr 7, 2017
Oct 26, 2016
Oct 26, 2016
Apr 7, 2017
Mar 9, 2021
Mar 16, 2021
Mar 9, 2021
Mar 16, 2021
Mar 9, 2021
Mar 17, 2021
Newer
100644
2107 lines (1802 sloc)
69.3 KB
1
/*
2
* generic decoding-related code
3
*
5
*
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
*
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
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
30
#include "libavutil/avassert.h"
33
#include "libavutil/common.h"
34
#include "libavutil/frame.h"
35
#include "libavutil/hwcontext.h"
36
#include "libavutil/imgutils.h"
40
41
#include "avcodec.h"
42
#include "bytestream.h"
45
#include "internal.h"
46
#include "thread.h"
47
48
typedef struct FramePool {
49
/**
50
* Pools for each data plane. For audio all the planes have the same size,
51
* so only pools[0] is used.
52
*/
53
AVBufferPool *pools[4];
54
55
/*
56
* Pool parameters
57
*/
58
int format;
59
int width, height;
60
int stride_align[AV_NUM_DATA_POINTERS];
61
int linesize[4];
62
int planes;
63
int channels;
64
int samples;
65
} FramePool;
66
68
{
71
const uint8_t *data;
72
uint32_t flags;
74
75
data = av_packet_get_side_data(avpkt, AV_PKT_DATA_PARAM_CHANGE, &size);
76
if (!data)
77
return 0;
78
79
if (!(avctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE)) {
80
av_log(avctx, AV_LOG_ERROR, "This decoder does not support parameter "
81
"changes, but PARAM_CHANGE side data was sent to it.\n");
82
ret = AVERROR(EINVAL);
83
goto fail2;
84
}
85
86
if (size < 4)
87
goto fail;
88
89
flags = bytestream_get_le32(&data);
90
size -= 4;
91
92
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_COUNT) {
93
if (size < 4)
94
goto fail;
95
val = bytestream_get_le32(&data);
96
if (val <= 0 || val > INT_MAX) {
97
av_log(avctx, AV_LOG_ERROR, "Invalid channel count");
98
ret = AVERROR_INVALIDDATA;
99
goto fail2;
100
}
101
avctx->channels = val;
102
size -= 4;
103
}
104
if (flags & AV_SIDE_DATA_PARAM_CHANGE_CHANNEL_LAYOUT) {
105
if (size < 8)
106
goto fail;
107
avctx->channel_layout = bytestream_get_le64(&data);
108
size -= 8;
109
}
110
if (flags & AV_SIDE_DATA_PARAM_CHANGE_SAMPLE_RATE) {
111
if (size < 4)
112
goto fail;
113
val = bytestream_get_le32(&data);
114
if (val <= 0 || val > INT_MAX) {
115
av_log(avctx, AV_LOG_ERROR, "Invalid sample rate");
116
ret = AVERROR_INVALIDDATA;
117
goto fail2;
118
}
119
avctx->sample_rate = val;
120
size -= 4;
121
}
122
if (flags & AV_SIDE_DATA_PARAM_CHANGE_DIMENSIONS) {
123
if (size < 8)
124
goto fail;
125
avctx->width = bytestream_get_le32(&data);
126
avctx->height = bytestream_get_le32(&data);
127
size -= 8;
128
ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
129
if (ret < 0)
130
goto fail2;
131
}
132
133
return 0;
134
fail:
135
av_log(avctx, AV_LOG_ERROR, "PARAM_CHANGE side data too small.\n");
136
ret = AVERROR_INVALIDDATA;
137
fail2:
138
if (ret < 0) {
139
av_log(avctx, AV_LOG_ERROR, "Error applying parameter changes.\n");
140
if (avctx->err_recognition & AV_EF_EXPLODE)
141
return ret;
142
}
143
return 0;
144
}
145
149
{
150
int ret = av_packet_copy_props(dst, src);
151
if (ret < 0)
152
return ret;
153
154
dst->size = src->size; // HACK: Needed for ff_decode_frame_props().
155
dst->data = (void*)1; // HACK: Needed for IS_EMPTY().
156
157
return 0;
158
}
159
165
if (IS_EMPTY(avci->last_pkt_props)) {
166
if (av_fifo_size(avci->pkt_props) >= sizeof(*pkt)) {
167
av_fifo_generic_read(avci->pkt_props, avci->last_pkt_props,
168
sizeof(*avci->last_pkt_props), NULL);
169
} else
170
return copy_packet_props(avci->last_pkt_props, pkt);
171
}
172
173
if (av_fifo_space(avci->pkt_props) < sizeof(*pkt)) {
174
ret = av_fifo_grow(avci->pkt_props, sizeof(*pkt));
175
if (ret < 0)
176
return ret;
177
}
178
179
ret = copy_packet_props(&tmp, pkt);
196
ret = av_bsf_list_parse_str(avctx->codec->bsfs, &avci->bsf);
197
if (ret < 0) {
198
av_log(avctx, AV_LOG_ERROR, "Error parsing decoder bitstream filters '%s': %s\n", avctx->codec->bsfs, av_err2str(ret));
199
if (ret != AVERROR(ENOMEM))
204
/* We do not currently have an API for passing the input timebase into decoders,
205
* but no filters used here should actually need it.
206
* So we make up some plausible-looking number (the MPEG 90kHz timebase) */
207
avci->bsf->time_base_in = (AVRational){ 1, 90000 };
208
ret = avcodec_parameters_from_context(avci->bsf->par_in, avctx);
209
if (ret < 0)
210
goto fail;
223
{
225
int ret;
226
235
236
ret = extract_packet_props(avctx->internal, pkt);
237
if (ret < 0)
238
goto finish;
239
240
ret = apply_param_change(avctx, pkt);
241
if (ret < 0)
242
goto finish;
243
248
255
/**
256
* Attempt to guess proper monotonic timestamps for decoded video frames
257
* which might have incorrect times. Input timestamps may wrap around, in
258
* which case the output will as well.
259
*
260
* @param pts the pts field of the decoded AVPacket, as passed through
261
* AVFrame.pts
262
* @param dts the dts field of the decoded AVPacket
263
* @return one of the input values, may be AV_NOPTS_VALUE
264
*/
265
static int64_t guess_correct_pts(AVCodecContext *ctx,
266
int64_t reordered_pts, int64_t dts)
267
{
268
int64_t pts = AV_NOPTS_VALUE;
269
270
if (dts != AV_NOPTS_VALUE) {
271
ctx->pts_correction_num_faulty_dts += dts <= ctx->pts_correction_last_dts;
272
ctx->pts_correction_last_dts = dts;
273
} else if (reordered_pts != AV_NOPTS_VALUE)
274
ctx->pts_correction_last_dts = reordered_pts;
275
276
if (reordered_pts != AV_NOPTS_VALUE) {
277
ctx->pts_correction_num_faulty_pts += reordered_pts <= ctx->pts_correction_last_pts;
278
ctx->pts_correction_last_pts = reordered_pts;
279
} else if(dts != AV_NOPTS_VALUE)
280
ctx->pts_correction_last_pts = dts;
281
282
if ((ctx->pts_correction_num_faulty_pts<=ctx->pts_correction_num_faulty_dts || dts == AV_NOPTS_VALUE)
283
&& reordered_pts != AV_NOPTS_VALUE)
284
pts = reordered_pts;
285
else
286
pts = dts;
287
288
return pts;
289
}
290
291
/*
292
* The core of the receive_frame_wrapper for the decoders implementing
293
* the simple API. Certain decoders might consume partial packets without
294
* returning any output, so this function needs to be called in a loop until it
295
* returns EAGAIN.
296
**/
297
static inline int decode_simple_internal(AVCodecContext *avctx, AVFrame *frame, int64_t *discarded_samples)
298
{
299
AVCodecInternal *avci = avctx->internal;
300
DecodeSimpleContext *ds = &avci->ds;
301
AVPacket *pkt = ds->in_pkt;
303
int ret;
304
305
if (!pkt->data && !avci->draining) {
306
av_packet_unref(pkt);
307
ret = ff_decode_get_packet(avctx, pkt);
308
if (ret < 0 && ret != AVERROR_EOF)
309
return ret;
310
}
311
312
// Some codecs (at least wma lossless) will crash when feeding drain packets
313
// after EOF was signaled.
315
return AVERROR_EOF;
316
317
if (!pkt->data &&
318
!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
319
avctx->active_thread_type & FF_THREAD_FRAME))
320
return AVERROR_EOF;
321
326
} else {
329
if (!(avctx->codec->caps_internal & FF_CODEC_CAP_SETS_PKT_DTS))
330
frame->pkt_dts = pkt->dts;
335
/* get_buffer is supposed to set frame parameters */
336
if (!(avctx->codec->capabilities & AV_CODEC_CAP_DR1)) {
337
if (!frame->sample_aspect_ratio.num) frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
338
if (!frame->width) frame->width = avctx->width;
339
if (!frame->height) frame->height = avctx->height;
340
if (frame->format == AV_PIX_FMT_NONE) frame->format = avctx->pix_fmt;
341
}
342
}
346
347
if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
348
if (frame->flags & AV_FRAME_FLAG_DISCARD)
349
got_frame = 0;
350
} else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
353
uint32_t discard_padding = 0;
354
uint8_t skip_reason = 0;
355
uint8_t discard_reason = 0;
356
358
if (frame->format == AV_SAMPLE_FMT_NONE)
359
frame->format = avctx->sample_fmt;
368
side= av_packet_get_side_data(avci->last_pkt_props, AV_PKT_DATA_SKIP_SAMPLES, &side_size);
371
discard_padding = AV_RL32(side + 4);
372
av_log(avctx, AV_LOG_DEBUG, "skip %d / discard %d samples due to side data\n",
394
av_samples_copy(frame->extended_data, frame->extended_data, 0, avci->skip_samples,
395
frame->nb_samples - avci->skip_samples, avctx->channels, frame->format);
398
(AVRational){1, avctx->sample_rate},
399
avctx->pkt_timebase);
400
if(frame->pts!=AV_NOPTS_VALUE)
401
frame->pts += diff_ts;
402
#if FF_API_PKT_PTS
403
FF_DISABLE_DEPRECATION_WARNINGS
404
if(frame->pkt_pts!=AV_NOPTS_VALUE)
405
frame->pkt_pts += diff_ts;
406
FF_ENABLE_DEPRECATION_WARNINGS
407
#endif
408
if(frame->pkt_dts!=AV_NOPTS_VALUE)
409
frame->pkt_dts += diff_ts;
412
} else {
413
av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for skipped samples.\n");
414
}
415
av_log(avctx, AV_LOG_DEBUG, "skip %d/%d samples\n",
422
424
!(avctx->flags2 & AV_CODEC_FLAG2_SKIP_MANUAL)) {
425
if (discard_padding == frame->nb_samples) {
428
} else {
429
if(avctx->pkt_timebase.num && avctx->sample_rate) {
430
int64_t diff_ts = av_rescale_q(frame->nb_samples - discard_padding,
431
(AVRational){1, avctx->sample_rate},
432
avctx->pkt_timebase);
434
} else {
435
av_log(avctx, AV_LOG_WARNING, "Could not update timestamps for discarded samples.\n");
436
}
437
av_log(avctx, AV_LOG_DEBUG, "discard %d/%d samples\n",
438
(int)discard_padding, frame->nb_samples);
439
frame->nb_samples -= discard_padding;
440
}
441
}
442
444
AVFrameSideData *fside = av_frame_new_side_data(frame, AV_FRAME_DATA_SKIP_SAMPLES, 10);
445
if (fside) {
447
AV_WL32(fside->data + 4, discard_padding);
448
AV_WL8(fside->data + 8, skip_reason);
449
AV_WL8(fside->data + 9, discard_reason);
455
if (avctx->codec->type == AVMEDIA_TYPE_AUDIO &&
456
!avci->showed_multi_packet_warning &&
457
ret >= 0 && ret != pkt->size && !(avctx->codec->capabilities & AV_CODEC_CAP_SUBFRAMES)) {
458
av_log(avctx, AV_LOG_WARNING, "Multiple frames in a packet.\n");
459
avci->showed_multi_packet_warning = 1;
460
}
461
465
if (ret >= 0 && avctx->codec->type == AVMEDIA_TYPE_VIDEO && !(avctx->flags & AV_CODEC_FLAG_TRUNCATED))
466
ret = pkt->size;
467
468
#if FF_API_AVCTX_TIMEBASE
469
if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
470
avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
472
473
/* do not stop draining when actual_got_frame != 0 or ret < 0 */
474
/* got_frame == 0 but actual_got_frame != 0 when frame is discarded */
476
if (ret < 0) {
477
/* prevent infinite loop if a decoder wrongly always return error on draining */
478
/* reasonable nb_errors_max = maximum b frames + thread count */
479
int nb_errors_max = 20 + (HAVE_THREADS && avctx->active_thread_type & FF_THREAD_FRAME ?
480
avctx->thread_count : 1);
481
482
if (avci->nb_draining_errors++ >= nb_errors_max) {
483
av_log(avctx, AV_LOG_ERROR, "Too many errors when draining, this is a bug. "
484
"Stop draining and force EOF.\n");
485
avci->draining_done = 1;
486
ret = AVERROR_BUG;
487
}
488
} else {
489
avci->draining_done = 1;
490
}
491
}
496
500
} else {
501
int consumed = ret;
502
506
pkt->pts = AV_NOPTS_VALUE;
507
pkt->dts = AV_NOPTS_VALUE;
508
avci->last_pkt_props->pts = AV_NOPTS_VALUE;
509
avci->last_pkt_props->dts = AV_NOPTS_VALUE;
510
}
511
512
if (got_frame)
513
av_assert0(frame->buf[0]);
514
515
return ret < 0 ? ret : 0;
516
}
517
518
static int decode_simple_receive_frame(AVCodecContext *avctx, AVFrame *frame)
519
{
520
int ret;
524
if (discarded_samples > avctx->max_samples)
525
return AVERROR(EAGAIN);
526
ret = decode_simple_internal(avctx, frame, &discarded_samples);
530
531
return 0;
532
}
533
535
{
537
int ret;
538
546
ret = decode_simple_receive_frame(avctx, frame);
547
548
if (ret == AVERROR_EOF)
549
avci->draining_done = 1;
550
552
frame->best_effort_timestamp = guess_correct_pts(avctx,
553
frame->pts,
554
frame->pkt_dts);
555
556
/* the only case where decode data is not set should be decoders
557
* that do not call ff_get_buffer() */
558
av_assert0((frame->private_ref && frame->private_ref->size == sizeof(FrameDecodeData)) ||
559
!(avctx->codec->capabilities & AV_CODEC_CAP_DR1));
560
561
if (frame->private_ref) {
562
FrameDecodeData *fdd = (FrameDecodeData*)frame->private_ref->data;
563
564
if (fdd->post_process) {
565
ret = fdd->post_process(avctx, frame);
566
if (ret < 0) {
567
av_frame_unref(frame);
568
return ret;
569
}
570
}
571
}
577
return ret;
578
}
579
580
int attribute_align_arg avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
581
{
582
AVCodecInternal *avci = avctx->internal;
585
if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
586
return AVERROR(EINVAL);
587
588
if (avctx->internal->draining)
589
return AVERROR_EOF;
590
594
av_packet_unref(avci->buffer_pkt);
595
if (avpkt && (avpkt->data || avpkt->side_data_elems)) {
599
}
600
607
if (!avci->buffer_frame->buf[0]) {
608
ret = decode_receive_frame_internal(avctx, avci->buffer_frame);
609
if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
610
return ret;
611
}
612
614
}
615
616
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
617
{
618
/* make sure we are noisy about decoders returning invalid cropping data */
619
if (frame->crop_left >= INT_MAX - frame->crop_right ||
620
frame->crop_top >= INT_MAX - frame->crop_bottom ||
621
(frame->crop_left + frame->crop_right) >= frame->width ||
622
(frame->crop_top + frame->crop_bottom) >= frame->height) {
623
av_log(avctx, AV_LOG_WARNING,
624
"Invalid cropping information set by a decoder: "
625
"%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER"/%"SIZE_SPECIFIER" "
626
"(frame size %dx%d). This is a bug, please report it\n",
627
frame->crop_left, frame->crop_right, frame->crop_top, frame->crop_bottom,
628
frame->width, frame->height);
629
frame->crop_left = 0;
630
frame->crop_right = 0;
631
frame->crop_top = 0;
632
frame->crop_bottom = 0;
633
return 0;
634
}
635
636
if (!avctx->apply_cropping)
637
return 0;
638
639
return av_frame_apply_cropping(frame, avctx->flags & AV_CODEC_FLAG_UNALIGNED ?
640
AV_FRAME_CROP_UNALIGNED : 0);
643
int attribute_align_arg avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
644
{
647
648
av_frame_unref(frame);
649
650
if (!avcodec_is_open(avctx) || !av_codec_is_decoder(avctx->codec))
651
return AVERROR(EINVAL);
652
653
if (avci->buffer_frame->buf[0]) {
654
av_frame_move_ref(frame, avci->buffer_frame);
655
} else {
656
ret = decode_receive_frame_internal(avctx, frame);
657
if (ret < 0)
658
return ret;
659
}
660
661
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
662
ret = apply_cropping(avctx, frame);
663
if (ret < 0) {
664
av_frame_unref(frame);
665
return ret;
666
}
667
}
668
670
671
if (avctx->flags & AV_CODEC_FLAG_DROPCHANGED) {
672
673
if (avctx->frame_number == 1) {
674
avci->initial_format = frame->format;
675
switch(avctx->codec_type) {
676
case AVMEDIA_TYPE_VIDEO:
677
avci->initial_width = frame->width;
678
avci->initial_height = frame->height;
679
break;
680
case AVMEDIA_TYPE_AUDIO:
681
avci->initial_sample_rate = frame->sample_rate ? frame->sample_rate :
682
avctx->sample_rate;
683
avci->initial_channels = frame->channels;
684
avci->initial_channel_layout = frame->channel_layout;
685
break;
686
}
687
}
688
689
if (avctx->frame_number > 1) {
690
changed = avci->initial_format != frame->format;
691
693
case AVMEDIA_TYPE_VIDEO:
694
changed |= avci->initial_width != frame->width ||
695
avci->initial_height != frame->height;
696
break;
697
case AVMEDIA_TYPE_AUDIO:
698
changed |= avci->initial_sample_rate != frame->sample_rate ||
699
avci->initial_sample_rate != avctx->sample_rate ||
700
avci->initial_channels != frame->channels ||
701
avci->initial_channel_layout != frame->channel_layout;
702
break;
703
}
704
705
if (changed) {
706
avci->changed_frames_dropped++;
707
av_log(avctx, AV_LOG_INFO, "dropped changed frame #%d pts %"PRId64
708
" drop count: %d \n",
709
avctx->frame_number, frame->pts,
710
avci->changed_frames_dropped);
711
av_frame_unref(frame);
712
return AVERROR_INPUT_CHANGED;
713
}
714
}
715
}
716
return 0;
717
}
718
721
static int unrefcount_frame(AVCodecInternal *avci, AVFrame *frame)
722
{
723
int ret;
724
725
/* move the original frame to our backup */
726
av_frame_unref(avci->to_free);
727
av_frame_move_ref(avci->to_free, frame);
728
729
/* now copy everything except the AVBufferRefs back
730
* note that we make a COPY of the side data, so calling av_frame_free() on
731
* the caller's frame will work properly */
732
ret = av_frame_copy_props(frame, avci->to_free);
733
if (ret < 0)
734
return ret;
735
736
memcpy(frame->data, avci->to_free->data, sizeof(frame->data));
737
memcpy(frame->linesize, avci->to_free->linesize, sizeof(frame->linesize));
738
if (avci->to_free->extended_data != avci->to_free->data) {
739
int planes = avci->to_free->channels;
740
int size = planes * sizeof(*frame->extended_data);
741
742
if (!size) {
743
av_frame_unref(frame);
744
return AVERROR_BUG;
745
}
746
747
frame->extended_data = av_malloc(size);
748
if (!frame->extended_data) {
749
av_frame_unref(frame);
750
return AVERROR(ENOMEM);
751
}
752
memcpy(frame->extended_data, avci->to_free->extended_data,
753
size);
754
} else
755
frame->extended_data = frame->data;
756
757
frame->format = avci->to_free->format;
758
frame->width = avci->to_free->width;
759
frame->height = avci->to_free->height;
760
frame->channel_layout = avci->to_free->channel_layout;
761
frame->nb_samples = avci->to_free->nb_samples;
762
frame->channels = avci->to_free->channels;
763
764
return 0;
765
}
766
769
{
770
AVCodecInternal *avci = avctx->internal;
772
774
775
if (avci->draining_done && pkt && pkt->size != 0) {
776
av_log(avctx, AV_LOG_WARNING, "Got unexpected packet after EOF\n");
777
avcodec_flush_buffers(avctx);
778
}
779
781
782
if (avci->compat_decode_partial_size > 0 &&
783
avci->compat_decode_partial_size != pkt->size) {
784
av_log(avctx, AV_LOG_ERROR,
785
"Got unexpected packet size after a partial decode\n");
786
ret = AVERROR(EINVAL);
787
goto finish;
788
}
790
if (!avci->compat_decode_partial_size) {
791
ret = avcodec_send_packet(avctx, pkt);
792
if (ret == AVERROR_EOF)
793
ret = 0;
794
else if (ret == AVERROR(EAGAIN)) {
795
/* we fully drain all the output in each decode call, so this should not
796
* ever happen */
797
ret = AVERROR_BUG;
798
goto finish;
799
} else if (ret < 0)
800
goto finish;
801
}
802
803
while (ret >= 0) {
804
ret = avcodec_receive_frame(avctx, frame);
805
if (ret < 0) {
806
if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
807
ret = 0;
808
goto finish;
809
}
810
812
if (!avctx->refcounted_frames) {
816
}
817
818
*got_frame = 1;
819
frame = avci->compat_decode_frame;
820
} else {
821
if (!avci->compat_decode_warned) {
822
av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_decode_* "
823
"API cannot return all the frames for this decoder. "
824
"Some frames will be dropped. Update your code to the "
825
"new decoding API to fix this.\n");
826
avci->compat_decode_warned = 1;
827
}
828
}
830
if (avci->draining || (!avctx->codec->bsfs && avci->compat_decode_consumed < pkt->size))
835
if (ret == 0) {
836
/* if there are any bsfs then assume full packet is always consumed */
837
if (avctx->codec->bsfs)
838
ret = pkt->size;
839
else
840
ret = FFMIN(avci->compat_decode_consumed, pkt->size);
841
}
842
avci->compat_decode_consumed = 0;
843
avci->compat_decode_partial_size = (ret >= 0) ? pkt->size - ret : 0;
844
848
int attribute_align_arg avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture,
849
int *got_picture_ptr,
855
int attribute_align_arg avcodec_decode_audio4(AVCodecContext *avctx,
856
AVFrame *frame,
857
int *got_frame_ptr,
859
{
861
}
864
865
static void get_subtitle_defaults(AVSubtitle *sub)
866
{
867
memset(sub, 0, sizeof(*sub));
868
sub->pts = AV_NOPTS_VALUE;
869
}
870
871
#define UTF8_MAX_BYTES 4 /* 5 and 6 bytes sequences should not be used */
872
static int recode_subtitle(AVCodecContext *avctx, AVPacket **outpkt,
873
AVPacket *inpkt, AVPacket *buf_pkt)
874
{
875
#if CONFIG_ICONV
876
iconv_t cd = (iconv_t)-1;
877
int ret = 0;
878
char *inb, *outb;
879
size_t inl, outl;
880
#endif
881
882
if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_PRE_DECODER || inpkt->size == 0) {
883
*outpkt = inpkt;
886
887
#if CONFIG_ICONV
888
inb = inpkt->data;
889
inl = inpkt->size;
890
891
if (inl >= INT_MAX / UTF8_MAX_BYTES - AV_INPUT_BUFFER_PADDING_SIZE) {
892
av_log(avctx, AV_LOG_ERROR, "Subtitles packet is too big for recoding\n");
896
cd = iconv_open("UTF-8", avctx->sub_charenc);
897
av_assert0(cd != (iconv_t)-1);
898
899
ret = av_new_packet(buf_pkt, inl * UTF8_MAX_BYTES);
900
if (ret < 0)
901
goto end;
902
ret = av_packet_copy_props(buf_pkt, inpkt);
907
908
if (iconv(cd, &inb, &inl, &outb, &outl) == (size_t)-1 ||
909
iconv(cd, NULL, NULL, &outb, &outl) == (size_t)-1 ||
911
ret = FFMIN(AVERROR(errno), -1);
912
av_log(avctx, AV_LOG_ERROR, "Unable to recode subtitle event \"%s\" "
913
"from %s to UTF-8\n", inpkt->data, avctx->sub_charenc);
914
goto end;
915
}
916
buf_pkt->size -= outl;
917
memset(buf_pkt->data + buf_pkt->size, 0, outl);
918
*outpkt = buf_pkt;
919
926
return ret;
927
#else
928
av_log(avctx, AV_LOG_ERROR, "requesting subtitles recoding without iconv");
929
return AVERROR(EINVAL);
930
#endif
931
}
932
933
static int utf8_check(const uint8_t *str)
934
{
935
const uint8_t *byte;
936
uint32_t codepoint, min;
937
938
while (*str) {
939
byte = str;
940
GET_UTF8(codepoint, *(byte++), return 0;);
941
min = byte - str == 1 ? 0 : byte - str == 2 ? 0x80 :
942
1 << (5 * (byte - str) - 4);
943
if (codepoint < min || codepoint >= 0x110000 ||
944
codepoint == 0xFFFE /* BOM */ ||
945
codepoint >= 0xD800 && codepoint <= 0xDFFF /* surrogates */)
946
return 0;
947
str = byte;
948
}
949
return 1;
950
}
951
952
#if FF_API_ASS_TIMING
953
static void insert_ts(AVBPrint *buf, int ts)
954
{
955
if (ts == -1) {
956
av_bprintf(buf, "9:59:59.99,");
957
} else {
958
int h, m, s;
959
960
h = ts/360000; ts -= 360000*h;
961
m = ts/ 6000; ts -= 6000*m;
962
s = ts/ 100; ts -= 100*s;
963
av_bprintf(buf, "%d:%02d:%02d.%02d,", h, m, s, ts);
964
}
965
}
966
967
static int convert_sub_to_old_ass_form(AVSubtitle *sub, const AVPacket *pkt, AVRational tb)
968
{
969
int i;
970
AVBPrint buf;
971
972
av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
973
974
for (i = 0; i < sub->num_rects; i++) {
975
char *final_dialog;
976
const char *dialog;
977
AVSubtitleRect *rect = sub->rects[i];
978
int ts_start, ts_duration = -1;
979
long int layer;
980
981
if (rect->type != SUBTITLE_ASS || !strncmp(rect->ass, "Dialogue: ", 10))
982
continue;
983
984
av_bprint_clear(&buf);
985
986
/* skip ReadOrder */
987
dialog = strchr(rect->ass, ',');
988
if (!dialog)
989
continue;
990
dialog++;
991
992
/* extract Layer or Marked */
993
layer = strtol(dialog, (char**)&dialog, 10);
994
if (*dialog != ',')
995
continue;
996
dialog++;
997
998
/* rescale timing to ASS time base (ms) */
999
ts_start = av_rescale_q(pkt->pts, tb, av_make_q(1, 100));
1000
if (pkt->duration != -1)
1001
ts_duration = av_rescale_q(pkt->duration, tb, av_make_q(1, 100));
1002
sub->end_display_time = FFMAX(sub->end_display_time, 10 * ts_duration);
1003
1004
/* construct ASS (standalone file form with timestamps) string */
1005
av_bprintf(&buf, "Dialogue: %ld,", layer);
1006
insert_ts(&buf, ts_start);
1007
insert_ts(&buf, ts_duration == -1 ? -1 : ts_start + ts_duration);
1008
av_bprintf(&buf, "%s\r\n", dialog);
1009
1010
final_dialog = av_strdup(buf.str);
1011
if (!av_bprint_is_complete(&buf) || !final_dialog) {
1012
av_freep(&final_dialog);
1013
av_bprint_finalize(&buf, NULL);
1014
return AVERROR(ENOMEM);
1015
}
1016
av_freep(&rect->ass);
1017
rect->ass = final_dialog;
1018
}
1019
1020
av_bprint_finalize(&buf, NULL);
1021
return 0;
1022
}
1024
1025
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub,
1026
int *got_sub_ptr,
1027
AVPacket *avpkt)
1028
{
1030
1031
if (!avpkt->data && avpkt->size) {
1032
av_log(avctx, AV_LOG_ERROR, "invalid packet: NULL data, size != 0\n");
1033
return AVERROR(EINVAL);
1034
}
1035
if (!avctx->codec)
1036
return AVERROR(EINVAL);
1037
if (avctx->codec->type != AVMEDIA_TYPE_SUBTITLE) {
1038
av_log(avctx, AV_LOG_ERROR, "Invalid media type for subtitles\n");
1039
return AVERROR(EINVAL);
1040
}
1041
1042
*got_sub_ptr = 0;
1043
get_subtitle_defaults(sub);
1044
1045
if ((avctx->codec->capabilities & AV_CODEC_CAP_DELAY) || avpkt->size) {
1053
if (avctx->pkt_timebase.num && avpkt->pts != AV_NOPTS_VALUE)
1054
sub->pts = av_rescale_q(avpkt->pts,
1055
avctx->pkt_timebase, AV_TIME_BASE_Q);
1056
ret = avctx->codec->decode(avctx, sub, got_sub_ptr, pkt);
1057
av_assert1((ret >= 0) >= !!*got_sub_ptr &&
1058
!!*got_sub_ptr >= !!sub->num_rects);
1061
if (avctx->sub_text_format == FF_SUB_TEXT_FMT_ASS_WITH_TIMINGS
1062
&& *got_sub_ptr && sub->num_rects) {
1063
const AVRational tb = avctx->pkt_timebase.num ? avctx->pkt_timebase
1064
: avctx->time_base;
1065
int err = convert_sub_to_old_ass_form(sub, avpkt, tb);
1066
if (err < 0)
1067
ret = err;
1068
}
1071
if (sub->num_rects && !sub->end_display_time && avpkt->duration &&
1072
avctx->pkt_timebase.num) {
1073
AVRational ms = { 1, 1000 };
1074
sub->end_display_time = av_rescale_q(avpkt->duration,
1075
avctx->pkt_timebase, ms);
1076
}
1078
if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB)
1079
sub->format = 0;
1080
else if (avctx->codec_descriptor->props & AV_CODEC_PROP_TEXT_SUB)
1081
sub->format = 1;
1082
1083
for (unsigned i = 0; i < sub->num_rects; i++) {
1084
if (avctx->sub_charenc_mode != FF_SUB_CHARENC_MODE_IGNORE &&
1085
sub->rects[i]->ass && !utf8_check(sub->rects[i]->ass)) {
1086
av_log(avctx, AV_LOG_ERROR,
1087
"Invalid UTF-8 in decoded subtitles text; "
1088
"maybe missing -sub_charenc option\n");
1089
avsubtitle_free(sub);
1090
ret = AVERROR_INVALIDDATA;
1091
break;
1097
1098
if (pkt == avci->buffer_pkt) // did we recode?
1099
av_packet_unref(avci->buffer_pkt);
1102
return ret;
1103
}
1104
1105
enum AVPixelFormat avcodec_default_get_format(struct AVCodecContext *avctx,
1106
const enum AVPixelFormat *fmt)
1107
{
1108
const AVPixFmtDescriptor *desc;
1109
const AVCodecHWConfig *config;
1110
int i, n;
1111
1112
// If a device was supplied when the codec was opened, assume that the
1113
// user wants to use it.
1114
if (avctx->hw_device_ctx && avctx->codec->hw_configs) {
1115
AVHWDeviceContext *device_ctx =
1116
(AVHWDeviceContext*)avctx->hw_device_ctx->data;
1117
for (i = 0;; i++) {
1118
config = &avctx->codec->hw_configs[i]->public;
1119
if (!config)
1120
break;
1121
if (!(config->methods &
1122
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX))
1123
continue;
1124
if (device_ctx->type != config->device_type)
1125
continue;
1126
for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1127
if (config->pix_fmt == fmt[n])
1128
return fmt[n];
1129
}
1130
}
1131
}
1132
// No device or other setup, so we have to choose from things which
1133
// don't any other external information.
1134
1135
// If the last element of the list is a software format, choose it
1136
// (this should be best software format if any exist).
1137
for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1138
desc = av_pix_fmt_desc_get(fmt[n - 1]);
1139
if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1140
return fmt[n - 1];
1141
1142
// Finally, traverse the list in order and choose the first entry
1143
// with no external dependencies (if there is no hardware configuration
1144
// information available then this just picks the first entry).
1145
for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++) {
1146
for (i = 0;; i++) {
1147
config = avcodec_get_hw_config(avctx->codec, i);
1148
if (!config)
1149
break;
1150
if (config->pix_fmt == fmt[n])
1151
break;
1152
}
1153
if (!config) {
1154
// No specific config available, so the decoder must be able
1155
// to handle this format without any additional setup.
1156
return fmt[n];
1157
}
1158
if (config->methods & AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1159
// Usable with only internal setup.
1160
return fmt[n];
1161
}
1166
}
1167
1168
int ff_decode_get_hw_frames_ctx(AVCodecContext *avctx,
1169
enum AVHWDeviceType dev_type)
1170
{
1171
AVHWDeviceContext *device_ctx;
1172
AVHWFramesContext *frames_ctx;
1173
int ret;
1174
1175
if (!avctx->hwaccel)
1176
return AVERROR(ENOSYS);
1177
1178
if (avctx->hw_frames_ctx)
1179
return 0;
1180
if (!avctx->hw_device_ctx) {
1181
av_log(avctx, AV_LOG_ERROR, "A hardware frames or device context is "
1182
"required for hardware accelerated decoding.\n");
1183
return AVERROR(EINVAL);
1184
}
1185
1186
device_ctx = (AVHWDeviceContext *)avctx->hw_device_ctx->data;
1187
if (device_ctx->type != dev_type) {
1188
av_log(avctx, AV_LOG_ERROR, "Device type %s expected for hardware "
1189
"decoding, but got %s.\n", av_hwdevice_get_type_name(dev_type),
1190
av_hwdevice_get_type_name(device_ctx->type));
1191
return AVERROR(EINVAL);
1192
}
1193
1194
ret = avcodec_get_hw_frames_parameters(avctx,
1195
avctx->hw_device_ctx,
1196
avctx->hwaccel->pix_fmt,
1199
return ret;
1200
1201
frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
1202
1203
1204
if (frames_ctx->initial_pool_size) {
1205
// We guarantee 4 base work surfaces. The function above guarantees 1
1206
// (the absolute minimum), so add the missing count.
1207
frames_ctx->initial_pool_size += 3;
1208
}
1209
1210
ret = av_hwframe_ctx_init(avctx->hw_frames_ctx);
1211
if (ret < 0) {
1212
av_buffer_unref(&avctx->hw_frames_ctx);
1213
return ret;
1214
}
1215
1216
return 0;
1217
}
1218
1219
int avcodec_get_hw_frames_parameters(AVCodecContext *avctx,
1220
AVBufferRef *device_ref,
1221
enum AVPixelFormat hw_pix_fmt,
1222
AVBufferRef **out_frames_ref)
1223
{
1224
AVBufferRef *frames_ref = NULL;
1225
const AVCodecHWConfigInternal *hw_config;
1226
const AVHWAccel *hwa;
1227
int i, ret;
1229
for (i = 0;; i++) {
1230
hw_config = avctx->codec->hw_configs[i];
1231
if (!hw_config)
1232
return AVERROR(ENOENT);
1233
if (hw_config->public.pix_fmt == hw_pix_fmt)
1234
break;
1235
}
1236
1237
hwa = hw_config->hwaccel;
1238
if (!hwa || !hwa->frame_params)
1239
return AVERROR(ENOENT);
1240
1241
frames_ref = av_hwframe_ctx_alloc(device_ref);
1242
if (!frames_ref)
1243
return AVERROR(ENOMEM);
1244
1245
ret = hwa->frame_params(avctx, frames_ref);
1246
if (ret >= 0) {
1247
AVHWFramesContext *frames_ctx = (AVHWFramesContext*)frames_ref->data;
1248
1249
if (frames_ctx->initial_pool_size) {
1250
// If the user has requested that extra output surfaces be
1251
// available then add them here.
1252
if (avctx->extra_hw_frames > 0)
1253
frames_ctx->initial_pool_size += avctx->extra_hw_frames;
1254
1255
// If frame threading is enabled then an extra surface per thread
1256
// is also required.
1257
if (avctx->active_thread_type & FF_THREAD_FRAME)
1258
frames_ctx->initial_pool_size += avctx->thread_count;
1261
*out_frames_ref = frames_ref;
1262
} else {
1263
av_buffer_unref(&frames_ref);
1264
}
1265
return ret;
1266
}
1267
1268
static int hwaccel_init(AVCodecContext *avctx,
1269
const AVCodecHWConfigInternal *hw_config)
1270
{
1273
1274
hwaccel = hw_config->hwaccel;
1275
if (hwaccel->capabilities & AV_HWACCEL_CODEC_CAP_EXPERIMENTAL &&
1276
avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
1277
av_log(avctx, AV_LOG_WARNING, "Ignoring experimental hwaccel: %s\n",
1282
if (hwaccel->priv_data_size) {
1283
avctx->internal->hwaccel_priv_data =
1284
av_mallocz(hwaccel->priv_data_size);
1285
if (!avctx->internal->hwaccel_priv_data)
1286
return AVERROR(ENOMEM);
1287
}
1288
1290
if (hwaccel->init) {
1291
err = hwaccel->init(avctx);
1292
if (err < 0) {
1293
av_log(avctx, AV_LOG_ERROR, "Failed setup for format %s: "
1294
"hwaccel initialisation returned error.\n",
1295
av_get_pix_fmt_name(hw_config->public.pix_fmt));
1296
av_freep(&avctx->internal->hwaccel_priv_data);
1299
}
1300
}
1301
1302
return 0;
1303
}
1304
1305
static void hwaccel_uninit(AVCodecContext *avctx)
1306
{
1307
if (avctx->hwaccel && avctx->hwaccel->uninit)
1308
avctx->hwaccel->uninit(avctx);
1309
1310
av_freep(&avctx->internal->hwaccel_priv_data);
1311
1312
avctx->hwaccel = NULL;
1313
1314
av_buffer_unref(&avctx->hw_frames_ctx);
1315
}
1316
1317
int ff_get_format(AVCodecContext *avctx, const enum AVPixelFormat *fmt)
1318
{
1319
const AVPixFmtDescriptor *desc;
1320
enum AVPixelFormat *choices;
1321
enum AVPixelFormat ret, user_choice;
1322
const AVCodecHWConfigInternal *hw_config;
1323
const AVCodecHWConfig *config;
1324
int i, n, err;
1325
1326
// Find end of list.
1327
for (n = 0; fmt[n] != AV_PIX_FMT_NONE; n++);
1328
// Must contain at least one entry.
1329
av_assert0(n >= 1);
1330
// If a software format is available, it must be the last entry.
1331
desc = av_pix_fmt_desc_get(fmt[n - 1]);
1332
if (desc->flags & AV_PIX_FMT_FLAG_HWACCEL) {
1333
// No software format is available.
1334
} else {
1335
avctx->sw_pix_fmt = fmt[n - 1];
1336
}
1337
1338
choices = av_malloc_array(n + 1, sizeof(*choices));
1339
if (!choices)
1340
return AV_PIX_FMT_NONE;
1341
1342
memcpy(choices, fmt, (n + 1) * sizeof(*choices));
1343
1344
for (;;) {
1347
1348
user_choice = avctx->get_format(avctx, choices);
1349
if (user_choice == AV_PIX_FMT_NONE) {
1350
// Explicitly chose nothing, give up.
1351
ret = AV_PIX_FMT_NONE;
1352
break;
1353
}
1354
1356
if (!desc) {
1357
av_log(avctx, AV_LOG_ERROR, "Invalid format returned by "
1358
"get_format() callback.\n");
1359
ret = AV_PIX_FMT_NONE;
1360
break;
1361
}
1362
av_log(avctx, AV_LOG_DEBUG, "Format %s chosen by get_format().\n",
1363
desc->name);
1364
1365
for (i = 0; i < n; i++) {
1366
if (choices[i] == user_choice)
1367
break;
1368
}
1369
if (i == n) {
1370
av_log(avctx, AV_LOG_ERROR, "Invalid return from get_format(): "
1371
"%s not in possible list.\n", desc->name);
1373
break;
1375
1376
if (avctx->codec->hw_configs) {
1377
for (i = 0;; i++) {
1378
hw_config = avctx->codec->hw_configs[i];
1379
if (!hw_config)
1380
break;
1381
if (hw_config->public.pix_fmt == user_choice)
1382
break;
1383
}
1386
}
1387
1388
if (!hw_config) {
1389
// No config available, so no extra setup required.
1390
ret = user_choice;
1391
break;
1392
}
1393
config = &hw_config->public;
1394
1395
if (config->methods &
1396
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
1397
avctx->hw_frames_ctx) {
1398
const AVHWFramesContext *frames_ctx =
1399
(AVHWFramesContext*)avctx->hw_frames_ctx->data;
1400
if (frames_ctx->format != user_choice) {
1401
av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1402
"does not match the format of the provided frames "
1403
"context.\n", desc->name);
1404
goto try_again;
1405
}
1406
} else if (config->methods &
1407
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX &&
1408
avctx->hw_device_ctx) {
1409
const AVHWDeviceContext *device_ctx =
1410
(AVHWDeviceContext*)avctx->hw_device_ctx->data;
1411
if (device_ctx->type != config->device_type) {
1412
av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1413
"does not match the type of the provided device "
1414
"context.\n", desc->name);
1415
goto try_again;
1416
}
1417
} else if (config->methods &
1418
AV_CODEC_HW_CONFIG_METHOD_INTERNAL) {
1419
// Internal-only setup, no additional configuration.
1420
} else if (config->methods &
1421
AV_CODEC_HW_CONFIG_METHOD_AD_HOC) {
1422
// Some ad-hoc configuration we can't see and can't check.
1423
} else {
1424
av_log(avctx, AV_LOG_ERROR, "Invalid setup for format %s: "
1425
"missing configuration.\n", desc->name);
1426
goto try_again;
1427
}
1428
if (hw_config->hwaccel) {
1429
av_log(avctx, AV_LOG_DEBUG, "Format %s requires hwaccel "
1430
"initialisation.\n", desc->name);
1431
err = hwaccel_init(avctx, hw_config);
1432
if (err < 0)
1433
goto try_again;
1434
}
1435
ret = user_choice;
1436
break;
1437
1438
try_again:
1439
av_log(avctx, AV_LOG_DEBUG, "Format %s not usable, retrying "
1440
"get_format() without it.\n", desc->name);
1441
for (i = 0; i < n; i++) {
1442
if (choices[i] == user_choice)
1443
break;
1444
}
1445
for (; i + 1 < n; i++)
1446
choices[i] = choices[i + 1];
1447
--n;
1448
}
1449
1450
av_freep(&choices);
1451
return ret;
1452
}
1453
1454
static void frame_pool_free(void *opaque, uint8_t *data)
1455
{
1456
FramePool *pool = (FramePool*)data;
1457
int i;
1458
1459
for (i = 0; i < FF_ARRAY_ELEMS(pool->pools); i++)
1460
av_buffer_pool_uninit(&pool->pools[i]);
1461
1462
av_freep(&data);
1463
}
1464
1465
static AVBufferRef *frame_pool_alloc(void)
1466
{
1467
FramePool *pool = av_mallocz(sizeof(*pool));
1468
AVBufferRef *buf;
1469
1470
if (!pool)
1471
return NULL;
1472
1473
buf = av_buffer_create((uint8_t*)pool, sizeof(*pool),
1474
frame_pool_free, NULL, 0);
1475
if (!buf) {
1476
av_freep(&pool);
1477
return NULL;
1478
}
1479
1480
return buf;
1481
}
1482
1483
static int update_frame_pool(AVCodecContext *avctx, AVFrame *frame)
1484
{
1485
FramePool *pool = avctx->internal->pool ?
1486
(FramePool*)avctx->internal->pool->data : NULL;
1487
AVBufferRef *pool_buf;
1488
int i, ret, ch, planes;
1489
1490
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
1491
int planar = av_sample_fmt_is_planar(frame->format);
1492
ch = frame->channels;
1493
planes = planar ? ch : 1;
1494
}
1495
1496
if (pool && pool->format == frame->format) {
1497
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO &&
1498
pool->width == frame->width && pool->height == frame->height)
1499
return 0;
1500
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && pool->planes == planes &&
1501
pool->channels == ch && frame->nb_samples == pool->samples)
1502
return 0;
1503
}
1504
1505
pool_buf = frame_pool_alloc();
1506
if (!pool_buf)
1507
return AVERROR(ENOMEM);
1508
pool = (FramePool*)pool_buf->data;
1509
1510
switch (avctx->codec_type) {
1511
case AVMEDIA_TYPE_VIDEO: {
1512
int linesize[4];
1513
int w = frame->width;
1514
int h = frame->height;
1518
1519
avcodec_align_dimensions2(avctx, &w, &h, pool->stride_align);
1520
1521
do {
1522
// NOTE: do not align linesizes individually, this breaks e.g. assumptions
1523
// that linesize[0] == 2*linesize[1] in the MPEG-encoder for 4:2:2
1527
// increase alignment of w for next try (rhs gives the lowest bit set in w)
1528
w += w & ~(w - 1);
1529
1530
unaligned = 0;
1531
for (i = 0; i < 4; i++)
1532
unaligned |= linesize[i] % pool->stride_align[i];
1533
} while (unaligned);
1534
1535
for (i = 0; i < 4; i++)
1536
linesize1[i] = linesize[i];
1537
ret = av_image_fill_plane_sizes(size, avctx->pix_fmt, h, linesize1);
1538
if (ret < 0)
1540
1541
for (i = 0; i < 4; i++) {
1542
pool->linesize[i] = linesize[i];
1543
if (size[i]) {
1544
if (size[i] > INT_MAX - (16 + STRIDE_ALIGN - 1)) {
1545
ret = AVERROR(EINVAL);
1546
goto fail;
1547
}
1548
pool->pools[i] = av_buffer_pool_init(size[i] + 16 + STRIDE_ALIGN - 1,
1549
CONFIG_MEMORY_POISONING ?
1550
NULL :
1551
av_buffer_allocz);
1552
if (!pool->pools[i]) {
1553
ret = AVERROR(ENOMEM);
1554
goto fail;
1555
}
1556
}
1557
}
1558
pool->format = frame->format;
1559
pool->width = frame->width;
1560
pool->height = frame->height;
1561
1562
break;
1563
}
1564
case AVMEDIA_TYPE_AUDIO: {
1565
ret = av_samples_get_buffer_size(&pool->linesize[0], ch,
1566
frame->nb_samples, frame->format, 0);
1567
if (ret < 0)
1568
goto fail;
1569
1570
pool->pools[0] = av_buffer_pool_init(pool->linesize[0], NULL);
1571
if (!pool->pools[0]) {
1572
ret = AVERROR(ENOMEM);
1573
goto fail;
1574
}
1575
1576
pool->format = frame->format;
1577
pool->planes = planes;
1578
pool->channels = ch;
1579
pool->samples = frame->nb_samples;
1580
break;
1581
}
1582
default: av_assert0(0);
1583
}
1584
1585
av_buffer_unref(&avctx->internal->pool);
1586
avctx->internal->pool = pool_buf;
1587
1588
return 0;
1589
fail:
1591
return ret;
1592
}
1593
1594
static int audio_get_buffer(AVCodecContext *avctx, AVFrame *frame)
1595
{
1597
int planes = pool->planes;
1598
int i;
1599
1600
frame->linesize[0] = pool->linesize[0];
1601
1602
if (planes > AV_NUM_DATA_POINTERS) {
1604
frame->nb_extended_buf = planes - AV_NUM_DATA_POINTERS;
1606
sizeof(*frame->extended_buf));
1607
if (!frame->extended_data || !frame->extended_buf) {
1608
av_freep(&frame->extended_data);
1609
av_freep(&frame->extended_buf);
1610
return AVERROR(ENOMEM);
1611
}
1613
frame->extended_data = frame->data;
1616
1617
for (i = 0; i < FFMIN(planes, AV_NUM_DATA_POINTERS); i++) {
1618
frame->buf[i] = av_buffer_pool_get(pool->pools[0]);
1619
if (!frame->buf[i])
1620
goto fail;
1621
frame->extended_data[i] = frame->data[i] = frame->buf[i]->data;
1622
}
1623
for (i = 0; i < frame->nb_extended_buf; i++) {
1624
frame->extended_buf[i] = av_buffer_pool_get(pool->pools[0]);
1625
if (!frame->extended_buf[i])
1626
goto fail;
1627
frame->extended_data[i + AV_NUM_DATA_POINTERS] = frame->extended_buf[i]->data;
1628
}
1629
1630
if (avctx->debug & FF_DEBUG_BUFFERS)
1631
av_log(avctx, AV_LOG_DEBUG, "default_get_buffer called on frame %p", frame);
1632
1633
return 0;
1634
fail:
1635
av_frame_unref(frame);
1636
return AVERROR(ENOMEM);
1637
}
1638
1639
static int video_get_buffer(AVCodecContext *s, AVFrame *pic)
1640
{
1643
int i;
1644
1645
if (pic->data[0] || pic->data[1] || pic->data[2] || pic->data[3]) {
1646
av_log(s, AV_LOG_ERROR, "pic->data[*]!=NULL in avcodec_default_get_buffer\n");
1647
return -1;
1648
}
1649
1650
if (!desc) {
1651
av_log(s, AV_LOG_ERROR,
1652
"Unable to get pixel format descriptor for format %s\n",
1653
av_get_pix_fmt_name(pic->format));
1654
return AVERROR(EINVAL);
1655
}
1656
1657
memset(pic->data, 0, sizeof(pic->data));
1658
pic->extended_data = pic->data;
1659
1660
for (i = 0; i < 4 && pool->pools[i]; i++) {
1661
pic->linesize[i] = pool->linesize[i];
1662
1663
pic->buf[i] = av_buffer_pool_get(pool->pools[i]);
1664
if (!pic->buf[i])
1665
goto fail;
1666
1667
pic->data[i] = pic->buf[i]->data;
1668
}
1669
for (; i < AV_NUM_DATA_POINTERS; i++) {
1670
pic->data[i] = NULL;
1671
pic->linesize[i] = 0;
1672
}
1676
1677
if (s->debug & FF_DEBUG_BUFFERS)
1678
av_log(s, AV_LOG_DEBUG, "default_get_buffer called on pic %p\n", pic);
1679
1680
return 0;
1681
fail:
1682
av_frame_unref(pic);
1683
return AVERROR(ENOMEM);
1684
}
1685
1686
int avcodec_default_get_buffer2(AVCodecContext *avctx, AVFrame *frame, int flags)
1687
{
1688
int ret;
1689
1690
if (avctx->hw_frames_ctx) {
1691
ret = av_hwframe_get_buffer(avctx->hw_frames_ctx, frame, 0);
1692
frame->width = avctx->coded_width;
1693
frame->height = avctx->coded_height;
1694
return ret;
1695
}
1696
1697
if ((ret = update_frame_pool(avctx, frame)) < 0)
1698
return ret;
1699
1700
switch (avctx->codec_type) {
1701
case AVMEDIA_TYPE_VIDEO:
1702
return video_get_buffer(avctx, frame);
1703
case AVMEDIA_TYPE_AUDIO:
1704
return audio_get_buffer(avctx, frame);
1705
default:
1706
return -1;
1707
}
1708
}
1709
1711
{
1716
1717
side_metadata = av_packet_get_side_data(avpkt,
1718
AV_PKT_DATA_STRINGS_METADATA, &size);
1719
return av_packet_unpack_dictionary(side_metadata, size, frame_md);
1720
}
1721
1726
enum AVPacketSideDataType packet;
1727
enum AVFrameSideDataType frame;
1728
} sd[] = {
1729
{ AV_PKT_DATA_REPLAYGAIN , AV_FRAME_DATA_REPLAYGAIN },
1730
{ AV_PKT_DATA_DISPLAYMATRIX, AV_FRAME_DATA_DISPLAYMATRIX },
1731
{ AV_PKT_DATA_SPHERICAL, AV_FRAME_DATA_SPHERICAL },
1732
{ AV_PKT_DATA_STEREO3D, AV_FRAME_DATA_STEREO3D },
1733
{ AV_PKT_DATA_AUDIO_SERVICE_TYPE, AV_FRAME_DATA_AUDIO_SERVICE_TYPE },
1734
{ AV_PKT_DATA_MASTERING_DISPLAY_METADATA, AV_FRAME_DATA_MASTERING_DISPLAY_METADATA },
1735
{ AV_PKT_DATA_CONTENT_LIGHT_LEVEL, AV_FRAME_DATA_CONTENT_LIGHT_LEVEL },
1739
};
1740
1741
if (IS_EMPTY(pkt) && av_fifo_size(avctx->internal->pkt_props) >= sizeof(*pkt))
1742
av_fifo_generic_read(avctx->internal->pkt_props,
1743
pkt, sizeof(*pkt), NULL);
1746
#if FF_API_PKT_PTS
1747
FF_DISABLE_DEPRECATION_WARNINGS
1749
FF_ENABLE_DEPRECATION_WARNINGS
1750
#endif
1751
frame->pkt_pos = pkt->pos;
1752
frame->pkt_duration = pkt->duration;
1753
frame->pkt_size = pkt->size;
1754
1755
for (int i = 0; i < FF_ARRAY_ELEMS(sd); i++) {
1756
buffer_size_t size;
1757
uint8_t *packet_sd = av_packet_get_side_data(pkt, sd[i].packet, &size);
1758
if (packet_sd) {
1759
AVFrameSideData *frame_sd = av_frame_new_side_data(frame,
1760
sd[i].frame,
1761
size);
1762
if (!frame_sd)
1763
return AVERROR(ENOMEM);
1764
1765
memcpy(frame_sd->data, packet_sd, size);
1769
1770
if (pkt->flags & AV_PKT_FLAG_DISCARD) {
1771
frame->flags |= AV_FRAME_FLAG_DISCARD;
1772
} else {
1773
frame->flags = (frame->flags & ~AV_FRAME_FLAG_DISCARD);
1774
}
1776
1777
if (frame->color_primaries == AVCOL_PRI_UNSPECIFIED)
1778
frame->color_primaries = avctx->color_primaries;
1779
if (frame->color_trc == AVCOL_TRC_UNSPECIFIED)
1780
frame->color_trc = avctx->color_trc;
1781
if (frame->colorspace == AVCOL_SPC_UNSPECIFIED)
1782
frame->colorspace = avctx->colorspace;
1783
if (frame->color_range == AVCOL_RANGE_UNSPECIFIED)
1784
frame->color_range = avctx->color_range;
1785
if (frame->chroma_location == AVCHROMA_LOC_UNSPECIFIED)
1786
frame->chroma_location = avctx->chroma_sample_location;
1787
1788
switch (avctx->codec->type) {
1789
case AVMEDIA_TYPE_VIDEO:
1791
if (!frame->sample_aspect_ratio.num)
1792
frame->sample_aspect_ratio = avctx->sample_aspect_ratio;
1793
1794
if (frame->width && frame->height &&
1795
av_image_check_sar(frame->width, frame->height,
1796
frame->sample_aspect_ratio) < 0) {
1797
av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
1798
frame->sample_aspect_ratio.num,
1799
frame->sample_aspect_ratio.den);
1800
frame->sample_aspect_ratio = (AVRational){ 0, 1 };
1801
}
1802
1803
break;
1804
case AVMEDIA_TYPE_AUDIO:
1805
if (!frame->sample_rate)
1806
frame->sample_rate = avctx->sample_rate;
1807
if (frame->format < 0)
1808
frame->format = avctx->sample_fmt;
1809
if (!frame->channel_layout) {
1810
if (avctx->channel_layout) {
1811
if (av_get_channel_layout_nb_channels(avctx->channel_layout) !=
1812
avctx->channels) {
1813
av_log(avctx, AV_LOG_ERROR, "Inconsistent channel "
1814
"configuration.\n");
1815
return AVERROR(EINVAL);
1816
}
1817
1818
frame->channel_layout = avctx->channel_layout;
1819
} else {
1820
if (avctx->channels > FF_SANE_NB_CHANNELS) {
1821
av_log(avctx, AV_LOG_ERROR, "Too many channels: %d.\n",
1822
avctx->channels);
1823
return AVERROR(ENOSYS);
1824
}
1825
}
1826
}
1828
break;
1829
}
1830
return 0;
1831
}
1832
1833
static void validate_avframe_allocation(AVCodecContext *avctx, AVFrame *frame)
1834
{
1835
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1836
int i;
1837
int num_planes = av_pix_fmt_count_planes(frame->format);
1838
const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(frame->format);
1839
int flags = desc ? desc->flags : 0;
1840
if (num_planes == 1 && (flags & AV_PIX_FMT_FLAG_PAL))
1841
num_planes = 2;
1844
for (i = 0; i < num_planes; i++) {
1845
av_assert0(frame->data[i]);
1846
}
1847
// For formats without data like hwaccel allow unused pointers to be non-NULL.
1848
for (i = num_planes; num_planes > 0 && i < FF_ARRAY_ELEMS(frame->data); i++) {
1849
if (frame->data[i])
1850
av_log(avctx, AV_LOG_ERROR, "Buffer returned by get_buffer2() did not zero unused plane pointers\n");
1851
frame->data[i] = NULL;
1852
}
1853
}
1854
}
1855
1856
static void decode_data_free(void *opaque, uint8_t *data)
1857
{
1858
FrameDecodeData *fdd = (FrameDecodeData*)data;
1859
1860
if (fdd->post_process_opaque_free)
1861
fdd->post_process_opaque_free(fdd->post_process_opaque);
1862
1866
av_freep(&fdd);
1867
}
1868
1869
int ff_attach_decode_data(AVFrame *frame)
1870
{
1871
AVBufferRef *fdd_buf;
1872
FrameDecodeData *fdd;
1873
1874
av_assert1(!frame->private_ref);
1875
av_buffer_unref(&frame->private_ref);
1876
1877
fdd = av_mallocz(sizeof(*fdd));
1878
if (!fdd)
1879
return AVERROR(ENOMEM);
1880
1881
fdd_buf = av_buffer_create((uint8_t*)fdd, sizeof(*fdd), decode_data_free,
1882
NULL, AV_BUFFER_FLAG_READONLY);
1883
if (!fdd_buf) {
1884
av_freep(&fdd);
1885
return AVERROR(ENOMEM);
1886
}
1887
1888
frame->private_ref = fdd_buf;
1889
1890
return 0;
1891
}
1892
1894
{
1895
const AVHWAccel *hwaccel = avctx->hwaccel;
1896
int override_dimensions = 1;
1897
int ret;
1898
1899
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
1900
if ((unsigned)avctx->width > INT_MAX - STRIDE_ALIGN ||
1901
(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) {
1905
}
1906
1907
if (frame->width <= 0 || frame->height <= 0) {
1908
frame->width = FFMAX(avctx->width, AV_CEIL_RSHIFT(avctx->coded_width, avctx->lowres));
1909
frame->height = FFMAX(avctx->height, AV_CEIL_RSHIFT(avctx->coded_height, avctx->lowres));
1910
override_dimensions = 0;
1911
}
1912
1913
if (frame->data[0] || frame->data[1] || frame->data[2] || frame->data[3]) {
1914
av_log(avctx, AV_LOG_ERROR, "pic->data[*]!=NULL in get_buffer_internal\n");
1920
av_log(avctx, AV_LOG_ERROR, "samples per frame %d, exceeds max_samples %"PRId64"\n", frame->nb_samples, avctx->max_samples);
1925
ret = ff_decode_frame_props(avctx, frame);
1926
if (ret < 0)
1928
1929
if (hwaccel) {
1930
if (hwaccel->alloc_frame) {
1931
ret = hwaccel->alloc_frame(avctx, frame);
1933
}
1934
} else
1935
avctx->sw_pix_fmt = avctx->pix_fmt;
1936
1937
ret = avctx->get_buffer2(avctx, frame, flags);
1940
1941
validate_avframe_allocation(avctx, frame);
1942
1943
ret = ff_attach_decode_data(frame);
1944
if (ret < 0)
1946
1948
if (avctx->codec_type == AVMEDIA_TYPE_VIDEO && !override_dimensions &&
1949
!(avctx->codec->caps_internal & FF_CODEC_CAP_EXPORTS_CROPPING)) {
1950
frame->width = avctx->width;
1951
frame->height = avctx->height;
1952
}
1953
1955
if (ret < 0) {
1956
av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
1957
av_frame_unref(frame);
1958
}
1959
1963
static int reget_buffer_internal(AVCodecContext *avctx, AVFrame *frame, int flags)
1964
{
1965
AVFrame *tmp;
1966
int ret;
1967
1968
av_assert0(avctx->codec_type == AVMEDIA_TYPE_VIDEO);
1969
1970
if (frame->data[0] && (frame->width != avctx->width || frame->height != avctx->height || frame->format != avctx->pix_fmt)) {
1971
av_log(avctx, AV_LOG_WARNING, "Picture changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s in reget buffer()\n",
1972
frame->width, frame->height, av_get_pix_fmt_name(frame->format), avctx->width, avctx->height, av_get_pix_fmt_name(avctx->pix_fmt));
1973
av_frame_unref(frame);
1974
}
1975
1976
if (!frame->data[0])
1977
return ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1978
1980
return ff_decode_frame_props(avctx, frame);
1981
1982
tmp = av_frame_alloc();
1983
if (!tmp)
1984
return AVERROR(ENOMEM);
1985
1986
av_frame_move_ref(tmp, frame);
1987
1988
ret = ff_get_buffer(avctx, frame, AV_GET_BUFFER_FLAG_REF);
1989
if (ret < 0) {
1990
av_frame_free(&tmp);
1991
return ret;
1992
}
1993
1994
av_frame_copy(frame, tmp);
1995
av_frame_free(&tmp);
1996
1997
return 0;
1998
}
1999
2003
if (ret < 0)
2004
av_log(avctx, AV_LOG_ERROR, "reget_buffer() failed\n");
2005
return ret;
2006
}
2012
/* if the decoder init function was already called previously,
2013
* free the already allocated subtitle_header before overwriting it */
2014
av_freep(&avctx->subtitle_header);
2015
2016
#if FF_API_THREAD_SAFE_CALLBACKS
2017
FF_DISABLE_DEPRECATION_WARNINGS
2018
if ((avctx->thread_type & FF_THREAD_FRAME) &&
2019
avctx->get_buffer2 != avcodec_default_get_buffer2 &&
2020
!avctx->thread_safe_callbacks) {
2021
av_log(avctx, AV_LOG_WARNING, "Requested frame threading with a "
2022
"custom get_buffer2() implementation which is not marked as "
2023
"thread safe. This is not supported anymore, make your "
2024
"callback thread-safe.\n");
2025
}
2026
FF_ENABLE_DEPRECATION_WARNINGS
2027
#endif
2028
2029
if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && avctx->channels == 0 &&
2030
!(avctx->codec->capabilities & AV_CODEC_CAP_CHANNEL_CONF)) {
2031
av_log(avctx, AV_LOG_ERROR, "Decoder requires channel count but channels not set\n");
2032
return AVERROR(EINVAL);
2033
}
2034
if (avctx->codec->max_lowres < avctx->lowres || avctx->lowres < 0) {
2035
av_log(avctx, AV_LOG_WARNING, "The maximum value for lowres supported by the decoder is %d\n",
2036
avctx->codec->max_lowres);
2037
avctx->lowres = avctx->codec->max_lowres;
2038
}
2039
if (avctx->sub_charenc) {
2040
if (avctx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
2041
av_log(avctx, AV_LOG_ERROR, "Character encoding is only "
2042
"supported with subtitles codecs\n");
2043
return AVERROR(EINVAL);
2044
} else if (avctx->codec_descriptor->props & AV_CODEC_PROP_BITMAP_SUB) {
2045
av_log(avctx, AV_LOG_WARNING, "Codec '%s' is bitmap-based, "
2046
"subtitles character encoding will be ignored\n",
2047
avctx->codec_descriptor->name);
2048
avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_DO_NOTHING;
2049
} else {
2050
/* input character encoding is set for a text based subtitle
2051
* codec at this point */
2052
if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_AUTOMATIC)
2053
avctx->sub_charenc_mode = FF_SUB_CHARENC_MODE_PRE_DECODER;
2054
2055
if (avctx->sub_charenc_mode == FF_SUB_CHARENC_MODE_PRE_DECODER) {
2056
#if CONFIG_ICONV
2057
iconv_t cd = iconv_open("UTF-8", avctx->sub_charenc);
2058
if (cd == (iconv_t)-1) {
2059
ret = AVERROR(errno);
2060
av_log(avctx, AV_LOG_ERROR, "Unable to open iconv context "
2061
"with input character encoding \"%s\"\n", avctx->sub_charenc);
2062
return ret;
2063
}
2064
iconv_close(cd);
2065
#else
2066
av_log(avctx, AV_LOG_ERROR, "Character encoding subtitles "
2067
"conversion needs a libavcodec built with iconv support "
2068
"for this codec\n");
2069
return AVERROR(ENOSYS);
2070
#endif
2071
}
2072
}
2073
}
2074
2075
avctx->pts_correction_num_faulty_pts =
2076
avctx->pts_correction_num_faulty_dts = 0;
2077
avctx->pts_correction_last_pts =
2078
avctx->pts_correction_last_dts = INT64_MIN;
2079
2080
if ( !CONFIG_GRAY && avctx->flags & AV_CODEC_FLAG_GRAY
2081
&& avctx->codec_descriptor->type == AVMEDIA_TYPE_VIDEO)
2082
av_log(avctx, AV_LOG_WARNING,
2083
"gray decoding requested but not enabled at configuration time\n");
2084
if (avctx->flags2 & AV_CODEC_FLAG2_EXPORT_MVS) {
2085
avctx->export_side_data |= AV_CODEC_EXPORT_DATA_MVS;
2086
}
2087
2094
2095
int ff_copy_palette(void *dst, const AVPacket *src, void *logctx)
2096
{
2097
buffer_size_t size;
2098
const void *pal = av_packet_get_side_data(src, AV_PKT_DATA_PALETTE, &size);
2099
2100
if (pal && size == AVPALETTE_SIZE) {
2101
memcpy(dst, pal, AVPALETTE_SIZE);
2102
return 1;
2103
} else if (pal) {
2104
av_log(logctx, AV_LOG_ERROR, "Palette size %d is wrong\n", size);
2105
}
2106
return 0;
2107
}