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"
24 #include "libavutil/emms.h"
25 #include "libavutil/frame.h"
26 #include "libavutil/imgutils.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/mem.h"
29 #include "libavutil/pixdesc.h"
30 #include "libavutil/samplefmt.h"
31 
32 #include "avcodec.h"
33 #include "avcodec_internal.h"
34 #include "codec_desc.h"
35 #include "codec_internal.h"
36 #include "encode.h"
37 #include "frame_thread_encoder.h"
38 #include "internal.h"
39 
40 typedef struct EncodeContext {
42 
43  /**
44  * This is set to AV_PKT_FLAG_KEY for encoders that encode intra-only
45  * formats (i.e. whose codec descriptor has AV_CODEC_PROP_INTRA_ONLY set).
46  * This is used to set said flag generically for said encoders.
47  */
49 
50  /**
51  * An audio frame with less than required samples has been submitted (and
52  * potentially padded with silence). Reject all subsequent frames.
53  */
56 
58 {
59  return (EncodeContext*)avci;
60 }
61 
63 {
64  if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE) {
65  av_log(avctx, AV_LOG_ERROR, "Invalid minimum required packet size %"PRId64" (max allowed is %d)\n",
67  return AVERROR(EINVAL);
68  }
69 
70  av_assert0(!avpkt->data);
71 
73  &avctx->internal->byte_buffer_size, size);
74  avpkt->data = avctx->internal->byte_buffer;
75  if (!avpkt->data) {
76  av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %"PRId64"\n", size);
77  return AVERROR(ENOMEM);
78  }
79  avpkt->size = size;
80 
81  return 0;
82 }
83 
85 {
86  int ret;
87 
88  if (avpkt->size < 0 || avpkt->size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
89  return AVERROR(EINVAL);
90 
91  if (avpkt->data || avpkt->buf) {
92  av_log(avctx, AV_LOG_ERROR, "avpkt->{data,buf} != NULL in avcodec_default_get_encode_buffer()\n");
93  return AVERROR(EINVAL);
94  }
95 
97  if (ret < 0) {
98  av_log(avctx, AV_LOG_ERROR, "Failed to allocate packet of size %d\n", avpkt->size);
99  return ret;
100  }
101  avpkt->data = avpkt->buf->data;
102 
103  return 0;
104 }
105 
107 {
108  int ret;
109 
110  if (size < 0 || size > INT_MAX - AV_INPUT_BUFFER_PADDING_SIZE)
111  return AVERROR(EINVAL);
112 
113  av_assert0(!avpkt->data && !avpkt->buf);
114 
115  avpkt->size = size;
116  ret = avctx->get_encode_buffer(avctx, avpkt, flags);
117  if (ret < 0)
118  goto fail;
119 
120  if (!avpkt->data || !avpkt->buf) {
121  av_log(avctx, AV_LOG_ERROR, "No buffer returned by get_encode_buffer()\n");
122  ret = AVERROR(EINVAL);
123  goto fail;
124  }
125  memset(avpkt->data + avpkt->size, 0, AV_INPUT_BUFFER_PADDING_SIZE);
126 
127  ret = 0;
128 fail:
129  if (ret < 0) {
130  av_log(avctx, AV_LOG_ERROR, "get_encode_buffer() failed\n");
131  av_packet_unref(avpkt);
132  }
133 
134  return ret;
135 }
136 
138 {
139  uint8_t *data = avpkt->data;
140  int ret;
141 
142  if (avpkt->buf)
143  return 0;
144 
145  avpkt->data = NULL;
146  ret = ff_get_encode_buffer(avctx, avpkt, avpkt->size, 0);
147  if (ret < 0)
148  return ret;
149  memcpy(avpkt->data, data, avpkt->size);
150 
151  return 0;
152 }
153 
154 /**
155  * Pad last frame with silence.
156  */
157 static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src, int out_samples)
158 {
159  int ret;
160 
161  frame->format = src->format;
162  frame->nb_samples = out_samples;
163  ret = av_channel_layout_copy(&frame->ch_layout, &s->ch_layout);
164  if (ret < 0)
165  goto fail;
167  if (ret < 0)
168  goto fail;
169 
171  if (ret < 0)
172  goto fail;
173 
174  if ((ret = av_samples_copy(frame->extended_data, src->extended_data, 0, 0,
175  src->nb_samples, s->ch_layout.nb_channels,
176  s->sample_fmt)) < 0)
177  goto fail;
178  if ((ret = av_samples_set_silence(frame->extended_data, src->nb_samples,
179  frame->nb_samples - src->nb_samples,
180  s->ch_layout.nb_channels, s->sample_fmt)) < 0)
181  goto fail;
182 
183  return 0;
184 
185 fail:
187  encode_ctx(s->internal)->last_audio_frame = 0;
188  return ret;
189 }
190 
191 int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size,
192  const AVSubtitle *sub)
193 {
194  int ret;
195  if (sub->start_display_time) {
196  av_log(avctx, AV_LOG_ERROR, "start_display_time must be 0.\n");
197  return -1;
198  }
199 
200  ret = ffcodec(avctx->codec)->cb.encode_sub(avctx, buf, buf_size, sub);
201  avctx->frame_num++;
202  return ret;
203 }
204 
206 {
207  AVCodecInternal *avci = avctx->internal;
208 
209  if (avci->draining)
210  return AVERROR_EOF;
211 
212  if (!avci->buffer_frame->buf[0])
213  return AVERROR(EAGAIN);
214 
216 
217 #if FF_API_FRAME_KEY
219  if (frame->key_frame)
220  frame->flags |= AV_FRAME_FLAG_KEY;
222 #endif
223 #if FF_API_INTERLACED_FRAME
225  if (frame->interlaced_frame)
227  if (frame->top_field_first)
230 #endif
231 
232  return 0;
233 }
234 
236  AVPacket *pkt, const AVFrame *frame)
237 {
238  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE) {
239  int ret = av_buffer_replace(&pkt->opaque_ref, frame->opaque_ref);
240  if (ret < 0)
241  return ret;
242  pkt->opaque = frame->opaque;
243  }
244 
245  return 0;
246 }
247 
249  AVFrame *frame, int *got_packet)
250 {
251  const FFCodec *const codec = ffcodec(avctx->codec);
252  int ret;
253 
254  ret = codec->cb.encode(avctx, avpkt, frame, got_packet);
255  emms_c();
256  av_assert0(ret <= 0);
257 
258  if (!ret && *got_packet) {
259  if (avpkt->data) {
260  ret = encode_make_refcounted(avctx, avpkt);
261  if (ret < 0)
262  goto unref;
263  // Date returned by encoders must always be ref-counted
264  av_assert0(avpkt->buf);
265  }
266 
267  // set the timestamps for the simple no-delay case
268  // encoders with delay have to set the timestamps themselves
269  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) ||
270  (frame && (codec->caps_internal & FF_CODEC_CAP_EOF_FLUSH))) {
271  if (avpkt->pts == AV_NOPTS_VALUE)
272  avpkt->pts = frame->pts;
273 
274  if (!avpkt->duration) {
275  if (frame->duration)
276  avpkt->duration = frame->duration;
277  else if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
278  avpkt->duration = ff_samples_to_time_base(avctx,
279  frame->nb_samples);
280  }
281  }
282 
283  ret = ff_encode_reordered_opaque(avctx, avpkt, frame);
284  if (ret < 0)
285  goto unref;
286  }
287 
288  // dts equals pts unless there is reordering
289  // there can be no reordering if there is no encoder delay
290  if (!(avctx->codec_descriptor->props & AV_CODEC_PROP_REORDER) ||
291  !(avctx->codec->capabilities & AV_CODEC_CAP_DELAY) ||
293  avpkt->dts = avpkt->pts;
294  } else {
295 unref:
296  av_packet_unref(avpkt);
297  }
298 
299  if (frame)
301 
302  return ret;
303 }
304 
306 {
307  AVCodecInternal *avci = avctx->internal;
308  AVFrame *frame = avci->in_frame;
309  const FFCodec *const codec = ffcodec(avctx->codec);
310  int got_packet;
311  int ret;
312 
313  if (avci->draining_done)
314  return AVERROR_EOF;
315 
316  if (!frame->buf[0] && !avci->draining) {
318  ret = ff_encode_get_frame(avctx, frame);
319  if (ret < 0 && ret != AVERROR_EOF)
320  return ret;
321  }
322 
323  if (!frame->buf[0]) {
324  if (!(avctx->codec->capabilities & AV_CODEC_CAP_DELAY ||
325  avci->frame_thread_encoder))
326  return AVERROR_EOF;
327 
328  // Flushing is signaled with a NULL frame
329  frame = NULL;
330  }
331 
332  got_packet = 0;
333 
335 
336  if (CONFIG_FRAME_THREAD_ENCODER && avci->frame_thread_encoder)
337  /* This will unref frame. */
338  ret = ff_thread_video_encode_frame(avctx, avpkt, frame, &got_packet);
339  else {
340  ret = ff_encode_encode_cb(avctx, avpkt, frame, &got_packet);
341  }
342 
343  if (avci->draining && !got_packet)
344  avci->draining_done = 1;
345 
346  return ret;
347 }
348 
350 {
351  int ret;
352 
353  while (!avpkt->data && !avpkt->side_data) {
354  ret = encode_simple_internal(avctx, avpkt);
355  if (ret < 0)
356  return ret;
357  }
358 
359  return 0;
360 }
361 
363 {
364  AVCodecInternal *avci = avctx->internal;
365  int ret;
366 
367  if (avci->draining_done)
368  return AVERROR_EOF;
369 
370  av_assert0(!avpkt->data && !avpkt->side_data);
371 
372  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
373  if ((avctx->flags & AV_CODEC_FLAG_PASS1) && avctx->stats_out)
374  avctx->stats_out[0] = '\0';
375  if (av_image_check_size2(avctx->width, avctx->height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx))
376  return AVERROR(EINVAL);
377  }
378 
380  ret = ffcodec(avctx->codec)->cb.receive_packet(avctx, avpkt);
381  if (ret < 0)
382  av_packet_unref(avpkt);
383  else
384  // Encoders must always return ref-counted buffers.
385  // Side-data only packets have no data and can be not ref-counted.
386  av_assert0(!avpkt->data || avpkt->buf);
387  } else
388  ret = encode_simple_receive_packet(avctx, avpkt);
389  if (ret >= 0)
390  avpkt->flags |= encode_ctx(avci)->intra_only_flag;
391 
392  if (ret == AVERROR_EOF)
393  avci->draining_done = 1;
394 
395  return ret;
396 }
397 
398 #if CONFIG_LCMS2
400 {
401  enum AVColorTransferCharacteristic trc = frame->color_trc;
402  enum AVColorPrimaries prim = frame->color_primaries;
403  const FFCodec *const codec = ffcodec(avctx->codec);
404  AVCodecInternal *avci = avctx->internal;
405  cmsHPROFILE profile;
406  int ret;
407 
408  /* don't generate ICC profiles if disabled or unsupported */
409  if (!(avctx->flags2 & AV_CODEC_FLAG2_ICC_PROFILES))
410  return 0;
412  return 0;
413 
414  if (trc == AVCOL_TRC_UNSPECIFIED)
415  trc = avctx->color_trc;
416  if (prim == AVCOL_PRI_UNSPECIFIED)
417  prim = avctx->color_primaries;
418  if (trc == AVCOL_TRC_UNSPECIFIED || prim == AVCOL_PRI_UNSPECIFIED)
419  return 0; /* can't generate ICC profile with missing csp tags */
420 
422  return 0; /* don't overwrite existing ICC profile */
423 
424  if (!avci->icc.avctx) {
425  ret = ff_icc_context_init(&avci->icc, avctx);
426  if (ret < 0)
427  return ret;
428  }
429 
430  ret = ff_icc_profile_generate(&avci->icc, prim, trc, &profile);
431  if (ret < 0)
432  return ret;
433 
434  ret = ff_icc_profile_attach(&avci->icc, profile, frame);
435  cmsCloseProfile(profile);
436  return ret;
437 }
438 #else /* !CONFIG_LCMS2 */
440 {
441  return 0;
442 }
443 #endif
444 
446 {
447  AVCodecInternal *avci = avctx->internal;
448  EncodeContext *ec = encode_ctx(avci);
449  AVFrame *dst = avci->buffer_frame;
450  int ret;
451 
452  if (avctx->codec->type == AVMEDIA_TYPE_AUDIO) {
453  /* extract audio service type metadata */
455  if (sd && sd->size >= sizeof(enum AVAudioServiceType))
456  avctx->audio_service_type = *(enum AVAudioServiceType*)sd->data;
457 
458  /* check for valid frame size */
460  /* if we already got an undersized frame, that must have been the last */
461  if (ec->last_audio_frame) {
462  av_log(avctx, AV_LOG_ERROR, "frame_size (%d) was not respected for a non-last frame\n", avctx->frame_size);
463  return AVERROR(EINVAL);
464  }
465  if (src->nb_samples > avctx->frame_size) {
466  av_log(avctx, AV_LOG_ERROR, "nb_samples (%d) > frame_size (%d)\n", src->nb_samples, avctx->frame_size);
467  return AVERROR(EINVAL);
468  }
469  if (src->nb_samples < avctx->frame_size) {
470  ec->last_audio_frame = 1;
472  int pad_samples = avci->pad_samples ? avci->pad_samples : avctx->frame_size;
473  int out_samples = (src->nb_samples + pad_samples - 1) / pad_samples * pad_samples;
474 
475  if (out_samples != src->nb_samples) {
476  ret = pad_last_frame(avctx, dst, src, out_samples);
477  if (ret < 0)
478  return ret;
479  goto finish;
480  }
481  }
482  }
483  }
484  }
485 
486  ret = av_frame_ref(dst, src);
487  if (ret < 0)
488  return ret;
489 
490 finish:
491 
492  if (avctx->codec->type == AVMEDIA_TYPE_VIDEO) {
494  if (ret < 0)
495  return ret;
496  }
497 
498  // unset frame duration unless AV_CODEC_FLAG_FRAME_DURATION is set,
499  // since otherwise we cannot be sure that whatever value it has is in the
500  // right timebase, so we would produce an incorrect value, which is worse
501  // than none at all
502  if (!(avctx->flags & AV_CODEC_FLAG_FRAME_DURATION))
503  dst->duration = 0;
504 
505  return 0;
506 }
507 
509 {
510  AVCodecInternal *avci = avctx->internal;
511  int ret;
512 
513  if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
514  return AVERROR(EINVAL);
515 
516  if (avci->draining)
517  return AVERROR_EOF;
518 
519  if (avci->buffer_frame->buf[0])
520  return AVERROR(EAGAIN);
521 
522  if (!frame) {
523  avci->draining = 1;
524  } else {
526  if (ret < 0)
527  return ret;
528  }
529 
530  if (!avci->buffer_pkt->data && !avci->buffer_pkt->side_data) {
532  if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)
533  return ret;
534  }
535 
536  avctx->frame_num++;
537 
538  return 0;
539 }
540 
542 {
543  AVCodecInternal *avci = avctx->internal;
544  int ret;
545 
546  av_packet_unref(avpkt);
547 
548  if (!avcodec_is_open(avctx) || !av_codec_is_encoder(avctx->codec))
549  return AVERROR(EINVAL);
550 
551  if (avci->buffer_pkt->data || avci->buffer_pkt->side_data) {
552  av_packet_move_ref(avpkt, avci->buffer_pkt);
553  } else {
554  ret = encode_receive_packet_internal(avctx, avpkt);
555  if (ret < 0)
556  return ret;
557  }
558 
559  return 0;
560 }
561 
563 {
564  const AVCodec *c = avctx->codec;
565  const AVPixFmtDescriptor *pixdesc = av_pix_fmt_desc_get(avctx->pix_fmt);
566  const enum AVPixelFormat *pix_fmts;
567  int ret, i, num_pix_fmts;
568 
569  if (!av_get_pix_fmt_name(avctx->pix_fmt)) {
570  av_log(avctx, AV_LOG_ERROR, "Invalid video pixel format: %d\n",
571  avctx->pix_fmt);
572  return AVERROR(EINVAL);
573  }
574 
576  0, (const void **) &pix_fmts, &num_pix_fmts);
577  if (ret < 0)
578  return ret;
579 
580  if (pix_fmts) {
581  for (i = 0; i < num_pix_fmts; i++)
582  if (avctx->pix_fmt == pix_fmts[i])
583  break;
584  if (i == num_pix_fmts) {
585  av_log(avctx, AV_LOG_ERROR,
586  "Specified pixel format %s is not supported by the %s encoder.\n",
587  av_get_pix_fmt_name(avctx->pix_fmt), c->name);
588 
589  av_log(avctx, AV_LOG_ERROR, "Supported pixel formats:\n");
590  for (int p = 0; pix_fmts[p] != AV_PIX_FMT_NONE; p++) {
591  av_log(avctx, AV_LOG_ERROR, " %s\n",
593  }
594 
595  return AVERROR(EINVAL);
596  }
597  if (pix_fmts[i] == AV_PIX_FMT_YUVJ420P ||
602  avctx->color_range = AVCOL_RANGE_JPEG;
603  }
604 
605  if ( avctx->bits_per_raw_sample < 0
606  || (avctx->bits_per_raw_sample > 8 && pixdesc->comp[0].depth <= 8)) {
607  av_log(avctx, AV_LOG_WARNING, "Specified bit depth %d not possible with the specified pixel formats depth %d\n",
608  avctx->bits_per_raw_sample, pixdesc->comp[0].depth);
609  avctx->bits_per_raw_sample = pixdesc->comp[0].depth;
610  }
611  if (avctx->width <= 0 || avctx->height <= 0) {
612  av_log(avctx, AV_LOG_ERROR, "dimensions not set\n");
613  return AVERROR(EINVAL);
614  }
615 
616 #if FF_API_TICKS_PER_FRAME
618  if (avctx->ticks_per_frame && avctx->time_base.num &&
619  avctx->ticks_per_frame > INT_MAX / avctx->time_base.num) {
620  av_log(avctx, AV_LOG_ERROR,
621  "ticks_per_frame %d too large for the timebase %d/%d.",
622  avctx->ticks_per_frame,
623  avctx->time_base.num,
624  avctx->time_base.den);
625  return AVERROR(EINVAL);
626  }
628 #endif
629 
630  if (avctx->hw_frames_ctx) {
631  AVHWFramesContext *frames_ctx = (AVHWFramesContext*)avctx->hw_frames_ctx->data;
632  if (frames_ctx->format != avctx->pix_fmt) {
633  av_log(avctx, AV_LOG_ERROR,
634  "Mismatching AVCodecContext.pix_fmt and AVHWFramesContext.format\n");
635  return AVERROR(EINVAL);
636  }
637  if (avctx->sw_pix_fmt != AV_PIX_FMT_NONE &&
638  avctx->sw_pix_fmt != frames_ctx->sw_format) {
639  av_log(avctx, AV_LOG_ERROR,
640  "Mismatching AVCodecContext.sw_pix_fmt (%s) "
641  "and AVHWFramesContext.sw_format (%s)\n",
643  av_get_pix_fmt_name(frames_ctx->sw_format));
644  return AVERROR(EINVAL);
645  }
646  avctx->sw_pix_fmt = frames_ctx->sw_format;
647  }
648 
649  return 0;
650 }
651 
653 {
654  const AVCodec *c = avctx->codec;
655  const enum AVSampleFormat *sample_fmts;
656  const int *supported_samplerates;
658  int ret, i, num_sample_fmts, num_samplerates, num_ch_layouts;
659 
660  if (!av_get_sample_fmt_name(avctx->sample_fmt)) {
661  av_log(avctx, AV_LOG_ERROR, "Invalid audio sample format: %d\n",
662  avctx->sample_fmt);
663  return AVERROR(EINVAL);
664  }
665  if (avctx->sample_rate <= 0) {
666  av_log(avctx, AV_LOG_ERROR, "Invalid audio sample rate: %d\n",
667  avctx->sample_rate);
668  return AVERROR(EINVAL);
669  }
670 
672  0, (const void **) &sample_fmts,
673  &num_sample_fmts);
674  if (ret < 0)
675  return ret;
676  if (sample_fmts) {
677  for (i = 0; i < num_sample_fmts; i++) {
678  if (avctx->sample_fmt == sample_fmts[i])
679  break;
680  if (avctx->ch_layout.nb_channels == 1 &&
683  avctx->sample_fmt = sample_fmts[i];
684  break;
685  }
686  }
687  if (i == num_sample_fmts) {
688  av_log(avctx, AV_LOG_ERROR,
689  "Specified sample format %s is not supported by the %s encoder\n",
690  av_get_sample_fmt_name(avctx->sample_fmt), c->name);
691 
692  av_log(avctx, AV_LOG_ERROR, "Supported sample formats:\n");
693  for (int p = 0; sample_fmts[p] != AV_SAMPLE_FMT_NONE; p++) {
694  av_log(avctx, AV_LOG_ERROR, " %s\n",
696  }
697 
698  return AVERROR(EINVAL);
699  }
700  }
701 
703  0, (const void **) &supported_samplerates,
704  &num_samplerates);
705  if (ret < 0)
706  return ret;
707  if (supported_samplerates) {
708  for (i = 0; i < num_samplerates; i++)
709  if (avctx->sample_rate == supported_samplerates[i])
710  break;
711  if (i == num_samplerates) {
712  av_log(avctx, AV_LOG_ERROR,
713  "Specified sample rate %d is not supported by the %s encoder\n",
714  avctx->sample_rate, c->name);
715 
716  av_log(avctx, AV_LOG_ERROR, "Supported sample rates:\n");
717  for (int p = 0; supported_samplerates[p]; p++)
718  av_log(avctx, AV_LOG_ERROR, " %d\n", supported_samplerates[p]);
719 
720  return AVERROR(EINVAL);
721  }
722  }
724  0, (const void **) &ch_layouts, &num_ch_layouts);
725  if (ret < 0)
726  return ret;
727  if (ch_layouts) {
728  for (i = 0; i < num_ch_layouts; i++) {
730  break;
731  }
732  if (i == num_ch_layouts) {
733  char buf[512];
734  int ret = av_channel_layout_describe(&avctx->ch_layout, buf, sizeof(buf));
735  av_log(avctx, AV_LOG_ERROR,
736  "Specified channel layout '%s' is not supported by the %s encoder\n",
737  ret > 0 ? buf : "?", c->name);
738 
739  av_log(avctx, AV_LOG_ERROR, "Supported channel layouts:\n");
740  for (int p = 0; ch_layouts[p].nb_channels; p++) {
741  ret = av_channel_layout_describe(&ch_layouts[p], buf, sizeof(buf));
742  av_log(avctx, AV_LOG_ERROR, " %s\n", ret > 0 ? buf : "?");
743  }
744  return AVERROR(EINVAL);
745  }
746  }
747 
748  if (!avctx->bits_per_raw_sample)
750  if (!avctx->bits_per_raw_sample)
752 
753  return 0;
754 }
755 
757 {
758  AVCodecInternal *avci = avctx->internal;
759  EncodeContext *ec = encode_ctx(avci);
760  int ret = 0;
761 
762  if (avctx->time_base.num <= 0 || avctx->time_base.den <= 0) {
763  av_log(avctx, AV_LOG_ERROR, "The encoder timebase is not set.\n");
764  return AVERROR(EINVAL);
765  }
766 
767  if (avctx->bit_rate < 0) {
768  av_log(avctx, AV_LOG_ERROR, "The encoder bitrate is negative.\n");
769  return AVERROR(EINVAL);
770  }
771 
772  if (avctx->flags & AV_CODEC_FLAG_COPY_OPAQUE &&
774  av_log(avctx, AV_LOG_ERROR, "The copy_opaque flag is set, but the "
775  "encoder does not support it.\n");
776  return AVERROR(EINVAL);
777  }
778 
779  switch (avctx->codec_type) {
780  case AVMEDIA_TYPE_VIDEO: ret = encode_preinit_video(avctx); break;
781  case AVMEDIA_TYPE_AUDIO: ret = encode_preinit_audio(avctx); break;
782  }
783  if (ret < 0)
784  return ret;
785 
786  if ( (avctx->codec_type == AVMEDIA_TYPE_VIDEO || avctx->codec_type == AVMEDIA_TYPE_AUDIO)
787  && avctx->bit_rate>0 && avctx->bit_rate<1000) {
788  av_log(avctx, AV_LOG_WARNING, "Bitrate %"PRId64" is extremely low, maybe you mean %"PRId64"k\n", avctx->bit_rate, avctx->bit_rate);
789  }
790 
791  if (!avctx->rc_initial_buffer_occupancy)
792  avctx->rc_initial_buffer_occupancy = avctx->rc_buffer_size * 3LL / 4;
793 
796 
797  if (ffcodec(avctx->codec)->cb_type == FF_CODEC_CB_TYPE_ENCODE) {
798  avci->in_frame = av_frame_alloc();
799  if (!avci->in_frame)
800  return AVERROR(ENOMEM);
801  }
802 
803  if ((avctx->flags & AV_CODEC_FLAG_RECON_FRAME)) {
805  av_log(avctx, AV_LOG_ERROR, "Reconstructed frame output requested "
806  "from an encoder not supporting it\n");
807  return AVERROR(ENOSYS);
808  }
809 
810  avci->recon_frame = av_frame_alloc();
811  if (!avci->recon_frame)
812  return AVERROR(ENOMEM);
813  }
814 
815  for (int i = 0; ff_sd_global_map[i].packet < AV_PKT_DATA_NB; i++) {
816  const enum AVPacketSideDataType type_packet = ff_sd_global_map[i].packet;
817  const enum AVFrameSideDataType type_frame = ff_sd_global_map[i].frame;
818  const AVFrameSideData *sd_frame;
819  AVPacketSideData *sd_packet;
820 
821  sd_frame = av_frame_side_data_get(avctx->decoded_side_data,
822  avctx->nb_decoded_side_data,
823  type_frame);
824  if (!sd_frame ||
826  type_packet))
827 
828  continue;
829 
830  sd_packet = av_packet_side_data_new(&avctx->coded_side_data, &avctx->nb_coded_side_data,
831  type_packet, sd_frame->size, 0);
832  if (!sd_packet)
833  return AVERROR(ENOMEM);
834 
835  memcpy(sd_packet->data, sd_frame->data, sd_frame->size);
836  }
837 
838  if (CONFIG_FRAME_THREAD_ENCODER) {
840  if (ret < 0)
841  return ret;
842  }
843 
844  return 0;
845 }
846 
848 {
849  int ret;
850 
851  switch (avctx->codec->type) {
852  case AVMEDIA_TYPE_VIDEO:
853  frame->format = avctx->pix_fmt;
854  if (frame->width <= 0 || frame->height <= 0) {
855  frame->width = FFMAX(avctx->width, avctx->coded_width);
856  frame->height = FFMAX(avctx->height, avctx->coded_height);
857  }
858 
859  break;
860  case AVMEDIA_TYPE_AUDIO:
861  frame->sample_rate = avctx->sample_rate;
862  frame->format = avctx->sample_fmt;
863  if (!frame->ch_layout.nb_channels) {
864  ret = av_channel_layout_copy(&frame->ch_layout, &avctx->ch_layout);
865  if (ret < 0)
866  return ret;
867  }
868  break;
869  }
870 
872  if (ret < 0) {
873  av_log(avctx, AV_LOG_ERROR, "get_buffer() failed\n");
875  return ret;
876  }
877 
878  return 0;
879 }
880 
882 {
883  AVCodecInternal *avci = avctx->internal;
884 
885  if (!avci->recon_frame)
886  return AVERROR(EINVAL);
887  if (!avci->recon_frame->buf[0])
888  return avci->draining_done ? AVERROR_EOF : AVERROR(EAGAIN);
889 
891  return 0;
892 }
893 
895 {
896  AVCodecInternal *avci = avctx->internal;
897 
898  if (avci->in_frame)
899  av_frame_unref(avci->in_frame);
900  if (avci->recon_frame)
902 }
903 
905 {
906  return av_mallocz(sizeof(EncodeContext));
907 }
908 
910 {
912  AVCPBProperties *props;
913  size_t size;
914  int i;
915 
916  for (i = 0; i < avctx->nb_coded_side_data; i++)
918  return (AVCPBProperties *)avctx->coded_side_data[i].data;
919 
920  props = av_cpb_properties_alloc(&size);
921  if (!props)
922  return NULL;
923 
924  tmp = av_realloc_array(avctx->coded_side_data, avctx->nb_coded_side_data + 1, sizeof(*tmp));
925  if (!tmp) {
926  av_freep(&props);
927  return NULL;
928  }
929 
930  avctx->coded_side_data = tmp;
931  avctx->nb_coded_side_data++;
932 
934  avctx->coded_side_data[avctx->nb_coded_side_data - 1].data = (uint8_t*)props;
935  avctx->coded_side_data[avctx->nb_coded_side_data - 1].size = size;
936 
937  return props;
938 }
AVSubtitle
Definition: avcodec.h:2238
avcodec_encode_subtitle
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: encode.c:191
ff_encode_reordered_opaque
int ff_encode_reordered_opaque(AVCodecContext *avctx, AVPacket *pkt, const AVFrame *frame)
Propagate user opaque values from the frame to avctx/pkt as needed.
Definition: encode.c:235
av_samples_copy
int av_samples_copy(uint8_t *const *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:222
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1083
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AVCodec
AVCodec.
Definition: codec.h:187
FF_ENABLE_DEPRECATION_WARNINGS
#define FF_ENABLE_DEPRECATION_WARNINGS
Definition: internal.h:73
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:215
AVPixelFormat
AVPixelFormat
Pixel format.
Definition: pixfmt.h:71
avcodec_receive_packet
int attribute_align_arg avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:541
AVERROR
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
AVCodecContext::audio_service_type
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1103
FF_CODEC_CB_TYPE_RECEIVE_PACKET
@ FF_CODEC_CB_TYPE_RECEIVE_PACKET
Definition: codec_internal.h:124
AVColorTransferCharacteristic
AVColorTransferCharacteristic
Color Transfer Characteristic.
Definition: pixfmt.h:611
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2087
av_frame_get_buffer
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:292
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
av_frame_get_side_data
AVFrameSideData * av_frame_get_side_data(const AVFrame *frame, enum AVFrameSideDataType type)
Definition: frame.c:951
sample_fmts
static enum AVSampleFormat sample_fmts[]
Definition: adpcmenc.c:948
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:3170
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
AV_CODEC_CONFIG_SAMPLE_RATE
@ AV_CODEC_CONFIG_SAMPLE_RATE
int, terminated by 0
Definition: avcodec.h:2707
AVHWFramesContext::format
enum AVPixelFormat format
The pixel format identifying the underlying HW surface type.
Definition: hwcontext.h:197
FF_CODEC_CAP_EOF_FLUSH
#define FF_CODEC_CAP_EOF_FLUSH
The encoder has AV_CODEC_CAP_DELAY set, but does not actually have delay - it only wants to be flushe...
Definition: codec_internal.h:90
AVCodecContext::codec_descriptor
const struct AVCodecDescriptor * codec_descriptor
AVCodecDescriptor.
Definition: avcodec.h:1872
AVCodecContext::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:1926
int64_t
long long int64_t
Definition: coverity.c:34
encode_make_refcounted
static int encode_make_refcounted(AVCodecContext *avctx, AVPacket *avpkt)
Definition: encode.c:137
AV_CODEC_CAP_ENCODER_RECON_FRAME
#define AV_CODEC_CAP_ENCODER_RECON_FRAME
The encoder is able to output reconstructed frame data, i.e.
Definition: codec.h:174
av_unused
#define av_unused
Definition: attributes.h:131
ff_encode_receive_frame
int ff_encode_receive_frame(AVCodecContext *avctx, AVFrame *frame)
avcodec_receive_frame() implementation for encoders.
Definition: encode.c:881
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
tmp
static uint8_t tmp[11]
Definition: aes_ctr.c:28
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
AVCOL_RANGE_JPEG
@ AVCOL_RANGE_JPEG
Full range content.
Definition: pixfmt.h:717
internal.h
av_samples_set_silence
int av_samples_set_silence(uint8_t *const *audio_data, int offset, int nb_samples, int nb_channels, enum AVSampleFormat sample_fmt)
Fill an audio buffer with silence.
Definition: samplefmt.c:246
AVPacket::data
uint8_t * data
Definition: packet.h:539
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVCodecInternal::frame_thread_encoder
void * frame_thread_encoder
Definition: internal.h:98
AVCodecInternal::in_frame
AVFrame * in_frame
The input frame is stored here for encoders implementing the simple encode API.
Definition: internal.h:106
encode.h
AVCOL_TRC_UNSPECIFIED
@ AVCOL_TRC_UNSPECIFIED
Definition: pixfmt.h:614
data
const char data[16]
Definition: mxf.c:149
FFCodec
Definition: codec_internal.h:127
FFCodec::encode
int(* encode)(struct AVCodecContext *avctx, struct AVPacket *avpkt, const struct AVFrame *frame, int *got_packet_ptr)
Encode data to an AVPacket.
Definition: codec_internal.h:220
ff_encode_encode_cb
int ff_encode_encode_cb(AVCodecContext *avctx, AVPacket *avpkt, AVFrame *frame, int *got_packet)
Definition: encode.c:248
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
AVColorPrimaries
AVColorPrimaries
Chromaticity coordinates of the source primaries.
Definition: pixfmt.h:586
AV_CODEC_CONFIG_PIX_FORMAT
@ AV_CODEC_CONFIG_PIX_FORMAT
AVPixelFormat, terminated by AV_PIX_FMT_NONE.
Definition: avcodec.h:2705
avcodec_is_open
int avcodec_is_open(AVCodecContext *s)
Definition: avcodec.c:708
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
ff_icc_profile_attach
int ff_icc_profile_attach(FFIccContext *s, cmsHPROFILE profile, AVFrame *frame)
Attach an ICC profile to a frame.
Definition: fflcms2.c:172
AVFrame::buf
AVBufferRef * buf[AV_NUM_DATA_POINTERS]
AVBuffer references backing the data for this frame.
Definition: frame.h:602
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
AV_FRAME_FLAG_TOP_FIELD_FIRST
#define AV_FRAME_FLAG_TOP_FIELD_FIRST
A flag to mark frames where the top field is displayed first if the content is interlaced.
Definition: frame.h:653
AVPacketSideData::size
size_t size
Definition: packet.h:392
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:373
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:460
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:575
AV_CODEC_FLAG_FRAME_DURATION
#define AV_CODEC_FLAG_FRAME_DURATION
Signal to the encoder that the values of AVFrame.duration are valid and should be used (typically for...
Definition: avcodec.h:306
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1071
fail
#define fail()
Definition: checkasm.h:188
ff_icc_context_init
int ff_icc_context_init(FFIccContext *s, void *avctx)
Initializes an FFIccContext.
Definition: fflcms2.c:30
encode_receive_packet_internal
static int encode_receive_packet_internal(AVCodecContext *avctx, AVPacket *avpkt)
Definition: encode.c:362
samplefmt.h
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
AVCodecContext::coded_height
int coded_height
Definition: avcodec.h:639
encode_preinit_video
static int encode_preinit_video(AVCodecContext *avctx)
Definition: encode.c:562
AVRational::num
int num
Numerator.
Definition: rational.h:59
AVFrameSideDataType
AVFrameSideDataType
Definition: frame.h:49
av_image_check_size2
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:289
av_get_planar_sample_fmt
enum AVSampleFormat av_get_planar_sample_fmt(enum AVSampleFormat sample_fmt)
Get the planar alternative form of the given sample format.
Definition: samplefmt.c:86
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
AV_PIX_FMT_YUVJ411P
@ AV_PIX_FMT_YUVJ411P
planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples) full scale (JPEG), deprecated in favor ...
Definition: pixfmt.h:283
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
encode_send_frame_internal
static int encode_send_frame_internal(AVCodecContext *avctx, const AVFrame *src)
Definition: encode.c:445
frame_thread_encoder.h
AVFrameSideData::size
size_t size
Definition: frame.h:268
encode_simple_internal
static int encode_simple_internal(AVCodecContext *avctx, AVPacket *avpkt)
Definition: encode.c:305
AVCodecContext::rc_initial_buffer_occupancy
int rc_initial_buffer_occupancy
Number of bits which should be loaded into the rc buffer before decoding starts.
Definition: avcodec.h:1330
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:648
AV_PIX_FMT_YUVJ422P
@ AV_PIX_FMT_YUVJ422P
planar YUV 4:2:2, 16bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV422P and setting col...
Definition: pixfmt.h:86
emms_c
#define emms_c()
Definition: emms.h:63
ff_frame_thread_encoder_init
av_cold int ff_frame_thread_encoder_init(AVCodecContext *avctx)
Initialize frame thread encoder.
Definition: frame_thread_encoder.c:120
AV_CODEC_CONFIG_SAMPLE_FORMAT
@ AV_CODEC_CONFIG_SAMPLE_FORMAT
AVSampleFormat, terminated by AV_SAMPLE_FMT_NONE.
Definition: avcodec.h:2708
s
#define s(width, name)
Definition: cbs_vp9.c:198
AVCodecInternal::buffer_pkt
AVPacket * buffer_pkt
Temporary buffers for newly received or not yet output packets/frames.
Definition: internal.h:144
av_realloc_array
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Definition: mem.c:217
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2088
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_FRAME_DATA_AUDIO_SERVICE_TYPE
@ AV_FRAME_DATA_AUDIO_SERVICE_TYPE
This side data must be associated with an audio frame and corresponds to enum AVAudioServiceType defi...
Definition: frame.h:114
AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
#define AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE
This encoder can reorder user opaque values from input AVFrames and return them with corresponding ou...
Definition: codec.h:159
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
pix_fmts
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:304
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1585
EncodeContext::avci
AVCodecInternal avci
Definition: encode.c:41
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
FF_CODEC_CB_TYPE_ENCODE
@ FF_CODEC_CB_TYPE_ENCODE
Definition: codec_internal.h:118
AVCodecContext::max_pixels
int64_t max_pixels
The number of pixels per image to maximally accept.
Definition: avcodec.h:1945
av_get_sample_fmt_name
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:51
FFCodec::encode_sub
int(* encode_sub)(struct AVCodecContext *avctx, uint8_t *buf, int buf_size, const struct AVSubtitle *sub)
Encode subtitles to a raw buffer.
Definition: codec_internal.h:226
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
AVCOL_PRI_UNSPECIFIED
@ AVCOL_PRI_UNSPECIFIED
Definition: pixfmt.h:589
AVCPBProperties
This structure describes the bitrate properties of an encoded bitstream.
Definition: defs.h:271
AV_PIX_FMT_YUVJ444P
@ AV_PIX_FMT_YUVJ444P
planar YUV 4:4:4, 24bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV444P and setting col...
Definition: pixfmt.h:87
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
ff_thread_video_encode_frame
int ff_thread_video_encode_frame(AVCodecContext *avctx, AVPacket *pkt, AVFrame *frame, int *got_packet_ptr)
Definition: frame_thread_encoder.c:301
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
if
if(ret)
Definition: filter_design.txt:179
AVCodecContext::rc_buffer_size
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:1287
AV_CODEC_PROP_INTRA_ONLY
#define AV_CODEC_PROP_INTRA_ONLY
Codec uses only intra compression.
Definition: codec_desc.h:72
AVPacket::buf
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: packet.h:522
NULL
#define NULL
Definition: coverity.c:32
AVHWFramesContext::sw_format
enum AVPixelFormat sw_format
The pixel format identifying the actual data layout of the hardware frames.
Definition: hwcontext.h:210
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:713
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
AVCodecContext::nb_coded_side_data
int nb_coded_side_data
Definition: avcodec.h:1927
ff_samples_to_time_base
static av_always_inline int64_t ff_samples_to_time_base(const AVCodecContext *avctx, int64_t samples)
Rescale from sample rate to AVCodecContext.time_base.
Definition: encode.h:90
AVCodecContext::internal
struct AVCodecInternal * internal
Private context used for internal data.
Definition: avcodec.h:486
AV_PIX_FMT_YUVJ420P
@ AV_PIX_FMT_YUVJ420P
planar YUV 4:2:0, 12bpp, full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV420P and setting col...
Definition: pixfmt.h:85
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
AVPacketSideData::type
enum AVPacketSideDataType type
Definition: packet.h:393
AV_FRAME_DATA_ICC_PROFILE
@ AV_FRAME_DATA_ICC_PROFILE
The data contains an ICC profile as an opaque octet buffer following the format described by ISO 1507...
Definition: frame.h:144
ff_encode_internal_alloc
AVCodecInternal * ff_encode_internal_alloc(void)
Definition: encode.c:904
AV_CODEC_CAP_VARIABLE_FRAME_SIZE
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: codec.h:128
AV_CODEC_FLAG2_ICC_PROFILES
#define AV_CODEC_FLAG2_ICC_PROFILES
Generate/parse ICC profiles on encode/decode, as appropriate for the type of file.
Definition: avcodec.h:398
av_packet_move_ref
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: packet.c:486
AVCodecInternal::draining_done
int draining_done
Definition: internal.h:146
ff_sd_global_map
const SideDataMap ff_sd_global_map[]
A map between packet and frame side data types.
Definition: avcodec.c:58
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVAudioServiceType
AVAudioServiceType
Definition: defs.h:224
AV_PKT_DATA_NB
@ AV_PKT_DATA_NB
The number of side data types.
Definition: packet.h:356
av_packet_side_data_get
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
Definition: packet.c:656
ff_icc_profile_generate
int ff_icc_profile_generate(FFIccContext *s, enum AVColorPrimaries color_prim, enum AVColorTransferCharacteristic color_trc, cmsHPROFILE *out_profile)
Generate an ICC profile for a given combination of color primaries and transfer function.
Definition: fflcms2.c:145
attribute_align_arg
#define attribute_align_arg
Definition: internal.h:50
AVCodecContext::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avcodec.h:550
ff_encode_alloc_frame
int ff_encode_alloc_frame(AVCodecContext *avctx, AVFrame *frame)
Allocate buffers for a frame.
Definition: encode.c:847
avcodec_get_supported_config
int avcodec_get_supported_config(const AVCodecContext *avctx, const AVCodec *codec, enum AVCodecConfig config, unsigned flags, const void **out, int *out_num)
Retrieve a list of all supported values for a given configuration type.
Definition: avcodec.c:796
AV_CODEC_CONFIG_CHANNEL_LAYOUT
@ AV_CODEC_CONFIG_CHANNEL_LAYOUT
AVChannelLayout, terminated by {0}.
Definition: avcodec.h:2709
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1344
av_get_exact_bits_per_sample
int av_get_exact_bits_per_sample(enum AVCodecID codec_id)
Return codec bits per sample.
Definition: utils.c:457
pad_last_frame
static int pad_last_frame(AVCodecContext *s, AVFrame *frame, const AVFrame *src, int out_samples)
Pad last frame with silence.
Definition: encode.c:157
f
f
Definition: af_crystalizer.c:122
AVCodecContext::flags2
int flags2
AV_CODEC_FLAG2_*.
Definition: avcodec.h:515
SideDataMap::packet
enum AVPacketSideDataType packet
Definition: avcodec_internal.h:35
AVPacket::size
int size
Definition: packet.h:540
av_frame_ref
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:388
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
codec_internal.h
AV_CODEC_PROP_REORDER
#define AV_CODEC_PROP_REORDER
Codec supports frame reordering.
Definition: codec_desc.h:92
dst
uint8_t ptrdiff_t const uint8_t ptrdiff_t int intptr_t intptr_t int int16_t * dst
Definition: dsp.h:83
FFCodec::receive_packet
int(* receive_packet)(struct AVCodecContext *avctx, struct AVPacket *avpkt)
Encode API with decoupled frame/packet dataflow.
Definition: codec_internal.h:235
EncodeContext
Definition: encode.c:40
AVCodecContext::sample_fmt
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1063
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
size
int size
Definition: twinvq_data.h:10344
EncodeContext::last_audio_frame
int last_audio_frame
An audio frame with less than required samples has been submitted (and potentially padded with silenc...
Definition: encode.c:54
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AVFrameSideData::data
uint8_t * data
Definition: frame.h:267
ffcodec
static const av_always_inline FFCodec * ffcodec(const AVCodec *codec)
Definition: codec_internal.h:330
AVCodecInternal::byte_buffer
uint8_t * byte_buffer
temporary buffer used for encoders to store their bitstream
Definition: internal.h:95
frame.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
attributes.h
SideDataMap::frame
enum AVFrameSideDataType frame
Definition: avcodec_internal.h:36
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
AVCodecInternal
Definition: internal.h:49
AVCodecInternal::byte_buffer_size
unsigned int byte_buffer_size
Definition: internal.h:96
encode_ctx
static EncodeContext * encode_ctx(AVCodecInternal *avci)
Definition: encode.c:57
ff_encode_preinit
int ff_encode_preinit(AVCodecContext *avctx)
Definition: encode.c:756
av_channel_layout_compare
int av_channel_layout_compare(const AVChannelLayout *chl, const AVChannelLayout *chl1)
Check whether two channel layouts are semantically the same, i.e.
Definition: channel_layout.c:804
av_codec_is_encoder
int av_codec_is_encoder(const AVCodec *codec)
Definition: utils.c:78
emms.h
avcodec_default_get_buffer2
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: get_buffer.c:250
FFCodec::caps_internal
unsigned caps_internal
Internal codec capabilities FF_CODEC_CAP_*.
Definition: codec_internal.h:136
AV_PKT_DATA_CPB_PROPERTIES
@ AV_PKT_DATA_CPB_PROPERTIES
This side data corresponds to the AVCPBProperties struct.
Definition: packet.h:142
AV_CODEC_FLAG_RECON_FRAME
#define AV_CODEC_FLAG_RECON_FRAME
Request the encoder to output reconstructed frames, i.e. frames that would be produced by decoding th...
Definition: avcodec.h:264
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
av_get_bytes_per_sample
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:108
internal.h
EncodeContext::intra_only_flag
int intra_only_flag
This is set to AV_PKT_FLAG_KEY for encoders that encode intra-only formats (i.e.
Definition: encode.c:48
AVSampleFormat
AVSampleFormat
Audio sample formats.
Definition: samplefmt.h:55
av_fast_padded_malloc
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:52
av_frame_move_ref
void av_frame_move_ref(AVFrame *dst, AVFrame *src)
Move everything contained in src to dst and reset src.
Definition: frame.c:637
ch_layouts
static const AVChannelLayout ch_layouts[]
Definition: adpcmenc.c:956
AV_PIX_FMT_YUVJ440P
@ AV_PIX_FMT_YUVJ440P
planar YUV 4:4:0 full scale (JPEG), deprecated in favor of AV_PIX_FMT_YUV440P and setting color_range
Definition: pixfmt.h:107
av_frame_unref
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:610
av_mallocz
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:256
av_buffer_replace
int av_buffer_replace(AVBufferRef **pdst, const AVBufferRef *src)
Ensure dst refers to the same data as src.
Definition: buffer.c:233
profile
int profile
Definition: mxfenc.c:2228
AVCodecContext::height
int height
Definition: avcodec.h:624
avcodec_send_frame
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:508
AVCodecContext::pix_fmt
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:663
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
FF_CODEC_CAP_ICC_PROFILES
#define FF_CODEC_CAP_ICC_PROFILES
Codec supports embedded ICC profiles (AV_FRAME_DATA_ICC_PROFILE).
Definition: codec_internal.h:82
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1485
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
AVCodecContext::frame_num
int64_t frame_num
Frame counter, set by libavcodec.
Definition: avcodec.h:2041
ret
ret
Definition: filter_design.txt:187
ff_encode_flush_buffers
void ff_encode_flush_buffers(AVCodecContext *avctx)
Definition: encode.c:894
frame
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
Definition: filter_design.txt:264
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: packet.c:706
AVPacket::side_data
AVPacketSideData * side_data
Additional packet data that can be provided by the container.
Definition: packet.h:550
AVCodecInternal::recon_frame
AVFrame * recon_frame
When the AV_CODEC_FLAG_RECON_FRAME flag is used.
Definition: internal.h:114
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: defs.h:40
AVCodecContext
main external API structure.
Definition: avcodec.h:451
channel_layout.h
avcodec_internal.h
ff_get_encode_buffer
int ff_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int64_t size, int flags)
Get a buffer for a packet.
Definition: encode.c:106
AVRational::den
int den
Denominator.
Definition: rational.h:60
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AVCodecInternal::pad_samples
int pad_samples
Audio encoders can set this flag during init to indicate that they want the small last frame to be pa...
Definition: internal.h:67
AVCodecContext::get_encode_buffer
int(* get_encode_buffer)(struct AVCodecContext *s, AVPacket *pkt, int flags)
This callback is called at the beginning of each packet to get a data buffer for it.
Definition: avcodec.h:2030
encode_simple_receive_packet
static int encode_simple_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Definition: encode.c:349
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
AVCodecContext::ticks_per_frame
attribute_deprecated int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:582
AV_CODEC_CAP_DELAY
#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: codec.h:76
AVPacketSideDataType
AVPacketSideDataType
Definition: packet.h:41
FFCodec::cb_type
unsigned cb_type
This field determines the type of the codec (decoder/encoder) and also the exact callback cb implemen...
Definition: codec_internal.h:149
av_buffer_realloc
int av_buffer_realloc(AVBufferRef **pbuf, size_t size)
Reallocate a given buffer.
Definition: buffer.c:183
AVCodecInternal::buffer_frame
AVFrame * buffer_frame
Definition: internal.h:145
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:444
AVCodecInternal::draining
int draining
decoding: AVERROR_EOF has been returned from ff_decode_get_packet(); must not be used by decoders tha...
Definition: internal.h:139
FF_DISABLE_DEPRECATION_WARNINGS
#define FF_DISABLE_DEPRECATION_WARNINGS
Definition: internal.h:72
AVCodecContext::coded_width
int coded_width
Bitstream width / height, may be different from width/height e.g.
Definition: avcodec.h:639
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
encode_preinit_audio
static int encode_preinit_audio(AVCodecContext *avctx)
Definition: encode.c:652
ff_encode_get_frame
int ff_encode_get_frame(AVCodecContext *avctx, AVFrame *frame)
Called by encoders to get the next frame for encoding.
Definition: encode.c:205
AVFrameSideData
Structure to hold side data for an AVFrame.
Definition: frame.h:265
AVPixFmtDescriptor
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:69
AVPacket
This structure stores compressed data.
Definition: packet.h:516
avcodec_default_get_encode_buffer
int avcodec_default_get_encode_buffer(AVCodecContext *avctx, AVPacket *avpkt, int flags)
The default callback for AVCodecContext.get_encode_buffer().
Definition: encode.c:84
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
FFCodec::cb
union FFCodec::@92 cb
av_frame_side_data_get
static const AVFrameSideData * av_frame_side_data_get(AVFrameSideData *const *sd, const int nb_sd, enum AVFrameSideDataType type)
Wrapper around av_frame_side_data_get_c() to workaround the limitation that for any type T the conver...
Definition: frame.h:1158
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
encode_generate_icc_profile
static int encode_generate_icc_profile(av_unused AVCodecContext *c, av_unused AVFrame *f)
Definition: encode.c:439
imgutils.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
ff_encode_add_cpb_side_data
AVCPBProperties * ff_encode_add_cpb_side_data(AVCodecContext *avctx)
Add a CPB properties side data to an encoding context.
Definition: encode.c:909
AVCodecContext::sw_pix_fmt
enum AVPixelFormat sw_pix_fmt
Nominal unaccelerated pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:670
AV_CODEC_CAP_SMALL_LAST_FRAME
#define AV_CODEC_CAP_SMALL_LAST_FRAME
Codec can be fed a final frame with a smaller size.
Definition: codec.h:81
codec_desc.h
ff_alloc_packet
int ff_alloc_packet(AVCodecContext *avctx, AVPacket *avpkt, int64_t size)
Check AVPacket size and allocate data.
Definition: encode.c:62
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2240
src
#define src
Definition: vp8dsp.c:248
av_get_pix_fmt_name
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:3090
av_cpb_properties_alloc
AVCPBProperties * av_cpb_properties_alloc(size_t *size)
Allocate a CPB properties structure and initialize its fields to default values.
Definition: utils.c:951
AV_CODEC_FLAG_PASS1
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:310