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 "libavformat/avformat.h"
31 #include "libavdevice/avdevice.h"
32 #include "libswscale/swscale.h"
34 #include "libavutil/opt.h"
36 #include "libavutil/parseutils.h"
37 #include "libavutil/samplefmt.h"
38 #include "libavutil/colorspace.h"
39 #include "libavutil/fifo.h"
40 #include "libavutil/intreadwrite.h"
41 #include "libavutil/dict.h"
42 #include "libavutil/mathematics.h"
43 #include "libavutil/pixdesc.h"
44 #include "libavutil/avstring.h"
45 #include "libavutil/libm.h"
46 #include "libavutil/imgutils.h"
47 #include "libavutil/time.h"
48 #include "libavformat/os_support.h"
49 
50 # include "libavfilter/avfilter.h"
52 # include "libavfilter/buffersrc.h"
53 # include "libavfilter/buffersink.h"
54 
55 #if HAVE_SYS_RESOURCE_H
56 #include <sys/time.h>
57 #include <sys/types.h>
58 #include <sys/resource.h>
59 #elif HAVE_GETPROCESSTIMES
60 #include <windows.h>
61 #endif
62 #if HAVE_GETPROCESSMEMORYINFO
63 #include <windows.h>
64 #include <psapi.h>
65 #endif
66 
67 #if HAVE_SYS_SELECT_H
68 #include <sys/select.h>
69 #endif
70 
71 #if HAVE_PTHREADS
72 #include <pthread.h>
73 #endif
74 
75 #include <time.h>
76 
77 #include "avconv.h"
78 #include "cmdutils.h"
79 
80 #include "libavutil/avassert.h"
81 
82 const char program_name[] = "avconv";
83 const int program_birth_year = 2000;
84 
85 static FILE *vstats_file;
86 
87 static int64_t video_size = 0;
88 static int64_t audio_size = 0;
89 static int64_t extra_size = 0;
90 static int nb_frames_dup = 0;
91 static int nb_frames_drop = 0;
92 
93 
94 
95 #if HAVE_PTHREADS
96 /* signal to input threads that they should exit; set by the main thread */
97 static int transcoding_finished;
98 #endif
99 
100 #define DEFAULT_PASS_LOGFILENAME_PREFIX "av2pass"
101 
106 
111 
114 
115 static void term_exit(void)
116 {
117  av_log(NULL, AV_LOG_QUIET, "");
118 }
119 
120 static volatile int received_sigterm = 0;
121 static volatile int received_nb_signals = 0;
122 
123 static void
125 {
126  received_sigterm = sig;
128  term_exit();
129 }
130 
131 static void term_init(void)
132 {
133  signal(SIGINT , sigterm_handler); /* Interrupt (ANSI). */
134  signal(SIGTERM, sigterm_handler); /* Termination (ANSI). */
135 #ifdef SIGXCPU
136  signal(SIGXCPU, sigterm_handler);
137 #endif
138 }
139 
140 static int decode_interrupt_cb(void *ctx)
141 {
142  return received_nb_signals > 1;
143 }
144 
146 
147 static void exit_program(void)
148 {
149  int i, j;
150 
151  for (i = 0; i < nb_filtergraphs; i++) {
152  avfilter_graph_free(&filtergraphs[i]->graph);
153  for (j = 0; j < filtergraphs[i]->nb_inputs; j++) {
154  av_freep(&filtergraphs[i]->inputs[j]->name);
155  av_freep(&filtergraphs[i]->inputs[j]);
156  }
157  av_freep(&filtergraphs[i]->inputs);
158  for (j = 0; j < filtergraphs[i]->nb_outputs; j++) {
159  av_freep(&filtergraphs[i]->outputs[j]->name);
160  av_freep(&filtergraphs[i]->outputs[j]);
161  }
162  av_freep(&filtergraphs[i]->outputs);
163  av_freep(&filtergraphs[i]);
164  }
165  av_freep(&filtergraphs);
166 
167  /* close files */
168  for (i = 0; i < nb_output_files; i++) {
169  AVFormatContext *s = output_files[i]->ctx;
170  if (!(s->oformat->flags & AVFMT_NOFILE) && s->pb)
171  avio_close(s->pb);
173  av_dict_free(&output_files[i]->opts);
174  av_freep(&output_files[i]);
175  }
176  for (i = 0; i < nb_output_streams; i++) {
177  AVBitStreamFilterContext *bsfc = output_streams[i]->bitstream_filters;
178  while (bsfc) {
179  AVBitStreamFilterContext *next = bsfc->next;
181  bsfc = next;
182  }
183  output_streams[i]->bitstream_filters = NULL;
184  avcodec_free_frame(&output_streams[i]->filtered_frame);
185 
186  av_freep(&output_streams[i]->forced_keyframes);
187  av_freep(&output_streams[i]->avfilter);
188  av_freep(&output_streams[i]->logfile_prefix);
189  av_freep(&output_streams[i]);
190  }
191  for (i = 0; i < nb_input_files; i++) {
192  avformat_close_input(&input_files[i]->ctx);
193  av_freep(&input_files[i]);
194  }
195  for (i = 0; i < nb_input_streams; i++) {
196  avcodec_free_frame(&input_streams[i]->decoded_frame);
197  av_dict_free(&input_streams[i]->opts);
198  free_buffer_pool(&input_streams[i]->buffer_pool);
199  av_freep(&input_streams[i]->filters);
200  av_freep(&input_streams[i]);
201  }
202 
203  if (vstats_file)
204  fclose(vstats_file);
206 
207  av_freep(&input_streams);
208  av_freep(&input_files);
209  av_freep(&output_streams);
210  av_freep(&output_files);
211 
212  uninit_opts();
213 
214  avfilter_uninit();
216 
217  if (received_sigterm) {
218  av_log(NULL, AV_LOG_INFO, "Received signal %d: terminating.\n",
219  (int) received_sigterm);
220  exit (255);
221  }
222 }
223 
225 {
227  if ((t = av_dict_get(m, "", NULL, AV_DICT_IGNORE_SUFFIX))) {
228  av_log(NULL, AV_LOG_FATAL, "Option %s not found.\n", t->key);
229  exit(1);
230  }
231 }
232 
233 static void abort_codec_experimental(AVCodec *c, int encoder)
234 {
235  const char *codec_string = encoder ? "encoder" : "decoder";
236  AVCodec *codec;
237  av_log(NULL, AV_LOG_FATAL, "%s '%s' is experimental and might produce bad "
238  "results.\nAdd '-strict experimental' if you want to use it.\n",
239  codec_string, c->name);
240  codec = encoder ? avcodec_find_encoder(c->id) : avcodec_find_decoder(c->id);
241  if (!(codec->capabilities & CODEC_CAP_EXPERIMENTAL))
242  av_log(NULL, AV_LOG_FATAL, "Or use the non experimental %s '%s'.\n",
243  codec_string, codec->name);
244  exit(1);
245 }
246 
247 /*
248  * Update the requested input sample format based on the output sample format.
249  * This is currently only used to request float output from decoders which
250  * support multiple sample formats, one of which is AV_SAMPLE_FMT_FLT.
251  * Ideally this will be removed in the future when decoders do not do format
252  * conversion and only output in their native format.
253  */
254 static void update_sample_fmt(AVCodecContext *dec, AVCodec *dec_codec,
255  AVCodecContext *enc)
256 {
257  /* if sample formats match or a decoder sample format has already been
258  requested, just return */
259  if (enc->sample_fmt == dec->sample_fmt ||
261  return;
262 
263  /* if decoder supports more than one output format */
264  if (dec_codec && dec_codec->sample_fmts &&
265  dec_codec->sample_fmts[0] != AV_SAMPLE_FMT_NONE &&
266  dec_codec->sample_fmts[1] != AV_SAMPLE_FMT_NONE) {
267  const enum AVSampleFormat *p;
268  int min_dec = INT_MAX, min_inc = INT_MAX;
269  enum AVSampleFormat dec_fmt = AV_SAMPLE_FMT_NONE;
270  enum AVSampleFormat inc_fmt = AV_SAMPLE_FMT_NONE;
271 
272  /* find a matching sample format in the encoder */
273  for (p = dec_codec->sample_fmts; *p != AV_SAMPLE_FMT_NONE; p++) {
274  if (*p == enc->sample_fmt) {
275  dec->request_sample_fmt = *p;
276  return;
277  } else {
280  int fmt_diff = 32 * abs(dfmt - efmt);
281  if (av_sample_fmt_is_planar(*p) !=
283  fmt_diff++;
284  if (dfmt == efmt) {
285  min_inc = fmt_diff;
286  inc_fmt = *p;
287  } else if (dfmt > efmt) {
288  if (fmt_diff < min_inc) {
289  min_inc = fmt_diff;
290  inc_fmt = *p;
291  }
292  } else {
293  if (fmt_diff < min_dec) {
294  min_dec = fmt_diff;
295  dec_fmt = *p;
296  }
297  }
298  }
299  }
300 
301  /* if none match, provide the one that matches quality closest */
302  dec->request_sample_fmt = min_inc != INT_MAX ? inc_fmt : dec_fmt;
303  }
304 }
305 
307 {
309  AVCodecContext *avctx = ost->st->codec;
310  int ret;
311 
312  /*
313  * Audio encoders may split the packets -- #frames in != #packets out.
314  * But there is no reordering, so we can limit the number of output packets
315  * by simply dropping them here.
316  * Counting encoded video frames needs to be done separately because of
317  * reordering, see do_video_out()
318  */
319  if (!(avctx->codec_type == AVMEDIA_TYPE_VIDEO && avctx->codec)) {
320  if (ost->frame_number >= ost->max_frames) {
321  av_free_packet(pkt);
322  return;
323  }
324  ost->frame_number++;
325  }
326 
327  while (bsfc) {
328  AVPacket new_pkt = *pkt;
329  int a = av_bitstream_filter_filter(bsfc, avctx, NULL,
330  &new_pkt.data, &new_pkt.size,
331  pkt->data, pkt->size,
332  pkt->flags & AV_PKT_FLAG_KEY);
333  if (a > 0) {
334  av_free_packet(pkt);
335  new_pkt.destruct = av_destruct_packet;
336  } else if (a < 0) {
337  av_log(NULL, AV_LOG_ERROR, "%s failed for stream %d, codec %s",
338  bsfc->filter->name, pkt->stream_index,
339  avctx->codec ? avctx->codec->name : "copy");
340  print_error("", a);
341  if (exit_on_error)
342  exit(1);
343  }
344  *pkt = new_pkt;
345 
346  bsfc = bsfc->next;
347  }
348 
349  pkt->stream_index = ost->index;
350  ret = av_interleaved_write_frame(s, pkt);
351  if (ret < 0) {
352  print_error("av_interleaved_write_frame()", ret);
353  exit(1);
354  }
355 }
356 
358 {
359  OutputFile *of = output_files[ost->file_index];
360 
361  if (of->recording_time != INT64_MAX &&
363  AV_TIME_BASE_Q) >= 0) {
364  ost->finished = 1;
365  return 0;
366  }
367  return 1;
368 }
369 
371  AVFrame *frame)
372 {
373  AVCodecContext *enc = ost->st->codec;
374  AVPacket pkt;
375  int got_packet = 0;
376 
377  av_init_packet(&pkt);
378  pkt.data = NULL;
379  pkt.size = 0;
380 
381  if (!check_recording_time(ost))
382  return;
383 
384  if (frame->pts == AV_NOPTS_VALUE || audio_sync_method < 0)
385  frame->pts = ost->sync_opts;
386  ost->sync_opts = frame->pts + frame->nb_samples;
387 
388  if (avcodec_encode_audio2(enc, &pkt, frame, &got_packet) < 0) {
389  av_log(NULL, AV_LOG_FATAL, "Audio encoding failed\n");
390  exit(1);
391  }
392 
393  if (got_packet) {
394  if (pkt.pts != AV_NOPTS_VALUE)
395  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
396  if (pkt.dts != AV_NOPTS_VALUE)
397  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
398  if (pkt.duration > 0)
399  pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
400 
401  write_frame(s, &pkt, ost);
402 
403  audio_size += pkt.size;
404  }
405 }
406 
407 static void pre_process_video_frame(InputStream *ist, AVPicture *picture, void **bufp)
408 {
409  AVCodecContext *dec;
410  AVPicture *picture2;
411  AVPicture picture_tmp;
412  uint8_t *buf = 0;
413 
414  dec = ist->st->codec;
415 
416  /* deinterlace : must be done before any resize */
417  if (do_deinterlace) {
418  int size;
419 
420  /* create temporary picture */
421  size = avpicture_get_size(dec->pix_fmt, dec->width, dec->height);
422  buf = av_malloc(size);
423  if (!buf)
424  return;
425 
426  picture2 = &picture_tmp;
427  avpicture_fill(picture2, buf, dec->pix_fmt, dec->width, dec->height);
428 
429  if (avpicture_deinterlace(picture2, picture,
430  dec->pix_fmt, dec->width, dec->height) < 0) {
431  /* if error, do not deinterlace */
432  av_log(NULL, AV_LOG_WARNING, "Deinterlacing failed\n");
433  av_free(buf);
434  buf = NULL;
435  picture2 = picture;
436  }
437  } else {
438  picture2 = picture;
439  }
440 
441  if (picture != picture2)
442  *picture = *picture2;
443  *bufp = buf;
444 }
445 
447  OutputStream *ost,
448  InputStream *ist,
449  AVSubtitle *sub,
450  int64_t pts)
451 {
452  static uint8_t *subtitle_out = NULL;
453  int subtitle_out_max_size = 1024 * 1024;
454  int subtitle_out_size, nb, i;
455  AVCodecContext *enc;
456  AVPacket pkt;
457 
458  if (pts == AV_NOPTS_VALUE) {
459  av_log(NULL, AV_LOG_ERROR, "Subtitle packets must have a pts\n");
460  if (exit_on_error)
461  exit(1);
462  return;
463  }
464 
465  enc = ost->st->codec;
466 
467  if (!subtitle_out) {
468  subtitle_out = av_malloc(subtitle_out_max_size);
469  }
470 
471  /* Note: DVB subtitle need one packet to draw them and one other
472  packet to clear them */
473  /* XXX: signal it in the codec context ? */
475  nb = 2;
476  else
477  nb = 1;
478 
479  for (i = 0; i < nb; i++) {
480  ost->sync_opts = av_rescale_q(pts, ist->st->time_base, enc->time_base);
481  if (!check_recording_time(ost))
482  return;
483 
484  sub->pts = av_rescale_q(pts, ist->st->time_base, AV_TIME_BASE_Q);
485  // start_display_time is required to be 0
486  sub->pts += av_rescale_q(sub->start_display_time, (AVRational){ 1, 1000 }, AV_TIME_BASE_Q);
488  sub->start_display_time = 0;
489  subtitle_out_size = avcodec_encode_subtitle(enc, subtitle_out,
490  subtitle_out_max_size, sub);
491  if (subtitle_out_size < 0) {
492  av_log(NULL, AV_LOG_FATAL, "Subtitle encoding failed\n");
493  exit(1);
494  }
495 
496  av_init_packet(&pkt);
497  pkt.data = subtitle_out;
498  pkt.size = subtitle_out_size;
499  pkt.pts = av_rescale_q(sub->pts, AV_TIME_BASE_Q, ost->st->time_base);
500  if (enc->codec_id == AV_CODEC_ID_DVB_SUBTITLE) {
501  /* XXX: the pts correction is handled here. Maybe handling
502  it in the codec would be better */
503  if (i == 0)
504  pkt.pts += 90 * sub->start_display_time;
505  else
506  pkt.pts += 90 * sub->end_display_time;
507  }
508  write_frame(s, &pkt, ost);
509  }
510 }
511 
513  OutputStream *ost,
514  AVFrame *in_picture,
515  int *frame_size)
516 {
517  int ret, format_video_sync;
518  AVPacket pkt;
519  AVCodecContext *enc = ost->st->codec;
520 
521  *frame_size = 0;
522 
523  format_video_sync = video_sync_method;
524  if (format_video_sync == VSYNC_AUTO)
525  format_video_sync = (s->oformat->flags & AVFMT_NOTIMESTAMPS) ? VSYNC_PASSTHROUGH :
527  if (format_video_sync != VSYNC_PASSTHROUGH &&
528  ost->frame_number &&
529  in_picture->pts != AV_NOPTS_VALUE &&
530  in_picture->pts < ost->sync_opts) {
531  nb_frames_drop++;
532  av_log(NULL, AV_LOG_VERBOSE, "*** drop!\n");
533  return;
534  }
535 
536  if (in_picture->pts == AV_NOPTS_VALUE)
537  in_picture->pts = ost->sync_opts;
538  ost->sync_opts = in_picture->pts;
539 
540 
541  if (!ost->frame_number)
542  ost->first_pts = in_picture->pts;
543 
544  av_init_packet(&pkt);
545  pkt.data = NULL;
546  pkt.size = 0;
547 
548  if (!check_recording_time(ost) ||
549  ost->frame_number >= ost->max_frames)
550  return;
551 
552  if (s->oformat->flags & AVFMT_RAWPICTURE &&
553  enc->codec->id == AV_CODEC_ID_RAWVIDEO) {
554  /* raw pictures are written as AVPicture structure to
555  avoid any copies. We support temporarily the older
556  method. */
557  enc->coded_frame->interlaced_frame = in_picture->interlaced_frame;
558  enc->coded_frame->top_field_first = in_picture->top_field_first;
559  pkt.data = (uint8_t *)in_picture;
560  pkt.size = sizeof(AVPicture);
561  pkt.pts = av_rescale_q(in_picture->pts, enc->time_base, ost->st->time_base);
562  pkt.flags |= AV_PKT_FLAG_KEY;
563 
564  write_frame(s, &pkt, ost);
565  } else {
566  int got_packet;
567  AVFrame big_picture;
568 
569  big_picture = *in_picture;
570  /* better than nothing: use input picture interlaced
571  settings */
572  big_picture.interlaced_frame = in_picture->interlaced_frame;
574  if (ost->top_field_first == -1)
575  big_picture.top_field_first = in_picture->top_field_first;
576  else
577  big_picture.top_field_first = !!ost->top_field_first;
578  }
579 
580  big_picture.quality = ost->st->codec->global_quality;
581  if (!enc->me_threshold)
582  big_picture.pict_type = 0;
583  if (ost->forced_kf_index < ost->forced_kf_count &&
584  big_picture.pts >= ost->forced_kf_pts[ost->forced_kf_index]) {
585  big_picture.pict_type = AV_PICTURE_TYPE_I;
586  ost->forced_kf_index++;
587  }
588  ret = avcodec_encode_video2(enc, &pkt, &big_picture, &got_packet);
589  if (ret < 0) {
590  av_log(NULL, AV_LOG_FATAL, "Video encoding failed\n");
591  exit(1);
592  }
593 
594  if (got_packet) {
595  if (pkt.pts != AV_NOPTS_VALUE)
596  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
597  if (pkt.dts != AV_NOPTS_VALUE)
598  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
599 
600  write_frame(s, &pkt, ost);
601  *frame_size = pkt.size;
602  video_size += pkt.size;
603 
604  /* if two pass, output log */
605  if (ost->logfile && enc->stats_out) {
606  fprintf(ost->logfile, "%s", enc->stats_out);
607  }
608  }
609  }
610  ost->sync_opts++;
611  /*
612  * For video, number of frames in == number of packets out.
613  * But there may be reordering, so we can't throw away frames on encoder
614  * flush, we need to limit them here, before they go into encoder.
615  */
616  ost->frame_number++;
617 }
618 
619 static double psnr(double d)
620 {
621  return -10.0 * log(d) / log(10.0);
622 }
623 
624 static void do_video_stats(OutputStream *ost, int frame_size)
625 {
626  AVCodecContext *enc;
627  int frame_number;
628  double ti1, bitrate, avg_bitrate;
629 
630  /* this is executed just the first time do_video_stats is called */
631  if (!vstats_file) {
632  vstats_file = fopen(vstats_filename, "w");
633  if (!vstats_file) {
634  perror("fopen");
635  exit(1);
636  }
637  }
638 
639  enc = ost->st->codec;
640  if (enc->codec_type == AVMEDIA_TYPE_VIDEO) {
641  frame_number = ost->frame_number;
642  fprintf(vstats_file, "frame= %5d q= %2.1f ", frame_number, enc->coded_frame->quality / (float)FF_QP2LAMBDA);
643  if (enc->flags&CODEC_FLAG_PSNR)
644  fprintf(vstats_file, "PSNR= %6.2f ", psnr(enc->coded_frame->error[0] / (enc->width * enc->height * 255.0 * 255.0)));
645 
646  fprintf(vstats_file,"f_size= %6d ", frame_size);
647  /* compute pts value */
648  ti1 = ost->sync_opts * av_q2d(enc->time_base);
649  if (ti1 < 0.01)
650  ti1 = 0.01;
651 
652  bitrate = (frame_size * 8) / av_q2d(enc->time_base) / 1000.0;
653  avg_bitrate = (double)(video_size * 8) / ti1 / 1000.0;
654  fprintf(vstats_file, "s_size= %8.0fkB time= %0.3f br= %7.1fkbits/s avg_br= %7.1fkbits/s ",
655  (double)video_size / 1024, ti1, bitrate, avg_bitrate);
656  fprintf(vstats_file, "type= %c\n", av_get_picture_type_char(enc->coded_frame->pict_type));
657  }
658 }
659 
660 /*
661  * Read one frame for lavfi output for ost and encode it.
662  */
663 static int poll_filter(OutputStream *ost)
664 {
665  OutputFile *of = output_files[ost->file_index];
666  AVFilterBufferRef *picref;
667  AVFrame *filtered_frame = NULL;
668  int frame_size, ret;
669 
670  if (!ost->filtered_frame && !(ost->filtered_frame = avcodec_alloc_frame())) {
671  return AVERROR(ENOMEM);
672  } else
674  filtered_frame = ost->filtered_frame;
675 
676  if (ost->enc->type == AVMEDIA_TYPE_AUDIO &&
678  ret = av_buffersink_read_samples(ost->filter->filter, &picref,
679  ost->st->codec->frame_size);
680  else
681  ret = av_buffersink_read(ost->filter->filter, &picref);
682 
683  if (ret < 0)
684  return ret;
685 
686  avfilter_copy_buf_props(filtered_frame, picref);
687  if (picref->pts != AV_NOPTS_VALUE) {
688  filtered_frame->pts = av_rescale_q(picref->pts,
689  ost->filter->filter->inputs[0]->time_base,
690  ost->st->codec->time_base) -
693  ost->st->codec->time_base);
694 
695  if (of->start_time && filtered_frame->pts < 0) {
696  avfilter_unref_buffer(picref);
697  return 0;
698  }
699  }
700 
701  switch (ost->filter->filter->inputs[0]->type) {
702  case AVMEDIA_TYPE_VIDEO:
703  if (!ost->frame_aspect_ratio)
704  ost->st->codec->sample_aspect_ratio = picref->video->pixel_aspect;
705 
706  do_video_out(of->ctx, ost, filtered_frame, &frame_size);
707  if (vstats_filename && frame_size)
708  do_video_stats(ost, frame_size);
709  break;
710  case AVMEDIA_TYPE_AUDIO:
711  do_audio_out(of->ctx, ost, filtered_frame);
712  break;
713  default:
714  // TODO support subtitle filters
715  av_assert0(0);
716  }
717 
718  avfilter_unref_buffer(picref);
719 
720  return 0;
721 }
722 
723 /*
724  * Read as many frames from possible from lavfi and encode them.
725  *
726  * Always read from the active stream with the lowest timestamp. If no frames
727  * are available for it then return EAGAIN and wait for more input. This way we
728  * can use lavfi sources that generate unlimited amount of frames without memory
729  * usage exploding.
730  */
731 static int poll_filters(void)
732 {
733  int i, j, ret = 0;
734 
735  while (ret >= 0 && !received_sigterm) {
736  OutputStream *ost = NULL;
737  int64_t min_pts = INT64_MAX;
738 
739  /* choose output stream with the lowest timestamp */
740  for (i = 0; i < nb_output_streams; i++) {
741  int64_t pts = output_streams[i]->sync_opts;
742 
743  if (!output_streams[i]->filter || output_streams[i]->finished)
744  continue;
745 
746  pts = av_rescale_q(pts, output_streams[i]->st->codec->time_base,
748  if (pts < min_pts) {
749  min_pts = pts;
750  ost = output_streams[i];
751  }
752  }
753 
754  if (!ost)
755  break;
756 
757  ret = poll_filter(ost);
758 
759  if (ret == AVERROR_EOF) {
760  OutputFile *of = output_files[ost->file_index];
761 
762  ost->finished = 1;
763 
764  if (of->shortest) {
765  for (j = 0; j < of->ctx->nb_streams; j++)
766  output_streams[of->ost_index + j]->finished = 1;
767  }
768 
769  ret = 0;
770  } else if (ret == AVERROR(EAGAIN))
771  return 0;
772  }
773 
774  return ret;
775 }
776 
777 static void print_report(int is_last_report, int64_t timer_start)
778 {
779  char buf[1024];
780  OutputStream *ost;
781  AVFormatContext *oc;
782  int64_t total_size;
783  AVCodecContext *enc;
784  int frame_number, vid, i;
785  double bitrate, ti1, pts;
786  static int64_t last_time = -1;
787  static int qp_histogram[52];
788 
789  if (!print_stats && !is_last_report)
790  return;
791 
792  if (!is_last_report) {
793  int64_t cur_time;
794  /* display the report every 0.5 seconds */
795  cur_time = av_gettime();
796  if (last_time == -1) {
797  last_time = cur_time;
798  return;
799  }
800  if ((cur_time - last_time) < 500000)
801  return;
802  last_time = cur_time;
803  }
804 
805 
806  oc = output_files[0]->ctx;
807 
808  total_size = avio_size(oc->pb);
809  if (total_size <= 0) // FIXME improve avio_size() so it works with non seekable output too
810  total_size = avio_tell(oc->pb);
811  if (total_size < 0) {
812  char errbuf[128];
813  av_strerror(total_size, errbuf, sizeof(errbuf));
814  av_log(NULL, AV_LOG_VERBOSE, "Bitrate not available, "
815  "avio_tell() failed: %s\n", errbuf);
816  total_size = 0;
817  }
818 
819  buf[0] = '\0';
820  ti1 = 1e10;
821  vid = 0;
822  for (i = 0; i < nb_output_streams; i++) {
823  float q = -1;
824  ost = output_streams[i];
825  enc = ost->st->codec;
826  if (!ost->stream_copy && enc->coded_frame)
827  q = enc->coded_frame->quality / (float)FF_QP2LAMBDA;
828  if (vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
829  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "q=%2.1f ", q);
830  }
831  if (!vid && enc->codec_type == AVMEDIA_TYPE_VIDEO) {
832  float t = (av_gettime() - timer_start) / 1000000.0;
833 
834  frame_number = ost->frame_number;
835  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "frame=%5d fps=%3d q=%3.1f ",
836  frame_number, (t > 1) ? (int)(frame_number / t + 0.5) : 0, q);
837  if (is_last_report)
838  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "L");
839  if (qp_hist) {
840  int j;
841  int qp = lrintf(q);
842  if (qp >= 0 && qp < FF_ARRAY_ELEMS(qp_histogram))
843  qp_histogram[qp]++;
844  for (j = 0; j < 32; j++)
845  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%X", (int)lrintf(log2(qp_histogram[j] + 1)));
846  }
847  if (enc->flags&CODEC_FLAG_PSNR) {
848  int j;
849  double error, error_sum = 0;
850  double scale, scale_sum = 0;
851  char type[3] = { 'Y','U','V' };
852  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "PSNR=");
853  for (j = 0; j < 3; j++) {
854  if (is_last_report) {
855  error = enc->error[j];
856  scale = enc->width * enc->height * 255.0 * 255.0 * frame_number;
857  } else {
858  error = enc->coded_frame->error[j];
859  scale = enc->width * enc->height * 255.0 * 255.0;
860  }
861  if (j)
862  scale /= 4;
863  error_sum += error;
864  scale_sum += scale;
865  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "%c:%2.2f ", type[j], psnr(error / scale));
866  }
867  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), "*:%2.2f ", psnr(error_sum / scale_sum));
868  }
869  vid = 1;
870  }
871  /* compute min output value */
872  pts = (double)ost->st->pts.val * av_q2d(ost->st->time_base);
873  if ((pts < ti1) && (pts > 0))
874  ti1 = pts;
875  }
876  if (ti1 < 0.01)
877  ti1 = 0.01;
878 
879  bitrate = (double)(total_size * 8) / ti1 / 1000.0;
880 
881  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf),
882  "size=%8.0fkB time=%0.2f bitrate=%6.1fkbits/s",
883  (double)total_size / 1024, ti1, bitrate);
884 
886  snprintf(buf + strlen(buf), sizeof(buf) - strlen(buf), " dup=%d drop=%d",
888 
889  av_log(NULL, AV_LOG_INFO, "%s \r", buf);
890 
891  fflush(stderr);
892 
893  if (is_last_report) {
894  int64_t raw= audio_size + video_size + extra_size;
895  av_log(NULL, AV_LOG_INFO, "\n");
896  av_log(NULL, AV_LOG_INFO, "video:%1.0fkB audio:%1.0fkB global headers:%1.0fkB muxing overhead %f%%\n",
897  video_size / 1024.0,
898  audio_size / 1024.0,
899  extra_size / 1024.0,
900  100.0 * (total_size - raw) / raw
901  );
902  }
903 }
904 
905 static void flush_encoders(void)
906 {
907  int i, ret;
908 
909  for (i = 0; i < nb_output_streams; i++) {
910  OutputStream *ost = output_streams[i];
911  AVCodecContext *enc = ost->st->codec;
912  AVFormatContext *os = output_files[ost->file_index]->ctx;
913  int stop_encoding = 0;
914 
915  if (!ost->encoding_needed)
916  continue;
917 
918  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO && enc->frame_size <= 1)
919  continue;
921  continue;
922 
923  for (;;) {
924  int (*encode)(AVCodecContext*, AVPacket*, const AVFrame*, int*) = NULL;
925  const char *desc;
926  int64_t *size;
927 
928  switch (ost->st->codec->codec_type) {
929  case AVMEDIA_TYPE_AUDIO:
930  encode = avcodec_encode_audio2;
931  desc = "Audio";
932  size = &audio_size;
933  break;
934  case AVMEDIA_TYPE_VIDEO:
935  encode = avcodec_encode_video2;
936  desc = "Video";
937  size = &video_size;
938  break;
939  default:
940  stop_encoding = 1;
941  }
942 
943  if (encode) {
944  AVPacket pkt;
945  int got_packet;
946  av_init_packet(&pkt);
947  pkt.data = NULL;
948  pkt.size = 0;
949 
950  ret = encode(enc, &pkt, NULL, &got_packet);
951  if (ret < 0) {
952  av_log(NULL, AV_LOG_FATAL, "%s encoding failed\n", desc);
953  exit(1);
954  }
955  *size += ret;
956  if (ost->logfile && enc->stats_out) {
957  fprintf(ost->logfile, "%s", enc->stats_out);
958  }
959  if (!got_packet) {
960  stop_encoding = 1;
961  break;
962  }
963  if (pkt.pts != AV_NOPTS_VALUE)
964  pkt.pts = av_rescale_q(pkt.pts, enc->time_base, ost->st->time_base);
965  if (pkt.dts != AV_NOPTS_VALUE)
966  pkt.dts = av_rescale_q(pkt.dts, enc->time_base, ost->st->time_base);
967  if (pkt.duration > 0)
968  pkt.duration = av_rescale_q(pkt.duration, enc->time_base, ost->st->time_base);
969  write_frame(os, &pkt, ost);
970  }
971 
972  if (stop_encoding)
973  break;
974  }
975  }
976 }
977 
978 /*
979  * Check whether a packet from ist should be written into ost at this time
980  */
982 {
983  OutputFile *of = output_files[ost->file_index];
984  int ist_index = input_files[ist->file_index]->ist_index + ist->st->index;
985 
986  if (ost->source_index != ist_index)
987  return 0;
988 
989  if (of->start_time && ist->last_dts < of->start_time)
990  return 0;
991 
992  return 1;
993 }
994 
995 static void do_streamcopy(InputStream *ist, OutputStream *ost, const AVPacket *pkt)
996 {
997  OutputFile *of = output_files[ost->file_index];
998  int64_t ost_tb_start_time = av_rescale_q(of->start_time, AV_TIME_BASE_Q, ost->st->time_base);
999  AVPacket opkt;
1000 
1001  av_init_packet(&opkt);
1002 
1003  if ((!ost->frame_number && !(pkt->flags & AV_PKT_FLAG_KEY)) &&
1005  return;
1006 
1007  if (of->recording_time != INT64_MAX &&
1008  ist->last_dts >= of->recording_time + of->start_time) {
1009  ost->finished = 1;
1010  return;
1011  }
1012 
1013  /* force the input stream PTS */
1014  if (ost->st->codec->codec_type == AVMEDIA_TYPE_AUDIO)
1015  audio_size += pkt->size;
1016  else if (ost->st->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
1017  video_size += pkt->size;
1018  ost->sync_opts++;
1019  }
1020 
1021  if (pkt->pts != AV_NOPTS_VALUE)
1022  opkt.pts = av_rescale_q(pkt->pts, ist->st->time_base, ost->st->time_base) - ost_tb_start_time;
1023  else
1024  opkt.pts = AV_NOPTS_VALUE;
1025 
1026  if (pkt->dts == AV_NOPTS_VALUE)
1027  opkt.dts = av_rescale_q(ist->last_dts, AV_TIME_BASE_Q, ost->st->time_base);
1028  else
1029  opkt.dts = av_rescale_q(pkt->dts, ist->st->time_base, ost->st->time_base);
1030  opkt.dts -= ost_tb_start_time;
1031 
1032  opkt.duration = av_rescale_q(pkt->duration, ist->st->time_base, ost->st->time_base);
1033  opkt.flags = pkt->flags;
1034 
1035  // FIXME remove the following 2 lines they shall be replaced by the bitstream filters
1036  if ( ost->st->codec->codec_id != AV_CODEC_ID_H264
1039  && ost->st->codec->codec_id != AV_CODEC_ID_VC1
1040  ) {
1041  if (av_parser_change(ist->st->parser, ost->st->codec, &opkt.data, &opkt.size, pkt->data, pkt->size, pkt->flags & AV_PKT_FLAG_KEY))
1043  } else {
1044  opkt.data = pkt->data;
1045  opkt.size = pkt->size;
1046  }
1047 
1048  write_frame(of->ctx, &opkt, ost);
1049  ost->st->codec->frame_number++;
1050 }
1051 
1052 static void rate_emu_sleep(InputStream *ist)
1053 {
1054  if (input_files[ist->file_index]->rate_emu) {
1055  int64_t pts = av_rescale(ist->last_dts, 1000000, AV_TIME_BASE);
1056  int64_t now = av_gettime() - ist->start;
1057  if (pts > now)
1058  av_usleep(pts - now);
1059  }
1060 }
1061 
1063 {
1064  AVCodecContext *dec = ist->st->codec;
1065 
1066  if (!dec->channel_layout) {
1067  char layout_name[256];
1068 
1070  if (!dec->channel_layout)
1071  return 0;
1072  av_get_channel_layout_string(layout_name, sizeof(layout_name),
1073  dec->channels, dec->channel_layout);
1074  av_log(NULL, AV_LOG_WARNING, "Guessed Channel Layout for Input Stream "
1075  "#%d.%d : %s\n", ist->file_index, ist->st->index, layout_name);
1076  }
1077  return 1;
1078 }
1079 
1080 static int decode_audio(InputStream *ist, AVPacket *pkt, int *got_output)
1081 {
1082  AVFrame *decoded_frame;
1083  AVCodecContext *avctx = ist->st->codec;
1084  int i, ret, resample_changed;
1085 
1086  if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1087  return AVERROR(ENOMEM);
1088  decoded_frame = ist->decoded_frame;
1089 
1090  ret = avcodec_decode_audio4(avctx, decoded_frame, got_output, pkt);
1091  if (!*got_output || ret < 0) {
1092  if (!pkt->size) {
1093  for (i = 0; i < ist->nb_filters; i++)
1095  }
1096  return ret;
1097  }
1098 
1099  /* if the decoder provides a pts, use it instead of the last packet pts.
1100  the decoder could be delaying output by a packet or more. */
1101  if (decoded_frame->pts != AV_NOPTS_VALUE)
1102  ist->next_dts = decoded_frame->pts;
1103  else if (pkt->pts != AV_NOPTS_VALUE) {
1104  decoded_frame->pts = pkt->pts;
1105  pkt->pts = AV_NOPTS_VALUE;
1106  }
1107 
1108  rate_emu_sleep(ist);
1109 
1110  resample_changed = ist->resample_sample_fmt != decoded_frame->format ||
1111  ist->resample_channels != avctx->channels ||
1112  ist->resample_channel_layout != decoded_frame->channel_layout ||
1113  ist->resample_sample_rate != decoded_frame->sample_rate;
1114  if (resample_changed) {
1115  char layout1[64], layout2[64];
1116 
1117  if (!guess_input_channel_layout(ist)) {
1118  av_log(NULL, AV_LOG_FATAL, "Unable to find default channel "
1119  "layout for Input Stream #%d.%d\n", ist->file_index,
1120  ist->st->index);
1121  exit(1);
1122  }
1123  decoded_frame->channel_layout = avctx->channel_layout;
1124 
1125  av_get_channel_layout_string(layout1, sizeof(layout1), ist->resample_channels,
1127  av_get_channel_layout_string(layout2, sizeof(layout2), avctx->channels,
1128  decoded_frame->channel_layout);
1129 
1131  "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",
1132  ist->file_index, ist->st->index,
1134  ist->resample_channels, layout1,
1135  decoded_frame->sample_rate, av_get_sample_fmt_name(decoded_frame->format),
1136  avctx->channels, layout2);
1137 
1138  ist->resample_sample_fmt = decoded_frame->format;
1139  ist->resample_sample_rate = decoded_frame->sample_rate;
1140  ist->resample_channel_layout = decoded_frame->channel_layout;
1141  ist->resample_channels = avctx->channels;
1142 
1143  for (i = 0; i < nb_filtergraphs; i++)
1144  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1145  configure_filtergraph(filtergraphs[i]) < 0) {
1146  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1147  exit(1);
1148  }
1149  }
1150 
1151  if (decoded_frame->pts != AV_NOPTS_VALUE)
1152  decoded_frame->pts = av_rescale_q(decoded_frame->pts,
1153  ist->st->time_base,
1154  (AVRational){1, ist->st->codec->sample_rate});
1155  for (i = 0; i < ist->nb_filters; i++)
1156  av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
1157 
1158  return ret;
1159 }
1160 
1161 static int decode_video(InputStream *ist, AVPacket *pkt, int *got_output)
1162 {
1163  AVFrame *decoded_frame;
1164  void *buffer_to_free = NULL;
1165  int i, ret = 0, resample_changed;
1166 
1167  if (!ist->decoded_frame && !(ist->decoded_frame = avcodec_alloc_frame()))
1168  return AVERROR(ENOMEM);
1169  decoded_frame = ist->decoded_frame;
1170 
1171  ret = avcodec_decode_video2(ist->st->codec,
1172  decoded_frame, got_output, pkt);
1173  if (!*got_output || ret < 0) {
1174  if (!pkt->size) {
1175  for (i = 0; i < ist->nb_filters; i++)
1177  }
1178  return ret;
1179  }
1180 
1181  decoded_frame->pts = guess_correct_pts(&ist->pts_ctx, decoded_frame->pkt_pts,
1182  decoded_frame->pkt_dts);
1183  pkt->size = 0;
1184  pre_process_video_frame(ist, (AVPicture *)decoded_frame, &buffer_to_free);
1185 
1186  rate_emu_sleep(ist);
1187 
1188  if (ist->st->sample_aspect_ratio.num)
1189  decoded_frame->sample_aspect_ratio = ist->st->sample_aspect_ratio;
1190 
1191  resample_changed = ist->resample_width != decoded_frame->width ||
1192  ist->resample_height != decoded_frame->height ||
1193  ist->resample_pix_fmt != decoded_frame->format;
1194  if (resample_changed) {
1196  "Input stream #%d:%d frame changed from size:%dx%d fmt:%s to size:%dx%d fmt:%s\n",
1197  ist->file_index, ist->st->index,
1199  decoded_frame->width, decoded_frame->height, av_get_pix_fmt_name(decoded_frame->format));
1200 
1201  ret = poll_filters();
1202  if (ret < 0 && (ret != AVERROR_EOF && ret != AVERROR(EAGAIN)))
1203  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
1204 
1205  ist->resample_width = decoded_frame->width;
1206  ist->resample_height = decoded_frame->height;
1207  ist->resample_pix_fmt = decoded_frame->format;
1208 
1209  for (i = 0; i < nb_filtergraphs; i++)
1210  if (ist_in_filtergraph(filtergraphs[i], ist) &&
1211  configure_filtergraph(filtergraphs[i]) < 0) {
1212  av_log(NULL, AV_LOG_FATAL, "Error reinitializing filters!\n");
1213  exit(1);
1214  }
1215  }
1216 
1217  for (i = 0; i < ist->nb_filters; i++) {
1218  if (ist->st->codec->codec->capabilities & CODEC_CAP_DR1 && !do_deinterlace) {
1219  FrameBuffer *buf = decoded_frame->opaque;
1221  decoded_frame->data, decoded_frame->linesize,
1223  ist->st->codec->width, ist->st->codec->height,
1224  ist->st->codec->pix_fmt);
1225 
1226  avfilter_copy_frame_props(fb, decoded_frame);
1227  fb->buf->priv = buf;
1229 
1230  buf->refcount++;
1231  av_buffersrc_buffer(ist->filters[i]->filter, fb);
1232  } else
1233  av_buffersrc_write_frame(ist->filters[i]->filter, decoded_frame);
1234  }
1235 
1236  av_free(buffer_to_free);
1237  return ret;
1238 }
1239 
1240 static int transcode_subtitles(InputStream *ist, AVPacket *pkt, int *got_output)
1241 {
1242  AVSubtitle subtitle;
1243  int i, ret = avcodec_decode_subtitle2(ist->st->codec,
1244  &subtitle, got_output, pkt);
1245  if (ret < 0)
1246  return ret;
1247  if (!*got_output)
1248  return ret;
1249 
1250  rate_emu_sleep(ist);
1251 
1252  for (i = 0; i < nb_output_streams; i++) {
1253  OutputStream *ost = output_streams[i];
1254 
1255  if (!check_output_constraints(ist, ost) || !ost->encoding_needed)
1256  continue;
1257 
1258  do_subtitle_out(output_files[ost->file_index]->ctx, ost, ist, &subtitle, pkt->pts);
1259  }
1260 
1261  avsubtitle_free(&subtitle);
1262  return ret;
1263 }
1264 
1265 /* pkt = NULL means EOF (needed to flush decoder buffers) */
1266 static int output_packet(InputStream *ist, const AVPacket *pkt)
1267 {
1268  int i;
1269  int got_output;
1270  AVPacket avpkt;
1271 
1272  if (ist->next_dts == AV_NOPTS_VALUE)
1273  ist->next_dts = ist->last_dts;
1274 
1275  if (pkt == NULL) {
1276  /* EOF handling */
1277  av_init_packet(&avpkt);
1278  avpkt.data = NULL;
1279  avpkt.size = 0;
1280  goto handle_eof;
1281  } else {
1282  avpkt = *pkt;
1283  }
1284 
1285  if (pkt->dts != AV_NOPTS_VALUE)
1286  ist->next_dts = ist->last_dts = av_rescale_q(pkt->dts, ist->st->time_base, AV_TIME_BASE_Q);
1287 
1288  // while we have more to decode or while the decoder did output something on EOF
1289  while (ist->decoding_needed && (avpkt.size > 0 || (!pkt && got_output))) {
1290  int ret = 0;
1291  handle_eof:
1292 
1293  ist->last_dts = ist->next_dts;
1294 
1295  if (avpkt.size && avpkt.size != pkt->size) {
1297  "Multiple frames in a packet from stream %d\n", pkt->stream_index);
1298  ist->showed_multi_packet_warning = 1;
1299  }
1300 
1301  switch (ist->st->codec->codec_type) {
1302  case AVMEDIA_TYPE_AUDIO:
1303  ret = decode_audio (ist, &avpkt, &got_output);
1304  break;
1305  case AVMEDIA_TYPE_VIDEO:
1306  ret = decode_video (ist, &avpkt, &got_output);
1307  if (avpkt.duration)
1308  ist->next_dts += av_rescale_q(avpkt.duration, ist->st->time_base, AV_TIME_BASE_Q);
1309  else if (ist->st->avg_frame_rate.num)
1310  ist->next_dts += av_rescale_q(1, av_inv_q(ist->st->avg_frame_rate),
1311  AV_TIME_BASE_Q);
1312  else if (ist->st->codec->time_base.num != 0) {
1313  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 :
1314  ist->st->codec->ticks_per_frame;
1315  ist->next_dts += av_rescale_q(ticks, ist->st->codec->time_base, AV_TIME_BASE_Q);
1316  }
1317  break;
1318  case AVMEDIA_TYPE_SUBTITLE:
1319  ret = transcode_subtitles(ist, &avpkt, &got_output);
1320  break;
1321  default:
1322  return -1;
1323  }
1324 
1325  if (ret < 0)
1326  return ret;
1327  // touch data and size only if not EOF
1328  if (pkt) {
1329  avpkt.data += ret;
1330  avpkt.size -= ret;
1331  }
1332  if (!got_output) {
1333  continue;
1334  }
1335  }
1336 
1337  /* handle stream copy */
1338  if (!ist->decoding_needed) {
1339  rate_emu_sleep(ist);
1340  ist->last_dts = ist->next_dts;
1341  switch (ist->st->codec->codec_type) {
1342  case AVMEDIA_TYPE_AUDIO:
1343  ist->next_dts += ((int64_t)AV_TIME_BASE * ist->st->codec->frame_size) /
1344  ist->st->codec->sample_rate;
1345  break;
1346  case AVMEDIA_TYPE_VIDEO:
1347  if (ist->st->codec->time_base.num != 0) {
1348  int ticks = ist->st->parser ? ist->st->parser->repeat_pict + 1 : ist->st->codec->ticks_per_frame;
1349  ist->next_dts += ((int64_t)AV_TIME_BASE *
1350  ist->st->codec->time_base.num * ticks) /
1351  ist->st->codec->time_base.den;
1352  }
1353  break;
1354  }
1355  }
1356  for (i = 0; pkt && i < nb_output_streams; i++) {
1357  OutputStream *ost = output_streams[i];
1358 
1359  if (!check_output_constraints(ist, ost) || ost->encoding_needed)
1360  continue;
1361 
1362  do_streamcopy(ist, ost, pkt);
1363  }
1364 
1365  return 0;
1366 }
1367 
1368 static void print_sdp(void)
1369 {
1370  char sdp[2048];
1371  int i;
1372  AVFormatContext **avc = av_malloc(sizeof(*avc) * nb_output_files);
1373 
1374  if (!avc)
1375  exit(1);
1376  for (i = 0; i < nb_output_files; i++)
1377  avc[i] = output_files[i]->ctx;
1378 
1379  av_sdp_create(avc, nb_output_files, sdp, sizeof(sdp));
1380  printf("SDP:\n%s\n", sdp);
1381  fflush(stdout);
1382  av_freep(&avc);
1383 }
1384 
1385 static int init_input_stream(int ist_index, char *error, int error_len)
1386 {
1387  int i, ret;
1388  InputStream *ist = input_streams[ist_index];
1389  if (ist->decoding_needed) {
1390  AVCodec *codec = ist->dec;
1391  if (!codec) {
1392  snprintf(error, error_len, "Decoder (codec id %d) not found for input stream #%d:%d",
1393  ist->st->codec->codec_id, ist->file_index, ist->st->index);
1394  return AVERROR(EINVAL);
1395  }
1396 
1397  /* update requested sample format for the decoder based on the
1398  corresponding encoder sample format */
1399  for (i = 0; i < nb_output_streams; i++) {
1400  OutputStream *ost = output_streams[i];
1401  if (ost->source_index == ist_index) {
1402  update_sample_fmt(ist->st->codec, codec, ost->st->codec);
1403  break;
1404  }
1405  }
1406 
1407  if (codec->type == AVMEDIA_TYPE_VIDEO && codec->capabilities & CODEC_CAP_DR1) {
1410  ist->st->codec->opaque = &ist->buffer_pool;
1411  }
1412 
1413  if (!av_dict_get(ist->opts, "threads", NULL, 0))
1414  av_dict_set(&ist->opts, "threads", "auto", 0);
1415  if ((ret = avcodec_open2(ist->st->codec, codec, &ist->opts)) < 0) {
1416  if (ret == AVERROR_EXPERIMENTAL)
1417  abort_codec_experimental(codec, 0);
1418  snprintf(error, error_len, "Error while opening decoder for input stream #%d:%d",
1419  ist->file_index, ist->st->index);
1420  return ret;
1421  }
1422  assert_avoptions(ist->opts);
1423  }
1424 
1425  ist->last_dts = ist->st->avg_frame_rate.num ? - ist->st->codec->has_b_frames * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
1426  ist->next_dts = AV_NOPTS_VALUE;
1428  ist->is_start = 1;
1429 
1430  return 0;
1431 }
1432 
1434 {
1435  if (ost->source_index >= 0)
1436  return input_streams[ost->source_index];
1437 
1438  if (ost->filter) {
1439  FilterGraph *fg = ost->filter->graph;
1440  int i;
1441 
1442  for (i = 0; i < fg->nb_inputs; i++)
1443  if (fg->inputs[i]->ist->st->codec->codec_type == ost->st->codec->codec_type)
1444  return fg->inputs[i]->ist;
1445  }
1446 
1447  return NULL;
1448 }
1449 
1450 static void parse_forced_key_frames(char *kf, OutputStream *ost,
1451  AVCodecContext *avctx)
1452 {
1453  char *p;
1454  int n = 1, i;
1455  int64_t t;
1456 
1457  for (p = kf; *p; p++)
1458  if (*p == ',')
1459  n++;
1460  ost->forced_kf_count = n;
1461  ost->forced_kf_pts = av_malloc(sizeof(*ost->forced_kf_pts) * n);
1462  if (!ost->forced_kf_pts) {
1463  av_log(NULL, AV_LOG_FATAL, "Could not allocate forced key frames array.\n");
1464  exit(1);
1465  }
1466 
1467  p = kf;
1468  for (i = 0; i < n; i++) {
1469  char *next = strchr(p, ',');
1470 
1471  if (next)
1472  *next++ = 0;
1473 
1474  t = parse_time_or_die("force_key_frames", p, 1);
1475  ost->forced_kf_pts[i] = av_rescale_q(t, AV_TIME_BASE_Q, avctx->time_base);
1476 
1477  p = next;
1478  }
1479 }
1480 
1481 static int transcode_init(void)
1482 {
1483  int ret = 0, i, j, k;
1484  AVFormatContext *oc;
1485  AVCodecContext *codec;
1486  OutputStream *ost;
1487  InputStream *ist;
1488  char error[1024];
1489  int want_sdp = 1;
1490 
1491  /* init framerate emulation */
1492  for (i = 0; i < nb_input_files; i++) {
1493  InputFile *ifile = input_files[i];
1494  if (ifile->rate_emu)
1495  for (j = 0; j < ifile->nb_streams; j++)
1496  input_streams[j + ifile->ist_index]->start = av_gettime();
1497  }
1498 
1499  /* output stream init */
1500  for (i = 0; i < nb_output_files; i++) {
1501  oc = output_files[i]->ctx;
1502  if (!oc->nb_streams && !(oc->oformat->flags & AVFMT_NOSTREAMS)) {
1503  av_dump_format(oc, i, oc->filename, 1);
1504  av_log(NULL, AV_LOG_ERROR, "Output file #%d does not contain any stream\n", i);
1505  return AVERROR(EINVAL);
1506  }
1507  }
1508 
1509  /* init complex filtergraphs */
1510  for (i = 0; i < nb_filtergraphs; i++)
1511  if ((ret = avfilter_graph_config(filtergraphs[i]->graph, NULL)) < 0)
1512  return ret;
1513 
1514  /* for each output stream, we compute the right encoding parameters */
1515  for (i = 0; i < nb_output_streams; i++) {
1516  AVCodecContext *icodec = NULL;
1517  ost = output_streams[i];
1518  oc = output_files[ost->file_index]->ctx;
1519  ist = get_input_stream(ost);
1520 
1521  if (ost->attachment_filename)
1522  continue;
1523 
1524  codec = ost->st->codec;
1525 
1526  if (ist) {
1527  icodec = ist->st->codec;
1528 
1529  ost->st->disposition = ist->st->disposition;
1530  codec->bits_per_raw_sample = icodec->bits_per_raw_sample;
1532  }
1533 
1534  if (ost->stream_copy) {
1535  uint64_t extra_size;
1536 
1537  av_assert0(ist && !ost->filter);
1538 
1539  extra_size = (uint64_t)icodec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE;
1540 
1541  if (extra_size > INT_MAX) {
1542  return AVERROR(EINVAL);
1543  }
1544 
1545  /* if stream_copy is selected, no need to decode or encode */
1546  codec->codec_id = icodec->codec_id;
1547  codec->codec_type = icodec->codec_type;
1548 
1549  if (!codec->codec_tag) {
1550  if (!oc->oformat->codec_tag ||
1551  av_codec_get_id (oc->oformat->codec_tag, icodec->codec_tag) == codec->codec_id ||
1552  av_codec_get_tag(oc->oformat->codec_tag, icodec->codec_id) <= 0)
1553  codec->codec_tag = icodec->codec_tag;
1554  }
1555 
1556  codec->bit_rate = icodec->bit_rate;
1557  codec->rc_max_rate = icodec->rc_max_rate;
1558  codec->rc_buffer_size = icodec->rc_buffer_size;
1559  codec->field_order = icodec->field_order;
1560  codec->extradata = av_mallocz(extra_size);
1561  if (!codec->extradata) {
1562  return AVERROR(ENOMEM);
1563  }
1564  memcpy(codec->extradata, icodec->extradata, icodec->extradata_size);
1565  codec->extradata_size = icodec->extradata_size;
1566  if (!copy_tb) {
1567  codec->time_base = icodec->time_base;
1568  codec->time_base.num *= icodec->ticks_per_frame;
1569  av_reduce(&codec->time_base.num, &codec->time_base.den,
1570  codec->time_base.num, codec->time_base.den, INT_MAX);
1571  } else
1572  codec->time_base = ist->st->time_base;
1573 
1574  switch (codec->codec_type) {
1575  case AVMEDIA_TYPE_AUDIO:
1576  if (audio_volume != 256) {
1577  av_log(NULL, AV_LOG_FATAL, "-acodec copy and -vol are incompatible (frames are not decoded)\n");
1578  exit(1);
1579  }
1580  codec->channel_layout = icodec->channel_layout;
1581  codec->sample_rate = icodec->sample_rate;
1582  codec->channels = icodec->channels;
1583  codec->frame_size = icodec->frame_size;
1584  codec->audio_service_type = icodec->audio_service_type;
1585  codec->block_align = icodec->block_align;
1586  break;
1587  case AVMEDIA_TYPE_VIDEO:
1588  codec->pix_fmt = icodec->pix_fmt;
1589  codec->width = icodec->width;
1590  codec->height = icodec->height;
1591  codec->has_b_frames = icodec->has_b_frames;
1592  if (!codec->sample_aspect_ratio.num) {
1593  codec->sample_aspect_ratio =
1594  ost->st->sample_aspect_ratio =
1596  ist->st->codec->sample_aspect_ratio.num ?
1597  ist->st->codec->sample_aspect_ratio : (AVRational){0, 1};
1598  }
1599  break;
1600  case AVMEDIA_TYPE_SUBTITLE:
1601  codec->width = icodec->width;
1602  codec->height = icodec->height;
1603  break;
1604  case AVMEDIA_TYPE_DATA:
1606  break;
1607  default:
1608  abort();
1609  }
1610  } else {
1611  if (!ost->enc) {
1612  /* should only happen when a default codec is not present. */
1613  snprintf(error, sizeof(error), "Automatic encoder selection "
1614  "failed for output stream #%d:%d. Default encoder for "
1615  "format %s is probably disabled. Please choose an "
1616  "encoder manually.\n", ost->file_index, ost->index,
1617  oc->oformat->name);
1618  ret = AVERROR(EINVAL);
1619  goto dump_format;
1620  }
1621 
1622  if (ist)
1623  ist->decoding_needed = 1;
1624  ost->encoding_needed = 1;
1625 
1626  /*
1627  * We want CFR output if and only if one of those is true:
1628  * 1) user specified output framerate with -r
1629  * 2) user specified -vsync cfr
1630  * 3) output format is CFR and the user didn't force vsync to
1631  * something else than CFR
1632  *
1633  * in such a case, set ost->frame_rate
1634  */
1635  if (codec->codec_type == AVMEDIA_TYPE_VIDEO &&
1636  !ost->frame_rate.num && ist &&
1640  ost->frame_rate = ist->framerate.num ? ist->framerate :
1641  ist->st->avg_frame_rate.num ?
1642  ist->st->avg_frame_rate :
1643  (AVRational){25, 1};
1644 
1645  if (ost->enc && ost->enc->supported_framerates && !ost->force_fps) {
1647  ost->frame_rate = ost->enc->supported_framerates[idx];
1648  }
1649  }
1650 
1651  if (!ost->filter &&
1652  (codec->codec_type == AVMEDIA_TYPE_VIDEO ||
1653  codec->codec_type == AVMEDIA_TYPE_AUDIO)) {
1654  FilterGraph *fg;
1655  fg = init_simple_filtergraph(ist, ost);
1656  if (configure_filtergraph(fg)) {
1657  av_log(NULL, AV_LOG_FATAL, "Error opening filters!\n");
1658  exit(1);
1659  }
1660  }
1661 
1662  switch (codec->codec_type) {
1663  case AVMEDIA_TYPE_AUDIO:
1664  codec->sample_fmt = ost->filter->filter->inputs[0]->format;
1665  codec->sample_rate = ost->filter->filter->inputs[0]->sample_rate;
1666  codec->channel_layout = ost->filter->filter->inputs[0]->channel_layout;
1668  codec->time_base = (AVRational){ 1, codec->sample_rate };
1669  break;
1670  case AVMEDIA_TYPE_VIDEO:
1671  codec->time_base = ost->filter->filter->inputs[0]->time_base;
1672 
1673  codec->width = ost->filter->filter->inputs[0]->w;
1674  codec->height = ost->filter->filter->inputs[0]->h;
1675  codec->sample_aspect_ratio = ost->st->sample_aspect_ratio =
1676  ost->frame_aspect_ratio ? // overridden by the -aspect cli option
1677  av_d2q(ost->frame_aspect_ratio * codec->height/codec->width, 255) :
1679  codec->pix_fmt = ost->filter->filter->inputs[0]->format;
1680 
1681  if (icodec &&
1682  (codec->width != icodec->width ||
1683  codec->height != icodec->height ||
1684  codec->pix_fmt != icodec->pix_fmt)) {
1685  codec->bits_per_raw_sample = 0;
1686  }
1687 
1688  if (ost->forced_keyframes)
1690  ost->st->codec);
1691  break;
1692  case AVMEDIA_TYPE_SUBTITLE:
1693  codec->time_base = (AVRational){1, 1000};
1694  break;
1695  default:
1696  abort();
1697  break;
1698  }
1699  /* two pass mode */
1700  if ((codec->flags & (CODEC_FLAG_PASS1 | CODEC_FLAG_PASS2))) {
1701  char logfilename[1024];
1702  FILE *f;
1703 
1704  snprintf(logfilename, sizeof(logfilename), "%s-%d.log",
1705  ost->logfile_prefix ? ost->logfile_prefix :
1707  i);
1708  if (!strcmp(ost->enc->name, "libx264")) {
1709  av_dict_set(&ost->opts, "stats", logfilename, AV_DICT_DONT_OVERWRITE);
1710  } else {
1711  if (codec->flags & CODEC_FLAG_PASS1) {
1712  f = fopen(logfilename, "wb");
1713  if (!f) {
1714  av_log(NULL, AV_LOG_FATAL, "Cannot write log file '%s' for pass-1 encoding: %s\n",
1715  logfilename, strerror(errno));
1716  exit(1);
1717  }
1718  ost->logfile = f;
1719  } else {
1720  char *logbuffer;
1721  size_t logbuffer_size;
1722  if (cmdutils_read_file(logfilename, &logbuffer, &logbuffer_size) < 0) {
1723  av_log(NULL, AV_LOG_FATAL, "Error reading log file '%s' for pass-2 encoding\n",
1724  logfilename);
1725  exit(1);
1726  }
1727  codec->stats_in = logbuffer;
1728  }
1729  }
1730  }
1731  }
1732  }
1733 
1734  /* open each encoder */
1735  for (i = 0; i < nb_output_streams; i++) {
1736  ost = output_streams[i];
1737  if (ost->encoding_needed) {
1738  AVCodec *codec = ost->enc;
1739  AVCodecContext *dec = NULL;
1740 
1741  if ((ist = get_input_stream(ost)))
1742  dec = ist->st->codec;
1743  if (dec && dec->subtitle_header) {
1745  if (!ost->st->codec->subtitle_header) {
1746  ret = AVERROR(ENOMEM);
1747  goto dump_format;
1748  }
1749  memcpy(ost->st->codec->subtitle_header, dec->subtitle_header, dec->subtitle_header_size);
1751  }
1752  if (!av_dict_get(ost->opts, "threads", NULL, 0))
1753  av_dict_set(&ost->opts, "threads", "auto", 0);
1754  if ((ret = avcodec_open2(ost->st->codec, codec, &ost->opts)) < 0) {
1755  if (ret == AVERROR_EXPERIMENTAL)
1756  abort_codec_experimental(codec, 1);
1757  snprintf(error, sizeof(error), "Error while opening encoder for output stream #%d:%d - maybe incorrect parameters such as bit_rate, rate, width or height",
1758  ost->file_index, ost->index);
1759  goto dump_format;
1760  }
1761  assert_avoptions(ost->opts);
1762  if (ost->st->codec->bit_rate && ost->st->codec->bit_rate < 1000)
1763  av_log(NULL, AV_LOG_WARNING, "The bitrate parameter is set too low."
1764  "It takes bits/s as argument, not kbits/s\n");
1765  extra_size += ost->st->codec->extradata_size;
1766 
1767  if (ost->st->codec->me_threshold)
1768  input_streams[ost->source_index]->st->codec->debug |= FF_DEBUG_MV;
1769  }
1770  }
1771 
1772  /* init input streams */
1773  for (i = 0; i < nb_input_streams; i++)
1774  if ((ret = init_input_stream(i, error, sizeof(error))) < 0)
1775  goto dump_format;
1776 
1777  /* discard unused programs */
1778  for (i = 0; i < nb_input_files; i++) {
1779  InputFile *ifile = input_files[i];
1780  for (j = 0; j < ifile->ctx->nb_programs; j++) {
1781  AVProgram *p = ifile->ctx->programs[j];
1782  int discard = AVDISCARD_ALL;
1783 
1784  for (k = 0; k < p->nb_stream_indexes; k++)
1785  if (!input_streams[ifile->ist_index + p->stream_index[k]]->discard) {
1786  discard = AVDISCARD_DEFAULT;
1787  break;
1788  }
1789  p->discard = discard;
1790  }
1791  }
1792 
1793  /* open files and write file headers */
1794  for (i = 0; i < nb_output_files; i++) {
1795  oc = output_files[i]->ctx;
1796  oc->interrupt_callback = int_cb;
1797  if ((ret = avformat_write_header(oc, &output_files[i]->opts)) < 0) {
1798  char errbuf[128];
1799  const char *errbuf_ptr = errbuf;
1800  if (av_strerror(ret, errbuf, sizeof(errbuf)) < 0)
1801  errbuf_ptr = strerror(AVUNERROR(ret));
1802  snprintf(error, sizeof(error), "Could not write header for output file #%d (incorrect codec parameters ?): %s", i, errbuf_ptr);
1803  ret = AVERROR(EINVAL);
1804  goto dump_format;
1805  }
1806  assert_avoptions(output_files[i]->opts);
1807  if (strcmp(oc->oformat->name, "rtp")) {
1808  want_sdp = 0;
1809  }
1810  }
1811 
1812  dump_format:
1813  /* dump the file output parameters - cannot be done before in case
1814  of stream copy */
1815  for (i = 0; i < nb_output_files; i++) {
1816  av_dump_format(output_files[i]->ctx, i, output_files[i]->ctx->filename, 1);
1817  }
1818 
1819  /* dump the stream mapping */
1820  av_log(NULL, AV_LOG_INFO, "Stream mapping:\n");
1821  for (i = 0; i < nb_input_streams; i++) {
1822  ist = input_streams[i];
1823 
1824  for (j = 0; j < ist->nb_filters; j++) {
1825  if (ist->filters[j]->graph->graph_desc) {
1826  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d (%s) -> %s",
1827  ist->file_index, ist->st->index, ist->dec ? ist->dec->name : "?",
1828  ist->filters[j]->name);
1829  if (nb_filtergraphs > 1)
1830  av_log(NULL, AV_LOG_INFO, " (graph %d)", ist->filters[j]->graph->index);
1831  av_log(NULL, AV_LOG_INFO, "\n");
1832  }
1833  }
1834  }
1835 
1836  for (i = 0; i < nb_output_streams; i++) {
1837  ost = output_streams[i];
1838 
1839  if (ost->attachment_filename) {
1840  /* an attached file */
1841  av_log(NULL, AV_LOG_INFO, " File %s -> Stream #%d:%d\n",
1842  ost->attachment_filename, ost->file_index, ost->index);
1843  continue;
1844  }
1845 
1846  if (ost->filter && ost->filter->graph->graph_desc) {
1847  /* output from a complex graph */
1848  av_log(NULL, AV_LOG_INFO, " %s", ost->filter->name);
1849  if (nb_filtergraphs > 1)
1850  av_log(NULL, AV_LOG_INFO, " (graph %d)", ost->filter->graph->index);
1851 
1852  av_log(NULL, AV_LOG_INFO, " -> Stream #%d:%d (%s)\n", ost->file_index,
1853  ost->index, ost->enc ? ost->enc->name : "?");
1854  continue;
1855  }
1856 
1857  av_log(NULL, AV_LOG_INFO, " Stream #%d:%d -> #%d:%d",
1858  input_streams[ost->source_index]->file_index,
1859  input_streams[ost->source_index]->st->index,
1860  ost->file_index,
1861  ost->index);
1862  if (ost->sync_ist != input_streams[ost->source_index])
1863  av_log(NULL, AV_LOG_INFO, " [sync #%d:%d]",
1864  ost->sync_ist->file_index,
1865  ost->sync_ist->st->index);
1866  if (ost->stream_copy)
1867  av_log(NULL, AV_LOG_INFO, " (copy)");
1868  else
1869  av_log(NULL, AV_LOG_INFO, " (%s -> %s)", input_streams[ost->source_index]->dec ?
1870  input_streams[ost->source_index]->dec->name : "?",
1871  ost->enc ? ost->enc->name : "?");
1872  av_log(NULL, AV_LOG_INFO, "\n");
1873  }
1874 
1875  if (ret) {
1876  av_log(NULL, AV_LOG_ERROR, "%s\n", error);
1877  return ret;
1878  }
1879 
1880  if (want_sdp) {
1881  print_sdp();
1882  }
1883 
1884  return 0;
1885 }
1886 
1887 /* Return 1 if there remain streams where more output is wanted, 0 otherwise. */
1888 static int need_output(void)
1889 {
1890  int i;
1891 
1892  for (i = 0; i < nb_output_streams; i++) {
1893  OutputStream *ost = output_streams[i];
1894  OutputFile *of = output_files[ost->file_index];
1895  AVFormatContext *os = output_files[ost->file_index]->ctx;
1896 
1897  if (ost->finished ||
1898  (os->pb && avio_tell(os->pb) >= of->limit_filesize))
1899  continue;
1900  if (ost->frame_number >= ost->max_frames) {
1901  int j;
1902  for (j = 0; j < of->ctx->nb_streams; j++)
1903  output_streams[of->ost_index + j]->finished = 1;
1904  continue;
1905  }
1906 
1907  return 1;
1908  }
1909 
1910  return 0;
1911 }
1912 
1914 {
1915  InputFile *ifile = NULL;
1916  int64_t ipts_min = INT64_MAX;
1917  int i;
1918 
1919  for (i = 0; i < nb_input_streams; i++) {
1920  InputStream *ist = input_streams[i];
1921  int64_t ipts = ist->last_dts;
1922 
1923  if (ist->discard || input_files[ist->file_index]->eagain)
1924  continue;
1925  if (!input_files[ist->file_index]->eof_reached) {
1926  if (ipts < ipts_min) {
1927  ipts_min = ipts;
1928  ifile = input_files[ist->file_index];
1929  }
1930  }
1931  }
1932 
1933  return ifile;
1934 }
1935 
1936 #if HAVE_PTHREADS
1937 static void *input_thread(void *arg)
1938 {
1939  InputFile *f = arg;
1940  int ret = 0;
1941 
1942  while (!transcoding_finished && ret >= 0) {
1943  AVPacket pkt;
1944  ret = av_read_frame(f->ctx, &pkt);
1945 
1946  if (ret == AVERROR(EAGAIN)) {
1947  av_usleep(10000);
1948  ret = 0;
1949  continue;
1950  } else if (ret < 0)
1951  break;
1952 
1953  pthread_mutex_lock(&f->fifo_lock);
1954  while (!av_fifo_space(f->fifo))
1955  pthread_cond_wait(&f->fifo_cond, &f->fifo_lock);
1956 
1957  av_dup_packet(&pkt);
1958  av_fifo_generic_write(f->fifo, &pkt, sizeof(pkt), NULL);
1959 
1960  pthread_mutex_unlock(&f->fifo_lock);
1961  }
1962 
1963  f->finished = 1;
1964  return NULL;
1965 }
1966 
1967 static void free_input_threads(void)
1968 {
1969  int i;
1970 
1971  if (nb_input_files == 1)
1972  return;
1973 
1974  transcoding_finished = 1;
1975 
1976  for (i = 0; i < nb_input_files; i++) {
1977  InputFile *f = input_files[i];
1978  AVPacket pkt;
1979 
1980  if (!f->fifo || f->joined)
1981  continue;
1982 
1983  pthread_mutex_lock(&f->fifo_lock);
1984  while (av_fifo_size(f->fifo)) {
1985  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
1986  av_free_packet(&pkt);
1987  }
1988  pthread_cond_signal(&f->fifo_cond);
1989  pthread_mutex_unlock(&f->fifo_lock);
1990 
1991  pthread_join(f->thread, NULL);
1992  f->joined = 1;
1993 
1994  while (av_fifo_size(f->fifo)) {
1995  av_fifo_generic_read(f->fifo, &pkt, sizeof(pkt), NULL);
1996  av_free_packet(&pkt);
1997  }
1998  av_fifo_free(f->fifo);
1999  }
2000 }
2001 
2002 static int init_input_threads(void)
2003 {
2004  int i, ret;
2005 
2006  if (nb_input_files == 1)
2007  return 0;
2008 
2009  for (i = 0; i < nb_input_files; i++) {
2010  InputFile *f = input_files[i];
2011 
2012  if (!(f->fifo = av_fifo_alloc(8*sizeof(AVPacket))))
2013  return AVERROR(ENOMEM);
2014 
2015  pthread_mutex_init(&f->fifo_lock, NULL);
2016  pthread_cond_init (&f->fifo_cond, NULL);
2017 
2018  if ((ret = pthread_create(&f->thread, NULL, input_thread, f)))
2019  return AVERROR(ret);
2020  }
2021  return 0;
2022 }
2023 
2024 static int get_input_packet_mt(InputFile *f, AVPacket *pkt)
2025 {
2026  int ret = 0;
2027 
2028  pthread_mutex_lock(&f->fifo_lock);
2029 
2030  if (av_fifo_size(f->fifo)) {
2031  av_fifo_generic_read(f->fifo, pkt, sizeof(*pkt), NULL);
2032  pthread_cond_signal(&f->fifo_cond);
2033  } else {
2034  if (f->finished)
2035  ret = AVERROR_EOF;
2036  else
2037  ret = AVERROR(EAGAIN);
2038  }
2039 
2040  pthread_mutex_unlock(&f->fifo_lock);
2041 
2042  return ret;
2043 }
2044 #endif
2045 
2047 {
2048 #if HAVE_PTHREADS
2049  if (nb_input_files > 1)
2050  return get_input_packet_mt(f, pkt);
2051 #endif
2052  return av_read_frame(f->ctx, pkt);
2053 }
2054 
2055 static int got_eagain(void)
2056 {
2057  int i;
2058  for (i = 0; i < nb_input_files; i++)
2059  if (input_files[i]->eagain)
2060  return 1;
2061  return 0;
2062 }
2063 
2064 static void reset_eagain(void)
2065 {
2066  int i;
2067  for (i = 0; i < nb_input_files; i++)
2068  input_files[i]->eagain = 0;
2069 }
2070 
2071 /*
2072  * Read one packet from an input file and send it for
2073  * - decoding -> lavfi (audio/video)
2074  * - decoding -> encoding -> muxing (subtitles)
2075  * - muxing (streamcopy)
2076  *
2077  * Return
2078  * - 0 -- one packet was read and processed
2079  * - AVERROR(EAGAIN) -- no packets were available for selected file,
2080  * this function should be called again
2081  * - AVERROR_EOF -- this function should not be called again
2082  */
2083 static int process_input(void)
2084 {
2085  InputFile *ifile;
2086  AVFormatContext *is;
2087  InputStream *ist;
2088  AVPacket pkt;
2089  int ret, i, j;
2090 
2091  /* select the stream that we must read now */
2092  ifile = select_input_file();
2093  /* if none, if is finished */
2094  if (!ifile) {
2095  if (got_eagain()) {
2096  reset_eagain();
2097  av_usleep(10000);
2098  return AVERROR(EAGAIN);
2099  }
2100  av_log(NULL, AV_LOG_VERBOSE, "No more inputs to read from.\n");
2101  return AVERROR_EOF;
2102  }
2103 
2104  is = ifile->ctx;
2105  ret = get_input_packet(ifile, &pkt);
2106 
2107  if (ret == AVERROR(EAGAIN)) {
2108  ifile->eagain = 1;
2109  return ret;
2110  }
2111  if (ret < 0) {
2112  if (ret != AVERROR_EOF) {
2113  print_error(is->filename, ret);
2114  if (exit_on_error)
2115  exit(1);
2116  }
2117  ifile->eof_reached = 1;
2118 
2119  for (i = 0; i < ifile->nb_streams; i++) {
2120  ist = input_streams[ifile->ist_index + i];
2121  if (ist->decoding_needed)
2122  output_packet(ist, NULL);
2123 
2124  /* mark all outputs that don't go through lavfi as finished */
2125  for (j = 0; j < nb_output_streams; j++) {
2126  OutputStream *ost = output_streams[j];
2127 
2128  if (ost->source_index == ifile->ist_index + i &&
2129  (ost->stream_copy || ost->enc->type == AVMEDIA_TYPE_SUBTITLE))
2130  ost->finished= 1;
2131  }
2132  }
2133 
2134  return AVERROR(EAGAIN);
2135  }
2136 
2137  reset_eagain();
2138 
2139  if (do_pkt_dump) {
2141  is->streams[pkt.stream_index]);
2142  }
2143  /* the following test is needed in case new streams appear
2144  dynamically in stream : we ignore them */
2145  if (pkt.stream_index >= ifile->nb_streams)
2146  goto discard_packet;
2147 
2148  ist = input_streams[ifile->ist_index + pkt.stream_index];
2149  if (ist->discard)
2150  goto discard_packet;
2151 
2152  if (pkt.dts != AV_NOPTS_VALUE)
2153  pkt.dts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2154  if (pkt.pts != AV_NOPTS_VALUE)
2155  pkt.pts += av_rescale_q(ifile->ts_offset, AV_TIME_BASE_Q, ist->st->time_base);
2156 
2157  if (pkt.pts != AV_NOPTS_VALUE)
2158  pkt.pts *= ist->ts_scale;
2159  if (pkt.dts != AV_NOPTS_VALUE)
2160  pkt.dts *= ist->ts_scale;
2161 
2162  if (pkt.dts != AV_NOPTS_VALUE && ist->next_dts != AV_NOPTS_VALUE &&
2163  (is->iformat->flags & AVFMT_TS_DISCONT)) {
2164  int64_t pkt_dts = av_rescale_q(pkt.dts, ist->st->time_base, AV_TIME_BASE_Q);
2165  int64_t delta = pkt_dts - ist->next_dts;
2166 
2167  if ((FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE || pkt_dts + 1 < ist->last_dts) && !copy_ts) {
2168  ifile->ts_offset -= delta;
2170  "timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
2171  delta, ifile->ts_offset);
2172  pkt.dts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2173  if (pkt.pts != AV_NOPTS_VALUE)
2174  pkt.pts -= av_rescale_q(delta, AV_TIME_BASE_Q, ist->st->time_base);
2175  }
2176  }
2177 
2178  ret = output_packet(ist, &pkt);
2179  if (ret < 0) {
2180  av_log(NULL, AV_LOG_ERROR, "Error while decoding stream #%d:%d\n",
2181  ist->file_index, ist->st->index);
2182  if (exit_on_error)
2183  exit(1);
2184  }
2185 
2186 discard_packet:
2187  av_free_packet(&pkt);
2188 
2189  return 0;
2190 }
2191 
2192 /*
2193  * The following code is the main loop of the file converter
2194  */
2195 static int transcode(void)
2196 {
2197  int ret, i, need_input = 1;
2198  AVFormatContext *os;
2199  OutputStream *ost;
2200  InputStream *ist;
2201  int64_t timer_start;
2202 
2203  ret = transcode_init();
2204  if (ret < 0)
2205  goto fail;
2206 
2207  av_log(NULL, AV_LOG_INFO, "Press ctrl-c to stop encoding\n");
2208  term_init();
2209 
2210  timer_start = av_gettime();
2211 
2212 #if HAVE_PTHREADS
2213  if ((ret = init_input_threads()) < 0)
2214  goto fail;
2215 #endif
2216 
2217  while (!received_sigterm) {
2218  /* check if there's any stream where output is still needed */
2219  if (!need_output()) {
2220  av_log(NULL, AV_LOG_VERBOSE, "No more output streams to write to, finishing.\n");
2221  break;
2222  }
2223 
2224  /* read and process one input packet if needed */
2225  if (need_input) {
2226  ret = process_input();
2227  if (ret == AVERROR_EOF)
2228  need_input = 0;
2229  }
2230 
2231  ret = poll_filters();
2232  if (ret < 0) {
2233  if (ret == AVERROR_EOF || ret == AVERROR(EAGAIN))
2234  continue;
2235 
2236  av_log(NULL, AV_LOG_ERROR, "Error while filtering.\n");
2237  break;
2238  }
2239 
2240  /* dump report by using the output first video and audio streams */
2241  print_report(0, timer_start);
2242  }
2243 #if HAVE_PTHREADS
2244  free_input_threads();
2245 #endif
2246 
2247  /* at the end of stream, we must flush the decoder buffers */
2248  for (i = 0; i < nb_input_streams; i++) {
2249  ist = input_streams[i];
2250  if (!input_files[ist->file_index]->eof_reached && ist->decoding_needed) {
2251  output_packet(ist, NULL);
2252  }
2253  }
2254  poll_filters();
2255  flush_encoders();
2256 
2257  term_exit();
2258 
2259  /* write the trailer if needed and close file */
2260  for (i = 0; i < nb_output_files; i++) {
2261  os = output_files[i]->ctx;
2262  av_write_trailer(os);
2263  }
2264 
2265  /* dump report by using the first video and audio streams */
2266  print_report(1, timer_start);
2267 
2268  /* close each encoder */
2269  for (i = 0; i < nb_output_streams; i++) {
2270  ost = output_streams[i];
2271  if (ost->encoding_needed) {
2272  av_freep(&ost->st->codec->stats_in);
2273  avcodec_close(ost->st->codec);
2274  }
2275  }
2276 
2277  /* close each decoder */
2278  for (i = 0; i < nb_input_streams; i++) {
2279  ist = input_streams[i];
2280  if (ist->decoding_needed) {
2281  avcodec_close(ist->st->codec);
2282  }
2283  }
2284 
2285  /* finished ! */
2286  ret = 0;
2287 
2288  fail:
2289 #if HAVE_PTHREADS
2290  free_input_threads();
2291 #endif
2292 
2293  if (output_streams) {
2294  for (i = 0; i < nb_output_streams; i++) {
2295  ost = output_streams[i];
2296  if (ost) {
2297  if (ost->stream_copy)
2298  av_freep(&ost->st->codec->extradata);
2299  if (ost->logfile) {
2300  fclose(ost->logfile);
2301  ost->logfile = NULL;
2302  }
2303  av_freep(&ost->st->codec->subtitle_header);
2304  av_free(ost->forced_kf_pts);
2305  av_dict_free(&ost->opts);
2306  }
2307  }
2308  }
2309  return ret;
2310 }
2311 
2312 static int64_t getutime(void)
2313 {
2314 #if HAVE_GETRUSAGE
2315  struct rusage rusage;
2316 
2317  getrusage(RUSAGE_SELF, &rusage);
2318  return (rusage.ru_utime.tv_sec * 1000000LL) + rusage.ru_utime.tv_usec;
2319 #elif HAVE_GETPROCESSTIMES
2320  HANDLE proc;
2321  FILETIME c, e, k, u;
2322  proc = GetCurrentProcess();
2323  GetProcessTimes(proc, &c, &e, &k, &u);
2324  return ((int64_t) u.dwHighDateTime << 32 | u.dwLowDateTime) / 10;
2325 #else
2326  return av_gettime();
2327 #endif
2328 }
2329 
2330 static int64_t getmaxrss(void)
2331 {
2332 #if HAVE_GETRUSAGE && HAVE_STRUCT_RUSAGE_RU_MAXRSS
2333  struct rusage rusage;
2334  getrusage(RUSAGE_SELF, &rusage);
2335  return (int64_t)rusage.ru_maxrss * 1024;
2336 #elif HAVE_GETPROCESSMEMORYINFO
2337  HANDLE proc;
2338  PROCESS_MEMORY_COUNTERS memcounters;
2339  proc = GetCurrentProcess();
2340  memcounters.cb = sizeof(memcounters);
2341  GetProcessMemoryInfo(proc, &memcounters, sizeof(memcounters));
2342  return memcounters.PeakPagefileUsage;
2343 #else
2344  return 0;
2345 #endif
2346 }
2347 
2348 int main(int argc, char **argv)
2349 {
2350  int ret;
2351  int64_t ti;
2352 
2353  atexit(exit_program);
2354 
2356  parse_loglevel(argc, argv, options);
2357 
2359 #if CONFIG_AVDEVICE
2361 #endif
2363  av_register_all();
2365 
2366  show_banner();
2367 
2368  /* parse options and open all input/output files */
2369  ret = avconv_parse_options(argc, argv);
2370  if (ret < 0)
2371  exit(1);
2372 
2373  if (nb_output_files <= 0 && nb_input_files == 0) {
2374  show_usage();
2375  av_log(NULL, AV_LOG_WARNING, "Use -h to get full help or, even better, run 'man %s'\n", program_name);
2376  exit(1);
2377  }
2378 
2379  /* file converter / grab */
2380  if (nb_output_files <= 0) {
2381  fprintf(stderr, "At least one output file must be specified\n");
2382  exit(1);
2383  }
2384 
2385  ti = getutime();
2386  if (transcode() < 0)
2387  exit(1);
2388  ti = getutime() - ti;
2389  if (do_benchmark) {
2390  int maxrss = getmaxrss() / 1024;
2391  printf("bench: utime=%0.3fs maxrss=%ikB\n", ti / 1000000.0, maxrss);
2392  }
2393 
2394  exit(0);
2395  return 0;
2396 }