FFmpeg coverage

GCC Code Coverage Report

Directory:	../../../ffmpeg/		Exec	Total	Coverage
File:	src/libavcodec/encode.c	Lines:	175	253	69.2 %
Date:	2020-04-04 00:26:16	Branches:	140	224	62.5 %


/*
 * generic encoding-related code
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
 * FFmpeg is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

#include "libavutil/attributes.h"
#include "libavutil/avassert.h"
#include "libavutil/frame.h"
#include "libavutil/imgutils.h"
#include "libavutil/internal.h"
#include "libavutil/samplefmt.h"

#include "avcodec.h"
#include "frame_thread_encoder.h"
#include "internal.h"

int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
{
    if (avpkt->size < 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid negative user packet size %d\n", avpkt->size);
        return AVERROR(EINVAL);
    }
    if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
        av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
               size, INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE);
        return AVERROR(EINVAL);
    }

    if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
        av_assert0(!avpkt->data || avpkt->data != avctx->internal->byte_buffer);
        if (!avpkt->data || avpkt->size < size) {
            av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
            avpkt->data = avctx->internal->byte_buffer;
            avpkt->size = avctx->internal->byte_buffer_size;
        }
    }

    if (avpkt->data) {
        AVBufferRef *buf = avpkt->buf;

        if (avpkt->size < size) {
            av_log(avctx, AV_LOG_ERROR, "User packet is too small (%d < %"PRId64")\n", avpkt->size, size);
            return AVERROR(EINVAL);
        }

        av_init_packet(avpkt);
        avpkt->buf      = buf;
        avpkt->size     = size;
        return 0;
    } else {
        int ret = av_new_packet(avpkt, size);
        if (ret < 0)
            av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
        return ret;
    }
}

int ff_alloc_packet(AVPacket *avpkt, int size)
{
    return ff_alloc_packet2(NULL, avpkt, size, 0);
}

/**
 * Pad last frame with silence.
 */
static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
{
    AVFrame *frame = NULL;
    int ret;

    if (!(frame = av_frame_alloc()))
        return AVERROR(ENOMEM);

    frame->format         = src->format;
    frame->channel_layout = src->channel_layout;
    frame->channels       = src->channels;
    frame->nb_samples     = s->frame_size;
    ret = av_frame_get_buffer(frame, 32);
    if (ret < 0)
        goto fail;

    ret = av_frame_copy_props(frame, src);
    if (ret < 0)
        goto fail;

    if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
                               src->nb_samples, s->channels, s->sample_fmt)) < 0)
        goto fail;
    if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
                                      frame->nb_samples - src->nb_samples,
                                      s->channels, s->sample_fmt)) < 0)
        goto fail;

    *dst = frame;

    return 0;

fail:
    av_frame_free(&frame);
    return ret;
}

int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
                                              AVPacket *avpkt,
                                              const AVFrame *frame,
                                              int *got_packet_ptr)
{
    AVFrame *extended_frame = NULL;
    AVFrame *padded_frame = NULL;
    int ret;
    AVPacket user_pkt = *avpkt;
    int needs_realloc = !user_pkt.data;

    *got_packet_ptr = 0;

    if (!avctx->codec->encode2) {
        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
        return AVERROR(ENOSYS);
    }

    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
        av_packet_unref(avpkt);
        return 0;
    }

    /* ensure that extended_data is properly set */
    if (frame && !frame->extended_data) {
        if (av_sample_fmt_is_planar(avctx->sample_fmt) &&
            avctx->channels > AV_NUM_DATA_POINTERS) {
            av_log(avctx, AV_LOG_ERROR, "Encoding to a planar sample format, "
                                        "with more than %d channels, but extended_data is not set.\n",
                   AV_NUM_DATA_POINTERS);
            return AVERROR(EINVAL);
        }
        av_log(avctx, AV_LOG_WARNING, "extended_data is not set.\n");

        extended_frame = av_frame_alloc();
        if (!extended_frame)
            return AVERROR(ENOMEM);

        memcpy(extended_frame, frame, sizeof(AVFrame));
        extended_frame->extended_data = extended_frame->data;
        frame = extended_frame;
    }

    /* extract audio service type metadata */
    if (frame) {
        AVFrameSideData *sd = av_frame_get_side_data(frame, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
        if (sd && sd->size >= sizeof(enum AVAudioServiceType))
            avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
    }

    /* check for valid frame size */
    if (frame) {
        if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
            if (frame->nb_samples > avctx->frame_size) {
                av_log(avctx, AV_LOG_ERROR, "more samples than frame size (avcodec_encode_audio2)\n");
                ret = AVERROR(EINVAL);
                goto end;
            }
        } else if (!(avctx->codec->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE)) {
            /* if we already got an undersized frame, that must have been the last */
            if (avctx->internal->last_audio_frame) {
                av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame (avcodec_encode_audio2)\n", avctx->frame_size);
                ret = AVERROR(EINVAL);
                goto end;
            }

            if (frame->nb_samples < avctx->frame_size) {
                ret = pad_last_frame(avctx, &padded_frame, frame);
                if (ret < 0)
                    goto end;

                frame = padded_frame;
                avctx->internal->last_audio_frame = 1;
            }

            if (frame->nb_samples != avctx->frame_size) {
                av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) != frame_size (%d) (avcodec_encode_audio2)\n", frame->nb_samples, avctx->frame_size);
                ret = AVERROR(EINVAL);
                goto end;
            }
        }
    }

    av_assert0(avctx->codec->encode2);

    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
    if (!ret) {
        if (*got_packet_ptr) {
            if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
                if (avpkt->pts == AV_NOPTS_VALUE)
                    avpkt->pts = frame->pts;
                if (!avpkt->duration)
                    avpkt->duration = ff_samples_to_time_base(avctx,
                                                              frame->nb_samples);
            }
            avpkt->dts = avpkt->pts;
        } else {
            avpkt->size = 0;
        }
    }
    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
        needs_realloc = 0;
        if (user_pkt.data) {
            if (user_pkt.size >= avpkt->size) {
                memcpy(user_pkt.data, avpkt->data, avpkt->size);
            } else {
                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
                avpkt->size = user_pkt.size;
                ret = -1;
            }
            avpkt->buf      = user_pkt.buf;
            avpkt->data     = user_pkt.data;
        } else if (!avpkt->buf) {
            ret = av_packet_make_refcounted(avpkt);
            if (ret < 0)
                goto end;
        }
    }

    if (!ret) {
        if (needs_realloc && avpkt->data) {
            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
            if (ret >= 0)
                avpkt->data = avpkt->buf->data;
        }
        if (frame)
            avctx->frame_number++;
    }

    if (ret < 0 || !*got_packet_ptr) {
        av_packet_unref(avpkt);
        goto end;
    }

    /* NOTE: if we add any audio encoders which output non-keyframe packets,
     *       this needs to be moved to the encoders, but for now we can do it
     *       here to simplify things */
    avpkt->flags |= AV_PKT_FLAG_KEY;

end:
    av_frame_free(&padded_frame);
    av_free(extended_frame);

    return ret;
}

int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
                                              AVPacket *avpkt,
                                              const AVFrame *frame,
                                              int *got_packet_ptr)
{
    int ret;
    AVPacket user_pkt = *avpkt;
    int needs_realloc = !user_pkt.data;

    *got_packet_ptr = 0;

    if (!avctx->codec->encode2) {
        av_log(avctx, AV_LOG_ERROR, "This encoder requires using the avcodec_send_frame() API.\n");
        return AVERROR(ENOSYS);
    }

    if(CONFIG_FRAME_THREAD_ENCODER &&
       avctx->internal->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))
        return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);

    if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
        avctx->stats_out[0] = '\0';

    if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
        av_packet_unref(avpkt);
        return 0;
    }

    if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
        return AVERROR(EINVAL);

    if (frame && frame->format == AV_PIX_FMT_NONE)
        av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
    if (frame && (frame->width == 0 || frame->height == 0))
        av_log(avctx, AV_LOG_WARNING, "AVFrame.width or height is not set\n");

    av_assert0(avctx->codec->encode2);

    ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
    av_assert0(ret <= 0);

    emms_c();

    if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
        needs_realloc = 0;
        if (user_pkt.data) {
            if (user_pkt.size >= avpkt->size) {
                memcpy(user_pkt.data, avpkt->data, avpkt->size);
            } else {
                av_log(avctx, AV_LOG_ERROR, "Provided packet is too small, needs to be %d\n", avpkt->size);
                avpkt->size = user_pkt.size;
                ret = -1;
            }
            avpkt->buf      = user_pkt.buf;
            avpkt->data     = user_pkt.data;
        } else if (!avpkt->buf) {
            ret = av_packet_make_refcounted(avpkt);
            if (ret < 0)
                return ret;
        }
    }

    if (!ret) {
        if (!*got_packet_ptr)
            avpkt->size = 0;
        else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
            avpkt->pts = avpkt->dts = frame->pts;

        if (needs_realloc && avpkt->data) {
            ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
            if (ret >= 0)
                avpkt->data = avpkt->buf->data;
        }

        if (frame)
            avctx->frame_number++;
    }

    if (ret < 0 || !*got_packet_ptr)
        av_packet_unref(avpkt);

    return ret;
}

int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
                            const AVSubtitle *sub)
{
    int ret;
    if (sub->start_display_time) {
        av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
        return -1;
    }

    ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
    avctx->frame_number++;
    return ret;
}

static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
{
    int ret;
    *got_packet = 0;

    av_packet_unref(avctx->internal->buffer_pkt);
    avctx->internal->buffer_pkt_valid = 0;

    if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
        ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
                                    frame, got_packet);
    } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
        ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
                                    frame, got_packet);
    } else {
        ret = AVERROR(EINVAL);
    }

    if (ret >= 0 && *got_packet) {
        // Encoders must always return ref-counted buffers.
        // Side-data only packets have no data and can be not ref-counted.
        av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
        avctx->internal->buffer_pkt_valid = 1;
        ret = 0;
    } else {
        av_packet_unref(avctx->internal->buffer_pkt);
    }

    return ret;
}

int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
{
    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
        return AVERROR(EINVAL);

    if (avctx->internal->draining)
        return AVERROR_EOF;

    if (!frame) {
        avctx->internal->draining = 1;

        if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
            return 0;
    }

    if (avctx->codec->send_frame)
        return avctx->codec->send_frame(avctx, frame);

    // Emulation via old API. Do it here instead of avcodec_receive_packet, because:
    // 1. if the AVFrame is not refcounted, the copying will be much more
    //    expensive than copying the packet data
    // 2. assume few users use non-refcounted AVPackets, so usually no copy is
    //    needed

    if (avctx->internal->buffer_pkt_valid)
        return AVERROR(EAGAIN);

    return do_encode(avctx, frame, &(int){0});
}

int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
{
    av_packet_unref(avpkt);

    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
        return AVERROR(EINVAL);

    if (avctx->codec->receive_packet) {
        int ret;
        if (avctx->internal->draining && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
            return AVERROR_EOF;
        ret = avctx->codec->receive_packet(avctx, avpkt);
        if (!ret)
            // Encoders must always return ref-counted buffers.
            // Side-data only packets have no data and can be not ref-counted.
            av_assert0(!avpkt->data || avpkt->buf);
        return ret;
    }

    // Emulation via old API.

    if (!avctx->internal->buffer_pkt_valid) {
        int got_packet;
        int ret;
        if (!avctx->internal->draining)
            return AVERROR(EAGAIN);
        ret = do_encode(avctx, NULL, &got_packet);
        if (ret < 0)
            return ret;
        if (ret >= 0 && !got_packet)
            return AVERROR_EOF;
    }

    av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
    avctx->internal->buffer_pkt_valid = 0;
    return 0;
}


Generated by: GCOVR (Version 4.2)

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