LCOV - code coverage report
Current view: top level - libavcodec - encode.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 183 255 71.8 %
Date: 2017-12-15 11:05:35 Functions: 8 9 88.9 %

          Line data    Source code
       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 "frame_thread_encoder.h"
      30             : #include "internal.h"
      31             : 
      32      391373 : int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
      33             : {
      34      391373 :     if (avpkt->size < 0) {
      35           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid negative user packet size %d\n", avpkt->size);
      36           0 :         return AVERROR(EINVAL);
      37             :     }
      38      391373 :     if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
      39           0 :         av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
      40             :                size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
      41           0 :         return AVERROR(EINVAL);
      42             :     }
      43             : 
      44      391373 :     if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
      45       65585 :         av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
      46       65585 :         if (!avpkt->data || avpkt->size < size) {
      47       65585 :             av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
      48       65585 :             avpkt->data = avctx->internal->byte_buffer;
      49       65585 :             avpkt->size = avctx->internal->byte_buffer_size;
      50             :         }
      51             :     }
      52             : 
      53      391373 :     if (avpkt->data) {
      54       65585 :         AVBufferRef *buf = avpkt->buf;
      55             : 
      56       65585 :         if (avpkt->size < size) {
      57           0 :             av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %"PRId64")\n", avpkt->size, size);
      58           0 :             return AVERROR(EINVAL);
      59             :         }
      60             : 
      61       65585 :         av_init_packet(avpkt);
      62       65585 :         avpkt->buf      = buf;
      63       65585 :         avpkt->size     = size;
      64       65585 :         return 0;
      65             :     } else {
      66      325788 :         int ret = av_new_packet(avpkt, size);
      67      325788 :         if (ret < 0)
      68           0 :             av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
      69      325788 :         return ret;
      70             :     }
      71             : }
      72             : 
      73           0 : int ff_alloc_packet(AVPacket *avpkt, int size)
      74             : {
      75           0 :     return ff_alloc_packet2(NULL, avpkt, size, 0);
      76             : }
      77             : 
      78             : /**
      79             :  * Pad last frame with silence.
      80             :  */
      81          40 : static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
      82             : {
      83          40 :     AVFrame *frame = NULL;
      84             :     int ret;
      85             : 
      86          40 :     if (!(frame = av_frame_alloc()))
      87           0 :         return AVERROR(ENOMEM);
      88             : 
      89          40 :     frame->format         = src->format;
      90          40 :     frame->channel_layout = src->channel_layout;
      91          40 :     frame->channels       = src->channels;
      92          40 :     frame->nb_samples     = s->frame_size;
      93          40 :     ret = av_frame_get_buffer(frame, 32);
      94          40 :     if (ret < 0)
      95           0 :         goto fail;
      96             : 
      97          40 :     ret = av_frame_copy_props(frame, src);
      98          40 :     if (ret < 0)
      99           0 :         goto fail;
     100             : 
     101          40 :     if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
     102             :                                src->nb_samples, s->channels, s->sample_fmt)) < 0)
     103           0 :         goto fail;
     104          80 :     if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
     105          40 :                                       frame->nb_samples - src->nb_samples,
     106             :                                       s->channels, s->sample_fmt)) < 0)
     107           0 :         goto fail;
     108             : 
     109          40 :     *dst = frame;
     110             : 
     111          40 :     return 0;
     112             : 
     113           0 : fail:
     114           0 :     av_frame_free(&frame);
     115           0 :     return ret;
     116             : }
     117             : 
     118      301309 : int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
     119             :                                               AVPacket *avpkt,
     120             :                                               const AVFrame *frame,
     121             :                                               int *got_packet_ptr)
     122             : {
     123      301309 :     AVFrame *extended_frame = NULL;
     124      301309 :     AVFrame *padded_frame = NULL;
     125             :     int ret;
     126      301309 :     AVPacket user_pkt = *avpkt;
     127      301309 :     int needs_realloc = !user_pkt.data;
     128             : 
     129      301309 :     *got_packet_ptr = 0;
     130             : 
     131      301309 :     if (!avctx->codec->encode2) {
     132           0 :         av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
     133           0 :         return AVERROR(ENOSYS);
     134             :     }
     135             : 
     136      301309 :     if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
     137          59 :         av_packet_unref(avpkt);
     138          59 :         av_init_packet(avpkt);
     139          59 :         return 0;
     140             :     }
     141             : 
     142             :     /* ensure that extended_data is properly set */
     143      301250 :     if (frame && !frame->extended_data) {
     144           0 :         if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
     145           0 :             avctx->channels > AV_NUM_DATA_POINTERS) {
     146           0 :             av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
     147             :                                         "with more than %d channels, but extended_data is not set.\n",
     148             :                    AV_NUM_DATA_POINTERS);
     149           0 :             return AVERROR(EINVAL);
     150             :         }
     151           0 :         av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");
     152             : 
     153           0 :         extended_frame = av_frame_alloc();
     154           0 :         if (!extended_frame)
     155           0 :             return AVERROR(ENOMEM);
     156             : 
     157           0 :         memcpy(extended_frame, frame, sizeof(AVFrame));
     158           0 :         extended_frame->extended_data = extended_frame->data;
     159           0 :         frame = extended_frame;
     160             :     }
     161             : 
     162             :     /* extract audio service type metadata */
     163      301250 :     if (frame) {
     164      301182 :         AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
     165      301182 :         if (sd && sd->size >= sizeof(enum AVAudioServiceType))
     166           0 :             avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
     167             :     }
     168             : 
     169             :     /* check for valid frame size */
     170      301250 :     if (frame) {
     171      301182 :         if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
     172       12083 :             if (frame->nb_samples > avctx->frame_size) {
     173           0 :                 av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
     174           0 :                 ret = AVERROR(EINVAL);
     175           0 :                 goto end;
     176             :             }
     177      289099 :         } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
     178       39349 :             if (frame->nb_samples < avctx->frame_size &&
     179          40 :                 !avctx->internal->last_audio_frame) {
     180          40 :                 ret = pad_last_frame(avctx, &padded_frame, frame);
     181          40 :                 if (ret < 0)
     182           0 :                     goto end;
     183             : 
     184          40 :                 frame = padded_frame;
     185          40 :                 avctx->internal->last_audio_frame = 1;
     186             :             }
     187             : 
     188       39309 :             if (frame->nb_samples != avctx->frame_size) {
     189           0 :                 av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
     190           0 :                 ret = AVERROR(EINVAL);
     191           0 :                 goto end;
     192             :             }
     193             :         }
     194             :     }
     195             : 
     196      301250 :     av_assert0(avctx->codec->encode2);
     197             : 
     198      301250 :     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
     199      301250 :     if (!ret) {
     200      301250 :         if (*got_packet_ptr) {
     201      295064 :             if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
     202      285130 :                 if (avpkt->pts == AV_NOPTS_VALUE)
     203      279081 :                     avpkt->pts = frame->pts;
     204      285130 :                 if (!avpkt->duration)
     205      284075 :                     avpkt->duration = ff_samples_to_time_base(avctx,
     206      284075 :                                                               frame->nb_samples);
     207             :             }
     208      295064 :             avpkt->dts = avpkt->pts;
     209             :         } else {
     210        6186 :             avpkt->size = 0;
     211             :         }
     212             :     }
     213      301250 :     if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
     214       45522 :         needs_realloc = 0;
     215       45522 :         if (user_pkt.data) {
     216           0 :             if (user_pkt.size >= avpkt->size) {
     217           0 :                 memcpy(user_pkt.data, avpkt->data, avpkt->size);
     218             :             } else {
     219           0 :                 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
     220           0 :                 avpkt->size = user_pkt.size;
     221           0 :                 ret = -1;
     222             :             }
     223           0 :             avpkt->buf      = user_pkt.buf;
     224           0 :             avpkt->data     = user_pkt.data;
     225       45522 :         } else if (!avpkt->buf) {
     226       45522 :             AVPacket tmp = { 0 };
     227       45522 :             ret = av_packet_ref(&tmp, avpkt);
     228       45522 :             av_packet_unref(avpkt);
     229       45522 :             if (ret < 0)
     230           0 :                 goto end;
     231       45522 :             *avpkt = tmp;
     232             :         }
     233             :     }
     234             : 
     235      301250 :     if (!ret) {
     236      301250 :         if (needs_realloc && avpkt->data) {
     237      249530 :             ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
     238      249530 :             if (ret >= 0)
     239      249530 :                 avpkt->data = avpkt->buf->data;
     240             :         }
     241             : 
     242      301250 :         avctx->frame_number++;
     243             :     }
     244             : 
     245      301250 :     if (ret < 0 || !*got_packet_ptr) {
     246        6186 :         av_packet_unref(avpkt);
     247        6186 :         av_init_packet(avpkt);
     248        6186 :         goto end;
     249             :     }
     250             : 
     251             :     /* NOTE: if we add any audio encoders which output non-keyframe packets,
     252             :      *       this needs to be moved to the encoders, but for now we can do it
     253             :      *       here to simplify things */
     254      295064 :     avpkt->flags |= AV_PKT_FLAG_KEY;
     255             : 
     256      301250 : end:
     257      301250 :     av_frame_free(&padded_frame);
     258      301250 :     av_free(extended_frame);
     259             : 
     260      301250 :     return ret;
     261             : }
     262             : 
     263      101611 : int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
     264             :                                               AVPacket *avpkt,
     265             :                                               const AVFrame *frame,
     266             :                                               int *got_packet_ptr)
     267             : {
     268             :     int ret;
     269      101611 :     AVPacket user_pkt = *avpkt;
     270      101611 :     int needs_realloc = !user_pkt.data;
     271             : 
     272      101611 :     *got_packet_ptr = 0;
     273             : 
     274      101611 :     if (!avctx->codec->encode2) {
     275           0 :         av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
     276           0 :         return AVERROR(ENOSYS);
     277             :     }
     278             : 
     279      101611 :     if(CONFIG_FRAME_THREAD_ENCODER &&
     280      103221 :        avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
     281         845 :         return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
     282             : 
     283      100766 :     if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
     284           0 :         avctx->stats_out[0] = '\0';
     285             : 
     286      100766 :     if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
     287        4079 :         av_packet_unref(avpkt);
     288        4079 :         av_init_packet(avpkt);
     289        4079 :         avpkt->size = 0;
     290        4079 :         return 0;
     291             :     }
     292             : 
     293       96687 :     if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
     294           0 :         return AVERROR(EINVAL);
     295             : 
     296       96687 :     if (frame && frame->format == AV_PIX_FMT_NONE)
     297           0 :         av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
     298       96687 :     if (frame && (frame->width == 0 || frame->height == 0))
     299           0 :         av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");
     300             : 
     301       96687 :     av_assert0(avctx->codec->encode2);
     302             : 
     303       96687 :     ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
     304       96687 :     av_assert0(ret <= 0);
     305             : 
     306       96687 :     emms_c();
     307             : 
     308       96687 :     if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
     309       20063 :         needs_realloc = 0;
     310       20063 :         if (user_pkt.data) {
     311           0 :             if (user_pkt.size >= avpkt->size) {
     312           0 :                 memcpy(user_pkt.data, avpkt->data, avpkt->size);
     313             :             } else {
     314           0 :                 av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
     315           0 :                 avpkt->size = user_pkt.size;
     316           0 :                 ret = -1;
     317             :             }
     318           0 :             avpkt->buf      = user_pkt.buf;
     319           0 :             avpkt->data     = user_pkt.data;
     320       20063 :         } else if (!avpkt->buf) {
     321       20063 :             AVPacket tmp = { 0 };
     322       20063 :             ret = av_packet_ref(&tmp, avpkt);
     323       20063 :             av_packet_unref(avpkt);
     324       20063 :             if (ret < 0)
     325           0 :                 return ret;
     326       20063 :             *avpkt = tmp;
     327             :         }
     328             :     }
     329             : 
     330       96687 :     if (!ret) {
     331       96687 :         if (!*got_packet_ptr)
     332         321 :             avpkt->size = 0;
     333       96366 :         else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
     334       90310 :             avpkt->pts = avpkt->dts = frame->pts;
     335             : 
     336       96687 :         if (needs_realloc && avpkt->data) {
     337       76303 :             ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
     338       76303 :             if (ret >= 0)
     339       76303 :                 avpkt->data = avpkt->buf->data;
     340             :         }
     341             : 
     342       96687 :         avctx->frame_number++;
     343             :     }
     344             : 
     345       96687 :     if (ret < 0 || !*got_packet_ptr)
     346         321 :         av_packet_unref(avpkt);
     347             : 
     348       96687 :     return ret;
     349             : }
     350             : 
     351         595 : int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
     352             :                             const AVSubtitle *sub)
     353             : {
     354             :     int ret;
     355         595 :     if (sub->start_display_time) {
     356           0 :         av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
     357           0 :         return -1;
     358             :     }
     359             : 
     360         595 :     ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
     361         595 :     avctx->frame_number++;
     362         595 :     return ret;
     363             : }
     364             : 
     365      398895 : static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
     366             : {
     367             :     int ret;
     368      398895 :     *got_packet = 0;
     369             : 
     370      398895 :     av_packet_unref(avctx->internal->buffer_pkt);
     371      398895 :     avctx->internal->buffer_pkt_valid = 0;
     372             : 
     373      398895 :     if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
     374      100786 :         ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
     375             :                                     frame, got_packet);
     376      298109 :     } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
     377      298109 :         ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
     378             :                                     frame, got_packet);
     379             :     } else {
     380           0 :         ret = AVERROR(EINVAL);
     381             :     }
     382             : 
     383      398895 :     if (ret >= 0 && *got_packet) {
     384             :         // Encoders must always return ref-counted buffers.
     385             :         // Side-data only packets have no data and can be not ref-counted.
     386      388170 :         av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
     387      388170 :         avctx->internal->buffer_pkt_valid = 1;
     388      388170 :         ret = 0;
     389             :     } else {
     390       10725 :         av_packet_unref(avctx->internal->buffer_pkt);
     391             :     }
     392             : 
     393      398895 :     return ret;
     394             : }
     395             : 
     396      398609 : int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
     397             : {
     398      398609 :     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
     399           0 :         return AVERROR(EINVAL);
     400             : 
     401      398609 :     if (avctx->internal->draining)
     402           0 :         return AVERROR_EOF;
     403             : 
     404      398609 :     if (!frame) {
     405        4321 :         avctx->internal->draining = 1;
     406             : 
     407        4321 :         if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
     408        4156 :             return 0;
     409             :     }
     410             : 
     411      394453 :     if (avctx->codec->send_frame)
     412           0 :         return avctx->codec->send_frame(avctx, frame);
     413             : 
     414             :     // Emulation via old API. Do it here instead of avcodec_receive_packet, because:
     415             :     // 1. if the AVFrame is not refcounted, the copying will be much more
     416             :     //    expensive than copying the packet data
     417             :     // 2. assume few users use non-refcounted AVPackets, so usually no copy is
     418             :     //    needed
     419             : 
     420      394453 :     if (avctx->internal->buffer_pkt_valid)
     421           0 :         return AVERROR(EAGAIN);
     422             : 
     423      394453 :     return do_encode(avctx, frame, &(int){0});
     424             : }
     425             : 
     426      791100 : int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
     427             : {
     428      791100 :     av_packet_unref(avpkt);
     429             : 
     430      791100 :     if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
     431           0 :         return AVERROR(EINVAL);
     432             : 
     433      791100 :     if (avctx->codec->receive_packet) {
     434           0 :         if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
     435           0 :             return AVERROR_EOF;
     436           0 :         return avctx->codec->receive_packet(avctx, avpkt);
     437             :     }
     438             : 
     439             :     // Emulation via old API.
     440             : 
     441      791100 :     if (!avctx->internal->buffer_pkt_valid) {
     442             :         int got_packet;
     443             :         int ret;
     444      403051 :         if (!avctx->internal->draining)
     445      801539 :             return AVERROR(EAGAIN);
     446        4442 :         ret = do_encode(avctx, NULL, &got_packet);
     447        4442 :         if (ret < 0)
     448           0 :             return ret;
     449        4442 :         if (ret >= 0 && !got_packet)
     450        4321 :             return AVERROR_EOF;
     451             :     }
     452             : 
     453      388170 :     av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
     454      388170 :     avctx->internal->buffer_pkt_valid = 0;
     455      388170 :     return 0;
     456             : }

Generated by: LCOV version 1.13