FFmpeg
ffmpeg_demux.c
Go to the documentation of this file.
1 /*
2  * This file is part of FFmpeg.
3  *
4  * FFmpeg is free software; you can redistribute it and/or
5  * modify it under the terms of the GNU Lesser General Public
6  * License as published by the Free Software Foundation; either
7  * version 2.1 of the License, or (at your option) any later version.
8  *
9  * FFmpeg is distributed in the hope that it will be useful,
10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
12  * Lesser General Public License for more details.
13  *
14  * You should have received a copy of the GNU Lesser General Public
15  * License along with FFmpeg; if not, write to the Free Software
16  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
17  */
18 
19 #include <float.h>
20 #include <stdint.h>
21 
22 #include "ffmpeg.h"
23 #include "ffmpeg_sched.h"
24 #include "ffmpeg_utils.h"
25 
26 #include "libavutil/avassert.h"
27 #include "libavutil/avstring.h"
28 #include "libavutil/display.h"
29 #include "libavutil/error.h"
30 #include "libavutil/intreadwrite.h"
31 #include "libavutil/mem.h"
32 #include "libavutil/opt.h"
33 #include "libavutil/parseutils.h"
34 #include "libavutil/pixdesc.h"
35 #include "libavutil/time.h"
36 #include "libavutil/timestamp.h"
37 
38 #include "libavcodec/bsf.h"
39 #include "libavcodec/packet.h"
40 
41 #include "libavformat/avformat.h"
42 
43 typedef struct DemuxStream {
45 
46  // name used for logging
47  char log_name[32];
48 
51 
52  double ts_scale;
53 
54  /* non zero if the packets must be decoded in 'raw_fifo', see DECODING_FOR_* */
56 #define DECODING_FOR_OST 1
57 #define DECODING_FOR_FILTER 2
58 
59  /* true if stream data should be discarded */
60  int discard;
61 
62  // scheduler returned EOF for this stream
63  int finished;
64 
70 
71 
74  ///< dts of the first packet read for this stream (in AV_TIME_BASE units)
76 
77  /* predicted dts of the next packet read for this stream or (when there are
78  * several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
80  ///< dts of the last packet read for this stream (in AV_TIME_BASE units)
82 
84 
87  char dec_name[16];
88  // decoded media properties, as estimated by opening the decoder
90 
92 
93  /* number of packets successfully read for this stream */
94  uint64_t nb_packets;
95  // combined size of all the packets read
96  uint64_t data_size;
97 } DemuxStream;
98 
99 typedef struct Demuxer {
101 
102  // name used for logging
103  char log_name[32];
104 
106 
107  /**
108  * Extra timestamp offset added by discontinuity handling.
109  */
112 
115 
116  /* number of times input stream should be looped */
117  int loop;
119  /* duration of the looped segment of the input file */
121  /* pts with the smallest/largest values ever seen */
124 
125  /* number of streams that the user was warned of */
127 
128  float readrate;
130 
132 
134 
138 } Demuxer;
139 
140 typedef struct DemuxThreadContext {
141  // packet used for reading from the demuxer
143  // packet for reading from BSFs
146 
148 {
149  return (DemuxStream*)ist;
150 }
151 
153 {
154  return (Demuxer*)f;
155 }
156 
158 {
159  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
160  DemuxStream *ds = ds_from_ist(ist);
161  if (ist->par->codec_type == type && ds->discard &&
162  ist->user_set_discard != AVDISCARD_ALL)
163  return ist;
164  }
165  return NULL;
166 }
167 
168 static void report_new_stream(Demuxer *d, const AVPacket *pkt)
169 {
170  const AVStream *st = d->f.ctx->streams[pkt->stream_index];
171 
172  if (pkt->stream_index < d->nb_streams_warn)
173  return;
175  "New %s stream with index %d at pos:%"PRId64" and DTS:%ss\n",
178  d->nb_streams_warn = pkt->stream_index + 1;
179 }
180 
181 static int seek_to_start(Demuxer *d, Timestamp end_pts)
182 {
183  InputFile *ifile = &d->f;
184  AVFormatContext *is = ifile->ctx;
185  int ret;
186 
187  ret = avformat_seek_file(is, -1, INT64_MIN, is->start_time, is->start_time, 0);
188  if (ret < 0)
189  return ret;
190 
191  if (end_pts.ts != AV_NOPTS_VALUE &&
192  (d->max_pts.ts == AV_NOPTS_VALUE ||
193  av_compare_ts(d->max_pts.ts, d->max_pts.tb, end_pts.ts, end_pts.tb) < 0))
194  d->max_pts = end_pts;
195 
196  if (d->max_pts.ts != AV_NOPTS_VALUE) {
197  int64_t min_pts = d->min_pts.ts == AV_NOPTS_VALUE ? 0 : d->min_pts.ts;
198  d->duration.ts = d->max_pts.ts - av_rescale_q(min_pts, d->min_pts.tb, d->max_pts.tb);
199  }
200  d->duration.tb = d->max_pts.tb;
201 
202  if (d->loop > 0)
203  d->loop--;
204 
205  return ret;
206 }
207 
209  AVPacket *pkt)
210 {
211  InputFile *ifile = &d->f;
212  DemuxStream *ds = ds_from_ist(ist);
213  const int fmt_is_discont = ifile->ctx->iformat->flags & AVFMT_TS_DISCONT;
214  int disable_discontinuity_correction = copy_ts;
217 
218  if (copy_ts && ds->next_dts != AV_NOPTS_VALUE &&
219  fmt_is_discont && ist->st->pts_wrap_bits < 60) {
220  int64_t wrap_dts = av_rescale_q_rnd(pkt->dts + (1LL<<ist->st->pts_wrap_bits),
223  if (FFABS(wrap_dts - ds->next_dts) < FFABS(pkt_dts - ds->next_dts)/10)
224  disable_discontinuity_correction = 0;
225  }
226 
227  if (ds->next_dts != AV_NOPTS_VALUE && !disable_discontinuity_correction) {
228  int64_t delta = pkt_dts - ds->next_dts;
229  if (fmt_is_discont) {
230  if (FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE ||
231  pkt_dts + AV_TIME_BASE/10 < ds->dts) {
232  d->ts_offset_discont -= delta;
233  av_log(ist, AV_LOG_WARNING,
234  "timestamp discontinuity "
235  "(stream id=%d): %"PRId64", new offset= %"PRId64"\n",
236  ist->st->id, delta, d->ts_offset_discont);
238  if (pkt->pts != AV_NOPTS_VALUE)
240  }
241  } else {
242  if (FFABS(delta) > 1LL * dts_error_threshold * AV_TIME_BASE) {
244  "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n",
245  pkt->dts, ds->next_dts, pkt->stream_index);
247  }
248  if (pkt->pts != AV_NOPTS_VALUE){
250  delta = pkt_pts - ds->next_dts;
251  if (FFABS(delta) > 1LL * dts_error_threshold * AV_TIME_BASE) {
253  "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n",
254  pkt->pts, ds->next_dts, pkt->stream_index);
256  }
257  }
258  }
259  } else if (ds->next_dts == AV_NOPTS_VALUE && !copy_ts &&
260  fmt_is_discont && d->last_ts != AV_NOPTS_VALUE) {
261  int64_t delta = pkt_dts - d->last_ts;
262  if (FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE) {
263  d->ts_offset_discont -= delta;
265  "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
268  if (pkt->pts != AV_NOPTS_VALUE)
270  }
271  }
272 
274 }
275 
277  AVPacket *pkt)
278 {
280  pkt->time_base);
281 
282  // apply previously-detected timestamp-discontinuity offset
283  // (to all streams, not just audio/video)
284  if (pkt->dts != AV_NOPTS_VALUE)
285  pkt->dts += offset;
286  if (pkt->pts != AV_NOPTS_VALUE)
287  pkt->pts += offset;
288 
289  // detect timestamp discontinuities for audio/video
290  if ((ist->par->codec_type == AVMEDIA_TYPE_VIDEO ||
291  ist->par->codec_type == AVMEDIA_TYPE_AUDIO) &&
292  pkt->dts != AV_NOPTS_VALUE)
293  ts_discontinuity_detect(d, ist, pkt);
294 }
295 
297 {
298  InputStream *ist = &ds->ist;
299  const AVCodecParameters *par = ist->par;
300 
301  if (!ds->saw_first_ts) {
302  ds->first_dts =
303  ds->dts = ist->st->avg_frame_rate.num ? - ist->par->video_delay * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
304  if (pkt->pts != AV_NOPTS_VALUE) {
305  ds->first_dts =
307  }
308  ds->saw_first_ts = 1;
309  }
310 
311  if (ds->next_dts == AV_NOPTS_VALUE)
312  ds->next_dts = ds->dts;
313 
314  if (pkt->dts != AV_NOPTS_VALUE)
316 
317  ds->dts = ds->next_dts;
318  switch (par->codec_type) {
319  case AVMEDIA_TYPE_AUDIO:
320  av_assert1(pkt->duration >= 0);
321  if (par->sample_rate) {
322  ds->next_dts += ((int64_t)AV_TIME_BASE * par->frame_size) /
323  par->sample_rate;
324  } else {
326  }
327  break;
328  case AVMEDIA_TYPE_VIDEO:
329  if (ist->framerate.num) {
330  // TODO: Remove work-around for c99-to-c89 issue 7
331  AVRational time_base_q = AV_TIME_BASE_Q;
332  int64_t next_dts = av_rescale_q(ds->next_dts, time_base_q, av_inv_q(ist->framerate));
333  ds->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
334  } else if (pkt->duration) {
336  } else if (ist->par->framerate.num != 0) {
337  AVRational field_rate = av_mul_q(ist->par->framerate,
338  (AVRational){ 2, 1 });
339  int fields = 2;
340 
341  if (ds->codec_desc &&
343  av_stream_get_parser(ist->st))
345 
346  ds->next_dts += av_rescale_q(fields, av_inv_q(field_rate), AV_TIME_BASE_Q);
347  }
348  break;
349  }
350 
351  fd->dts_est = ds->dts;
352 
353  return 0;
354 }
355 
356 static int ts_fixup(Demuxer *d, AVPacket *pkt, FrameData *fd)
357 {
358  InputFile *ifile = &d->f;
359  InputStream *ist = ifile->streams[pkt->stream_index];
360  DemuxStream *ds = ds_from_ist(ist);
361  const int64_t start_time = ifile->start_time_effective;
363  int ret;
364 
365  pkt->time_base = ist->st->time_base;
366 
367 #define SHOW_TS_DEBUG(tag_) \
368  if (debug_ts) { \
369  av_log(ist, AV_LOG_INFO, "%s -> ist_index:%d:%d type:%s " \
370  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s duration:%s duration_time:%s\n", \
371  tag_, ifile->index, pkt->stream_index, \
372  av_get_media_type_string(ist->st->codecpar->codec_type), \
373  av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &pkt->time_base), \
374  av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &pkt->time_base), \
375  av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &pkt->time_base)); \
376  }
377 
378  SHOW_TS_DEBUG("demuxer");
379 
381  ist->st->pts_wrap_bits < 64) {
382  int64_t stime, stime2;
383 
385  stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
386  ds->wrap_correction_done = 1;
387 
388  if(stime2 > stime && pkt->dts != AV_NOPTS_VALUE && pkt->dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
389  pkt->dts -= 1ULL<<ist->st->pts_wrap_bits;
390  ds->wrap_correction_done = 0;
391  }
392  if(stime2 > stime && pkt->pts != AV_NOPTS_VALUE && pkt->pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
393  pkt->pts -= 1ULL<<ist->st->pts_wrap_bits;
394  ds->wrap_correction_done = 0;
395  }
396  }
397 
398  if (pkt->dts != AV_NOPTS_VALUE)
400  if (pkt->pts != AV_NOPTS_VALUE)
402 
403  if (pkt->pts != AV_NOPTS_VALUE)
404  pkt->pts *= ds->ts_scale;
405  if (pkt->dts != AV_NOPTS_VALUE)
406  pkt->dts *= ds->ts_scale;
407 
409  if (pkt->pts != AV_NOPTS_VALUE) {
410  // audio decoders take precedence for estimating total file duration
411  int64_t pkt_duration = d->have_audio_dec ? 0 : pkt->duration;
412 
413  pkt->pts += duration;
414 
415  // update max/min pts that will be used to compute total file duration
416  // when using -stream_loop
417  if (d->max_pts.ts == AV_NOPTS_VALUE ||
419  pkt->pts + pkt_duration, pkt->time_base) < 0) {
420  d->max_pts = (Timestamp){ .ts = pkt->pts + pkt_duration,
421  .tb = pkt->time_base };
422  }
423  if (d->min_pts.ts == AV_NOPTS_VALUE ||
425  pkt->pts, pkt->time_base) > 0) {
426  d->min_pts = (Timestamp){ .ts = pkt->pts,
427  .tb = pkt->time_base };
428  }
429  }
430 
431  if (pkt->dts != AV_NOPTS_VALUE)
432  pkt->dts += duration;
433 
434  SHOW_TS_DEBUG("demuxer+tsfixup");
435 
436  // detect and try to correct for timestamp discontinuities
437  ts_discontinuity_process(d, ist, pkt);
438 
439  // update estimated/predicted dts
440  ret = ist_dts_update(ds, pkt, fd);
441  if (ret < 0)
442  return ret;
443 
444  return 0;
445 }
446 
447 static int input_packet_process(Demuxer *d, AVPacket *pkt, unsigned *send_flags)
448 {
449  InputFile *f = &d->f;
450  InputStream *ist = f->streams[pkt->stream_index];
451  DemuxStream *ds = ds_from_ist(ist);
452  FrameData *fd;
453  int ret = 0;
454 
455  fd = packet_data(pkt);
456  if (!fd)
457  return AVERROR(ENOMEM);
458 
459  ret = ts_fixup(d, pkt, fd);
460  if (ret < 0)
461  return ret;
462 
463  if (d->recording_time != INT64_MAX) {
464  int64_t start_time = 0;
465  if (copy_ts) {
466  start_time += f->start_time != AV_NOPTS_VALUE ? f->start_time : 0;
467  start_time += start_at_zero ? 0 : f->start_time_effective;
468  }
469  if (ds->dts >= d->recording_time + start_time)
470  *send_flags |= DEMUX_SEND_STREAMCOPY_EOF;
471  }
472 
473  ds->data_size += pkt->size;
474  ds->nb_packets++;
475 
477 
478  if (debug_ts) {
479  av_log(NULL, AV_LOG_INFO, "demuxer+ffmpeg -> ist_index:%d:%d type:%s pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s duration:%s duration_time:%s off:%s off_time:%s\n",
480  f->index, pkt->stream_index,
485  av_ts2str(f->ts_offset), av_ts2timestr(f->ts_offset, &AV_TIME_BASE_Q));
486  }
487 
488  return 0;
489 }
490 
491 static void readrate_sleep(Demuxer *d)
492 {
493  InputFile *f = &d->f;
494  int64_t file_start = copy_ts * (
495  (f->start_time_effective != AV_NOPTS_VALUE ? f->start_time_effective * !start_at_zero : 0) +
496  (f->start_time != AV_NOPTS_VALUE ? f->start_time : 0)
497  );
498  int64_t burst_until = AV_TIME_BASE * d->readrate_initial_burst;
499  for (int i = 0; i < f->nb_streams; i++) {
500  InputStream *ist = f->streams[i];
501  DemuxStream *ds = ds_from_ist(ist);
502  int64_t stream_ts_offset, pts, now;
503  stream_ts_offset = FFMAX(ds->first_dts != AV_NOPTS_VALUE ? ds->first_dts : 0, file_start);
504  pts = av_rescale(ds->dts, 1000000, AV_TIME_BASE);
505  now = (av_gettime_relative() - d->wallclock_start) * d->readrate + stream_ts_offset;
506  if (pts - burst_until > now)
507  av_usleep(pts - burst_until - now);
508  }
509 }
510 
511 static int do_send(Demuxer *d, DemuxStream *ds, AVPacket *pkt, unsigned flags,
512  const char *pkt_desc)
513 {
514  int ret;
515 
517 
518  ret = sch_demux_send(d->sch, d->f.index, pkt, flags);
519  if (ret == AVERROR_EOF) {
521 
522  av_log(ds, AV_LOG_VERBOSE, "All consumers of this stream are done\n");
523  ds->finished = 1;
524 
525  if (++d->nb_streams_finished == d->nb_streams_used) {
526  av_log(d, AV_LOG_VERBOSE, "All consumers are done\n");
527  return AVERROR_EOF;
528  }
529  } else if (ret < 0) {
530  if (ret != AVERROR_EXIT)
531  av_log(d, AV_LOG_ERROR,
532  "Unable to send %s packet to consumers: %s\n",
533  pkt_desc, av_err2str(ret));
534  return ret;
535  }
536 
537  return 0;
538 }
539 
541  AVPacket *pkt, unsigned flags)
542 {
543  InputFile *f = &d->f;
544  int ret;
545 
546  // pkt can be NULL only when flushing BSFs
547  av_assert0(ds->bsf || pkt);
548 
549  // send heartbeat for sub2video streams
550  if (d->pkt_heartbeat && pkt && pkt->pts != AV_NOPTS_VALUE) {
551  for (int i = 0; i < f->nb_streams; i++) {
552  DemuxStream *ds1 = ds_from_ist(f->streams[i]);
553 
554  if (ds1->finished || !ds1->have_sub2video)
555  continue;
556 
557  d->pkt_heartbeat->pts = pkt->pts;
559  d->pkt_heartbeat->opaque = (void*)(intptr_t)PKT_OPAQUE_SUB_HEARTBEAT;
560 
561  ret = do_send(d, ds1, d->pkt_heartbeat, 0, "heartbeat");
562  if (ret < 0)
563  return ret;
564  }
565  }
566 
567  if (ds->bsf) {
568  if (pkt)
570 
571  ret = av_bsf_send_packet(ds->bsf, pkt);
572  if (ret < 0) {
573  if (pkt)
575  av_log(ds, AV_LOG_ERROR, "Error submitting a packet for filtering: %s\n",
576  av_err2str(ret));
577  return ret;
578  }
579 
580  while (1) {
581  ret = av_bsf_receive_packet(ds->bsf, dt->pkt_bsf);
582  if (ret == AVERROR(EAGAIN))
583  return 0;
584  else if (ret < 0) {
585  if (ret != AVERROR_EOF)
586  av_log(ds, AV_LOG_ERROR,
587  "Error applying bitstream filters to a packet: %s\n",
588  av_err2str(ret));
589  return ret;
590  }
591 
592  dt->pkt_bsf->time_base = ds->bsf->time_base_out;
593 
594  ret = do_send(d, ds, dt->pkt_bsf, 0, "filtered");
595  if (ret < 0) {
597  return ret;
598  }
599  }
600  } else {
601  ret = do_send(d, ds, pkt, flags, "demuxed");
602  if (ret < 0)
603  return ret;
604  }
605 
606  return 0;
607 }
608 
610 {
611  InputFile *f = &d->f;
612  int ret;
613 
614  for (unsigned i = 0; i < f->nb_streams; i++) {
615  DemuxStream *ds = ds_from_ist(f->streams[i]);
616 
617  if (!ds->bsf)
618  continue;
619 
620  ret = demux_send(d, dt, ds, NULL, 0);
621  ret = (ret == AVERROR_EOF) ? 0 : (ret < 0) ? ret : AVERROR_BUG;
622  if (ret < 0) {
623  av_log(ds, AV_LOG_ERROR, "Error flushing BSFs: %s\n",
624  av_err2str(ret));
625  return ret;
626  }
627 
628  av_bsf_flush(ds->bsf);
629  }
630 
631  return 0;
632 }
633 
635 {
636  for (int j = 0; j < ifile->ctx->nb_programs; j++) {
637  AVProgram *p = ifile->ctx->programs[j];
638  int discard = AVDISCARD_ALL;
639 
640  for (int k = 0; k < p->nb_stream_indexes; k++) {
641  DemuxStream *ds = ds_from_ist(ifile->streams[p->stream_index[k]]);
642 
643  if (!ds->discard) {
644  discard = AVDISCARD_DEFAULT;
645  break;
646  }
647  }
648  p->discard = discard;
649  }
650 }
651 
653 {
654  char name[16];
655  snprintf(name, sizeof(name), "dmx%d:%s", f->index, f->ctx->iformat->name);
657 }
658 
660 {
662  av_packet_free(&dt->pkt_bsf);
663 
664  memset(dt, 0, sizeof(*dt));
665 }
666 
668 {
669  memset(dt, 0, sizeof(*dt));
670 
671  dt->pkt_demux = av_packet_alloc();
672  if (!dt->pkt_demux)
673  return AVERROR(ENOMEM);
674 
675  dt->pkt_bsf = av_packet_alloc();
676  if (!dt->pkt_bsf)
677  return AVERROR(ENOMEM);
678 
679  return 0;
680 }
681 
682 static int input_thread(void *arg)
683 {
684  Demuxer *d = arg;
685  InputFile *f = &d->f;
686 
688 
689  int ret = 0;
690 
691  ret = demux_thread_init(&dt);
692  if (ret < 0)
693  goto finish;
694 
696 
698 
699  d->read_started = 1;
701 
702  while (1) {
703  DemuxStream *ds;
704  unsigned send_flags = 0;
705 
706  ret = av_read_frame(f->ctx, dt.pkt_demux);
707 
708  if (ret == AVERROR(EAGAIN)) {
709  av_usleep(10000);
710  continue;
711  }
712  if (ret < 0) {
713  int ret_bsf;
714 
715  if (ret == AVERROR_EOF)
716  av_log(d, AV_LOG_VERBOSE, "EOF while reading input\n");
717  else {
718  av_log(d, AV_LOG_ERROR, "Error during demuxing: %s\n",
719  av_err2str(ret));
720  ret = exit_on_error ? ret : 0;
721  }
722 
723  ret_bsf = demux_bsf_flush(d, &dt);
724  ret = err_merge(ret == AVERROR_EOF ? 0 : ret, ret_bsf);
725 
726  if (d->loop) {
727  /* signal looping to our consumers */
728  dt.pkt_demux->stream_index = -1;
729  ret = sch_demux_send(d->sch, f->index, dt.pkt_demux, 0);
730  if (ret >= 0)
731  ret = seek_to_start(d, (Timestamp){ .ts = dt.pkt_demux->pts,
732  .tb = dt.pkt_demux->time_base });
733  if (ret >= 0)
734  continue;
735 
736  /* fallthrough to the error path */
737  }
738 
739  break;
740  }
741 
742  if (do_pkt_dump) {
744  f->ctx->streams[dt.pkt_demux->stream_index]);
745  }
746 
747  /* the following test is needed in case new streams appear
748  dynamically in stream : we ignore them */
749  ds = dt.pkt_demux->stream_index < f->nb_streams ?
750  ds_from_ist(f->streams[dt.pkt_demux->stream_index]) : NULL;
751  if (!ds || ds->discard || ds->finished) {
754  continue;
755  }
756 
757  if (dt.pkt_demux->flags & AV_PKT_FLAG_CORRUPT) {
759  "corrupt input packet in stream %d\n",
760  dt.pkt_demux->stream_index);
761  if (exit_on_error) {
764  break;
765  }
766  }
767 
768  ret = input_packet_process(d, dt.pkt_demux, &send_flags);
769  if (ret < 0)
770  break;
771 
772  if (d->readrate)
773  readrate_sleep(d);
774 
775  ret = demux_send(d, &dt, ds, dt.pkt_demux, send_flags);
776  if (ret < 0)
777  break;
778  }
779 
780  // EOF/EXIT is normal termination
781  if (ret == AVERROR_EOF || ret == AVERROR_EXIT)
782  ret = 0;
783 
784 finish:
785  demux_thread_uninit(&dt);
786 
787  return ret;
788 }
789 
790 static void demux_final_stats(Demuxer *d)
791 {
792  InputFile *f = &d->f;
793  uint64_t total_packets = 0, total_size = 0;
794 
795  av_log(f, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
796  f->index, f->ctx->url);
797 
798  for (int j = 0; j < f->nb_streams; j++) {
799  InputStream *ist = f->streams[j];
800  DemuxStream *ds = ds_from_ist(ist);
801  enum AVMediaType type = ist->par->codec_type;
802 
803  if (ds->discard || type == AVMEDIA_TYPE_ATTACHMENT)
804  continue;
805 
806  total_size += ds->data_size;
807  total_packets += ds->nb_packets;
808 
809  av_log(f, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ",
810  f->index, j, av_get_media_type_string(type));
811  av_log(f, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
812  ds->nb_packets, ds->data_size);
813 
814  if (ds->decoding_needed) {
816  "%"PRIu64" frames decoded; %"PRIu64" decode errors",
818  if (type == AVMEDIA_TYPE_AUDIO)
819  av_log(f, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->decoder->samples_decoded);
820  av_log(f, AV_LOG_VERBOSE, "; ");
821  }
822 
823  av_log(f, AV_LOG_VERBOSE, "\n");
824  }
825 
826  av_log(f, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
827  total_packets, total_size);
828 }
829 
830 static void ist_free(InputStream **pist)
831 {
832  InputStream *ist = *pist;
833  DemuxStream *ds;
834 
835  if (!ist)
836  return;
837  ds = ds_from_ist(ist);
838 
839  dec_free(&ist->decoder);
840 
842  av_freep(&ist->filters);
843  av_freep(&ist->outputs);
845 
847 
849 
850  av_bsf_free(&ds->bsf);
851 
852  av_freep(pist);
853 }
854 
856 {
857  InputFile *f = *pf;
859 
860  if (!f)
861  return;
862 
863  if (d->read_started)
865 
866  for (int i = 0; i < f->nb_streams; i++)
867  ist_free(&f->streams[i]);
868  av_freep(&f->streams);
869 
870  avformat_close_input(&f->ctx);
871 
873 
874  av_freep(pf);
875 }
876 
877 static int ist_use(InputStream *ist, int decoding_needed)
878 {
879  Demuxer *d = demuxer_from_ifile(ist->file);
880  DemuxStream *ds = ds_from_ist(ist);
881  int ret;
882 
883  if (ist->user_set_discard == AVDISCARD_ALL) {
884  av_log(ist, AV_LOG_ERROR, "Cannot %s a disabled input stream\n",
885  decoding_needed ? "decode" : "streamcopy");
886  return AVERROR(EINVAL);
887  }
888 
889  if (decoding_needed && !ist->dec) {
890  av_log(ist, AV_LOG_ERROR,
891  "Decoding requested, but no decoder found for: %s\n",
892  avcodec_get_name(ist->par->codec_id));
893  return AVERROR(EINVAL);
894  }
895 
896  if (ds->sch_idx_stream < 0) {
897  ret = sch_add_demux_stream(d->sch, d->f.index);
898  if (ret < 0)
899  return ret;
900  ds->sch_idx_stream = ret;
901  }
902 
903  if (ds->discard) {
904  ds->discard = 0;
905  d->nb_streams_used++;
906  }
907 
908  ist->st->discard = ist->user_set_discard;
909  ds->decoding_needed |= decoding_needed;
910  ds->streamcopy_needed |= !decoding_needed;
911 
912  if (decoding_needed && ds->sch_idx_dec < 0) {
913  int is_audio = ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
914 
917  (!!(d->loop && is_audio) * DECODER_FLAG_SEND_END_TS)
918 #if FFMPEG_OPT_TOP
920 #endif
921  ;
922 
923  if (ist->framerate.num) {
925  ds->dec_opts.framerate = ist->framerate;
926  } else
927  ds->dec_opts.framerate = ist->st->avg_frame_rate;
928 
929  if (ist->dec->id == AV_CODEC_ID_DVB_SUBTITLE &&
931  av_dict_set(&ds->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
933  av_log(ist, AV_LOG_WARNING,
934  "Warning using DVB subtitles for filtering and output at the "
935  "same time is not fully supported, also see -compute_edt [0|1]\n");
936  }
937 
938  snprintf(ds->dec_name, sizeof(ds->dec_name), "%d:%d", ist->file->index, ist->index);
939  ds->dec_opts.name = ds->dec_name;
940 
941  ds->dec_opts.codec = ist->dec;
942  ds->dec_opts.par = ist->par;
943 
944  ds->dec_opts.log_parent = ist;
945 
947  if (!ds->decoded_params)
948  return AVERROR(ENOMEM);
949 
950  ret = dec_init(&ist->decoder, d->sch,
951  &ds->decoder_opts, &ds->dec_opts, ds->decoded_params);
952  if (ret < 0)
953  return ret;
954  ds->sch_idx_dec = ret;
955 
957  SCH_DEC(ds->sch_idx_dec));
958  if (ret < 0)
959  return ret;
960 
961  d->have_audio_dec |= is_audio;
962  }
963 
964  return 0;
965 }
966 
968 {
969  DemuxStream *ds = ds_from_ist(ist);
970  int ret;
971 
972  ret = ist_use(ist, ost->enc ? DECODING_FOR_OST : 0);
973  if (ret < 0)
974  return ret;
975 
976  ret = GROW_ARRAY(ist->outputs, ist->nb_outputs);
977  if (ret < 0)
978  return ret;
979 
980  ist->outputs[ist->nb_outputs - 1] = ost;
981 
982  return ost->enc ? ds->sch_idx_dec : ds->sch_idx_stream;
983 }
984 
985 int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple,
987 {
988  Demuxer *d = demuxer_from_ifile(ist->file);
989  DemuxStream *ds = ds_from_ist(ist);
990  int64_t tsoffset = 0;
991  int ret;
992 
993  ret = ist_use(ist, is_simple ? DECODING_FOR_OST : DECODING_FOR_FILTER);
994  if (ret < 0)
995  return ret;
996 
997  ret = GROW_ARRAY(ist->filters, ist->nb_filters);
998  if (ret < 0)
999  return ret;
1000 
1001  ist->filters[ist->nb_filters - 1] = ifilter;
1002 
1003  if (ist->par->codec_type == AVMEDIA_TYPE_VIDEO) {
1005  ist->par->nb_coded_side_data,
1007  if (ist->framerate.num > 0 && ist->framerate.den > 0) {
1008  opts->framerate = ist->framerate;
1009  opts->flags |= IFILTER_FLAG_CFR;
1010  } else
1011  opts->framerate = av_guess_frame_rate(d->f.ctx, ist->st, NULL);
1012  if (sd && sd->size >= sizeof(uint32_t) * 4) {
1013  opts->crop_top = AV_RL32(sd->data + 0);
1014  opts->crop_bottom = AV_RL32(sd->data + 4);
1015  opts->crop_left = AV_RL32(sd->data + 8);
1016  opts->crop_right = AV_RL32(sd->data + 12);
1017  if (ds->apply_cropping && ds->apply_cropping != CROP_CODEC &&
1018  (opts->crop_top | opts->crop_bottom | opts->crop_left | opts->crop_right))
1019  opts->flags |= IFILTER_FLAG_CROP;
1020  }
1021  } else if (ist->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1022  /* Compute the size of the canvas for the subtitles stream.
1023  If the subtitles codecpar has set a size, use it. Otherwise use the
1024  maximum dimensions of the video streams in the same file. */
1025  opts->sub2video_width = ist->par->width;
1026  opts->sub2video_height = ist->par->height;
1027  if (!(opts->sub2video_width && opts->sub2video_height)) {
1028  for (int j = 0; j < d->f.nb_streams; j++) {
1029  AVCodecParameters *par1 = d->f.streams[j]->par;
1030  if (par1->codec_type == AVMEDIA_TYPE_VIDEO) {
1031  opts->sub2video_width = FFMAX(opts->sub2video_width, par1->width);
1032  opts->sub2video_height = FFMAX(opts->sub2video_height, par1->height);
1033  }
1034  }
1035  }
1036 
1037  if (!(opts->sub2video_width && opts->sub2video_height)) {
1038  opts->sub2video_width = FFMAX(opts->sub2video_width, 720);
1039  opts->sub2video_height = FFMAX(opts->sub2video_height, 576);
1040  }
1041 
1042  if (!d->pkt_heartbeat) {
1044  if (!d->pkt_heartbeat)
1045  return AVERROR(ENOMEM);
1046  }
1047  ds->have_sub2video = 1;
1048  }
1049 
1050  ret = av_frame_copy_props(opts->fallback, ds->decoded_params);
1051  if (ret < 0)
1052  return ret;
1053  opts->fallback->format = ds->decoded_params->format;
1054  opts->fallback->width = ds->decoded_params->width;
1055  opts->fallback->height = ds->decoded_params->height;
1056 
1057  ret = av_channel_layout_copy(&opts->fallback->ch_layout, &ds->decoded_params->ch_layout);
1058  if (ret < 0)
1059  return ret;
1060 
1061  if (copy_ts) {
1062  tsoffset = d->f.start_time == AV_NOPTS_VALUE ? 0 : d->f.start_time;
1063  if (!start_at_zero && d->f.ctx->start_time != AV_NOPTS_VALUE)
1064  tsoffset += d->f.ctx->start_time;
1065  }
1066  opts->trim_start_us = ((d->f.start_time == AV_NOPTS_VALUE) || !d->accurate_seek) ?
1067  AV_NOPTS_VALUE : tsoffset;
1068  opts->trim_end_us = d->recording_time;
1069 
1070  opts->name = av_strdup(ds->dec_name);
1071  if (!opts->name)
1072  return AVERROR(ENOMEM);
1073 
1074  opts->flags |= IFILTER_FLAG_AUTOROTATE * !!(ds->autorotate) |
1076 
1077  return ds->sch_idx_dec;
1078 }
1079 
1080 static int choose_decoder(const OptionsContext *o, void *logctx,
1081  AVFormatContext *s, AVStream *st,
1082  enum HWAccelID hwaccel_id, enum AVHWDeviceType hwaccel_device_type,
1083  const AVCodec **pcodec)
1084 
1085 {
1086  const char *codec_name = NULL;
1087 
1088  opt_match_per_stream_str(logctx, &o->codec_names, s, st, &codec_name);
1089  if (codec_name) {
1090  int ret = find_codec(NULL, codec_name, st->codecpar->codec_type, 0, pcodec);
1091  if (ret < 0)
1092  return ret;
1093  st->codecpar->codec_id = (*pcodec)->id;
1094  if (recast_media && st->codecpar->codec_type != (*pcodec)->type)
1095  st->codecpar->codec_type = (*pcodec)->type;
1096  return 0;
1097  } else {
1098  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1099  hwaccel_id == HWACCEL_GENERIC &&
1100  hwaccel_device_type != AV_HWDEVICE_TYPE_NONE) {
1101  const AVCodec *c;
1102  void *i = NULL;
1103 
1104  while ((c = av_codec_iterate(&i))) {
1105  const AVCodecHWConfig *config;
1106 
1107  if (c->id != st->codecpar->codec_id ||
1109  continue;
1110 
1111  for (int j = 0; config = avcodec_get_hw_config(c, j); j++) {
1112  if (config->device_type == hwaccel_device_type) {
1113  av_log(NULL, AV_LOG_VERBOSE, "Selecting decoder '%s' because of requested hwaccel method %s\n",
1114  c->name, av_hwdevice_get_type_name(hwaccel_device_type));
1115  *pcodec = c;
1116  return 0;
1117  }
1118  }
1119  }
1120  }
1121 
1122  *pcodec = avcodec_find_decoder(st->codecpar->codec_id);
1123  return 0;
1124  }
1125 }
1126 
1128  int guess_layout_max)
1129 {
1130  if (par->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) {
1131  char layout_name[256];
1132 
1133  if (par->ch_layout.nb_channels > guess_layout_max)
1134  return 0;
1137  return 0;
1138  av_channel_layout_describe(&par->ch_layout, layout_name, sizeof(layout_name));
1139  av_log(ist, AV_LOG_WARNING, "Guessed Channel Layout: %s\n", layout_name);
1140  }
1141  return 1;
1142 }
1143 
1146 {
1147  AVStream *st = ist->st;
1148  AVPacketSideData *sd;
1149  double rotation = DBL_MAX;
1150  int hflip = -1, vflip = -1;
1151  int hflip_set = 0, vflip_set = 0, rotation_set = 0;
1152  int32_t *buf;
1153 
1154  opt_match_per_stream_dbl(ist, &o->display_rotations, ctx, st, &rotation);
1155  opt_match_per_stream_int(ist, &o->display_hflips, ctx, st, &hflip);
1156  opt_match_per_stream_int(ist, &o->display_vflips, ctx, st, &vflip);
1157 
1158  rotation_set = rotation != DBL_MAX;
1159  hflip_set = hflip != -1;
1160  vflip_set = vflip != -1;
1161 
1162  if (!rotation_set && !hflip_set && !vflip_set)
1163  return 0;
1164 
1168  sizeof(int32_t) * 9, 0);
1169  if (!sd) {
1170  av_log(ist, AV_LOG_FATAL, "Failed to generate a display matrix!\n");
1171  return AVERROR(ENOMEM);
1172  }
1173 
1174  buf = (int32_t *)sd->data;
1176  rotation_set ? -(rotation) : -0.0f);
1177 
1179  hflip_set ? hflip : 0,
1180  vflip_set ? vflip : 0);
1181 
1182  return 0;
1183 }
1184 
1185 static const char *input_stream_item_name(void *obj)
1186 {
1187  const DemuxStream *ds = obj;
1188 
1189  return ds->log_name;
1190 }
1191 
1192 static const AVClass input_stream_class = {
1193  .class_name = "InputStream",
1194  .version = LIBAVUTIL_VERSION_INT,
1195  .item_name = input_stream_item_name,
1196  .category = AV_CLASS_CATEGORY_DEMUXER,
1197 };
1198 
1200 {
1201  const char *type_str = av_get_media_type_string(st->codecpar->codec_type);
1202  InputFile *f = &d->f;
1203  DemuxStream *ds;
1204 
1205  ds = allocate_array_elem(&f->streams, sizeof(*ds), &f->nb_streams);
1206  if (!ds)
1207  return NULL;
1208 
1209  ds->sch_idx_stream = -1;
1210  ds->sch_idx_dec = -1;
1211 
1212  ds->ist.st = st;
1213  ds->ist.file = f;
1214  ds->ist.index = st->index;
1215  ds->ist.class = &input_stream_class;
1216 
1217  snprintf(ds->log_name, sizeof(ds->log_name), "%cist#%d:%d/%s",
1218  type_str ? *type_str : '?', d->f.index, st->index,
1220 
1221  return ds;
1222 }
1223 
1224 static int ist_add(const OptionsContext *o, Demuxer *d, AVStream *st, AVDictionary **opts_used)
1225 {
1226  AVFormatContext *ic = d->f.ctx;
1227  AVCodecParameters *par = st->codecpar;
1228  DemuxStream *ds;
1229  InputStream *ist;
1230  const char *framerate = NULL, *hwaccel_device = NULL;
1231  const char *hwaccel = NULL;
1232  const char *apply_cropping = NULL;
1233  const char *hwaccel_output_format = NULL;
1234  const char *codec_tag = NULL;
1235  const char *bsfs = NULL;
1236  char *next;
1237  const char *discard_str = NULL;
1238  int ret;
1239 
1240  ds = demux_stream_alloc(d, st);
1241  if (!ds)
1242  return AVERROR(ENOMEM);
1243 
1244  ist = &ds->ist;
1245 
1246  ds->discard = 1;
1247  st->discard = AVDISCARD_ALL;
1248  ds->first_dts = AV_NOPTS_VALUE;
1249  ds->next_dts = AV_NOPTS_VALUE;
1250 
1251  ds->dec_opts.time_base = st->time_base;
1252 
1253  ds->ts_scale = 1.0;
1254  opt_match_per_stream_dbl(ist, &o->ts_scale, ic, st, &ds->ts_scale);
1255 
1256  ds->autorotate = 1;
1257  opt_match_per_stream_int(ist, &o->autorotate, ic, st, &ds->autorotate);
1258 
1259  ds->apply_cropping = CROP_ALL;
1261  if (apply_cropping) {
1262  const AVOption opts[] = {
1263  { "apply_cropping", NULL, 0, AV_OPT_TYPE_INT,
1264  { .i64 = CROP_ALL }, CROP_DISABLED, CROP_CONTAINER, AV_OPT_FLAG_DECODING_PARAM, .unit = "apply_cropping" },
1265  { "none", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CROP_DISABLED }, .unit = "apply_cropping" },
1266  { "all", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CROP_ALL }, .unit = "apply_cropping" },
1267  { "codec", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CROP_CODEC }, .unit = "apply_cropping" },
1268  { "container", NULL, 0, AV_OPT_TYPE_CONST, { .i64 = CROP_CONTAINER }, .unit = "apply_cropping" },
1269  { NULL },
1270  };
1271  const AVClass class = {
1272  .class_name = "apply_cropping",
1273  .item_name = av_default_item_name,
1274  .option = opts,
1275  .version = LIBAVUTIL_VERSION_INT,
1276  };
1277  const AVClass *pclass = &class;
1278 
1280  if (ret < 0) {
1281  av_log(ist, AV_LOG_ERROR, "Invalid apply_cropping value '%s'.\n", apply_cropping);
1282  return ret;
1283  }
1284  }
1285 
1286  opt_match_per_stream_str(ist, &o->codec_tags, ic, st, &codec_tag);
1287  if (codec_tag) {
1288  uint32_t tag = strtol(codec_tag, &next, 0);
1289  if (*next) {
1290  uint8_t buf[4] = { 0 };
1291  memcpy(buf, codec_tag, FFMIN(sizeof(buf), strlen(codec_tag)));
1292  tag = AV_RL32(buf);
1293  }
1294 
1295  st->codecpar->codec_tag = tag;
1296  }
1297 
1298  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1299  ret = add_display_matrix_to_stream(o, ic, ist);
1300  if (ret < 0)
1301  return ret;
1302 
1303  opt_match_per_stream_str(ist, &o->hwaccels, ic, st, &hwaccel);
1305  &hwaccel_output_format);
1306  if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
1307  av_log(ist, AV_LOG_WARNING,
1308  "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
1309  "with old commandlines. This behaviour is DEPRECATED and will be removed "
1310  "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
1312  } else if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "qsv")) {
1313  av_log(ist, AV_LOG_WARNING,
1314  "WARNING: defaulting hwaccel_output_format to qsv for compatibility "
1315  "with old commandlines. This behaviour is DEPRECATED and will be removed "
1316  "in the future. Please explicitly set \"-hwaccel_output_format qsv\".\n");
1318  } else if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "mediacodec")) {
1319  // There is no real AVHWFrameContext implementation. Set
1320  // hwaccel_output_format to avoid av_hwframe_transfer_data error.
1322  } else if (hwaccel_output_format) {
1323  ds->dec_opts.hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
1325  av_log(ist, AV_LOG_FATAL, "Unrecognised hwaccel output "
1326  "format: %s", hwaccel_output_format);
1327  }
1328  } else {
1330  }
1331 
1332  if (hwaccel) {
1333  // The NVDEC hwaccels use a CUDA device, so remap the name here.
1334  if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
1335  hwaccel = "cuda";
1336 
1337  if (!strcmp(hwaccel, "none"))
1339  else if (!strcmp(hwaccel, "auto"))
1341  else {
1343  if (type != AV_HWDEVICE_TYPE_NONE) {
1346  }
1347 
1348  if (!ds->dec_opts.hwaccel_id) {
1349  av_log(ist, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
1350  hwaccel);
1351  av_log(ist, AV_LOG_FATAL, "Supported hwaccels: ");
1353  while ((type = av_hwdevice_iterate_types(type)) !=
1355  av_log(ist, AV_LOG_FATAL, "%s ",
1357  av_log(ist, AV_LOG_FATAL, "\n");
1358  return AVERROR(EINVAL);
1359  }
1360  }
1361  }
1362 
1363  opt_match_per_stream_str(ist, &o->hwaccel_devices, ic, st, &hwaccel_device);
1364  if (hwaccel_device) {
1365  ds->dec_opts.hwaccel_device = av_strdup(hwaccel_device);
1366  if (!ds->dec_opts.hwaccel_device)
1367  return AVERROR(ENOMEM);
1368  }
1369  }
1370 
1371  ret = choose_decoder(o, ist, ic, st, ds->dec_opts.hwaccel_id,
1372  ds->dec_opts.hwaccel_device_type, &ist->dec);
1373  if (ret < 0)
1374  return ret;
1375 
1376  if (ist->dec) {
1378  ic, st, ist->dec, &ds->decoder_opts, opts_used);
1379  if (ret < 0)
1380  return ret;
1381  }
1382 
1383  ds->reinit_filters = -1;
1384  opt_match_per_stream_int(ist, &o->reinit_filters, ic, st, &ds->reinit_filters);
1385 
1387 
1388  if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
1393 
1394  opt_match_per_stream_str(ist, &o->discard, ic, st, &discard_str);
1395  if (discard_str) {
1396  ret = av_opt_set(ist->st, "discard", discard_str, 0);
1397  if (ret < 0) {
1398  av_log(ist, AV_LOG_ERROR, "Error parsing discard %s.\n", discard_str);
1399  return ret;
1400  }
1401  ist->user_set_discard = ist->st->discard;
1402  }
1403 
1405 
1406  av_dict_set_int(&ds->decoder_opts, "apply_cropping",
1407  ds->apply_cropping && ds->apply_cropping != CROP_CONTAINER, 0);
1408 
1409  /* Attached pics are sparse, therefore we would not want to delay their decoding
1410  * till EOF. */
1412  av_dict_set(&ds->decoder_opts, "thread_type", "-frame", 0);
1413 
1414  switch (par->codec_type) {
1415  case AVMEDIA_TYPE_VIDEO:
1416  opt_match_per_stream_str(ist, &o->frame_rates, ic, st, &framerate);
1417  if (framerate) {
1419  if (ret < 0) {
1420  av_log(ist, AV_LOG_ERROR, "Error parsing framerate %s.\n",
1421  framerate);
1422  return ret;
1423  }
1424  }
1425 
1426 #if FFMPEG_OPT_TOP
1427  ist->top_field_first = -1;
1428  opt_match_per_stream_int(ist, &o->top_field_first, ic, st, &ist->top_field_first);
1429 #endif
1430 
1431  break;
1432  case AVMEDIA_TYPE_AUDIO: {
1433  const char *ch_layout_str = NULL;
1434 
1435  opt_match_per_stream_str(ist, &o->audio_ch_layouts, ic, st, &ch_layout_str);
1436  if (ch_layout_str) {
1437  AVChannelLayout ch_layout;
1438  ret = av_channel_layout_from_string(&ch_layout, ch_layout_str);
1439  if (ret < 0) {
1440  av_log(ist, AV_LOG_ERROR, "Error parsing channel layout %s.\n", ch_layout_str);
1441  return ret;
1442  }
1443  if (par->ch_layout.nb_channels <= 0 || par->ch_layout.nb_channels == ch_layout.nb_channels) {
1445  par->ch_layout = ch_layout;
1446  } else {
1447  av_log(ist, AV_LOG_ERROR,
1448  "Specified channel layout '%s' has %d channels, but input has %d channels.\n",
1449  ch_layout_str, ch_layout.nb_channels, par->ch_layout.nb_channels);
1450  av_channel_layout_uninit(&ch_layout);
1451  return AVERROR(EINVAL);
1452  }
1453  } else {
1454  int guess_layout_max = INT_MAX;
1455  opt_match_per_stream_int(ist, &o->guess_layout_max, ic, st, &guess_layout_max);
1456  guess_input_channel_layout(ist, par, guess_layout_max);
1457  }
1458  break;
1459  }
1460  case AVMEDIA_TYPE_DATA:
1461  case AVMEDIA_TYPE_SUBTITLE: {
1462  const char *canvas_size = NULL;
1463 
1465  opt_match_per_stream_str(ist, &o->canvas_sizes, ic, st, &canvas_size);
1466  if (canvas_size) {
1467  ret = av_parse_video_size(&par->width, &par->height,
1468  canvas_size);
1469  if (ret < 0) {
1470  av_log(ist, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
1471  return ret;
1472  }
1473  }
1474  break;
1475  }
1477  case AVMEDIA_TYPE_UNKNOWN:
1478  break;
1479  default: av_assert0(0);
1480  }
1481 
1482  ist->par = avcodec_parameters_alloc();
1483  if (!ist->par)
1484  return AVERROR(ENOMEM);
1485 
1486  ret = avcodec_parameters_copy(ist->par, par);
1487  if (ret < 0) {
1488  av_log(ist, AV_LOG_ERROR, "Error exporting stream parameters.\n");
1489  return ret;
1490  }
1491 
1492  if (ist->st->sample_aspect_ratio.num)
1494 
1495  opt_match_per_stream_str(ist, &o->bitstream_filters, ic, st, &bsfs);
1496  if (bsfs) {
1497  ret = av_bsf_list_parse_str(bsfs, &ds->bsf);
1498  if (ret < 0) {
1499  av_log(ist, AV_LOG_ERROR,
1500  "Error parsing bitstream filter sequence '%s': %s\n",
1501  bsfs, av_err2str(ret));
1502  return ret;
1503  }
1504 
1505  ret = avcodec_parameters_copy(ds->bsf->par_in, ist->par);
1506  if (ret < 0)
1507  return ret;
1508  ds->bsf->time_base_in = ist->st->time_base;
1509 
1510  ret = av_bsf_init(ds->bsf);
1511  if (ret < 0) {
1512  av_log(ist, AV_LOG_ERROR, "Error initializing bitstream filters: %s\n",
1513  av_err2str(ret));
1514  return ret;
1515  }
1516 
1517  ret = avcodec_parameters_copy(ist->par, ds->bsf->par_out);
1518  if (ret < 0)
1519  return ret;
1520  }
1521 
1523 
1524  return 0;
1525 }
1526 
1527 static int dump_attachment(InputStream *ist, const char *filename)
1528 {
1529  AVStream *st = ist->st;
1530  int ret;
1531  AVIOContext *out = NULL;
1532  const AVDictionaryEntry *e;
1533 
1534  if (!st->codecpar->extradata_size) {
1535  av_log(ist, AV_LOG_WARNING, "No extradata to dump.\n");
1536  return 0;
1537  }
1538  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1539  filename = e->value;
1540  if (!*filename) {
1541  av_log(ist, AV_LOG_FATAL, "No filename specified and no 'filename' tag");
1542  return AVERROR(EINVAL);
1543  }
1544 
1545  ret = assert_file_overwrite(filename);
1546  if (ret < 0)
1547  return ret;
1548 
1549  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1550  av_log(ist, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1551  filename);
1552  return ret;
1553  }
1554 
1556  ret = avio_close(out);
1557 
1558  if (ret >= 0)
1559  av_log(ist, AV_LOG_INFO, "Wrote attachment (%d bytes) to '%s'\n",
1560  st->codecpar->extradata_size, filename);
1561 
1562  return ret;
1563 }
1564 
1565 static const char *input_file_item_name(void *obj)
1566 {
1567  const Demuxer *d = obj;
1568 
1569  return d->log_name;
1570 }
1571 
1572 static const AVClass input_file_class = {
1573  .class_name = "InputFile",
1574  .version = LIBAVUTIL_VERSION_INT,
1575  .item_name = input_file_item_name,
1576  .category = AV_CLASS_CATEGORY_DEMUXER,
1577 };
1578 
1579 static Demuxer *demux_alloc(void)
1580 {
1582 
1583  if (!d)
1584  return NULL;
1585 
1586  d->f.class = &input_file_class;
1587  d->f.index = nb_input_files - 1;
1588 
1589  snprintf(d->log_name, sizeof(d->log_name), "in#%d", d->f.index);
1590 
1591  return d;
1592 }
1593 
1594 int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch)
1595 {
1596  Demuxer *d;
1597  InputFile *f;
1598  AVFormatContext *ic;
1599  const AVInputFormat *file_iformat = NULL;
1600  int err, ret = 0;
1601  int64_t timestamp;
1602  AVDictionary *opts_used = NULL;
1603  const char* video_codec_name = NULL;
1604  const char* audio_codec_name = NULL;
1605  const char* subtitle_codec_name = NULL;
1606  const char* data_codec_name = NULL;
1607  int scan_all_pmts_set = 0;
1608 
1610  int64_t start_time_eof = o->start_time_eof;
1611  int64_t stop_time = o->stop_time;
1612  int64_t recording_time = o->recording_time;
1613 
1614  d = demux_alloc();
1615  if (!d)
1616  return AVERROR(ENOMEM);
1617 
1618  f = &d->f;
1619 
1620  ret = sch_add_demux(sch, input_thread, d);
1621  if (ret < 0)
1622  return ret;
1623  d->sch = sch;
1624 
1625  if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
1626  stop_time = INT64_MAX;
1627  av_log(d, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1628  }
1629 
1630  if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
1631  int64_t start = start_time == AV_NOPTS_VALUE ? 0 : start_time;
1632  if (stop_time <= start) {
1633  av_log(d, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1634  return AVERROR(EINVAL);
1635  } else {
1636  recording_time = stop_time - start;
1637  }
1638  }
1639 
1640  if (o->format) {
1641  if (!(file_iformat = av_find_input_format(o->format))) {
1642  av_log(d, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1643  return AVERROR(EINVAL);
1644  }
1645  }
1646 
1647  if (!strcmp(filename, "-"))
1648  filename = "fd:";
1649 
1650  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1651  strcmp(filename, "fd:") &&
1652  strcmp(filename, "/dev/stdin");
1653 
1654  /* get default parameters from command line */
1655  ic = avformat_alloc_context();
1656  if (!ic)
1657  return AVERROR(ENOMEM);
1658  if (o->audio_sample_rate.nb_opt) {
1659  av_dict_set_int(&o->g->format_opts, "sample_rate", o->audio_sample_rate.opt[o->audio_sample_rate.nb_opt - 1].u.i, 0);
1660  }
1661  if (o->audio_channels.nb_opt) {
1662  const AVClass *priv_class;
1663  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1664  av_opt_find(&priv_class, "ch_layout", NULL, 0,
1666  char buf[32];
1667  snprintf(buf, sizeof(buf), "%dC", o->audio_channels.opt[o->audio_channels.nb_opt - 1].u.i);
1668  av_dict_set(&o->g->format_opts, "ch_layout", buf, 0);
1669  }
1670  }
1671  if (o->audio_ch_layouts.nb_opt) {
1672  const AVClass *priv_class;
1673  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1674  av_opt_find(&priv_class, "ch_layout", NULL, 0,
1676  av_dict_set(&o->g->format_opts, "ch_layout", o->audio_ch_layouts.opt[o->audio_ch_layouts.nb_opt - 1].u.str, 0);
1677  }
1678  }
1679  if (o->frame_rates.nb_opt) {
1680  const AVClass *priv_class;
1681  /* set the format-level framerate option;
1682  * this is important for video grabbers, e.g. x11 */
1683  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1684  av_opt_find(&priv_class, "framerate", NULL, 0,
1686  av_dict_set(&o->g->format_opts, "framerate",
1687  o->frame_rates.opt[o->frame_rates.nb_opt - 1].u.str, 0);
1688  }
1689  }
1690  if (o->frame_sizes.nb_opt) {
1691  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes.opt[o->frame_sizes.nb_opt - 1].u.str, 0);
1692  }
1693  if (o->frame_pix_fmts.nb_opt)
1694  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts.opt[o->frame_pix_fmts.nb_opt - 1].u.str, 0);
1695 
1699  data_codec_name = opt_match_per_type_str(&o->codec_names, 'd');
1700 
1701  if (video_codec_name)
1703  &ic->video_codec));
1704  if (audio_codec_name)
1706  &ic->audio_codec));
1707  if (subtitle_codec_name)
1709  &ic->subtitle_codec));
1710  if (data_codec_name)
1711  ret = err_merge(ret, find_codec(NULL, data_codec_name , AVMEDIA_TYPE_DATA, 0,
1712  &ic->data_codec));
1713  if (ret < 0) {
1715  return ret;
1716  }
1717 
1721  ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1722 
1723  ic->flags |= AVFMT_FLAG_NONBLOCK;
1724  if (o->bitexact)
1725  ic->flags |= AVFMT_FLAG_BITEXACT;
1726  ic->interrupt_callback = int_cb;
1727 
1728  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1729  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1730  scan_all_pmts_set = 1;
1731  }
1732  /* open the input file with generic avformat function */
1733  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1734  if (err < 0) {
1735  av_log(d, AV_LOG_ERROR,
1736  "Error opening input: %s\n", av_err2str(err));
1737  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1738  av_log(d, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1739  return err;
1740  }
1741  f->ctx = ic;
1742 
1743  av_strlcat(d->log_name, "/", sizeof(d->log_name));
1744  av_strlcat(d->log_name, ic->iformat->name, sizeof(d->log_name));
1745 
1746  if (scan_all_pmts_set)
1747  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1749 
1751  if (ret < 0)
1752  return ret;
1753 
1754  /* apply forced codec ids */
1755  for (int i = 0; i < ic->nb_streams; i++) {
1756  const AVCodec *dummy;
1758  &dummy);
1759  if (ret < 0)
1760  return ret;
1761  }
1762 
1763  if (o->find_stream_info) {
1764  AVDictionary **opts;
1765  int orig_nb_streams = ic->nb_streams;
1766 
1768  if (ret < 0)
1769  return ret;
1770 
1771  /* If not enough info to get the stream parameters, we decode the
1772  first frames to get it. (used in mpeg case for example) */
1774 
1775  for (int i = 0; i < orig_nb_streams; i++)
1776  av_dict_free(&opts[i]);
1777  av_freep(&opts);
1778 
1779  if (ret < 0) {
1780  av_log(d, AV_LOG_FATAL, "could not find codec parameters\n");
1781  if (ic->nb_streams == 0)
1782  return ret;
1783  }
1784  }
1785 
1786  if (start_time != AV_NOPTS_VALUE && start_time_eof != AV_NOPTS_VALUE) {
1787  av_log(d, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss\n");
1788  start_time_eof = AV_NOPTS_VALUE;
1789  }
1790 
1791  if (start_time_eof != AV_NOPTS_VALUE) {
1792  if (start_time_eof >= 0) {
1793  av_log(d, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1794  return AVERROR(EINVAL);
1795  }
1796  if (ic->duration > 0) {
1797  start_time = start_time_eof + ic->duration;
1798  if (start_time < 0) {
1799  av_log(d, AV_LOG_WARNING, "-sseof value seeks to before start of file; ignored\n");
1801  }
1802  } else
1803  av_log(d, AV_LOG_WARNING, "Cannot use -sseof, file duration not known\n");
1804  }
1805  timestamp = (start_time == AV_NOPTS_VALUE) ? 0 : start_time;
1806  /* add the stream start time */
1807  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1808  timestamp += ic->start_time;
1809 
1810  /* if seeking requested, we execute it */
1811  if (start_time != AV_NOPTS_VALUE) {
1812  int64_t seek_timestamp = timestamp;
1813 
1814  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1815  int dts_heuristic = 0;
1816  for (int i = 0; i < ic->nb_streams; i++) {
1817  const AVCodecParameters *par = ic->streams[i]->codecpar;
1818  if (par->video_delay) {
1819  dts_heuristic = 1;
1820  break;
1821  }
1822  }
1823  if (dts_heuristic) {
1824  seek_timestamp -= 3*AV_TIME_BASE / 23;
1825  }
1826  }
1827  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1828  if (ret < 0) {
1829  av_log(d, AV_LOG_WARNING, "could not seek to position %0.3f\n",
1830  (double)timestamp / AV_TIME_BASE);
1831  }
1832  }
1833 
1834  f->start_time = start_time;
1835  d->recording_time = recording_time;
1836  f->input_sync_ref = o->input_sync_ref;
1837  f->input_ts_offset = o->input_ts_offset;
1838  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1839  d->accurate_seek = o->accurate_seek;
1840  d->loop = o->loop;
1841  d->nb_streams_warn = ic->nb_streams;
1842 
1843  d->duration = (Timestamp){ .ts = 0, .tb = (AVRational){ 1, 1 } };
1844  d->min_pts = (Timestamp){ .ts = AV_NOPTS_VALUE, .tb = (AVRational){ 1, 1 } };
1845  d->max_pts = (Timestamp){ .ts = AV_NOPTS_VALUE, .tb = (AVRational){ 1, 1 } };
1846 
1847  d->readrate = o->readrate ? o->readrate : 0.0;
1848  if (d->readrate < 0.0f) {
1849  av_log(d, AV_LOG_ERROR, "Option -readrate is %0.3f; it must be non-negative.\n", d->readrate);
1850  return AVERROR(EINVAL);
1851  }
1852  if (o->rate_emu) {
1853  if (d->readrate) {
1854  av_log(d, AV_LOG_WARNING, "Both -readrate and -re set. Using -readrate %0.3f.\n", d->readrate);
1855  } else
1856  d->readrate = 1.0f;
1857  }
1858 
1859  if (d->readrate) {
1861  if (d->readrate_initial_burst < 0.0) {
1862  av_log(d, AV_LOG_ERROR,
1863  "Option -readrate_initial_burst is %0.3f; it must be non-negative.\n",
1865  return AVERROR(EINVAL);
1866  }
1867  } else if (o->readrate_initial_burst) {
1868  av_log(d, AV_LOG_WARNING, "Option -readrate_initial_burst ignored "
1869  "since neither -readrate nor -re were given\n");
1870  }
1871 
1872  /* Add all the streams from the given input file to the demuxer */
1873  for (int i = 0; i < ic->nb_streams; i++) {
1874  ret = ist_add(o, d, ic->streams[i], &opts_used);
1875  if (ret < 0) {
1876  av_dict_free(&opts_used);
1877  return ret;
1878  }
1879  }
1880 
1881  /* dump the file content */
1882  av_dump_format(ic, f->index, filename, 0);
1883 
1884  /* check if all codec options have been used */
1885  ret = check_avoptions_used(o->g->codec_opts, opts_used, d, 1);
1886  av_dict_free(&opts_used);
1887  if (ret < 0)
1888  return ret;
1889 
1890  for (int i = 0; i < o->dump_attachment.nb_opt; i++) {
1891  for (int j = 0; j < f->nb_streams; j++) {
1892  InputStream *ist = f->streams[j];
1893 
1894  if (check_stream_specifier(ic, ist->st, o->dump_attachment.opt[i].specifier) == 1) {
1896  if (ret < 0)
1897  return ret;
1898  }
1899  }
1900  }
1901 
1902  return 0;
1903 }
OptionsContext::readrate
float readrate
Definition: ffmpeg.h:145
AV_PKT_DATA_DISPLAYMATRIX
@ AV_PKT_DATA_DISPLAYMATRIX
This side data contains a 3x3 transformation matrix describing an affine transformation that needs to...
Definition: packet.h:105
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: packet.c:429
AVCodec
AVCodec.
Definition: codec.h:187
OptionsContext::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:142
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
DemuxStream::ist
InputStream ist
Definition: ffmpeg_demux.c:44
av_gettime_relative
int64_t av_gettime_relative(void)
Get the current time in microseconds since some unspecified starting point.
Definition: time.c:56
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:90
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:186
InputFile::start_time
int64_t start_time
Definition: ffmpeg.h:464
AV_PIX_FMT_CUDA
@ AV_PIX_FMT_CUDA
HW acceleration through CUDA.
Definition: pixfmt.h:260
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:69
name
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf default minimum maximum flags name is the option name
Definition: writing_filters.txt:88
OptionsContext::stop_time
int64_t stop_time
Definition: ffmpeg.h:169
demux_final_stats
static void demux_final_stats(Demuxer *d)
Definition: ffmpeg_demux.c:790
err_merge
static int err_merge(int err0, int err1)
Merge two return codes - return one of the error codes if at least one of them was negative,...
Definition: ffmpeg_utils.h:39
AVERROR
Filter the word “frame” indicates either a video frame or a group of audio as stored in an AVFrame structure Format for each input and each output the list of supported formats For video that means pixel format For audio that means channel sample they are references to shared objects When the negotiation mechanism computes the intersection of the formats supported at each end of a all references to both lists are replaced with a reference to the intersection And when a single format is eventually chosen for a link amongst the remaining all references to the list are updated That means that if a filter requires that its input and output have the same format amongst a supported all it has to do is use a reference to the same list of formats query_formats can leave some formats unset and return AVERROR(EAGAIN) to cause the negotiation mechanism toagain later. That can be used by filters with complex requirements to use the format negotiated on one link to set the formats supported on another. Frame references ownership and permissions
nb_input_files
int nb_input_files
Definition: ffmpeg.c:105
opt.h
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:51
input_stream_class
static const AVClass input_stream_class
Definition: ffmpeg_demux.c:1192
av_compare_ts
int av_compare_ts(int64_t ts_a, AVRational tb_a, int64_t ts_b, AVRational tb_b)
Compare two timestamps each in its own time base.
Definition: mathematics.c:147
FrameData
Definition: ffmpeg.h:649
ist_output_add
int ist_output_add(InputStream *ist, OutputStream *ost)
Definition: ffmpeg_demux.c:967
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1216
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: cmdutils.c:1527
apply_cropping
static int apply_cropping(AVCodecContext *avctx, AVFrame *frame)
Definition: decode.c:753
out
FILE * out
Definition: movenc.c:55
DecoderOpts
Definition: ffmpeg.h:372
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
AV_PKT_DATA_FRAME_CROPPING
@ AV_PKT_DATA_FRAME_CROPPING
The number of pixels to discard from the top/bottom/left/right border of the decoded frame to obtain ...
Definition: packet.h:340
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:47
DECODER_FLAG_SEND_END_TS
@ DECODER_FLAG_SEND_END_TS
Definition: ffmpeg.h:367
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
AV_DISPOSITION_ATTACHED_PIC
#define AV_DISPOSITION_ATTACHED_PIC
The stream is stored in the file as an attached picture/"cover art" (e.g.
Definition: avformat.h:674
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:819
FrameData::dts_est
int64_t dts_est
Definition: ffmpeg.h:652
sch_add_demux
int sch_add_demux(Scheduler *sch, SchThreadFunc func, void *ctx)
Add a demuxer to the scheduler.
Definition: ffmpeg_sched.c:676
input_packet_process
static int input_packet_process(Demuxer *d, AVPacket *pkt, unsigned *send_flags)
Definition: ffmpeg_demux.c:447
demux_thread_init
static int demux_thread_init(DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:667
InputStream::outputs
struct OutputStream ** outputs
Definition: ffmpeg.h:446
SCH_DSTREAM
#define SCH_DSTREAM(file, stream)
Definition: ffmpeg_sched.h:111
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:479
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
int64_t
long long int64_t
Definition: coverity.c:34
InputStream::user_set_discard
int user_set_discard
Definition: ffmpeg.h:417
DemuxStream::sch_idx_stream
int sch_idx_stream
Definition: ffmpeg_demux.c:49
OptionsContext::audio_ch_layouts
SpecifierOptList audio_ch_layouts
Definition: ffmpeg.h:133
ist_add
static int ist_add(const OptionsContext *o, Demuxer *d, AVStream *st, AVDictionary **opts_used)
Definition: ffmpeg_demux.c:1224
ist_iter
InputStream * ist_iter(InputStream *prev)
Definition: ffmpeg.c:376
av_frame_free
void av_frame_free(AVFrame **frame)
Free the frame and any dynamically allocated objects in it, e.g.
Definition: frame.c:161
DemuxStream::finished
int finished
Definition: ffmpeg_demux.c:63
InputFile::index
int index
Definition: ffmpeg.h:453
AVFrame
This structure describes decoded (raw) audio or video data.
Definition: frame.h:380
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1355
AVFrame::width
int width
Definition: frame.h:452
DECODER_FLAG_FRAMERATE_FORCED
@ DECODER_FLAG_FRAMERATE_FORCED
Definition: ffmpeg.h:363
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:390
OptionsContext::display_hflips
SpecifierOptList display_hflips
Definition: ffmpeg.h:196
DecoderOpts::par
const AVCodecParameters * par
Definition: ffmpeg.h:379
ifile_close
void ifile_close(InputFile **pf)
Definition: ffmpeg_demux.c:855
DemuxStream::streamcopy_needed
int streamcopy_needed
Definition: ffmpeg_demux.c:65
av_display_matrix_flip
void av_display_matrix_flip(int32_t matrix[9], int hflip, int vflip)
Flip the input matrix horizontally and/or vertically.
Definition: display.c:66
subtitle_codec_name
static const char * subtitle_codec_name
Definition: ffplay.c:340
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
OptionsContext::subtitle_disable
int subtitle_disable
Definition: ffmpeg.h:179
demux_stream_alloc
static DemuxStream * demux_stream_alloc(Demuxer *d, AVStream *st)
Definition: ffmpeg_demux.c:1199
AVOption
AVOption.
Definition: opt.h:429
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:837
DecoderOpts::hwaccel_id
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:382
InputStream::nb_filters
int nb_filters
Definition: ffmpeg.h:439
AVCodecParameters::framerate
AVRational framerate
Video only.
Definition: codec_par.h:156
av_hwdevice_find_type_by_name
enum AVHWDeviceType av_hwdevice_find_type_by_name(const char *name)
Look up an AVHWDeviceType by name.
Definition: hwcontext.c:102
ffmpeg.h
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
float.h
DemuxStream::decoder_opts
AVDictionary * decoder_opts
Definition: ffmpeg_demux.c:85
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1488
av_hwdevice_iterate_types
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:121
OptionsContext::bitexact
int bitexact
Definition: ffmpeg.h:175
av_display_rotation_set
void av_display_rotation_set(int32_t matrix[9], double angle)
Initialize a transformation matrix describing a pure clockwise rotation by the specified angle (in de...
Definition: display.c:51
AVPacket::duration
int64_t duration
Duration of this packet in AVStream->time_base units, 0 if unknown.
Definition: packet.h:557
AVCodecParameters::codec_tag
uint32_t codec_tag
Additional information about the codec (corresponds to the AVI FOURCC).
Definition: codec_par.h:59
AVDictionary
Definition: dict.c:34
AVChannelLayout::order
enum AVChannelOrder order
Channel order used in this layout.
Definition: channel_layout.h:316
FFMAX
#define FFMAX(a, b)
Definition: macros.h:47
av_read_frame
int av_read_frame(AVFormatContext *s, AVPacket *pkt)
Return the next frame of a stream.
Definition: demux.c:1538
AVFormatContext::video_codec_id
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1494
IFILTER_FLAG_AUTOROTATE
@ IFILTER_FLAG_AUTOROTATE
Definition: ffmpeg.h:240
OptionsContext::format
const char * format
Definition: ffmpeg.h:130
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:321
DECODER_FLAG_BITEXACT
@ DECODER_FLAG_BITEXACT
Definition: ffmpeg.h:369
av_bsf_free
void av_bsf_free(AVBSFContext **pctx)
Free a bitstream filter context and everything associated with it; write NULL into the supplied point...
Definition: bsf.c:52
Timestamp::ts
int64_t ts
Definition: ffmpeg_utils.h:31
ost
static AVStream * ost
Definition: vaapi_transcode.c:42
tf_sess_config.config
config
Definition: tf_sess_config.py:33
file_iformat
static const AVInputFormat * file_iformat
Definition: ffplay.c:305
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: packet.c:74
OptionsContext::frame_pix_fmts
SpecifierOptList frame_pix_fmts
Definition: ffmpeg.h:139
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
OptionsContext::canvas_sizes
SpecifierOptList canvas_sizes
Definition: ffmpeg.h:216
InputStream::nb_outputs
int nb_outputs
Definition: ffmpeg.h:447
Demuxer::wallclock_start
int64_t wallclock_start
Definition: ffmpeg_demux.c:105
SpecifierOpt::i
int i
Definition: cmdutils.h:171
InputStream
Definition: ffmpeg.h:408
DecoderOpts::hwaccel_output_format
enum AVPixelFormat hwaccel_output_format
Definition: ffmpeg.h:385
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:69
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:363
AVPacketSideData::size
size_t size
Definition: packet.h:392
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1560
Demuxer
Definition: ffmpeg_demux.c:99
OptionsContext::rate_emu
int rate_emu
Definition: ffmpeg.h:144
CROP_CODEC
@ CROP_CODEC
Definition: ffmpeg.h:559
dts_delta_threshold
float dts_delta_threshold
Definition: ffmpeg_opt.c:55
DemuxStream::data_size
uint64_t data_size
Definition: ffmpeg_demux.c:96
finish
static void finish(void)
Definition: movenc.c:373
bsf.h
AVFMT_SEEK_TO_PTS
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:503
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:124
Demuxer::log_name
char log_name[32]
Definition: ffmpeg_demux.c:103
Decoder::frames_decoded
uint64_t frames_decoded
Definition: ffmpeg.h:403
Demuxer::nb_streams_finished
int nb_streams_finished
Definition: ffmpeg_demux.c:137
opt_match_per_stream_int
void opt_match_per_stream_int(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, int *out)
dummy
int dummy
Definition: motion.c:66
AVProgram::discard
enum AVDiscard discard
selects which program to discard and which to feed to the caller
Definition: avformat.h:1214
DecoderOpts::log_parent
void * log_parent
Definition: ffmpeg.h:376
input_file_item_name
static const char * input_file_item_name(void *obj)
Definition: ffmpeg_demux.c:1565
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: defs.h:215
AVFrame::ch_layout
AVChannelLayout ch_layout
Channel layout of the audio data.
Definition: frame.h:781
type
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf type
Definition: writing_filters.txt:86
pts
static int64_t pts
Definition: transcode_aac.c:644
OptionsContext
Definition: ffmpeg.h:123
AVBSFContext::par_out
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:96
av_opt_set
int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
Definition: opt.c:748
do_pkt_dump
int do_pkt_dump
Definition: ffmpeg_opt.c:65
Demuxer::ts_offset_discont
int64_t ts_offset_discont
Extra timestamp offset added by discontinuity handling.
Definition: ffmpeg_demux.c:110
AVRational::num
int num
Numerator.
Definition: rational.h:59
Demuxer::f
InputFile f
Definition: ffmpeg_demux.c:100
Decoder::samples_decoded
uint64_t samples_decoded
Definition: ffmpeg.h:404
InputFile
Definition: ffmpeg.h:450
DemuxStream::nb_packets
uint64_t nb_packets
Definition: ffmpeg_demux.c:94
Demuxer::nb_streams_used
int nb_streams_used
Definition: ffmpeg_demux.c:136
OptionsContext::recording_time
int64_t recording_time
Definition: ffmpeg.h:168
av_frame_alloc
AVFrame * av_frame_alloc(void)
Allocate an AVFrame and set its fields to default values.
Definition: frame.c:149
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:551
LATENCY_PROBE_DEMUX
@ LATENCY_PROBE_DEMUX
Definition: ffmpeg.h:99
OptionsContext::audio_disable
int audio_disable
Definition: ffmpeg.h:178
check_stream_specifier
int check_stream_specifier(AVFormatContext *s, AVStream *st, const char *spec)
Check if the given stream matches a stream specifier.
Definition: cmdutils.c:1334
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:60
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
ifile_open
int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch)
Definition: ffmpeg_demux.c:1594
AVInputFormat
Definition: avformat.h:548
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:595
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:343
av_dump_format
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,...
Definition: dump.c:824
OptionsContext::hwaccel_output_formats
SpecifierOptList hwaccel_output_formats
Definition: ffmpeg.h:156
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:181
CROP_DISABLED
@ CROP_DISABLED
Definition: ffmpeg.h:557
duration
int64_t duration
Definition: movenc.c:65
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, const AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: demux.c:215
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:195
av_dict_get
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:62
av_channel_layout_describe
int av_channel_layout_describe(const AVChannelLayout *channel_layout, char *buf, size_t buf_size)
Get a human-readable string describing the channel layout properties.
Definition: channel_layout.c:648
HWACCEL_GENERIC
@ HWACCEL_GENERIC
Definition: ffmpeg.h:84
assert_file_overwrite
int assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:673
SpecifierOpt::specifier
char * specifier
Definition: cmdutils.h:165
AVCodecDescriptor
This struct describes the properties of a single codec described by an AVCodecID.
Definition: codec_desc.h:38
intreadwrite.h
AVFormatContext::video_codec
const struct AVCodec * video_codec
Forced video codec.
Definition: avformat.h:1812
s
#define s(width, name)
Definition: cbs_vp9.c:198
DemuxStream::first_dts
int64_t first_dts
Definition: ffmpeg_demux.c:75
Demuxer::readrate
float readrate
Definition: ffmpeg_demux.c:128
av_bsf_flush
void av_bsf_flush(AVBSFContext *ctx)
Reset the internal bitstream filter state.
Definition: bsf.c:190
InputStream::framerate
AVRational framerate
Definition: ffmpeg.h:429
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1438
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:144
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1487
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:553
dec_init
int dec_init(Decoder **pdec, Scheduler *sch, AVDictionary **dec_opts, const DecoderOpts *o, AVFrame *param_out)
Definition: ffmpeg_dec.c:1281
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1299
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:134
OptionsContext::hwaccel_devices
SpecifierOptList hwaccel_devices
Definition: ffmpeg.h:155
AV_CHANNEL_ORDER_UNSPEC
@ AV_CHANNEL_ORDER_UNSPEC
Only the channel count is specified, without any further information about the channel order.
Definition: channel_layout.h:116
sch_add_demux_stream
int sch_add_demux_stream(Scheduler *sch, unsigned demux_idx)
Add a demuxed stream for a previously added demuxer.
Definition: ffmpeg_sched.c:703
av_q2d
static double av_q2d(AVRational a)
Convert an AVRational to a double.
Definition: rational.h:104
Demuxer::readrate_initial_burst
double readrate_initial_burst
Definition: ffmpeg_demux.c:129
InputFilter
Definition: ffmpeg.h:323
DemuxStream::ts_scale
double ts_scale
Definition: ffmpeg_demux.c:52
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:40
AVHWDeviceType
AVHWDeviceType
Definition: hwcontext.h:27
AVIO_FLAG_WRITE
#define AVIO_FLAG_WRITE
write-only
Definition: avio.h:618
discard_unused_programs
static void discard_unused_programs(InputFile *ifile)
Definition: ffmpeg_demux.c:634
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
AVPacketSideData::data
uint8_t * data
Definition: packet.h:391
DemuxThreadContext
Definition: ffmpeg_demux.c:140
ctx
AVFormatContext * ctx
Definition: movenc.c:49
AVBSFContext::time_base_in
AVRational time_base_in
The timebase used for the timestamps of the input packets.
Definition: bsf.h:102
InputStream::filters
InputFilter ** filters
Definition: ffmpeg.h:438
demux_send
static int demux_send(Demuxer *d, DemuxThreadContext *dt, DemuxStream *ds, AVPacket *pkt, unsigned flags)
Definition: ffmpeg_demux.c:540
Demuxer::nb_streams_warn
int nb_streams_warn
Definition: ffmpeg_demux.c:126
av_rescale_q
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
Definition: mathematics.c:142
OptionsContext::fix_sub_duration
SpecifierOptList fix_sub_duration
Definition: ffmpeg.h:214
DecoderOpts::hwaccel_device
char * hwaccel_device
Definition: ffmpeg.h:384
input_stream_item_name
static const char * input_stream_item_name(void *obj)
Definition: ffmpeg_demux.c:1185
ffmpeg_utils.h
av_hwdevice_get_type_name
const char * av_hwdevice_get_type_name(enum AVHWDeviceType type)
Get the string name of an AVHWDeviceType.
Definition: hwcontext.c:112
OptionsContext::accurate_seek
int accurate_seek
Definition: ffmpeg.h:147
av_usleep
int av_usleep(unsigned usec)
Sleep for a period of time.
Definition: time.c:84
AVCodecParameters::nb_coded_side_data
int nb_coded_side_data
Amount of entries in coded_side_data.
Definition: codec_par.h:86
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:135
AVPacket::opaque
void * opaque
for some private data of the user
Definition: packet.h:564
AVFormatContext::data_codec
const struct AVCodec * data_codec
Forced data codec.
Definition: avformat.h:1836
AV_ROUND_PASS_MINMAX
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
Definition: mathematics.h:159
Demuxer::duration
Timestamp duration
Definition: ffmpeg_demux.c:120
DemuxThreadContext::pkt_demux
AVPacket * pkt_demux
Definition: ffmpeg_demux.c:142
AV_PIX_FMT_MEDIACODEC
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Definition: pixfmt.h:316
arg
const char * arg
Definition: jacosubdec.c:67
AV_CLASS_CATEGORY_DEMUXER
@ AV_CLASS_CATEGORY_DEMUXER
Definition: log.h:33
ist_filter_add
int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple, InputFilterOptions *opts)
Definition: ffmpeg_demux.c:985
AVCodecDescriptor::props
int props
Codec properties, a combination of AV_CODEC_PROP_* flags.
Definition: codec_desc.h:54
fields
the definition of that something depends on the semantic of the filter The callback must examine the status of the filter s links and proceed accordingly The status of output links is stored in the status_in and status_out fields and tested by the then the processing requires a frame on this link and the filter is expected to make efforts in that direction The status of input links is stored by the fifo and status_out fields
Definition: filter_design.txt:155
FFABS
#define FFABS(a)
Absolute value, Note, INT_MIN / INT64_MIN result in undefined behavior as they are not representable ...
Definition: common.h:74
if
if(ret)
Definition: filter_design.txt:179
AVCodecParserContext::repeat_pict
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:2760
OptionsContext::start_time
int64_t start_time
Definition: ffmpeg.h:127
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:221
AVFormatContext
Format I/O context.
Definition: avformat.h:1287
DECODING_FOR_OST
#define DECODING_FOR_OST
Definition: ffmpeg_demux.c:56
AVFormatContext::audio_codec_id
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1500
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:344
opts
AVDictionary * opts
Definition: movenc.c:51
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:771
framerate
float framerate
Definition: av1_levels.c:29
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
av_bsf_init
int av_bsf_init(AVBSFContext *ctx)
Prepare the filter for use, after all the parameters and options have been set.
Definition: bsf.c:149
demuxer_from_ifile
static Demuxer * demuxer_from_ifile(InputFile *f)
Definition: ffmpeg_demux.c:152
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
ist_use
static int ist_use(InputStream *ist, int decoding_needed)
Definition: ffmpeg_demux.c:877
AVStream::time_base
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
Definition: avformat.h:787
NULL
#define NULL
Definition: coverity.c:32
Decoder::decode_errors
uint64_t decode_errors
Definition: ffmpeg.h:405
av_frame_copy_props
int av_frame_copy_props(AVFrame *dst, const AVFrame *src)
Copy only "metadata" fields from src to dst.
Definition: frame.c:712
InputStream::top_field_first
int top_field_first
Definition: ffmpeg.h:431
InputStream::st
AVStream * st
Definition: ffmpeg.h:416
avcodec_parameters_free
void avcodec_parameters_free(AVCodecParameters **ppar)
Free an AVCodecParameters instance and everything associated with it and write NULL to the supplied p...
Definition: codec_par.c:66
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:230
OptionsContext::audio_channels
SpecifierOptList audio_channels
Definition: ffmpeg.h:134
InputFile::start_time_effective
int64_t start_time_effective
Effective format start time based on enabled streams.
Definition: ffmpeg.h:461
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
filter_codec_opts
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst, AVDictionary **opts_used)
Filter out options for given codec.
Definition: cmdutils.c:1348
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:237
Demuxer::recording_time
int64_t recording_time
Definition: ffmpeg_demux.c:113
parseutils.h
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1215
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:828
OptionsContext::reinit_filters
SpecifierOptList reinit_filters
Definition: ffmpeg.h:213
AV_OPT_SEARCH_FAKE_OBJ
#define AV_OPT_SEARCH_FAKE_OBJ
The obj passed to av_opt_find() is fake – only a double pointer to AVClass instead of a required poin...
Definition: opt.h:613
OptionsContext::dump_attachment
SpecifierOptList dump_attachment
Definition: ffmpeg.h:153
InputStream::fix_sub_duration
int fix_sub_duration
Definition: ffmpeg.h:434
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:666
AV_DICT_DONT_OVERWRITE
#define AV_DICT_DONT_OVERWRITE
Don't overwrite existing entries.
Definition: dict.h:81
time.h
DEMUX_SEND_STREAMCOPY_EOF
@ DEMUX_SEND_STREAMCOPY_EOF
Treat the packet as an EOF for SCH_NODE_TYPE_MUX destinations send normally to other types.
Definition: ffmpeg_sched.h:328
OptionsContext::display_vflips
SpecifierOptList display_vflips
Definition: ffmpeg.h:197
DemuxThreadContext::pkt_bsf
AVPacket * pkt_bsf
Definition: ffmpeg_demux.c:144
InputFilterOptions
Definition: ffmpeg.h:246
AV_PIX_FMT_QSV
@ AV_PIX_FMT_QSV
HW acceleration through QSV, data[3] contains a pointer to the mfxFrameSurface1 structure.
Definition: pixfmt.h:247
Demuxer::read_started
int read_started
Definition: ffmpeg_demux.c:135
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:180
OptionsContext::input_sync_ref
int input_sync_ref
Definition: ffmpeg.h:149
report_new_stream
static void report_new_stream(Demuxer *d, const AVPacket *pkt)
Definition: ffmpeg_demux.c:168
guess_input_channel_layout
static int guess_input_channel_layout(InputStream *ist, AVCodecParameters *par, int guess_layout_max)
Definition: ffmpeg_demux.c:1127
DECODER_FLAG_FIX_SUB_DURATION
@ DECODER_FLAG_FIX_SUB_DURATION
Definition: ffmpeg.h:358
c
Undefined Behavior In the C some operations are like signed integer dereferencing freed accessing outside allocated Undefined Behavior must not occur in a C it is not safe even if the output of undefined operations is unused The unsafety may seem nit picking but Optimizing compilers have in fact optimized code on the assumption that no undefined Behavior occurs Optimizing code based on wrong assumptions can and has in some cases lead to effects beyond the output of computations The signed integer overflow problem in speed critical code Code which is highly optimized and works with signed integers sometimes has the problem that often the output of the computation does not c
Definition: undefined.txt:32
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:184
Demuxer::sch
Scheduler * sch
Definition: ffmpeg_demux.c:131
find_codec
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **codec)
Definition: ffmpeg_opt.c:640
AVFormatContext::audio_codec
const struct AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1820
InputStream::par
AVCodecParameters * par
Codec parameters - to be used by the decoding/streamcopy code.
Definition: ffmpeg.h:424
input_files
InputFile ** input_files
Definition: ffmpeg.c:104
error.h
Scheduler
Definition: ffmpeg_sched.c:269
av_packet_side_data_get
const AVPacketSideData * av_packet_side_data_get(const AVPacketSideData *sd, int nb_sd, enum AVPacketSideDataType type)
Get side information from a side data array.
Definition: packet.c:656
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:1007
recast_media
int recast_media
Definition: ffmpeg_opt.c:86
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:73
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1343
DemuxStream::dts
int64_t dts
Definition: ffmpeg_demux.c:81
av_codec_is_decoder
int av_codec_is_decoder(const AVCodec *codec)
Definition: utils.c:86
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: demux.c:2516
av_opt_find
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:1957
OptionsContext::discard
SpecifierOptList discard
Definition: ffmpeg.h:223
IFILTER_FLAG_REINIT
@ IFILTER_FLAG_REINIT
Definition: ffmpeg.h:241
f
f
Definition: af_crystalizer.c:122
AVIOContext
Bytestream IO Context.
Definition: avio.h:160
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:83
seek_to_start
static int seek_to_start(Demuxer *d, Timestamp end_pts)
Definition: ffmpeg_demux.c:181
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:540
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:161
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:216
AVChannelLayout
An AVChannelLayout holds information about the channel layout of audio data.
Definition: channel_layout.h:311
FFMPEG_OPT_TOP
#define FFMPEG_OPT_TOP
Definition: ffmpeg.h:57
DemuxStream::have_sub2video
int have_sub2video
Definition: ffmpeg_demux.c:66
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:202
av_err2str
#define av_err2str(errnum)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: error.h:122
start_time
static int64_t start_time
Definition: ffplay.c:326
Demuxer::pkt_heartbeat
AVPacket * pkt_heartbeat
Definition: ffmpeg_demux.c:133
DemuxStream::decoding_needed
int decoding_needed
Definition: ffmpeg_demux.c:55
OptionsContext::apply_cropping
SpecifierOptList apply_cropping
Definition: ffmpeg.h:158
demux_thread_uninit
static void demux_thread_uninit(DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:659
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:66
avformat_seek_file
int avformat_seek_file(AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Seek to timestamp ts.
Definition: seek.c:663
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_CODEC_PROP_FIELDS
#define AV_CODEC_PROP_FIELDS
Video codec supports separate coding of fields in interlaced frames.
Definition: codec_desc.h:97
OptionsContext::seek_timestamp
int seek_timestamp
Definition: ffmpeg.h:129
input_file_class
static const AVClass input_file_class
Definition: ffmpeg_demux.c:1572
DECODING_FOR_FILTER
#define DECODING_FOR_FILTER
Definition: ffmpeg_demux.c:57
AVFrame::format
int format
format of the frame, -1 if unknown or unset Values correspond to enum AVPixelFormat for video frames,...
Definition: frame.h:467
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
DemuxStream::bsf
AVBSFContext * bsf
Definition: ffmpeg_demux.c:91
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:826
OptionsContext::readrate_initial_burst
double readrate_initial_burst
Definition: ffmpeg.h:146
allocate_array_elem
void * allocate_array_elem(void *ptr, size_t elem_size, int *nb_elems)
Atomically add a new element to an array of pointers, i.e.
Definition: cmdutils.c:1465
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:538
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:201
OptionsContext::find_stream_info
int find_stream_info
Definition: ffmpeg.h:150
OptionsContext::display_rotations
SpecifierOptList display_rotations
Definition: ffmpeg.h:195
DemuxStream::autorotate
int autorotate
Definition: ffmpeg_demux.c:68
DemuxStream::sch_idx_dec
int sch_idx_dec
Definition: ffmpeg_demux.c:50
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:180
SCH_DEC
#define SCH_DEC(decoder)
Definition: ffmpeg_sched.h:117
offset
it s the only field you need to keep assuming you have a context There is some magic you don t need to care about around this just let it vf offset
Definition: writing_filters.txt:86
opt_match_per_stream_dbl
void opt_match_per_stream_dbl(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, double *out)
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:545
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: packet.c:63
av_dict_free
void av_dict_free(AVDictionary **pm)
Free all the memory allocated for an AVDictionary struct and all keys and values.
Definition: dict.c:223
OptionsContext::ts_scale
SpecifierOptList ts_scale
Definition: ffmpeg.h:152
av_parse_video_size
int av_parse_video_size(int *width_ptr, int *height_ptr, const char *str)
Parse str and put in width_ptr and height_ptr the detected values.
Definition: parseutils.c:150
av_packet_rescale_ts
void av_packet_rescale_ts(AVPacket *pkt, AVRational src_tb, AVRational dst_tb)
Convert valid timing fields (timestamps / durations) in a packet from one timebase to another.
Definition: packet.c:533
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
video_codec_name
static const char * video_codec_name
Definition: ffplay.c:341
DemuxStream::next_dts
int64_t next_dts
dts of the last packet read for this stream (in AV_TIME_BASE units)
Definition: ffmpeg_demux.c:79
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
CROP_CONTAINER
@ CROP_CONTAINER
Definition: ffmpeg.h:560
av_channel_layout_default
void av_channel_layout_default(AVChannelLayout *ch_layout, int nb_channels)
Get the default channel layout for a given number of channels.
Definition: channel_layout.c:834
avcodec_parameters_alloc
AVCodecParameters * avcodec_parameters_alloc(void)
Allocate a new AVCodecParameters and set its fields to default values (unknown/invalid/0).
Definition: codec_par.c:56
avcodec_get_name
const char * avcodec_get_name(enum AVCodecID id)
Get the name of a codec.
Definition: utils.c:409
HWACCEL_AUTO
@ HWACCEL_AUTO
Definition: ffmpeg.h:83
DemuxStream
Definition: ffmpeg_demux.c:43
av_parse_video_rate
int av_parse_video_rate(AVRational *rate, const char *arg)
Parse str and store the detected values in *rate.
Definition: parseutils.c:181
CROP_ALL
@ CROP_ALL
Definition: ffmpeg.h:558
DemuxStream::dec_name
char dec_name[16]
Definition: ffmpeg_demux.c:87
av_channel_layout_from_string
int av_channel_layout_from_string(AVChannelLayout *channel_layout, const char *str)
Initialize a channel layout from a given string description.
Definition: channel_layout.c:307
DemuxStream::apply_cropping
int apply_cropping
Definition: ffmpeg_demux.c:69
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:50
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:256
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:532
OptionsContext::frame_rates
SpecifierOptList frame_rates
Definition: ffmpeg.h:136
setup_find_stream_info_opts
int setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *local_codec_opts, AVDictionary ***dst)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1416
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:132
packet.h
demux_bsf_flush
static int demux_bsf_flush(Demuxer *d, DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:609
AVFormatContext::subtitle_codec
const struct AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1828
AVCodecParameters::height
int height
Definition: codec_par.h:135
OptionsContext::autorotate
SpecifierOptList autorotate
Definition: ffmpeg.h:157
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
DecoderOpts::time_base
AVRational time_base
Definition: ffmpeg.h:387
SHOW_TS_DEBUG
#define SHOW_TS_DEBUG(tag_)
OptionsContext::start_time_eof
int64_t start_time_eof
Definition: ffmpeg.h:128
display.h
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:70
Demuxer::have_audio_dec
int have_audio_dec
Definition: ffmpeg_demux.c:118
av_assert1
#define av_assert1(cond)
assert() equivalent, that does not lie in speed critical code.
Definition: avassert.h:56
delta
float delta
Definition: vorbis_enc_data.h:430
AVMEDIA_TYPE_ATTACHMENT
@ AVMEDIA_TYPE_ATTACHMENT
Opaque data information usually sparse.
Definition: avutil.h:205
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:455
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
OptionsContext::hwaccels
SpecifierOptList hwaccels
Definition: ffmpeg.h:154
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1211
av_inv_q
static av_always_inline AVRational av_inv_q(AVRational q)
Invert a rational.
Definition: rational.h:159
av_rescale
int64_t av_rescale(int64_t a, int64_t b, int64_t c)
Rescale a 64-bit integer with rounding to nearest.
Definition: mathematics.c:129
int_cb
const AVIOInterruptCB int_cb
Definition: ffmpeg.c:307
AVBSFContext::time_base_out
AVRational time_base_out
The timebase used for the timestamps of the output packets.
Definition: bsf.h:108
AVCodecParameters::coded_side_data
AVPacketSideData * coded_side_data
Additional data associated with the entire stream.
Definition: codec_par.h:81
DemuxStream::discard
int discard
Definition: ffmpeg_demux.c:60
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1441
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:958
sch_connect
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
Definition: ffmpeg_sched.c:897
ist_find_unused
InputStream * ist_find_unused(enum AVMediaType type)
Find an unused input stream of given type.
Definition: ffmpeg_demux.c:157
Timestamp::tb
AVRational tb
Definition: ffmpeg_utils.h:32
InputStream::decoder
Decoder * decoder
Definition: ffmpeg.h:425
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:817
DemuxStream::codec_desc
const AVCodecDescriptor * codec_desc
Definition: ffmpeg_demux.c:83
ts_discontinuity_process
static void ts_discontinuity_process(Demuxer *d, InputStream *ist, AVPacket *pkt)
Definition: ffmpeg_demux.c:276
tag
uint32_t tag
Definition: movenc.c:1876
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:760
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1455
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:748
AV_LOG_FATAL
#define AV_LOG_FATAL
Something went wrong and recovery is not possible.
Definition: log.h:174
dec_free
void dec_free(Decoder **pdec)
Definition: ffmpeg_dec.c:97
av_guess_frame_rate
AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
Guess the frame rate, based on both the container and codec information.
Definition: avformat.c:755
DemuxStream::wrap_correction_done
int wrap_correction_done
Definition: ffmpeg_demux.c:72
AVClass::class_name
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
Definition: log.h:71
av_strlcat
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:95
av_opt_eval_int
int av_opt_eval_int(void *obj, const AVOption *o, const char *val, int *int_out)
Demuxer::loop
int loop
Definition: ffmpeg_demux.c:117
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:469
add_display_matrix_to_stream
static int add_display_matrix_to_stream(const OptionsContext *o, AVFormatContext *ctx, InputStream *ist)
Definition: ffmpeg_demux.c:1144
hwaccel
static const char * hwaccel
Definition: ffplay.c:353
DECODER_FLAG_TOP_FIELD_FIRST
@ DECODER_FLAG_TOP_FIELD_FIRST
Definition: ffmpeg.h:365
Demuxer::accurate_seek
int accurate_seek
Definition: ffmpeg_demux.c:114
avformat.h
HWAccelID
HWAccelID
Definition: ffmpeg.h:81
av_packet_side_data_new
AVPacketSideData * av_packet_side_data_new(AVPacketSideData **psd, int *pnb_sd, enum AVPacketSideDataType type, size_t size, int flags)
Allocate a new packet side data.
Definition: packet.c:706
choose_decoder
static int choose_decoder(const OptionsContext *o, void *logctx, AVFormatContext *s, AVStream *st, enum HWAccelID hwaccel_id, enum AVHWDeviceType hwaccel_device_type, const AVCodec **pcodec)
Definition: ffmpeg_demux.c:1080
check_avoptions_used
int check_avoptions_used(const AVDictionary *opts, const AVDictionary *opts_used, void *logctx, int decode)
Definition: ffmpeg.c:477
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: cmdutils.c:1518
AV_DICT_MATCH_CASE
#define AV_DICT_MATCH_CASE
Only get an entry with exact-case key match.
Definition: dict.h:74
AV_RL32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_RL32
Definition: bytestream.h:92
av_get_pix_fmt
enum AVPixelFormat av_get_pix_fmt(const char *name)
Return the pixel format corresponding to name.
Definition: pixdesc.c:2897
AVFormatContext::data_codec_id
enum AVCodecID data_codec_id
Forced Data codec_id.
Definition: avformat.h:1512
av_get_media_type_string
const char * av_get_media_type_string(enum AVMediaType media_type)
Return a string describing the media_type enum, NULL if media_type is unknown.
Definition: utils.c:28
AVFrame::height
int height
Definition: frame.h:452
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:754
IFILTER_FLAG_CROP
@ IFILTER_FLAG_CROP
Definition: ffmpeg.h:243
InputFile::class
const AVClass * class
Definition: ffmpeg.h:451
OptionsContext::audio_sample_rate
SpecifierOptList audio_sample_rate
Definition: ffmpeg.h:135
audio_codec_name
static const char * audio_codec_name
Definition: ffplay.c:339
sch_demux_send
int sch_demux_send(Scheduler *sch, unsigned demux_idx, AVPacket *pkt, unsigned flags)
Called by demuxer tasks to communicate with their downstreams.
Definition: ffmpeg_sched.c:1970
ts_discontinuity_detect
static void ts_discontinuity_detect(Demuxer *d, InputStream *ist, AVPacket *pkt)
Definition: ffmpeg_demux.c:208
PKT_OPAQUE_SUB_HEARTBEAT
@ PKT_OPAQUE_SUB_HEARTBEAT
Definition: ffmpeg.h:94
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:567
AVRational::den
int den
Denominator.
Definition: rational.h:60
InputStream::file
struct InputFile * file
Definition: ffmpeg.h:412
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:170
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
AV_OPT_TYPE_INT
@ AV_OPT_TYPE_INT
Underlying C type is int.
Definition: opt.h:259
av_channel_layout_uninit
void av_channel_layout_uninit(AVChannelLayout *channel_layout)
Free any allocated data in the channel layout and reset the channel count to 0.
Definition: channel_layout.c:437
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:145
IFILTER_FLAG_CFR
@ IFILTER_FLAG_CFR
Definition: ffmpeg.h:242
OptionsContext::frame_sizes
SpecifierOptList frame_sizes
Definition: ffmpeg.h:138
OptionsContext::video_disable
int video_disable
Definition: ffmpeg.h:177
ds_from_ist
static DemuxStream * ds_from_ist(InputStream *ist)
Definition: ffmpeg_demux.c:147
av_find_input_format
const AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:144
demux_alloc
static Demuxer * demux_alloc(void)
Definition: ffmpeg_demux.c:1579
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1422
av_mul_q
AVRational av_mul_q(AVRational b, AVRational c)
Multiply two rationals.
Definition: rational.c:80
AVPacket::stream_index
int stream_index
Definition: packet.h:541
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:532
HWACCEL_NONE
@ HWACCEL_NONE
Definition: ffmpeg.h:82
avcodec_get_hw_config
const AVCodecHWConfig * avcodec_get_hw_config(const AVCodec *codec, int index)
Retrieve supported hardware configurations for a codec.
Definition: utils.c:833
ist_dts_update
static int ist_dts_update(DemuxStream *ds, AVPacket *pkt, FrameData *fd)
Definition: ffmpeg_demux.c:296
InputFile::ts_offset
int64_t ts_offset
Definition: ffmpeg.h:462
av_channel_layout_copy
int av_channel_layout_copy(AVChannelLayout *dst, const AVChannelLayout *src)
Make a copy of a channel layout.
Definition: channel_layout.c:444
av_dict_set_int
int av_dict_set_int(AVDictionary **pm, const char *key, int64_t value, int flags)
Convenience wrapper for av_dict_set() that converts the value to a string and stores it.
Definition: dict.c:167
OptionsContext::codec_tags
SpecifierOptList codec_tags
Definition: ffmpeg.h:188
DecoderOpts::flags
int flags
Definition: ffmpeg.h:373
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:272
AV_OPT_FLAG_DECODING_PARAM
#define AV_OPT_FLAG_DECODING_PARAM
A generic parameter which can be set by the user for demuxing or decoding.
Definition: opt.h:356
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
av_bsf_list_parse_str
int av_bsf_list_parse_str(const char *str, AVBSFContext **bsf_lst)
Parse string describing list of bitstream filters and create single AVBSFContext describing the whole...
Definition: bsf.c:526
start_at_zero
int start_at_zero
Definition: ffmpeg_opt.c:67
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:481
mem.h
SpecifierOpt::u
union SpecifierOpt::@0 u
avio_open2
int avio_open2(AVIOContext **s, const char *filename, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: avio.c:491
DECODER_FLAG_TS_UNRELIABLE
@ DECODER_FLAG_TS_UNRELIABLE
Definition: ffmpeg.h:360
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:175
DemuxStream::log_name
char log_name[32]
Definition: ffmpeg_demux.c:47
DecoderOpts::codec
const AVCodec * codec
Definition: ffmpeg.h:378
InputStream::class
const AVClass * class
Definition: ffmpeg.h:409
InputStream::index
int index
Definition: ffmpeg.h:414
readrate_sleep
static void readrate_sleep(Demuxer *d)
Definition: ffmpeg_demux.c:491
ffmpeg_sched.h
AVDictionaryEntry
Definition: dict.h:89
Demuxer::max_pts
Timestamp max_pts
Definition: ffmpeg_demux.c:123
DemuxStream::dec_opts
DecoderOpts dec_opts
Definition: ffmpeg_demux.c:86
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:73
do_hex_dump
int do_hex_dump
Definition: ffmpeg_opt.c:64
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:55
AVPacket
This structure stores compressed data.
Definition: packet.h:516
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:34
av_dict_set
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:88
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:559
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:465
OptionsContext::data_disable
int data_disable
Definition: ffmpeg.h:180
int32_t
int32_t
Definition: audioconvert.c:56
ist_free
static void ist_free(InputStream **pist)
Definition: ffmpeg_demux.c:830
DemuxStream::reinit_filters
int reinit_filters
Definition: ffmpeg_demux.c:67
timestamp.h
OutputStream
Definition: mux.c:53
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:482
Demuxer::min_pts
Timestamp min_pts
Definition: ffmpeg_demux.c:122
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
ts_fixup
static int ts_fixup(Demuxer *d, AVPacket *pkt, FrameData *fd)
Definition: ffmpeg_demux.c:356
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: avio.c:616
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:27
AVFormatContext::start_time
int64_t start_time
Position of the first frame of the component, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1412
DecoderOpts::framerate
AVRational framerate
Definition: ffmpeg.h:391
dts_error_threshold
float dts_error_threshold
Definition: ffmpeg_opt.c:56
AVERROR_INVALIDDATA
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
Definition: error.h:61
av_ts2str
#define av_ts2str(ts)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:54
av_stream_get_parser
struct AVCodecParserContext * av_stream_get_parser(const AVStream *s)
Definition: demux_utils.c:32
AVCodecHWConfig
Definition: codec.h:345
AVERROR_EXIT
#define AVERROR_EXIT
Immediate exit was requested; the called function should not be restarted.
Definition: error.h:58
av_pkt_dump_log2
void av_pkt_dump_log2(void *avcl, int level, const AVPacket *pkt, int dump_payload, const AVStream *st)
Send a nice dump of a packet to the log.
Definition: dump.c:121
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3741
do_send
static int do_send(Demuxer *d, DemuxStream *ds, AVPacket *pkt, unsigned flags, const char *pkt_desc)
Definition: ffmpeg_demux.c:511
Demuxer::last_ts
int64_t last_ts
Definition: ffmpeg_demux.c:111
DemuxStream::decoded_params
AVFrame * decoded_params
Definition: ffmpeg_demux.c:89
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
Timestamp
Definition: ffmpeg_utils.h:30
opt_match_per_type_str
const char * opt_match_per_type_str(const SpecifierOptList *sol, char mediatype)
Definition: ffmpeg_opt.c:154
opt_match_per_stream_str
void opt_match_per_stream_str(void *logctx, const SpecifierOptList *sol, AVFormatContext *fc, AVStream *st, const char **out)
DemuxStream::saw_first_ts
int saw_first_ts
dts of the first packet read for this stream (in AV_TIME_BASE units)
Definition: ffmpeg_demux.c:73
InputFile::nb_streams
int nb_streams
Definition: ffmpeg.h:470
OptionsContext::guess_layout_max
SpecifierOptList guess_layout_max
Definition: ffmpeg.h:221
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:923
dump_attachment
static int dump_attachment(InputStream *ist, const char *filename)
Definition: ffmpeg_demux.c:1527
AVERROR_PROTOCOL_NOT_FOUND
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:65
AV_OPT_TYPE_CONST
@ AV_OPT_TYPE_CONST
Special option type for declaring named constants.
Definition: opt.h:299
InputStream::dec
const AVCodec * dec
Definition: ffmpeg.h:426
snprintf
#define snprintf
Definition: snprintf.h:34
DecoderOpts::hwaccel_device_type
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg.h:383
av_rescale_q_rnd
int64_t av_rescale_q_rnd(int64_t a, AVRational bq, AVRational cq, enum AVRounding rnd)
Rescale a 64-bit integer by 2 rational numbers with specified rounding.
Definition: mathematics.c:134
OptionsContext::bitstream_filters
SpecifierOptList bitstream_filters
Definition: ffmpeg.h:187
input_thread
static int input_thread(void *arg)
Definition: ffmpeg_demux.c:682
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:578
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:106
AVPacket::time_base
AVRational time_base
Time base of the packet's timestamps.
Definition: packet.h:583
OptionsContext::top_field_first
SpecifierOptList top_field_first
Definition: ffmpeg.h:203
OptionsContext::loop
int loop
Definition: ffmpeg.h:143
thread_set_name
static void thread_set_name(InputFile *f)
Definition: ffmpeg_demux.c:652
ff_thread_setname
static int ff_thread_setname(const char *name)
Definition: thread.h:216
AVFormatContext::subtitle_codec_id
enum AVCodecID subtitle_codec_id
Forced subtitle codec_id.
Definition: avformat.h:1506
DecoderOpts::name
char * name
Definition: ffmpeg.h:375