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 
476 void update_benchmark(const char *fmt, ...)
477 {
478  if (do_benchmark_all) {
480  va_list va;
481  char buf[1024];
482 
483  if (fmt) {
484  va_start(va, fmt);
485  vsnprintf(buf, sizeof(buf), fmt, va);
486  va_end(va);
488  "bench: %8" PRIu64 " user %8" PRIu64 " sys %8" PRIu64 " real %s \n",
491  t.real_usec - current_time.real_usec, buf);
492  }
493  current_time = t;
494  }
495 }
496 
497 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time, int64_t pts)
498 {
499  AVBPrint buf, buf_script;
500  int64_t total_size = of_filesize(output_files[0]);
501  int vid;
502  double bitrate;
503  double speed;
504  static int64_t last_time = -1;
505  static int first_report = 1;
506  uint64_t nb_frames_dup = 0, nb_frames_drop = 0;
507  int mins, secs, us;
508  int64_t hours;
509  const char *hours_sign;
510  int ret;
511  float t;
512 
513  if (!print_stats && !is_last_report && !progress_avio)
514  return;
515 
516  if (!is_last_report) {
517  if (last_time == -1) {
518  last_time = cur_time;
519  }
520  if (((cur_time - last_time) < stats_period && !first_report) ||
521  (first_report && atomic_load(&nb_output_dumped) < nb_output_files))
522  return;
523  last_time = cur_time;
524  }
525 
526  t = (cur_time-timer_start) / 1000000.0;
527 
528  vid = 0;
530  av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
531  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
532  const float q = ost->enc ? atomic_load(&ost->quality) / (float) FF_QP2LAMBDA : -1;
533 
534  if (vid && ost->type == AVMEDIA_TYPE_VIDEO) {
535  av_bprintf(&buf, "q=%2.1f ", q);
536  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
537  ost->file->index, ost->index, q);
538  }
539  if (!vid && ost->type == AVMEDIA_TYPE_VIDEO && ost->filter) {
540  float fps;
541  uint64_t frame_number = atomic_load(&ost->packets_written);
542 
543  fps = t > 1 ? frame_number / t : 0;
544  av_bprintf(&buf, "frame=%5"PRId64" fps=%3.*f q=%3.1f ",
545  frame_number, fps < 9.95, fps, q);
546  av_bprintf(&buf_script, "frame=%"PRId64"\n", frame_number);
547  av_bprintf(&buf_script, "fps=%.2f\n", fps);
548  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
549  ost->file->index, ost->index, q);
550  if (is_last_report)
551  av_bprintf(&buf, "L");
552 
553  nb_frames_dup = atomic_load(&ost->filter->nb_frames_dup);
554  nb_frames_drop = atomic_load(&ost->filter->nb_frames_drop);
555 
556  vid = 1;
557  }
558  }
559 
560  if (copy_ts) {
561  if (copy_ts_first_pts == AV_NOPTS_VALUE && pts > 1)
565  }
566 
568  secs = FFABS64U(pts) / AV_TIME_BASE % 60;
569  mins = FFABS64U(pts) / AV_TIME_BASE / 60 % 60;
570  hours = FFABS64U(pts) / AV_TIME_BASE / 3600;
571  hours_sign = (pts < 0) ? "-" : "";
572 
573  bitrate = pts != AV_NOPTS_VALUE && pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
574  speed = pts != AV_NOPTS_VALUE && t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
575 
576  if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
577  else av_bprintf(&buf, "size=%8.0fKiB time=", total_size / 1024.0);
578  if (pts == AV_NOPTS_VALUE) {
579  av_bprintf(&buf, "N/A ");
580  } else {
581  av_bprintf(&buf, "%s%02"PRId64":%02d:%02d.%02d ",
582  hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
583  }
584 
585  if (bitrate < 0) {
586  av_bprintf(&buf, "bitrate=N/A");
587  av_bprintf(&buf_script, "bitrate=N/A\n");
588  }else{
589  av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
590  av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
591  }
592 
593  if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
594  else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
595  if (pts == AV_NOPTS_VALUE) {
596  av_bprintf(&buf_script, "out_time_us=N/A\n");
597  av_bprintf(&buf_script, "out_time_ms=N/A\n");
598  av_bprintf(&buf_script, "out_time=N/A\n");
599  } else {
600  av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
601  av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
602  av_bprintf(&buf_script, "out_time=%s%02"PRId64":%02d:%02d.%06d\n",
603  hours_sign, hours, mins, secs, us);
604  }
605 
606  if (nb_frames_dup || nb_frames_drop)
607  av_bprintf(&buf, " dup=%"PRId64" drop=%"PRId64, nb_frames_dup, nb_frames_drop);
608  av_bprintf(&buf_script, "dup_frames=%"PRId64"\n", nb_frames_dup);
609  av_bprintf(&buf_script, "drop_frames=%"PRId64"\n", nb_frames_drop);
610 
611  if (speed < 0) {
612  av_bprintf(&buf, " speed=N/A");
613  av_bprintf(&buf_script, "speed=N/A\n");
614  } else {
615  av_bprintf(&buf, " speed=%4.3gx", speed);
616  av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
617  }
618 
619  if (print_stats || is_last_report) {
620  const char end = is_last_report ? '\n' : '\r';
621  if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
622  fprintf(stderr, "%s %c", buf.str, end);
623  } else
624  av_log(NULL, AV_LOG_INFO, "%s %c", buf.str, end);
625 
626  fflush(stderr);
627  }
628  av_bprint_finalize(&buf, NULL);
629 
630  if (progress_avio) {
631  av_bprintf(&buf_script, "progress=%s\n",
632  is_last_report ? "end" : "continue");
633  avio_write(progress_avio, buf_script.str,
634  FFMIN(buf_script.len, buf_script.size - 1));
636  av_bprint_finalize(&buf_script, NULL);
637  if (is_last_report) {
638  if ((ret = avio_closep(&progress_avio)) < 0)
640  "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
641  }
642  }
643 
644  first_report = 0;
645 }
646 
647 static void print_stream_maps(void)
648 {
649  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
650  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
651  for (int j = 0; j < ist->nb_filters; j++) {
652  if (!filtergraph_is_simple(ist->filters[j]->graph)) {
653  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
654  ist->file->index, ist->index, ist->dec ? ist->dec->name : "?",
655  ist->filters[j]->name);
656  if (nb_filtergraphs > 1)
657  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
658  av_log(NULL, AV_LOG_INFO, "\n");
659  }
660  }
661  }
662 
663  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
664  if (ost->attachment_filename) {
665  /* an attached file */
666  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
667  ost->attachment_filename, ost->file->index, ost->index);
668  continue;
669  }
670 
671  if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
672  /* output from a complex graph */
673  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
674  if (nb_filtergraphs > 1)
675  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
676 
677  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file->index,
678  ost->index, ost->enc_ctx->codec->name);
679  continue;
680  }
681 
682  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
683  ost->ist->file->index,
684  ost->ist->index,
685  ost->file->index,
686  ost->index);
687  if (ost->enc_ctx) {
688  const AVCodec *in_codec = ost->ist->dec;
689  const AVCodec *out_codec = ost->enc_ctx->codec;
690  const char *decoder_name = "?";
691  const char *in_codec_name = "?";
692  const char *encoder_name = "?";
693  const char *out_codec_name = "?";
694  const AVCodecDescriptor *desc;
695 
696  if (in_codec) {
697  decoder_name = in_codec->name;
698  desc = avcodec_descriptor_get(in_codec->id);
699  if (desc)
700  in_codec_name = desc->name;
701  if (!strcmp(decoder_name, in_codec_name))
702  decoder_name = "native";
703  }
704 
705  if (out_codec) {
706  encoder_name = out_codec->name;
707  desc = avcodec_descriptor_get(out_codec->id);
708  if (desc)
709  out_codec_name = desc->name;
710  if (!strcmp(encoder_name, out_codec_name))
711  encoder_name = "native";
712  }
713 
714  av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
715  in_codec_name, decoder_name,
716  out_codec_name, encoder_name);
717  } else
718  av_log(NULL, AV_LOG_INFO, " (copy)");
719  av_log(NULL, AV_LOG_INFO, "\n");
720  }
721 }
722 
723 static void set_tty_echo(int on)
724 {
725 #if HAVE_TERMIOS_H
726  struct termios tty;
727  if (tcgetattr(0, &tty) == 0) {
728  if (on) tty.c_lflag |= ECHO;
729  else tty.c_lflag &= ~ECHO;
730  tcsetattr(0, TCSANOW, &tty);
731  }
732 #endif
733 }
734 
735 static int check_keyboard_interaction(int64_t cur_time)
736 {
737  int i, key;
738  static int64_t last_time;
740  return AVERROR_EXIT;
741  /* read_key() returns 0 on EOF */
742  if (cur_time - last_time >= 100000) {
743  key = read_key();
744  last_time = cur_time;
745  }else
746  key = -1;
747  if (key == 'q') {
748  av_log(NULL, AV_LOG_INFO, "\n\n[q] command received. Exiting.\n\n");
749  return AVERROR_EXIT;
750  }
751  if (key == '+') av_log_set_level(av_log_get_level()+10);
752  if (key == '-') av_log_set_level(av_log_get_level()-10);
753  if (key == 'c' || key == 'C'){
754  char buf[4096], target[64], command[256], arg[256] = {0};
755  double time;
756  int k, n = 0;
757  fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
758  i = 0;
759  set_tty_echo(1);
760  while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
761  if (k > 0)
762  buf[i++] = k;
763  buf[i] = 0;
764  set_tty_echo(0);
765  fprintf(stderr, "\n");
766  if (k > 0 &&
767  (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
768  av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
769  target, time, command, arg);
770  for (OutputStream *ost = ost_iter(NULL); ost; ost = ost_iter(ost)) {
771  if (ost->fg_simple)
772  fg_send_command(ost->fg_simple, time, target, command, arg,
773  key == 'C');
774  }
775  for (i = 0; i < nb_filtergraphs; i++)
776  fg_send_command(filtergraphs[i], time, target, command, arg,
777  key == 'C');
778  } else {
780  "Parse error, at least 3 arguments were expected, "
781  "only %d given in string '%s'\n", n, buf);
782  }
783  }
784  if (key == '?'){
785  fprintf(stderr, "key function\n"
786  "? show this help\n"
787  "+ increase verbosity\n"
788  "- decrease verbosity\n"
789  "c Send command to first matching filter supporting it\n"
790  "C Send/Queue command to all matching filters\n"
791  "h dump packets/hex press to cycle through the 3 states\n"
792  "q quit\n"
793  "s Show QP histogram\n"
794  );
795  }
796  return 0;
797 }
798 
799 /*
800  * The following code is the main loop of the file converter
801  */
802 static int transcode(Scheduler *sch)
803 {
804  int ret = 0;
805  int64_t timer_start, transcode_ts = 0;
806 
808 
810 
811  ret = sch_start(sch);
812  if (ret < 0)
813  return ret;
814 
815  if (stdin_interaction) {
816  av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
817  }
818 
819  timer_start = av_gettime_relative();
820 
821  while (!sch_wait(sch, stats_period, &transcode_ts)) {
822  int64_t cur_time= av_gettime_relative();
823 
824  /* if 'q' pressed, exits */
825  if (stdin_interaction)
826  if (check_keyboard_interaction(cur_time) < 0)
827  break;
828 
829  /* dump report by using the output first video and audio streams */
830  print_report(0, timer_start, cur_time, transcode_ts);
831  }
832 
833  ret = sch_stop(sch, &transcode_ts);
834 
835  /* write the trailer if needed */
836  for (int i = 0; i < nb_output_files; i++) {
837  int err = of_write_trailer(output_files[i]);
838  ret = err_merge(ret, err);
839  }
840 
841  term_exit();
842 
843  /* dump report by using the first video and audio streams */
844  print_report(1, timer_start, av_gettime_relative(), transcode_ts);
845 
846  return ret;
847 }
848 
850 {
851  BenchmarkTimeStamps time_stamps = { av_gettime_relative() };
852 #if HAVE_GETRUSAGE
853  struct rusage rusage;
854 
855  getrusage(RUSAGE_SELF, &rusage);
856  time_stamps.user_usec =
857  (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
858  time_stamps.sys_usec =
859  (rusage.ru_stime.tv_sec * 1000000LL) + rusage.ru_stime.tv_usec;
860 #elif HAVE_GETPROCESSTIMES
861  HANDLE proc;
862  FILETIME c, e, k, u;
863  proc = GetCurrentProcess();
864  GetProcessTimes(proc, &c, &e, &k, &u);
865  time_stamps.user_usec =
866  ((int64_t)u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
867  time_stamps.sys_usec =
868  ((int64_t)k.dwHighDateTime << 32 | k.dwLowDateTime) / 10;
869 #else
870  time_stamps.user_usec = time_stamps.sys_usec = 0;
871 #endif
872  return time_stamps;
873 }
874 
875 static int64_t getmaxrss(void)
876 {
877 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
878  struct rusage rusage;
879  getrusage(RUSAGE_SELF, &rusage);
880  return (int64_t)rusage.ru_maxrss * 1024;
881 #elif HAVE_GETPROCESSMEMORYINFO
882  HANDLE proc;
883  PROCESS_MEMORY_COUNTERS memcounters;
884  proc = GetCurrentProcess();
885  memcounters.cb = sizeof(memcounters);
886  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
887  return memcounters.PeakPagefileUsage;
888 #else
889  return 0;
890 #endif
891 }
892 
893 int main(int argc, char **argv)
894 {
895  Scheduler *sch = NULL;
896 
897  int ret;
899 
900  init_dynload();
901 
902  setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
903 
905  parse_loglevel(argc, argv, options);
906 
907 #if CONFIG_AVDEVICE
909 #endif
911 
912  show_banner(argc, argv, options);
913 
914  sch = sch_alloc();
915  if (!sch) {
916  ret = AVERROR(ENOMEM);
917  goto finish;
918  }
919 
920  /* parse options and open all input/output files */
921  ret = ffmpeg_parse_options(argc, argv, sch);
922  if (ret < 0)
923  goto finish;
924 
925  if (nb_output_files <= 0 && nb_input_files == 0) {
926  show_usage();
927  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
928  ret = 1;
929  goto finish;
930  }
931 
932  if (nb_output_files <= 0) {
933  av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
934  ret = 1;
935  goto finish;
936  }
937 
939  ret = transcode(sch);
940  if (ret >= 0 && do_benchmark) {
941  int64_t utime, stime, rtime;
943  utime = current_time.user_usec - ti.user_usec;
944  stime = current_time.sys_usec - ti.sys_usec;
945  rtime = current_time.real_usec - ti.real_usec;
947  "bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
948  utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
949  }
950 
951  ret = received_nb_signals ? 255 :
952  (ret == FFMPEG_ERROR_RATE_EXCEEDED) ? 69 : ret;
953 
954 finish:
955  if (ret == AVERROR_EXIT)
956  ret = 0;
957 
959 
960  sch_free(&sch);
961 
962  return ret;
963 }
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
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
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
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:556
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:476
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:802
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:849
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
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:893
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:875
check_keyboard_interaction
static int check_keyboard_interaction(int64_t cur_time)
Definition: ffmpeg.c:735
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:647
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:497
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
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
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
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
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:73
AVPacket
This structure stores compressed data.
Definition: packet.h:497
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
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:92
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:723
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
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