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
 531     if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
 532         av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
 533         return AVERROR(EINVAL);
 534     }
 535
 536     if (avctx->codec->sample_fmts) {
 537         for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
 538             if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
 539                 break;
 540             if (avctx->channels == 1 &&
 541                 av_get_planar_sample_fmt(avctx->sample_fmt) ==
 542                 av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
 543                 avctx->sample_fmt = avctx->codec->sample_fmts[i];
 544                 break;
 545             }
 546         }
 547         if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
 548             char buf[128];
 549             snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
 550             av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
 551                    (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
 552             return AVERROR(EINVAL);
 553         }
 554     }
 555     if (avctx->codec->pix_fmts) {
 556         for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
 557             if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
 558                 break;
 559         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
 560             char buf[128];
 561             snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
 562             av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
 563                    (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
 564             return AVERROR(EINVAL);
 565         }
 566         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
 567             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
 568             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
 569             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
 570             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
 571             avctx->color_range = AVCOL_RANGE_JPEG;
 572     }
 573     if (avctx->codec->supported_samplerates) {
 574         for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
 575             if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
 576                 break;
 577         if (avctx->codec->supported_samplerates[i] == 0) {
 578             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 579                    avctx->sample_rate);
 580             return AVERROR(EINVAL);
 581         }
 582     }
 583     if (avctx->sample_rate < 0) {
 584         av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 585                 avctx->sample_rate);
 586         return AVERROR(EINVAL);
 587     }
 588     if (avctx->codec->channel_layouts) {
 589         if (!avctx->channel_layout) {
 590             av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
 591         } else {
 592             for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
 593                 if (avctx->channel_layout == avctx->codec->channel_layouts[i])
 594                     break;
 595             if (avctx->codec->channel_layouts[i] == 0) {
 596                 char buf[512];
 597                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 598                 av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
 599                 return AVERROR(EINVAL);
 600             }
 601         }
 602     }
 603     if (avctx->channel_layout && avctx->channels) {
 604         int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 605         if (channels != avctx->channels) {
 606             char buf[512];
 607             av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 608             av_log(avctx, AV_LOG_ERROR,
 609                    "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
 610                    buf, channels, avctx->channels);
 611             return AVERROR(EINVAL);
 612         }
 613     } else if (avctx->channel_layout) {
 614         avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 615     }
 616     if (avctx->channels < 0) {
 617         av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
 618                 avctx->channels);
 619         return AVERROR(EINVAL);
 620     }
 621     if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 622         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
 623         if (    avctx->bits_per_raw_sample < 0
 624             || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
 625             av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
 626                 avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
 627             avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
 628         }
 629         if (avctx->width <= 0 || avctx->height <= 0) {
 630             av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
 631             return AVERROR(EINVAL);
 632         }
 633     }
 634     if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
 635         && avctx->bit_rate>0 && avctx->bit_rate<1000) {
 636         av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
 637     }
 638
 639     if (!avctx->rc_initial_buffer_occupancy)
 640         avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
 641
 642     if (avctx->ticks_per_frame && avctx->time_base.num &&
 643         avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
 644         av_log(avctx, AV_LOG_ERROR,
 645                "ticks_per_frame %d too large for the timebase %d/%d.",
 646                avctx->ticks_per_frame,
 647                avctx->time_base.num,
 648                avctx->time_base.den);
 649         return AVERROR(EINVAL);
 650     }
 651
 652     if (avctx->hw_frames_ctx) {
 653         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
 654         if (frames_ctx->format != avctx->pix_fmt) {
 655             av_log(avctx, AV_LOG_ERROR,
 656                    "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
 657             return AVERROR(EINVAL);
 658         }
 659         if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
 660             avctx->sw_pix_fmt != frames_ctx->sw_format) {
 661             av_log(avctx, AV_LOG_ERROR,
 662                    "Mismatching AVCodecContext.sw_pix_fmt (%s) "
 663                    "and AVHWFramesContext.sw_format (%s)\n",
 664                    av_get_pix_fmt_name(avctx->sw_pix_fmt),
 665                    av_get_pix_fmt_name(frames_ctx->sw_format));
 666             return AVERROR(EINVAL);
 667         }
 668         avctx->sw_pix_fmt = frames_ctx->sw_format;
 669     }
 670
 671     return 0;
 672 }