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 
691 {
692  OutputFile *of = output_files[ost->file_index];
693  int i;
694 
695  ost->finished = 1;
696 
697  if (of->shortest) {
698  for (i = 0; i < of->ctx->nb_streams; i++)
699  output_streams[of->ost_index + i]->finished = 1;
700  }
701 }
702 
703 /*
704  * Read as many frames from possible from lavfi and encode them.
705  *
706  * Always read from the active stream with the lowest timestamp. If no frames
707  * are available for it then return EAGAIN and wait for more input. This way we
708  * can use lavfi sources that generate unlimited amount of frames without memory
709  * usage exploding.
710  */
711 static int poll_filters(void)
712 {
713  int i, ret = 0;
714 
715  while (ret >= 0 && !received_sigterm) {
716  OutputStream *ost = NULL;
717  int64_t min_pts = INT64_MAX;
718 
719  /* choose output stream with the lowest timestamp */
720  for (i = 0; i < nb_output_streams; i++) {
721  int64_t pts = output_streams[i]->sync_opts;
722 
723  if (!output_streams[i]->filter || output_streams[i]->finished)
724  continue;
725 
726  pts = av_rescale_q(pts, output_streams[i]->st->codec->time_base,
728  if (pts < min_pts) {
729  min_pts = pts;
730  ost = output_streams[i];
731  }
732  }
733 
734  if (!ost)
735  break;
736 
737  ret = poll_filter(ost);
738 
739  if (ret == AVERROR_EOF) {
741  ret = 0;
742  } else if (ret == AVERROR(EAGAIN))
743  return 0;
744  }
745 
746  return ret;
747 }
748 
749 static void print_report(int is_last_report, int64_t timer_start)
750 {
751  char buf[1024];
752  OutputStream *ost;
753  AVFormatContext *oc;
754  int64_t total_size;
755  AVCodecContext *enc;
756  int frame_number, vid, i;
757  double bitrate, ti1, pts;
758  static int64_t last_time = -1;
759  static int qp_histogram[52];
760 
761  if (!print_stats && !is_last_report)
762  return;
763 
764  if (!is_last_report) {
765  int64_t cur_time;
766  /* display the report every 0.5 seconds */
767  cur_time = av_gettime();
768  if (last_time == -1) {
769  last_time = cur_time;
770  return;
771  }
772  if ((cur_time - last_time) < 500000)
773  return;
774  last_time = cur_time;
775  }
776 
777 
778  oc = output_files[0]->ctx;
779 
780  total_size = avio_size(oc->pb);
781  if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
782  total_size = avio_tell(oc->pb);
783  if (total_size < 0) {
784  char errbuf[128];
785  av_strerror(total_size, errbuf, sizeof(errbuf));
786  av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
787  "avio_tell() failed: %s\n", errbuf);
788  total_size = 0;
789  }
790 
791  buf[0] = '\0';
792  ti1 = 1e10;
793  vid = 0;
794  for (i = 0; i < nb_output_streams; i++) {
795  float q = -1;
796  ost = output_streams[i];
797  enc = ost->st->codec;
798  if (!ost->stream_copy && enc->coded_frame)
799  q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
800  if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
801  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
802  }
803  if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
804  float t = (av_gettime() - timer_start) / 1000000.0;
805 
806  frame_number = ost->frame_number;
807  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
808  frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
809  if (is_last_report)
810  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
811  if (qp_hist) {
812  int j;
813  int qp = lrintf(q);
814  if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
815  qp_histogram[qp]++;
816  for (j = 0; j < 32; j++)
817  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
818  }
819  if (enc->flags&CODEC_FLAG_PSNR) {
820  int j;
821  double error, error_sum = 0;
822  double scale, scale_sum = 0;
823  char type[3] = { 'Y','U','V' };
824  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
825  for (j = 0; j < 3; j++) {
826  if (is_last_report) {
827  error = enc->error[j];
828  scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
829  } else {
830  error = enc->coded_frame->error[j];
831  scale = enc->width * enc->height * 255.0 * 255.0;
832  }
833  if (j)
834  scale /= 4;
835  error_sum += error;
836  scale_sum += scale;
837  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
838  }
839  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
840  }
841  vid = 1;
842  }
843  /* compute min output value */
844  pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
845  if ((pts < ti1) && (pts > 0))
846  ti1 = pts;
847  }
848  if (ti1 < 0.01)
849  ti1 = 0.01;
850 
851  bitrate = (double)(total_size * 8) / ti1 / 1000.0;
852 
853  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
854  "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
855  (double)total_size / 1024, ti1, bitrate);
856 
858  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
860 
861  av_log(NULL, AV_LOG_INFO, "%s \r", buf);
862 
863  fflush(stderr);
864 
865  if (is_last_report) {
866  int64_t raw = audio_size + video_size + extra_size;
867  float percent = 0.0;
868 
869  if (raw)
870  percent = 100.0 * (total_size - raw) / raw;
871 
872  av_log(NULL, AV_LOG_INFO, "\n");
873  av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
874  video_size / 1024.0,
875  audio_size / 1024.0,
876  extra_size / 1024.0,
877  percent);
878  }
879 }
880 
881 static void flush_encoders(void)
882 {
883  int i, ret;
884 
885  for (i = 0; i < nb_output_streams; i++) {
886  OutputStream *ost = output_streams[i];
887  AVCodecContext *enc = ost->st->codec;
888  AVFormatContext *os = output_files[ost->file_index]->ctx;
889  int stop_encoding = 0;
890 
891  if (!ost->encoding_needed)
892  continue;
893 
894  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
895  continue;
897  continue;
898 
899  for (;;) {
900  int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
901  const char *desc;
902  int64_t *size;
903 
904  switch (ost->st->codec->codec_type) {
905  case AVMEDIA_TYPE_AUDIO:
906  encode = avcodec_encode_audio2;
907  desc = "Audio";
908  size = &audio_size;
909  break;
910  case AVMEDIA_TYPE_VIDEO:
911  encode = avcodec_encode_video2;
912  desc = "Video";
913  size = &video_size;
914  break;
915  default:
916  stop_encoding = 1;
917  }
918 
919  if (encode) {
920  AVPacket pkt;
921  int got_packet;
922  av_init_packet(&pkt);
923  pkt.data = NULL;
924  pkt.size = 0;
925 
926  ret = encode(enc, &pkt, NULL, &got_packet);
927  if (ret < 0) {
928  av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
929  exit_program(1);
930  }
931  *size += ret;
932  if (ost->logfile && enc->stats_out) {
933  fprintf(ost->logfile, "%s", enc->stats_out);
934  }
935  if (!got_packet) {
936  stop_encoding = 1;
937  break;
938  }
939  if (pkt.pts != AV_NOPTS_VALUE)
940  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
941  if (pkt.dts != AV_NOPTS_VALUE)
942  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
943  if (pkt.duration > 0)
944  pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
945  write_frame(os, &pkt, ost);
946  }
947 
948  if (stop_encoding)
949  break;
950  }
951  }
952 }
953 
954 /*
955  * Check whether a packet from ist should be written into ost at this time
956  */
958 {
959  OutputFile *of = output_files[ost->file_index];
960  int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
961 
962  if (ost->source_index != ist_index)
963  return 0;
964 
965  if (of->start_time != AV_NOPTS_VALUE && ist->last_dts < of->start_time)
966  return 0;
967 
968  return 1;
969 }
970 
971 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
972 {
973  OutputFile *of = output_files[ost->file_index];
974  InputFile *f = input_files [ist->file_index];
975  int64_t start_time = (of->start_time == AV_NOPTS_VALUE) ? 0 : of->start_time;
976  int64_t ost_tb_start_time = av_rescale_q(start_time, AV_TIME_BASE_Q, ost->st->time_base);
977  AVPacket opkt;
978 
979  av_init_packet(&opkt);
980 
981  if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
983  return;
984 
985  if (of->recording_time != INT64_MAX &&
986  ist->last_dts >= of->recording_time + start_time) {
987  ost->finished = 1;
988  return;
989  }
990 
991  if (f->recording_time != INT64_MAX) {
992  start_time = f->ctx->start_time;
993  if (f->start_time != AV_NOPTS_VALUE)
994  start_time += f->start_time;
995  if (ist->last_dts >= f->recording_time + start_time) {
996  ost->finished = 1;
997  return;
998  }
999  }
1000 
1001  /* force the input stream PTS */
1002  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1003  audio_size += pkt->size;
1004  else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1005  video_size += pkt->size;
1006  ost->sync_opts++;
1007  }
1008 
1009  if (pkt->pts != AV_NOPTS_VALUE)
1010  opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1011  else
1012  opkt.pts = AV_NOPTS_VALUE;
1013 
1014  if (pkt->dts == AV_NOPTS_VALUE)
1015  opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1016  else
1017  opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1018  opkt.dts -= ost_tb_start_time;
1019 
1020  opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1021  opkt.flags = pkt->flags;
1022 
1023  // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1024  if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1027  && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1028  ) {
1029  if (av_parser_change(ost->parser, ost->st->codec,
1030  &opkt.data, &opkt.size,
1031  pkt->data, pkt->size,
1032  pkt->flags & AV_PKT_FLAG_KEY)) {
1033  opkt.buf = av_buffer_create(opkt.data, opkt.size, av_buffer_default_free, NULL, 0);
1034  if (!opkt.buf)
1035  exit_program(1);
1036  }
1037  } else {
1038  opkt.data = pkt->data;
1039  opkt.size = pkt->size;
1040  }
1041 
1042  write_frame(of->ctx, &opkt, ost);
1043  ost->st->codec->frame_number++;
1044 }
1045 
1047 {
1048  AVCodecContext *dec = ist->st->codec;
1049 
1050  if (!dec->channel_layout) {
1051  char layout_name[256];
1052 
1054  if (!dec->channel_layout)
1055  return 0;
1056  av_get_channel_layout_string(layout_name, sizeof(layout_name),
1057  dec->channels, dec->channel_layout);
1058  av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1059  "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1060  }
1061  return 1;
1062 }
1063 
1064 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1065 {
1066  AVFrame *decoded_frame, *f;
1067  AVCodecContext *avctx = ist->st->codec;
1068  int i, ret, err = 0, resample_changed;
1069 
1070  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1071  return AVERROR(ENOMEM);
1072  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1073  return AVERROR(ENOMEM);
1074  decoded_frame = ist->decoded_frame;
1075 
1076  ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1077  if (!*got_output || ret < 0) {
1078  if (!pkt->size) {
1079  for (i = 0; i < ist->nb_filters; i++)
1081  }
1082  return ret;
1083  }
1084 
1085  /* if the decoder provides a pts, use it instead of the last packet pts.
1086  the decoder could be delaying output by a packet or more. */
1087  if (decoded_frame->pts != AV_NOPTS_VALUE)
1088  ist->next_dts = decoded_frame->pts;
1089  else if (pkt->pts != AV_NOPTS_VALUE) {
1090  decoded_frame->pts = pkt->pts;
1091  pkt->pts = AV_NOPTS_VALUE;
1092  }
1093 
1094  resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1095  ist->resample_channels != avctx->channels ||
1096  ist->resample_channel_layout != decoded_frame->channel_layout ||
1097  ist->resample_sample_rate != decoded_frame->sample_rate;
1098  if (resample_changed) {
1099  char layout1[64], layout2[64];
1100 
1101  if (!guess_input_channel_layout(ist)) {
1102  av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1103  "layout for Input Stream #%d.%d\n", ist->file_index,
1104  ist->st->index);
1105  exit_program(1);
1106  }
1107  decoded_frame->channel_layout = avctx->channel_layout;
1108 
1109  av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1111  av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1112  decoded_frame->channel_layout);
1113 
1115  "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",
1116  ist->file_index, ist->st->index,
1118  ist->resample_channels, layout1,
1119  decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1120  avctx->channels, layout2);
1121 
1122  ist->resample_sample_fmt = decoded_frame->format;
1123  ist->resample_sample_rate = decoded_frame->sample_rate;
1124  ist->resample_channel_layout = decoded_frame->channel_layout;
1125  ist->resample_channels = avctx->channels;
1126 
1127  for (i = 0; i < nb_filtergraphs; i++)
1128  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1129  configure_filtergraph(filtergraphs[i]) < 0) {
1130  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1131  exit_program(1);
1132  }
1133  }
1134 
1135  if (decoded_frame->pts != AV_NOPTS_VALUE)
1136  decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1137  ist->st->time_base,
1138  (AVRational){1, ist->st->codec->sample_rate});
1139  for (i = 0; i < ist->nb_filters; i++) {
1140  if (i < ist->nb_filters - 1) {
1141  f = ist->filter_frame;
1142  err = av_frame_ref(f, decoded_frame);
1143  if (err < 0)
1144  break;
1145  } else
1146  f = decoded_frame;
1147 
1148  err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1149  if (err < 0)
1150  break;
1151  }
1152 
1154  av_frame_unref(decoded_frame);
1155  return err < 0 ? err : ret;
1156 }
1157 
1158 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1159 {
1160  AVFrame *decoded_frame, *f;
1161  int i, ret = 0, err = 0, resample_changed;
1162 
1163  if (!ist->decoded_frame && !(ist->decoded_frame = av_frame_alloc()))
1164  return AVERROR(ENOMEM);
1165  if (!ist->filter_frame && !(ist->filter_frame = av_frame_alloc()))
1166  return AVERROR(ENOMEM);
1167  decoded_frame = ist->decoded_frame;
1168 
1169  ret = avcodec_decode_video2(ist->st->codec,
1170  decoded_frame, got_output, pkt);
1171  if (!*got_output || ret < 0) {
1172  if (!pkt->size) {
1173  for (i = 0; i < ist->nb_filters; i++)
1175  }
1176  return ret;
1177  }
1178 
1179  if (ist->hwaccel_retrieve_data && decoded_frame->format == ist->hwaccel_pix_fmt) {
1180  err = ist->hwaccel_retrieve_data(ist->st->codec, decoded_frame);
1181  if (err < 0)
1182  goto fail;
1183  }
1184  ist->hwaccel_retrieved_pix_fmt = decoded_frame->format;
1185 
1186  decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1187  decoded_frame->pkt_dts);
1188  pkt->size = 0;
1189 
1190  if (ist->st->sample_aspect_ratio.num)
1191  decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1192 
1193  resample_changed = ist->resample_width != decoded_frame->width ||
1194  ist->resample_height != decoded_frame->height ||
1195  ist->resample_pix_fmt != decoded_frame->format;
1196  if (resample_changed) {
1198  "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1199  ist->file_index, ist->st->index,
1201  decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1202 
1203  ret = poll_filters();
1204  if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN)))
1205  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
1206 
1207  ist->resample_width = decoded_frame->width;
1208  ist->resample_height = decoded_frame->height;
1209  ist->resample_pix_fmt = decoded_frame->format;
1210 
1211  for (i = 0; i < nb_filtergraphs; i++)
1212  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1213  configure_filtergraph(filtergraphs[i]) < 0) {
1214  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1215  exit_program(1);
1216  }
1217  }
1218 
1219  for (i = 0; i < ist->nb_filters; i++) {
1220  if (i < ist->nb_filters - 1) {
1221  f = ist->filter_frame;
1222  err = av_frame_ref(f, decoded_frame);
1223  if (err < 0)
1224  break;
1225  } else
1226  f = decoded_frame;
1227 
1228  err = av_buffersrc_add_frame(ist->filters[i]->filter, f);
1229  if (err < 0)
1230  break;
1231  }
1232 
1233 fail:
1235  av_frame_unref(decoded_frame);
1236  return err < 0 ? err : ret;
1237 }
1238 
1239 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1240 {
1241  AVSubtitle subtitle;
1242  int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1243  &subtitle, got_output, pkt);
1244  if (ret < 0)
1245  return ret;
1246  if (!*got_output)
1247  return ret;
1248 
1249  for (i = 0; i < nb_output_streams; i++) {
1250  OutputStream *ost = output_streams[i];
1251 
1252  if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1253  continue;
1254 
1255  do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1256  }
1257 
1258  avsubtitle_free(&subtitle);
1259  return ret;
1260 }
1261 
1262 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1263 static int output_packet(InputStream *ist, const AVPacket *pkt)
1264 {
1265  int i;
1266  int got_output;
1267  AVPacket avpkt;
1268 
1269  if (ist->next_dts == AV_NOPTS_VALUE)
1270  ist->next_dts = ist->last_dts;
1271 
1272  if (pkt == NULL) {
1273  /* EOF handling */
1274  av_init_packet(&avpkt);
1275  avpkt.data = NULL;
1276  avpkt.size = 0;
1277  goto handle_eof;
1278  } else {
1279  avpkt = *pkt;
1280  }
1281 
1282  if (pkt->dts != AV_NOPTS_VALUE)
1283  ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1284 
1285  // while we have more to decode or while the decoder did output something on EOF
1286  while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1287  int ret = 0;
1288  handle_eof:
1289 
1290  ist->last_dts = ist->next_dts;
1291 
1292  if (avpkt.size && avpkt.size != pkt->size) {
1294  "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1295  ist->showed_multi_packet_warning = 1;
1296  }
1297 
1298  switch (ist->st->codec->codec_type) {
1299  case AVMEDIA_TYPE_AUDIO:
1300  ret = decode_audio (ist, &avpkt, &got_output);
1301  break;
1302  case AVMEDIA_TYPE_VIDEO:
1303  ret = decode_video (ist, &avpkt, &got_output);
1304  if (avpkt.duration)
1305  ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1306  else if (ist->st->avg_frame_rate.num)
1307  ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
1308  AV_TIME_BASE_Q);
1309  else if (ist->st->codec->time_base.num != 0) {
1310  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1311  ist->st->codec->ticks_per_frame;
1312  ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
1313  }
1314  break;
1315  case AVMEDIA_TYPE_SUBTITLE:
1316  ret = transcode_subtitles(ist, &avpkt, &got_output);
1317  break;
1318  default:
1319  return -1;
1320  }
1321 
1322  if (ret < 0)
1323  return ret;
1324  // touch data and size only if not EOF
1325  if (pkt) {
1326  avpkt.data += ret;
1327  avpkt.size -= ret;
1328  }
1329  if (!got_output) {
1330  continue;
1331  }
1332  }
1333 
1334  /* handle stream copy */
1335  if (!ist->decoding_needed) {
1336  ist->last_dts = ist->next_dts;
1337  switch (ist->st->codec->codec_type) {
1338  case AVMEDIA_TYPE_AUDIO:
1339  ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1340  ist->st->codec->sample_rate;
1341  break;
1342  case AVMEDIA_TYPE_VIDEO:
1343  if (ist->st->codec->time_base.num != 0) {
1344  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1345  ist->next_dts += ((int64_t)AV_TIME_BASE *
1346  ist->st->codec->time_base.num * ticks) /
1347  ist->st->codec->time_base.den;
1348  }
1349  break;
1350  }
1351  }
1352  for (i = 0; pkt && i < nb_output_streams; i++) {
1353  OutputStream *ost = output_streams[i];
1354 
1355  if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1356  continue;
1357 
1358  do_streamcopy(ist, ost, pkt);
1359  }
1360 
1361  return 0;
1362 }
1363 
1364 static void print_sdp(void)
1365 {
1366  char sdp[16384];
1367  int i;
1368  AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1369 
1370  if (!avc)
1371  exit_program(1);
1372  for (i = 0; i < nb_output_files; i++)
1373  avc[i] = output_files[i]->ctx;
1374 
1375  av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1376  printf("SDP:\n%s\n", sdp);
1377  fflush(stdout);
1378  av_freep(&avc);
1379 }
1380 
1382 {
1383  int i;
1384  for (i = 0; hwaccels[i].name; i++)
1385  if (hwaccels[i].pix_fmt == pix_fmt)
1386  return &hwaccels[i];
1387  return NULL;
1388 }
1389 
1390 static enum AVPixelFormat get_format(AVCodecContext *s, const enum AVPixelFormat *pix_fmts)
1391 {
1392  InputStream *ist = s->opaque;
1393  const enum AVPixelFormat *p;
1394  int ret;
1395 
1396  for (p = pix_fmts; *p != -1; p++) {
1397  const AVPixFmtDescriptor *desc = av_pix_fmt_desc_get(*p);
1398  const HWAccel *hwaccel;
1399 
1400  if (!(desc->flags & AV_PIX_FMT_FLAG_HWACCEL))
1401  break;
1402 
1403  hwaccel = get_hwaccel(*p);
1404  if (!hwaccel ||
1405  (ist->active_hwaccel_id && ist->active_hwaccel_id != hwaccel->id) ||
1406  (ist->hwaccel_id != HWACCEL_AUTO && ist->hwaccel_id != hwaccel->id))
1407  continue;
1408 
1409  ret = hwaccel->init(s);
1410  if (ret < 0) {
1411  if (ist->hwaccel_id == hwaccel->id) {
1413  "%s hwaccel requested for input stream #%d:%d, "
1414  "but cannot be initialized.\n", hwaccel->name,
1415  ist->file_index, ist->st->index);
1416  exit_program(1);
1417  }
1418  continue;
1419  }
1420  ist->active_hwaccel_id = hwaccel->id;
1421  ist->hwaccel_pix_fmt = *p;
1422  break;
1423  }
1424 
1425  return *p;
1426 }
1427 
1428 static int get_buffer(AVCodecContext *s, AVFrame *frame, int flags)
1429 {
1430  InputStream *ist = s->opaque;
1431 
1432  if (ist->hwaccel_get_buffer && frame->format == ist->hwaccel_pix_fmt)
1433  return ist->hwaccel_get_buffer(s, frame, flags);
1434 
1435  return avcodec_default_get_buffer2(s, frame, flags);
1436 }
1437 
1438 static int init_input_stream(int ist_index, char *error, int error_len)
1439 {
1440  int i, ret;
1441  InputStream *ist = input_streams[ist_index];
1442  if (ist->decoding_needed) {
1443  AVCodec *codec = ist->dec;
1444  if (!codec) {
1445  snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1446  ist->st->codec->codec_id, ist->file_index, ist->st->index);
1447  return AVERROR(EINVAL);
1448  }
1449 
1450  /* update requested sample format for the decoder based on the
1451  corresponding encoder sample format */
1452  for (i = 0; i < nb_output_streams; i++) {
1453  OutputStream *ost = output_streams[i];
1454  if (ost->source_index == ist_index) {
1455  update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1456  break;
1457  }
1458  }
1459 
1460  ist->st->codec->opaque = ist;
1461  ist->st->codec->get_format = get_format;
1462  ist->st->codec->get_buffer2 = get_buffer;
1463  ist->st->codec->thread_safe_callbacks = 1;
1464 
1465  av_opt_set_int(ist->st->codec, "refcounted_frames", 1, 0);
1466 
1467  if (!av_dict_get(ist->opts, "threads", NULL, 0))
1468  av_dict_set(&ist->opts, "threads", "auto", 0);
1469  if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
1470  char errbuf[128];
1471  if (ret == AVERROR_EXPERIMENTAL)
1472  abort_codec_experimental(codec, 0);
1473 
1474  av_strerror(ret, errbuf, sizeof(errbuf));
1475 
1476  snprintf(error, error_len,
1477  "Error while opening decoder for input stream "
1478  "#%d:%d : %s",
1479  ist->file_index, ist->st->index, errbuf);
1480  return ret;
1481  }
1482  assert_avoptions(ist->opts);
1483  }
1484 
1485  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;
1486  ist->next_dts = AV_NOPTS_VALUE;
1488  ist->is_start = 1;
1489 
1490  return 0;
1491 }
1492 
1494 {
1495  if (ost->source_index >= 0)
1496  return input_streams[ost->source_index];
1497 
1498  if (ost->filter) {
1499  FilterGraph *fg = ost->filter->graph;
1500  int i;
1501 
1502  for (i = 0; i < fg->nb_inputs; i++)
1503  if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
1504  return fg->inputs[i]->ist;
1505  }
1506 
1507  return NULL;
1508 }
1509 
1510 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1511  AVCodecContext *avctx)
1512 {
1513  char *p;
1514  int n = 1, i;
1515  int64_t t;
1516 
1517  for (p = kf; *p; p++)
1518  if (*p == ',')
1519  n++;
1520  ost->forced_kf_count = n;
1521  ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1522  if (!ost->forced_kf_pts) {
1523  av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1524  exit_program(1);
1525  }
1526 
1527  p = kf;
1528  for (i = 0; i < n; i++) {
1529  char *next = strchr(p, ',');
1530 
1531  if (next)
1532  *next++ = 0;
1533 
1534  t = parse_time_or_die("force_key_frames", p, 1);
1535  ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1536 
1537  p = next;
1538  }
1539 }
1540 
1541 static int transcode_init(void)
1542 {
1543  int ret = 0, i, j, k;
1544  AVFormatContext *oc;
1545  AVCodecContext *codec;
1546  OutputStream *ost;
1547  InputStream *ist;
1548  char error[1024];
1549  int want_sdp = 1;
1550 
1551  /* init framerate emulation */
1552  for (i = 0; i < nb_input_files; i++) {
1553  InputFile *ifile = input_files[i];
1554  if (ifile->rate_emu)
1555  for (j = 0; j < ifile->nb_streams; j++)
1556  input_streams[j + ifile->ist_index]->start = av_gettime();
1557  }
1558 
1559  /* output stream init */
1560  for (i = 0; i < nb_output_files; i++) {
1561  oc = output_files[i]->ctx;
1562  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1563  av_dump_format(oc, i, oc->filename, 1);
1564  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1565  return AVERROR(EINVAL);
1566  }
1567  }
1568 
1569  /* init complex filtergraphs */
1570  for (i = 0; i < nb_filtergraphs; i++)
1571  if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
1572  return ret;
1573 
1574  /* for each output stream, we compute the right encoding parameters */
1575  for (i = 0; i < nb_output_streams; i++) {
1576  AVCodecContext *icodec = NULL;
1577  ost = output_streams[i];
1578  oc = output_files[ost->file_index]->ctx;
1579  ist = get_input_stream(ost);
1580 
1581  if (ost->attachment_filename)
1582  continue;
1583 
1584  codec = ost->st->codec;
1585 
1586  if (ist) {
1587  icodec = ist->st->codec;
1588 
1589  ost->st->disposition = ist->st->disposition;
1590  codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
1592  }
1593 
1594  if (ost->stream_copy) {
1595  AVRational sar;
1596  uint64_t extra_size;
1597 
1598  av_assert0(ist && !ost->filter);
1599 
1600  extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1601 
1602  if (extra_size > INT_MAX) {
1603  return AVERROR(EINVAL);
1604  }
1605 
1606  /* if stream_copy is selected, no need to decode or encode */
1607  codec->codec_id = icodec->codec_id;
1608  codec->codec_type = icodec->codec_type;
1609 
1610  if (!codec->codec_tag) {
1611  if (!oc->oformat->codec_tag ||
1612  av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
1613  av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
1614  codec->codec_tag = icodec->codec_tag;
1615  }
1616 
1617  codec->bit_rate = icodec->bit_rate;
1618  codec->rc_max_rate = icodec->rc_max_rate;
1619  codec->rc_buffer_size = icodec->rc_buffer_size;
1620  codec->field_order = icodec->field_order;
1621  codec->extradata = av_mallocz(extra_size);
1622  if (!codec->extradata) {
1623  return AVERROR(ENOMEM);
1624  }
1625  memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1626  codec->extradata_size = icodec->extradata_size;
1627  if (!copy_tb) {
1628  codec->time_base = icodec->time_base;
1629  codec->time_base.num *= icodec->ticks_per_frame;
1630  av_reduce(&codec->time_base.num, &codec->time_base.den,
1631  codec->time_base.num, codec->time_base.den, INT_MAX);
1632  } else
1633  codec->time_base = ist->st->time_base;
1634 
1635  ost->parser = av_parser_init(codec->codec_id);
1636 
1637  switch (codec->codec_type) {
1638  case AVMEDIA_TYPE_AUDIO:
1639  if (audio_volume != 256) {
1640  av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1641  exit_program(1);
1642  }
1643  codec->channel_layout = icodec->channel_layout;
1644  codec->sample_rate = icodec->sample_rate;
1645  codec->channels = icodec->channels;
1646  codec->frame_size = icodec->frame_size;
1647  codec->audio_service_type = icodec->audio_service_type;
1648  codec->block_align = icodec->block_align;
1649  break;
1650  case AVMEDIA_TYPE_VIDEO:
1651  codec->pix_fmt = icodec->pix_fmt;
1652  codec->width = icodec->width;
1653  codec->height = icodec->height;
1654  codec->has_b_frames = icodec->has_b_frames;
1655  if (ost->frame_aspect_ratio)
1656  sar = av_d2q(ost->frame_aspect_ratio * codec->height / codec->width, 255);
1657  else if (ist->st->sample_aspect_ratio.num)
1658  sar = ist->st->sample_aspect_ratio;
1659  else
1660  sar = icodec->sample_aspect_ratio;
1661  ost->st->sample_aspect_ratio = codec->sample_aspect_ratio = sar;
1662  break;
1663  case AVMEDIA_TYPE_SUBTITLE:
1664  codec->width = icodec->width;
1665  codec->height = icodec->height;
1666  break;
1667  case AVMEDIA_TYPE_DATA:
1669  break;
1670  default:
1671  abort();
1672  }
1673  } else {
1674  if (!ost->enc) {
1675  /* should only happen when a default codec is not present. */
1676  snprintf(error, sizeof(error), "Automatic encoder selection "
1677  "failed for output stream #%d:%d. Default encoder for "
1678  "format %s is probably disabled. Please choose an "
1679  "encoder manually.\n", ost->file_index, ost->index,
1680  oc->oformat->name);
1681  ret = AVERROR(EINVAL);
1682  goto dump_format;
1683  }
1684 
1685  if (ist)
1686  ist->decoding_needed = 1;
1687  ost->encoding_needed = 1;
1688 
1689  /*
1690  * We want CFR output if and only if one of those is true:
1691  * 1) user specified output framerate with -r
1692  * 2) user specified -vsync cfr
1693  * 3) output format is CFR and the user didn't force vsync to
1694  * something else than CFR
1695  *
1696  * in such a case, set ost->frame_rate
1697  */
1698  if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1699  !ost->frame_rate.num && ist &&
1703  if (ist->framerate.num)
1704  ost->frame_rate = ist->framerate;
1705  else if (ist->st->avg_frame_rate.num)
1706  ost->frame_rate = ist->st->avg_frame_rate;
1707  else {
1708  av_log(NULL, AV_LOG_WARNING, "Constant framerate requested "
1709  "for the output stream #%d:%d, but no information "
1710  "about the input framerate is available. Falling "
1711  "back to a default value of 25fps. Use the -r option "
1712  "if you want a different framerate.\n",
1713  ost->file_index, ost->index);
1714  ost->frame_rate = (AVRational){ 25, 1 };
1715  }
1716 
1717  if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
1719  ost->frame_rate = ost->enc->supported_framerates[idx];
1720  }
1721  }
1722 
1723  if (!ost->filter &&
1724  (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
1725  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
1726  FilterGraph *fg;
1727  fg = init_simple_filtergraph(ist, ost);
1728  if (configure_filtergraph(fg)) {
1729  av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
1730  exit_program(1);
1731  }
1732  }
1733 
1734  switch (codec->codec_type) {
1735  case AVMEDIA_TYPE_AUDIO:
1736  codec->sample_fmt = ost->filter->filter->inputs[0]->format;
1737  codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
1738  codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1740  codec->time_base = (AVRational){ 1, codec->sample_rate };
1741  break;
1742  case AVMEDIA_TYPE_VIDEO:
1743  codec->time_base = ost->filter->filter->inputs[0]->time_base;
1744 
1745  codec->width = ost->filter->filter->inputs[0]->w;
1746  codec->height = ost->filter->filter->inputs[0]->h;
1747  codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
1748  ost->frame_aspect_ratio ? // overridden by the -aspect cli option
1749  av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
1751  codec->pix_fmt = ost->filter->filter->inputs[0]->format;
1752 
1753  if (icodec &&
1754  (codec->width != icodec->width ||
1755  codec->height != icodec->height ||
1756  codec->pix_fmt != icodec->pix_fmt)) {
1757  codec->bits_per_raw_sample = 0;
1758  }
1759 
1760  if (ost->forced_keyframes)
1762  ost->st->codec);
1763  break;
1764  case AVMEDIA_TYPE_SUBTITLE:
1765  codec->time_base = (AVRational){1, 1000};
1766  break;
1767  default:
1768  abort();
1769  break;
1770  }
1771  /* two pass mode */
1772  if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1773  char logfilename[1024];
1774  FILE *f;
1775 
1776  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1777  ost->logfile_prefix ? ost->logfile_prefix :
1779  i);
1780  if (!strcmp(ost->enc->name, "libx264")) {
1781  av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1782  } else {
1783  if (codec->flags & CODEC_FLAG_PASS1) {
1784  f = fopen(logfilename, "wb");
1785  if (!f) {
1786  av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1787  logfilename, strerror(errno));
1788  exit_program(1);
1789  }
1790  ost->logfile = f;
1791  } else {
1792  char *logbuffer;
1793  size_t logbuffer_size;
1794  if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
1795  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1796  logfilename);
1797  exit_program(1);
1798  }
1799  codec->stats_in = logbuffer;
1800  }
1801  }
1802  }
1803  }
1804  }
1805 
1806  /* open each encoder */
1807  for (i = 0; i < nb_output_streams; i++) {
1808  ost = output_streams[i];
1809  if (ost->encoding_needed) {
1810  AVCodec *codec = ost->enc;
1811  AVCodecContext *dec = NULL;
1812 
1813  if ((ist = get_input_stream(ost)))
1814  dec = ist->st->codec;
1815  if (dec && dec->subtitle_header) {
1817  if (!ost->st->codec->subtitle_header) {
1818  ret = AVERROR(ENOMEM);
1819  goto dump_format;
1820  }
1821  memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
1823  }
1824  if (!av_dict_get(ost->opts, "threads", NULL, 0))
1825  av_dict_set(&ost->opts, "threads", "auto", 0);
1826  if ((ret = avcodec_open2(ost->st->codec, codec, &ost->opts)) < 0) {
1827  if (ret == AVERROR_EXPERIMENTAL)
1828  abort_codec_experimental(codec, 1);
1829  snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1830  ost->file_index, ost->index);
1831  goto dump_format;
1832  }
1833  assert_avoptions(ost->opts);
1834  if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
1835  av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
1836  "It takes bits/s as argument, not kbits/s\n");
1837  extra_size += ost->st->codec->extradata_size;
1838  } else {
1839  av_opt_set_dict(ost->st->codec, &ost->opts);
1840  }
1841  }
1842 
1843  /* init input streams */
1844  for (i = 0; i < nb_input_streams; i++)
1845  if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
1846  goto dump_format;
1847 
1848  /* discard unused programs */
1849  for (i = 0; i < nb_input_files; i++) {
1850  InputFile *ifile = input_files[i];
1851  for (j = 0; j < ifile->ctx->nb_programs; j++) {
1852  AVProgram *p = ifile->ctx->programs[j];
1853  int discard = AVDISCARD_ALL;
1854 
1855  for (k = 0; k < p->nb_stream_indexes; k++)
1856  if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
1857  discard = AVDISCARD_DEFAULT;
1858  break;
1859  }
1860  p->discard = discard;
1861  }
1862  }
1863 
1864  /* open files and write file headers */
1865  for (i = 0; i < nb_output_files; i++) {
1866  oc = output_files[i]->ctx;
1867  oc->interrupt_callback = int_cb;
1868  if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
1869  char errbuf[128];
1870  av_strerror(ret, errbuf, sizeof(errbuf));
1871  snprintf(error, sizeof(error),
1872  "Could not write header for output file #%d "
1873  "(incorrect codec parameters ?): %s",
1874  i, errbuf);
1875  ret = AVERROR(EINVAL);
1876  goto dump_format;
1877  }
1878  assert_avoptions(output_files[i]->opts);
1879  if (strcmp(oc->oformat->name, "rtp")) {
1880  want_sdp = 0;
1881  }
1882  }
1883 
1884  dump_format:
1885  /* dump the file output parameters - cannot be done before in case
1886  of stream copy */
1887  for (i = 0; i < nb_output_files; i++) {
1888  av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
1889  }
1890 
1891  /* dump the stream mapping */
1892  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
1893  for (i = 0; i < nb_input_streams; i++) {
1894  ist = input_streams[i];
1895 
1896  for (j = 0; j < ist->nb_filters; j++) {
1897  if (ist->filters[j]->graph->graph_desc) {
1898  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
1899  ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
1900  ist->filters[j]->name);
1901  if (nb_filtergraphs > 1)
1902  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
1903  av_log(NULL, AV_LOG_INFO, "\n");
1904  }
1905  }
1906  }
1907 
1908  for (i = 0; i < nb_output_streams; i++) {
1909  ost = output_streams[i];
1910 
1911  if (ost->attachment_filename) {
1912  /* an attached file */
1913  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
1914  ost->attachment_filename, ost->file_index, ost->index);
1915  continue;
1916  }
1917 
1918  if (ost->filter && ost->filter->graph->graph_desc) {
1919  /* output from a complex graph */
1920  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
1921  if (nb_filtergraphs > 1)
1922  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
1923 
1924  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
1925  ost->index, ost->enc ? ost->enc->name : "?");
1926  continue;
1927  }
1928 
1929  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
1930  input_streams[ost->source_index]->file_index,
1931  input_streams[ost->source_index]->st->index,
1932  ost->file_index,
1933  ost->index);
1934  if (ost->sync_ist != input_streams[ost->source_index])
1935  av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
1936  ost->sync_ist->file_index,
1937  ost->sync_ist->st->index);
1938  if (ost->stream_copy)
1939  av_log(NULL, AV_LOG_INFO, " (copy)");
1940  else
1941  av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
1942  input_streams[ost->source_index]->dec->name : "?",
1943  ost->enc ? ost->enc->name : "?");
1944  av_log(NULL, AV_LOG_INFO, "\n");
1945  }
1946 
1947  if (ret) {
1948  av_log(NULL, AV_LOG_ERROR, "%s\n", error);
1949  return ret;
1950  }
1951 
1952  if (want_sdp) {
1953  print_sdp();
1954  }
1955 
1956  return 0;
1957 }
1958 
1959 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
1960 static int need_output(void)
1961 {
1962  int i;
1963 
1964  for (i = 0; i < nb_output_streams; i++) {
1965  OutputStream *ost = output_streams[i];
1966  OutputFile *of = output_files[ost->file_index];
1967  AVFormatContext *os = output_files[ost->file_index]->ctx;
1968 
1969  if (ost->finished ||
1970  (os->pb && avio_tell(os->pb) >= of->limit_filesize))
1971  continue;
1972  if (ost->frame_number >= ost->max_frames) {
1973  int j;
1974  for (j = 0; j < of->ctx->nb_streams; j++)
1975  output_streams[of->ost_index + j]->finished = 1;
1976  continue;
1977  }
1978 
1979  return 1;
1980  }
1981 
1982  return 0;
1983 }
1984 
1986 {
1987  InputFile *ifile = NULL;
1988  int64_t ipts_min = INT64_MAX;
1989  int i;
1990 
1991  for (i = 0; i < nb_input_streams; i++) {
1992  InputStream *ist = input_streams[i];
1993  int64_t ipts = ist->last_dts;
1994 
1995  if (ist->discard || input_files[ist->file_index]->eagain)
1996  continue;
1997  if (!input_files[ist->file_index]->eof_reached) {
1998  if (ipts < ipts_min) {
1999  ipts_min = ipts;
2000  ifile = input_files[ist->file_index];
2001  }
2002  }
2003  }
2004 
2005  return ifile;
2006 }
2007 
2008 #if HAVE_PTHREADS
2009 static void *input_thread(void *arg)
2010 {
2011  InputFile *f = arg;
2012  int ret = 0;
2013 
2014  while (!transcoding_finished && ret >= 0) {
2015  AVPacket pkt;
2016  ret = av_read_frame(f->ctx, &pkt);
2017 
2018  if (ret == AVERROR(EAGAIN)) {
2019  av_usleep(10000);
2020  ret = 0;
2021  continue;
2022  } else if (ret < 0)
2023  break;
2024 
2025  pthread_mutex_lock(&f->fifo_lock);
2026  while (!av_fifo_space(f->fifo))
2027  pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
2028 
2029  av_dup_packet(&pkt);
2030  av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
2031 
2032  pthread_mutex_unlock(&f->fifo_lock);
2033  }
2034 
2035  f->finished = 1;
2036  return NULL;
2037 }
2038 
2039 static void free_input_threads(void)
2040 {
2041  int i;
2042 
2043  if (nb_input_files == 1)
2044  return;
2045 
2046  transcoding_finished = 1;
2047 
2048  for (i = 0; i < nb_input_files; i++) {
2049  InputFile *f = input_files[i];
2050  AVPacket pkt;
2051 
2052  if (!f->fifo || f->joined)
2053  continue;
2054 
2055  pthread_mutex_lock(&f->fifo_lock);
2056  while (av_fifo_size(f->fifo)) {
2057  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2058  av_free_packet(&pkt);
2059  }
2060  pthread_cond_signal(&f->fifo_cond);
2061  pthread_mutex_unlock(&f->fifo_lock);
2062 
2063  pthread_join(f->thread, NULL);
2064  f->joined = 1;
2065 
2066  while (av_fifo_size(f->fifo)) {
2067  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
2068  av_free_packet(&pkt);
2069  }
2070  av_fifo_free(f->fifo);
2071  }
2072 }
2073 
2074 static int init_input_threads(void)
2075 {
2076  int i, ret;
2077 
2078  if (nb_input_files == 1)
2079  return 0;
2080 
2081  for (i = 0; i < nb_input_files; i++) {
2082  InputFile *f = input_files[i];
2083 
2084  if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2085  return AVERROR(ENOMEM);
2086 
2087  pthread_mutex_init(&f->fifo_lock, NULL);
2088  pthread_cond_init (&f->fifo_cond, NULL);
2089 
2090  if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2091  return AVERROR(ret);
2092  }
2093  return 0;
2094 }
2095 
2096 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2097 {
2098  int ret = 0;
2099 
2100  pthread_mutex_lock(&f->fifo_lock);
2101 
2102  if (av_fifo_size(f->fifo)) {
2103  av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2104  pthread_cond_signal(&f->fifo_cond);
2105  } else {
2106  if (f->finished)
2107  ret = AVERROR_EOF;
2108  else
2109  ret = AVERROR(EAGAIN);
2110  }
2111 
2112  pthread_mutex_unlock(&f->fifo_lock);
2113 
2114  return ret;
2115 }
2116 #endif
2117 
2119 {
2120  if (f->rate_emu) {
2121  int i;
2122  for (i = 0; i < f->nb_streams; i++) {
2123  InputStream *ist = input_streams[f->ist_index + i];
2124  int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
2125  int64_t now = av_gettime() - ist->start;
2126  if (pts > now)
2127  return AVERROR(EAGAIN);
2128  }
2129  }
2130 
2131 #if HAVE_PTHREADS
2132  if (nb_input_files > 1)
2133  return get_input_packet_mt(f, pkt);
2134 #endif
2135  return av_read_frame(f->ctx, pkt);
2136 }
2137 
2138 static int got_eagain(void)
2139 {
2140  int i;
2141  for (i = 0; i < nb_input_files; i++)
2142  if (input_files[i]->eagain)
2143  return 1;
2144  return 0;
2145 }
2146 
2147 static void reset_eagain(void)
2148 {
2149  int i;
2150  for (i = 0; i < nb_input_files; i++)
2151  input_files[i]->eagain = 0;
2152 }
2153 
2154 /*
2155  * Read one packet from an input file and send it for
2156  * - decoding -> lavfi (audio/video)
2157  * - decoding -> encoding -> muxing (subtitles)
2158  * - muxing (streamcopy)
2159  *
2160  * Return
2161  * - 0 -- one packet was read and processed
2162  * - AVERROR(EAGAIN) -- no packets were available for selected file,
2163  * this function should be called again
2164  * - AVERROR_EOF -- this function should not be called again
2165  */
2166 static int process_input(void)
2167 {
2168  InputFile *ifile;
2169  AVFormatContext *is;
2170  InputStream *ist;
2171  AVPacket pkt;
2172  int ret, i, j;
2173 
2174  /* select the stream that we must read now */
2175  ifile = select_input_file();
2176  /* if none, if is finished */
2177  if (!ifile) {
2178  if (got_eagain()) {
2179  reset_eagain();
2180  av_usleep(10000);
2181  return AVERROR(EAGAIN);
2182  }
2183  av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
2184  return AVERROR_EOF;
2185  }
2186 
2187  is = ifile->ctx;
2188  ret = get_input_packet(ifile, &pkt);
2189 
2190  if (ret == AVERROR(EAGAIN)) {
2191  ifile->eagain = 1;
2192  return ret;
2193  }
2194  if (ret < 0) {
2195  if (ret != AVERROR_EOF) {
2196  print_error(is->filename, ret);
2197  if (exit_on_error)
2198  exit_program(1);
2199  }
2200  ifile->eof_reached = 1;
2201 
2202  for (i = 0; i < ifile->nb_streams; i++) {
2203  ist = input_streams[ifile->ist_index + i];
2204  if (ist->decoding_needed)
2205  output_packet(ist, NULL);
2206 
2207  /* mark all outputs that don't go through lavfi as finished */
2208  for (j = 0; j < nb_output_streams; j++) {
2209  OutputStream *ost = output_streams[j];
2210 
2211  if (ost->source_index == ifile->ist_index + i &&
2212  (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2213  finish_output_stream(ost);
2214  }
2215  }
2216 
2217  return AVERROR(EAGAIN);
2218  }
2219 
2220  reset_eagain();
2221 
2222  if (do_pkt_dump) {
2224  is->streams[pkt.stream_index]);
2225  }
2226  /* the following test is needed in case new streams appear
2227  dynamically in stream : we ignore them */
2228  if (pkt.stream_index >= ifile->nb_streams)
2229  goto discard_packet;
2230 
2231  ist = input_streams[ifile->ist_index + pkt.stream_index];
2232  if (ist->discard)
2233  goto discard_packet;
2234 
2235  if (pkt.dts != AV_NOPTS_VALUE)
2236  pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2237  if (pkt.pts != AV_NOPTS_VALUE)
2238  pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2239 
2240  if (pkt.pts != AV_NOPTS_VALUE)
2241  pkt.pts *= ist->ts_scale;
2242  if (pkt.dts != AV_NOPTS_VALUE)
2243  pkt.dts *= ist->ts_scale;
2244 
2245  if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
2246  (is->iformat->flags & AVFMT_TS_DISCONT)) {
2247  int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2248  int64_t delta = pkt_dts - ist->next_dts;
2249 
2250  if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2251  ifile->ts_offset -= delta;
2253  "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2254  delta, ifile->ts_offset);
2255  pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2256  if (pkt.pts != AV_NOPTS_VALUE)
2257  pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2258  }
2259  }
2260 
2261  ret = output_packet(ist, &pkt);
2262  if (ret < 0) {
2263  av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2264  ist->file_index, ist->st->index);
2265  if (exit_on_error)
2266  exit_program(1);
2267  }
2268 
2269 discard_packet:
2270  av_free_packet(&pkt);
2271 
2272  return 0;
2273 }
2274 
2275 /*
2276  * The following code is the main loop of the file converter
2277  */
2278 static int transcode(void)
2279 {
2280  int ret, i, need_input = 1;
2281  AVFormatContext *os;
2282  OutputStream *ost;
2283  InputStream *ist;
2284  int64_t timer_start;
2285 
2286  ret = transcode_init();
2287  if (ret < 0)
2288  goto fail;
2289 
2290  av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2291  term_init();
2292 
2293  timer_start = av_gettime();
2294 
2295 #if HAVE_PTHREADS
2296  if ((ret = init_input_threads()) < 0)
2297  goto fail;
2298 #endif
2299 
2300  while (!received_sigterm) {
2301  /* check if there's any stream where output is still needed */
2302  if (!need_output()) {
2303  av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2304  break;
2305  }
2306 
2307  /* read and process one input packet if needed */
2308  if (need_input) {
2309  ret = process_input();
2310  if (ret == AVERROR_EOF)
2311  need_input = 0;
2312  }
2313 
2314  ret = poll_filters();
2315  if (ret < 0) {
2316  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
2317  continue;
2318 
2319  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
2320  break;
2321  }
2322 
2323  /* dump report by using the output first video and audio streams */
2324  print_report(0, timer_start);
2325  }
2326 #if HAVE_PTHREADS
2327  free_input_threads();
2328 #endif
2329 
2330  /* at the end of stream, we must flush the decoder buffers */
2331  for (i = 0; i < nb_input_streams; i++) {
2332  ist = input_streams[i];
2333  if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2334  output_packet(ist, NULL);
2335  }
2336  }
2337  poll_filters();
2338  flush_encoders();
2339 
2340  term_exit();
2341 
2342  /* write the trailer if needed and close file */
2343  for (i = 0; i < nb_output_files; i++) {
2344  os = output_files[i]->ctx;
2345  av_write_trailer(os);
2346  }
2347 
2348  /* dump report by using the first video and audio streams */
2349  print_report(1, timer_start);
2350 
2351  /* close each encoder */
2352  for (i = 0; i < nb_output_streams; i++) {
2353  ost = output_streams[i];
2354  if (ost->encoding_needed) {
2355  av_freep(&ost->st->codec->stats_in);
2356  avcodec_close(ost->st->codec);
2357  }
2358  }
2359 
2360  /* close each decoder */
2361  for (i = 0; i < nb_input_streams; i++) {
2362  ist = input_streams[i];
2363  if (ist->decoding_needed) {
2364  avcodec_close(ist->st->codec);
2365  if (ist->hwaccel_uninit)
2366  ist->hwaccel_uninit(ist->st->codec);
2367  }
2368  }
2369 
2370  /* finished ! */
2371  ret = 0;
2372 
2373  fail:
2374 #if HAVE_PTHREADS
2375  free_input_threads();
2376 #endif
2377 
2378  if (output_streams) {
2379  for (i = 0; i < nb_output_streams; i++) {
2380  ost = output_streams[i];
2381  if (ost) {
2382  if (ost->stream_copy)
2383  av_freep(&ost->st->codec->extradata);
2384  if (ost->logfile) {
2385  fclose(ost->logfile);
2386  ost->logfile = NULL;
2387  }
2388  av_freep(&ost->st->codec->subtitle_header);
2389  av_free(ost->forced_kf_pts);
2390  av_dict_free(&ost->opts);
2391  av_dict_free(&ost->resample_opts);
2392  }
2393  }
2394  }
2395  return ret;
2396 }
2397 
2398 static int64_t getutime(void)
2399 {
2400 #if HAVE_GETRUSAGE
2401  struct rusage rusage;
2402 
2403  getrusage(RUSAGE_SELF, &rusage);
2404  return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2405 #elif HAVE_GETPROCESSTIMES
2406  HANDLE proc;
2407  FILETIME c, e, k, u;
2408  proc = GetCurrentProcess();
2409  GetProcessTimes(proc, &c, &e, &k, &u);
2410  return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2411 #else
2412  return av_gettime();
2413 #endif
2414 }
2415 
2416 static int64_t getmaxrss(void)
2417 {
2418 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2419  struct rusage rusage;
2420  getrusage(RUSAGE_SELF, &rusage);
2421  return (int64_t)rusage.ru_maxrss * 1024;
2422 #elif HAVE_GETPROCESSMEMORYINFO
2423  HANDLE proc;
2424  PROCESS_MEMORY_COUNTERS memcounters;
2425  proc = GetCurrentProcess();
2426  memcounters.cb = sizeof(memcounters);
2427  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2428  return memcounters.PeakPagefileUsage;
2429 #else
2430  return 0;
2431 #endif
2432 }
2433 
2434 int main(int argc, char **argv)
2435 {
2436  int ret;
2437  int64_t ti;
2438 
2440 
2442  parse_loglevel(argc, argv, options);
2443 
2445 #if CONFIG_AVDEVICE
2447 #endif
2449  av_register_all();
2451 
2452  show_banner();
2453 
2454  /* parse options and open all input/output files */
2455  ret = avconv_parse_options(argc, argv);
2456  if (ret < 0)
2457  exit_program(1);
2458 
2459  if (nb_output_files <= 0 && nb_input_files == 0) {
2460  show_usage();
2461  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
2462  exit_program(1);
2463  }
2464 
2465  /* file converter / grab */
2466  if (nb_output_files <= 0) {
2467  fprintf(stderr, "At least one output file must be specified\n");
2468  exit_program(1);
2469  }
2470 
2471  ti = getutime();
2472  if (transcode() < 0)
2473  exit_program(1);
2474  ti = getutime() - ti;
2475  if (do_benchmark) {
2476  int maxrss = getmaxrss() / 1024;
2477  printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
2478  }
2479 
2480  exit_program(0);
2481  return 0;
2482 }
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:1960
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:1541
enum HWAccelID active_hwaccel_id
Definition: avconv.h:256
static int check_output_constraints(InputStream *ist, OutputStream *ost)
Definition: avconv.c:957
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:2138
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:1064
Main libavfilter public API header.
static void flush_encoders(void)
Definition: avconv.c:881
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
static void finish_output_stream(OutputStream *ost)
Definition: avconv.c:690
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:971
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:1390
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:1239
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:2434
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:1493
#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:1428
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:1364
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:1510
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:1263
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:2416
#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:1158
static int64_t getutime(void)
Definition: avconv.c:2398
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:2166
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:711
static const HWAccel * get_hwaccel(enum AVPixelFormat pix_fmt)
Definition: avconv.c:1381
static int get_input_packet(InputFile *f, AVPacket *pkt)
Definition: avconv.c:2118
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:1046
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:2147
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:1985
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:2278
#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:1438
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:749
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