FFmpeg: fftools/ffmpeg.c Source File

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

AltStyle によって変換されたページ (->オリジナル) /