git.sesse.net Git - ffmpeg/blob - libavcodec/encode.c

   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
  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
  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
  78     return 0;
  79 }
  80
  81 int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
  82 {
  83     int ret;
  84
  85     if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
  86         return AVERROR(EINVAL);
  87
  88     av_assert0(!avpkt->data && !avpkt->buf);
  89
  90     avpkt->size = size;
  91     ret = avctx->get_encode_buffer(avctx, avpkt, flags);
  92     if (ret < 0)
  93         goto fail;
  94
  95     if (!avpkt->data || !avpkt->buf) {
  96         av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n");
  97         ret = AVERROR(EINVAL);
  98         goto fail;
  99     }
 100     memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
 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  */
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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             char buf[128];
 569             snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
 570             av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
 571                    (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
 572             return AVERROR(EINVAL);
 573         }
 574         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
 575             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
 576             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
 577             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
 578             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
 579             avctx->color_range = AVCOL_RANGE_JPEG;
 580     }
 581     if (avctx->codec->supported_samplerates) {
 582         for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
 583             if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
 584                 break;
 585         if (avctx->codec->supported_samplerates[i] == 0) {
 586             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 587                    avctx->sample_rate);
 588             return AVERROR(EINVAL);
 589         }
 590     }
 591     if (avctx->sample_rate < 0) {
 592         av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 593                 avctx->sample_rate);
 594         return AVERROR(EINVAL);
 595     }
 596     if (avctx->codec->channel_layouts) {
 597         if (!avctx->channel_layout) {
 598             av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
 599         } else {
 600             for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
 601                 if (avctx->channel_layout == avctx->codec->channel_layouts[i])
 602                     break;
 603             if (avctx->codec->channel_layouts[i] == 0) {
 604                 char buf[512];
 605                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 606                 av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
 607                 return AVERROR(EINVAL);
 608             }
 609         }
 610     }
 611     if (avctx->channel_layout && avctx->channels) {
 612         int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 613         if (channels != avctx->channels) {
 614             char buf[512];
 615             av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 616             av_log(avctx, AV_LOG_ERROR,
 617                    "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
 618                    buf, channels, avctx->channels);
 619             return AVERROR(EINVAL);
 620         }
 621     } else if (avctx->channel_layout) {
 622         avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 623     }
 624     if (avctx->channels < 0) {
 625         av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
 626                 avctx->channels);
 627         return AVERROR(EINVAL);
 628     }
 629     if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 630         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
 631         if (    avctx->bits_per_raw_sample < 0
 632             || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
 633             av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
 634                 avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
 635             avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
 636         }
 637         if (avctx->width <= 0 || avctx->height <= 0) {
 638             av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
 639             return AVERROR(EINVAL);
 640         }
 641     }
 642     if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
 643         && avctx->bit_rate>0 && avctx->bit_rate<1000) {
 644         av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
 645     }
 646
 647     if (!avctx->rc_initial_buffer_occupancy)
 648         avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
 649
 650     if (avctx->ticks_per_frame && avctx->time_base.num &&
 651         avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
 652         av_log(avctx, AV_LOG_ERROR,
 653                "ticks_per_frame %d too large for the timebase %d/%d.",
 654                avctx->ticks_per_frame,
 655                avctx->time_base.num,
 656                avctx->time_base.den);
 657         return AVERROR(EINVAL);
 658     }
 659
 660     if (avctx->hw_frames_ctx) {
 661         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
 662         if (frames_ctx->format != avctx->pix_fmt) {
 663             av_log(avctx, AV_LOG_ERROR,
 664                    "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
 665             return AVERROR(EINVAL);
 666         }
 667         if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
 668             avctx->sw_pix_fmt != frames_ctx->sw_format) {
 669             av_log(avctx, AV_LOG_ERROR,
 670                    "Mismatching AVCodecContext.sw_pix_fmt (%s) "
 671                    "and AVHWFramesContext.sw_format (%s)\n",
 672                    av_get_pix_fmt_name(avctx->sw_pix_fmt),
 673                    av_get_pix_fmt_name(frames_ctx->sw_format));
 674             return AVERROR(EINVAL);
 675         }
 676         avctx->sw_pix_fmt = frames_ctx->sw_format;
 677     }
 678
 679     return 0;
 680 }