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;
50 
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 {
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 
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 &&
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 &&
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 
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,
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;
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
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 
195  &enc_ctx->nb_decoded_side_data,
196  frame->side_data[i],
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;
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
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;
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
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 
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
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
279 
280  break;
281  }
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);
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 (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
311  av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
312 
314  ret = av_dict_set(&ost->encoder_opts, "flags", "+copy_opaque", AV_DICT_MULTIKEY);
315  if (ret < 0)
316  return ret;
317  }
318 
319  av_dict_set(&ost->encoder_opts, "flags", "+frame_duration", AV_DICT_MULTIKEY);
320 
321  ret = hw_device_setup_for_encode(ost, frame ? frame->hw_frames_ctx : NULL);
322  if (ret < 0) {
324  "Encoding hardware device setup failed: %s\n", av_err2str(ret));
325  return ret;
326  }
327 
328  if ((ret = avcodec_open2(ost->enc_ctx, enc, &ost->encoder_opts)) < 0) {
329  if (ret != AVERROR_EXPERIMENTAL)
330  av_log(ost, AV_LOG_ERROR, "Error while opening encoder - maybe "
331  "incorrect parameters such as bit_rate, rate, width or height.\n");
332  return ret;
333  }
334 
335  e->opened = 1;
336 
337  if (ost->enc_ctx->frame_size)
338  frame_samples = ost->enc_ctx->frame_size;
339 
340  ret = check_avoptions(ost->encoder_opts);
341  if (ret < 0)
342  return ret;
343 
344  if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
345  ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
346  av_log(ost, AV_LOG_WARNING, "The bitrate parameter is set too low."
347  " It takes bits/s as argument, not kbits/s\n");
348 
349  ret = avcodec_parameters_from_context(ost->par_in, ost->enc_ctx);
350  if (ret < 0) {
352  "Error initializing the output stream codec context.\n");
353  return ret;
354  }
355 
356  // copy timebase while removing common factors
357  if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
358  ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
359 
360  ret = of_stream_init(of, ost);
361  if (ret < 0)
362  return ret;
363 
364  return frame_samples;
365 }
366 
368 {
369  OutputFile *of = ost->file;
370 
371  if (of->recording_time != INT64_MAX &&
372  av_compare_ts(ts, tb, of->recording_time, AV_TIME_BASE_Q) >= 0) {
373  return 0;
374  }
375  return 1;
376 }
377 
378 static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub,
379  AVPacket *pkt)
380 {
381  Encoder *e = ost->enc;
382  int subtitle_out_max_size = 1024 * 1024;
383  int subtitle_out_size, nb, i, ret;
384  AVCodecContext *enc;
385  int64_t pts;
386 
387  if (sub->pts == AV_NOPTS_VALUE) {
388  av_log(ost, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
389  return exit_on_error ? AVERROR(EINVAL) : 0;
390  }
391  if ((of->start_time != AV_NOPTS_VALUE && sub->pts < of->start_time))
392  return 0;
393 
394  enc = ost->enc_ctx;
395 
396  /* Note: DVB subtitle need one packet to draw them and one other
397  packet to clear them */
398  /* XXX: signal it in the codec context ? */
400  nb = 2;
401  else if (enc->codec_id == AV_CODEC_ID_ASS)
402  nb = FFMAX(sub->num_rects, 1);
403  else
404  nb = 1;
405 
406  /* shift timestamp to honor -ss and make check_recording_time() work with -t */
407  pts = sub->pts;
408  if (of->start_time != AV_NOPTS_VALUE)
409  pts -= of->start_time;
410  for (i = 0; i < nb; i++) {
411  AVSubtitle local_sub = *sub;
412 
414  return AVERROR_EOF;
415 
416  ret = av_new_packet(pkt, subtitle_out_max_size);
417  if (ret < 0)
418  return AVERROR(ENOMEM);
419 
420  local_sub.pts = pts;
421  // start_display_time is required to be 0
422  local_sub.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
423  local_sub.end_display_time -= sub->start_display_time;
424  local_sub.start_display_time = 0;
425 
426  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE && i == 1)
427  local_sub.num_rects = 0;
428  else if (enc->codec_id == AV_CODEC_ID_ASS && sub->num_rects > 0) {
429  local_sub.num_rects = 1;
430  local_sub.rects += i;
431  }
432 
433  ost->frames_encoded++;
434 
435  subtitle_out_size = avcodec_encode_subtitle(enc, pkt->data, pkt->size, &local_sub);
436  if (subtitle_out_size < 0) {
437  av_log(ost, AV_LOG_FATAL, "Subtitle encoding failed\n");
438  return subtitle_out_size;
439  }
440 
441  av_shrink_packet(pkt, subtitle_out_size);
443  pkt->pts = sub->pts;
445  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
446  /* XXX: the pts correction is handled here. Maybe handling
447  it in the codec would be better */
448  if (i == 0)
449  pkt->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
450  else
451  pkt->pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
452  }
453  pkt->dts = pkt->pts;
454 
455  ret = sch_enc_send(e->sch, e->sch_idx, pkt);
456  if (ret < 0) {
458  return ret;
459  }
460  }
461 
462  return 0;
463 }
464 
466  const AVFrame *frame, const AVPacket *pkt,
467  uint64_t frame_num)
468 {
469  Encoder *e = ost->enc;
470  AVIOContext *io = es->io;
471  AVRational tb = frame ? frame->time_base : pkt->time_base;
472  int64_t pts = frame ? frame->pts : pkt->pts;
473 
474  AVRational tbi = (AVRational){ 0, 1};
475  int64_t ptsi = INT64_MAX;
476 
477  const FrameData *fd;
478 
479  if ((frame && frame->opaque_ref) || (pkt && pkt->opaque_ref)) {
480  fd = (const FrameData*)(frame ? frame->opaque_ref->data : pkt->opaque_ref->data);
481  tbi = fd->dec.tb;
482  ptsi = fd->dec.pts;
483  }
484 
485  pthread_mutex_lock(&es->lock);
486 
487  for (size_t i = 0; i < es->nb_components; i++) {
488  const EncStatsComponent *c = &es->components[i];
489 
490  switch (c->type) {
491  case ENC_STATS_LITERAL: avio_write (io, c->str, c->str_len); continue;
492  case ENC_STATS_FILE_IDX: avio_printf(io, "%d", ost->file->index); continue;
493  case ENC_STATS_STREAM_IDX: avio_printf(io, "%d", ost->index); continue;
494  case ENC_STATS_TIMEBASE: avio_printf(io, "%d/%d", tb.num, tb.den); continue;
495  case ENC_STATS_TIMEBASE_IN: avio_printf(io, "%d/%d", tbi.num, tbi.den); continue;
496  case ENC_STATS_PTS: avio_printf(io, "%"PRId64, pts); continue;
497  case ENC_STATS_PTS_IN: avio_printf(io, "%"PRId64, ptsi); continue;
498  case ENC_STATS_PTS_TIME: avio_printf(io, "%g", pts * av_q2d(tb)); continue;
499  case ENC_STATS_PTS_TIME_IN: avio_printf(io, "%g", ptsi == INT64_MAX ?
500  INFINITY : ptsi * av_q2d(tbi)); continue;
501  case ENC_STATS_FRAME_NUM: avio_printf(io, "%"PRIu64, frame_num); continue;
502  case ENC_STATS_FRAME_NUM_IN: avio_printf(io, "%"PRIu64, fd ? fd->dec.frame_num : -1); continue;
503  }
504 
505  if (frame) {
506  switch (c->type) {
507  case ENC_STATS_SAMPLE_NUM: avio_printf(io, "%"PRIu64, ost->samples_encoded); continue;
508  case ENC_STATS_NB_SAMPLES: avio_printf(io, "%d", frame->nb_samples); continue;
509  default: av_assert0(0);
510  }
511  } else {
512  switch (c->type) {
513  case ENC_STATS_DTS: avio_printf(io, "%"PRId64, pkt->dts); continue;
514  case ENC_STATS_DTS_TIME: avio_printf(io, "%g", pkt->dts * av_q2d(tb)); continue;
515  case ENC_STATS_PKT_SIZE: avio_printf(io, "%d", pkt->size); continue;
517  "K" : "N", 1); continue;
518  case ENC_STATS_BITRATE: {
519  double duration = FFMAX(pkt->duration, 1) * av_q2d(tb);
520  avio_printf(io, "%g", 8.0 * pkt->size / duration);
521  continue;
522  }
523  case ENC_STATS_AVG_BITRATE: {
524  double duration = pkt->dts * av_q2d(tb);
525  avio_printf(io, "%g", duration > 0 ? 8.0 * e->data_size / duration : -1.);
526  continue;
527  }
528  default: av_assert0(0);
529  }
530  }
531  }
532  avio_w8(io, '\n');
533  avio_flush(io);
534 
536 }
537 
538 static inline double psnr(double d)
539 {
540  return -10.0 * log10(d);
541 }
542 
543 static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
544 {
545  Encoder *e = ost->enc;
547  NULL);
548  AVCodecContext *enc = ost->enc_ctx;
549  enum AVPictureType pict_type;
550  int64_t frame_number;
551  double ti1, bitrate, avg_bitrate;
552  double psnr_val = -1;
553  int quality;
554 
555  quality = sd ? AV_RL32(sd) : -1;
556  pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
557 
558  atomic_store(&ost->quality, quality);
559 
560  if ((enc->flags & AV_CODEC_FLAG_PSNR) && sd && sd[5]) {
561  // FIXME the scaling assumes 8bit
562  double error = AV_RL64(sd + 8) / (enc->width * enc->height * 255.0 * 255.0);
563  if (error >= 0 && error <= 1)
564  psnr_val = psnr(error);
565  }
566 
567  if (!write_vstats)
568  return 0;
569 
570  /* this is executed just the first time update_video_stats is called */
571  if (!vstats_file) {
572  vstats_file = fopen(vstats_filename, "w");
573  if (!vstats_file) {
574  perror("fopen");
575  return AVERROR(errno);
576  }
577  }
578 
579  frame_number = e->packets_encoded;
580  if (vstats_version <= 1) {
581  fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number,
582  quality / (float)FF_QP2LAMBDA);
583  } else {
584  fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ",
585  ost->file->index, ost->index, frame_number,
586  quality / (float)FF_QP2LAMBDA);
587  }
588 
589  if (psnr_val >= 0)
590  fprintf(vstats_file, "PSNR= %6.2f ", psnr_val);
591 
592  fprintf(vstats_file,"f_size= %6d ", pkt->size);
593  /* compute pts value */
594  ti1 = pkt->dts * av_q2d(pkt->time_base);
595  if (ti1 < 0.01)
596  ti1 = 0.01;
597 
598  bitrate = (pkt->size * 8) / av_q2d(enc->time_base) / 1000.0;
599  avg_bitrate = (double)(e->data_size * 8) / ti1 / 1000.0;
600  fprintf(vstats_file, "s_size= %8.0fKiB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
601  (double)e->data_size / 1024, ti1, bitrate, avg_bitrate);
602  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(pict_type));
603 
604  return 0;
605 }
606 
608  AVPacket *pkt)
609 {
610  Encoder *e = ost->enc;
611  AVCodecContext *enc = ost->enc_ctx;
612  const char *type_desc = av_get_media_type_string(enc->codec_type);
613  const char *action = frame ? "encode" : "flush";
614  int ret;
615 
616  if (frame) {
617  FrameData *fd = frame_data(frame);
618 
619  if (!fd)
620  return AVERROR(ENOMEM);
621 
623 
624  if (ost->enc_stats_pre.io)
625  enc_stats_write(ost, &ost->enc_stats_pre, frame, NULL,
626  ost->frames_encoded);
627 
628  ost->frames_encoded++;
629  ost->samples_encoded += frame->nb_samples;
630 
631  if (debug_ts) {
632  av_log(ost, AV_LOG_INFO, "encoder <- type:%s "
633  "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
634  type_desc,
635  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
636  enc->time_base.num, enc->time_base.den);
637  }
638 
639  if (frame->sample_aspect_ratio.num && !ost->frame_aspect_ratio.num)
640  enc->sample_aspect_ratio = frame->sample_aspect_ratio;
641  }
642 
644 
645  ret = avcodec_send_frame(enc, frame);
646  if (ret < 0 && !(ret == AVERROR_EOF && !frame)) {
647  av_log(ost, AV_LOG_ERROR, "Error submitting %s frame to the encoder\n",
648  type_desc);
649  return ret;
650  }
651 
652  while (1) {
653  FrameData *fd;
654 
656 
658  update_benchmark("%s_%s %d.%d", action, type_desc,
659  of->index, ost->index);
660 
661  pkt->time_base = enc->time_base;
662 
663  /* if two pass, output log on success and EOF */
664  if ((ret >= 0 || ret == AVERROR_EOF) && ost->logfile && enc->stats_out)
665  fprintf(ost->logfile, "%s", enc->stats_out);
666 
667  if (ret == AVERROR(EAGAIN)) {
668  av_assert0(frame); // should never happen during flushing
669  return 0;
670  } else if (ret < 0) {
671  if (ret != AVERROR_EOF)
672  av_log(ost, AV_LOG_ERROR, "%s encoding failed\n", type_desc);
673  return ret;
674  }
675 
676  fd = packet_data(pkt);
677  if (!fd)
678  return AVERROR(ENOMEM);
680 
681  // attach stream parameters to first packet if requested
683  if (e->attach_par && !e->packets_encoded) {
685  if (!fd->par_enc)
686  return AVERROR(ENOMEM);
687 
689  if (ret < 0)
690  return ret;
691  }
692 
694 
695  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
697  if (ret < 0)
698  return ret;
699  }
700 
701  if (ost->enc_stats_post.io)
702  enc_stats_write(ost, &ost->enc_stats_post, NULL, pkt,
703  e->packets_encoded);
704 
705  if (debug_ts) {
706  av_log(ost, AV_LOG_INFO, "encoder -> type:%s "
707  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s "
708  "duration:%s duration_time:%s\n",
709  type_desc,
713  }
714 
715  e->data_size += pkt->size;
716 
717  e->packets_encoded++;
718 
719  ret = sch_enc_send(e->sch, e->sch_idx, pkt);
720  if (ret < 0) {
722  return ret;
723  }
724  }
725 
726  av_assert0(0);
727 }
728 
729 static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf,
730  const AVFrame *frame)
731 {
732  double pts_time;
733 
734  if (kf->ref_pts == AV_NOPTS_VALUE)
735  kf->ref_pts = frame->pts;
736 
737  pts_time = (frame->pts - kf->ref_pts) * av_q2d(frame->time_base);
738  if (kf->index < kf->nb_pts &&
739  av_compare_ts(frame->pts, frame->time_base, kf->pts[kf->index], AV_TIME_BASE_Q) >= 0) {
740  kf->index++;
741  goto force_keyframe;
742  } else if (kf->pexpr) {
743  double res;
744  kf->expr_const_values[FKF_T] = pts_time;
745  res = av_expr_eval(kf->pexpr,
746  kf->expr_const_values, NULL);
747  av_log(logctx, AV_LOG_TRACE,
748  "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
754  res);
755 
756  kf->expr_const_values[FKF_N] += 1;
757 
758  if (res) {
762  goto force_keyframe;
763  }
764  } else if (kf->type == KF_FORCE_SOURCE && (frame->flags & AV_FRAME_FLAG_KEY)) {
765  goto force_keyframe;
766  }
767 
768  return AV_PICTURE_TYPE_NONE;
769 
770 force_keyframe:
771  av_log(logctx, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
772  return AV_PICTURE_TYPE_I;
773 }
774 
776 {
777  OutputFile *of = ost->file;
778  enum AVMediaType type = ost->type;
779 
780  if (type == AVMEDIA_TYPE_SUBTITLE) {
781  const AVSubtitle *subtitle = frame && frame->buf[0] ?
782  (AVSubtitle*)frame->buf[0]->data : NULL;
783 
784  // no flushing for subtitles
785  return subtitle && subtitle->num_rects ?
786  do_subtitle_out(of, ost, subtitle, pkt) : 0;
787  }
788 
789  if (frame) {
790  if (!check_recording_time(ost, frame->pts, frame->time_base))
791  return AVERROR_EOF;
792 
793  if (type == AVMEDIA_TYPE_VIDEO) {
794  frame->quality = ost->enc_ctx->global_quality;
795  frame->pict_type = forced_kf_apply(ost, &ost->kf, frame);
796 
797 #if FFMPEG_OPT_TOP
798  if (ost->top_field_first >= 0) {
800  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * (!!ost->top_field_first);
801  }
802 #endif
803  } else {
804  if (!(ost->enc_ctx->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
805  ost->enc_ctx->ch_layout.nb_channels != frame->ch_layout.nb_channels) {
807  "Audio channel count changed and encoder does not support parameter changes\n");
808  return 0;
809  }
810  }
811  }
812 
813  return encode_frame(of, ost, frame, pkt);
814 }
815 
817 {
818  char name[16];
819  snprintf(name, sizeof(name), "enc%d:%d:%s", ost->file->index, ost->index,
820  ost->enc_ctx->codec->name);
822 }
823 
825 {
826  av_packet_free(&et->pkt);
827  av_frame_free(&et->frame);
828 
829  memset(et, 0, sizeof(*et));
830 }
831 
833 {
834  memset(et, 0, sizeof(*et));
835 
836  et->frame = av_frame_alloc();
837  if (!et->frame)
838  goto fail;
839 
840  et->pkt = av_packet_alloc();
841  if (!et->pkt)
842  goto fail;
843 
844  return 0;
845 
846 fail:
847  enc_thread_uninit(et);
848  return AVERROR(ENOMEM);
849 }
850 
851 int encoder_thread(void *arg)
852 {
853  OutputStream *ost = arg;
854  Encoder *e = ost->enc;
855  EncoderThread et;
856  int ret = 0, input_status = 0;
857  int name_set = 0;
858 
859  ret = enc_thread_init(&et);
860  if (ret < 0)
861  goto finish;
862 
863  /* Open the subtitle encoders immediately. AVFrame-based encoders
864  * are opened through a callback from the scheduler once they get
865  * their first frame
866  *
867  * N.B.: because the callback is called from a different thread,
868  * enc_ctx MUST NOT be accessed before sch_enc_receive() returns
869  * for the first time for audio/video. */
870  if (ost->type != AVMEDIA_TYPE_VIDEO && ost->type != AVMEDIA_TYPE_AUDIO) {
871  ret = enc_open(ost, NULL);
872  if (ret < 0)
873  goto finish;
874  }
875 
876  while (!input_status) {
877  input_status = sch_enc_receive(e->sch, e->sch_idx, et.frame);
878  if (input_status < 0) {
879  if (input_status == AVERROR_EOF) {
880  av_log(ost, AV_LOG_VERBOSE, "Encoder thread received EOF\n");
881  if (e->opened)
882  break;
883 
884  av_log(ost, AV_LOG_ERROR, "Could not open encoder before EOF\n");
885  ret = AVERROR(EINVAL);
886  } else {
887  av_log(ost, AV_LOG_ERROR, "Error receiving a frame for encoding: %s\n",
888  av_err2str(ret));
889  ret = input_status;
890  }
891  goto finish;
892  }
893 
894  if (!name_set) {
896  name_set = 1;
897  }
898 
899  ret = frame_encode(ost, et.frame, et.pkt);
900 
901  av_packet_unref(et.pkt);
902  av_frame_unref(et.frame);
903 
904  if (ret < 0) {
905  if (ret == AVERROR_EOF)
906  av_log(ost, AV_LOG_VERBOSE, "Encoder returned EOF, finishing\n");
907  else
908  av_log(ost, AV_LOG_ERROR, "Error encoding a frame: %s\n",
909  av_err2str(ret));
910  break;
911  }
912  }
913 
914  // flush the encoder
915  if (ret == 0 || ret == AVERROR_EOF) {
916  ret = frame_encode(ost, NULL, et.pkt);
917  if (ret < 0 && ret != AVERROR_EOF)
918  av_log(ost, AV_LOG_ERROR, "Error flushing encoder: %s\n",
919  av_err2str(ret));
920  }
921 
922  // EOF is normal thread termination
923  if (ret == AVERROR_EOF)
924  ret = 0;
925 
926 finish:
927  enc_thread_uninit(&et);
928 
929  return ret;
930 }
931 
933 {
934  enc->attach_par = 1;
935  return enc->sch_idx;
936 }
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:2227
KeyframeForceCtx::pts
int64_t * pts
Definition: ffmpeg.h:530
Decoder::subtitle_header
const uint8_t * subtitle_header
Definition: ffmpeg.h:385
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:427
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:649
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:463
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:2232
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:685
FrameData
Definition: ffmpeg.h:630
AVCodecContext::decoded_side_data
AVFrameSideData ** decoded_side_data
Array containing static side data, such as HDR10 CLL / MDCV structures.
Definition: avcodec.h:2076
ENC_STATS_PTS
@ ENC_STATS_PTS
Definition: ffmpeg.h:479
ENC_STATS_FRAME_NUM_IN
@ ENC_STATS_FRAME_NUM_IN
Definition: ffmpeg.h:476
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1050
FKF_PREV_FORCED_N
@ FKF_PREV_FORCED_N
Definition: ffmpeg.h:462
AV_PKT_DATA_QUALITY_STATS
@ AV_PKT_DATA_QUALITY_STATS
This side data contains quality related information from the encoder.
Definition: packet.h:133
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:483
AV_FIELD_PROGRESSIVE
@ AV_FIELD_PROGRESSIVE
Definition: defs.h:200
AVPictureType
AVPictureType
Definition: avutil.h:277
KeyframeForceCtx::nb_pts
int nb_pts
Definition: ffmpeg.h:531
rational.h
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
AVSubtitle::num_rects
unsigned num_rects
Definition: avcodec.h:2231
ENC_STATS_AVG_BITRATE
@ ENC_STATS_AVG_BITRATE
Definition: ffmpeg.h:489
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:160
OutputFile::start_time
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:624
Encoder::sch
Scheduler * sch
Definition: ffmpeg_enc.c:51
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
pixdesc.h
AVCodecContext::color_trc
enum AVColorTransferCharacteristic color_trc
Color Transfer Characteristic.
Definition: avcodec.h:678
AVCodec::capabilities
int capabilities
Codec capabilities.
Definition: codec.h:206
FKF_T
@ FKF_T
Definition: ffmpeg.h:464
AVPacket::data
uint8_t * data
Definition: packet.h:524
ENC_STATS_LITERAL
@ ENC_STATS_LITERAL
Definition: ffmpeg.h:472
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:708
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:832
KeyframeForceCtx::type
int type
Definition: ffmpeg.h:525
AVCodecContext::subtitle_header
uint8_t * subtitle_header
Definition: avcodec.h:1891
forced_kf_apply
static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf, const AVFrame *frame)
Definition: ffmpeg_enc.c:729
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:542
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:872
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:538
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:579
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:607
ENC_STATS_TIMEBASE_IN
@ ENC_STATS_TIMEBASE_IN
Definition: ffmpeg.h:478
AV_FIELD_BT
@ AV_FIELD_BT
Bottom coded first, top displayed first.
Definition: defs.h:204
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:638
FrameData::frame_num
uint64_t frame_num
Definition: ffmpeg.h:637
InputStream
Definition: ffmpeg.h:394
AVCodecContext::framerate
AVRational framerate
Definition: avcodec.h:560
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:69
AV_FIELD_TT
@ AV_FIELD_TT
Top coded_first, top displayed first.
Definition: defs.h:201
AV_CODEC_ID_ASS
@ AV_CODEC_ID_ASS
Definition: codec_id.h:572
finish
static void finish(void)
Definition: movenc.c:373
vstats_version
int vstats_version
Definition: ffmpeg_opt.c:77
AVCodecContext::codec
const struct AVCodec * codec
Definition: avcodec.h:454
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:560
AVCodecContext::ch_layout
AVChannelLayout ch_layout
Audio channel layout.
Definition: avcodec.h:1065
fail
#define fail()
Definition: checkasm.h:179
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:502
KeyframeForceCtx::ref_pts
int64_t ref_pts
Definition: ffmpeg.h:527
Encoder::attach_par
int attach_par
Definition: ffmpeg_enc.c:49
update_benchmark
void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:496
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
pts
static int64_t pts
Definition: transcode_aac.c:644
FrameData::tb
AVRational tb
Definition: ffmpeg.h:640
AVRational::num
int num
Numerator.
Definition: rational.h:59
AV_FIELD_TB
@ AV_FIELD_TB
Top coded first, bottom displayed first.
Definition: defs.h:203
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:148
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:824
avassert.h
AVCodecContext::color_primaries
enum AVColorPrimaries color_primaries
Chromaticity coordinates of the source primaries.
Definition: avcodec.h:671
FrameData::frame_rate_filter
AVRational frame_rate_filter
Definition: ffmpeg.h:643
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:1045
encoder_thread
int encoder_thread(void *arg)
Definition: ffmpeg_enc.c:851
ENC_STATS_PTS_IN
@ ENC_STATS_PTS_IN
Definition: ffmpeg.h:481
AV_FRAME_FLAG_KEY
#define AV_FRAME_FLAG_KEY
A flag to mark frames that are keyframes.
Definition: frame.h:625
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:501
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:52
AVCodecContext::nb_decoded_side_data
int nb_decoded_side_data
Definition: avcodec.h:2077
bitrate
int64_t bitrate
Definition: av1_levels.c:47
ENC_STATS_FILE_IDX
@ ENC_STATS_FILE_IDX
Definition: ffmpeg.h:473
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:488
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:1574
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:465
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:518
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2233
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:2235
AV_SIDE_DATA_PROP_GLOBAL
@ AV_SIDE_DATA_PROP_GLOBAL
The side data type can be used in stream-global structures.
Definition: frame.h:264
AVCodecContext::codec_id
enum AVCodecID codec_id
Definition: avcodec.h:455
arg
const char * arg
Definition: jacosubdec.c:67
KeyframeForceCtx::expr_const_values
double expr_const_values[FKF_NB]
Definition: ffmpeg.h:535
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:490
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:782
NULL
#define NULL
Definition: coverity.c:32
frame_encode
static int frame_encode(OutputStream *ost, AVFrame *frame, AVPacket *pkt)
Definition: ffmpeg_enc.c:775
AVCodecContext::color_range
enum AVColorRange color_range
MPEG vs JPEG YUV range.
Definition: avcodec.h:695
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
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:380
ENC_STATS_PTS_TIME
@ ENC_STATS_PTS_TIME
Definition: ffmpeg.h:480
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
EncStats::lock
pthread_mutex_t lock
Definition: ffmpeg.h:506
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:1890
EncStats
Definition: ffmpeg.h:500
vstats_file
FILE * vstats_file
Definition: ffmpeg.c:88
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:823
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:647
double
double
Definition: af_crystalizer.c:131
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:142
time.h
avio_w8
void avio_w8(AVIOContext *s, int b)
Definition: aviobuf.c:179
OutputFile::index
int index
Definition: ffmpeg.h:616
EncoderThread::pkt
AVPacket * pkt
Definition: ffmpeg_enc.c:58
ENC_STATS_PTS_TIME_IN
@ ENC_STATS_PTS_TIME_IN
Definition: ffmpeg.h:482
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:2279
pthread_mutex_unlock
#define pthread_mutex_unlock(a)
Definition: ffprobe.c:82
enc_loopback
int enc_loopback(Encoder *enc)
Definition: ffmpeg_enc.c:932
Scheduler
Definition: ffmpeg_sched.c:269
enc_thread_init
static int enc_thread_init(EncoderThread *et)
Definition: ffmpeg_enc.c:832
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:544
AVCodecContext::stats_out
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:1334
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:525
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:121
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:1057
AV_SAMPLE_FMT_NONE
@ AV_SAMPLE_FMT_NONE
Definition: samplefmt.h:56
ENC_STATS_NB_SAMPLES
@ ENC_STATS_NB_SAMPLES
Definition: ffmpeg.h:486
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: ffmpeg.c:485
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:452
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:821
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2230
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:523
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:639
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:530
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:475
KeyframeForceCtx
Definition: ffmpeg.h:524
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
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:302
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:816
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:517
FrameData::bits_per_raw_sample
int bits_per_raw_sample
Definition: ffmpeg.h:645
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:626
display.h
AV_FIELD_BB
@ AV_FIELD_BB
Bottom coded first, bottom displayed first.
Definition: defs.h:202
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:70
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:606
tb
#define tb
Definition: regdef.h:68
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:702
ENC_STATS_STREAM_IDX
@ ENC_STATS_STREAM_IDX
Definition: ffmpeg.h:474
AVCodecContext::height
int height
Definition: avcodec.h:618
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:657
ENC_STATS_SAMPLE_NUM
@ ENC_STATS_SAMPLE_NUM
Definition: ffmpeg.h:485
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:633
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:315
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:411
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:445
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
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:532
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:378
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:386
check_recording_time
static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
Definition: ffmpeg_enc.c:367
AVSideDataDescriptor
This struct describes the properties of a side data type.
Definition: frame.h:277
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:838
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:440
AVCodecContext::codec_type
enum AVMediaType codec_type
Definition: avcodec.h:453
desc
const char * desc
Definition: libsvtav1.c:75
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:534
FKF_N_FORCED
@ FKF_N_FORCED
Definition: ffmpeg.h:461
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:1018
AVPacket
This structure stores compressed data.
Definition: packet.h:501
EncStatsComponent
Definition: ffmpeg.h:493
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:502
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:464
d
d
Definition: ffmpeg_filter.c:424
AVCodecContext::width
int width
picture width / height.
Definition: avcodec.h:618
ENC_STATS_PKT_SIZE
@ ENC_STATS_PKT_SIZE
Definition: ffmpeg.h:487
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:334
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:460
ENC_STATS_DTS_TIME
@ ENC_STATS_DTS_TIME
Definition: ffmpeg.h:484
OutputFile::recording_time
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:623
of_stream_init
int of_stream_init(OutputFile *of, OutputStream *ost)
Definition: ffmpeg_mux.c:612
AV_PKT_FLAG_TRUSTED
#define AV_PKT_FLAG_TRUSTED
The packet comes from a trusted source.
Definition: packet.h:593
snprintf
#define snprintf
Definition: snprintf.h:34
EncStats::io
AVIOContext * io
Definition: ffmpeg.h:504
update_video_stats
static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
Definition: ffmpeg_enc.c:543
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:642
AVSubtitle::start_display_time
uint32_t start_display_time
Definition: avcodec.h:2229
ENC_STATS_TIMEBASE
@ ENC_STATS_TIMEBASE
Definition: ffmpeg.h:477
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:568
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:613
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