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/bprint.h"
72 #include "libavutil/dict.h"
73 #include "libavutil/mem.h"
74 #include "libavutil/time.h"
75 
76 #include "libavformat/avformat.h"
77 
78 #include "libavdevice/avdevice.h"
79 
80 #include "cmdutils.h"
81 #include "ffmpeg.h"
82 #include "ffmpeg_sched.h"
83 #include "ffmpeg_utils.h"
84 
85 const char program_name[] = "ffmpeg";
86 const int program_birth_year = 2000;
87 
89 
90 typedef struct BenchmarkTimeStamps {
91  int64_t real_usec;
92  int64_t user_usec;
93  int64_t sys_usec;
95 
97 static int64_t getmaxrss(void);
98 
100 
103 
106 
109 
112 
115 
116 #if HAVE_TERMIOS_H
117 
118 /* init terminal so that we can grab keys */
119 static struct termios oldtty;
120 static int restore_tty;
121 #endif
122 
123 static void term_exit_sigsafe(void)
124 {
125 #if HAVE_TERMIOS_H
126  if(restore_tty)
127  tcsetattr (0, TCSANOW, &oldtty);
128 #endif
129 }
130 
131 void term_exit(void)
132 {
133  av_log(NULL, AV_LOG_QUIET, "%s", "");
135 }
136 
137 static volatile int received_sigterm = 0;
138 static volatile int received_nb_signals = 0;
140 static volatile int ffmpeg_exited = 0;
142 
143 static void
145 {
146  int ret;
147  received_sigterm = sig;
150  if(received_nb_signals > 3) {
151  ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
152  strlen("Received > 3 system signals, hard exiting\n"));
153  if (ret < 0) { /* Do nothing */ };
154  exit(123);
155  }
156 }
157 
158 #if HAVE_SETCONSOLECTRLHANDLER
159 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
160 {
161  av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
162 
163  switch (fdwCtrlType)
164  {
165  case CTRL_C_EVENT:
166  case CTRL_BREAK_EVENT:
167  sigterm_handler(SIGINT);
168  return TRUE;
169 
170  case CTRL_CLOSE_EVENT:
171  case CTRL_LOGOFF_EVENT:
172  case CTRL_SHUTDOWN_EVENT:
173  sigterm_handler(SIGTERM);
174  /* Basically, with these 3 events, when we return from this method the
175  process is hard terminated, so stall as long as we need to
176  to try and let the main thread(s) clean up and gracefully terminate
177  (we have at most 5 seconds, but should be done far before that). */
178  while (!ffmpeg_exited) {
179  Sleep(0);
180  }
181  return TRUE;
182 
183  default:
184  av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
185  return FALSE;
186  }
187 }
188 #endif
189 
190 #ifdef __linux__
191 #define SIGNAL(sig, func) \
192  do { \
193  action.sa_handler = func; \
194  sigaction(sig, &action, NULL); \
195  } while (0)
196 #else
197 #define SIGNAL(sig, func) \
198  signal(sig, func)
199 #endif
200 
201 void term_init(void)
202 {
203 #if defined __linux__
204  struct sigaction action = {0};
205  action.sa_handler = sigterm_handler;
206 
207  /* block other interrupts while processing this one */
208  sigfillset(&action.sa_mask);
209 
210  /* restart interruptible functions (i.e. don't fail with EINTR) */
211  action.sa_flags = SA_RESTART;
212 #endif
213 
214 #if HAVE_TERMIOS_H
215  if (stdin_interaction) {
216  struct termios tty;
217  if (tcgetattr (0, &tty) == 0) {
218  oldtty = tty;
219  restore_tty = 1;
220 
221  tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
222  |INLCR|IGNCR|ICRNL|IXON);
223  tty.c_oflag |= OPOST;
224  tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
225  tty.c_cflag &= ~(CSIZE|PARENB);
226  tty.c_cflag |= CS8;
227  tty.c_cc[VMIN] = 1;
228  tty.c_cc[VTIME] = 0;
229 
230  tcsetattr (0, TCSANOW, &tty);
231  }
232  SIGNAL(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
233  }
234 #endif
235 
236  SIGNAL(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
237  SIGNAL(SIGTERM, sigterm_handler); /* Termination (ANSI). */
238 #ifdef SIGXCPU
239  SIGNAL(SIGXCPU, sigterm_handler);
240 #endif
241 #ifdef SIGPIPE
242  signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
243 #endif
244 #if HAVE_SETCONSOLECTRLHANDLER
245  SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
246 #endif
247 }
248 
249 /* read a key without blocking */
250 static int read_key(void)
251 {
252  unsigned char ch;
253 #if HAVE_TERMIOS_H
254  int n = 1;
255  struct timeval tv;
256  fd_set rfds;
257 
258  FD_ZERO(&rfds);
259  FD_SET(0, &rfds);
260  tv.tv_sec = 0;
261  tv.tv_usec = 0;
262  n = select(1, &rfds, NULL, NULL, &tv);
263  if (n > 0) {
264  n = read(0, &ch, 1);
265  if (n == 1)
266  return ch;
267 
268  return n;
269  }
270 #elif HAVE_KBHIT
271 # if HAVE_PEEKNAMEDPIPE && HAVE_GETSTDHANDLE
272  static int is_pipe;
273  static HANDLE input_handle;
274  DWORD dw, nchars;
275  if(!input_handle){
276  input_handle = GetStdHandle(STD_INPUT_HANDLE);
277  is_pipe = !GetConsoleMode(input_handle, &dw);
278  }
279 
280  if (is_pipe) {
281  /* When running under a GUI, you will end here. */
282  if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
283  // input pipe may have been closed by the program that ran ffmpeg
284  return -1;
285  }
286  //Read it
287  if(nchars != 0) {
288  read(0, &ch, 1);
289  return ch;
290  }else{
291  return -1;
292  }
293  }
294 # endif
295  if(kbhit())
296  return(getch());
297 #endif
298  return -1;
299 }
300 
301 static int decode_interrupt_cb(void *ctx)
302 {
304 }
305 
307 
308 static void ffmpeg_cleanup(int ret)
309 {
310  if (do_benchmark) {
311  int maxrss = getmaxrss() / 1024;
312  av_log(NULL, AV_LOG_INFO, "bench: maxrss=%iKiB\n", maxrss);
313  }
314 
315  for (int i = 0; i < nb_filtergraphs; i++)
318 
319  for (int i = 0; i < nb_output_files; i++)
321 
322  for (int i = 0; i < nb_input_files; i++)
324 
325  for (int i = 0; i < nb_decoders; i++)
326  dec_free(&decoders[i]);
327  av_freep(&decoders);
328 
329  if (vstats_file) {
330  if (fclose(vstats_file))
332  "Error closing vstats file, loss of information possible: %s\n",
333  av_err2str(AVERROR(errno)));
334  }
337 
339 
341 
344 
345  uninit_opts();
346 
348 
349  if (received_sigterm) {
350  av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
351  (int) received_sigterm);
352  } else if (ret && atomic_load(&transcode_init_done)) {
353  av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
354  }
355  term_exit();
356  ffmpeg_exited = 1;
357 }
358 
360 {
361  int of_idx = prev ? prev->file->index : 0;
362  int ost_idx = prev ? prev->index + 1 : 0;
363 
364  for (; of_idx < nb_output_files; of_idx++) {
365  OutputFile *of = output_files[of_idx];
366  if (ost_idx < of->nb_streams)
367  return of->streams[ost_idx];
368 
369  ost_idx = 0;
370  }
371 
372  return NULL;
373 }
374 
376 {
377  int if_idx = prev ? prev->file->index : 0;
378  int ist_idx = prev ? prev->index + 1 : 0;
379 
380  for (; if_idx < nb_input_files; if_idx++) {
381  InputFile *f = input_files[if_idx];
382  if (ist_idx < f->nb_streams)
383  return f->streams[ist_idx];
384 
385  ist_idx = 0;
386  }
387 
388  return NULL;
389 }
390 
391 static void frame_data_free(void *opaque, uint8_t *data)
392 {
393  FrameData *fd = (FrameData *)data;
394 
396 
397  av_free(data);
398 }
399 
400 static int frame_data_ensure(AVBufferRef **dst, int writable)
401 {
402  AVBufferRef *src = *dst;
403 
404  if (!src || (writable && !av_buffer_is_writable(src))) {
405  FrameData *fd;
406 
407  fd = av_mallocz(sizeof(*fd));
408  if (!fd)
409  return AVERROR(ENOMEM);
410 
411  *dst = av_buffer_create((uint8_t *)fd, sizeof(*fd),
412  frame_data_free, NULL, 0);
413  if (!*dst) {
415  av_freep(&fd);
416  return AVERROR(ENOMEM);
417  }
418 
419  if (src) {
420  const FrameData *fd_src = (const FrameData *)src->data;
421 
422  memcpy(fd, fd_src, sizeof(*fd));
423  fd->par_enc = NULL;
424 
425  if (fd_src->par_enc) {
426  int ret = 0;
427 
428  fd->par_enc = avcodec_parameters_alloc();
429  ret = fd->par_enc ?
430  avcodec_parameters_copy(fd->par_enc, fd_src->par_enc) :
431  AVERROR(ENOMEM);
432  if (ret < 0) {
433  av_buffer_unref(dst);
435  return ret;
436  }
437  }
438 
440  } else {
441  fd->dec.frame_num = UINT64_MAX;
442  fd->dec.pts = AV_NOPTS_VALUE;
443 
444  for (unsigned i = 0; i < FF_ARRAY_ELEMS(fd->wallclock); i++)
445  fd->wallclock[i] = INT64_MIN;
446  }
447  }
448 
449  return 0;
450 }
451 
453 {
454  int ret = frame_data_ensure(&frame->opaque_ref, 1);
455  return ret < 0 ? NULL : (FrameData*)frame->opaque_ref->data;
456 }
457 
459 {
460  int ret = frame_data_ensure(&frame->opaque_ref, 0);
461  return ret < 0 ? NULL : (const FrameData*)frame->opaque_ref->data;
462 }
463 
465 {
466  int ret = frame_data_ensure(&pkt->opaque_ref, 1);
467  return ret < 0 ? NULL : (FrameData*)pkt->opaque_ref->data;
468 }
469 
471 {
472  int ret = frame_data_ensure(&pkt->opaque_ref, 0);
473  return ret < 0 ? NULL : (const FrameData*)pkt->opaque_ref->data;
474 }
475 
477 {
478  const AVDictionaryEntry *t = NULL;
479 
480  while ((t = av_dict_iterate(b, t))) {
482  }
483 }
484 
486 {
487  const AVDictionaryEntry *t = av_dict_iterate(m, NULL);
488  if (t) {
489  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
491  }
492 
493  return 0;
494 }
495 
496 void update_benchmark(const char *fmt, ...)
497 {
498  if (do_benchmark_all) {
500  va_list va;
501  char buf[1024];
502 
503  if (fmt) {
504  va_start(va, fmt);
505  vsnprintf(buf, sizeof(buf), fmt, va);
506  va_end(va);
508  "bench: %8" PRIu64 " user %8" PRIu64 " sys %8" PRIu64 " real %s \n",
511  t.real_usec - current_time.real_usec, buf);
512  }
513  current_time = t;
514  }
515 }
516 
517 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time, int64_t pts)
518 {
519  AVBPrint buf, buf_script;
520  int64_t total_size = of_filesize(output_files[0]);
521  int vid;
522  double bitrate;
523  double speed;
524  static int64_t last_time = -1;
525  static int first_report = 1;
526  uint64_t nb_frames_dup = 0, nb_frames_drop = 0;
527  int mins, secs, us;
528  int64_t hours;
529  const char *hours_sign;
530  int ret;
531  float t;
532 
533  if (!print_stats && !is_last_report && !progress_avio)
534  return;
535 
536  if (!is_last_report) {
537  if (last_time == -1) {
538  last_time = cur_time;
539  }
540  if (((cur_time - last_time) < stats_period && !first_report) ||
541  (first_report && atomic_load(&nb_output_dumped) < nb_output_files))
542  return;
543  last_time = cur_time;
544  }
545 
546  t = (cur_time-timer_start) / 1000000.0;
547 
548  vid = 0;
550  av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
551  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
552  const float q = ost->enc ? atomic_load(&ost->quality) / (float) FF_QP2LAMBDA : -1;
553 
554  if (vid && ost->type == AVMEDIA_TYPE_VIDEO) {
555  av_bprintf(&buf, "q=%2.1f ", q);
556  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
557  ost->file->index, ost->index, q);
558  }
559  if (!vid && ost->type == AVMEDIA_TYPE_VIDEO && ost->filter) {
560  float fps;
561  uint64_t frame_number = atomic_load(&ost->packets_written);
562 
563  fps = t > 1 ? frame_number / t : 0;
564  av_bprintf(&buf, "frame=%5"PRId64" fps=%3.*f q=%3.1f ",
565  frame_number, fps < 9.95, fps, q);
566  av_bprintf(&buf_script, "frame=%"PRId64"\n", frame_number);
567  av_bprintf(&buf_script, "fps=%.2f\n", fps);
568  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
569  ost->file->index, ost->index, q);
570  if (is_last_report)
571  av_bprintf(&buf, "L");
572 
573  nb_frames_dup = atomic_load(&ost->filter->nb_frames_dup);
574  nb_frames_drop = atomic_load(&ost->filter->nb_frames_drop);
575 
576  vid = 1;
577  }
578  }
579 
580  if (copy_ts) {
581  if (copy_ts_first_pts == AV_NOPTS_VALUE && pts > 1)
585  }
586 
588  secs = FFABS64U(pts) / AV_TIME_BASE % 60;
589  mins = FFABS64U(pts) / AV_TIME_BASE / 60 % 60;
590  hours = FFABS64U(pts) / AV_TIME_BASE / 3600;
591  hours_sign = (pts < 0) ? "-" : "";
592 
593  bitrate = pts != AV_NOPTS_VALUE && pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
594  speed = pts != AV_NOPTS_VALUE && t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
595 
596  if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
597  else av_bprintf(&buf, "size=%8.0fKiB time=", total_size / 1024.0);
598  if (pts == AV_NOPTS_VALUE) {
599  av_bprintf(&buf, "N/A ");
600  } else {
601  av_bprintf(&buf, "%s%02"PRId64":%02d:%02d.%02d ",
602  hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
603  }
604 
605  if (bitrate < 0) {
606  av_bprintf(&buf, "bitrate=N/A");
607  av_bprintf(&buf_script, "bitrate=N/A\n");
608  }else{
609  av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
610  av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
611  }
612 
613  if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
614  else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
615  if (pts == AV_NOPTS_VALUE) {
616  av_bprintf(&buf_script, "out_time_us=N/A\n");
617  av_bprintf(&buf_script, "out_time_ms=N/A\n");
618  av_bprintf(&buf_script, "out_time=N/A\n");
619  } else {
620  av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
621  av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
622  av_bprintf(&buf_script, "out_time=%s%02"PRId64":%02d:%02d.%06d\n",
623  hours_sign, hours, mins, secs, us);
624  }
625 
626  if (nb_frames_dup || nb_frames_drop)
627  av_bprintf(&buf, " dup=%"PRId64" drop=%"PRId64, nb_frames_dup, nb_frames_drop);
628  av_bprintf(&buf_script, "dup_frames=%"PRId64"\n", nb_frames_dup);
629  av_bprintf(&buf_script, "drop_frames=%"PRId64"\n", nb_frames_drop);
630 
631  if (speed < 0) {
632  av_bprintf(&buf, " speed=N/A");
633  av_bprintf(&buf_script, "speed=N/A\n");
634  } else {
635  av_bprintf(&buf, " speed=%4.3gx", speed);
636  av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
637  }
638 
639  if (print_stats || is_last_report) {
640  const char end = is_last_report ? '\n' : '\r';
641  if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
642  fprintf(stderr, "%s %c", buf.str, end);
643  } else
644  av_log(NULL, AV_LOG_INFO, "%s %c", buf.str, end);
645 
646  fflush(stderr);
647  }
648  av_bprint_finalize(&buf, NULL);
649 
650  if (progress_avio) {
651  av_bprintf(&buf_script, "progress=%s\n",
652  is_last_report ? "end" : "continue");
653  avio_write(progress_avio, buf_script.str,
654  FFMIN(buf_script.len, buf_script.size - 1));
656  av_bprint_finalize(&buf_script, NULL);
657  if (is_last_report) {
658  if ((ret = avio_closep(&progress_avio)) < 0)
660  "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
661  }
662  }
663 
664  first_report = 0;
665 }
666 
667 static void print_stream_maps(void)
668 {
669  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
670  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
671  for (int j = 0; j < ist->nb_filters; j++) {
672  if (!filtergraph_is_simple(ist->filters[j]->graph)) {
673  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
674  ist->file->index, ist->index, ist->dec ? ist->dec->name : "?",
675  ist->filters[j]->name);
676  if (nb_filtergraphs > 1)
677  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
678  av_log(NULL, AV_LOG_INFO, "\n");
679  }
680  }
681  }
682 
683  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
684  if (ost->attachment_filename) {
685  /* an attached file */
686  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
687  ost->attachment_filename, ost->file->index, ost->index);
688  continue;
689  }
690 
691  if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
692  /* output from a complex graph */
693  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
694  if (nb_filtergraphs > 1)
695  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
696 
697  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file->index,
698  ost->index, ost->enc_ctx->codec->name);
699  continue;
700  }
701 
702  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
703  ost->ist->file->index,
704  ost->ist->index,
705  ost->file->index,
706  ost->index);
707  if (ost->enc_ctx) {
708  const AVCodec *in_codec = ost->ist->dec;
709  const AVCodec *out_codec = ost->enc_ctx->codec;
710  const char *decoder_name = "?";
711  const char *in_codec_name = "?";
712  const char *encoder_name = "?";
713  const char *out_codec_name = "?";
714  const AVCodecDescriptor *desc;
715 
716  if (in_codec) {
717  decoder_name = in_codec->name;
718  desc = avcodec_descriptor_get(in_codec->id);
719  if (desc)
720  in_codec_name = desc->name;
721  if (!strcmp(decoder_name, in_codec_name))
722  decoder_name = "native";
723  }
724 
725  if (out_codec) {
726  encoder_name = out_codec->name;
727  desc = avcodec_descriptor_get(out_codec->id);
728  if (desc)
729  out_codec_name = desc->name;
730  if (!strcmp(encoder_name, out_codec_name))
731  encoder_name = "native";
732  }
733 
734  av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
735  in_codec_name, decoder_name,
736  out_codec_name, encoder_name);
737  } else
738  av_log(NULL, AV_LOG_INFO, " (copy)");
739  av_log(NULL, AV_LOG_INFO, "\n");
740  }
741 }
742 
743 static void set_tty_echo(int on)
744 {
745 #if HAVE_TERMIOS_H
746  struct termios tty;
747  if (tcgetattr(0, &tty) == 0) {
748  if (on) tty.c_lflag |= ECHO;
749  else tty.c_lflag &= ~ECHO;
750  tcsetattr(0, TCSANOW, &tty);
751  }
752 #endif
753 }
754 
755 static int check_keyboard_interaction(int64_t cur_time)
756 {
757  int i, key;
758  static int64_t last_time;
760  return AVERROR_EXIT;
761  /* read_key() returns 0 on EOF */
762  if (cur_time - last_time >= 100000) {
763  key = read_key();
764  last_time = cur_time;
765  }else
766  key = -1;
767  if (key == 'q') {
768  av_log(NULL, AV_LOG_INFO, "\n\n[q] command received. Exiting.\n\n");
769  return AVERROR_EXIT;
770  }
771  if (key == '+') av_log_set_level(av_log_get_level()+10);
772  if (key == '-') av_log_set_level(av_log_get_level()-10);
773  if (key == 'c' || key == 'C'){
774  char buf[4096], target[64], command[256], arg[256] = {0};
775  double time;
776  int k, n = 0;
777  fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
778  i = 0;
779  set_tty_echo(1);
780  while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
781  if (k > 0)
782  buf[i++] = k;
783  buf[i] = 0;
784  set_tty_echo(0);
785  fprintf(stderr, "\n");
786  if (k > 0 &&
787  (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
788  av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
789  target, time, command, arg);
790  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
791  if (ost->fg_simple)
792  fg_send_command(ost->fg_simple, time, target, command, arg,
793  key == 'C');
794  }
795  for (i = 0; i < nb_filtergraphs; i++)
796  fg_send_command(filtergraphs[i], time, target, command, arg,
797  key == 'C');
798  } else {
800  "Parse error, at least 3 arguments were expected, "
801  "only %d given in string '%s'\n", n, buf);
802  }
803  }
804  if (key == '?'){
805  fprintf(stderr, "key function\n"
806  "? show this help\n"
807  "+ increase verbosity\n"
808  "- decrease verbosity\n"
809  "c Send command to first matching filter supporting it\n"
810  "C Send/Queue command to all matching filters\n"
811  "h dump packets/hex press to cycle through the 3 states\n"
812  "q quit\n"
813  "s Show QP histogram\n"
814  );
815  }
816  return 0;
817 }
818 
819 /*
820  * The following code is the main loop of the file converter
821  */
822 static int transcode(Scheduler *sch)
823 {
824  int ret = 0;
825  int64_t timer_start, transcode_ts = 0;
826 
828 
830 
831  ret = sch_start(sch);
832  if (ret < 0)
833  return ret;
834 
835  if (stdin_interaction) {
836  av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
837  }
838 
839  timer_start = av_gettime_relative();
840 
841  while (!sch_wait(sch, stats_period, &transcode_ts)) {
842  int64_t cur_time= av_gettime_relative();
843 
844  /* if 'q' pressed, exits */
845  if (stdin_interaction)
846  if (check_keyboard_interaction(cur_time) < 0)
847  break;
848 
849  /* dump report by using the output first video and audio streams */
850  print_report(0, timer_start, cur_time, transcode_ts);
851  }
852 
853  ret = sch_stop(sch, &transcode_ts);
854 
855  /* write the trailer if needed */
856  for (int i = 0; i < nb_output_files; i++) {
857  int err = of_write_trailer(output_files[i]);
858  ret = err_merge(ret, err);
859  }
860 
861  term_exit();
862 
863  /* dump report by using the first video and audio streams */
864  print_report(1, timer_start, av_gettime_relative(), transcode_ts);
865 
866  return ret;
867 }
868 
870 {
871  BenchmarkTimeStamps time_stamps = { av_gettime_relative() };
872 #if HAVE_GETRUSAGE
873  struct rusage rusage;
874 
875  getrusage(RUSAGE_SELF, &rusage);
876  time_stamps.user_usec =
877  (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
878  time_stamps.sys_usec =
879  (rusage.ru_stime.tv_sec * 1000000LL) + rusage.ru_stime.tv_usec;
880 #elif HAVE_GETPROCESSTIMES
881  HANDLE proc;
882  FILETIME c, e, k, u;
883  proc = GetCurrentProcess();
884  GetProcessTimes(proc, &c, &e, &k, &u);
885  time_stamps.user_usec =
886  ((int64_t)u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
887  time_stamps.sys_usec =
888  ((int64_t)k.dwHighDateTime << 32 | k.dwLowDateTime) / 10;
889 #else
890  time_stamps.user_usec = time_stamps.sys_usec = 0;
891 #endif
892  return time_stamps;
893 }
894 
895 static int64_t getmaxrss(void)
896 {
897 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
898  struct rusage rusage;
899  getrusage(RUSAGE_SELF, &rusage);
900  return (int64_t)rusage.ru_maxrss * 1024;
901 #elif HAVE_GETPROCESSMEMORYINFO
902  HANDLE proc;
903  PROCESS_MEMORY_COUNTERS memcounters;
904  proc = GetCurrentProcess();
905  memcounters.cb = sizeof(memcounters);
906  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
907  return memcounters.PeakPagefileUsage;
908 #else
909  return 0;
910 #endif
911 }
912 
913 int main(int argc, char **argv)
914 {
915  Scheduler *sch = NULL;
916 
917  int ret;
919 
920  init_dynload();
921 
922  setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
923 
925  parse_loglevel(argc, argv, options);
926 
927 #if CONFIG_AVDEVICE
929 #endif
931 
932  show_banner(argc, argv, options);
933 
934  sch = sch_alloc();
935  if (!sch) {
936  ret = AVERROR(ENOMEM);
937  goto finish;
938  }
939 
940  /* parse options and open all input/output files */
941  ret = ffmpeg_parse_options(argc, argv, sch);
942  if (ret < 0)
943  goto finish;
944 
945  if (nb_output_files <= 0 && nb_input_files == 0) {
946  show_usage();
947  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
948  ret = 1;
949  goto finish;
950  }
951 
952  if (nb_output_files <= 0) {
953  av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
954  ret = 1;
955  goto finish;
956  }
957 
959  ret = transcode(sch);
960  if (ret >= 0 && do_benchmark) {
961  int64_t utime, stime, rtime;
963  utime = current_time.user_usec - ti.user_usec;
964  stime = current_time.sys_usec - ti.sys_usec;
965  rtime = current_time.real_usec - ti.real_usec;
967  "bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
968  utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
969  }
970 
971  ret = received_nb_signals ? 255 :
972  (ret == FFMPEG_ERROR_RATE_EXCEEDED) ? 69 : ret;
973 
974 finish:
975  if (ret == AVERROR_EXIT)
976  ret = 0;
977 
979 
980  sch_free(&sch);
981 
982  return ret;
983 }
FrameData::par_enc
AVCodecParameters * par_enc
Definition: ffmpeg.h:649
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:105
ffmpeg_exited
static volatile int ffmpeg_exited
Definition: ffmpeg.c:140
FrameData
Definition: ffmpeg.h:630
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:251
AV_LOG_QUIET
#define AV_LOG_QUIET
Print no output.
Definition: log.h:162
AVBufferRef::data
uint8_t * data
The data buffer.
Definition: buffer.h:90
fg_free
void fg_free(FilterGraph **pfg)
Definition: ffmpeg_filter.c:990
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:476
BenchmarkTimeStamps::user_usec
int64_t user_usec
Definition: ffmpeg.c:92
frame_data_free
static void frame_data_free(void *opaque, uint8_t *data)
Definition: ffmpeg.c:391
ist_iter
InputStream * ist_iter(InputStream *prev)
Definition: ffmpeg.c:375
InputFile::index
int index
Definition: ffmpeg.h:439
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:374
of_filesize
int64_t of_filesize(OutputFile *of)
Definition: ffmpeg_mux.c:876
current_time
static BenchmarkTimeStamps current_time
Definition: ffmpeg.c:101
OutputStream::index
int index
Definition: ffmpeg.h:550
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
ffmpeg.h
BenchmarkTimeStamps::sys_usec
int64_t sys_usec
Definition: ffmpeg.c:93
progress_avio
AVIOContext * progress_avio
Definition: ffmpeg.c:102
show_usage
void show_usage(void)
Definition: ffmpeg_opt.c:1165
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:86
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
term_exit_sigsafe
static void term_exit_sigsafe(void)
Definition: ffmpeg.c:123
OutputStream::file
struct OutputFile * file
Definition: ffmpeg.h:548
ECHO
#define ECHO(name, type, min, max)
Definition: af_aecho.c:158
AVIOInterruptCB
Callback for checking whether to abort blocking functions.
Definition: avio.h:59
InputStream
Definition: ffmpeg.h:394
filter_nbthreads
char * filter_nbthreads
Definition: ffmpeg_opt.c:75
stats_period
int64_t stats_period
Definition: ffmpeg_opt.c:79
finish
static void finish(void)
Definition: movenc.c:373
sch_stop
int sch_stop(Scheduler *sch, int64_t *finish_ts)
Definition: ffmpeg_sched.c:2504
AVPacket::opaque_ref
AVBufferRef * opaque_ref
AVBufferRef for free use by the API user.
Definition: packet.h:560
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:470
update_benchmark
void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:496
pts
static int64_t pts
Definition: transcode_aac.c:644
us
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
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:3031
avformat_network_init
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:546
InputFile
Definition: ffmpeg.h:436
transcode
static int transcode(Scheduler *sch)
Definition: ffmpeg.c:822
ffmpeg_cleanup
static void ffmpeg_cleanup(int ret)
Definition: ffmpeg.c:308
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
sch_free
void sch_free(Scheduler **psch)
Definition: ffmpeg_sched.c:461
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen.c:29
BenchmarkTimeStamps::real_usec
int64_t real_usec
Definition: ffmpeg.c:91
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
get_benchmark_time_stamps
static BenchmarkTimeStamps get_benchmark_time_stamps(void)
Definition: ffmpeg.c:869
vstats_filename
char * vstats_filename
Definition: ffmpeg_opt.c:52
sch_alloc
Scheduler * sch_alloc(void)
Definition: ffmpeg_sched.c:573
copy_ts_first_pts
static int64_t copy_ts_first_pts
Definition: ffmpeg.c:141
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:201
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:49
limits.h
nb_streams
static int nb_streams
Definition: ffprobe.c:384
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:131
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:1186
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:223
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:75
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:913
Decoder
Definition: ffmpeg.h:380
nb_output_dumped
atomic_uint nb_output_dumped
Definition: ffmpeg.c:99
getmaxrss
static int64_t getmaxrss(void)
Definition: ffmpeg.c:895
check_keyboard_interaction
static int check_keyboard_interaction(int64_t cur_time)
Definition: ffmpeg.c:755
av_log_set_flags
void av_log_set_flags(int arg)
Definition: log.c:452
print_stream_maps
static void print_stream_maps(void)
Definition: ffmpeg.c:667
vstats_file
FILE * vstats_file
Definition: ffmpeg.c:88
ost_iter
OutputStream * ost_iter(OutputStream *prev)
Definition: ffmpeg.c:359
double
double
Definition: af_crystalizer.c:131
time.h
received_nb_signals
static volatile int received_nb_signals
Definition: ffmpeg.c:138
do_benchmark_all
int do_benchmark_all
Definition: ffmpeg_opt.c:63
OutputFile::index
int index
Definition: ffmpeg.h:616
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:104
OutputFile::streams
OutputStream ** streams
Definition: ffmpeg.h:620
Scheduler
Definition: ffmpeg_sched.c:269
FilterGraph
Definition: ffmpeg.h:333
print_stats
int print_stats
Definition: ffmpeg_opt.c:72
decode_interrupt_cb
static int decode_interrupt_cb(void *ctx)
Definition: ffmpeg.c:301
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:517
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
output_files
OutputFile ** output_files
Definition: ffmpeg.c:107
SIGNAL
#define SIGNAL(sig, func)
Definition: ffmpeg.c:197
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
received_sigterm
static volatile int received_sigterm
Definition: ffmpeg.c:137
filtergraph_is_simple
int filtergraph_is_simple(const FilterGraph *fg)
Definition: ffmpeg_filter.c:2025
uninit_opts
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents.
Definition: cmdutils.c:62
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:66
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: ffmpeg.c:485
frame_data
FrameData * frame_data(AVFrame *frame)
Get our axiliary frame data attached to the frame, allocating it if needed.
Definition: ffmpeg.c:452
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:201
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:62
decoders
Decoder ** decoders
Definition: ffmpeg.c:113
nb_decoders
int nb_decoders
Definition: ffmpeg.c:114
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:256
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
vsnprintf
#define vsnprintf
Definition: snprintf.h:36
sigterm_handler
static void sigterm_handler(int sig)
Definition: ffmpeg.c:144
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:256
AVCodec::name
const char * name
Name of the codec implementation.
Definition: codec.h:194
filtergraphs
FilterGraph ** filtergraphs
Definition: ffmpeg.c:110
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:306
nb_output_files
int nb_output_files
Definition: ffmpeg.c:108
frame_data_ensure
static int frame_data_ensure(AVBufferRef **dst, int writable)
Definition: ffmpeg.c:400
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:540
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:97
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
hw_device_free_all
void hw_device_free_all(void)
Definition: ffmpeg_hw.c:286
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:854
avformat_network_deinit
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:558
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:749
transcode_init_done
static atomic_int transcode_init_done
Definition: ffmpeg.c:139
BenchmarkTimeStamps
Definition: ffmpeg.c:90
InputStream::file
struct InputFile * file
Definition: ffmpeg.h:398
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:85
ffmpeg_parse_options
int ffmpeg_parse_options(int argc, char **argv, Scheduler *sch)
desc
const char * desc
Definition: libsvtav1.c:79
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
mem.h
AVBufferRef
A reference to a data buffer.
Definition: buffer.h:82
InputStream::index
int index
Definition: ffmpeg.h:400
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:1596
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:73
AVPacket
This structure stores compressed data.
Definition: packet.h:501
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:649
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:464
nb_filtergraphs
int nb_filtergraphs
Definition: ffmpeg.c:111
sch_start
int sch_start(Scheduler *sch)
Definition: ffmpeg_sched.c:1530
OutputStream
Definition: mux.c:53
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
FFABS64U
#define FFABS64U(a)
Definition: common.h:91
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:3735
set_tty_echo
static void set_tty_echo(int on)
Definition: ffmpeg.c:743
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:458
read_key
static int read_key(void)
Definition: ffmpeg.c:250
of_write_trailer
int of_write_trailer(OutputFile *of)
Definition: ffmpeg_mux.c:741
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:613
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