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
ff_alloc_packet2(AVCodecContext * avctx,AVPacket * avpkt,int64_t size,int64_t min_size)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 */
pad_last_frame(AVCodecContext * s,AVFrame * frame,const AVFrame * src)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
avcodec_encode_subtitle(AVCodecContext * avctx,uint8_t * buf,int buf_size,const AVSubtitle * sub)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
ff_encode_get_frame(AVCodecContext * avctx,AVFrame * frame)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
encode_simple_internal(AVCodecContext * avctx,AVPacket * avpkt)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
encode_simple_receive_packet(AVCodecContext * avctx,AVPacket * avpkt)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
encode_receive_packet_internal(AVCodecContext * avctx,AVPacket * avpkt)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
encode_send_frame_internal(AVCodecContext * avctx,const AVFrame * src)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
avcodec_send_frame(AVCodecContext * avctx,const AVFrame * frame)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
avcodec_receive_packet(AVCodecContext * avctx,AVPacket * avpkt)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
compat_encode(AVCodecContext * avctx,AVPacket * avpkt,int * got_packet,const AVFrame * frame)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
avcodec_encode_audio2(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)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
avcodec_encode_video2(AVCodecContext * avctx,AVPacket * avpkt,const AVFrame * frame,int * got_packet_ptr)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 }
459