1
PAT Section:
2
┌──────────┬──────────┬──────────┬──────────┬──────────┬──────────┬──────────┐
3
│ table_id │ section_ │ transport│ version/ │ section_ │ 节目列表 │ CRC32    │
4
│ =0x00    │ length   │ _stream_ │ current_ │ number/  │ (循环)   │ (4字节)  │
5
│ (1字节)  │ (2字节)  │ id       │ next     │ last_    │          │          │
6
│          │          │ (2字节)  │ (1字节)  │ section  │          │          │
7
└──────────┴──────────┴──────────┴──────────┴──────────┴──────────┴──────────┘
8

9
节目列表每项4字节：
10
┌──────────────────────┬──────────────────────┐
11
│ program_number       │ PMT PID / NIT PID    │
12
│ (2字节)              │ (13位PID + 3位保留)  │
13
└──────────────────────┴──────────────────────┘
14
  program_number=0 → 该PID指向NIT
15
  program_number≠0 → 该PID指向对应节目的PMT

1
void parse_ts_packet(uint8_t* ts_packet) {
2
    if (ts_packet[0] != 0x47) {
3
        return;
4
    }
5

6
    bool transport_error = (ts_packet[1] & 0x80) != 0;
7
    bool payload_start = (ts_packet[1] & 0x40) != 0;
8
    bool priority = (ts_packet[1] & 0x20) != 0;
9
    uint16_t pid = ((ts_packet[1] & 0x1F) << 8) | ts_packet[2];
10
    uint8_t scrambling_control = (ts_packet[3] >> 6) & 0x03;
11
    uint8_t adaptation_field_control = (ts_packet[3] >> 4) & 0x03;
12
    uint8_t continuity_counter = ts_packet[3] & 0x0F;
13

14
    if (transport_error) {
15
        return;
16
    }
17

18
    if (pid == 0x1FFF) {
19
        return;
20
    }
21

22
    int pos = 4;
23
    if (adaptation_field_control & 0x02) {
24
        uint8_t af_length = ts_packet[pos++];
25
        if (af_length > 0) {
26
            uint8_t flags = ts_packet[pos];
27
            if (flags & 0x10) {
28
                uint64_t pcr_base = ((uint64_t)(ts_packet[pos + 1]) << 25) |
29
                                    ((uint64_t)(ts_packet[pos + 2]) << 17) |
30
                                    ((uint64_t)(ts_packet[pos + 3]) << 9) |
31
                                    ((uint64_t)(ts_packet[pos + 4]) << 1) |
32
                                    ((ts_packet[pos + 5] >> 7) & 0x01);
33
                uint16_t pcr_ext = (((ts_packet[pos + 5] & 0x01) << 8) |
34
                                    ts_packet[pos + 6]);
35
                uint64_t pcr = pcr_base * 300 + pcr_ext;
36
                update_system_clock(pcr);
37
            }
38
        }
39
        pos += af_length;
40
    }
41

42
    if (adaptation_field_control & 0x01) {
43
        if (pid == 0x0000) {
44
            parse_pat(ts_packet + pos, 188 - pos, payload_start);
45
        } else if (is_pmt_pid(pid)) {
46
            parse_pmt(ts_packet + pos, 188 - pos, payload_start);
47
        } else if (is_video_pid(pid) || is_audio_pid(pid)) {
48
            add_to_pes_buffer(pid, ts_packet + pos, 188 - pos, payload_start);
49
            if (is_pes_complete(pid)) {
50
                PesPacket* pes = get_complete_pes(pid);
51
                decode_pes(pes);
52
            }
53
        }
54
    }
55
}

1
struct ProgramInfo {
2
    uint16_t program_number;
3
    uint16_t pmt_pid;
4
};
5

6
struct StreamInfo {
7
    uint8_t stream_type;
8
    uint16_t elementary_pid;
9
    std::vector<uint8_t> es_info;
10
};
11

12
std::vector<ProgramInfo> program_map;
13

14
void parse_pat(uint8_t* data, int length, bool payload_start) {
15
    int offset = 0;
16
    if (payload_start) {
17
        uint8_t pointer_field = data[offset++];
18
        offset += pointer_field;
19
    }
20

21
    uint8_t table_id = data[offset++];
22
    if (table_id != 0x00) return;
23

24
    uint16_t section_length = ((data[offset] & 0x0F) << 8) | data[offset + 1];
25
    offset += 2;
26

27
    uint16_t transport_stream_id = (data[offset] << 8) | data[offset + 1];
28
    offset += 2;
29

30
    uint8_t version_number = (data[offset] >> 1) & 0x1F;
31
    bool current_next = data[offset] & 0x01;
32
    offset++;
33

34
    uint8_t section_number = data[offset++];
35
    uint8_t last_section_number = data[offset++];
36

37
    program_map.clear();
38
    int program_data_end = offset + section_length - 5 - 4;
39
    while (offset < program_data_end) {
40
        ProgramInfo info;
41
        info.program_number = (data[offset] << 8) | data[offset + 1];
42
        info.pmt_pid = ((data[offset + 2] & 0x1F) << 8) | data[offset + 3];
43
        offset += 4;
44
        if (info.program_number != 0) {
45
            program_map.push_back(info);
46
        }
47
    }
48
}
49

50
void parse_pmt(uint8_t* data, int length, bool payload_start) {
51
    int offset = 0;
52
    if (payload_start) {
53
        uint8_t pointer_field = data[offset++];
54
        offset += pointer_field;
55
    }
56

57
    uint8_t table_id = data[offset++];
58
    if (table_id != 0x02) return;
59

60
    uint16_t section_length = ((data[offset] & 0x0F) << 8) | data[offset + 1];
61
    offset += 2;
62

63
    uint16_t program_number = (data[offset] << 8) | data[offset + 1];
64
    offset += 2;
65

66
    uint8_t version_number = (data[offset] >> 1) & 0x1F;
67
    offset++;
68

69
    uint8_t section_number = data[offset++];
70
    uint8_t last_section_number = data[offset++];
71

72
    uint16_t pcr_pid = ((data[offset] & 0x1F) << 8) | data[offset + 1];
73
    offset += 2;
74

75
    uint16_t program_info_length = ((data[offset] & 0x0F) << 8) | data[offset + 1];
76
    offset += 2 + program_info_length;
77

78
    int stream_end = offset + section_length - 9 - 4;
79
    while (offset < stream_end) {
80
        StreamInfo si;
81
        si.stream_type = data[offset++];
82
        si.elementary_pid = ((data[offset] & 0x1F) << 8) | data[offset + 1];
83
        offset += 2;
84
        uint16_t es_info_length = ((data[offset] & 0x0F) << 8) | data[offset + 1];
85
        offset += 2;
86
        if (es_info_length > 0) {
87
            si.es_info.assign(data + offset, data + offset + es_info_length);
88
            offset += es_info_length;
89
        }
90
    }
91
}

1
enum class PesState { WAITING_START, COLLECTING, COMPLETE };
2

3
struct PesBuffer {
4
    PesState state = PesState::WAITING_START;
5
    std::vector<uint8_t> data;
6
    uint16_t expected_length = 0;
7
};
8

9
std::map<uint16_t, PesBuffer> pes_buffers;
10

11
void add_to_pes_buffer(uint16_t pid, uint8_t* data, int length, bool payload_start) {
12
    auto& buf = pes_buffers[pid];
13

14
    if (payload_start) {
15
        if (buf.state == PesState::COLLECTING && buf.data.size() > 0) {
16
            process_complete_pes(pid, buf.data);
17
        }
18
        buf.data.clear();
19
        buf.state = PesState::COLLECTING;
20

21
        if (length >= 6) {
22
            uint8_t stream_id = data[3];
23
            buf.expected_length = ((data[4] << 8) | data[5]);
24
        }
25
    }
26

27
    if (buf.state == PesState::COLLECTING) {
28
        buf.data.insert(buf.data.end(), data, data + length);
29

30
        if (buf.expected_length > 0) {
31
            uint16_t pes_payload_size = buf.expected_length + 3;
32
            if (buf.data.size() >= pes_payload_size + 6) {
33
                buf.state = PesState::COMPLETE;
34
                process_complete_pes(pid, buf.data);
35
                buf.data.clear();
36
                buf.state = PesState::WAITING_START;
37
            }
38
        }
39
    }
40
}
41

42
void process_complete_pes(uint16_t pid, const std::vector<uint8_t>& pes_data) {
43
    if (pes_data.size() < 9) return;
44

45
    uint8_t stream_id = pes_data[3];
46
    uint16_t pes_packet_length = (pes_data[4] << 8) | pes_data[5];
47

48
    uint8_t pts_dts_flags = (pes_data[7] >> 6) & 0x03;
49
    uint8_t pes_header_data_length = pes_data[8];
50

51
    int64_t pts = -1, dts = -1;
52
    int offset = 9;
53

54
    if (pts_dts_flags >= 2) {
55
        pts = ((int64_t)(pes_data[offset] & 0x0E) << 29) |
56
              ((int64_t)pes_data[offset + 1] << 22) |
57
              ((int64_t)(pes_data[offset + 2] & 0xFE) << 14) |
58
              ((int64_t)pes_data[offset + 3] << 7) |
59
              ((int64_t)(pes_data[offset + 4] & 0xFE) >> 1);
60
        offset += 5;
61

62
        if (pts_dts_flags == 3) {
63
            dts = ((int64_t)(pes_data[offset] & 0x0E) << 29) |
64
                  ((int64_t)pes_data[offset + 1] << 22) |
65
                  ((int64_t)(pes_data[offset + 2] & 0xFE) << 14) |
66
                  ((int64_t)pes_data[offset + 3] << 7) |
67
                  ((int64_t)(pes_data[offset + 4] & 0xFE) >> 1);
68
        }
69
    }
70

71
    int es_data_offset = 9 + pes_header_data_length;
72
    int es_data_length = pes_data.size() - es_data_offset;
73

74
    decode_es(pid, stream_id, pts, dts, pes_data.data() + es_data_offset, es_data_length);
75
}

1
#define SYNC_BYTE 0x47
2
#define TS_PACKET_SIZE 188
3

4
int find_sync_byte(uint8_t* buffer, int length) {
5
    for (int i = 0; i <= length - TS_PACKET_SIZE; i++) {
6
        if (buffer[i] == SYNC_BYTE) {
7
            bool sync_ok = true;
8
            for (int j = 1; j < 4 && sync_ok; j++) {
9
                if (i + j * TS_PACKET_SIZE < length) {
10
                    if (buffer[i + j * TS_PACKET_SIZE] != SYNC_BYTE) {
11
                        sync_ok = false;
12
                    }
13
                }
14
            }
15
            if (sync_ok) return i;
16
        }
17
    }
18
    return -1;
19
}
20

21
bool check_continuity(uint16_t pid, uint8_t new_cc) {
22
    static std::map<uint16_t, uint8_t> last_cc;
23
    auto it = last_cc.find(pid);
24
    if (it != last_cc.end()) {
25
        uint8_t expected = (it->second + 1) & 0x0F;
26
        if (new_cc != expected) {
27
            return false;
28
        }
29
    }
30
    last_cc[pid] = new_cc;
31
    return true;
32
}