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 typedef struct EncoderPriv {
43 
44  void *log_parent;
45  char log_name[32];
46 
47  // combined size of all the packets received from the encoder
48  uint64_t data_size;
49 
50  // number of packets received from the encoder
51  uint64_t packets_encoded;
52 
53  int opened;
55 
57  unsigned sch_idx;
58 } EncoderPriv;
59 
61 {
62  return (EncoderPriv*)enc;
63 }
64 
65 // data that is local to the decoder thread and not visible outside of it
66 typedef struct EncoderThread {
70 
71 void enc_free(Encoder **penc)
72 {
73  Encoder *enc = *penc;
74 
75  if (!enc)
76  return;
77 
78  if (enc->enc_ctx)
79  av_freep(&enc->enc_ctx->stats_in);
81 
82  av_freep(penc);
83 }
84 
85 static const char *enc_item_name(void *obj)
86 {
87  const EncoderPriv *ep = obj;
88 
89  return ep->log_name;
90 }
91 
92 static const AVClass enc_class = {
93  .class_name = "Encoder",
94  .version = LIBAVUTIL_VERSION_INT,
95  .parent_log_context_offset = offsetof(EncoderPriv, log_parent),
96  .item_name = enc_item_name,
97 };
98 
99 int enc_alloc(Encoder **penc, const AVCodec *codec,
100  Scheduler *sch, unsigned sch_idx, void *log_parent)
101 {
102  EncoderPriv *ep;
103  int ret = 0;
104 
105  *penc = NULL;
106 
107  ep = av_mallocz(sizeof(*ep));
108  if (!ep)
109  return AVERROR(ENOMEM);
110 
111  ep->e.class = &enc_class;
112  ep->log_parent = log_parent;
113 
114  ep->sch = sch;
115  ep->sch_idx = sch_idx;
116 
117  snprintf(ep->log_name, sizeof(ep->log_name), "enc:%s", codec->name);
118 
119  ep->e.enc_ctx = avcodec_alloc_context3(codec);
120  if (!ep->e.enc_ctx) {
121  ret = AVERROR(ENOMEM);
122  goto fail;
123  }
124 
125  *penc = &ep->e;
126 
127  return 0;
128 fail:
129  enc_free((Encoder**)&ep);
130  return ret;
131 }
132 
134  AVBufferRef *frames_ref)
135 {
136  const AVCodecHWConfig *config;
137  HWDevice *dev = NULL;
138 
139  if (frames_ref &&
140  ((AVHWFramesContext*)frames_ref->data)->format ==
141  enc_ctx->pix_fmt) {
142  // Matching format, will try to use hw_frames_ctx.
143  } else {
144  frames_ref = NULL;
145  }
146 
147  for (int i = 0;; i++) {
148  config = avcodec_get_hw_config(enc_ctx->codec, i);
149  if (!config)
150  break;
151 
152  if (frames_ref &&
154  (config->pix_fmt == AV_PIX_FMT_NONE ||
155  config->pix_fmt == enc_ctx->pix_fmt)) {
156  av_log(e, AV_LOG_VERBOSE, "Using input "
157  "frames context (format %s) with %s encoder.\n",
158  av_get_pix_fmt_name(enc_ctx->pix_fmt),
159  enc_ctx->codec->name);
160  enc_ctx->hw_frames_ctx = av_buffer_ref(frames_ref);
161  if (!enc_ctx->hw_frames_ctx)
162  return AVERROR(ENOMEM);
163  return 0;
164  }
165 
166  if (!dev &&
168  dev = hw_device_get_by_type(config->device_type);
169  }
170 
171  if (dev) {
172  av_log(e, AV_LOG_VERBOSE, "Using device %s "
173  "(type %s) with %s encoder.\n", dev->name,
174  av_hwdevice_get_type_name(dev->type), enc_ctx->codec->name);
175  enc_ctx->hw_device_ctx = av_buffer_ref(dev->device_ref);
176  if (!enc_ctx->hw_device_ctx)
177  return AVERROR(ENOMEM);
178  } else {
179  // No device required, or no device available.
180  }
181  return 0;
182 }
183 
184 int enc_open(void *opaque, const AVFrame *frame)
185 {
186  OutputStream *ost = opaque;
187  InputStream *ist = ost->ist;
188  Encoder *e = ost->enc;
189  EncoderPriv *ep = ep_from_enc(e);
190  AVCodecContext *enc_ctx = e->enc_ctx;
191  Decoder *dec = NULL;
192  const AVCodec *enc = enc_ctx->codec;
193  OutputFile *of = ost->file;
194  FrameData *fd;
195  int frame_samples = 0;
196  int ret;
197 
198  if (ep->opened)
199  return 0;
200 
201  // frame is always non-NULL for audio and video
203 
204  if (frame) {
205  av_assert0(frame->opaque_ref);
206  fd = (FrameData*)frame->opaque_ref->data;
207 
208  for (int i = 0; i < frame->nb_side_data; i++) {
209  const AVSideDataDescriptor *desc = av_frame_side_data_desc(frame->side_data[i]->type);
210 
211  if (!(desc->props & AV_SIDE_DATA_PROP_GLOBAL))
212  continue;
213 
215  &enc_ctx->nb_decoded_side_data,
216  frame->side_data[i],
218  if (ret < 0)
219  return ret;
220  }
221  }
222 
223  if (ist)
224  dec = ist->decoder;
225 
226  // the timebase is chosen by filtering code
227  if (ost->type == AVMEDIA_TYPE_AUDIO || ost->type == AVMEDIA_TYPE_VIDEO) {
228  enc_ctx->time_base = frame->time_base;
229  enc_ctx->framerate = fd->frame_rate_filter;
230  }
231 
232  switch (enc_ctx->codec_type) {
233  case AVMEDIA_TYPE_AUDIO:
234  av_assert0(frame->format != AV_SAMPLE_FMT_NONE &&
235  frame->sample_rate > 0 &&
236  frame->ch_layout.nb_channels > 0);
237  enc_ctx->sample_fmt = frame->format;
238  enc_ctx->sample_rate = frame->sample_rate;
239  ret = av_channel_layout_copy(&enc_ctx->ch_layout, &frame->ch_layout);
240  if (ret < 0)
241  return ret;
242 
243  if (ost->bits_per_raw_sample)
244  enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
245  else
247  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
248  break;
249 
250  case AVMEDIA_TYPE_VIDEO: {
251  av_assert0(frame->format != AV_PIX_FMT_NONE &&
252  frame->width > 0 &&
253  frame->height > 0);
254  enc_ctx->width = frame->width;
255  enc_ctx->height = frame->height;
256  enc_ctx->sample_aspect_ratio =
257  ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
258  av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
259  frame->sample_aspect_ratio;
260 
261  enc_ctx->pix_fmt = frame->format;
262 
263  if (ost->bits_per_raw_sample)
264  enc_ctx->bits_per_raw_sample = ost->bits_per_raw_sample;
265  else
267  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
268 
269  enc_ctx->color_range = frame->color_range;
270  enc_ctx->color_primaries = frame->color_primaries;
271  enc_ctx->color_trc = frame->color_trc;
272  enc_ctx->colorspace = frame->colorspace;
273  enc_ctx->chroma_sample_location = frame->chroma_location;
274 
277 #if FFMPEG_OPT_TOP
278  || ost->top_field_first >= 0
279 #endif
280  ) {
281  int top_field_first =
282 #if FFMPEG_OPT_TOP
283  ost->top_field_first >= 0 ?
284  ost->top_field_first :
285 #endif
287 
288  if (enc->id == AV_CODEC_ID_MJPEG)
289  enc_ctx->field_order = top_field_first ? AV_FIELD_TT : AV_FIELD_BB;
290  else
291  enc_ctx->field_order = top_field_first ? AV_FIELD_TB : AV_FIELD_BT;
292  } else
294 
295  break;
296  }
298  enc_ctx->time_base = AV_TIME_BASE_Q;
299 
300  if (!enc_ctx->width) {
301  enc_ctx->width = ost->ist->par->width;
302  enc_ctx->height = ost->ist->par->height;
303  }
304 
305  av_assert0(dec);
306  if (dec->subtitle_header) {
307  /* ASS code assumes this buffer is null terminated so add extra byte. */
308  enc_ctx->subtitle_header = av_mallocz(dec->subtitle_header_size + 1);
309  if (!enc_ctx->subtitle_header)
310  return AVERROR(ENOMEM);
311  memcpy(enc_ctx->subtitle_header, dec->subtitle_header,
312  dec->subtitle_header_size);
314  }
315 
316  break;
317  default:
318  av_assert0(0);
319  break;
320  }
321 
322  if (ost->bitexact)
323  enc_ctx->flags |= AV_CODEC_FLAG_BITEXACT;
324 
326  enc_ctx->flags |= AV_CODEC_FLAG_COPY_OPAQUE;
327 
329 
330  ret = hw_device_setup_for_encode(e, enc_ctx, frame ? frame->hw_frames_ctx : NULL);
331  if (ret < 0) {
332  av_log(e, AV_LOG_ERROR,
333  "Encoding hardware device setup failed: %s\n", av_err2str(ret));
334  return ret;
335  }
336 
337  if ((ret = avcodec_open2(enc_ctx, enc, NULL)) < 0) {
338  if (ret != AVERROR_EXPERIMENTAL)
339  av_log(e, AV_LOG_ERROR, "Error while opening encoder - maybe "
340  "incorrect parameters such as bit_rate, rate, width or height.\n");
341  return ret;
342  }
343 
344  ep->opened = 1;
345 
346  if (enc_ctx->frame_size)
347  frame_samples = enc_ctx->frame_size;
348 
349  if (enc_ctx->bit_rate && enc_ctx->bit_rate < 1000 &&
350  enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
351  av_log(e, AV_LOG_WARNING, "The bitrate parameter is set too low."
352  " It takes bits/s as argument, not kbits/s\n");
353 
354  ret = of_stream_init(of, ost, enc_ctx);
355  if (ret < 0)
356  return ret;
357 
358  return frame_samples;
359 }
360 
362 {
363  OutputFile *of = ost->file;
364 
365  if (of->recording_time != INT64_MAX &&
366  av_compare_ts(ts, tb, of->recording_time, AV_TIME_BASE_Q) >= 0) {
367  return 0;
368  }
369  return 1;
370 }
371 
372 static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub,
373  AVPacket *pkt)
374 {
375  Encoder *e = ost->enc;
376  EncoderPriv *ep = ep_from_enc(e);
377  int subtitle_out_max_size = 1024 * 1024;
378  int subtitle_out_size, nb, i, ret;
379  AVCodecContext *enc;
380  int64_t pts;
381 
382  if (sub->pts == AV_NOPTS_VALUE) {
383  av_log(e, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
384  return exit_on_error ? AVERROR(EINVAL) : 0;
385  }
386  if ((of->start_time != AV_NOPTS_VALUE && sub->pts < of->start_time))
387  return 0;
388 
389  enc = e->enc_ctx;
390 
391  /* Note: DVB subtitle need one packet to draw them and one other
392  packet to clear them */
393  /* XXX: signal it in the codec context ? */
395  nb = 2;
396  else if (enc->codec_id == AV_CODEC_ID_ASS)
397  nb = FFMAX(sub->num_rects, 1);
398  else
399  nb = 1;
400 
401  /* shift timestamp to honor -ss and make check_recording_time() work with -t */
402  pts = sub->pts;
403  if (of->start_time != AV_NOPTS_VALUE)
404  pts -= of->start_time;
405  for (i = 0; i < nb; i++) {
406  AVSubtitle local_sub = *sub;
407 
409  return AVERROR_EOF;
410 
411  ret = av_new_packet(pkt, subtitle_out_max_size);
412  if (ret < 0)
413  return AVERROR(ENOMEM);
414 
415  local_sub.pts = pts;
416  // start_display_time is required to be 0
417  local_sub.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
418  local_sub.end_display_time -= sub->start_display_time;
419  local_sub.start_display_time = 0;
420 
421  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE && i == 1)
422  local_sub.num_rects = 0;
423  else if (enc->codec_id == AV_CODEC_ID_ASS && sub->num_rects > 0) {
424  local_sub.num_rects = 1;
425  local_sub.rects += i;
426  }
427 
428  e->frames_encoded++;
429 
430  subtitle_out_size = avcodec_encode_subtitle(enc, pkt->data, pkt->size, &local_sub);
431  if (subtitle_out_size < 0) {
432  av_log(e, AV_LOG_FATAL, "Subtitle encoding failed\n");
433  return subtitle_out_size;
434  }
435 
436  av_shrink_packet(pkt, subtitle_out_size);
438  pkt->pts = sub->pts;
440  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
441  /* XXX: the pts correction is handled here. Maybe handling
442  it in the codec would be better */
443  if (i == 0)
444  pkt->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
445  else
446  pkt->pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, pkt->time_base);
447  }
448  pkt->dts = pkt->pts;
449 
450  ret = sch_enc_send(ep->sch, ep->sch_idx, pkt);
451  if (ret < 0) {
453  return ret;
454  }
455  }
456 
457  return 0;
458 }
459 
461  const AVFrame *frame, const AVPacket *pkt,
462  uint64_t frame_num)
463 {
464  Encoder *e = ost->enc;
465  EncoderPriv *ep = ep_from_enc(e);
466  AVIOContext *io = es->io;
467  AVRational tb = frame ? frame->time_base : pkt->time_base;
468  int64_t pts = frame ? frame->pts : pkt->pts;
469 
470  AVRational tbi = (AVRational){ 0, 1};
471  int64_t ptsi = INT64_MAX;
472 
473  const FrameData *fd = NULL;
474 
475  if (frame ? frame->opaque_ref : pkt->opaque_ref) {
476  fd = (const FrameData*)(frame ? frame->opaque_ref->data : pkt->opaque_ref->data);
477  tbi = fd->dec.tb;
478  ptsi = fd->dec.pts;
479  }
480 
481  pthread_mutex_lock(&es->lock);
482 
483  for (size_t i = 0; i < es->nb_components; i++) {
484  const EncStatsComponent *c = &es->components[i];
485 
486  switch (c->type) {
487  case ENC_STATS_LITERAL: avio_write (io, c->str, c->str_len); continue;
488  case ENC_STATS_FILE_IDX: avio_printf(io, "%d", ost->file->index); continue;
489  case ENC_STATS_STREAM_IDX: avio_printf(io, "%d", ost->index); continue;
490  case ENC_STATS_TIMEBASE: avio_printf(io, "%d/%d", tb.num, tb.den); continue;
491  case ENC_STATS_TIMEBASE_IN: avio_printf(io, "%d/%d", tbi.num, tbi.den); continue;
492  case ENC_STATS_PTS: avio_printf(io, "%"PRId64, pts); continue;
493  case ENC_STATS_PTS_IN: avio_printf(io, "%"PRId64, ptsi); continue;
494  case ENC_STATS_PTS_TIME: avio_printf(io, "%g", pts * av_q2d(tb)); continue;
495  case ENC_STATS_PTS_TIME_IN: avio_printf(io, "%g", ptsi == INT64_MAX ?
496  INFINITY : ptsi * av_q2d(tbi)); continue;
497  case ENC_STATS_FRAME_NUM: avio_printf(io, "%"PRIu64, frame_num); continue;
498  case ENC_STATS_FRAME_NUM_IN: avio_printf(io, "%"PRIu64, fd ? fd->dec.frame_num : -1); continue;
499  }
500 
501  if (frame) {
502  switch (c->type) {
503  case ENC_STATS_SAMPLE_NUM: avio_printf(io, "%"PRIu64, e->samples_encoded); continue;
504  case ENC_STATS_NB_SAMPLES: avio_printf(io, "%d", frame->nb_samples); continue;
505  default: av_assert0(0);
506  }
507  } else {
508  switch (c->type) {
509  case ENC_STATS_DTS: avio_printf(io, "%"PRId64, pkt->dts); continue;
510  case ENC_STATS_DTS_TIME: avio_printf(io, "%g", pkt->dts * av_q2d(tb)); continue;
511  case ENC_STATS_PKT_SIZE: avio_printf(io, "%d", pkt->size); continue;
513  "K" : "N", 1); continue;
514  case ENC_STATS_BITRATE: {
515  double duration = FFMAX(pkt->duration, 1) * av_q2d(tb);
516  avio_printf(io, "%g", 8.0 * pkt->size / duration);
517  continue;
518  }
519  case ENC_STATS_AVG_BITRATE: {
520  double duration = pkt->dts * av_q2d(tb);
521  avio_printf(io, "%g", duration > 0 ? 8.0 * ep->data_size / duration : -1.);
522  continue;
523  }
524  default: av_assert0(0);
525  }
526  }
527  }
528  avio_w8(io, '\n');
529  avio_flush(io);
530 
532 }
533 
534 static inline double psnr(double d)
535 {
536  return -10.0 * log10(d);
537 }
538 
539 static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
540 {
541  Encoder *e = ost->enc;
542  EncoderPriv *ep = ep_from_enc(e);
544  NULL);
545  AVCodecContext *enc = e->enc_ctx;
546  enum AVPictureType pict_type;
547  int64_t frame_number;
548  double ti1, bitrate, avg_bitrate;
549  double psnr_val = -1;
550  int quality;
551 
552  quality = sd ? AV_RL32(sd) : -1;
553  pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
554 
555  atomic_store(&ost->quality, quality);
556 
557  if ((enc->flags & AV_CODEC_FLAG_PSNR) && sd && sd[5]) {
558  // FIXME the scaling assumes 8bit
559  double error = AV_RL64(sd + 8) / (enc->width * enc->height * 255.0 * 255.0);
560  if (error >= 0 && error <= 1)
561  psnr_val = psnr(error);
562  }
563 
564  if (!write_vstats)
565  return 0;
566 
567  /* this is executed just the first time update_video_stats is called */
568  if (!vstats_file) {
569  vstats_file = fopen(vstats_filename, "w");
570  if (!vstats_file) {
571  perror("fopen");
572  return AVERROR(errno);
573  }
574  }
575 
576  frame_number = ep->packets_encoded;
577  if (vstats_version <= 1) {
578  fprintf(vstats_file, "frame= %5"PRId64" q= %2.1f ", frame_number,
579  quality / (float)FF_QP2LAMBDA);
580  } else {
581  fprintf(vstats_file, "out= %2d st= %2d frame= %5"PRId64" q= %2.1f ",
582  ost->file->index, ost->index, frame_number,
583  quality / (float)FF_QP2LAMBDA);
584  }
585 
586  if (psnr_val >= 0)
587  fprintf(vstats_file, "PSNR= %6.2f ", psnr_val);
588 
589  fprintf(vstats_file,"f_size= %6d ", pkt->size);
590  /* compute pts value */
591  ti1 = pkt->dts * av_q2d(pkt->time_base);
592  if (ti1 < 0.01)
593  ti1 = 0.01;
594 
595  bitrate = (pkt->size * 8) / av_q2d(enc->time_base) / 1000.0;
596  avg_bitrate = (double)(ep->data_size * 8) / ti1 / 1000.0;
597  fprintf(vstats_file, "s_size= %8.0fKiB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
598  (double)ep->data_size / 1024, ti1, bitrate, avg_bitrate);
599  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(pict_type));
600 
601  return 0;
602 }
603 
605  AVPacket *pkt)
606 {
607  Encoder *e = ost->enc;
608  EncoderPriv *ep = ep_from_enc(e);
609  AVCodecContext *enc = e->enc_ctx;
610  const char *type_desc = av_get_media_type_string(enc->codec_type);
611  const char *action = frame ? "encode" : "flush";
612  int ret;
613 
614  if (frame) {
615  FrameData *fd = frame_data(frame);
616 
617  if (!fd)
618  return AVERROR(ENOMEM);
619 
621 
622  if (ost->enc_stats_pre.io)
623  enc_stats_write(ost, &ost->enc_stats_pre, frame, NULL,
624  e->frames_encoded);
625 
626  e->frames_encoded++;
627  e->samples_encoded += frame->nb_samples;
628 
629  if (debug_ts) {
630  av_log(e, AV_LOG_INFO, "encoder <- type:%s "
631  "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
632  type_desc,
633  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
634  enc->time_base.num, enc->time_base.den);
635  }
636 
637  if (frame->sample_aspect_ratio.num && !ost->frame_aspect_ratio.num)
638  enc->sample_aspect_ratio = frame->sample_aspect_ratio;
639  }
640 
642 
643  ret = avcodec_send_frame(enc, frame);
644  if (ret < 0 && !(ret == AVERROR_EOF && !frame)) {
645  av_log(e, AV_LOG_ERROR, "Error submitting %s frame to the encoder\n",
646  type_desc);
647  return ret;
648  }
649 
650  while (1) {
651  FrameData *fd;
652 
654 
656  update_benchmark("%s_%s %d.%d", action, type_desc,
657  of->index, ost->index);
658 
659  pkt->time_base = enc->time_base;
660 
661  /* if two pass, output log on success and EOF */
662  if ((ret >= 0 || ret == AVERROR_EOF) && ost->logfile && enc->stats_out)
663  fprintf(ost->logfile, "%s", enc->stats_out);
664 
665  if (ret == AVERROR(EAGAIN)) {
666  av_assert0(frame); // should never happen during flushing
667  return 0;
668  } else if (ret < 0) {
669  if (ret != AVERROR_EOF)
670  av_log(e, AV_LOG_ERROR, "%s encoding failed\n", type_desc);
671  return ret;
672  }
673 
674  fd = packet_data(pkt);
675  if (!fd)
676  return AVERROR(ENOMEM);
678 
679  // attach stream parameters to first packet if requested
681  if (ep->attach_par && !ep->packets_encoded) {
683  if (!fd->par_enc)
684  return AVERROR(ENOMEM);
685 
687  if (ret < 0)
688  return ret;
689  }
690 
692 
693  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
695  if (ret < 0)
696  return ret;
697  }
698 
699  if (ost->enc_stats_post.io)
700  enc_stats_write(ost, &ost->enc_stats_post, NULL, pkt,
701  ep->packets_encoded);
702 
703  if (debug_ts) {
704  av_log(e, AV_LOG_INFO, "encoder -> type:%s "
705  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s "
706  "duration:%s duration_time:%s\n",
707  type_desc,
711  }
712 
713  ep->data_size += pkt->size;
714 
715  ep->packets_encoded++;
716 
717  ret = sch_enc_send(ep->sch, ep->sch_idx, pkt);
718  if (ret < 0) {
720  return ret;
721  }
722  }
723 
724  av_assert0(0);
725 }
726 
727 static enum AVPictureType forced_kf_apply(void *logctx, KeyframeForceCtx *kf,
728  const AVFrame *frame)
729 {
730  double pts_time;
731 
732  if (kf->ref_pts == AV_NOPTS_VALUE)
733  kf->ref_pts = frame->pts;
734 
735  pts_time = (frame->pts - kf->ref_pts) * av_q2d(frame->time_base);
736  if (kf->index < kf->nb_pts &&
737  av_compare_ts(frame->pts, frame->time_base, kf->pts[kf->index], AV_TIME_BASE_Q) >= 0) {
738  kf->index++;
739  goto force_keyframe;
740  } else if (kf->pexpr) {
741  double res;
742  kf->expr_const_values[FKF_T] = pts_time;
743  res = av_expr_eval(kf->pexpr,
744  kf->expr_const_values, NULL);
745  av_log(logctx, AV_LOG_TRACE,
746  "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
752  res);
753 
754  kf->expr_const_values[FKF_N] += 1;
755 
756  if (res) {
760  goto force_keyframe;
761  }
762  } else if (kf->type == KF_FORCE_SOURCE && (frame->flags & AV_FRAME_FLAG_KEY)) {
763  goto force_keyframe;
764  }
765 
766  return AV_PICTURE_TYPE_NONE;
767 
768 force_keyframe:
769  av_log(logctx, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
770  return AV_PICTURE_TYPE_I;
771 }
772 
774 {
775  Encoder *e = ost->enc;
776  OutputFile *of = ost->file;
777  enum AVMediaType type = ost->type;
778 
779  if (type == AVMEDIA_TYPE_SUBTITLE) {
780  const AVSubtitle *subtitle = frame && frame->buf[0] ?
781  (AVSubtitle*)frame->buf[0]->data : NULL;
782 
783  // no flushing for subtitles
784  return subtitle && subtitle->num_rects ?
785  do_subtitle_out(of, ost, subtitle, pkt) : 0;
786  }
787 
788  if (frame) {
789  if (!check_recording_time(ost, frame->pts, frame->time_base))
790  return AVERROR_EOF;
791 
792  if (type == AVMEDIA_TYPE_VIDEO) {
793  frame->quality = e->enc_ctx->global_quality;
794  frame->pict_type = forced_kf_apply(e, &ost->kf, frame);
795 
796 #if FFMPEG_OPT_TOP
797  if (ost->top_field_first >= 0) {
799  frame->flags |= AV_FRAME_FLAG_TOP_FIELD_FIRST * (!!ost->top_field_first);
800  }
801 #endif
802  } else {
804  e->enc_ctx->ch_layout.nb_channels != frame->ch_layout.nb_channels) {
805  av_log(e, AV_LOG_ERROR,
806  "Audio channel count changed and encoder does not support parameter changes\n");
807  return 0;
808  }
809  }
810  }
811 
812  return encode_frame(of, ost, frame, pkt);
813 }
814 
816 {
817  char name[16];
818  snprintf(name, sizeof(name), "enc%d:%d:%s", ost->file->index, ost->index,
819  ost->enc->enc_ctx->codec->name);
821 }
822 
824 {
825  av_packet_free(&et->pkt);
826  av_frame_free(&et->frame);
827 
828  memset(et, 0, sizeof(*et));
829 }
830 
832 {
833  memset(et, 0, sizeof(*et));
834 
835  et->frame = av_frame_alloc();
836  if (!et->frame)
837  goto fail;
838 
839  et->pkt = av_packet_alloc();
840  if (!et->pkt)
841  goto fail;
842 
843  return 0;
844 
845 fail:
846  enc_thread_uninit(et);
847  return AVERROR(ENOMEM);
848 }
849 
850 int encoder_thread(void *arg)
851 {
852  OutputStream *ost = arg;
853  Encoder *e = ost->enc;
854  EncoderPriv *ep = ep_from_enc(e);
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(ep->sch, ep->sch_idx, et.frame);
878  if (input_status < 0) {
879  if (input_status == AVERROR_EOF) {
880  av_log(e, AV_LOG_VERBOSE, "Encoder thread received EOF\n");
881  if (ep->opened)
882  break;
883 
884  av_log(e, AV_LOG_ERROR, "Could not open encoder before EOF\n");
885  ret = AVERROR(EINVAL);
886  } else {
887  av_log(e, 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(e, AV_LOG_VERBOSE, "Encoder returned EOF, finishing\n");
907  else
908  av_log(e, 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(e, 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  EncoderPriv *ep = ep_from_enc(enc);
935  ep->attach_par = 1;
936  return ep->sch_idx;
937 }
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:555
Decoder::subtitle_header
const uint8_t * subtitle_header
Definition: ffmpeg.h:425
avcodec_encode_subtitle
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: encode.c:191
AVCodecContext::frame_size
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1083
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:674
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:215
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:495
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
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
Encoder::samples_encoded
uint64_t samples_encoded
Definition: ffmpeg.h:572
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:655
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:511
ENC_STATS_FRAME_NUM_IN
@ ENC_STATS_FRAME_NUM_IN
Definition: ffmpeg.h:508
AVCodecContext::sample_rate
int sample_rate
samples per second
Definition: avcodec.h:1056
FKF_PREV_FORCED_N
@ FKF_PREV_FORCED_N
Definition: ffmpeg.h:494
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:3170
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
ENC_STATS_DTS
@ ENC_STATS_DTS
Definition: ffmpeg.h:515
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:556
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:521
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:649
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:496
AVPacket::data
uint8_t * data
Definition: packet.h:539
ENC_STATS_LITERAL
@ ENC_STATS_LITERAL
Definition: ffmpeg.h:504
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
KeyframeForceCtx::type
int type
Definition: ffmpeg.h:550
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:727
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:225
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
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
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:534
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:604
ENC_STATS_TIMEBASE_IN
@ ENC_STATS_TIMEBASE_IN
Definition: ffmpeg.h:510
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:662
InputStream
Definition: ffmpeg.h:434
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:577
AV_CODEC_FLAG_COPY_OPAQUE
#define AV_CODEC_FLAG_COPY_OPAQUE
Definition: avcodec.h:299
finish
static void finish(void)
Definition: movenc.c:373
EncoderPriv::log_name
char log_name[32]
Definition: ffmpeg_enc.c:45
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:552
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:665
EncoderPriv::packets_encoded
uint64_t packets_encoded
Definition: ffmpeg_enc.c:51
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_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:556
enc_thread_uninit
static void enc_thread_uninit(EncoderThread *et)
Definition: ffmpeg_enc.c:823
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:668
AV_LOG_TRACE
#define AV_LOG_TRACE
Extremely verbose debugging, useful for libav* development.
Definition: log.h:235
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:209
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:850
ENC_STATS_PTS_IN
@ ENC_STATS_PTS_IN
Definition: ffmpeg.h:513
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
EncStats::components
EncStatsComponent * components
Definition: ffmpeg.h:533
avcodec_alloc_context3
AVCodecContext * avcodec_alloc_context3(const AVCodec *codec)
Allocate an AVCodecContext and set its fields to default values.
Definition: options.c:149
enc_class
static const AVClass enc_class
Definition: ffmpeg_enc.c:92
intreadwrite.h
AVCodecContext::stats_in
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:1352
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
AVCodecContext::global_quality
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1249
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:53
EncoderPriv::attach_par
int attach_par
Definition: ffmpeg_enc.c:54
Encoder::class
const AVClass * class
Definition: ffmpeg.h:566
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:505
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
enc_item_name
static const char * enc_item_name(void *obj)
Definition: ffmpeg_enc.c:85
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:520
Encoder::frames_encoded
uint64_t frames_encoded
Definition: ffmpeg.h:571
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:230
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:460
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
EncoderPriv::sch_idx
unsigned sch_idx
Definition: ffmpeg_enc.c:57
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:543
AVSubtitle::pts
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:2244
Encoder::enc_ctx
AVCodecContext * enc_ctx
Definition: ffmpeg.h:568
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:512
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:2312
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:560
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:522
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:75
ep_from_enc
static EncoderPriv * ep_from_enc(Encoder *enc)
Definition: ffmpeg_enc.c:60
NULL
#define NULL
Definition: coverity.c:32
frame_encode
static int frame_encode(OutputStream *ost, AVFrame *frame, AVPacket *pkt)
Definition: ffmpeg_enc.c:773
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:420
ENC_STATS_PTS_TIME
@ ENC_STATS_PTS_TIME
Definition: ffmpeg.h:512
avcodec_free_context
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer.
Definition: options.c:164
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
EncStats::lock
pthread_mutex_t lock
Definition: ffmpeg.h:538
AVCodecContext::bit_rate
int64_t bit_rate
the average bitrate
Definition: avcodec.h:501
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:532
vstats_file
FILE * vstats_file
Definition: ffmpeg.c:88
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:672
double
double
Definition: af_crystalizer.c:132
of_stream_init
int of_stream_init(OutputFile *of, OutputStream *ost, const AVCodecContext *enc_ctx)
Definition: ffmpeg_mux.c:611
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:641
EncoderThread::pkt
AVPacket * pkt
Definition: ffmpeg_enc.c:68
ENC_STATS_PTS_TIME_IN
@ ENC_STATS_PTS_TIME_IN
Definition: ffmpeg.h:514
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:2356
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:275
enc_thread_init
static int enc_thread_init(EncoderThread *et)
Definition: ffmpeg_enc.c:831
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
EncoderPriv::sch
Scheduler * sch
Definition: ffmpeg_enc.c:56
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:518
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
hw_device_setup_for_encode
static int hw_device_setup_for_encode(Encoder *e, AVCodecContext *enc_ctx, AVBufferRef *frames_ref)
Definition: ffmpeg_enc.c:133
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
AVSubtitle::end_display_time
uint32_t end_display_time
Definition: avcodec.h:2241
frame.h
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
EncoderPriv::data_size
uint64_t data_size
Definition: ffmpeg_enc.c:48
FrameData::pts
int64_t pts
Definition: ffmpeg.h:664
EncoderPriv::opened
int opened
Definition: ffmpeg_enc.c:53
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.h:565
ENC_STATS_FRAME_NUM
@ ENC_STATS_FRAME_NUM
Definition: ffmpeg.h:507
KeyframeForceCtx
Definition: ffmpeg.h:549
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:220
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:815
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:670
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
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
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
AVCodecContext::hw_device_ctx
AVBufferRef * hw_device_ctx
A reference to the AVHWDeviceContext describing the device which will be used by a hardware encoder/d...
Definition: avcodec.h:1507
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:506
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:517
AV_FRAME_FLAG_INTERLACED
#define AV_FRAME_FLAG_INTERLACED
A flag to mark frames whose content is interlaced.
Definition: frame.h:648
AVCodecContext::hw_frames_ctx
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames.
Definition: avcodec.h:1485
avcodec.h
AVHWFramesContext
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:115
InputStream::decoder
Decoder * decoder
Definition: ffmpeg.h:451
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:203
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:80
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
EncoderThread::frame
AVFrame * frame
Definition: ffmpeg_enc.c:67
EncoderPriv
Definition: ffmpeg_enc.c:41
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
enc_open
int enc_open(void *opaque, const AVFrame *frame)
Definition: ffmpeg_enc.c:184
AVRational::den
int den
Denominator.
Definition: rational.h:60
KeyframeForceCtx::index
int index
Definition: ffmpeg.h:557
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
EncoderPriv::e
Encoder e
Definition: ffmpeg_enc.c:42
do_subtitle_out
static int do_subtitle_out(OutputFile *of, OutputStream *ost, const AVSubtitle *sub, AVPacket *pkt)
Definition: ffmpeg_enc.c:372
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:426
check_recording_time
static int check_recording_time(OutputStream *ost, int64_t ts, AVRational tb)
Definition: ffmpeg_enc.c:361
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:71
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
enc_alloc
int enc_alloc(Encoder **penc, const AVCodec *codec, Scheduler *sch, unsigned sch_idx, void *log_parent)
Definition: ffmpeg_enc.c:99
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:559
FKF_N_FORCED
@ FKF_N_FORCED
Definition: ffmpeg.h:493
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:525
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
HWDevice::type
enum AVHWDeviceType type
Definition: ffmpeg.h:111
EncStats::nb_components
int nb_components
Definition: ffmpeg.h:534
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:519
timestamp.h
OutputStream
Definition: mux.c:53
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
EncoderPriv::log_parent
void * log_parent
Definition: ffmpeg_enc.c:44
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:492
ENC_STATS_DTS_TIME
@ ENC_STATS_DTS_TIME
Definition: ffmpeg.h:516
OutputFile::recording_time
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:648
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:536
update_video_stats
static int update_video_stats(OutputStream *ost, const AVPacket *pkt, int write_vstats)
Definition: ffmpeg_enc.c:539
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:509
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:3090
EncoderThread
Definition: ffmpeg_enc.c:66
OutputFile
Definition: ffmpeg.h:638
pthread_mutex_lock
#define pthread_mutex_lock(a)
Definition: ffprobe.c:78
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216