FFmpeg  4.3
mpeg.c
Go to the documentation of this file.
1 /*
2  * MPEG-1/2 demuxer
3  * Copyright (c) 2000, 2001, 2002 Fabrice Bellard
4  *
5  * This file is part of FFmpeg.
6  *
7  * FFmpeg is free software; you can redistribute it and/or
8  * modify it under the terms of the GNU Lesser General Public
9  * License as published by the Free Software Foundation; either
10  * version 2.1 of the License, or (at your option) any later version.
11  *
12  * FFmpeg is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15  * Lesser General Public License for more details.
16  *
17  * You should have received a copy of the GNU Lesser General Public
18  * License along with FFmpeg; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
22 #include "avformat.h"
23 #include "avio_internal.h"
24 #include "internal.h"
25 #include "mpeg.h"
26 
27 /*********************************************/
28 /* demux code */
29 
30 #define MAX_SYNC_SIZE 100000
31 
32 static int check_pes(const uint8_t *p, const uint8_t *end)
33 {
34  int pes1;
35  int pes2 = (p[3] & 0xC0) == 0x80 &&
36  (p[4] & 0xC0) != 0x40 &&
37  ((p[4] & 0xC0) == 0x00 ||
38  (p[4] & 0xC0) >> 2 == (p[6] & 0xF0));
39 
40  for (p += 3; p < end && *p == 0xFF; p++) ;
41  if ((*p & 0xC0) == 0x40)
42  p += 2;
43 
44  if ((*p & 0xF0) == 0x20)
45  pes1 = p[0] & p[2] & p[4] & 1;
46  else if ((*p & 0xF0) == 0x30)
47  pes1 = p[0] & p[2] & p[4] & p[5] & p[7] & p[9] & 1;
48  else
49  pes1 = *p == 0x0F;
50 
51  return pes1 || pes2;
52 }
53 
54 static int check_pack_header(const uint8_t *buf)
55 {
56  return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
57 }
58 
59 static int mpegps_probe(const AVProbeData *p)
60 {
61  uint32_t code = -1;
62  int i;
63  int sys = 0, pspack = 0, priv1 = 0, vid = 0;
64  int audio = 0, invalid = 0, score = 0;
65  int endpes = 0;
66 
67  for (i = 0; i < p->buf_size; i++) {
68  code = (code << 8) + p->buf[i];
69  if ((code & 0xffffff00) == 0x100) {
70  int len = p->buf[i + 1] << 8 | p->buf[i + 2];
71  int pes = endpes <= i && check_pes(p->buf + i, p->buf + p->buf_size);
72  int pack = check_pack_header(p->buf + i);
73 
75  sys++;
76  else if (code == PACK_START_CODE && pack)
77  pspack++;
78  else if ((code & 0xf0) == VIDEO_ID && pes) {
79  endpes = i + len;
80  vid++;
81  }
82  // skip pes payload to avoid start code emulation for private
83  // and audio streams
84  else if ((code & 0xe0) == AUDIO_ID && pes) {audio++; i+=len;}
85  else if (code == PRIVATE_STREAM_1 && pes) {priv1++; i+=len;}
86  else if (code == 0x1fd && pes) vid++; //VC1
87 
88  else if ((code & 0xf0) == VIDEO_ID && !pes) invalid++;
89  else if ((code & 0xe0) == AUDIO_ID && !pes) invalid++;
90  else if (code == PRIVATE_STREAM_1 && !pes) invalid++;
91  }
92  }
93 
94  if (vid + audio > invalid + 1) /* invalid VDR files nd short PES streams */
95  score = AVPROBE_SCORE_EXTENSION / 2;
96 
97 // av_log(NULL, AV_LOG_ERROR, "vid:%d aud:%d sys:%d pspack:%d invalid:%d size:%d \n",
98 // vid, audio, sys, pspack, invalid, p->buf_size);
99 
100  if (sys > invalid && sys * 9 <= pspack * 10)
101  return (audio > 12 || vid > 3 || pspack > 2) ? AVPROBE_SCORE_EXTENSION + 2
102  : AVPROBE_SCORE_EXTENSION / 2 + (audio + vid + pspack > 1); // 1 more than mp3
103  if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
104  return pspack > 2 ? AVPROBE_SCORE_EXTENSION + 2
105  : AVPROBE_SCORE_EXTENSION / 2; // 1 more than .mpg
106  if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
107  !pspack && p->buf_size > 2048 && vid + audio > invalid) /* PES stream */
108  return (audio > 12 || vid > 6 + 2 * invalid) ? AVPROBE_SCORE_EXTENSION + 2
110 
111  // 02-Penguin.flac has sys:0 priv1:0 pspack:0 vid:0 audio:1
112  // mp3_misidentified_2.mp3 has sys:0 priv1:0 pspack:0 vid:0 audio:6
113  // Have\ Yourself\ a\ Merry\ Little\ Christmas.mp3 0 0 0 5 0 1 len:21618
114  return score;
115 }
116 
117 typedef struct MpegDemuxContext {
119  unsigned char psm_es_type[256];
120  int sofdec;
121  int dvd;
123  int raw_ac3;
125 
127 {
128  MpegDemuxContext *m = s->priv_data;
129  char buffer[7] = { 0 };
130  int64_t last_pos = avio_tell(s->pb);
131 
132  m->header_state = 0xff;
133  s->ctx_flags |= AVFMTCTX_NOHEADER;
134 
135  avio_get_str(s->pb, 6, buffer, sizeof(buffer));
136  if (!memcmp("IMKH", buffer, 4)) {
137  m->imkh_cctv = 1;
138  } else if (!memcmp("Sofdec", buffer, 6)) {
139  m->sofdec = 1;
140  } else
141  avio_seek(s->pb, last_pos, SEEK_SET);
142 
143  /* no need to do more */
144  return 0;
145 }
146 
147 static int64_t get_pts(AVIOContext *pb, int c)
148 {
149  uint8_t buf[5];
150 
151  buf[0] = c < 0 ? avio_r8(pb) : c;
152  avio_read(pb, buf + 1, 4);
153 
154  return ff_parse_pes_pts(buf);
155 }
156 
157 static int find_next_start_code(AVIOContext *pb, int *size_ptr,
158  int32_t *header_state)
159 {
160  unsigned int state, v;
161  int val, n;
162 
163  state = *header_state;
164  n = *size_ptr;
165  while (n > 0) {
166  if (avio_feof(pb))
167  break;
168  v = avio_r8(pb);
169  n--;
170  if (state == 0x000001) {
171  state = ((state << 8) | v) & 0xffffff;
172  val = state;
173  goto found;
174  }
175  state = ((state << 8) | v) & 0xffffff;
176  }
177  val = -1;
178 
179 found:
180  *header_state = state;
181  *size_ptr = n;
182  return val;
183 }
184 
185 /**
186  * Extract stream types from a program stream map
187  * According to ISO/IEC 13818-1 ('MPEG-2 Systems') table 2-35
188  *
189  * @return number of bytes occupied by PSM in the bitstream
190  */
192 {
193  int psm_length, ps_info_length, es_map_length;
194 
195  psm_length = avio_rb16(pb);
196  avio_r8(pb);
197  avio_r8(pb);
198  ps_info_length = avio_rb16(pb);
199 
200  /* skip program_stream_info */
201  avio_skip(pb, ps_info_length);
202  /*es_map_length = */avio_rb16(pb);
203  /* Ignore es_map_length, trust psm_length */
204  es_map_length = psm_length - ps_info_length - 10;
205 
206  /* at least one es available? */
207  while (es_map_length >= 4) {
208  unsigned char type = avio_r8(pb);
209  unsigned char es_id = avio_r8(pb);
210  uint16_t es_info_length = avio_rb16(pb);
211 
212  /* remember mapping from stream id to stream type */
213  m->psm_es_type[es_id] = type;
214  /* skip program_stream_info */
215  avio_skip(pb, es_info_length);
216  es_map_length -= 4 + es_info_length;
217  }
218  avio_rb32(pb); /* crc32 */
219  return 2 + psm_length;
220 }
221 
222 /* read the next PES header. Return its position in ppos
223  * (if not NULL), and its start code, pts and dts.
224  */
226  int64_t *ppos, int *pstart_code,
227  int64_t *ppts, int64_t *pdts)
228 {
229  MpegDemuxContext *m = s->priv_data;
230  int len, size, startcode, c, flags, header_len;
231  int pes_ext, ext2_len, id_ext, skip;
232  int64_t pts, dts;
233  int64_t last_sync = avio_tell(s->pb);
234 
235 error_redo:
236  avio_seek(s->pb, last_sync, SEEK_SET);
237 redo:
238  /* next start code (should be immediately after) */
239  m->header_state = 0xff;
241  startcode = find_next_start_code(s->pb, &size, &m->header_state);
242  last_sync = avio_tell(s->pb);
243  if (startcode < 0) {
244  if (avio_feof(s->pb))
245  return AVERROR_EOF;
246  // FIXME we should remember header_state
247  return FFERROR_REDO;
248  }
249 
250  if (startcode == PACK_START_CODE)
251  goto redo;
252  if (startcode == SYSTEM_HEADER_START_CODE)
253  goto redo;
254  if (startcode == PADDING_STREAM) {
255  avio_skip(s->pb, avio_rb16(s->pb));
256  goto redo;
257  }
258  if (startcode == PRIVATE_STREAM_2) {
259  if (!m->sofdec) {
260  /* Need to detect whether this from a DVD or a 'Sofdec' stream */
261  int len = avio_rb16(s->pb);
262  int bytesread = 0;
263  uint8_t *ps2buf = av_malloc(len);
264 
265  if (ps2buf) {
266  bytesread = avio_read(s->pb, ps2buf, len);
267 
268  if (bytesread != len) {
269  avio_skip(s->pb, len - bytesread);
270  } else {
271  uint8_t *p = 0;
272  if (len >= 6)
273  p = memchr(ps2buf, 'S', len - 5);
274 
275  if (p)
276  m->sofdec = !memcmp(p+1, "ofdec", 5);
277 
278  m->sofdec -= !m->sofdec;
279 
280  if (m->sofdec < 0) {
281  if (len == 980 && ps2buf[0] == 0) {
282  /* PCI structure? */
283  uint32_t startpts = AV_RB32(ps2buf + 0x0d);
284  uint32_t endpts = AV_RB32(ps2buf + 0x11);
285  uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
286  uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
287  uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
288 
289  m->dvd = (hours <= 23 &&
290  mins <= 59 &&
291  secs <= 59 &&
292  (ps2buf[0x19] & 0x0f) < 10 &&
293  (ps2buf[0x1a] & 0x0f) < 10 &&
294  (ps2buf[0x1b] & 0x0f) < 10 &&
295  endpts >= startpts);
296  } else if (len == 1018 && ps2buf[0] == 1) {
297  /* DSI structure? */
298  uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
299  uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
300  uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
301 
302  m->dvd = (hours <= 23 &&
303  mins <= 59 &&
304  secs <= 59 &&
305  (ps2buf[0x1d] & 0x0f) < 10 &&
306  (ps2buf[0x1e] & 0x0f) < 10 &&
307  (ps2buf[0x1f] & 0x0f) < 10);
308  }
309  }
310  }
311 
312  av_free(ps2buf);
313 
314  /* If this isn't a DVD packet or no memory
315  * could be allocated, just ignore it.
316  * If we did, move back to the start of the
317  * packet (plus 'length' field) */
318  if (!m->dvd || avio_skip(s->pb, -(len + 2)) < 0) {
319  /* Skip back failed.
320  * This packet will be lost but that can't be helped
321  * if we can't skip back
322  */
323  goto redo;
324  }
325  } else {
326  /* No memory */
327  avio_skip(s->pb, len);
328  goto redo;
329  }
330  } else if (!m->dvd) {
331  int len = avio_rb16(s->pb);
332  avio_skip(s->pb, len);
333  goto redo;
334  }
335  }
336  if (startcode == PROGRAM_STREAM_MAP) {
337  mpegps_psm_parse(m, s->pb);
338  goto redo;
339  }
340 
341  /* find matching stream */
342  if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
343  (startcode >= 0x1e0 && startcode <= 0x1ef) ||
344  (startcode == 0x1bd) ||
345  (startcode == PRIVATE_STREAM_2) ||
346  (startcode == 0x1fd)))
347  goto redo;
348  if (ppos) {
349  *ppos = avio_tell(s->pb) - 4;
350  }
351  len = avio_rb16(s->pb);
352  pts =
353  dts = AV_NOPTS_VALUE;
354  if (startcode != PRIVATE_STREAM_2)
355  {
356  /* stuffing */
357  for (;;) {
358  if (len < 1)
359  goto error_redo;
360  c = avio_r8(s->pb);
361  len--;
362  /* XXX: for MPEG-1, should test only bit 7 */
363  if (c != 0xff)
364  break;
365  }
366  if ((c & 0xc0) == 0x40) {
367  /* buffer scale & size */
368  avio_r8(s->pb);
369  c = avio_r8(s->pb);
370  len -= 2;
371  }
372  if ((c & 0xe0) == 0x20) {
373  dts =
374  pts = get_pts(s->pb, c);
375  len -= 4;
376  if (c & 0x10) {
377  dts = get_pts(s->pb, -1);
378  len -= 5;
379  }
380  } else if ((c & 0xc0) == 0x80) {
381  /* mpeg 2 PES */
382  flags = avio_r8(s->pb);
383  header_len = avio_r8(s->pb);
384  len -= 2;
385  if (header_len > len)
386  goto error_redo;
387  len -= header_len;
388  if (flags & 0x80) {
389  dts = pts = get_pts(s->pb, -1);
390  header_len -= 5;
391  if (flags & 0x40) {
392  dts = get_pts(s->pb, -1);
393  header_len -= 5;
394  }
395  }
396  if (flags & 0x3f && header_len == 0) {
397  flags &= 0xC0;
398  av_log(s, AV_LOG_WARNING, "Further flags set but no bytes left\n");
399  }
400  if (flags & 0x01) { /* PES extension */
401  pes_ext = avio_r8(s->pb);
402  header_len--;
403  /* Skip PES private data, program packet sequence counter
404  * and P-STD buffer */
405  skip = (pes_ext >> 4) & 0xb;
406  skip += skip & 0x9;
407  if (pes_ext & 0x40 || skip > header_len) {
408  av_log(s, AV_LOG_WARNING, "pes_ext %X is invalid\n", pes_ext);
409  pes_ext = skip = 0;
410  }
411  avio_skip(s->pb, skip);
412  header_len -= skip;
413 
414  if (pes_ext & 0x01) { /* PES extension 2 */
415  ext2_len = avio_r8(s->pb);
416  header_len--;
417  if ((ext2_len & 0x7f) > 0) {
418  id_ext = avio_r8(s->pb);
419  if ((id_ext & 0x80) == 0)
420  startcode = ((startcode & 0xff) << 8) | id_ext;
421  header_len--;
422  }
423  }
424  }
425  if (header_len < 0)
426  goto error_redo;
427  avio_skip(s->pb, header_len);
428  } else if (c != 0xf)
429  goto redo;
430  }
431 
432  if (startcode == PRIVATE_STREAM_1) {
433  int ret = ffio_ensure_seekback(s->pb, 2);
434 
435  if (ret < 0)
436  return ret;
437 
438  startcode = avio_r8(s->pb);
439  m->raw_ac3 = 0;
440  if (startcode == 0x0b) {
441  if (avio_r8(s->pb) == 0x77) {
442  startcode = 0x80;
443  m->raw_ac3 = 1;
444  avio_skip(s->pb, -2);
445  } else {
446  avio_skip(s->pb, -1);
447  }
448  } else {
449  len--;
450  }
451  }
452  if (len < 0)
453  goto error_redo;
454  if (dts != AV_NOPTS_VALUE && ppos) {
455  int i;
456  for (i = 0; i < s->nb_streams; i++) {
457  if (startcode == s->streams[i]->id &&
458  (s->pb->seekable & AVIO_SEEKABLE_NORMAL) /* index useless on streams anyway */) {
459  ff_reduce_index(s, i);
460  av_add_index_entry(s->streams[i], *ppos, dts, 0, 0,
461  AVINDEX_KEYFRAME /* FIXME keyframe? */);
462  }
463  }
464  }
465 
466  *pstart_code = startcode;
467  *ppts = pts;
468  *pdts = dts;
469  return len;
470 }
471 
473  AVPacket *pkt)
474 {
475  MpegDemuxContext *m = s->priv_data;
476  AVStream *st;
477  int len, startcode, i, es_type, ret;
478  int pcm_dvd = 0;
479  int request_probe= 0;
481  enum AVMediaType type;
482  int64_t pts, dts, dummy_pos; // dummy_pos is needed for the index building to work
483 
484 redo:
485  len = mpegps_read_pes_header(s, &dummy_pos, &startcode, &pts, &dts);
486  if (len < 0)
487  return len;
488 
489  if (startcode >= 0x80 && startcode <= 0xcf) {
490  if (len < 4)
491  goto skip;
492 
493  if (!m->raw_ac3) {
494  /* audio: skip header */
495  avio_skip(s->pb, 3);
496  len -= 3;
497  if (startcode >= 0xb0 && startcode <= 0xbf) {
498  /* MLP/TrueHD audio has a 4-byte header */
499  avio_r8(s->pb);
500  len--;
501  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
502  ret = ffio_ensure_seekback(s->pb, 3);
503  if (ret < 0)
504  return ret;
505  pcm_dvd = (avio_rb24(s->pb) & 0xFF) == 0x80;
506  avio_skip(s->pb, -3);
507  }
508  }
509  }
510 
511  /* now find stream */
512  for (i = 0; i < s->nb_streams; i++) {
513  st = s->streams[i];
514  if (st->id == startcode)
515  goto found;
516  }
517 
518  es_type = m->psm_es_type[startcode & 0xff];
519  if (es_type == STREAM_TYPE_VIDEO_MPEG1) {
522  } else if (es_type == STREAM_TYPE_VIDEO_MPEG2) {
525  } else if (es_type == STREAM_TYPE_AUDIO_MPEG1 ||
526  es_type == STREAM_TYPE_AUDIO_MPEG2) {
529  } else if (es_type == STREAM_TYPE_AUDIO_AAC) {
532  } else if (es_type == STREAM_TYPE_VIDEO_MPEG4) {
535  } else if (es_type == STREAM_TYPE_VIDEO_H264) {
538  } else if (es_type == STREAM_TYPE_VIDEO_HEVC) {
541  } else if (es_type == STREAM_TYPE_AUDIO_AC3) {
544  } else if (m->imkh_cctv && es_type == 0x91) {
547  } else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
548  static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
549  unsigned char buf[8];
550 
551  avio_read(s->pb, buf, 8);
552  avio_seek(s->pb, -8, SEEK_CUR);
553  if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
555  else
556  request_probe= 1;
558  } else if (startcode == PRIVATE_STREAM_2) {
561  } else if (startcode >= 0x1c0 && startcode <= 0x1df) {
563  if (m->sofdec > 0) {
565  // Auto-detect AC-3
566  request_probe = 50;
567  } else if (m->imkh_cctv && startcode == 0x1c0 && len > 80) {
569  request_probe = 50;
570  } else {
572  if (m->imkh_cctv)
573  request_probe = 25;
574  }
575  } else if (startcode >= 0x80 && startcode <= 0x87) {
578  } else if ((startcode >= 0x88 && startcode <= 0x8f) ||
579  (startcode >= 0x98 && startcode <= 0x9f)) {
580  /* 0x90 - 0x97 is reserved for SDDS in DVD specs */
583  } else if (startcode >= 0xa0 && startcode <= 0xaf) {
585  if (!pcm_dvd) {
587  } else {
589  }
590  } else if (startcode >= 0xb0 && startcode <= 0xbf) {
593  } else if (startcode >= 0xc0 && startcode <= 0xcf) {
594  /* Used for both AC-3 and E-AC-3 in EVOB files */
597  } else if (startcode >= 0x20 && startcode <= 0x3f) {
600  } else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
603  } else {
604 skip:
605  /* skip packet */
606  avio_skip(s->pb, len);
607  goto redo;
608  }
609  /* no stream found: add a new stream */
610  st = avformat_new_stream(s, NULL);
611  if (!st)
612  goto skip;
613  st->id = startcode;
614  st->codecpar->codec_type = type;
615  st->codecpar->codec_id = codec_id;
618  st->codecpar->channels = 1;
620  st->codecpar->sample_rate = 8000;
621  }
622  st->request_probe = request_probe;
624 
625 found:
626  if (st->discard >= AVDISCARD_ALL)
627  goto skip;
628  if (startcode >= 0xa0 && startcode <= 0xaf) {
629  if (st->codecpar->codec_id == AV_CODEC_ID_MLP) {
630  if (len < 6)
631  goto skip;
632  avio_skip(s->pb, 6);
633  len -=6;
634  }
635  }
636  ret = av_get_packet(s->pb, pkt, len);
637 
638  pkt->pts = pts;
639  pkt->dts = dts;
640  pkt->pos = dummy_pos;
641  pkt->stream_index = st->index;
642 
643  if (s->debug & FF_FDEBUG_TS)
644  av_log(s, AV_LOG_DEBUG, "%d: pts=%0.3f dts=%0.3f size=%d\n",
645  pkt->stream_index, pkt->pts / 90000.0, pkt->dts / 90000.0,
646  pkt->size);
647 
648  return (ret < 0) ? ret : 0;
649 }
650 
651 static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index,
652  int64_t *ppos, int64_t pos_limit)
653 {
654  int len, startcode;
655  int64_t pos, pts, dts;
656 
657  pos = *ppos;
658  if (avio_seek(s->pb, pos, SEEK_SET) < 0)
659  return AV_NOPTS_VALUE;
660 
661  for (;;) {
662  len = mpegps_read_pes_header(s, &pos, &startcode, &pts, &dts);
663  if (len < 0) {
664  if (s->debug & FF_FDEBUG_TS)
665  av_log(s, AV_LOG_DEBUG, "none (ret=%d)\n", len);
666  return AV_NOPTS_VALUE;
667  }
668  if (startcode == s->streams[stream_index]->id &&
669  dts != AV_NOPTS_VALUE) {
670  break;
671  }
672  avio_skip(s->pb, len);
673  }
674  if (s->debug & FF_FDEBUG_TS)
675  av_log(s, AV_LOG_DEBUG, "pos=0x%"PRIx64" dts=0x%"PRIx64" %0.3f\n",
676  pos, dts, dts / 90000.0);
677  *ppos = pos;
678  return dts;
679 }
680 
682  .name = "mpeg",
683  .long_name = NULL_IF_CONFIG_SMALL("MPEG-PS (MPEG-2 Program Stream)"),
684  .priv_data_size = sizeof(MpegDemuxContext),
688  .read_timestamp = mpegps_read_dts,
690 };
691 
692 #if CONFIG_VOBSUB_DEMUXER
693 
694 #include "subtitles.h"
695 #include "libavutil/avassert.h"
696 #include "libavutil/bprint.h"
697 #include "libavutil/opt.h"
698 
699 #define REF_STRING "# VobSub index file,"
700 #define MAX_LINE_SIZE 2048
701 
702 typedef struct VobSubDemuxContext {
703  const AVClass *class;
704  AVFormatContext *sub_ctx;
705  FFDemuxSubtitlesQueue q[32];
706  char *sub_name;
707 } VobSubDemuxContext;
708 
709 static int vobsub_probe(const AVProbeData *p)
710 {
711  if (!strncmp(p->buf, REF_STRING, sizeof(REF_STRING) - 1))
712  return AVPROBE_SCORE_MAX;
713  return 0;
714 }
715 
716 static int vobsub_read_close(AVFormatContext *s)
717 {
718  VobSubDemuxContext *vobsub = s->priv_data;
719  int i;
720 
721  for (i = 0; i < s->nb_streams; i++)
722  ff_subtitles_queue_clean(&vobsub->q[i]);
723  if (vobsub->sub_ctx)
724  avformat_close_input(&vobsub->sub_ctx);
725  return 0;
726 }
727 
728 static int vobsub_read_header(AVFormatContext *s)
729 {
730  int i, ret = 0, header_parsed = 0, langidx = 0;
731  VobSubDemuxContext *vobsub = s->priv_data;
732  size_t fname_len;
733  AVBPrint header;
734  int64_t delay = 0;
735  AVStream *st = NULL;
736  int stream_id = -1;
737  char id[64] = {0};
738  char alt[MAX_LINE_SIZE] = {0};
740 
741  if (!vobsub->sub_name) {
742  char *ext;
743  vobsub->sub_name = av_strdup(s->url);
744  if (!vobsub->sub_name) {
745  return AVERROR(ENOMEM);
746  }
747 
748  fname_len = strlen(vobsub->sub_name);
749  ext = vobsub->sub_name - 3 + fname_len;
750  if (fname_len < 4 || *(ext - 1) != '.') {
751  av_log(s, AV_LOG_ERROR, "The input index filename is too short "
752  "to guess the associated .SUB file\n");
753  return AVERROR_INVALIDDATA;
754  }
755  memcpy(ext, !strncmp(ext, "IDX", 3) ? "SUB" : "sub", 3);
756  av_log(s, AV_LOG_VERBOSE, "IDX/SUB: %s -> %s\n", s->url, vobsub->sub_name);
757  }
758 
759  if (!(iformat = av_find_input_format("mpeg"))) {
761  }
762 
763  vobsub->sub_ctx = avformat_alloc_context();
764  if (!vobsub->sub_ctx) {
765  return AVERROR(ENOMEM);
766  }
767 
769 
770  if ((ret = ff_copy_whiteblacklists(vobsub->sub_ctx, s)) < 0)
771  goto end;
772 
773  ret = avformat_open_input(&vobsub->sub_ctx, vobsub->sub_name, iformat, NULL);
774  if (ret < 0) {
775  av_log(s, AV_LOG_ERROR, "Unable to open %s as MPEG subtitles\n", vobsub->sub_name);
776  goto end;
777  }
778 
779  while (!avio_feof(s->pb)) {
780  char line[MAX_LINE_SIZE];
781  int len = ff_get_line(s->pb, line, sizeof(line));
782 
783  if (!len)
784  break;
785 
786  line[strcspn(line, "\r\n")] = 0;
787 
788  if (!strncmp(line, "id:", 3)) {
789  if (sscanf(line, "id: %63[^,], index: %u", id, &stream_id) != 2) {
790  av_log(s, AV_LOG_WARNING, "Unable to parse index line '%s', "
791  "assuming 'id: und, index: 0'\n", line);
792  strcpy(id, "und");
793  stream_id = 0;
794  }
795 
796  if (stream_id >= FF_ARRAY_ELEMS(vobsub->q)) {
797  av_log(s, AV_LOG_ERROR, "Maximum number of subtitles streams reached\n");
798  ret = AVERROR(EINVAL);
799  goto end;
800  }
801 
802  header_parsed = 1;
803  alt[0] = '\0';
804  /* We do not create the stream immediately to avoid adding empty
805  * streams. See the following timestamp entry. */
806 
807  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] id=%s\n", stream_id, id);
808 
809  } else if (!strncmp(line, "timestamp:", 10)) {
810  AVPacket *sub;
811  int hh, mm, ss, ms;
812  int64_t pos, timestamp;
813  const char *p = line + 10;
814 
815  if (stream_id == -1) {
816  av_log(s, AV_LOG_ERROR, "Timestamp declared before any stream\n");
818  goto end;
819  }
820 
821  if (!st || st->id != stream_id) {
822  st = avformat_new_stream(s, NULL);
823  if (!st) {
824  ret = AVERROR(ENOMEM);
825  goto end;
826  }
827  st->id = stream_id;
830  avpriv_set_pts_info(st, 64, 1, 1000);
831  av_dict_set(&st->metadata, "language", id, 0);
832  if (alt[0])
833  av_dict_set(&st->metadata, "title", alt, 0);
834  }
835 
836  if (sscanf(p, "%02d:%02d:%02d:%03d, filepos: %"SCNx64,
837  &hh, &mm, &ss, &ms, &pos) != 5) {
838  av_log(s, AV_LOG_ERROR, "Unable to parse timestamp line '%s', "
839  "abort parsing\n", line);
841  goto end;
842  }
843  timestamp = (hh*3600LL + mm*60LL + ss) * 1000LL + ms + delay;
844  timestamp = av_rescale_q(timestamp, av_make_q(1, 1000), st->time_base);
845 
846  sub = ff_subtitles_queue_insert(&vobsub->q[s->nb_streams - 1], "", 0, 0);
847  if (!sub) {
848  ret = AVERROR(ENOMEM);
849  goto end;
850  }
851  sub->pos = pos;
852  sub->pts = timestamp;
853  sub->stream_index = s->nb_streams - 1;
854 
855  } else if (!strncmp(line, "alt:", 4)) {
856  const char *p = line + 4;
857 
858  while (*p == ' ')
859  p++;
860  av_log(s, AV_LOG_DEBUG, "IDX stream[%d] name=%s\n", stream_id, p);
861  av_strlcpy(alt, p, sizeof(alt));
862  header_parsed = 1;
863 
864  } else if (!strncmp(line, "delay:", 6)) {
865  int sign = 1, hh = 0, mm = 0, ss = 0, ms = 0;
866  const char *p = line + 6;
867 
868  while (*p == ' ')
869  p++;
870  if (*p == '-' || *p == '+') {
871  sign = *p == '-' ? -1 : 1;
872  p++;
873  }
874  sscanf(p, "%d:%d:%d:%d", &hh, &mm, &ss, &ms);
875  delay = ((hh*3600LL + mm*60LL + ss) * 1000LL + ms) * sign;
876 
877  } else if (!strncmp(line, "langidx:", 8)) {
878  const char *p = line + 8;
879 
880  if (sscanf(p, "%d", &langidx) != 1)
881  av_log(s, AV_LOG_ERROR, "Invalid langidx specified\n");
882 
883  } else if (!header_parsed) {
884  if (line[0] && line[0] != '#')
885  av_bprintf(&header, "%s\n", line);
886  }
887  }
888 
889  if (langidx < s->nb_streams)
890  s->streams[langidx]->disposition |= AV_DISPOSITION_DEFAULT;
891 
892  for (i = 0; i < s->nb_streams; i++) {
893  vobsub->q[i].sort = SUB_SORT_POS_TS;
894  vobsub->q[i].keep_duplicates = 1;
895  ff_subtitles_queue_finalize(s, &vobsub->q[i]);
896  }
897 
898  if (!av_bprint_is_complete(&header)) {
899  ret = AVERROR(ENOMEM);
900  goto end;
901  }
902  for (i = 0; i < s->nb_streams; i++) {
903  AVCodecParameters *par = s->streams[i]->codecpar;
904  ret = ff_alloc_extradata(par, header.len);
905  if (ret < 0) {
906  goto end;
907  }
908  memcpy(par->extradata, header.str, header.len);
909  }
910 end:
911  if (ret < 0)
912  vobsub_read_close(s);
914  return ret;
915 }
916 
917 static int vobsub_read_packet(AVFormatContext *s, AVPacket *pkt)
918 {
919  VobSubDemuxContext *vobsub = s->priv_data;
921  AVIOContext *pb = vobsub->sub_ctx->pb;
922  int ret, psize, total_read = 0, i;
923 
924  int64_t min_ts = INT64_MAX;
925  int sid = 0;
926  for (i = 0; i < s->nb_streams; i++) {
927  FFDemuxSubtitlesQueue *tmpq = &vobsub->q[i];
928  int64_t ts;
929  av_assert0(tmpq->nb_subs);
930 
931  if (tmpq->current_sub_idx >= tmpq->nb_subs)
932  continue;
933 
934  ts = tmpq->subs[tmpq->current_sub_idx].pts;
935  if (ts < min_ts) {
936  min_ts = ts;
937  sid = i;
938  }
939  }
940  q = &vobsub->q[sid];
941  /* The returned packet will have size zero,
942  * so that it can be directly used with av_grow_packet. */
944  if (ret < 0)
945  return ret;
946 
947  /* compute maximum packet size using the next packet position. This is
948  * useful when the len in the header is non-sense */
949  if (q->current_sub_idx < q->nb_subs) {
950  psize = q->subs[q->current_sub_idx].pos - pkt->pos;
951  } else {
952  int64_t fsize = avio_size(pb);
953  psize = fsize < 0 ? 0xffff : fsize - pkt->pos;
954  }
955 
956  avio_seek(pb, pkt->pos, SEEK_SET);
957 
958  do {
959  int n, to_read, startcode;
960  int64_t pts, dts;
961  int64_t old_pos = avio_tell(pb), new_pos;
962  int pkt_size;
963 
964  ret = mpegps_read_pes_header(vobsub->sub_ctx, NULL, &startcode, &pts, &dts);
965  if (ret < 0) {
966  if (pkt->size) // raise packet even if incomplete
967  break;
968  return ret;
969  }
970  to_read = ret & 0xffff;
971  new_pos = avio_tell(pb);
972  pkt_size = ret + (new_pos - old_pos);
973 
974  /* this prevents reads above the current packet */
975  if (total_read + pkt_size > psize)
976  break;
977  total_read += pkt_size;
978 
979  /* the current chunk doesn't match the stream index (unlikely) */
980  if ((startcode & 0x1f) != s->streams[pkt->stream_index]->id)
981  break;
982 
983  ret = av_grow_packet(pkt, to_read);
984  if (ret < 0)
985  return ret;
986 
987  n = avio_read(pb, pkt->data + (pkt->size - to_read), to_read);
988  if (n < to_read)
989  pkt->size -= to_read - n;
990  } while (total_read < psize);
991 
992  return 0;
993 }
994 
995 static int vobsub_read_seek(AVFormatContext *s, int stream_index,
996  int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
997 {
998  VobSubDemuxContext *vobsub = s->priv_data;
999 
1000  /* Rescale requested timestamps based on the first stream (timebase is the
1001  * same for all subtitles stream within a .idx/.sub). Rescaling is done just
1002  * like in avformat_seek_file(). */
1003  if (stream_index == -1 && s->nb_streams != 1) {
1004  int i, ret = 0;
1005  AVRational time_base = s->streams[0]->time_base;
1006  ts = av_rescale_q(ts, AV_TIME_BASE_Q, time_base);
1007  min_ts = av_rescale_rnd(min_ts, time_base.den,
1008  time_base.num * (int64_t)AV_TIME_BASE,
1010  max_ts = av_rescale_rnd(max_ts, time_base.den,
1011  time_base.num * (int64_t)AV_TIME_BASE,
1013  for (i = 0; i < s->nb_streams; i++) {
1014  int r = ff_subtitles_queue_seek(&vobsub->q[i], s, stream_index,
1015  min_ts, ts, max_ts, flags);
1016  if (r < 0)
1017  ret = r;
1018  }
1019  return ret;
1020  }
1021 
1022  if (stream_index == -1) // only 1 stream
1023  stream_index = 0;
1024  return ff_subtitles_queue_seek(&vobsub->q[stream_index], s, stream_index,
1025  min_ts, ts, max_ts, flags);
1026 }
1027 
1028 static const AVOption options[] = {
1029  { "sub_name", "URI for .sub file", offsetof(VobSubDemuxContext, sub_name), AV_OPT_TYPE_STRING, { .str = NULL }, 0, 0, AV_OPT_FLAG_DECODING_PARAM },
1030  { NULL }
1031 };
1032 
1033 static const AVClass vobsub_demuxer_class = {
1034  .class_name = "vobsub",
1035  .item_name = av_default_item_name,
1036  .option = options,
1037  .version = LIBAVUTIL_VERSION_INT,
1038 };
1039 
1041  .name = "vobsub",
1042  .long_name = NULL_IF_CONFIG_SMALL("VobSub subtitle format"),
1043  .priv_data_size = sizeof(VobSubDemuxContext),
1044  .read_probe = vobsub_probe,
1045  .read_header = vobsub_read_header,
1046  .read_packet = vobsub_read_packet,
1047  .read_seek2 = vobsub_read_seek,
1048  .read_close = vobsub_read_close,
1049  .flags = AVFMT_SHOW_IDS,
1050  .extensions = "idx",
1051  .priv_class = &vobsub_demuxer_class,
1052 };
1053 #endif
AVMEDIA_TYPE_SUBTITLE
@ AVMEDIA_TYPE_SUBTITLE
Definition: avutil.h:204
MAX_LINE_SIZE
#define MAX_LINE_SIZE
Definition: vf_lut3d.c:483
AV_LOG_WARNING
#define AV_LOG_WARNING
Something somehow does not look correct.
Definition: log.h:182
AVCodecParameters::extradata
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
Definition: codec_par.h:74
AV_CODEC_ID_AC3
@ AV_CODEC_ID_AC3
Definition: codec_id.h:413
SYSTEM_HEADER_START_CODE
#define SYSTEM_HEADER_START_CODE
Definition: mpeg.h:29
mpegps_read_packet
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
Definition: mpeg.c:472
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:4519
AVCodecParameters::codec_type
enum AVMediaType codec_type
General type of the encoded data.
Definition: codec_par.h:56
AVFMT_SHOW_IDS
#define AVFMT_SHOW_IDS
Show format stream IDs numbers.
Definition: avformat.h:460
av_bprint_finalize
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
Definition: bprint.c:235
FF_FDEBUG_TS
#define FF_FDEBUG_TS
Definition: avformat.h:1619
FFERROR_REDO
#define FFERROR_REDO
Returned by demuxers to indicate that data was consumed but discarded (ignored streams or junk data).
Definition: internal.h:633
STREAM_TYPE_AUDIO_AAC
#define STREAM_TYPE_AUDIO_AAC
Definition: mpeg.h:55
ff_parse_pes_pts
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
Definition: mpeg.h:68
av_bprint_init
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
Definition: bprint.c:69
AVCodecParameters
This struct describes the properties of an encoded stream.
Definition: codec_par.h:52
AVERROR_EOF
#define AVERROR_EOF
End of file.
Definition: error.h:55
AVStream::discard
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
Definition: avformat.h:920
AV_CH_LAYOUT_MONO
#define AV_CH_LAYOUT_MONO
Definition: channel_layout.h:85
FFDemuxSubtitlesQueue::nb_subs
int nb_subs
number of subtitles packets
Definition: subtitles.h:104
AV_TIME_BASE_Q
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
Definition: avutil.h:260
av_grow_packet
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
Definition: avpacket.c:111
AV_DISPOSITION_DEFAULT
#define AV_DISPOSITION_DEFAULT
Definition: avformat.h:810
AV_CODEC_ID_MPEG4
@ AV_CODEC_ID_MPEG4
Definition: codec_id.h:61
end
static av_cold int end(AVCodecContext *avctx)
Definition: avrndec.c:90
STREAM_TYPE_AUDIO_MPEG1
#define STREAM_TYPE_AUDIO_MPEG1
Definition: mpeg.h:51
AVPacket::data
uint8_t * data
Definition: packet.h:355
AVOption
AVOption.
Definition: opt.h:246
find_next_start_code
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
Definition: mpeg.c:157
AV_LOG_VERBOSE
#define AV_LOG_VERBOSE
Detailed information.
Definition: log.h:192
AUDIO_ID
#define AUDIO_ID
Definition: mpeg.h:41
AVProbeData::buf_size
int buf_size
Size of buf except extra allocated bytes.
Definition: avformat.h:444
avio_size
int64_t avio_size(AVIOContext *s)
Get the filesize.
Definition: aviobuf.c:334
AV_CODEC_ID_TRUEHD
@ AV_CODEC_ID_TRUEHD
Definition: codec_id.h:454
MpegDemuxContext::dvd
int dvd
Definition: mpeg.c:121
av_malloc
#define av_malloc(s)
Definition: tableprint_vlc.h:31
STREAM_TYPE_AUDIO_MPEG2
#define STREAM_TYPE_AUDIO_MPEG2
Definition: mpeg.h:52
ff_const59
#define ff_const59
The ff_const59 define is not part of the public API and will be removed without further warning.
Definition: avformat.h:535
FFDemuxSubtitlesQueue::current_sub_idx
int current_sub_idx
current position for the read packet callback
Definition: subtitles.h:106
AVINDEX_KEYFRAME
#define AVINDEX_KEYFRAME
Definition: avformat.h:803
AVPROBE_SCORE_MAX
#define AVPROBE_SCORE_MAX
maximum score
Definition: avformat.h:453
avformat_close_input
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
Definition: utils.c:4491
AVCodecParameters::channels
int channels
Audio only.
Definition: codec_par.h:166
av_add_index_entry
int av_add_index_entry(AVStream *st, int64_t pos, int64_t timestamp, int size, int distance, int flags)
Add an index entry into a sorted list.
Definition: utils.c:2045
read_close
static av_cold int read_close(AVFormatContext *ctx)
Definition: libcdio.c:145
avio_tell
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
Definition: avio.h:557
val
static double val(void *priv, double ch)
Definition: aeval.c:76
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:647
AV_ROUND_UP
@ AV_ROUND_UP
Round toward +infinity.
Definition: mathematics.h:83
ff_mpegps_demuxer
AVInputFormat ff_mpegps_demuxer
Definition: mpeg.c:681
AV_CODEC_ID_MP3
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
Definition: codec_id.h:411
ss
#define ss(width, name, subs,...)
Definition: cbs_vp9.c:261
AVRational::num
int num
Numerator.
Definition: rational.h:59
ff_subtitles_queue_seek
int ff_subtitles_queue_seek(FFDemuxSubtitlesQueue *q, AVFormatContext *s, int stream_index, int64_t min_ts, int64_t ts, int64_t max_ts, int flags)
Update current_sub_idx to emulate a seek.
Definition: subtitles.c:250
avassert.h
avio_rb32
unsigned int avio_rb32(AVIOContext *s)
Definition: aviobuf.c:778
AV_LOG_ERROR
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
Definition: log.h:176
PROGRAM_STREAM_MAP
#define PROGRAM_STREAM_MAP
Definition: mpeg.h:36
AVInputFormat
Definition: avformat.h:636
STREAM_TYPE_AUDIO_AC3
#define STREAM_TYPE_AUDIO_AC3
Definition: mpeg.h:61
STREAM_TYPE_VIDEO_MPEG4
#define STREAM_TYPE_VIDEO_MPEG4
Definition: mpeg.h:56
s
#define s(width, name)
Definition: cbs_vp9.c:257
AVInputFormat::name
const char * name
A comma separated list of short names for the format.
Definition: avformat.h:641
AVProbeData::buf
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Definition: avformat.h:443
AVMEDIA_TYPE_AUDIO
@ AVMEDIA_TYPE_AUDIO
Definition: avutil.h:202
AV_CODEC_ID_MP2
@ AV_CODEC_ID_MP2
Definition: codec_id.h:410
get_pts
static int64_t get_pts(AVIOContext *pb, int c)
Definition: mpeg.c:147
av_assert0
#define av_assert0(cond)
assert() equivalent, that is always enabled.
Definition: avassert.h:37
AV_LOG_DEBUG
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
Definition: log.h:197
AVStream::need_parsing
enum AVStreamParseType need_parsing
Definition: avformat.h:1083
nb_streams
static int nb_streams
Definition: ffprobe.c:282
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
AV_CODEC_ID_PCM_MULAW
@ AV_CODEC_ID_PCM_MULAW
Definition: codec_id.h:307
codec_id
enum AVCodecID codec_id
Definition: vaapi_decode.c:369
AV_CODEC_ID_PCM_DVD
@ AV_CODEC_ID_PCM_DVD
Definition: codec_id.h:320
AVMEDIA_TYPE_DATA
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
Definition: avutil.h:203
STREAM_TYPE_VIDEO_MPEG1
#define STREAM_TYPE_VIDEO_MPEG1
Definition: mpeg.h:49
fsize
static int64_t fsize(FILE *f)
Definition: audiomatch.c:28
ff_subtitles_queue_read_packet
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
Generic read_packet() callback for subtitles demuxers using this queue system.
Definition: subtitles.c:212
AV_CODEC_ID_H264
@ AV_CODEC_ID_H264
Definition: codec_id.h:76
int32_t
int32_t
Definition: audio_convert.c:194
AV_CODEC_ID_DVD_NAV
@ AV_CODEC_ID_DVD_NAV
Definition: codec_id.h:547
if
if(ret)
Definition: filter_design.txt:179
AVERROR_DEMUXER_NOT_FOUND
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
Definition: error.h:53
SUB_SORT_POS_TS
@ SUB_SORT_POS_TS
sort by position, then timestamps
Definition: subtitles.h:31
AVDISCARD_ALL
@ AVDISCARD_ALL
discard all
Definition: avcodec.h:236
AVFormatContext
Format I/O context.
Definition: avformat.h:1335
AV_CODEC_ID_PCM_ALAW
@ AV_CODEC_ID_PCM_ALAW
Definition: codec_id.h:308
internal.h
mpegps_read_header
static int mpegps_read_header(AVFormatContext *s)
Definition: mpeg.c:126
AVStream::codecpar
AVCodecParameters * codecpar
Codec parameters associated with this stream.
Definition: avformat.h:1012
LIBAVUTIL_VERSION_INT
#define LIBAVUTIL_VERSION_INT
Definition: version.h:85
hours
FFmpeg Automated Testing Environment ************************************Introduction Using FATE from your FFmpeg source directory Submitting the results to the FFmpeg result aggregation server Uploading new samples to the fate suite FATE makefile targets and variables Makefile targets Makefile variables Examples Introduction **************FATE is an extended regression suite on the client side and a means for results aggregation and presentation on the server side The first part of this document explains how you can use FATE from your FFmpeg source directory to test your ffmpeg binary The second part describes how you can run FATE to submit the results to FFmpeg’s FATE server In any way you can have a look at the publicly viewable FATE results by visiting this as it can be seen if some test on some platform broke with their recent contribution This usually happens on the platforms the developers could not test on The second part of this document describes how you can run FATE to submit your results to FFmpeg’s FATE server If you want to submit your results be sure to check that your combination of OS and compiler is not already listed on the above mentioned website In the third part you can find a comprehensive listing of FATE makefile targets and variables Using FATE from your FFmpeg source directory **********************************************If you want to run FATE on your machine you need to have the samples in place You can get the samples via the build target fate rsync Use this command from the top level source this will cause FATE to fail NOTE To use a custom wrapper to run the pass ‘ target exec’ to ‘configure’ or set the TARGET_EXEC Make variable Submitting the results to the FFmpeg result aggregation server ****************************************************************To submit your results to the server you should run fate through the shell script ‘tests fate sh’ from the FFmpeg sources This script needs to be invoked with a configuration file as its first argument tests fate sh path to fate_config A configuration file template with comments describing the individual configuration variables can be found at ‘doc fate_config sh template’ Create a configuration that suits your based on the configuration template The ‘slot’ configuration variable can be any string that is not yet but it is suggested that you name it adhering to the following pattern ‘ARCH OS COMPILER COMPILER VERSION’ The configuration file itself will be sourced in a shell therefore all shell features may be used This enables you to setup the environment as you need it for your build For your first test runs the ‘fate_recv’ variable should be empty or commented out This will run everything as normal except that it will omit the submission of the results to the server The following files should be present in $workdir as specified in the configuration it may help to try out the ‘ssh’ command with one or more ‘ v’ options You should get detailed output concerning your SSH configuration and the authentication process The only thing left is to automate the execution of the fate sh script and the synchronisation of the samples directory Uploading new samples to the fate suite *****************************************If you need a sample uploaded send a mail to samples request This is for developers who have an account on the fate suite server If you upload new please make sure they are as small as space on each network bandwidth and so on benefit from smaller test cases Also keep in mind older checkouts use existing sample that means in practice generally do not remove or overwrite files as it likely would break older checkouts or releases Also all needed samples for a commit should be ideally hours
Definition: fate.txt:145
read_header
static int read_header(FFV1Context *f)
Definition: ffv1dec.c:527
AVClass
Describe the class of an AVClass context structure.
Definition: log.h:67
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:894
NULL
#define NULL
Definition: coverity.c:32
read_probe
static int read_probe(const AVProbeData *pd)
Definition: jvdec.c:55
AVFMTCTX_NOHEADER
#define AVFMTCTX_NOHEADER
signal that no header is present (streams are added dynamically)
Definition: avformat.h:1284
check_pes
static int check_pes(const uint8_t *p, const uint8_t *end)
Definition: mpeg.c:32
AVRational
Rational number (pair of numerator and denominator).
Definition: rational.h:58
AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_DVD_SUBTITLE
Definition: codec_id.h:508
av_default_item_name
const char * av_default_item_name(void *ptr)
Return the context name.
Definition: log.c:235
AVProbeData
This structure contains the data a format has to probe a file.
Definition: avformat.h:441
AVStream::metadata
AVDictionary * metadata
Definition: avformat.h:929
PACK_START_CODE
#define PACK_START_CODE
Definition: mpeg.h:28
ff_subtitles_queue_insert
AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)
Insert a new subtitle event.
Definition: subtitles.c:111
AV_RB32
#define AV_RB32
Definition: intreadwrite.h:130
MpegDemuxContext::sofdec
int sofdec
Definition: mpeg.c:120
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
AVPROBE_SCORE_EXTENSION
#define AVPROBE_SCORE_EXTENSION
score for file extension
Definition: avformat.h:451
AVCodecParameters::sample_rate
int sample_rate
Audio only.
Definition: codec_par.h:170
av_bprint_is_complete
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
Definition: bprint.h:185
AVCodecID
AVCodecID
Identify the syntax and semantics of the bitstream.
Definition: codec_id.h:46
AV_CODEC_ID_AAC
@ AV_CODEC_ID_AAC
Definition: codec_id.h:412
av_rescale_rnd
int64_t av_rescale_rnd(int64_t a, int64_t b, int64_t c, enum AVRounding rnd)
Rescale a 64-bit integer with specified rounding.
Definition: mathematics.c:58
options
const OptionDef options[]
AVIOContext
Bytestream IO Context.
Definition: avio.h:161
avio_rb24
unsigned int avio_rb24(AVIOContext *s)
Definition: aviobuf.c:771
MpegDemuxContext::psm_es_type
unsigned char psm_es_type[256]
Definition: mpeg.c:119
AVMediaType
AVMediaType
Definition: avutil.h:199
AV_CODEC_ID_ADPCM_ADX
@ AV_CODEC_ID_ADPCM_ADX
Definition: codec_id.h:349
AVPacket::size
int size
Definition: packet.h:356
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:186
PRIVATE_STREAM_1
#define PRIVATE_STREAM_1
Definition: mpeg.h:37
check_pack_header
static int check_pack_header(const uint8_t *buf)
Definition: mpeg.c:54
avformat_alloc_context
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
Definition: options.c:144
STREAM_TYPE_VIDEO_HEVC
#define STREAM_TYPE_VIDEO_HEVC
Definition: mpeg.h:58
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:4938
AV_CODEC_ID_DTS
@ AV_CODEC_ID_DTS
Definition: codec_id.h:414
ff_copy_whiteblacklists
int ff_copy_whiteblacklists(AVFormatContext *dst, const AVFormatContext *src)
Copies the whilelists from one context to the other.
Definition: utils.c:159
avio_get_str
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
Definition: aviobuf.c:857
size
int size
Definition: twinvq_data.h:11134
av_make_q
static AVRational av_make_q(int num, int den)
Create an AVRational.
Definition: rational.h:71
state
static struct @314 state
AV_NOPTS_VALUE
#define AV_NOPTS_VALUE
Undefined timestamp value.
Definition: avutil.h:248
MpegDemuxContext::header_state
int32_t header_state
Definition: mpeg.c:118
ff_subtitles_queue_finalize
void ff_subtitles_queue_finalize(void *log_ctx, FFDemuxSubtitlesQueue *q)
Set missing durations, sort subtitles by PTS (and then byte position), and drop duplicated events.
Definition: subtitles.c:194
FFDemuxSubtitlesQueue
Definition: subtitles.h:102
header
static const uint8_t header[24]
Definition: sdr2.c:67
AVPacket::dts
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
Definition: packet.h:354
avio_r8
int avio_r8(AVIOContext *s)
Definition: aviobuf.c:616
STREAM_TYPE_VIDEO_MPEG2
#define STREAM_TYPE_VIDEO_MPEG2
Definition: mpeg.h:50
ffio_ensure_seekback
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
Definition: aviobuf.c:982
ff_subtitles_queue_clean
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
Definition: subtitles.c:302
mpeg.h
line
Definition: graph2dot.c:48
MpegDemuxContext::imkh_cctv
int imkh_cctv
Definition: mpeg.c:122
MpegDemuxContext::raw_ac3
int raw_ac3
Definition: mpeg.c:123
r
#define r
Definition: input.c:40
PRIVATE_STREAM_2
#define PRIVATE_STREAM_2
Definition: mpeg.h:39
av_find_input_format
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
Definition: format.c:118
bprint.h
AV_CODEC_ID_NONE
@ AV_CODEC_ID_NONE
Definition: codec_id.h:47
i
#define i(width, name, range_min, range_max)
Definition: cbs_h2645.c:269
AVPacket::pts
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
Definition: packet.h:348
code
and forward the test the status of outputs and forward it to the corresponding return FFERROR_NOT_READY If the filters stores internally one or a few frame for some it can consider them to be part of the FIFO and delay acknowledging a status change accordingly Example code
Definition: filter_design.txt:178
avio_internal.h
avformat_open_input
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
Definition: utils.c:533
AV_TIME_BASE
#define AV_TIME_BASE
Internal time base represented as integer.
Definition: avutil.h:254
FFDemuxSubtitlesQueue::subs
AVPacket * subs
array of subtitles packets
Definition: subtitles.h:103
AV_CODEC_ID_CAVS
@ AV_CODEC_ID_CAVS
Definition: codec_id.h:136
AV_ROUND_DOWN
@ AV_ROUND_DOWN
Round toward -infinity.
Definition: mathematics.h:82
AV_CODEC_ID_HEVC
@ AV_CODEC_ID_HEVC
Definition: codec_id.h:223
xf
#define xf(width, name, var, range_min, range_max, subs,...)
Definition: cbs_av1.c:667
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:277
uint8_t
uint8_t
Definition: audio_convert.c:194
ff_get_line
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
Definition: aviobuf.c:786
AV_CODEC_ID_VC1
@ AV_CODEC_ID_VC1
Definition: codec_id.h:119
len
int len
Definition: vorbis_enc_data.h:452
av_get_packet
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
Allocate and read the payload of a packet and initialize its fields with default values.
Definition: utils.c:304
AVStream::id
int id
Format-specific stream ID.
Definition: avformat.h:872
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:865
avio_seek
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
Definition: aviobuf.c:241
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:72
avio_rb16
unsigned int avio_rb16(AVIOContext *s)
Definition: aviobuf.c:763
pos
unsigned int pos
Definition: spdifenc.c:410
avformat.h
iformat
static AVInputFormat * iformat
Definition: ffprobe.c:259
av_bprintf
void av_bprintf(AVBPrint *buf, const char *fmt,...)
Definition: bprint.c:94
AV_INPUT_BUFFER_PADDING_SIZE
#define AV_INPUT_BUFFER_PADDING_SIZE
Definition: avcodec.h:215
mpegps_psm_parse
static long mpegps_psm_parse(MpegDemuxContext *m, AVIOContext *pb)
Extract stream types from a program stream map According to ISO/IEC 13818-1 ('MPEG-2 Systems') table ...
Definition: mpeg.c:191
FF_ARRAY_ELEMS
#define FF_ARRAY_ELEMS(a)
Definition: sinewin_tablegen_template.c:38
VIDEO_ID
#define VIDEO_ID
Definition: mpeg.h:42
AVStream::index
int index
stream index in AVFormatContext
Definition: avformat.h:866
STREAM_TYPE_VIDEO_H264
#define STREAM_TYPE_VIDEO_H264
Definition: mpeg.h:57
subtitles.h
ff_vobsub_demuxer
AVInputFormat ff_vobsub_demuxer
PADDING_STREAM
#define PADDING_STREAM
Definition: mpeg.h:38
pkt
static AVPacket pkt
Definition: demuxing_decoding.c:54
AVIO_SEEKABLE_NORMAL
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
Definition: avio.h:40
buffer
the frame and frame reference mechanism is intended to as much as expensive copies of that data while still allowing the filters to produce correct results The data is stored in buffers represented by AVFrame structures Several references can point to the same frame buffer
Definition: filter_design.txt:49
ff_reduce_index
void ff_reduce_index(AVFormatContext *s, int stream_index)
Ensure the index uses less memory than the maximum specified in AVFormatContext.max_index_size by dis...
Definition: utils.c:1973
AVRational::den
int den
Denominator.
Definition: rational.h:60
avio_read
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
Definition: aviobuf.c:625
AVStream::request_probe
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
Definition: avformat.h:1122
AVPacket::stream_index
int stream_index
Definition: packet.h:357
avio_skip
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
Definition: aviobuf.c:329
av_strdup
char * av_strdup(const char *s)
Duplicate a string.
Definition: mem.c:253
AVMEDIA_TYPE_VIDEO
@ AVMEDIA_TYPE_VIDEO
Definition: avutil.h:201
AVFMT_TS_DISCONT
#define AVFMT_TS_DISCONT
Format allows timestamp discontinuities.
Definition: avformat.h:464
av_free
#define av_free(p)
Definition: tableprint_vlc.h:34
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:332
mpegps_read_pes_header
static int mpegps_read_pes_header(AVFormatContext *s, int64_t *ppos, int *pstart_code, int64_t *ppts, int64_t *pdts)
Definition: mpeg.c:225
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:70
AVPacket::pos
int64_t pos
byte position in stream, -1 if unknown
Definition: packet.h:375
mpegps_probe
static int mpegps_probe(const AVProbeData *p)
Definition: mpeg.c:59
AVCodecParameters::channel_layout
uint64_t channel_layout
Audio only.
Definition: codec_par.h:162
AVSTREAM_PARSE_FULL
@ AVSTREAM_PARSE_FULL
full parsing and repack
Definition: avformat.h:786
flags
#define flags(name, subs,...)
Definition: cbs_av1.c:564
av_strlcpy
size_t av_strlcpy(char *dst, const char *src, size_t size)
Copy the string src to dst, but no more than size - 1 bytes, and null-terminate dst.
Definition: avstring.c:83
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:59
mpegps_read_dts
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
Definition: mpeg.c:651
MAX_SYNC_SIZE
#define MAX_SYNC_SIZE
Definition: mpeg.c:30
AV_OPT_TYPE_STRING
@ AV_OPT_TYPE_STRING
Definition: opt.h:227
MpegDemuxContext
Definition: mpeg.c:117
AV_CODEC_ID_MPEG2VIDEO
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
Definition: codec_id.h:51
AV_CODEC_ID_MLP
@ AV_CODEC_ID_MLP
Definition: codec_id.h:439
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:3321
avio_feof
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
Definition: aviobuf.c:356