FFmpeg  4.1.5
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 #include <ctype.h>
28 #include <string.h>
29 #include <math.h>
30 #include <stdlib.h>
31 #include <errno.h>
32 #include <limits.h>
33 #include <stdatomic.h>
34 #include <stdint.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 #include "libavformat/avformat.h"
44 #include "libavdevice/avdevice.h"
46 #include "libavutil/opt.h"
48 #include "libavutil/parseutils.h"
49 #include "libavutil/samplefmt.h"
50 #include "libavutil/fifo.h"
51 #include "libavutil/hwcontext.h"
52 #include "libavutil/internal.h"
53 #include "libavutil/intreadwrite.h"
54 #include "libavutil/dict.h"
55 #include "libavutil/display.h"
56 #include "libavutil/mathematics.h"
57 #include "libavutil/pixdesc.h"
58 #include "libavutil/avstring.h"
59 #include "libavutil/libm.h"
60 #include "libavutil/imgutils.h"
61 #include "libavutil/timestamp.h"
62 #include "libavutil/bprint.h"
63 #include "libavutil/time.h"
64 #include "libavutil/thread.h"
66 #include "libavcodec/mathops.h"
67 #include "libavformat/os_support.h"
68 
69 # include "libavfilter/avfilter.h"
70 # include "libavfilter/buffersrc.h"
71 # include "libavfilter/buffersink.h"
72 
73 #if HAVE_SYS_RESOURCE_H
74 #include <sys/time.h>
75 #include <sys/types.h>
76 #include <sys/resource.h>
77 #elif HAVE_GETPROCESSTIMES
78 #include <windows.h>
79 #endif
80 #if HAVE_GETPROCESSMEMORYINFO
81 #include <windows.h>
82 #include <psapi.h>
83 #endif
84 #if HAVE_SETCONSOLECTRLHANDLER
85 #include <windows.h>
86 #endif
87 
88 
89 #if HAVE_SYS_SELECT_H
90 #include <sys/select.h>
91 #endif
92 
93 #if HAVE_TERMIOS_H
94 #include <fcntl.h>
95 #include <sys/ioctl.h>
96 #include <sys/time.h>
97 #include <termios.h>
98 #elif HAVE_KBHIT
99 #include <conio.h>
100 #endif
101 
102 #include <time.h>
103 
104 #include "ffmpeg.h"
105 #include "cmdutils.h"
106 
107 #include "libavutil/avassert.h"
108 
109 const char program_name[] = "ffmpeg";
110 const int program_birth_year = 2000;
111 
112 static FILE *vstats_file;
113 
114 const char *const forced_keyframes_const_names[] = {
115  "n",
116  "n_forced",
117  "prev_forced_n",
118  "prev_forced_t",
119  "t",
120  NULL
121 };
122 
123 typedef struct BenchmarkTimeStamps {
124  int64_t real_usec;
125  int64_t user_usec;
126  int64_t sys_usec;
128 
129 static void do_video_stats(OutputStream *ost, int frame_size);
131 static int64_t getmaxrss(void);
133 
134 static int run_as_daemon = 0;
135 static int nb_frames_dup = 0;
136 static unsigned dup_warning = 1000;
137 static int nb_frames_drop = 0;
138 static int64_t decode_error_stat[2];
139 
140 static int want_sdp = 1;
141 
144 
146 
151 
156 
159 
160 #if HAVE_TERMIOS_H
161 
162 /* init terminal so that we can grab keys */
163 static struct termios oldtty;
164 static int restore_tty;
165 #endif
166 
167 #if HAVE_THREADS
168 static void free_input_threads(void);
169 #endif
170 
171 /* sub2video hack:
172  Convert subtitles to video with alpha to insert them in filter graphs.
173  This is a temporary solution until libavfilter gets real subtitles support.
174  */
175 
177 {
178  int ret;
179  AVFrame *frame = ist->sub2video.frame;
180 
181  av_frame_unref(frame);
182  ist->sub2video.frame->width = ist->dec_ctx->width ? ist->dec_ctx->width : ist->sub2video.w;
183  ist->sub2video.frame->height = ist->dec_ctx->height ? ist->dec_ctx->height : ist->sub2video.h;
185  if ((ret = av_frame_get_buffer(frame, 32)) < 0)
186  return ret;
187  memset(frame->data[0], 0, frame->height * frame->linesize[0]);
188  return 0;
189 }
190 
191 static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h,
192  AVSubtitleRect *r)
193 {
194  uint32_t *pal, *dst2;
195  uint8_t *src, *src2;
196  int x, y;
197 
198  if (r->type != SUBTITLE_BITMAP) {
199  av_log(NULL, AV_LOG_WARNING, "sub2video: non-bitmap subtitle\n");
200  return;
201  }
202  if (r->x < 0 || r->x + r->w > w || r->y < 0 || r->y + r->h > h) {
203  av_log(NULL, AV_LOG_WARNING, "sub2video: rectangle (%d %d %d %d) overflowing %d %d\n",
204  r->x, r->y, r->w, r->h, w, h
205  );
206  return;
207  }
208 
209  dst += r->y * dst_linesize + r->x * 4;
210  src = r->data[0];
211  pal = (uint32_t *)r->data[1];
212  for (y = 0; y < r->h; y++) {
213  dst2 = (uint32_t *)dst;
214  src2 = src;
215  for (x = 0; x < r->w; x++)
216  *(dst2++) = pal[*(src2++)];
217  dst += dst_linesize;
218  src += r->linesize[0];
219  }
220 }
221 
222 static void sub2video_push_ref(InputStream *ist, int64_t pts)
223 {
224  AVFrame *frame = ist->sub2video.frame;
225  int i;
226  int ret;
227 
228  av_assert1(frame->data[0]);
229  ist->sub2video.last_pts = frame->pts = pts;
230  for (i = 0; i < ist->nb_filters; i++) {
231  ret = av_buffersrc_add_frame_flags(ist->filters[i]->filter, frame,
234  if (ret != AVERROR_EOF && ret < 0)
235  av_log(NULL, AV_LOG_WARNING, "Error while add the frame to buffer source(%s).\n",
236  av_err2str(ret));
237  }
238 }
239 
241 {
242  AVFrame *frame = ist->sub2video.frame;
243  int8_t *dst;
244  int dst_linesize;
245  int num_rects, i;
246  int64_t pts, end_pts;
247 
248  if (!frame)
249  return;
250  if (sub) {
251  pts = av_rescale_q(sub->pts + sub->start_display_time * 1000LL,
252  AV_TIME_BASE_Q, ist->st->time_base);
253  end_pts = av_rescale_q(sub->pts + sub->end_display_time * 1000LL,
254  AV_TIME_BASE_Q, ist->st->time_base);
255  num_rects = sub->num_rects;
256  } else {
257  pts = ist->sub2video.end_pts;
258  end_pts = INT64_MAX;
259  num_rects = 0;
260  }
261  if (sub2video_get_blank_frame(ist) < 0) {
263  "Impossible to get a blank canvas.\n");
264  return;
265  }
266  dst = frame->data [0];
267  dst_linesize = frame->linesize[0];
268  for (i = 0; i < num_rects; i++)
269  sub2video_copy_rect(dst, dst_linesize, frame->width, frame->height, sub->rects[i]);
270  sub2video_push_ref(ist, pts);
271  ist->sub2video.end_pts = end_pts;
272 }
273 
274 static void sub2video_heartbeat(InputStream *ist, int64_t pts)
275 {
276  InputFile *infile = input_files[ist->file_index];
277  int i, j, nb_reqs;
278  int64_t pts2;
279 
280  /* When a frame is read from a file, examine all sub2video streams in
281  the same file and send the sub2video frame again. Otherwise, decoded
282  video frames could be accumulating in the filter graph while a filter
283  (possibly overlay) is desperately waiting for a subtitle frame. */
284  for (i = 0; i < infile->nb_streams; i++) {
285  InputStream *ist2 = input_streams[infile->ist_index + i];
286  if (!ist2->sub2video.frame)
287  continue;
288  /* subtitles seem to be usually muxed ahead of other streams;
289  if not, subtracting a larger time here is necessary */
290  pts2 = av_rescale_q(pts, ist->st->time_base, ist2->st->time_base) - 1;
291  /* do not send the heartbeat frame if the subtitle is already ahead */
292  if (pts2 <= ist2->sub2video.last_pts)
293  continue;
294  if (pts2 >= ist2->sub2video.end_pts ||
295  (!ist2->sub2video.frame->data[0] && ist2->sub2video.end_pts < INT64_MAX))
296  sub2video_update(ist2, NULL);
297  for (j = 0, nb_reqs = 0; j < ist2->nb_filters; j++)
298  nb_reqs += av_buffersrc_get_nb_failed_requests(ist2->filters[j]->filter);
299  if (nb_reqs)
300  sub2video_push_ref(ist2, pts2);
301  }
302 }
303 
304 static void sub2video_flush(InputStream *ist)
305 {
306  int i;
307  int ret;
308 
309  if (ist->sub2video.end_pts < INT64_MAX)
310  sub2video_update(ist, NULL);
311  for (i = 0; i < ist->nb_filters; i++) {
312  ret = av_buffersrc_add_frame(ist->filters[i]->filter, NULL);
313  if (ret != AVERROR_EOF && ret < 0)
314  av_log(NULL, AV_LOG_WARNING, "Flush the frame error.\n");
315  }
316 }
317 
318 /* end of sub2video hack */
319 
320 static void term_exit_sigsafe(void)
321 {
322 #if HAVE_TERMIOS_H
323  if(restore_tty)
324  tcsetattr (0, TCSANOW, &oldtty);
325 #endif
326 }
327 
328 void term_exit(void)
329 {
330  av_log(NULL, AV_LOG_QUIET, "%s", "");
332 }
333 
334 static volatile int received_sigterm = 0;
335 static volatile int received_nb_signals = 0;
337 static volatile int ffmpeg_exited = 0;
338 static int main_return_code = 0;
339 
340 static void
342 {
343  int ret;
344  received_sigterm = sig;
347  if(received_nb_signals > 3) {
348  ret = write(2/*STDERR_FILENO*/, "Received > 3 system signals, hard exiting\n",
349  strlen("Received > 3 system signals, hard exiting\n"));
350  if (ret < 0) { /* Do nothing */ };
351  exit(123);
352  }
353 }
354 
355 #if HAVE_SETCONSOLECTRLHANDLER
356 static BOOL WINAPI CtrlHandler(DWORD fdwCtrlType)
357 {
358  av_log(NULL, AV_LOG_DEBUG, "\nReceived windows signal %ld\n", fdwCtrlType);
359 
360  switch (fdwCtrlType)
361  {
362  case CTRL_C_EVENT:
363  case CTRL_BREAK_EVENT:
364  sigterm_handler(SIGINT);
365  return TRUE;
366 
367  case CTRL_CLOSE_EVENT:
368  case CTRL_LOGOFF_EVENT:
369  case CTRL_SHUTDOWN_EVENT:
370  sigterm_handler(SIGTERM);
371  /* Basically, with these 3 events, when we return from this method the
372  process is hard terminated, so stall as long as we need to
373  to try and let the main thread(s) clean up and gracefully terminate
374  (we have at most 5 seconds, but should be done far before that). */
375  while (!ffmpeg_exited) {
376  Sleep(0);
377  }
378  return TRUE;
379 
380  default:
381  av_log(NULL, AV_LOG_ERROR, "Received unknown windows signal %ld\n", fdwCtrlType);
382  return FALSE;
383  }
384 }
385 #endif
386 
387 void term_init(void)
388 {
389 #if HAVE_TERMIOS_H
391  struct termios tty;
392  if (tcgetattr (0, &tty) == 0) {
393  oldtty = tty;
394  restore_tty = 1;
395 
396  tty.c_iflag &= ~(IGNBRK|BRKINT|PARMRK|ISTRIP
397  |INLCR|IGNCR|ICRNL|IXON);
398  tty.c_oflag |= OPOST;
399  tty.c_lflag &= ~(ECHO|ECHONL|ICANON|IEXTEN);
400  tty.c_cflag &= ~(CSIZE|PARENB);
401  tty.c_cflag |= CS8;
402  tty.c_cc[VMIN] = 1;
403  tty.c_cc[VTIME] = 0;
404 
405  tcsetattr (0, TCSANOW, &tty);
406  }
407  signal(SIGQUIT, sigterm_handler); /* Quit (POSIX). */
408  }
409 #endif
410 
411  signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
412  signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
413 #ifdef SIGXCPU
414  signal(SIGXCPU, sigterm_handler);
415 #endif
416 #ifdef SIGPIPE
417  signal(SIGPIPE, SIG_IGN); /* Broken pipe (POSIX). */
418 #endif
419 #if HAVE_SETCONSOLECTRLHANDLER
420  SetConsoleCtrlHandler((PHANDLER_ROUTINE) CtrlHandler, TRUE);
421 #endif
422 }
423 
424 /* read a key without blocking */
425 static int read_key(void)
426 {
427  unsigned char ch;
428 #if HAVE_TERMIOS_H
429  int n = 1;
430  struct timeval tv;
431  fd_set rfds;
432 
433  FD_ZERO(&rfds);
434  FD_SET(0, &rfds);
435  tv.tv_sec = 0;
436  tv.tv_usec = 0;
437  n = select(1, &rfds, NULL, NULL, &tv);
438  if (n > 0) {
439  n = read(0, &ch, 1);
440  if (n == 1)
441  return ch;
442 
443  return n;
444  }
445 #elif HAVE_KBHIT
446 # if HAVE_PEEKNAMEDPIPE
447  static int is_pipe;
448  static HANDLE input_handle;
449  DWORD dw, nchars;
450  if(!input_handle){
451  input_handle = GetStdHandle(STD_INPUT_HANDLE);
452  is_pipe = !GetConsoleMode(input_handle, &dw);
453  }
454 
455  if (is_pipe) {
456  /* When running under a GUI, you will end here. */
457  if (!PeekNamedPipe(input_handle, NULL, 0, NULL, &nchars, NULL)) {
458  // input pipe may have been closed by the program that ran ffmpeg
459  return -1;
460  }
461  //Read it
462  if(nchars != 0) {
463  read(0, &ch, 1);
464  return ch;
465  }else{
466  return -1;
467  }
468  }
469 # endif
470  if(kbhit())
471  return(getch());
472 #endif
473  return -1;
474 }
475 
476 static int decode_interrupt_cb(void *ctx)
477 {
479 }
480 
482 
483 static void ffmpeg_cleanup(int ret)
484 {
485  int i, j;
486 
487  if (do_benchmark) {
488  int maxrss = getmaxrss() / 1024;
489  av_log(NULL, AV_LOG_INFO, "bench: maxrss=%ikB\n", maxrss);
490  }
491 
492  for (i = 0; i < nb_filtergraphs; i++) {
493  FilterGraph *fg = filtergraphs[i];
495  for (j = 0; j < fg->nb_inputs; j++) {
496  while (av_fifo_size(fg->inputs[j]->frame_queue)) {
497  AVFrame *frame;
498  av_fifo_generic_read(fg->inputs[j]->frame_queue, &frame,
499  sizeof(frame), NULL);
500  av_frame_free(&frame);
501  }
502  av_fifo_freep(&fg->inputs[j]->frame_queue);
503  if (fg->inputs[j]->ist->sub2video.sub_queue) {
504  while (av_fifo_size(fg->inputs[j]->ist->sub2video.sub_queue)) {
505  AVSubtitle sub;
507  &sub, sizeof(sub), NULL);
508  avsubtitle_free(&sub);
509  }
511  }
513  av_freep(&fg->inputs[j]->name);
514  av_freep(&fg->inputs[j]);
515  }
516  av_freep(&fg->inputs);
517  for (j = 0; j < fg->nb_outputs; j++) {
518  av_freep(&fg->outputs[j]->name);
519  av_freep(&fg->outputs[j]->formats);
520  av_freep(&fg->outputs[j]->channel_layouts);
521  av_freep(&fg->outputs[j]->sample_rates);
522  av_freep(&fg->outputs[j]);
523  }
524  av_freep(&fg->outputs);
525  av_freep(&fg->graph_desc);
526 
527  av_freep(&filtergraphs[i]);
528  }
529  av_freep(&filtergraphs);
530 
532 
533  /* close files */
534  for (i = 0; i < nb_output_files; i++) {
535  OutputFile *of = output_files[i];
537  if (!of)
538  continue;
539  s = of->ctx;
540  if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE))
541  avio_closep(&s->pb);
543  av_dict_free(&of->opts);
544 
545  av_freep(&output_files[i]);
546  }
547  for (i = 0; i < nb_output_streams; i++) {
548  OutputStream *ost = output_streams[i];
549 
550  if (!ost)
551  continue;
552 
553  for (j = 0; j < ost->nb_bitstream_filters; j++)
554  av_bsf_free(&ost->bsf_ctx[j]);
555  av_freep(&ost->bsf_ctx);
556 
558  av_frame_free(&ost->last_frame);
559  av_dict_free(&ost->encoder_opts);
560 
561  av_freep(&ost->forced_keyframes);
563  av_freep(&ost->avfilter);
564  av_freep(&ost->logfile_prefix);
565 
567  ost->audio_channels_mapped = 0;
568 
569  av_dict_free(&ost->sws_dict);
570 
573 
574  if (ost->muxing_queue) {
575  while (av_fifo_size(ost->muxing_queue)) {
576  AVPacket pkt;
577  av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
578  av_packet_unref(&pkt);
579  }
581  }
582 
583  av_freep(&output_streams[i]);
584  }
585 #if HAVE_THREADS
586  free_input_threads();
587 #endif
588  for (i = 0; i < nb_input_files; i++) {
589  avformat_close_input(&input_files[i]->ctx);
590  av_freep(&input_files[i]);
591  }
592  for (i = 0; i < nb_input_streams; i++) {
593  InputStream *ist = input_streams[i];
594 
597  av_dict_free(&ist->decoder_opts);
600  av_freep(&ist->filters);
601  av_freep(&ist->hwaccel_device);
602  av_freep(&ist->dts_buffer);
603 
605 
606  av_freep(&input_streams[i]);
607  }
608 
609  if (vstats_file) {
610  if (fclose(vstats_file))
612  "Error closing vstats file, loss of information possible: %s\n",
613  av_err2str(AVERROR(errno)));
614  }
616 
617  av_freep(&input_streams);
618  av_freep(&input_files);
619  av_freep(&output_streams);
620  av_freep(&output_files);
621 
622  uninit_opts();
623 
625 
626  if (received_sigterm) {
627  av_log(NULL, AV_LOG_INFO, "Exiting normally, received signal %d.\n",
628  (int) received_sigterm);
629  } else if (ret && atomic_load(&transcode_init_done)) {
630  av_log(NULL, AV_LOG_INFO, "Conversion failed!\n");
631  }
632  term_exit();
633  ffmpeg_exited = 1;
634 }
635 
637 {
638  AVDictionaryEntry *t = NULL;
639 
640  while ((t = av_dict_get(b, "", t, AV_DICT_IGNORE_SUFFIX))) {
642  }
643 }
644 
646 {
648  if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
649  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
650  exit_program(1);
651  }
652 }
653 
654 static void abort_codec_experimental(AVCodec *c, int encoder)
655 {
656  exit_program(1);
657 }
658 
659 static void update_benchmark(const char *fmt, ...)
660 {
661  if (do_benchmark_all) {
663  va_list va;
664  char buf[1024];
665 
666  if (fmt) {
667  va_start(va, fmt);
668  vsnprintf(buf, sizeof(buf), fmt, va);
669  va_end(va);
671  "bench: %8" PRIu64 " user %8" PRIu64 " sys %8" PRIu64 " real %s \n",
672  t.user_usec - current_time.user_usec,
673  t.sys_usec - current_time.sys_usec,
674  t.real_usec - current_time.real_usec, buf);
675  }
676  current_time = t;
677  }
678 }
679 
681 {
682  int i;
683  for (i = 0; i < nb_output_streams; i++) {
684  OutputStream *ost2 = output_streams[i];
685  ost2->finished |= ost == ost2 ? this_stream : others;
686  }
687 }
688 
689 static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
690 {
691  AVFormatContext *s = of->ctx;
692  AVStream *st = ost->st;
693  int ret;
694 
695  /*
696  * Audio encoders may split the packets -- #frames in != #packets out.
697  * But there is no reordering, so we can limit the number of output packets
698  * by simply dropping them here.
699  * Counting encoded video frames needs to be done separately because of
700  * reordering, see do_video_out().
701  * Do not count the packet when unqueued because it has been counted when queued.
702  */
703  if (!(st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO && ost->encoding_needed) && !unqueue) {
704  if (ost->frame_number >= ost->max_frames) {
705  av_packet_unref(pkt);
706  return;
707  }
708  ost->frame_number++;
709  }
710 
711  if (!of->header_written) {
712  AVPacket tmp_pkt = {0};
713  /* the muxer is not initialized yet, buffer the packet */
714  if (!av_fifo_space(ost->muxing_queue)) {
715  int new_size = FFMIN(2 * av_fifo_size(ost->muxing_queue),
716  ost->max_muxing_queue_size);
717  if (new_size <= av_fifo_size(ost->muxing_queue)) {
719  "Too many packets buffered for output stream %d:%d.\n",
720  ost->file_index, ost->st->index);
721  exit_program(1);
722  }
723  ret = av_fifo_realloc2(ost->muxing_queue, new_size);
724  if (ret < 0)
725  exit_program(1);
726  }
727  ret = av_packet_make_refcounted(pkt);
728  if (ret < 0)
729  exit_program(1);
730  av_packet_move_ref(&tmp_pkt, pkt);
731  av_fifo_generic_write(ost->muxing_queue, &tmp_pkt, sizeof(tmp_pkt), NULL);
732  return;
733  }
734 
737  pkt->pts = pkt->dts = AV_NOPTS_VALUE;
738 
739  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
740  int i;
742  NULL);
743  ost->quality = sd ? AV_RL32(sd) : -1;
744  ost->pict_type = sd ? sd[4] : AV_PICTURE_TYPE_NONE;
745 
746  for (i = 0; i<FF_ARRAY_ELEMS(ost->error); i++) {
747  if (sd && i < sd[5])
748  ost->error[i] = AV_RL64(sd + 8 + 8*i);
749  else
750  ost->error[i] = -1;
751  }
752 
753  if (ost->frame_rate.num && ost->is_cfr) {
754  if (pkt->duration > 0)
755  av_log(NULL, AV_LOG_WARNING, "Overriding packet duration by frame rate, this should not happen\n");
756  pkt->duration = av_rescale_q(1, av_inv_q(ost->frame_rate),
757  ost->mux_timebase);
758  }
759  }
760 
761  av_packet_rescale_ts(pkt, ost->mux_timebase, ost->st->time_base);
762 
763  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS)) {
764  if (pkt->dts != AV_NOPTS_VALUE &&
765  pkt->pts != AV_NOPTS_VALUE &&
766  pkt->dts > pkt->pts) {
767  av_log(s, AV_LOG_WARNING, "Invalid DTS: %"PRId64" PTS: %"PRId64" in output stream %d:%d, replacing by guess\n",
768  pkt->dts, pkt->pts,
769  ost->file_index, ost->st->index);
770  pkt->pts =
771  pkt->dts = pkt->pts + pkt->dts + ost->last_mux_dts + 1
772  - FFMIN3(pkt->pts, pkt->dts, ost->last_mux_dts + 1)
773  - FFMAX3(pkt->pts, pkt->dts, ost->last_mux_dts + 1);
774  }
776  pkt->dts != AV_NOPTS_VALUE &&
777  !(st->codecpar->codec_id == AV_CODEC_ID_VP9 && ost->stream_copy) &&
778  ost->last_mux_dts != AV_NOPTS_VALUE) {
779  int64_t max = ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT);
780  if (pkt->dts < max) {
781  int loglevel = max - pkt->dts > 2 || st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO ? AV_LOG_WARNING : AV_LOG_DEBUG;
782  av_log(s, loglevel, "Non-monotonous DTS in output stream "
783  "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
784  ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
785  if (exit_on_error) {
786  av_log(NULL, AV_LOG_FATAL, "aborting.\n");
787  exit_program(1);
788  }
789  av_log(s, loglevel, "changing to %"PRId64". This may result "
790  "in incorrect timestamps in the output file.\n",
791  max);
792  if (pkt->pts >= pkt->dts)
793  pkt->pts = FFMAX(pkt->pts, max);
794  pkt->dts = max;
795  }
796  }
797  }
798  ost->last_mux_dts = pkt->dts;
799 
800  ost->data_size += pkt->size;
801  ost->packets_written++;
802 
803  pkt->stream_index = ost->index;
804 
805  if (debug_ts) {
806  av_log(NULL, AV_LOG_INFO, "muxer <- type:%s "
807  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s size:%d\n",
809  av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &ost->st->time_base),
810  av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &ost->st->time_base),
811  pkt->size
812  );
813  }
814 
815  ret = av_interleaved_write_frame(s, pkt);
816  if (ret < 0) {
817  print_error("av_interleaved_write_frame()", ret);
818  main_return_code = 1;
820  }
821  av_packet_unref(pkt);
822 }
823 
825 {
826  OutputFile *of = output_files[ost->file_index];
827 
828  ost->finished |= ENCODER_FINISHED;
829  if (of->shortest) {
830  int64_t end = av_rescale_q(ost->sync_opts - ost->first_pts, ost->enc_ctx->time_base, AV_TIME_BASE_Q);
831  of->recording_time = FFMIN(of->recording_time, end);
832  }
833 }
834 
835 /*
836  * Send a single packet to the output, applying any bitstream filters
837  * associated with the output stream. This may result in any number
838  * of packets actually being written, depending on what bitstream
839  * filters are applied. The supplied packet is consumed and will be
840  * blank (as if newly-allocated) when this function returns.
841  *
842  * If eof is set, instead indicate EOF to all bitstream filters and
843  * therefore flush any delayed packets to the output. A blank packet
844  * must be supplied in this case.
845  */
847  OutputStream *ost, int eof)
848 {
849  int ret = 0;
850 
851  /* apply the output bitstream filters, if any */
852  if (ost->nb_bitstream_filters) {
853  int idx;
854 
855  ret = av_bsf_send_packet(ost->bsf_ctx[0], eof ? NULL : pkt);
856  if (ret < 0)
857  goto finish;
858 
859  eof = 0;
860  idx = 1;
861  while (idx) {
862  /* get a packet from the previous filter up the chain */
863  ret = av_bsf_receive_packet(ost->bsf_ctx[idx - 1], pkt);
864  if (ret == AVERROR(EAGAIN)) {
865  ret = 0;
866  idx--;
867  continue;
868  } else if (ret == AVERROR_EOF) {
869  eof = 1;
870  } else if (ret < 0)
871  goto finish;
872 
873  /* send it to the next filter down the chain or to the muxer */
874  if (idx < ost->nb_bitstream_filters) {
875  ret = av_bsf_send_packet(ost->bsf_ctx[idx], eof ? NULL : pkt);
876  if (ret < 0)
877  goto finish;
878  idx++;
879  eof = 0;
880  } else if (eof)
881  goto finish;
882  else
883  write_packet(of, pkt, ost, 0);
884  }
885  } else if (!eof)
886  write_packet(of, pkt, ost, 0);
887 
888 finish:
889  if (ret < 0 && ret != AVERROR_EOF) {
890  av_log(NULL, AV_LOG_ERROR, "Error applying bitstream filters to an output "
891  "packet for stream #%d:%d.\n", ost->file_index, ost->index);
892  if(exit_on_error)
893  exit_program(1);
894  }
895 }
896 
898 {
899  OutputFile *of = output_files[ost->file_index];
900 
901  if (of->recording_time != INT64_MAX &&
903  AV_TIME_BASE_Q) >= 0) {
904  close_output_stream(ost);
905  return 0;
906  }
907  return 1;
908 }
909 
911  AVFrame *frame)
912 {
913  AVCodecContext *enc = ost->enc_ctx;
914  AVPacket pkt;
915  int ret;
916 
917  av_init_packet(&pkt);
918  pkt.data = NULL;
919  pkt.size = 0;
920 
921  if (!check_recording_time(ost))
922  return;
923 
924  if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
925  frame->pts = ost->sync_opts;
926  ost->sync_opts = frame->pts + frame->nb_samples;
927  ost->samples_encoded += frame->nb_samples;
928  ost->frames_encoded++;
929 
930  av_assert0(pkt.size || !pkt.data);
932  if (debug_ts) {
933  av_log(NULL, AV_LOG_INFO, "encoder <- type:audio "
934  "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
935  av_ts2str(frame->pts), av_ts2timestr(frame->pts, &enc->time_base),
936  enc->time_base.num, enc->time_base.den);
937  }
938 
939  ret = avcodec_send_frame(enc, frame);
940  if (ret < 0)
941  goto error;
942 
943  while (1) {
944  ret = avcodec_receive_packet(enc, &pkt);
945  if (ret == AVERROR(EAGAIN))
946  break;
947  if (ret < 0)
948  goto error;
949 
950  update_benchmark("encode_audio %d.%d", ost->file_index, ost->index);
951 
952  av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
953 
954  if (debug_ts) {
955  av_log(NULL, AV_LOG_INFO, "encoder -> type:audio "
956  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
957  av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
958  av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
959  }
960 
961  output_packet(of, &pkt, ost, 0);
962  }
963 
964  return;
965 error:
966  av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
967  exit_program(1);
968 }
969 
970 static void do_subtitle_out(OutputFile *of,
971  OutputStream *ost,
972  AVSubtitle *sub)
973 {
974  int subtitle_out_max_size = 1024 * 1024;
975  int subtitle_out_size, nb, i;
976  AVCodecContext *enc;
977  AVPacket pkt;
978  int64_t pts;
979 
980  if (sub->pts == AV_NOPTS_VALUE) {
981  av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
982  if (exit_on_error)
983  exit_program(1);
984  return;
985  }
986 
987  enc = ost->enc_ctx;
988 
989  if (!subtitle_out) {
990  subtitle_out = av_malloc(subtitle_out_max_size);
991  if (!subtitle_out) {
992  av_log(NULL, AV_LOG_FATAL, "Failed to allocate subtitle_out\n");
993  exit_program(1);
994  }
995  }
996 
997  /* Note: DVB subtitle need one packet to draw them and one other
998  packet to clear them */
999  /* XXX: signal it in the codec context ? */
1000  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE)
1001  nb = 2;
1002  else
1003  nb = 1;
1004 
1005  /* shift timestamp to honor -ss and make check_recording_time() work with -t */
1006  pts = sub->pts;
1007  if (output_files[ost->file_index]->start_time != AV_NOPTS_VALUE)
1008  pts -= output_files[ost->file_index]->start_time;
1009  for (i = 0; i < nb; i++) {
1010  unsigned save_num_rects = sub->num_rects;
1011 
1012  ost->sync_opts = av_rescale_q(pts, AV_TIME_BASE_Q, enc->time_base);
1013  if (!check_recording_time(ost))
1014  return;
1015 
1016  sub->pts = pts;
1017  // start_display_time is required to be 0
1018  sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
1019  sub->end_display_time -= sub->start_display_time;
1020  sub->start_display_time = 0;
1021  if (i == 1)
1022  sub->num_rects = 0;
1023 
1024  ost->frames_encoded++;
1025 
1026  subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
1027  subtitle_out_max_size, sub);
1028  if (i == 1)
1029  sub->num_rects = save_num_rects;
1030  if (subtitle_out_size < 0) {
1031  av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
1032  exit_program(1);
1033  }
1034 
1035  av_init_packet(&pkt);
1036  pkt.data = subtitle_out;
1037  pkt.size = subtitle_out_size;
1038  pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->mux_timebase);
1039  pkt.duration = av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1040  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
1041  /* XXX: the pts correction is handled here. Maybe handling
1042  it in the codec would be better */
1043  if (i == 0)
1044  pkt.pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1045  else
1046  pkt.pts += av_rescale_q(sub->end_display_time, (AVRational){ 1, 1000 }, ost->mux_timebase);
1047  }
1048  pkt.dts = pkt.pts;
1049  output_packet(of, &pkt, ost, 0);
1050  }
1051 }
1052 
1053 static void do_video_out(OutputFile *of,
1054  OutputStream *ost,
1055  AVFrame *next_picture,
1056  double sync_ipts)
1057 {
1058  int ret, format_video_sync;
1059  AVPacket pkt;
1060  AVCodecContext *enc = ost->enc_ctx;
1061  AVCodecParameters *mux_par = ost->st->codecpar;
1062  AVRational frame_rate;
1063  int nb_frames, nb0_frames, i;
1064  double delta, delta0;
1065  double duration = 0;
1066  int frame_size = 0;
1067  InputStream *ist = NULL;
1069 
1070  if (ost->source_index >= 0)
1071  ist = input_streams[ost->source_index];
1072 
1073  frame_rate = av_buffersink_get_frame_rate(filter);
1074  if (frame_rate.num > 0 && frame_rate.den > 0)
1075  duration = 1/(av_q2d(frame_rate) * av_q2d(enc->time_base));
1076 
1077  if(ist && ist->st->start_time != AV_NOPTS_VALUE && ist->st->first_dts != AV_NOPTS_VALUE && ost->frame_rate.num)
1078  duration = FFMIN(duration, 1/(av_q2d(ost->frame_rate) * av_q2d(enc->time_base)));
1079 
1080  if (!ost->filters_script &&
1081  !ost->filters &&
1082  next_picture &&
1083  ist &&
1084  lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base)) > 0) {
1085  duration = lrintf(next_picture->pkt_duration * av_q2d(ist->st->time_base) / av_q2d(enc->time_base));
1086  }
1087 
1088  if (!next_picture) {
1089  //end, flushing
1090  nb0_frames = nb_frames = mid_pred(ost->last_nb0_frames[0],
1091  ost->last_nb0_frames[1],
1092  ost->last_nb0_frames[2]);
1093  } else {
1094  delta0 = sync_ipts - ost->sync_opts; // delta0 is the "drift" between the input frame (next_picture) and where it would fall in the output.
1095  delta = delta0 + duration;
1096 
1097  /* by default, we output a single frame */
1098  nb0_frames = 0; // tracks the number of times the PREVIOUS frame should be duplicated, mostly for variable framerate (VFR)
1099  nb_frames = 1;
1100 
1101  format_video_sync = video_sync_method;
1102  if (format_video_sync == VSYNC_AUTO) {
1103  if(!strcmp(of->ctx->oformat->name, "avi")) {
1104  format_video_sync = VSYNC_VFR;
1105  } else
1106  format_video_sync = (of->ctx->oformat->flags & AVFMT_VARIABLE_FPS) ? ((of->ctx->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH : VSYNC_VFR) : VSYNC_CFR;
1107  if ( ist
1108  && format_video_sync == VSYNC_CFR
1109  && input_files[ist->file_index]->ctx->nb_streams == 1
1110  && input_files[ist->file_index]->input_ts_offset == 0) {
1111  format_video_sync = VSYNC_VSCFR;
1112  }
1113  if (format_video_sync == VSYNC_CFR && copy_ts) {
1114  format_video_sync = VSYNC_VSCFR;
1115  }
1116  }
1117  ost->is_cfr = (format_video_sync == VSYNC_CFR || format_video_sync == VSYNC_VSCFR);
1118 
1119  if (delta0 < 0 &&
1120  delta > 0 &&
1121  format_video_sync != VSYNC_PASSTHROUGH &&
1122  format_video_sync != VSYNC_DROP) {
1123  if (delta0 < -0.6) {
1124  av_log(NULL, AV_LOG_VERBOSE, "Past duration %f too large\n", -delta0);
1125  } else
1126  av_log(NULL, AV_LOG_DEBUG, "Clipping frame in rate conversion by %f\n", -delta0);
1127  sync_ipts = ost->sync_opts;
1128  duration += delta0;
1129  delta0 = 0;
1130  }
1131 
1132  switch (format_video_sync) {
1133  case VSYNC_VSCFR:
1134  if (ost->frame_number == 0 && delta0 >= 0.5) {
1135  av_log(NULL, AV_LOG_DEBUG, "Not duplicating %d initial frames\n", (int)lrintf(delta0));
1136  delta = duration;
1137  delta0 = 0;
1138  ost->sync_opts = lrint(sync_ipts);
1139  }
1140  case VSYNC_CFR:
1141  // FIXME set to 0.5 after we fix some dts/pts bugs like in avidec.c
1142  if (frame_drop_threshold && delta < frame_drop_threshold && ost->frame_number) {
1143  nb_frames = 0;
1144  } else if (delta < -1.1)
1145  nb_frames = 0;
1146  else if (delta > 1.1) {
1147  nb_frames = lrintf(delta);
1148  if (delta0 > 1.1)
1149  nb0_frames = lrintf(delta0 - 0.6);
1150  }
1151  break;
1152  case VSYNC_VFR:
1153  if (delta <= -0.6)
1154  nb_frames = 0;
1155  else if (delta > 0.6)
1156  ost->sync_opts = lrint(sync_ipts);
1157  break;
1158  case VSYNC_DROP:
1159  case VSYNC_PASSTHROUGH:
1160  ost->sync_opts = lrint(sync_ipts);
1161  break;
1162  default:
1163  av_assert0(0);
1164  }
1165  }
1166 
1167  nb_frames = FFMIN(nb_frames, ost->max_frames - ost->frame_number);
1168  nb0_frames = FFMIN(nb0_frames, nb_frames);
1169 
1170  memmove(ost->last_nb0_frames + 1,
1171  ost->last_nb0_frames,
1172  sizeof(ost->last_nb0_frames[0]) * (FF_ARRAY_ELEMS(ost->last_nb0_frames) - 1));
1173  ost->last_nb0_frames[0] = nb0_frames;
1174 
1175  if (nb0_frames == 0 && ost->last_dropped) {
1176  nb_frames_drop++;
1178  "*** dropping frame %d from stream %d at ts %"PRId64"\n",
1179  ost->frame_number, ost->st->index, ost->last_frame->pts);
1180  }
1181  if (nb_frames > (nb0_frames && ost->last_dropped) + (nb_frames > nb0_frames)) {
1182  if (nb_frames > dts_error_threshold * 30) {
1183  av_log(NULL, AV_LOG_ERROR, "%d frame duplication too large, skipping\n", nb_frames - 1);
1184  nb_frames_drop++;
1185  return;
1186  }
1187  nb_frames_dup += nb_frames - (nb0_frames && ost->last_dropped) - (nb_frames > nb0_frames);
1188  av_log(NULL, AV_LOG_VERBOSE, "*** %d dup!\n", nb_frames - 1);
1189  if (nb_frames_dup > dup_warning) {
1190  av_log(NULL, AV_LOG_WARNING, "More than %d frames duplicated\n", dup_warning);
1191  dup_warning *= 10;
1192  }
1193  }
1194  ost->last_dropped = nb_frames == nb0_frames && next_picture;
1195 
1196  /* duplicates frame if needed */
1197  for (i = 0; i < nb_frames; i++) {
1198  AVFrame *in_picture;
1199  av_init_packet(&pkt);
1200  pkt.data = NULL;
1201  pkt.size = 0;
1202 
1203  if (i < nb0_frames && ost->last_frame) {
1204  in_picture = ost->last_frame;
1205  } else
1206  in_picture = next_picture;
1207 
1208  if (!in_picture)
1209  return;
1210 
1211  in_picture->pts = ost->sync_opts;
1212 
1213 #if 1
1214  if (!check_recording_time(ost))
1215 #else
1216  if (ost->frame_number >= ost->max_frames)
1217 #endif
1218  return;
1219 
1220  {
1221  int forced_keyframe = 0;
1222  double pts_time;
1223 
1225  ost->top_field_first >= 0)
1226  in_picture->top_field_first = !!ost->top_field_first;
1227 
1228  if (in_picture->interlaced_frame) {
1229  if (enc->codec->id == AV_CODEC_ID_MJPEG)
1230  mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TT:AV_FIELD_BB;
1231  else
1232  mux_par->field_order = in_picture->top_field_first ? AV_FIELD_TB:AV_FIELD_BT;
1233  } else
1234  mux_par->field_order = AV_FIELD_PROGRESSIVE;
1235 
1236  in_picture->quality = enc->global_quality;
1237  in_picture->pict_type = 0;
1238 
1239  if (ost->forced_kf_ref_pts == AV_NOPTS_VALUE &&
1240  in_picture->pts != AV_NOPTS_VALUE)
1241  ost->forced_kf_ref_pts = in_picture->pts;
1242 
1243  pts_time = in_picture->pts != AV_NOPTS_VALUE ?
1244  (in_picture->pts - ost->forced_kf_ref_pts) * av_q2d(enc->time_base) : NAN;
1245  if (ost->forced_kf_index < ost->forced_kf_count &&
1246  in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
1247  ost->forced_kf_index++;
1248  forced_keyframe = 1;
1249  } else if (ost->forced_keyframes_pexpr) {
1250  double res;
1251  ost->forced_keyframes_expr_const_values[FKF_T] = pts_time;
1254  ff_dlog(NULL, "force_key_frame: n:%f n_forced:%f prev_forced_n:%f t:%f prev_forced_t:%f -> res:%f\n",
1260  res);
1261  if (res) {
1262  forced_keyframe = 1;
1268  }
1269 
1271  } else if ( ost->forced_keyframes
1272  && !strncmp(ost->forced_keyframes, "source", 6)
1273  && in_picture->key_frame==1) {
1274  forced_keyframe = 1;
1275  }
1276 
1277  if (forced_keyframe) {
1278  in_picture->pict_type = AV_PICTURE_TYPE_I;
1279  av_log(NULL, AV_LOG_DEBUG, "Forced keyframe at time %f\n", pts_time);
1280  }
1281 
1283  if (debug_ts) {
1284  av_log(NULL, AV_LOG_INFO, "encoder <- type:video "
1285  "frame_pts:%s frame_pts_time:%s time_base:%d/%d\n",
1286  av_ts2str(in_picture->pts), av_ts2timestr(in_picture->pts, &enc->time_base),
1287  enc->time_base.num, enc->time_base.den);
1288  }
1289 
1290  ost->frames_encoded++;
1291 
1292  ret = avcodec_send_frame(enc, in_picture);
1293  if (ret < 0)
1294  goto error;
1295 
1296  while (1) {
1297  ret = avcodec_receive_packet(enc, &pkt);
1298  update_benchmark("encode_video %d.%d", ost->file_index, ost->index);
1299  if (ret == AVERROR(EAGAIN))
1300  break;
1301  if (ret < 0)
1302  goto error;
1303 
1304  if (debug_ts) {
1305  av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1306  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1307  av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &enc->time_base),
1308  av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &enc->time_base));
1309  }
1310 
1311  if (pkt.pts == AV_NOPTS_VALUE && !(enc->codec->capabilities & AV_CODEC_CAP_DELAY))
1312  pkt.pts = ost->sync_opts;
1313 
1314  av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1315 
1316  if (debug_ts) {
1317  av_log(NULL, AV_LOG_INFO, "encoder -> type:video "
1318  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s\n",
1319  av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ost->mux_timebase),
1320  av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ost->mux_timebase));
1321  }
1322 
1323  frame_size = pkt.size;
1324  output_packet(of, &pkt, ost, 0);
1325 
1326  /* if two pass, output log */
1327  if (ost->logfile && enc->stats_out) {
1328  fprintf(ost->logfile, "%s", enc->stats_out);
1329  }
1330  }
1331  }
1332  ost->sync_opts++;
1333  /*
1334  * For video, number of frames in == number of packets out.
1335  * But there may be reordering, so we can't throw away frames on encoder
1336  * flush, we need to limit them here, before they go into encoder.
1337  */
1338  ost->frame_number++;
1339 
1340  if (vstats_filename && frame_size)
1341  do_video_stats(ost, frame_size);
1342  }
1343 
1344  if (!ost->last_frame)
1345  ost->last_frame = av_frame_alloc();
1346  av_frame_unref(ost->last_frame);
1347  if (next_picture && ost->last_frame)
1348  av_frame_ref(ost->last_frame, next_picture);
1349  else
1350  av_frame_free(&ost->last_frame);
1351 
1352  return;
1353 error:
1354  av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
1355  exit_program(1);
1356 }
1357 
1358 static double psnr(double d)
1359 {
1360  return -10.0 * log10(d);
1361 }
1362 
1364 {
1365  AVCodecContext *enc;
1366  int frame_number;
1367  double ti1, bitrate, avg_bitrate;
1368 
1369  /* this is executed just the first time do_video_stats is called */
1370  if (!vstats_file) {
1371  vstats_file = fopen(vstats_filename, "w");
1372  if (!vstats_file) {
1373  perror("fopen");
1374  exit_program(1);
1375  }
1376  }
1377 
1378  enc = ost->enc_ctx;
1379  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1380  frame_number = ost->st->nb_frames;
1381  if (vstats_version <= 1) {
1382  fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number,
1383  ost->quality / (float)FF_QP2LAMBDA);
1384  } else {
1385  fprintf(vstats_file, "out= %2d st= %2d frame= %5d q= %2.1f ", ost->file_index, ost->index, frame_number,
1386  ost->quality / (float)FF_QP2LAMBDA);
1387  }
1388 
1389  if (ost->error[0]>=0 && (enc->flags & AV_CODEC_FLAG_PSNR))
1390  fprintf(vstats_file, "PSNR= %6.2f ", psnr(ost->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
1391 
1392  fprintf(vstats_file,"f_size= %6d ", frame_size);
1393  /* compute pts value */
1394  ti1 = av_stream_get_end_pts(ost->st) * av_q2d(ost->st->time_base);
1395  if (ti1 < 0.01)
1396  ti1 = 0.01;
1397 
1398  bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
1399  avg_bitrate = (double)(ost->data_size * 8) / ti1 / 1000.0;
1400  fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
1401  (double)ost->data_size / 1024, ti1, bitrate, avg_bitrate);
1402  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(ost->pict_type));
1403  }
1404 }
1405 
1406 static int init_output_stream(OutputStream *ost, char *error, int error_len);
1407 
1409 {
1410  OutputFile *of = output_files[ost->file_index];
1411  int i;
1412 
1414 
1415  if (of->shortest) {
1416  for (i = 0; i < of->ctx->nb_streams; i++)
1417  output_streams[of->ost_index + i]->finished = ENCODER_FINISHED | MUXER_FINISHED;
1418  }
1419 }
1420 
1421 /**
1422  * Get and encode new output from any of the filtergraphs, without causing
1423  * activity.
1424  *
1425  * @return 0 for success, <0 for severe errors
1426  */
1427 static int reap_filters(int flush)
1428 {
1429  AVFrame *filtered_frame = NULL;
1430  int i;
1431 
1432  /* Reap all buffers present in the buffer sinks */
1433  for (i = 0; i < nb_output_streams; i++) {
1434  OutputStream *ost = output_streams[i];
1435  OutputFile *of = output_files[ost->file_index];
1437  AVCodecContext *enc = ost->enc_ctx;
1438  int ret = 0;
1439 
1440  if (!ost->filter || !ost->filter->graph->graph)
1441  continue;
1442  filter = ost->filter->filter;
1443 
1444  if (!ost->initialized) {
1445  char error[1024] = "";
1446  ret = init_output_stream(ost, error, sizeof(error));
1447  if (ret < 0) {
1448  av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1449  ost->file_index, ost->index, error);
1450  exit_program(1);
1451  }
1452  }
1453 
1454  if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
1455  return AVERROR(ENOMEM);
1456  }
1457  filtered_frame = ost->filtered_frame;
1458 
1459  while (1) {
1460  double float_pts = AV_NOPTS_VALUE; // this is identical to filtered_frame.pts but with higher precision
1461  ret = av_buffersink_get_frame_flags(filter, filtered_frame,
1463  if (ret < 0) {
1464  if (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
1466  "Error in av_buffersink_get_frame_flags(): %s\n", av_err2str(ret));
1467  } else if (flush && ret == AVERROR_EOF) {
1469  do_video_out(of, ost, NULL, AV_NOPTS_VALUE);
1470  }
1471  break;
1472  }
1473  if (ost->finished) {
1474  av_frame_unref(filtered_frame);
1475  continue;
1476  }
1477  if (filtered_frame->pts != AV_NOPTS_VALUE) {
1478  int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
1479  AVRational filter_tb = av_buffersink_get_time_base(filter);
1480  AVRational tb = enc->time_base;
1481  int extra_bits = av_clip(29 - av_log2(tb.den), 0, 16);
1482 
1483  tb.den <<= extra_bits;
1484  float_pts =
1485  av_rescale_q(filtered_frame->pts, filter_tb, tb) -
1486  av_rescale_q(start_time, AV_TIME_BASE_Q, tb);
1487  float_pts /= 1 << extra_bits;
1488  // avoid exact midoints to reduce the chance of rounding differences, this can be removed in case the fps code is changed to work with integers
1489  float_pts += FFSIGN(float_pts) * 1.0 / (1<<17);
1490 
1491  filtered_frame->pts =
1492  av_rescale_q(filtered_frame->pts, filter_tb, enc->time_base) -
1493  av_rescale_q(start_time, AV_TIME_BASE_Q, enc->time_base);
1494  }
1495  //if (ost->source_index >= 0)
1496  // *filtered_frame= *input_streams[ost->source_index]->decoded_frame; //for me_threshold
1497 
1498  switch (av_buffersink_get_type(filter)) {
1499  case AVMEDIA_TYPE_VIDEO:
1500  if (!ost->frame_aspect_ratio.num)
1501  enc->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
1502 
1503  if (debug_ts) {
1504  av_log(NULL, AV_LOG_INFO, "filter -> pts:%s pts_time:%s exact:%f time_base:%d/%d\n",
1505  av_ts2str(filtered_frame->pts), av_ts2timestr(filtered_frame->pts, &enc->time_base),
1506  float_pts,
1507  enc->time_base.num, enc->time_base.den);
1508  }
1509 
1510  do_video_out(of, ost, filtered_frame, float_pts);
1511  break;
1512  case AVMEDIA_TYPE_AUDIO:
1513  if (!(enc->codec->capabilities & AV_CODEC_CAP_PARAM_CHANGE) &&
1514  enc->channels != filtered_frame->channels) {
1516  "Audio filter graph output is not normalized and encoder does not support parameter changes\n");
1517  break;
1518  }
1519  do_audio_out(of, ost, filtered_frame);
1520  break;
1521  default:
1522  // TODO support subtitle filters
1523  av_assert0(0);
1524  }
1525 
1526  av_frame_unref(filtered_frame);
1527  }
1528  }
1529 
1530  return 0;
1531 }
1532 
1533 static void print_final_stats(int64_t total_size)
1534 {
1535  uint64_t video_size = 0, audio_size = 0, extra_size = 0, other_size = 0;
1536  uint64_t subtitle_size = 0;
1537  uint64_t data_size = 0;
1538  float percent = -1.0;
1539  int i, j;
1540  int pass1_used = 1;
1541 
1542  for (i = 0; i < nb_output_streams; i++) {
1543  OutputStream *ost = output_streams[i];
1544  switch (ost->enc_ctx->codec_type) {
1545  case AVMEDIA_TYPE_VIDEO: video_size += ost->data_size; break;
1546  case AVMEDIA_TYPE_AUDIO: audio_size += ost->data_size; break;
1547  case AVMEDIA_TYPE_SUBTITLE: subtitle_size += ost->data_size; break;
1548  default: other_size += ost->data_size; break;
1549  }
1550  extra_size += ost->enc_ctx->extradata_size;
1551  data_size += ost->data_size;
1554  pass1_used = 0;
1555  }
1556 
1557  if (data_size && total_size>0 && total_size >= data_size)
1558  percent = 100.0 * (total_size - data_size) / data_size;
1559 
1560  av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB subtitle:%1.0fkB other streams:%1.0fkB global headers:%1.0fkB muxing overhead: ",
1561  video_size / 1024.0,
1562  audio_size / 1024.0,
1563  subtitle_size / 1024.0,
1564  other_size / 1024.0,
1565  extra_size / 1024.0);
1566  if (percent >= 0.0)
1567  av_log(NULL, AV_LOG_INFO, "%f%%", percent);
1568  else
1569  av_log(NULL, AV_LOG_INFO, "unknown");
1570  av_log(NULL, AV_LOG_INFO, "\n");
1571 
1572  /* print verbose per-stream stats */
1573  for (i = 0; i < nb_input_files; i++) {
1574  InputFile *f = input_files[i];
1575  uint64_t total_packets = 0, total_size = 0;
1576 
1577  av_log(NULL, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
1578  i, f->ctx->url);
1579 
1580  for (j = 0; j < f->nb_streams; j++) {
1581  InputStream *ist = input_streams[f->ist_index + j];
1582  enum AVMediaType type = ist->dec_ctx->codec_type;
1583 
1584  total_size += ist->data_size;
1585  total_packets += ist->nb_packets;
1586 
1587  av_log(NULL, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ",
1588  i, j, media_type_string(type));
1589  av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
1590  ist->nb_packets, ist->data_size);
1591 
1592  if (ist->decoding_needed) {
1593  av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames decoded",
1594  ist->frames_decoded);
1595  if (type == AVMEDIA_TYPE_AUDIO)
1596  av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->samples_decoded);
1597  av_log(NULL, AV_LOG_VERBOSE, "; ");
1598  }
1599 
1600  av_log(NULL, AV_LOG_VERBOSE, "\n");
1601  }
1602 
1603  av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
1604  total_packets, total_size);
1605  }
1606 
1607  for (i = 0; i < nb_output_files; i++) {
1608  OutputFile *of = output_files[i];
1609  uint64_t total_packets = 0, total_size = 0;
1610 
1611  av_log(NULL, AV_LOG_VERBOSE, "Output file #%d (%s):\n",
1612  i, of->ctx->url);
1613 
1614  for (j = 0; j < of->ctx->nb_streams; j++) {
1615  OutputStream *ost = output_streams[of->ost_index + j];
1616  enum AVMediaType type = ost->enc_ctx->codec_type;
1617 
1618  total_size += ost->data_size;
1619  total_packets += ost->packets_written;
1620 
1621  av_log(NULL, AV_LOG_VERBOSE, " Output stream #%d:%d (%s): ",
1622  i, j, media_type_string(type));
1623  if (ost->encoding_needed) {
1624  av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" frames encoded",
1625  ost->frames_encoded);
1626  if (type == AVMEDIA_TYPE_AUDIO)
1627  av_log(NULL, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ost->samples_encoded);
1628  av_log(NULL, AV_LOG_VERBOSE, "; ");
1629  }
1630 
1631  av_log(NULL, AV_LOG_VERBOSE, "%"PRIu64" packets muxed (%"PRIu64" bytes); ",
1632  ost->packets_written, ost->data_size);
1633 
1634  av_log(NULL, AV_LOG_VERBOSE, "\n");
1635  }
1636 
1637  av_log(NULL, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) muxed\n",
1638  total_packets, total_size);
1639  }
1640  if(video_size + data_size + audio_size + subtitle_size + extra_size == 0){
1641  av_log(NULL, AV_LOG_WARNING, "Output file is empty, nothing was encoded ");
1642  if (pass1_used) {
1643  av_log(NULL, AV_LOG_WARNING, "\n");
1644  } else {
1645  av_log(NULL, AV_LOG_WARNING, "(check -ss / -t / -frames parameters if used)\n");
1646  }
1647  }
1648 }
1649 
1650 static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
1651 {
1652  AVBPrint buf, buf_script;
1653  OutputStream *ost;
1654  AVFormatContext *oc;
1655  int64_t total_size;
1656  AVCodecContext *enc;
1657  int frame_number, vid, i;
1658  double bitrate;
1659  double speed;
1660  int64_t pts = INT64_MIN + 1;
1661  static int64_t last_time = -1;
1662  static int qp_histogram[52];
1663  int hours, mins, secs, us;
1664  const char *hours_sign;
1665  int ret;
1666  float t;
1667 
1668  if (!print_stats && !is_last_report && !progress_avio)
1669  return;
1670 
1671  if (!is_last_report) {
1672  if (last_time == -1) {
1673  last_time = cur_time;
1674  return;
1675  }
1676  if ((cur_time - last_time) < 500000)
1677  return;
1678  last_time = cur_time;
1679  }
1680 
1681  t = (cur_time-timer_start) / 1000000.0;
1682 
1683 
1684  oc = output_files[0]->ctx;
1685 
1686  total_size = avio_size(oc->pb);
1687  if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
1688  total_size = avio_tell(oc->pb);
1689 
1690  vid = 0;
1692  av_bprint_init(&buf_script, 0, AV_BPRINT_SIZE_AUTOMATIC);
1693  for (i = 0; i < nb_output_streams; i++) {
1694  float q = -1;
1695  ost = output_streams[i];
1696  enc = ost->enc_ctx;
1697  if (!ost->stream_copy)
1698  q = ost->quality / (float) FF_QP2LAMBDA;
1699 
1700  if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1701  av_bprintf(&buf, "q=%2.1f ", q);
1702  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1703  ost->file_index, ost->index, q);
1704  }
1705  if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
1706  float fps;
1707 
1708  frame_number = ost->frame_number;
1709  fps = t > 1 ? frame_number / t : 0;
1710  av_bprintf(&buf, "frame=%5d fps=%3.*f q=%3.1f ",
1711  frame_number, fps < 9.95, fps, q);
1712  av_bprintf(&buf_script, "frame=%d\n", frame_number);
1713  av_bprintf(&buf_script, "fps=%.2f\n", fps);
1714  av_bprintf(&buf_script, "stream_%d_%d_q=%.1f\n",
1715  ost->file_index, ost->index, q);
1716  if (is_last_report)
1717  av_bprintf(&buf, "L");
1718  if (qp_hist) {
1719  int j;
1720  int qp = lrintf(q);
1721  if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
1722  qp_histogram[qp]++;
1723  for (j = 0; j < 32; j++)
1724  av_bprintf(&buf, "%X", av_log2(qp_histogram[j] + 1));
1725  }
1726 
1727  if ((enc->flags & AV_CODEC_FLAG_PSNR) && (ost->pict_type != AV_PICTURE_TYPE_NONE || is_last_report)) {
1728  int j;
1729  double error, error_sum = 0;
1730  double scale, scale_sum = 0;
1731  double p;
1732  char type[3] = { 'Y','U','V' };
1733  av_bprintf(&buf, "PSNR=");
1734  for (j = 0; j < 3; j++) {
1735  if (is_last_report) {
1736  error = enc->error[j];
1737  scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
1738  } else {
1739  error = ost->error[j];
1740  scale = enc->width * enc->height * 255.0 * 255.0;
1741  }
1742  if (j)
1743  scale /= 4;
1744  error_sum += error;
1745  scale_sum += scale;
1746  p = psnr(error / scale);
1747  av_bprintf(&buf, "%c:%2.2f ", type[j], p);
1748  av_bprintf(&buf_script, "stream_%d_%d_psnr_%c=%2.2f\n",
1749  ost->file_index, ost->index, type[j] | 32, p);
1750  }
1751  p = psnr(error_sum / scale_sum);
1752  av_bprintf(&buf, "*:%2.2f ", psnr(error_sum / scale_sum));
1753  av_bprintf(&buf_script, "stream_%d_%d_psnr_all=%2.2f\n",
1754  ost->file_index, ost->index, p);
1755  }
1756  vid = 1;
1757  }
1758  /* compute min output value */
1760  pts = FFMAX(pts, av_rescale_q(av_stream_get_end_pts(ost->st),
1761  ost->st->time_base, AV_TIME_BASE_Q));
1762  if (is_last_report)
1763  nb_frames_drop += ost->last_dropped;
1764  }
1765 
1766  secs = FFABS(pts) / AV_TIME_BASE;
1767  us = FFABS(pts) % AV_TIME_BASE;
1768  mins = secs / 60;
1769  secs %= 60;
1770  hours = mins / 60;
1771  mins %= 60;
1772  hours_sign = (pts < 0) ? "-" : "";
1773 
1774  bitrate = pts && total_size >= 0 ? total_size * 8 / (pts / 1000.0) : -1;
1775  speed = t != 0.0 ? (double)pts / AV_TIME_BASE / t : -1;
1776 
1777  if (total_size < 0) av_bprintf(&buf, "size=N/A time=");
1778  else av_bprintf(&buf, "size=%8.0fkB time=", total_size / 1024.0);
1779  if (pts == AV_NOPTS_VALUE) {
1780  av_bprintf(&buf, "N/A ");
1781  } else {
1782  av_bprintf(&buf, "%s%02d:%02d:%02d.%02d ",
1783  hours_sign, hours, mins, secs, (100 * us) / AV_TIME_BASE);
1784  }
1785 
1786  if (bitrate < 0) {
1787  av_bprintf(&buf, "bitrate=N/A");
1788  av_bprintf(&buf_script, "bitrate=N/A\n");
1789  }else{
1790  av_bprintf(&buf, "bitrate=%6.1fkbits/s", bitrate);
1791  av_bprintf(&buf_script, "bitrate=%6.1fkbits/s\n", bitrate);
1792  }
1793 
1794  if (total_size < 0) av_bprintf(&buf_script, "total_size=N/A\n");
1795  else av_bprintf(&buf_script, "total_size=%"PRId64"\n", total_size);
1796  if (pts == AV_NOPTS_VALUE) {
1797  av_bprintf(&buf_script, "out_time_us=N/A\n");
1798  av_bprintf(&buf_script, "out_time_ms=N/A\n");
1799  av_bprintf(&buf_script, "out_time=N/A\n");
1800  } else {
1801  av_bprintf(&buf_script, "out_time_us=%"PRId64"\n", pts);
1802  av_bprintf(&buf_script, "out_time_ms=%"PRId64"\n", pts);
1803  av_bprintf(&buf_script, "out_time=%s%02d:%02d:%02d.%06d\n",
1804  hours_sign, hours, mins, secs, us);
1805  }
1806 
1808  av_bprintf(&buf, " dup=%d drop=%d", nb_frames_dup, nb_frames_drop);
1809  av_bprintf(&buf_script, "dup_frames=%d\n", nb_frames_dup);
1810  av_bprintf(&buf_script, "drop_frames=%d\n", nb_frames_drop);
1811 
1812  if (speed < 0) {
1813  av_bprintf(&buf, " speed=N/A");
1814  av_bprintf(&buf_script, "speed=N/A\n");
1815  } else {
1816  av_bprintf(&buf, " speed=%4.3gx", speed);
1817  av_bprintf(&buf_script, "speed=%4.3gx\n", speed);
1818  }
1819 
1820  if (print_stats || is_last_report) {
1821  const char end = is_last_report ? '\n' : '\r';
1822  if (print_stats==1 && AV_LOG_INFO > av_log_get_level()) {
1823  fprintf(stderr, "%s %c", buf.str, end);
1824  } else
1825  av_log(NULL, AV_LOG_INFO, "%s %c", buf.str, end);
1826 
1827  fflush(stderr);
1828  }
1829  av_bprint_finalize(&buf, NULL);
1830 
1831  if (progress_avio) {
1832  av_bprintf(&buf_script, "progress=%s\n",
1833  is_last_report ? "end" : "continue");
1834  avio_write(progress_avio, buf_script.str,
1835  FFMIN(buf_script.len, buf_script.size - 1));
1836  avio_flush(progress_avio);
1837  av_bprint_finalize(&buf_script, NULL);
1838  if (is_last_report) {
1839  if ((ret = avio_closep(&progress_avio)) < 0)
1841  "Error closing progress log, loss of information possible: %s\n", av_err2str(ret));
1842  }
1843  }
1844 
1845  if (is_last_report)
1846  print_final_stats(total_size);
1847 }
1848 
1850 {
1851  // We never got any input. Set a fake format, which will
1852  // come from libavformat.
1853  ifilter->format = par->format;
1854  ifilter->sample_rate = par->sample_rate;
1855  ifilter->channels = par->channels;
1856  ifilter->channel_layout = par->channel_layout;
1857  ifilter->width = par->width;
1858  ifilter->height = par->height;
1859  ifilter->sample_aspect_ratio = par->sample_aspect_ratio;
1860 }
1861 
1862 static void flush_encoders(void)
1863 {
1864  int i, ret;
1865 
1866  for (i = 0; i < nb_output_streams; i++) {
1867  OutputStream *ost = output_streams[i];
1868  AVCodecContext *enc = ost->enc_ctx;
1869  OutputFile *of = output_files[ost->file_index];
1870 
1871  if (!ost->encoding_needed)
1872  continue;
1873 
1874  // Try to enable encoding with no input frames.
1875  // Maybe we should just let encoding fail instead.
1876  if (!ost->initialized) {
1877  FilterGraph *fg = ost->filter->graph;
1878  char error[1024] = "";
1879 
1881  "Finishing stream %d:%d without any data written to it.\n",
1882  ost->file_index, ost->st->index);
1883 
1884  if (ost->filter && !fg->graph) {
1885  int x;
1886  for (x = 0; x < fg->nb_inputs; x++) {
1887  InputFilter *ifilter = fg->inputs[x];
1888  if (ifilter->format < 0)
1889  ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
1890  }
1891 
1893  continue;
1894 
1895  ret = configure_filtergraph(fg);
1896  if (ret < 0) {
1897  av_log(NULL, AV_LOG_ERROR, "Error configuring filter graph\n");
1898  exit_program(1);
1899  }
1900 
1901  finish_output_stream(ost);
1902  }
1903 
1904  ret = init_output_stream(ost, error, sizeof(error));
1905  if (ret < 0) {
1906  av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
1907  ost->file_index, ost->index, error);
1908  exit_program(1);
1909  }
1910  }
1911 
1912  if (enc->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
1913  continue;
1914 
1916  continue;
1917 
1918  for (;;) {
1919  const char *desc = NULL;
1920  AVPacket pkt;
1921  int pkt_size;
1922 
1923  switch (enc->codec_type) {
1924  case AVMEDIA_TYPE_AUDIO:
1925  desc = "audio";
1926  break;
1927  case AVMEDIA_TYPE_VIDEO:
1928  desc = "video";
1929  break;
1930  default:
1931  av_assert0(0);
1932  }
1933 
1934  av_init_packet(&pkt);
1935  pkt.data = NULL;
1936  pkt.size = 0;
1937 
1939 
1940  while ((ret = avcodec_receive_packet(enc, &pkt)) == AVERROR(EAGAIN)) {
1941  ret = avcodec_send_frame(enc, NULL);
1942  if (ret < 0) {
1943  av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1944  desc,
1945  av_err2str(ret));
1946  exit_program(1);
1947  }
1948  }
1949 
1950  update_benchmark("flush_%s %d.%d", desc, ost->file_index, ost->index);
1951  if (ret < 0 && ret != AVERROR_EOF) {
1952  av_log(NULL, AV_LOG_FATAL, "%s encoding failed: %s\n",
1953  desc,
1954  av_err2str(ret));
1955  exit_program(1);
1956  }
1957  if (ost->logfile && enc->stats_out) {
1958  fprintf(ost->logfile, "%s", enc->stats_out);
1959  }
1960  if (ret == AVERROR_EOF) {
1961  output_packet(of, &pkt, ost, 1);
1962  break;
1963  }
1964  if (ost->finished & MUXER_FINISHED) {
1965  av_packet_unref(&pkt);
1966  continue;
1967  }
1968  av_packet_rescale_ts(&pkt, enc->time_base, ost->mux_timebase);
1969  pkt_size = pkt.size;
1970  output_packet(of, &pkt, ost, 0);
1972  do_video_stats(ost, pkt_size);
1973  }
1974  }
1975  }
1976 }
1977 
1978 /*
1979  * Check whether a packet from ist should be written into ost at this time
1980  */
1982 {
1983  OutputFile *of = output_files[ost->file_index];
1984  int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
1985 
1986  if (ost->source_index != ist_index)
1987  return 0;
1988 
1989  if (ost->finished)
1990  return 0;
1991 
1992  if (of->start_time != AV_NOPTS_VALUE && ist->pts < of->start_time)
1993  return 0;
1994 
1995  return 1;
1996 }
1997 
1998 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
1999 {
2000  OutputFile *of = output_files[ost->file_index];
2001  InputFile *f = input_files [ist->file_index];
2002  int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
2003  int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->mux_timebase);
2004  AVPacket opkt = { 0 };
2005 
2006  av_init_packet(&opkt);
2007 
2008  // EOF: flush output bitstream filters.
2009  if (!pkt) {
2010  output_packet(of, &opkt, ost, 1);
2011  return;
2012  }
2013 
2014  if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
2016  return;
2017 
2018  if (!ost->frame_number && !ost->copy_prior_start) {
2019  int64_t comp_start = start_time;
2020  if (copy_ts && f->start_time != AV_NOPTS_VALUE)
2021  comp_start = FFMAX(start_time, f->start_time + f->ts_offset);
2022  if (pkt->pts == AV_NOPTS_VALUE ?
2023  ist->pts < comp_start :
2024  pkt->pts < av_rescale_q(comp_start, AV_TIME_BASE_Q, ist->st->time_base))
2025  return;
2026  }
2027 
2028  if (of->recording_time != INT64_MAX &&
2029  ist->pts >= of->recording_time + start_time) {
2030  close_output_stream(ost);
2031  return;
2032  }
2033 
2034  if (f->recording_time != INT64_MAX) {
2035  start_time = f->ctx->start_time;
2036  if (f->start_time != AV_NOPTS_VALUE && copy_ts)
2037  start_time += f->start_time;
2038  if (ist->pts >= f->recording_time + start_time) {
2039  close_output_stream(ost);
2040  return;
2041  }
2042  }
2043 
2044  /* force the input stream PTS */
2045  if (ost->enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO)
2046  ost->sync_opts++;
2047 
2048  if (pkt->pts != AV_NOPTS_VALUE)
2049  opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->mux_timebase) - ost_tb_start_time;
2050  else
2051  opkt.pts = AV_NOPTS_VALUE;
2052 
2053  if (pkt->dts == AV_NOPTS_VALUE)
2054  opkt.dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ost->mux_timebase);
2055  else
2056  opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->mux_timebase);
2057  opkt.dts -= ost_tb_start_time;
2058 
2059  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO && pkt->dts != AV_NOPTS_VALUE) {
2061  if(!duration)
2062  duration = ist->dec_ctx->frame_size;
2063  opkt.dts = opkt.pts = av_rescale_delta(ist->st->time_base, pkt->dts,
2064  (AVRational){1, ist->dec_ctx->sample_rate}, duration, &ist->filter_in_rescale_delta_last,
2065  ost->mux_timebase) - ost_tb_start_time;
2066  }
2067 
2068  opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->mux_timebase);
2069 
2070  opkt.flags = pkt->flags;
2071 
2072  if (pkt->buf) {
2073  opkt.buf = av_buffer_ref(pkt->buf);
2074  if (!opkt.buf)
2075  exit_program(1);
2076  }
2077  opkt.data = pkt->data;
2078  opkt.size = pkt->size;
2079 
2080  av_copy_packet_side_data(&opkt, pkt);
2081 
2082  output_packet(of, &opkt, ost, 0);
2083 }
2084 
2086 {
2087  AVCodecContext *dec = ist->dec_ctx;
2088 
2089  if (!dec->channel_layout) {
2090  char layout_name[256];
2091 
2092  if (dec->channels > ist->guess_layout_max)
2093  return 0;
2095  if (!dec->channel_layout)
2096  return 0;
2097  av_get_channel_layout_string(layout_name, sizeof(layout_name),
2098  dec->channels, dec->channel_layout);
2099  av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
2100  "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
2101  }
2102  return 1;
2103 }
2104 
2105 static void check_decode_result(InputStream *ist, int *got_output, int ret)
2106 {
2107  if (*got_output || ret<0)
2108  decode_error_stat[ret<0] ++;
2109 
2110  if (ret < 0 && exit_on_error)
2111  exit_program(1);
2112 
2113  if (*got_output && ist) {
2116  "%s: corrupt decoded frame in stream %d\n", input_files[ist->file_index]->ctx->url, ist->st->index);
2117  if (exit_on_error)
2118  exit_program(1);
2119  }
2120  }
2121 }
2122 
2123 // Filters can be configured only if the formats of all inputs are known.
2125 {
2126  int i;
2127  for (i = 0; i < fg->nb_inputs; i++) {
2128  if (fg->inputs[i]->format < 0 && (fg->inputs[i]->type == AVMEDIA_TYPE_AUDIO ||
2129  fg->inputs[i]->type == AVMEDIA_TYPE_VIDEO))
2130  return 0;
2131  }
2132  return 1;
2133 }
2134 
2136 {
2137  FilterGraph *fg = ifilter->graph;
2138  int need_reinit, ret, i;
2139 
2140  /* determine if the parameters for this input changed */
2141  need_reinit = ifilter->format != frame->format;
2142 
2143  switch (ifilter->ist->st->codecpar->codec_type) {
2144  case AVMEDIA_TYPE_AUDIO:
2145  need_reinit |= ifilter->sample_rate != frame->sample_rate ||
2146  ifilter->channels != frame->channels ||
2147  ifilter->channel_layout != frame->channel_layout;
2148  break;
2149  case AVMEDIA_TYPE_VIDEO:
2150  need_reinit |= ifilter->width != frame->width ||
2151  ifilter->height != frame->height;
2152  break;
2153  }
2154 
2155  if (!ifilter->ist->reinit_filters && fg->graph)
2156  need_reinit = 0;
2157 
2158  if (!!ifilter->hw_frames_ctx != !!frame->hw_frames_ctx ||
2159  (ifilter->hw_frames_ctx && ifilter->hw_frames_ctx->data != frame->hw_frames_ctx->data))
2160  need_reinit = 1;
2161 
2162  if (need_reinit) {
2163  ret = ifilter_parameters_from_frame(ifilter, frame);
2164  if (ret < 0)
2165  return ret;
2166  }
2167 
2168  /* (re)init the graph if possible, otherwise buffer the frame and return */
2169  if (need_reinit || !fg->graph) {
2170  for (i = 0; i < fg->nb_inputs; i++) {
2171  if (!ifilter_has_all_input_formats(fg)) {
2172  AVFrame *tmp = av_frame_clone(frame);
2173  if (!tmp)
2174  return AVERROR(ENOMEM);
2175  av_frame_unref(frame);
2176 
2177  if (!av_fifo_space(ifilter->frame_queue)) {
2178  ret = av_fifo_realloc2(ifilter->frame_queue, 2 * av_fifo_size(ifilter->frame_queue));
2179  if (ret < 0) {
2180  av_frame_free(&tmp);
2181  return ret;
2182  }
2183  }
2184  av_fifo_generic_write(ifilter->frame_queue, &tmp, sizeof(tmp), NULL);
2185  return 0;
2186  }
2187  }
2188 
2189  ret = reap_filters(1);
2190  if (ret < 0 && ret != AVERROR_EOF) {
2191  av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2192  return ret;
2193  }
2194 
2195  ret = configure_filtergraph(fg);
2196  if (ret < 0) {
2197  av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
2198  return ret;
2199  }
2200  }
2201 
2203  if (ret < 0) {
2204  if (ret != AVERROR_EOF)
2205  av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
2206  return ret;
2207  }
2208 
2209  return 0;
2210 }
2211 
2212 static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
2213 {
2214  int ret;
2215 
2216  ifilter->eof = 1;
2217 
2218  if (ifilter->filter) {
2219  ret = av_buffersrc_close(ifilter->filter, pts, AV_BUFFERSRC_FLAG_PUSH);
2220  if (ret < 0)
2221  return ret;
2222  } else {
2223  // the filtergraph was never configured
2224  if (ifilter->format < 0)
2225  ifilter_parameters_from_codecpar(ifilter, ifilter->ist->st->codecpar);
2226  if (ifilter->format < 0 && (ifilter->type == AVMEDIA_TYPE_AUDIO || ifilter->type == AVMEDIA_TYPE_VIDEO)) {
2227  av_log(NULL, AV_LOG_ERROR, "Cannot determine format of input stream %d:%d after EOF\n", ifilter->ist->file_index, ifilter->ist->st->index);
2228  return AVERROR_INVALIDDATA;
2229  }
2230  }
2231 
2232  return 0;
2233 }
2234 
2235 // This does not quite work like avcodec_decode_audio4/avcodec_decode_video2.
2236 // There is the following difference: if you got a frame, you must call
2237 // it again with pkt=NULL. pkt==NULL is treated differently from pkt->size==0
2238 // (pkt==NULL means get more output, pkt->size==0 is a flush/drain packet)
2239 static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
2240 {
2241  int ret;
2242 
2243  *got_frame = 0;
2244 
2245  if (pkt) {
2246  ret = avcodec_send_packet(avctx, pkt);
2247  // In particular, we don't expect AVERROR(EAGAIN), because we read all
2248  // decoded frames with avcodec_receive_frame() until done.
2249  if (ret < 0 && ret != AVERROR_EOF)
2250  return ret;
2251  }
2252 
2253  ret = avcodec_receive_frame(avctx, frame);
2254  if (ret < 0 && ret != AVERROR(EAGAIN))
2255  return ret;
2256  if (ret >= 0)
2257  *got_frame = 1;
2258 
2259  return 0;
2260 }
2261 
2262 static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
2263 {
2264  int i, ret;
2265  AVFrame *f;
2266 
2267  av_assert1(ist->nb_filters > 0); /* ensure ret is initialized */
2268  for (i = 0; i < ist->nb_filters; i++) {
2269  if (i < ist->nb_filters - 1) {
2270  f = ist->filter_frame;
2271  ret = av_frame_ref(f, decoded_frame);
2272  if (ret < 0)
2273  break;
2274  } else
2275  f = decoded_frame;
2276  ret = ifilter_send_frame(ist->filters[i], f);
2277  if (ret == AVERROR_EOF)
2278  ret = 0; /* ignore */
2279  if (ret < 0) {
2281  "Failed to inject frame into filter network: %s\n", av_err2str(ret));
2282  break;
2283  }
2284  }
2285  return ret;
2286 }
2287 
2288 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output,
2289  int *decode_failed)
2290 {
2291  AVFrame *decoded_frame;
2292  AVCodecContext *avctx = ist->dec_ctx;
2293  int ret, err = 0;
2294  AVRational decoded_frame_tb;
2295 
2296  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2297  return AVERROR(ENOMEM);
2298  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2299  return AVERROR(ENOMEM);
2300  decoded_frame = ist->decoded_frame;
2301 
2303  ret = decode(avctx, decoded_frame, got_output, pkt);
2304  update_benchmark("decode_audio %d.%d", ist->file_index, ist->st->index);
2305  if (ret < 0)
2306  *decode_failed = 1;
2307 
2308  if (ret >= 0 && avctx->sample_rate <= 0) {
2309  av_log(avctx, AV_LOG_ERROR, "Sample rate %d invalid\n", avctx->sample_rate);
2310  ret = AVERROR_INVALIDDATA;
2311  }
2312 
2313  if (ret != AVERROR_EOF)
2314  check_decode_result(ist, got_output, ret);
2315 
2316  if (!*got_output || ret < 0)
2317  return ret;
2318 
2319  ist->samples_decoded += decoded_frame->nb_samples;
2320  ist->frames_decoded++;
2321 
2322 #if 1
2323  /* increment next_dts to use for the case where the input stream does not
2324  have timestamps or there are multiple frames in the packet */
2325  ist->next_pts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2326  avctx->sample_rate;
2327  ist->next_dts += ((int64_t)AV_TIME_BASE * decoded_frame->nb_samples) /
2328  avctx->sample_rate;
2329 #endif
2330 
2331  if (decoded_frame->pts != AV_NOPTS_VALUE) {
2332  decoded_frame_tb = ist->st->time_base;
2333  } else if (pkt && pkt->pts != AV_NOPTS_VALUE) {
2334  decoded_frame->pts = pkt->pts;
2335  decoded_frame_tb = ist->st->time_base;
2336  }else {
2337  decoded_frame->pts = ist->dts;
2338  decoded_frame_tb = AV_TIME_BASE_Q;
2339  }
2340  if (decoded_frame->pts != AV_NOPTS_VALUE)
2341  decoded_frame->pts = av_rescale_delta(decoded_frame_tb, decoded_frame->pts,
2342  (AVRational){1, avctx->sample_rate}, decoded_frame->nb_samples, &ist->filter_in_rescale_delta_last,
2343  (AVRational){1, avctx->sample_rate});
2344  ist->nb_samples = decoded_frame->nb_samples;
2345  err = send_frame_to_filters(ist, decoded_frame);
2346 
2348  av_frame_unref(decoded_frame);
2349  return err < 0 ? err : ret;
2350 }
2351 
2352 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof,
2353  int *decode_failed)
2354 {
2355  AVFrame *decoded_frame;
2356  int i, ret = 0, err = 0;
2357  int64_t best_effort_timestamp;
2358  int64_t dts = AV_NOPTS_VALUE;
2359  AVPacket avpkt;
2360 
2361  // With fate-indeo3-2, we're getting 0-sized packets before EOF for some
2362  // reason. This seems like a semi-critical bug. Don't trigger EOF, and
2363  // skip the packet.
2364  if (!eof && pkt && pkt->size == 0)
2365  return 0;
2366 
2367  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
2368  return AVERROR(ENOMEM);
2369  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
2370  return AVERROR(ENOMEM);
2371  decoded_frame = ist->decoded_frame;
2372  if (ist->dts != AV_NOPTS_VALUE)
2373  dts = av_rescale_q(ist->dts, AV_TIME_BASE_Q, ist->st->time_base);
2374  if (pkt) {
2375  avpkt = *pkt;
2376  avpkt.dts = dts; // ffmpeg.c probably shouldn't do this
2377  }
2378 
2379  // The old code used to set dts on the drain packet, which does not work
2380  // with the new API anymore.
2381  if (eof) {
2382  void *new = av_realloc_array(ist->dts_buffer, ist->nb_dts_buffer + 1, sizeof(ist->dts_buffer[0]));
2383  if (!new)
2384  return AVERROR(ENOMEM);
2385  ist->dts_buffer = new;
2386  ist->dts_buffer[ist->nb_dts_buffer++] = dts;
2387  }
2388 
2390  ret = decode(ist->dec_ctx, decoded_frame, got_output, pkt ? &avpkt : NULL);
2391  update_benchmark("decode_video %d.%d", ist->file_index, ist->st->index);
2392  if (ret < 0)
2393  *decode_failed = 1;
2394 
2395  // The following line may be required in some cases where there is no parser
2396  // or the parser does not has_b_frames correctly
2397  if (ist->st->codecpar->video_delay < ist->dec_ctx->has_b_frames) {
2398  if (ist->dec_ctx->codec_id == AV_CODEC_ID_H264) {
2399  ist->st->codecpar->video_delay = ist->dec_ctx->has_b_frames;
2400  } else
2402  "video_delay is larger in decoder than demuxer %d > %d.\n"
2403  "If you want to help, upload a sample "
2404  "of this file to ftp://upload.ffmpeg.org/incoming/ "
2405  "and contact the ffmpeg-devel mailing list. (ffmpeg-devel@ffmpeg.org)\n",
2406  ist->dec_ctx->has_b_frames,
2407  ist->st->codecpar->video_delay);
2408  }
2409 
2410  if (ret != AVERROR_EOF)
2411  check_decode_result(ist, got_output, ret);
2412 
2413  if (*got_output && ret >= 0) {
2414  if (ist->dec_ctx->width != decoded_frame->width ||
2415  ist->dec_ctx->height != decoded_frame->height ||
2416  ist->dec_ctx->pix_fmt != decoded_frame->format) {
2417  av_log(NULL, AV_LOG_DEBUG, "Frame parameters mismatch context %d,%d,%d != %d,%d,%d\n",
2418  decoded_frame->width,
2419  decoded_frame->height,
2420  decoded_frame->format,
2421  ist->dec_ctx->width,
2422  ist->dec_ctx->height,
2423  ist->dec_ctx->pix_fmt);
2424  }
2425  }
2426 
2427  if (!*got_output || ret < 0)
2428  return ret;
2429 
2430  if(ist->top_field_first>=0)
2431  decoded_frame->top_field_first = ist->top_field_first;
2432 
2433  ist->frames_decoded++;
2434 
2435  if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
2436  err = ist->hwaccel_retrieve_data(ist->dec_ctx, decoded_frame);
2437  if (err < 0)
2438  goto fail;
2439  }
2440  ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
2441 
2442  best_effort_timestamp= decoded_frame->best_effort_timestamp;
2443  *duration_pts = decoded_frame->pkt_duration;
2444 
2445  if (ist->framerate.num)
2446  best_effort_timestamp = ist->cfr_next_pts++;
2447 
2448  if (eof && best_effort_timestamp == AV_NOPTS_VALUE && ist->nb_dts_buffer > 0) {
2449  best_effort_timestamp = ist->dts_buffer[0];
2450 
2451  for (i = 0; i < ist->nb_dts_buffer - 1; i++)
2452  ist->dts_buffer[i] = ist->dts_buffer[i + 1];
2453  ist->nb_dts_buffer--;
2454  }
2455 
2456  if(best_effort_timestamp != AV_NOPTS_VALUE) {
2457  int64_t ts = av_rescale_q(decoded_frame->pts = best_effort_timestamp, ist->st->time_base, AV_TIME_BASE_Q);
2458 
2459  if (ts != AV_NOPTS_VALUE)
2460  ist->next_pts = ist->pts = ts;
2461  }
2462 
2463  if (debug_ts) {
2464  av_log(NULL, AV_LOG_INFO, "decoder -> ist_index:%d type:video "
2465  "frame_pts:%s frame_pts_time:%s best_effort_ts:%"PRId64" best_effort_ts_time:%s keyframe:%d frame_type:%d time_base:%d/%d\n",
2466  ist->st->index, av_ts2str(decoded_frame->pts),
2467  av_ts2timestr(decoded_frame->pts, &ist->st->time_base),
2468  best_effort_timestamp,
2469  av_ts2timestr(best_effort_timestamp, &ist->st->time_base),
2470  decoded_frame->key_frame, decoded_frame->pict_type,
2471  ist->st->time_base.num, ist->st->time_base.den);
2472  }
2473 
2474  if (ist->st->sample_aspect_ratio.num)
2475  decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
2476 
2477  err = send_frame_to_filters(ist, decoded_frame);
2478 
2479 fail:
2481  av_frame_unref(decoded_frame);
2482  return err < 0 ? err : ret;
2483 }
2484 
2485 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output,
2486  int *decode_failed)
2487 {
2488  AVSubtitle subtitle;
2489  int free_sub = 1;
2490  int i, ret = avcodec_decode_subtitle2(ist->dec_ctx,
2491  &subtitle, got_output, pkt);
2492 
2493  check_decode_result(NULL, got_output, ret);
2494 
2495  if (ret < 0 || !*got_output) {
2496  *decode_failed = 1;
2497  if (!pkt->size)
2498  sub2video_flush(ist);
2499  return ret;
2500  }
2501 
2502  if (ist->fix_sub_duration) {
2503  int end = 1;
2504  if (ist->prev_sub.got_output) {
2505  end = av_rescale(subtitle.pts - ist->prev_sub.subtitle.pts,
2506  1000, AV_TIME_BASE);
2507  if (end < ist->prev_sub.subtitle.end_display_time) {
2508  av_log(ist->dec_ctx, AV_LOG_DEBUG,
2509  "Subtitle duration reduced from %"PRId32" to %d%s\n",
2511  end <= 0 ? ", dropping it" : "");
2513  }
2514  }
2515  FFSWAP(int, *got_output, ist->prev_sub.got_output);
2516  FFSWAP(int, ret, ist->prev_sub.ret);
2517  FFSWAP(AVSubtitle, subtitle, ist->prev_sub.subtitle);
2518  if (end <= 0)
2519  goto out;
2520  }
2521 
2522  if (!*got_output)
2523  return ret;
2524 
2525  if (ist->sub2video.frame) {
2526  sub2video_update(ist, &subtitle);
2527  } else if (ist->nb_filters) {
2528  if (!ist->sub2video.sub_queue)
2529  ist->sub2video.sub_queue = av_fifo_alloc(8 * sizeof(AVSubtitle));
2530  if (!ist->sub2video.sub_queue)
2531  exit_program(1);
2532  if (!av_fifo_space(ist->sub2video.sub_queue)) {
2534  if (ret < 0)
2535  exit_program(1);
2536  }
2537  av_fifo_generic_write(ist->sub2video.sub_queue, &subtitle, sizeof(subtitle), NULL);
2538  free_sub = 0;
2539  }
2540 
2541  if (!subtitle.num_rects)
2542  goto out;
2543 
2544  ist->frames_decoded++;
2545 
2546  for (i = 0; i < nb_output_streams; i++) {
2547  OutputStream *ost = output_streams[i];
2548 
2549  if (!check_output_constraints(ist, ost) || !ost->encoding_needed
2550  || ost->enc->type != AVMEDIA_TYPE_SUBTITLE)
2551  continue;
2552 
2553  do_subtitle_out(output_files[ost->file_index], ost, &subtitle);
2554  }
2555 
2556 out:
2557  if (free_sub)
2558  avsubtitle_free(&subtitle);
2559  return ret;
2560 }
2561 
2563 {
2564  int i, ret;
2565  /* TODO keep pts also in stream time base to avoid converting back */
2566  int64_t pts = av_rescale_q_rnd(ist->pts, AV_TIME_BASE_Q, ist->st->time_base,
2568 
2569  for (i = 0; i < ist->nb_filters; i++) {
2570  ret = ifilter_send_eof(ist->filters[i], pts);
2571  if (ret < 0)
2572  return ret;
2573  }
2574  return 0;
2575 }
2576 
2577 /* pkt = NULL means EOF (needed to flush decoder buffers) */
2578 static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
2579 {
2580  int ret = 0, i;
2581  int repeating = 0;
2582  int eof_reached = 0;
2583 
2584  AVPacket avpkt;
2585  if (!ist->saw_first_ts) {
2586  ist->dts = ist->st->avg_frame_rate.num ? - ist->dec_ctx->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
2587  ist->pts = 0;
2588  if (pkt && pkt->pts != AV_NOPTS_VALUE && !ist->decoding_needed) {
2589  ist->dts += av_rescale_q(pkt->pts, ist->st->time_base, AV_TIME_BASE_Q);
2590  ist->pts = ist->dts; //unused but better to set it to a value thats not totally wrong
2591  }
2592  ist->saw_first_ts = 1;
2593  }
2594 
2595  if (ist->next_dts == AV_NOPTS_VALUE)
2596  ist->next_dts = ist->dts;
2597  if (ist->next_pts == AV_NOPTS_VALUE)
2598  ist->next_pts = ist->pts;
2599 
2600  if (!pkt) {
2601  /* EOF handling */
2602  av_init_packet(&avpkt);
2603  avpkt.data = NULL;
2604  avpkt.size = 0;
2605  } else {
2606  avpkt = *pkt;
2607  }
2608 
2609  if (pkt && pkt->dts != AV_NOPTS_VALUE) {
2610  ist->next_dts = ist->dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
2611  if (ist->dec_ctx->codec_type != AVMEDIA_TYPE_VIDEO || !ist->decoding_needed)
2612  ist->next_pts = ist->pts = ist->dts;
2613  }
2614 
2615  // while we have more to decode or while the decoder did output something on EOF
2616  while (ist->decoding_needed) {
2617  int64_t duration_dts = 0;
2618  int64_t duration_pts = 0;
2619  int got_output = 0;
2620  int decode_failed = 0;
2621 
2622  ist->pts = ist->next_pts;
2623  ist->dts = ist->next_dts;
2624 
2625  switch (ist->dec_ctx->codec_type) {
2626  case AVMEDIA_TYPE_AUDIO:
2627  ret = decode_audio (ist, repeating ? NULL : &avpkt, &got_output,
2628  &decode_failed);
2629  break;
2630  case AVMEDIA_TYPE_VIDEO:
2631  ret = decode_video (ist, repeating ? NULL : &avpkt, &got_output, &duration_pts, !pkt,
2632  &decode_failed);
2633  if (!repeating || !pkt || got_output) {
2634  if (pkt && pkt->duration) {
2635  duration_dts = av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2636  } else if(ist->dec_ctx->framerate.num != 0 && ist->dec_ctx->framerate.den != 0) {
2638  duration_dts = ((int64_t)AV_TIME_BASE *
2639  ist->dec_ctx->framerate.den * ticks) /
2641  }
2642 
2643  if(ist->dts != AV_NOPTS_VALUE && duration_dts) {
2644  ist->next_dts += duration_dts;
2645  }else
2646  ist->next_dts = AV_NOPTS_VALUE;
2647  }
2648 
2649  if (got_output) {
2650  if (duration_pts > 0) {
2651  ist->next_pts += av_rescale_q(duration_pts, ist->st->time_base, AV_TIME_BASE_Q);
2652  } else {
2653  ist->next_pts += duration_dts;
2654  }
2655  }
2656  break;
2657  case AVMEDIA_TYPE_SUBTITLE:
2658  if (repeating)
2659  break;
2660  ret = transcode_subtitles(ist, &avpkt, &got_output, &decode_failed);
2661  if (!pkt && ret >= 0)
2662  ret = AVERROR_EOF;
2663  break;
2664  default:
2665  return -1;
2666  }
2667 
2668  if (ret == AVERROR_EOF) {
2669  eof_reached = 1;
2670  break;
2671  }
2672 
2673  if (ret < 0) {
2674  if (decode_failed) {
2675  av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d: %s\n",
2676  ist->file_index, ist->st->index, av_err2str(ret));
2677  } else {
2678  av_log(NULL, AV_LOG_FATAL, "Error while processing the decoded "
2679  "data for stream #%d:%d\n", ist->file_index, ist->st->index);
2680  }
2681  if (!decode_failed || exit_on_error)
2682  exit_program(1);
2683  break;
2684  }
2685 
2686  if (got_output)
2687  ist->got_output = 1;
2688 
2689  if (!got_output)
2690  break;
2691 
2692  // During draining, we might get multiple output frames in this loop.
2693  // ffmpeg.c does not drain the filter chain on configuration changes,
2694  // which means if we send multiple frames at once to the filters, and
2695  // one of those frames changes configuration, the buffered frames will
2696  // be lost. This can upset certain FATE tests.
2697  // Decode only 1 frame per call on EOF to appease these FATE tests.
2698  // The ideal solution would be to rewrite decoding to use the new
2699  // decoding API in a better way.
2700  if (!pkt)
2701  break;
2702 
2703  repeating = 1;
2704  }
2705 
2706  /* after flushing, send an EOF on all the filter inputs attached to the stream */
2707  /* except when looping we need to flush but not to send an EOF */
2708  if (!pkt && ist->decoding_needed && eof_reached && !no_eof) {
2709  int ret = send_filter_eof(ist);
2710  if (ret < 0) {
2711  av_log(NULL, AV_LOG_FATAL, "Error marking filters as finished\n");
2712  exit_program(1);
2713  }
2714  }
2715 
2716  /* handle stream copy */
2717  if (!ist->decoding_needed && pkt) {
2718  ist->dts = ist->next_dts;
2719  switch (ist->dec_ctx->codec_type) {
2720  case AVMEDIA_TYPE_AUDIO:
2721  av_assert1(pkt->duration >= 0);
2722  if (ist->dec_ctx->sample_rate) {
2723  ist->next_dts += ((int64_t)AV_TIME_BASE * ist->dec_ctx->frame_size) /
2724  ist->dec_ctx->sample_rate;
2725  } else {
2726  ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2727  }
2728  break;
2729  case AVMEDIA_TYPE_VIDEO:
2730  if (ist->framerate.num) {
2731  // TODO: Remove work-around for c99-to-c89 issue 7
2732  AVRational time_base_q = AV_TIME_BASE_Q;
2733  int64_t next_dts = av_rescale_q(ist->next_dts, time_base_q, av_inv_q(ist->framerate));
2734  ist->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
2735  } else if (pkt->duration) {
2736  ist->next_dts += av_rescale_q(pkt->duration, ist->st->time_base, AV_TIME_BASE_Q);
2737  } else if(ist->dec_ctx->framerate.num != 0) {
2738  int ticks= av_stream_get_parser(ist->st) ? av_stream_get_parser(ist->st)->repeat_pict + 1 : ist->dec_ctx->ticks_per_frame;
2739  ist->next_dts += ((int64_t)AV_TIME_BASE *
2740  ist->dec_ctx->framerate.den * ticks) /
2742  }
2743  break;
2744  }
2745  ist->pts = ist->dts;
2746  ist->next_pts = ist->next_dts;
2747  }
2748  for (i = 0; i < nb_output_streams; i++) {
2749  OutputStream *ost = output_streams[i];
2750 
2751  if (!check_output_constraints(ist, ost) || ost->encoding_needed)
2752  continue;
2753 
2754  do_streamcopy(ist, ost, pkt);
2755  }
2756 
2757  return !eof_reached;
2758 }
2759 
2760 static void print_sdp(void)
2761 {
2762  char sdp[16384];
2763  int i;
2764  int j;
2765  AVIOContext *sdp_pb;
2766  AVFormatContext **avc;
2767 
2768  for (i = 0; i < nb_output_files; i++) {
2769  if (!output_files[i]->header_written)
2770  return;
2771  }
2772 
2773  avc = av_malloc_array(nb_output_files, sizeof(*avc));
2774  if (!avc)
2775  exit_program(1);
2776  for (i = 0, j = 0; i < nb_output_files; i++) {
2777  if (!strcmp(output_files[i]->ctx->oformat->name, "rtp")) {
2778  avc[j] = output_files[i]->ctx;
2779  j++;
2780  }
2781  }
2782 
2783  if (!j)
2784  goto fail;
2785 
2786  av_sdp_create(avc, j, sdp, sizeof(sdp));
2787 
2788  if (!sdp_filename) {
2789  printf("SDP:\n%s\n", sdp);
2790  fflush(stdout);
2791  } else {
2792  if (avio_open2(&sdp_pb, sdp_filename, AVIO_FLAG_WRITE, &int_cb, NULL) < 0) {
2793  av_log(NULL, AV_LOG_ERROR, "Failed to open sdp file '%s'\n", sdp_filename);
2794  } else {
2795  avio_printf(sdp_pb, "SDP:\n%s", sdp);
2796  avio_closep(&sdp_pb);
2798  }
2799  }
2800 
2801 fail:
2802  av_freep(&avc);
2803 }
2804 
2806 {
2807  InputStream *ist = s->opaque;
2808  const enum AVPixelFormat *p;
2809  int ret;
2810 
2811  for (p = pix_fmts; *p != AV_PIX_FMT_NONE; p++) {
2813  const AVCodecHWConfig *config = NULL;
2814  int i;
2815 
2816  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
2817  break;
2818 
2819  if (ist->hwaccel_id == HWACCEL_GENERIC ||
2820  ist->hwaccel_id == HWACCEL_AUTO) {
2821  for (i = 0;; i++) {
2822  config = avcodec_get_hw_config(s->codec, i);
2823  if (!config)
2824  break;
2825  if (!(config->methods &
2827  continue;
2828  if (config->pix_fmt == *p)
2829  break;
2830  }
2831  }
2832  if (config) {
2833  if (config->device_type != ist->hwaccel_device_type) {
2834  // Different hwaccel offered, ignore.
2835  continue;
2836  }
2837 
2838  ret = hwaccel_decode_init(s);
2839  if (ret < 0) {
2840  if (ist->hwaccel_id == HWACCEL_GENERIC) {
2842  "%s hwaccel requested for input stream #%d:%d, "
2843  "but cannot be initialized.\n",
2845  ist->file_index, ist->st->index);
2846  return AV_PIX_FMT_NONE;
2847  }
2848  continue;
2849  }
2850  } else {
2851  const HWAccel *hwaccel = NULL;
2852  int i;
2853  for (i = 0; hwaccels[i].name; i++) {
2854  if (hwaccels[i].pix_fmt == *p) {
2855  hwaccel = &hwaccels[i];
2856  break;
2857  }
2858  }
2859  if (!hwaccel) {
2860  // No hwaccel supporting this pixfmt.
2861  continue;
2862  }
2863  if (hwaccel->id != ist->hwaccel_id) {
2864  // Does not match requested hwaccel.
2865  continue;
2866  }
2867 
2868  ret = hwaccel->init(s);
2869  if (ret < 0) {
2871  "%s hwaccel requested for input stream #%d:%d, "
2872  "but cannot be initialized.\n", hwaccel->name,
2873  ist->file_index, ist->st->index);
2874  return AV_PIX_FMT_NONE;
2875  }
2876  }
2877 
2878  if (ist->hw_frames_ctx) {
2880  if (!s->hw_frames_ctx)
2881  return AV_PIX_FMT_NONE;
2882  }
2883 
2884  ist->hwaccel_pix_fmt = *p;
2885  break;
2886  }
2887 
2888  return *p;
2889 }
2890 
2892 {
2893  InputStream *ist = s->opaque;
2894 
2895  if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
2896  return ist->hwaccel_get_buffer(s, frame, flags);
2897 
2898  return avcodec_default_get_buffer2(s, frame, flags);
2899 }
2900 
2901 static int init_input_stream(int ist_index, char *error, int error_len)
2902 {
2903  int ret;
2904  InputStream *ist = input_streams[ist_index];
2905 
2906  if (ist->decoding_needed) {
2907  AVCodec *codec = ist->dec;
2908  if (!codec) {
2909  snprintf(error, error_len, "Decoder (codec %s) not found for input stream #%d:%d",
2910  avcodec_get_name(ist->dec_ctx->codec_id), ist->file_index, ist->st->index);
2911  return AVERROR(EINVAL);
2912  }
2913 
2914  ist->dec_ctx->opaque = ist;
2915  ist->dec_ctx->get_format = get_format;
2916  ist->dec_ctx->get_buffer2 = get_buffer;
2917  ist->dec_ctx->thread_safe_callbacks = 1;
2918 
2919  av_opt_set_int(ist->dec_ctx, "refcounted_frames", 1, 0);
2920  if (ist->dec_ctx->codec_id == AV_CODEC_ID_DVB_SUBTITLE &&
2921  (ist->decoding_needed & DECODING_FOR_OST)) {
2922  av_dict_set(&ist->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
2924  av_log(NULL, AV_LOG_WARNING, "Warning using DVB subtitles for filtering and output at the same time is not fully supported, also see -compute_edt [0|1]\n");
2925  }
2926 
2927  av_dict_set(&ist->decoder_opts, "sub_text_format", "ass", AV_DICT_DONT_OVERWRITE);
2928 
2929  /* Useful for subtitles retiming by lavf (FIXME), skipping samples in
2930  * audio, and video decoders such as cuvid or mediacodec */
2931  ist->dec_ctx->pkt_timebase = ist->st->time_base;
2932 
2933  if (!av_dict_get(ist->decoder_opts, "threads", NULL, 0))
2934  av_dict_set(&ist->decoder_opts, "threads", "auto", 0);
2935  /* Attached pics are sparse, therefore we would not want to delay their decoding till EOF. */
2937  av_dict_set(&ist->decoder_opts, "threads", "1", 0);
2938 
2939  ret = hw_device_setup_for_decode(ist);
2940  if (ret < 0) {
2941  snprintf(error, error_len, "Device setup failed for "
2942  "decoder on input stream #%d:%d : %s",
2943  ist->file_index, ist->st->index, av_err2str(ret));
2944  return ret;
2945  }
2946 
2947  if ((ret = avcodec_open2(ist->dec_ctx, codec, &ist->decoder_opts)) < 0) {
2948  if (ret == AVERROR_EXPERIMENTAL)
2949  abort_codec_experimental(codec, 0);
2950 
2951  snprintf(error, error_len,
2952  "Error while opening decoder for input stream "
2953  "#%d:%d : %s",
2954  ist->file_index, ist->st->index, av_err2str(ret));
2955  return ret;
2956  }
2958  }
2959 
2960  ist->next_pts = AV_NOPTS_VALUE;
2961  ist->next_dts = AV_NOPTS_VALUE;
2962 
2963  return 0;
2964 }
2965 
2967 {
2968  if (ost->source_index >= 0)
2969  return input_streams[ost->source_index];
2970  return NULL;
2971 }
2972 
2973 static int compare_int64(const void *a, const void *b)
2974 {
2975  return FFDIFFSIGN(*(const int64_t *)a, *(const int64_t *)b);
2976 }
2977 
2978 /* open the muxer when all the streams are initialized */
2979 static int check_init_output_file(OutputFile *of, int file_index)
2980 {
2981  int ret, i;
2982 
2983  for (i = 0; i < of->ctx->nb_streams; i++) {
2984  OutputStream *ost = output_streams[of->ost_index + i];
2985  if (!ost->initialized)
2986  return 0;
2987  }
2988 
2989  of->ctx->interrupt_callback = int_cb;
2990 
2991  ret = avformat_write_header(of->ctx, &of->opts);
2992  if (ret < 0) {
2994  "Could not write header for output file #%d "
2995  "(incorrect codec parameters ?): %s\n",
2996  file_index, av_err2str(ret));
2997  return ret;
2998  }
2999  //assert_avoptions(of->opts);
3000  of->header_written = 1;
3001 
3002  av_dump_format(of->ctx, file_index, of->ctx->url, 1);
3003 
3004  if (sdp_filename || want_sdp)
3005  print_sdp();
3006 
3007  /* flush the muxing queues */
3008  for (i = 0; i < of->ctx->nb_streams; i++) {
3009  OutputStream *ost = output_streams[of->ost_index + i];
3010 
3011  /* try to improve muxing time_base (only possible if nothing has been written yet) */
3012  if (!av_fifo_size(ost->muxing_queue))
3013  ost->mux_timebase = ost->st->time_base;
3014 
3015  while (av_fifo_size(ost->muxing_queue)) {
3016  AVPacket pkt;
3017  av_fifo_generic_read(ost->muxing_queue, &pkt, sizeof(pkt), NULL);
3018  write_packet(of, &pkt, ost, 1);
3019  }
3020  }
3021 
3022  return 0;
3023 }
3024 
3026 {
3027  AVBSFContext *ctx;
3028  int i, ret;
3029 
3030  if (!ost->nb_bitstream_filters)
3031  return 0;
3032 
3033  for (i = 0; i < ost->nb_bitstream_filters; i++) {
3034  ctx = ost->bsf_ctx[i];
3035 
3036  ret = avcodec_parameters_copy(ctx->par_in,
3037  i ? ost->bsf_ctx[i - 1]->par_out : ost->st->codecpar);
3038  if (ret < 0)
3039  return ret;
3040 
3041  ctx->time_base_in = i ? ost->bsf_ctx[i - 1]->time_base_out : ost->st->time_base;
3042 
3043  ret = av_bsf_init(ctx);
3044  if (ret < 0) {
3045  av_log(NULL, AV_LOG_ERROR, "Error initializing bitstream filter: %s\n",
3046  ost->bsf_ctx[i]->filter->name);
3047  return ret;
3048  }
3049  }
3050 
3051  ctx = ost->bsf_ctx[ost->nb_bitstream_filters - 1];
3052  ret = avcodec_parameters_copy(ost->st->codecpar, ctx->par_out);
3053  if (ret < 0)
3054  return ret;
3055 
3056  ost->st->time_base = ctx->time_base_out;
3057 
3058  return 0;
3059 }
3060 
3062 {
3063  OutputFile *of = output_files[ost->file_index];
3064  InputStream *ist = get_input_stream(ost);
3065  AVCodecParameters *par_dst = ost->st->codecpar;
3066  AVCodecParameters *par_src = ost->ref_par;
3067  AVRational sar;
3068  int i, ret;
3069  uint32_t codec_tag = par_dst->codec_tag;
3070 
3071  av_assert0(ist && !ost->filter);
3072 
3073  ret = avcodec_parameters_to_context(ost->enc_ctx, ist->st->codecpar);
3074  if (ret >= 0)
3075  ret = av_opt_set_dict(ost->enc_ctx, &ost->encoder_opts);
3076  if (ret < 0) {
3078  "Error setting up codec context options.\n");
3079  return ret;
3080  }
3081 
3082  ret = avcodec_parameters_from_context(par_src, ost->enc_ctx);
3083  if (ret < 0) {
3085  "Error getting reference codec parameters.\n");
3086  return ret;
3087  }
3088 
3089  if (!codec_tag) {
3090  unsigned int codec_tag_tmp;
3091  if (!of->ctx->oformat->codec_tag ||
3092  av_codec_get_id (of->ctx->oformat->codec_tag, par_src->codec_tag) == par_src->codec_id ||
3093  !av_codec_get_tag2(of->ctx->oformat->codec_tag, par_src->codec_id, &codec_tag_tmp))
3094  codec_tag = par_src->codec_tag;
3095  }
3096 
3097  ret = avcodec_parameters_copy(par_dst, par_src);
3098  if (ret < 0)
3099  return ret;
3100 
3101  par_dst->codec_tag = codec_tag;
3102 
3103  if (!ost->frame_rate.num)
3104  ost->frame_rate = ist->framerate;
3105  ost->st->avg_frame_rate = ost->frame_rate;
3106 
3108  if (ret < 0)
3109  return ret;
3110 
3111  // copy timebase while removing common factors
3112  if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3114 
3115  // copy estimated duration as a hint to the muxer
3116  if (ost->st->duration <= 0 && ist->st->duration > 0)
3117  ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3118 
3119  // copy disposition
3120  ost->st->disposition = ist->st->disposition;
3121 
3122  if (ist->st->nb_side_data) {
3123  for (i = 0; i < ist->st->nb_side_data; i++) {
3124  const AVPacketSideData *sd_src = &ist->st->side_data[i];
3125  uint8_t *dst_data;
3126 
3127  dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3128  if (!dst_data)
3129  return AVERROR(ENOMEM);
3130  memcpy(dst_data, sd_src->data, sd_src->size);
3131  }
3132  }
3133 
3134  if (ost->rotate_overridden) {
3136  sizeof(int32_t) * 9);
3137  if (sd)
3139  }
3140 
3141  switch (par_dst->codec_type) {
3142  case AVMEDIA_TYPE_AUDIO:
3143  if (audio_volume != 256) {
3144  av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
3145  exit_program(1);
3146  }
3147  if((par_dst->block_align == 1 || par_dst->block_align == 1152 || par_dst->block_align == 576) && par_dst->codec_id == AV_CODEC_ID_MP3)
3148  par_dst->block_align= 0;
3149  if(par_dst->codec_id == AV_CODEC_ID_AC3)
3150  par_dst->block_align= 0;
3151  break;
3152  case AVMEDIA_TYPE_VIDEO:
3153  if (ost->frame_aspect_ratio.num) { // overridden by the -aspect cli option
3154  sar =
3156  (AVRational){ par_dst->height, par_dst->width });
3157  av_log(NULL, AV_LOG_WARNING, "Overriding aspect ratio "
3158  "with stream copy may produce invalid files\n");
3159  }
3160  else if (ist->st->sample_aspect_ratio.num)
3161  sar = ist->st->sample_aspect_ratio;
3162  else
3163  sar = par_src->sample_aspect_ratio;
3164  ost->st->sample_aspect_ratio = par_dst->sample_aspect_ratio = sar;
3165  ost->st->avg_frame_rate = ist->st->avg_frame_rate;
3166  ost->st->r_frame_rate = ist->st->r_frame_rate;
3167  break;
3168  }
3169 
3170  ost->mux_timebase = ist->st->time_base;
3171 
3172  return 0;
3173 }
3174 
3176 {
3177  AVDictionaryEntry *e;
3178 
3179  uint8_t *encoder_string;
3180  int encoder_string_len;
3181  int format_flags = 0;
3182  int codec_flags = ost->enc_ctx->flags;
3183 
3184  if (av_dict_get(ost->st->metadata, "encoder", NULL, 0))
3185  return;
3186 
3187  e = av_dict_get(of->opts, "fflags", NULL, 0);
3188  if (e) {
3189  const AVOption *o = av_opt_find(of->ctx, "fflags", NULL, 0, 0);
3190  if (!o)
3191  return;
3192  av_opt_eval_flags(of->ctx, o, e->value, &format_flags);
3193  }
3194  e = av_dict_get(ost->encoder_opts, "flags", NULL, 0);
3195  if (e) {
3196  const AVOption *o = av_opt_find(ost->enc_ctx, "flags", NULL, 0, 0);
3197  if (!o)
3198  return;
3199  av_opt_eval_flags(ost->enc_ctx, o, e->value, &codec_flags);
3200  }
3201 
3202  encoder_string_len = sizeof(LIBAVCODEC_IDENT) + strlen(ost->enc->name) + 2;
3203  encoder_string = av_mallocz(encoder_string_len);
3204  if (!encoder_string)
3205  exit_program(1);
3206 
3207  if (!(format_flags & AVFMT_FLAG_BITEXACT) && !(codec_flags & AV_CODEC_FLAG_BITEXACT))
3208  av_strlcpy(encoder_string, LIBAVCODEC_IDENT " ", encoder_string_len);
3209  else
3210  av_strlcpy(encoder_string, "Lavc ", encoder_string_len);
3211  av_strlcat(encoder_string, ost->enc->name, encoder_string_len);
3212  av_dict_set(&ost->st->metadata, "encoder", encoder_string,
3214 }
3215 
3216 static void parse_forced_key_frames(char *kf, OutputStream *ost,
3217  AVCodecContext *avctx)
3218 {
3219  char *p;
3220  int n = 1, i, size, index = 0;
3221  int64_t t, *pts;
3222 
3223  for (p = kf; *p; p++)
3224  if (*p == ',')
3225  n++;
3226  size = n;
3227  pts = av_malloc_array(size, sizeof(*pts));
3228  if (!pts) {
3229  av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
3230  exit_program(1);
3231  }
3232 
3233  p = kf;
3234  for (i = 0; i < n; i++) {
3235  char *next = strchr(p, ',');
3236 
3237  if (next)
3238  *next++ = 0;
3239 
3240  if (!memcmp(p, "chapters", 8)) {
3241 
3242  AVFormatContext *avf = output_files[ost->file_index]->ctx;
3243  int j;
3244 
3245  if (avf->nb_chapters > INT_MAX - size ||
3246  !(pts = av_realloc_f(pts, size += avf->nb_chapters - 1,
3247  sizeof(*pts)))) {
3249  "Could not allocate forced key frames array.\n");
3250  exit_program(1);
3251  }
3252  t = p[8] ? parse_time_or_die("force_key_frames", p + 8, 1) : 0;
3253  t = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3254 
3255  for (j = 0; j < avf->nb_chapters; j++) {
3256  AVChapter *c = avf->chapters[j];
3257  av_assert1(index < size);
3258  pts[index++] = av_rescale_q(c->start, c->time_base,
3259  avctx->time_base) + t;
3260  }
3261 
3262  } else {
3263 
3264  t = parse_time_or_die("force_key_frames", p, 1);
3265  av_assert1(index < size);
3266  pts[index++] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
3267 
3268  }
3269 
3270  p = next;
3271  }
3272 
3273  av_assert0(index == size);
3274  qsort(pts, size, sizeof(*pts), compare_int64);
3275  ost->forced_kf_count = size;
3276  ost->forced_kf_pts = pts;
3277 }
3278 
3279 static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
3280 {
3281  InputStream *ist = get_input_stream(ost);
3282  AVCodecContext *enc_ctx = ost->enc_ctx;
3283  AVFormatContext *oc;
3284 
3285  if (ost->enc_timebase.num > 0) {
3286  enc_ctx->time_base = ost->enc_timebase;
3287  return;
3288  }
3289 
3290  if (ost->enc_timebase.num < 0) {
3291  if (ist) {
3292  enc_ctx->time_base = ist->st->time_base;
3293  return;
3294  }
3295 
3296  oc = output_files[ost->file_index]->ctx;
3297  av_log(oc, AV_LOG_WARNING, "Input stream data not available, using default time base\n");
3298  }
3299 
3300  enc_ctx->time_base = default_time_base;
3301 }
3302 
3304 {
3305  InputStream *ist = get_input_stream(ost);
3306  AVCodecContext *enc_ctx = ost->enc_ctx;
3308  AVFormatContext *oc = output_files[ost->file_index]->ctx;
3309  int j, ret;
3310 
3311  set_encoder_id(output_files[ost->file_index], ost);
3312 
3313  // Muxers use AV_PKT_DATA_DISPLAYMATRIX to signal rotation. On the other
3314  // hand, the legacy API makes demuxers set "rotate" metadata entries,
3315  // which have to be filtered out to prevent leaking them to output files.
3316  av_dict_set(&ost->st->metadata, "rotate", NULL, 0);
3317 
3318  if (ist) {
3319  ost->st->disposition = ist->st->disposition;
3320 
3321  dec_ctx = ist->dec_ctx;
3322 
3323  enc_ctx->chroma_sample_location = dec_ctx->chroma_sample_location;
3324  } else {
3325  for (j = 0; j < oc->nb_streams; j++) {
3326  AVStream *st = oc->streams[j];
3327  if (st != ost->st && st->codecpar->codec_type == ost->st->codecpar->codec_type)
3328  break;
3329  }
3330  if (j == oc->nb_streams)
3331  if (ost->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO ||
3334  }
3335 
3336  if (enc_ctx->codec_type == AVMEDIA_TYPE_VIDEO) {
3337  if (!ost->frame_rate.num)
3339  if (ist && !ost->frame_rate.num)
3340  ost->frame_rate = ist->framerate;
3341  if (ist && !ost->frame_rate.num)
3342  ost->frame_rate = ist->st->r_frame_rate;
3343  if (ist && !ost->frame_rate.num) {
3344  ost->frame_rate = (AVRational){25, 1};
3346  "No information "
3347  "about the input framerate is available. Falling "
3348  "back to a default value of 25fps for output stream #%d:%d. Use the -r option "
3349  "if you want a different framerate.\n",
3350  ost->file_index, ost->index);
3351  }
3352 // ost->frame_rate = ist->st->avg_frame_rate.num ? ist->st->avg_frame_rate : (AVRational){25, 1};
3353  if (ost->enc->supported_framerates && !ost->force_fps) {
3354  int idx = av_find_nearest_q_idx(ost->frame_rate, ost->enc->supported_framerates);
3355  ost->frame_rate = ost->enc->supported_framerates[idx];
3356  }
3357  // reduce frame rate for mpeg4 to be within the spec limits
3358  if (enc_ctx->codec_id == AV_CODEC_ID_MPEG4) {
3359  av_reduce(&ost->frame_rate.num, &ost->frame_rate.den,
3360  ost->frame_rate.num, ost->frame_rate.den, 65535);
3361  }
3362  }
3363 
3364  switch (enc_ctx->codec_type) {
3365  case AVMEDIA_TYPE_AUDIO:
3367  if (dec_ctx)
3368  enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3369  av_get_bytes_per_sample(enc_ctx->sample_fmt) << 3);
3373 
3374  init_encoder_time_base(ost, av_make_q(1, enc_ctx->sample_rate));
3375  break;
3376 
3377  case AVMEDIA_TYPE_VIDEO:
3379 
3380  if (!(enc_ctx->time_base.num && enc_ctx->time_base.den))
3382  if ( av_q2d(enc_ctx->time_base) < 0.001 && video_sync_method != VSYNC_PASSTHROUGH
3384  av_log(oc, AV_LOG_WARNING, "Frame rate very high for a muxer not efficiently supporting it.\n"
3385  "Please consider specifying a lower framerate, a different muxer or -vsync 2\n");
3386  }
3387  for (j = 0; j < ost->forced_kf_count; j++)
3388  ost->forced_kf_pts[j] = av_rescale_q(ost->forced_kf_pts[j],
3390  enc_ctx->time_base);
3391 
3392  enc_ctx->width = av_buffersink_get_w(ost->filter->filter);
3393  enc_ctx->height = av_buffersink_get_h(ost->filter->filter);
3394  enc_ctx->sample_aspect_ratio = ost->st->sample_aspect_ratio =
3395  ost->frame_aspect_ratio.num ? // overridden by the -aspect cli option
3396  av_mul_q(ost->frame_aspect_ratio, (AVRational){ enc_ctx->height, enc_ctx->width }) :
3398 
3399  enc_ctx->pix_fmt = av_buffersink_get_format(ost->filter->filter);
3400  if (dec_ctx)
3401  enc_ctx->bits_per_raw_sample = FFMIN(dec_ctx->bits_per_raw_sample,
3402  av_pix_fmt_desc_get(enc_ctx->pix_fmt)->comp[0].depth);
3403 
3404  enc_ctx->framerate = ost->frame_rate;
3405 
3406  ost->st->avg_frame_rate = ost->frame_rate;
3407 
3408  if (!dec_ctx ||
3409  enc_ctx->width != dec_ctx->width ||
3410  enc_ctx->height != dec_ctx->height ||
3411  enc_ctx->pix_fmt != dec_ctx->pix_fmt) {
3413  }
3414 
3415  if (ost->top_field_first == 0) {
3416  enc_ctx->field_order = AV_FIELD_BB;
3417  } else if (ost->top_field_first == 1) {
3418  enc_ctx->field_order = AV_FIELD_TT;
3419  }
3420 
3421  if (ost->forced_keyframes) {
3422  if (!strncmp(ost->forced_keyframes, "expr:", 5)) {
3425  if (ret < 0) {
3427  "Invalid force_key_frames expression '%s'\n", ost->forced_keyframes+5);
3428  return ret;
3429  }
3434 
3435  // Don't parse the 'forced_keyframes' in case of 'keep-source-keyframes',
3436  // parse it only for static kf timings
3437  } else if(strncmp(ost->forced_keyframes, "source", 6)) {
3439  }
3440  }
3441  break;
3442  case AVMEDIA_TYPE_SUBTITLE:
3443  enc_ctx->time_base = AV_TIME_BASE_Q;
3444  if (!enc_ctx->width) {
3445  enc_ctx->width = input_streams[ost->source_index]->st->codecpar->width;
3446  enc_ctx->height = input_streams[ost->source_index]->st->codecpar->height;
3447  }
3448  break;
3449  case AVMEDIA_TYPE_DATA:
3450  break;
3451  default:
3452  abort();
3453  break;
3454  }
3455 
3456  ost->mux_timebase = enc_ctx->time_base;
3457 
3458  return 0;
3459 }
3460 
3461 static int init_output_stream(OutputStream *ost, char *error, int error_len)
3462 {
3463  int ret = 0;
3464 
3465  if (ost->encoding_needed) {
3466  AVCodec *codec = ost->enc;
3467  AVCodecContext *dec = NULL;
3468  InputStream *ist;
3469 
3470  ret = init_output_stream_encode(ost);
3471  if (ret < 0)
3472  return ret;
3473 
3474  if ((ist = get_input_stream(ost)))
3475  dec = ist->dec_ctx;
3476  if (dec && dec->subtitle_header) {
3477  /* ASS code assumes this buffer is null terminated so add extra byte. */
3479  if (!ost->enc_ctx->subtitle_header)
3480  return AVERROR(ENOMEM);
3481  memcpy(ost->enc_ctx->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
3483  }
3484  if (!av_dict_get(ost->encoder_opts, "threads", NULL, 0))
3485  av_dict_set(&ost->encoder_opts, "threads", "auto", 0);
3486  if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3487  !codec->defaults &&
3488  !av_dict_get(ost->encoder_opts, "b", NULL, 0) &&
3489  !av_dict_get(ost->encoder_opts, "ab", NULL, 0))
3490  av_dict_set(&ost->encoder_opts, "b", "128000", 0);
3491 
3492  if (ost->filter && av_buffersink_get_hw_frames_ctx(ost->filter->filter) &&
3496  if (!ost->enc_ctx->hw_frames_ctx)
3497  return AVERROR(ENOMEM);
3498  } else {
3499  ret = hw_device_setup_for_encode(ost);
3500  if (ret < 0) {
3501  snprintf(error, error_len, "Device setup failed for "
3502  "encoder on output stream #%d:%d : %s",
3503  ost->file_index, ost->index, av_err2str(ret));
3504  return ret;
3505  }
3506  }
3507  if (ist && ist->dec->type == AVMEDIA_TYPE_SUBTITLE && ost->enc->type == AVMEDIA_TYPE_SUBTITLE) {
3508  int input_props = 0, output_props = 0;
3509  AVCodecDescriptor const *input_descriptor =
3511  AVCodecDescriptor const *output_descriptor =
3513  if (input_descriptor)
3514  input_props = input_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
3515  if (output_descriptor)
3516  output_props = output_descriptor->props & (AV_CODEC_PROP_TEXT_SUB | AV_CODEC_PROP_BITMAP_SUB);
3517  if (input_props && output_props && input_props != output_props) {
3518  snprintf(error, error_len,
3519  "Subtitle encoding currently only possible from text to text "
3520  "or bitmap to bitmap");
3521  return AVERROR_INVALIDDATA;
3522  }
3523  }
3524 
3525  if ((ret = avcodec_open2(ost->enc_ctx, codec, &ost->encoder_opts)) < 0) {
3526  if (ret == AVERROR_EXPERIMENTAL)
3527  abort_codec_experimental(codec, 1);
3528  snprintf(error, error_len,
3529  "Error while opening encoder for output stream #%d:%d - "
3530  "maybe incorrect parameters such as bit_rate, rate, width or height",
3531  ost->file_index, ost->index);
3532  return ret;
3533  }
3534  if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
3535  !(ost->enc->capabilities & AV_CODEC_CAP_VARIABLE_FRAME_SIZE))
3537  ost->enc_ctx->frame_size);
3539  if (ost->enc_ctx->bit_rate && ost->enc_ctx->bit_rate < 1000 &&
3540  ost->enc_ctx->codec_id != AV_CODEC_ID_CODEC2 /* don't complain about 700 bit/s modes */)
3541  av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
3542  " It takes bits/s as argument, not kbits/s\n");
3543 
3545  if (ret < 0) {
3547  "Error initializing the output stream codec context.\n");
3548  exit_program(1);
3549  }
3550  /*
3551  * FIXME: ost->st->codec should't be needed here anymore.
3552  */
3553  ret = avcodec_copy_context(ost->st->codec, ost->enc_ctx);
3554  if (ret < 0)
3555  return ret;
3556 
3557  if (ost->enc_ctx->nb_coded_side_data) {
3558  int i;
3559 
3560  for (i = 0; i < ost->enc_ctx->nb_coded_side_data; i++) {
3561  const AVPacketSideData *sd_src = &ost->enc_ctx->coded_side_data[i];
3562  uint8_t *dst_data;
3563 
3564  dst_data = av_stream_new_side_data(ost->st, sd_src->type, sd_src->size);
3565  if (!dst_data)
3566  return AVERROR(ENOMEM);
3567  memcpy(dst_data, sd_src->data, sd_src->size);
3568  }
3569  }
3570 
3571  /*
3572  * Add global input side data. For now this is naive, and copies it
3573  * from the input stream's global side data. All side data should
3574  * really be funneled over AVFrame and libavfilter, then added back to
3575  * packet side data, and then potentially using the first packet for
3576  * global side data.
3577  */
3578  if (ist) {
3579  int i;
3580  for (i = 0; i < ist->st->nb_side_data; i++) {
3581  AVPacketSideData *sd = &ist->st->side_data[i];
3582  uint8_t *dst = av_stream_new_side_data(ost->st, sd->type, sd->size);
3583  if (!dst)
3584  return AVERROR(ENOMEM);
3585  memcpy(dst, sd->data, sd->size);
3586  if (ist->autorotate && sd->type == AV_PKT_DATA_DISPLAYMATRIX)
3587  av_display_rotation_set((uint32_t *)dst, 0);
3588  }
3589  }
3590 
3591  // copy timebase while removing common factors
3592  if (ost->st->time_base.num <= 0 || ost->st->time_base.den <= 0)
3593  ost->st->time_base = av_add_q(ost->enc_ctx->time_base, (AVRational){0, 1});
3594 
3595  // copy estimated duration as a hint to the muxer
3596  if (ost->st->duration <= 0 && ist && ist->st->duration > 0)
3597  ost->st->duration = av_rescale_q(ist->st->duration, ist->st->time_base, ost->st->time_base);
3598 
3599  ost->st->codec->codec= ost->enc_ctx->codec;
3600  } else if (ost->stream_copy) {
3601  ret = init_output_stream_streamcopy(ost);
3602  if (ret < 0)
3603  return ret;
3604  }
3605 
3606  // parse user provided disposition, and update stream values
3607  if (ost->disposition) {
3608  static const AVOption opts[] = {
3609  { "disposition" , NULL, 0, AV_OPT_TYPE_FLAGS, { .i64 = 0 }, INT64_MIN, INT64_MAX, .unit = "flags" },
3610  { "default" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEFAULT }, .unit = "flags" },
3611  { "dub" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DUB }, .unit = "flags" },
3612  { "original" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ORIGINAL }, .unit = "flags" },
3613  { "comment" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_COMMENT }, .unit = "flags" },
3614  { "lyrics" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_LYRICS }, .unit = "flags" },
3615  { "karaoke" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_KARAOKE }, .unit = "flags" },
3616  { "forced" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_FORCED }, .unit = "flags" },
3617  { "hearing_impaired" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_HEARING_IMPAIRED }, .unit = "flags" },
3618  { "visual_impaired" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_VISUAL_IMPAIRED }, .unit = "flags" },
3619  { "clean_effects" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CLEAN_EFFECTS }, .unit = "flags" },
3620  { "attached_pic" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_ATTACHED_PIC }, .unit = "flags" },
3621  { "captions" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_CAPTIONS }, .unit = "flags" },
3622  { "descriptions" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DESCRIPTIONS }, .unit = "flags" },
3623  { "dependent" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_DEPENDENT }, .unit = "flags" },
3624  { "metadata" , NULL, 0, AV_OPT_TYPE_CONST, { .i64 = AV_DISPOSITION_METADATA }, .unit = "flags" },
3625  { NULL },
3626  };
3627  static const AVClass class = {
3628  .class_name = "",
3629  .item_name = av_default_item_name,
3630  .option = opts,
3631  .version = LIBAVUTIL_VERSION_INT,
3632  };
3633  const AVClass *pclass = &class;
3634 
3635  ret = av_opt_eval_flags(&pclass, &opts[0], ost->disposition, &ost->st->disposition);
3636  if (ret < 0)
3637  return ret;
3638  }
3639 
3640  /* initialize bitstream filters for the output stream
3641  * needs to be done here, because the codec id for streamcopy is not
3642  * known until now */
3643  ret = init_output_bsfs(ost);
3644  if (ret < 0)
3645  return ret;
3646 
3647  ost->initialized = 1;
3648 
3649  ret = check_init_output_file(output_files[ost->file_index], ost->file_index);
3650  if (ret < 0)
3651  return ret;
3652 
3653  return ret;
3654 }
3655 
3656 static void report_new_stream(int input_index, AVPacket *pkt)
3657 {
3658  InputFile *file = input_files[input_index];
3659  AVStream *st = file->ctx->streams[pkt->stream_index];
3660 
3661  if (pkt->stream_index < file->nb_streams_warn)
3662  return;
3663  av_log(file->ctx, AV_LOG_WARNING,
3664  "New %s stream %d:%d at pos:%"PRId64" and DTS:%ss\n",
3666  input_index, pkt->stream_index,
3667  pkt->pos, av_ts2timestr(pkt->dts, &st->time_base));
3668  file->nb_streams_warn = pkt->stream_index + 1;
3669 }
3670 
3671 static int transcode_init(void)
3672 {
3673  int ret = 0, i, j, k;
3674  AVFormatContext *oc;
3675  OutputStream *ost;
3676  InputStream *ist;
3677  char error[1024] = {0};
3678 
3679  for (i = 0; i < nb_filtergraphs; i++) {
3680  FilterGraph *fg = filtergraphs[i];
3681  for (j = 0; j < fg->nb_outputs; j++) {
3682  OutputFilter *ofilter = fg->outputs[j];
3683  if (!ofilter->ost || ofilter->ost->source_index >= 0)
3684  continue;
3685  if (fg->nb_inputs != 1)
3686  continue;
3687  for (k = nb_input_streams-1; k >= 0 ; k--)
3688  if (fg->inputs[0]->ist == input_streams[k])
3689  break;
3690  ofilter->ost->source_index = k;
3691  }
3692  }
3693 
3694  /* init framerate emulation */
3695  for (i = 0; i < nb_input_files; i++) {
3696  InputFile *ifile = input_files[i];
3697  if (ifile->rate_emu)
3698  for (j = 0; j < ifile->nb_streams; j++)
3699  input_streams[j + ifile->ist_index]->start = av_gettime_relative();
3700  }
3701 
3702  /* init input streams */
3703  for (i = 0; i < nb_input_streams; i++)
3704  if ((ret = init_input_stream(i, error, sizeof(error))) < 0) {
3705  for (i = 0; i < nb_output_streams; i++) {
3706  ost = output_streams[i];
3707  avcodec_close(ost->enc_ctx);
3708  }
3709  goto dump_format;
3710  }
3711 
3712  /* open each encoder */
3713  for (i = 0; i < nb_output_streams; i++) {
3714  // skip streams fed from filtergraphs until we have a frame for them
3715  if (output_streams[i]->filter)
3716  continue;
3717 
3718  ret = init_output_stream(output_streams[i], error, sizeof(error));
3719  if (ret < 0)
3720  goto dump_format;
3721  }
3722 
3723  /* discard unused programs */
3724  for (i = 0; i < nb_input_files; i++) {
3725  InputFile *ifile = input_files[i];
3726  for (j = 0; j < ifile->ctx->nb_programs; j++) {
3727  AVProgram *p = ifile->ctx->programs[j];
3728  int discard = AVDISCARD_ALL;
3729 
3730  for (k = 0; k < p->nb_stream_indexes; k++)
3731  if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
3732  discard = AVDISCARD_DEFAULT;
3733  break;
3734  }
3735  p->discard = discard;
3736  }
3737  }
3738 
3739  /* write headers for files with no streams */
3740  for (i = 0; i < nb_output_files; i++) {
3741  oc = output_files[i]->ctx;
3742  if (oc->oformat->flags & AVFMT_NOSTREAMS && oc->nb_streams == 0) {
3743  ret = check_init_output_file(output_files[i], i);
3744  if (ret < 0)
3745  goto dump_format;
3746  }
3747  }
3748 
3749  dump_format:
3750  /* dump the stream mapping */
3751  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
3752  for (i = 0; i < nb_input_streams; i++) {
3753  ist = input_streams[i];
3754 
3755  for (j = 0; j < ist->nb_filters; j++) {
3756  if (!filtergraph_is_simple(ist->filters[j]->graph)) {
3757  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
3758  ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
3759  ist->filters[j]->name);
3760  if (nb_filtergraphs > 1)
3761  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
3762  av_log(NULL, AV_LOG_INFO, "\n");
3763  }
3764  }
3765  }
3766 
3767  for (i = 0; i < nb_output_streams; i++) {
3768  ost = output_streams[i];
3769 
3770  if (ost->attachment_filename) {
3771  /* an attached file */
3772  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
3773  ost->attachment_filename, ost->file_index, ost->index);
3774  continue;
3775  }
3776 
3777  if (ost->filter && !filtergraph_is_simple(ost->filter->graph)) {
3778  /* output from a complex graph */
3779  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
3780  if (nb_filtergraphs > 1)
3781  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
3782 
3783  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
3784  ost->index, ost->enc ? ost->enc->name : "?");
3785  continue;
3786  }
3787 
3788  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
3789  input_streams[ost->source_index]->file_index,
3790  input_streams[ost->source_index]->st->index,
3791  ost->file_index,
3792  ost->index);
3793  if (ost->sync_ist != input_streams[ost->source_index])
3794  av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
3795  ost->sync_ist->file_index,
3796  ost->sync_ist->st->index);
3797  if (ost->stream_copy)
3798  av_log(NULL, AV_LOG_INFO, " (copy)");
3799  else {
3800  const AVCodec *in_codec = input_streams[ost->source_index]->dec;
3801  const AVCodec *out_codec = ost->enc;
3802  const char *decoder_name = "?";
3803  const char *in_codec_name = "?";
3804  const char *encoder_name = "?";
3805  const char *out_codec_name = "?";
3806  const AVCodecDescriptor *desc;
3807 
3808  if (in_codec) {
3809  decoder_name = in_codec->name;
3810  desc = avcodec_descriptor_get(in_codec->id);
3811  if (desc)
3812  in_codec_name = desc->name;
3813  if (!strcmp(decoder_name, in_codec_name))
3814  decoder_name = "native";
3815  }
3816 
3817  if (out_codec) {
3818  encoder_name = out_codec->name;
3819  desc = avcodec_descriptor_get(out_codec->id);
3820  if (desc)
3821  out_codec_name = desc->name;
3822  if (!strcmp(encoder_name, out_codec_name))
3823  encoder_name = "native";
3824  }
3825 
3826  av_log(NULL, AV_LOG_INFO, " (%s (%s) -> %s (%s))",
3827  in_codec_name, decoder_name,
3828  out_codec_name, encoder_name);
3829  }
3830  av_log(NULL, AV_LOG_INFO, "\n");
3831  }
3832 
3833  if (ret) {
3834  av_log(NULL, AV_LOG_ERROR, "%s\n", error);
3835  return ret;
3836  }
3837 
3839 
3840  return 0;
3841 }
3842 
3843 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
3844 static int need_output(void)
3845 {
3846  int i;
3847 
3848  for (i = 0; i < nb_output_streams; i++) {
3849  OutputStream *ost = output_streams[i];
3850  OutputFile *of = output_files[ost->file_index];
3851  AVFormatContext *os = output_files[ost->file_index]->ctx;
3852 
3853  if (ost->finished ||
3854  (os->pb && avio_tell(os->pb) >= of->limit_filesize))
3855  continue;
3856  if (ost->frame_number >= ost->max_frames) {
3857  int j;
3858  for (j = 0; j < of->ctx->nb_streams; j++)
3859  close_output_stream(output_streams[of->ost_index + j]);
3860  continue;
3861  }
3862 
3863  return 1;
3864  }
3865 
3866  return 0;
3867 }
3868 
3869 /**
3870  * Select the output stream to process.
3871  *
3872  * @return selected output stream, or NULL if none available
3873  */
3875 {
3876  int i;
3877  int64_t opts_min = INT64_MAX;
3878  OutputStream *ost_min = NULL;
3879 
3880  for (i = 0; i < nb_output_streams; i++) {
3881  OutputStream *ost = output_streams[i];
3882  int64_t opts = ost->st->cur_dts == AV_NOPTS_VALUE ? INT64_MIN :
3883  av_rescale_q(ost->st->cur_dts, ost->st->time_base,
3884  AV_TIME_BASE_Q);
3885  if (ost->st->cur_dts == AV_NOPTS_VALUE)
3886  av_log(NULL, AV_LOG_DEBUG, "cur_dts is invalid (this is harmless if it occurs once at the start per stream)\n");
3887 
3888  if (!ost->initialized && !ost->inputs_done)
3889  return ost;
3890 
3891  if (!ost->finished && opts < opts_min) {
3892  opts_min = opts;
3893  ost_min = ost->unavailable ? NULL : ost;
3894  }
3895  }
3896  return ost_min;
3897 }
3898 
3899 static void set_tty_echo(int on)
3900 {
3901 #if HAVE_TERMIOS_H
3902  struct termios tty;
3903  if (tcgetattr(0, &tty) == 0) {
3904  if (on) tty.c_lflag |= ECHO;
3905  else tty.c_lflag &= ~ECHO;
3906  tcsetattr(0, TCSANOW, &tty);
3907  }
3908 #endif
3909 }
3910 
3911 static int check_keyboard_interaction(int64_t cur_time)
3912 {
3913  int i, ret, key;
3914  static int64_t last_time;
3915  if (received_nb_signals)
3916  return AVERROR_EXIT;
3917  /* read_key() returns 0 on EOF */
3918  if(cur_time - last_time >= 100000 && !run_as_daemon){
3919  key = read_key();
3920  last_time = cur_time;
3921  }else
3922  key = -1;
3923  if (key == 'q')
3924  return AVERROR_EXIT;
3925  if (key == '+') av_log_set_level(av_log_get_level()+10);
3926  if (key == '-') av_log_set_level(av_log_get_level()-10);
3927  if (key == 's') qp_hist ^= 1;
3928  if (key == 'h'){
3929  if (do_hex_dump){
3930  do_hex_dump = do_pkt_dump = 0;
3931  } else if(do_pkt_dump){
3932  do_hex_dump = 1;
3933  } else
3934  do_pkt_dump = 1;
3936  }
3937  if (key == 'c' || key == 'C'){
3938  char buf[4096], target[64], command[256], arg[256] = {0};
3939  double time;
3940  int k, n = 0;
3941  fprintf(stderr, "\nEnter command: <target>|all <time>|-1 <command>[ <argument>]\n");
3942  i = 0;
3943  set_tty_echo(1);
3944  while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3945  if (k > 0)
3946  buf[i++] = k;
3947  buf[i] = 0;
3948  set_tty_echo(0);
3949  fprintf(stderr, "\n");
3950  if (k > 0 &&
3951  (n = sscanf(buf, "%63[^ ] %lf %255[^ ] %255[^\n]", target, &time, command, arg)) >= 3) {
3952  av_log(NULL, AV_LOG_DEBUG, "Processing command target:%s time:%f command:%s arg:%s",
3953  target, time, command, arg);
3954  for (i = 0; i < nb_filtergraphs; i++) {
3955  FilterGraph *fg = filtergraphs[i];
3956  if (fg->graph) {
3957  if (time < 0) {
3958  ret = avfilter_graph_send_command(fg->graph, target, command, arg, buf, sizeof(buf),
3959  key == 'c' ? AVFILTER_CMD_FLAG_ONE : 0);
3960  fprintf(stderr, "Command reply for stream %d: ret:%d res:\n%s", i, ret, buf);
3961  } else if (key == 'c') {
3962  fprintf(stderr, "Queuing commands only on filters supporting the specific command is unsupported\n");
3963  ret = AVERROR_PATCHWELCOME;
3964  } else {
3965  ret = avfilter_graph_queue_command(fg->graph, target, command, arg, 0, time);
3966  if (ret < 0)
3967  fprintf(stderr, "Queuing command failed with error %s\n", av_err2str(ret));
3968  }
3969  }
3970  }
3971  } else {
3973  "Parse error, at least 3 arguments were expected, "
3974  "only %d given in string '%s'\n", n, buf);
3975  }
3976  }
3977  if (key == 'd' || key == 'D'){
3978  int debug=0;
3979  if(key == 'D') {
3980  debug = input_streams[0]->st->codec->debug<<1;
3981  if(!debug) debug = 1;
3982  while(debug & (FF_DEBUG_DCT_COEFF
3983 #if FF_API_DEBUG_MV
3984  |FF_DEBUG_VIS_QP|FF_DEBUG_VIS_MB_TYPE
3985 #endif
3986  )) //unsupported, would just crash
3987  debug += debug;
3988  }else{
3989  char buf[32];
3990  int k = 0;
3991  i = 0;
3992  set_tty_echo(1);
3993  while ((k = read_key()) != '\n' && k != '\r' && i < sizeof(buf)-1)
3994  if (k > 0)
3995  buf[i++] = k;
3996  buf[i] = 0;
3997  set_tty_echo(0);
3998  fprintf(stderr, "\n");
3999  if (k <= 0 || sscanf(buf, "%d", &debug)!=1)
4000  fprintf(stderr,"error parsing debug value\n");
4001  }
4002  for(i=0;i<nb_input_streams;i++) {
4003  input_streams[i]->st->codec->debug = debug;
4004  }
4005  for(i=0;i<nb_output_streams;i++) {
4006  OutputStream *ost = output_streams[i];
4007  ost->enc_ctx->debug = debug;
4008  }
4009  if(debug) av_log_set_level(AV_LOG_DEBUG);
4010  fprintf(stderr,"debug=%d\n", debug);
4011  }
4012  if (key == '?'){
4013  fprintf(stderr, "key function\n"
4014  "? show this help\n"
4015  "+ increase verbosity\n"
4016  "- decrease verbosity\n"
4017  "c Send command to first matching filter supporting it\n"
4018  "C Send/Queue command to all matching filters\n"
4019  "D cycle through available debug modes\n"
4020  "h dump packets/hex press to cycle through the 3 states\n"
4021  "q quit\n"
4022  "s Show QP histogram\n"
4023  );
4024  }
4025  return 0;
4026 }
4027 
4028 #if HAVE_THREADS
4029 static void *input_thread(void *arg)
4030 {
4031  InputFile *f = arg;
4032  unsigned flags = f->non_blocking ? AV_THREAD_MESSAGE_NONBLOCK : 0;
4033  int ret = 0;
4034 
4035  while (1) {
4036  AVPacket pkt;
4037  ret = av_read_frame(f->ctx, &pkt);
4038 
4039  if (ret == AVERROR(EAGAIN)) {
4040  av_usleep(10000);
4041  continue;
4042  }
4043  if (ret < 0) {
4044  av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
4045  break;
4046  }
4047  ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
4048  if (flags && ret == AVERROR(EAGAIN)) {
4049  flags = 0;
4050  ret = av_thread_message_queue_send(f->in_thread_queue, &pkt, flags);
4052  "Thread message queue blocking; consider raising the "
4053  "thread_queue_size option (current value: %d)\n",
4054  f->thread_queue_size);
4055  }
4056  if (ret < 0) {
4057  if (ret != AVERROR_EOF)
4058  av_log(f->ctx, AV_LOG_ERROR,
4059  "Unable to send packet to main thread: %s\n",
4060  av_err2str(ret));
4061  av_packet_unref(&pkt);
4062  av_thread_message_queue_set_err_recv(f->in_thread_queue, ret);
4063  break;
4064  }
4065  }
4066 
4067  return NULL;
4068 }
4069 
4070 static void free_input_thread(int i)
4071 {
4072  InputFile *f = input_files[i];
4073  AVPacket pkt;
4074 
4075  if (!f || !f->in_thread_queue)
4076  return;
4078  while (av_thread_message_queue_recv(f->in_thread_queue, &pkt, 0) >= 0)
4079  av_packet_unref(&pkt);
4080 
4081  pthread_join(f->thread, NULL);
4082  f->joined = 1;
4083  av_thread_message_queue_free(&f->in_thread_queue);
4084 }
4085 
4086 static void free_input_threads(void)
4087 {
4088  int i;
4089 
4090  for (i = 0; i < nb_input_files; i++)
4091  free_input_thread(i);
4092 }
4093 
4094 static int init_input_thread(int i)
4095 {
4096  int ret;
4097  InputFile *f = input_files[i];
4098 
4099  if (nb_input_files == 1)
4100  return 0;
4101 
4102  if (f->ctx->pb ? !f->ctx->pb->seekable :
4103  strcmp(f->ctx->iformat->name, "lavfi"))
4104  f->non_blocking = 1;
4105  ret = av_thread_message_queue_alloc(&f->in_thread_queue,
4106  f->thread_queue_size, sizeof(AVPacket));
4107  if (ret < 0)
4108  return ret;
4109 
4110  if ((ret = pthread_create(&f->thread, NULL, input_thread, f))) {
4111  av_log(NULL, AV_LOG_ERROR, "pthread_create failed: %s. Try to increase `ulimit -v` or decrease `ulimit -s`.\n", strerror(ret));
4112  av_thread_message_queue_free(&f->in_thread_queue);
4113  return AVERROR(ret);
4114  }
4115 
4116  return 0;
4117 }
4118 
4119 static int init_input_threads(void)
4120 {
4121  int i, ret;
4122 
4123  for (i = 0; i < nb_input_files; i++) {
4124  ret = init_input_thread(i);
4125  if (ret < 0)
4126  return ret;
4127  }
4128  return 0;
4129 }
4130 
4131 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
4132 {
4133  return av_thread_message_queue_recv(f->in_thread_queue, pkt,
4134  f->non_blocking ?
4136 }
4137 #endif
4138 
4140 {
4141  if (f->rate_emu) {
4142  int i;
4143  for (i = 0; i < f->nb_streams; i++) {
4144  InputStream *ist = input_streams[f->ist_index + i];
4145  int64_t pts = av_rescale(ist->dts, 1000000, AV_TIME_BASE);
4146  int64_t now = av_gettime_relative() - ist->start;
4147  if (pts > now)
4148  return AVERROR(EAGAIN);
4149  }
4150  }
4151 
4152 #if HAVE_THREADS
4153  if (nb_input_files > 1)
4154  return get_input_packet_mt(f, pkt);
4155 #endif
4156  return av_read_frame(f->ctx, pkt);
4157 }
4158 
4159 static int got_eagain(void)
4160 {
4161  int i;
4162  for (i = 0; i < nb_output_streams; i++)
4163  if (output_streams[i]->unavailable)
4164  return 1;
4165  return 0;
4166 }
4167 
4168 static void reset_eagain(void)
4169 {
4170  int i;
4171  for (i = 0; i < nb_input_files; i++)
4172  input_files[i]->eagain = 0;
4173  for (i = 0; i < nb_output_streams; i++)
4174  output_streams[i]->unavailable = 0;
4175 }
4176 
4177 // set duration to max(tmp, duration) in a proper time base and return duration's time_base
4178 static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base,
4179  AVRational time_base)
4180 {
4181  int ret;
4182 
4183  if (!*duration) {
4184  *duration = tmp;
4185  return tmp_time_base;
4186  }
4187 
4188  ret = av_compare_ts(*duration, time_base, tmp, tmp_time_base);
4189  if (ret < 0) {
4190  *duration = tmp;
4191  return tmp_time_base;
4192  }
4193 
4194  return time_base;
4195 }
4196 
4198 {
4199  InputStream *ist;
4200  AVCodecContext *avctx;
4201  int i, ret, has_audio = 0;
4202  int64_t duration = 0;
4203 
4204  ret = av_seek_frame(is, -1, is->start_time, 0);
4205  if (ret < 0)
4206  return ret;
4207 
4208  for (i = 0; i < ifile->nb_streams; i++) {
4209  ist = input_streams[ifile->ist_index + i];
4210  avctx = ist->dec_ctx;
4211 
4212  /* duration is the length of the last frame in a stream
4213  * when audio stream is present we don't care about
4214  * last video frame length because it's not defined exactly */
4215  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples)
4216  has_audio = 1;
4217  }
4218 
4219  for (i = 0; i < ifile->nb_streams; i++) {
4220  ist = input_streams[ifile->ist_index + i];
4221  avctx = ist->dec_ctx;
4222 
4223  if (has_audio) {
4224  if (avctx->codec_type == AVMEDIA_TYPE_AUDIO && ist->nb_samples) {
4225  AVRational sample_rate = {1, avctx->sample_rate};
4226 
4227  duration = av_rescale_q(ist->nb_samples, sample_rate, ist->st->time_base);
4228  } else {
4229  continue;
4230  }
4231  } else {
4232  if (ist->framerate.num) {
4233  duration = av_rescale_q(1, av_inv_q(ist->framerate), ist->st->time_base);
4234  } else if (ist->st->avg_frame_rate.num) {
4235  duration = av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate), ist->st->time_base);
4236  } else {
4237  duration = 1;
4238  }
4239  }
4240  if (!ifile->duration)
4241  ifile->time_base = ist->st->time_base;
4242  /* the total duration of the stream, max_pts - min_pts is
4243  * the duration of the stream without the last frame */
4244  duration += ist->max_pts - ist->min_pts;
4245  ifile->time_base = duration_max(duration, &ifile->duration, ist->st->time_base,
4246  ifile->time_base);
4247  }
4248 
4249  if (ifile->loop > 0)
4250  ifile->loop--;
4251 
4252  return ret;
4253 }
4254 
4255 /*
4256  * Return
4257  * - 0 -- one packet was read and processed
4258  * - AVERROR(EAGAIN) -- no packets were available for selected file,
4259  * this function should be called again
4260  * - AVERROR_EOF -- this function should not be called again
4261  */
4262 static int process_input(int file_index)
4263 {
4264  InputFile *ifile = input_files[file_index];
4266  InputStream *ist;
4267  AVPacket pkt;
4268  int ret, thread_ret, i, j;
4269  int64_t duration;
4270  int64_t pkt_dts;
4271 
4272  is = ifile->ctx;
4273  ret = get_input_packet(ifile, &pkt);
4274 
4275  if (ret == AVERROR(EAGAIN)) {
4276  ifile->eagain = 1;
4277  return ret;
4278  }
4279  if (ret < 0 && ifile->loop) {
4280  AVCodecContext *avctx;
4281  for (i = 0; i < ifile->nb_streams; i++) {
4282  ist = input_streams[ifile->ist_index + i];
4283  avctx = ist->dec_ctx;
4284  if (ist->decoding_needed) {
4285  ret = process_input_packet(ist, NULL, 1);
4286  if (ret>0)
4287  return 0;
4288  avcodec_flush_buffers(avctx);
4289  }
4290  }
4291 #if HAVE_THREADS
4292  free_input_thread(file_index);
4293 #endif
4294  ret = seek_to_start(ifile, is);
4295 #if HAVE_THREADS
4296  thread_ret = init_input_thread(file_index);
4297  if (thread_ret < 0)
4298  return thread_ret;
4299 #endif
4300  if (ret < 0)
4301  av_log(NULL, AV_LOG_WARNING, "Seek to start failed.\n");
4302  else
4303  ret = get_input_packet(ifile, &pkt);
4304  if (ret == AVERROR(EAGAIN)) {
4305  ifile->eagain = 1;
4306  return ret;
4307  }
4308  }
4309  if (ret < 0) {
4310  if (ret != AVERROR_EOF) {
4311  print_error(is->url, ret);
4312  if (exit_on_error)
4313  exit_program(1);
4314  }
4315 
4316  for (i = 0; i < ifile->nb_streams; i++) {
4317  ist = input_streams[ifile->ist_index + i];
4318  if (ist->decoding_needed) {
4319  ret = process_input_packet(ist, NULL, 0);
4320  if (ret>0)
4321  return 0;
4322  }
4323 
4324  /* mark all outputs that don't go through lavfi as finished */
4325  for (j = 0; j < nb_output_streams; j++) {
4326  OutputStream *ost = output_streams[j];
4327 
4328  if (ost->source_index == ifile->ist_index + i &&
4329  (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
4330  finish_output_stream(ost);
4331  }
4332  }
4333 
4334  ifile->eof_reached = 1;
4335  return AVERROR(EAGAIN);
4336  }
4337 
4338  reset_eagain();
4339 
4340  if (do_pkt_dump) {
4342  is->streams[pkt.stream_index]);
4343  }
4344  /* the following test is needed in case new streams appear
4345  dynamically in stream : we ignore them */
4346  if (pkt.stream_index >= ifile->nb_streams) {
4347  report_new_stream(file_index, &pkt);
4348  goto discard_packet;
4349  }
4350 
4351  ist = input_streams[ifile->ist_index + pkt.stream_index];
4352 
4353  ist->data_size += pkt.size;
4354  ist->nb_packets++;
4355 
4356  if (ist->discard)
4357  goto discard_packet;
4358 
4359  if (pkt.flags & AV_PKT_FLAG_CORRUPT) {
4361  "%s: corrupt input packet in stream %d\n", is->url, pkt.stream_index);
4362  if (exit_on_error)
4363  exit_program(1);
4364  }
4365 
4366  if (debug_ts) {
4367  av_log(NULL, AV_LOG_INFO, "demuxer -> ist_index:%d type:%s "
4368  "next_dts:%s next_dts_time:%s next_pts:%s next_pts_time:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
4372  av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
4373  av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
4374  av_ts2str(input_files[ist->file_index]->ts_offset),
4375  av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
4376  }
4377 
4378  if(!ist->wrap_correction_done && is->start_time != AV_NOPTS_VALUE && ist->st->pts_wrap_bits < 64){
4379  int64_t stime, stime2;
4380  // Correcting starttime based on the enabled streams
4381  // FIXME this ideally should be done before the first use of starttime but we do not know which are the enabled streams at that point.
4382  // so we instead do it here as part of discontinuity handling
4383  if ( ist->next_dts == AV_NOPTS_VALUE
4384  && ifile->ts_offset == -is->start_time
4385  && (is->iformat->flags & AVFMT_TS_DISCONT)) {
4386  int64_t new_start_time = INT64_MAX;
4387  for (i=0; i<is->nb_streams; i++) {
4388  AVStream *st = is->streams[i];
4389  if(st->discard == AVDISCARD_ALL || st->start_time == AV_NOPTS_VALUE)
4390  continue;
4391  new_start_time = FFMIN(new_start_time, av_rescale_q(st->start_time, st->time_base, AV_TIME_BASE_Q));
4392  }
4393  if (new_start_time > is->start_time) {
4394  av_log(is, AV_LOG_VERBOSE, "Correcting start time by %"PRId64"\n", new_start_time - is->start_time);
4395  ifile->ts_offset = -new_start_time;
4396  }
4397  }
4398 
4399  stime = av_rescale_q(is->start_time, AV_TIME_BASE_Q, ist->st->time_base);
4400  stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
4401  ist->wrap_correction_done = 1;
4402 
4403  if(stime2 > stime && pkt.dts != AV_NOPTS_VALUE && pkt.dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
4404  pkt.dts -= 1ULL<<ist->st->pts_wrap_bits;
4405  ist->wrap_correction_done = 0;
4406  }
4407  if(stime2 > stime && pkt.pts != AV_NOPTS_VALUE && pkt.pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
4408  pkt.pts -= 1ULL<<ist->st->pts_wrap_bits;
4409  ist->wrap_correction_done = 0;
4410  }
4411  }
4412 
4413  /* add the stream-global side data to the first packet */
4414  if (ist->nb_packets == 1) {
4415  for (i = 0; i < ist->st->nb_side_data; i++) {
4416  AVPacketSideData *src_sd = &ist->st->side_data[i];
4417  uint8_t *dst_data;
4418 
4419  if (src_sd->type == AV_PKT_DATA_DISPLAYMATRIX)
4420  continue;
4421 
4422  if (av_packet_get_side_data(&pkt, src_sd->type, NULL))
4423  continue;
4424 
4425  dst_data = av_packet_new_side_data(&pkt, src_sd->type, src_sd->size);
4426  if (!dst_data)
4427  exit_program(1);
4428 
4429  memcpy(dst_data, src_sd->data, src_sd->size);
4430  }
4431  }
4432 
4433  if (pkt.dts != AV_NOPTS_VALUE)
4434  pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
4435  if (pkt.pts != AV_NOPTS_VALUE)
4436  pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
4437 
4438  if (pkt.pts != AV_NOPTS_VALUE)
4439  pkt.pts *= ist->ts_scale;
4440  if (pkt.dts != AV_NOPTS_VALUE)
4441  pkt.dts *= ist->ts_scale;
4442 
4444  if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
4446  pkt_dts != AV_NOPTS_VALUE && ist->next_dts == AV_NOPTS_VALUE && !copy_ts
4447  && (is->iformat->flags & AVFMT_TS_DISCONT) && ifile->last_ts != AV_NOPTS_VALUE) {
4448  int64_t delta = pkt_dts - ifile->last_ts;
4449  if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
4450  delta > 1LL*dts_delta_threshold*AV_TIME_BASE){
4451  ifile->ts_offset -= delta;
4453  "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
4454  delta, ifile->ts_offset);
4455  pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
4456  if (pkt.pts != AV_NOPTS_VALUE)
4457  pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
4458  }
4459  }
4460 
4461  duration = av_rescale_q(ifile->duration, ifile->time_base, ist->st->time_base);
4462  if (pkt.pts != AV_NOPTS_VALUE) {
4463  pkt.pts += duration;
4464  ist->max_pts = FFMAX(pkt.pts, ist->max_pts);
4465  ist->min_pts = FFMIN(pkt.pts, ist->min_pts);
4466  }
4467 
4468  if (pkt.dts != AV_NOPTS_VALUE)
4469  pkt.dts += duration;
4470 
4472  if ((ist->dec_ctx->codec_type == AVMEDIA_TYPE_VIDEO ||
4474  pkt_dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
4475  !copy_ts) {
4476  int64_t delta = pkt_dts - ist->next_dts;
4477  if (is->iformat->flags & AVFMT_TS_DISCONT) {
4478  if (delta < -1LL*dts_delta_threshold*AV_TIME_BASE ||
4479  delta > 1LL*dts_delta_threshold*AV_TIME_BASE ||
4480  pkt_dts + AV_TIME_BASE/10 < FFMAX(ist->pts, ist->dts)) {
4481  ifile->ts_offset -= delta;
4483  "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
4484  delta, ifile->ts_offset);
4485  pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
4486  if (pkt.pts != AV_NOPTS_VALUE)
4487  pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
4488  }
4489  } else {
4490  if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
4491  delta > 1LL*dts_error_threshold*AV_TIME_BASE) {
4492  av_log(NULL, AV_LOG_WARNING, "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n", pkt.dts, ist->next_dts, pkt.stream_index);
4493  pkt.dts = AV_NOPTS_VALUE;
4494  }
4495  if (pkt.pts != AV_NOPTS_VALUE){
4496  int64_t pkt_pts = av_rescale_q(pkt.pts, ist->st->time_base, AV_TIME_BASE_Q);
4497  delta = pkt_pts - ist->next_dts;
4498  if ( delta < -1LL*dts_error_threshold*AV_TIME_BASE ||
4499  delta > 1LL*dts_error_threshold*AV_TIME_BASE) {
4500  av_log(NULL, AV_LOG_WARNING, "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n", pkt.pts, ist->next_dts, pkt.stream_index);
4501  pkt.pts = AV_NOPTS_VALUE;
4502  }
4503  }
4504  }
4505  }
4506 
4507  if (pkt.dts != AV_NOPTS_VALUE)
4508  ifile->last_ts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
4509 
4510  if (debug_ts) {
4511  av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s off:%s off_time:%s\n",
4513  av_ts2str(pkt.pts), av_ts2timestr(pkt.pts, &ist->st->time_base),
4514  av_ts2str(pkt.dts), av_ts2timestr(pkt.dts, &ist->st->time_base),
4515  av_ts2str(input_files[ist->file_index]->ts_offset),
4516  av_ts2timestr(input_files[ist->file_index]->ts_offset, &AV_TIME_BASE_Q));
4517  }
4518 
4519  sub2video_heartbeat(ist, pkt.pts);
4520 
4521  process_input_packet(ist, &pkt, 0);
4522 
4523 discard_packet:
4524  av_packet_unref(&pkt);
4525 
4526  return 0;
4527 }
4528 
4529 /**
4530  * Perform a step of transcoding for the specified filter graph.
4531  *
4532  * @param[in] graph filter graph to consider
4533  * @param[out] best_ist input stream where a frame would allow to continue
4534  * @return 0 for success, <0 for error
4535  */
4536 static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
4537 {
4538  int i, ret;
4539  int nb_requests, nb_requests_max = 0;
4540  InputFilter *ifilter;
4541  InputStream *ist;
4542 
4543  *best_ist = NULL;
4544  ret = avfilter_graph_request_oldest(graph->graph);
4545  if (ret >= 0)
4546  return reap_filters(0);
4547 
4548  if (ret == AVERROR_EOF) {
4549  ret = reap_filters(1);
4550  for (i = 0; i < graph->nb_outputs; i++)
4551  close_output_stream(graph->outputs[i]->ost);
4552  return ret;
4553  }
4554  if (ret != AVERROR(EAGAIN))
4555  return ret;
4556 
4557  for (i = 0; i < graph->nb_inputs; i++) {
4558  ifilter = graph->inputs[i];
4559  ist = ifilter->ist;
4560  if (input_files[ist->file_index]->eagain ||
4561  input_files[ist->file_index]->eof_reached)
4562  continue;
4563  nb_requests = av_buffersrc_get_nb_failed_requests(ifilter->filter);
4564  if (nb_requests > nb_requests_max) {
4565  nb_requests_max = nb_requests;
4566  *best_ist = ist;
4567  }
4568  }
4569 
4570  if (!*best_ist)
4571  for (i = 0; i < graph->nb_outputs; i++)
4572  graph->outputs[i]->ost->unavailable = 1;
4573 
4574  return 0;
4575 }
4576 
4577 /**
4578  * Run a single step of transcoding.
4579  *
4580  * @return 0 for success, <0 for error
4581  */
4582 static int transcode_step(void)
4583 {
4584  OutputStream *ost;
4585  InputStream *ist = NULL;
4586  int ret;
4587 
4588  ost = choose_output();
4589  if (!ost) {
4590  if (got_eagain()) {
4591  reset_eagain();
4592  av_usleep(10000);
4593  return 0;
4594  }
4595  av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from, finishing.\n");
4596  return AVERROR_EOF;
4597  }
4598 
4599  if (ost->filter && !ost->filter->graph->graph) {
4601  ret = configure_filtergraph(ost->filter->graph);
4602  if (ret < 0) {
4603  av_log(NULL, AV_LOG_ERROR, "Error reinitializing filters!\n");
4604  return ret;
4605  }
4606  }
4607  }
4608 
4609  if (ost->filter && ost->filter->graph->graph) {
4610  if (!ost->initialized) {
4611  char error[1024] = {0};
4612  ret = init_output_stream(ost, error, sizeof(error));
4613  if (ret < 0) {
4614  av_log(NULL, AV_LOG_ERROR, "Error initializing output stream %d:%d -- %s\n",
4615  ost->file_index, ost->index, error);
4616  exit_program(1);
4617  }
4618  }
4619  if ((ret = transcode_from_filter(ost->filter->graph, &ist)) < 0)
4620  return ret;
4621  if (!ist)
4622  return 0;
4623  } else if (ost->filter) {
4624  int i;
4625  for (i = 0; i < ost->filter->graph->nb_inputs; i++) {
4626  InputFilter *ifilter = ost->filter->graph->inputs[i];
4627  if (!ifilter->ist->got_output && !input_files[ifilter->ist->file_index]->eof_reached) {
4628  ist = ifilter->ist;
4629  break;
4630  }
4631  }
4632  if (!ist) {
4633  ost->inputs_done = 1;
4634  return 0;
4635  }
4636  } else {
4637  av_assert0(ost->source_index >= 0);
4638  ist = input_streams[ost->source_index];
4639  }
4640 
4641  ret = process_input(ist->file_index);
4642  if (ret == AVERROR(EAGAIN)) {
4643  if (input_files[ist->file_index]->eagain)
4644  ost->unavailable = 1;
4645  return 0;
4646  }
4647 
4648  if (ret < 0)
4649  return ret == AVERROR_EOF ? 0 : ret;
4650 
4651  return reap_filters(0);
4652 }
4653 
4654 /*
4655  * The following code is the main loop of the file converter
4656  */
4657 static int transcode(void)
4658 {
4659  int ret, i;
4660  AVFormatContext *os;
4661  OutputStream *ost;
4662  InputStream *ist;
4663  int64_t timer_start;
4664  int64_t total_packets_written = 0;
4665 
4666  ret = transcode_init();
4667  if (ret < 0)
4668  goto fail;
4669 
4670  if (stdin_interaction) {
4671  av_log(NULL, AV_LOG_INFO, "Press [q] to stop, [?] for help\n");
4672  }
4673 
4674  timer_start = av_gettime_relative();
4675 
4676 #if HAVE_THREADS
4677  if ((ret = init_input_threads()) < 0)
4678  goto fail;
4679 #endif
4680 
4681  while (!received_sigterm) {
4682  int64_t cur_time= av_gettime_relative();
4683 
4684  /* if 'q' pressed, exits */
4685  if (stdin_interaction)
4686  if (check_keyboard_interaction(cur_time) < 0)
4687  break;
4688 
4689  /* check if there's any stream where output is still needed */
4690  if (!need_output()) {
4691  av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
4692  break;
4693  }
4694 
4695  ret = transcode_step();
4696  if (ret < 0 && ret != AVERROR_EOF) {
4697  av_log(NULL, AV_LOG_ERROR, "Error while filtering: %s\n", av_err2str(ret));
4698  break;
4699  }
4700 
4701  /* dump report by using the output first video and audio streams */
4702  print_report(0, timer_start, cur_time);
4703  }
4704 #if HAVE_THREADS
4705  free_input_threads();
4706 #endif
4707 
4708  /* at the end of stream, we must flush the decoder buffers */
4709  for (i = 0; i < nb_input_streams; i++) {
4710  ist = input_streams[i];
4711  if (!input_files[ist->file_index]->eof_reached) {
4712  process_input_packet(ist, NULL, 0);
4713  }
4714  }
4715  flush_encoders();
4716 
4717  term_exit();
4718 
4719  /* write the trailer if needed and close file */
4720  for (i = 0; i < nb_output_files; i++) {
4721  os = output_files[i]->ctx;
4722  if (!output_files[i]->header_written) {
4724  "Nothing was written into output file %d (%s), because "
4725  "at least one of its streams received no packets.\n",
4726  i, os->url);
4727  continue;
4728  }
4729  if ((ret = av_write_trailer(os)) < 0) {
4730  av_log(NULL, AV_LOG_ERROR, "Error writing trailer of %s: %s\n", os->url, av_err2str(ret));
4731  if (exit_on_error)
4732  exit_program(1);
4733  }
4734  }
4735 
4736  /* dump report by using the first video and audio streams */
4737  print_report(1, timer_start, av_gettime_relative());
4738 
4739  /* close each encoder */
4740  for (i = 0; i < nb_output_streams; i++) {
4741  ost = output_streams[i];
4742  if (ost->encoding_needed) {
4743  av_freep(&ost->enc_ctx->stats_in);
4744  }
4745  total_packets_written += ost->packets_written;
4746  }
4747 
4748  if (!total_packets_written && (abort_on_flags & ABORT_ON_FLAG_EMPTY_OUTPUT)) {
4749  av_log(NULL, AV_LOG_FATAL, "Empty output\n");
4750  exit_program(1);
4751  }
4752 
4753  /* close each decoder */
4754  for (i = 0; i < nb_input_streams; i++) {
4755  ist = input_streams[i];
4756  if (ist->decoding_needed) {
4757  avcodec_close(ist->dec_ctx);
4758  if (ist->hwaccel_uninit)
4759  ist->hwaccel_uninit(ist->dec_ctx);
4760  }
4761  }
4762 
4765 
4766  /* finished ! */
4767  ret = 0;
4768 
4769  fail:
4770 #if HAVE_THREADS
4771  free_input_threads();
4772 #endif
4773 
4774  if (output_streams) {
4775  for (i = 0; i < nb_output_streams; i++) {
4776  ost = output_streams[i];
4777  if (ost) {
4778  if (ost->logfile) {
4779  if (fclose(ost->logfile))
4781  "Error closing logfile, loss of information possible: %s\n",
4782  av_err2str(AVERROR(errno)));
4783  ost->logfile = NULL;
4784  }
4785  av_freep(&ost->forced_kf_pts);
4786  av_freep(&ost->apad);
4787  av_freep(&ost->disposition);
4788  av_dict_free(&ost->encoder_opts);
4789  av_dict_free(&ost->sws_dict);
4790  av_dict_free(&ost->swr_opts);
4791  av_dict_free(&ost->resample_opts);
4792  }
4793  }
4794  }
4795  return ret;
4796 }
4797 
4799 {
4800  BenchmarkTimeStamps time_stamps = { av_gettime_relative() };
4801 #if HAVE_GETRUSAGE
4802  struct rusage rusage;
4803 
4804  getrusage(RUSAGE_SELF, &rusage);
4805  time_stamps.user_usec =
4806  (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
4807  time_stamps.sys_usec =
4808  (rusage.ru_stime.tv_sec * 1000000LL) + rusage.ru_stime.tv_usec;
4809 #elif HAVE_GETPROCESSTIMES
4810  HANDLE proc;
4811  FILETIME c, e, k, u;
4812  proc = GetCurrentProcess();
4813  GetProcessTimes(proc, &c, &e, &k, &u);
4814  time_stamps.user_usec =
4815  ((int64_t)u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
4816  time_stamps.sys_usec =
4817  ((int64_t)k.dwHighDateTime << 32 | k.dwLowDateTime) / 10;
4818 #else
4819  time_stamps.user_usec = time_stamps.sys_usec = 0;
4820 #endif
4821  return time_stamps;
4822 }
4823 
4824 static int64_t getmaxrss(void)
4825 {
4826 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
4827  struct rusage rusage;
4828  getrusage(RUSAGE_SELF, &rusage);
4829  return (int64_t)rusage.ru_maxrss * 1024;
4830 #elif HAVE_GETPROCESSMEMORYINFO
4831  HANDLE proc;
4832  PROCESS_MEMORY_COUNTERS memcounters;
4833  proc = GetCurrentProcess();
4834  memcounters.cb = sizeof(memcounters);
4835  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
4836  return memcounters.PeakPagefileUsage;
4837 #else
4838  return 0;
4839 #endif
4840 }
4841 
4842 static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
4843 {
4844 }
4845 
4846 int main(int argc, char **argv)
4847 {
4848  int i, ret;
4850 
4851  init_dynload();
4852 
4854 
4855  setvbuf(stderr,NULL,_IONBF,0); /* win32 runtime needs this */
4856 
4858  parse_loglevel(argc, argv, options);
4859 
4860  if(argc>1 && !strcmp(argv[1], "-d")){
4861  run_as_daemon=1;
4863  argc--;
4864  argv++;
4865  }
4866 
4867 #if CONFIG_AVDEVICE
4869 #endif
4871 
4872  show_banner(argc, argv, options);
4873 
4874  /* parse options and open all input/output files */
4875  ret = ffmpeg_parse_options(argc, argv);
4876  if (ret < 0)
4877  exit_program(1);
4878 
4879  if (nb_output_files <= 0 && nb_input_files == 0) {
4880  show_usage();
4881  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
4882  exit_program(1);
4883  }
4884 
4885  /* file converter / grab */
4886  if (nb_output_files <= 0) {
4887  av_log(NULL, AV_LOG_FATAL, "At least one output file must be specified\n");
4888  exit_program(1);
4889  }
4890 
4891 // if (nb_input_files == 0) {
4892 // av_log(NULL, AV_LOG_FATAL, "At least one input file must be specified\n");
4893 // exit_program(1);
4894 // }
4895 
4896  for (i = 0; i < nb_output_files; i++) {
4897  if (strcmp(output_files[i]->ctx->oformat->name, "rtp"))
4898  want_sdp = 0;
4899  }
4900 
4901  current_time = ti = get_benchmark_time_stamps();
4902  if (transcode() < 0)
4903  exit_program(1);
4904  if (do_benchmark) {
4905  int64_t utime, stime, rtime;
4906  current_time = get_benchmark_time_stamps();
4907  utime = current_time.user_usec - ti.user_usec;
4908  stime = current_time.sys_usec - ti.sys_usec;
4909  rtime = current_time.real_usec - ti.real_usec;
4911  "bench: utime=%0.3fs stime=%0.3fs rtime=%0.3fs\n",
4912  utime / 1000000.0, stime / 1000000.0, rtime / 1000000.0);
4913  }
4914  av_log(NULL, AV_LOG_DEBUG, "%"PRIu64" frames successfully decoded, %"PRIu64" decoding errors\n",
4917  exit_program(69);
4918 
4920  return main_return_code;
4921 }
unsigned int nb_chapters
Number of chapters in AVChapter array.
Definition: avformat.h:1580
int64_t pts
current pts of the decoded frame (in AV_TIME_BASE units)
Definition: ffmpeg.h:316
int nb_bitstream_filters
Definition: ffmpeg.h:462
#define extra_bits(eb)
Definition: intrax8.c:159
#define AV_CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:904
void init_dynload(void)
Initialize dynamic library loading.
Definition: cmdutils.c:120
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:1785
AVRational enc_timebase
Definition: ffmpeg.h:460
static void write_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int unqueue)
Definition: ffmpeg.c:689
int got_output
Definition: ffmpeg.h:341
#define AV_DISPOSITION_METADATA
Definition: avformat.h:856
void av_bsf_free(AVBSFContext **ctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:35
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
Definition: ffmpeg.c:1998
int64_t first_dts
Timestamp corresponding to the last dts sync point.
Definition: avformat.h:1076
int guess_input_channel_layout(InputStream *ist)
Definition: ffmpeg.c:2085
#define ATOMIC_VAR_INIT(value)
Definition: stdatomic.h:31
#define NULL
Definition: coverity.c:32
int frame_number
Definition: ffmpeg.h:448
const struct AVCodec * codec
Definition: avcodec.h:1542
Definition: ffmpeg.h:425
AVRational framerate
Definition: avcodec.h:3056
enum AVFieldOrder field_order
Video only.
Definition: avcodec.h:3981
static void output_packet(OutputFile *of, AVPacket *pkt, OutputStream *ost, int eof)
Definition: ffmpeg.c:846
static void do_subtitle_out(OutputFile *of, OutputStream *ost, AVSubtitle *sub)
Definition: ffmpeg.c:970
Bytestream IO Context.
Definition: avio.h:161
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:59
static enum AVPixelFormat pix_fmt
int64_t recording_time
desired length of the resulting file in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:558
void term_init(void)
Definition: ffmpeg.c:387
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:336
AVCodecParameters * par_out
Parameters of the output stream.
Definition: avcodec.h:5737
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
uint8_t * name
Definition: ffmpeg.h:263
int nb_outputs
Definition: ffmpeg.h:292
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:125
int size
AVDictionary * swr_opts
Definition: ffmpeg.h:509
#define DECODING_FOR_FILTER
Definition: ffmpeg.h:302
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:2446
#define av_realloc_f(p, o, n)
This structure describes decoded (raw) audio or video data.
Definition: frame.h:226
int avfilter_graph_queue_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, int flags, double ts)
Queue a command for one or more filter instances.
static int init_output_stream_streamcopy(OutputStream *ost)
Definition: ffmpeg.c:3061
void term_exit(void)
Definition: ffmpeg.c:328
int stream_copy
Definition: ffmpeg.h:514
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:1185
int x
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3842
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1629
#define atomic_store(object, desired)
Definition: stdatomic.h:85
AVOption.
Definition: opt.h:246
AVRational frame_rate
Definition: ffmpeg.h:477
int64_t * forced_kf_pts
Definition: ffmpeg.h:488
void av_thread_message_queue_set_err_recv(AVThreadMessageQueue *mq, int err)
Set the receiving error code.
static void flush(AVCodecContext *avctx)
static void sub2video_flush(InputStream *ist)
Definition: ffmpeg.c:304
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2709
AVBufferRef * hw_frames_ctx
Definition: ffmpeg.h:376
char * filters
filtergraph associated to the -filter option
Definition: ffmpeg.h:504
#define AV_CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:883
static int process_input(int file_index)
Definition: ffmpeg.c:4262
int exit_on_error
Definition: ffmpeg_opt.c:103
int64_t cfr_next_pts
Definition: ffmpeg.h:326
int64_t forced_kf_ref_pts
Definition: ffmpeg.h:487
const char * fmt
Definition: avisynth_c.h:769
static int init_output_stream(OutputStream *ost, char *error, int error_len)
Definition: ffmpeg.c:3461
static atomic_int transcode_init_done
Definition: ffmpeg.c:336
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
int64_t bit_rate
the average bitrate
Definition: avcodec.h:1583
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
Main libavfilter public API header.
int64_t pos
byte position in stream, -1 if unknown
Definition: avcodec.h:1465
#define AV_DICT_DONT_OVERWRITE
Don&#39;t overwrite existing entries.
Definition: dict.h:79
static int run_as_daemon
Definition: ffmpeg.c:134
Memory buffer source API.
const char * desc
Definition: nvenc.c:65
void av_log_set_level(int level)
Set the log level.
Definition: log.c:385
AVRational framerate
Definition: ffmpeg.h:333
AVRational sample_aspect_ratio
Video only.
Definition: avcodec.h:3976
int avcodec_receive_packet(AVCodecContext *avctx, AVPacket *avpkt)
Read encoded data from the encoder.
Definition: encode.c:417
int height
Definition: ffmpeg.h:247
int64_t max_pts
Definition: ffmpeg.h:322
int decoding_needed
Definition: ffmpeg.h:300
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: avcodec.h:3900
void sub2video_update(InputStream *ist, AVSubtitle *sub)
Definition: ffmpeg.c:240
const struct AVBitStreamFilter * filter
The bitstream filter this context is an instance of.
Definition: avcodec.h:5712
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:936
int num
Numerator.
Definition: rational.h:59
The bitstream filter state.
Definition: avcodec.h:5703
static void print_report(int is_last_report, int64_t timer_start, int64_t cur_time)
Definition: ffmpeg.c:1650
#define vsnprintf
Definition: snprintf.h:36
int rotate_overridden
Definition: ffmpeg.h:481
int index
stream index in AVFormatContext
Definition: avformat.h:875
int size
Definition: avcodec.h:1446
static int64_t getmaxrss(void)
Definition: ffmpeg.c:4824
uint8_t pi<< 24) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_U8,(uint64_t)((*(const uint8_t *) pi - 0x80U))<< 56) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0f/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_U8,(*(const uint8_t *) pi - 0x80) *(1.0/(1<< 7))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S16,(*(const int16_t *) pi >>8)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S16,(uint64_t)(*(const int16_t *) pi)<< 48) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0f/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S16, *(const int16_t *) pi *(1.0/(1<< 15))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S32,(*(const int32_t *) pi >>24)+0x80) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_S32,(uint64_t)(*(const int32_t *) pi)<< 32) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0f/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S32, *(const int32_t *) pi *(1.0/(1U<< 31))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_S64,(*(const int64_t *) pi >>56)+0x80) CONV_FUNC(AV_SAMPLE_FMT_FLT, float, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0f/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_DBL, double, AV_SAMPLE_FMT_S64, *(const int64_t *) pi *(1.0/(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_FLT, av_clip_uint8(lrintf(*(const float *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_FLT, av_clip_int16(lrintf(*(const float *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_FLT, av_clipl_int32(llrintf(*(const float *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_FLT, llrintf(*(const float *) pi *(INT64_C(1)<< 63))) CONV_FUNC(AV_SAMPLE_FMT_U8, uint8_t, AV_SAMPLE_FMT_DBL, av_clip_uint8(lrint(*(const double *) pi *(1<< 7))+0x80)) CONV_FUNC(AV_SAMPLE_FMT_S16, int16_t, AV_SAMPLE_FMT_DBL, av_clip_int16(lrint(*(const double *) pi *(1<< 15)))) CONV_FUNC(AV_SAMPLE_FMT_S32, int32_t, AV_SAMPLE_FMT_DBL, av_clipl_int32(llrint(*(const double *) pi *(1U<< 31)))) CONV_FUNC(AV_SAMPLE_FMT_S64, int64_t, AV_SAMPLE_FMT_DBL, llrint(*(const double *) pi *(INT64_C(1)<< 63))) #define FMT_PAIR_FUNC(out, in) static conv_func_type *const fmt_pair_to_conv_functions[AV_SAMPLE_FMT_NB *AV_SAMPLE_FMT_NB]={ FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_U8), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S16), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S32), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_FLT), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_DBL), FMT_PAIR_FUNC(AV_SAMPLE_FMT_U8, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S16, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S32, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_FLT, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_DBL, AV_SAMPLE_FMT_S64), FMT_PAIR_FUNC(AV_SAMPLE_FMT_S64, AV_SAMPLE_FMT_S64), };static void cpy1(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, len);} static void cpy2(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 2 *len);} static void cpy4(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 4 *len);} static void cpy8(uint8_t **dst, const uint8_t **src, int len){ memcpy(*dst, *src, 8 *len);} AudioConvert *swri_audio_convert_alloc(enum AVSampleFormat out_fmt, enum AVSampleFormat in_fmt, int channels, const int *ch_map, int flags) { AudioConvert *ctx;conv_func_type *f=fmt_pair_to_conv_functions[av_get_packed_sample_fmt(out_fmt)+AV_SAMPLE_FMT_NB *av_get_packed_sample_fmt(in_fmt)];if(!f) return NULL;ctx=av_mallocz(sizeof(*ctx));if(!ctx) return NULL;if(channels==1){ in_fmt=av_get_planar_sample_fmt(in_fmt);out_fmt=av_get_planar_sample_fmt(out_fmt);} ctx->channels=channels;ctx->conv_f=f;ctx->ch_map=ch_map;if(in_fmt==AV_SAMPLE_FMT_U8||in_fmt==AV_SAMPLE_FMT_U8P) memset(ctx->silence, 0x80, sizeof(ctx->silence));if(out_fmt==in_fmt &&!ch_map) { switch(av_get_bytes_per_sample(in_fmt)){ case 1:ctx->simd_f=cpy1;break;case 2:ctx->simd_f=cpy2;break;case 4:ctx->simd_f=cpy4;break;case 8:ctx->simd_f=cpy8;break;} } if(HAVE_X86ASM &&HAVE_MMX) swri_audio_convert_init_x86(ctx, out_fmt, in_fmt, channels);if(ARCH_ARM) swri_audio_convert_init_arm(ctx, out_fmt, in_fmt, channels);if(ARCH_AARCH64) swri_audio_convert_init_aarch64(ctx, out_fmt, in_fmt, channels);return ctx;} void swri_audio_convert_free(AudioConvert **ctx) { av_freep(ctx);} int swri_audio_convert(AudioConvert *ctx, AudioData *out, AudioData *in, int len) { int ch;int off=0;const int os=(out->planar ? 1 :out->ch_count) *out->bps;unsigned misaligned=0;av_assert0(ctx->channels==out->ch_count);if(ctx->in_simd_align_mask) { int planes=in->planar ? in->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) in->ch[ch];misaligned|=m &ctx->in_simd_align_mask;} if(ctx->out_simd_align_mask) { int planes=out->planar ? out->ch_count :1;unsigned m=0;for(ch=0;ch< planes;ch++) m|=(intptr_t) out->ch[ch];misaligned|=m &ctx->out_simd_align_mask;} if(ctx->simd_f &&!ctx->ch_map &&!misaligned){ off=len &~15;av_assert1(off >=0);av_assert1(off<=len);av_assert2(ctx->channels==SWR_CH_MAX||!in->ch[ctx->channels]);if(off >0){ if(out->planar==in->planar){ int planes=out->planar ? out->ch_count :1;for(ch=0;ch< planes;ch++){ ctx->simd_f(out-> ch ch
Definition: audioconvert.c:56
int max_muxing_queue_size
Definition: ffmpeg.h:542
const char * b
Definition: vf_curves.c:116
static int nb_frames_dup
Definition: ffmpeg.c:135
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:191
#define us(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:263
static InputStream * get_input_stream(OutputStream *ost)
Definition: ffmpeg.c:2966
void hw_device_free_all(void)
Definition: ffmpeg_hw.c:269
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:655
#define AV_DISPOSITION_DUB
Definition: avformat.h:820
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown) That is the width of a pixel divided by the height of the pixel...
Definition: avcodec.h:1912
int eagain
Definition: ffmpeg.h:396
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
#define AV_CODEC_PROP_TEXT_SUB
Subtitle codec is text based.
Definition: avcodec.h:772
void show_banner(int argc, char **argv, const OptionDef *options)
Print the program banner to stderr.
Definition: cmdutils.c:1180
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1743
static int init_output_stream_encode(OutputStream *ost)
Definition: ffmpeg.c:3303
static void abort_codec_experimental(AVCodec *c, int encoder)
Definition: ffmpeg.c:654
#define AV_DISPOSITION_HEARING_IMPAIRED
stream for hearing impaired audiences
Definition: avformat.h:832
void(* hwaccel_uninit)(AVCodecContext *s)
Definition: ffmpeg.h:371
int quality
Definition: ffmpeg.h:540
unsigned num_rects
Definition: avcodec.h:3880
AVFrame * filter_frame
Definition: ffmpeg.h:307
static int transcode_init(void)
Definition: ffmpeg.c:3671
static int compare_int64(const void *a, const void *b)
Definition: ffmpeg.c:2973
static int process_input_packet(InputStream *ist, const AVPacket *pkt, int no_eof)
Definition: ffmpeg.c:2578
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2556
int do_benchmark_all
Definition: ffmpeg_opt.c:96
enum AVMediaType type
Definition: avcodec.h:3437
#define AV_DISPOSITION_CLEAN_EFFECTS
stream without voice
Definition: avformat.h:834
const char * key
int last_dropped
Definition: ffmpeg.h:471
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
int av_expr_parse(AVExpr **expr, const char *s, const char *const *const_names, const char *const *func1_names, double(*const *funcs1)(void *, double), const char *const *func2_names, double(*const *funcs2)(void *, double, double), int log_offset, void *log_ctx)
Parse an expression.
Definition: eval.c:679
discard all
Definition: avcodec.h:803
AVPacketSideData * side_data
An array of side data that applies to the whole stream (i.e.
Definition: avformat.h:976
int64_t input_ts_offset
Definition: ffmpeg.h:402
int do_hex_dump
Definition: ffmpeg_opt.c:97
static AVPacket pkt
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2757
int nb_input_streams
Definition: ffmpeg.c:148
const char * name
Definition: ffmpeg.h:68
intptr_t atomic_int
Definition: stdatomic.h:55
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: decode.c:1025
static void report_new_stream(int input_index, AVPacket *pkt)
Definition: ffmpeg.c:3656
#define src
Definition: vp8dsp.c:254
uint64_t packets_written
Definition: ffmpeg.h:534
AVCodec.
Definition: avcodec.h:3424
#define VSYNC_VFR
Definition: ffmpeg.h:52
int nb_dts_buffer
Definition: ffmpeg.h:388
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:479
This struct describes the properties of an encoded stream.
Definition: avcodec.h:3892
int print_stats
Definition: ffmpeg_opt.c:105
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:135
float dts_error_threshold
Definition: ffmpeg_opt.c:88
int64_t start_time
start time in microseconds == AV_TIME_BASE units
Definition: ffmpeg.h:559
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
int index
Definition: ffmpeg.h:283
uint64_t data_size
Definition: ffmpeg.h:532
static int decode_interrupt_cb(void *ctx)
Definition: ffmpeg.c:476
AVBSFContext ** bsf_ctx
Definition: ffmpeg.h:463
int av_fifo_generic_write(AVFifoBuffer *f, void *src, int size, int(*func)(void *, void *, int))
Feed data from a user-supplied callback to an AVFifoBuffer.
Definition: fifo.c:122
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure counterclockwise rotation by the specified angle...
Definition: display.c:50
#define AV_DISPOSITION_KARAOKE
Definition: avformat.h:824
struct FilterGraph * graph
Definition: ffmpeg.h:238
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1656
static int send_frame_to_filters(InputStream *ist, AVFrame *decoded_frame)
Definition: ffmpeg.c:2262
Undefined.
Definition: avutil.h:273
AVSubtitleRect ** rects
Definition: avcodec.h:3881
int encoding_needed
Definition: ffmpeg.h:447
static void update_benchmark(const char *fmt,...)
Definition: ffmpeg.c:659
static void log_callback_null(void *ptr, int level, const char *fmt, va_list vl)
Definition: ffmpeg.c:4842
AVBufferRef * hw_frames_ctx
For hwaccel-format frames, this should be a reference to the AVHWFramesContext describing the frame...
Definition: frame.h:564
static int check_keyboard_interaction(int64_t cur_time)
Definition: ffmpeg.c:3911
Format I/O context.
Definition: avformat.h:1351
Immediately push the frame to the output.
Definition: buffersrc.h:46
uint64_t samples_decoded
Definition: ffmpeg.h:385
memory buffer sink API for audio and video
struct InputStream * ist
Definition: ffmpeg.h:237
static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output, int64_t *duration_pts, int eof, int *decode_failed)
Definition: ffmpeg.c:2352
#define AV_RL64
Definition: intreadwrite.h:173
unsigned int nb_stream_indexes
Definition: avformat.h:1273
#define AV_LOG_QUIET
Print no output.
Definition: log.h:158
enum HWAccelID id
Definition: ffmpeg.h:70
int64_t cur_dts
Definition: avformat.h:1077
int w
width of pict, undefined when pict is not set
Definition: avcodec.h:3844
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:72
#define AV_CODEC_CAP_DELAY
Encoder or decoder requires flushing with NULL input at the end in order to give the complete and cor...
Definition: avcodec.h:993
uint64_t frames_decoded
Definition: ffmpeg.h:384
int header_written
Definition: ffmpeg.h:564
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AVFilterGraph * graph
Definition: ffmpeg.h:286
int av_buffersink_get_sample_rate(const AVFilterContext *ctx)
Public dictionary API.
char * logfile_prefix
Definition: ffmpeg.h:499
static uint8_t * subtitle_out
Definition: ffmpeg.c:145
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:212
static void filter(int16_t *output, ptrdiff_t out_stride, int16_t *low, ptrdiff_t low_stride, int16_t *high, ptrdiff_t high_stride, int len, int clip)
Definition: cfhd.c:153
static int main_return_code
Definition: ffmpeg.c:338
static int64_t start_time
Definition: ffplay.c:330
int copy_initial_nonkeyframes
Definition: ffmpeg.h:524
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:131
static int init_output_bsfs(OutputStream *ost)
Definition: ffmpeg.c:3025
AVComponentDescriptor comp[4]
Parameters that describe how pixels are packed.
Definition: pixdesc.h:117
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:2197
int64_t * dts_buffer
Definition: ffmpeg.h:387
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT, AVFMT_TS_NEGATIVE
Definition: avformat.h:526
uint8_t
#define av_malloc(s)
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:189
Opaque data information usually continuous.
Definition: avutil.h:203
AVDictionary * sws_dict
Definition: ffmpeg.h:508
int av_thread_message_queue_recv(AVThreadMessageQueue *mq, void *msg, unsigned flags)
Receive a message from the queue.
int width
Video only.
Definition: avcodec.h:3966
float delta
static void sub2video_push_ref(InputStream *ist, int64_t pts)
Definition: ffmpeg.c:222
AVOptions.
int subtitle_header_size
Definition: avcodec.h:3002
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_GENERIC_INDEX, AVFMT_TS_DISCONT, AVFMT_NOBINSEARCH, AVFMT_NOGENSEARCH, AVFMT_NO_BYTE_SEEK, AVFMT_SEEK_TO_PTS.
Definition: avformat.h:661
enum AVCodecID av_codec_get_id(const struct AVCodecTag *const *tags, unsigned int tag)
Get the AVCodecID for the given codec tag tag.
miscellaneous OS support macros and functions.
timestamp utils, mostly useful for debugging/logging purposes
int avformat_transfer_internal_stream_timing_info(const AVOutputFormat *ofmt, AVStream *ost, const AVStream *ist, enum AVTimebaseSource copy_tb)
Transfer internal timing information from one stream to another.
Definition: utils.c:5759
int stdin_interaction
Definition: ffmpeg_opt.c:107
FILE * logfile
Definition: ffmpeg.h:500
#define f(width, name)
Definition: cbs_vp9.c:255
AVDictionary * opts
Definition: ffmpeg.h:556
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
#define media_type_string
Definition: cmdutils.h:620
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:1463
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: avcodec.h:1220
int av_thread_message_queue_send(AVThreadMessageQueue *mq, void *msg, unsigned flags)
Send a message on the queue.
#define ECHO(name, type, min, max)
Definition: af_aecho.c:186
#define FF_API_DEBUG_MV
Definition: version.h:58
static int need_output(void)
Definition: ffmpeg.c:3844
int av_frame_ref(AVFrame *dst, const AVFrame *src)
Set up a new reference to the data described by the source frame.
Definition: frame.c:443
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:319
enum AVPixelFormat pix_fmt
A hardware pixel format which the codec can use.
Definition: avcodec.h:3402
int av_fifo_space(const AVFifoBuffer *f)
Return the amount of space in bytes in the AVFifoBuffer, that is the amount of data you can write int...
Definition: fifo.c:82
int nb_side_data
The number of elements in the AVStream.side_data array.
Definition: avformat.h:980
static double psnr(double d)
Definition: ffmpeg.c:1358
int do_benchmark
Definition: ffmpeg_opt.c:95
int audio_sync_method
Definition: ffmpeg_opt.c:91
#define u(width, name, range_min, range_max)
Definition: cbs_h2645.c:253
int shortest
Definition: ffmpeg.h:562
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1419
int64_t duration
Definition: movenc.c:63
int avcodec_parameters_to_context(AVCodecContext *codec, const AVCodecParameters *par)
Fill the codec context based on the values from the supplied codec parameters.
Definition: utils.c:2115
int av_codec_get_tag2(const struct AVCodecTag *const *tags, enum AVCodecID id, unsigned int *tag)
Get the codec tag for the given codec id.
static AVFrame * frame
static void ifilter_parameters_from_codecpar(InputFilter *ifilter, AVCodecParameters *par)
Definition: ffmpeg.c:1849
void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload, const AVStream *st)
Send a nice dump of a packet to the log.
Definition: dump.c:113
AVRational av_buffersink_get_frame_rate(const AVFilterContext *ctx)
const char * name
Definition: avcodec.h:5753
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:40
static void finish(void)
Definition: movenc.c:345
#define AV_DISPOSITION_DEPENDENT
dependent audio stream (mix_type=0 in mpegts)
Definition: avformat.h:857
int nb_streams
Definition: ffmpeg.h:409
uint8_t * data
Definition: avcodec.h:1445
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
enum AVMediaType type
Definition: ffmpeg.h:240
static void set_tty_echo(int on)
Definition: ffmpeg.c:3899
AVDictionary * resample_opts
Definition: ffmpeg.h:510
void av_packet_move_ref(AVPacket *dst, AVPacket *src)
Move every field in src to dst and reset src.
Definition: avpacket.c:653
static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
Definition: ffmpeg.c:3216
#define FFMIN3(a, b, c)
Definition: common.h:97
AVFilterContext * filter
Definition: ffmpeg.h:260
static int seek_to_start(InputFile *ifile, AVFormatContext *is)
Definition: ffmpeg.c:4197
int avformat_network_init(void)
Do global initialization of network libraries.
Definition: utils.c:4996
char av_get_picture_type_char(enum AVPictureType pict_type)
Return a single letter to describe the given picture type pict_type.
Definition: utils.c:88
int * formats
Definition: ffmpeg.h:277
#define ff_dlog(a,...)
int nb_input_files
Definition: ffmpeg.c:150
#define AVERROR_EOF
End of file.
Definition: error.h:55
static int read_key(void)
Definition: ffmpeg.c:425
static int reap_filters(int flush)
Get and encode new output from any of the filtergraphs, without causing activity. ...
Definition: ffmpeg.c:1427
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
#define lrintf(x)
Definition: libm_mips.h:70
static volatile int ffmpeg_exited
Definition: ffmpeg.c:337
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
Generate an SDP for an RTP session.
Definition: sdp.c:841
static void do_video_stats(OutputStream *ost, int frame_size)
Definition: ffmpeg.c:1363
uint8_t * data
Definition: avcodec.h:1389
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:373
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the &#39;-loglevel&#39; option in the command line args and apply it.
Definition: cmdutils.c:506
int h
height of pict, undefined when pict is not set
Definition: avcodec.h:3845
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
int av_reduce(int *dst_num, int *dst_den, int64_t num, int64_t den, int64_t max)
Reduce a fraction.
Definition: rational.c:35
AVCodec * dec
Definition: ffmpeg.h:305
AVBufferRef * av_buffersink_get_hw_frames_ctx(const AVFilterContext *ctx)
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1271
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2548
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:218
int top_field_first
Definition: ffmpeg.h:334
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1499
int nb_output_streams
Definition: ffmpeg.c:153
int file_index
Definition: ffmpeg.h:296
void * av_realloc_array(void *ptr, size_t nmemb, size_t size)
Allocate, reallocate, or free an array.
Definition: mem.c:198
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:2171
unsigned int * stream_index
Definition: avformat.h:1272
int av_buffersink_get_h(const AVFilterContext *ctx)
struct InputStream::sub2video sub2video
int av_buffersink_get_format(const AVFilterContext *ctx)
The codec supports this format via the hw_device_ctx interface.
Definition: avcodec.h:3370
int wrap_correction_done
Definition: ffmpeg.h:317
int64_t filter_in_rescale_delta_last
Definition: ffmpeg.h:319
uint64_t channel_layout
Audio only.
Definition: avcodec.h:4002
#define av_log(a,...)
static void sub2video_heartbeat(InputStream *ist, int64_t pts)
Definition: ffmpeg.c:274
#define AV_DISPOSITION_CAPTIONS
To specify text track kind (different from subtitles default).
Definition: avformat.h:854
#define AV_BUFFERSINK_FLAG_NO_REQUEST
Tell av_buffersink_get_buffer_ref() not to request a frame from its input.
Definition: buffersink.h:60
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:1370
int64_t next_dts
Definition: ffmpeg.h:312
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1477
attribute_deprecated int av_copy_packet_side_data(AVPacket *dst, const AVPacket *src)
Copy packet side data.
Definition: avpacket.c:226
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Print detailed information about the input or output format, such as duration, bitrate, streams, container, programs, metadata, side data, codec and time base.
Definition: dump.c:563
AVFifoBuffer * sub_queue
queue of AVSubtitle* before filter init
Definition: ffmpeg.h:349
Main libavdevice API header.
Callback for checking whether to abort blocking functions.
Definition: avio.h:58
int avcodec_close(AVCodecContext *avctx)
Close a given AVCodecContext and free all the data associated with it (but not the AVCodecContext its...
Definition: utils.c:1096
AVRational pkt_timebase
Timebase in which pkt_dts/pts and AVPacket.dts/pts are.
Definition: avcodec.h:3070
static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output, int *decode_failed)
Definition: ffmpeg.c:2485
AVRational av_stream_get_codec_timebase(const AVStream *st)
Get the internal codec timebase from a stream.
Definition: utils.c:5821
libswresample public header
enum AVCodecID id
Definition: avcodec.h:3438
int(* hwaccel_retrieve_data)(AVCodecContext *s, AVFrame *frame)
Definition: ffmpeg.h:373
AVRational sample_aspect_ratio
Definition: ffmpeg.h:248
const AVCodecDefault * defaults
Private codec-specific defaults.
Definition: avcodec.h:3497
int rate_emu
Definition: ffmpeg.h:412
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:258
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: utils.c:2040
int width
Definition: frame.h:284
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:69
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1823
int sample_rate
Definition: ffmpeg.h:250
static void finish_output_stream(OutputStream *ost)
Definition: ffmpeg.c:1408
static void reset_eagain(void)
Definition: ffmpeg.c:4168
static AVBufferRef * hw_device_ctx
Definition: hw_decode.c:45
enum AVPixelFormat hwaccel_pix_fmt
Definition: ffmpeg.h:374
void av_packet_rescale_ts(AVPacket *pkt, AVRational tb_src, AVRational tb_dst)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another...
Definition: avpacket.c:700
int ffmpeg_parse_options(int argc, char **argv)
Definition: ffmpeg_opt.c:3248
FilterGraph ** filtergraphs
Definition: ffmpeg.c:157
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:481
AVFilterContext * filter
Definition: ffmpeg.h:236
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:471
#define atomic_load(object)
Definition: stdatomic.h:93
int64_t start
Definition: ffmpeg.h:309
int loop
Definition: ffmpeg.h:398
int y
top left corner of pict, undefined when pict is not set
Definition: avcodec.h:3843
uint64_t nb_packets
Definition: ffmpeg.h:382
static BenchmarkTimeStamps current_time
Definition: ffmpeg.c:142
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: ffmpeg.h:457
int video_sync_method
Definition: ffmpeg_opt.c:92
int format
Definition: ffmpeg.h:245
int av_opt_eval_flags(void *obj, const AVOption *o, const char *val, int *flags_out)
uint8_t * av_packet_get_side_data(const AVPacket *pkt, enum AVPacketSideDataType type, int *size)
Get side information from packet.
Definition: avpacket.c:350
static int64_t decode_error_stat[2]
Definition: ffmpeg.c:138
#define VSYNC_VSCFR
Definition: ffmpeg.h:53
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:202
char * sdp_filename
Definition: ffmpeg_opt.c:84
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
#define FALSE
Definition: windows2linux.h:37
int last_nb0_frames[3]
Definition: ffmpeg.h:472
Display matrix.
int methods
Bit set of AV_CODEC_HW_CONFIG_METHOD_* flags, describing the possible setup methods which can be used...
Definition: avcodec.h:3407
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
char * url
input or output URL.
Definition: avformat.h:1447
int video_delay
Video only.
Definition: avcodec.h:3995
int avcodec_receive_frame(AVCodecContext *avctx, AVFrame *frame)
Return decoded output data from a decoder.
Definition: decode.c:740
const char * r
Definition: vf_curves.c:114
const char *const forced_keyframes_const_names[]
Definition: ffmpeg.c:114
int capabilities
Codec capabilities.
Definition: avcodec.h:3443
struct AVCodecParserContext * av_stream_get_parser(const AVStream *s)
Definition: utils.c:149
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
int av_fifo_generic_read(AVFifoBuffer *f, void *dest, int buf_size, void(*func)(void *, void *, int))
Feed data from an AVFifoBuffer to a user-supplied callback.
Definition: fifo.c:213
int av_buffersrc_close(AVFilterContext *ctx, int64_t pts, unsigned flags)
Close the buffer source after EOF.
Definition: buffersrc.c:263
unsigned int nb_programs
Definition: avformat.h:1530
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:203
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: avcodec.h:559
enum AVMediaType codec_type
General type of the encoded data.
Definition: avcodec.h:3896
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:1428
const char * arg
Definition: jacosubdec.c:66
int flags
AV_CODEC_FLAG_*.
Definition: avcodec.h:1613
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:568
AVChapter ** chapters
Definition: avformat.h:1581
#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:345
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:84
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: avcodec.h:5743
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:140
simple assert() macros that are a bit more flexible than ISO C assert().
enum AVPacketSideDataType type
Definition: avcodec.h:1391
int av_log_get_level(void)
Get the current log level.
Definition: log.c:380
void * av_mallocz(size_t size)
Allocate a memory block with alignment suitable for all memory accesses (including vectors if availab...
Definition: mem.c:236
const char * name
Name of the codec implementation.
Definition: avcodec.h:3431
static int check_recording_time(OutputStream *ost)
Definition: ffmpeg.c:897
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:636
int eof
Definition: ffmpeg.h:256
int force_fps
Definition: ffmpeg.h:479
int hw_device_setup_for_encode(OutputStream *ost)
Definition: ffmpeg_hw.c:414
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:947
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1268
#define FFMAX(a, b)
Definition: common.h:94
int attribute_align_arg av_buffersink_get_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:119
void avcodec_parameters_free(AVCodecParameters **par)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: utils.c:2029
int qp_hist
Definition: ffmpeg_opt.c:106
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
#define fail()
Definition: checkasm.h:117
float frame_drop_threshold
Definition: ffmpeg_opt.c:93
#define AV_CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: avcodec.h:1040
int64_t error[4]
Definition: ffmpeg.h:551
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:1451
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3199
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:2240
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
uint32_t end_display_time
Definition: avcodec.h:3879
static int want_sdp
Definition: ffmpeg.c:140
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3882
OutputFilter * filter
Definition: ffmpeg.h:502
static void check_decode_result(InputStream *ist, int *got_output, int ret)
Definition: ffmpeg.c:2105
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:404
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: avcodec.h:724
AVRational frame_aspect_ratio
Definition: ffmpeg.h:484
#define AV_DISPOSITION_LYRICS
Definition: avformat.h:823
static int ifilter_send_eof(InputFilter *ifilter, int64_t pts)
Definition: ffmpeg.c:2212
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:1608
#define FFDIFFSIGN(x, y)
Comparator.
Definition: common.h:92
#define AV_DISPOSITION_FORCED
Track should be used during playback by default.
Definition: avformat.h:831
common internal API header
uint64_t flags
Combination of AV_PIX_FMT_FLAG_...
Definition: pixdesc.h:106
AVRational mux_timebase
Definition: ffmpeg.h:459
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1407
AVDictionary * opts
Definition: movenc.c:50
int block_align
Audio only.
Definition: avcodec.h:4017
static int nb_frames_drop
Definition: ffmpeg.c:137
A bitmap, pict will be set.
Definition: avcodec.h:3824
int linesize[4]
Definition: avcodec.h:3860
int nb_output_files
Definition: ffmpeg.c:155
int seekable
A combination of AVIO_SEEKABLE_ flags or 0 when the stream is not seekable.
Definition: avio.h:260
int void avio_flush(AVIOContext *s)
Force flushing of buffered data.
Definition: aviobuf.c:238
int channels
number of audio channels, only used for audio.
Definition: frame.h:531
audio channel layout utility functions
int is_cfr
Definition: ffmpeg.h:478
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:309
static int transcode(void)
Definition: ffmpeg.c:4657
#define AV_CODEC_FLAG_BITEXACT
Use only bitexact stuff (except (I)DCT).
Definition: avcodec.h:895
int flags
Frame flags, a combination of AV_FRAME_FLAGS.
Definition: frame.h:464
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:53
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
#define NAN
Definition: mathematics.h:64
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
av_warn_unused_result int avformat_write_header(AVFormatContext *s, AVDictionary **options)
Allocate the stream private data and write the stream header to an output media file.
Definition: mux.c:508
#define FFMIN(a, b)
Definition: common.h:96
AVPacketSideData * coded_side_data
Additional data associated with the entire coded stream.
Definition: avcodec.h:3188
uint64_t * channel_layouts
Definition: ffmpeg.h:278
#define VSYNC_AUTO
Definition: ffmpeg.h:49
void av_log_set_callback(void(*callback)(void *, int, const char *, va_list))
Set the logging callback.
Definition: log.c:400
attribute_deprecated int avcodec_copy_context(AVCodecContext *dest, const AVCodecContext *src)
Copy the settings of the source AVCodecContext into the destination AVCodecContext.
Definition: options.c:215
int saw_first_ts
Definition: ffmpeg.h:331
int abort_on_flags
Definition: ffmpeg_opt.c:104
This side data contains quality related information from the encoder.
Definition: avcodec.h:1244
#define AV_DICT_DONT_STRDUP_VAL
Take ownership of a value that&#39;s been allocated with av_malloc() or another memory allocation functio...
Definition: dict.h:76
#define FFSIGN(a)
Definition: common.h:73
struct OutputStream * ost
Definition: ffmpeg.h:261
int width
picture width / height.
Definition: avcodec.h:1706
PVOID HANDLE
uint8_t w
Definition: llviddspenc.c:38
char * apad
Definition: ffmpeg.h:511
AVBufferRef * hw_frames_ctx
A reference to the AVHWFramesContext describing the input (for encoding) or output (decoding) frames...
Definition: avcodec.h:3213
int64_t nb_samples
Definition: ffmpeg.h:328
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: avcodec.h:5749
int hw_device_setup_for_decode(InputStream *ist)
Definition: ffmpeg_hw.c:298
double forced_keyframes_expr_const_values[FKF_NB]
Definition: ffmpeg.h:493
int av_packet_make_refcounted(AVPacket *pkt)
Ensure the data described by a given packet is reference counted.
Definition: avpacket.c:661
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:186
int64_t duration
Definition: ffmpeg.h:399
#define AV_FRAME_FLAG_CORRUPT
The frame data may be corrupted, e.g.
Definition: frame.h:452
const char * name
Definition: avformat.h:507
int width
Definition: ffmpeg.h:247
int32_t
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:119
AVFormatContext * ctx
Definition: movenc.c:48
#define AV_CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:874
int ifilter_parameters_from_frame(InputFilter *ifilter, const AVFrame *frame)
#define AV_CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:858
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output, int *decode_failed)
Definition: ffmpeg.c:2288
int nb_filtergraphs
Definition: ffmpeg.c:158
static av_always_inline int pthread_join(pthread_t thread, void **value_ptr)
Definition: os2threads.h:90
int64_t last_ts
Definition: ffmpeg.h:405
#define TRUE
Definition: windows2linux.h:33
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:72
#define s(width, name)
Definition: cbs_vp9.c:257
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:349
int do_pkt_dump
Definition: ffmpeg_opt.c:98
int64_t max_frames
Definition: ffmpeg.h:468
#define AV_RL32
Definition: intreadwrite.h:146
static void term_exit_sigsafe(void)
Definition: ffmpeg.c:320
int audio_channels_mapped
Definition: ffmpeg.h:497
int n
Definition: avisynth_c.h:684
AVDictionary * metadata
Definition: avformat.h:938
uint8_t * av_stream_new_side_data(AVStream *stream, enum AVPacketSideDataType type, int size)
Allocate new information from stream.
Definition: utils.c:5530
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1665
#define AVFILTER_CMD_FLAG_ONE
Stop once a filter understood the command (for target=all for example), fast filters are favored auto...
Definition: avfilter.h:691
static uint32_t codec_flags(enum AVCodecID codec_id)
Definition: cafenc.c:37
const char program_name[]
program name, defined by the program for show_version().
Definition: ffmpeg.c:109
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:56
#define is(width, name, range_min, range_max, subs,...)
Definition: cbs_h2645.c:269
uint8_t * data[4]
data+linesize for the bitmap of this subtitle.
Definition: avcodec.h:3859
static int got_eagain(void)
Definition: ffmpeg.c:4159
int inputs_done
Definition: ffmpeg.h:521
static void error(const char *err)
int vstats_version
Definition: ffmpeg_opt.c:112
AVFrame * av_frame_clone(const AVFrame *src)
Create a new frame that references the same data as src.
Definition: frame.c:540
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:72
#define FF_ARRAY_ELEMS(a)
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:842
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:1162
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:136
AVCodecContext * enc
Definition: muxing.c:55
#define av_log2
Definition: intmath.h:83
#define AV_DISPOSITION_VISUAL_IMPAIRED
stream for visual impaired audiences
Definition: avformat.h:833
int ret
Definition: ffmpeg.h:342
int audio_volume
Definition: ffmpeg_opt.c:90
int64_t sys_usec
Definition: ffmpeg.c:126
void av_get_channel_layout_string(char *buf, int buf_size, int nb_channels, uint64_t channel_layout)
Return a description of a channel layout.
Stream structure.
Definition: avformat.h:874
void avcodec_flush_buffers(AVCodecContext *avctx)
Reset the internal decoder state / flush internal buffers.
Definition: decode.c:1981
#define AVERROR_PATCHWELCOME
Not yet implemented in FFmpeg, patches welcome.
Definition: error.h:62
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:469
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:299
InputFilter ** filters
Definition: ffmpeg.h:358
int fix_sub_duration
Definition: ffmpeg.h:339
static BenchmarkTimeStamps get_benchmark_time_stamps(void)
Definition: ffmpeg.c:4798
int avcodec_send_packet(AVCodecContext *avctx, const AVPacket *avpkt)
Supply raw packet data as input to a decoder.
Definition: decode.c:677
#define VSYNC_DROP
Definition: ffmpeg.h:54
static int ifilter_has_all_input_formats(FilterGraph *fg)
Definition: ffmpeg.c:2124
int64_t recording_time
Definition: ffmpeg.h:408
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:5008
Definition: ffmpeg.h:67
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:2209
static av_always_inline int pthread_create(pthread_t *thread, const pthread_attr_t *attr, void *(*start_routine)(void *), void *arg)
Definition: os2threads.h:76
int(* init)(AVCodecContext *s)
Definition: ffmpeg.h:69
static int check_init_output_file(OutputFile *of, int file_index)
Definition: ffmpeg.c:2979
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:819
AVStream * st
Definition: ffmpeg.h:297
static int sub2video_get_blank_frame(InputStream *ist)
Definition: ffmpeg.c:176
sample_rate
static void set_encoder_id(OutputFile *of, OutputStream *ost)
Definition: ffmpeg.c:3175
#define AV_LOG_INFO
Standard information.
Definition: log.h:187
AVRational av_buffersink_get_sample_aspect_ratio(const AVFilterContext *ctx)
int frame_size
Definition: mxfenc.c:2092
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg.h:365
#define AV_DISPOSITION_DESCRIPTIONS
Definition: avformat.h:855
int ost_index
Definition: ffmpeg.h:557
struct InputStream * sync_ist
Definition: ffmpeg.h:451
#define AV_BPRINT_SIZE_AUTOMATIC
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: decode.c:1656
enum AVMediaType codec_type
Definition: avcodec.h:1541
double ts_scale
Definition: ffmpeg.h:330
int unavailable
Definition: ffmpeg.h:513
int64_t pkt_duration
duration of the corresponding packet, expressed in AVStream->time_base units, 0 if unknown...
Definition: frame.h:506
void av_thread_message_queue_set_err_send(AVThreadMessageQueue *mq, int err)
Set the sending error code.
void avcodec_free_context(AVCodecContext **avctx)
Free the codec context and everything associated with it and write NULL to the provided pointer...
Definition: options.c:171
static int init_input_stream(int ist_index, char *error, int error_len)
Definition: ffmpeg.c:2901
enum AVCodecID codec_id
Definition: avcodec.h:1543
void av_expr_free(AVExpr *e)
Free a parsed expression previously created with av_expr_parse().
Definition: eval.c:334
int av_fifo_size(const AVFifoBuffer *f)
Return the amount of data in bytes in the AVFifoBuffer, that is the amount of data you can read from ...
Definition: fifo.c:77
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
int av_opt_set_dict(void *obj, AVDictionary **options)
Set all the options from a given dictionary on an object.
Definition: opt.c:1603
static void sub2video_copy_rect(uint8_t *dst, int dst_linesize, int w, int h, AVSubtitleRect *r)
Definition: ffmpeg.c:191
float max_error_rate
Definition: ffmpeg_opt.c:109
int sample_rate
samples per second
Definition: avcodec.h:2189
int linesize[AV_NUM_DATA_POINTERS]
For video, size in bytes of each picture line.
Definition: frame.h:257
uint64_t frames_encoded
Definition: ffmpeg.h:536
AVIOContext * pb
I/O context.
Definition: avformat.h:1393
int64_t av_rescale_delta(AVRational in_tb, int64_t in_ts, AVRational fs_tb, int duration, int64_t *last, AVRational out_tb)
Rescale a timestamp while preserving known durations.
Definition: mathematics.c:168
int av_fifo_realloc2(AVFifoBuffer *f, unsigned int new_size)
Resize an AVFifoBuffer.
Definition: fifo.c:87
AVFifoBuffer * muxing_queue
Definition: ffmpeg.h:545
int ist_index
Definition: ffmpeg.h:397
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:532
static int loop
Definition: ffplay.c:339
int debug
debug
Definition: avcodec.h:2614
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
static void print_sdp(void)
Definition: ffmpeg.c:2760
const char * graph_desc
Definition: ffmpeg.h:284
int guess_layout_max
Definition: ffmpeg.h:335
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:81
uint64_t av_buffersink_get_channel_layout(const AVFilterContext *ctx)
int64_t start_time
Definition: ffmpeg.h:406
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:1784
main external API structure.
Definition: avcodec.h:1533
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:598
int64_t user_usec
Definition: ffmpeg.c:125
#define AV_PIX_FMT_RGB32
Definition: pixfmt.h:352
uint8_t * data
The data buffer.
Definition: buffer.h:89
static void ffmpeg_cleanup(int ret)
Definition: ffmpeg.c:483
static int command(AVFilterContext *ctx, const char *cmd, const char *arg, char *res, int res_len, int flags)
Definition: vf_drawtext.c:863
int * sample_rates
Definition: ffmpeg.h:279
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1077
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:314
const char * attachment_filename
Definition: ffmpeg.h:523
static int check_output_constraints(InputStream *ist, OutputStream *ost)
Definition: ffmpeg.c:1981
int avfilter_graph_request_oldest(AVFilterGraph *graph)
Request a frame on the oldest sink link.
a very simple circular buffer FIFO implementation
int avcodec_send_frame(AVCodecContext *avctx, const AVFrame *frame)
Supply a raw video or audio frame to the encoder.
Definition: encode.c:387
AVRational time_base
Definition: ffmpeg.h:401
#define AV_CODEC_PROP_BITMAP_SUB
Subtitle codec is bitmap based Decoded AVSubtitle data can be read from the AVSubtitleRect->pict fiel...
Definition: avcodec.h:767
void assert_avoptions(AVDictionary *m)
Definition: ffmpeg.c:645
AVCodecContext * enc_ctx
Definition: ffmpeg.h:465
void * buf
Definition: avisynth_c.h:690
AVFrame * decoded_frame
Definition: ffmpeg.h:306
int extradata_size
Definition: avcodec.h:1635
Perform non-blocking operation.
Definition: threadmessage.h:31
AVBufferRef * hw_frames_ctx
Definition: ffmpeg.h:254
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
Definition: dict.c:70
Replacements for frequently missing libm functions.
static int transcode_from_filter(FilterGraph *graph, InputStream **best_ist)
Perform a step of transcoding for the specified filter graph.
Definition: ffmpeg.c:4536
int nb_coded_side_data
Definition: avcodec.h:3189
int channels
Definition: ffmpeg.h:251
int * audio_channels_map
Definition: ffmpeg.h:496
#define VSYNC_PASSTHROUGH
Definition: ffmpeg.h:50
Describe the class of an AVClass context structure.
Definition: log.h:67
int sample_rate
Sample rate of the audio data.
Definition: frame.h:399
int configure_filtergraph(FilterGraph *fg)
int(* get_buffer2)(struct AVCodecContext *s, AVFrame *frame, int flags)
This callback is called at the beginning of each frame to get data buffer(s) for it.
Definition: avcodec.h:2344
OutputStream ** output_streams
Definition: ffmpeg.c:152
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:88
int index
Definition: gxfenc.c:89
enum AVMediaType av_buffersink_get_type(const AVFilterContext *ctx)
int av_find_nearest_q_idx(AVRational q, const AVRational *q_list)
Find the value in a list of rationals nearest a given reference rational.
Definition: rational.c:142
#define FF_DEBUG_DCT_COEFF
Definition: avcodec.h:2626
Rational number (pair of numerator and denominator).
Definition: rational.h:58
int file_index
Definition: ffmpeg.h:443
int av_thread_message_queue_alloc(AVThreadMessageQueue **mq, unsigned nelem, unsigned elsize)
Allocate a new message queue.
Definition: threadmessage.c:40
#define ABORT_ON_FLAG_EMPTY_OUTPUT
Definition: ffmpeg.h:433
double rotate_override_value
Definition: ffmpeg.h:482
int avcodec_parameters_from_context(AVCodecParameters *par, const AVCodecContext *codec)
Fill the parameters struct based on the values from the supplied codec context.
Definition: utils.c:2058
int64_t sync_opts
Definition: ffmpeg.h:452
char * vstats_filename
Definition: ffmpeg_opt.c:83
int64_t parse_time_or_die(const char *context, const char *timestr, int is_duration)
Parse a string specifying a time and return its corresponding value as a number of microseconds...
Definition: cmdutils.c:165
AVCodecContext * dec_ctx
Definition: ffmpeg.h:304
char * disposition
Definition: ffmpeg.h:526
This struct describes a set or pool of "hardware" frames (i.e.
Definition: hwcontext.h:123
cl_device_type type
int filtergraph_is_simple(FilterGraph *fg)
struct InputStream::@24 prev_sub
#define mid_pred
Definition: mathops.h:97
AVMediaType
Definition: avutil.h:199
discard useless packets like 0 size packets in avi
Definition: avcodec.h:798
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1177
int av_buffersink_get_w(const AVFilterContext *ctx)
int nb_streams_warn
Definition: ffmpeg.h:411
static void init_encoder_time_base(OutputStream *ost, AVRational default_time_base)
Definition: ffmpeg.c:3279
AVDictionary * decoder_opts
Definition: ffmpeg.h:332
int autorotate
Definition: ffmpeg.h:337
const char * name
Name of the codec described by this descriptor.
Definition: avcodec.h:716
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:544
#define snprintf
Definition: snprintf.h:34
int64_t best_effort_timestamp
frame timestamp estimated using various heuristics, in stream time base
Definition: frame.h:491
int frame_bits_per_raw_sample
Definition: ffmpeg_opt.c:108
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:4392
int64_t ts_offset
Definition: ffmpeg.h:404
uint32_t DWORD
unsigned av_buffersrc_get_nb_failed_requests(AVFilterContext *buffer_src)
Get the number of failed requests.
Definition: buffersrc.c:293
static int transcode_step(void)
Run a single step of transcoding.
Definition: ffmpeg.c:4582
char * filters_script
filtergraph script associated to the -filter_script option
Definition: ffmpeg.h:505
int decode_error_flags
decode error flags of the frame, set to a combination of FF_DECODE_ERROR_xxx flags if the decoder pro...
Definition: frame.h:522
int av_get_audio_frame_duration(AVCodecContext *avctx, int frame_bytes)
Return audio frame duration.
Definition: utils.c:1737
misc parsing utilities
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1768
static AVRational duration_max(int64_t tmp, int64_t *duration, AVRational tmp_time_base, AVRational time_base)
Definition: ffmpeg.c:4178
size_t av_strlcat(char *dst, const char *src, size_t size)
Append the string src to the string dst, but to a total length of no more than size - 1 bytes...
Definition: avstring.c:93
static enum AVPixelFormat pix_fmts[]
Definition: libkvazaar.c:266
This struct describes the properties of a single codec described by an AVCodecID. ...
Definition: avcodec.h:708
AVFrame * filtered_frame
Definition: ffmpeg.h:469
int source_index
Definition: ffmpeg.h:445
int av_frame_get_buffer(AVFrame *frame, int align)
Allocate new buffer(s) for audio or video data.
Definition: frame.c:324
static volatile int received_nb_signals
Definition: ffmpeg.c:335
int(* hwaccel_get_buffer)(AVCodecContext *s, AVFrame *frame, int flags)
Definition: ffmpeg.h:372
int copy_prior_start
Definition: ffmpeg.h:525
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:553
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1599
static void close_all_output_streams(OutputStream *ost, OSTFinished this_stream, OSTFinished others)
Definition: ffmpeg.c:680
static int64_t pts
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:76
#define flags(name, subs,...)
Definition: cbs_av1.c:606
void av_thread_message_queue_free(AVThreadMessageQueue **mq)
Free a message queue.
Definition: threadmessage.c:91
int nb_filters
Definition: ffmpeg.h:359
static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
Definition: ffmpeg.c:2805
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:1456
uint8_t * data[AV_NUM_DATA_POINTERS]
pointer to the picture/channel planes.
Definition: frame.h:240
uint8_t level
Definition: svq3.c:207
AVExpr * forced_keyframes_pexpr
Definition: ffmpeg.h:492
int av_get_bytes_per_sample(enum AVSampleFormat sample_fmt)
Return number of bytes per sample.
Definition: samplefmt.c:106
int64_t real_usec
Definition: ffmpeg.c:124
int64_t dts
dts of the last packet read for this stream (in AV_TIME_BASE units)
Definition: ffmpeg.h:313
int av_seek_frame(AVFormatContext *s, int stream_index, int64_t timestamp, int flags)
Seek to the keyframe at timestamp.
Definition: utils.c:2506
int forced_kf_count
Definition: ffmpeg.h:489
int64_t start
Definition: avformat.h:1311
int64_t duration
Decoding: duration of the stream, in stream time base.
Definition: avformat.h:923
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
OSTFinished finished
Definition: ffmpeg.h:512
char * forced_keyframes
Definition: ffmpeg.h:491
int sample_rate
Audio only.
Definition: avcodec.h:4010
uint64_t data_size
Definition: ffmpeg.h:380
int64_t bitrate
Definition: h264_levels.c:89
void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:67
int64_t next_pts
synthetic pts for the next decode frame (in AV_TIME_BASE units)
Definition: ffmpeg.h:315
static AVStream * ost
Main libavformat public API header.
void print_error(const char *filename, int err)
Print an error message to stderr, indicating filename and a human readable description of the error c...
Definition: cmdutils.c:1081
struct FilterGraph * graph
Definition: ffmpeg.h:262
uint64_t limit_filesize
Definition: ffmpeg.h:560
const OptionDef options[]
Definition: ffmpeg_opt.c:3324
static void print_final_stats(int64_t total_size)
Definition: ffmpeg.c:1533
AVIOContext * progress_avio
Definition: ffmpeg.c:143
int main(int argc, char **argv)
Definition: ffmpeg.c:4846
int reinit_filters
Definition: ffmpeg.h:361
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:465
AVCodecParameters * ref_par
Definition: ffmpeg.h:466
#define VSYNC_CFR
Definition: ffmpeg.h:51
void av_buffersink_set_frame_size(AVFilterContext *ctx, unsigned frame_size)
Set the frame size for an audio buffer sink.
Definition: buffersink.c:175
#define AV_CODEC_CAP_PARAM_CHANGE
Codec supports changed parameters at any point.
Definition: avcodec.h:1032
int64_t start_time
Decoding: pts of the first frame of the stream in presentation order, in stream time base...
Definition: avformat.h:913
static double c[64]
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:474
AVStream * st
Definition: muxing.c:54
static AVCodecContext * dec_ctx
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:927
uint32_t start_display_time
Definition: avcodec.h:3878
AVRational av_add_q(AVRational b, AVRational c)
Add two rationals.
Definition: rational.c:93
AVBufferRef * av_buffer_ref(AVBufferRef *buf)
Create a new reference to an AVBuffer.
Definition: buffer.c:93
int pts_wrap_bits
number of bits in pts (used for wrapping control)
Definition: avformat.h:1066
uint64_t samples_encoded
Definition: ffmpeg.h:537
AVRational time_base
time base in which the start/end timestamps are specified
Definition: avformat.h:1310
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:33
int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:2814
int64_t nb_frames
number of frames in this stream if known or 0
Definition: avformat.h:925
char * key
Definition: dict.h:86
uint32_t BOOL
static FILE * vstats_file
Definition: ffmpeg.c:112
int den
Denominator.
Definition: rational.h:60
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents...
Definition: cmdutils.c:90
AVFrame * last_frame
Definition: ffmpeg.h:470
int avfilter_graph_send_command(AVFilterGraph *graph, const char *target, const char *cmd, const char *arg, char *res, int res_len, int flags)
Send a command to one or more filter instances.
int attribute_align_arg av_buffersrc_add_frame_flags(AVFilterContext *ctx, AVFrame *frame, int flags)
Add a frame to the buffer source.
Definition: buffersrc.c:152
uint64_t channel_layout
Definition: ffmpeg.h:252
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: avcodec.h:1478
int copy_ts
Definition: ffmpeg_opt.c:99
static void do_video_out(OutputFile *of, OutputStream *ost, AVFrame *next_picture, double sync_ipts)
Definition: ffmpeg.c:1053
struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1363
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4430
AVFormatContext * ctx
Definition: ffmpeg.h:394
int pict_type
Definition: ffmpeg.h:548
AVSubtitle subtitle
Definition: ffmpeg.h:343
#define AV_CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:862
int eof_reached
Definition: ffmpeg.h:395
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:108
int forced_kf_index
Definition: ffmpeg.h:490
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:472
char * avfilter
Definition: ffmpeg.h:503
int hwaccel_decode_init(AVCodecContext *avctx)
Definition: ffmpeg_hw.c:472
uint8_t * name
Definition: ffmpeg.h:239
char * value
Definition: dict.h:87
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:43
Keep a reference to the frame.
Definition: buffersrc.h:53
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:378
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
float dts_delta_threshold
Definition: ffmpeg_opt.c:87
double av_expr_eval(AVExpr *e, const double *const_values, void *opaque)
Evaluate a previously parsed expression.
Definition: eval.c:734
int channels
number of audio channels
Definition: avcodec.h:2190
int top_field_first
Definition: ffmpeg.h:480
int av_buffersink_get_channels(const AVFilterContext *ctx)
OutputFilter ** outputs
Definition: ffmpeg.h:291
InputFile ** input_files
Definition: ffmpeg.c:149
static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
Definition: ffmpeg.c:2891
void av_log_set_flags(int arg)
Definition: log.c:390
int key_frame
1 -> keyframe, 0-> not
Definition: frame.h:304
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:227
static int ifilter_send_frame(InputFilter *ifilter, AVFrame *frame)
Definition: ffmpeg.c:2135
AVFormatContext * ctx
Definition: ffmpeg.h:555
#define lrint
Definition: tablegen.h:53
#define AV_DISPOSITION_COMMENT
Definition: avformat.h:822
void show_usage(void)
Definition: ffmpeg_opt.c:3198
int channels
Audio only.
Definition: avcodec.h:4006
An instance of a filter.
Definition: avfilter.h:338
static void do_audio_out(OutputFile *of, OutputStream *ost, AVFrame *frame)
Definition: ffmpeg.c:910
#define LIBAVCODEC_IDENT
Definition: version.h:42
char * hwaccel_device
Definition: ffmpeg.h:366
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:1444
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVDictionary * encoder_opts
Definition: ffmpeg.h:507
int64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:1247
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: ffmpeg.c:110
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:5066
int height
Definition: frame.h:284
FILE * out
Definition: movenc.c:54
InputFilter ** inputs
Definition: ffmpeg.h:289
#define av_freep(p)
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:2186
enum AVPixelFormat hwaccel_retrieved_pix_fmt
Definition: ffmpeg.h:375
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:647
static int decode(AVCodecContext *avctx, AVFrame *frame, int *got_frame, AVPacket *pkt)
Definition: ffmpeg.c:2239
#define AV_DICT_IGNORE_SUFFIX
Return first entry in a dictionary whose first part corresponds to the search key, ignoring the suffix of the found key string.
Definition: dict.h:70
static int send_filter_eof(InputStream *ist)
Definition: ffmpeg.c:2562
OutputFile ** output_files
Definition: ffmpeg.c:154
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:170
void av_fifo_freep(AVFifoBuffer **f)
Free an AVFifoBuffer and reset pointer to NULL.
Definition: fifo.c:63
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1021
#define av_malloc_array(a, b)
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
enum AVHWDeviceType device_type
The device type associated with the configuration.
Definition: avcodec.h:3414
static void flush_encoders(void)
Definition: ffmpeg.c:1862
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: avcodec.h:3904
int copy_tb
Definition: ffmpeg_opt.c:101
int64_t min_pts
Definition: ffmpeg.h:321
int initialized
Definition: ffmpeg.h:519
static volatile int received_sigterm
Definition: ffmpeg.c:334
#define FFSWAP(type, a, b)
Definition: common.h:99
int discard
Definition: ffmpeg.h:298
static int get_input_packet(InputFile *f, AVPacket *pkt)
Definition: ffmpeg.c:4139
uint8_t * av_packet_new_side_data(AVPacket *pkt, enum AVPacketSideDataType type, int size)
Allocate new information of a packet.
Definition: avpacket.c:329
int stream_index
Definition: avcodec.h:1447
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:903
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:364
int depth
Number of bits in the component.
Definition: pixdesc.h:58
enum AVSubtitleType type
Definition: avcodec.h:3862
int64_t first_pts
Definition: ffmpeg.h:455
int nb_inputs
Definition: ffmpeg.h:290
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:929
#define DECODING_FOR_OST
Definition: ffmpeg.h:301
int index
Definition: ffmpeg.h:444
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:998
AVPixelFormat
Pixel format.
Definition: pixfmt.h:64
OSTFinished
Definition: ffmpeg.h:437
This structure stores compressed data.
Definition: avcodec.h:1422
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: aviobuf.c:1214
AVCodecParameters * par_in
Parameters of the input stream.
Definition: avcodec.h:5731
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: encode.c:342
AVFifoBuffer * frame_queue
Definition: ffmpeg.h:242
int debug_ts
Definition: ffmpeg_opt.c:102
AVRational av_buffersink_get_time_base(const AVFilterContext *ctx)
static OutputStream * choose_output(void)
Select the output stream to process.
Definition: ffmpeg.c:3874
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:292
static void sigterm_handler(int sig)
Definition: ffmpeg.c:341
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:1438
int64_t av_stream_get_end_pts(const AVStream *st)
Returns the pts of the last muxed packet + its duration.
Definition: utils.c:141
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:1575
for(j=16;j >0;--j)
#define FFMAX3(a, b, c)
Definition: common.h:95
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
#define tb
Definition: regdef.h:68
AVProgram ** programs
Definition: avformat.h:1531
#define AV_DISPOSITION_ORIGINAL
Definition: avformat.h:821
int avio_printf(AVIOContext *s, const char *fmt,...) av_printf_format(2
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:144
InputStream ** input_streams
Definition: ffmpeg.c:147
static unsigned dup_warning
Definition: ffmpeg.c:136
const HWAccel hwaccels[]
Definition: ffmpeg_opt.c:68
Definition: ffmpeg.h:429
static void close_output_stream(OutputStream *ost)
Definition: ffmpeg.c:824
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:3001
static uint8_t tmp[11]
Definition: aes_ctr.c:26