Mercurial > libavformat.hg
annotate mpegts.c @ 5061:5ff6a72c9686 libavformat
In mov_read_packet remember the AVStream we want to demux next instead of the
MOVStreamContext. We need the AVStream anyway and it is easier to get the
MOVStreamContext from the AVStream than the other way around.
author | reimar |
---|---|
date | Wed, 24 Jun 2009 08:23:40 +0000 |
parents | d44e963aaf1c |
children | 11e86c7bdc25 |
rev | line source |
---|---|
0 | 1 /* |
1415
3b00fb8ef8e4
replace coder/decoder file description in libavformat by muxer/demuxer
aurel
parents:
1358
diff
changeset
|
2 * MPEG2 transport stream (aka DVB) demuxer |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4201
diff
changeset
|
3 * Copyright (c) 2002-2003 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 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 | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1280
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
892
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
3286 | 21 |
4962
66a7afa20cc7
move DEBUG define before include to get dprintf
bcoudurier
parents:
4868
diff
changeset
|
22 //#define DEBUG |
66a7afa20cc7
move DEBUG define before include to get dprintf
bcoudurier
parents:
4868
diff
changeset
|
23 //#define DEBUG_SEEK |
66a7afa20cc7
move DEBUG define before include to get dprintf
bcoudurier
parents:
4868
diff
changeset
|
24 |
3286 | 25 #include "libavutil/crc.h" |
4201
7d2f3f1b68d8
Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents:
4087
diff
changeset
|
26 #include "libavutil/intreadwrite.h" |
4860
d14d1f5f4eb4
simplify registration descriptor parsing with bytestream get functions
bcoudurier
parents:
4859
diff
changeset
|
27 #include "libavcodec/bytestream.h" |
0 | 28 #include "avformat.h" |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
29 #include "mpegts.h" |
4062
297c1d6f9c5e
Add necessary header for av_set_program_name and av_program_add_stream_index.
diego
parents:
4059
diff
changeset
|
30 #include "internal.h" |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
31 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
32 /* 1.0 second at 24Mbit/s */ |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
33 #define MAX_SCAN_PACKETS 32000 |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
34 |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
35 /* maximum size in which we look for synchronisation if |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
36 synchronisation is lost */ |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
37 #define MAX_RESYNC_SIZE 4096 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
38 |
4963 | 39 #define MAX_PES_PAYLOAD 200*1024 |
40 | |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
41 typedef struct PESContext PESContext; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
42 |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
43 static PESContext* add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
44 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
45 enum MpegTSFilterType { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
46 MPEGTS_PES, |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
47 MPEGTS_SECTION, |
0 | 48 }; |
49 | |
2236
117edddfce20
update SectionCallback and PESCallback typedefs to match functions
mru
parents:
2222
diff
changeset
|
50 typedef struct MpegTSFilter MpegTSFilter; |
117edddfce20
update SectionCallback and PESCallback typedefs to match functions
mru
parents:
2222
diff
changeset
|
51 |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
52 typedef int PESCallback(MpegTSFilter *f, const uint8_t *buf, int len, int is_start, int64_t pos); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
53 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
54 typedef struct MpegTSPESFilter { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
55 PESCallback *pes_cb; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
56 void *opaque; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
57 } MpegTSPESFilter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
58 |
2236
117edddfce20
update SectionCallback and PESCallback typedefs to match functions
mru
parents:
2222
diff
changeset
|
59 typedef void SectionCallback(MpegTSFilter *f, const uint8_t *buf, int len); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
60 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
61 typedef void SetServiceCallback(void *opaque, int ret); |
0 | 62 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
63 typedef struct MpegTSSectionFilter { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
64 int section_index; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
65 int section_h_size; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
66 uint8_t *section_buf; |
3553
c3b9334f46ae
One-bit bitfields should probably be unsigned. Unfortunately, it is left
takis
parents:
3487
diff
changeset
|
67 unsigned int check_crc:1; |
c3b9334f46ae
One-bit bitfields should probably be unsigned. Unfortunately, it is left
takis
parents:
3487
diff
changeset
|
68 unsigned int end_of_section_reached:1; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
69 SectionCallback *section_cb; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
70 void *opaque; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
71 } MpegTSSectionFilter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
72 |
2236
117edddfce20
update SectionCallback and PESCallback typedefs to match functions
mru
parents:
2222
diff
changeset
|
73 struct MpegTSFilter { |
0 | 74 int pid; |
75 int last_cc; /* last cc code (-1 if first packet) */ | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
76 enum MpegTSFilterType type; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
77 union { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
78 MpegTSPESFilter pes_filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
79 MpegTSSectionFilter section_filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
80 } u; |
2236
117edddfce20
update SectionCallback and PESCallback typedefs to match functions
mru
parents:
2222
diff
changeset
|
81 }; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
82 |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
83 #define MAX_PIDS_PER_PROGRAM 64 |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
84 struct Program { |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
85 unsigned int id; //program id/service id |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
86 unsigned int nb_pids; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
87 unsigned int pids[MAX_PIDS_PER_PROGRAM]; |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
88 }; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
89 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
90 struct MpegTSContext { |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
91 /* user data */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
92 AVFormatContext *stream; |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
93 /** raw packet size, including FEC if present */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
94 int raw_packet_size; |
3240
78153a85dccc
Ensure that the timestamp reading code used for seeking chooses a position
michael
parents:
3226
diff
changeset
|
95 |
78153a85dccc
Ensure that the timestamp reading code used for seeking chooses a position
michael
parents:
3226
diff
changeset
|
96 int pos47; |
78153a85dccc
Ensure that the timestamp reading code used for seeking chooses a position
michael
parents:
3226
diff
changeset
|
97 |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
98 /** if true, all pids are analyzed to find streams */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
99 int auto_guess; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
100 |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
101 /** compute exact PCR for each transport stream packet */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
102 int mpeg2ts_compute_pcr; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
103 |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
104 int64_t cur_pcr; /**< used to estimate the exact PCR */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
105 int pcr_incr; /**< used to estimate the exact PCR */ |
885 | 106 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
107 /* data needed to handle file based ts */ |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
108 /** stop parsing loop */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
109 int stop_parse; |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
110 /** packet containing Audio/Video data */ |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
111 AVPacket *pkt; |
4963 | 112 /** to detect seek */ |
113 int64_t last_pos; | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
114 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
115 /******************************************/ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
116 /* private mpegts data */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
117 /* scan context */ |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
118 /** structure to keep track of Program->pids mapping */ |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
119 unsigned int nb_prg; |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
120 struct Program *prg; |
885 | 121 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
122 |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
123 /** filters for various streams specified by PMT + for the PAT and PMT */ |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
124 MpegTSFilter *pids[NB_PID_MAX]; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
125 }; |
0 | 126 |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
127 /* TS stream handling */ |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
128 |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
129 enum MpegTSState { |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
130 MPEGTS_HEADER = 0, |
5000 | 131 MPEGTS_PESHEADER, |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
132 MPEGTS_PESHEADER_FILL, |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
133 MPEGTS_PAYLOAD, |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
134 MPEGTS_SKIP, |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
135 }; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
136 |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
137 /* enough for PES header + length */ |
5000 | 138 #define PES_START_SIZE 6 |
139 #define PES_HEADER_SIZE 9 | |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
140 #define MAX_PES_HEADER_SIZE (9 + 255) |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
141 |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
142 struct PESContext { |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
143 int pid; |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
144 int pcr_pid; /**< if -1 then all packets containing PCR are considered */ |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
145 int stream_type; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
146 MpegTSContext *ts; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
147 AVFormatContext *stream; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
148 AVStream *st; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
149 enum MpegTSState state; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
150 /* used to get the format */ |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
151 int data_index; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
152 int total_size; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
153 int pes_header_size; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
154 int64_t pts, dts; |
4615
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
155 int64_t ts_packet_pos; /**< position of first TS packet of this PES packet */ |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
156 uint8_t header[MAX_PES_HEADER_SIZE]; |
4963 | 157 uint8_t *buffer; |
2133
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
158 }; |
2b2f5fc314e0
move structs and enums to top of file so they can be used
michael
parents:
2132
diff
changeset
|
159 |
2555 | 160 extern AVInputFormat mpegts_demuxer; |
161 | |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
162 static void clear_program(MpegTSContext *ts, unsigned int programid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
163 { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
164 int i; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
165 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
166 for(i=0; i<ts->nb_prg; i++) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
167 if(ts->prg[i].id == programid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
168 ts->prg[i].nb_pids = 0; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
169 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
170 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
171 static void clear_programs(MpegTSContext *ts) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
172 { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
173 av_freep(&ts->prg); |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
174 ts->nb_prg=0; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
175 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
176 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
177 static void add_pat_entry(MpegTSContext *ts, unsigned int programid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
178 { |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
179 struct Program *p; |
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
180 void *tmp = av_realloc(ts->prg, (ts->nb_prg+1)*sizeof(struct Program)); |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
181 if(!tmp) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
182 return; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
183 ts->prg = tmp; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
184 p = &ts->prg[ts->nb_prg]; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
185 p->id = programid; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
186 p->nb_pids = 0; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
187 ts->nb_prg++; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
188 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
189 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
190 static void add_pid_to_pmt(MpegTSContext *ts, unsigned int programid, unsigned int pid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
191 { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
192 int i; |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
193 struct Program *p = NULL; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
194 for(i=0; i<ts->nb_prg; i++) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
195 if(ts->prg[i].id == programid) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
196 p = &ts->prg[i]; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
197 break; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
198 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
199 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
200 if(!p) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
201 return; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
202 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
203 if(p->nb_pids >= MAX_PIDS_PER_PROGRAM) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
204 return; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
205 p->pids[p->nb_pids++] = pid; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
206 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
207 |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
208 /** |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
209 * \brief discard_pid() decides if the pid is to be discarded according |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
210 * to caller's programs selection |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
211 * \param ts : - TS context |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
212 * \param pid : - pid |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
213 * \return 1 if the pid is only comprised in programs that have .discard=AVDISCARD_ALL |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
214 * 0 otherwise |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
215 */ |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
216 static int discard_pid(MpegTSContext *ts, unsigned int pid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
217 { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
218 int i, j, k; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
219 int used = 0, discarded = 0; |
4087
950dc8531665
mpegts: replace Program_t typedef with "struct Program"
mru
parents:
4062
diff
changeset
|
220 struct Program *p; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
221 for(i=0; i<ts->nb_prg; i++) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
222 p = &ts->prg[i]; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
223 for(j=0; j<p->nb_pids; j++) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
224 if(p->pids[j] != pid) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
225 continue; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
226 //is program with id p->id set to be discarded? |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
227 for(k=0; k<ts->stream->nb_programs; k++) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
228 if(ts->stream->programs[k]->id == p->id) { |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
229 if(ts->stream->programs[k]->discard == AVDISCARD_ALL) |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
230 discarded++; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
231 else |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
232 used++; |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
233 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
234 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
235 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
236 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
237 |
3278 | 238 return !used && discarded; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
239 } |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
240 |
1726
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
241 /** |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
242 * Assembles PES packets out of TS packets, and then calls the "section_cb" |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
243 * function when they are complete. |
63bb140936c0
mpegts-documentation-only.patch -- adds documentation patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1724
diff
changeset
|
244 */ |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
245 static void write_section_data(AVFormatContext *s, MpegTSFilter *tss1, |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
246 const uint8_t *buf, int buf_size, int is_start) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
247 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
248 MpegTSSectionFilter *tss = &tss1->u.section_filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
249 int len; |
885 | 250 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
251 if (is_start) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
252 memcpy(tss->section_buf, buf, buf_size); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
253 tss->section_index = buf_size; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
254 tss->section_h_size = -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
255 tss->end_of_section_reached = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
256 } else { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
257 if (tss->end_of_section_reached) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
258 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
259 len = 4096 - tss->section_index; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
260 if (buf_size < len) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
261 len = buf_size; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
262 memcpy(tss->section_buf + tss->section_index, buf, len); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
263 tss->section_index += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
264 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
265 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
266 /* compute section length if possible */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
267 if (tss->section_h_size == -1 && tss->section_index >= 3) { |
2222 | 268 len = (AV_RB16(tss->section_buf + 1) & 0xfff) + 3; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
269 if (len > 4096) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
270 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
271 tss->section_h_size = len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
272 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
273 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
274 if (tss->section_h_size != -1 && tss->section_index >= tss->section_h_size) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
275 tss->end_of_section_reached = 1; |
675
29a19aec26b2
Writing to freed memory in write_section_data() patch by (Wolfram Gloger <wmglo dent dot med dot uni-muenchen de>)
michael
parents:
555
diff
changeset
|
276 if (!tss->check_crc || |
2893 | 277 av_crc(av_crc_get_table(AV_CRC_32_IEEE), -1, |
278 tss->section_buf, tss->section_h_size) == 0) | |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
279 tss->section_cb(tss1, tss->section_buf, tss->section_h_size); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
280 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
281 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
282 |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1047
diff
changeset
|
283 static MpegTSFilter *mpegts_open_section_filter(MpegTSContext *ts, unsigned int pid, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
284 SectionCallback *section_cb, void *opaque, |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
285 int check_crc) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
286 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
287 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
288 MpegTSFilter *filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
289 MpegTSSectionFilter *sec; |
885 | 290 |
4862 | 291 dprintf(ts->stream, "Filter: pid=0x%x\n", pid); |
292 | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
293 if (pid >= NB_PID_MAX || ts->pids[pid]) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
294 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
295 filter = av_mallocz(sizeof(MpegTSFilter)); |
885 | 296 if (!filter) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
297 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
298 ts->pids[pid] = filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
299 filter->type = MPEGTS_SECTION; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
300 filter->pid = pid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
301 filter->last_cc = -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
302 sec = &filter->u.section_filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
303 sec->section_cb = section_cb; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
304 sec->opaque = opaque; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
305 sec->section_buf = av_malloc(MAX_SECTION_SIZE); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
306 sec->check_crc = check_crc; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
307 if (!sec->section_buf) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
308 av_free(filter); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
309 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
310 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
311 return filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
312 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
313 |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1047
diff
changeset
|
314 static MpegTSFilter *mpegts_open_pes_filter(MpegTSContext *ts, unsigned int pid, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
315 PESCallback *pes_cb, |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
316 void *opaque) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
317 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
318 MpegTSFilter *filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
319 MpegTSPESFilter *pes; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
320 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
321 if (pid >= NB_PID_MAX || ts->pids[pid]) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
322 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
323 filter = av_mallocz(sizeof(MpegTSFilter)); |
885 | 324 if (!filter) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
325 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
326 ts->pids[pid] = filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
327 filter->type = MPEGTS_PES; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
328 filter->pid = pid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
329 filter->last_cc = -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
330 pes = &filter->u.pes_filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
331 pes->pes_cb = pes_cb; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
332 pes->opaque = opaque; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
333 return filter; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
334 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
335 |
1124
d3aff2c607f9
Add const to (mostly) char* and make some functions static, which aren't used
diego
parents:
1047
diff
changeset
|
336 static void mpegts_close_filter(MpegTSContext *ts, MpegTSFilter *filter) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
337 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
338 int pid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
339 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
340 pid = filter->pid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
341 if (filter->type == MPEGTS_SECTION) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
342 av_freep(&filter->u.section_filter.section_buf); |
4390 | 343 else if (filter->type == MPEGTS_PES) { |
4963 | 344 PESContext *pes = filter->u.pes_filter.opaque; |
345 av_freep(&pes->buffer); | |
4390 | 346 /* referenced private data will be freed later in |
347 * av_close_input_stream */ | |
348 if (!((PESContext *)filter->u.pes_filter.opaque)->st) { | |
349 av_freep(&filter->u.pes_filter.opaque); | |
350 } | |
351 } | |
342
0c1b489c96bf
memleak patch by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
329
diff
changeset
|
352 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
353 av_free(filter); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
354 ts->pids[pid] = NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
355 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
356 |
329 | 357 static int analyze(const uint8_t *buf, int size, int packet_size, int *index){ |
358 int stat[packet_size]; | |
359 int i; | |
360 int x=0; | |
361 int best_score=0; | |
362 | |
363 memset(stat, 0, packet_size*sizeof(int)); | |
364 | |
3589 | 365 for(x=i=0; i<size-3; i++){ |
366 if(buf[i] == 0x47 && !(buf[i+1] & 0x80) && (buf[i+3] & 0x30)){ | |
329 | 367 stat[x]++; |
368 if(stat[x] > best_score){ | |
369 best_score= stat[x]; | |
370 if(index) *index= x; | |
371 } | |
372 } | |
373 | |
374 x++; | |
375 if(x == packet_size) x= 0; | |
376 } | |
377 | |
378 return best_score; | |
379 } | |
380 | |
0 | 381 /* autodetect fec presence. Must have at least 1024 bytes */ |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
382 static int get_packet_size(const uint8_t *buf, int size) |
0 | 383 { |
891 | 384 int score, fec_score, dvhs_score; |
0 | 385 |
386 if (size < (TS_FEC_PACKET_SIZE * 5 + 1)) | |
387 return -1; | |
885 | 388 |
329 | 389 score = analyze(buf, size, TS_PACKET_SIZE, NULL); |
891 | 390 dvhs_score = analyze(buf, size, TS_DVHS_PACKET_SIZE, NULL); |
329 | 391 fec_score= analyze(buf, size, TS_FEC_PACKET_SIZE, NULL); |
891 | 392 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score); |
885 | 393 |
891 | 394 if (score > fec_score && score > dvhs_score) return TS_PACKET_SIZE; |
395 else if(dvhs_score > score && dvhs_score > fec_score) return TS_DVHS_PACKET_SIZE; | |
396 else if(score < fec_score && dvhs_score < fec_score) return TS_FEC_PACKET_SIZE; | |
329 | 397 else return -1; |
0 | 398 } |
399 | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
400 typedef struct SectionHeader { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
401 uint8_t tid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
402 uint16_t id; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
403 uint8_t version; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
404 uint8_t sec_num; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
405 uint8_t last_sec_num; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
406 } SectionHeader; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
407 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
408 static inline int get8(const uint8_t **pp, const uint8_t *p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
409 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
410 const uint8_t *p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
411 int c; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
412 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
413 p = *pp; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
414 if (p >= p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
415 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
416 c = *p++; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
417 *pp = p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
418 return c; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
419 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
420 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
421 static inline int get16(const uint8_t **pp, const uint8_t *p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
422 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
423 const uint8_t *p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
424 int c; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
425 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
426 p = *pp; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
427 if ((p + 1) >= p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
428 return -1; |
2222 | 429 c = AV_RB16(p); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
430 p += 2; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
431 *pp = p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
432 return c; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
433 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
434 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
435 /* read and allocate a DVB string preceeded by its length */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
436 static char *getstr8(const uint8_t **pp, const uint8_t *p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
437 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
438 int len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
439 const uint8_t *p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
440 char *str; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
441 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
442 p = *pp; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
443 len = get8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
444 if (len < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
445 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
446 if ((p + len) > p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
447 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
448 str = av_malloc(len + 1); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
449 if (!str) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
450 return NULL; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
451 memcpy(str, p, len); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
452 str[len] = '\0'; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
453 p += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
454 *pp = p; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
455 return str; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
456 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
457 |
885 | 458 static int parse_section_header(SectionHeader *h, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
459 const uint8_t **pp, const uint8_t *p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
460 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
461 int val; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
462 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
463 val = get8(pp, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
464 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
465 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
466 h->tid = val; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
467 *pp += 2; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
468 val = get16(pp, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
469 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
470 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
471 h->id = val; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
472 val = get8(pp, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
473 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
474 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
475 h->version = (val >> 1) & 0x1f; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
476 val = get8(pp, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
477 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
478 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
479 h->sec_num = val; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
480 val = get8(pp, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
481 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
482 return -1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
483 h->last_sec_num = val; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
484 return 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
485 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
486 |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
487 typedef struct { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
488 uint32_t stream_type; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
489 enum CodecType codec_type; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
490 enum CodecID codec_id; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
491 } StreamType; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
492 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
493 static const StreamType ISO_types[] = { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
494 { 0x01, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
495 { 0x02, CODEC_TYPE_VIDEO, CODEC_ID_MPEG2VIDEO }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
496 { 0x03, CODEC_TYPE_AUDIO, CODEC_ID_MP3 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
497 { 0x04, CODEC_TYPE_AUDIO, CODEC_ID_MP3 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
498 { 0x0f, CODEC_TYPE_AUDIO, CODEC_ID_AAC }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
499 { 0x10, CODEC_TYPE_VIDEO, CODEC_ID_MPEG4 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
500 { 0x1b, CODEC_TYPE_VIDEO, CODEC_ID_H264 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
501 { 0xd1, CODEC_TYPE_VIDEO, CODEC_ID_DIRAC }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
502 { 0xea, CODEC_TYPE_VIDEO, CODEC_ID_VC1 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
503 { 0 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
504 }; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
505 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
506 static const StreamType HDMV_types[] = { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
507 { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
508 { 0x82, CODEC_TYPE_AUDIO, CODEC_ID_DTS }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
509 { 0 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
510 }; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
511 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
512 /* ATSC ? */ |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
513 static const StreamType MISC_types[] = { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
514 { 0x81, CODEC_TYPE_AUDIO, CODEC_ID_AC3 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
515 { 0x8a, CODEC_TYPE_AUDIO, CODEC_ID_DTS }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
516 { 0 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
517 }; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
518 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
519 static const StreamType REGD_types[] = { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
520 { MKTAG('d','r','a','c'), CODEC_TYPE_VIDEO, CODEC_ID_DIRAC }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
521 { MKTAG('A','C','-','3'), CODEC_TYPE_AUDIO, CODEC_ID_AC3 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
522 { 0 }, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
523 }; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
524 |
4982 | 525 /* descriptor present */ |
526 static const StreamType DESC_types[] = { | |
527 { 0x6a, CODEC_TYPE_AUDIO, CODEC_ID_AC3 }, /* AC-3 descriptor */ | |
4991 | 528 { 0x7a, CODEC_TYPE_AUDIO, CODEC_ID_EAC3 }, /* E-AC-3 descriptor */ |
4982 | 529 { 0x7b, CODEC_TYPE_AUDIO, CODEC_ID_DTS }, |
530 { 0x59, CODEC_TYPE_SUBTITLE, CODEC_ID_DVB_SUBTITLE }, /* subtitling descriptor */ | |
5048
d44e963aaf1c
add 0-termination in table, patch by Wolfram Gloger, wmglo at dent dot med dot uni-muenchen dot de
bcoudurier
parents:
5000
diff
changeset
|
531 { 0 }, |
4982 | 532 }; |
533 | |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
534 static void mpegts_find_stream_type(AVStream *st, |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
535 uint32_t stream_type, const StreamType *types) |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
536 { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
537 for (; types->stream_type; types++) { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
538 if (stream_type == types->stream_type) { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
539 st->codec->codec_type = types->codec_type; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
540 st->codec->codec_id = types->codec_id; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
541 return; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
542 } |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
543 } |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
544 } |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
545 |
4986
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
546 static AVStream *new_pes_av_stream(PESContext *pes, uint32_t prog_reg_desc, uint32_t code) |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
547 { |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
548 AVStream *st = av_new_stream(pes->stream, pes->pid); |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
549 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
550 if (!st) |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
551 return NULL; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
552 |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
553 av_set_pts_info(st, 33, 1, 90000); |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
554 st->priv_data = pes; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
555 st->codec->codec_type = CODEC_TYPE_DATA; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
556 st->codec->codec_id = CODEC_ID_PROBE; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
557 st->need_parsing = AVSTREAM_PARSE_FULL; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
558 pes->st = st; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
559 |
4981 | 560 dprintf(pes->stream, "stream_type=%x pid=%x prog_reg_desc=%.4s\n", |
561 pes->stream_type, pes->pid, (char*)&prog_reg_desc); | |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
562 |
4988
ba58d4eaca58
set codec_tag to stream type, so user can deal with it
bcoudurier
parents:
4987
diff
changeset
|
563 st->codec->codec_tag = pes->stream_type; |
ba58d4eaca58
set codec_tag to stream type, so user can deal with it
bcoudurier
parents:
4987
diff
changeset
|
564 |
4984 | 565 mpegts_find_stream_type(st, pes->stream_type, ISO_types); |
566 if (prog_reg_desc == AV_RL32("HDMV") && | |
567 st->codec->codec_id == CODEC_ID_PROBE) | |
568 mpegts_find_stream_type(st, pes->stream_type, HDMV_types); | |
569 if (st->codec->codec_id == CODEC_ID_PROBE) | |
570 mpegts_find_stream_type(st, pes->stream_type, MISC_types); | |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
571 |
4986
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
572 /* stream was not present in PMT, guess based on PES start code */ |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
573 if (st->codec->codec_id == CODEC_ID_PROBE) { |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
574 if (code >= 0x1c0 && code <= 0x1df) { |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
575 st->codec->codec_type = CODEC_TYPE_AUDIO; |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
576 st->codec->codec_id = CODEC_ID_MP2; |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
577 } else if (code == 0x1bd) { |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
578 st->codec->codec_type = CODEC_TYPE_AUDIO; |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
579 st->codec->codec_id = CODEC_ID_AC3; |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
580 } |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
581 } |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
582 |
4980
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
583 return st; |
3f9b378936f2
move new_pes_av_stream to avoid forward declaration
bcoudurier
parents:
4979
diff
changeset
|
584 } |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
585 |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
586 static void pmt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
587 { |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
588 MpegTSContext *ts = filter->u.section_filter.opaque; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
589 SectionHeader h1, *h = &h1; |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
590 PESContext *pes; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
591 AVStream *st; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
592 const uint8_t *p, *p_end, *desc_list_end, *desc_end; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
593 int program_info_length, pcr_pid, pid, stream_type; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
594 int desc_list_len, desc_len, desc_tag; |
4983 | 595 int comp_page, anc_page; |
596 char language[4]; | |
4978 | 597 uint32_t prog_reg_desc = 0; /* registration descriptor */ |
885 | 598 |
4862 | 599 #ifdef DEBUG |
600 dprintf(ts->stream, "PMT: len %i\n", section_len); | |
1908
174083eafc6c
Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents:
1787
diff
changeset
|
601 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
602 #endif |
4862 | 603 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
604 p_end = section + section_len - 4; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
605 p = section; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
606 if (parse_section_header(h, &p, p_end) < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
607 return; |
4862 | 608 |
609 dprintf(ts->stream, "sid=0x%x sec_num=%d/%d\n", | |
1724
940907f49a33
"converts printf's to avlog's" patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1481
diff
changeset
|
610 h->id, h->sec_num, h->last_sec_num); |
4862 | 611 |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
612 if (h->tid != PMT_TID) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
613 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
614 |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
615 clear_program(ts, h->id); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
616 pcr_pid = get16(&p, p_end) & 0x1fff; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
617 if (pcr_pid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
618 return; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
619 add_pid_to_pmt(ts, h->id, pcr_pid); |
4862 | 620 |
621 dprintf(ts->stream, "pcr_pid=0x%x\n", pcr_pid); | |
622 | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
623 program_info_length = get16(&p, p_end) & 0xfff; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
624 if (program_info_length < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
625 return; |
3059
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
626 while(program_info_length >= 2) { |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
627 uint8_t tag, len; |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
628 tag = get8(&p, p_end); |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
629 len = get8(&p, p_end); |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
630 if(len > program_info_length - 2) |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
631 //something else is broken, exit the program_descriptors_loop |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
632 break; |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
633 program_info_length -= len + 2; |
4979 | 634 if(tag == 0x05 && len >= 4) { // registration descriptor |
4978 | 635 prog_reg_desc = bytestream_get_le32(&p); |
3059
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
636 len -= 4; |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
637 } |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
638 p += len; |
f982a5a75e40
treat stream_type==0x82 as AUDIO_DTS when the program has a REGISTRATION_DESCRIPTOR with the value HDMV; approved by Mans
nicodvb
parents:
2893
diff
changeset
|
639 } |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
640 p += program_info_length; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
641 if (p >= p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
642 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
643 for(;;) { |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
644 st = 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
645 stream_type = get8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
646 if (stream_type < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
647 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
648 pid = get16(&p, p_end) & 0x1fff; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
649 if (pid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
650 break; |
4981 | 651 |
652 /* now create ffmpeg stream */ | |
653 if (ts->pids[pid] && ts->pids[pid]->type == MPEGTS_PES) { | |
654 pes = ts->pids[pid]->u.pes_filter.opaque; | |
655 st = pes->st; | |
656 } else { | |
657 if (ts->pids[pid]) mpegts_close_filter(ts, ts->pids[pid]); //wrongly added sdt filter probably | |
658 pes = add_pes_stream(ts, pid, pcr_pid, stream_type); | |
659 if (pes) | |
4986
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
660 st = new_pes_av_stream(pes, prog_reg_desc, 0); |
4981 | 661 } |
662 | |
663 if (!st) | |
664 return; | |
665 | |
666 add_pid_to_pmt(ts, h->id, pid); | |
667 | |
668 av_program_add_stream_index(ts->stream, h->id, st->index); | |
669 | |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
670 desc_list_len = get16(&p, p_end) & 0xfff; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
671 if (desc_list_len < 0) |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
672 break; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
673 desc_list_end = p + desc_list_len; |
4859
0929b70d4407
Ok, ts demuxer is more complicated than I thought
bcoudurier
parents:
4858
diff
changeset
|
674 if (desc_list_end > p_end) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
675 break; |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
676 for(;;) { |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
677 desc_tag = get8(&p, desc_list_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
678 if (desc_tag < 0) |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
679 break; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
680 desc_len = get8(&p, desc_list_end); |
4859
0929b70d4407
Ok, ts demuxer is more complicated than I thought
bcoudurier
parents:
4858
diff
changeset
|
681 if (desc_len < 0) |
0929b70d4407
Ok, ts demuxer is more complicated than I thought
bcoudurier
parents:
4858
diff
changeset
|
682 break; |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
683 desc_end = p + desc_len; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
684 if (desc_end > desc_list_end) |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
685 break; |
4862 | 686 |
687 dprintf(ts->stream, "tag: 0x%02x len=%d\n", | |
1724
940907f49a33
"converts printf's to avlog's" patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1481
diff
changeset
|
688 desc_tag, desc_len); |
4862 | 689 |
4982 | 690 if (st->codec->codec_id == CODEC_ID_PROBE && |
691 stream_type == STREAM_TYPE_PRIVATE_DATA) | |
692 mpegts_find_stream_type(st, desc_tag, DESC_types); | |
693 | |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
694 switch(desc_tag) { |
4979 | 695 case 0x59: /* subtitling descriptor */ |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
696 language[0] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
697 language[1] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
698 language[2] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
699 language[3] = 0; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
700 get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
701 comp_page = get16(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
702 anc_page = get16(&p, desc_end); |
4981 | 703 st->codec->sub_id = (anc_page << 16) | comp_page; |
704 av_metadata_set(&st->metadata, "language", language); | |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
705 break; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
706 case 0x0a: /* ISO 639 language descriptor */ |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
707 language[0] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
708 language[1] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
709 language[2] = get8(&p, desc_end); |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
710 language[3] = 0; |
4981 | 711 av_metadata_set(&st->metadata, "language", language); |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
712 break; |
4979 | 713 case 0x05: /* registration descriptor */ |
4987
62bf51efe6ec
set codec_tag to registration descriptor if present
bcoudurier
parents:
4986
diff
changeset
|
714 st->codec->codec_tag = bytestream_get_le32(&p); |
4995 | 715 dprintf(ts->stream, "reg_desc=%.4s\n", (char*)&st->codec->codec_tag); |
4981 | 716 if (st->codec->codec_id == CODEC_ID_PROBE && |
717 stream_type == STREAM_TYPE_PRIVATE_DATA) | |
4987
62bf51efe6ec
set codec_tag to registration descriptor if present
bcoudurier
parents:
4986
diff
changeset
|
718 mpegts_find_stream_type(st, st->codec->codec_tag, REGD_types); |
4860
d14d1f5f4eb4
simplify registration descriptor parsing with bytestream get functions
bcoudurier
parents:
4859
diff
changeset
|
719 break; |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
720 default: |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
721 break; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
722 } |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
723 p = desc_end; |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
724 } |
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
725 p = desc_list_end; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
726 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
727 /* all parameters are there */ |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
728 ts->stop_parse++; |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
729 mpegts_close_filter(ts, filter); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
730 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
731 |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
732 static void pat_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
733 { |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
734 MpegTSContext *ts = filter->u.section_filter.opaque; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
735 SectionHeader h1, *h = &h1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
736 const uint8_t *p, *p_end; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
737 int sid, pmt_pid; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
738 |
4862 | 739 #ifdef DEBUG |
740 dprintf(ts->stream, "PAT:\n"); | |
1908
174083eafc6c
Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents:
1787
diff
changeset
|
741 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
742 #endif |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
743 p_end = section + section_len - 4; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
744 p = section; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
745 if (parse_section_header(h, &p, p_end) < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
746 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
747 if (h->tid != PAT_TID) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
748 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
749 |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
750 clear_programs(ts); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
751 for(;;) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
752 sid = get16(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
753 if (sid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
754 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
755 pmt_pid = get16(&p, p_end) & 0x1fff; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
756 if (pmt_pid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
757 break; |
4862 | 758 |
759 dprintf(ts->stream, "sid=0x%x pid=0x%x\n", sid, pmt_pid); | |
760 | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
761 if (sid == 0x0000) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
762 /* NIT info */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
763 } else { |
2574
9e51e62f5bdd
replaced custom tracking of programs/services with calls to with av_new_program()
nicodvb
parents:
2555
diff
changeset
|
764 av_new_program(ts->stream, sid); |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
765 ts->stop_parse--; |
2137 | 766 mpegts_open_section_filter(ts, pmt_pid, pmt_cb, ts, 1); |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
767 add_pat_entry(ts, sid); |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
768 add_pid_to_pmt(ts, sid, 0); //add pat pid to program |
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
769 add_pid_to_pmt(ts, sid, pmt_pid); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
770 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
771 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
772 /* not found */ |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
773 ts->stop_parse++; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
774 |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
775 mpegts_close_filter(ts, filter); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
776 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
777 |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
778 static void sdt_cb(MpegTSFilter *filter, const uint8_t *section, int section_len) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
779 { |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
780 MpegTSContext *ts = filter->u.section_filter.opaque; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
781 SectionHeader h1, *h = &h1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
782 const uint8_t *p, *p_end, *desc_list_end, *desc_end; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
783 int onid, val, sid, desc_list_len, desc_tag, desc_len, service_type; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
784 char *name, *provider_name; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
785 |
4862 | 786 #ifdef DEBUG |
787 dprintf(ts->stream, "SDT:\n"); | |
1908
174083eafc6c
Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents:
1787
diff
changeset
|
788 av_hex_dump_log(ts->stream, AV_LOG_DEBUG, (uint8_t *)section, section_len); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
789 #endif |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
790 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
791 p_end = section + section_len - 4; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
792 p = section; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
793 if (parse_section_header(h, &p, p_end) < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
794 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
795 if (h->tid != SDT_TID) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
796 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
797 onid = get16(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
798 if (onid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
799 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
800 val = get8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
801 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
802 return; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
803 for(;;) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
804 sid = get16(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
805 if (sid < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
806 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
807 val = get8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
808 if (val < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
809 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
810 desc_list_len = get16(&p, p_end) & 0xfff; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
811 if (desc_list_len < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
812 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
813 desc_list_end = p + desc_list_len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
814 if (desc_list_end > p_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
815 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
816 for(;;) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
817 desc_tag = get8(&p, desc_list_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
818 if (desc_tag < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
819 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
820 desc_len = get8(&p, desc_list_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
821 desc_end = p + desc_len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
822 if (desc_end > desc_list_end) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
823 break; |
4862 | 824 |
825 dprintf(ts->stream, "tag: 0x%02x len=%d\n", | |
1724
940907f49a33
"converts printf's to avlog's" patch by Daniel Kristjansson / danielk mrl.nyu edu
michael
parents:
1481
diff
changeset
|
826 desc_tag, desc_len); |
4862 | 827 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
828 switch(desc_tag) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
829 case 0x48: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
830 service_type = get8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
831 if (service_type < 0) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
832 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
833 provider_name = getstr8(&p, p_end); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
834 if (!provider_name) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
835 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
836 name = getstr8(&p, p_end); |
2574
9e51e62f5bdd
replaced custom tracking of programs/services with calls to with av_new_program()
nicodvb
parents:
2555
diff
changeset
|
837 if (name) { |
9e51e62f5bdd
replaced custom tracking of programs/services with calls to with av_new_program()
nicodvb
parents:
2555
diff
changeset
|
838 AVProgram *program = av_new_program(ts->stream, sid); |
4427 | 839 if(program) { |
840 av_metadata_set(&program->metadata, "name", name); | |
841 av_metadata_set(&program->metadata, "provider_name", provider_name); | |
842 } | |
2574
9e51e62f5bdd
replaced custom tracking of programs/services with calls to with av_new_program()
nicodvb
parents:
2555
diff
changeset
|
843 } |
3247 | 844 av_free(name); |
845 av_free(provider_name); | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
846 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
847 default: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
848 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
849 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
850 p = desc_end; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
851 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
852 p = desc_list_end; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
853 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
854 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
855 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
856 static int64_t get_pts(const uint8_t *p) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
857 { |
2222 | 858 int64_t pts = (int64_t)((p[0] >> 1) & 0x07) << 30; |
859 pts |= (AV_RB16(p + 1) >> 1) << 15; | |
860 pts |= AV_RB16(p + 3) >> 1; | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
861 return pts; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
862 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
863 |
4963 | 864 static void new_pes_packet(PESContext *pes, AVPacket *pkt) |
865 { | |
866 av_init_packet(pkt); | |
867 | |
868 pkt->destruct = av_destruct_packet; | |
869 pkt->data = pes->buffer; | |
870 pkt->size = pes->data_index; | |
871 memset(pkt->data+pkt->size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
872 | |
873 pkt->stream_index = pes->st->index; | |
874 pkt->pts = pes->pts; | |
875 pkt->dts = pes->dts; | |
876 /* store position of first TS packet of this PES packet */ | |
877 pkt->pos = pes->ts_packet_pos; | |
878 | |
879 /* reset pts values */ | |
880 pes->pts = AV_NOPTS_VALUE; | |
881 pes->dts = AV_NOPTS_VALUE; | |
882 pes->buffer = NULL; | |
883 pes->data_index = 0; | |
884 } | |
885 | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
886 /* return non zero if a packet could be constructed */ |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
887 static int mpegts_push_data(MpegTSFilter *filter, |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
888 const uint8_t *buf, int buf_size, int is_start, |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
889 int64_t pos) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
890 { |
2132
c8e642dd5f9c
passing MpegTSFilter to the filters instead of a random void *opaque
michael
parents:
2129
diff
changeset
|
891 PESContext *pes = filter->u.pes_filter.opaque; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
892 MpegTSContext *ts = pes->ts; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
893 const uint8_t *p; |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
894 int len, code; |
885 | 895 |
2111
4aafc6050f39
kill completely idiotic code which hides all but 2 streams
michael
parents:
2110
diff
changeset
|
896 if(!ts->pkt) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
897 return 0; |
2111
4aafc6050f39
kill completely idiotic code which hides all but 2 streams
michael
parents:
2110
diff
changeset
|
898 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
899 if (is_start) { |
4963 | 900 if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) { |
901 new_pes_packet(pes, ts->pkt); | |
902 ts->stop_parse = 1; | |
903 } | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
904 pes->state = MPEGTS_HEADER; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
905 pes->data_index = 0; |
4615
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
906 pes->ts_packet_pos = pos; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
907 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
908 p = buf; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
909 while (buf_size > 0) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
910 switch(pes->state) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
911 case MPEGTS_HEADER: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
912 len = PES_START_SIZE - pes->data_index; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
913 if (len > buf_size) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
914 len = buf_size; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
915 memcpy(pes->header + pes->data_index, p, len); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
916 pes->data_index += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
917 p += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
918 buf_size -= len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
919 if (pes->data_index == PES_START_SIZE) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
920 /* we got all the PES or section header. We can now |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
921 decide */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
922 #if 0 |
1908
174083eafc6c
Introduce two new logging functions av_hex_dump_log() and av_pkt_dump_log()
takis
parents:
1787
diff
changeset
|
923 av_hex_dump_log(pes->stream, AV_LOG_DEBUG, pes->header, pes->data_index); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
924 #endif |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
925 if (pes->header[0] == 0x00 && pes->header[1] == 0x00 && |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
926 pes->header[2] == 0x01) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
927 /* it must be an mpeg2 PES stream */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
928 code = pes->header[3] | 0x100; |
4998 | 929 dprintf(pes->stream, "pid=%x pes_code=%#x\n", pes->pid, code); |
930 | |
4999 | 931 if ((!pes->st && pes->stream->nb_streams == MAX_STREAMS) || |
932 (pes->st && pes->st->discard == AVDISCARD_ALL) || | |
4998 | 933 code == 0x1be) /* padding_stream */ |
934 goto skip; | |
4986
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
935 |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
936 /* stream not present in PMT */ |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
937 if (!pes->st) |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
938 pes->st = new_pes_av_stream(pes, 0, code); |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
939 if (!pes->st) |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
940 return AVERROR(ENOMEM); |
b9c3d05b3267
add streams even if they are not present in PMT, fix #1092 and #835
bcoudurier
parents:
4985
diff
changeset
|
941 |
2222 | 942 pes->total_size = AV_RB16(pes->header + 4); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
943 /* NOTE: a zero total size means the PES size is |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
944 unbounded */ |
4998 | 945 if (!pes->total_size) |
946 pes->total_size = MAX_PES_PAYLOAD; | |
947 | |
948 /* allocate pes buffer */ | |
949 pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE); | |
950 if (!pes->buffer) | |
951 return AVERROR(ENOMEM); | |
952 | |
953 if (code != 0x1bc && code != 0x1bf && /* program_stream_map, private_stream_2 */ | |
954 code != 0x1f0 && code != 0x1f1 && /* ECM, EMM */ | |
955 code != 0x1ff && code != 0x1f2 && /* program_stream_directory, DSMCC_stream */ | |
956 code != 0x1f8) { /* ITU-T Rec. H.222.1 type E stream */ | |
5000 | 957 pes->state = MPEGTS_PESHEADER; |
4998 | 958 } else { |
959 pes->state = MPEGTS_PAYLOAD; | |
960 pes->data_index = 0; | |
961 } | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
962 } else { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
963 /* otherwise, it should be a table */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
964 /* skip packet */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
965 skip: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
966 pes->state = MPEGTS_SKIP; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
967 continue; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
968 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
969 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
970 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
971 /**********************************************/ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
972 /* PES packing parsing */ |
5000 | 973 case MPEGTS_PESHEADER: |
974 len = PES_HEADER_SIZE - pes->data_index; | |
975 if (len < 0) | |
976 return -1; | |
977 if (len > buf_size) | |
978 len = buf_size; | |
979 memcpy(pes->header + pes->data_index, p, len); | |
980 pes->data_index += len; | |
981 p += len; | |
982 buf_size -= len; | |
983 if (pes->data_index == PES_HEADER_SIZE) { | |
984 pes->pes_header_size = pes->header[8] + 9; | |
985 pes->state = MPEGTS_PESHEADER_FILL; | |
986 } | |
987 break; | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
988 case MPEGTS_PESHEADER_FILL: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
989 len = pes->pes_header_size - pes->data_index; |
4964 | 990 if (len < 0) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
991 return -1; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
992 if (len > buf_size) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
993 len = buf_size; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
994 memcpy(pes->header + pes->data_index, p, len); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
995 pes->data_index += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
996 p += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
997 buf_size -= len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
998 if (pes->data_index == pes->pes_header_size) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
999 const uint8_t *r; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1000 unsigned int flags; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1001 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1002 flags = pes->header[7]; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1003 r = pes->header + 9; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1004 pes->pts = AV_NOPTS_VALUE; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1005 pes->dts = AV_NOPTS_VALUE; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1006 if ((flags & 0xc0) == 0x80) { |
4280
99d0dac39813
set pts and dts when only pts is present, according to specs
bcoudurier
parents:
4251
diff
changeset
|
1007 pes->dts = pes->pts = get_pts(r); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1008 r += 5; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1009 } else if ((flags & 0xc0) == 0xc0) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1010 pes->pts = get_pts(r); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1011 r += 5; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1012 pes->dts = get_pts(r); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1013 r += 5; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1014 } |
4963 | 1015 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1016 /* we got the full header. We parse it and get the payload */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1017 pes->state = MPEGTS_PAYLOAD; |
4963 | 1018 pes->data_index = 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1019 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1020 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1021 case MPEGTS_PAYLOAD: |
4963 | 1022 if (buf_size > 0) { |
1023 if (pes->data_index+buf_size > pes->total_size) { | |
1024 new_pes_packet(pes, ts->pkt); | |
1025 pes->total_size = MAX_PES_PAYLOAD; | |
1026 pes->buffer = av_malloc(pes->total_size+FF_INPUT_BUFFER_PADDING_SIZE); | |
1027 if (!pes->buffer) | |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1028 return AVERROR(ENOMEM); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1029 ts->stop_parse = 1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1030 } |
4963 | 1031 memcpy(pes->buffer+pes->data_index, p, buf_size); |
1032 pes->data_index += buf_size; | |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1033 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1034 buf_size = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1035 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1036 case MPEGTS_SKIP: |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1037 buf_size = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1038 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1039 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1040 } |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1041 |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1042 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1043 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1044 |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
1045 static PESContext *add_pes_stream(MpegTSContext *ts, int pid, int pcr_pid, int stream_type) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1046 { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1047 MpegTSFilter *tss; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1048 PESContext *pes; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1049 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1050 /* if no pid found, then add a pid context */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1051 pes = av_mallocz(sizeof(PESContext)); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1052 if (!pes) |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
1053 return 0; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1054 pes->ts = ts; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1055 pes->stream = ts->stream; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1056 pes->pid = pid; |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
1057 pes->pcr_pid = pcr_pid; |
313
622892a75ddb
support more codecs in MPEG-TS patch by (mru at kth dot se (M«©ns Rullg«©rd))
michael
parents:
310
diff
changeset
|
1058 pes->stream_type = stream_type; |
4997 | 1059 pes->state = MPEGTS_SKIP; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1060 tss = mpegts_open_pes_filter(ts, pid, mpegts_push_data, pes); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1061 if (!tss) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1062 av_free(pes); |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
1063 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1064 } |
819
a6c035e7f429
DVB subtitle decoder by (Ian Caulfield: imc25, cam ac uk)
michael
parents:
775
diff
changeset
|
1065 return pes; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1066 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1067 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1068 /* handle one TS packet */ |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1069 static int handle_packet(MpegTSContext *ts, const uint8_t *packet) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1070 { |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1071 AVFormatContext *s = ts->stream; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1072 MpegTSFilter *tss; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1073 int len, pid, cc, cc_ok, afc, is_start; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1074 const uint8_t *p, *p_end; |
4615
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
1075 int64_t pos; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1076 |
2222 | 1077 pid = AV_RB16(packet + 1) & 0x1fff; |
2575
06d31789d338
added structures and code to keep track of pids<->programs mapping: it's needed
nicodvb
parents:
2574
diff
changeset
|
1078 if(pid && discard_pid(ts, pid)) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1079 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1080 is_start = packet[1] & 0x40; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1081 tss = ts->pids[pid]; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1082 if (ts->auto_guess && tss == NULL && is_start) { |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
1083 add_pes_stream(ts, pid, -1, 0); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1084 tss = ts->pids[pid]; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1085 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1086 if (!tss) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1087 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1088 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1089 /* continuity check (currently not used) */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1090 cc = (packet[3] & 0xf); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1091 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc)); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1092 tss->last_cc = cc; |
885 | 1093 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1094 /* skip adaptation field */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1095 afc = (packet[3] >> 4) & 3; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1096 p = packet + 4; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1097 if (afc == 0) /* reserved value */ |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1098 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1099 if (afc == 2) /* adaptation field only */ |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1100 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1101 if (afc == 3) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1102 /* skip adapation field */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1103 p += p[0] + 1; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1104 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1105 /* if past the end of packet, ignore */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1106 p_end = packet + TS_PACKET_SIZE; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1107 if (p >= p_end) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1108 return 0; |
885 | 1109 |
4615
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
1110 pos = url_ftell(ts->stream->pb); |
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
1111 ts->pos47= pos % ts->raw_packet_size; |
3240
78153a85dccc
Ensure that the timestamp reading code used for seeking chooses a position
michael
parents:
3226
diff
changeset
|
1112 |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1113 if (tss->type == MPEGTS_SECTION) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1114 if (is_start) { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1115 /* pointer field present */ |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1116 len = *p++; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1117 if (p + len > p_end) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1118 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1119 if (len && cc_ok) { |
675
29a19aec26b2
Writing to freed memory in write_section_data() patch by (Wolfram Gloger <wmglo dent dot med dot uni-muenchen de>)
michael
parents:
555
diff
changeset
|
1120 /* write remaining section bytes */ |
885 | 1121 write_section_data(s, tss, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1122 p, len, 0); |
675
29a19aec26b2
Writing to freed memory in write_section_data() patch by (Wolfram Gloger <wmglo dent dot med dot uni-muenchen de>)
michael
parents:
555
diff
changeset
|
1123 /* check whether filter has been closed */ |
29a19aec26b2
Writing to freed memory in write_section_data() patch by (Wolfram Gloger <wmglo dent dot med dot uni-muenchen de>)
michael
parents:
555
diff
changeset
|
1124 if (!ts->pids[pid]) |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1125 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1126 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1127 p += len; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1128 if (p < p_end) { |
885 | 1129 write_section_data(s, tss, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1130 p, p_end - p, 1); |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1131 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1132 } else { |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1133 if (cc_ok) { |
885 | 1134 write_section_data(s, tss, |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1135 p, p_end - p, 0); |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1136 } |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1137 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1138 } else { |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1139 int ret; |
4615
12a7cd9178dd
Change TS seeking so it returns position/timestamp of a key frame.
cehoyos
parents:
4427
diff
changeset
|
1140 // Note: The position here points actually behind the current packet. |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1141 if ((ret = tss->u.pes_filter.pes_cb(tss, p, p_end - p, is_start, |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1142 pos - ts->raw_packet_size)) < 0) |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1143 return ret; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1144 } |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1145 |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1146 return 0; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1147 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1148 |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1149 /* XXX: try to find a better synchro over several packets (use |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1150 get_packet_size() ?) */ |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1151 static int mpegts_resync(ByteIOContext *pb) |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1152 { |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1153 int c, i; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1154 |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1155 for(i = 0;i < MAX_RESYNC_SIZE; i++) { |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1156 c = url_fgetc(pb); |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1157 if (c < 0) |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1158 return -1; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1159 if (c == 0x47) { |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1160 url_fseek(pb, -1, SEEK_CUR); |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1161 return 0; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1162 } |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1163 } |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1164 /* no sync found */ |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1165 return -1; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1166 } |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1167 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1168 /* return -1 if error or EOF. Return 0 if OK. */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1169 static int read_packet(ByteIOContext *pb, uint8_t *buf, int raw_packet_size) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1170 { |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1171 int skip, len; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1172 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1173 for(;;) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1174 len = get_buffer(pb, buf, TS_PACKET_SIZE); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1175 if (len != TS_PACKET_SIZE) |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2247
diff
changeset
|
1176 return AVERROR(EIO); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1177 /* check paquet sync byte */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1178 if (buf[0] != 0x47) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1179 /* find a new packet start */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1180 url_fseek(pb, -TS_PACKET_SIZE, SEEK_CUR); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1181 if (mpegts_resync(pb) < 0) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1182 return AVERROR_INVALIDDATA; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1183 else |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1184 continue; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1185 } else { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1186 skip = raw_packet_size - TS_PACKET_SIZE; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1187 if (skip > 0) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1188 url_fskip(pb, skip); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1189 break; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1190 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1191 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1192 return 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1193 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1194 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1195 static int handle_packets(MpegTSContext *ts, int nb_packets) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1196 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1197 AVFormatContext *s = ts->stream; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1198 ByteIOContext *pb = s->pb; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1199 uint8_t packet[TS_PACKET_SIZE]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1200 int packet_num, ret; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1201 |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1202 ts->stop_parse = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1203 packet_num = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1204 for(;;) { |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
1205 if (ts->stop_parse>0) |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1206 break; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1207 packet_num++; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1208 if (nb_packets != 0 && packet_num >= nb_packets) |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1209 break; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1210 ret = read_packet(pb, packet, ts->raw_packet_size); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1211 if (ret != 0) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1212 return ret; |
4966
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1213 ret = handle_packet(ts, packet); |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1214 if (ret != 0) |
a6c807c154b1
return error in mpegts_push_data and propagate it
bcoudurier
parents:
4965
diff
changeset
|
1215 return ret; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1216 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1217 return 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1218 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1219 |
0 | 1220 static int mpegts_probe(AVProbeData *p) |
1221 { | |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1222 #if 1 |
329 | 1223 const int size= p->buf_size; |
891 | 1224 int score, fec_score, dvhs_score; |
4365
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1225 int check_count= size / TS_FEC_PACKET_SIZE; |
329 | 1226 #define CHECK_COUNT 10 |
885 | 1227 |
4365
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1228 if (check_count < CHECK_COUNT) |
329 | 1229 return -1; |
885 | 1230 |
4365
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1231 score = analyze(p->buf, TS_PACKET_SIZE *check_count, TS_PACKET_SIZE , NULL)*CHECK_COUNT/check_count; |
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1232 dvhs_score= analyze(p->buf, TS_DVHS_PACKET_SIZE*check_count, TS_DVHS_PACKET_SIZE, NULL)*CHECK_COUNT/check_count; |
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1233 fec_score = analyze(p->buf, TS_FEC_PACKET_SIZE *check_count, TS_FEC_PACKET_SIZE , NULL)*CHECK_COUNT/check_count; |
891 | 1234 // av_log(NULL, AV_LOG_DEBUG, "score: %d, dvhs_score: %d, fec_score: %d \n", score, dvhs_score, fec_score); |
885 | 1235 |
329 | 1236 // we need a clear definition for the returned score otherwise things will become messy sooner or later |
891 | 1237 if (score > fec_score && score > dvhs_score && score > 6) return AVPROBE_SCORE_MAX + score - CHECK_COUNT; |
1238 else if(dvhs_score > score && dvhs_score > fec_score && dvhs_score > 6) return AVPROBE_SCORE_MAX + dvhs_score - CHECK_COUNT; | |
329 | 1239 else if( fec_score > 6) return AVPROBE_SCORE_MAX + fec_score - CHECK_COUNT; |
1240 else return -1; | |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1241 #else |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1242 /* only use the extension for safer guess */ |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1243 if (match_ext(p->filename, "ts")) |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1244 return AVPROBE_SCORE_MAX; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1245 else |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1246 return 0; |
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1247 #endif |
0 | 1248 } |
1249 | |
3968 | 1250 /* return the 90kHz PCR and the extension for the 27MHz PCR. return |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1251 (-1) if not available */ |
885 | 1252 static int parse_pcr(int64_t *ppcr_high, int *ppcr_low, |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1253 const uint8_t *packet) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1254 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1255 int afc, len, flags; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1256 const uint8_t *p; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1257 unsigned int v; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1258 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1259 afc = (packet[3] >> 4) & 3; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1260 if (afc <= 1) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1261 return -1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1262 p = packet + 4; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1263 len = p[0]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1264 p++; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1265 if (len == 0) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1266 return -1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1267 flags = *p++; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1268 len--; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1269 if (!(flags & 0x10)) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1270 return -1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1271 if (len < 6) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1272 return -1; |
2222 | 1273 v = AV_RB32(p); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1274 *ppcr_high = ((int64_t)v << 1) | (p[4] >> 7); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1275 *ppcr_low = ((p[4] & 1) << 8) | p[5]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1276 return 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1277 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1278 |
0 | 1279 static int mpegts_read_header(AVFormatContext *s, |
1280 AVFormatParameters *ap) | |
1281 { | |
1282 MpegTSContext *ts = s->priv_data; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1283 ByteIOContext *pb = s->pb; |
4365
85ba93088fb5
Fix probe & demuxing of Topfield 58XXPVR and 68XXPVR (topfield.rec)
michael
parents:
4280
diff
changeset
|
1284 uint8_t buf[5*1024]; |
2135 | 1285 int len; |
65 | 1286 int64_t pos; |
474 | 1287 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1288 if (ap) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1289 ts->mpeg2ts_compute_pcr = ap->mpeg2ts_compute_pcr; |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1290 if(ap->mpeg2ts_raw){ |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1291 av_log(s, AV_LOG_ERROR, "use mpegtsraw_demuxer!\n"); |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1292 return -1; |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1293 } |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1294 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1295 |
0 | 1296 /* read the first 1024 bytes to get packet size */ |
1297 pos = url_ftell(pb); | |
1298 len = get_buffer(pb, buf, sizeof(buf)); | |
1299 if (len != sizeof(buf)) | |
1300 goto fail; | |
1301 ts->raw_packet_size = get_packet_size(buf, sizeof(buf)); | |
1302 if (ts->raw_packet_size <= 0) | |
1303 goto fail; | |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1304 ts->stream = s; |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1305 ts->auto_guess = 0; |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1306 |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1307 if (s->iformat == &mpegts_demuxer) { |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1308 /* normal demux */ |
170
0543d27721c1
cosmetic change in resync code - added PAT scanning code if no SDT is found (in the futur it would be interesting to give an API to change channel - also useful for DV input number or TV grab tunning
bellard
parents:
165
diff
changeset
|
1309 |
2126 | 1310 /* first do a scaning to get all the services */ |
1311 url_fseek(pb, pos, SEEK_SET); | |
4868 | 1312 |
1313 mpegts_open_section_filter(ts, SDT_PID, sdt_cb, ts, 1); | |
2126 | 1314 |
4866 | 1315 mpegts_open_section_filter(ts, PAT_PID, pat_cb, ts, 1); |
885 | 1316 |
2137 | 1317 handle_packets(ts, s->probesize); |
2126 | 1318 /* if could not find service, enable auto_guess */ |
885 | 1319 |
2126 | 1320 ts->auto_guess = 1; |
885 | 1321 |
4862 | 1322 dprintf(ts->stream, "tuning done\n"); |
1323 | |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1324 s->ctx_flags |= AVFMTCTX_NOHEADER; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1325 } else { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1326 AVStream *st; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1327 int pcr_pid, pid, nb_packets, nb_pcrs, ret, pcr_l; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1328 int64_t pcrs[2], pcr_h; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1329 int packet_count[2]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1330 uint8_t packet[TS_PACKET_SIZE]; |
885 | 1331 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1332 /* only read packets */ |
885 | 1333 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1334 st = av_new_stream(s, 0); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1335 if (!st) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1336 goto fail; |
462
b69898ffc92a
move time_base (pts_num/pts_den) from AVFormatContext -> AVStream
michael
parents:
444
diff
changeset
|
1337 av_set_pts_info(st, 60, 1, 27000000); |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
819
diff
changeset
|
1338 st->codec->codec_type = CODEC_TYPE_DATA; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
819
diff
changeset
|
1339 st->codec->codec_id = CODEC_ID_MPEG2TS; |
885 | 1340 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1341 /* we iterate until we find two PCRs to estimate the bitrate */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1342 pcr_pid = -1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1343 nb_pcrs = 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1344 nb_packets = 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1345 for(;;) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1346 ret = read_packet(s->pb, packet, ts->raw_packet_size); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1347 if (ret < 0) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1348 return -1; |
2222 | 1349 pid = AV_RB16(packet + 1) & 0x1fff; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1350 if ((pcr_pid == -1 || pcr_pid == pid) && |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1351 parse_pcr(&pcr_h, &pcr_l, packet) == 0) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1352 pcr_pid = pid; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1353 packet_count[nb_pcrs] = nb_packets; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1354 pcrs[nb_pcrs] = pcr_h * 300 + pcr_l; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1355 nb_pcrs++; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1356 if (nb_pcrs >= 2) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1357 break; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1358 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1359 nb_packets++; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1360 } |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1361 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1362 /* NOTE1: the bitrate is computed without the FEC */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1363 /* NOTE2: it is only the bitrate of the start of the stream */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1364 ts->pcr_incr = (pcrs[1] - pcrs[0]) / (packet_count[1] - packet_count[0]); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1365 ts->cur_pcr = pcrs[0] - ts->pcr_incr * packet_count[0]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1366 s->bit_rate = (TS_PACKET_SIZE * 8) * 27e6 / ts->pcr_incr; |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
819
diff
changeset
|
1367 st->codec->bit_rate = s->bit_rate; |
743 | 1368 st->start_time = ts->cur_pcr; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1369 #if 0 |
1748 | 1370 av_log(ts->stream, AV_LOG_DEBUG, "start=%0.3f pcr=%0.3f incr=%d\n", |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1371 st->start_time / 1000000.0, pcrs[0] / 27e6, ts->pcr_incr); |
152
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1372 #endif |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1373 } |
cc03a75cbde4
mpeg ts demux uses DVB SI info and generates correct PTS info - added prototype mpeg ts mux
bellard
parents:
107
diff
changeset
|
1374 |
0 | 1375 url_fseek(pb, pos, SEEK_SET); |
1376 return 0; | |
1377 fail: | |
1378 return -1; | |
1379 } | |
1380 | |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1381 #define MAX_PACKET_READAHEAD ((128 * 1024) / 188) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1382 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1383 static int mpegts_raw_read_packet(AVFormatContext *s, |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1384 AVPacket *pkt) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1385 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1386 MpegTSContext *ts = s->priv_data; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1387 int ret, i; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1388 int64_t pcr_h, next_pcr_h, pos; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1389 int pcr_l, next_pcr_l; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1390 uint8_t pcr_buf[12]; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1391 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1392 if (av_new_packet(pkt, TS_PACKET_SIZE) < 0) |
1787
eb16c64144ee
This fixes error handling for BeOS, removing the need for some ifdefs.
mmu_man
parents:
1774
diff
changeset
|
1393 return AVERROR(ENOMEM); |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1394 pkt->pos= url_ftell(s->pb); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1395 ret = read_packet(s->pb, pkt->data, ts->raw_packet_size); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1396 if (ret < 0) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1397 av_free_packet(pkt); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1398 return ret; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1399 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1400 if (ts->mpeg2ts_compute_pcr) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1401 /* compute exact PCR for each packet */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1402 if (parse_pcr(&pcr_h, &pcr_l, pkt->data) == 0) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1403 /* we read the next PCR (XXX: optimize it by using a bigger buffer */ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1404 pos = url_ftell(s->pb); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1405 for(i = 0; i < MAX_PACKET_READAHEAD; i++) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1406 url_fseek(s->pb, pos + i * ts->raw_packet_size, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1407 get_buffer(s->pb, pcr_buf, 12); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1408 if (parse_pcr(&next_pcr_h, &next_pcr_l, pcr_buf) == 0) { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1409 /* XXX: not precise enough */ |
885 | 1410 ts->pcr_incr = ((next_pcr_h - pcr_h) * 300 + (next_pcr_l - pcr_l)) / |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1411 (i + 1); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1412 break; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1413 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1414 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1415 url_fseek(s->pb, pos, SEEK_SET); |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1416 /* no next PCR found: we use previous increment */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1417 ts->cur_pcr = pcr_h * 300 + pcr_l; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1418 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1419 pkt->pts = ts->cur_pcr; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1420 pkt->duration = ts->pcr_incr; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1421 ts->cur_pcr += ts->pcr_incr; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1422 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1423 pkt->stream_index = 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1424 return 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1425 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1426 |
0 | 1427 static int mpegts_read_packet(AVFormatContext *s, |
1428 AVPacket *pkt) | |
1429 { | |
1430 MpegTSContext *ts = s->priv_data; | |
4963 | 1431 int ret, i; |
1432 | |
1433 if (url_ftell(s->pb) != ts->last_pos) { | |
1434 /* seek detected, flush pes buffer */ | |
1435 for (i = 0; i < NB_PID_MAX; i++) { | |
1436 if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) { | |
1437 PESContext *pes = ts->pids[i]->u.pes_filter.opaque; | |
1438 av_freep(&pes->buffer); | |
1439 pes->data_index = 0; | |
1440 pes->state = MPEGTS_SKIP; /* skip until pes header */ | |
1441 } | |
1442 } | |
1443 } | |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1444 |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1445 ts->pkt = pkt; |
4963 | 1446 ret = handle_packets(ts, 0); |
1447 if (ret < 0) { | |
1448 /* flush pes data left */ | |
1449 for (i = 0; i < NB_PID_MAX; i++) { | |
1450 if (ts->pids[i] && ts->pids[i]->type == MPEGTS_PES) { | |
1451 PESContext *pes = ts->pids[i]->u.pes_filter.opaque; | |
1452 if (pes->state == MPEGTS_PAYLOAD && pes->data_index > 0) { | |
1453 new_pes_packet(pes, pkt); | |
1454 ret = 0; | |
1455 break; | |
1456 } | |
1457 } | |
1458 } | |
1459 } | |
1460 | |
1461 ts->last_pos = url_ftell(s->pb); | |
1462 | |
1463 return ret; | |
0 | 1464 } |
1465 | |
1466 static int mpegts_read_close(AVFormatContext *s) | |
1467 { | |
1468 MpegTSContext *ts = s->priv_data; | |
1469 int i; | |
3247 | 1470 |
1471 clear_programs(ts); | |
1472 | |
0 | 1473 for(i=0;i<NB_PID_MAX;i++) |
342
0c1b489c96bf
memleak patch by (Gildas Bazin <gbazin at altern dot org>)
michael
parents:
329
diff
changeset
|
1474 if (ts->pids[i]) mpegts_close_filter(ts, ts->pids[i]); |
1046 | 1475 |
0 | 1476 return 0; |
1477 } | |
1478 | |
885 | 1479 static int64_t mpegts_get_pcr(AVFormatContext *s, int stream_index, |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1480 int64_t *ppos, int64_t pos_limit) |
310 | 1481 { |
1482 MpegTSContext *ts = s->priv_data; | |
1483 int64_t pos, timestamp; | |
1484 uint8_t buf[TS_PACKET_SIZE]; | |
2157
0103a8479df5
proper per stream pcr_pid support by (Wolfram Gloger wmglo dent.med.uni-muenchen@de )
michael
parents:
2146
diff
changeset
|
1485 int pcr_l, pcr_pid = ((PESContext*)s->streams[stream_index]->priv_data)->pcr_pid; |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1486 const int find_next= 1; |
3240
78153a85dccc
Ensure that the timestamp reading code used for seeking chooses a position
michael
parents:
3226
diff
changeset
|
1487 pos = ((*ppos + ts->raw_packet_size - 1 - ts->pos47) / ts->raw_packet_size) * ts->raw_packet_size + ts->pos47; |
310 | 1488 if (find_next) { |
1489 for(;;) { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1490 url_fseek(s->pb, pos, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1491 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) |
310 | 1492 return AV_NOPTS_VALUE; |
2222 | 1493 if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) && |
310 | 1494 parse_pcr(×tamp, &pcr_l, buf) == 0) { |
1495 break; | |
1496 } | |
1497 pos += ts->raw_packet_size; | |
1498 } | |
1499 } else { | |
1500 for(;;) { | |
1501 pos -= ts->raw_packet_size; | |
1502 if (pos < 0) | |
1503 return AV_NOPTS_VALUE; | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1504 url_fseek(s->pb, pos, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1505 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) |
310 | 1506 return AV_NOPTS_VALUE; |
2222 | 1507 if ((pcr_pid < 0 || (AV_RB16(buf + 1) & 0x1fff) == pcr_pid) && |
310 | 1508 parse_pcr(×tamp, &pcr_l, buf) == 0) { |
1509 break; | |
1510 } | |
1511 } | |
1512 } | |
1513 *ppos = pos; | |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1514 |
310 | 1515 return timestamp; |
1516 } | |
1517 | |
555 | 1518 static int read_seek(AVFormatContext *s, int stream_index, int64_t target_ts, int flags){ |
474 | 1519 MpegTSContext *ts = s->priv_data; |
1520 uint8_t buf[TS_PACKET_SIZE]; | |
1521 int64_t pos; | |
1522 | |
555 | 1523 if(av_seek_frame_binary(s, stream_index, target_ts, flags) < 0) |
474 | 1524 return -1; |
1525 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1526 pos= url_ftell(s->pb); |
474 | 1527 |
1528 for(;;) { | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1529 url_fseek(s->pb, pos, SEEK_SET); |
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1530 if (get_buffer(s->pb, buf, TS_PACKET_SIZE) != TS_PACKET_SIZE) |
474 | 1531 return -1; |
2222 | 1532 // pid = AV_RB16(buf + 1) & 0x1fff; |
474 | 1533 if(buf[1] & 0x40) break; |
1534 pos += ts->raw_packet_size; | |
885 | 1535 } |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2761
diff
changeset
|
1536 url_fseek(s->pb, pos, SEEK_SET); |
474 | 1537 |
1538 return 0; | |
1539 } | |
1540 | |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1541 /**************************************************************/ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1542 /* parsing functions - called from other demuxers such as RTP */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1543 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1544 MpegTSContext *mpegts_parse_open(AVFormatContext *s) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1545 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1546 MpegTSContext *ts; |
885 | 1547 |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1548 ts = av_mallocz(sizeof(MpegTSContext)); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1549 if (!ts) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1550 return NULL; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1551 /* no stream case, currently used by RTP */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1552 ts->raw_packet_size = TS_PACKET_SIZE; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1553 ts->stream = s; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1554 ts->auto_guess = 1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1555 return ts; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1556 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1557 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1558 /* return the consumed length if a packet was output, or -1 if no |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1559 packet is output */ |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1560 int mpegts_parse_packet(MpegTSContext *ts, AVPacket *pkt, |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1561 const uint8_t *buf, int len) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1562 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1563 int len1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1564 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1565 len1 = len; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1566 ts->pkt = pkt; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1567 ts->stop_parse = 0; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1568 for(;;) { |
2134
16cf48c9af53
dont rescan for information on each pid, but rather do it just once by
michael
parents:
2133
diff
changeset
|
1569 if (ts->stop_parse>0) |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1570 break; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1571 if (len < TS_PACKET_SIZE) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1572 return -1; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1573 if (buf[0] != 0x47) { |
444
d42038d418a0
Off-by-two in mpegts.c patch by (Wolfram Gloger <wmglo at dent dot med dot uni-muenchen dot de>)
michael
parents:
398
diff
changeset
|
1574 buf++; |
292
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1575 len--; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1576 } else { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1577 handle_packet(ts, buf); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1578 buf += TS_PACKET_SIZE; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1579 len -= TS_PACKET_SIZE; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1580 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1581 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1582 return len1 - len; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1583 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1584 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1585 void mpegts_parse_close(MpegTSContext *ts) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1586 { |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1587 int i; |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1588 |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1589 for(i=0;i<NB_PID_MAX;i++) |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1590 av_free(ts->pids[i]); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1591 av_free(ts); |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1592 } |
155ce13f1033
mpeg TS demux API (called from RTP layer) - raw mpeg TS reader (uses fake codec MPEG2TS)
bellard
parents:
283
diff
changeset
|
1593 |
1167 | 1594 AVInputFormat mpegts_demuxer = { |
0 | 1595 "mpegts", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
1596 NULL_IF_CONFIG_SMALL("MPEG-2 transport stream format"), |
0 | 1597 sizeof(MpegTSContext), |
1598 mpegts_probe, | |
1599 mpegts_read_header, | |
1600 mpegts_read_packet, | |
1601 mpegts_read_close, | |
474 | 1602 read_seek, |
463
696f41bc8784
store index for seeking in the native timebase of each stream
michael
parents:
462
diff
changeset
|
1603 mpegts_get_pcr, |
3724
178cc6f9d5ec
Add flag to mark demuxers that can output discontinuous timestamps.
michael
parents:
3716
diff
changeset
|
1604 .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, |
0 | 1605 }; |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1606 |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1607 AVInputFormat mpegtsraw_demuxer = { |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1608 "mpegtsraw", |
3424
7a0230981402
Make long_names in lavf/lavdev optional depending on CONFIG_SMALL.
diego
parents:
3286
diff
changeset
|
1609 NULL_IF_CONFIG_SMALL("MPEG-2 raw transport stream format"), |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1610 sizeof(MpegTSContext), |
3226
dcde7da1d183
Using the same probe function in 2 formats is not a good idea.
michael
parents:
3059
diff
changeset
|
1611 NULL, |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1612 mpegts_read_header, |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1613 mpegts_raw_read_packet, |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1614 mpegts_read_close, |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1615 read_seek, |
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1616 mpegts_get_pcr, |
3724
178cc6f9d5ec
Add flag to mark demuxers that can output discontinuous timestamps.
michael
parents:
3716
diff
changeset
|
1617 .flags = AVFMT_SHOW_IDS|AVFMT_TS_DISCONT, |
2108
31619b03d1ce
split mpeg2ts_raw mode into its own demuxer using such a flag is an incredibly dirty hack
michael
parents:
2101
diff
changeset
|
1618 }; |