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 int ff_encode_preinit(AVCodecContext *avctx)
 417 {
 418     int i;
 419
 420     if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
 421         av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
 422         return AVERROR(EINVAL);
 423     }
 424
 425     if (avctx->codec->sample_fmts) {
 426         for (i = 0; avctx->codec->sample_fmts[i] != AV_SAMPLE_FMT_NONE; i++) {
 427             if (avctx->sample_fmt == avctx->codec->sample_fmts[i])
 428                 break;
 429             if (avctx->channels == 1 &&
 430                 av_get_planar_sample_fmt(avctx->sample_fmt) ==
 431                 av_get_planar_sample_fmt(avctx->codec->sample_fmts[i])) {
 432                 avctx->sample_fmt = avctx->codec->sample_fmts[i];
 433                 break;
 434             }
 435         }
 436         if (avctx->codec->sample_fmts[i] == AV_SAMPLE_FMT_NONE) {
 437             char buf[128];
 438             snprintf(buf, sizeof(buf), "%d", avctx->sample_fmt);
 439             av_log(avctx, AV_LOG_ERROR, "Specified sample format %s is invalid or not supported\n",
 440                    (char *)av_x_if_null(av_get_sample_fmt_name(avctx->sample_fmt), buf));
 441             return AVERROR(EINVAL);
 442         }
 443     }
 444     if (avctx->codec->pix_fmts) {
 445         for (i = 0; avctx->codec->pix_fmts[i] != AV_PIX_FMT_NONE; i++)
 446             if (avctx->pix_fmt == avctx->codec->pix_fmts[i])
 447                 break;
 448         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_NONE) {
 449             char buf[128];
 450             snprintf(buf, sizeof(buf), "%d", avctx->pix_fmt);
 451             av_log(avctx, AV_LOG_ERROR, "Specified pixel format %s is invalid or not supported\n",
 452                    (char *)av_x_if_null(av_get_pix_fmt_name(avctx->pix_fmt), buf));
 453             return AVERROR(EINVAL);
 454         }
 455         if (avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
 456             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ411P ||
 457             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ422P ||
 458             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ440P ||
 459             avctx->codec->pix_fmts[i] == AV_PIX_FMT_YUVJ444P)
 460             avctx->color_range = AVCOL_RANGE_JPEG;
 461     }
 462     if (avctx->codec->supported_samplerates) {
 463         for (i = 0; avctx->codec->supported_samplerates[i] != 0; i++)
 464             if (avctx->sample_rate == avctx->codec->supported_samplerates[i])
 465                 break;
 466         if (avctx->codec->supported_samplerates[i] == 0) {
 467             av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 468                    avctx->sample_rate);
 469             return AVERROR(EINVAL);
 470         }
 471     }
 472     if (avctx->sample_rate < 0) {
 473         av_log(avctx, AV_LOG_ERROR, "Specified sample rate %d is not supported\n",
 474                 avctx->sample_rate);
 475         return AVERROR(EINVAL);
 476     }
 477     if (avctx->codec->channel_layouts) {
 478         if (!avctx->channel_layout) {
 479             av_log(avctx, AV_LOG_WARNING, "Channel layout not specified\n");
 480         } else {
 481             for (i = 0; avctx->codec->channel_layouts[i] != 0; i++)
 482                 if (avctx->channel_layout == avctx->codec->channel_layouts[i])
 483                     break;
 484             if (avctx->codec->channel_layouts[i] == 0) {
 485                 char buf[512];
 486                 av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 487                 av_log(avctx, AV_LOG_ERROR, "Specified channel layout '%s' is not supported\n", buf);
 488                 return AVERROR(EINVAL);
 489             }
 490         }
 491     }
 492     if (avctx->channel_layout && avctx->channels) {
 493         int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 494         if (channels != avctx->channels) {
 495             char buf[512];
 496             av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
 497             av_log(avctx, AV_LOG_ERROR,
 498                    "Channel layout '%s' with %d channels does not match number of specified channels %d\n",
 499                    buf, channels, avctx->channels);
 500             return AVERROR(EINVAL);
 501         }
 502     } else if (avctx->channel_layout) {
 503         avctx->channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
 504     }
 505     if (avctx->channels < 0) {
 506         av_log(avctx, AV_LOG_ERROR, "Specified number of channels %d is not supported\n",
 507                 avctx->channels);
 508         return AVERROR(EINVAL);
 509     }
 510     if(avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
 511         const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
 512         if (    avctx->bits_per_raw_sample < 0
 513             || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
 514             av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
 515                 avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
 516             avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
 517         }
 518         if (avctx->width <= 0 || avctx->height <= 0) {
 519             av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
 520             return AVERROR(EINVAL);
 521         }
 522     }
 523     if (   (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
 524         && avctx->bit_rate>0 && avctx->bit_rate<1000) {
 525         av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
 526     }
 527
 528     if (!avctx->rc_initial_buffer_occupancy)
 529         avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
 530
 531     if (avctx->ticks_per_frame && avctx->time_base.num &&
 532         avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
 533         av_log(avctx, AV_LOG_ERROR,
 534                "ticks_per_frame %d too large for the timebase %d/%d.",
 535                avctx->ticks_per_frame,
 536                avctx->time_base.num,
 537                avctx->time_base.den);
 538         return AVERROR(EINVAL);
 539     }
 540
 541     if (avctx->hw_frames_ctx) {
 542         AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
 543         if (frames_ctx->format != avctx->pix_fmt) {
 544             av_log(avctx, AV_LOG_ERROR,
 545                    "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
 546             return AVERROR(EINVAL);
 547         }
 548         if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
 549             avctx->sw_pix_fmt != frames_ctx->sw_format) {
 550             av_log(avctx, AV_LOG_ERROR,
 551                    "Mismatching AVCodecContext.sw_pix_fmt (%s) "
 552                    "and AVHWFramesContext.sw_format (%s)\n",
 553                    av_get_pix_fmt_name(avctx->sw_pix_fmt),
 554                    av_get_pix_fmt_name(frames_ctx->sw_format));
 555             return AVERROR(EINVAL);
 556         }
 557         avctx->sw_pix_fmt = frames_ctx->sw_format;
 558     }
 559
 560     return 0;
 561 }