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     memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
  78
  79     return 0;
  80 }
  81
  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  */
 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                     av_init_packet(&user_pkt);
 466                 } else {
 467                     av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
 468                     av_packet_unref(avpkt);
 469                     ret = AVERROR(EINVAL);
 470                     goto finish;
 471                 }
 472             }
 473
 474             *got_packet = 1;
 475             avpkt = avci->compat_encode_packet;
 476         } else {
 477             if (!avci->compat_decode_warned) {
 478                 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* "
 479                        "API cannot return all the packets for this encoder. "
 480                        "Some packets will be dropped. Update your code to the "
 481                        "new encoding API to fix this.\n");
 482                 avci->compat_decode_warned = 1;
 483                 av_packet_unref(avpkt);
 484             }
 485         }
 486
 487         if (avci->draining)
 488             break;
 489     }
 490
 491 finish:
 492     if (ret < 0)
 493         av_packet_unref(&user_pkt);
 494
 495     return ret;
 496 }
 497
 498 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
 499                                               AVPacket *avpkt,
 500                                               const AVFrame *frame,
 501                                               int *got_packet_ptr)
 502 {
 503     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
 504
 505     if (ret < 0)
 506         av_packet_unref(avpkt);
 507
 508     return ret;
 509 }
 510
 511 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
 512                                               AVPacket *avpkt,
 513                                               const AVFrame *frame,
 514                                               int *got_packet_ptr)
 515 {
 516     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
 517
 518     if (ret < 0)
 519         av_packet_unref(avpkt);
 520
 521     return ret;
 522 }
 523 #endif