FFmpeg
ffmpeg.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2000-2003 Fabrice Bellard
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with FFmpeg; if not, write to the Free Software
18  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 /**
22  * @file
23  * multimedia converter based on the FFmpeg libraries
24  */
25 
26 #include "config.h"
27 
28 #include <errno.h>
29 #include <limits.h>
30 #include <stdatomic.h>
31 #include <stdint.h>
32 #include <stdlib.h>
33 #include <string.h>
34 #include <time.h>
35 
36 #if HAVE_IO_H
37 #include <io.h>
38 #endif
39 #if HAVE_UNISTD_H
40 #include <unistd.h>
41 #endif
42 
43 #if HAVE_SYS_RESOURCE_H
44 #include <sys/time.h>
45 #include <sys/types.h>
46 #include <sys/resource.h>
47 #elif HAVE_GETPROCESSTIMES
48 #include <windows.h>
49 #endif
50 #if HAVE_GETPROCESSMEMORYINFO
51 #include <windows.h>
52 #include <psapi.h>
53 #endif
54 #if HAVE_SETCONSOLECTRLHANDLER
55 #include <windows.h>
56 #endif
57 
58 #if HAVE_SYS_SELECT_H
59 #include <sys/select.h>
60 #endif
61 
62 #if HAVE_TERMIOS_H
63 #include <fcntl.h>
64 #include <sys/ioctl.h>
65 #include <sys/time.h>
66 #include <termios.h>
67 #elif HAVE_KBHIT
68 #include <conio.h>
69 #endif
70 
71 #include "libavutil/avassert.h"
72 #include "libavutil/avstring.h"
73 #include "libavutil/bprint.h"
75 #include "libavutil/dict.h"
76 #include "libavutil/display.h"
77 #include "libavutil/fifo.h"
78 #include "libavutil/hwcontext.h"
79 #include "libavutil/imgutils.h"
80 #include "libavutil/intreadwrite.h"
81 #include "libavutil/libm.h"
82 #include "libavutil/mathematics.h"
83 #include "libavutil/opt.h"
84 #include "libavutil/parseutils.h"
85 #include "libavutil/pixdesc.h"
86 #include "libavutil/samplefmt.h"
87 #include "libavutil/thread.h"
89 #include "libavutil/time.h"
90 #include "libavutil/timestamp.h"
91 
92 #include "libavcodec/version.h"
93 
94 #include "libavformat/avformat.h"
95 
96 #include "libavdevice/avdevice.h"
97 
99 
100 #include "cmdutils.h"
101 #include "ffmpeg.h"
102 #include "ffmpeg_sched.h"
103 #include "ffmpeg_utils.h"
104 #include "sync_queue.h"
105 
106 const char program_name[] = "ffmpeg";
107 const int program_birth_year = 2000;
108 
110 
111 typedef struct BenchmarkTimeStamps {
112  int64_t real_usec;
113  int64_t user_usec;
114  int64_t sys_usec;
116 
118 static int64_t getmaxrss(void);
119 
121 
124 
127 
130 
133 
136 
137 #if HAVE_TERMIOS_H
138 
139 /* init terminal so that we can grab keys */
140 static struct termios oldtty;
141 static int restore_tty;
142 #endif
143 
144 static void term_exit_sigsafe(void)
145 {
146 #if HAVE_TERMIOS_H
147  if(restore_tty)
148  tcsetattr (0, TCSANOW, &oldtty);
149 #endif
150 }
151 
152 void term_exit(void)
153 {
154  av_log(NULL, AV_LOG_QUIET, "%s", "");
156 }
157 
158 static volatile int received_sigterm = 0;
159 static volatile int received_nb_signals = 0;
161 static volatile int ffmpeg_exited = 0;
163 
164 static void
166 {
167  int ret;
168  received_sigterm = sig;
171  if(received_nb_signals > 3) {
172  ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
173  strlen("Received > 3 system signals, hard exiting\n"));
174  if (ret < 0) { /* Do nothing */ };
175  exit(123);
176  }
177 }
178 
179 #if HAVE_SETCONSOLECTRLHANDLER
180 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
181 {
182  av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
183 
184  switch (fdwCtrlType)
185  {
186  case CTRL_C_EVENT:
187  case CTRL_BREAK_EVENT:
188  sigterm_handler(SIGINT);
189  return TRUE;
190 
191  case CTRL_CLOSE_EVENT:
192  case CTRL_LOGOFF_EVENT:
193  case CTRL_SHUTDOWN_EVENT:
194  sigterm_handler(SIGTERM);
195  /* Basically, with these 3 events, when we return from this method the
196  process is hard terminated, so stall as long as we need to
197  to try and let the main thread(s) clean up and gracefully terminate
198  (we have at most 5 seconds, but should be done far before that). */
199  while (!ffmpeg_exited) {
200  Sleep(0);
201  }
202  return TRUE;
203 
204  default:
205  av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
206  return FALSE;
207  }
208 }
209 #endif
210 
211 #ifdef __linux__
212 #define SIGNAL(sig, func) \
213  do { \
214  action.sa_handler = func; \
215  sigaction(sig, &action, NULL); \
216  } while (0)
217 #else
218 #define SIGNAL(sig, func) \
219  signal(sig, func)
220 #endif
221 
222 void term_init(void)
223 {
224 #if defined __linux__
225  struct sigaction action = {0};
226  action.sa_handler = sigterm_handler;
227 
228  /* block other interrupts while processing this one */
229  sigfillset(&action.sa_mask);
230 
231  /* restart interruptible functions (i.e. don't fail with EINTR) */
232  action.sa_flags = SA_RESTART;
233 #endif
234 
235 #if HAVE_TERMIOS_H
236  if (stdin_interaction) {
237  struct termios tty;
238  if (tcgetattr (0, &tty) == 0) {
239  oldtty = tty;
240  restore_tty = 1;
241 
242  tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
243  |INLCR|IGNCR|ICRNL|IXON);
244  tty.c_oflag |= OPOST;
245  tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
246  tty.c_cflag &= ~(CSIZE|PARENB);
247  tty.c_cflag |= CS8;
248  tty.c_cc[VMIN] = 1;
249  tty.c_cc[VTIME] = 0;
250 
251  tcsetattr (0, TCSANOW, &tty);
252  }
253  SIGNAL(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
254  }
255 #endif
256 
257  SIGNAL(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
258  SIGNAL(SIGTERM, sigterm_handler); /* Termination (ANSI). */
259 #ifdef SIGXCPU
260  SIGNAL(SIGXCPU, sigterm_handler);
261 #endif
262 #ifdef SIGPIPE
263  signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
264 #endif
265 #if HAVE_SETCONSOLECTRLHANDLER
266  SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
267 #endif
268 }
269 
270 /* read a key without blocking */
271 static int read_key(void)
272 {
273  unsigned char ch;
274 #if HAVE_TERMIOS_H
275  int n = 1;
276  struct timeval tv;
277  fd_set rfds;
278 
279  FD_ZERO(&rfds);
280  FD_SET(0, &rfds);
281  tv.tv_sec = 0;
282  tv.tv_usec = 0;
283  n = select(1, &rfds, NULL, NULL, &tv);
284  if (n > 0) {
285  n = read(0, &ch, 1);
286  if (n == 1)
287  return ch;
288 
289  return n;
290  }
291 #elif HAVE_KBHIT
292 # if HAVE_PEEKNAMEDPIPE && HAVE_GETSTDHANDLE
293  static int is_pipe;
294  static HANDLE input_handle;
295  DWORD dw, nchars;
296  if(!input_handle){
297  input_handle = GetStdHandle(STD_INPUT_HANDLE);
298  is_pipe = !GetConsoleMode(input_handle, &dw);
299  }
300 
301  if (is_pipe) {
302  /* When running under a GUI, you will end here. */
303  if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
304  // input pipe may have been closed by the program that ran ffmpeg
305  return -1;
306  }
307  //Read it
308  if(nchars != 0) {
309  read(0, &ch, 1);
310  return ch;
311  }else{
312  return -1;
313  }
314  }
315 # endif
316  if(kbhit())
317  return(getch());
318 #endif
319  return -1;
320 }
321 
322 static int decode_interrupt_cb(void *ctx)
323 {
325 }
326 
328 
329 static void ffmpeg_cleanup(int ret)
330 {
331  if (do_benchmark) {
332  int maxrss = getmaxrss() / 1024;
333  av_log(NULL, AV_LOG_INFO, "bench: maxrss=%iKiB\n", maxrss);
334  }
335 
336  for (int i = 0; i < nb_filtergraphs; i++)
339 
340  for (int i = 0; i < nb_output_files; i++)
342 
343  for (int i = 0; i < nb_input_files; i++)
345 
346  for (int i = 0; i < nb_decoders; i++)
347  dec_free(&decoders[i]);
348  av_freep(&decoders);
349 
350  if (vstats_file) {
351  if (fclose(vstats_file))
353  "Error closing vstats file, loss of information possible: %s\n",
354  av_err2str(AVERROR(errno)));
355  }
358 
360 
362 
365 
366  uninit_opts();
367 
369 
370  if (received_sigterm) {
371  av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
372  (int) received_sigterm);
373  } else if (ret && atomic_load(&transcode_init_done)) {
374  av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
375  }
376  term_exit();
377  ffmpeg_exited = 1;
378 }
379 
381 {
382  int of_idx = prev ? prev->file->index : 0;
383  int ost_idx = prev ? prev->index + 1 : 0;
384 
385  for (; of_idx < nb_output_files; of_idx++) {
386  OutputFile *of = output_files[of_idx];
387  if (ost_idx < of->nb_streams)
388  return of->streams[ost_idx];
389 
390  ost_idx = 0;
391  }
392 
393  return NULL;
394 }
395 
397 {
398  int if_idx = prev ? prev->file->index : 0;
399  int ist_idx = prev ? prev->index + 1 : 0;
400 
401  for (; if_idx < nb_input_files; if_idx++) {
402  InputFile *f = input_files[if_idx];
403  if (ist_idx < f->nb_streams)
404  return f->streams[ist_idx];
405 
406  ist_idx = 0;
407  }
408 
409  return NULL;
410 }
411 
412 static void frame_data_free(void *opaque, uint8_t *data)
413 {
414  FrameData *fd = (FrameData *)data;
415 
417 
418  av_free(data);
419 }
420 
421 static int frame_data_ensure(AVBufferRef **dst, int writable)
422 {
423  AVBufferRef *src = *dst;
424 
425  if (!src || (writable && !av_buffer_is_writable(src))) {
426  FrameData *fd;
427 
428  fd = av_mallocz(sizeof(*fd));
429  if (!fd)
430  return AVERROR(ENOMEM);
431 
432  *dst = av_buffer_create((uint8_t *)fd, sizeof(*fd),
433  frame_data_free, NULL, 0);
434  if (!*dst) {
436  av_freep(&fd);
437  return AVERROR(ENOMEM);
438  }
439 
440  if (src) {
441  const FrameData *fd_src = (const FrameData *)src->data;
442 
443  memcpy(fd, fd_src, sizeof(*fd));
444  fd->par_enc = NULL;
445 
446  if (fd_src->par_enc) {
447  int ret = 0;
448 
449  fd->par_enc = avcodec_parameters_alloc();
450  ret = fd->par_enc ?
451  avcodec_parameters_copy(fd->par_enc, fd_src->par_enc) :
452  AVERROR(ENOMEM);
453  if (ret < 0) {
454  av_buffer_unref(dst);
456  return ret;
457  }
458  }
459 
461  } else {
462  fd->dec.frame_num = UINT64_MAX;
463  fd->dec.pts = AV_NOPTS_VALUE;
464 
465  for (unsigned i = 0; i < FF_ARRAY_ELEMS(fd->wallclock); i++)
466  fd->wallclock[i] = INT64_MIN;
467  }
468  }
469 
470  return 0;
471 }
472 
474 {
476  return ret < 0 ? NULL : (FrameData*)frame->opaque_ref->data;
477 }
478 
480 {
482  return ret < 0 ? NULL : (const FrameData*)frame->opaque_ref->data;
483 }
484 
486 {
487  int ret = frame_data_ensure(&pkt->opaque_ref, 1);
488  return ret < 0 ? NULL : (FrameData*)pkt->opaque_ref->data;
489 }
490 
492 {
493  int ret = frame_data_ensure(&pkt->opaque_ref, 0);
494  return ret < 0 ? NULL : (const FrameData*)pkt->opaque_ref->data;
495 }
496 
498 {
499  const AVDictionaryEntry *t = NULL;
500 
501  while ((t = av_dict_iterate(b, t))) {
503  }
504 }
505 
507 {
508  const AVDictionaryEntry *t;
509  if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
510  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
512  }
513 
514  return 0;
515 }
516 
517 void update_benchmark(const char *fmt, ...)
518 {
519  if (do_benchmark_all) {
521  va_list va;
522  char buf[1024];
523 
524  if (fmt) {
525  va_start(va, fmt);
526  vsnprintf(buf, sizeof(buf), fmt, va);
527  va_end(va);
529  "bench: %8" PRIu64 " user %8" PRIu64 " sys %8" PRIu64 " real %s \n",
532  t.real_usec - current_time.real_usec, buf);
533  }
534  current_time = t;
535  }
536 }
537 
538 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time, int64_t pts)
539 {
540  AVBPrint buf, buf_script;
541  int64_t total_size = of_filesize(output_files[0]);
542  int vid;
543  double bitrate;
544  double speed;
545  static int64_t last_time = -1;
546  static int first_report = 1;
547  uint64_t nb_frames_dup = 0, nb_frames_drop = 0;
548  int mins, secs, us;
549  int64_t hours;
550  const char *hours_sign;
551  int ret;
552  float t;
553 
554  if (!print_stats && !is_last_report && !progress_avio)
555  return;
556 
557  if (!is_last_report) {
558  if (last_time == -1) {
559  last_time = cur_time;
560  }
561  if (((cur_time - last_time) < stats_period && !first_report) ||
562  (first_report && atomic_load(&nb_output_dumped) < nb_output_files))
563  return;
564  last_time = cur_time;
565  }
566 
567  t = (cur_time-timer_start) / 1000000.0;
568 
569  vid = 0;
571  av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
572  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
573  const float q = ost->enc ? atomic_load(&ost->quality) / (float) FF_QP2LAMBDA : -1;
574 
575  if (vid && ost->type == AVMEDIA_TYPE_VIDEO) {
576  av_bprintf(&buf, "q=%2.1f ", q);
577  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
578  ost->file->index, ost->index, q);
579  }
580  if (!vid && ost->type == AVMEDIA_TYPE_VIDEO && ost->filter) {
581  float fps;
582  uint64_t frame_number = atomic_load(&ost->packets_written);
583 
584  fps = t > 1 ? frame_number / t : 0;
585  av_bprintf(&buf, "frame=%5"PRId64" fps=%3.*f q=%3.1f ",
586  frame_number, fps < 9.95, fps, q);
587  av_bprintf(&buf_script, "frame=%"PRId64"\n", frame_number);
588  av_bprintf(&buf_script, "fps=%.2f\n", fps);
589  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
590  ost->file->index, ost->index, q);
591  if (is_last_report)
592  av_bprintf(&buf, "L");
593 
594  nb_frames_dup = atomic_load(&ost->filter->nb_frames_dup);
595  nb_frames_drop = atomic_load(&ost->filter->nb_frames_drop);
596 
597  vid = 1;
598  }
599  }
600 
601  if (copy_ts) {
602  if (copy_ts_first_pts == AV_NOPTS_VALUE && pts > 1)
606  }
607 
609  secs = FFABS64U(pts) / AV_TIME_BASE % 60;
610  mins = FFABS64U(pts) / AV_TIME_BASE / 60 % 60;
611  hours = FFABS64U(pts) / AV_TIME_BASE / 3600;
612  hours_sign = (pts < 0) ? "-" : "";
613 
614  bitrate = pts != AV_NOPTS_VALUE && pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
615  speed = pts != AV_NOPTS_VALUE && t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
616 
617  if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
618  else av_bprintf(&buf, "size=%8.0fKiB time=", total_size / 1024.0);
619  if (pts == AV_NOPTS_VALUE) {
620  av_bprintf(&buf, "N/A ");
621  } else {
622  av_bprintf(&buf, "%s%02"PRId64":%02d:%02d.%02d ",
623  hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
624  }
625 
626  if (bitrate < 0) {
627  av_bprintf(&buf, "bitrate=N/A");
628  av_bprintf(&buf_script, "bitrate=N/A\n");
629  }else{
630  av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
631  av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
632  }
633 
634  if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
635  else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
636  if (pts == AV_NOPTS_VALUE) {
637  av_bprintf(&buf_script, "out_time_us=N/A\n");
638  av_bprintf(&buf_script, "out_time_ms=N/A\n");
639  av_bprintf(&buf_script, "out_time=N/A\n");
640  } else {
641  av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
642  av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
643  av_bprintf(&buf_script, "out_time=%s%02"PRId64":%02d:%02d.%06d\n",
644  hours_sign, hours, mins, secs, us);
645  }
646 
647  if (nb_frames_dup || nb_frames_drop)
648  av_bprintf(&buf, " dup=%"PRId64" drop=%"PRId64, nb_frames_dup, nb_frames_drop);
649  av_bprintf(&buf_script, "dup_frames=%"PRId64"\n", nb_frames_dup);
650  av_bprintf(&buf_script, "drop_frames=%"PRId64"\n", nb_frames_drop);
651 
652  if (speed < 0) {
653  av_bprintf(&buf, " speed=N/A");
654  av_bprintf(&buf_script, "speed=N/A\n");
655  } else {
656  av_bprintf(&buf, " speed=%4.3gx", speed);
657  av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
658  }
659 
660  if (print_stats || is_last_report) {
661  const char end = is_last_report ? '\n' : '\r';
662  if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
663  fprintf(stderr, "%s %c", buf.str, end);
664  } else
665  av_log(NULL, AV_LOG_INFO, "%s %c", buf.str, end);
666 
667  fflush(stderr);
668  }
669  av_bprint_finalize(&buf, NULL);
670 
671  if (progress_avio) {
672  av_bprintf(&buf_script, "progress=%s\n",
673  is_last_report ? "end" : "continue");
674  avio_write(progress_avio, buf_script.str,
675  FFMIN(buf_script.len, buf_script.size - 1));
677  av_bprint_finalize(&buf_script, NULL);
678  if (is_last_report) {
679  if ((ret = avio_closep(&progress_avio)) < 0)
681  "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
682  }
683  }
684 
685  first_report = 0;
686 }
687 
688 static void print_stream_maps(void)
689 {
690  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
691  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
692  for (int j = 0; j < ist->nb_filters; j++) {
693  if (!filtergraph_is_simple(ist->filters[j]->graph)) {
694  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
695  ist->file->index, ist->index, ist->dec ? ist->dec->name : "?",
696  ist->filters[j]->name);
697  if (nb_filtergraphs > 1)
698  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
699  av_log(NULL, AV_LOG_INFO, "\n");
700  }
701  }
702  }
703 
704  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
705  if (ost->attachment_filename) {
706  /* an attached file */
707  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
708  ost->attachment_filename, ost->file->index, ost->index);
709  continue;
710  }
711 
712  if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
713  /* output from a complex graph */
714  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
715  if (nb_filtergraphs > 1)
716  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
717 
718  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file->index,
719  ost->index, ost->enc_ctx->codec->name);
720  continue;
721  }
722 
723  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
724  ost->ist->file->index,
725  ost->ist->index,
726  ost->file->index,
727  ost->index);
728  if (ost->enc_ctx) {
729  const AVCodec *in_codec = ost->ist->dec;
730  const AVCodec *out_codec = ost->enc_ctx->codec;
731  const char *decoder_name = "?";
732  const char *in_codec_name = "?";
733  const char *encoder_name = "?";
734  const char *out_codec_name = "?";
735  const AVCodecDescriptor *desc;
736 
737  if (in_codec) {
738  decoder_name = in_codec->name;
739  desc = avcodec_descriptor_get(in_codec->id);
740  if (desc)
741  in_codec_name = desc->name;
742  if (!strcmp(decoder_name, in_codec_name))
743  decoder_name = "native";
744  }
745 
746  if (out_codec) {
747  encoder_name = out_codec->name;
748  desc = avcodec_descriptor_get(out_codec->id);
749  if (desc)
750  out_codec_name = desc->name;
751  if (!strcmp(encoder_name, out_codec_name))
752  encoder_name = "native";
753  }
754 
755  av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
756  in_codec_name, decoder_name,
757  out_codec_name, encoder_name);
758  } else
759  av_log(NULL, AV_LOG_INFO, " (copy)");
760  av_log(NULL, AV_LOG_INFO, "\n");
761  }
762 }
763 
764 static void set_tty_echo(int on)
765 {
766 #if HAVE_TERMIOS_H
767  struct termios tty;
768  if (tcgetattr(0, &tty) == 0) {
769  if (on) tty.c_lflag |= ECHO;
770  else tty.c_lflag &= ~ECHO;
771  tcsetattr(0, TCSANOW, &tty);
772  }
773 #endif
774 }
775 
776 static int check_keyboard_interaction(int64_t cur_time)
777 {
778  int i, key;
779  static int64_t last_time;
781  return AVERROR_EXIT;
782  /* read_key() returns 0 on EOF */
783  if (cur_time - last_time >= 100000) {
784  key = read_key();
785  last_time = cur_time;
786  }else
787  key = -1;
788  if (key == 'q') {
789  av_log(NULL, AV_LOG_INFO, "\n\n[q] command received. Exiting.\n\n");
790  return AVERROR_EXIT;
791  }
792  if (key == '+') av_log_set_level(av_log_get_level()+10);
793  if (key == '-') av_log_set_level(av_log_get_level()-10);
794  if (key == 'c' || key == 'C'){
795  char buf[4096], target[64], command[256], arg[256] = {0};
796  double time;
797  int k, n = 0;
798  fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
799  i = 0;
800  set_tty_echo(1);
801  while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
802  if (k > 0)
803  buf[i++] = k;
804  buf[i] = 0;
805  set_tty_echo(0);
806  fprintf(stderr, "\n");
807  if (k > 0 &&
808  (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
809  av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
810  target, time, command, arg);
811  for (i = 0; i < nb_filtergraphs; i++)
812  fg_send_command(filtergraphs[i], time, target, command, arg,
813  key == 'C');
814  } else {
816  "Parse error, at least 3 arguments were expected, "
817  "only %d given in string '%s'\n", n, buf);
818  }
819  }
820  if (key == '?'){
821  fprintf(stderr, "key function\n"
822  "? show this help\n"
823  "+ increase verbosity\n"
824  "- decrease verbosity\n"
825  "c Send command to first matching filter supporting it\n"
826  "C Send/Queue command to all matching filters\n"
827  "h dump packets/hex press to cycle through the 3 states\n"
828  "q quit\n"
829  "s Show QP histogram\n"
830  );
831  }
832  return 0;
833 }
834 
835 /*
836  * The following code is the main loop of the file converter
837  */
838 static int transcode(Scheduler *sch)
839 {
840  int ret = 0;
841  int64_t timer_start, transcode_ts = 0;
842 
844 
846 
847  ret = sch_start(sch);
848  if (ret < 0)
849  return ret;
850 
851  if (stdin_interaction) {
852  av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
853  }
854 
855  timer_start = av_gettime_relative();
856 
857  while (!sch_wait(sch, stats_period, &transcode_ts)) {
858  int64_t cur_time= av_gettime_relative();
859 
860  /* if 'q' pressed, exits */
861  if (stdin_interaction)
862  if (check_keyboard_interaction(cur_time) < 0)
863  break;
864 
865  /* dump report by using the output first video and audio streams */
866  print_report(0, timer_start, cur_time, transcode_ts);
867  }
868 
869  ret = sch_stop(sch, &transcode_ts);
870 
871  /* write the trailer if needed */
872  for (int i = 0; i < nb_output_files; i++) {
873  int err = of_write_trailer(output_files[i]);
874  ret = err_merge(ret, err);
875  }
876 
877  term_exit();
878 
879  /* dump report by using the first video and audio streams */
880  print_report(1, timer_start, av_gettime_relative(), transcode_ts);
881 
882  return ret;
883 }
884 
886 {
887  BenchmarkTimeStamps time_stamps = { av_gettime_relative() };
888 #if HAVE_GETRUSAGE
889  struct rusage rusage;
890 
891  getrusage(RUSAGE_SELF, &rusage);
892  time_stamps.user_usec =
893  (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
894  time_stamps.sys_usec =
895  (rusage.ru_stime.tv_sec * 1000000LL) + rusage.ru_stime.tv_usec;
896 #elif HAVE_GETPROCESSTIMES
897  HANDLE proc;
898  FILETIME c, e, k, u;
899  proc = GetCurrentProcess();
900  GetProcessTimes(proc, &c, &e, &k, &u);
901  time_stamps.user_usec =
902  ((int64_t)u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
903  time_stamps.sys_usec =
904  ((int64_t)k.dwHighDateTime << 32 | k.dwLowDateTime) / 10;
905 #else
906  time_stamps.user_usec = time_stamps.sys_usec = 0;
907 #endif
908  return time_stamps;
909 }
910 
911 static int64_t getmaxrss(void)
912 {
913 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
914  struct rusage rusage;
915  getrusage(RUSAGE_SELF, &rusage);
916  return (int64_t)rusage.ru_maxrss * 1024;
917 #elif HAVE_GETPROCESSMEMORYINFO
918  HANDLE proc;
919  PROCESS_MEMORY_COUNTERS memcounters;
920  proc = GetCurrentProcess();
921  memcounters.cb = sizeof(memcounters);
922  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
923  return memcounters.PeakPagefileUsage;
924 #else
925  return 0;
926 #endif
927 }
928 
929 int main(int argc, char **argv)
930 {
931  Scheduler *sch = NULL;
932 
933  int ret;
935 
936  init_dynload();
937 
938  setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
939 
941  parse_loglevel(argc, argv, options);
942 
943 #if CONFIG_AVDEVICE
945 #endif
947 
948  show_banner(argc, argv, options);
949 
950  sch = sch_alloc();
951  if (!sch) {
952  ret = AVERROR(ENOMEM);
953  goto finish;
954  }
955 
956  /* parse options and open all input/output files */
957  ret = ffmpeg_parse_options(argc, argv, sch);
958  if (ret < 0)
959  goto finish;
960 
961  if (nb_output_files <= 0 && nb_input_files == 0) {
962  show_usage();
963  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
964  ret = 1;
965  goto finish;
966  }
967 
968  if (nb_output_files <= 0) {
969  av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
970  ret = 1;
971  goto finish;
972  }
973 
975  ret = transcode(sch);
976  if (ret >= 0 && do_benchmark) {
977  int64_t utime, stime, rtime;
979  utime = current_time.user_usec - ti.user_usec;
980  stime = current_time.sys_usec - ti.sys_usec;
981  rtime = current_time.real_usec - ti.real_usec;
983  "bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
984  utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
985  }
986 
987  ret = received_nb_signals ? 255 :
988  (ret == FFMPEG_ERROR_RATE_EXCEEDED) ? 69 : ret;
989 
990 finish:
991  if (ret == AVERROR_EXIT)
992  ret = 0;
993 
995 
996  sch_free(&sch);
997 
998  return ret;
999 }
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:612
AVCodec
AVCodec.
Definition: codec.h:187
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
atomic_store
#define atomic_store(object, desired)
Definition: stdatomic.h:85
err_merge
static int err_merge(int err0, int err1)
Merge two return codes - return one of the error codes if at least one of them was negative,...
Definition: ffmpeg_utils.h:41
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
nb_input_files
int nb_input_files
Definition: ffmpeg.c:126
opt.h
ffmpeg_exited
static volatile int ffmpeg_exited
Definition: ffmpeg.c:161
libm.h
FrameData
Definition: ffmpeg.h:593
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
u
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:250
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:162
thread.h
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
fg_free
void fg_free(FilterGraph **pfg)
Definition: ffmpeg_filter.c:908
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:497
BenchmarkTimeStamps::user_usec
int64_t user_usec
Definition: ffmpeg.c:113
frame_data_free
static void frame_data_free(void *opaque, uint8_t *data)
Definition: ffmpeg.c:412
ist_iter
InputStream * ist_iter(InputStream *prev)
Definition: ffmpeg.c:396
InputFile::index
int index
Definition: ffmpeg.h:392
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:340
pixdesc.h
of_filesize
int64_t of_filesize(OutputFile *of)
Definition: ffmpeg_mux.c:876
sync_queue.h
current_time
static BenchmarkTimeStamps current_time
Definition: ffmpeg.c:122
OutputStream::index
int index
Definition: ffmpeg.h:503
ATOMIC_VAR_INIT
#define ATOMIC_VAR_INIT(value)
Definition: stdatomic.h:31
b
#define b
Definition: input.c:41
data
const char data[16]
Definition: mxf.c:148
atomic_int
intptr_t atomic_int
Definition: stdatomic.h:55
AV_DICT_IGNORE_SUFFIX
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key,...
Definition: dict.h:75
version.h
ffmpeg.h
BenchmarkTimeStamps::sys_usec
int64_t sys_usec
Definition: ffmpeg.c:114
progress_avio
AVIOContext * progress_avio
Definition: ffmpeg.c:123
show_usage
void show_usage(void)
Definition: ffmpeg_opt.c:1172
mathematics.h
AVDictionary
Definition: dict.c:34
program_birth_year
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:107
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
term_exit_sigsafe
static void term_exit_sigsafe(void)
Definition: ffmpeg.c:144
OutputStream::file
struct OutputFile * file
Definition: ffmpeg.h:501
ECHO
#define ECHO(name, type, min, max)
Definition: af_aecho.c:157
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
AVFrame::opaque_ref
AVBufferRef * opaque_ref
Frame owner's private data.
Definition: frame.h:707
InputStream
Definition: ffmpeg.h:345
filter_nbthreads
char * filter_nbthreads
Definition: ffmpeg_opt.c:82
stats_period
int64_t stats_period
Definition: ffmpeg_opt.c:86
fifo.h
finish
static void finish(void)
Definition: movenc.c:342
sch_stop
int sch_stop(Scheduler *sch, int64_t *finish_ts)
Definition: ffmpeg_sched.c:457
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:558
samplefmt.h
AVERROR_OPTION_NOT_FOUND
#define AVERROR_OPTION_NOT_FOUND
Option not found.
Definition: error.h:63
AV_BPRINT_SIZE_AUTOMATIC
#define AV_BPRINT_SIZE_AUTOMATIC
packet_data_c
const FrameData * packet_data_c(AVPacket *pkt)
Definition: ffmpeg.c:491
update_benchmark
void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:517
pts
static int64_t pts
Definition: transcode_aac.c:643
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:262
fg_send_command
void fg_send_command(FilterGraph *fg, double time, const char *target, const char *command, const char *arg, int all_filters)
Definition: ffmpeg_filter.c:2894
avformat_network_init
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:558
InputFile
Definition: ffmpeg.h:389
transcode
static int transcode(Scheduler *sch)
Definition: ffmpeg.c:838
ffmpeg_cleanup
static void ffmpeg_cleanup(int ret)
Definition: ffmpeg.c:329
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
sch_free
void sch_free(Scheduler **psch)
Definition: ffmpeg_sched.c:510
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
BenchmarkTimeStamps::real_usec
int64_t real_usec
Definition: ffmpeg.c:112
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
float
float
Definition: af_crystalizer.c:121
of_free
void of_free(OutputFile **pof)
Definition: ffmpeg_mux.c:850
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
get_benchmark_time_stamps
static BenchmarkTimeStamps get_benchmark_time_stamps(void)
Definition: ffmpeg.c:885
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:59
sch_alloc
Scheduler * sch_alloc(void)
Definition: ffmpeg_sched.c:622
copy_ts_first_pts
static int64_t copy_ts_first_pts
Definition: ffmpeg.c:162
bitrate
int64_t bitrate
Definition: av1_levels.c:47
AVDictionaryEntry::key
char * key
Definition: dict.h:90
term_init
void term_init(void)
Definition: ffmpeg.c:222
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
ctx
AVFormatContext * ctx
Definition: movenc.c:48
limits.h
nb_streams
static int nb_streams
Definition: ffprobe.c:383
on
s EdgeDetect Foobar g libavfilter vf_edgedetect c libavfilter vf_foobar c edit libavfilter and add an entry for foobar following the pattern of the other filters edit libavfilter allfilters and add an entry for foobar following the pattern of the other filters configure make j< whatever > ffmpeg ffmpeg i you should get a foobar png with Lena edge detected That s your new playground is ready Some little details about what s going on
Definition: writing_filters.txt:34
term_exit
void term_exit(void)
Definition: ffmpeg.c:152
ffmpeg_utils.h
key
const char * key
Definition: hwcontext_opencl.c:189
atomic_load
#define atomic_load(object)
Definition: stdatomic.h:93
command
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:1185
frame
static AVFrame * frame
Definition: demux_decode.c:54
arg
const char * arg
Definition: jacosubdec.c:67
of_enc_stats_close
void of_enc_stats_close(void)
Definition: ffmpeg_mux_init.c:196
avio_flush
void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:222
av_log_get_level
int av_log_get_level(void)
Get the current log level.
Definition: log.c:442
init_dynload
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:78
NULL
#define NULL
Definition: coverity.c:32
av_buffer_unref
void av_buffer_unref(AVBufferRef **buf)
Free a given reference and automatically free the buffer if there are no more references to it.
Definition: buffer.c:139
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
main
int main(int argc, char **argv)
Definition: ffmpeg.c:929
Decoder
Definition: ffmpeg.h:331
nb_output_dumped
atomic_uint nb_output_dumped
Definition: ffmpeg.c:120
getmaxrss
static int64_t getmaxrss(void)
Definition: ffmpeg.c:911
check_keyboard_interaction
static int check_keyboard_interaction(int64_t cur_time)
Definition: ffmpeg.c:776
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:452
parseutils.h
print_stream_maps
static void print_stream_maps(void)
Definition: ffmpeg.c:688
vstats_file
FILE * vstats_file
Definition: ffmpeg.c:109
ost_iter
OutputStream * ost_iter(OutputStream *prev)
Definition: ffmpeg.c:380
double
double
Definition: af_crystalizer.c:131
time.h
received_nb_signals
static volatile int received_nb_signals
Definition: ffmpeg.c:159
do_benchmark_all
int do_benchmark_all
Definition: ffmpeg_opt.c:70
OutputFile::index
int index
Definition: ffmpeg.h:577
swresample.h
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
av_buffer_create
AVBufferRef * av_buffer_create(uint8_t *data, size_t size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:55
input_files
InputFile ** input_files
Definition: ffmpeg.c:125
OutputFile::streams
OutputStream ** streams
Definition: ffmpeg.h:582
Scheduler
Definition: ffmpeg_sched.c:263
FilterGraph
Definition: ffmpeg.h:286
print_stats
int print_stats
Definition: ffmpeg_opt.c:79
decode_interrupt_cb
static int decode_interrupt_cb(void *ctx)
Definition: ffmpeg.c:322
options
const OptionDef options[]
print_report
static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time, int64_t pts)
Definition: ffmpeg.c:538
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:240
threadmessage.h
output_files
OutputFile ** output_files
Definition: ffmpeg.c:128
SIGNAL
#define SIGNAL(sig, func)
Definition: ffmpeg.c:218
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
received_sigterm
static volatile int received_sigterm
Definition: ffmpeg.c:158
filtergraph_is_simple
int filtergraph_is_simple(const FilterGraph *fg)
Definition: ffmpeg_filter.c:1889
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:65
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:73
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: ffmpeg.c:506
frame_data
FrameData * frame_data(AVFrame *frame)
Get our axiliary frame data attached to the frame, allocating it if needed.
Definition: ffmpeg.c:473
avdevice.h
show_banner
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: opt_common.c:237
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:200
a
The reader does not expect b to be semantically here and if the code is changed by maybe adding a a division or other the signedness will almost certainly be mistaken To avoid this confusion a new type was SUINT is the C unsigned type but it holds a signed int to use the same example SUINT a
Definition: undefined.txt:41
do_benchmark
int do_benchmark
Definition: ffmpeg_opt.c:69
decoders
Decoder ** decoders
Definition: ffmpeg.c:134
nb_decoders
int nb_decoders
Definition: ffmpeg.c:135
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
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_log_set_level
void av_log_set_level(int level)
Set the log level.
Definition: log.c:447
bprint.h
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:255
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
display.h
vsnprintf
#define vsnprintf
Definition: snprintf.h:36
sigterm_handler
static void sigterm_handler(int sig)
Definition: ffmpeg.c:165
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
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:254
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
filtergraphs
FilterGraph ** filtergraphs
Definition: ffmpeg.c:131
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:327
nb_output_files
int nb_output_files
Definition: ffmpeg.c:129
frame_data_ensure
static int frame_data_ensure(AVBufferRef **dst, int writable)
Definition: ffmpeg.c:421
av_buffer_is_writable
int av_buffer_is_writable(const AVBufferRef *buf)
Definition: buffer.c:147
parse_loglevel
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
Definition: cmdutils.c:543
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
dec_free
void dec_free(Decoder **pdec)
Definition: ffmpeg_dec.c:98
hw_device_free_all
void hw_device_free_all(void)
Definition: ffmpeg_hw.c:288
avformat.h
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:99
dict.h
AV_LOG_SKIP_REPEATED
#define AV_LOG_SKIP_REPEATED
Skip repeated messages, this requires the user app to use av_log() instead of (f)printf as the 2 woul...
Definition: log.h:370
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
ifile_close
void ifile_close(InputFile **f)
Definition: ffmpeg_demux.c:851
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:570
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
transcode_init_done
static atomic_int transcode_init_done
Definition: ffmpeg.c:160
BenchmarkTimeStamps
Definition: ffmpeg.c:111
channel_layout.h
InputStream::file
struct InputFile * file
Definition: ffmpeg.h:349
atomic_uint
intptr_t atomic_uint
Definition: stdatomic.h:56
program_name
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:106
ffmpeg_parse_options
int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
desc
const char * desc
Definition: libsvtav1.c:73
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
InputStream::index
int index
Definition: ffmpeg.h:351
ffmpeg_sched.h
sch_wait
int sch_wait(Scheduler *sch, uint64_t timeout_us, int64_t *transcode_ts)
Wait until transcoding terminates or the specified timeout elapses.
Definition: ffmpeg_sched.c:1626
FFMPEG_ERROR_RATE_EXCEEDED
#define FFMPEG_ERROR_RATE_EXCEEDED
Definition: ffmpeg.h:63
av_free
#define av_free(p)
Definition: tableprint_vlc.h:33
AVDictionaryEntry
Definition: dict.h:89
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:80
AVPacket
This structure stores compressed data.
Definition: packet.h:499
avio_closep
int avio_closep(AVIOContext **s)
Close the resource accessed by the AVIOContext *s, free it and set the pointer pointing to it to NULL...
Definition: avio.c:648
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
src
INIT_CLIP pixel * src
Definition: h264pred_template.c:418
cmdutils.h
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:485
nb_filtergraphs
int nb_filtergraphs
Definition: ffmpeg.c:132
imgutils.h
sch_start
int sch_start(Scheduler *sch)
Definition: ffmpeg_sched.c:1564
timestamp.h
OutputStream
Definition: mux.c:53
hwcontext.h
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFABS64U
#define FFABS64U(a)
Definition: common.h:90
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3727
set_tty_echo
static void set_tty_echo(int on)
Definition: ffmpeg.c:764
avstring.h
FF_QP2LAMBDA
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
frame_data_c
const FrameData * frame_data_c(AVFrame *frame)
Definition: ffmpeg.c:479
read_key
static int read_key(void)
Definition: ffmpeg.c:271
of_write_trailer
int of_write_trailer(OutputFile *of)
Definition: ffmpeg_mux.c:738
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
read
static uint32_t BS_FUNC() read(BSCTX *bc, unsigned int n)
Return n bits from the buffer, n has to be in the 0-32 range.
Definition: bitstream_template.h:231
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
OutputFile
Definition: ffmpeg.h:574
avdevice_register_all
FF_VISIBILITY_POP_HIDDEN av_cold void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:70