Libav
avconv.c
Go to the documentation of this file.
1 /*
2  * avconv main
3  * Copyright (c) 2000-2011 The libav developers.
4  *
5  * This file is part of Libav.
6  *
7  * Libav is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * Libav is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with Libav; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "config.h"
23 #include <ctype.h>
24 #include <string.h>
25 #include <math.h>
26 #include <stdlib.h>
27 #include <errno.h>
28 #include <signal.h>
29 #include <limits.h>
30 #include <stdint.h>
31 
32 #include "libavformat/avformat.h"
33 #include "libavdevice/avdevice.h"
34 #include "libswscale/swscale.h"
36 #include "libavutil/opt.h"
38 #include "libavutil/parseutils.h"
39 #include "libavutil/samplefmt.h"
40 #include "libavutil/fifo.h"
41 #include "libavutil/intreadwrite.h"
42 #include "libavutil/dict.h"
43 #include "libavutil/mathematics.h"
44 #include "libavutil/pixdesc.h"
45 #include "libavutil/avstring.h"
46 #include "libavutil/libm.h"
47 #include "libavutil/imgutils.h"
48 #include "libavutil/time.h"
49 #include "libavformat/os_support.h"
50 
51 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersrc.h"
53 # include "libavfilter/buffersink.h"
54 
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/time.h>
57 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
60 #include <windows.h>
61 #endif
62 #if HAVE_GETPROCESSMEMORYINFO
63 #include <windows.h>
64 #include <psapi.h>
65 #endif
66 
67 #if HAVE_SYS_SELECT_H
68 #include <sys/select.h>
69 #endif
70 
71 #if HAVE_PTHREADS
72 #include <pthread.h>
73 #endif
74 
75 #include <time.h>
76 
77 #include "avconv.h"
78 #include "cmdutils.h"
79 
80 #include "libavutil/avassert.h"
81 
82 const char program_name[] = "avconv";
83 const int program_birth_year = 2000;
84 
85 static FILE *vstats_file;
86 
87 static int64_t video_size = 0;
88 static int64_t audio_size = 0;
89 static int64_t extra_size = 0;
90 static int nb_frames_dup = 0;
91 static int nb_frames_drop = 0;
92 
93 
94 
95 #if HAVE_PTHREADS
96 /* signal to input threads that they should exit; set by the main thread */
97 static int transcoding_finished;
98 #endif
99 
100 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
101 
106 
111 
114 
115 static void term_exit(void)
116 {
117  av_log(NULL, AV_LOG_QUIET, "");
118 }
119 
120 static volatile int received_sigterm = 0;
121 static volatile int received_nb_signals = 0;
122 
123 static void
125 {
126  received_sigterm = sig;
128  term_exit();
129 }
130 
131 static void term_init(void)
132 {
133  signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
134  signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
135 #ifdef SIGXCPU
136  signal(SIGXCPU, sigterm_handler);
137 #endif
138 }
139 
140 static int decode_interrupt_cb(void *ctx)
141 {
142  return received_nb_signals > 1;
143 }
144 
146 
147 static void avconv_cleanup(int ret)
148 {
149  int i, j;
150 
151  for (i = 0; i < nb_filtergraphs; i++) {
152  avfilter_graph_free(&filtergraphs[i]->graph);
153  for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
154  av_freep(&filtergraphs[i]->inputs[j]->name);
155  av_freep(&filtergraphs[i]->inputs[j]);
156  }
157  av_freep(&filtergraphs[i]->inputs);
158  for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
159  av_freep(&filtergraphs[i]->outputs[j]->name);
160  av_freep(&filtergraphs[i]->outputs[j]);
161  }
162  av_freep(&filtergraphs[i]->outputs);
163  av_freep(&filtergraphs[i]->graph_desc);
164  av_freep(&filtergraphs[i]);
165  }
166  av_freep(&filtergraphs);
167 
168  /* close files */
169  for (i = 0; i < nb_output_files; i++) {
170  AVFormatContext *s = output_files[i]->ctx;
171  if (s && s->oformat && !(s->oformat->flags & AVFMT_NOFILE) && s->pb)
172  avio_close(s->pb);
174  av_dict_free(&output_files[i]->opts);
175  av_freep(&output_files[i]);
176  }
177  for (i = 0; i < nb_output_streams; i++) {
178  AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
179  while (bsfc) {
180  AVBitStreamFilterContext *next = bsfc->next;
182  bsfc = next;
183  }
184  output_streams[i]->bitstream_filters = NULL;
185  av_frame_free(&output_streams[i]->filtered_frame);
186 
187  av_parser_close(output_streams[i]->parser);
188 
189  av_freep(&output_streams[i]->forced_keyframes);
190  av_freep(&output_streams[i]->avfilter);
191  av_freep(&output_streams[i]->logfile_prefix);
192  av_freep(&output_streams[i]);
193  }
194  for (i = 0; i < nb_input_files; i++) {
195  avformat_close_input(&input_files[i]->ctx);
196  av_freep(&input_files[i]);
197  }
198  for (i = 0; i < nb_input_streams; i++) {
199  av_frame_free(&input_streams[i]->decoded_frame);
200  av_frame_free(&input_streams[i]->filter_frame);
201  av_dict_free(&input_streams[i]->opts);
202  av_freep(&input_streams[i]->filters);
203  av_freep(&input_streams[i]->hwaccel_device);
204  av_freep(&input_streams[i]);
205  }
206 
207  if (vstats_file)
208  fclose(vstats_file);
210 
211  av_freep(&input_streams);
212  av_freep(&input_files);
213  av_freep(&output_streams);
214  av_freep(&output_files);
215 
216  uninit_opts();
217 
219 
220  if (received_sigterm) {
221  av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
222  (int) received_sigterm);
223  exit (255);
224  }
225 }
226 
228 {
230  if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
231  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
232  exit_program(1);
233  }
234 }
235 
236 static void abort_codec_experimental(AVCodec *c, int encoder)
237 {
238  const char *codec_string = encoder ? "encoder" : "decoder";
239  AVCodec *codec;
240  av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
241  "results.\nAdd '-strict experimental' if you want to use it.\n",
242  codec_string, c->name);
243  codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id);
244  if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
245  av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
246  codec_string, codec->name);
247  exit_program(1);
248 }
249 
250 /*
251  * Update the requested input sample format based on the output sample format.
252  * This is currently only used to request float output from decoders which
253  * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
254  * Ideally this will be removed in the future when decoders do not do format
255  * conversion and only output in their native format.
256  */
257 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
258  AVCodecContext *enc)
259 {
260  /* if sample formats match or a decoder sample format has already been
261  requested, just return */
262  if (enc->sample_fmt == dec->sample_fmt ||
264  return;
265 
266  /* if decoder supports more than one output format */
267  if (dec_codec && dec_codec->sample_fmts &&
268  dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
269  dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
270  const enum AVSampleFormat *p;
271  int min_dec = INT_MAX, min_inc = INT_MAX;
272  enum AVSampleFormat dec_fmt = AV_SAMPLE_FMT_NONE;
273  enum AVSampleFormat inc_fmt = AV_SAMPLE_FMT_NONE;
274 
275  /* find a matching sample format in the encoder */
276  for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
277  if (*p == enc->sample_fmt) {
278  dec->request_sample_fmt = *p;
279  return;
280  } else {
283  int fmt_diff = 32 * abs(dfmt - efmt);
284  if (av_sample_fmt_is_planar(*p) !=
286  fmt_diff++;
287  if (dfmt == efmt) {
288  min_inc = fmt_diff;
289  inc_fmt = *p;
290  } else if (dfmt > efmt) {
291  if (fmt_diff < min_inc) {
292  min_inc = fmt_diff;
293  inc_fmt = *p;
294  }
295  } else {
296  if (fmt_diff < min_dec) {
297  min_dec = fmt_diff;
298  dec_fmt = *p;
299  }
300  }
301  }
302  }
303 
304  /* if none match, provide the one that matches quality closest */
305  dec->request_sample_fmt = min_inc != INT_MAX ? inc_fmt : dec_fmt;
306  }
307 }
308 
310 {
312  AVCodecContext *avctx = ost->st->codec;
313  int ret;
314 
315  /*
316  * Audio encoders may split the packets -- #frames in != #packets out.
317  * But there is no reordering, so we can limit the number of output packets
318  * by simply dropping them here.
319  * Counting encoded video frames needs to be done separately because of
320  * reordering, see do_video_out()
321  */
322  if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
323  if (ost->frame_number >= ost->max_frames) {
324  av_free_packet(pkt);
325  return;
326  }
327  ost->frame_number++;
328  }
329 
330  while (bsfc) {
331  AVPacket new_pkt = *pkt;
332  int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
333  &new_pkt.data, &new_pkt.size,
334  pkt->data, pkt->size,
335  pkt->flags & AV_PKT_FLAG_KEY);
336  if (a > 0) {
337  av_free_packet(pkt);
338  new_pkt.buf = av_buffer_create(new_pkt.data, new_pkt.size,
340  if (!new_pkt.buf)
341  exit_program(1);
342  } else if (a < 0) {
343  av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
344  bsfc->filter->name, pkt->stream_index,
345  avctx->codec ? avctx->codec->name : "copy");
346  print_error("", a);
347  if (exit_on_error)
348  exit_program(1);
349  }
350  *pkt = new_pkt;
351 
352  bsfc = bsfc->next;
353  }
354 
355  if (!(s->oformat->flags & AVFMT_NOTIMESTAMPS) &&
356  ost->last_mux_dts != AV_NOPTS_VALUE &&
357  pkt->dts < ost->last_mux_dts + !(s->oformat->flags & AVFMT_TS_NONSTRICT)) {
358  av_log(NULL, AV_LOG_WARNING, "Non-monotonous DTS in output stream "
359  "%d:%d; previous: %"PRId64", current: %"PRId64"; ",
360  ost->file_index, ost->st->index, ost->last_mux_dts, pkt->dts);
361  if (exit_on_error) {
362  av_log(NULL, AV_LOG_FATAL, "aborting.\n");
363  exit_program(1);
364  }
365  av_log(NULL, AV_LOG_WARNING, "changing to %"PRId64". This may result "
366  "in incorrect timestamps in the output file.\n",
367  ost->last_mux_dts + 1);
368  pkt->dts = ost->last_mux_dts + 1;
369  if (pkt->pts != AV_NOPTS_VALUE)
370  pkt->pts = FFMAX(pkt->pts, pkt->dts);
371  }
372  ost->last_mux_dts = pkt->dts;
373 
374  pkt->stream_index = ost->index;
375  ret = av_interleaved_write_frame(s, pkt);
376  if (ret < 0) {
377  print_error("av_interleaved_write_frame()", ret);
378  exit_program(1);
379  }
380 }
381 
383 {
384  OutputFile *of = output_files[ost->file_index];
385 
386  if (of->recording_time != INT64_MAX &&
388  AV_TIME_BASE_Q) >= 0) {
389  ost->finished = 1;
390  return 0;
391  }
392  return 1;
393 }
394 
396  AVFrame *frame)
397 {
398  AVCodecContext *enc = ost->st->codec;
399  AVPacket pkt;
400  int got_packet = 0;
401 
402  av_init_packet(&pkt);
403  pkt.data = NULL;
404  pkt.size = 0;
405 
406  if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
407  frame->pts = ost->sync_opts;
408  ost->sync_opts = frame->pts + frame->nb_samples;
409 
410  if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
411  av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
412  exit_program(1);
413  }
414 
415  if (got_packet) {
416  if (pkt.pts != AV_NOPTS_VALUE)
417  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
418  if (pkt.dts != AV_NOPTS_VALUE)
419  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
420  if (pkt.duration > 0)
421  pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
422 
423  write_frame(s, &pkt, ost);
424 
425  audio_size += pkt.size;
426  }
427 }
428 
430  OutputStream *ost,
431  InputStream *ist,
432  AVSubtitle *sub,
433  int64_t pts)
434 {
435  static uint8_t *subtitle_out = NULL;
436  int subtitle_out_max_size = 1024 * 1024;
437  int subtitle_out_size, nb, i;
438  AVCodecContext *enc;
439  AVPacket pkt;
440 
441  if (pts == AV_NOPTS_VALUE) {
442  av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
443  if (exit_on_error)
444  exit_program(1);
445  return;
446  }
447 
448  enc = ost->st->codec;
449 
450  if (!subtitle_out) {
451  subtitle_out = av_malloc(subtitle_out_max_size);
452  }
453 
454  /* Note: DVB subtitle need one packet to draw them and one other
455  packet to clear them */
456  /* XXX: signal it in the codec context ? */
458  nb = 2;
459  else
460  nb = 1;
461 
462  for (i = 0; i < nb; i++) {
463  ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
464  if (!check_recording_time(ost))
465  return;
466 
467  sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
468  // start_display_time is required to be 0
469  sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
471  sub->start_display_time = 0;
472  subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
473  subtitle_out_max_size, sub);
474  if (subtitle_out_size < 0) {
475  av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
476  exit_program(1);
477  }
478 
479  av_init_packet(&pkt);
480  pkt.data = subtitle_out;
481  pkt.size = subtitle_out_size;
482  pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
483  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
484  /* XXX: the pts correction is handled here. Maybe handling
485  it in the codec would be better */
486  if (i == 0)
487  pkt.pts += 90 * sub->start_display_time;
488  else
489  pkt.pts += 90 * sub->end_display_time;
490  }
491  write_frame(s, &pkt, ost);
492  }
493 }
494 
496  OutputStream *ost,
497  AVFrame *in_picture,
498  int *frame_size)
499 {
500  int ret, format_video_sync;
501  AVPacket pkt;
502  AVCodecContext *enc = ost->st->codec;
503 
504  *frame_size = 0;
505 
506  format_video_sync = video_sync_method;
507  if (format_video_sync == VSYNC_AUTO)
508  format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
510  if (format_video_sync != VSYNC_PASSTHROUGH &&
511  ost->frame_number &&
512  in_picture->pts != AV_NOPTS_VALUE &&
513  in_picture->pts < ost->sync_opts) {
514  nb_frames_drop++;
515  av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
516  return;
517  }
518 
519  if (in_picture->pts == AV_NOPTS_VALUE)
520  in_picture->pts = ost->sync_opts;
521  ost->sync_opts = in_picture->pts;
522 
523 
524  if (!ost->frame_number)
525  ost->first_pts = in_picture->pts;
526 
527  av_init_packet(&pkt);
528  pkt.data = NULL;
529  pkt.size = 0;
530 
531  if (ost->frame_number >= ost->max_frames)
532  return;
533 
534  if (s->oformat->flags & AVFMT_RAWPICTURE &&
535  enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
536  /* raw pictures are written as AVPicture structure to
537  avoid any copies. We support temporarily the older
538  method. */
539  enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
540  enc->coded_frame->top_field_first = in_picture->top_field_first;
541  pkt.data = (uint8_t *)in_picture;
542  pkt.size = sizeof(AVPicture);
543  pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
544  pkt.flags |= AV_PKT_FLAG_KEY;
545 
546  write_frame(s, &pkt, ost);
547  } else {
548  int got_packet;
549 
551  ost->top_field_first >= 0)
552  in_picture->top_field_first = !!ost->top_field_first;
553 
554  in_picture->quality = ost->st->codec->global_quality;
555  if (!enc->me_threshold)
556  in_picture->pict_type = 0;
557  if (ost->forced_kf_index < ost->forced_kf_count &&
558  in_picture->pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
559  in_picture->pict_type = AV_PICTURE_TYPE_I;
560  ost->forced_kf_index++;
561  }
562  ret = avcodec_encode_video2(enc, &pkt, in_picture, &got_packet);
563  if (ret < 0) {
564  av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
565  exit_program(1);
566  }
567 
568  if (got_packet) {
569  if (pkt.pts != AV_NOPTS_VALUE)
570  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
571  if (pkt.dts != AV_NOPTS_VALUE)
572  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
573 
574  write_frame(s, &pkt, ost);
575  *frame_size = pkt.size;
576  video_size += pkt.size;
577 
578  /* if two pass, output log */
579  if (ost->logfile && enc->stats_out) {
580  fprintf(ost->logfile, "%s", enc->stats_out);
581  }
582  }
583  }
584  ost->sync_opts++;
585  /*
586  * For video, number of frames in == number of packets out.
587  * But there may be reordering, so we can't throw away frames on encoder
588  * flush, we need to limit them here, before they go into encoder.
589  */
590  ost->frame_number++;
591 }
592 
593 static double psnr(double d)
594 {
595  return -10.0 * log(d) / log(10.0);
596 }
597 
598 static void do_video_stats(OutputStream *ost, int frame_size)
599 {
600  AVCodecContext *enc;
601  int frame_number;
602  double ti1, bitrate, avg_bitrate;
603 
604  /* this is executed just the first time do_video_stats is called */
605  if (!vstats_file) {
606  vstats_file = fopen(vstats_filename, "w");
607  if (!vstats_file) {
608  perror("fopen");
609  exit_program(1);
610  }
611  }
612 
613  enc = ost->st->codec;
614  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
615  frame_number = ost->frame_number;
616  fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
617  if (enc->flags&CODEC_FLAG_PSNR)
618  fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
619 
620  fprintf(vstats_file,"f_size= %6d ", frame_size);
621  /* compute pts value */
622  ti1 = ost->sync_opts * av_q2d(enc->time_base);
623  if (ti1 < 0.01)
624  ti1 = 0.01;
625 
626  bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
627  avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
628  fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
629  (double)video_size / 1024, ti1, bitrate, avg_bitrate);
630  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
631  }
632 }
633 
634 /*
635  * Read one frame for lavfi output for ost and encode it.
636  */
637 static int poll_filter(OutputStream *ost)
638 {
639  OutputFile *of = output_files[ost->file_index];
640  AVFrame *filtered_frame = NULL;
641  int frame_size, ret;
642 
643  if (!ost->filtered_frame && !(ost->filtered_frame = av_frame_alloc())) {
644  return AVERROR(ENOMEM);
645  }
646  filtered_frame = ost->filtered_frame;
647 
648  if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
650  ret = av_buffersink_get_samples(ost->filter->filter, filtered_frame,
651  ost->st->codec->frame_size);
652  else
653  ret = av_buffersink_get_frame(ost->filter->filter, filtered_frame);
654 
655  if (ret < 0)
656  return ret;
657 
658  if (filtered_frame->pts != AV_NOPTS_VALUE) {
659  int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
660  filtered_frame->pts = av_rescale_q(filtered_frame->pts,
661  ost->filter->filter->inputs[0]->time_base,
662  ost->st->codec->time_base) -
663  av_rescale_q(start_time,
665  ost->st->codec->time_base);
666  }
667 
668  switch (ost->filter->filter->inputs[0]->type) {
669  case AVMEDIA_TYPE_VIDEO:
670  if (!ost->frame_aspect_ratio)
671  ost->st->codec->sample_aspect_ratio = filtered_frame->sample_aspect_ratio;
672 
673  do_video_out(of->ctx, ost, filtered_frame, &frame_size);
674  if (vstats_filename && frame_size)
675  do_video_stats(ost, frame_size);
676  break;
677  case AVMEDIA_TYPE_AUDIO:
678  do_audio_out(of->ctx, ost, filtered_frame);
679  break;
680  default:
681  // TODO support subtitle filters
682  av_assert0(0);
683  }
684 
685  av_frame_unref(filtered_frame);
686 
687  return 0;
688 }
689 
690 /*
691  * Read as many frames from possible from lavfi and encode them.
692  *
693  * Always read from the active stream with the lowest timestamp. If no frames
694  * are available for it then return EAGAIN and wait for more input. This way we
695  * can use lavfi sources that generate unlimited amount of frames without memory
696  * usage exploding.
697  */
698 static int poll_filters(void)
699 {
700  int i, j, ret = 0;
701 
702  while (ret >= 0 && !received_sigterm) {
703  OutputStream *ost = NULL;
704  int64_t min_pts = INT64_MAX;
705 
706  /* choose output stream with the lowest timestamp */
707  for (i = 0; i < nb_output_streams; i++) {
708  int64_t pts = output_streams[i]->sync_opts;
709 
710  if (!output_streams[i]->filter || output_streams[i]->finished)
711  continue;
712 
713  pts = av_rescale_q(pts, output_streams[i]->st->codec->time_base,
715  if (pts < min_pts) {
716  min_pts = pts;
717  ost = output_streams[i];
718  }
719  }
720 
721  if (!ost)
722  break;
723 
724  ret = poll_filter(ost);
725 
726  if (ret == AVERROR_EOF) {
727  OutputFile *of = output_files[ost->file_index];
728 
729  ost->finished = 1;
730 
731  if (of->shortest) {
732  for (j = 0; j < of->ctx->nb_streams; j++)
733  output_streams[of->ost_index + j]->finished = 1;
734  }
735 
736  ret = 0;
737  } else if (ret == AVERROR(EAGAIN))
738  return 0;
739  }
740 
741  return ret;
742 }
743 
744 static void print_report(int is_last_report, int64_t timer_start)
745 {
746  char buf[1024];
747  OutputStream *ost;
748  AVFormatContext *oc;
749  int64_t total_size;
750  AVCodecContext *enc;
751  int frame_number, vid, i;
752  double bitrate, ti1, pts;
753  static int64_t last_time = -1;
754  static int qp_histogram[52];
755 
756  if (!print_stats && !is_last_report)
757  return;
758 
759  if (!is_last_report) {
760  int64_t cur_time;
761  /* display the report every 0.5 seconds */
762  cur_time = av_gettime();
763  if (last_time == -1) {
764  last_time = cur_time;
765  return;
766  }
767  if ((cur_time - last_time) < 500000)
768  return;
769  last_time = cur_time;
770  }
771 
772 
773  oc = output_files[0]->ctx;
774 
775  total_size = avio_size(oc->pb);
776  if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
777  total_size = avio_tell(oc->pb);
778  if (total_size < 0) {
779  char errbuf[128];
780  av_strerror(total_size, errbuf, sizeof(errbuf));
781  av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
782  "avio_tell() failed: %s\n", errbuf);
783  total_size = 0;
784  }
785 
786  buf[0] = '\0';
787  ti1 = 1e10;
788  vid = 0;
789  for (i = 0; i < nb_output_streams; i++) {
790  float q = -1;
791  ost = output_streams[i];
792  enc = ost->st->codec;
793  if (!ost->stream_copy && enc->coded_frame)
794  q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
795  if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
796  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
797  }
798  if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
799  float t = (av_gettime() - timer_start) / 1000000.0;
800 
801  frame_number = ost->frame_number;
802  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
803  frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
804  if (is_last_report)
805  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
806  if (qp_hist) {
807  int j;
808  int qp = lrintf(q);
809  if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
810  qp_histogram[qp]++;
811  for (j = 0; j < 32; j++)
812  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
813  }
814  if (enc->flags&CODEC_FLAG_PSNR) {
815  int j;
816  double error, error_sum = 0;
817  double scale, scale_sum = 0;
818  char type[3] = { 'Y','U','V' };
819  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
820  for (j = 0; j < 3; j++) {
821  if (is_last_report) {
822  error = enc->error[j];
823  scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
824  } else {
825  error = enc->coded_frame->error[j];
826  scale = enc->width * enc->height * 255.0 * 255.0;
827  }
828  if (j)
829  scale /= 4;
830  error_sum += error;
831  scale_sum += scale;
832  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
833  }
834  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
835  }
836  vid = 1;
837  }
838  /* compute min output value */
839  pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
840  if ((pts < ti1) && (pts > 0))
841  ti1 = pts;
842  }
843  if (ti1 < 0.01)
844  ti1 = 0.01;
845 
846  bitrate = (double)(total_size * 8) / ti1 / 1000.0;
847 
848  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
849  "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
850  (double)total_size / 1024, ti1, bitrate);
851 
853  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
855 
856  av_log(NULL, AV_LOG_INFO, "%s \r", buf);
857 
858  fflush(stderr);
859 
860  if (is_last_report) {
861  int64_t raw = audio_size + video_size + extra_size;
862  float percent = 0.0;
863 
864  if (raw)
865  percent = 100.0 * (total_size - raw) / raw;
866 
867  av_log(NULL, AV_LOG_INFO, "\n");
868  av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
869  video_size / 1024.0,
870  audio_size / 1024.0,
871  extra_size / 1024.0,
872  percent);
873  }
874 }
875 
876 static void flush_encoders(void)
877 {
878  int i, ret;
879 
880  for (i = 0; i < nb_output_streams; i++) {
881  OutputStream *ost = output_streams[i];
882  AVCodecContext *enc = ost->st->codec;
883  AVFormatContext *os = output_files[ost->file_index]->ctx;
884  int stop_encoding = 0;
885 
886  if (!ost->encoding_needed)
887  continue;
888 
889  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
890  continue;
892  continue;
893 
894  for (;;) {
895  int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
896  const char *desc;
897  int64_t *size;
898 
899  switch (ost->st->codec->codec_type) {
900  case AVMEDIA_TYPE_AUDIO:
901  encode = avcodec_encode_audio2;
902  desc = "Audio";
903  size = &audio_size;
904  break;
905  case AVMEDIA_TYPE_VIDEO:
906  encode = avcodec_encode_video2;
907  desc = "Video";
908  size = &video_size;
909  break;
910  default:
911  stop_encoding = 1;
912  }
913 
914  if (encode) {
915  AVPacket pkt;
916  int got_packet;
917  av_init_packet(&pkt);
918  pkt.data = NULL;
919  pkt.size = 0;
920 
921  ret = encode(enc, &pkt, NULL, &got_packet);
922  if (ret < 0) {
923  av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
924  exit_program(1);
925  }
926  *size += ret;
927  if (ost->logfile && enc->stats_out) {
928  fprintf(ost->logfile, "%s", enc->stats_out);
929  }
930  if (!got_packet) {
931  stop_encoding = 1;
932  break;
933  }
934  if (pkt.pts != AV_NOPTS_VALUE)
935  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
936  if (pkt.dts != AV_NOPTS_VALUE)
937  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
938  if (pkt.duration > 0)
939  pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
940  write_frame(os, &pkt, ost);
941  }
942 
943  if (stop_encoding)
944  break;
945  }
946  }
947 }
948 
949 /*
950  * Check whether a packet from ist should be written into ost at this time
951  */
953 {
954  OutputFile *of = output_files[ost->file_index];
955  int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
956 
957  if (ost->source_index != ist_index)
958  return 0;
959 
960  if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
961  return 0;
962 
963  return 1;
964 }
965 
966 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
967 {
968  OutputFile *of = output_files[ost->file_index];
969  InputFile *f = input_files [ist->file_index];
970  int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
971  int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
972  AVPacket opkt;
973 
974  av_init_packet(&opkt);
975 
976  if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
978  return;
979 
980  if (of->recording_time != INT64_MAX &&
981  ist->last_dts >= of->recording_time + start_time) {
982  ost->finished = 1;
983  return;
984  }
985 
986  if (f->recording_time != INT64_MAX) {
987  start_time = f->ctx->start_time;
988  if (f->start_time != AV_NOPTS_VALUE)
989  start_time += f->start_time;
990  if (ist->last_dts >= f->recording_time + start_time) {
991  ost->finished = 1;
992  return;
993  }
994  }
995 
996  /* force the input stream PTS */
997  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
998  audio_size += pkt->size;
999  else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1000  video_size += pkt->size;
1001  ost->sync_opts++;
1002  }
1003 
1004  if (pkt->pts != AV_NOPTS_VALUE)
1005  opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1006  else
1007  opkt.pts = AV_NOPTS_VALUE;
1008 
1009  if (pkt->dts == AV_NOPTS_VALUE)
1010  opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1011  else
1012  opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1013  opkt.dts -= ost_tb_start_time;
1014 
1015  opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1016  opkt.flags = pkt->flags;
1017 
1018  // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1019  if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1022  && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1023  ) {
1024  if (av_parser_change(ost->parser, ost->st->codec,
1025  &opkt.data, &opkt.size,
1026  pkt->data, pkt->size,
1027  pkt->flags & AV_PKT_FLAG_KEY)) {
1028  opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1029  if (!opkt.buf)
1030  exit_program(1);
1031  }
1032  } else {
1033  opkt.data = pkt->data;
1034  opkt.size = pkt->size;
1035  }
1036 
1037  write_frame(of->ctx, &opkt, ost);
1038  ost->st->codec->frame_number++;
1039 }
1040 
1042 {
1043  AVCodecContext *dec = ist->st->codec;
1044 
1045  if (!dec->channel_layout) {
1046  char layout_name[256];
1047 
1049  if (!dec->channel_layout)
1050  return 0;
1051  av_get_channel_layout_string(layout_name, sizeof(layout_name),
1052  dec->channels, dec->channel_layout);
1053  av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1054  "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1055  }
1056  return 1;
1057 }
1058 
1059 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1060 {
1061  AVFrame *decoded_frame, *f;
1062  AVCodecContext *avctx = ist->st->codec;
1063  int i, ret, err = 0, resample_changed;
1064 
1065  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1066  return AVERROR(ENOMEM);
1067  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1068  return AVERROR(ENOMEM);
1069  decoded_frame = ist->decoded_frame;
1070 
1071  ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1072  if (!*got_output || ret < 0) {
1073  if (!pkt->size) {
1074  for (i = 0; i < ist->nb_filters; i++)
1076  }
1077  return ret;
1078  }
1079 
1080  /* if the decoder provides a pts, use it instead of the last packet pts.
1081  the decoder could be delaying output by a packet or more. */
1082  if (decoded_frame->pts != AV_NOPTS_VALUE)
1083  ist->next_dts = decoded_frame->pts;
1084  else if (pkt->pts != AV_NOPTS_VALUE) {
1085  decoded_frame->pts = pkt->pts;
1086  pkt->pts = AV_NOPTS_VALUE;
1087  }
1088 
1089  resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1090  ist->resample_channels != avctx->channels ||
1091  ist->resample_channel_layout != decoded_frame->channel_layout ||
1092  ist->resample_sample_rate != decoded_frame->sample_rate;
1093  if (resample_changed) {
1094  char layout1[64], layout2[64];
1095 
1096  if (!guess_input_channel_layout(ist)) {
1097  av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1098  "layout for Input Stream #%d.%d\n", ist->file_index,
1099  ist->st->index);
1100  exit_program(1);
1101  }
1102  decoded_frame->channel_layout = avctx->channel_layout;
1103 
1104  av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1106  av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1107  decoded_frame->channel_layout);
1108 
1110  "Input stream #%d:%d frame changed from rate:%d fmt:%s ch:%d chl:%s to rate:%d fmt:%s ch:%d chl:%s\n",
1111  ist->file_index, ist->st->index,
1113  ist->resample_channels, layout1,
1114  decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1115  avctx->channels, layout2);
1116 
1117  ist->resample_sample_fmt = decoded_frame->format;
1118  ist->resample_sample_rate = decoded_frame->sample_rate;
1119  ist->resample_channel_layout = decoded_frame->channel_layout;
1120  ist->resample_channels = avctx->channels;
1121 
1122  for (i = 0; i < nb_filtergraphs; i++)
1123  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1124  configure_filtergraph(filtergraphs[i]) < 0) {
1125  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1126  exit_program(1);
1127  }
1128  }
1129 
1130  if (decoded_frame->pts != AV_NOPTS_VALUE)
1131  decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1132  ist->st->time_base,
1133  (AVRational){1, ist->st->codec->sample_rate});
1134  for (i = 0; i < ist->nb_filters; i++) {
1135  if (i < ist->nb_filters - 1) {
1136  f = ist->filter_frame;
1137  err = av_frame_ref(f, decoded_frame);
1138  if (err < 0)
1139  break;
1140  } else
1141  f = decoded_frame;
1142 
1143  err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1144  if (err < 0)
1145  break;
1146  }
1147 
1148  av_frame_unref(ist->filter_frame);
1149  av_frame_unref(decoded_frame);
1150  return err < 0 ? err : ret;
1151 }
1152 
1153 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1154 {
1155  AVFrame *decoded_frame, *f;
1156  int i, ret = 0, err = 0, resample_changed;
1157 
1158  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1159  return AVERROR(ENOMEM);
1160  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1161  return AVERROR(ENOMEM);
1162  decoded_frame = ist->decoded_frame;
1163 
1164  ret = avcodec_decode_video2(ist->st->codec,
1165  decoded_frame, got_output, pkt);
1166  if (!*got_output || ret < 0) {
1167  if (!pkt->size) {
1168  for (i = 0; i < ist->nb_filters; i++)
1170  }
1171  return ret;
1172  }
1173 
1174  if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
1175  err = ist->hwaccel_retrieve_data(ist->st->codec, decoded_frame);
1176  if (err < 0)
1177  goto fail;
1178  }
1179  ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
1180 
1181  decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1182  decoded_frame->pkt_dts);
1183  pkt->size = 0;
1184 
1185  if (ist->st->sample_aspect_ratio.num)
1186  decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1187 
1188  resample_changed = ist->resample_width != decoded_frame->width ||
1189  ist->resample_height != decoded_frame->height ||
1190  ist->resample_pix_fmt != decoded_frame->format;
1191  if (resample_changed) {
1193  "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1194  ist->file_index, ist->st->index,
1196  decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1197 
1198  ret = poll_filters();
1199  if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN)))
1200  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
1201 
1202  ist->resample_width = decoded_frame->width;
1203  ist->resample_height = decoded_frame->height;
1204  ist->resample_pix_fmt = decoded_frame->format;
1205 
1206  for (i = 0; i < nb_filtergraphs; i++)
1207  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1208  configure_filtergraph(filtergraphs[i]) < 0) {
1209  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1210  exit_program(1);
1211  }
1212  }
1213 
1214  for (i = 0; i < ist->nb_filters; i++) {
1215  if (i < ist->nb_filters - 1) {
1216  f = ist->filter_frame;
1217  err = av_frame_ref(f, decoded_frame);
1218  if (err < 0)
1219  break;
1220  } else
1221  f = decoded_frame;
1222 
1223  err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1224  if (err < 0)
1225  break;
1226  }
1227 
1228 fail:
1230  av_frame_unref(decoded_frame);
1231  return err < 0 ? err : ret;
1232 }
1233 
1234 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1235 {
1236  AVSubtitle subtitle;
1237  int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1238  &subtitle, got_output, pkt);
1239  if (ret < 0)
1240  return ret;
1241  if (!*got_output)
1242  return ret;
1243 
1244  for (i = 0; i < nb_output_streams; i++) {
1245  OutputStream *ost = output_streams[i];
1246 
1247  if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1248  continue;
1249 
1250  do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1251  }
1252 
1253  avsubtitle_free(&subtitle);
1254  return ret;
1255 }
1256 
1257 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1258 static int output_packet(InputStream *ist, const AVPacket *pkt)
1259 {
1260  int i;
1261  int got_output;
1262  AVPacket avpkt;
1263 
1264  if (ist->next_dts == AV_NOPTS_VALUE)
1265  ist->next_dts = ist->last_dts;
1266 
1267  if (pkt == NULL) {
1268  /* EOF handling */
1269  av_init_packet(&avpkt);
1270  avpkt.data = NULL;
1271  avpkt.size = 0;
1272  goto handle_eof;
1273  } else {
1274  avpkt = *pkt;
1275  }
1276 
1277  if (pkt->dts != AV_NOPTS_VALUE)
1278  ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1279 
1280  // while we have more to decode or while the decoder did output something on EOF
1281  while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1282  int ret = 0;
1283  handle_eof:
1284 
1285  ist->last_dts = ist->next_dts;
1286 
1287  if (avpkt.size && avpkt.size != pkt->size) {
1289  "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1290  ist->showed_multi_packet_warning = 1;
1291  }
1292 
1293  switch (ist->st->codec->codec_type) {
1294  case AVMEDIA_TYPE_AUDIO:
1295  ret = decode_audio (ist, &avpkt, &got_output);
1296  break;
1297  case AVMEDIA_TYPE_VIDEO:
1298  ret = decode_video (ist, &avpkt, &got_output);
1299  if (avpkt.duration)
1300  ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1301  else if (ist->st->avg_frame_rate.num)
1302  ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
1303  AV_TIME_BASE_Q);
1304  else if (ist->st->codec->time_base.num != 0) {
1305  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1306  ist->st->codec->ticks_per_frame;
1307  ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
1308  }
1309  break;
1310  case AVMEDIA_TYPE_SUBTITLE:
1311  ret = transcode_subtitles(ist, &avpkt, &got_output);
1312  break;
1313  default:
1314  return -1;
1315  }
1316 
1317  if (ret < 0)
1318  return ret;
1319  // touch data and size only if not EOF
1320  if (pkt) {
1321  avpkt.data += ret;
1322  avpkt.size -= ret;
1323  }
1324  if (!got_output) {
1325  continue;
1326  }
1327  }
1328 
1329  /* handle stream copy */
1330  if (!ist->decoding_needed) {
1331  ist->last_dts = ist->next_dts;
1332  switch (ist->st->codec->codec_type) {
1333  case AVMEDIA_TYPE_AUDIO:
1334  ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1335  ist->st->codec->sample_rate;
1336  break;
1337  case AVMEDIA_TYPE_VIDEO:
1338  if (ist->st->codec->time_base.num != 0) {
1339  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1340  ist->next_dts += ((int64_t)AV_TIME_BASE *
1341  ist->st->codec->time_base.num * ticks) /
1342  ist->st->codec->time_base.den;
1343  }
1344  break;
1345  }
1346  }
1347  for (i = 0; pkt && i < nb_output_streams; i++) {
1348  OutputStream *ost = output_streams[i];
1349 
1350  if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1351  continue;
1352 
1353  do_streamcopy(ist, ost, pkt);
1354  }
1355 
1356  return 0;
1357 }
1358 
1359 static void print_sdp(void)
1360 {
1361  char sdp[16384];
1362  int i;
1363  AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1364 
1365  if (!avc)
1366  exit_program(1);
1367  for (i = 0; i < nb_output_files; i++)
1368  avc[i] = output_files[i]->ctx;
1369 
1370  av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1371  printf("SDP:\n%s\n", sdp);
1372  fflush(stdout);
1373  av_freep(&avc);
1374 }
1375 
1377 {
1378  int i;
1379  for (i = 0; hwaccels[i].name; i++)
1380  if (hwaccels[i].pix_fmt == pix_fmt)
1381  return &hwaccels[i];
1382  return NULL;
1383 }
1384 
1385 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
1386 {
1387  InputStream *ist = s->opaque;
1388  const enum AVPixelFormat *p;
1389  int ret;
1390 
1391  for (p = pix_fmts; *p != -1; p++) {
1392  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
1393  const HWAccel *hwaccel;
1394 
1395  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1396  break;
1397 
1398  hwaccel = get_hwaccel(*p);
1399  if (!hwaccel ||
1400  (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
1401  (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
1402  continue;
1403 
1404  ret = hwaccel->init(s);
1405  if (ret < 0) {
1406  if (ist->hwaccel_id == hwaccel->id) {
1408  "%s hwaccel requested for input stream #%d:%d, "
1409  "but cannot be initialized.\n", hwaccel->name,
1410  ist->file_index, ist->st->index);
1411  exit_program(1);
1412  }
1413  continue;
1414  }
1415  ist->active_hwaccel_id = hwaccel->id;
1416  ist->hwaccel_pix_fmt = *p;
1417  break;
1418  }
1419 
1420  return *p;
1421 }
1422 
1423 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
1424 {
1425  InputStream *ist = s->opaque;
1426 
1427  if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
1428  return ist->hwaccel_get_buffer(s, frame, flags);
1429 
1430  return avcodec_default_get_buffer2(s, frame, flags);
1431 }
1432 
1433 static int init_input_stream(int ist_index, char *error, int error_len)
1434 {
1435  int i, ret;
1436  InputStream *ist = input_streams[ist_index];
1437  if (ist->decoding_needed) {
1438  AVCodec *codec = ist->dec;
1439  if (!codec) {
1440  snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1441  ist->st->codec->codec_id, ist->file_index, ist->st->index);
1442  return AVERROR(EINVAL);
1443  }
1444 
1445  /* update requested sample format for the decoder based on the
1446  corresponding encoder sample format */
1447  for (i = 0; i < nb_output_streams; i++) {
1448  OutputStream *ost = output_streams[i];
1449  if (ost->source_index == ist_index) {
1450  update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1451  break;
1452  }
1453  }
1454 
1455  ist->st->codec->opaque = ist;
1456  ist->st->codec->get_format = get_format;
1457  ist->st->codec->get_buffer2 = get_buffer;
1458  ist->st->codec->thread_safe_callbacks = 1;
1459 
1460  av_opt_set_int(ist->st->codec, "refcounted_frames", 1, 0);
1461 
1462  if (!av_dict_get(ist->opts, "threads", NULL, 0))
1463  av_dict_set(&ist->opts, "threads", "auto", 0);
1464  if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
1465  char errbuf[128];
1466  if (ret == AVERROR_EXPERIMENTAL)
1467  abort_codec_experimental(codec, 0);
1468 
1469  av_strerror(ret, errbuf, sizeof(errbuf));
1470 
1471  snprintf(error, error_len,
1472  "Error while opening decoder for input stream "
1473  "#%d:%d : %s",
1474  ist->file_index, ist->st->index, errbuf);
1475  return ret;
1476  }
1477  assert_avoptions(ist->opts);
1478  }
1479 
1480  ist->last_dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1481  ist->next_dts = AV_NOPTS_VALUE;
1483  ist->is_start = 1;
1484 
1485  return 0;
1486 }
1487 
1489 {
1490  if (ost->source_index >= 0)
1491  return input_streams[ost->source_index];
1492 
1493  if (ost->filter) {
1494  FilterGraph *fg = ost->filter->graph;
1495  int i;
1496 
1497  for (i = 0; i < fg->nb_inputs; i++)
1498  if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
1499  return fg->inputs[i]->ist;
1500  }
1501 
1502  return NULL;
1503 }
1504 
1505 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1506  AVCodecContext *avctx)
1507 {
1508  char *p;
1509  int n = 1, i;
1510  int64_t t;
1511 
1512  for (p = kf; *p; p++)
1513  if (*p == ',')
1514  n++;
1515  ost->forced_kf_count = n;
1516  ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1517  if (!ost->forced_kf_pts) {
1518  av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1519  exit_program(1);
1520  }
1521 
1522  p = kf;
1523  for (i = 0; i < n; i++) {
1524  char *next = strchr(p, ',');
1525 
1526  if (next)
1527  *next++ = 0;
1528 
1529  t = parse_time_or_die("force_key_frames", p, 1);
1530  ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1531 
1532  p = next;
1533  }
1534 }
1535 
1536 static int transcode_init(void)
1537 {
1538  int ret = 0, i, j, k;
1539  AVFormatContext *oc;
1540  AVCodecContext *codec;
1541  OutputStream *ost;
1542  InputStream *ist;
1543  char error[1024];
1544  int want_sdp = 1;
1545 
1546  /* init framerate emulation */
1547  for (i = 0; i < nb_input_files; i++) {
1548  InputFile *ifile = input_files[i];
1549  if (ifile->rate_emu)
1550  for (j = 0; j < ifile->nb_streams; j++)
1551  input_streams[j + ifile->ist_index]->start = av_gettime();
1552  }
1553 
1554  /* output stream init */
1555  for (i = 0; i < nb_output_files; i++) {
1556  oc = output_files[i]->ctx;
1557  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1558  av_dump_format(oc, i, oc->filename, 1);
1559  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1560  return AVERROR(EINVAL);
1561  }
1562  }
1563 
1564  /* init complex filtergraphs */
1565  for (i = 0; i < nb_filtergraphs; i++)
1566  if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
1567  return ret;
1568 
1569  /* for each output stream, we compute the right encoding parameters */
1570  for (i = 0; i < nb_output_streams; i++) {
1571  AVCodecContext *icodec = NULL;
1572  ost = output_streams[i];
1573  oc = output_files[ost->file_index]->ctx;
1574  ist = get_input_stream(ost);
1575 
1576  if (ost->attachment_filename)
1577  continue;
1578 
1579  codec = ost->st->codec;
1580 
1581  if (ist) {
1582  icodec = ist->st->codec;
1583 
1584  ost->st->disposition = ist->st->disposition;
1585  codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
1587  }
1588 
1589  if (ost->stream_copy) {
1590  AVRational sar;
1591  uint64_t extra_size;
1592 
1593  av_assert0(ist && !ost->filter);
1594 
1595  extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1596 
1597  if (extra_size > INT_MAX) {
1598  return AVERROR(EINVAL);
1599  }
1600 
1601  /* if stream_copy is selected, no need to decode or encode */
1602  codec->codec_id = icodec->codec_id;
1603  codec->codec_type = icodec->codec_type;
1604 
1605  if (!codec->codec_tag) {
1606  if (!oc->oformat->codec_tag ||
1607  av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
1608  av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
1609  codec->codec_tag = icodec->codec_tag;
1610  }
1611 
1612  codec->bit_rate = icodec->bit_rate;
1613  codec->rc_max_rate = icodec->rc_max_rate;
1614  codec->rc_buffer_size = icodec->rc_buffer_size;
1615  codec->field_order = icodec->field_order;
1616  codec->extradata = av_mallocz(extra_size);
1617  if (!codec->extradata) {
1618  return AVERROR(ENOMEM);
1619  }
1620  memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1621  codec->extradata_size = icodec->extradata_size;
1622  if (!copy_tb) {
1623  codec->time_base = icodec->time_base;
1624  codec->time_base.num *= icodec->ticks_per_frame;
1625  av_reduce(&codec->time_base.num, &codec->time_base.den,
1626  codec->time_base.num, codec->time_base.den, INT_MAX);
1627  } else
1628  codec->time_base = ist->st->time_base;
1629 
1630  ost->parser = av_parser_init(codec->codec_id);
1631 
1632  switch (codec->codec_type) {
1633  case AVMEDIA_TYPE_AUDIO:
1634  if (audio_volume != 256) {
1635  av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1636  exit_program(1);
1637  }
1638  codec->channel_layout = icodec->channel_layout;
1639  codec->sample_rate = icodec->sample_rate;
1640  codec->channels = icodec->channels;
1641  codec->frame_size = icodec->frame_size;
1642  codec->audio_service_type = icodec->audio_service_type;
1643  codec->block_align = icodec->block_align;
1644  break;
1645  case AVMEDIA_TYPE_VIDEO:
1646  codec->pix_fmt = icodec->pix_fmt;
1647  codec->width = icodec->width;
1648  codec->height = icodec->height;
1649  codec->has_b_frames = icodec->has_b_frames;
1650  if (ost->frame_aspect_ratio)
1651  sar = av_d2q(ost->frame_aspect_ratio * codec->height / codec->width, 255);
1652  else if (ist->st->sample_aspect_ratio.num)
1653  sar = ist->st->sample_aspect_ratio;
1654  else
1655  sar = icodec->sample_aspect_ratio;
1656  ost->st->sample_aspect_ratio = codec->sample_aspect_ratio = sar;
1657  break;
1658  case AVMEDIA_TYPE_SUBTITLE:
1659  codec->width = icodec->width;
1660  codec->height = icodec->height;
1661  break;
1662  case AVMEDIA_TYPE_DATA:
1664  break;
1665  default:
1666  abort();
1667  }
1668  } else {
1669  if (!ost->enc) {
1670  /* should only happen when a default codec is not present. */
1671  snprintf(error, sizeof(error), "Automatic encoder selection "
1672  "failed for output stream #%d:%d. Default encoder for "
1673  "format %s is probably disabled. Please choose an "
1674  "encoder manually.\n", ost->file_index, ost->index,
1675  oc->oformat->name);
1676  ret = AVERROR(EINVAL);
1677  goto dump_format;
1678  }
1679 
1680  if (ist)
1681  ist->decoding_needed = 1;
1682  ost->encoding_needed = 1;
1683 
1684  /*
1685  * We want CFR output if and only if one of those is true:
1686  * 1) user specified output framerate with -r
1687  * 2) user specified -vsync cfr
1688  * 3) output format is CFR and the user didn't force vsync to
1689  * something else than CFR
1690  *
1691  * in such a case, set ost->frame_rate
1692  */
1693  if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1694  !ost->frame_rate.num && ist &&
1698  if (ist->framerate.num)
1699  ost->frame_rate = ist->framerate;
1700  else if (ist->st->avg_frame_rate.num)
1701  ost->frame_rate = ist->st->avg_frame_rate;
1702  else {
1703  av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1704  "for the output stream #%d:%d, but no information "
1705  "about the input framerate is available. Falling "
1706  "back to a default value of 25fps. Use the -r option "
1707  "if you want a different framerate.\n",
1708  ost->file_index, ost->index);
1709  ost->frame_rate = (AVRational){ 25, 1 };
1710  }
1711 
1712  if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
1714  ost->frame_rate = ost->enc->supported_framerates[idx];
1715  }
1716  }
1717 
1718  if (!ost->filter &&
1719  (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
1720  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
1721  FilterGraph *fg;
1722  fg = init_simple_filtergraph(ist, ost);
1723  if (configure_filtergraph(fg)) {
1724  av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
1725  exit_program(1);
1726  }
1727  }
1728 
1729  switch (codec->codec_type) {
1730  case AVMEDIA_TYPE_AUDIO:
1731  codec->sample_fmt = ost->filter->filter->inputs[0]->format;
1732  codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
1733  codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1735  codec->time_base = (AVRational){ 1, codec->sample_rate };
1736  break;
1737  case AVMEDIA_TYPE_VIDEO:
1738  codec->time_base = ost->filter->filter->inputs[0]->time_base;
1739 
1740  codec->width = ost->filter->filter->inputs[0]->w;
1741  codec->height = ost->filter->filter->inputs[0]->h;
1742  codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
1743  ost->frame_aspect_ratio ? // overridden by the -aspect cli option
1744  av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
1746  codec->pix_fmt = ost->filter->filter->inputs[0]->format;
1747 
1748  if (icodec &&
1749  (codec->width != icodec->width ||
1750  codec->height != icodec->height ||
1751  codec->pix_fmt != icodec->pix_fmt)) {
1752  codec->bits_per_raw_sample = 0;
1753  }
1754 
1755  if (ost->forced_keyframes)
1757  ost->st->codec);
1758  break;
1759  case AVMEDIA_TYPE_SUBTITLE:
1760  codec->time_base = (AVRational){1, 1000};
1761  break;
1762  default:
1763  abort();
1764  break;
1765  }
1766  /* two pass mode */
1767  if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1768  char logfilename[1024];
1769  FILE *f;
1770 
1771  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1772  ost->logfile_prefix ? ost->logfile_prefix :
1774  i);
1775  if (!strcmp(ost->enc->name, "libx264")) {
1776  av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1777  } else {
1778  if (codec->flags & CODEC_FLAG_PASS1) {
1779  f = fopen(logfilename, "wb");
1780  if (!f) {
1781  av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1782  logfilename, strerror(errno));
1783  exit_program(1);
1784  }
1785  ost->logfile = f;
1786  } else {
1787  char *logbuffer;
1788  size_t logbuffer_size;
1789  if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
1790  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1791  logfilename);
1792  exit_program(1);
1793  }
1794  codec->stats_in = logbuffer;
1795  }
1796  }
1797  }
1798  }
1799  }
1800 
1801  /* open each encoder */
1802  for (i = 0; i < nb_output_streams; i++) {
1803  ost = output_streams[i];
1804  if (ost->encoding_needed) {
1805  AVCodec *codec = ost->enc;
1806  AVCodecContext *dec = NULL;
1807 
1808  if ((ist = get_input_stream(ost)))
1809  dec = ist->st->codec;
1810  if (dec && dec->subtitle_header) {
1812  if (!ost->st->codec->subtitle_header) {
1813  ret = AVERROR(ENOMEM);
1814  goto dump_format;
1815  }
1816  memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
1818  }
1819  if (!av_dict_get(ost->opts, "threads", NULL, 0))
1820  av_dict_set(&ost->opts, "threads", "auto", 0);
1821  if ((ret = avcodec_open2(ost->st->codec, codec, &ost->opts)) < 0) {
1822  if (ret == AVERROR_EXPERIMENTAL)
1823  abort_codec_experimental(codec, 1);
1824  snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1825  ost->file_index, ost->index);
1826  goto dump_format;
1827  }
1828  assert_avoptions(ost->opts);
1829  if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
1830  av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
1831  "It takes bits/s as argument, not kbits/s\n");
1832  extra_size += ost->st->codec->extradata_size;
1833  } else {
1834  av_opt_set_dict(ost->st->codec, &ost->opts);
1835  }
1836  }
1837 
1838  /* init input streams */
1839  for (i = 0; i < nb_input_streams; i++)
1840  if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
1841  goto dump_format;
1842 
1843  /* discard unused programs */
1844  for (i = 0; i < nb_input_files; i++) {
1845  InputFile *ifile = input_files[i];
1846  for (j = 0; j < ifile->ctx->nb_programs; j++) {
1847  AVProgram *p = ifile->ctx->programs[j];
1848  int discard = AVDISCARD_ALL;
1849 
1850  for (k = 0; k < p->nb_stream_indexes; k++)
1851  if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
1852  discard = AVDISCARD_DEFAULT;
1853  break;
1854  }
1855  p->discard = discard;
1856  }
1857  }
1858 
1859  /* open files and write file headers */
1860  for (i = 0; i < nb_output_files; i++) {
1861  oc = output_files[i]->ctx;
1862  oc->interrupt_callback = int_cb;
1863  if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
1864  char errbuf[128];
1865  av_strerror(ret, errbuf, sizeof(errbuf));
1866  snprintf(error, sizeof(error),
1867  "Could not write header for output file #%d "
1868  "(incorrect codec parameters ?): %s",
1869  i, errbuf);
1870  ret = AVERROR(EINVAL);
1871  goto dump_format;
1872  }
1873  assert_avoptions(output_files[i]->opts);
1874  if (strcmp(oc->oformat->name, "rtp")) {
1875  want_sdp = 0;
1876  }
1877  }
1878 
1879  dump_format:
1880  /* dump the file output parameters - cannot be done before in case
1881  of stream copy */
1882  for (i = 0; i < nb_output_files; i++) {
1883  av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
1884  }
1885 
1886  /* dump the stream mapping */
1887  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
1888  for (i = 0; i < nb_input_streams; i++) {
1889  ist = input_streams[i];
1890 
1891  for (j = 0; j < ist->nb_filters; j++) {
1892  if (ist->filters[j]->graph->graph_desc) {
1893  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
1894  ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
1895  ist->filters[j]->name);
1896  if (nb_filtergraphs > 1)
1897  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
1898  av_log(NULL, AV_LOG_INFO, "\n");
1899  }
1900  }
1901  }
1902 
1903  for (i = 0; i < nb_output_streams; i++) {
1904  ost = output_streams[i];
1905 
1906  if (ost->attachment_filename) {
1907  /* an attached file */
1908  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
1909  ost->attachment_filename, ost->file_index, ost->index);
1910  continue;
1911  }
1912 
1913  if (ost->filter && ost->filter->graph->graph_desc) {
1914  /* output from a complex graph */
1915  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
1916  if (nb_filtergraphs > 1)
1917  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
1918 
1919  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
1920  ost->index, ost->enc ? ost->enc->name : "?");
1921  continue;
1922  }
1923 
1924  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
1925  input_streams[ost->source_index]->file_index,
1926  input_streams[ost->source_index]->st->index,
1927  ost->file_index,
1928  ost->index);
1929  if (ost->sync_ist != input_streams[ost->source_index])
1930  av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
1931  ost->sync_ist->file_index,
1932  ost->sync_ist->st->index);
1933  if (ost->stream_copy)
1934  av_log(NULL, AV_LOG_INFO, " (copy)");
1935  else
1936  av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
1937  input_streams[ost->source_index]->dec->name : "?",
1938  ost->enc ? ost->enc->name : "?");
1939  av_log(NULL, AV_LOG_INFO, "\n");
1940  }
1941 
1942  if (ret) {
1943  av_log(NULL, AV_LOG_ERROR, "%s\n", error);
1944  return ret;
1945  }
1946 
1947  if (want_sdp) {
1948  print_sdp();
1949  }
1950 
1951  return 0;
1952 }
1953 
1954 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
1955 static int need_output(void)
1956 {
1957  int i;
1958 
1959  for (i = 0; i < nb_output_streams; i++) {
1960  OutputStream *ost = output_streams[i];
1961  OutputFile *of = output_files[ost->file_index];
1962  AVFormatContext *os = output_files[ost->file_index]->ctx;
1963 
1964  if (ost->finished ||
1965  (os->pb && avio_tell(os->pb) >= of->limit_filesize))
1966  continue;
1967  if (ost->frame_number >= ost->max_frames) {
1968  int j;
1969  for (j = 0; j < of->ctx->nb_streams; j++)
1970  output_streams[of->ost_index + j]->finished = 1;
1971  continue;
1972  }
1973 
1974  return 1;
1975  }
1976 
1977  return 0;
1978 }
1979 
1981 {
1982  InputFile *ifile = NULL;
1983  int64_t ipts_min = INT64_MAX;
1984  int i;
1985 
1986  for (i = 0; i < nb_input_streams; i++) {
1987  InputStream *ist = input_streams[i];
1988  int64_t ipts = ist->last_dts;
1989 
1990  if (ist->discard || input_files[ist->file_index]->eagain)
1991  continue;
1992  if (!input_files[ist->file_index]->eof_reached) {
1993  if (ipts < ipts_min) {
1994  ipts_min = ipts;
1995  ifile = input_files[ist->file_index];
1996  }
1997  }
1998  }
1999 
2000  return ifile;
2001 }
2002 
2003 #if HAVE_PTHREADS
2004 static void *input_thread(void *arg)
2005 {
2006  InputFile *f = arg;
2007  int ret = 0;
2008 
2009  while (!transcoding_finished && ret >= 0) {
2010  AVPacket pkt;
2011  ret = av_read_frame(f->ctx, &pkt);
2012 
2013  if (ret == AVERROR(EAGAIN)) {
2014  av_usleep(10000);
2015  ret = 0;
2016  continue;
2017  } else if (ret < 0)
2018  break;
2019 
2020  pthread_mutex_lock(&f->fifo_lock);
2021  while (!av_fifo_space(f->fifo))
2022  pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2023 
2024  av_dup_packet(&pkt);
2025  av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2026 
2027  pthread_mutex_unlock(&f->fifo_lock);
2028  }
2029 
2030  f->finished = 1;
2031  return NULL;
2032 }
2033 
2034 static void free_input_threads(void)
2035 {
2036  int i;
2037 
2038  if (nb_input_files == 1)
2039  return;
2040 
2041  transcoding_finished = 1;
2042 
2043  for (i = 0; i < nb_input_files; i++) {
2044  InputFile *f = input_files[i];
2045  AVPacket pkt;
2046 
2047  if (!f->fifo || f->joined)
2048  continue;
2049 
2050  pthread_mutex_lock(&f->fifo_lock);
2051  while (av_fifo_size(f->fifo)) {
2052  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2053  av_free_packet(&pkt);
2054  }
2055  pthread_cond_signal(&f->fifo_cond);
2056  pthread_mutex_unlock(&f->fifo_lock);
2057 
2058  pthread_join(f->thread, NULL);
2059  f->joined = 1;
2060 
2061  while (av_fifo_size(f->fifo)) {
2062  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2063  av_free_packet(&pkt);
2064  }
2065  av_fifo_free(f->fifo);
2066  }
2067 }
2068 
2069 static int init_input_threads(void)
2070 {
2071  int i, ret;
2072 
2073  if (nb_input_files == 1)
2074  return 0;
2075 
2076  for (i = 0; i < nb_input_files; i++) {
2077  InputFile *f = input_files[i];
2078 
2079  if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2080  return AVERROR(ENOMEM);
2081 
2082  pthread_mutex_init(&f->fifo_lock, NULL);
2083  pthread_cond_init (&f->fifo_cond, NULL);
2084 
2085  if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2086  return AVERROR(ret);
2087  }
2088  return 0;
2089 }
2090 
2091 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2092 {
2093  int ret = 0;
2094 
2095  pthread_mutex_lock(&f->fifo_lock);
2096 
2097  if (av_fifo_size(f->fifo)) {
2098  av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2099  pthread_cond_signal(&f->fifo_cond);
2100  } else {
2101  if (f->finished)
2102  ret = AVERROR_EOF;
2103  else
2104  ret = AVERROR(EAGAIN);
2105  }
2106 
2107  pthread_mutex_unlock(&f->fifo_lock);
2108 
2109  return ret;
2110 }
2111 #endif
2112 
2114 {
2115  if (f->rate_emu) {
2116  int i;
2117  for (i = 0; i < f->nb_streams; i++) {
2118  InputStream *ist = input_streams[f->ist_index + i];
2119  int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2120  int64_t now = av_gettime() - ist->start;
2121  if (pts > now)
2122  return AVERROR(EAGAIN);
2123  }
2124  }
2125 
2126 #if HAVE_PTHREADS
2127  if (nb_input_files > 1)
2128  return get_input_packet_mt(f, pkt);
2129 #endif
2130  return av_read_frame(f->ctx, pkt);
2131 }
2132 
2133 static int got_eagain(void)
2134 {
2135  int i;
2136  for (i = 0; i < nb_input_files; i++)
2137  if (input_files[i]->eagain)
2138  return 1;
2139  return 0;
2140 }
2141 
2142 static void reset_eagain(void)
2143 {
2144  int i;
2145  for (i = 0; i < nb_input_files; i++)
2146  input_files[i]->eagain = 0;
2147 }
2148 
2149 /*
2150  * Read one packet from an input file and send it for
2151  * - decoding -> lavfi (audio/video)
2152  * - decoding -> encoding -> muxing (subtitles)
2153  * - muxing (streamcopy)
2154  *
2155  * Return
2156  * - 0 -- one packet was read and processed
2157  * - AVERROR(EAGAIN) -- no packets were available for selected file,
2158  * this function should be called again
2159  * - AVERROR_EOF -- this function should not be called again
2160  */
2161 static int process_input(void)
2162 {
2163  InputFile *ifile;
2164  AVFormatContext *is;
2165  InputStream *ist;
2166  AVPacket pkt;
2167  int ret, i, j;
2168 
2169  /* select the stream that we must read now */
2170  ifile = select_input_file();
2171  /* if none, if is finished */
2172  if (!ifile) {
2173  if (got_eagain()) {
2174  reset_eagain();
2175  av_usleep(10000);
2176  return AVERROR(EAGAIN);
2177  }
2178  av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
2179  return AVERROR_EOF;
2180  }
2181 
2182  is = ifile->ctx;
2183  ret = get_input_packet(ifile, &pkt);
2184 
2185  if (ret == AVERROR(EAGAIN)) {
2186  ifile->eagain = 1;
2187  return ret;
2188  }
2189  if (ret < 0) {
2190  if (ret != AVERROR_EOF) {
2191  print_error(is->filename, ret);
2192  if (exit_on_error)
2193  exit_program(1);
2194  }
2195  ifile->eof_reached = 1;
2196 
2197  for (i = 0; i < ifile->nb_streams; i++) {
2198  ist = input_streams[ifile->ist_index + i];
2199  if (ist->decoding_needed)
2200  output_packet(ist, NULL);
2201 
2202  /* mark all outputs that don't go through lavfi as finished */
2203  for (j = 0; j < nb_output_streams; j++) {
2204  OutputStream *ost = output_streams[j];
2205 
2206  if (ost->source_index == ifile->ist_index + i &&
2207  (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2208  ost->finished= 1;
2209  }
2210  }
2211 
2212  return AVERROR(EAGAIN);
2213  }
2214 
2215  reset_eagain();
2216 
2217  if (do_pkt_dump) {
2219  is->streams[pkt.stream_index]);
2220  }
2221  /* the following test is needed in case new streams appear
2222  dynamically in stream : we ignore them */
2223  if (pkt.stream_index >= ifile->nb_streams)
2224  goto discard_packet;
2225 
2226  ist = input_streams[ifile->ist_index + pkt.stream_index];
2227  if (ist->discard)
2228  goto discard_packet;
2229 
2230  if (pkt.dts != AV_NOPTS_VALUE)
2231  pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2232  if (pkt.pts != AV_NOPTS_VALUE)
2233  pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2234 
2235  if (pkt.pts != AV_NOPTS_VALUE)
2236  pkt.pts *= ist->ts_scale;
2237  if (pkt.dts != AV_NOPTS_VALUE)
2238  pkt.dts *= ist->ts_scale;
2239 
2240  if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
2241  (is->iformat->flags & AVFMT_TS_DISCONT)) {
2242  int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2243  int64_t delta = pkt_dts - ist->next_dts;
2244 
2245  if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2246  ifile->ts_offset -= delta;
2248  "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2249  delta, ifile->ts_offset);
2250  pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2251  if (pkt.pts != AV_NOPTS_VALUE)
2252  pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2253  }
2254  }
2255 
2256  ret = output_packet(ist, &pkt);
2257  if (ret < 0) {
2258  av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2259  ist->file_index, ist->st->index);
2260  if (exit_on_error)
2261  exit_program(1);
2262  }
2263 
2264 discard_packet:
2265  av_free_packet(&pkt);
2266 
2267  return 0;
2268 }
2269 
2270 /*
2271  * The following code is the main loop of the file converter
2272  */
2273 static int transcode(void)
2274 {
2275  int ret, i, need_input = 1;
2276  AVFormatContext *os;
2277  OutputStream *ost;
2278  InputStream *ist;
2279  int64_t timer_start;
2280 
2281  ret = transcode_init();
2282  if (ret < 0)
2283  goto fail;
2284 
2285  av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2286  term_init();
2287 
2288  timer_start = av_gettime();
2289 
2290 #if HAVE_PTHREADS
2291  if ((ret = init_input_threads()) < 0)
2292  goto fail;
2293 #endif
2294 
2295  while (!received_sigterm) {
2296  /* check if there's any stream where output is still needed */
2297  if (!need_output()) {
2298  av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2299  break;
2300  }
2301 
2302  /* read and process one input packet if needed */
2303  if (need_input) {
2304  ret = process_input();
2305  if (ret == AVERROR_EOF)
2306  need_input = 0;
2307  }
2308 
2309  ret = poll_filters();
2310  if (ret < 0) {
2311  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
2312  continue;
2313 
2314  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
2315  break;
2316  }
2317 
2318  /* dump report by using the output first video and audio streams */
2319  print_report(0, timer_start);
2320  }
2321 #if HAVE_PTHREADS
2322  free_input_threads();
2323 #endif
2324 
2325  /* at the end of stream, we must flush the decoder buffers */
2326  for (i = 0; i < nb_input_streams; i++) {
2327  ist = input_streams[i];
2328  if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2329  output_packet(ist, NULL);
2330  }
2331  }
2332  poll_filters();
2333  flush_encoders();
2334 
2335  term_exit();
2336 
2337  /* write the trailer if needed and close file */
2338  for (i = 0; i < nb_output_files; i++) {
2339  os = output_files[i]->ctx;
2340  av_write_trailer(os);
2341  }
2342 
2343  /* dump report by using the first video and audio streams */
2344  print_report(1, timer_start);
2345 
2346  /* close each encoder */
2347  for (i = 0; i < nb_output_streams; i++) {
2348  ost = output_streams[i];
2349  if (ost->encoding_needed) {
2350  av_freep(&ost->st->codec->stats_in);
2351  avcodec_close(ost->st->codec);
2352  }
2353  }
2354 
2355  /* close each decoder */
2356  for (i = 0; i < nb_input_streams; i++) {
2357  ist = input_streams[i];
2358  if (ist->decoding_needed) {
2359  avcodec_close(ist->st->codec);
2360  if (ist->hwaccel_uninit)
2361  ist->hwaccel_uninit(ist->st->codec);
2362  }
2363  }
2364 
2365  /* finished ! */
2366  ret = 0;
2367 
2368  fail:
2369 #if HAVE_PTHREADS
2370  free_input_threads();
2371 #endif
2372 
2373  if (output_streams) {
2374  for (i = 0; i < nb_output_streams; i++) {
2375  ost = output_streams[i];
2376  if (ost) {
2377  if (ost->stream_copy)
2378  av_freep(&ost->st->codec->extradata);
2379  if (ost->logfile) {
2380  fclose(ost->logfile);
2381  ost->logfile = NULL;
2382  }
2383  av_freep(&ost->st->codec->subtitle_header);
2384  av_free(ost->forced_kf_pts);
2385  av_dict_free(&ost->opts);
2386  av_dict_free(&ost->resample_opts);
2387  }
2388  }
2389  }
2390  return ret;
2391 }
2392 
2393 static int64_t getutime(void)
2394 {
2395 #if HAVE_GETRUSAGE
2396  struct rusage rusage;
2397 
2398  getrusage(RUSAGE_SELF, &rusage);
2399  return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2400 #elif HAVE_GETPROCESSTIMES
2401  HANDLE proc;
2402  FILETIME c, e, k, u;
2403  proc = GetCurrentProcess();
2404  GetProcessTimes(proc, &c, &e, &k, &u);
2405  return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2406 #else
2407  return av_gettime();
2408 #endif
2409 }
2410 
2411 static int64_t getmaxrss(void)
2412 {
2413 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2414  struct rusage rusage;
2415  getrusage(RUSAGE_SELF, &rusage);
2416  return (int64_t)rusage.ru_maxrss * 1024;
2417 #elif HAVE_GETPROCESSMEMORYINFO
2418  HANDLE proc;
2419  PROCESS_MEMORY_COUNTERS memcounters;
2420  proc = GetCurrentProcess();
2421  memcounters.cb = sizeof(memcounters);
2422  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2423  return memcounters.PeakPagefileUsage;
2424 #else
2425  return 0;
2426 #endif
2427 }
2428 
2429 int main(int argc, char **argv)
2430 {
2431  int ret;
2432  int64_t ti;
2433 
2435 
2437  parse_loglevel(argc, argv, options);
2438 
2440 #if CONFIG_AVDEVICE
2442 #endif
2444  av_register_all();
2446 
2447  show_banner();
2448 
2449  /* parse options and open all input/output files */
2450  ret = avconv_parse_options(argc, argv);
2451  if (ret < 0)
2452  exit_program(1);
2453 
2454  if (nb_output_files <= 0 && nb_input_files == 0) {
2455  show_usage();
2456  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
2457  exit_program(1);
2458  }
2459 
2460  /* file converter / grab */
2461  if (nb_output_files <= 0) {
2462  fprintf(stderr, "At least one output file must be specified\n");
2463  exit_program(1);
2464  }
2465 
2466  ti = getutime();
2467  if (transcode() < 0)
2468  exit_program(1);
2469  ti = getutime() - ti;
2470  if (do_benchmark) {
2471  int maxrss = getmaxrss() / 1024;
2472  printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
2473  }
2474 
2475  exit_program(0);
2476  return 0;
2477 }
uint64_t av_get_default_channel_layout(int nb_channels)
Return default channel layout for a given number of channels.
int nb_input_files
Definition: avconv.c:105
static int need_output(void)
Definition: avconv.c:1955
int frame_number
Definition: avconv.h:294
const struct AVCodec * codec
Definition: avcodec.h:1063
void * av_malloc(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:62
static int transcode_init(void)
Definition: avconv.c:1536
enum HWAccelID active_hwaccel_id
Definition: avconv.h:256
static int check_output_constraints(InputStream *ist, OutputStream *ost)
Definition: avconv.c:952
static int pthread_cond_wait(pthread_cond_t *cond, pthread_mutex_t *mutex)
Definition: w32pthreads.h:207
int64_t recording_time
Definition: avconv.h:346
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:241
int nb_input_streams
Definition: avconv.c:103
uint8_t * name
Definition: avconv.h:197
#define VSYNC_AUTO
Definition: avconv.h:46
int nb_outputs
Definition: avconv.h:212
int size
void av_free_packet(AVPacket *pkt)
Free a packet.
Definition: avpacket.c:242
const AVPixFmtDescriptor * av_pix_fmt_desc_get(enum AVPixelFormat pix_fmt)
Definition: pixdesc.c:1507
static int got_eagain(void)
Definition: avconv.c:2133
int resample_channels
Definition: avconv.h:243
This structure describes decoded (raw) audio or video data.
Definition: frame.h:107
static void pthread_join(pthread_t thread, void **value_ptr)
Definition: w32pthreads.h:94
int stream_copy
Definition: avconv.h:333
AVCodec * avcodec_find_encoder(enum AVCodecID id)
Find a registered encoder with a matching codec ID.
Definition: utils.c:1654
int av_interleaved_write_frame(AVFormatContext *s, AVPacket *pkt)
Write a packet to an output media file ensuring correct interleaving.
Definition: mux.c:616
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1097
AVRational frame_rate
Definition: avconv.h:311
int64_t * forced_kf_pts
Definition: avconv.h:318
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: avcodec.h:2436
#define CODEC_FLAG_PASS2
Use internal 2pass ratecontrol in second pass mode.
Definition: avcodec.h:669
#define CODEC_CAP_VARIABLE_FRAME_SIZE
Audio encoder supports receiving a different number of samples in each call.
Definition: avcodec.h:798
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:302
misc image utilities
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:129
static const AVFilterPad outputs[]
Definition: af_ashowinfo.c:122
static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
Definition: avconv.c:1059
Main libavfilter public API header.
static void flush_encoders(void)
Definition: avconv.c:876
AVStream * st
Definition: avconv.h:292
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:69
#define CODEC_FLAG_PASS1
Use internal 2pass ratecontrol in first pass mode.
Definition: avcodec.h:668
Memory buffer source API.
AVFrame * coded_frame
the picture in the bitstream
Definition: avcodec.h:2506
void show_banner(void)
Print the program banner to stderr.
Definition: cmdutils.c:815
AVRational framerate
Definition: avconv.h:235
int avfilter_graph_config(AVFilterGraph *graphctx, void *log_ctx)
Check validity and configure all the links and formats in the graph.
static void term_exit(void)
Definition: avconv.c:115
PtsCorrectionContext pts_ctx
Definition: avconv.h:230
static int64_t cur_time
Definition: avserver.c:318
static int nb_frames_drop
Definition: avconv.c:91
int ist_in_filtergraph(FilterGraph *fg, InputStream *ist)
AVCodecParserContext * parser
Definition: avconv.h:339
int decoding_needed
Definition: avconv.h:219
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:747
int num
numerator
Definition: rational.h:44
int index
stream index in AVFormatContext
Definition: avformat.h:684
int size
Definition: avcodec.h:974
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:1422
int eagain
Definition: avconv.h:268
void avfilter_graph_free(AVFilterGraph **graph)
Free a graph, destroy its links, and set *graph to NULL.
enum AVPixelFormat pix_fmt
Pixel format, see AV_PIX_FMT_xxx.
Definition: avcodec.h:1247
AVBitStreamFilterContext * bitstream_filters
Definition: avconv.h:305
AVFrame * filter_frame
Definition: avconv.h:222
FilterGraph * init_simple_filtergraph(InputStream *ist, OutputStream *ost)
char * stats_in
pass2 encoding statistics input buffer Concatenated stuff from stats_out of pass1 should be placed he...
Definition: avcodec.h:2286
void avdevice_register_all(void)
Initialize libavdevice and register all the input and output devices.
Definition: alldevices.c:41
FilterGraph ** filtergraphs
Definition: avconv.c:112
enum AVMediaType type
Definition: avcodec.h:2768
int copy_ts
Definition: avconv_opt.c:74
#define FF_ARRAY_ELEMS(a)
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:54
int print_stats
Definition: avconv_opt.c:77
discard all
Definition: avcodec.h:546
int(* hwaccel_get_buffer)(AVCodecContext *s, AVFrame *frame, int flags)
Definition: avconv.h:259
int avcodec_encode_audio2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of audio.
Definition: utils.c:1194
int bits_per_raw_sample
Bits per sample/pixel of internal libavcodec pixel/sample format.
Definition: avcodec.h:2488
void avcodec_register_all(void)
Register all the codecs, parsers and bitstream filters which were enabled at configuration time...
Definition: allcodecs.c:68
const char * name
Definition: avconv.h:58
int avcodec_decode_subtitle2(AVCodecContext *avctx, AVSubtitle *sub, int *got_sub_ptr, AVPacket *avpkt)
Decode a subtitle message.
Definition: utils.c:1557
AVDictionaryEntry * av_dict_get(AVDictionary *m, const char *key, const AVDictionaryEntry *prev, int flags)
Get a dictionary entry with matching key.
Definition: dict.c:39
int av_dup_packet(AVPacket *pkt)
Definition: avpacket.c:189
four components are given, that's all.
Definition: avcodec.h:2950
static volatile int received_sigterm
Definition: avconv.c:120
AVCodec.
Definition: avcodec.h:2755
int block_align
number of bytes per packet if constant and known or 0 Used by some WAV based audio codecs...
Definition: avcodec.h:1816
#define AVFMT_TS_NONSTRICT
Format does not require strictly increasing timestamps, but they must still be monotonic.
Definition: avformat.h:417
int64_t start_time
Definition: avconv.h:347
void init_pts_correction(PtsCorrectionContext *ctx)
Reset the state of the PtsCorrectionContext.
Definition: cmdutils.c:1427
int index
Definition: avconv.h:204
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:84
int64_t last_dts
Definition: avconv.h:229
int video_sync_method
Definition: avconv_opt.c:70
#define log2(x)
Definition: libm.h:111
struct FilterGraph * graph
Definition: avconv.h:189
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avcodec.h:1173
void av_freep(void *arg)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc() and set the pointer ...
Definition: mem.c:198
float dts_delta_threshold
Definition: avconv_opt.c:66
enum AVAudioServiceType audio_service_type
Type of service that the audio stream conveys.
Definition: avcodec.h:1854
int encoding_needed
Definition: avconv.h:293
Format I/O context.
Definition: avformat.h:871
memory buffer sink API
struct InputStream * ist
Definition: avconv.h:188
unsigned int nb_stream_indexes
Definition: avformat.h:846
#define AV_LOG_QUIET
Print no output.
Definition: log.h:105
enum HWAccelID id
Definition: avconv.h:60
#define CODEC_FLAG_PSNR
error[?] variables will be set during encoding.
Definition: avcodec.h:678
AVFilterLink ** inputs
array of pointers to input links
Definition: avfilter.h:571
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
Public dictionary API.
char * logfile_prefix
Definition: avconv.h:323
int copy_initial_nonkeyframes
Definition: avconv.h:335
static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
Definition: avconv.c:966
void register_exit(void(*cb)(int ret))
Register a program-specific cleanup routine.
Definition: cmdutils.c:89
enum AVSampleFormat sample_fmt
audio sample format
Definition: avcodec.h:1787
int flags
can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_RAWPICTURE, AVFMT_GLOBALHEADER, AVFMT_NOTIMESTAMPS, AVFMT_VARIABLE_FPS, AVFMT_NODIMENSIONS, AVFMT_NOSTREAMS, AVFMT_ALLOW_FLUSH, AVFMT_TS_NONSTRICT
Definition: avformat.h:456
uint8_t
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:43
Opaque data information usually continuous.
Definition: avutil.h:189
static void pthread_cond_init(pthread_cond_t *cond, const void *unused_attr)
Definition: w32pthreads.h:136
int av_parser_change(AVCodecParserContext *s, AVCodecContext *avctx, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
Definition: parser.c:174
float delta
static void write_frame(AVFormatContext *s, AVPacket *pkt, OutputStream *ost)
Definition: avconv.c:309
AVOptions.
int subtitle_header_size
Definition: avcodec.h:2712
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.
Definition: avformat.h:530
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.
InputFile ** input_files
Definition: avconv.c:104
int is_start
Definition: avconv.h:232
FILE * logfile
Definition: avconv.h:324
#define VSYNC_PASSTHROUGH
Definition: avconv.h:47
AVDictionary * opts
Definition: avconv.h:330
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:174
int64_t pts
Presentation timestamp in time_base units (time when frame should be shown to user).
Definition: frame.h:183
uint8_t * extradata
some codecs need / can use extradata like Huffman tables.
Definition: avcodec.h:1162
const char * name
int shortest
Definition: avconv.h:350
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:935
int avcodec_encode_video2(AVCodecContext *avctx, AVPacket *avpkt, const AVFrame *frame, int *got_packet_ptr)
Encode a frame of video.
Definition: utils.c:1292
void avfilter_register_all(void)
Initialize the filter system.
Definition: allfilters.c:39
const char * name
Definition: avcodec.h:4203
static double av_q2d(AVRational a)
Convert rational to double.
Definition: rational.h:69
int nb_streams
Definition: avconv.h:273
uint8_t * data
Definition: avcodec.h:973
static void term_init(void)
Definition: avconv.c:131
AVDictionary * resample_opts
Definition: avconv.h:331
static int flags
Definition: log.c:44
AVFilterContext * filter
Definition: avconv.h:194
int avformat_network_init(void)
Do global initialization of network components.
Definition: utils.c:3329
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:43
static int pthread_create(pthread_t *thread, const void *unused_attr, void *(*start_routine)(void *), void *arg)
Definition: w32pthreads.h:84
#define AVERROR_EOF
End of file.
Definition: error.h:51
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:139
void av_fifo_free(AVFifoBuffer *f)
Free an AVFifoBuffer.
Definition: fifo.c:38
int av_sdp_create(AVFormatContext *ac[], int n_files, char *buf, int size)
Generate an SDP for an RTP session.
Definition: sdp.c:689
int resample_sample_rate
Definition: avconv.h:242
int interlaced_frame
The content of the picture is interlaced.
Definition: frame.h:292
void parse_loglevel(int argc, char **argv, const OptionDef *options)
Find the '-loglevel' option in the command line args and apply it.
Definition: cmdutils.c:423
external api for the swscale stuff
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:219
AVCodec * dec
Definition: avconv.h:220
static float t
Definition: output.c:52
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:844
char * stats_out
pass1 encoding statistics output buffer
Definition: avcodec.h:2278
static FILE * vstats_file
Definition: avconv.c:85
int file_index
Definition: avconv.h:216
int duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: avcodec.h:995
struct AVBitStreamFilterContext * next
Definition: avcodec.h:4198
enum AVChromaLocation chroma_sample_location
This defines the location of chroma samples.
Definition: avcodec.h:1761
unsigned int * stream_index
Definition: avformat.h:845
static int decode_interrupt_cb(void *ctx)
Definition: avconv.c:140
int resample_pix_fmt
Definition: avconv.h:239
int resample_height
Definition: avconv.h:237
struct AVOutputFormat * oformat
The output container format.
Definition: avformat.h:890
int64_t next_dts
Definition: avconv.h:227
#define AV_PKT_FLAG_KEY
The packet contains a keyframe.
Definition: avcodec.h:1023
int configure_filtergraph(FilterGraph *fg)
static void pthread_cond_signal(pthread_cond_t *cond)
Definition: w32pthreads.h:239
void av_buffer_default_free(void *opaque, uint8_t *data)
Default free callback, which calls av_free() on the buffer data.
Definition: buffer.c:60
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:122
static void abort_codec_experimental(AVCodec *c, int encoder)
Definition: avconv.c:236
static const uint8_t frame_size[4]
Definition: g723_1_data.h:47
void av_dump_format(AVFormatContext *ic, int index, const char *url, int is_output)
Definition: utils.c:2875
static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
Definition: avconv.c:1385
Main libavdevice API header.
Callback for checking whether to abort blocking functions.
Definition: avio.h:51
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:1590
enum AVCodecID id
Definition: avcodec.h:2769
int rate_emu
Definition: avconv.h:275
static int64_t start_time
Definition: avplay.c:245
int width
width and height of the video frame
Definition: frame.h:146
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:123
int has_b_frames
Size of the frame reordering buffer in the decoder.
Definition: avcodec.h:1332
void av_free(void *ptr)
Free a memory block which has been allocated with av_malloc(z)() or av_realloc(). ...
Definition: mem.c:186
enum AVPixelFormat hwaccel_pix_fmt
Definition: avconv.h:261
static int64_t extra_size
Definition: avconv.c:89
AVFilterContext * filter
Definition: avconv.h:187
#define CODEC_FLAG_INTERLACED_ME
interlaced motion estimation
Definition: avcodec.h:689
void(* hwaccel_uninit)(AVCodecContext *s)
Definition: avconv.h:258
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:409
int64_t start
Definition: avconv.h:224
#define AVERROR(e)
Definition: error.h:43
int64_t last_mux_dts
Definition: avconv.h:304
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:55
enum AVSampleFormat request_sample_fmt
Used to request a sample format from the decoder.
Definition: avcodec.h:1861
static int pthread_mutex_init(pthread_mutex_t *m, void *attr)
Definition: w32pthreads.h:104
static int pthread_mutex_unlock(pthread_mutex_t *m)
Definition: w32pthreads.h:119
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:794
int capabilities
Codec capabilities.
Definition: avcodec.h:2774
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:144
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:107
void av_bitstream_filter_close(AVBitStreamFilterContext *bsf)
unsigned int nb_programs
Definition: avformat.h:1003
static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec, AVCodecContext *enc)
Definition: avconv.c:257
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values. ...
Definition: dict.c:159
int av_get_channel_layout_nb_channels(uint64_t channel_layout)
Return the number of channels in the channel layout.
AVBufferRef * buf
A reference to the reference-counted buffer where the packet data is stored.
Definition: avcodec.h:956
static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
Definition: avconv.c:1234
int flags
CODEC_FLAG_*.
Definition: avcodec.h:1142
int av_opt_set_int(void *obj, const char *name, int64_t val, int search_flags)
Definition: opt.c:263
#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:255
int finished
Definition: avconv.h:332
int rc_max_rate
maximum bitrate
Definition: avcodec.h:2115
#define AV_PIX_FMT_FLAG_HWACCEL
Pixel format is an HW accelerated format.
Definition: pixdesc.h:103
simple assert() macros that are a bit more flexible than ISO C assert().
void av_log(void *avcl, int level, const char *fmt,...)
Definition: log.c:148
int main(int argc, char **argv)
Definition: avconv.c:2429
const char * name
Name of the codec implementation.
Definition: avcodec.h:2762
int(* init)(AVCodecContext *s)
Definition: avconv.h:59
AVBufferRef * av_buffer_create(uint8_t *data, int size, void(*free)(void *opaque, uint8_t *data), void *opaque, int flags)
Create an AVBuffer from an existing array.
Definition: buffer.c:27
#define VSYNC_VFR
Definition: avconv.h:49
int force_fps
Definition: avconv.h:312
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:754
New fields can be added to the end with minor version bumps.
Definition: avformat.h:841
#define FFMAX(a, b)
Definition: common.h:55
static char logfilename[1024]
Definition: avserver.c:264
int flags
A combination of AV_PKT_FLAG values.
Definition: avcodec.h:979
uint64_t channel_layout
Audio channel layout.
Definition: avcodec.h:1840
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare 2 timestamps each in its own timebases.
Definition: mathematics.c:127
uint32_t end_display_time
Definition: avcodec.h:3010
int nb_output_streams
Definition: avconv.c:108
int64_t guess_correct_pts(PtsCorrectionContext *ctx, int64_t reordered_pts, int64_t dts)
Attempt to guess proper monotonic timestamps for decoded video frames which might have incorrect time...
Definition: cmdutils.c:1433
int64_t pts
Same as packet pts, in AV_TIME_BASE.
Definition: avcodec.h:3013
AVCodecContext * codec
Codec context associated with this stream.
Definition: avformat.h:702
int rc_buffer_size
decoder bitstream buffer size
Definition: avcodec.h:2093
OutputFilter * filter
Definition: avconv.h:326
uint64_t channel_layout
Channel layout of the audio data.
Definition: frame.h:353
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
AVDictionary * opts
Definition: avconv.h:234
#define FF_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding...
Definition: avcodec.h:509
static void filter(MpegAudioContext *s, int ch, const short *samples, int incr)
Definition: mpegaudioenc.c:307
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:923
int nb_filtergraphs
Definition: avconv.c:113
int copy_tb
Definition: avconv_opt.c:75
int bit_rate
the average bitrate
Definition: avcodec.h:1112
static int64_t audio_size
Definition: avconv.c:88
audio channel layout utility functions
AVRational av_d2q(double d, int max)
Convert a double precision floating point number to a rational.
Definition: rational.c:105
static void do_audio_out(AVFormatContext *s, OutputStream *ost, AVFrame *frame)
Definition: avconv.c:395
enum AVPictureType pict_type
Picture type of the frame.
Definition: frame.h:168
const AVIOInterruptCB int_cb
Definition: avconv.c:145
char filename[1024]
input or output filename
Definition: avformat.h:943
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:110
static InputStream * get_input_stream(OutputStream *ost)
Definition: avconv.c:1488
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:234
external API header
int width
picture width / height.
Definition: avcodec.h:1217
static void do_video_stats(OutputStream *ost, int frame_size)
Definition: avconv.c:598
int attribute_align_arg av_buffersink_get_samples(AVFilterContext *ctx, AVFrame *frame, int nb_samples)
Same as av_buffersink_get_frame(), but with the ability to specify the number of samples read...
Definition: buffersink.c:102
const char * name
Definition: avformat.h:437
static void do_video_out(AVFormatContext *s, OutputStream *ost, AVFrame *in_picture, int *frame_size)
Definition: avconv.c:495
void av_parser_close(AVCodecParserContext *s)
Definition: parser.c:207
static av_always_inline av_const long int lrintf(float x)
Definition: libm.h:144
enum AVSampleFormat av_get_packed_sample_fmt(enum AVSampleFormat sample_fmt)
Get the packed alternative form of the given sample format.
Definition: samplefmt.c:64
#define FFABS(a)
Definition: common.h:52
int quality
quality (between 1 (good) and FF_LAMBDA_MAX (bad))
Definition: frame.h:207
static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
Definition: avconv.c:1423
int64_t max_frames
Definition: avconv.h:307
#define CODEC_FLAG_INTERLACED_DCT
Use interlaced DCT.
Definition: avcodec.h:682
static void do_subtitle_out(AVFormatContext *s, OutputStream *ost, InputStream *ist, AVSubtitle *sub, int64_t pts)
Definition: avconv.c:429
int(* hwaccel_retrieve_data)(AVCodecContext *s, AVFrame *frame)
Definition: avconv.h:260
static volatile int received_nb_signals
Definition: avconv.c:121
int ticks_per_frame
For some codecs, the time base is closer to the field rate than the frame rate.
Definition: avcodec.h:1182
Opaque data information usually sparse.
Definition: avutil.h:191
enum AVPixelFormat pix_fmt
Definition: movenc.c:821
const char * av_get_sample_fmt_name(enum AVSampleFormat sample_fmt)
Return the name of sample_fmt, or NULL if sample_fmt is not recognized.
Definition: samplefmt.c:47
#define VSYNC_CFR
Definition: avconv.h:48
int do_benchmark
Definition: avconv_opt.c:71
preferred ID for MPEG-1/2 video decoding
Definition: avcodec.h:110
int av_find_nearest_q_idx(AVRational q, const AVRational *q_list)
Find the nearest value in q_list to q.
Definition: rational.c:137
#define AVERROR_EXPERIMENTAL
Requested feature is flagged experimental. Set strict_std_compliance if you really want to use it...
Definition: error.h:62
void exit_program(int ret)
Wraps exit with a program-specific cleanup routine.
Definition: cmdutils.c:94
if(ac->has_optimized_func)
static void print_sdp(void)
Definition: avconv.c:1359
int64_t av_gettime(void)
Get the current time in microseconds.
Definition: time.c:37
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:407
int audio_sync_method
Definition: avconv_opt.c:69
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames...
Definition: frame.h:158
InputFilter ** filters
Definition: avconv.h:248
int64_t recording_time
Definition: avconv.h:272
int avformat_network_deinit(void)
Undo the initialization done by avformat_network_init.
Definition: utils.c:3341
Definition: avconv.h:57
int frame_size
Number of samples per channel in an audio frame.
Definition: avcodec.h:1799
static void parse_forced_key_frames(char *kf, OutputStream *ost, AVCodecContext *avctx)
Definition: avconv.c:1505
NULL
Definition: eval.c:55
static int pthread_mutex_lock(pthread_mutex_t *m)
Definition: w32pthreads.h:114
static int output_packet(InputStream *ist, const AVPacket *pkt)
Definition: avconv.c:1258
int av_fifo_space(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:57
static int64_t getmaxrss(void)
Definition: avconv.c:2411
#define AV_LOG_INFO
Standard information.
Definition: log.h:134
int av_bitstream_filter_filter(AVBitStreamFilterContext *bsfc, AVCodecContext *avctx, const char *args, uint8_t **poutbuf, int *poutbuf_size, const uint8_t *buf, int buf_size, int keyframe)
uint64_t error[AV_NUM_DATA_POINTERS]
error
Definition: frame.h:276
AVCodecParserContext * av_parser_init(int codec_id)
Definition: parser.c:46
int ost_index
Definition: avconv.h:345
struct InputStream * sync_ist
Definition: avconv.h:298
int avcodec_default_get_buffer2(AVCodecContext *s, AVFrame *frame, int flags)
The default callback for AVCodecContext.get_buffer2().
Definition: utils.c:524
OutputFile ** output_files
Definition: avconv.c:109
int exit_on_error
Definition: avconv_opt.c:76
enum AVMediaType codec_type
Definition: avcodec.h:1062
double ts_scale
Definition: avconv.h:231
int me_threshold
Motion estimation threshold below which no motion estimation is performed, but instead the user speci...
Definition: avcodec.h:1612
const AVRational * supported_framerates
array of supported framerates, or NULL if any, array is terminated by {0,0}
Definition: avcodec.h:2775
#define DEFAULT_PASS_LOGFILENAME_PREFIX
Definition: avconv.c:100
enum AVCodecID codec_id
Definition: avcodec.h:1065
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:240
int av_opt_set_dict(void *obj, AVDictionary **options)
Definition: opt.c:621
AV_SAMPLE_FMT_NONE
Definition: avconv_filter.c:68
int sample_rate
samples per second
Definition: avcodec.h:1779
static void avconv_cleanup(int ret)
Definition: avconv.c:147
AVIOContext * pb
I/O context.
Definition: avformat.h:913
OutputStream ** output_streams
Definition: avconv.c:107
int ist_index
Definition: avconv.h:269
const struct AVCodecTag *const * codec_tag
List of supported codec_id-codec_tag pairs, ordered by "better choice first".
Definition: avformat.h:462
uint8_t flags
Definition: pixdesc.h:78
const char * graph_desc
Definition: avconv.h:205
Descriptor that unambiguously describes how the bits of a pixel are stored in the up to 4 data planes...
Definition: pixdesc.h:57
int64_t start_time
Definition: avconv.h:271
#define AVFMT_RAWPICTURE
Format wants AVPicture structure for raw picture data.
Definition: avformat.h:403
main external API structure.
Definition: avcodec.h:1054
AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: utils.c:1673
static int check_recording_time(OutputStream *ost)
Definition: avconv.c:382
static double psnr(double d)
Definition: avconv.c:593
void avsubtitle_free(AVSubtitle *sub)
Free all allocated data in the given subtitle struct.
Definition: utils.c:1571
AVRational sample_aspect_ratio
Sample aspect ratio for the video frame, 0/1 if unknown/unspecified.
Definition: frame.h:178
const int program_birth_year
program birth year, defined by the program for show_banner()
Definition: avconv.c:83
const char * attachment_filename
Definition: avconv.h:334
unsigned int codec_tag
fourcc (LSB first, so "ABCD" -> ('D'<<24) + ('C'<<16) + ('B'<<8) + 'A').
Definition: avcodec.h:1080
a very simple circular buffer FIFO implementation
AVFrame * decoded_frame
Definition: avconv.h:221
int extradata_size
Definition: avcodec.h:1163
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:62
Replacements for frequently missing libm functions.
int avconv_parse_options(int argc, char **argv)
Definition: avconv_opt.c:2104
struct AVBitStreamFilter * filter
Definition: avcodec.h:4196
AVStream * st
Definition: avconv.h:217
int sample_rate
Sample rate of the audio data.
Definition: frame.h:348
enum AVPixelFormat(* get_format)(struct AVCodecContext *s, const enum AVPixelFormat *fmt)
callback to negotiate the pixelFormat
Definition: avcodec.h:1294
static const AVFilterPad inputs[]
Definition: af_ashowinfo.c:111
int av_sample_fmt_is_planar(enum AVSampleFormat sample_fmt)
Check if the sample format is planar.
Definition: samplefmt.c:101
rational number numerator/denominator
Definition: rational.h:43
const char program_name[]
program name, defined by the program for show_version().
Definition: avconv.c:82
int file_index
Definition: avconv.h:289
int64_t sync_opts
Definition: avconv.h:299
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:123
static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
Definition: avconv.c:1153
static int64_t getutime(void)
Definition: avconv.c:2393
discard useless packets like 0 size packets in avi
Definition: avcodec.h:542
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:2037
static int poll_filter(OutputStream *ost)
Definition: avconv.c:637
int avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
Initialize the AVCodecContext to use the given AVCodec.
Definition: utils.c:872
int showed_multi_packet_warning
Definition: avconv.h:233
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: utils.c:2595
int64_t ts_offset
Definition: avconv.h:270
misc parsing utilities
int attribute_align_arg av_buffersrc_add_frame(AVFilterContext *ctx, AVFrame *frame)
Add a frame to the buffer source.
Definition: buffersrc.c:92
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: utils.c:1120
static int filter_frame(AVFilterLink *inlink, AVFrame *buf)
Definition: af_amix.c:459
int64_t pkt_pts
PTS copied from the AVPacket that was decoded to produce this frame.
Definition: frame.h:188
AVFrame * filtered_frame
Definition: avconv.h:308
int source_index
Definition: avconv.h:291
void av_frame_unref(AVFrame *frame)
Unreference all the buffers referenced by frame and reset the frame fields.
Definition: frame.c:273
int cmdutils_read_file(const char *filename, char **bufptr, size_t *size)
Read the file with name filename, and put its content in a newly allocated 0-terminated buffer...
Definition: cmdutils.c:1390
int global_quality
Global quality for codecs which cannot change it per frame.
Definition: avcodec.h:1128
int nb_filters
Definition: avconv.h:249
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:122
int64_t val
Definition: avformat.h:377
static const uint16_t scale[4]
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds. ...
Definition: avformat.h:952
int qp_hist
Definition: avconv_opt.c:78
static int process_input(void)
Definition: avconv.c:2161
int av_strerror(int errnum, char *errbuf, size_t errbuf_size)
Put a description of the AVERROR code errnum in errbuf.
Definition: error.c:23
int resample_sample_fmt
Definition: avconv.h:241
int forced_kf_count
Definition: avconv.h:319
char * forced_keyframes
Definition: avconv.h:321
const OptionDef options[]
Definition: avserver.c:4624
static int poll_filters(void)
Definition: avconv.c:698
static const HWAccel * get_hwaccel(enum AVPixelFormat pix_fmt)
Definition: avconv.c:1376
static int get_input_packet(InputFile *f, AVPacket *pkt)
Definition: avconv.c:2113
int64_t pkt_dts
DTS copied from the AVPacket that triggered returning this frame.
Definition: frame.h:193
int resample_width
Definition: avconv.h:238
int guess_input_channel_layout(InputStream *ist)
Definition: avconv.c:1041
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:758
int av_fifo_size(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:52
struct FilterGraph * graph
Definition: avconv.h:196
uint64_t limit_filesize
Definition: avconv.h:348
#define AVFMT_NOFILE
Demuxer will use avio_open, no opened file should be provided by the caller.
Definition: avformat.h:400
static void reset_eagain(void)
Definition: avconv.c:2142
InputStream ** input_streams
Definition: avconv.c:102
int do_pkt_dump
Definition: avconv_opt.c:73
#define AVFMT_NOSTREAMS
Format does not require any streams.
Definition: avformat.h:412
const HWAccel hwaccels[]
Definition: avconv_opt.c:56
int disposition
AV_DISPOSITION_* bit field.
Definition: avformat.h:738
uint32_t start_display_time
Definition: avcodec.h:3009
AVSampleFormat
Audio Sample Formats.
Definition: samplefmt.h:49
#define CODEC_CAP_EXPERIMENTAL
Codec is experimental and is thus avoided in favor of non experimental encoders.
Definition: avcodec.h:768
static InputFile * select_input_file(void)
Definition: avconv.c:1980
char * vstats_filename
Definition: avconv_opt.c:63
void av_init_packet(AVPacket *pkt)
Initialize optional fields of a packet with default values.
Definition: avpacket.c:46
int thread_safe_callbacks
Set by the client if its custom get_buffer() callback can be called synchronously from another thread...
Definition: avcodec.h:2543
char * key
Definition: dict.h:75
int den
denominator
Definition: rational.h:45
void uninit_opts(void)
Uninitialize the cmdutils option system, in particular free the *_opts contexts and their contents...
Definition: cmdutils.c:71
void show_usage(void)
Definition: avconv_opt.c:2054
struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:883
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:2640
AVFormatContext * ctx
Definition: avconv.h:266
AVCodec * enc
Definition: avconv.h:306
int eof_reached
Definition: avconv.h:267
int forced_kf_index
Definition: avconv.h:320
#define AVFMT_VARIABLE_FPS
Format allows variable fps.
Definition: avformat.h:410
uint8_t * name
Definition: avconv.h:190
AVFifoBuffer * av_fifo_alloc(unsigned int size)
Initialize an AVFifoBuffer.
Definition: fifo.c:25
int top_field_first
If the content is interlaced, is top field displayed first.
Definition: frame.h:297
int audio_volume
Definition: avconv_opt.c:68
struct AVFrac pts
encoding: pts generation when outputting stream
Definition: avformat.h:708
int channels
number of audio channels
Definition: avcodec.h:1780
static int64_t video_size
Definition: avconv.c:87
int top_field_first
Definition: avconv.h:313
struct AVCodecParserContext * parser
Definition: avformat.h:817
void av_log_set_flags(int arg)
Definition: log.c:175
static int transcode(void)
Definition: avconv.c:2273
#define FF_QP2LAMBDA
factor to convert from H.263 QP to lambda
Definition: avutil.h:207
AVFormatContext * ctx
Definition: avconv.h:343
int avcodec_decode_video2(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, AVPacket *avpkt)
Decode the video frame of size avpkt->size from avpkt->data into picture.
Definition: utils.c:1454
int nb_output_files
Definition: avconv.c:110
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed...
Definition: avcodec.h:972
int av_write_trailer(AVFormatContext *s)
Write the stream trailer to an output media file and free the file private data.
Definition: mux.c:672
int frame_number
Frame counter, set by libavcodec.
Definition: avcodec.h:1810
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:3590
int do_hex_dump
Definition: avconv_opt.c:72
int height
Definition: frame.h:146
InputFilter ** inputs
Definition: avconv.h:209
enum AVFieldOrder field_order
Field order.
Definition: avcodec.h:1776
float frame_aspect_ratio
Definition: avconv.h:315
enum AVPixelFormat hwaccel_retrieved_pix_fmt
Definition: avconv.h:262
#define AV_DICT_IGNORE_SUFFIX
Definition: dict.h:62
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:117
enum AVSampleFormat * sample_fmts
array of supported sample formats, or NULL if unknown, array is terminated by -1
Definition: avcodec.h:2778
static void sigterm_handler(int sig)
Definition: avconv.c:124
int discard
Definition: avconv.h:218
static int init_input_stream(int ist_index, char *error, int error_len)
Definition: avconv.c:1433
const char * av_get_pix_fmt_name(enum AVPixelFormat pix_fmt)
Return the short name for a pixel format, NULL in case pix_fmt is unknown.
Definition: pixdesc.c:1449
void av_pkt_dump_log2(void *avcl, int level, AVPacket *pkt, int dump_payload, AVStream *st)
Send a nice dump of a packet to the log.
Definition: utils.c:3086
int stream_index
Definition: avcodec.h:975
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented...
Definition: avformat.h:719
enum HWAccelID hwaccel_id
Definition: avconv.h:252
int64_t first_pts
Definition: avconv.h:302
unsigned int av_codec_get_tag(const struct AVCodecTag *const *tags, enum AVCodecID id)
Get the codec tag for the given codec id id.
int nb_inputs
Definition: avconv.h:210
int index
Definition: avconv.h:290
void assert_avoptions(AVDictionary *m)
Definition: avconv.c:227
int attribute_align_arg av_buffersink_get_frame(AVFilterContext *ctx, AVFrame *frame)
Get a frame with filtered data from sink and put it in frame.
Definition: buffersink.c:62
AVPixelFormat
Pixel format.
Definition: pixfmt.h:63
uint64_t resample_channel_layout
Definition: avconv.h:244
This structure stores compressed data.
Definition: avcodec.h:950
void av_register_all(void)
Initialize libavformat and register all the muxers, demuxers and protocols.
Definition: allformats.c:51
int avcodec_encode_subtitle(AVCodecContext *avctx, uint8_t *buf, int buf_size, const AVSubtitle *sub)
Definition: utils.c:1337
static void print_report(int is_last_report, int64_t timer_start)
Definition: avconv.c:744
int nb_samples
number of audio samples (per channel) described by this frame
Definition: frame.h:151
void * av_mallocz(size_t size)
Allocate a block of size bytes with alignment suitable for all memory accesses (including vectors if ...
Definition: mem.c:205
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: avcodec.h:966
void * opaque
Private data of the user, can be used to carry app specific stuff.
Definition: avcodec.h:1105
static int nb_frames_dup
Definition: avconv.c:90
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:228
AVProgram ** programs
Definition: avformat.h:1004
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.
uint8_t * subtitle_header
Header containing style information for text subtitles.
Definition: avcodec.h:2711
int avcodec_decode_audio4(AVCodecContext *avctx, AVFrame *frame, int *got_frame_ptr, AVPacket *avpkt)
Decode the audio frame of size avpkt->size from avpkt->data into frame.
Definition: utils.c:1510