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