FFmpeg
encode.c
Go to the documentation of this file.
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 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  }
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) {
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 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 static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
82 {
83  AVFrame *frame = NULL;
84  int ret;
85 
86  if (!(frame = av_frame_alloc()))
87  return AVERROR(ENOMEM);
88 
89  frame->format = src->format;
90  frame->channel_layout = src->channel_layout;
91  frame->channels = src->channels;
92  frame->nb_samples = s->frame_size;
93  ret = av_frame_get_buffer(frame, 32);
94  if (ret < 0)
95  goto fail;
96 
97  ret = av_frame_copy_props(frame, src);
98  if (ret < 0)
99  goto fail;
100 
101  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  if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
105  frame->nb_samples - src->nb_samples,
106  s->channels, s->sample_fmt)) < 0)
107  goto fail;
108 
109  *dst = frame;
110 
111  return 0;
112 
113 fail:
114  av_frame_free(&frame);
115  return ret;
116 }
117 
118 int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx,
119  AVPacket *avpkt,
120  const AVFrame *frame,
121  int *got_packet_ptr)
122 {
123  AVFrame *extended_frame = NULL;
124  AVFrame *padded_frame = NULL;
125  int ret;
126  AVPacket user_pkt = *avpkt;
127  int needs_realloc = !user_pkt.data;
128 
129  *got_packet_ptr = 0;
130 
131  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  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
137  av_packet_unref(avpkt);
138  return 0;
139  }
140 
141  /* ensure that extended_data is properly set */
142  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",
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  if (frame) {
164  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  if (frame) {
171  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  } 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  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  if (frame->nb_samples < avctx->frame_size) {
185  ret = pad_last_frame(avctx, &padded_frame, frame);
186  if (ret < 0)
187  goto end;
188 
189  frame = padded_frame;
190  avctx->internal->last_audio_frame = 1;
191  }
192 
193  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  av_assert0(avctx->codec->encode2);
202 
203  ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
204  if (!ret) {
205  if (*got_packet_ptr) {
206  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY)) {
207  if (avpkt->pts == AV_NOPTS_VALUE)
208  avpkt->pts = frame->pts;
209  if (!avpkt->duration)
210  avpkt->duration = ff_samples_to_time_base(avctx,
211  frame->nb_samples);
212  }
213  avpkt->dts = avpkt->pts;
214  } else {
215  avpkt->size = 0;
216  }
217  }
218  if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
219  needs_realloc = 0;
220  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  } else if (!avpkt->buf) {
231  ret = av_packet_make_refcounted(avpkt);
232  if (ret < 0)
233  goto end;
234  }
235  }
236 
237  if (!ret) {
238  if (needs_realloc && avpkt->data) {
239  ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
240  if (ret >= 0)
241  avpkt->data = avpkt->buf->data;
242  }
243  if (frame)
244  avctx->frame_number++;
245  }
246 
247  if (ret < 0 || !*got_packet_ptr) {
248  av_packet_unref(avpkt);
249  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  avpkt->flags |= AV_PKT_FLAG_KEY;
256 
257 end:
258  av_frame_free(&padded_frame);
259  av_free(extended_frame);
260 
261  return ret;
262 }
263 
264 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  AVPacket user_pkt = *avpkt;
271  int needs_realloc = !user_pkt.data;
272 
273  *got_packet_ptr = 0;
274 
275  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  if(CONFIG_FRAME_THREAD_ENCODER &&
282  return ff_thread_video_encode_frame(avctx, avpkt, frame, got_packet_ptr);
283 
284  if ((avctx->flags&AV_CODEC_FLAG_PASS1) && avctx->stats_out)
285  avctx->stats_out[0] = '\0';
286 
287  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) && !frame) {
288  av_packet_unref(avpkt);
289  return 0;
290  }
291 
292  if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
293  return AVERROR(EINVAL);
294 
295  if (frame && frame->format == AV_PIX_FMT_NONE)
296  av_log(avctx, AV_LOG_WARNING, "AVFrame.format is not set\n");
297  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  av_assert0(avctx->codec->encode2);
301 
302  ret = avctx->codec->encode2(avctx, avpkt, frame, got_packet_ptr);
303  av_assert0(ret <= 0);
304 
305  emms_c();
306 
307  if (avpkt->data && avpkt->data == avctx->internal->byte_buffer) {
308  needs_realloc = 0;
309  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  } else if (!avpkt->buf) {
320  ret = av_packet_make_refcounted(avpkt);
321  if (ret < 0)
322  return ret;
323  }
324  }
325 
326  if (!ret) {
327  if (!*got_packet_ptr)
328  avpkt->size = 0;
329  else if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
330  avpkt->pts = avpkt->dts = frame->pts;
331 
332  if (needs_realloc && avpkt->data) {
333  ret = av_buffer_realloc(&avpkt->buf, avpkt->size + AV_INPUT_BUFFER_PADDING_SIZE);
334  if (ret >= 0)
335  avpkt->data = avpkt->buf->data;
336  }
337 
338  if (frame)
339  avctx->frame_number++;
340  }
341 
342  if (ret < 0 || !*got_packet_ptr)
343  av_packet_unref(avpkt);
344 
345  return ret;
346 }
347 
349  const AVSubtitle *sub)
350 {
351  int ret;
352  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  ret = avctx->codec->encode_sub(avctx, buf, buf_size, sub);
358  avctx->frame_number++;
359  return ret;
360 }
361 
362 static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
363 {
364  int ret;
365  *got_packet = 0;
366 
368  avctx->internal->buffer_pkt_valid = 0;
369 
370  if (avctx->codec_type == AVMEDIA_TYPE_VIDEO) {
371  ret = avcodec_encode_video2(avctx, avctx->internal->buffer_pkt,
372  frame, got_packet);
373  } else if (avctx->codec_type == AVMEDIA_TYPE_AUDIO) {
374  ret = avcodec_encode_audio2(avctx, avctx->internal->buffer_pkt,
375  frame, got_packet);
376  } else {
377  ret = AVERROR(EINVAL);
378  }
379 
380  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  av_assert0(!avctx->internal->buffer_pkt->data || avctx->internal->buffer_pkt->buf);
384  avctx->internal->buffer_pkt_valid = 1;
385  ret = 0;
386  } else {
388  }
389 
390  return ret;
391 }
392 
393 int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
394 {
395  if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
396  return AVERROR(EINVAL);
397 
398  if (avctx->internal->draining)
399  return AVERROR_EOF;
400 
401  if (!frame) {
402  avctx->internal->draining = 1;
403 
404  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY))
405  return 0;
406  }
407 
408  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  if (avctx->internal->buffer_pkt_valid)
418  return AVERROR(EAGAIN);
419 
420  return do_encode(avctx, frame, &(int){0});
421 }
422 
423 int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
424 {
425  av_packet_unref(avpkt);
426 
427  if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
428  return AVERROR(EINVAL);
429 
430  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  if (!avctx->internal->buffer_pkt_valid) {
445  int got_packet;
446  int ret;
447  if (!avctx->internal->draining)
448  return AVERROR(EAGAIN);
449  ret = do_encode(avctx, NULL, &got_packet);
450  if (ret < 0)
451  return ret;
452  if (ret >= 0 && !got_packet)
453  return AVERROR_EOF;
454  }
455 
456  av_packet_move_ref(avpkt, avctx->internal->buffer_pkt);
457  avctx->internal->buffer_pkt_valid = 0;
458  return 0;
459 }
#define NULL
Definition: coverity.c:32
const struct AVCodec * codec
Definition: avcodec.h:1577
#define AV_NUM_DATA_POINTERS
Definition: frame.h:296
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame, int *got_packet_ptr)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:295
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:113
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:423
int size
Definition: avcodec.h:1481
int attribute_align_arg avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
Definition: encode.c:118
void av_fast_padded_malloc(void *ptr, unsigned int *size, size_t min_size)
Same behaviour av_fast_malloc but the buffer has additional AV_INPUT_BUFFER_PADDING_SIZE at the end w...
Definition: utils.c:70
#define src
Definition: vp8dsp.c:254
static int pad_last_frame(AVCodecContext *s, AVFrame **dst, const AVFrame *src)
Pad last frame with silence.
Definition: encode.c:81
Macro definitions for various function/variable attributes.
int(* receive_packet)(AVCodecContext *avctx, AVPacket *avpkt)
Definition: avcodec.h:3601
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:734
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:2293
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:94
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:1009
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
int ff_alloc_packet2(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int64_t min_size)
Check AVPacket size and/or allocate data.
Definition: encode.c:32
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2236
uint8_t
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1498
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:388
void * frame_thread_encoder
Definition: internal.h:180
Structure to hold side data for an AVFrame.
Definition: frame.h:201
uint8_t * data
Definition: avcodec.h:1480
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:655
#define AVERROR_EOF
End of file.
Definition: error.h:55
ptrdiff_t size
Definition: opengl_enc.c:100
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2587
#define av_log(a,...)
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:112
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1512
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: avpacket.c:86
int width
Definition: frame.h:353
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
int av_samples_set_silence(uint8_t **audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition: samplefmt.c:237
AVAudioServiceType
Definition: avcodec.h:817
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
int(* send_frame)(AVCodecContext *avctx, const AVFrame *frame)
Encode API with decoupled packet/frame dataflow.
Definition: avcodec.h:3600
int active_thread_type
Which multithreading methods are in use by the codec.
Definition: avcodec.h:2846
int avcodec_is_open(AVCodecContext *s)
Definition: utils.c:1898
int capabilities
Codec capabilities.
Definition: avcodec.h:3511
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1463
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1648
simple assert() macros that are a bit more flexible than ISO C assert().
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:3295
int av_buffer_realloc(AVBufferRef **pbuf, int size)
Reallocate a given buffer.
Definition: buffer.c:169
#define fail()
Definition: checkasm.h:122
int ff_alloc_packet(AVPacket *avpkt, int size)
Definition: encode.c:73
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: avcodec.h:1056
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1486
reference-counted frame API
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:472
common internal API header
int channels
number of audio channels, only used for audio.
Definition: frame.h:601
#define FF_THREAD_FRAME
Decode more than one frame at once.
Definition: avcodec.h:2838
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: avcodec.h:1014
int width
picture width / height.
Definition: avcodec.h:1741
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:663
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:874
these buffered frames must be flushed immediately if a new input produces new the filter must not call request_frame to get more It must just process the frame or queue it The task of requesting more frames is left to the filter s request_frame method or the application If a filter has several the filter must be ready for frames arriving randomly on any input any filter with several inputs will most likely require some kind of queuing mechanism It is perfectly acceptable to have a limited queue and to drop frames when the inputs are too unbalanced request_frame For filters that do not use the this method is called when a frame is wanted on an output For a it should directly call filter_frame on the corresponding output For a if there are queued frames already one of these frames should be pushed If the filter should request a frame on one of its repeatedly until at least one frame has been pushed Return or at least make progress towards producing a frame
#define s(width, name)
Definition: cbs_vp9.c:257
int draining
checks API usage: after codec draining, flush is required to resume operation
Definition: internal.h:195
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:368
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2248
Libavcodec external API header.
enum AVMediaType codec_type
Definition: avcodec.h:1576
main external API structure.
Definition: avcodec.h:1568
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:599
uint8_t * data
The data buffer.
Definition: buffer.h:89
uint8_t * data
Definition: frame.h:203
int attribute_align_arg avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
Definition: encode.c:393
int av_samples_copy(uint8_t **dst, uint8_t *const *src, int dst_offset, int src_offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Copy samples from src to dst.
Definition: samplefmt.c:213
void * buf
Definition: avisynth_c.h:766
int attribute_align_arg avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: encode.c:264
int buffer_pkt_valid
Definition: internal.h:201
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:324
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:309
AVPacket * buffer_pkt
buffers for using new encode/decode API through legacy API
Definition: internal.h:200
A reference to a data buffer.
Definition: buffer.h:81
common internal api header.
uint32_t start_display_time
Definition: avcodec.h:3946
int(* encode_sub)(AVCodecContext *, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Definition: avcodec.h:3576
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int av_image_check_size2(unsigned int w, unsigned int h, int64_t max_pixels, enum AVPixelFormat pix_fmt, int log_offset, void *log_ctx)
Check if the given dimension of an image is valid, meaning that all bytes of a plane of an image with...
Definition: imgutils.c:253
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:793
#define av_free(p)
int(* encode2)(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: avcodec.h:3588
int channels
number of audio channels
Definition: avcodec.h:2229
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:1603
unsigned int byte_buffer_size
Definition: internal.h:178
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1479
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:2259
int height
Definition: frame.h:353
static av_always_inline int64_t ff_samples_to_time_base(AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: internal.h:288
static int do_encode(AVCodecContext *avctx, const AVFrame *frame, int *got_packet)
Definition: encode.c:362
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later.That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another.Frame references ownership and permissions
uint8_t ** extended_data
pointers to the data planes/channels.
Definition: frame.h:342
This structure stores compressed data.
Definition: avcodec.h:1457
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:177
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: encode.c:348
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:361
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1473
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:654
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
int last_audio_frame
An audio frame with less than required samples has been submitted and padded with silence...
Definition: internal.h:157