1 /*
2 * generic encoding-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 "libavutil/attributes.h"
22 #include "libavutil/avassert.h"
23 #include "libavutil/frame.h"
24 #include "libavutil/imgutils.h"
25 #include "libavutil/internal.h"
26 #include "libavutil/samplefmt.h"
27
28 #include "avcodec.h"
29 #include "encode.h"
30 #include "frame_thread_encoder.h"
31 #include "internal.h"
32
ff_alloc_packet2(AVCodecContext * avctx,AVPacket * avpkt,int64_t size,int64_t min_size)33 int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
34 {
35 if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
36 av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
37 size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
38 return AVERROR(EINVAL);
39 }
40
41 av_assert0(!avpkt->data);
42
43 if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
44 av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
45 avpkt->data = avctx->internal->byte_buffer;
46 avpkt->size = size;
47 }
48
49 if (!avpkt->data) {
50 int ret = av_new_packet(avpkt, size);
51 if (ret < 0)
52 av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
53 return ret;
54 }
55
56 return 0;
57 }
58
avcodec_default_get_encode_buffer(AVCodecContext * avctx,AVPacket * avpkt,int flags)59 int avcodec_default_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int flags)
60 {
61 int ret;
62
63 if (avpkt->size < 0 || avpkt->size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
64 return AVERROR(EINVAL);
65
66 if (avpkt->data || avpkt->buf) {
67 av_log(avctx, AV_LOG_ERROR, "avpkt->{data,buf} != NULL in avcodec_default_get_encode_buffer()\n");
68 return AVERROR(EINVAL);
69 }
70
71 ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
72 if (ret < 0) {
73 av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", avpkt->size);
74 return ret;
75 }
76 avpkt->data = avpkt->buf->data;
77 memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
78
79 return 0;
80 }
81
ff_get_encode_buffer(AVCodecContext * avctx,AVPacket * avpkt,int64_t size,int flags)82 int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
83 {
84 int ret;
85
86 if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
87 return AVERROR(EINVAL);
88
89 av_assert0(!avpkt->data && !avpkt->buf);
90
91 avpkt->size = size;
92 ret = avctx->get_encode_buffer(avctx, avpkt, flags);
93 if (ret < 0)
94 goto fail;
95
96 if (!avpkt->data || !avpkt->buf) {
97 av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n");
98 ret = AVERROR(EINVAL);
99 goto fail;
100 }
101
102 ret = 0;
103 fail:
104 if (ret < 0) {
105 av_log(avctx, AV_LOG_ERROR, "get_encode_buffer() failed\n");
106 av_packet_unref(avpkt);
107 }
108
109 return ret;
110 }
111
112 /**
113 * Pad last frame with silence.
114 */
pad_last_frame(AVCodecContext * s,AVFrame * frame,const AVFrame * src)115 static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src)
116 {
117 int ret;
118
119 frame->format = src->format;
120 frame->channel_layout = src->channel_layout;
121 frame->channels = src->channels;
122 frame->nb_samples = s->frame_size;
123 ret = av_frame_get_buffer(frame, 0);
124 if (ret < 0)
125 goto fail;
126
127 ret = av_frame_copy_props(frame, src);
128 if (ret < 0)
129 goto fail;
130
131 if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
132 src->nb_samples, s->channels, s->sample_fmt)) < 0)
133 goto fail;
134 if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
135 frame->nb_samples - src->nb_samples,
136 s->channels, s->sample_fmt)) < 0)
137 goto fail;
138
139 return 0;
140
141 fail:
142 av_frame_unref(frame);
143 return ret;
144 }
145
avcodec_encode_subtitle(AVCodecContext * avctx,uint8_t * buf,int buf_size,const AVSubtitle * sub)146 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
147 const AVSubtitle *sub)
148 {
149 int ret;
150 if (sub->start_display_time) {
151 av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
152 return -1;
153 }
154
155 ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
156 avctx->frame_number++;
157 return ret;
158 }
159
ff_encode_get_frame(AVCodecContext * avctx,AVFrame * frame)160 int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
161 {
162 AVCodecInternal *avci = avctx->internal;
163
164 if (avci->draining)
165 return AVERROR_EOF;
166
167 if (!avci->buffer_frame->buf[0])
168 return AVERROR(EAGAIN);
169
170 av_frame_move_ref(frame, avci->buffer_frame);
171
172 return 0;
173 }
174
encode_simple_internal(AVCodecContext * avctx,AVPacket * avpkt)175 static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)
176 {
177 AVCodecInternal *avci = avctx->internal;
178 EncodeSimpleContext *es = &avci->es;
179 AVFrame *frame = es->in_frame;
180 int got_packet;
181 int ret;
182
183 if (avci->draining_done)
184 return AVERROR_EOF;
185
186 if (!frame->buf[0] && !avci->draining) {
187 av_frame_unref(frame);
188 ret = ff_encode_get_frame(avctx, frame);
189 if (ret < 0 && ret != AVERROR_EOF)
190 return ret;
191 }
192
193 if (!frame->buf[0]) {
194 if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
195 (avci->frame_thread_encoder && avctx->active_thread_type & FF_THREAD_FRAME)))
196 return AVERROR_EOF;
197
198 // Flushing is signaled with a NULL frame
199 frame = NULL;
200 }
201
202 got_packet = 0;
203
204 av_assert0(avctx->codec->encode2);
205
206 if (CONFIG_FRAME_THREAD_ENCODER &&
207 avci->frame_thread_encoder && (avctx->active_thread_type & FF_THREAD_FRAME))
208 /* This might modify frame, but it doesn't matter, because
209 * the frame properties used below are not used for video
210 * (due to the delay inherent in frame threaded encoding, it makes
211 * no sense to use the properties of the current frame anyway). */
212 ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);
213 else {
214 ret = avctx->codec->encode2(avctx, avpkt, frame, &got_packet);
215 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO && !ret && got_packet &&
216 !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
217 avpkt->pts = avpkt->dts = frame->pts;
218 }
219
220 av_assert0(ret <= 0);
221
222 emms_c();
223
224 if (!ret && got_packet) {
225 if (avpkt->data) {
226 ret = av_packet_make_refcounted(avpkt);
227 if (ret < 0)
228 goto end;
229 }
230
231 if (frame && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
232 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
233 if (avpkt->pts == AV_NOPTS_VALUE)
234 avpkt->pts = frame->pts;
235 if (!avpkt->duration)
236 avpkt->duration = ff_samples_to_time_base(avctx,
237 frame->nb_samples);
238 }
239 }
240 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
241 /* NOTE: if we add any audio encoders which output non-keyframe packets,
242 * this needs to be moved to the encoders, but for now we can do it
243 * here to simplify things */
244 avpkt->flags |= AV_PKT_FLAG_KEY;
245 avpkt->dts = avpkt->pts;
246 }
247 }
248
249 if (avci->draining && !got_packet)
250 avci->draining_done = 1;
251
252 end:
253 if (ret < 0 || !got_packet)
254 av_packet_unref(avpkt);
255
256 if (frame) {
257 if (!ret)
258 avctx->frame_number++;
259 av_frame_unref(frame);
260 }
261
262 if (got_packet)
263 // Encoders must always return ref-counted buffers.
264 // Side-data only packets have no data and can be not ref-counted.
265 av_assert0(!avpkt->data || avpkt->buf);
266
267 return ret;
268 }
269
encode_simple_receive_packet(AVCodecContext * avctx,AVPacket * avpkt)270 static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
271 {
272 int ret;
273
274 while (!avpkt->data && !avpkt->side_data) {
275 ret = encode_simple_internal(avctx, avpkt);
276 if (ret < 0)
277 return ret;
278 }
279
280 return 0;
281 }
282
encode_receive_packet_internal(AVCodecContext * avctx,AVPacket * avpkt)283 static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)
284 {
285 AVCodecInternal *avci = avctx->internal;
286 int ret;
287
288 if (avci->draining_done)
289 return AVERROR_EOF;
290
291 av_assert0(!avpkt->data && !avpkt->side_data);
292
293 if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
294 if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)
295 avctx->stats_out[0] = '\0';
296 if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
297 return AVERROR(EINVAL);
298 }
299
300 if (avctx->codec->receive_packet) {
301 ret = avctx->codec->receive_packet(avctx, avpkt);
302 if (ret < 0)
303 av_packet_unref(avpkt);
304 else
305 // Encoders must always return ref-counted buffers.
306 // Side-data only packets have no data and can be not ref-counted.
307 av_assert0(!avpkt->data || avpkt->buf);
308 } else
309 ret = encode_simple_receive_packet(avctx, avpkt);
310
311 if (ret == AVERROR_EOF)
312 avci->draining_done = 1;
313
314 return ret;
315 }
316
encode_send_frame_internal(AVCodecContext * avctx,const AVFrame * src)317 static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)
318 {
319 AVCodecInternal *avci = avctx->internal;
320 AVFrame *dst = avci->buffer_frame;
321 int ret;
322
323 if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
324 /* extract audio service type metadata */
325 AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
326 if (sd && sd->size >= sizeof(enum AVAudioServiceType))
327 avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
328
329 /* check for valid frame size */
330 if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
331 if (src->nb_samples > avctx->frame_size) {
332 av_log(avctx, AV_LOG_ERROR, "more samples than frame size\n");
333 return AVERROR(EINVAL);
334 }
335 } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
336 /* if we already got an undersized frame, that must have been the last */
337 if (avctx->internal->last_audio_frame) {
338 av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size);
339 return AVERROR(EINVAL);
340 }
341
342 if (src->nb_samples < avctx->frame_size) {
343 ret = pad_last_frame(avctx, dst, src);
344 if (ret < 0)
345 return ret;
346
347 avctx->internal->last_audio_frame = 1;
348 } else if (src->nb_samples > avctx->frame_size) {
349 av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d)\n", src->nb_samples, avctx->frame_size);
350 return AVERROR(EINVAL);
351 }
352 }
353 }
354
355 if (!dst->data[0]) {
356 ret = av_frame_ref(dst, src);
357 if (ret < 0)
358 return ret;
359 }
360
361 return 0;
362 }
363
avcodec_send_frame(AVCodecContext * avctx,const AVFrame * frame)364 int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
365 {
366 AVCodecInternal *avci = avctx->internal;
367 int ret;
368
369 if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
370 return AVERROR(EINVAL);
371
372 if (avci->draining)
373 return AVERROR_EOF;
374
375 if (avci->buffer_frame->data[0])
376 return AVERROR(EAGAIN);
377
378 if (!frame) {
379 avci->draining = 1;
380 } else {
381 ret = encode_send_frame_internal(avctx, frame);
382 if (ret < 0)
383 return ret;
384 }
385
386 if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {
387 ret = encode_receive_packet_internal(avctx, avci->buffer_pkt);
388 if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
389 return ret;
390 }
391
392 return 0;
393 }
394
avcodec_receive_packet(AVCodecContext * avctx,AVPacket * avpkt)395 int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
396 {
397 AVCodecInternal *avci = avctx->internal;
398 int ret;
399
400 av_packet_unref(avpkt);
401
402 if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
403 return AVERROR(EINVAL);
404
405 if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {
406 av_packet_move_ref(avpkt, avci->buffer_pkt);
407 } else {
408 ret = encode_receive_packet_internal(avctx, avpkt);
409 if (ret < 0)
410 return ret;
411 }
412
413 return 0;
414 }
415
416 #if FF_API_OLD_ENCDEC
compat_encode(AVCodecContext * avctx,AVPacket * avpkt,int * got_packet,const AVFrame * frame)417 static int compat_encode(AVCodecContext *avctx, AVPacket *avpkt,
418 int *got_packet, const AVFrame *frame)
419 {
420 AVCodecInternal *avci = avctx->internal;
421 AVPacket user_pkt;
422 int ret;
423
424 *got_packet = 0;
425
426 if (frame && avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
427 if (frame->format == AV_PIX_FMT_NONE)
428 av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
429 if (frame->width == 0 || frame->height == 0)
430 av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
431 }
432
433 if (avctx->codec->capabilities & AV_CODEC_CAP_DR1) {
434 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* API does not support "
435 "AV_CODEC_CAP_DR1 encoders\n");
436 return AVERROR(ENOSYS);
437 }
438
439 ret = avcodec_send_frame(avctx, frame);
440 if (ret == AVERROR_EOF)
441 ret = 0;
442 else if (ret == AVERROR(EAGAIN)) {
443 /* we fully drain all the output in each encode call, so this should not
444 * ever happen */
445 return AVERROR_BUG;
446 } else if (ret < 0)
447 return ret;
448
449 av_packet_move_ref(&user_pkt, avpkt);
450 while (ret >= 0) {
451 ret = avcodec_receive_packet(avctx, avpkt);
452 if (ret < 0) {
453 if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
454 ret = 0;
455 goto finish;
456 }
457
458 if (avpkt != avci->compat_encode_packet) {
459 if (avpkt->data && user_pkt.data) {
460 if (user_pkt.size >= avpkt->size) {
461 memcpy(user_pkt.data, avpkt->data, avpkt->size);
462 av_buffer_unref(&avpkt->buf);
463 avpkt->buf = user_pkt.buf;
464 avpkt->data = user_pkt.data;
465 FF_DISABLE_DEPRECATION_WARNINGS
466 av_init_packet(&user_pkt);
467 FF_ENABLE_DEPRECATION_WARNINGS
468 } else {
469 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
470 av_packet_unref(avpkt);
471 ret = AVERROR(EINVAL);
472 goto finish;
473 }
474 }
475
476 *got_packet = 1;
477 avpkt = avci->compat_encode_packet;
478 } else {
479 if (!avci->compat_decode_warned) {
480 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* "
481 "API cannot return all the packets for this encoder. "
482 "Some packets will be dropped. Update your code to the "
483 "new encoding API to fix this.\n");
484 avci->compat_decode_warned = 1;
485 av_packet_unref(avpkt);
486 }
487 }
488
489 if (avci->draining)
490 break;
491 }
492
493 finish:
494 if (ret < 0)
495 av_packet_unref(&user_pkt);
496
497 return ret;
498 }
499
avcodec_encode_audio2(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)500 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
501 AVPacket *avpkt,
502 const AVFrame *frame,
503 int *got_packet_ptr)
504 {
505 int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
506
507 if (ret < 0)
508 av_packet_unref(avpkt);
509
510 return ret;
511 }
512
avcodec_encode_video2(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)513 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
514 AVPacket *avpkt,
515 const AVFrame *frame,
516 int *got_packet_ptr)
517 {
518 int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
519
520 if (ret < 0)
521 av_packet_unref(avpkt);
522
523 return ret;
524 }
525 #endif
526
ff_encode_preinit(AVCodecContext * avctx)527 int ff_encode_preinit(AVCodecContext *avctx)
528 {
529 int i;
530 #if FF_API_CODED_FRAME
531 FF_DISABLE_DEPRECATION_WARNINGS
532 avctx->coded_frame = av_frame_alloc();
533 if (!avctx->coded_frame) {
534 return AVERROR(ENOMEM);
535 }
536 FF_ENABLE_DEPRECATION_WARNINGS
537 #endif
538
539 if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
540 av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
541 return AVERROR(EINVAL);
542 }
543
544 if (avctx->codec->sample_fmts) {
545 for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
546 if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
547 break;
548 if (avctx->channels == 1 &&
549 av_get_planar_sample_fmt(avctx->sample_fmt) ==
550 av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
551 avctx->sample_fmt = avctx->codec->sample_fmts[i];
552 break;
553 }
554 }
555 if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
556 char buf[128];
557 snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
558 av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
559 (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
560 return AVERROR(EINVAL);
561 }
562 }
563 if (avctx->codec->pix_fmts) {
564 for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
565 if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
566 break;
567 if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE
568 && !(avctx->codec_id == AV_CODEC_ID_MJPEG
569 && avctx->strict_std_compliance <= FF_COMPLIANCE_UNOFFICIAL)) {
570 char buf[128];
571 snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
572 av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
573 (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
574 return AVERROR(EINVAL);
575 }
576 if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
577 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
578 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
579 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
580 avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
581 avctx->color_range = AVCOL_RANGE_JPEG;
582 }
583 if (avctx->codec->supported_samplerates) {
584 for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
585 if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
586 break;
587 if (avctx->codec->supported_samplerates[i] == 0) {
588 av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
589 avctx->sample_rate);
590 return AVERROR(EINVAL);
591 }
592 }
593 if (avctx->sample_rate < 0) {
594 av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
595 avctx->sample_rate);
596 return AVERROR(EINVAL);
597 }
598 if (avctx->codec->channel_layouts) {
599 if (!avctx->channel_layout) {
600 av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
601 } else {
602 for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
603 if (avctx->channel_layout == avctx->codec->channel_layouts[i])
604 break;
605 if (avctx->codec->channel_layouts[i] == 0) {
606 char buf[512];
607 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
608 av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
609 return AVERROR(EINVAL);
610 }
611 }
612 }
613 if (avctx->channel_layout && avctx->channels) {
614 int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
615 if (channels != avctx->channels) {
616 char buf[512];
617 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
618 av_log(avctx, AV_LOG_ERROR,
619 "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
620 buf, channels, avctx->channels);
621 return AVERROR(EINVAL);
622 }
623 } else if (avctx->channel_layout) {
624 avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
625 }
626 if (avctx->channels < 0) {
627 av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
628 avctx->channels);
629 return AVERROR(EINVAL);
630 }
631 if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
632 const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
633 if ( avctx->bits_per_raw_sample < 0
634 || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
635 av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
636 avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
637 avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
638 }
639 if (avctx->width <= 0 || avctx->height <= 0) {
640 av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
641 return AVERROR(EINVAL);
642 }
643 }
644 if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
645 && avctx->bit_rate>0 && avctx->bit_rate<1000) {
646 av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
647 }
648
649 if (!avctx->rc_initial_buffer_occupancy)
650 avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
651
652 if (avctx->ticks_per_frame && avctx->time_base.num &&
653 avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
654 av_log(avctx, AV_LOG_ERROR,
655 "ticks_per_frame %d too large for the timebase %d/%d.",
656 avctx->ticks_per_frame,
657 avctx->time_base.num,
658 avctx->time_base.den);
659 return AVERROR(EINVAL);
660 }
661
662 if (avctx->hw_frames_ctx) {
663 AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
664 if (frames_ctx->format != avctx->pix_fmt) {
665 av_log(avctx, AV_LOG_ERROR,
666 "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
667 return AVERROR(EINVAL);
668 }
669 if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
670 avctx->sw_pix_fmt != frames_ctx->sw_format) {
671 av_log(avctx, AV_LOG_ERROR,
672 "Mismatching AVCodecContext.sw_pix_fmt (%s) "
673 "and AVHWFramesContext.sw_format (%s)\n",
674 av_get_pix_fmt_name(avctx->sw_pix_fmt),
675 av_get_pix_fmt_name(frames_ctx->sw_format));
676 return AVERROR(EINVAL);
677 }
678 avctx->sw_pix_fmt = frames_ctx->sw_format;
679 }
680
681 return 0;
682 }
683