FFmpeg: fftools/ffmpeg_enc.c Source File

FFmpeg
ffmpeg_enc.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <math.h>
20 #include <stdint.h>
21 
22 #include "ffmpeg.h"
23 
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/avutil.h"
27 #include "libavutil/dict.h"
28 #include "libavutil/display.h"
29 #include "libavutil/eval.h"
30 #include "libavutil/frame.h"
31 #include "libavutil/intreadwrite.h"
32 #include "libavutil/log.h"
33 #include "libavutil/mem.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/rational.h"
36 #include "libavutil/time.h"
37 #include "libavutil/timestamp.h"
38 
39 #include "libavcodec/avcodec.h"
40 
41  struct Encoder {
42  // combined size of all the packets received from the encoder
43   uint64_t data_size;
44 
45  // number of packets received from the encoder
46   uint64_t packets_encoded;
47 
48   int opened;
49   int attach_par;
50 
51   Scheduler *sch;
52   unsigned sch_idx;
53 };
54 
55 // data that is local to the decoder thread and not visible outside of it
56  typedef struct EncoderThread {
57   AVFrame *frame;
58   AVPacket *pkt;
59 } EncoderThread;
60 
61  void enc_free(Encoder **penc)
62 {
63  Encoder *enc = *penc;
64 
65  if (!enc)
66  return;
67 
68  av_freep(penc);
69 }
70 
71  int enc_alloc(Encoder **penc, const AVCodec *codec,
72  Scheduler *sch, unsigned sch_idx)
73 {
74  Encoder *enc;
75 
76  *penc = NULL;
77 
78  enc = av_mallocz(sizeof(*enc));
79  if (!enc)
80  return AVERROR(ENOMEM);
81 
82  enc->sch = sch;
83  enc->sch_idx = sch_idx;
84 
85  *penc = enc;
86 
87  return 0;
88 }
89 
90  static int hw_device_setup_for_encode(OutputStream *ost, AVBufferRef *frames_ref)
91 {
92  const AVCodecHWConfig *config;
93  HWDevice *dev = NULL;
94 
95  if (frames_ref &&
96  ((AVHWFramesContext*)frames_ref->data)->format ==
97  ost->enc_ctx->pix_fmt) {
98  // Matching format, will try to use hw_frames_ctx.
99  } else {
100  frames_ref = NULL;
101  }
102 
103  for (int i = 0;; i++) {
104  config = avcodec_get_hw_config(ost->enc_ctx->codec, i);
105  if (!config)
106  break;
107 
108  if (frames_ref &&
109  config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX &&
110  (config->pix_fmt == AV_PIX_FMT_NONE ||
111  config->pix_fmt == ost->enc_ctx->pix_fmt)) {
112  av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using input "
113  "frames context (format %s) with %s encoder.\n",
114  av_get_pix_fmt_name(ost->enc_ctx->pix_fmt),
115  ost->enc_ctx->codec->name);
116  ost->enc_ctx->hw_frames_ctx = av_buffer_ref(frames_ref);
117  if (!ost->enc_ctx->hw_frames_ctx)
118  return AVERROR(ENOMEM);
119  return 0;
120  }
121 
122  if (!dev &&
123  config->methods & AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX)
124  dev = hw_device_get_by_type(config->device_type);
125  }
126 
127  if (dev) {
128  av_log(ost->enc_ctx, AV_LOG_VERBOSE, "Using device %s "
129  "(type %s) with %s encoder.\n", dev->name,
130  av_hwdevice_get_type_name(dev->type), ost->enc_ctx->codec->name);
131  ost->enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
132  if (!ost->enc_ctx->hw_device_ctx)
133  return AVERROR(ENOMEM);
134  } else {
135  // No device required, or no device available.
136  }
137  return 0;
138 }
139 
140  static int set_encoder_id(OutputFile *of, OutputStream *ost)
141 {
142  const char *cname = ost->enc_ctx->codec->name;
143  uint8_t *encoder_string;
144  int encoder_string_len;
145 
146  if (av_dict_get(ost->st->metadata, "encoder", NULL, 0))
147  return 0;
148 
149  encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(cname) + 2;
150  encoder_string = av_mallocz(encoder_string_len);
151  if (!encoder_string)
152  return AVERROR(ENOMEM);
153 
154  if (!of->bitexact && !ost->bitexact)
155  av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
156  else
157  av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
158  av_strlcat(encoder_string, cname, encoder_string_len);
159  av_dict_set(&ost->st->metadata, "encoder", encoder_string,
160  AV_DICT_DONT_STRDUP_VAL | AV_DICT_DONT_OVERWRITE);
161 
162  return 0;
163 }
164 
165  int enc_open(void *opaque, const AVFrame *frame)
166 {
167  OutputStream *ost = opaque;
168  InputStream *ist = ost->ist;
169  Encoder *e = ost->enc;
170  AVCodecContext *enc_ctx = ost->enc_ctx;
171  Decoder *dec = NULL;
172  const AVCodec *enc = enc_ctx->codec;
173  OutputFile *of = ost->file;
174  FrameData *fd;
175  int frame_samples = 0;
176  int ret;
177 
178  if (e->opened)
179  return 0;
180 
181  // frame is always non-NULL for audio and video
182  av_assert0(frame || (enc->type != AVMEDIA_TYPE_VIDEO && enc->type != AVMEDIA_TYPE_AUDIO));
183 
184  if (frame) {
185  av_assert0(frame->opaque_ref);
186  fd = (FrameData*)frame->opaque_ref->data;
187 
188  for (int i = 0; i < frame->nb_side_data; i++) {
189  const AVSideDataDescriptor *desc = av_frame_side_data_desc(frame->side_data[i]->type);
190 
191  if (!(desc->props & AV_SIDE_DATA_PROP_GLOBAL))
192  continue;
193 
194  ret = av_frame_side_data_clone(&enc_ctx->decoded_side_data,
195  &enc_ctx->nb_decoded_side_data,
196  frame->side_data[i],
197  AV_FRAME_SIDE_DATA_FLAG_UNIQUE);
198  if (ret < 0)
199  return ret;
200  }
201  }
202 
203  ret = set_encoder_id(of, ost);
204  if (ret < 0)
205  return ret;
206 
207  if (ist)
208  dec = ist->decoder;
209 
210  // the timebase is chosen by filtering code
211  if (ost->type == AVMEDIA_TYPE_AUDIO || ost->type == AVMEDIA_TYPE_VIDEO) {
212  enc_ctx->time_base = frame->time_base;
213  enc_ctx->framerate = fd->frame_rate_filter;
214  ost->st->avg_frame_rate = fd->frame_rate_filter;
215  }
216 
217  switch (enc_ctx->codec_type) {
218  case AVMEDIA_TYPE_AUDIO:
219  av_assert0(frame->format != AV_SAMPLE_FMT_NONE &&
220  frame->sample_rate > 0 &&
221  frame->ch_layout.nb_channels > 0);
222  enc_ctx->sample_fmt = frame->format;
223  enc_ctx->sample_rate = frame->sample_rate;
224  ret = av_channel_layout_copy(&enc_ctx->ch_layout, &frame->ch_layout);
225  if (ret < 0)
226  return ret;
227 
228  if (ost->bits_per_raw_sample)
229  enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
230  else
231  enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
232  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
233  break;
234 
235  case AVMEDIA_TYPE_VIDEO: {
236  av_assert0(frame->format != AV_PIX_FMT_NONE &&
237  frame->width > 0 &&
238  frame->height > 0);
239  enc_ctx->width = frame->width;
240  enc_ctx->height = frame->height;
241  enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
242  ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
243  av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
244  frame->sample_aspect_ratio;
245 
246  enc_ctx->pix_fmt = frame->format;
247 
248  if (ost->bits_per_raw_sample)
249  enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
250  else
251  enc_ctx->bits_per_raw_sample = FFMIN(fd->bits_per_raw_sample,
252  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
253 
254  enc_ctx->color_range = frame->color_range;
255  enc_ctx->color_primaries = frame->color_primaries;
256  enc_ctx->color_trc = frame->color_trc;
257  enc_ctx->colorspace = frame->colorspace;
258  enc_ctx->chroma_sample_location = frame->chroma_location;
259 
260  if (enc_ctx->flags & (AV_CODEC_FLAG_INTERLACED_DCT | AV_CODEC_FLAG_INTERLACED_ME) ||
261  (frame->flags & AV_FRAME_FLAG_INTERLACED)
262 #if FFMPEG_OPT_TOP
263  || ost->top_field_first >= 0
264 #endif
265  ) {
266  int top_field_first =
267 #if FFMPEG_OPT_TOP
268  ost->top_field_first >= 0 ?
269  ost->top_field_first :
270 #endif
271  !!(frame->flags & AV_FRAME_FLAG_TOP_FIELD_FIRST);
272 
273  if (enc->id == AV_CODEC_ID_MJPEG)
274  enc_ctx->field_order = top_field_first ? AV_FIELD_TT : AV_FIELD_BB;
275  else
276  enc_ctx->field_order = top_field_first ? AV_FIELD_TB : AV_FIELD_BT;
277  } else
278  enc_ctx->field_order = AV_FIELD_PROGRESSIVE;
279 
280  break;
281  }
282  case AVMEDIA_TYPE_SUBTITLE:
283  enc_ctx->time_base = AV_TIME_BASE_Q;
284 
285  if (!enc_ctx->width) {
286  enc_ctx->width = ost->ist->par->width;
287  enc_ctx->height = ost->ist->par->height;
288  }
289 
290  av_assert0(dec);
291  if (dec->subtitle_header) {
292  /* ASS code assumes this buffer is null terminated so add extra byte. */
293  enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
294  if (!enc_ctx->subtitle_header)
295  return AVERROR(ENOMEM);
296  memcpy(enc_ctx->subtitle_header, dec->subtitle_header,
297  dec->subtitle_header_size);
298  enc_ctx->subtitle_header_size = dec->subtitle_header_size;
299  }
300 
301  break;
302  default:
303  av_assert0(0);
304  break;
305  }
306 
307  if (ost->bitexact)
308  enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
309 
310  if (enc->capabilities & AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE)
311  enc_ctx->flags |= AV_CODEC_FLAG_COPY_OPAQUE;
312 
313  enc_ctx->flags |= AV_CODEC_FLAG_FRAME_DURATION;
314 
315  ret = hw_device_setup_for_encode(ost, frame ? frame->hw_frames_ctx : NULL);
316  if (ret < 0) {
317  av_log(ost, AV_LOG_ERROR,
318  "Encoding hardware device setup failed: %s\n", av_err2str(ret));
319  return ret;
320  }
321 
322  if ((ret = avcodec_open2(ost->enc_ctx, enc, NULL)) < 0) {
323  if (ret != AVERROR_EXPERIMENTAL)
324  av_log(ost, AV_LOG_ERROR, "Error while opening encoder - maybe "
325  "incorrect parameters such as bit_rate, rate, width or height.\n");
326  return ret;
327  }
328 
329  e->opened = 1;
330 
331  if (ost->enc_ctx->frame_size)
332  frame_samples = ost->enc_ctx->frame_size;
333 
334  if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
335  ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
336  av_log(ost, AV_LOG_WARNING, "The bitrate parameter is set too low."
337  " It takes bits/s as argument, not kbits/s\n");
338 
339  ret = avcodec_parameters_from_context(ost->par_in, ost->enc_ctx);
340  if (ret < 0) {
341  av_log(ost, AV_LOG_FATAL,
342  "Error initializing the output stream codec context.\n");
343  return ret;
344  }
345 
346  // copy timebase while removing common factors
347  if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
348  ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
349 
350  ret = of_stream_init(of, ost);
351  if (ret < 0)
352  return ret;
353 
354  return frame_samples;
355 }
356 
357  static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
358 {
359  OutputFile *of = ost->file;
360 
361  if (of->recording_time != INT64_MAX &&
362  av_compare_ts(ts, tb, of->recording_time, AV_TIME_BASE_Q) >= 0) {
363  return 0;
364  }
365  return 1;
366 }
367 
368  static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub,
369  AVPacket *pkt)
370 {
371  Encoder *e = ost->enc;
372  int subtitle_out_max_size = 1024 * 1024;
373  int subtitle_out_size, nb, i, ret;
374  AVCodecContext *enc;
375  int64_t pts;
376 
377  if (sub->pts == AV_NOPTS_VALUE) {
378  av_log(ost, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
379  return exit_on_error ? AVERROR(EINVAL) : 0;
380  }
381  if ((of->start_time != AV_NOPTS_VALUE && sub->pts < of->start_time))
382  return 0;
383 
384  enc = ost->enc_ctx;
385 
386  /* Note: DVB subtitle need one packet to draw them and one other
387  packet to clear them */
388  /* XXX: signal it in the codec context ? */
389  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
390  nb = 2;
391  else if (enc->codec_id == AV_CODEC_ID_ASS)
392  nb = FFMAX(sub->num_rects, 1);
393  else
394  nb = 1;
395 
396  /* shift timestamp to honor -ss and make check_recording_time() work with -t */
397  pts = sub->pts;
398  if (of->start_time != AV_NOPTS_VALUE)
399  pts -= of->start_time;
400  for (i = 0; i < nb; i++) {
401  AVSubtitle local_sub = *sub;
402 
403  if (!check_recording_time(ost, pts, AV_TIME_BASE_Q))
404  return AVERROR_EOF;
405 
406  ret = av_new_packet(pkt, subtitle_out_max_size);
407  if (ret < 0)
408  return AVERROR(ENOMEM);
409 
410  local_sub.pts = pts;
411  // start_display_time is required to be 0
412  local_sub.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
413  local_sub.end_display_time -= sub->start_display_time;
414  local_sub.start_display_time = 0;
415 
416  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE && i == 1)
417  local_sub.num_rects = 0;
418  else if (enc->codec_id == AV_CODEC_ID_ASS && sub->num_rects > 0) {
419  local_sub.num_rects = 1;
420  local_sub.rects += i;
421  }
422 
423  ost->frames_encoded++;
424 
425  subtitle_out_size = avcodec_encode_subtitle(enc, pkt->data, pkt->size, &local_sub);
426  if (subtitle_out_size < 0) {
427  av_log(ost, AV_LOG_FATAL, "Subtitle encoding failed\n");
428  return subtitle_out_size;
429  }
430 
431  av_shrink_packet(pkt, subtitle_out_size);
432  pkt->time_base = AV_TIME_BASE_Q;
433  pkt->pts = sub->pts;
434  pkt->duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
435  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
436  /* XXX: the pts correction is handled here. Maybe handling
437  it in the codec would be better */
438  if (i == 0)
439  pkt->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
440  else
441  pkt->pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
442  }
443  pkt->dts = pkt->pts;
444 
445  ret = sch_enc_send(e->sch, e->sch_idx, pkt);
446  if (ret < 0) {
447  av_packet_unref(pkt);
448  return ret;
449  }
450  }
451 
452  return 0;
453 }
454 
455  void enc_stats_write(OutputStream *ost, EncStats *es,
456  const AVFrame *frame, const AVPacket *pkt,
457  uint64_t frame_num)
458 {
459  Encoder *e = ost->enc;
460  AVIOContext *io = es->io;
461  AVRational tb = frame ? frame->time_base : pkt->time_base;
462  int64_t pts = frame ? frame->pts : pkt->pts;
463 
464  AVRational tbi = (AVRational){ 0, 1};
465  int64_t ptsi = INT64_MAX;
466 
467  const FrameData *fd = NULL;
468 
469  if (frame ? frame->opaque_ref : pkt->opaque_ref) {
470  fd = (const FrameData*)(frame ? frame->opaque_ref->data : pkt->opaque_ref->data);
471  tbi = fd->dec.tb;
472  ptsi = fd->dec.pts;
473  }
474 
475  pthread_mutex_lock(&es->lock);
476 
477  for (size_t i = 0; i < es->nb_components; i++) {
478  const EncStatsComponent *c = &es->components[i];
479 
480  switch (c->type) {
481  case ENC_STATS_LITERAL: avio_write (io, c->str, c->str_len); continue;
482  case ENC_STATS_FILE_IDX: avio_printf(io, "%d", ost->file->index); continue;
483  case ENC_STATS_STREAM_IDX: avio_printf(io, "%d", ost->index); continue;
484  case ENC_STATS_TIMEBASE: avio_printf(io, "%d/%d", tb.num, tb.den); continue;
485  case ENC_STATS_TIMEBASE_IN: avio_printf(io, "%d/%d", tbi.num, tbi.den); continue;
486  case ENC_STATS_PTS: avio_printf(io, "%"PRId64, pts); continue;
487  case ENC_STATS_PTS_IN: avio_printf(io, "%"PRId64, ptsi); continue;
488  case ENC_STATS_PTS_TIME: avio_printf(io, "%g", pts * av_q2d(tb)); continue;
489  case ENC_STATS_PTS_TIME_IN: avio_printf(io, "%g", ptsi == INT64_MAX ?
490  INFINITY : ptsi * av_q2d(tbi)); continue;
491  case ENC_STATS_FRAME_NUM: avio_printf(io, "%"PRIu64, frame_num); continue;
492  case ENC_STATS_FRAME_NUM_IN: avio_printf(io, "%"PRIu64, fd ? fd->dec.frame_num : -1); continue;
493  }
494 
495  if (frame) {
496  switch (c->type) {
497  case ENC_STATS_SAMPLE_NUM: avio_printf(io, "%"PRIu64, ost->samples_encoded); continue;
498  case ENC_STATS_NB_SAMPLES: avio_printf(io, "%d", frame->nb_samples); continue;
499  default: av_assert0(0);
500  }
501  } else {
502  switch (c->type) {
503  case ENC_STATS_DTS: avio_printf(io, "%"PRId64, pkt->dts); continue;
504  case ENC_STATS_DTS_TIME: avio_printf(io, "%g", pkt->dts * av_q2d(tb)); continue;
505  case ENC_STATS_PKT_SIZE: avio_printf(io, "%d", pkt->size); continue;
506  case ENC_STATS_KEYFRAME: avio_write(io, (pkt->flags & AV_PKT_FLAG_KEY) ?
507  "K" : "N", 1); continue;
508  case ENC_STATS_BITRATE: {
509  double duration = FFMAX(pkt->duration, 1) * av_q2d(tb);
510  avio_printf(io, "%g", 8.0 * pkt->size / duration);
511  continue;
512  }
513  case ENC_STATS_AVG_BITRATE: {
514  double duration = pkt->dts * av_q2d(tb);
515  avio_printf(io, "%g", duration > 0 ? 8.0 * e->data_size / duration : -1.);
516  continue;
517  }
518  default: av_assert0(0);
519  }
520  }
521  }
522  avio_w8(io, '\n');
523  avio_flush(io);
524 
525  pthread_mutex_unlock(&es->lock);
526 }
527 
528  static inline double psnr(double d)
529 {
530  return -10.0 * log10(d);
531 }
532 
533  static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
534 {
535  Encoder *e = ost->enc;
536  const uint8_t *sd = av_packet_get_side_data(pkt, AV_PKT_DATA_QUALITY_STATS,
537  NULL);
538  AVCodecContext *enc = ost->enc_ctx;
539  enum AVPictureType pict_type;
540  int64_t frame_number;
541  double ti1, bitrate, avg_bitrate;
542  double psnr_val = -1;
543  int quality;
544 
545  quality = sd ? AV_RL32(sd) : -1;
546  pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
547 
548  atomic_store(&ost->quality, quality);
549 
550  if ((enc->flags & AV_CODEC_FLAG_PSNR) && sd && sd[5]) {
551  // FIXME the scaling assumes 8bit
552  double error = AV_RL64(sd + 8) / (enc->width * enc->height * 255.0 * 255.0);
553  if (error >= 0 && error <= 1)
554  psnr_val = psnr(error);
555  }
556 
557  if (!write_vstats)
558  return 0;
559 
560  /* this is executed just the first time update_video_stats is called */
561  if (!vstats_file) {
562  vstats_file = fopen(vstats_filename, "w");
563  if (!vstats_file) {
564  perror("fopen");
565  return AVERROR(errno);
566  }
567  }
568 
569  frame_number = e->packets_encoded;
570  if (vstats_version <= 1) {
571  fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number,
572  quality / (float)FF_QP2LAMBDA);
573  } else {
574  fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ",
575  ost->file->index, ost->index, frame_number,
576  quality / (float)FF_QP2LAMBDA);
577  }
578 
579  if (psnr_val >= 0)
580  fprintf(vstats_file, "PSNR= %6.2f ", psnr_val);
581 
582  fprintf(vstats_file,"f_size= %6d ", pkt->size);
583  /* compute pts value */
584  ti1 = pkt->dts * av_q2d(pkt->time_base);
585  if (ti1 < 0.01)
586  ti1 = 0.01;
587 
588  bitrate = (pkt->size * 8) / av_q2d(enc->time_base) / 1000.0;
589  avg_bitrate = (double)(e->data_size * 8) / ti1 / 1000.0;
590  fprintf(vstats_file, "s_size= %8.0fKiB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
591  (double)e->data_size / 1024, ti1, bitrate, avg_bitrate);
592  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(pict_type));
593 
594  return 0;
595 }
596 
597  static int encode_frame(OutputFile *of, OutputStream *ost, AVFrame *frame,
598  AVPacket *pkt)
599 {
600  Encoder *e = ost->enc;
601  AVCodecContext *enc = ost->enc_ctx;
602  const char *type_desc = av_get_media_type_string(enc->codec_type);
603  const char *action = frame ? "encode" : "flush";
604  int ret;
605 
606  if (frame) {
607  FrameData *fd = frame_data(frame);
608 
609  if (!fd)
610  return AVERROR(ENOMEM);
611 
612  fd->wallclock[LATENCY_PROBE_ENC_PRE] = av_gettime_relative();
613 
614  if (ost->enc_stats_pre.io)
615  enc_stats_write(ost, &ost->enc_stats_pre, frame, NULL,
616  ost->frames_encoded);
617 
618  ost->frames_encoded++;
619  ost->samples_encoded += frame->nb_samples;
620 
621  if (debug_ts) {
622  av_log(ost, AV_LOG_INFO, "encoder <- type:%s "
623  "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
624  type_desc,
625  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
626  enc->time_base.num, enc->time_base.den);
627  }
628 
629  if (frame->sample_aspect_ratio.num && !ost->frame_aspect_ratio.num)
630  enc->sample_aspect_ratio = frame->sample_aspect_ratio;
631  }
632 
633  update_benchmark(NULL);
634 
635  ret = avcodec_send_frame(enc, frame);
636  if (ret < 0 && !(ret == AVERROR_EOF && !frame)) {
637  av_log(ost, AV_LOG_ERROR, "Error submitting %s frame to the encoder\n",
638  type_desc);
639  return ret;
640  }
641 
642  while (1) {
643  FrameData *fd;
644 
645  av_packet_unref(pkt);
646 
647  ret = avcodec_receive_packet(enc, pkt);
648  update_benchmark("%s_%s %d.%d", action, type_desc,
649  of->index, ost->index);
650 
651  pkt->time_base = enc->time_base;
652 
653  /* if two pass, output log on success and EOF */
654  if ((ret >= 0 || ret == AVERROR_EOF) && ost->logfile && enc->stats_out)
655  fprintf(ost->logfile, "%s", enc->stats_out);
656 
657  if (ret == AVERROR(EAGAIN)) {
658  av_assert0(frame); // should never happen during flushing
659  return 0;
660  } else if (ret < 0) {
661  if (ret != AVERROR_EOF)
662  av_log(ost, AV_LOG_ERROR, "%s encoding failed\n", type_desc);
663  return ret;
664  }
665 
666  fd = packet_data(pkt);
667  if (!fd)
668  return AVERROR(ENOMEM);
669  fd->wallclock[LATENCY_PROBE_ENC_POST] = av_gettime_relative();
670 
671  // attach stream parameters to first packet if requested
672  avcodec_parameters_free(&fd->par_enc);
673  if (e->attach_par && !e->packets_encoded) {
674  fd->par_enc = avcodec_parameters_alloc();
675  if (!fd->par_enc)
676  return AVERROR(ENOMEM);
677 
678  ret = avcodec_parameters_from_context(fd->par_enc, enc);
679  if (ret < 0)
680  return ret;
681  }
682 
683  pkt->flags |= AV_PKT_FLAG_TRUSTED;
684 
685  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
686  ret = update_video_stats(ost, pkt, !!vstats_filename);
687  if (ret < 0)
688  return ret;
689  }
690 
691  if (ost->enc_stats_post.io)
692  enc_stats_write(ost, &ost->enc_stats_post, NULL, pkt,
693  e->packets_encoded);
694 
695  if (debug_ts) {
696  av_log(ost, AV_LOG_INFO, "encoder -> type:%s "
697  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s "
698  "duration:%s duration_time:%s\n",
699  type_desc,
700  av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &enc->time_base),
701  av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &enc->time_base),
702  av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &enc->time_base));
703  }
704 
705  e->data_size += pkt->size;
706 
707  e->packets_encoded++;
708 
709  ret = sch_enc_send(e->sch, e->sch_idx, pkt);
710  if (ret < 0) {
711  av_packet_unref(pkt);
712  return ret;
713  }
714  }
715 
716  av_assert0(0);
717 }
718 
719  static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf,
720  const AVFrame *frame)
721 {
722  double pts_time;
723 
724  if (kf->ref_pts == AV_NOPTS_VALUE)
725  kf->ref_pts = frame->pts;
726 
727  pts_time = (frame->pts - kf->ref_pts) * av_q2d(frame->time_base);
728  if (kf->index < kf->nb_pts &&
729  av_compare_ts(frame->pts, frame->time_base, kf->pts[kf->index], AV_TIME_BASE_Q) >= 0) {
730  kf->index++;
731  goto force_keyframe;
732  } else if (kf->pexpr) {
733  double res;
734  kf->expr_const_values[FKF_T] = pts_time;
735  res = av_expr_eval(kf->pexpr,
736  kf->expr_const_values, NULL);
737  av_log(logctx, AV_LOG_TRACE,
738  "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
739  kf->expr_const_values[FKF_N],
740  kf->expr_const_values[FKF_N_FORCED],
741  kf->expr_const_values[FKF_PREV_FORCED_N],
742  kf->expr_const_values[FKF_T],
743  kf->expr_const_values[FKF_PREV_FORCED_T],
744  res);
745 
746  kf->expr_const_values[FKF_N] += 1;
747 
748  if (res) {
749  kf->expr_const_values[FKF_PREV_FORCED_N] = kf->expr_const_values[FKF_N] - 1;
750  kf->expr_const_values[FKF_PREV_FORCED_T] = kf->expr_const_values[FKF_T];
751  kf->expr_const_values[FKF_N_FORCED] += 1;
752  goto force_keyframe;
753  }
754  } else if (kf->type == KF_FORCE_SOURCE && (frame->flags & AV_FRAME_FLAG_KEY)) {
755  goto force_keyframe;
756  }
757 
758  return AV_PICTURE_TYPE_NONE;
759 
760 force_keyframe:
761  av_log(logctx, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
762  return AV_PICTURE_TYPE_I;
763 }
764 
765  static int frame_encode(OutputStream *ost, AVFrame *frame, AVPacket *pkt)
766 {
767  OutputFile *of = ost->file;
768  enum AVMediaType type = ost->type;
769 
770  if (type == AVMEDIA_TYPE_SUBTITLE) {
771  const AVSubtitle *subtitle = frame && frame->buf[0] ?
772  (AVSubtitle*)frame->buf[0]->data : NULL;
773 
774  // no flushing for subtitles
775  return subtitle && subtitle->num_rects ?
776  do_subtitle_out(of, ost, subtitle, pkt) : 0;
777  }
778 
779  if (frame) {
780  if (!check_recording_time(ost, frame->pts, frame->time_base))
781  return AVERROR_EOF;
782 
783  if (type == AVMEDIA_TYPE_VIDEO) {
784  frame->quality = ost->enc_ctx->global_quality;
785  frame->pict_type = forced_kf_apply(ost, &ost->kf, frame);
786 
787 #if FFMPEG_OPT_TOP
788  if (ost->top_field_first >= 0) {
789  frame->flags &= ~AV_FRAME_FLAG_TOP_FIELD_FIRST;
790  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * (!!ost->top_field_first);
791  }
792 #endif
793  } else {
794  if (!(ost->enc_ctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
795  ost->enc_ctx->ch_layout.nb_channels != frame->ch_layout.nb_channels) {
796  av_log(ost, AV_LOG_ERROR,
797  "Audio channel count changed and encoder does not support parameter changes\n");
798  return 0;
799  }
800  }
801  }
802 
803  return encode_frame(of, ost, frame, pkt);
804 }
805 
806  static void enc_thread_set_name(const OutputStream *ost)
807 {
808  char name[16];
809  snprintf(name, sizeof(name), "enc%d:%d:%s", ost->file->index, ost->index,
810  ost->enc_ctx->codec->name);
811  ff_thread_setname(name);
812 }
813 
814  static void enc_thread_uninit(EncoderThread *et)
815 {
816  av_packet_free(&et->pkt);
817  av_frame_free(&et->frame);
818 
819  memset(et, 0, sizeof(*et));
820 }
821 
822  static int enc_thread_init(EncoderThread *et)
823 {
824  memset(et, 0, sizeof(*et));
825 
826  et->frame = av_frame_alloc();
827  if (!et->frame)
828  goto fail;
829 
830  et->pkt = av_packet_alloc();
831  if (!et->pkt)
832  goto fail;
833 
834  return 0;
835 
836 fail:
837  enc_thread_uninit(et);
838  return AVERROR(ENOMEM);
839 }
840 
841  int encoder_thread(void *arg)
842 {
843  OutputStream *ost = arg;
844  Encoder *e = ost->enc;
845  EncoderThread et;
846  int ret = 0, input_status = 0;
847  int name_set = 0;
848 
849  ret = enc_thread_init(&et);
850  if (ret < 0)
851  goto finish;
852 
853  /* Open the subtitle encoders immediately. AVFrame-based encoders
854  * are opened through a callback from the scheduler once they get
855  * their first frame
856  *
857  * N.B.: because the callback is called from a different thread,
858  * enc_ctx MUST NOT be accessed before sch_enc_receive() returns
859  * for the first time for audio/video. */
860  if (ost->type != AVMEDIA_TYPE_VIDEO && ost->type != AVMEDIA_TYPE_AUDIO) {
861  ret = enc_open(ost, NULL);
862  if (ret < 0)
863  goto finish;
864  }
865 
866  while (!input_status) {
867  input_status = sch_enc_receive(e->sch, e->sch_idx, et.frame);
868  if (input_status < 0) {
869  if (input_status == AVERROR_EOF) {
870  av_log(ost, AV_LOG_VERBOSE, "Encoder thread received EOF\n");
871  if (e->opened)
872  break;
873 
874  av_log(ost, AV_LOG_ERROR, "Could not open encoder before EOF\n");
875  ret = AVERROR(EINVAL);
876  } else {
877  av_log(ost, AV_LOG_ERROR, "Error receiving a frame for encoding: %s\n",
878  av_err2str(ret));
879  ret = input_status;
880  }
881  goto finish;
882  }
883 
884  if (!name_set) {
885  enc_thread_set_name(ost);
886  name_set = 1;
887  }
888 
889  ret = frame_encode(ost, et.frame, et.pkt);
890 
891  av_packet_unref(et.pkt);
892  av_frame_unref(et.frame);
893 
894  if (ret < 0) {
895  if (ret == AVERROR_EOF)
896  av_log(ost, AV_LOG_VERBOSE, "Encoder returned EOF, finishing\n");
897  else
898  av_log(ost, AV_LOG_ERROR, "Error encoding a frame: %s\n",
899  av_err2str(ret));
900  break;
901  }
902  }
903 
904  // flush the encoder
905  if (ret == 0 || ret == AVERROR_EOF) {
906  ret = frame_encode(ost, NULL, et.pkt);
907  if (ret < 0 && ret != AVERROR_EOF)
908  av_log(ost, AV_LOG_ERROR, "Error flushing encoder: %s\n",
909  av_err2str(ret));
910  }
911 
912  // EOF is normal thread termination
913  if (ret == AVERROR_EOF)
914  ret = 0;
915 
916 finish:
917  enc_thread_uninit(&et);
918 
919  return ret;
920 }
921 
922  int enc_loopback(Encoder *enc)
923 {
924  enc->attach_par = 1;
925  return enc->sch_idx;
926 }
frame_samples
static int frame_samples(const SyncQueue *sq, SyncQueueFrame frame)
Definition: sync_queue.c:141
error
static void error(const char *err)
Definition: target_bsf_fuzzer.c:32
AVSubtitle
Definition: avcodec.h:2238
KeyframeForceCtx::pts
int64_t * pts
Definition: ffmpeg.h:568
Decoder::subtitle_header
const uint8_t * subtitle_header
Definition: ffmpeg.h:423
avcodec_encode_subtitle
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: encode.c:191
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:692
AVCodec
AVCodec.
Definition: codec.h:187
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
AVERROR_EXPERIMENTAL
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it.
Definition: error.h:74
INFINITY
#define INFINITY
Definition: mathematics.h:118
FKF_PREV_FORCED_T
@ FKF_PREV_FORCED_T
Definition: ffmpeg.h:501
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
avcodec_receive_packet
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:541
Encoder::opened
int opened
Definition: ffmpeg_enc.c:48
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
AVSubtitle::rects
AVSubtitleRect ** rects
Definition: avcodec.h:2243
LIBAVCODEC_IDENT
#define LIBAVCODEC_IDENT
Definition: version.h:43
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
AVCodecContext::colorspace
enum AVColorSpace colorspace
YUV colorspace type.
Definition: avcodec.h:691
FrameData
Definition: ffmpeg.h:673
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2087
ENC_STATS_PTS
@ ENC_STATS_PTS
Definition: ffmpeg.h:517
ENC_STATS_FRAME_NUM_IN
@ ENC_STATS_FRAME_NUM_IN
Definition: ffmpeg.h:514
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
FKF_PREV_FORCED_N
@ FKF_PREV_FORCED_N
Definition: ffmpeg.h:500
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:129
AV_RL64
uint64_t_TMPL AV_RL64
Definition: bytestream.h:91
av_pix_fmt_desc_get
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2965
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ENC_STATS_DTS
@ ENC_STATS_DTS
Definition: ffmpeg.h:521
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:202
AVPictureType
AVPictureType
Definition: avutil.h:277
KeyframeForceCtx::nb_pts
int nb_pts
Definition: ffmpeg.h:569
rational.h
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2242
ENC_STATS_AVG_BITRATE
@ ENC_STATS_AVG_BITRATE
Definition: ffmpeg.h:527
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:162
OutputFile::start_time
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:667
Encoder::sch
Scheduler * sch
Definition: ffmpeg_enc.c:51
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:389
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:684
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
FKF_T
@ FKF_T
Definition: ffmpeg.h:502
AVPacket::data
uint8_t * data
Definition: packet.h:539
ENC_STATS_LITERAL
@ ENC_STATS_LITERAL
Definition: ffmpeg.h:510
AVComponentDescriptor::depth
int depth
Number of bits in the component.
Definition: pixdesc.h:57
AVCodecContext::field_order
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:714
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
KeyframeForceCtx::type
int type
Definition: ffmpeg.h:563
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1902
forced_kf_apply
static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf, const AVFrame *frame)
Definition: ffmpeg_enc.c:719
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
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
AV_CODEC_FLAG_PSNR
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:326
HWDevice
Definition: ffmpeg.h:109
av_buffer_ref
AVBufferRef * av_buffer_ref(const AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:103
av_frame_side_data_clone
int av_frame_side_data_clone(AVFrameSideData ***sd, int *nb_sd, const AVFrameSideData *src, unsigned int flags)
Add a new side data entry to an array based on existing side data, taking a reference towards the con...
Definition: frame.c:876
LATENCY_PROBE_ENC_POST
@ LATENCY_PROBE_ENC_POST
Definition: ffmpeg.h:105
set_encoder_id
static int set_encoder_id(OutputFile *of, OutputStream *ost)
Definition: ffmpeg_enc.c:140
AV_CODEC_FLAG_INTERLACED_ME
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:351
psnr
static double psnr(double d)
Definition: ffmpeg_enc.c:528
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
tf_sess_config.config
config
Definition: tf_sess_config.py:33
AV_PKT_FLAG_KEY
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: packet.h:594
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
quality
trying all byte sequences megabyte in length and selecting the best looking sequence will yield cases to try But a word about quality
Definition: rate_distortion.txt:12
encode_frame
static int encode_frame(OutputFile *of, OutputStream *ost, AVFrame *frame, AVPacket *pkt)
Definition: ffmpeg_enc.c:597
ENC_STATS_TIMEBASE_IN
@ ENC_STATS_TIMEBASE_IN
Definition: ffmpeg.h:516
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:206
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
FrameData::frame_num
uint64_t frame_num
Definition: ffmpeg.h:680
InputStream
Definition: ffmpeg.h:432
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:566
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:70
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:203
AV_CODEC_ID_ASS
@ AV_CODEC_ID_ASS
Definition: codec_id.h:572
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:374
vstats_version
int vstats_version
Definition: ffmpeg_opt.c:78
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
av_shrink_packet
void av_shrink_packet(AVPacket *pkt, int size)
Reduce packet size, correctly zeroing padding.
Definition: packet.c:113
AVCodecContext::flags
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:508
KeyframeForceCtx::ref_pts
int64_t ref_pts
Definition: ffmpeg.h:565
Encoder::attach_par
int attach_par
Definition: ffmpeg_enc.c:49
update_benchmark
void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:527
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_FRAMES_CTX
The codec supports this format via the hw_frames_ctx interface.
Definition: codec.h:326
pts
static int64_t pts
Definition: transcode_aac.c:644
FrameData::tb
AVRational tb
Definition: ffmpeg.h:683
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:205
AV_CODEC_FLAG_INTERLACED_DCT
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:330
AV_DICT_DONT_STRDUP_VAL
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that's been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:79
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:150
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
enc_thread_uninit
static void enc_thread_uninit(EncoderThread *et)
Definition: ffmpeg_enc.c:814
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:677
FrameData::frame_rate_filter
AVRational frame_rate_filter
Definition: ffmpeg.h:686
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:206
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:180
AV_FRAME_SIDE_DATA_FLAG_UNIQUE
#define AV_FRAME_SIDE_DATA_FLAG_UNIQUE
Remove existing entries before adding new ones.
Definition: frame.h:1060
encoder_thread
int encoder_thread(void *arg)
Definition: ffmpeg_enc.c:841
ENC_STATS_PTS_IN
@ ENC_STATS_PTS_IN
Definition: ffmpeg.h:519
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:640
duration
int64_t duration
Definition: movenc.c:65
av_dict_get
AVDictionaryEntry * av_dict_get(const AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:62
EncStats::components
EncStatsComponent * components
Definition: ffmpeg.h:539
intreadwrite.h
av_new_packet
int av_new_packet(AVPacket *pkt, int size)
Allocate the payload of a packet and initialize its fields with default values.
Definition: packet.c:98
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:53
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2088
bitrate
int64_t bitrate
Definition: av1_levels.c:47
ENC_STATS_FILE_IDX
@ ENC_STATS_FILE_IDX
Definition: ffmpeg.h:511
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
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
ENC_STATS_BITRATE
@ ENC_STATS_BITRATE
Definition: ffmpeg.h:526
Encoder::data_size
uint64_t data_size
Definition: ffmpeg_enc.c:43
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
LATENCY_PROBE_ENC_PRE
@ LATENCY_PROBE_ENC_PRE
Definition: ffmpeg.h:104
AVCodecContext::bits_per_raw_sample
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:1585
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
enc_stats_write
void enc_stats_write(OutputStream *ost, EncStats *es, const AVFrame *frame, const AVPacket *pkt, uint64_t frame_num)
Definition: ffmpeg_enc.c:455
FrameData::dec
struct FrameData::@4 dec
av_expr_eval
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:792
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
KF_FORCE_SOURCE
@ KF_FORCE_SOURCE
Definition: ffmpeg.h:556
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2244
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:112
AV_CODEC_ID_CODEC2
@ AV_CODEC_ID_CODEC2
Definition: codec_id.h:507
sch_enc_receive
int sch_enc_receive(Scheduler *sch, unsigned enc_idx, AVFrame *frame)
Called by encoder tasks to obtain frames for encoding.
Definition: ffmpeg_sched.c:2282
AV_SIDE_DATA_PROP_GLOBAL
@ AV_SIDE_DATA_PROP_GLOBAL
The side data type can be used in stream-global structures.
Definition: frame.h:279
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:461
arg
const char * arg
Definition: jacosubdec.c:67
KeyframeForceCtx::expr_const_values
double expr_const_values[FKF_NB]
Definition: ffmpeg.h:573
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:223
ENC_STATS_KEYFRAME
@ ENC_STATS_KEYFRAME
Definition: ffmpeg.h:528
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:787
NULL
#define NULL
Definition: coverity.c:32
frame_encode
static int frame_encode(OutputStream *ost, AVFrame *frame, AVPacket *pkt)
Definition: ffmpeg_enc.c:765
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:701
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
AVCodec::type
enum AVMediaType type
Definition: codec.h:200
Decoder
Definition: ffmpeg.h:418
ENC_STATS_PTS_TIME
@ ENC_STATS_PTS_TIME
Definition: ffmpeg.h:518
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
EncStats::lock
pthread_mutex_t lock
Definition: ffmpeg.h:544
AV_PICTURE_TYPE_I
@ AV_PICTURE_TYPE_I
Intra.
Definition: avutil.h:279
AVCodecContext::subtitle_header_size
int subtitle_header_size
Header containing style information for text subtitles.
Definition: avcodec.h:1901
EncStats
Definition: ffmpeg.h:538
vstats_file
FILE * vstats_file
Definition: ffmpeg.c:88
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:690
double
double
Definition: af_crystalizer.c:132
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
avcodec_open2
int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: avcodec.c:143
time.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
@ AV_CODEC_HW_CONFIG_METHOD_HW_DEVICE_CTX
The codec supports this format via the hw_device_ctx interface.
Definition: codec.h:313
OutputFile::index
int index
Definition: ffmpeg.h:659
EncoderThread::pkt
AVPacket * pkt
Definition: ffmpeg_enc.c:58
ENC_STATS_PTS_TIME_IN
@ ENC_STATS_PTS_TIME_IN
Definition: ffmpeg.h:520
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
sch_enc_send
int sch_enc_send(Scheduler *sch, unsigned enc_idx, AVPacket *pkt)
Called by encoder tasks to send encoded packets downstream.
Definition: ffmpeg_sched.c:2326
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:82
enc_loopback
int enc_loopback(Encoder *enc)
Definition: ffmpeg_enc.c:922
Scheduler
Definition: ffmpeg_sched.c:275
enc_thread_init
static int enc_thread_init(EncoderThread *et)
Definition: ffmpeg_enc.c:822
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
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1344
eval.h
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:540
FFMPEG_OPT_TOP
#define FFMPEG_OPT_TOP
Definition: ffmpeg.h:57
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
for
for(k=2;k<=8;++k)
Definition: h264pred_template.c:425
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
ENC_STATS_NB_SAMPLES
@ ENC_STATS_NB_SAMPLES
Definition: ffmpeg.h:524
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
HWDevice::device_ref
AVBufferRef * device_ref
Definition: ffmpeg.h:112
hw_device_get_by_type
HWDevice * hw_device_get_by_type(enum AVHWDeviceType type)
Definition: ffmpeg_hw.c:28
AV_PICTURE_TYPE_NONE
@ AV_PICTURE_TYPE_NONE
Undefined.
Definition: avutil.h:278
frame_data
FrameData * frame_data(AVFrame *frame)
Get our axiliary frame data attached to the frame, allocating it if needed.
Definition: ffmpeg.c:453
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:826
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2241
frame.h
enc_alloc
int enc_alloc(Encoder **penc, const AVCodec *codec, Scheduler *sch, unsigned sch_idx)
Definition: ffmpeg_enc.c:71
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
FrameData::pts
int64_t pts
Definition: ffmpeg.h:682
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
Encoder
Definition: ffmpeg_enc.c:41
ENC_STATS_FRAME_NUM
@ ENC_STATS_FRAME_NUM
Definition: ffmpeg.h:513
KeyframeForceCtx
Definition: ffmpeg.h:562
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
enc_thread_set_name
static void enc_thread_set_name(const OutputStream *ost)
Definition: ffmpeg_enc.c:806
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
av_get_picture_type_char
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:40
AV_CODEC_ID_MJPEG
@ AV_CODEC_ID_MJPEG
Definition: codec_id.h:59
log.h
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
FrameData::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffmpeg.h:688
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
av_packet_get_side_data
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, size_t *size)
Get side information from packet.
Definition: packet.c:252
OutputFile::bitexact
int bitexact
Definition: ffmpeg.h:669
display.h
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:204
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:71
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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
AVCodecContext::chroma_sample_location
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:708
ENC_STATS_STREAM_IDX
@ ENC_STATS_STREAM_IDX
Definition: ffmpeg.h:512
AVCodecContext::height
int height
Definition: avcodec.h:624
avcodec_send_frame
int 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
ENC_STATS_SAMPLE_NUM
@ ENC_STATS_SAMPLE_NUM
Definition: ffmpeg.h:523
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
InputStream::decoder
Decoder * decoder
Definition: ffmpeg.h:449
ret
ret
Definition: filter_design.txt:187
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
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_strlcat
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes,...
Definition: avstring.c:95
hw_device_setup_for_encode
static int hw_device_setup_for_encode(OutputStream *ost, AVBufferRef *frames_ref)
Definition: ffmpeg_enc.c:90
EncoderThread::frame
AVFrame * frame
Definition: ffmpeg_enc.c:57
dict.h
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
avio_printf
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
Writes a formatted string to the context.
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVCodecContext
main external API structure.
Definition: avcodec.h:451
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
HWDevice::name
const char * name
Definition: ffmpeg.h:110
Encoder::sch_idx
unsigned sch_idx
Definition: ffmpeg_enc.c:52
enc_open
int enc_open(void *opaque, const AVFrame *frame)
Definition: ffmpeg_enc.c:165
AVRational::den
int den
Denominator.
Definition: rational.h:60
KeyframeForceCtx::index
int index
Definition: ffmpeg.h:570
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
do_subtitle_out
static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub, AVPacket *pkt)
Definition: ffmpeg_enc.c:368
AVPixFmtDescriptor::comp
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:105
Decoder::subtitle_header_size
int subtitle_header_size
Definition: ffmpeg.h:424
check_recording_time
static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
Definition: ffmpeg_enc.c:357
AVSideDataDescriptor
This struct describes the properties of a side data type.
Definition: frame.h:292
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:833
enc_free
void enc_free(Encoder **penc)
Definition: ffmpeg_enc.c:61
AV_CODEC_CAP_PARAM_CHANGE
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: codec.h:118
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
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:459
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
avutil.h
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
AV_CODEC_FLAG_BITEXACT
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:342
avcodec_parameters_from_context
int avcodec_parameters_from_context(struct AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: codec_par.c:137
KeyframeForceCtx::pexpr
AVExpr * pexpr
Definition: ffmpeg.h:572
FKF_N_FORCED
@ FKF_N_FORCED
Definition: ffmpeg.h:499
av_add_q
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
av_frame_side_data_desc
const AVSideDataDescriptor * av_frame_side_data_desc(enum AVFrameSideDataType type)
Definition: frame.c:1022
AVPacket
This structure stores compressed data.
Definition: packet.h:516
EncStatsComponent
Definition: ffmpeg.h:531
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:88
HWDevice::type
enum AVHWDeviceType type
Definition: ffmpeg.h:111
EncStats::nb_components
int nb_components
Definition: ffmpeg.h:540
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:465
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:624
ENC_STATS_PKT_SIZE
@ ENC_STATS_PKT_SIZE
Definition: ffmpeg.h:525
timestamp.h
OutputStream
Definition: mux.c:53
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:85
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
AVCodecHWConfig
Definition: codec.h:345
avstring.h
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
FKF_N
@ FKF_N
Definition: ffmpeg.h:498
ENC_STATS_DTS_TIME
@ ENC_STATS_DTS_TIME
Definition: ffmpeg.h:522
OutputFile::recording_time
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:666
of_stream_init
int of_stream_init(OutputFile *of, OutputStream *ost)
Definition: ffmpeg_mux.c:611
AV_PKT_FLAG_TRUSTED
#define AV_PKT_FLAG_TRUSTED
The packet comes from a trusted source.
Definition: packet.h:608
snprintf
#define snprintf
Definition: snprintf.h:34
EncStats::io
AVIOContext * io
Definition: ffmpeg.h:542
update_video_stats
static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
Definition: ffmpeg_enc.c:533
AVCodecContext::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel.
Definition: avcodec.h:648
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2240
ENC_STATS_TIMEBASE
@ ENC_STATS_TIMEBASE
Definition: ffmpeg.h:515
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:583
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:2885
EncoderThread
Definition: ffmpeg_enc.c:56
OutputFile
Definition: ffmpeg.h:656
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:78
Encoder::packets_encoded
uint64_t packets_encoded
Definition: ffmpeg_enc.c:46
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216
Generated on Fri Aug 22 2025 13:58:03 for FFmpeg by   doxygen 1.8.17

AltStyle によって変換されたページ (->オリジナル) /