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