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