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