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/opt.h"
32 #include "libavutil/parseutils.h"
33 #include "libavutil/pixdesc.h"
34 #include "libavutil/time.h"
35 #include "libavutil/timestamp.h"
36 
37 #include "libavcodec/bsf.h"
38 #include "libavcodec/packet.h"
39 
40 #include "libavformat/avformat.h"
41 
42 typedef struct DemuxStream {
44 
45  // name used for logging
46  char log_name[32];
47 
50 
51  double ts_scale;
52 
53  /* non zero if the packets must be decoded in 'raw_fifo', see DECODING_FOR_* */
55 #define DECODING_FOR_OST 1
56 #define DECODING_FOR_FILTER 2
57 
58  /* true if stream data should be discarded */
59  int discard;
60 
61  // scheduler returned EOF for this stream
62  int finished;
63 
67 
70  ///< dts of the first packet read for this stream (in AV_TIME_BASE units)
71  int64_t first_dts;
72 
73  /* predicted dts of the next packet read for this stream or (when there are
74  * several frames in a packet) of the next frame in current packet (in AV_TIME_BASE units) */
75  int64_t next_dts;
76  ///< dts of the last packet read for this stream (in AV_TIME_BASE units)
77  int64_t dts;
78 
80 
83  char dec_name[16];
84 
86 
87  /* number of packets successfully read for this stream */
88  uint64_t nb_packets;
89  // combined size of all the packets read
90  uint64_t data_size;
91 } DemuxStream;
92 
93 typedef struct Demuxer {
95 
96  // name used for logging
97  char log_name[32];
98 
99  int64_t wallclock_start;
100 
101  /**
102  * Extra timestamp offset added by discontinuity handling.
103  */
105  int64_t last_ts;
106 
107  int64_t recording_time;
109 
110  /* number of times input stream should be looped */
111  int loop;
113  /* duration of the looped segment of the input file */
115  /* pts with the smallest/largest values ever seen */
118 
119  /* number of streams that the user was warned of */
121 
122  float readrate;
124 
126 
128 
132 } Demuxer;
133 
134 typedef struct DemuxThreadContext {
135  // packet used for reading from the demuxer
137  // packet for reading from BSFs
140 
142 {
143  return (DemuxStream*)ist;
144 }
145 
147 {
148  return (Demuxer*)f;
149 }
150 
152 {
153  for (InputStream *ist = ist_iter(NULL); ist; ist = ist_iter(ist)) {
154  DemuxStream *ds = ds_from_ist(ist);
155  if (ist->par->codec_type == type && ds->discard &&
156  ist->user_set_discard != AVDISCARD_ALL)
157  return ist;
158  }
159  return NULL;
160 }
161 
162 static void report_new_stream(Demuxer *d, const AVPacket *pkt)
163 {
164  AVStream *st = d->f.ctx->streams[pkt->stream_index];
165 
166  if (pkt->stream_index < d->nb_streams_warn)
167  return;
169  "New %s stream with index %d at pos:%"PRId64" and DTS:%ss\n",
172  d->nb_streams_warn = pkt->stream_index + 1;
173 }
174 
175 static int seek_to_start(Demuxer *d, Timestamp end_pts)
176 {
177  InputFile *ifile = &d->f;
178  AVFormatContext *is = ifile->ctx;
179  int ret;
180 
181  ret = avformat_seek_file(is, -1, INT64_MIN, is->start_time, is->start_time, 0);
182  if (ret < 0)
183  return ret;
184 
185  if (end_pts.ts != AV_NOPTS_VALUE &&
186  (d->max_pts.ts == AV_NOPTS_VALUE ||
187  av_compare_ts(d->max_pts.ts, d->max_pts.tb, end_pts.ts, end_pts.tb) < 0))
188  d->max_pts = end_pts;
189 
190  if (d->max_pts.ts != AV_NOPTS_VALUE) {
191  int64_t min_pts = d->min_pts.ts == AV_NOPTS_VALUE ? 0 : d->min_pts.ts;
192  d->duration.ts = d->max_pts.ts - av_rescale_q(min_pts, d->min_pts.tb, d->max_pts.tb);
193  }
194  d->duration.tb = d->max_pts.tb;
195 
196  if (d->loop > 0)
197  d->loop--;
198 
199  return ret;
200 }
201 
203  AVPacket *pkt)
204 {
205  InputFile *ifile = &d->f;
206  DemuxStream *ds = ds_from_ist(ist);
207  const int fmt_is_discont = ifile->ctx->iformat->flags & AVFMT_TS_DISCONT;
208  int disable_discontinuity_correction = copy_ts;
209  int64_t pkt_dts = av_rescale_q_rnd(pkt->dts, pkt->time_base, AV_TIME_BASE_Q,
211 
212  if (copy_ts && ds->next_dts != AV_NOPTS_VALUE &&
213  fmt_is_discont && ist->st->pts_wrap_bits < 60) {
214  int64_t wrap_dts = av_rescale_q_rnd(pkt->dts + (1LL<<ist->st->pts_wrap_bits),
217  if (FFABS(wrap_dts - ds->next_dts) < FFABS(pkt_dts - ds->next_dts)/10)
218  disable_discontinuity_correction = 0;
219  }
220 
221  if (ds->next_dts != AV_NOPTS_VALUE && !disable_discontinuity_correction) {
222  int64_t delta = pkt_dts - ds->next_dts;
223  if (fmt_is_discont) {
224  if (FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE ||
225  pkt_dts + AV_TIME_BASE/10 < ds->dts) {
226  d->ts_offset_discont -= delta;
227  av_log(ist, AV_LOG_WARNING,
228  "timestamp discontinuity "
229  "(stream id=%d): %"PRId64", new offset= %"PRId64"\n",
230  ist->st->id, delta, d->ts_offset_discont);
232  if (pkt->pts != AV_NOPTS_VALUE)
234  }
235  } else {
236  if (FFABS(delta) > 1LL * dts_error_threshold * AV_TIME_BASE) {
238  "DTS %"PRId64", next:%"PRId64" st:%d invalid dropping\n",
239  pkt->dts, ds->next_dts, pkt->stream_index);
241  }
242  if (pkt->pts != AV_NOPTS_VALUE){
243  int64_t pkt_pts = av_rescale_q(pkt->pts, pkt->time_base, AV_TIME_BASE_Q);
244  delta = pkt_pts - ds->next_dts;
245  if (FFABS(delta) > 1LL * dts_error_threshold * AV_TIME_BASE) {
247  "PTS %"PRId64", next:%"PRId64" invalid dropping st:%d\n",
248  pkt->pts, ds->next_dts, pkt->stream_index);
250  }
251  }
252  }
253  } else if (ds->next_dts == AV_NOPTS_VALUE && !copy_ts &&
254  fmt_is_discont && d->last_ts != AV_NOPTS_VALUE) {
255  int64_t delta = pkt_dts - d->last_ts;
256  if (FFABS(delta) > 1LL * dts_delta_threshold * AV_TIME_BASE) {
257  d->ts_offset_discont -= delta;
259  "Inter stream timestamp discontinuity %"PRId64", new offset= %"PRId64"\n",
260  delta, d->ts_offset_discont);
262  if (pkt->pts != AV_NOPTS_VALUE)
264  }
265  }
266 
267  d->last_ts = av_rescale_q(pkt->dts, pkt->time_base, AV_TIME_BASE_Q);
268 }
269 
271  AVPacket *pkt)
272 {
273  int64_t offset = av_rescale_q(d->ts_offset_discont, AV_TIME_BASE_Q,
274  pkt->time_base);
275 
276  // apply previously-detected timestamp-discontinuity offset
277  // (to all streams, not just audio/video)
278  if (pkt->dts != AV_NOPTS_VALUE)
279  pkt->dts += offset;
280  if (pkt->pts != AV_NOPTS_VALUE)
281  pkt->pts += offset;
282 
283  // detect timestamp discontinuities for audio/video
284  if ((ist->par->codec_type == AVMEDIA_TYPE_VIDEO ||
285  ist->par->codec_type == AVMEDIA_TYPE_AUDIO) &&
286  pkt->dts != AV_NOPTS_VALUE)
288 }
289 
291 {
292  InputStream *ist = &ds->ist;
293  const AVCodecParameters *par = ist->par;
294 
295  if (!ds->saw_first_ts) {
296  ds->first_dts =
297  ds->dts = ist->st->avg_frame_rate.num ? - ist->par->video_delay * AV_TIME_BASE / av_q2d(ist->st->avg_frame_rate) : 0;
298  if (pkt->pts != AV_NOPTS_VALUE) {
299  ds->first_dts =
301  }
302  ds->saw_first_ts = 1;
303  }
304 
305  if (ds->next_dts == AV_NOPTS_VALUE)
306  ds->next_dts = ds->dts;
307 
308  if (pkt->dts != AV_NOPTS_VALUE)
310 
311  ds->dts = ds->next_dts;
312  switch (par->codec_type) {
313  case AVMEDIA_TYPE_AUDIO:
314  av_assert1(pkt->duration >= 0);
315  if (par->sample_rate) {
316  ds->next_dts += ((int64_t)AV_TIME_BASE * par->frame_size) /
317  par->sample_rate;
318  } else {
320  }
321  break;
322  case AVMEDIA_TYPE_VIDEO:
323  if (ist->framerate.num) {
324  // TODO: Remove work-around for c99-to-c89 issue 7
325  AVRational time_base_q = AV_TIME_BASE_Q;
326  int64_t next_dts = av_rescale_q(ds->next_dts, time_base_q, av_inv_q(ist->framerate));
327  ds->next_dts = av_rescale_q(next_dts + 1, av_inv_q(ist->framerate), time_base_q);
328  } else if (pkt->duration) {
330  } else if (ist->par->framerate.num != 0) {
331  AVRational field_rate = av_mul_q(ist->par->framerate,
332  (AVRational){ 2, 1 });
333  int fields = 2;
334 
335  if (ds->codec_desc &&
337  av_stream_get_parser(ist->st))
339 
340  ds->next_dts += av_rescale_q(fields, av_inv_q(field_rate), AV_TIME_BASE_Q);
341  }
342  break;
343  }
344 
345  fd->dts_est = ds->dts;
346 
347  return 0;
348 }
349 
350 static int ts_fixup(Demuxer *d, AVPacket *pkt, FrameData *fd)
351 {
352  InputFile *ifile = &d->f;
353  InputStream *ist = ifile->streams[pkt->stream_index];
354  DemuxStream *ds = ds_from_ist(ist);
355  const int64_t start_time = ifile->start_time_effective;
356  int64_t duration;
357  int ret;
358 
359  pkt->time_base = ist->st->time_base;
360 
361 #define SHOW_TS_DEBUG(tag_) \
362  if (debug_ts) { \
363  av_log(ist, AV_LOG_INFO, "%s -> ist_index:%d:%d type:%s " \
364  "pkt_pts:%s pkt_pts_time:%s pkt_dts:%s pkt_dts_time:%s duration:%s duration_time:%s\n", \
365  tag_, ifile->index, pkt->stream_index, \
366  av_get_media_type_string(ist->st->codecpar->codec_type), \
367  av_ts2str(pkt->pts), av_ts2timestr(pkt->pts, &pkt->time_base), \
368  av_ts2str(pkt->dts), av_ts2timestr(pkt->dts, &pkt->time_base), \
369  av_ts2str(pkt->duration), av_ts2timestr(pkt->duration, &pkt->time_base)); \
370  }
371 
372  SHOW_TS_DEBUG("demuxer");
373 
375  ist->st->pts_wrap_bits < 64) {
376  int64_t stime, stime2;
377 
379  stime2= stime + (1ULL<<ist->st->pts_wrap_bits);
380  ds->wrap_correction_done = 1;
381 
382  if(stime2 > stime && pkt->dts != AV_NOPTS_VALUE && pkt->dts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
383  pkt->dts -= 1ULL<<ist->st->pts_wrap_bits;
384  ds->wrap_correction_done = 0;
385  }
386  if(stime2 > stime && pkt->pts != AV_NOPTS_VALUE && pkt->pts > stime + (1LL<<(ist->st->pts_wrap_bits-1))) {
387  pkt->pts -= 1ULL<<ist->st->pts_wrap_bits;
388  ds->wrap_correction_done = 0;
389  }
390  }
391 
392  if (pkt->dts != AV_NOPTS_VALUE)
394  if (pkt->pts != AV_NOPTS_VALUE)
396 
397  if (pkt->pts != AV_NOPTS_VALUE)
398  pkt->pts *= ds->ts_scale;
399  if (pkt->dts != AV_NOPTS_VALUE)
400  pkt->dts *= ds->ts_scale;
401 
402  duration = av_rescale_q(d->duration.ts, d->duration.tb, pkt->time_base);
403  if (pkt->pts != AV_NOPTS_VALUE) {
404  // audio decoders take precedence for estimating total file duration
405  int64_t pkt_duration = d->have_audio_dec ? 0 : pkt->duration;
406 
407  pkt->pts += duration;
408 
409  // update max/min pts that will be used to compute total file duration
410  // when using -stream_loop
411  if (d->max_pts.ts == AV_NOPTS_VALUE ||
412  av_compare_ts(d->max_pts.ts, d->max_pts.tb,
413  pkt->pts + pkt_duration, pkt->time_base) < 0) {
414  d->max_pts = (Timestamp){ .ts = pkt->pts + pkt_duration,
415  .tb = pkt->time_base };
416  }
417  if (d->min_pts.ts == AV_NOPTS_VALUE ||
418  av_compare_ts(d->min_pts.ts, d->min_pts.tb,
419  pkt->pts, pkt->time_base) > 0) {
420  d->min_pts = (Timestamp){ .ts = pkt->pts,
421  .tb = pkt->time_base };
422  }
423  }
424 
425  if (pkt->dts != AV_NOPTS_VALUE)
426  pkt->dts += duration;
427 
428  SHOW_TS_DEBUG("demuxer+tsfixup");
429 
430  // detect and try to correct for timestamp discontinuities
432 
433  // update estimated/predicted dts
434  ret = ist_dts_update(ds, pkt, fd);
435  if (ret < 0)
436  return ret;
437 
438  return 0;
439 }
440 
441 static int input_packet_process(Demuxer *d, AVPacket *pkt, unsigned *send_flags)
442 {
443  InputFile *f = &d->f;
444  InputStream *ist = f->streams[pkt->stream_index];
445  DemuxStream *ds = ds_from_ist(ist);
446  FrameData *fd;
447  int ret = 0;
448 
449  fd = packet_data(pkt);
450  if (!fd)
451  return AVERROR(ENOMEM);
452 
453  ret = ts_fixup(d, pkt, fd);
454  if (ret < 0)
455  return ret;
456 
457  if (d->recording_time != INT64_MAX) {
458  int64_t start_time = 0;
459  if (copy_ts) {
460  start_time += f->start_time != AV_NOPTS_VALUE ? f->start_time : 0;
461  start_time += start_at_zero ? 0 : f->start_time_effective;
462  }
463  if (ds->dts >= d->recording_time + start_time)
464  *send_flags |= DEMUX_SEND_STREAMCOPY_EOF;
465  }
466 
467  ds->data_size += pkt->size;
468  ds->nb_packets++;
469 
471 
472  if (debug_ts) {
473  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",
474  f->index, pkt->stream_index,
479  av_ts2str(f->ts_offset), av_ts2timestr(f->ts_offset, &AV_TIME_BASE_Q));
480  }
481 
482  return 0;
483 }
484 
485 static void readrate_sleep(Demuxer *d)
486 {
487  InputFile *f = &d->f;
488  int64_t file_start = copy_ts * (
489  (f->start_time_effective != AV_NOPTS_VALUE ? f->start_time_effective * !start_at_zero : 0) +
490  (f->start_time != AV_NOPTS_VALUE ? f->start_time : 0)
491  );
492  int64_t burst_until = AV_TIME_BASE * d->readrate_initial_burst;
493  for (int i = 0; i < f->nb_streams; i++) {
494  InputStream *ist = f->streams[i];
495  DemuxStream *ds = ds_from_ist(ist);
496  int64_t stream_ts_offset, pts, now;
497  stream_ts_offset = FFMAX(ds->first_dts != AV_NOPTS_VALUE ? ds->first_dts : 0, file_start);
498  pts = av_rescale(ds->dts, 1000000, AV_TIME_BASE);
499  now = (av_gettime_relative() - d->wallclock_start) * d->readrate + stream_ts_offset;
500  if (pts - burst_until > now)
501  av_usleep(pts - burst_until - now);
502  }
503 }
504 
505 static int do_send(Demuxer *d, DemuxStream *ds, AVPacket *pkt, unsigned flags,
506  const char *pkt_desc)
507 {
508  int ret;
509 
511 
512  ret = sch_demux_send(d->sch, d->f.index, pkt, flags);
513  if (ret == AVERROR_EOF) {
515 
516  av_log(ds, AV_LOG_VERBOSE, "All consumers of this stream are done\n");
517  ds->finished = 1;
518 
519  if (++d->nb_streams_finished == d->nb_streams_used) {
520  av_log(d, AV_LOG_VERBOSE, "All consumers are done\n");
521  return AVERROR_EOF;
522  }
523  } else if (ret < 0) {
524  if (ret != AVERROR_EXIT)
526  "Unable to send %s packet to consumers: %s\n",
527  pkt_desc, av_err2str(ret));
528  return ret;
529  }
530 
531  return 0;
532 }
533 
535  AVPacket *pkt, unsigned flags)
536 {
537  InputFile *f = &d->f;
538  int ret;
539 
540  // pkt can be NULL only when flushing BSFs
541  av_assert0(ds->bsf || pkt);
542 
543  // send heartbeat for sub2video streams
544  if (d->pkt_heartbeat && pkt && pkt->pts != AV_NOPTS_VALUE) {
545  for (int i = 0; i < f->nb_streams; i++) {
546  DemuxStream *ds1 = ds_from_ist(f->streams[i]);
547 
548  if (ds1->finished || !ds1->have_sub2video)
549  continue;
550 
551  d->pkt_heartbeat->pts = pkt->pts;
552  d->pkt_heartbeat->time_base = pkt->time_base;
553  d->pkt_heartbeat->opaque = (void*)(intptr_t)PKT_OPAQUE_SUB_HEARTBEAT;
554 
555  ret = do_send(d, ds1, d->pkt_heartbeat, 0, "heartbeat");
556  if (ret < 0)
557  return ret;
558  }
559  }
560 
561  if (ds->bsf) {
562  if (pkt)
564 
565  ret = av_bsf_send_packet(ds->bsf, pkt);
566  if (ret < 0) {
567  if (pkt)
569  av_log(ds, AV_LOG_ERROR, "Error submitting a packet for filtering: %s\n",
570  av_err2str(ret));
571  return ret;
572  }
573 
574  while (1) {
575  ret = av_bsf_receive_packet(ds->bsf, dt->pkt_bsf);
576  if (ret == AVERROR(EAGAIN))
577  return 0;
578  else if (ret < 0) {
579  if (ret != AVERROR_EOF)
580  av_log(ds, AV_LOG_ERROR,
581  "Error applying bitstream filters to a packet: %s\n",
582  av_err2str(ret));
583  return ret;
584  }
585 
586  dt->pkt_bsf->time_base = ds->bsf->time_base_out;
587 
588  ret = do_send(d, ds, dt->pkt_bsf, 0, "filtered");
589  if (ret < 0) {
591  return ret;
592  }
593  }
594  } else {
595  ret = do_send(d, ds, pkt, flags, "demuxed");
596  if (ret < 0)
597  return ret;
598  }
599 
600  return 0;
601 }
602 
604 {
605  InputFile *f = &d->f;
606  int ret;
607 
608  for (unsigned i = 0; i < f->nb_streams; i++) {
609  DemuxStream *ds = ds_from_ist(f->streams[i]);
610 
611  if (!ds->bsf)
612  continue;
613 
614  ret = demux_send(d, dt, ds, NULL, 0);
615  ret = (ret == AVERROR_EOF) ? 0 : (ret < 0) ? ret : AVERROR_BUG;
616  if (ret < 0) {
617  av_log(ds, AV_LOG_ERROR, "Error flushing BSFs: %s\n",
618  av_err2str(ret));
619  return ret;
620  }
621 
622  av_bsf_flush(ds->bsf);
623  }
624 
625  return 0;
626 }
627 
629 {
630  for (int j = 0; j < ifile->ctx->nb_programs; j++) {
631  AVProgram *p = ifile->ctx->programs[j];
632  int discard = AVDISCARD_ALL;
633 
634  for (int k = 0; k < p->nb_stream_indexes; k++) {
635  DemuxStream *ds = ds_from_ist(ifile->streams[p->stream_index[k]]);
636 
637  if (!ds->discard) {
638  discard = AVDISCARD_DEFAULT;
639  break;
640  }
641  }
642  p->discard = discard;
643  }
644 }
645 
647 {
648  char name[16];
649  snprintf(name, sizeof(name), "dmx%d:%s", f->index, f->ctx->iformat->name);
651 }
652 
654 {
656  av_packet_free(&dt->pkt_bsf);
657 
658  memset(dt, 0, sizeof(*dt));
659 }
660 
662 {
663  memset(dt, 0, sizeof(*dt));
664 
665  dt->pkt_demux = av_packet_alloc();
666  if (!dt->pkt_demux)
667  return AVERROR(ENOMEM);
668 
669  dt->pkt_bsf = av_packet_alloc();
670  if (!dt->pkt_bsf)
671  return AVERROR(ENOMEM);
672 
673  return 0;
674 }
675 
676 static void *input_thread(void *arg)
677 {
678  Demuxer *d = arg;
679  InputFile *f = &d->f;
680 
682 
683  int ret = 0;
684 
685  ret = demux_thread_init(&dt);
686  if (ret < 0)
687  goto finish;
688 
690 
692 
693  d->read_started = 1;
694  d->wallclock_start = av_gettime_relative();
695 
696  while (1) {
697  DemuxStream *ds;
698  unsigned send_flags = 0;
699 
700  ret = av_read_frame(f->ctx, dt.pkt_demux);
701 
702  if (ret == AVERROR(EAGAIN)) {
703  av_usleep(10000);
704  continue;
705  }
706  if (ret < 0) {
707  int ret_bsf;
708 
709  if (ret == AVERROR_EOF)
710  av_log(d, AV_LOG_VERBOSE, "EOF while reading input\n");
711  else {
712  av_log(d, AV_LOG_ERROR, "Error during demuxing: %s\n",
713  av_err2str(ret));
714  ret = exit_on_error ? ret : 0;
715  }
716 
717  ret_bsf = demux_bsf_flush(d, &dt);
718  ret = err_merge(ret == AVERROR_EOF ? 0 : ret, ret_bsf);
719 
720  if (d->loop) {
721  /* signal looping to our consumers */
722  dt.pkt_demux->stream_index = -1;
723  ret = sch_demux_send(d->sch, f->index, dt.pkt_demux, 0);
724  if (ret >= 0)
725  ret = seek_to_start(d, (Timestamp){ .ts = dt.pkt_demux->pts,
726  .tb = dt.pkt_demux->time_base });
727  if (ret >= 0)
728  continue;
729 
730  /* fallthrough to the error path */
731  }
732 
733  break;
734  }
735 
736  if (do_pkt_dump) {
738  f->ctx->streams[dt.pkt_demux->stream_index]);
739  }
740 
741  /* the following test is needed in case new streams appear
742  dynamically in stream : we ignore them */
743  ds = dt.pkt_demux->stream_index < f->nb_streams ?
744  ds_from_ist(f->streams[dt.pkt_demux->stream_index]) : NULL;
745  if (!ds || ds->discard || ds->finished) {
748  continue;
749  }
750 
751  if (dt.pkt_demux->flags & AV_PKT_FLAG_CORRUPT) {
753  "corrupt input packet in stream %d\n",
754  dt.pkt_demux->stream_index);
755  if (exit_on_error) {
758  break;
759  }
760  }
761 
762  ret = input_packet_process(d, dt.pkt_demux, &send_flags);
763  if (ret < 0)
764  break;
765 
766  if (d->readrate)
767  readrate_sleep(d);
768 
769  ret = demux_send(d, &dt, ds, dt.pkt_demux, send_flags);
770  if (ret < 0)
771  break;
772  }
773 
774  // EOF/EXIT is normal termination
775  if (ret == AVERROR_EOF || ret == AVERROR_EXIT)
776  ret = 0;
777 
778 finish:
779  demux_thread_uninit(&dt);
780 
781  return (void*)(intptr_t)ret;
782 }
783 
785 {
786  InputFile *f = &d->f;
787  uint64_t total_packets = 0, total_size = 0;
788 
789  av_log(f, AV_LOG_VERBOSE, "Input file #%d (%s):\n",
790  f->index, f->ctx->url);
791 
792  for (int j = 0; j < f->nb_streams; j++) {
793  InputStream *ist = f->streams[j];
794  DemuxStream *ds = ds_from_ist(ist);
795  enum AVMediaType type = ist->par->codec_type;
796 
797  if (ds->discard || type == AVMEDIA_TYPE_ATTACHMENT)
798  continue;
799 
800  total_size += ds->data_size;
801  total_packets += ds->nb_packets;
802 
803  av_log(f, AV_LOG_VERBOSE, " Input stream #%d:%d (%s): ",
804  f->index, j, av_get_media_type_string(type));
805  av_log(f, AV_LOG_VERBOSE, "%"PRIu64" packets read (%"PRIu64" bytes); ",
806  ds->nb_packets, ds->data_size);
807 
808  if (ds->decoding_needed) {
810  "%"PRIu64" frames decoded; %"PRIu64" decode errors",
812  if (type == AVMEDIA_TYPE_AUDIO)
813  av_log(f, AV_LOG_VERBOSE, " (%"PRIu64" samples)", ist->decoder->samples_decoded);
814  av_log(f, AV_LOG_VERBOSE, "; ");
815  }
816 
817  av_log(f, AV_LOG_VERBOSE, "\n");
818  }
819 
820  av_log(f, AV_LOG_VERBOSE, " Total: %"PRIu64" packets (%"PRIu64" bytes) demuxed\n",
821  total_packets, total_size);
822 }
823 
824 static void ist_free(InputStream **pist)
825 {
826  InputStream *ist = *pist;
827  DemuxStream *ds;
828 
829  if (!ist)
830  return;
831  ds = ds_from_ist(ist);
832 
833  dec_free(&ist->decoder);
834 
836  av_freep(&ist->filters);
837  av_freep(&ist->outputs);
839 
841 
842  av_bsf_free(&ds->bsf);
843 
844  av_freep(pist);
845 }
846 
848 {
849  InputFile *f = *pf;
851 
852  if (!f)
853  return;
854 
855  if (d->read_started)
857 
858  for (int i = 0; i < f->nb_streams; i++)
859  ist_free(&f->streams[i]);
860  av_freep(&f->streams);
861 
862  avformat_close_input(&f->ctx);
863 
864  av_packet_free(&d->pkt_heartbeat);
865 
866  av_freep(pf);
867 }
868 
869 static int ist_use(InputStream *ist, int decoding_needed)
870 {
871  Demuxer *d = demuxer_from_ifile(ist->file);
872  DemuxStream *ds = ds_from_ist(ist);
873  int ret;
874 
875  if (ist->user_set_discard == AVDISCARD_ALL) {
876  av_log(ist, AV_LOG_ERROR, "Cannot %s a disabled input stream\n",
877  decoding_needed ? "decode" : "streamcopy");
878  return AVERROR(EINVAL);
879  }
880 
881  if (decoding_needed && !ist->dec) {
882  av_log(ist, AV_LOG_ERROR,
883  "Decoding requested, but no decoder found for: %s\n",
884  avcodec_get_name(ist->par->codec_id));
885  return AVERROR(EINVAL);
886  }
887 
888  if (ds->sch_idx_stream < 0) {
889  ret = sch_add_demux_stream(d->sch, d->f.index);
890  if (ret < 0)
891  return ret;
892  ds->sch_idx_stream = ret;
893  }
894 
895  if (ds->discard) {
896  ds->discard = 0;
897  d->nb_streams_used++;
898  }
899 
900  ist->st->discard = ist->user_set_discard;
901  ds->decoding_needed |= decoding_needed;
902  ds->streamcopy_needed |= !decoding_needed;
903 
904  if (decoding_needed && ds->sch_idx_dec < 0) {
905  int is_audio = ist->st->codecpar->codec_type == AVMEDIA_TYPE_AUDIO;
906 
908  (!!(d->f.ctx->iformat->flags & AVFMT_NOTIMESTAMPS) * DECODER_FLAG_TS_UNRELIABLE) |
909  (!!(d->loop && is_audio) * DECODER_FLAG_SEND_END_TS)
910 #if FFMPEG_OPT_TOP
912 #endif
913  ;
914 
915  if (ist->framerate.num) {
917  ds->dec_opts.framerate = ist->framerate;
918  } else
919  ds->dec_opts.framerate = ist->st->avg_frame_rate;
920 
921  if (ist->dec->id == AV_CODEC_ID_DVB_SUBTITLE &&
923  av_dict_set(&ds->decoder_opts, "compute_edt", "1", AV_DICT_DONT_OVERWRITE);
925  av_log(ist, AV_LOG_WARNING,
926  "Warning using DVB subtitles for filtering and output at the "
927  "same time is not fully supported, also see -compute_edt [0|1]\n");
928  }
929 
930  snprintf(ds->dec_name, sizeof(ds->dec_name), "%d:%d", ist->file->index, ist->index);
931  ds->dec_opts.name = ds->dec_name;
932 
933  ds->dec_opts.codec = ist->dec;
934  ds->dec_opts.par = ist->par;
935 
936  ds->dec_opts.log_parent = ist;
937 
938  ret = dec_open(&ist->decoder, d->sch,
939  &ds->decoder_opts, &ds->dec_opts);
940  if (ret < 0)
941  return ret;
942  ds->sch_idx_dec = ret;
943 
944  ret = sch_connect(d->sch, SCH_DSTREAM(d->f.index, ds->sch_idx_stream),
945  SCH_DEC(ds->sch_idx_dec));
946  if (ret < 0)
947  return ret;
948 
949  d->have_audio_dec |= is_audio;
950  }
951 
952  return 0;
953 }
954 
956 {
957  DemuxStream *ds = ds_from_ist(ist);
958  int ret;
959 
960  ret = ist_use(ist, ost->enc ? DECODING_FOR_OST : 0);
961  if (ret < 0)
962  return ret;
963 
964  ret = GROW_ARRAY(ist->outputs, ist->nb_outputs);
965  if (ret < 0)
966  return ret;
967 
968  ist->outputs[ist->nb_outputs - 1] = ost;
969 
970  return ost->enc ? ds->sch_idx_dec : ds->sch_idx_stream;
971 }
972 
973 int ist_filter_add(InputStream *ist, InputFilter *ifilter, int is_simple,
975 {
976  Demuxer *d = demuxer_from_ifile(ist->file);
977  DemuxStream *ds = ds_from_ist(ist);
978  int64_t tsoffset = 0;
979  int ret;
980 
981  ret = ist_use(ist, is_simple ? DECODING_FOR_OST : DECODING_FOR_FILTER);
982  if (ret < 0)
983  return ret;
984 
985  ret = GROW_ARRAY(ist->filters, ist->nb_filters);
986  if (ret < 0)
987  return ret;
988 
989  ist->filters[ist->nb_filters - 1] = ifilter;
990 
991  ret = dec_add_filter(ist->decoder, ifilter);
992  if (ret < 0)
993  return ret;
994 
995  if (ist->par->codec_type == AVMEDIA_TYPE_VIDEO) {
996  if (ist->framerate.num > 0 && ist->framerate.den > 0) {
997  opts->framerate = ist->framerate;
998  opts->flags |= IFILTER_FLAG_CFR;
999  } else
1000  opts->framerate = av_guess_frame_rate(d->f.ctx, ist->st, NULL);
1001  } else if (ist->par->codec_type == AVMEDIA_TYPE_SUBTITLE) {
1002  /* Compute the size of the canvas for the subtitles stream.
1003  If the subtitles codecpar has set a size, use it. Otherwise use the
1004  maximum dimensions of the video streams in the same file. */
1005  opts->sub2video_width = ist->par->width;
1006  opts->sub2video_height = ist->par->height;
1007  if (!(opts->sub2video_width && opts->sub2video_height)) {
1008  for (int j = 0; j < d->f.nb_streams; j++) {
1009  AVCodecParameters *par1 = d->f.streams[j]->par;
1010  if (par1->codec_type == AVMEDIA_TYPE_VIDEO) {
1011  opts->sub2video_width = FFMAX(opts->sub2video_width, par1->width);
1012  opts->sub2video_height = FFMAX(opts->sub2video_height, par1->height);
1013  }
1014  }
1015  }
1016 
1017  if (!(opts->sub2video_width && opts->sub2video_height)) {
1018  opts->sub2video_width = FFMAX(opts->sub2video_width, 720);
1019  opts->sub2video_height = FFMAX(opts->sub2video_height, 576);
1020  }
1021 
1022  if (!d->pkt_heartbeat) {
1023  d->pkt_heartbeat = av_packet_alloc();
1024  if (!d->pkt_heartbeat)
1025  return AVERROR(ENOMEM);
1026  }
1027  ds->have_sub2video = 1;
1028  }
1029 
1030  if (copy_ts) {
1031  tsoffset = d->f.start_time == AV_NOPTS_VALUE ? 0 : d->f.start_time;
1032  if (!start_at_zero && d->f.ctx->start_time != AV_NOPTS_VALUE)
1033  tsoffset += d->f.ctx->start_time;
1034  }
1035  opts->trim_start_us = ((d->f.start_time == AV_NOPTS_VALUE) || !d->accurate_seek) ?
1036  AV_NOPTS_VALUE : tsoffset;
1037  opts->trim_end_us = d->recording_time;
1038 
1039  opts->name = av_strdup(ds->dec_name);
1040  if (!opts->name)
1041  return AVERROR(ENOMEM);
1042 
1043  opts->flags |= IFILTER_FLAG_AUTOROTATE * !!(ist->autorotate) |
1045 
1046  return ds->sch_idx_dec;
1047 }
1048 
1050  enum HWAccelID hwaccel_id, enum AVHWDeviceType hwaccel_device_type,
1051  const AVCodec **pcodec)
1052 
1053 {
1054  char *codec_name = NULL;
1055 
1056  MATCH_PER_STREAM_OPT(codec_names, str, codec_name, s, st);
1057  if (codec_name) {
1058  int ret = find_codec(NULL, codec_name, st->codecpar->codec_type, 0, pcodec);
1059  if (ret < 0)
1060  return ret;
1061  st->codecpar->codec_id = (*pcodec)->id;
1062  if (recast_media && st->codecpar->codec_type != (*pcodec)->type)
1063  st->codecpar->codec_type = (*pcodec)->type;
1064  return 0;
1065  } else {
1066  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO &&
1067  hwaccel_id == HWACCEL_GENERIC &&
1068  hwaccel_device_type != AV_HWDEVICE_TYPE_NONE) {
1069  const AVCodec *c;
1070  void *i = NULL;
1071 
1072  while ((c = av_codec_iterate(&i))) {
1073  const AVCodecHWConfig *config;
1074 
1075  if (c->id != st->codecpar->codec_id ||
1077  continue;
1078 
1079  for (int j = 0; config = avcodec_get_hw_config(c, j); j++) {
1080  if (config->device_type == hwaccel_device_type) {
1081  av_log(NULL, AV_LOG_VERBOSE, "Selecting decoder '%s' because of requested hwaccel method %s\n",
1082  c->name, av_hwdevice_get_type_name(hwaccel_device_type));
1083  *pcodec = c;
1084  return 0;
1085  }
1086  }
1087  }
1088  }
1089 
1090  *pcodec = avcodec_find_decoder(st->codecpar->codec_id);
1091  return 0;
1092  }
1093 }
1094 
1096  int guess_layout_max)
1097 {
1098  if (par->ch_layout.order == AV_CHANNEL_ORDER_UNSPEC) {
1099  char layout_name[256];
1100 
1101  if (par->ch_layout.nb_channels > guess_layout_max)
1102  return 0;
1105  return 0;
1106  av_channel_layout_describe(&par->ch_layout, layout_name, sizeof(layout_name));
1107  av_log(ist, AV_LOG_WARNING, "Guessed Channel Layout: %s\n", layout_name);
1108  }
1109  return 1;
1110 }
1111 
1114 {
1115  AVStream *st = ist->st;
1116  AVPacketSideData *sd;
1117  double rotation = DBL_MAX;
1118  int hflip = -1, vflip = -1;
1119  int hflip_set = 0, vflip_set = 0, rotation_set = 0;
1120  int32_t *buf;
1121 
1122  MATCH_PER_STREAM_OPT(display_rotations, dbl, rotation, ctx, st);
1123  MATCH_PER_STREAM_OPT(display_hflips, i, hflip, ctx, st);
1124  MATCH_PER_STREAM_OPT(display_vflips, i, vflip, ctx, st);
1125 
1126  rotation_set = rotation != DBL_MAX;
1127  hflip_set = hflip != -1;
1128  vflip_set = vflip != -1;
1129 
1130  if (!rotation_set && !hflip_set && !vflip_set)
1131  return 0;
1132 
1136  sizeof(int32_t) * 9, 0);
1137  if (!sd) {
1138  av_log(ist, AV_LOG_FATAL, "Failed to generate a display matrix!\n");
1139  return AVERROR(ENOMEM);
1140  }
1141 
1142  buf = (int32_t *)sd->data;
1144  rotation_set ? -(rotation) : -0.0f);
1145 
1147  hflip_set ? hflip : 0,
1148  vflip_set ? vflip : 0);
1149 
1150  return 0;
1151 }
1152 
1153 static const char *input_stream_item_name(void *obj)
1154 {
1155  const DemuxStream *ds = obj;
1156 
1157  return ds->log_name;
1158 }
1159 
1160 static const AVClass input_stream_class = {
1161  .class_name = "InputStream",
1162  .version = LIBAVUTIL_VERSION_INT,
1163  .item_name = input_stream_item_name,
1164  .category = AV_CLASS_CATEGORY_DEMUXER,
1165 };
1166 
1168 {
1169  const char *type_str = av_get_media_type_string(st->codecpar->codec_type);
1170  InputFile *f = &d->f;
1171  DemuxStream *ds;
1172 
1173  ds = allocate_array_elem(&f->streams, sizeof(*ds), &f->nb_streams);
1174  if (!ds)
1175  return NULL;
1176 
1177  ds->sch_idx_stream = -1;
1178  ds->sch_idx_dec = -1;
1179 
1180  ds->ist.st = st;
1181  ds->ist.file = f;
1182  ds->ist.index = st->index;
1183  ds->ist.class = &input_stream_class;
1184 
1185  snprintf(ds->log_name, sizeof(ds->log_name), "%cist#%d:%d/%s",
1186  type_str ? *type_str : '?', d->f.index, st->index,
1188 
1189  return ds;
1190 }
1191 
1192 static int ist_add(const OptionsContext *o, Demuxer *d, AVStream *st)
1193 {
1194  AVFormatContext *ic = d->f.ctx;
1195  AVCodecParameters *par = st->codecpar;
1196  DemuxStream *ds;
1197  InputStream *ist;
1198  char *framerate = NULL, *hwaccel_device = NULL;
1199  const char *hwaccel = NULL;
1200  char *hwaccel_output_format = NULL;
1201  char *codec_tag = NULL;
1202  char *bsfs = NULL;
1203  char *next;
1204  char *discard_str = NULL;
1205  int ret;
1206 
1207  ds = demux_stream_alloc(d, st);
1208  if (!ds)
1209  return AVERROR(ENOMEM);
1210 
1211  ist = &ds->ist;
1212 
1213  ds->discard = 1;
1214  st->discard = AVDISCARD_ALL;
1215  ds->first_dts = AV_NOPTS_VALUE;
1216  ds->next_dts = AV_NOPTS_VALUE;
1217 
1218  ds->dec_opts.time_base = st->time_base;
1219 
1220  ds->ts_scale = 1.0;
1221  MATCH_PER_STREAM_OPT(ts_scale, dbl, ds->ts_scale, ic, st);
1222 
1223  ist->autorotate = 1;
1224  MATCH_PER_STREAM_OPT(autorotate, i, ist->autorotate, ic, st);
1225 
1226  MATCH_PER_STREAM_OPT(codec_tags, str, codec_tag, ic, st);
1227  if (codec_tag) {
1228  uint32_t tag = strtol(codec_tag, &next, 0);
1229  if (*next) {
1230  uint8_t buf[4] = { 0 };
1231  memcpy(buf, codec_tag, FFMIN(sizeof(buf), strlen(codec_tag)));
1232  tag = AV_RL32(buf);
1233  }
1234 
1235  st->codecpar->codec_tag = tag;
1236  }
1237 
1238  if (st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
1239  ret = add_display_matrix_to_stream(o, ic, ist);
1240  if (ret < 0)
1241  return ret;
1242 
1243  MATCH_PER_STREAM_OPT(hwaccels, str, hwaccel, ic, st);
1244  MATCH_PER_STREAM_OPT(hwaccel_output_formats, str,
1245  hwaccel_output_format, ic, st);
1246 
1247  if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "cuvid")) {
1248  av_log(ist, AV_LOG_WARNING,
1249  "WARNING: defaulting hwaccel_output_format to cuda for compatibility "
1250  "with old commandlines. This behaviour is DEPRECATED and will be removed "
1251  "in the future. Please explicitly set \"-hwaccel_output_format cuda\".\n");
1253  } else if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "qsv")) {
1254  av_log(ist, AV_LOG_WARNING,
1255  "WARNING: defaulting hwaccel_output_format to qsv for compatibility "
1256  "with old commandlines. This behaviour is DEPRECATED and will be removed "
1257  "in the future. Please explicitly set \"-hwaccel_output_format qsv\".\n");
1259  } else if (!hwaccel_output_format && hwaccel && !strcmp(hwaccel, "mediacodec")) {
1260  // There is no real AVHWFrameContext implementation. Set
1261  // hwaccel_output_format to avoid av_hwframe_transfer_data error.
1263  } else if (hwaccel_output_format) {
1264  ds->dec_opts.hwaccel_output_format = av_get_pix_fmt(hwaccel_output_format);
1266  av_log(ist, AV_LOG_FATAL, "Unrecognised hwaccel output "
1267  "format: %s", hwaccel_output_format);
1268  }
1269  } else {
1271  }
1272 
1273  if (hwaccel) {
1274  // The NVDEC hwaccels use a CUDA device, so remap the name here.
1275  if (!strcmp(hwaccel, "nvdec") || !strcmp(hwaccel, "cuvid"))
1276  hwaccel = "cuda";
1277 
1278  if (!strcmp(hwaccel, "none"))
1280  else if (!strcmp(hwaccel, "auto"))
1282  else {
1284  if (type != AV_HWDEVICE_TYPE_NONE) {
1287  }
1288 
1289  if (!ds->dec_opts.hwaccel_id) {
1290  av_log(ist, AV_LOG_FATAL, "Unrecognized hwaccel: %s.\n",
1291  hwaccel);
1292  av_log(ist, AV_LOG_FATAL, "Supported hwaccels: ");
1294  while ((type = av_hwdevice_iterate_types(type)) !=
1296  av_log(ist, AV_LOG_FATAL, "%s ",
1298  av_log(ist, AV_LOG_FATAL, "\n");
1299  return AVERROR(EINVAL);
1300  }
1301  }
1302  }
1303 
1304  MATCH_PER_STREAM_OPT(hwaccel_devices, str, hwaccel_device, ic, st);
1305  if (hwaccel_device) {
1306  ds->dec_opts.hwaccel_device = av_strdup(hwaccel_device);
1307  if (!ds->dec_opts.hwaccel_device)
1308  return AVERROR(ENOMEM);
1309  }
1310  }
1311 
1312  ret = choose_decoder(o, ic, st, ds->dec_opts.hwaccel_id,
1313  ds->dec_opts.hwaccel_device_type, &ist->dec);
1314  if (ret < 0)
1315  return ret;
1316 
1318  ic, st, ist->dec, &ds->decoder_opts);
1319  if (ret < 0)
1320  return ret;
1321 
1322  ds->reinit_filters = -1;
1323  MATCH_PER_STREAM_OPT(reinit_filters, i, ds->reinit_filters, ic, st);
1324 
1326 
1327  if ((o->video_disable && ist->st->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) ||
1332 
1333  MATCH_PER_STREAM_OPT(discard, str, discard_str, ic, st);
1334  if (discard_str) {
1335  ret = av_opt_set(ist->st, "discard", discard_str, 0);
1336  if (ret < 0) {
1337  av_log(ist, AV_LOG_ERROR, "Error parsing discard %s.\n", discard_str);
1338  return ret;
1339  }
1340  ist->user_set_discard = ist->st->discard;
1341  }
1342 
1343  if (o->bitexact)
1344  av_dict_set(&ds->decoder_opts, "flags", "+bitexact", AV_DICT_MULTIKEY);
1345 
1346  /* Attached pics are sparse, therefore we would not want to delay their decoding
1347  * till EOF. */
1349  av_dict_set(&ds->decoder_opts, "thread_type", "-frame", 0);
1350 
1351  switch (par->codec_type) {
1352  case AVMEDIA_TYPE_VIDEO:
1353  MATCH_PER_STREAM_OPT(frame_rates, str, framerate, ic, st);
1354  if (framerate) {
1356  if (ret < 0) {
1357  av_log(ist, AV_LOG_ERROR, "Error parsing framerate %s.\n",
1358  framerate);
1359  return ret;
1360  }
1361  }
1362 
1363 #if FFMPEG_OPT_TOP
1364  ist->top_field_first = -1;
1365  MATCH_PER_STREAM_OPT(top_field_first, i, ist->top_field_first, ic, st);
1366 #endif
1367 
1368  break;
1369  case AVMEDIA_TYPE_AUDIO: {
1370  int guess_layout_max = INT_MAX;
1371  MATCH_PER_STREAM_OPT(guess_layout_max, i, guess_layout_max, ic, st);
1372  guess_input_channel_layout(ist, par, guess_layout_max);
1373  break;
1374  }
1375  case AVMEDIA_TYPE_DATA:
1376  case AVMEDIA_TYPE_SUBTITLE: {
1377  char *canvas_size = NULL;
1378  MATCH_PER_STREAM_OPT(fix_sub_duration, i, ist->fix_sub_duration, ic, st);
1379  MATCH_PER_STREAM_OPT(canvas_sizes, str, canvas_size, ic, st);
1380  if (canvas_size) {
1381  ret = av_parse_video_size(&par->width, &par->height,
1382  canvas_size);
1383  if (ret < 0) {
1384  av_log(ist, AV_LOG_FATAL, "Invalid canvas size: %s.\n", canvas_size);
1385  return ret;
1386  }
1387  }
1388  break;
1389  }
1391  case AVMEDIA_TYPE_UNKNOWN:
1392  break;
1393  default: av_assert0(0);
1394  }
1395 
1396  ist->par = avcodec_parameters_alloc();
1397  if (!ist->par)
1398  return AVERROR(ENOMEM);
1399 
1400  ret = avcodec_parameters_copy(ist->par, par);
1401  if (ret < 0) {
1402  av_log(ist, AV_LOG_ERROR, "Error exporting stream parameters.\n");
1403  return ret;
1404  }
1405 
1406  if (ist->st->sample_aspect_ratio.num)
1408 
1409  MATCH_PER_STREAM_OPT(bitstream_filters, str, bsfs, ic, st);
1410  if (bsfs) {
1411  ret = av_bsf_list_parse_str(bsfs, &ds->bsf);
1412  if (ret < 0) {
1413  av_log(ist, AV_LOG_ERROR,
1414  "Error parsing bitstream filter sequence '%s': %s\n",
1415  bsfs, av_err2str(ret));
1416  return ret;
1417  }
1418 
1419  ret = avcodec_parameters_copy(ds->bsf->par_in, ist->par);
1420  if (ret < 0)
1421  return ret;
1422  ds->bsf->time_base_in = ist->st->time_base;
1423 
1424  ret = av_bsf_init(ds->bsf);
1425  if (ret < 0) {
1426  av_log(ist, AV_LOG_ERROR, "Error initializing bitstream filters: %s\n",
1427  av_err2str(ret));
1428  return ret;
1429  }
1430 
1431  ret = avcodec_parameters_copy(ist->par, ds->bsf->par_out);
1432  if (ret < 0)
1433  return ret;
1434  }
1435 
1437 
1438  return 0;
1439 }
1440 
1441 static int dump_attachment(InputStream *ist, const char *filename)
1442 {
1443  AVStream *st = ist->st;
1444  int ret;
1445  AVIOContext *out = NULL;
1446  const AVDictionaryEntry *e;
1447 
1448  if (!st->codecpar->extradata_size) {
1449  av_log(ist, AV_LOG_WARNING, "No extradata to dump.\n");
1450  return 0;
1451  }
1452  if (!*filename && (e = av_dict_get(st->metadata, "filename", NULL, 0)))
1453  filename = e->value;
1454  if (!*filename) {
1455  av_log(ist, AV_LOG_FATAL, "No filename specified and no 'filename' tag");
1456  return AVERROR(EINVAL);
1457  }
1458 
1459  ret = assert_file_overwrite(filename);
1460  if (ret < 0)
1461  return ret;
1462 
1463  if ((ret = avio_open2(&out, filename, AVIO_FLAG_WRITE, &int_cb, NULL)) < 0) {
1464  av_log(ist, AV_LOG_FATAL, "Could not open file %s for writing.\n",
1465  filename);
1466  return ret;
1467  }
1468 
1470  ret = avio_close(out);
1471 
1472  if (ret >= 0)
1473  av_log(ist, AV_LOG_INFO, "Wrote attachment (%d bytes) to '%s'\n",
1474  st->codecpar->extradata_size, filename);
1475 
1476  return ret;
1477 }
1478 
1479 static const char *input_file_item_name(void *obj)
1480 {
1481  const Demuxer *d = obj;
1482 
1483  return d->log_name;
1484 }
1485 
1486 static const AVClass input_file_class = {
1487  .class_name = "InputFile",
1488  .version = LIBAVUTIL_VERSION_INT,
1489  .item_name = input_file_item_name,
1490  .category = AV_CLASS_CATEGORY_DEMUXER,
1491 };
1492 
1493 static Demuxer *demux_alloc(void)
1494 {
1496 
1497  if (!d)
1498  return NULL;
1499 
1500  d->f.class = &input_file_class;
1501  d->f.index = nb_input_files - 1;
1502 
1503  snprintf(d->log_name, sizeof(d->log_name), "in#%d", d->f.index);
1504 
1505  return d;
1506 }
1507 
1508 int ifile_open(const OptionsContext *o, const char *filename, Scheduler *sch)
1509 {
1510  Demuxer *d;
1511  InputFile *f;
1512  AVFormatContext *ic;
1513  const AVInputFormat *file_iformat = NULL;
1514  int err, i, ret = 0;
1515  int64_t timestamp;
1516  AVDictionary *unused_opts = NULL;
1517  const AVDictionaryEntry *e = NULL;
1518  const char* video_codec_name = NULL;
1519  const char* audio_codec_name = NULL;
1520  const char* subtitle_codec_name = NULL;
1521  const char* data_codec_name = NULL;
1522  int scan_all_pmts_set = 0;
1523 
1524  int64_t start_time = o->start_time;
1525  int64_t start_time_eof = o->start_time_eof;
1526  int64_t stop_time = o->stop_time;
1527  int64_t recording_time = o->recording_time;
1528 
1529  d = demux_alloc();
1530  if (!d)
1531  return AVERROR(ENOMEM);
1532 
1533  f = &d->f;
1534 
1535  ret = sch_add_demux(sch, input_thread, d);
1536  if (ret < 0)
1537  return ret;
1538  d->sch = sch;
1539 
1540  if (stop_time != INT64_MAX && recording_time != INT64_MAX) {
1541  stop_time = INT64_MAX;
1542  av_log(d, AV_LOG_WARNING, "-t and -to cannot be used together; using -t.\n");
1543  }
1544 
1545  if (stop_time != INT64_MAX && recording_time == INT64_MAX) {
1546  int64_t start = start_time == AV_NOPTS_VALUE ? 0 : start_time;
1547  if (stop_time <= start) {
1548  av_log(d, AV_LOG_ERROR, "-to value smaller than -ss; aborting.\n");
1549  return AVERROR(EINVAL);
1550  } else {
1551  recording_time = stop_time - start;
1552  }
1553  }
1554 
1555  if (o->format) {
1556  if (!(file_iformat = av_find_input_format(o->format))) {
1557  av_log(d, AV_LOG_FATAL, "Unknown input format: '%s'\n", o->format);
1558  return AVERROR(EINVAL);
1559  }
1560  }
1561 
1562  if (!strcmp(filename, "-"))
1563  filename = "fd:";
1564 
1565  stdin_interaction &= strncmp(filename, "pipe:", 5) &&
1566  strcmp(filename, "fd:") &&
1567  strcmp(filename, "/dev/stdin");
1568 
1569  /* get default parameters from command line */
1570  ic = avformat_alloc_context();
1571  if (!ic)
1572  return AVERROR(ENOMEM);
1573  if (o->audio_sample_rate.nb_opt) {
1574  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);
1575  }
1576  if (o->audio_channels.nb_opt) {
1577  const AVClass *priv_class;
1578  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1579  av_opt_find(&priv_class, "ch_layout", NULL, 0,
1581  char buf[32];
1582  snprintf(buf, sizeof(buf), "%dC", o->audio_channels.opt[o->audio_channels.nb_opt - 1].u.i);
1583  av_dict_set(&o->g->format_opts, "ch_layout", buf, 0);
1584  }
1585  }
1586  if (o->audio_ch_layouts.nb_opt) {
1587  const AVClass *priv_class;
1588  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1589  av_opt_find(&priv_class, "ch_layout", NULL, 0,
1591  av_dict_set(&o->g->format_opts, "ch_layout", o->audio_ch_layouts.opt[o->audio_ch_layouts.nb_opt - 1].u.str, 0);
1592  }
1593  }
1594  if (o->frame_rates.nb_opt) {
1595  const AVClass *priv_class;
1596  /* set the format-level framerate option;
1597  * this is important for video grabbers, e.g. x11 */
1598  if (file_iformat && (priv_class = file_iformat->priv_class) &&
1599  av_opt_find(&priv_class, "framerate", NULL, 0,
1601  av_dict_set(&o->g->format_opts, "framerate",
1602  o->frame_rates.opt[o->frame_rates.nb_opt - 1].u.str, 0);
1603  }
1604  }
1605  if (o->frame_sizes.nb_opt) {
1606  av_dict_set(&o->g->format_opts, "video_size", o->frame_sizes.opt[o->frame_sizes.nb_opt - 1].u.str, 0);
1607  }
1608  if (o->frame_pix_fmts.nb_opt)
1609  av_dict_set(&o->g->format_opts, "pixel_format", o->frame_pix_fmts.opt[o->frame_pix_fmts.nb_opt - 1].u.str, 0);
1610 
1614  data_codec_name = opt_match_per_type_str(&o->codec_names, 'd');
1615 
1616  if (video_codec_name)
1618  &ic->video_codec));
1619  if (audio_codec_name)
1621  &ic->audio_codec));
1622  if (subtitle_codec_name)
1624  &ic->subtitle_codec));
1625  if (data_codec_name)
1626  ret = err_merge(ret, find_codec(NULL, data_codec_name , AVMEDIA_TYPE_DATA, 0,
1627  &ic->data_codec));
1628  if (ret < 0) {
1630  return ret;
1631  }
1632 
1636  ic->data_codec_id = data_codec_name ? ic->data_codec->id : AV_CODEC_ID_NONE;
1637 
1638  ic->flags |= AVFMT_FLAG_NONBLOCK;
1639  if (o->bitexact)
1640  ic->flags |= AVFMT_FLAG_BITEXACT;
1641  ic->interrupt_callback = int_cb;
1642 
1643  if (!av_dict_get(o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE)) {
1644  av_dict_set(&o->g->format_opts, "scan_all_pmts", "1", AV_DICT_DONT_OVERWRITE);
1645  scan_all_pmts_set = 1;
1646  }
1647  /* open the input file with generic avformat function */
1648  err = avformat_open_input(&ic, filename, file_iformat, &o->g->format_opts);
1649  if (err < 0) {
1651  "Error opening input: %s\n", av_err2str(err));
1652  if (err == AVERROR_PROTOCOL_NOT_FOUND)
1653  av_log(d, AV_LOG_ERROR, "Did you mean file:%s?\n", filename);
1654  return err;
1655  }
1656  f->ctx = ic;
1657 
1658  av_strlcat(d->log_name, "/", sizeof(d->log_name));
1659  av_strlcat(d->log_name, ic->iformat->name, sizeof(d->log_name));
1660 
1661  if (scan_all_pmts_set)
1662  av_dict_set(&o->g->format_opts, "scan_all_pmts", NULL, AV_DICT_MATCH_CASE);
1664 
1666  if (ret < 0)
1667  return ret;
1668 
1669  /* apply forced codec ids */
1670  for (i = 0; i < ic->nb_streams; i++) {
1671  const AVCodec *dummy;
1673  &dummy);
1674  if (ret < 0)
1675  return ret;
1676  }
1677 
1678  if (o->find_stream_info) {
1679  AVDictionary **opts;
1680  int orig_nb_streams = ic->nb_streams;
1681 
1683  if (ret < 0)
1684  return ret;
1685 
1686  /* If not enough info to get the stream parameters, we decode the
1687  first frames to get it. (used in mpeg case for example) */
1689 
1690  for (i = 0; i < orig_nb_streams; i++)
1691  av_dict_free(&opts[i]);
1692  av_freep(&opts);
1693 
1694  if (ret < 0) {
1695  av_log(d, AV_LOG_FATAL, "could not find codec parameters\n");
1696  if (ic->nb_streams == 0)
1697  return ret;
1698  }
1699  }
1700 
1701  if (start_time != AV_NOPTS_VALUE && start_time_eof != AV_NOPTS_VALUE) {
1702  av_log(d, AV_LOG_WARNING, "Cannot use -ss and -sseof both, using -ss\n");
1703  start_time_eof = AV_NOPTS_VALUE;
1704  }
1705 
1706  if (start_time_eof != AV_NOPTS_VALUE) {
1707  if (start_time_eof >= 0) {
1708  av_log(d, AV_LOG_ERROR, "-sseof value must be negative; aborting\n");
1709  return AVERROR(EINVAL);
1710  }
1711  if (ic->duration > 0) {
1712  start_time = start_time_eof + ic->duration;
1713  if (start_time < 0) {
1714  av_log(d, AV_LOG_WARNING, "-sseof value seeks to before start of file; ignored\n");
1716  }
1717  } else
1718  av_log(d, AV_LOG_WARNING, "Cannot use -sseof, file duration not known\n");
1719  }
1720  timestamp = (start_time == AV_NOPTS_VALUE) ? 0 : start_time;
1721  /* add the stream start time */
1722  if (!o->seek_timestamp && ic->start_time != AV_NOPTS_VALUE)
1723  timestamp += ic->start_time;
1724 
1725  /* if seeking requested, we execute it */
1726  if (start_time != AV_NOPTS_VALUE) {
1727  int64_t seek_timestamp = timestamp;
1728 
1729  if (!(ic->iformat->flags & AVFMT_SEEK_TO_PTS)) {
1730  int dts_heuristic = 0;
1731  for (i=0; i<ic->nb_streams; i++) {
1732  const AVCodecParameters *par = ic->streams[i]->codecpar;
1733  if (par->video_delay) {
1734  dts_heuristic = 1;
1735  break;
1736  }
1737  }
1738  if (dts_heuristic) {
1739  seek_timestamp -= 3*AV_TIME_BASE / 23;
1740  }
1741  }
1742  ret = avformat_seek_file(ic, -1, INT64_MIN, seek_timestamp, seek_timestamp, 0);
1743  if (ret < 0) {
1744  av_log(d, AV_LOG_WARNING, "could not seek to position %0.3f\n",
1745  (double)timestamp / AV_TIME_BASE);
1746  }
1747  }
1748 
1749  f->start_time = start_time;
1750  d->recording_time = recording_time;
1751  f->input_sync_ref = o->input_sync_ref;
1752  f->input_ts_offset = o->input_ts_offset;
1753  f->ts_offset = o->input_ts_offset - (copy_ts ? (start_at_zero && ic->start_time != AV_NOPTS_VALUE ? ic->start_time : 0) : timestamp);
1754  d->accurate_seek = o->accurate_seek;
1755  d->loop = o->loop;
1756  d->nb_streams_warn = ic->nb_streams;
1757 
1758  d->duration = (Timestamp){ .ts = 0, .tb = (AVRational){ 1, 1 } };
1759  d->min_pts = (Timestamp){ .ts = AV_NOPTS_VALUE, .tb = (AVRational){ 1, 1 } };
1760  d->max_pts = (Timestamp){ .ts = AV_NOPTS_VALUE, .tb = (AVRational){ 1, 1 } };
1761 
1762  d->readrate = o->readrate ? o->readrate : 0.0;
1763  if (d->readrate < 0.0f) {
1764  av_log(d, AV_LOG_ERROR, "Option -readrate is %0.3f; it must be non-negative.\n", d->readrate);
1765  return AVERROR(EINVAL);
1766  }
1767  if (o->rate_emu) {
1768  if (d->readrate) {
1769  av_log(d, AV_LOG_WARNING, "Both -readrate and -re set. Using -readrate %0.3f.\n", d->readrate);
1770  } else
1771  d->readrate = 1.0f;
1772  }
1773 
1774  if (d->readrate) {
1775  d->readrate_initial_burst = o->readrate_initial_burst ? o->readrate_initial_burst : 0.5;
1776  if (d->readrate_initial_burst < 0.0) {
1778  "Option -readrate_initial_burst is %0.3f; it must be non-negative.\n",
1779  d->readrate_initial_burst);
1780  return AVERROR(EINVAL);
1781  }
1782  } else if (o->readrate_initial_burst) {
1783  av_log(d, AV_LOG_WARNING, "Option -readrate_initial_burst ignored "
1784  "since neither -readrate nor -re were given\n");
1785  }
1786 
1787  /* Add all the streams from the given input file to the demuxer */
1788  for (int i = 0; i < ic->nb_streams; i++) {
1789  ret = ist_add(o, d, ic->streams[i]);
1790  if (ret < 0)
1791  return ret;
1792  }
1793 
1794  /* dump the file content */
1795  av_dump_format(ic, f->index, filename, 0);
1796 
1797  /* check if all codec options have been used */
1798  unused_opts = strip_specifiers(o->g->codec_opts);
1799  for (i = 0; i < f->nb_streams; i++) {
1800  DemuxStream *ds = ds_from_ist(f->streams[i]);
1801  e = NULL;
1802  while ((e = av_dict_iterate(ds->decoder_opts, e)))
1803  av_dict_set(&unused_opts, e->key, NULL, 0);
1804  }
1805 
1806  e = NULL;
1807  while ((e = av_dict_iterate(unused_opts, e))) {
1808  const AVClass *class = avcodec_get_class();
1809  const AVOption *option = av_opt_find(&class, e->key, NULL, 0,
1811  const AVClass *fclass = avformat_get_class();
1812  const AVOption *foption = av_opt_find(&fclass, e->key, NULL, 0,
1814  if (!option || foption)
1815  continue;
1816 
1817 
1818  if (!(option->flags & AV_OPT_FLAG_DECODING_PARAM)) {
1819  av_log(d, AV_LOG_ERROR, "Codec AVOption %s (%s) is not a decoding "
1820  "option.\n", e->key, option->help ? option->help : "");
1821  return AVERROR(EINVAL);
1822  }
1823 
1824  av_log(d, AV_LOG_WARNING, "Codec AVOption %s (%s) has not been used "
1825  "for any stream. The most likely reason is either wrong type "
1826  "(e.g. a video option with no video streams) or that it is a "
1827  "private option of some decoder which was not actually used "
1828  "for any stream.\n", e->key, option->help ? option->help : "");
1829  }
1830  av_dict_free(&unused_opts);
1831 
1832  for (i = 0; i < o->dump_attachment.nb_opt; i++) {
1833  int j;
1834 
1835  for (j = 0; j < f->nb_streams; j++) {
1836  InputStream *ist = f->streams[j];
1837 
1838  if (check_stream_specifier(ic, ist->st, o->dump_attachment.opt[i].specifier) == 1) {
1840  if (ret < 0)
1841  return ret;
1842  }
1843  }
1844  }
1845 
1846  return 0;
1847 }
OptionsContext::readrate
float readrate
Definition: ffmpeg.h:156
input_thread
static void * input_thread(void *arg)
Definition: ffmpeg_demux.c:676
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:109
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:427
AVCodec
AVCodec.
Definition: codec.h:187
OptionsContext::input_ts_offset
int64_t input_ts_offset
Definition: ffmpeg.h:153
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
DemuxStream::ist
InputStream ist
Definition: ffmpeg_demux.c:43
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
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:183
demux_final_stats
static void demux_final_stats(Demuxer *d)
Definition: ffmpeg_demux.c:784
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:41
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:126
opt.h
MATCH_PER_STREAM_OPT
#define MATCH_PER_STREAM_OPT(name, type, outvar, fmtctx, st)
Definition: ffmpeg.h:845
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:1160
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:616
ist_output_add
int ist_output_add(InputStream *ist, OutputStream *ost)
Definition: ffmpeg_demux.c:955
AVProgram::nb_stream_indexes
unsigned int nb_stream_indexes
Definition: avformat.h:1131
avio_close
int avio_close(AVIOContext *s)
Close the resource accessed by the AVIOContext s and free it.
Definition: aviobuf.c:1335
out
FILE * out
Definition: movenc.c:54
DecoderOpts
Definition: ffmpeg.h:322
is
The official guide to swscale for confused that is
Definition: swscale.txt:28
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:319
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:772
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:912
FrameData::dts_est
int64_t dts_est
Definition: ffmpeg.h:619
sch_add_demux
int sch_add_demux(Scheduler *sch, SchThreadFunc func, void *ctx)
Add a demuxer to the scheduler.
Definition: ffmpeg_sched.c:716
input_packet_process
static int input_packet_process(Demuxer *d, AVPacket *pkt, unsigned *send_flags)
Definition: ffmpeg_demux.c:441
demux_thread_init
static int demux_thread_init(DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:661
remove_avoptions
void remove_avoptions(AVDictionary **a, AVDictionary *b)
Definition: ffmpeg.c:452
InputStream::outputs
struct OutputStream ** outputs
Definition: ffmpeg.h:396
SCH_DSTREAM
#define SCH_DSTREAM(file, stream)
Definition: ffmpeg_sched.h:107
AVFMT_NOTIMESTAMPS
#define AVFMT_NOTIMESTAMPS
Format does not need / have any timestamps.
Definition: avformat.h:480
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:264
InputStream::user_set_discard
int user_set_discard
Definition: ffmpeg.h:365
DemuxStream::sch_idx_stream
int sch_idx_stream
Definition: ffmpeg_demux.c:48
avformat_get_class
const AVClass * avformat_get_class(void)
Get the AVClass for AVFormatContext.
Definition: options.c:206
OptionsContext::audio_ch_layouts
SpecifierOptList audio_ch_layouts
Definition: ffmpeg.h:144
ist_iter
InputStream * ist_iter(InputStream *prev)
Definition: ffmpeg.c:391
DemuxStream::finished
int finished
Definition: ffmpeg_demux.c:62
InputFile::index
int index
Definition: ffmpeg.h:403
pixdesc.h
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1270
DECODER_FLAG_FRAMERATE_FORCED
@ DECODER_FLAG_FRAMERATE_FORCED
Definition: ffmpeg.h:315
AVPacketSideData
This structure stores auxiliary information for decoding, presenting, or otherwise processing the cod...
Definition: packet.h:373
DecoderOpts::par
const AVCodecParameters * par
Definition: ffmpeg.h:329
ifile_close
void ifile_close(InputFile **pf)
Definition: ffmpeg_demux.c:847
DemuxStream::streamcopy_needed
int streamcopy_needed
Definition: ffmpeg_demux.c:64
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:343
AV_HWDEVICE_TYPE_NONE
@ AV_HWDEVICE_TYPE_NONE
Definition: hwcontext.h:28
OptionsContext::subtitle_disable
int subtitle_disable
Definition: ffmpeg.h:193
demux_stream_alloc
static DemuxStream * demux_stream_alloc(Demuxer *d, AVStream *st)
Definition: ffmpeg_demux.c:1167
AVOption
AVOption.
Definition: opt.h:251
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:930
DecoderOpts::hwaccel_id
enum HWAccelID hwaccel_id
Definition: ffmpeg.h:332
InputStream::nb_filters
int nb_filters
Definition: ffmpeg.h:389
AVCodecParameters::framerate
AVRational framerate
Video only.
Definition: codec_par.h:218
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:87
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:81
AVFormatContext::programs
AVProgram ** programs
Definition: avformat.h:1370
av_hwdevice_iterate_types
enum AVHWDeviceType av_hwdevice_iterate_types(enum AVHWDeviceType prev)
Iterate over supported device types.
Definition: hwcontext.c:106
OptionsContext::bitexact
int bitexact
Definition: ffmpeg.h:189
autorotate
static int autorotate
Definition: ffplay.c:351
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:540
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:318
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:1558
AVFormatContext::video_codec_id
enum AVCodecID video_codec_id
Forced video codec_id.
Definition: avformat.h:1376
IFILTER_FLAG_AUTOROTATE
@ IFILTER_FLAG_AUTOROTATE
Definition: ffmpeg.h:254
OptionsContext::format
const char * format
Definition: ffmpeg.h:141
AVChannelLayout::nb_channels
int nb_channels
Number of channels in this layout.
Definition: channel_layout.h:323
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:308
av_packet_free
void av_packet_free(AVPacket **pkt)
Free the packet, if the packet is reference counted, it will be unreferenced first.
Definition: avpacket.c:74
OptionsContext::frame_pix_fmts
SpecifierOptList frame_pix_fmts
Definition: ffmpeg.h:150
AVBSFContext
The bitstream filter state.
Definition: bsf.h:68
InputStream::nb_outputs
int nb_outputs
Definition: ffmpeg.h:397
Demuxer::wallclock_start
int64_t wallclock_start
Definition: ffmpeg_demux.c:99
SpecifierOpt::i
int i
Definition: cmdutils.h:109
InputStream
Definition: ffmpeg.h:356
DecoderOpts::hwaccel_output_format
enum AVPixelFormat hwaccel_output_format
Definition: ffmpeg.h:335
debug_ts
int debug_ts
Definition: ffmpeg_opt.c:76
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: demux.c:374
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1468
Demuxer
Definition: ffmpeg_demux.c:93
OptionsContext::rate_emu
int rate_emu
Definition: ffmpeg.h:155
dts_delta_threshold
float dts_delta_threshold
Definition: ffmpeg_opt.c:62
DemuxStream::data_size
uint64_t data_size
Definition: ffmpeg_demux.c:90
avio_open2
int avio_open2(AVIOContext **s, const char *url, int flags, const AVIOInterruptCB *int_cb, AVDictionary **options)
Create and initialize a AVIOContext for accessing the resource indicated by url.
Definition: aviobuf.c:1329
finish
static void finish(void)
Definition: movenc.c:342
bsf.h
AVFMT_SEEK_TO_PTS
#define AVFMT_SEEK_TO_PTS
Seeking is based on PTS.
Definition: avformat.h:504
OptionsContext::g
OptionGroup * g
Definition: ffmpeg.h:135
Demuxer::log_name
char log_name[32]
Definition: ffmpeg_demux.c:97
Decoder::frames_decoded
uint64_t frames_decoded
Definition: ffmpeg.h:351
Demuxer::nb_streams_finished
int nb_streams_finished
Definition: ffmpeg_demux.c:131
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:1129
DecoderOpts::log_parent
void * log_parent
Definition: ffmpeg.h:326
input_file_item_name
static const char * input_file_item_name(void *obj)
Definition: ffmpeg_demux.c:1479
AVDISCARD_NONE
@ AVDISCARD_NONE
discard nothing
Definition: defs.h:213
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:643
OptionsContext
Definition: ffmpeg.h:134
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:487
do_pkt_dump
int do_pkt_dump
Definition: ffmpeg_opt.c:72
Demuxer::ts_offset_discont
int64_t ts_offset_discont
Extra timestamp offset added by discontinuity handling.
Definition: ffmpeg_demux.c:104
AVRational::num
int num
Numerator.
Definition: rational.h:59
Demuxer::f
InputFile f
Definition: ffmpeg_demux.c:94
Decoder::samples_decoded
uint64_t samples_decoded
Definition: ffmpeg.h:352
InputFile
Definition: ffmpeg.h:400
DemuxStream::nb_packets
uint64_t nb_packets
Definition: ffmpeg_demux.c:88
Demuxer::nb_streams_used
int nb_streams_used
Definition: ffmpeg_demux.c:130
OptionsContext::recording_time
int64_t recording_time
Definition: ffmpeg.h:182
AV_CODEC_ID_DVB_SUBTITLE
@ AV_CODEC_ID_DVB_SUBTITLE
Definition: codec_id.h:553
LATENCY_PROBE_DEMUX
@ LATENCY_PROBE_DEMUX
Definition: ffmpeg.h:103
OptionsContext::audio_disable
int audio_disable
Definition: ffmpeg.h:192
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:988
avassert.h
pkt
AVPacket * pkt
Definition: movenc.c:59
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:1508
AVInputFormat
Definition: avformat.h:549
AV_PKT_FLAG_CORRUPT
#define AV_PKT_FLAG_CORRUPT
The packet content is corrupted.
Definition: packet.h:578
OptionGroup::codec_opts
AVDictionary * codec_opts
Definition: cmdutils.h:275
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:755
SpecifierOptList::nb_opt
int nb_opt
Definition: cmdutils.h:119
duration
int64_t duration
Definition: movenc.c:64
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:226
AVCodecParameters::frame_size
int frame_size
Audio only.
Definition: codec_par.h:182
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:847
HWACCEL_GENERIC
@ HWACCEL_GENERIC
Definition: ffmpeg.h:88
assert_file_overwrite
int assert_file_overwrite(const char *filename)
Definition: ffmpeg_opt.c:724
SpecifierOpt::specifier
char * specifier
stream/chapter/program/...
Definition: cmdutils.h:106
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:1670
s
#define s(width, name)
Definition: cbs_vp9.c:198
DemuxStream::first_dts
int64_t first_dts
Definition: ffmpeg_demux.c:71
Demuxer::readrate
float readrate
Definition: ffmpeg_demux.c:122
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:377
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1320
AVCodecParameters::sample_aspect_ratio
AVRational sample_aspect_ratio
Video only.
Definition: codec_par.h:131
AVFormatContext::nb_programs
unsigned int nb_programs
Definition: avformat.h:1369
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:554
AVFormatContext::iformat
const struct AVInputFormat * iformat
The input container format.
Definition: avformat.h:1214
AVDictionaryEntry::key
char * key
Definition: dict.h:90
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AVCodecParameters::width
int width
Video only.
Definition: codec_par.h:121
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:112
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:743
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:123
InputFilter
Definition: ffmpeg.h:279
DemuxStream::ts_scale
double ts_scale
Definition: ffmpeg_demux.c:51
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:637
setup_find_stream_info_opts
int setup_find_stream_info_opts(AVFormatContext *s, AVDictionary *codec_opts, AVDictionary ***dst)
Setup AVCodecContext options for avformat_find_stream_info().
Definition: cmdutils.c:1061
discard_unused_programs
static void discard_unused_programs(InputFile *ifile)
Definition: ffmpeg_demux.c:628
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:374
DemuxThreadContext
Definition: ffmpeg_demux.c:134
ist_add
static int ist_add(const OptionsContext *o, Demuxer *d, AVStream *st)
Definition: ffmpeg_demux.c:1192
ctx
AVFormatContext * ctx
Definition: movenc.c:48
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:388
demux_send
static int demux_send(Demuxer *d, DemuxThreadContext *dt, DemuxStream *ds, AVPacket *pkt, unsigned flags)
Definition: ffmpeg_demux.c:534
Demuxer::nb_streams_warn
int nb_streams_warn
Definition: ffmpeg_demux.c:120
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
DecoderOpts::hwaccel_device
char * hwaccel_device
Definition: ffmpeg.h:334
input_stream_item_name
static const char * input_stream_item_name(void *obj)
Definition: ffmpeg_demux.c:1153
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:97
OptionsContext::accurate_seek
int accurate_seek
Definition: ffmpeg.h:158
filter_codec_opts
int filter_codec_opts(const AVDictionary *opts, enum AVCodecID codec_id, AVFormatContext *s, AVStream *st, const AVCodec *codec, AVDictionary **dst)
Filter out options for given codec.
Definition: cmdutils.c:996
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:231
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
AVFormatContext::data_codec
const struct AVCodec * data_codec
Forced data codec.
Definition: avformat.h:1694
Demuxer::duration
Timestamp duration
Definition: ffmpeg_demux.c:114
DemuxThreadContext::pkt_demux
AVPacket * pkt_demux
Definition: ffmpeg_demux.c:136
AV_PIX_FMT_MEDIACODEC
@ AV_PIX_FMT_MEDIACODEC
hardware decoding through MediaCodec
Definition: pixfmt.h:320
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:1772
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:973
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:72
if
if(ret)
Definition: filter_design.txt:179
option
option
Definition: libkvazaar.c:320
AVCodecParserContext::repeat_pict
int repeat_pict
This field is used for proper frame duration computation in lavf.
Definition: avcodec.h:2799
OptionsContext::start_time
int64_t start_time
Definition: ffmpeg.h:138
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: defs.h:219
AVFormatContext
Format I/O context.
Definition: avformat.h:1202
DECODING_FOR_OST
#define DECODING_FOR_OST
Definition: ffmpeg_demux.c:55
AVFormatContext::audio_codec_id
enum AVCodecID audio_codec_id
Forced audio codec_id.
Definition: avformat.h:1382
OptionGroup::format_opts
AVDictionary * format_opts
Definition: cmdutils.h:276
opts
AVDictionary * opts
Definition: movenc.c:50
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:864
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:146
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
avcodec_get_class
const AVClass * avcodec_get_class(void)
Get the AVClass for AVCodecContext.
Definition: options.c:188
ist_use
static int ist_use(InputStream *ist, int decoding_needed)
Definition: ffmpeg_demux.c:869
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:880
NULL
#define NULL
Definition: coverity.c:32
Decoder::decode_errors
uint64_t decode_errors
Definition: ffmpeg.h:353
InputStream::top_field_first
int top_field_first
Definition: ffmpeg.h:379
InputStream::st
AVStream * st
Definition: ffmpeg.h:364
AV_DICT_MULTIKEY
#define AV_DICT_MULTIKEY
Allow to store several equal keys in the dictionary.
Definition: dict.h:84
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:145
InputFile::start_time_effective
int64_t start_time_effective
Effective format start time based on enabled streams.
Definition: ffmpeg.h:411
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
Demuxer::recording_time
int64_t recording_time
Definition: ffmpeg_demux.c:107
parseutils.h
AVProgram::stream_index
unsigned int * stream_index
Definition: avformat.h:1130
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:921
AV_ROUND_NEAR_INF
@ AV_ROUND_NEAR_INF
Round to nearest and halfway cases away from zero.
Definition: mathematics.h:135
OptionsContext::dump_attachment
SpecifierOptList dump_attachment
Definition: ffmpeg.h:164
InputStream::fix_sub_duration
int fix_sub_duration
Definition: ffmpeg.h:384
FrameData::wallclock
int64_t wallclock[LATENCY_PROBE_NB]
Definition: ffmpeg.h:633
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:312
DemuxThreadContext::pkt_bsf
AVPacket * pkt_bsf
Definition: ffmpeg_demux.c:138
InputFilterOptions
Definition: ffmpeg.h:259
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:129
AVCodecParameters::ch_layout
AVChannelLayout ch_layout
Audio only.
Definition: codec_par.h:206
OptionsContext::input_sync_ref
int input_sync_ref
Definition: ffmpeg.h:160
report_new_stream
static void report_new_stream(Demuxer *d, const AVPacket *pkt)
Definition: ffmpeg_demux.c:162
guess_input_channel_layout
static int guess_input_channel_layout(InputStream *ist, AVCodecParameters *par, int guess_layout_max)
Definition: ffmpeg_demux.c:1095
DECODER_FLAG_FIX_SUB_DURATION
@ DECODER_FLAG_FIX_SUB_DURATION
Definition: ffmpeg.h:310
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:171
Demuxer::sch
Scheduler * sch
Definition: ffmpeg_demux.c:125
choose_decoder
static int choose_decoder(const OptionsContext *o, AVFormatContext *s, AVStream *st, enum HWAccelID hwaccel_id, enum AVHWDeviceType hwaccel_device_type, const AVCodec **pcodec)
Definition: ffmpeg_demux.c:1049
find_codec
int find_codec(void *logctx, const char *name, enum AVMediaType type, int encoder, const AVCodec **codec)
Definition: ffmpeg_opt.c:691
AVFormatContext::audio_codec
const struct AVCodec * audio_codec
Forced audio codec.
Definition: avformat.h:1678
InputStream::par
AVCodecParameters * par
Codec parameters - to be used by the decoding/streamcopy code.
Definition: ffmpeg.h:372
input_files
InputFile ** input_files
Definition: ffmpeg.c:125
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:571
error.h
Scheduler
Definition: ffmpeg_sched.c:259
avcodec_find_decoder
const AVCodec * avcodec_find_decoder(enum AVCodecID id)
Find a registered decoder with a matching codec ID.
Definition: allcodecs.c:981
recast_media
int recast_media
Definition: ffmpeg_opt.c:96
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:1258
DemuxStream::dts
int64_t dts
Definition: ffmpeg_demux.c:77
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:2532
IFILTER_FLAG_REINIT
@ IFILTER_FLAG_REINIT
Definition: ffmpeg.h:255
f
f
Definition: af_crystalizer.c:121
AVIOContext
Bytestream IO Context.
Definition: avio.h:166
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:76
seek_to_start
static int seek_to_start(Demuxer *d, Timestamp end_pts)
Definition: ffmpeg_demux.c:175
AVMediaType
AVMediaType
Definition: avutil.h:199
AVPacket::size
int size
Definition: packet.h:523
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:167
AVDISCARD_DEFAULT
@ AVDISCARD_DEFAULT
discard useless packets like 0 size packets in avi
Definition: defs.h:214
FFMPEG_OPT_TOP
#define FFMPEG_OPT_TOP
Definition: ffmpeg.h:61
DemuxStream::have_sub2video
int have_sub2video
Definition: ffmpeg_demux.c:65
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:121
start_time
static int64_t start_time
Definition: ffplay.c:329
Demuxer::pkt_heartbeat
AVPacket * pkt_heartbeat
Definition: ffmpeg_demux.c:127
DemuxStream::decoding_needed
int decoding_needed
Definition: ffmpeg_demux.c:54
demux_thread_uninit
static void demux_thread_uninit(DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:653
copy_ts
int copy_ts
Definition: ffmpeg_opt.c:73
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:662
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
check_avoptions
int check_avoptions(AVDictionary *m)
Definition: ffmpeg.c:461
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:140
input_file_class
static const AVClass input_file_class
Definition: ffmpeg_demux.c:1486
DECODING_FOR_FILTER
#define DECODING_FOR_FILTER
Definition: ffmpeg_demux.c:56
AVMEDIA_TYPE_UNKNOWN
@ AVMEDIA_TYPE_UNKNOWN
Usually treated as AVMEDIA_TYPE_DATA.
Definition: avutil.h:200
DemuxStream::bsf
AVBSFContext * bsf
Definition: ffmpeg_demux.c:85
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:919
OptionsContext::readrate_initial_burst
double readrate_initial_burst
Definition: ffmpeg.h:157
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:1110
AV_OPT_SEARCH_CHILDREN
#define AV_OPT_SEARCH_CHILDREN
Search in possible children of the given object first.
Definition: opt.h:563
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:521
avio_write
void avio_write(AVIOContext *s, const unsigned char *buf, int size)
Definition: aviobuf.c:248
OptionsContext::find_stream_info
int find_stream_info
Definition: ffmpeg.h:161
DemuxStream::sch_idx_dec
int sch_idx_dec
Definition: ffmpeg_demux.c:49
strip_specifiers
AVDictionary * strip_specifiers(const AVDictionary *dict)
Definition: ffmpeg_opt.c:166
SpecifierOptList::opt
SpecifierOpt * opt
Definition: cmdutils.h:118
SCH_DEC
#define SCH_DEC(decoder)
Definition: ffmpeg_sched.h:113
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
AVPacket::flags
int flags
A combination of AV_PKT_FLAG values.
Definition: packet.h:528
av_packet_alloc
AVPacket * av_packet_alloc(void)
Allocate an AVPacket and set its fields to default values.
Definition: avpacket.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:225
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: avpacket.c:531
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:344
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:75
AVCodec::id
enum AVCodecID id
Definition: codec.h:201
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:1033
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:417
HWACCEL_AUTO
@ HWACCEL_AUTO
Definition: ffmpeg.h:87
DemuxStream
Definition: ffmpeg_demux.c:42
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
DemuxStream::dec_name
char dec_name[16]
Definition: ffmpeg_demux.c:83
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:245
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:515
OptionsContext::frame_rates
SpecifierOptList frame_rates
Definition: ffmpeg.h:147
OptionsContext::codec_names
SpecifierOptList codec_names
Definition: ffmpeg.h:143
packet.h
demux_bsf_flush
static int demux_bsf_flush(Demuxer *d, DemuxThreadContext *dt)
Definition: ffmpeg_demux.c:603
AVFormatContext::subtitle_codec
const struct AVCodec * subtitle_codec
Forced subtitle codec.
Definition: avformat.h:1686
dec_open
int dec_open(Decoder **pdec, Scheduler *sch, AVDictionary **dec_opts, const DecoderOpts *o)
Definition: ffmpeg_dec.c:1062
AVCodecParameters::height
int height
Definition: codec_par.h:122
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:337
SHOW_TS_DEBUG
#define SHOW_TS_DEBUG(tag_)
OptionsContext::start_time_eof
int64_t start_time_eof
Definition: ffmpeg.h:139
display.h
exit_on_error
int exit_on_error
Definition: ffmpeg_opt.c:77
Demuxer::have_audio_dec
int have_audio_dec
Definition: ffmpeg_demux.c:112
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
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:282
InputFile::ctx
AVFormatContext * ctx
Definition: ffmpeg.h:405
FFMIN
#define FFMIN(a, b)
Definition: macros.h:49
AVProgram
New fields can be added to the end with minor version bumps.
Definition: avformat.h:1126
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:324
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:226
DemuxStream::discard
int discard
Definition: ffmpeg_demux.c:59
AVFMT_FLAG_NONBLOCK
#define AVFMT_FLAG_NONBLOCK
Do not block when reading packets from input.
Definition: avformat.h:1323
av_codec_iterate
const AVCodec * av_codec_iterate(void **opaque)
Iterate over all registered codecs.
Definition: allcodecs.c:932
sch_connect
int sch_connect(Scheduler *sch, SchedulerNode src, SchedulerNode dst)
Definition: ffmpeg_sched.c:933
ist_find_unused
InputStream * ist_find_unused(enum AVMediaType type)
Find an unused input stream of given type.
Definition: ffmpeg_demux.c:151
Timestamp::tb
AVRational tb
Definition: ffmpeg_utils.h:32
InputStream::decoder
Decoder * decoder
Definition: ffmpeg.h:373
AVStream::disposition
int disposition
Stream disposition - a combination of AV_DISPOSITION_* flags.
Definition: avformat.h:910
DemuxStream::codec_desc
const AVCodecDescriptor * codec_desc
Definition: ffmpeg_demux.c:79
ts_discontinuity_process
static void ts_discontinuity_process(Demuxer *d, InputStream *ist, AVPacket *pkt)
Definition: ffmpeg_demux.c:270
tag
uint32_t tag
Definition: movenc.c:1786
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:853
AVFMT_FLAG_BITEXACT
#define AVFMT_FLAG_BITEXACT
When muxing, try to avoid writing any random/volatile data to the output.
Definition: avformat.h:1337
ret
ret
Definition: filter_design.txt:187
AVStream
Stream structure.
Definition: avformat.h:841
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:90
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:727
DemuxStream::wrap_correction_done
int wrap_correction_done
Definition: ffmpeg_demux.c:68
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
Demuxer::loop
int loop
Definition: ffmpeg_demux.c:111
InputFile::streams
InputStream ** streams
Definition: ffmpeg.h:419
add_display_matrix_to_stream
static int add_display_matrix_to_stream(const OptionsContext *o, AVFormatContext *ctx, InputStream *ist)
Definition: ffmpeg_demux.c:1112
hwaccel
static const char * hwaccel
Definition: ffplay.c:356
DECODER_FLAG_TOP_FIELD_FIRST
@ DECODER_FLAG_TOP_FIELD_FIRST
Definition: ffmpeg.h:317
Demuxer::accurate_seek
int accurate_seek
Definition: ffmpeg_demux.c:108
avformat.h
HWAccelID
HWAccelID
Definition: ffmpeg.h:85
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: avpacket.c:704
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:2900
AVFormatContext::data_codec_id
enum AVCodecID data_codec_id
Forced Data codec_id.
Definition: avformat.h:1732
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
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:847
OptionsContext::audio_sample_rate
SpecifierOptList audio_sample_rate
Definition: ffmpeg.h:146
audio_codec_name
static const char * audio_codec_name
Definition: ffplay.c:342
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:1801
ts_discontinuity_detect
static void ts_discontinuity_detect(Demuxer *d, InputStream *ist, AVPacket *pkt)
Definition: ffmpeg_demux.c:202
PKT_OPAQUE_SUB_HEARTBEAT
@ PKT_OPAQUE_SUB_HEARTBEAT
Definition: ffmpeg.h:98
AVInputFormat::flags
int flags
Can use flags: AVFMT_NOFILE, AVFMT_NEEDNUMBER, AVFMT_SHOW_IDS, AVFMT_NOTIMESTAMPS,...
Definition: avformat.h:568
AVRational::den
int den
Denominator.
Definition: rational.h:60
InputStream::file
struct InputFile * file
Definition: ffmpeg.h:360
SpecifierOpt::str
uint8_t * str
Definition: cmdutils.h:108
AV_PIX_FMT_NONE
@ AV_PIX_FMT_NONE
Definition: pixfmt.h:72
avformat_free_context
void avformat_free_context(AVFormatContext *s)
Free an AVFormatContext and all its streams.
Definition: avformat.c:128
IFILTER_FLAG_CFR
@ IFILTER_FLAG_CFR
Definition: ffmpeg.h:256
OptionsContext::frame_sizes
SpecifierOptList frame_sizes
Definition: ffmpeg.h:149
OptionsContext::video_disable
int video_disable
Definition: ffmpeg.h:191
ds_from_ist
static DemuxStream * ds_from_ist(InputStream *ist)
Definition: ffmpeg_demux.c:141
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:1493
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1304
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:524
GROW_ARRAY
#define GROW_ARRAY(array, nb_elems)
Definition: cmdutils.h:459
HWACCEL_NONE
@ HWACCEL_NONE
Definition: ffmpeg.h:86
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:859
ist_dts_update
static int ist_dts_update(DemuxStream *ds, AVPacket *pkt, FrameData *fd)
Definition: ffmpeg_demux.c:290
InputFile::ts_offset
int64_t ts_offset
Definition: ffmpeg.h:412
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:169
DecoderOpts::flags
int flags
Definition: ffmpeg.h:323
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:270
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:74
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:482
SpecifierOpt::u
union SpecifierOpt::@0 u
DECODER_FLAG_TS_UNRELIABLE
@ DECODER_FLAG_TS_UNRELIABLE
Definition: ffmpeg.h:312
AVCodecParameters::video_delay
int video_delay
Video only.
Definition: codec_par.h:150
DemuxStream::log_name
char log_name[32]
Definition: ffmpeg_demux.c:46
DecoderOpts::codec
const AVCodec * codec
Definition: ffmpeg.h:328
InputStream::class
const AVClass * class
Definition: ffmpeg.h:357
InputStream::index
int index
Definition: ffmpeg.h:362
readrate_sleep
static void readrate_sleep(Demuxer *d)
Definition: ffmpeg_demux.c:485
ffmpeg_sched.h
AVDictionaryEntry
Definition: dict.h:89
Demuxer::max_pts
Timestamp max_pts
Definition: ffmpeg_demux.c:117
DemuxStream::dec_opts
DecoderOpts dec_opts
Definition: ffmpeg_demux.c:82
stdin_interaction
int stdin_interaction
Definition: ffmpeg_opt.c:80
do_hex_dump
int do_hex_dump
Definition: ffmpeg_opt.c:71
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
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:499
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:542
packet_data
FrameData * packet_data(AVPacket *pkt)
Definition: ffmpeg.c:440
OptionsContext::data_disable
int data_disable
Definition: ffmpeg.h:194
d
d
Definition: ffmpeg_filter.c:424
int32_t
int32_t
Definition: audioconvert.c:56
ist_free
static void ist_free(InputStream **pist)
Definition: ffmpeg_demux.c:824
DemuxStream::reinit_filters
int reinit_filters
Definition: ffmpeg_demux.c:66
timestamp.h
OutputStream
Definition: mux.c:53
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:474
Demuxer::min_pts
Timestamp min_pts
Definition: ffmpeg_demux.c:116
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:350
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:1294
DecoderOpts::framerate
AVRational framerate
Definition: ffmpeg.h:341
dts_error_threshold
float dts_error_threshold
Definition: ffmpeg_opt.c:63
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:341
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:119
avcodec_descriptor_get
const AVCodecDescriptor * avcodec_descriptor_get(enum AVCodecID id)
Definition: codec_desc.c:3736
do_send
static int do_send(Demuxer *d, DemuxStream *ds, AVPacket *pkt, unsigned flags, const char *pkt_desc)
Definition: ffmpeg_demux.c:505
Demuxer::last_ts
int64_t last_ts
Definition: ffmpeg_demux.c:105
AVDictionaryEntry::value
char * value
Definition: dict.h:91
avstring.h
dec_add_filter
int dec_add_filter(Decoder *dec, InputFilter *ifilter)
Definition: ffmpeg_dec.c:1167
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:183
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:69
AVStream::pts_wrap_bits
int pts_wrap_bits
Number of bits in timestamps.
Definition: avformat.h:1016
dump_attachment
static int dump_attachment(InputStream *ist, const char *filename)
Definition: ffmpeg_demux.c:1441
AVERROR_PROTOCOL_NOT_FOUND
#define AVERROR_PROTOCOL_NOT_FOUND
Protocol not found.
Definition: error.h:65
InputStream::dec
const AVCodec * dec
Definition: ffmpeg.h:374
snprintf
#define snprintf
Definition: snprintf.h:34
DecoderOpts::hwaccel_device_type
enum AVHWDeviceType hwaccel_device_type
Definition: ffmpeg.h:333
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
av_dict_iterate
const AVDictionaryEntry * av_dict_iterate(const AVDictionary *m, const AVDictionaryEntry *prev)
Iterate over a dictionary.
Definition: dict.c:44
AVInputFormat::priv_class
const AVClass * priv_class
AVClass for the private context.
Definition: avformat.h:579
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:566
OptionsContext::loop
int loop
Definition: ffmpeg.h:154
InputStream::autorotate
int autorotate
Definition: ffmpeg.h:382
thread_set_name
static void thread_set_name(InputFile *f)
Definition: ffmpeg_demux.c:646
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:1388
DecoderOpts::name
char * name
Definition: ffmpeg.h:325