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 /**
  60  * Pad last frame with silence.
  61  */
  62 static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src)
  63 {
  64     int ret;
  65
  66     frame->format         = src->format;
  67     frame->channel_layout = src->channel_layout;
  68     frame->channels       = src->channels;
  69     frame->nb_samples     = s->frame_size;
  70     ret = av_frame_get_buffer(frame, 0);
  71     if (ret < 0)
  72         goto fail;
  73
  74     ret = av_frame_copy_props(frame, src);
  75     if (ret < 0)
  76         goto fail;
  77
  78     if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
  79                                src->nb_samples, s->channels, s->sample_fmt)) < 0)
  80         goto fail;
  81     if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
  82                                       frame->nb_samples - src->nb_samples,
  83                                       s->channels, s->sample_fmt)) < 0)
  84         goto fail;
  85
  86     return 0;
  87
  88 fail:
  89     av_frame_unref(frame);
  90     return ret;
  91 }
  92
  93 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
  94                             const AVSubtitle *sub)
  95 {
  96     int ret;
  97     if (sub->start_display_time) {
  98         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
  99         return -1;
 100     }
 101
 102     ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
 103     avctx->frame_number++;
 104     return ret;
 105 }
 106
 107 int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
 108 {
 109     AVCodecInternal *avci = avctx->internal;
 110
 111     if (avci->draining)
 112         return AVERROR_EOF;
 113
 114     if (!avci->buffer_frame->buf[0])
 115         return AVERROR(EAGAIN);
 116
 117     av_frame_move_ref(frame, avci->buffer_frame);
 118
 119     return 0;
 120 }
 121
 122 static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)
 123 {
 124     AVCodecInternal   *avci = avctx->internal;
 125     EncodeSimpleContext *es = &avci->es;
 126     AVFrame          *frame = es->in_frame;
 127     int got_packet;
 128     int ret;
 129
 130     if (avci->draining_done)
 131         return AVERROR_EOF;
 132
 133     if (!frame->buf[0] && !avci->draining) {
 134         av_frame_unref(frame);
 135         ret = ff_encode_get_frame(avctx, frame);
 136         if (ret < 0 && ret != AVERROR_EOF)
 137             return ret;
 138     }
 139
 140     if (!frame->buf[0]) {
 141         if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
 142               (avci->frame_thread_encoder && avctx->active_thread_type & FF_THREAD_FRAME)))
 143             return AVERROR_EOF;
 144
 145         // Flushing is signaled with a NULL frame
 146         frame = NULL;
 147     }
 148
 149     got_packet = 0;
 150
 151     av_assert0(avctx->codec->encode2);
 152
 153     if (CONFIG_FRAME_THREAD_ENCODER &&
 154         avci->frame_thread_encoder && (avctx->active_thread_type & FF_THREAD_FRAME))
 155         ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);
 156     else {
 157         ret = avctx->codec->encode2(avctx, avpkt, frame, &got_packet);
 158         if (avctx->codec->type == AVMEDIA_TYPE_VIDEO && !ret && got_packet &&
 159             !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
 160             avpkt->pts = avpkt->dts = frame->pts;
 161     }
 162
 163     av_assert0(ret <= 0);
 164
 165     emms_c();
 166
 167     if (!ret && got_packet) {
 168         if (avpkt->data) {
 169             ret = av_packet_make_refcounted(avpkt);
 170             if (ret < 0)
 171                 goto end;
 172         }
 173
 174         if (frame && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
 175             if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
 176                 if (avpkt->pts == AV_NOPTS_VALUE)
 177                     avpkt->pts = frame->pts;
 178                 if (!avpkt->duration)
 179                     avpkt->duration = ff_samples_to_time_base(avctx,
 180                                                               frame->nb_samples);
 181             }
 182         }
 183         if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
 184             /* NOTE: if we add any audio encoders which output non-keyframe packets,
 185              *       this needs to be moved to the encoders, but for now we can do it
 186              *       here to simplify things */
 187             avpkt->flags |= AV_PKT_FLAG_KEY;
 188             avpkt->dts = avpkt->pts;
 189         }
 190     }
 191
 192     if (avci->draining && !got_packet)
 193         avci->draining_done = 1;
 194
 195 end:
 196     if (ret < 0 || !got_packet)
 197         av_packet_unref(avpkt);
 198
 199     if (frame) {
 200         if (!ret)
 201             avctx->frame_number++;
 202         av_frame_unref(frame);
 203     }
 204
 205     if (got_packet)
 206         // Encoders must always return ref-counted buffers.
 207         // Side-data only packets have no data and can be not ref-counted.
 208         av_assert0(!avpkt->data || avpkt->buf);
 209
 210     return ret;
 211 }
 212
 213 static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
 214 {
 215     int ret;
 216
 217     while (!avpkt->data && !avpkt->side_data) {
 218         ret = encode_simple_internal(avctx, avpkt);
 219         if (ret < 0)
 220             return ret;
 221     }
 222
 223     return 0;
 224 }
 225
 226 static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)
 227 {
 228     AVCodecInternal *avci = avctx->internal;
 229     int ret;
 230
 231     if (avci->draining_done)
 232         return AVERROR_EOF;
 233
 234     av_assert0(!avpkt->data && !avpkt->side_data);
 235
 236     if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
 237         if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)
 238             avctx->stats_out[0] = '\0';
 239         if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
 240             return AVERROR(EINVAL);
 241     }
 242
 243     if (avctx->codec->receive_packet) {
 244         ret = avctx->codec->receive_packet(avctx, avpkt);
 245         if (ret < 0)
 246             av_packet_unref(avpkt);
 247         else
 248             // Encoders must always return ref-counted buffers.
 249             // Side-data only packets have no data and can be not ref-counted.
 250             av_assert0(!avpkt->data || avpkt->buf);
 251     } else
 252         ret = encode_simple_receive_packet(avctx, avpkt);
 253
 254     if (ret == AVERROR_EOF)
 255         avci->draining_done = 1;
 256
 257     return ret;
 258 }
 259
 260 static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)
 261 {
 262     AVCodecInternal *avci = avctx->internal;
 263     AVFrame *dst = avci->buffer_frame;
 264     int ret;
 265
 266     if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
 267         /* extract audio service type metadata */
 268         AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
 269         if (sd && sd->size >= sizeof(enum AVAudioServiceType))
 270             avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
 271
 272         /* check for valid frame size */
 273         if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
 274             if (src->nb_samples > avctx->frame_size) {
 275                 av_log(avctx, AV_LOG_ERROR, "more samples than frame size\n");
 276                 return AVERROR(EINVAL);
 277             }
 278         } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
 279             /* if we already got an undersized frame, that must have been the last */
 280             if (avctx->internal->last_audio_frame) {
 281                 av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size);
 282                 return AVERROR(EINVAL);
 283             }
 284
 285             if (src->nb_samples < avctx->frame_size) {
 286                 ret = pad_last_frame(avctx, dst, src);
 287                 if (ret < 0)
 288                     return ret;
 289
 290                 avctx->internal->last_audio_frame = 1;
 291             } else if (src->nb_samples > avctx->frame_size) {
 292                 av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d)\n", src->nb_samples, avctx->frame_size);
 293                 return AVERROR(EINVAL);
 294             }
 295         }
 296     }
 297
 298     if (!dst->data[0]) {
 299         ret = av_frame_ref(dst, src);
 300         if (ret < 0)
 301              return ret;
 302     }
 303
 304     return 0;
 305 }
 306
 307 int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
 308 {
 309     AVCodecInternal *avci = avctx->internal;
 310     int ret;
 311
 312     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
 313         return AVERROR(EINVAL);
 314
 315     if (avci->draining)
 316         return AVERROR_EOF;
 317
 318     if (avci->buffer_frame->data[0])
 319         return AVERROR(EAGAIN);
 320
 321     if (!frame) {
 322         avci->draining = 1;
 323     } else {
 324         ret = encode_send_frame_internal(avctx, frame);
 325         if (ret < 0)
 326             return ret;
 327     }
 328
 329     if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {
 330         ret = encode_receive_packet_internal(avctx, avci->buffer_pkt);
 331         if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
 332             return ret;
 333     }
 334
 335     return 0;
 336 }
 337
 338 int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
 339 {
 340     AVCodecInternal *avci = avctx->internal;
 341     int ret;
 342
 343     av_packet_unref(avpkt);
 344
 345     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
 346         return AVERROR(EINVAL);
 347
 348     if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {
 349         av_packet_move_ref(avpkt, avci->buffer_pkt);
 350     } else {
 351         ret = encode_receive_packet_internal(avctx, avpkt);
 352         if (ret < 0)
 353             return ret;
 354     }
 355
 356     return 0;
 357 }
 358
 359 static int compat_encode(AVCodecContext *avctx, AVPacket *avpkt,
 360                          int *got_packet, const AVFrame *frame)
 361 {
 362     AVCodecInternal *avci = avctx->internal;
 363     AVPacket user_pkt;
 364     int ret;
 365
 366     *got_packet = 0;
 367
 368     if (frame && avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
 369         if (frame->format == AV_PIX_FMT_NONE)
 370             av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
 371         if (frame->width == 0 || frame->height == 0)
 372             av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
 373     }
 374
 375     ret = avcodec_send_frame(avctx, frame);
 376     if (ret == AVERROR_EOF)
 377         ret = 0;
 378     else if (ret == AVERROR(EAGAIN)) {
 379         /* we fully drain all the output in each encode call, so this should not
 380          * ever happen */
 381         return AVERROR_BUG;
 382     } else if (ret < 0)
 383         return ret;
 384
 385     av_packet_move_ref(&user_pkt, avpkt);
 386     while (ret >= 0) {
 387         ret = avcodec_receive_packet(avctx, avpkt);
 388         if (ret < 0) {
 389             if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
 390                 ret = 0;
 391             goto finish;
 392         }
 393
 394         if (avpkt != avci->compat_encode_packet) {
 395             if (avpkt->data && user_pkt.data) {
 396                 if (user_pkt.size >= avpkt->size) {
 397                     memcpy(user_pkt.data, avpkt->data, avpkt->size);
 398                     av_buffer_unref(&avpkt->buf);
 399                     avpkt->buf  = user_pkt.buf;
 400                     avpkt->data = user_pkt.data;
 401                     av_init_packet(&user_pkt);
 402                 } else {
 403                     av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
 404                     av_packet_unref(avpkt);
 405                     ret = AVERROR(EINVAL);
 406                     goto finish;
 407                 }
 408             }
 409
 410             *got_packet = 1;
 411             avpkt = avci->compat_encode_packet;
 412         } else {
 413             if (!avci->compat_decode_warned) {
 414                 av_log(avctx, AV_LOG_WARNING, "The deprecated avcodec_encode_* "
 415                        "API cannot return all the packets for this encoder. "
 416                        "Some packets will be dropped. Update your code to the "
 417                        "new encoding API to fix this.\n");
 418                 avci->compat_decode_warned = 1;
 419                 av_packet_unref(avpkt);
 420             }
 421         }
 422
 423         if (avci->draining)
 424             break;
 425     }
 426
 427 finish:
 428     if (ret < 0)
 429         av_packet_unref(&user_pkt);
 430
 431     return ret;
 432 }
 433
 434 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
 435                                               AVPacket *avpkt,
 436                                               const AVFrame *frame,
 437                                               int *got_packet_ptr)
 438 {
 439     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
 440
 441     if (ret < 0)
 442         av_packet_unref(avpkt);
 443
 444     return ret;
 445 }
 446
 447 int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
 448                                               AVPacket *avpkt,
 449                                               const AVFrame *frame,
 450                                               int *got_packet_ptr)
 451 {
 452     int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
 453
 454     if (ret < 0)
 455         av_packet_unref(avpkt);
 456
 457     return ret;
 458 }