41 #define MAX_RESYNC_SIZE 65536
43 #define MAX_PES_PAYLOAD 200*1024
45 #define MAX_MP4_DESCR_COUNT 16
86 #define MAX_PIDS_PER_PROGRAM 64
157 #define PES_START_SIZE 6
158 #define PES_HEADER_SIZE 9
159 #define MAX_PES_HEADER_SIZE (9 + 255)
189 for(i=0; i<ts->
nb_prg; i++)
190 if(ts->
prg[i].
id == programid)
217 for(i=0; i<ts->
nb_prg; i++) {
218 if(ts->
prg[i].
id == programid) {
242 int used = 0, discarded = 0;
255 for(i=0; i<ts->
nb_prg; i++) {
258 if(p->
pids[j] != pid)
272 return !used && discarded;
280 const uint8_t *buf,
int buf_size,
int is_start)
399 memset(stat, 0, packet_size*
sizeof(
int));
401 for(x=i=0; i<size-3; i++){
402 if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){
404 if(stat[x] > best_score){
411 if(x == packet_size) x= 0;
420 int score, fec_score, dvhs_score;
428 av_dlog(
NULL,
"score: %d, dvhs_score: %d, fec_score: %d \n",
429 score, dvhs_score, fec_score);
431 if (score > fec_score && score > dvhs_score)
return TS_PACKET_SIZE;
464 if ((p + 1) >= p_end)
480 len =
get8(&p, p_end);
483 if ((p + len) > p_end)
500 val =
get8(pp, p_end);
505 val =
get16(pp, p_end);
509 val =
get8(pp, p_end);
512 h->
version = (val >> 1) & 0x1f;
513 val =
get8(pp, p_end);
517 val =
get8(pp, p_end);
585 uint32_t stream_type,
const StreamType *types)
597 uint32_t stream_type, uint32_t prog_reg_desc)
608 "stream=%d stream_type=%x pid=%x prog_reg_desc=%.4s\n",
614 if (prog_reg_desc ==
AV_RL32(
"HDMV") &&
625 memcpy(sub_pes, pes,
sizeof(*sub_pes));
633 sub_st->
id = pes->
pid;
685 int au_start_flag = 0, au_end_flag = 0, ocr_flag = 0, idle_flag = 0;
686 int padding_flag = 0, padding_bits = 0, inst_bitrate_flag = 0;
687 int dts_flag = -1, cts_flag = -1;
696 au_start_flag = au_end_flag = 1;
706 if (!idle_flag && (!padding_flag || padding_bits != 0)) {
732 if (inst_bitrate_flag)
749 const uint8_t *buf,
int buf_size,
int is_start,
770 while (buf_size > 0) {
786 code = pes->
header[3] | 0x100;
814 if (code != 0x1bc && code != 0x1bf &&
815 code != 0x1f0 && code != 0x1f1 &&
816 code != 0x1ff && code != 0x1f2 &&
866 unsigned int flags, pes_ext, skip;
872 if ((flags & 0xc0) == 0x80) {
875 }
else if ((flags & 0xc0) == 0xc0) {
885 skip = (pes_ext >> 4) & 0xb;
888 if ((pes_ext & 0x41) == 0x01 &&
891 if ((r[0] & 0x7f) > 0 && (r[1] & 0x80) == 0)
902 p += sl_header_bytes;
903 buf_size -= sl_header_bytes;
908 if (buf_size > 0 && pes->
buffer) {
1004 (*len) -= new_off - *
off;
1039 if (!(id_flags & 0x0020)) {
1116 if (len < 0 || len1 > len || len1 <= 0) {
1117 av_log(d->
s,
AV_LOG_ERROR,
"Tag %x length violation new length %d bytes remaining %d\n", tag, len1, len);
1126 if (target_tag && tag != target_tag) {
1156 Mp4Descr *descr,
int *descr_count,
int max_descr_count)
1169 Mp4Descr *descr,
int *descr_count,
int max_descr_count)
1188 int mp4_descr_count = 0;
1192 p_end = section + section_len - 4;
1204 for (i = 0; i < mp4_descr_count; i++) {
1219 pes->
sl = mp4_descr[i].
sl;
1241 for (i = 0; i < mp4_descr_count; i++)
1242 av_free(mp4_descr[i].dec_config_descr);
1247 Mp4Descr *mp4_descr,
int mp4_descr_count,
int pid,
1251 int desc_len, desc_tag, desc_es_id;
1255 desc_tag =
get8(pp, desc_list_end);
1258 desc_len =
get8(pp, desc_list_end);
1261 desc_end = *pp + desc_len;
1262 if (desc_end > desc_list_end)
1265 av_dlog(fc,
"tag: 0x%02x len=%d\n", desc_tag, desc_len);
1273 desc_es_id =
get16(pp, desc_end);
1274 if (ts && ts->
pids[pid])
1276 for (i = 0; i < mp4_descr_count; i++)
1277 if (mp4_descr[i].dec_config_descr_len &&
1278 mp4_descr[i].es_id == desc_es_id) {
1291 get16(pp, desc_end);
1304 language[0] =
get8(pp, desc_end);
1305 language[1] =
get8(pp, desc_end);
1306 language[2] =
get8(pp, desc_end);
1311 language[0] =
get8(pp, desc_end);
1312 language[1] =
get8(pp, desc_end);
1313 language[2] =
get8(pp, desc_end);
1316 switch(
get8(pp, desc_end)) {
1340 for (i = 0; i + 4 <= desc_len; i += 4) {
1341 language[i + 0] =
get8(pp, desc_end);
1342 language[i + 1] =
get8(pp, desc_end);
1343 language[i + 2] =
get8(pp, desc_end);
1344 language[i + 3] =
',';
1345 switch (
get8(pp, desc_end)) {
1352 language[i - 1] = 0;
1375 const uint8_t *p, *p_end, *desc_list_end;
1376 int program_info_length, pcr_pid, pid, stream_type;
1378 uint32_t prog_reg_desc = 0;
1381 int mp4_descr_count = 0;
1387 p_end = section + section_len - 4;
1399 pcr_pid =
get16(&p, p_end);
1407 program_info_length =
get16(&p, p_end);
1408 if (program_info_length < 0)
1410 program_info_length &= 0xfff;
1411 while(program_info_length >= 2) {
1413 tag =
get8(&p, p_end);
1414 len =
get8(&p, p_end);
1416 av_dlog(ts->
stream,
"program tag: 0x%02x len=%d\n", tag, len);
1418 if(len > program_info_length - 2)
1421 program_info_length -= len + 2;
1428 }
else if (tag == 0x05 && len >= 4) {
1429 prog_reg_desc = bytestream_get_le32(&p);
1434 p += program_info_length;
1445 stream_type =
get8(&p, p_end);
1446 if (stream_type < 0)
1448 pid =
get16(&p, p_end);
1461 }
else if (stream_type != 0x13) {
1489 desc_list_len =
get16(&p, p_end);
1490 if (desc_list_len < 0)
1492 desc_list_len &= 0xfff;
1493 desc_list_end = p + desc_list_len;
1494 if (desc_list_end > p_end)
1498 mp4_descr, mp4_descr_count, pid, ts) < 0)
1501 if (pes && prog_reg_desc ==
AV_RL32(
"HDMV") && stream_type == 0x83 && pes->
sub_st) {
1510 for (i = 0; i < mp4_descr_count; i++)
1511 av_free(mp4_descr[i].dec_config_descr);
1524 p_end = section + section_len - 4;
1533 sid =
get16(&p, p_end);
1536 pmt_pid =
get16(&p, p_end);
1543 if (sid == 0x0000) {
1547 if (ts->
pids[pmt_pid])
1561 const uint8_t *p, *p_end, *desc_list_end, *desc_end;
1562 int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type;
1563 char *
name, *provider_name;
1568 p_end = section + section_len - 4;
1574 onid =
get16(&p, p_end);
1577 val =
get8(&p, p_end);
1581 sid =
get16(&p, p_end);
1584 val =
get8(&p, p_end);
1587 desc_list_len =
get16(&p, p_end);
1588 if (desc_list_len < 0)
1590 desc_list_len &= 0xfff;
1591 desc_list_end = p + desc_list_len;
1592 if (desc_list_end > p_end)
1595 desc_tag =
get8(&p, desc_list_end);
1598 desc_len =
get8(&p, desc_list_end);
1599 desc_end = p + desc_len;
1600 if (desc_end > desc_list_end)
1604 desc_tag, desc_len);
1608 service_type =
get8(&p, p_end);
1609 if (service_type < 0)
1611 provider_name =
getstr8(&p, p_end);
1639 int len, pid, cc, expected_cc, cc_ok, afc, is_start, is_discontinuity,
1640 has_adaptation, has_payload;
1644 pid =
AV_RB16(packet + 1) & 0x1fff;
1647 is_start = packet[1] & 0x40;
1648 tss = ts->
pids[pid];
1651 tss = ts->
pids[pid];
1656 afc = (packet[3] >> 4) & 3;
1659 has_adaptation = afc & 2;
1660 has_payload = afc & 1;
1661 is_discontinuity = has_adaptation
1663 && (packet[5] & 0x80);
1666 cc = (packet[3] & 0xf);
1667 expected_cc = has_payload ? (tss->
last_cc + 1) & 0x0f : tss->
last_cc;
1668 cc_ok = pid == 0x1FFF
1671 || expected_cc == cc;
1676 "Continuity check failed for pid %d expected %d got %d\n",
1677 pid, expected_cc, cc);
1687 if (has_adaptation) {
1703 if (p + len > p_end)
1767 if ((*data)[0] != 0x47) {
1794 int packet_num, ret = 0;
1820 if (nb_packets != 0 && packet_num >= nb_packets)
1837 int score, fec_score, dvhs_score;
1839 #define CHECK_COUNT 10
1847 av_dlog(
NULL,
"score: %d, dvhs_score: %d, fec_score: %d \n",
1848 score, dvhs_score, fec_score);
1852 else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6)
return AVPROBE_SCORE_MAX + dvhs_score - CHECK_COUNT;
1866 afc = (packet[3] >> 4) & 3;
1876 if (!(flags & 0x10))
1881 *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7);
1882 *ppcr_low = ((p[4] & 1) << 8) | p[5];
1897 if (len !=
sizeof(buf))
1905 if (s->
iformat == &ff_mpegts_demuxer) {
1926 int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l;
1927 int64_t pcrs[2], pcr_h;
1928 int packet_count[2];
1949 pid =
AV_RB16(data + 1) & 0x1fff;
1950 if ((pcr_pid == -1 || pcr_pid == pid) &&
1954 packet_count[nb_pcrs] = nb_packets;
1955 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l;
1967 ts->
pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]);
1982 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188)
1989 int64_t pcr_h, next_pcr_h, pos;
1990 int pcr_l, next_pcr_l;
2002 if (data != pkt->
data)
2013 if (
parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) {
2015 ts->
pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) /
2022 ts->
cur_pcr = pcr_h * 300 + pcr_l;
2056 if (!ret && pkt->
size < 0)
2075 int64_t *ppos, int64_t pos_limit)
2078 int64_t pos, timestamp;
2081 const int find_next= 1;
2088 if ((pcr_pid < 0 || (
AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
2089 parse_pcr(×tamp, &pcr_l, buf) == 0) {
2102 if ((pcr_pid < 0 || (
AV_RB16(buf + 1) & 0x1fff) == pcr_pid) &&
2103 parse_pcr(×tamp, &pcr_l, buf) == 0) {
2128 if(buf[1] & 0x40)
break;
2168 if (buf[0] != 0x47) {
2203 .
name =
"mpegtsraw",
2212 .priv_class = &mpegtsraw_class,