GCC Code Coverage Report
Directory: ../../../ffmpeg/ Exec Total Coverage
File: src/libavcodec/encode.c Lines: 183 242 75.6 %
Date: 2021-01-26 11:44:58 Branches: 152 228 66.7 %

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 "encode.h"
30
#include "frame_thread_encoder.h"
31
#include "internal.h"
32
33
397314
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
34
{
35

397314
    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
397314
    av_assert0(!avpkt->data);
42
43

397314
    if (avctx && 2*min_size < size) { // FIXME The factor needs to be finetuned
44
80014
        av_fast_padded_malloc(&avctx->internal->byte_buffer, &avctx->internal->byte_buffer_size, size);
45
80014
        avpkt->data = avctx->internal->byte_buffer;
46
80014
        avpkt->size = size;
47
    }
48
49
397314
    if (!avpkt->data) {
50
317300
        int ret = av_new_packet(avpkt, size);
51
317300
        if (ret < 0)
52
            av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
53
317300
        return ret;
54
    }
55
56
80014
    return 0;
57
}
58
59
/**
60
 * Pad last frame with silence.
61
 */
62
49
static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src)
63
{
64
    int ret;
65
66
49
    frame->format         = src->format;
67
49
    frame->channel_layout = src->channel_layout;
68
49
    frame->channels       = src->channels;
69
49
    frame->nb_samples     = s->frame_size;
70
49
    ret = av_frame_get_buffer(frame, 0);
71
49
    if (ret < 0)
72
        goto fail;
73
74
49
    ret = av_frame_copy_props(frame, src);
75
49
    if (ret < 0)
76
        goto fail;
77
78
49
    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
49
    if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
82
49
                                      frame->nb_samples - src->nb_samples,
83
                                      s->channels, s->sample_fmt)) < 0)
84
        goto fail;
85
86
49
    return 0;
87
88
fail:
89
    av_frame_unref(frame);
90
    return ret;
91
}
92
93
667
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
94
                            const AVSubtitle *sub)
95
{
96
    int ret;
97
667
    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
667
    ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
103
667
    avctx->frame_number++;
104
667
    return ret;
105
}
106
107
819121
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
108
{
109
819121
    AVCodecInternal *avci = avctx->internal;
110
111
819121
    if (avci->draining)
112
        return AVERROR_EOF;
113
114
819121
    if (!avci->buffer_frame->buf[0])
115
415643
        return AVERROR(EAGAIN);
116
117
403478
    av_frame_move_ref(frame, avci->buffer_frame);
118
119
403478
    return 0;
120
}
121
122
825358
static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)
123
{
124
825358
    AVCodecInternal   *avci = avctx->internal;
125
825358
    EncodeSimpleContext *es = &avci->es;
126
825358
    AVFrame          *frame = es->in_frame;
127
    int got_packet;
128
    int ret;
129
130
825358
    if (avci->draining_done)
131
186
        return AVERROR_EOF;
132
133

825172
    if (!frame->buf[0] && !avci->draining) {
134
819121
        av_frame_unref(frame);
135
819121
        ret = ff_encode_get_frame(avctx, frame);
136

819121
        if (ret < 0 && ret != AVERROR_EOF)
137
415643
            return ret;
138
    }
139
140
409529
    if (!frame->buf[0]) {
141
6051
        if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
142

5725
              (avci->frame_thread_encoder && avctx->active_thread_type & FF_THREAD_FRAME)))
143
5610
            return AVERROR_EOF;
144
145
        // Flushing is signaled with a NULL frame
146
441
        frame = NULL;
147
    }
148
149
403919
    got_packet = 0;
150
151
403919
    av_assert0(avctx->codec->encode2);
152
153
403919
    if (CONFIG_FRAME_THREAD_ENCODER &&
154

403919
        avci->frame_thread_encoder && (avctx->active_thread_type & FF_THREAD_FRAME))
155
880
        ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);
156
    else {
157
403039
        ret = avctx->codec->encode2(avctx, avpkt, frame, &got_packet);
158

403039
        if (avctx->codec->type == AVMEDIA_TYPE_VIDEO && !ret && got_packet &&
159
98763
            !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
160
92732
            avpkt->pts = avpkt->dts = frame->pts;
161
    }
162
163
403919
    av_assert0(ret <= 0);
164
165
403919
    emms_c();
166
167

403919
    if (!ret && got_packet) {
168
397364
        if (avpkt->data) {
169
397349
            ret = av_packet_make_refcounted(avpkt);
170
397349
            if (ret < 0)
171
                goto end;
172
        }
173
174

397364
        if (frame && !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
175
365137
            if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
176
271737
                if (avpkt->pts == AV_NOPTS_VALUE)
177
260689
                    avpkt->pts = frame->pts;
178
271737
                if (!avpkt->duration)
179
270682
                    avpkt->duration = ff_samples_to_time_base(avctx,
180
270682
                                                              frame->nb_samples);
181
            }
182
        }
183
397364
        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
297836
            avpkt->flags |= AV_PKT_FLAG_KEY;
188
297836
            avpkt->dts = avpkt->pts;
189
        }
190
    }
191
192

403919
    if (avci->draining && !got_packet)
193
186
        avci->draining_done = 1;
194
195
403733
end:
196

403919
    if (ret < 0 || !got_packet)
197
6555
        av_packet_unref(avpkt);
198
199
403919
    if (frame) {
200
403478
        if (!ret)
201
403478
            avctx->frame_number++;
202
403478
        av_frame_unref(frame);
203
    }
204
205
403919
    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

397364
        av_assert0(!avpkt->data || avpkt->buf);
209
210
403919
    return ret;
211
}
212
213
818803
static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
214
{
215
    int ret;
216
217

1222722
    while (!avpkt->data && !avpkt->side_data) {
218
825358
        ret = encode_simple_internal(avctx, avpkt);
219
825358
        if (ret < 0)
220
421439
            return ret;
221
    }
222
223
397364
    return 0;
224
}
225
226
824481
static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)
227
{
228
824481
    AVCodecInternal *avci = avctx->internal;
229
    int ret;
230
231
824481
    if (avci->draining_done)
232
5678
        return AVERROR_EOF;
233
234

818803
    av_assert0(!avpkt->data && !avpkt->side_data);
235
236
818803
    if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
237

208615
        if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)
238
            avctx->stats_out[0] = '\0';
239
208615
        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
818803
    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
818803
        ret = encode_simple_receive_packet(avctx, avpkt);
253
254
818803
    if (ret == AVERROR_EOF)
255
5796
        avci->draining_done = 1;
256
257
818803
    return ret;
258
}
259
260
403478
static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)
261
{
262
403478
    AVCodecInternal *avci = avctx->internal;
263
403478
    AVFrame *dst = avci->buffer_frame;
264
    int ret;
265
266
403478
    if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
267
        /* extract audio service type metadata */
268
303950
        AVFrameSideData *sd = av_frame_get_side_data(src, AV_FRAME_DATA_AUDIO_SERVICE_TYPE);
269

303950
        if (sd && sd->size >= sizeof(enum AVAudioServiceType))
270
            avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
271
272
        /* check for valid frame size */
273
303950
        if (avctx->codec->capabilities & AV_CODEC_CAP_SMALL_LAST_FRAME) {
274
12483
            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
291467
        } 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
52512
            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
52512
            if (src->nb_samples < avctx->frame_size) {
286
49
                ret = pad_last_frame(avctx, dst, src);
287
49
                if (ret < 0)
288
                    return ret;
289
290
49
                avctx->internal->last_audio_frame = 1;
291
52463
            } 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
403478
    if (!dst->data[0]) {
299
403429
        ret = av_frame_ref(dst, src);
300
403429
        if (ret < 0)
301
             return ret;
302
    }
303
304
403478
    return 0;
305
}
306
307
409274
int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
308
{
309
409274
    AVCodecInternal *avci = avctx->internal;
310
    int ret;
311
312

409274
    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
313
        return AVERROR(EINVAL);
314
315
409274
    if (avci->draining)
316
        return AVERROR_EOF;
317
318
409274
    if (avci->buffer_frame->data[0])
319
        return AVERROR(EAGAIN);
320
321
409274
    if (!frame) {
322
5796
        avci->draining = 1;
323
    } else {
324
403478
        ret = encode_send_frame_internal(avctx, frame);
325
403478
        if (ret < 0)
326
            return ret;
327
    }
328
329

409274
    if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {
330
409274
        ret = encode_receive_packet_internal(avctx, avci->buffer_pkt);
331

409274
        if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
332
            return ret;
333
    }
334
335
409274
    return 0;
336
}
337
338
812434
int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
339
{
340
812434
    AVCodecInternal *avci = avctx->internal;
341
    int ret;
342
343
812434
    av_packet_unref(avpkt);
344
345

812434
    if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
346
        return AVERROR(EINVAL);
347
348

812434
    if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {
349
397227
        av_packet_move_ref(avpkt, avci->buffer_pkt);
350
    } else {
351
415207
        ret = encode_receive_packet_internal(avctx, avpkt);
352
415207
        if (ret < 0)
353
415070
            return ret;
354
    }
355
356
397364
    return 0;
357
}
358
359
3260
static int compat_encode(AVCodecContext *avctx, AVPacket *avpkt,
360
                         int *got_packet, const AVFrame *frame)
361
{
362
3260
    AVCodecInternal *avci = avctx->internal;
363
    AVPacket user_pkt;
364
    int ret;
365
366
3260
    *got_packet = 0;
367
368

3260
    if (frame && avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
369
60
        if (frame->format == AV_PIX_FMT_NONE)
370
            av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
371

60
        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
3260
    ret = avcodec_send_frame(avctx, frame);
376
3260
    if (ret == AVERROR_EOF)
377
        ret = 0;
378
3260
    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
3260
    } else if (ret < 0)
383
        return ret;
384
385
3260
    av_packet_move_ref(&user_pkt, avpkt);
386
6520
    while (ret >= 0) {
387
6520
        ret = avcodec_receive_packet(avctx, avpkt);
388
6520
        if (ret < 0) {
389

3260
            if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
390
3260
                ret = 0;
391
3260
            goto finish;
392
        }
393
394
3260
        if (avpkt != avci->compat_encode_packet) {
395

3260
            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
3260
            *got_packet = 1;
411
3260
            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
3260
        if (avci->draining)
424
            break;
425
    }
426
427
finish:
428
3260
    if (ret < 0)
429
        av_packet_unref(&user_pkt);
430
431
3260
    return ret;
432
}
433
434
3200
int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
435
                                              AVPacket *avpkt,
436
                                              const AVFrame *frame,
437
                                              int *got_packet_ptr)
438
{
439
3200
    int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
440
441
3200
    if (ret < 0)
442
        av_packet_unref(avpkt);
443
444
3200
    return ret;
445
}
446
447
60
int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx,
448
                                              AVPacket *avpkt,
449
                                              const AVFrame *frame,
450
                                              int *got_packet_ptr)
451
{
452
60
    int ret = compat_encode(avctx, avpkt, got_packet_ptr, frame);
453
454
60
    if (ret < 0)
455
        av_packet_unref(avpkt);
456
457
60
    return ret;
458
}