30 #define MAX_SYNC_SIZE 100000
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));
40 for (p += 3; p < end && *p == 0xFF; p++) ;
41 if ((*p & 0xC0) == 0x40)
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;
56 return (buf[1] & 0xC0) == 0x40 || (buf[1] & 0xF0) == 0x20;
63 int sys = 0, pspack = 0, priv1 = 0, vid = 0;
64 int audio = 0, invalid = 0, score = 0;
69 if ((
code & 0xffffff00) == 0x100) {
86 else if (
code == 0x1fd && pes) vid++;
94 if (vid + audio > invalid + 1)
100 if (sys > invalid && sys * 9 <= pspack * 10)
103 if (pspack > invalid && (priv1 + vid + audio) * 10 >= pspack * 9)
106 if ((!!vid ^ !!audio) && (audio > 4 || vid > 1) && !sys &&
107 !pspack && p->
buf_size > 2048 && vid + audio > invalid)
136 if (!memcmp(
"IMKH",
buffer, 4)) {
138 }
else if (!memcmp(
"Sofdec",
buffer, 6)) {
163 unsigned int state, v;
166 state = *header_state;
173 if (
state == 0x000001) {
183 *header_state =
state;
196 int psm_length, ps_info_length, es_map_length;
207 es_map_length = psm_length - ps_info_length - 10;
210 while (es_map_length >= 4) {
212 unsigned char es_id =
avio_r8(pb);
219 es_map_length -= 4 + es_info_length;
222 return 2 + psm_length;
229 int64_t *ppos,
int *pstart_code,
230 int64_t *ppts, int64_t *pdts)
234 int pes_ext, ext2_len, id_ext, skip;
271 if (bytesread !=
len) {
276 p = memchr(ps2buf,
'S',
len - 5);
279 m->
sofdec = !memcmp(p+1,
"ofdec", 5);
284 if (
len == 980 && ps2buf[0] == 0) {
286 uint32_t startpts =
AV_RB32(ps2buf + 0x0d);
287 uint32_t endpts =
AV_RB32(ps2buf + 0x11);
288 uint8_t hours = ((ps2buf[0x19] >> 4) * 10) + (ps2buf[0x19] & 0x0f);
289 uint8_t mins = ((ps2buf[0x1a] >> 4) * 10) + (ps2buf[0x1a] & 0x0f);
290 uint8_t secs = ((ps2buf[0x1b] >> 4) * 10) + (ps2buf[0x1b] & 0x0f);
292 m->
dvd = (hours <= 23 &&
295 (ps2buf[0x19] & 0x0f) < 10 &&
296 (ps2buf[0x1a] & 0x0f) < 10 &&
297 (ps2buf[0x1b] & 0x0f) < 10 &&
299 }
else if (
len == 1018 && ps2buf[0] == 1) {
301 uint8_t hours = ((ps2buf[0x1d] >> 4) * 10) + (ps2buf[0x1d] & 0x0f);
302 uint8_t mins = ((ps2buf[0x1e] >> 4) * 10) + (ps2buf[0x1e] & 0x0f);
303 uint8_t secs = ((ps2buf[0x1f] >> 4) * 10) + (ps2buf[0x1f] & 0x0f);
305 m->
dvd = (hours <= 23 &&
308 (ps2buf[0x1d] & 0x0f) < 10 &&
309 (ps2buf[0x1e] & 0x0f) < 10 &&
310 (ps2buf[0x1f] & 0x0f) < 10);
333 }
else if (!m->
dvd) {
345 if (!((startcode >= 0x1c0 && startcode <= 0x1df) ||
346 (startcode >= 0x1e0 && startcode <= 0x1ef) ||
347 (startcode == 0x1bd) ||
349 (startcode == 0x1fd)))
369 if ((
c & 0xc0) == 0x40) {
375 if ((
c & 0xe0) == 0x20) {
383 }
else if ((
c & 0xc0) == 0x80) {
388 if (header_len >
len)
399 if (
flags & 0x3f && header_len == 0) {
408 skip = (pes_ext >> 4) & 0xb;
410 if (pes_ext & 0x40 || skip > header_len) {
417 if (pes_ext & 0x01) {
420 if ((ext2_len & 0x7f) > 0) {
422 if ((id_ext & 0x80) == 0)
423 startcode = ((startcode & 0xff) << 8) | id_ext;
443 if (startcode == 0x0b) {
459 for (
i = 0;
i <
s->nb_streams;
i++) {
460 if (startcode ==
s->streams[
i]->id &&
469 *pstart_code = startcode;
480 int len, startcode,
i, es_type, ret;
482 int request_probe= 0;
485 int64_t
pts, dts, dummy_pos;
492 if (startcode >= 0x80 && startcode <= 0xcf) {
500 if (startcode >= 0xb0 && startcode <= 0xbf) {
504 }
else if (startcode >= 0xa0 && startcode <= 0xaf) {
515 for (
i = 0;
i <
s->nb_streams;
i++) {
517 if (st->
id == startcode)
547 }
else if (m->
imkh_cctv && es_type == 0x91) {
550 }
else if (startcode >= 0x1e0 && startcode <= 0x1ef) {
551 static const unsigned char avs_seqh[4] = { 0, 0, 1, 0xb0 };
552 unsigned char buf[8];
556 if (!memcmp(buf, avs_seqh, 4) && (buf[6] != 0 || buf[7] != 1))
564 }
else if (startcode >= 0x1c0 && startcode <= 0x1df) {
570 }
else if (m->
imkh_cctv && startcode == 0x1c0 &&
len > 80) {
578 }
else if (startcode >= 0x80 && startcode <= 0x87) {
581 }
else if ((startcode >= 0x88 && startcode <= 0x8f) ||
582 (startcode >= 0x98 && startcode <= 0x9f)) {
586 }
else if (startcode >= 0xa0 && startcode <= 0xaf) {
593 }
else if (startcode >= 0xb0 && startcode <= 0xbf) {
596 }
else if (startcode >= 0xc0 && startcode <= 0xcf) {
600 }
else if (startcode >= 0x20 && startcode <= 0x3f) {
603 }
else if (startcode >= 0xfd55 && startcode <= 0xfd5f) {
631 if (startcode >= 0xa0 && startcode <= 0xaf) {
651 return (ret < 0) ? ret : 0;
655 int64_t *ppos, int64_t pos_limit)
671 if (startcode ==
s->streams[stream_index]->id &&
679 pos, dts, dts / 90000.0);
695 #if CONFIG_VOBSUB_DEMUXER
702 #define REF_STRING "# VobSub index file,"
703 #define MAX_LINE_SIZE 2048
705 typedef struct VobSubDemuxContext {
710 } VobSubDemuxContext;
714 if (!strncmp(p->
buf, REF_STRING,
sizeof(REF_STRING) - 1))
721 VobSubDemuxContext *vobsub =
s->priv_data;
724 for (
i = 0;
i <
s->nb_streams;
i++)
733 int i, ret = 0, header_parsed = 0, langidx = 0;
734 VobSubDemuxContext *vobsub =
s->priv_data;
744 if (!vobsub->sub_name) {
747 if (!vobsub->sub_name) {
751 fname_len = strlen(vobsub->sub_name);
752 ext = vobsub->sub_name - 3 + fname_len;
753 if (fname_len < 4 || *(ext - 1) !=
'.') {
755 "to guess the associated .SUB file\n");
758 memcpy(ext, !strncmp(ext,
"IDX", 3) ?
"SUB" :
"sub", 3);
767 if (!vobsub->sub_ctx) {
791 if (!strncmp(
line,
"id:", 3)) {
792 if (sscanf(
line,
"id: %63[^,], index: %u",
id, &stream_id) != 2) {
794 "assuming 'id: und, index: 0'\n",
line);
812 }
else if (!strncmp(
line,
"timestamp:", 10)) {
815 int64_t
pos, timestamp;
816 const char *p =
line + 10;
818 if (stream_id == -1) {
824 if (!st || st->
id != stream_id) {
839 if (sscanf(p,
"%02d:%02d:%02d:%03d, filepos: %"SCNx64,
840 &hh, &mm, &
ss, &ms, &
pos) != 5) {
842 "abort parsing\n",
line);
846 timestamp = (hh*3600LL + mm*60LL +
ss) * 1000LL + ms + delay;
855 sub->pts = timestamp;
856 sub->stream_index =
s->nb_streams - 1;
858 }
else if (!strncmp(
line,
"alt:", 4)) {
859 const char *p =
line + 4;
867 }
else if (!strncmp(
line,
"delay:", 6)) {
868 int sign = 1, hh = 0, mm = 0,
ss = 0, ms = 0;
869 const char *p =
line + 6;
873 if (*p ==
'-' || *p ==
'+') {
874 sign = *p ==
'-' ? -1 : 1;
877 sscanf(p,
"%d:%d:%d:%d", &hh, &mm, &
ss, &ms);
878 delay = ((hh*3600LL + mm*60LL +
ss) * 1000LL + ms) * sign;
880 }
else if (!strncmp(
line,
"langidx:", 8)) {
881 const char *p =
line + 8;
883 if (sscanf(p,
"%d", &langidx) != 1)
886 }
else if (!header_parsed) {
895 for (
i = 0;
i <
s->nb_streams;
i++) {
897 vobsub->q[
i].keep_duplicates = 1;
905 for (
i = 0;
i <
s->nb_streams;
i++) {
915 vobsub_read_close(
s);
922 VobSubDemuxContext *vobsub =
s->priv_data;
925 int ret, psize, total_read = 0,
i;
927 int64_t min_ts = INT64_MAX;
929 for (
i = 0;
i <
s->nb_streams;
i++) {
962 int n, to_read, startcode;
964 int64_t old_pos =
avio_tell(pb), new_pos;
973 to_read = ret & 0xffff;
975 pkt_size = ret + (new_pos - old_pos);
978 if (total_read + pkt_size > psize)
980 total_read += pkt_size;
993 }
while (total_read < psize);
999 int64_t min_ts, int64_t ts, int64_t max_ts,
int flags)
1001 VobSubDemuxContext *vobsub =
s->priv_data;
1006 if (stream_index == -1 &&
s->nb_streams != 1) {
1016 for (
i = 0;
i <
s->nb_streams;
i++) {
1018 min_ts, ts, max_ts,
flags);
1025 if (stream_index == -1)
1028 min_ts, ts, max_ts,
flags);
1036 static const AVClass vobsub_demuxer_class = {
1046 .priv_data_size =
sizeof(VobSubDemuxContext),
1050 .read_seek2 = vobsub_read_seek,
1053 .extensions =
"idx",
1054 .priv_class = &vobsub_demuxer_class,
static double val(void *priv, double ch)
static int64_t fsize(FILE *f)
simple assert() macros that are a bit more flexible than ISO C assert().
#define av_assert0(cond)
assert() equivalent, that is always enabled.
int64_t avio_seek(AVIOContext *s, int64_t offset, int whence)
fseek() equivalent for AVIOContext.
#define AVIO_SEEKABLE_NORMAL
Seeking works like for a local file.
int64_t avio_size(AVIOContext *s)
Get the filesize.
unsigned int avio_rb16(AVIOContext *s)
int avio_feof(AVIOContext *s)
Similar to feof() but also returns nonzero on read errors.
static av_always_inline int64_t avio_tell(AVIOContext *s)
ftell() equivalent for AVIOContext.
int64_t avio_skip(AVIOContext *s, int64_t offset)
Skip given number of bytes forward.
int avio_read(AVIOContext *s, unsigned char *buf, int size)
Read size bytes from AVIOContext into buf.
int avio_get_str(AVIOContext *pb, int maxlen, char *buf, int buflen)
Read a string from pb into buf.
unsigned int avio_rb24(AVIOContext *s)
unsigned int avio_rb32(AVIOContext *s)
int avio_r8(AVIOContext *s)
int ffio_ensure_seekback(AVIOContext *s, int64_t buf_size)
Ensures that the requested seekback buffer size will be available.
static int read_packet(void *opaque, uint8_t *buf, int buf_size)
int ff_get_line(AVIOContext *s, char *buf, int maxlen)
Read a whole line of text from AVIOContext.
void av_bprintf(AVBPrint *buf, const char *fmt,...)
void av_bprint_init(AVBPrint *buf, unsigned size_init, unsigned size_max)
int av_bprint_finalize(AVBPrint *buf, char **ret_str)
Finalize a print buffer.
static int av_bprint_is_complete(const AVBPrint *buf)
Test if the print buffer is complete (not truncated).
#define flags(name, subs,...)
#define ss(width, name, subs,...)
static float sub(float src0, float src1)
const OptionDef options[]
static AVInputFormat * iformat
static int read_header(FFV1Context *f)
#define AV_CH_LAYOUT_MONO
AVCodecID
Identify the syntax and semantics of the bitstream.
@ AV_CODEC_ID_DVD_SUBTITLE
@ AV_CODEC_ID_MP3
preferred ID for decoding MPEG audio layer 1, 2 or 3
@ AV_CODEC_ID_MPEG2VIDEO
preferred ID for MPEG-1/2 video decoding
#define AV_INPUT_BUFFER_PADDING_SIZE
Required number of additionally allocated bytes at the end of the input bitstream for decoding.
@ AVDISCARD_ALL
discard all
int av_grow_packet(AVPacket *pkt, int grow_by)
Increase packet size, correctly zeroing padding.
AVFormatContext * avformat_alloc_context(void)
Allocate an AVFormatContext.
AVStream * avformat_new_stream(AVFormatContext *s, const AVCodec *c)
Add a new stream to a media file.
ff_const59 AVInputFormat * av_find_input_format(const char *short_name)
Find AVInputFormat based on the short name of the input format.
void avformat_close_input(AVFormatContext **s)
Close an opened input AVFormatContext.
int avformat_open_input(AVFormatContext **ps, const char *url, ff_const59 AVInputFormat *fmt, AVDictionary **options)
Open an input stream and read the header.
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.
int av_dict_set(AVDictionary **pm, const char *key, const char *value, int flags)
Set the given entry in *pm, overwriting an existing entry.
#define AVERROR_INVALIDDATA
Invalid data found when processing input.
#define AVERROR_EOF
End of file.
#define AVERROR_DEMUXER_NOT_FOUND
Demuxer not found.
#define AV_LOG_DEBUG
Stuff which is only useful for libav* developers.
#define AV_LOG_WARNING
Something somehow does not look correct.
#define AV_LOG_VERBOSE
Detailed information.
#define AV_LOG_ERROR
Something went wrong and cannot losslessly be recovered.
const char * av_default_item_name(void *ptr)
Return the context name.
static AVRational av_make_q(int num, int den)
Create an AVRational.
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.
int64_t av_rescale_q(int64_t a, AVRational bq, AVRational cq)
Rescale a 64-bit integer by 2 rational numbers.
@ AV_ROUND_DOWN
Round toward -infinity.
@ AV_ROUND_PASS_MINMAX
Flag telling rescaling functions to pass INT64_MIN/MAX through unchanged, avoiding special cases for ...
@ AV_ROUND_UP
Round toward +infinity.
char * av_strdup(const char *s)
Duplicate a string.
@ AVMEDIA_TYPE_DATA
Opaque data information usually continuous.
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.
#define AV_NOPTS_VALUE
Undefined timestamp value.
#define AV_TIME_BASE
Internal time base represented as integer.
#define AV_TIME_BASE_Q
Internal time base represented as fractional value.
#define LIBAVUTIL_VERSION_INT
common internal API header
#define NULL_IF_CONFIG_SMALL(x)
Return NULL if CONFIG_SMALL is true, otherwise the argument without modification.
static av_cold int read_close(AVFormatContext *ctx)
static int64_t get_pts(AVIOContext *pb, int c)
static int mpegps_read_packet(AVFormatContext *s, AVPacket *pkt)
static int mpegps_read_pes_header(AVFormatContext *s, int64_t *ppos, int *pstart_code, int64_t *ppts, int64_t *pdts)
static int64_t mpegps_read_dts(AVFormatContext *s, int stream_index, int64_t *ppos, int64_t pos_limit)
static int find_next_start_code(AVIOContext *pb, int *size_ptr, int32_t *header_state)
static int check_pack_header(const uint8_t *buf)
AVInputFormat ff_mpegps_demuxer
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 ...
static int check_pes(const uint8_t *p, const uint8_t *end)
static int mpegps_probe(const AVProbeData *p)
static int mpegps_read_header(AVFormatContext *s)
#define STREAM_TYPE_VIDEO_MPEG4
#define STREAM_TYPE_AUDIO_MPEG2
#define STREAM_TYPE_VIDEO_HEVC
#define SYSTEM_HEADER_START_CODE
#define PROGRAM_STREAM_MAP
#define STREAM_TYPE_AUDIO_AC3
#define STREAM_TYPE_VIDEO_MPEG1
#define STREAM_TYPE_AUDIO_AAC
#define STREAM_TYPE_VIDEO_H264
#define STREAM_TYPE_AUDIO_MPEG1
static int64_t ff_parse_pes_pts(const uint8_t *buf)
Parse MPEG-PES five-byte timestamp.
#define STREAM_TYPE_VIDEO_MPEG2
#define AV_OPT_FLAG_DECODING_PARAM
a generic parameter which can be set by the user for demuxing or decoding
static const uint8_t header[24]
#define FF_ARRAY_ELEMS(a)
Describe the class of an AVClass context structure.
const char * class_name
The name of the class; usually it is the same name as the context structure type to which the AVClass...
This struct describes the properties of an encoded stream.
uint64_t channel_layout
Audio only.
enum AVMediaType codec_type
General type of the encoded data.
uint8_t * extradata
Extra binary data needed for initializing the decoder, codec-dependent.
enum AVCodecID codec_id
Specific type of the encoded data (the codec used).
int sample_rate
Audio only.
This structure stores compressed data.
int64_t pts
Presentation timestamp in AVStream->time_base units; the time at which the decompressed packet will b...
int64_t dts
Decompression timestamp in AVStream->time_base units; the time at which the packet is decompressed.
int64_t pos
byte position in stream, -1 if unknown
This structure contains the data a format has to probe a file.
int buf_size
Size of buf except extra allocated bytes.
unsigned char * buf
Buffer must have AVPROBE_PADDING_SIZE of extra allocated bytes filled with zero.
Rational number (pair of numerator and denominator).
int request_probe
stream probing state -1 -> probing finished 0 -> no probing requested rest -> perform probing with re...
AVCodecParameters * codecpar
Codec parameters associated with this stream.
enum AVDiscard discard
Selects which packets can be discarded at will and do not need to be demuxed.
int id
Format-specific stream ID.
int index
stream index in AVFormatContext
AVRational time_base
This is the fundamental unit of time (in seconds) in terms of which frame timestamps are represented.
enum AVStreamParseType need_parsing
AVStreamInternal * internal
An opaque field for libavformat internal usage.
int nb_subs
number of subtitles packets
AVPacket ** subs
array of subtitles packets
int current_sub_idx
current position for the read packet callback
unsigned char psm_es_type[256]
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.
int ff_subtitles_queue_read_packet(FFDemuxSubtitlesQueue *q, AVPacket *pkt)
Generic read_packet() callback for subtitles demuxers using this queue system.
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.
void ff_subtitles_queue_clean(FFDemuxSubtitlesQueue *q)
Remove and destroy all the subtitles packets.
AVPacket * ff_subtitles_queue_insert(FFDemuxSubtitlesQueue *q, const uint8_t *event, size_t len, int merge)
Insert a new subtitle event.
@ SUB_SORT_POS_TS
sort by position, then timestamps