FFmpeg
concatdec.c
Go to the documentation of this file.
1 /*
2  * Copyright (c) 2012 Nicolas George
3  *
4  * This file is part of FFmpeg.
5  *
6  * FFmpeg is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public License
8  * as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * FFmpeg is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14  * GNU Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public License
17  * along with FFmpeg; if not, write to the Free Software Foundation, Inc.,
18  * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19  */
20 
21 #include "libavutil/avstring.h"
22 #include "libavutil/bprint.h"
23 #include "libavutil/intreadwrite.h"
24 #include "libavutil/opt.h"
25 #include "libavutil/parseutils.h"
26 #include "libavutil/timestamp.h"
27 #include "libavcodec/bsf.h"
28 #include "avformat.h"
29 #include "avio_internal.h"
30 #include "internal.h"
31 #include "url.h"
32 
33 typedef enum ConcatMatchMode {
37 
38 typedef struct ConcatStream {
41 } ConcatStream;
42 
43 typedef struct {
44  char *url;
45  int64_t start_time;
46  int64_t file_start_time;
47  int64_t file_inpoint;
48  int64_t duration;
49  int64_t user_duration;
50  int64_t next_dts;
52  int64_t inpoint;
53  int64_t outpoint;
56 } ConcatFile;
57 
58 typedef struct {
59  AVClass *class;
62  unsigned nb_files;
64  int safe;
65  int seekable;
66  int eof;
68  unsigned auto_convert;
71 
72 static int concat_probe(const AVProbeData *probe)
73 {
74  return memcmp(probe->buf, "ffconcat version 1.0", 20) ?
76 }
77 
78 static char *get_keyword(uint8_t **cursor)
79 {
80  char *ret = *cursor += strspn(*cursor, SPACE_CHARS);
81  *cursor += strcspn(*cursor, SPACE_CHARS);
82  if (**cursor) {
83  *((*cursor)++) = 0;
84  *cursor += strspn(*cursor, SPACE_CHARS);
85  }
86  return ret;
87 }
88 
89 static int safe_filename(const char *f)
90 {
91  const char *start = f;
92 
93  for (; *f; f++) {
94  /* A-Za-z0-9_- */
95  if (!((unsigned)((*f | 32) - 'a') < 26 ||
96  (unsigned)(*f - '0') < 10 || *f == '_' || *f == '-')) {
97  if (f == start)
98  return 0;
99  else if (*f == '/')
100  start = f + 1;
101  else if (*f != '.')
102  return 0;
103  }
104  }
105  return 1;
106 }
107 
108 #define FAIL(retcode) do { ret = (retcode); goto fail; } while(0)
109 
110 static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile,
111  unsigned *nb_files_alloc)
112 {
113  ConcatContext *cat = avf->priv_data;
114  ConcatFile *file;
115  char *url = NULL;
116  const char *proto;
117  const char *ptr;
118  size_t url_len;
119  int ret;
120 
121  if (cat->safe > 0 && !safe_filename(filename)) {
122  av_log(avf, AV_LOG_ERROR, "Unsafe file name '%s'\n", filename);
123  FAIL(AVERROR(EPERM));
124  }
125 
126  proto = avio_find_protocol_name(filename);
127  if (proto && av_strstart(filename, proto, &ptr) &&
128  (*ptr == ':' || *ptr == ',')) {
129  url = filename;
130  filename = NULL;
131  } else {
132  url_len = strlen(avf->url) + strlen(filename) + 16;
133  if (!(url = av_malloc(url_len)))
134  FAIL(AVERROR(ENOMEM));
135  ff_make_absolute_url(url, url_len, avf->url, filename);
136  av_freep(&filename);
137  }
138 
139  if (cat->nb_files >= *nb_files_alloc) {
140  size_t n = FFMAX(*nb_files_alloc * 2, 16);
141  ConcatFile *new_files;
142  if (n <= cat->nb_files || n > SIZE_MAX / sizeof(*cat->files) ||
143  !(new_files = av_realloc(cat->files, n * sizeof(*cat->files))))
144  FAIL(AVERROR(ENOMEM));
145  cat->files = new_files;
146  *nb_files_alloc = n;
147  }
148 
149  file = &cat->files[cat->nb_files++];
150  memset(file, 0, sizeof(*file));
151  *rfile = file;
152 
153  file->url = url;
154  file->start_time = AV_NOPTS_VALUE;
155  file->duration = AV_NOPTS_VALUE;
156  file->next_dts = AV_NOPTS_VALUE;
157  file->inpoint = AV_NOPTS_VALUE;
158  file->outpoint = AV_NOPTS_VALUE;
160 
161  return 0;
162 
163 fail:
164  av_free(url);
165  av_free(filename);
166  return ret;
167 }
168 
169 static int copy_stream_props(AVStream *st, AVStream *source_st)
170 {
171  int ret;
172 
173  if (st->codecpar->codec_id || !source_st->codecpar->codec_id) {
174  if (st->codecpar->extradata_size < source_st->codecpar->extradata_size) {
176  source_st->codecpar->extradata_size);
177  if (ret < 0)
178  return ret;
179  }
180  memcpy(st->codecpar->extradata, source_st->codecpar->extradata,
181  source_st->codecpar->extradata_size);
182  return 0;
183  }
184  if ((ret = avcodec_parameters_copy(st->codecpar, source_st->codecpar)) < 0)
185  return ret;
186  st->r_frame_rate = source_st->r_frame_rate;
187  st->avg_frame_rate = source_st->avg_frame_rate;
188  st->sample_aspect_ratio = source_st->sample_aspect_ratio;
189  avpriv_set_pts_info(st, 64, source_st->time_base.num, source_st->time_base.den);
190 
191  av_dict_copy(&st->metadata, source_st->metadata, 0);
192  return 0;
193 }
194 
195 static int detect_stream_specific(AVFormatContext *avf, int idx)
196 {
197  ConcatContext *cat = avf->priv_data;
198  AVStream *st = cat->avf->streams[idx];
199  ConcatStream *cs = &cat->cur_file->streams[idx];
200  const AVBitStreamFilter *filter;
201  AVBSFContext *bsf;
202  int ret;
203 
204  if (cat->auto_convert && st->codecpar->codec_id == AV_CODEC_ID_H264) {
205  if (!st->codecpar->extradata_size ||
206  (st->codecpar->extradata_size >= 3 && AV_RB24(st->codecpar->extradata) == 1) ||
207  (st->codecpar->extradata_size >= 4 && AV_RB32(st->codecpar->extradata) == 1))
208  return 0;
209  av_log(cat->avf, AV_LOG_INFO,
210  "Auto-inserting h264_mp4toannexb bitstream filter\n");
211  filter = av_bsf_get_by_name("h264_mp4toannexb");
212  if (!filter) {
213  av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb bitstream filter "
214  "required for H.264 streams\n");
215  return AVERROR_BSF_NOT_FOUND;
216  }
217  ret = av_bsf_alloc(filter, &bsf);
218  if (ret < 0)
219  return ret;
220  cs->bsf = bsf;
221 
223  if (ret < 0)
224  return ret;
225 
226  ret = av_bsf_init(bsf);
227  if (ret < 0)
228  return ret;
229 
231  if (ret < 0)
232  return ret;
233  }
234  return 0;
235 }
236 
238 {
239  ConcatContext *cat = avf->priv_data;
240  AVStream *st;
241  int i, ret;
242 
243  for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
244  if (i < avf->nb_streams) {
245  st = avf->streams[i];
246  } else {
247  if (!(st = avformat_new_stream(avf, NULL)))
248  return AVERROR(ENOMEM);
249  }
250  if ((ret = copy_stream_props(st, cat->avf->streams[i])) < 0)
251  return ret;
252  cat->cur_file->streams[i].out_stream_index = i;
253  }
254  return 0;
255 }
256 
258 {
259  ConcatContext *cat = avf->priv_data;
260  AVStream *st;
261  int i, j, ret;
262 
263  for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
264  st = cat->avf->streams[i];
265  for (j = 0; j < avf->nb_streams; j++) {
266  if (avf->streams[j]->id == st->id) {
267  av_log(avf, AV_LOG_VERBOSE,
268  "Match slave stream #%d with stream #%d id 0x%x\n",
269  i, j, st->id);
270  if ((ret = copy_stream_props(avf->streams[j], st)) < 0)
271  return ret;
272  cat->cur_file->streams[i].out_stream_index = j;
273  }
274  }
275  }
276  return 0;
277 }
278 
280 {
281  ConcatContext *cat = avf->priv_data;
282  ConcatStream *map;
283  int i, ret;
284 
285  if (cat->cur_file->nb_streams >= cat->avf->nb_streams)
286  return 0;
287  map = av_realloc(cat->cur_file->streams,
288  cat->avf->nb_streams * sizeof(*map));
289  if (!map)
290  return AVERROR(ENOMEM);
291  cat->cur_file->streams = map;
292  memset(map + cat->cur_file->nb_streams, 0,
293  (cat->avf->nb_streams - cat->cur_file->nb_streams) * sizeof(*map));
294 
295  for (i = cat->cur_file->nb_streams; i < cat->avf->nb_streams; i++) {
296  map[i].out_stream_index = -1;
297  if ((ret = detect_stream_specific(avf, i)) < 0)
298  return ret;
299  }
300  switch (cat->stream_match_mode) {
301  case MATCH_ONE_TO_ONE:
303  break;
304  case MATCH_EXACT_ID:
306  break;
307  default:
308  ret = AVERROR_BUG;
309  }
310  if (ret < 0)
311  return ret;
312  cat->cur_file->nb_streams = cat->avf->nb_streams;
313  return 0;
314 }
315 
317 {
318  if (file->user_duration != AV_NOPTS_VALUE)
319  return file->user_duration;
320  if (file->outpoint != AV_NOPTS_VALUE)
321  return file->outpoint - file->file_inpoint;
322  if (avf->duration > 0)
323  return avf->duration - (file->file_inpoint - file->file_start_time);
324  if (file->next_dts != AV_NOPTS_VALUE)
325  return file->next_dts - file->file_inpoint;
326  return AV_NOPTS_VALUE;
327 }
328 
329 static int open_file(AVFormatContext *avf, unsigned fileno)
330 {
331  ConcatContext *cat = avf->priv_data;
332  ConcatFile *file = &cat->files[fileno];
333  int ret;
334 
335  if (cat->avf)
336  avformat_close_input(&cat->avf);
337 
338  cat->avf = avformat_alloc_context();
339  if (!cat->avf)
340  return AVERROR(ENOMEM);
341 
342  cat->avf->flags |= avf->flags & ~AVFMT_FLAG_CUSTOM_IO;
343  cat->avf->interrupt_callback = avf->interrupt_callback;
344 
345  if ((ret = ff_copy_whiteblacklists(cat->avf, avf)) < 0)
346  return ret;
347 
348  if ((ret = avformat_open_input(&cat->avf, file->url, NULL, NULL)) < 0 ||
349  (ret = avformat_find_stream_info(cat->avf, NULL)) < 0) {
350  av_log(avf, AV_LOG_ERROR, "Impossible to open '%s'\n", file->url);
351  avformat_close_input(&cat->avf);
352  return ret;
353  }
354  cat->cur_file = file;
355  file->start_time = !fileno ? 0 :
356  cat->files[fileno - 1].start_time +
357  cat->files[fileno - 1].duration;
358  file->file_start_time = (cat->avf->start_time == AV_NOPTS_VALUE) ? 0 : cat->avf->start_time;
359  file->file_inpoint = (file->inpoint == AV_NOPTS_VALUE) ? file->file_start_time : file->inpoint;
360  file->duration = get_best_effort_duration(file, cat->avf);
361 
362  if (cat->segment_time_metadata) {
363  av_dict_set_int(&file->metadata, "lavf.concatdec.start_time", file->start_time, 0);
364  if (file->duration != AV_NOPTS_VALUE)
365  av_dict_set_int(&file->metadata, "lavf.concatdec.duration", file->duration, 0);
366  }
367 
368  if ((ret = match_streams(avf)) < 0)
369  return ret;
370  if (file->inpoint != AV_NOPTS_VALUE) {
371  if ((ret = avformat_seek_file(cat->avf, -1, INT64_MIN, file->inpoint, file->inpoint, 0)) < 0)
372  return ret;
373  }
374  return 0;
375 }
376 
378 {
379  ConcatContext *cat = avf->priv_data;
380  unsigned i, j;
381 
382  for (i = 0; i < cat->nb_files; i++) {
383  av_freep(&cat->files[i].url);
384  for (j = 0; j < cat->files[i].nb_streams; j++) {
385  if (cat->files[i].streams[j].bsf)
386  av_bsf_free(&cat->files[i].streams[j].bsf);
387  }
388  av_freep(&cat->files[i].streams);
389  av_dict_free(&cat->files[i].metadata);
390  }
391  if (cat->avf)
392  avformat_close_input(&cat->avf);
393  av_freep(&cat->files);
394  return 0;
395 }
396 
398 {
399  ConcatContext *cat = avf->priv_data;
400  AVBPrint bp;
401  uint8_t *cursor, *keyword;
402  int line = 0, i;
403  unsigned nb_files_alloc = 0;
404  ConcatFile *file = NULL;
405  int64_t ret, time = 0;
406 
408 
409  while ((ret = ff_read_line_to_bprint_overwrite(avf->pb, &bp)) >= 0) {
410  line++;
411  cursor = bp.str;
412  keyword = get_keyword(&cursor);
413  if (!*keyword || *keyword == '#')
414  continue;
415 
416  if (!strcmp(keyword, "file")) {
417  char *filename = av_get_token((const char **)&cursor, SPACE_CHARS);
418  if (!filename) {
419  av_log(avf, AV_LOG_ERROR, "Line %d: filename required\n", line);
421  }
422  if ((ret = add_file(avf, filename, &file, &nb_files_alloc)) < 0)
423  goto fail;
424  } else if (!strcmp(keyword, "duration") || !strcmp(keyword, "inpoint") || !strcmp(keyword, "outpoint")) {
425  char *dur_str = get_keyword(&cursor);
426  int64_t dur;
427  if (!file) {
428  av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",
429  line, keyword);
431  }
432  if ((ret = av_parse_time(&dur, dur_str, 1)) < 0) {
433  av_log(avf, AV_LOG_ERROR, "Line %d: invalid %s '%s'\n",
434  line, keyword, dur_str);
435  goto fail;
436  }
437  if (!strcmp(keyword, "duration"))
438  file->user_duration = dur;
439  else if (!strcmp(keyword, "inpoint"))
440  file->inpoint = dur;
441  else if (!strcmp(keyword, "outpoint"))
442  file->outpoint = dur;
443  } else if (!strcmp(keyword, "file_packet_metadata")) {
444  char *metadata;
445  if (!file) {
446  av_log(avf, AV_LOG_ERROR, "Line %d: %s without file\n",
447  line, keyword);
449  }
450  metadata = av_get_token((const char **)&cursor, SPACE_CHARS);
451  if (!metadata) {
452  av_log(avf, AV_LOG_ERROR, "Line %d: packet metadata required\n", line);
454  }
455  if ((ret = av_dict_parse_string(&file->metadata, metadata, "=", "", 0)) < 0) {
456  av_log(avf, AV_LOG_ERROR, "Line %d: failed to parse metadata string\n", line);
457  av_freep(&metadata);
459  }
460  av_freep(&metadata);
461  } else if (!strcmp(keyword, "stream")) {
462  if (!avformat_new_stream(avf, NULL))
463  FAIL(AVERROR(ENOMEM));
464  } else if (!strcmp(keyword, "exact_stream_id")) {
465  if (!avf->nb_streams) {
466  av_log(avf, AV_LOG_ERROR, "Line %d: exact_stream_id without stream\n",
467  line);
469  }
470  avf->streams[avf->nb_streams - 1]->id =
471  strtol(get_keyword(&cursor), NULL, 0);
472  } else if (!strcmp(keyword, "ffconcat")) {
473  char *ver_kw = get_keyword(&cursor);
474  char *ver_val = get_keyword(&cursor);
475  if (strcmp(ver_kw, "version") || strcmp(ver_val, "1.0")) {
476  av_log(avf, AV_LOG_ERROR, "Line %d: invalid version\n", line);
478  }
479  if (cat->safe < 0)
480  cat->safe = 1;
481  } else {
482  av_log(avf, AV_LOG_ERROR, "Line %d: unknown keyword '%s'\n",
483  line, keyword);
485  }
486  }
487  if (ret != AVERROR_EOF && ret < 0)
488  goto fail;
489  if (!cat->nb_files)
491 
492  for (i = 0; i < cat->nb_files; i++) {
493  if (cat->files[i].start_time == AV_NOPTS_VALUE)
494  cat->files[i].start_time = time;
495  else
496  time = cat->files[i].start_time;
497  if (cat->files[i].user_duration == AV_NOPTS_VALUE) {
498  if (cat->files[i].inpoint == AV_NOPTS_VALUE || cat->files[i].outpoint == AV_NOPTS_VALUE)
499  break;
500  cat->files[i].user_duration = cat->files[i].outpoint - cat->files[i].inpoint;
501  }
502  cat->files[i].duration = cat->files[i].user_duration;
503  time += cat->files[i].user_duration;
504  }
505  if (i == cat->nb_files) {
506  avf->duration = time;
507  cat->seekable = 1;
508  }
509 
510  cat->stream_match_mode = avf->nb_streams ? MATCH_EXACT_ID :
512  if ((ret = open_file(avf, 0)) < 0)
513  goto fail;
514 
515 fail:
516  av_bprint_finalize(&bp, NULL);
517  return ret;
518 }
519 
521 {
522  ConcatContext *cat = avf->priv_data;
523  unsigned fileno = cat->cur_file - cat->files;
524 
525  cat->cur_file->duration = get_best_effort_duration(cat->cur_file, cat->avf);
526 
527  if (++fileno >= cat->nb_files) {
528  cat->eof = 1;
529  return AVERROR_EOF;
530  }
531  return open_file(avf, fileno);
532 }
533 
535 {
536  int ret;
537 
538  if (cs->bsf) {
539  ret = av_bsf_send_packet(cs->bsf, pkt);
540  if (ret < 0) {
541  av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "
542  "failed to send input packet\n");
543  return ret;
544  }
545 
546  while (!ret)
548 
549  if (ret < 0 && (ret != AVERROR(EAGAIN) && ret != AVERROR_EOF)) {
550  av_log(avf, AV_LOG_ERROR, "h264_mp4toannexb filter "
551  "failed to receive output packet\n");
552  return ret;
553  }
554  }
555  return 0;
556 }
557 
558 /* Returns true if the packet dts is greater or equal to the specified outpoint. */
560 {
561  if (cat->cur_file->outpoint != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE) {
562  return av_compare_ts(pkt->dts, cat->avf->streams[pkt->stream_index]->time_base,
563  cat->cur_file->outpoint, AV_TIME_BASE_Q) >= 0;
564  }
565  return 0;
566 }
567 
569 {
570  ConcatContext *cat = avf->priv_data;
571  int ret;
572  int64_t delta;
573  ConcatStream *cs;
574  AVStream *st;
575 
576  if (cat->eof)
577  return AVERROR_EOF;
578 
579  if (!cat->avf)
580  return AVERROR(EIO);
581 
582  while (1) {
583  ret = av_read_frame(cat->avf, pkt);
584  if (ret == AVERROR_EOF) {
585  if ((ret = open_next_file(avf)) < 0)
586  return ret;
587  continue;
588  }
589  if (ret < 0)
590  return ret;
591  if ((ret = match_streams(avf)) < 0) {
592  return ret;
593  }
594  if (packet_after_outpoint(cat, pkt)) {
596  if ((ret = open_next_file(avf)) < 0)
597  return ret;
598  continue;
599  }
600  cs = &cat->cur_file->streams[pkt->stream_index];
601  if (cs->out_stream_index < 0) {
603  continue;
604  }
605  break;
606  }
607  if ((ret = filter_packet(avf, cs, pkt)) < 0)
608  return ret;
609 
610  st = cat->avf->streams[pkt->stream_index];
611  av_log(avf, AV_LOG_DEBUG, "file:%d stream:%d pts:%s pts_time:%s dts:%s dts_time:%s",
612  (unsigned)(cat->cur_file - cat->files), pkt->stream_index,
615 
616  delta = av_rescale_q(cat->cur_file->start_time - cat->cur_file->file_inpoint,
618  cat->avf->streams[pkt->stream_index]->time_base);
619  if (pkt->pts != AV_NOPTS_VALUE)
620  pkt->pts += delta;
621  if (pkt->dts != AV_NOPTS_VALUE)
622  pkt->dts += delta;
623  av_log(avf, AV_LOG_DEBUG, " -> pts:%s pts_time:%s dts:%s dts_time:%s\n",
626  if (cat->cur_file->metadata) {
627  size_t metadata_len;
628  char* packed_metadata = av_packet_pack_dictionary(cat->cur_file->metadata, &metadata_len);
629  if (!packed_metadata)
630  return AVERROR(ENOMEM);
632  packed_metadata, metadata_len);
633  if (ret < 0) {
634  av_freep(&packed_metadata);
635  return ret;
636  }
637  }
638 
639  if (cat->cur_file->duration == AV_NOPTS_VALUE && st->internal->cur_dts != AV_NOPTS_VALUE) {
640  int64_t next_dts = av_rescale_q(st->internal->cur_dts, st->time_base, AV_TIME_BASE_Q);
641  if (cat->cur_file->next_dts == AV_NOPTS_VALUE || next_dts > cat->cur_file->next_dts) {
642  cat->cur_file->next_dts = next_dts;
643  }
644  }
645 
647  return 0;
648 }
649 
650 static void rescale_interval(AVRational tb_in, AVRational tb_out,
651  int64_t *min_ts, int64_t *ts, int64_t *max_ts)
652 {
653  *ts = av_rescale_q (* ts, tb_in, tb_out);
654  *min_ts = av_rescale_q_rnd(*min_ts, tb_in, tb_out,
656  *max_ts = av_rescale_q_rnd(*max_ts, tb_in, tb_out,
658 }
659 
660 static int try_seek(AVFormatContext *avf, int stream,
661  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
662 {
663  ConcatContext *cat = avf->priv_data;
664  int64_t t0 = cat->cur_file->start_time - cat->cur_file->file_inpoint;
665 
666  ts -= t0;
667  min_ts = min_ts == INT64_MIN ? INT64_MIN : min_ts - t0;
668  max_ts = max_ts == INT64_MAX ? INT64_MAX : max_ts - t0;
669  if (stream >= 0) {
670  if (stream >= cat->avf->nb_streams)
671  return AVERROR(EIO);
672  rescale_interval(AV_TIME_BASE_Q, cat->avf->streams[stream]->time_base,
673  &min_ts, &ts, &max_ts);
674  }
675  return avformat_seek_file(cat->avf, stream, min_ts, ts, max_ts, flags);
676 }
677 
678 static int real_seek(AVFormatContext *avf, int stream,
679  int64_t min_ts, int64_t ts, int64_t max_ts, int flags, AVFormatContext *cur_avf)
680 {
681  ConcatContext *cat = avf->priv_data;
682  int ret, left, right;
683 
684  if (stream >= 0) {
685  if (stream >= avf->nb_streams)
686  return AVERROR(EINVAL);
688  &min_ts, &ts, &max_ts);
689  }
690 
691  left = 0;
692  right = cat->nb_files;
693 
694  /* Always support seek to start */
695  if (ts <= 0)
696  right = 1;
697  else if (!cat->seekable)
698  return AVERROR(ESPIPE); /* XXX: can we use it? */
699 
700  while (right - left > 1) {
701  int mid = (left + right) / 2;
702  if (ts < cat->files[mid].start_time)
703  right = mid;
704  else
705  left = mid;
706  }
707 
708  if (cat->cur_file != &cat->files[left]) {
709  if ((ret = open_file(avf, left)) < 0)
710  return ret;
711  } else {
712  cat->avf = cur_avf;
713  }
714 
715  ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);
716  if (ret < 0 &&
717  left < cat->nb_files - 1 &&
718  cat->files[left + 1].start_time < max_ts) {
719  if (cat->cur_file == &cat->files[left])
720  cat->avf = NULL;
721  if ((ret = open_file(avf, left + 1)) < 0)
722  return ret;
723  ret = try_seek(avf, stream, min_ts, ts, max_ts, flags);
724  }
725  return ret;
726 }
727 
728 static int concat_seek(AVFormatContext *avf, int stream,
729  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
730 {
731  ConcatContext *cat = avf->priv_data;
732  ConcatFile *cur_file_saved = cat->cur_file;
733  AVFormatContext *cur_avf_saved = cat->avf;
734  int ret;
735 
737  return AVERROR(ENOSYS);
738  cat->avf = NULL;
739  if ((ret = real_seek(avf, stream, min_ts, ts, max_ts, flags, cur_avf_saved)) < 0) {
740  if (cat->cur_file != cur_file_saved) {
741  if (cat->avf)
742  avformat_close_input(&cat->avf);
743  }
744  cat->avf = cur_avf_saved;
745  cat->cur_file = cur_file_saved;
746  } else {
747  if (cat->cur_file != cur_file_saved) {
748  avformat_close_input(&cur_avf_saved);
749  }
750  cat->eof = 0;
751  }
752  return ret;
753 }
754 
755 #define OFFSET(x) offsetof(ConcatContext, x)
756 #define DEC AV_OPT_FLAG_DECODING_PARAM
757 
758 static const AVOption options[] = {
759  { "safe", "enable safe mode",
760  OFFSET(safe), AV_OPT_TYPE_BOOL, {.i64 = 1}, -1, 1, DEC },
761  { "auto_convert", "automatically convert bitstream format",
762  OFFSET(auto_convert), AV_OPT_TYPE_BOOL, {.i64 = 1}, 0, 1, DEC },
763  { "segment_time_metadata", "output file segment start time and duration as packet metadata",
764  OFFSET(segment_time_metadata), AV_OPT_TYPE_BOOL, {.i64 = 0}, 0, 1, DEC },
765  { NULL }
766 };
767 
768 static const AVClass concat_class = {
769  .class_name = "concat demuxer",
770  .item_name = av_default_item_name,
771  .option = options,
772  .version = LIBAVUTIL_VERSION_INT,
773 };
774 
775 
777  .name = "concat",
778  .long_name = NULL_IF_CONFIG_SMALL("Virtual concatenation script"),
779  .priv_data_size = sizeof(ConcatContext),
780  .flags_internal = FF_FMT_INIT_CLEANUP,
785  .read_seek2 = concat_seek,
786  .priv_class = &concat_class,
787 };
add_file
static int add_file(AVFormatContext *avf, char *filename, ConcatFile **rfile, unsigned *nb_files_alloc)
Definition: concatdec.c:110
real_seek
static int real_seek(AVFormatContext *avf, int stream, int64_t min_ts, int64_t ts, int64_t max_ts, int flags, AVFormatContext *cur_avf)
Definition: concatdec.c:678
av_packet_unref
void av_packet_unref(AVPacket *pkt)
Wipe the packet.
Definition: avpacket.c:417
AVBSFContext::par_in
AVCodecParameters * par_in
Parameters of the input stream.
Definition: bsf.h:77
AV_BPRINT_SIZE_UNLIMITED
#define AV_BPRINT_SIZE_UNLIMITED
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
OFFSET
#define OFFSET(x)
Definition: concatdec.c:755
FF_FMT_INIT_CLEANUP
#define FF_FMT_INIT_CLEANUP
For an AVInputFormat with this flag set read_close() needs to be called by the caller upon read_heade...
Definition: internal.h:48
packet_after_outpoint
static int packet_after_outpoint(ConcatContext *cat, AVPacket *pkt)
Definition: concatdec.c:559
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
opt.h
avformat_new_stream
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
Definition: utils.c:4375
ConcatFile::duration
int64_t duration
Definition: concatdec.c:48
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:146
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:234
AVSEEK_FLAG_FRAME
#define AVSEEK_FLAG_FRAME
seeking based on frame number
Definition: avformat.h:2170
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:68
av_get_token
char * av_get_token(const char **buf, const char *term)
Unescape the given string until a non escaped terminating char, and return the token corresponding to...
Definition: avstring.c:151
ConcatContext::segment_time_metadata
int segment_time_metadata
Definition: concatdec.c:69
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:57
ConcatFile::next_dts
int64_t next_dts
Definition: concatdec.c:50
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
get_best_effort_duration
static int64_t get_best_effort_duration(ConcatFile *file, AVFormatContext *avf)
Definition: concatdec.c:316
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:145
ConcatFile::file_inpoint
int64_t file_inpoint
Definition: concatdec.c:47
AVFormatContext::streams
AVStream ** streams
A list of all streams in the file.
Definition: avformat.h:1175
ff_read_line_to_bprint_overwrite
int64_t ff_read_line_to_bprint_overwrite(AVIOContext *s, struct AVBPrint *bp)
Read a whole line of text from AVIOContext to an AVBPrint buffer overwriting its contents.
Definition: aviobuf.c:828
AVStream::internal
AVStreamInternal * internal
An opaque field for libavformat internal usage.
Definition: avformat.h:1009
AVOption
AVOption.
Definition: opt.h:247
t0
#define t0
Definition: regdef.h:28
AVStream::avg_frame_rate
AVRational avg_frame_rate
Average framerate.
Definition: avformat.h:914
AVFMT_FLAG_CUSTOM_IO
#define AVFMT_FLAG_CUSTOM_IO
The caller has supplied a custom AVIOContext, don't avio_close() it.
Definition: avformat.h:1233
ConcatContext::stream_match_mode
ConcatMatchMode stream_match_mode
Definition: concatdec.c:67
AVSEEK_FLAG_BYTE
#define AVSEEK_FLAG_BYTE
seeking based on position in bytes
Definition: avformat.h:2168
open_next_file
static int open_next_file(AVFormatContext *avf)
Definition: concatdec.c:520
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:196
concat_probe
static int concat_probe(const AVProbeData *probe)
Definition: concatdec.c:72
cat
#define cat(a, bpp, b)
Definition: vp9dsp_init.h:32
ConcatContext::nb_files
unsigned nb_files
Definition: concatdec.c:62
filter
filter_frame For filters that do not use the this method is called when a frame is pushed to the filter s input It can be called at any time except in a reentrant way If the input frame is enough to produce then the filter should push the output frames on the output link immediately As an exception to the previous rule if the input frame is enough to produce several output frames then the filter needs output only at least one per link The additional frames can be left buffered in the filter
Definition: filter_design.txt:228
AVDictionary
Definition: dict.c:30
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: utils.c:1669
AVBSFContext
The bitstream filter state.
Definition: bsf.h:49
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
av_bsf_get_by_name
const AVBitStreamFilter * av_bsf_get_by_name(const char *name)
Definition: bitstream_filters.c:78
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:458
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4347
AVFormatContext::interrupt_callback
AVIOInterruptCB interrupt_callback
Custom interrupt callbacks for the I/O layer.
Definition: avformat.h:1374
bsf.h
av_packet_add_side_data
int av_packet_add_side_data(AVPacket *pkt, enum AVPacketSideDataType type, uint8_t *data, size_t size)
Wrap an existing array as a packet side data.
Definition: avpacket.c:191
fail
#define fail()
Definition: checkasm.h:136
concat_read_header
static int concat_read_header(AVFormatContext *avf)
Definition: concatdec.c:397
match_streams_exact_id
static int match_streams_exact_id(AVFormatContext *avf)
Definition: concatdec.c:257
filter_packet
static int filter_packet(AVFormatContext *avf, ConcatStream *cs, AVPacket *pkt)
Definition: concatdec.c:534
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:141
ConcatFile::outpoint
int64_t outpoint
Definition: concatdec.c:53
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
AVBSFContext::par_out
AVCodecParameters * par_out
Parameters of the output stream.
Definition: bsf.h:83
concat_read_packet
static int concat_read_packet(AVFormatContext *avf, AVPacket *pkt)
Definition: concatdec.c:568
AVRational::num
int num
Numerator.
Definition: rational.h:59
SPACE_CHARS
#define SPACE_CHARS
Definition: dnn_backend_tf.c:299
AV_PKT_DATA_STRINGS_METADATA
@ AV_PKT_DATA_STRINGS_METADATA
A list of zero terminated key/value strings.
Definition: packet.h:172
ConcatFile::streams
ConcatStream * streams
Definition: concatdec.c:51
pkt
AVPacket * pkt
Definition: movenc.c:59
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:180
AVInputFormat
Definition: avformat.h:626
get_keyword
static char * get_keyword(uint8_t **cursor)
Definition: concatdec.c:78
ConcatFile::file_start_time
int64_t file_start_time
Definition: concatdec.c:46
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: utils.c:483
intreadwrite.h
copy_stream_props
static int copy_stream_props(AVStream *st, AVStream *source_st)
Definition: concatdec.c:169
AVFormatContext::flags
int flags
Flags modifying the (de)muxer behaviour.
Definition: avformat.h:1225
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:631
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:201
nb_streams
static int nb_streams
Definition: ffprobe.c:289
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:141
ConcatFile::inpoint
int64_t inpoint
Definition: concatdec.c:52
f
#define f(width, name)
Definition: cbs_vp9.c:255
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:77
MATCH_ONE_TO_ONE
@ MATCH_ONE_TO_ONE
Definition: concatdec.c:34
AVFormatContext
Format I/O context.
Definition: avformat.h:1107
internal.h
options
static const AVOption options[]
Definition: concatdec.c:758
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:994
open_file
static int open_file(AVFormatContext *avf, unsigned fileno)
Definition: concatdec.c:329
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:66
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:870
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AVStreamInternal::cur_dts
int64_t cur_dts
Definition: internal.h:408
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVFormatContext::pb
AVIOContext * pb
I/O context.
Definition: avformat.h:1149
AVERROR_BSF_NOT_FOUND
#define AVERROR_BSF_NOT_FOUND
Bitstream filter not found.
Definition: error.h:51
parseutils.h
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:446
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:905
av_parse_time
int av_parse_time(int64_t *timeval, const char *timestr, int duration)
Parse timestr and return in *time a corresponding number of microseconds.
Definition: parseutils.c:587
AVCodecParameters::extradata_size
int extradata_size
Size of the extradata content in bytes.
Definition: codec_par.h:78
AVFormatContext::nb_streams
unsigned int nb_streams
Number of elements in AVFormatContext.streams.
Definition: avformat.h:1163
avformat_find_stream_info
int avformat_find_stream_info(AVFormatContext *ic, AVDictionary **options)
Read packets of a media file to get stream information.
Definition: utils.c:3547
ConcatContext::avf
AVFormatContext * avf
Definition: concatdec.c:63
av_ts2timestr
#define av_ts2timestr(ts, tb)
Convenience macro, the return value should be used only directly in function arguments but never stan...
Definition: timestamp.h:76
NULL_IF_CONFIG_SMALL
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
Definition: internal.h:116
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:166
ConcatStream
Definition: concatdec.c:38
try_seek
static int try_seek(AVFormatContext *avf, int stream, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Definition: concatdec.c:660
start_time
static int64_t start_time
Definition: ffplay.c:330
avpriv_set_pts_info
void avpriv_set_pts_info(AVStream *s, int pts_wrap_bits, unsigned int pts_num, unsigned int pts_den)
Set the time base and wrapping info for a given stream.
Definition: utils.c:4800
AVFormatContext::url
char * url
input or output URL.
Definition: avformat.h:1190
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:146
ConcatStream::out_stream_index
int out_stream_index
Definition: concatdec.c:40
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: utils.c:2467
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
AV_RB32
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_RB32
Definition: bytestream.h:96
ConcatContext::auto_convert
unsigned auto_convert
Definition: concatdec.c:68
match_streams_one_to_one
static int match_streams_one_to_one(AVFormatContext *avf)
Definition: concatdec.c:237
concat_class
static const AVClass concat_class
Definition: concatdec.c:768
AVStream::sample_aspect_ratio
AVRational sample_aspect_ratio
sample aspect ratio (0 if unknown)
Definition: avformat.h:903
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:372
FAIL
#define FAIL(retcode)
Definition: concatdec.c:108
line
Definition: graph2dot.c:48
av_packet_pack_dictionary
uint8_t * av_packet_pack_dictionary(AVDictionary *dict, size_t *size)
Pack a dictionary for use in side_data.
Definition: avpacket.c:302
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:203
av_strstart
int av_strstart(const char *str, const char *pfx, const char **ptr)
Return non-zero if pfx is a prefix of str.
Definition: avstring.c:34
AV_LOG_INFO
#define AV_LOG_INFO
Standard information.
Definition: log.h:191
safe_filename
static int safe_filename(const char *f)
Definition: concatdec.c:89
av_realloc
void * av_realloc(void *ptr, size_t size)
Allocate, reallocate, or free a block of memory.
Definition: mem.c:134
avcodec_parameters_copy
int avcodec_parameters_copy(AVCodecParameters *dst, const AVCodecParameters *src)
Copy the contents of src to dst.
Definition: codec_par.c:72
bprint.h
i
int i
Definition: input.c:406
av_bsf_receive_packet
int av_bsf_receive_packet(AVBSFContext *ctx, AVPacket *pkt)
Retrieve a filtered packet.
Definition: bsf.c:224
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:366
avio_internal.h
ConcatFile::start_time
int64_t start_time
Definition: concatdec.c:45
ConcatContext::cur_file
ConcatFile * cur_file
Definition: concatdec.c:61
MATCH_EXACT_ID
@ MATCH_EXACT_ID
Definition: concatdec.c:35
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:82
delta
float delta
Definition: vorbis_enc_data.h:430
url.h
ConcatContext::eof
int eof
Definition: concatdec.c:66
ConcatContext
Definition: avf_concat.c:37
files
Writing a table generator This documentation is preliminary Parts of the API are not good and should be changed Basic concepts A table generator consists of two files
Definition: tablegen.txt:8
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:854
ret
ret
Definition: filter_design.txt:187
read_packet
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
Definition: avio_reading.c:42
AVStream
Stream structure.
Definition: avformat.h:847
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
ConcatStream::bsf
AVBSFContext * bsf
Definition: concatdec.c:39
ConcatFile
Definition: concatdec.c:43
avformat.h
av_bsf_send_packet
int av_bsf_send_packet(AVBSFContext *ctx, AVPacket *pkt)
Submit a packet for filtering.
Definition: bsf.c:198
left
Tag MUST be and< 10hcoeff half pel interpolation filter coefficients, hcoeff[0] are the 2 middle coefficients[1] are the next outer ones and so on, resulting in a filter like:...eff[2], hcoeff[1], hcoeff[0], hcoeff[0], hcoeff[1], hcoeff[2] ... the sign of the coefficients is not explicitly stored but alternates after each coeff and coeff[0] is positive, so ...,+,-,+,-,+,+,-,+,-,+,... hcoeff[0] is not explicitly stored but found by subtracting the sum of all stored coefficients with signs from 32 hcoeff[0]=32 - hcoeff[1] - hcoeff[2] - ... a good choice for hcoeff and htaps is htaps=6 hcoeff={40,-10, 2} an alternative which requires more computations at both encoder and decoder side and may or may not be better is htaps=8 hcoeff={42,-14, 6,-2}ref_frames minimum of the number of available reference frames and max_ref_frames for example the first frame after a key frame always has ref_frames=1spatial_decomposition_type wavelet type 0 is a 9/7 symmetric compact integer wavelet 1 is a 5/3 symmetric compact integer wavelet others are reserved stored as delta from last, last is reset to 0 if always_reset||keyframeqlog quality(logarithmic quantizer scale) stored as delta from last, last is reset to 0 if always_reset||keyframemv_scale stored as delta from last, last is reset to 0 if always_reset||keyframe FIXME check that everything works fine if this changes between framesqbias dequantization bias stored as delta from last, last is reset to 0 if always_reset||keyframeblock_max_depth maximum depth of the block tree stored as delta from last, last is reset to 0 if always_reset||keyframequant_table quantization tableHighlevel bitstream structure:==============================--------------------------------------------|Header|--------------------------------------------|------------------------------------|||Block0||||split?||||yes no||||......... intra?||||:Block01 :yes no||||:Block02 :....... ..........||||:Block03 ::y DC ::ref index:||||:Block04 ::cb DC ::motion x :||||......... :cr DC ::motion y :||||....... ..........|||------------------------------------||------------------------------------|||Block1|||...|--------------------------------------------|------------ ------------ ------------|||Y subbands||Cb subbands||Cr subbands||||--- ---||--- ---||--- ---|||||LL0||HL0||||LL0||HL0||||LL0||HL0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||LH0||HH0||||LH0||HH0||||LH0||HH0|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HL1||LH1||||HL1||LH1||||HL1||LH1|||||--- ---||--- ---||--- ---||||--- ---||--- ---||--- ---|||||HH1||HL2||||HH1||HL2||||HH1||HL2|||||...||...||...|||------------ ------------ ------------|--------------------------------------------Decoding process:=================------------|||Subbands|------------||||------------|Intra DC||||LL0 subband prediction ------------|\ Dequantization ------------------- \||Reference frames|\ IDWT|------- -------|Motion \|||Frame 0||Frame 1||Compensation . OBMC v -------|------- -------|--------------. \------> Frame n output Frame Frame<----------------------------------/|...|------------------- Range Coder:============Binary Range Coder:------------------- The implemented range coder is an adapted version based upon "Range encoding: an algorithm for removing redundancy from a digitised message." by G. N. N. Martin. The symbols encoded by the Snow range coder are bits(0|1). The associated probabilities are not fix but change depending on the symbol mix seen so far. bit seen|new state ---------+----------------------------------------------- 0|256 - state_transition_table[256 - old_state];1|state_transition_table[old_state];state_transition_table={ 0, 0, 0, 0, 0, 0, 0, 0, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70, 71, 72, 73, 74, 75, 75, 76, 77, 78, 79, 80, 81, 82, 83, 84, 85, 86, 87, 88, 89, 90, 91, 92, 93, 94, 94, 95, 96, 97, 98, 99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125, 126, 127, 128, 129, 130, 131, 132, 133, 133, 134, 135, 136, 137, 138, 139, 140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 152, 153, 154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167, 168, 169, 170, 171, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181, 182, 183, 184, 185, 186, 187, 188, 189, 190, 190, 191, 192, 194, 194, 195, 196, 197, 198, 199, 200, 201, 202, 202, 204, 205, 206, 207, 208, 209, 209, 210, 211, 212, 213, 215, 215, 216, 217, 218, 219, 220, 220, 222, 223, 224, 225, 226, 227, 227, 229, 229, 230, 231, 232, 234, 234, 235, 236, 237, 238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 248, 0, 0, 0, 0, 0, 0, 0};FIXME Range Coding of integers:------------------------- FIXME Neighboring Blocks:===================left and top are set to the respective blocks unless they are outside of the image in which case they are set to the Null block top-left is set to the top left block unless it is outside of the image in which case it is set to the left block if this block has no larger parent block or it is at the left side of its parent block and the top right block is not outside of the image then the top right block is used for top-right else the top-left block is used Null block y, cb, cr are 128 level, ref, mx and my are 0 Motion Vector Prediction:=========================1. the motion vectors of all the neighboring blocks are scaled to compensate for the difference of reference frames scaled_mv=(mv *(256 *(current_reference+1)/(mv.reference+1))+128)> the median of the scaled left
Definition: snow.txt:386
probe
static int probe(const AVProbeData *p)
Definition: act.c:36
ConcatFile::url
char * url
Definition: concatdec.c:44
AVBitStreamFilter
Definition: bsf.h:98
ConcatContext::seekable
int seekable
Definition: concatdec.c:65
DEC
#define DEC
Definition: concatdec.c:756
AVRational::den
int den
Denominator.
Definition: rational.h:60
av_dict_parse_string
int av_dict_parse_string(AVDictionary **pm, const char *str, const char *key_val_sep, const char *pairs_sep, int flags)
Parse the key/value pairs list and add the parsed entries to a dictionary.
Definition: dict.c:180
ConcatContext::files
ConcatFile * files
Definition: concatdec.c:60
AVStream::r_frame_rate
AVRational r_frame_rate
Real base framerate of the stream.
Definition: avformat.h:983
rescale_interval
static void rescale_interval(AVRational tb_in, AVRational tb_out, int64_t *min_ts, int64_t *ts, int64_t *max_ts)
Definition: concatdec.c:650
AVFormatContext::duration
int64_t duration
Duration of the stream, in AV_TIME_BASE fractional seconds.
Definition: avformat.h:1209
AVPacket::stream_index
int stream_index
Definition: packet.h:375
ConcatFile::nb_streams
int nb_streams
Definition: concatdec.c:55
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:147
detect_stream_specific
static int detect_stream_specific(AVFormatContext *avf, int idx)
Definition: concatdec.c:195
map
const VDPAUPixFmtMap * map
Definition: hwcontext_vdpau.c:71
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
ff_make_absolute_url
int ff_make_absolute_url(char *buf, int size, const char *base, const char *rel)
Convert a relative url into an absolute url, given a base url.
Definition: url.c:319
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:108
AVCodecParameters::codec_id
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
Definition: codec_par.h:60
AVPacket
This structure stores compressed data.
Definition: packet.h:350
AV_OPT_TYPE_BOOL
@ AV_OPT_TYPE_BOOL
Definition: opt.h:241
ff_concat_demuxer
const AVInputFormat ff_concat_demuxer
Definition: concatdec.c:776
av_freep
#define av_freep(p)
Definition: tableprint_vlc.h:35
av_dict_copy
int av_dict_copy(AVDictionary **dst, const AVDictionary *src, int flags)
Copy entries from one AVDictionary struct into another.
Definition: dict.c:217
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:40
avio_find_protocol_name
const char * avio_find_protocol_name(const char *url)
Return the name of the protocol that will handle the passed URL.
Definition: avio.c:467
timestamp.h
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:561
AVERROR_BUG
#define AVERROR_BUG
Internal bug, also see AVERROR_BUG2.
Definition: error.h:52
ConcatContext::safe
int safe
Definition: concatdec.c:64
av_log
#define av_log(a,...)
Definition: tableprint_vlc.h:28
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
concat_seek
static int concat_seek(AVFormatContext *avf, int stream, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Definition: concatdec.c:728
avstring.h
ConcatFile::metadata
AVDictionary * metadata
Definition: concatdec.c:54
AV_RB24
uint64_t_TMPL AV_WL64 unsigned int_TMPL AV_WL32 unsigned int_TMPL AV_WL24 unsigned int_TMPL AV_WL16 uint64_t_TMPL AV_WB64 unsigned int_TMPL AV_WB32 unsigned int_TMPL AV_RB24
Definition: bytestream.h:97
match_streams
static int match_streams(AVFormatContext *avf)
Definition: concatdec.c:279
ConcatMatchMode
ConcatMatchMode
Definition: concatdec.c:33
AVFormatContext::priv_data
void * priv_data
Format private data.
Definition: avformat.h:1135
ConcatFile::user_duration
int64_t user_duration
Definition: concatdec.c:49
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:133
av_bsf_alloc
int av_bsf_alloc(const AVBitStreamFilter *filter, AVBSFContext **pctx)
Allocate a context for a given bitstream filter.
Definition: bsf.c:92
concat_read_close
static int concat_read_close(AVFormatContext *avf)
Definition: concatdec.c:377
ff_alloc_extradata
int ff_alloc_extradata(AVCodecParameters *par, int size)
Allocate extradata with additional AV_INPUT_BUFFER_PADDING_SIZE at end which is always set to 0.
Definition: utils.c:3265