annotate libmpdemux/demux_ts.c @ 12335:189cd9abb0a1

forgot this, needed for vf_harddup
author rfelker
date Wed, 28 Apr 2004 04:07:07 +0000
parents 5da6a113b6af
children 996757299a82
Ignore whitespace changes - Everywhere: Within whitespace: At end of lines:
rev   line source
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1 /*
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2 * Demultiplexer for MPEG2 Transport Streams.
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
3 *
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
4 * Written by Nico <nsabbi@libero.it>
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
5 * Kind feedback is appreciated; 'sucks' and alike is not.
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
6 * Originally based on demux_pva.c written by Matteo Giani and FFmpeg (libavformat) sources
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
7 *
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
8 * This file is free software; you can redistribute it and/or
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
9 * modify it under the terms of the GNU General Public
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
10 * License as published by the Free Software Foundation; either
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
11 * version 2 of the License, or (at your option) any later version.
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
12 *
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
13 * This file is distributed in the hope that it will be useful,
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
16 * Lesser General Public License for more details.
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
17 *
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
18 * You should have received a copy of the GNU Lesser General Public
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
19 * License along with this library; if not, write to the Free Software
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
21 */
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
22
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
23
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
24 #include <stdio.h>
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
25 #include <stdlib.h>
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
26 #include <string.h>
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
27
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
28 #include "config.h"
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
29 #include "mp_msg.h"
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
30 #include "help_mp.h"
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
31
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
32 #include "stream.h"
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
33 #include "demuxer.h"
11412
ec3dac7d17a0 Warning fixes (approved by A'rpi).
rathann
parents: 11190
diff changeset
34 #include "parse_es.h"
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
35 #include "stheader.h"
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
36
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
37 #include "bswap.h"
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
38 #include "../unrarlib.h"
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
39
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
40
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
41 #define TS_FEC_PACKET_SIZE 204
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
42 #define TS_PACKET_SIZE 188
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
43 #define NB_PID_MAX 8192
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
44
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
45 #define MAX_HEADER_SIZE 6 /* enough for PES header + length */
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
46 #define MAX_CHECK_SIZE 65535
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
47 #define TS_MAX_PROBE_SIZE 2000000 /* dont forget to change this in cfg-common.h too */
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
48 #define NUM_CONSECUTIVE_TS_PACKETS 32
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
49 #define NUM_CONSECUTIVE_AUDIO_PACKETS 348
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
50
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
51
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
52 int ts_prog;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
53 int ts_keep_broken=0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
54 off_t ts_probe = TS_MAX_PROBE_SIZE;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
55 extern char *dvdsub_lang, *audio_lang; //for -alang
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
56
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
57 typedef enum
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
58 {
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
59 UNKNOWN = -1,
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
60 VIDEO_MPEG1 = 0x10000001,
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
61 VIDEO_MPEG2 = 0x10000002,
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
62 VIDEO_MPEG4 = 0x10000004,
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
63 AUDIO_MP2 = 0x50,
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
64 AUDIO_A52 = 0x2000,
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
65 AUDIO_LPCM_BE = 0x10001,
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
66 AUDIO_AAC = mmioFOURCC('M', 'P', '4', 'A'),
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
67 SPU_DVD = 0x3000000,
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
68 SPU_DVB = 0x3000001
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
69 } es_stream_type_t;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
70
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
71
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
72 typedef struct {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
73 int size;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
74 unsigned char *start;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
75 uint16_t payload_size;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
76 es_stream_type_t type;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
77 float pts, last_pts;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
78 int pid;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
79 char lang[4];
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
80 int last_cc; // last cc code (-1 if first packet)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
81 uint64_t seen;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
82 } ES_stream_t;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
83
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
84
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
85 typedef struct MpegTSContext {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
86 int packet_size; // raw packet size, including FEC if present e.g. 188 bytes
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
87 ES_stream_t *pids[NB_PID_MAX];
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
88 } MpegTSContext;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
89
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
90
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
91 typedef struct {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
92 demux_stream_t *ds;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
93 demux_packet_t *pack;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
94 int offset, buffer_size;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
95 int broken; //set if it's the final part of a chunk (doesn't have a corresponding is_start)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
96 } av_fifo_t;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
97
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
98 typedef struct {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
99 uint8_t skip;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
100 uint8_t table_id;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
101 uint8_t ssi;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
102 uint16_t section_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
103 uint16_t ts_id;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
104 uint8_t version_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
105 uint8_t curr_next;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
106 uint8_t section_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
107 uint8_t last_section_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
108 struct pat_progs_t {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
109 uint16_t id;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
110 uint16_t pmt_pid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
111 } *progs;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
112 uint16_t progs_cnt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
113 char buffer[65535];
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
114 uint16_t buffer_len;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
115 } pat_t;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
116
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
117 typedef struct {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
118 uint16_t progid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
119 uint8_t skip;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
120 uint8_t table_id;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
121 uint8_t ssi;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
122 uint16_t section_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
123 uint8_t version_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
124 uint8_t curr_next;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
125 uint8_t section_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
126 uint8_t last_section_number;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
127 uint16_t PCR_PID;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
128 uint16_t prog_descr_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
129 char buffer[2048];
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
130 uint16_t buffer_len;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
131 uint16_t es_cnt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
132 struct pmt_es_t {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
133 uint16_t pid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
134 uint32_t type; //it's 8 bit long, but cast to the right type as FOURCC
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
135 uint16_t descr_length;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
136 uint8_t format_descriptor[5];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
137 uint8_t lang[4];
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
138 } *es;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
139 } pmt_t;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
140
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
141 typedef struct {
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
142 MpegTSContext ts;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
143 int last_pid;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
144 av_fifo_t fifo[3]; //0 for audio, 1 for video, 2 for subs
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
145 pat_t pat;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
146 pmt_t *pmt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
147 uint16_t pmt_cnt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
148 uint32_t prog;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
149 int keep_broken;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
150 } ts_priv_t;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
151
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
152
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
153 static int ts_parse(demuxer_t *demuxer, ES_stream_t *es, unsigned char *packet, int probe);
10310
68e714ed669f fix one missing #include, one missing extern and one 10l error.
rathann
parents: 10259
diff changeset
154 extern void resync_audio_stream( sh_audio_t *sh_audio );
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
155
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
156 static uint8_t get_packet_size(const unsigned char *buf, int size)
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
157 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
158 int i;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
159
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
160 if (size < (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS))
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
161 return 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
162
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
163 for(i=0; i<NUM_CONSECUTIVE_TS_PACKETS; i++)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
164 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
165 if (buf[i * TS_PACKET_SIZE] != 0x47)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
166 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
167 mp_msg(MSGT_DEMUX, MSGL_DBG2, "GET_PACKET_SIZE, pos %d, char: %2x\n", i, buf[i * TS_PACKET_SIZE]);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
168 goto try_fec;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
169 }
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
170 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
171 return TS_PACKET_SIZE;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
172
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
173 try_fec:
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
174 for(i=0; i<NUM_CONSECUTIVE_TS_PACKETS; i++)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
175 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
176 if (buf[i * TS_FEC_PACKET_SIZE] != 0x47)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
177 return 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
178 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
179 return TS_FEC_PACKET_SIZE;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
180 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
181
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
182
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
183
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
184 int ts_check_file(demuxer_t * demuxer)
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
185 {
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
186 const int buf_size = (TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS);
10841
d4cf5407d7c6 Fix a gcc 3.x crash when compiling demux_ts.c with -g -O4 (or -O3). Patch by Arpi.
mosu
parents: 10735
diff changeset
187 unsigned char buf[TS_FEC_PACKET_SIZE * NUM_CONSECUTIVE_TS_PACKETS], done = 0, *ptr;
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
188 uint32_t _read, i, count = 0, is_ts;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
189 int cc[NB_PID_MAX], last_cc[NB_PID_MAX], pid, cc_ok, c, good, bad;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
190 uint8_t size = 0;
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
191 off_t pos = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
192 off_t init_pos;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
193
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
194 mp_msg(MSGT_DEMUX, MSGL_V, "Checking for MPEG-TS...\n");
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
195
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
196 init_pos = stream_tell(demuxer->stream);
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
197 is_ts = 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
198 while(! done)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
199 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
200 i = 1;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
201 c = 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
202
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
203 while(((c=stream_read_char(demuxer->stream)) != 0x47)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
204 && (c >= 0)
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
205 && (i < MAX_CHECK_SIZE)
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
206 && ! demuxer->stream->eof
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
207 ) i++;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
208
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
209
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
210 if(c != 0x47)
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
211 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
212 mp_msg(MSGT_DEMUX, MSGL_V, "THIS DOESN'T LOOK LIKE AN MPEG-TS FILE!\n");
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
213 is_ts = 0;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
214 done = 1;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
215 continue;
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
216 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
217
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
218 pos = stream_tell(demuxer->stream) - 1;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
219 buf[0] = c;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
220 _read = stream_read(demuxer->stream, &buf[1], buf_size-1);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
221
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
222 if(_read < buf_size-1)
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
223 {
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
224 mp_msg(MSGT_DEMUX, MSGL_V, "COULDN'T READ ENOUGH DATA, EXITING TS_CHECK\n");
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
225 stream_reset(demuxer->stream);
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
226 return 0;
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
227 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
228
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
229 size = get_packet_size(buf, buf_size);
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
230 if(size)
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
231 {
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
232 done = 1;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
233 is_ts = 1;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
234 }
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
235
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
236 if(pos - init_pos >= MAX_CHECK_SIZE)
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
237 {
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
238 done = 1;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
239 is_ts = 0;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
240 }
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
241 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
242
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
243 mp_msg(MSGT_DEMUX, MSGL_V, "TRIED UP TO POSITION %llu, FOUND %x, packet_size= %d, SEEMS A TS? %d\n", (uint64_t) pos, c, size, is_ts);
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
244 stream_seek(demuxer->stream, pos);
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
245
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
246 if(! is_ts)
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
247 return 0;
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
248
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
249 //LET'S CHECK continuity counters
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
250 good = bad = 0;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
251 for(count = 0; count < NB_PID_MAX; count++)
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
252 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
253 cc[count] = last_cc[count] = -1;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
254 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
255
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
256 for(count = 0; count < NUM_CONSECUTIVE_TS_PACKETS; count++)
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
257 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
258 ptr = &(buf[size * count]);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
259 pid = ((ptr[1] & 0x1f) << 8) | ptr[2];
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
260 mp_msg(MSGT_DEMUX, MSGL_DBG2, "BUF: %02x %02x %02x %02x, PID %d, SIZE: %d \n",
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
261 ptr[0], ptr[1], ptr[2], ptr[3], pid, size);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
262
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
263 if((pid == 8191) || (pid < 16))
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
264 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
265
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
266 cc[pid] = (ptr[3] & 0xf);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
267 cc_ok = (last_cc[pid] < 0) || ((((last_cc[pid] + 1) & 0x0f) == cc[pid]));
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
268 mp_msg(MSGT_DEMUX, MSGL_DBG2, "PID %d, COMPARE CC %d AND LAST_CC %d\n", pid, cc[pid], last_cc[pid]);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
269 if(! cc_ok)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
270 //return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
271 bad++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
272 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
273 good++;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
274
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
275 last_cc[pid] = cc[pid];
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
276 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
277
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
278 mp_msg(MSGT_DEMUX, MSGL_V, "GOOD CC: %d, BAD CC: %d\n", good, bad);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
279
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
280 if(good >= bad)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
281 return size;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
282 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
283 return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
284 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
285
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
286
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
287 static inline int32_t progid_idx_in_pmt(ts_priv_t *priv, uint16_t progid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
288 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
289 int x;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
290
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
291 if(priv->pmt == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
292 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
293
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
294 for(x = 0; x < priv->pmt_cnt; x++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
295 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
296 if(priv->pmt[x].progid == progid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
297 return x;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
298 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
299
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
300 return -1;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
301 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
302
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
303
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
304 static inline int32_t progid_for_pid(ts_priv_t *priv, int pid, int32_t req) //finds the first program listing a pid
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
305 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
306 int i, j;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
307 pmt_t *pmt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
308
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
309
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
310 if(priv->pmt == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
311 return -1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
312
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
313
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
314 for(i=0; i < priv->pmt_cnt; i++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
315 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
316 pmt = &(priv->pmt[i]);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
317
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
318 if(pmt->es == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
319 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
320
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
321 for(j = 0; j < pmt->es_cnt; j++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
322 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
323 if(pmt->es[j].pid == pid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
324 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
325 if((req == 0) || (req == pmt->progid))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
326 return pmt->progid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
327 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
328 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
329
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
330 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
331 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
332 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
333
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
334
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
335 static inline int pid_match_lang(ts_priv_t *priv, uint16_t pid, char *lang)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
336 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
337 uint16_t i, j;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
338 pmt_t *pmt;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
339
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
340 if(priv->pmt == NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
341 return -1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
342
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
343 for(i=0; i < priv->pmt_cnt; i++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
344 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
345 pmt = &(priv->pmt[i]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
346
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
347 if(pmt->es == NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
348 return -1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
349
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
350 for(j = 0; j < pmt->es_cnt; j++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
351 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
352 if(pmt->es[j].pid != pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
353 continue;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
354
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
355 mp_msg(MSGT_DEMUXER, MSGL_V, "CMP LANG %s AND %s, pids: %d %d\n",pmt->es[j].lang, lang, pmt->es[j].pid, pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
356 if(strncmp(pmt->es[j].lang, lang, 3) == 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
357 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
358 return 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
359 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
360 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
361
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
362 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
363
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
364 return -1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
365 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
366
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
367 typedef struct {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
368 int32_t atype, vtype, stype; //types
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
369 int32_t apid, vpid, spid; //stream ids
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
370 char slang[4], alang[4]; //languages
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
371 int16_t prog;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
372 off_t probe;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
373 } tsdemux_init_t;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
374
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
375 static off_t ts_detect_streams(demuxer_t *demuxer, tsdemux_init_t *param)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
376 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
377 int video_found = 0, audio_found = 0, sub_found = 0, i, num_packets = 0, req_apid, req_vpid, req_spid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
378 int is_audio, is_video, is_sub, has_tables;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
379 int32_t p, chosen_pid = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
380 off_t pos=0, ret = 0, init_pos;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
381 ES_stream_t es;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
382 unsigned char tmp[TS_FEC_PACKET_SIZE];
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
383 ts_priv_t *priv = (ts_priv_t*) demuxer->priv;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
384
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
385 priv->last_pid = 8192; //invalid pid
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
386
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
387 req_apid = param->apid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
388 req_vpid = param->vpid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
389 req_spid = param->spid;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
390
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
391 has_tables = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
392 init_pos = stream_tell(demuxer->stream);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
393 mp_msg(MSGT_DEMUXER, MSGL_INFO, "PROBING UP TO %llu, PROG: %d\n", (uint64_t) param->probe, param->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
394 while((pos <= init_pos + param->probe) && (! demuxer->stream->eof))
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
395 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
396 pos = stream_tell(demuxer->stream);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
397 if(ts_parse(demuxer, &es, tmp, 1))
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
398 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
399 is_audio = ((es.type == AUDIO_MP2) || (es.type == AUDIO_A52) || (es.type == AUDIO_LPCM_BE) || (es.type == AUDIO_AAC));
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
400 is_video = ((es.type == VIDEO_MPEG1) || (es.type == VIDEO_MPEG2) || (es.type == VIDEO_MPEG4));
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
401 is_sub = ((es.type == SPU_DVD) || (es.type == SPU_DVB));
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
402
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
403
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
404 if((! is_audio) && (! is_video) && (! is_sub))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
405 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
406
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
407 if(is_video)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
408 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
409 chosen_pid = (req_vpid == es.pid);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
410 if((! chosen_pid) && (req_vpid > 0))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
411 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
412 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
413 else if(is_audio)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
414 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
415 if(req_apid > 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
416 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
417 chosen_pid = (req_apid == es.pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
418 if(! chosen_pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
419 continue;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
420 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
421 else if(param->alang[0] > 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
422 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
423 if(pid_match_lang(priv, es.pid, param->alang) == -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
424 continue;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
425
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
426 chosen_pid = 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
427 param->apid = req_apid = es.pid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
428 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
429 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
430 else if(is_sub)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
431 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
432 chosen_pid = (req_spid == es.pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
433 if((! chosen_pid) && (req_spid > 0))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
434 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
435 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
436
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
437 if(req_apid < 0 && (param->alang[0] == 0) && req_vpid < 0 && req_spid < 0)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
438 chosen_pid = 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
439
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
440 if((ret == 0) && chosen_pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
441 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
442 ret = stream_tell(demuxer->stream);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
443 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
444
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
445 p = progid_for_pid(priv, es.pid, param->prog);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
446 if(p != -1)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
447 has_tables++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
448
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
449 if((param->prog == 0) && (p != -1))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
450 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
451 if(chosen_pid)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
452 param->prog = p;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
453 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
454
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
455 if((param->prog > 0) && (param->prog != p))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
456 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
457 if(audio_found)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
458 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
459 if(is_video && (req_vpid == es.pid))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
460 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
461 param->vtype = es.type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
462 param->vpid = es.pid;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
463 video_found = 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
464 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
465 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
466 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
467
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
468 if(video_found)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
469 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
470 if(is_audio && (req_apid == es.pid))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
471 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
472 param->atype = es.type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
473 param->apid = es.pid;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
474 audio_found = 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
475 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
476 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
477 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
478
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
479
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
480 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
481 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
482
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
483
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
484 mp_msg(MSGT_DEMUXER, MSGL_DBG2, "TYPE: %x, PID: %d, PROG FOUND: %d\n", es.type, es.pid, param->prog);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
485
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
486
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
487 if(is_video)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
488 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
489 if((req_vpid == -1) || (req_vpid == es.pid))
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
490 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
491 param->vtype = es.type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
492 param->vpid = es.pid;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
493 video_found = 1;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
494 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
495 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
496
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
497
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
498 if(((req_vpid == -2) || (num_packets >= NUM_CONSECUTIVE_AUDIO_PACKETS)) && audio_found)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
499 {
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
500 //novideo or we have at least 348 audio packets (64 KB) without video (TS with audio only)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
501 param->vtype = 0;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
502 break;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
503 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
504
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
505 if(is_sub)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
506 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
507 if((req_spid == -1) || (req_spid == es.pid))
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
508 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
509 param->stype = es.type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
510 param->spid = es.pid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
511 sub_found = 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
512 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
513 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
514
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
515 if(is_audio)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
516 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
517 if((req_apid == -1) || (req_apid == es.pid))
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
518 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
519 param->atype = es.type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
520 param->apid = es.pid;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
521 audio_found = 1;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
522 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
523 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
524
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
525 if(audio_found && (param->apid == es.pid) && (! video_found))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
526 num_packets++;
10259
b60e89268837 - discard soon non TS files (previously it took too long, as in the case
arpi
parents: 10253
diff changeset
527
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
528 if((req_apid == -2) && video_found)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
529 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
530 param->atype = 0;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
531 break;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
532 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
533
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
534 if((has_tables==0) && (video_found && audio_found) && (pos >= 1000000))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
535 break;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
536 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
537 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
538
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
539 if(video_found)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
540 mp_msg(MSGT_DEMUXER, MSGL_INFO, "VIDEO MPEG%d(pid=%d)...", (param->vtype == VIDEO_MPEG1 ? 1 : (param->vtype == VIDEO_MPEG2 ? 2 : 4)), param->vpid);
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
541 else
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
542 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
543 video_found = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
544 param->vtype = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
545 //WE DIDN'T MATCH ANY VIDEO STREAM
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
546 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO VIDEO! ");
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
547 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
548
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
549 if(param->atype == AUDIO_MP2)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
550 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO MP2(pid=%d)", param->apid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
551 else if(param->atype == AUDIO_A52)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
552 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO A52(pid=%d)", param->apid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
553 else if(param->atype == AUDIO_LPCM_BE)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
554 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO LPCM(pid=%d)", param->apid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
555 else if(param->atype == AUDIO_AAC)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
556 mp_msg(MSGT_DEMUXER, MSGL_INFO, "AUDIO AAC(pid=%d)", param->apid);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
557 else
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
558 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
559 audio_found = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
560 param->atype = UNKNOWN;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
561 //WE DIDN'T MATCH ANY AUDIO STREAM, SO WE FORCE THE DEMUXER TO IGNORE AUDIO
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
562 mp_msg(MSGT_DEMUXER, MSGL_INFO, "NO AUDIO! ");
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
563 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
564
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
565 if(param->stype == SPU_DVD || param->stype == SPU_DVB)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
566 mp_msg(MSGT_DEMUXER, MSGL_INFO, " SUB DVx(pid=%d) ", param->spid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
567 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
568 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
569 param->stype = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
570 mp_msg(MSGT_DEMUXER, MSGL_INFO, " NO SUBS (yet)! ");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
571 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
572
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
573 if(video_found || audio_found)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
574 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
575 if(demuxer->stream->eof && (ret == 0))
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
576 ret = init_pos;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
577 mp_msg(MSGT_DEMUXER, MSGL_INFO, " PROGRAM N. %d\n", param->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
578 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
579 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
580 mp_msg(MSGT_DEMUXER, MSGL_INFO, "\n");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
581
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
582
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
583 for(i=0; i<8192; i++)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
584 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
585 if(priv->ts.pids[i] != NULL)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
586 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
587 priv->ts.pids[i]->payload_size = 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
588 priv->ts.pids[i]->pts = priv->ts.pids[i]->last_pts = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
589 priv->ts.pids[i]->seen = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
590 priv->ts.pids[i]->last_cc = -1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
591 }
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
592 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
593
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
594 return ret;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
595 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
596
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
597
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
598 demuxer_t *demux_open_ts(demuxer_t * demuxer)
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
599 {
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
600 int i;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
601 uint8_t packet_size;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
602 sh_video_t *sh_video;
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
603 sh_audio_t *sh_audio;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
604 off_t start_pos;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
605 tsdemux_init_t params;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
606 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
607
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
608 mp_msg(MSGT_DEMUX, MSGL_INFO, "DEMUX OPEN, AUDIO_ID: %d, VIDEO_ID: %d, SUBTITLE_ID: %d,\n",
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
609 demuxer->audio->id, demuxer->video->id, demuxer->sub->id);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
610
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
611
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
612 demuxer->type= DEMUXER_TYPE_MPEG_TS;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
613
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
614
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
615 stream_reset(demuxer->stream);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
616
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
617 packet_size = ts_check_file(demuxer);
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
618 if(!packet_size)
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
619 return NULL;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
620
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
621 priv = malloc(sizeof(ts_priv_t));
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
622 if(priv == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
623 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
624 mp_msg(MSGT_DEMUX, MSGL_FATAL, "DEMUX_OPEN_TS, couldn't allocate enough memory for ts->priv, exit\n");
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
625 return NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
626 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
627
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
628 for(i=0; i < 8192; i++)
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
629 priv->ts.pids[i] = NULL;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
630 priv->pat.progs = NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
631 priv->pat.progs_cnt = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
632
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
633 priv->pmt = NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
634 priv->pmt_cnt = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
635
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
636 priv->keep_broken = ts_keep_broken;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
637 priv->ts.packet_size = packet_size;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
638
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
639
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
640 demuxer->priv = priv;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
641 if(demuxer->stream->type != STREAMTYPE_FILE)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
642 demuxer->seekable = 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
643 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
644 demuxer->seekable = 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
645
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
646
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
647 params.atype = params.vtype = params.stype = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
648 params.apid = demuxer->audio->id;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
649 params.vpid = demuxer->video->id;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
650 params.spid = demuxer->sub->id;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
651 params.prog = ts_prog;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
652 params.probe = ts_probe;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
653
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
654 if(dvdsub_lang != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
655 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
656 strncpy(params.slang, dvdsub_lang, 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
657 params.slang[3] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
658 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
659 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
660 memset(params.slang, 0, 4);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
661
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
662 if(audio_lang != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
663 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
664 strncpy(params.alang, audio_lang, 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
665 params.alang[3] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
666 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
667 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
668 memset(params.alang, 0, 4);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
669
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
670 start_pos = ts_detect_streams(demuxer, &params);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
671
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
672 demuxer->audio->id = params.apid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
673 demuxer->video->id = params.vpid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
674 demuxer->sub->id = params.spid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
675 priv->prog = params.prog;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
676
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
677
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
678 if(params.vtype != UNKNOWN)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
679 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
680 if(params.vtype == VIDEO_MPEG4)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
681 demuxer->file_format= DEMUXER_TYPE_MPEG4_IN_TS;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
682
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
683 sh_video = new_sh_video(demuxer, 0);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
684 sh_video->ds = demuxer->video;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
685 sh_video->format = params.vtype;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
686 demuxer->video->sh = sh_video;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
687 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
688
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
689 if(params.atype != UNKNOWN)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
690 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
691 sh_audio = new_sh_audio(demuxer, 0);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
692 sh_audio->ds = demuxer->audio;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
693 sh_audio->format = params.atype;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
694 demuxer->audio->sh = sh_audio;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
695 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
696
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
697
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
698 mp_msg(MSGT_DEMUXER,MSGL_INFO, "Opened TS demuxer, audio: %x(pid %d), video: %x(pid %d)...POS=%llu\n", params.atype, demuxer->audio->id, params.vtype, demuxer->video->id, (uint64_t) start_pos);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
699
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
700
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
701 start_pos = (start_pos <= priv->ts.packet_size ? 0 : start_pos - priv->ts.packet_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
702 demuxer->movi_start = start_pos;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
703 stream_reset(demuxer->stream);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
704 stream_seek(demuxer->stream, start_pos); //IF IT'S FROM A PIPE IT WILL FAIL, BUT WHO CARES?
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
705
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
706
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
707 priv->last_pid = 8192; //invalid pid
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
708
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
709 for(i = 0; i < 3; i++)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
710 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
711 priv->fifo[i].pack = NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
712 priv->fifo[i].offset = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
713 priv->fifo[i].broken = 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
714 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
715 priv->fifo[0].ds = demuxer->audio;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
716 priv->fifo[1].ds = demuxer->video;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
717 priv->fifo[2].ds = demuxer->sub;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
718
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
719 priv->fifo[0].buffer_size = 1536;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
720 priv->fifo[1].buffer_size = 32767;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
721 priv->fifo[2].buffer_size = 32767;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
722
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
723 priv->pat.buffer_len = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
724
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
725 demuxer->filepos = stream_tell(demuxer->stream);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
726 return demuxer;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
727 }
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
728
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
729 void demux_close_ts(demuxer_t * demuxer)
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
730 {
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
731 if(demuxer->priv)
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
732 {
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
733 free(demuxer->priv);
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
734 demuxer->priv=NULL;
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
735 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
736 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
737
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
738 static int pes_parse2(unsigned char *buf, uint16_t packet_len, ES_stream_t *es, int32_t type_from_pmt)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
739 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
740 unsigned char *p;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
741 uint32_t header_len;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
742 int64_t pts;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
743 uint32_t stream_id;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
744 uint32_t pkt_len;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
745
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
746 //THE FOLLOWING CODE might be needed in the future:
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
747 //uint8_t es_rate_flag, escr_flag, pts_flag;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
748 //int64_t escr, dts;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
749 //uint32_t es_rate;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
750
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
751 //Here we are always at the start of a PES packet
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
752 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(%p, %d): \n", buf, (uint32_t) packet_len);
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
753
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
754 if(packet_len == 0)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
755 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
756 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2(,PACKET_LEN = 0, EXIT\n");
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
757 return 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
758 }
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
759
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
760 if(packet_len > 184)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
761 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
762 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2, BUFFER LEN IS TOO BIG: %d, EXIT\n", packet_len);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
763 return 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
764 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
765
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
766
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
767 p = buf;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
768 pkt_len = packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
769
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
770
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
771 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: HEADER %02x %02x %02x %02x\n", p[0], p[1], p[2], p[3]);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
772 if (p[0] || p[1] || (p[2] != 1))
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
773 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
774 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: error HEADER %02x %02x %02x (should be 0x000001) \n", p[0], p[1], p[2]);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
775 return 0 ;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
776 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
777
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
778 packet_len -= 6;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
779 if(packet_len==0)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
780 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
781 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: packet too short: %d, exit\n", packet_len);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
782 return 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
783 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
784
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
785 es->payload_size = (p[4] << 8 | p[5]);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
786
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
787 stream_id = p[3];
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
788
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
789
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
790 if (p[7] & 0x80)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
791 { /* pts available */
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
792 pts = (int64_t)(p[9] & 0x0E) << 29 ;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
793 pts |= p[10] << 22 ;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
794 pts |= (p[11] & 0xFE) << 14 ;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
795 pts |= p[12] << 7 ;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
796 pts |= (p[13] & 0xFE) >> 1 ;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
797
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
798 es->pts = pts / 90000.0f;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
799 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
800 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
801 es->pts = 0.0f;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
802
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
803 /*
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
804 CODE TO CALCULATE ES_RATE AND ESCR, ACTUALLY UNUSED BUT POSSIBLY NEEDED IN THE FUTURE
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
805
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
806 pts_flag = ((p[7] & 0xc0) >> 6) & 3;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
807 escr_flag = p[7] & 0x20;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
808 es_rate_flag = p[7] & 0x10;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
809 mp_msg(MSGT_DEMUX, MSGL_V, "pes_parse: ES_RATE_FLAG=%d, ESCR_FLAG=%d, PTS_FLAG=%d, byte=%02X\n", es_rate_flag, escr_flag, pts_flag, p[7]);
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
810
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
811
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
812 if(es_rate_flag)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
813 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
814 char *base;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
815 int bytes = 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
816
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
817 if(pts_flag == 2)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
818 bytes += 5;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
819 else if(pts_flag == 3)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
820 bytes += 10;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
821
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
822 if(escr_flag)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
823 bytes += 6;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
824
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
825 base = p[8+bytes];
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
826 es_rate = ((base[0] & 0x7f) << 8) | (base[1] << 8) | (base[0] & 0xfe);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
827 mp_msg(MSGT_DEMUX, MSGL_V, "demux_ts: ES_RATE=%d)\n", es_rate*50);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
828 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
829 */
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
830
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
831 header_len = p[8];
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
832
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
833
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
834 if (header_len + 9 > pkt_len) //9 are the bytes read up to the header_length field
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
835 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
836 mp_msg(MSGT_DEMUX, MSGL_DBG2, "demux_ts: illegal value for PES_header_data_length (0x%02x)\n", header_len);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
837 return 0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
838 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
839
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
840 p += header_len + 9;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
841 packet_len -= header_len + 3;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
842
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
843 /*
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
844 if(packet_len <= 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
845 mp_msg(MSGT_DEMUX, MSGL_INFO, "\n\nNow: %d, prima: %d, ORIG: %d\n\n\n", packet_len, packet_len+3+header_len, pkt_len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
846 */
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
847
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
848 if(es->payload_size)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
849 es->payload_size -= header_len + 3;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
850
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
851
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
852 if (stream_id == 0xbd)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
853 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
854 int track; //, spu_id;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
855
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
856 mp_msg(MSGT_DEMUX, MSGL_DBG3, "pes_parse2: audio buf = %02X %02X %02X %02X %02X %02X %02X %02X, 80: %d\n",
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
857 p[0], p[1], p[2], p[3], p[4], p[5], p[6], p[7], p[0] & 0x80);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
858
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
859 track = p[0] & 0x0F;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
860 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 TRACK: %d\n", track);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
861
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
862
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
863 /*
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
864 * we check the descriptor tag first because some stations
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
865 * do not include any of the A52 header info in their audio tracks
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
866 * these "raw" streams may begin with a byte that looks like a stream type.
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
867 */
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
868
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
869
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
870 if(
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
871 (type_from_pmt == AUDIO_A52) || /* A52 - raw */
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
872 (p[0] == 0x0B && p[1] == 0x77) /* A52 - syncword */
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
873 )
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
874 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
875 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 RAW OR SYNCWORD\n");
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
876 es->start = p;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
877 es->size = packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
878 es->type = AUDIO_A52;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
879 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
880
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
881 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
882 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
883 /* SPU SUBS */
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
884 else if(type_from_pmt == SPU_DVB ||
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
885 (p[0] == 0x20)) // && p[1] == 0x00))
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
886 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
887 es->start = p;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
888 es->size = packet_len;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
889 es->type = SPU_DVB;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
890 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
891
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
892 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
893 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
894 else if ((p[0] & 0xE0) == 0x20) //SPU_DVD
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
895 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
896 //DVD SUBS
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
897 es->start = p+1;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
898 es->size = packet_len-1;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
899 es->type = SPU_DVD;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
900 es->payload_size -= packet_len;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
901
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
902 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
903 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
904 else if ((p[0] & 0xF0) == 0x80)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
905 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
906 mp_msg(MSGT_DEMUX, MSGL_DBG2, "A52 WITH HEADER\n");
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
907 es->start = p+4;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
908 es->size = packet_len - 4;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
909 es->type = AUDIO_A52;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
910 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
911
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
912 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
913 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
914 else if ((p[0]&0xf0) == 0xa0)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
915 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
916 int pcm_offset;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
917
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
918 for (pcm_offset=0; ++pcm_offset < packet_len-1 ; )
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
919 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
920 if (p[pcm_offset] == 0x01 && p[pcm_offset+1] == 0x80)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
921 { /* START */
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
922 pcm_offset += 2;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
923 break;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
924 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
925 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
926
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
927 es->start = p + pcm_offset;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
928 es->size = packet_len - pcm_offset;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
929 es->type = AUDIO_LPCM_BE;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
930 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
931
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
932 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
933 }
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
934 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
935 else if ((stream_id >= 0xbc) && ((stream_id & 0xf0) == 0xe0))
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
936 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
937 es->start = p;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
938 es->size = packet_len;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
939 if(type_from_pmt != UNKNOWN)
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
940 es->type = type_from_pmt;
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
941 else
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
942 es->type = VIDEO_MPEG2;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
943 if(es->payload_size)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
944 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
945
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
946 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: M2V size %d\n", es->size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
947 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
948 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
949 else if ((stream_id == 0xfa))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
950 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
951 if(type_from_pmt != -1) //MP4 A/V
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
952 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
953 es->start = p;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
954 es->size = packet_len;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
955 es->type = type_from_pmt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
956 if(es->payload_size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
957 es->payload_size -= packet_len;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
958
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
959 return 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
960 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
961 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
962 else if ((stream_id & 0xe0) == 0xc0)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
963 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
964 int profile = 0, srate = 0, channels = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
965 uint32_t hdr, l = 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
966
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
967 hdr = (p[0] << 24) | (p[1] << 16) | (p[2] << 8) | p[3];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
968 if((hdr & 0xfff00000) == 0xfff00000)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
969 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
970 // ADTS AAC shows with MPA layer 4 (00 in the layer bitstream)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
971 l = 4 - ((hdr & 0x00060000) >> 17);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
972 profile = ((hdr & 0x0000C000) >> 14);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
973 srate = ((hdr & 0x00003c00) >> 10);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
974 channels = ((hdr & 0x000001E0) >> 5);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
975 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
976 mp_msg(MSGT_DEMUX, MSGL_DBG2, "\n\naudio header: %2X %2X %2X %2X\nLAYER: %d, PROFILE: %d, SRATE=%d, CHANNELS=%d\n\n", p[0], p[1], p[3], p[4], l, profile, srate, channels);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
977
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
978 es->start = p;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
979 es->size = packet_len;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
980
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
981
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
982 //if((type_from_pmt == 0x0f) || (l == 4)) //see in parse_pmt()
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
983 if(l==4)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
984 es->type = AUDIO_AAC;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
985 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
986 es->type = AUDIO_MP2;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
987
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
988 es->payload_size -= packet_len;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
989
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
990 return 1;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
991 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
992 else if (type_from_pmt != -1) //as a last resort here we trust the PMT, if present
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
993 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
994 es->start = p;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
995 es->size = packet_len;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
996 es->type = type_from_pmt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
997 es->payload_size -= packet_len;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
998
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
999 return 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1000 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1001 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1002 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1003 mp_msg(MSGT_DEMUX, MSGL_DBG2, "pes_parse2: unknown packet, id: %x\n", stream_id);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1004 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1005
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1006 return 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1007 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1008
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1009
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1010
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1011
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1012 static int ts_sync(stream_t *stream)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1013 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1014 int c=0;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1015
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1016 mp_msg(MSGT_DEMUX, MSGL_DBG2, "TS_SYNC \n");
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1017
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1018 while(((c=stream_read_char(stream)) != 0x47) && ! stream->eof);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1019
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1020 if(c == 0x47)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1021 return c;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1022 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1023 return 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1024 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1025
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1026
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1027 static void ts_dump_streams(ts_priv_t *priv)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1028 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1029 int i;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1030
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1031 for(i = 0; i < 3; i++)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1032 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1033 if((priv->fifo[i].pack != NULL) && (priv->fifo[i].offset != 0))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1034 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1035 resize_demux_packet(priv->fifo[i].pack, priv->fifo[i].offset);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1036 ds_add_packet(priv->fifo[i].ds, priv->fifo[i].pack);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1037 priv->fifo[i].offset = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1038 priv->fifo[i].pack = NULL;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1039 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1040 priv->fifo[i].broken = 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1041 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1042 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1043
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1044
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1045 static inline int32_t prog_idx_in_pat(ts_priv_t *priv, uint16_t progid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1046 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1047 int x;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1048
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1049 if(priv->pat.progs == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1050 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1051
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1052 for(x = 0; x < priv->pat.progs_cnt; x++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1053 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1054 if(priv->pat.progs[x].id == progid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1055 return x;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1056 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1057
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1058 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1059 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1060
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1061
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1062 static inline int32_t prog_id_in_pat(ts_priv_t *priv, uint16_t pid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1063 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1064 int x;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1065
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1066 if(priv->pat.progs == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1067 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1068
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1069 for(x = 0; x < priv->pat.progs_cnt; x++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1070 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1071 if(priv->pat.progs[x].pmt_pid == pid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1072 return priv->pat.progs[x].id;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1073 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1074
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1075 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1076 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1077
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1078 /*
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1079 DON'T REMOVE, I'LL NEED IT IN THE (NEAR) FUTURE)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1080 static int check_crc32(uint32_t val, uint8_t *ptr, uint16_t len, uint8_t *vbase)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1081 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1082 uint32_t tab_crc32, calc_crc32;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1083
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1084 calc_crc32 = CalcCRC32(val, ptr, len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1085
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1086 tab_crc32 = (vbase[0] << 24) | (vbase[1] << 16) | (vbase[2] << 8) | vbase[3];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1087
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1088 printf("CRC32, TAB: %x, CALC: %x, eq: %x\n", tab_crc32, calc_crc32, tab_crc32 == calc_crc32);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1089 return (tab_crc32 == calc_crc32);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1090
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1091 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1092 */
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1093
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1094 static int parse_pat(ts_priv_t * priv, int is_start, unsigned char *buff, int size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1095 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1096 uint8_t skip, m = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1097 unsigned char *ptr;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1098 unsigned char *base;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1099 int entries, i, sections;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1100 uint16_t progid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1101
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1102 //PRE-FILLING
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1103 if(! is_start)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1104 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1105 if(priv->pat.buffer_len == 0) //a broken packet
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1106 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1107 return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1108 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1109
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1110 if(priv->pat.skip)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1111 m = min(priv->pat.skip, size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1112
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1113 priv->pat.skip -= m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1114 if(m == size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1115 return -1; //keep on buffering
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1116 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1117 else //IS_START, replace the old content
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1118 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1119 priv->pat.buffer_len = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1120 skip = buff[0]+1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1121 m = min(skip, size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1122
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1123 priv->pat.skip = skip - m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1124
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1125 if(m == size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1126 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1127 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1128
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1129 //FILLING
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1130 memcpy(&(priv->pat.buffer[priv->pat.buffer_len]), &buff[m], size - m);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1131
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1132 priv->pat.buffer_len += size - m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1133
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1134 //PARSING
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1135 ptr = priv->pat.buffer;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1136
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1137 priv->pat.table_id = ptr[0];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1138 priv->pat.ssi = (ptr[1] >> 7) & 0x1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1139 priv->pat.curr_next = ptr[5] & 0x01;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1140 priv->pat.ts_id = (ptr[3] << 8 ) | ptr[4];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1141 priv->pat.version_number = (ptr[5] >> 1) & 0x1F;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1142 priv->pat.section_length = ((ptr[1] & 0x03) << 8 ) | ptr[2];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1143 priv->pat.section_number = ptr[6];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1144 priv->pat.last_section_number = ptr[7];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1145
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1146
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1147 if((! priv->pat.curr_next) || (priv->pat.table_id != 0)) // || (! priv->pat.ssi))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1148 return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1149
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1150
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1151 //beginning of sections loop
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1152 sections = priv->pat.last_section_number - priv->pat.section_number + 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1153 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PAT, section %d of %d, TOTAL: %d\n", priv->pat.section_number, priv->pat.last_section_number, sections);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1154
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1155 if(priv->pat.section_length + 3 > priv->pat.buffer_len)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1156 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1157 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PAT, section larger than buffer size: %d > %d, EXIT\n",
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1158 priv->pat.section_length, priv->pat.buffer_len - 3);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1159
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1160 return -1; //KEEP ON FILLING THE TABLE
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1161 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1162
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1163 //check_crc32(0xFFFFFFFFL, ptr, priv->pat.buffer_len - 4, &ptr[priv->pat.buffer_len - 4]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1164
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1165 entries = (int) (priv->pat.section_length - 9) / 4; //entries per section
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1166
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1167
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1168 for(i=0; i < entries; i++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1169 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1170 int32_t idx;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1171 base = &ptr[8 + i*4];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1172 progid = (base[0] << 8) | base[1];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1173
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1174 if((idx = prog_idx_in_pat(priv, progid)) == -1)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1175 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1176 int sz = sizeof(struct pat_progs_t) * (priv->pat.progs_cnt+1);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1177 priv->pat.progs = (struct pat_progs_t*) realloc(priv->pat.progs, sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1178 if(priv->pat.progs == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1179 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1180 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PAT: COULDN'T REALLOC %d bytes, NEXT\n", sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1181 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1182 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1183
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1184 idx = priv->pat.progs_cnt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1185 priv->pat.progs_cnt++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1186 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1187
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1188 priv->pat.progs[idx].id = progid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1189 priv->pat.progs[idx].pmt_pid = ((base[2] & 0x1F) << 8) | base[3];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1190 mp_msg(MSGT_DEMUX, MSGL_V, "PROG: %d (%d-th of %d), PMT: %d\n", priv->pat.progs[idx].id, i+1, entries, priv->pat.progs[idx].pmt_pid);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1191 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1192
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1193 return 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1194 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1195
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1196
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1197 static inline int32_t es_pid_in_pmt(pmt_t * pmt, uint16_t pid)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1198 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1199 uint16_t i;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1200
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1201 if(pmt == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1202 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1203
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1204 if(pmt->es == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1205 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1206
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1207 for(i = 0; i < pmt->es_cnt; i++)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1208 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1209 if(pmt->es[i].pid == pid)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1210 return (int32_t) i;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1211 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1212
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1213 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1214 }
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1215
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1216
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1217 static int parse_descriptors(struct pmt_es_t *es, uint8_t *ptr)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1218 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1219 int j, descr_len, len;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1220
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1221 j = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1222 len = es->descr_length;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1223 while(len > 2)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1224 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1225 descr_len = ptr[j+1];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1226 mp_msg(MSGT_DEMUX, MSGL_DBG2, "...descr id: 0x%x, len=%d\n", ptr[j], descr_len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1227 if(descr_len > len)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1228 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1229 mp_msg(MSGT_DEMUX, MSGL_DBG2, "INVALID DESCR LEN: %d vs %d max, EXIT LOOP\n", descr_len, len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1230 return -1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1231 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1232
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1233
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1234 if(ptr[j] == 0x6a) //A52 Descriptor
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1235 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1236 es->type = AUDIO_A52;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1237 mp_msg(MSGT_DEMUX, MSGL_DBG2, "DVB A52 Descriptor\n");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1238 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1239 else if(ptr[j] == 0x59) //Subtitling Descriptor
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1240 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1241 uint8_t subtype;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1242
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1243 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Subtitling Descriptor\n");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1244 if(descr_len < 8)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1245 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1246 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Descriptor length too short for DVB Subtitle Descriptor: %d, SKIPPING\n", descr_len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1247 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1248 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1249 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1250 memcpy(es->lang, &ptr[j+2], 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1251 es->lang[3] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1252 subtype = ptr[j+5];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1253 if(
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1254 (subtype >= 0x10 && subtype <= 0x13) ||
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1255 (subtype >= 0x20 && subtype <= 0x23)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1256 )
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1257 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1258 es->type = SPU_DVB;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1259 //page parameters: compo page 2 bytes, ancillary page 2 bytes
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1260 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1261 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1262 es->type = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1263 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1264 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1265 else if(ptr[j] == 0x50) //Component Descriptor
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1266 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1267 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Component Descriptor\n");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1268 memcpy(es->lang, &ptr[j+5], 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1269 es->lang[3] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1270 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1271 else if(ptr[j] == 0xa) //Language Descriptor
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1272 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1273 memcpy(es->lang, &ptr[j+2], 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1274 es->lang[3] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1275 mp_msg(MSGT_DEMUX, MSGL_V, "Language Descriptor: %s\n", es->lang);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1276 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1277 else if(ptr[j] == 0x5) //Registration Descriptor (looks like e fourCC :) )
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1278 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1279 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor\n");
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1280 if(descr_len < 4)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1281 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1282 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Registration Descriptor length too short: %d, SKIPPING\n", descr_len);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1283 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1284 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1285 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1286 char *d;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1287 memcpy(es->format_descriptor, &ptr[j+2], 4);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1288 es->format_descriptor[4] = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1289
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1290 d = &ptr[j+2];
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1291 if(d[0] == 'A' && d[1] == 'C' && d[2] == '-' && d[3] == '3')
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1292 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1293 es->type = AUDIO_A52;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1294 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1295 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1296 es->type = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1297 mp_msg(MSGT_DEMUX, MSGL_DBG2, "FORMAT %s\n", es->format_descriptor);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1298 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1299 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1300 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1301 mp_msg(MSGT_DEMUX, MSGL_DBG2, "Unknown descriptor 0x%x, SKIPPING\n", ptr[j]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1302
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1303 len -= 2 + descr_len;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1304 j += 2 + descr_len;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1305 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1306
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1307 return 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1308 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1309
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1310
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1311
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1312 static int parse_pmt(ts_priv_t * priv, uint16_t progid, uint16_t pid, int is_start, unsigned char *buff, int size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1313 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1314 unsigned char *base, *es_base;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1315 pmt_t *pmt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1316 int32_t idx, es_count, section_bytes;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1317 uint8_t skip, m=0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1318
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1319 idx = progid_idx_in_pmt(priv, progid);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1320
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1321 if(idx == -1)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1322 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1323 int sz = (priv->pmt_cnt + 1) * sizeof(pmt_t);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1324 priv->pmt = (pmt_t *) realloc(priv->pmt, sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1325 if(priv->pmt == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1326 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1327 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT: COULDN'T REALLOC %d bytes, NEXT\n", sz);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1328 return NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1329 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1330
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1331 idx = priv->pmt_cnt;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1332 memset(&(priv->pmt[idx]), 0, sizeof(pmt_t));
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1333 priv->pmt_cnt++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1334 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1335
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1336 pmt = &(priv->pmt[idx]);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1337
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1338
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1339 if(! is_start)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1340 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1341 if(pmt->buffer_len == 0)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1342 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1343 //BROKEN PMT PACKET, DISCARD
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1344 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1345 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1346
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1347 if(pmt->skip)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1348 m = min(pmt->skip, size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1349
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1350 pmt->skip -= m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1351 if(m == size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1352 return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1353 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1354 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1355 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1356 pmt->buffer_len = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1357 skip = buff[0] + 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1358 m = min(skip, size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1359
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1360 pmt->skip = skip - m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1361
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1362 if(m == size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1363 return 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1364 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1365
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1366
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1367 if(size-m + pmt->buffer_len > 2048)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1368 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1369 mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d, PID=%d), ERROR! PMT TOO LONG, IGNORING\n", progid, pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1370 pmt->buffer_len = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1371 return NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1372 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1373
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1374 memcpy(&(pmt->buffer[pmt->buffer_len]), &buff[m], size - m);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1375 pmt->progid = progid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1376 pmt->buffer_len += size - m;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1377
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1378 mp_msg(MSGT_DEMUX, MSGL_V, "FILL_PMT(prog=%d), PMT_len: %d, IS_START: %d, TS_PID: %d, SIZE=%d, M=%d, ES_CNT=%d, IDX=%d, PMT_PTR=%p\n",
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1379 progid, pmt->buffer_len, is_start, pid, size, m, pmt->es_cnt, idx, pmt);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1380
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1381 base = pmt->buffer;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1382
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1383
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1384 pmt->table_id = base[0];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1385 pmt->ssi = base[1] & 0x80;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1386 pmt->section_length = (((base[1] & 0xf) << 8 ) | base[2]);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1387 pmt->version_number = (base[5] >> 1) & 0x1f;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1388 pmt->curr_next = (base[5] & 1);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1389 pmt->section_number = base[6];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1390 pmt->last_section_number = base[7];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1391 pmt->PCR_PID = ((base[8] & 0x1f) << 8 ) | base[9];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1392 pmt->prog_descr_length = ((base[10] & 0xf) << 8 ) | base[11];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1393
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1394
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1395
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1396 if((pmt->curr_next == 0) || (pmt->table_id != 2))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1397 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1398
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1399
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1400 if(pmt->section_length + 3 > pmt->buffer_len)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1401 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1402 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, SECTION LENGTH TOO LARGE FOR CURRENT BUFFER (%d vs %d), NEXT TIME\n", pmt->section_length, pmt->buffer_len);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1403
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1404 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1405 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1406
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1407 if(pmt->prog_descr_length > pmt->section_length - 9)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1408 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1409 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, INVALID PROG_DESCR LENGTH (%d vs %d)\n", pmt->prog_descr_length, pmt->section_length - 9);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1410 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1411 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1412
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1413
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1414 es_base = &base[12 + pmt->prog_descr_length]; //the beginning of th ES loop
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1415
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1416 section_bytes= pmt->section_length - 13 - pmt->prog_descr_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1417 es_count = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1418
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1419 while(section_bytes >= 5)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1420 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1421 int es_pid, es_type;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1422
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1423 es_type = es_base[0];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1424 es_pid = ((es_base[1] & 0x1f) << 8) | es_base[2];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1425
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1426 idx = es_pid_in_pmt(pmt, es_pid);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1427 if(idx == -1)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1428 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1429 int sz = sizeof(struct pmt_es_t) * (pmt->es_cnt + 1);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1430 pmt->es = (struct pmt_es_t *) realloc(pmt->es, sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1431 if(pmt->es == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1432 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1433 mp_msg(MSGT_DEMUX, MSGL_ERR, "PARSE_PMT, COULDN'T ALLOCATE %d bytes for PMT_ES\n", sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1434 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1435 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1436 idx = pmt->es_cnt;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1437 memset(&(pmt->es[idx]), 0, sizeof(struct pmt_es_t));
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1438 pmt->es_cnt++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1439 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1440
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1441 pmt->es[idx].descr_length = ((es_base[3] & 0xf) << 8) | es_base[4];
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1442
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1443
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1444 if(pmt->es[idx].descr_length > section_bytes - 5)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1445 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1446 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT, ES_DESCR_LENGTH TOO LARGE %d > %d, EXIT\n",
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1447 pmt->es[idx].descr_length, section_bytes - 5);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1448 return -1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1449 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1450
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1451
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1452 pmt->es[idx].pid = es_pid;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1453 pmt->es[idx].type = es_type;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1454
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1455 pmt->es[idx].type = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1456
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1457 switch(es_type)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1458 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1459 case 1:
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1460 pmt->es[idx].type = VIDEO_MPEG1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1461 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1462 case 2:
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1463 pmt->es[idx].type = VIDEO_MPEG2;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1464 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1465 case 3:
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1466 case 4:
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1467 parse_descriptors(&pmt->es[idx], &es_base[5]);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1468 pmt->es[idx].type = AUDIO_MP2;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1469 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1470 case 6:
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1471 parse_descriptors(&pmt->es[idx], &es_base[5]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1472 if(pmt->es[idx].type == 0x6)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1473 pmt->es[idx].type = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1474 break;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1475 case 0x10:
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1476 pmt->es[idx].type = VIDEO_MPEG4;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1477 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1478 case 0x11:
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1479 parse_descriptors(&pmt->es[idx], &es_base[5]);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1480 pmt->es[idx].type = AUDIO_AAC;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1481 break;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1482
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1483 /* seems to indicate an AAC in a certain broadcaster's tables, but
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1484 it's deceiving, so it's commented out
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1485 case 0x0f:
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1486 parse_descriptors(&pmt->es[idx], &es_base[5]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1487 pmt->es[idx].type = 0x0f;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1488 break;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1489 */
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1490
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1491 case 0x81:
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1492 pmt->es[idx].type = AUDIO_A52;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1493 break;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1494
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1495 default:
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1496 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1497 if(es_type > 0x80)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1498 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1499 parse_descriptors(&pmt->es[idx], &es_base[5]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1500 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1501 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1502 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1503 mp_msg(MSGT_DEMUX, MSGL_DBG2, "UNKNOWN ES TYPE=0x%x\n", es_type);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1504 pmt->es[idx].type = UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1505 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1506 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1507 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1508
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1509 section_bytes -= 5 + pmt->es[idx].descr_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1510 mp_msg(MSGT_DEMUX, MSGL_V, "PARSE_PMT(%d INDEX %d), STREAM: %d, FOUND pid=0x%x (%d), type=0x%x, ES_DESCR_LENGTH: %d, bytes left: %d\n",
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1511 progid, idx, es_count, pmt->es[idx].pid, pmt->es[idx].pid, pmt->es[idx].type, pmt->es[idx].descr_length, section_bytes);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1512
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1513
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1514 es_base += 5 + pmt->es[idx].descr_length;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1515
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1516 es_count++;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1517 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1518
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1519 mp_msg(MSGT_DEMUX, MSGL_V, "----------------------------\n");
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1520 return 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1521 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1522
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1523
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1524 static inline int32_t pid_type_from_pmt(ts_priv_t *priv, int pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1525 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1526 int32_t pmt_idx, pid_idx, i, j;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1527
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1528 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1529
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1530 if(pmt_idx != -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1531 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1532 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1533 if(pid_idx != -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1534 return priv->pmt[pmt_idx].es[pid_idx].type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1535 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1536 //else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1537 //{
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1538 for(i = 0; i < priv->pmt_cnt; i++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1539 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1540 pmt_t *pmt = &(priv->pmt[i]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1541 for(j = 0; j < pmt->es_cnt; j++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1542 if(pmt->es[j].pid == pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1543 return pmt->es[j].type;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1544 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1545 //}
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1546
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1547 return UNKNOWN;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1548 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1549
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1550
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1551 static inline uint8_t *pid_lang_from_pmt(ts_priv_t *priv, int pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1552 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1553 int32_t pmt_idx, pid_idx, i, j;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1554
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1555 pmt_idx = progid_idx_in_pmt(priv, priv->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1556
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1557 if(pmt_idx != -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1558 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1559 pid_idx = es_pid_in_pmt(&(priv->pmt[pmt_idx]), pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1560 if(pid_idx != -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1561 return priv->pmt[pmt_idx].es[pid_idx].lang;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1562 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1563 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1564 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1565 for(i = 0; i < priv->pmt_cnt; i++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1566 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1567 pmt_t *pmt = &(priv->pmt[i]);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1568 for(j = 0; j < pmt->es_cnt; j++)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1569 if(pmt->es[j].pid == pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1570 return pmt->es[j].lang;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1571 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1572 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1573
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1574 return NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1575 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1576
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1577
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1578 static int fill_packet(demuxer_t *demuxer, demux_stream_t *ds, demux_packet_t **dp, int *dp_offset, int *broken)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1579 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1580 int ret = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1581
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1582 if((*dp != NULL) && (*dp_offset > 0))
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1583 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1584 if(*broken == 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1585 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1586 ret = *dp_offset;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1587 resize_demux_packet(*dp, ret); //shrinked to the right size
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1588 ds_add_packet(ds, *dp);
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1589 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ADDED %d bytes to %s fifo, PTS=%f\n", ret, (ds == demuxer->audio ? "audio" : (ds == demuxer->video ? "video" : "sub")), (*dp)->pts);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1590 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1591 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1592 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1593 ret = 0;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1594 mp_msg(MSGT_DEMUX, MSGL_DBG2, "BROKEN PES, DISCARDING\n");
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1595 free_demux_packet(*dp);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1596 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1597 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1598
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1599 *broken = 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1600 *dp = NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1601 *dp_offset = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1602
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1603 return ret;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1604 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1605
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1606 // 0 = EOF or no stream found
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1607 // else = [-] number of bytes written to the packet
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1608 static int ts_parse(demuxer_t *demuxer , ES_stream_t *es, unsigned char *packet, int probe)
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
1609 {
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
1610 ES_stream_t *tss;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1611 uint8_t done = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1612 int buf_size, is_start, pid, base;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1613 int len, cc, cc_ok, afc, retv = 0, is_video, is_audio, is_sub;
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
1614 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1615 stream_t *stream = demuxer->stream;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1616 char *p, tmp[TS_FEC_PACKET_SIZE];
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1617 demux_stream_t *ds = NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1618 demux_packet_t **dp = NULL;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1619 int *dp_offset = 0, *buffer_size = 0, *broken = NULL;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1620 int32_t progid, pid_type, bad, ts_error;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1621
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1622
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1623 while(! done)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1624 {
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1625 bad = ts_error = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1626 ds = (demux_stream_t*) NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1627 dp = (demux_packet_t **) NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1628 broken = dp_offset = buffer_size = NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1629
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1630 buf_size = priv->ts.packet_size;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1631
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1632 if(stream_eof(stream))
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1633 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1634 if(! probe)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1635 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1636 ts_dump_streams(priv);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1637 demuxer->filepos = stream_tell(demuxer->stream);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1638 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1639
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1640 return 0;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1641 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1642
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1643
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1644 if(! ts_sync(stream))
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1645 {
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1646 mp_msg(MSGT_DEMUX, MSGL_DBG2, "TS_PARSE: COULDN'T SYNC\n");
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1647 return 0;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1648 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1649
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1650 len = stream_read(stream, &packet[1], 3);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1651 if (len != 3)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1652 return 0;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1653
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1654 if((packet[1] >> 7) & 0x01) //transport error
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1655 ts_error = 1;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1656
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1657 buf_size -= 4;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1658
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1659 is_start = packet[1] & 0x40;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1660 pid = ((packet[1] & 0x1f) << 8) | packet[2];
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1661
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1662 tss = priv->ts.pids[pid]; //an ES stream
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1663 if(tss == NULL)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1664 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1665 tss = malloc(sizeof(ES_stream_t));
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1666 if(! tss)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1667 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1668 memset(tss, 0, sizeof(ES_stream_t));
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1669 tss->pid = pid;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1670 tss->last_cc = -1;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1671 tss->type = UNKNOWN;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1672 tss->payload_size = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1673 tss->seen = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1674 priv->ts.pids[pid] = tss;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1675 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1676
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1677
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1678
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1679 if(((pid > 1) && (pid < 16)) || (pid == 8191)) //invalid pid
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1680 {
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1681 stream_skip(stream, buf_size-1);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1682 continue;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1683 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1684
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1685 cc = (packet[3] & 0xf);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1686 cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1687 tss->last_cc = cc;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1688
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1689 bad = ts_error || (! cc_ok);
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1690
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1691 if(! bad)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1692 {
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1693 // skip adaptation field, but only if cc_ok is not corrupt,
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1694 //otherwise we may throw away good data
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1695 afc = (packet[3] >> 4) & 3;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1696 if(! (afc % 2)) //no payload in this TS packet
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1697 {
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1698 stream_skip(stream, buf_size-1);
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1699 continue;
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1700 }
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1701
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1702 if(afc == 3)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1703 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1704 int c;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1705 c = stream_read_char(stream);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1706 buf_size--;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1707
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1708 c = min(c, buf_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1709 stream_skip(stream, c);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1710 buf_size -= c;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1711 if(buf_size == 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1712 continue;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1713
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1714 afc = c + 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1715 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1716 else
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1717 afc = 0; //payload only
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1718 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1719 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1720 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1721 // logically this packet should be dropped, but if I do it
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1722 // certain streams play corrupted. Maybe the decoders know
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1723 // how to deal with it, but at least I consider the packet
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1724 // as "not initial"
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1725 mp_msg(MSGT_DEMUX, MSGL_V, "ts_parse: PID=%d, Transport error: %d, CC_OK: %s\n\n", tss->pid, ts_error, (cc_ok ? "yes" : "no"));
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1726
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1727 if(priv->keep_broken == 0)
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1728 {
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1729 stream_skip(stream, buf_size-1);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1730 continue;
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1731 }
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1732
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1733 is_start = 0; //queued to the packet data
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1734 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1735
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1736 tss->seen++;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1737 if(tss->seen == 16 && cc_ok) //at least a complete round
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1738 mp_msg(MSGT_DEMUX, MSGL_V, "\nNew TS pid=%u\n", pid);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1739
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1740
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1741 //TABLE PARSING
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1742
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1743 base = priv->ts.packet_size - buf_size;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1744 if(pid == 0)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1745 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1746 stream_read(stream,&packet[base], buf_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1747 parse_pat(priv, is_start, &packet[base], buf_size);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1748 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1749 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1750 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1751 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1752 progid = prog_id_in_pat(priv, pid);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1753 if(((progid != -1) || (pid == 16)))
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1754 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1755 if(pid != demuxer->video->id && pid != demuxer->audio->id && pid != demuxer->sub->id)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1756 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1757 stream_read(stream,&packet[base], buf_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1758 parse_pmt(priv, progid, pid, is_start, &packet[base], buf_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1759 continue;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1760 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1761 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1762 mp_msg(MSGT_DEMUX, MSGL_ERR, "Argh! Data pid used in the PMT, Skipping PMT parsing!\n");
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1763 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1764 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1765
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1766
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1767 priv->last_pid = pid;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1768
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1769 is_video = ((tss->type == VIDEO_MPEG1) || (tss->type == VIDEO_MPEG2) || (tss->type == VIDEO_MPEG4));
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1770 is_audio = ((tss->type == AUDIO_MP2) || (tss->type == AUDIO_A52) || (tss->type == AUDIO_LPCM_BE) || (tss->type == AUDIO_AAC));
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1771 is_sub = ((tss->type == SPU_DVD) || (tss->type == SPU_DVB));
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1772 pid_type = pid_type_from_pmt(priv, pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1773
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1774 // PES CONTENT STARTS HERE
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1775 if(! probe)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1776 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1777 if((pid == demuxer->sub->id)) //or the lang is right
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1778 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1779 pid_type = SPU_DVD;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1780 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1781
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1782 if(is_video && (demuxer->video->id == tss->pid))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1783 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1784 ds = demuxer->video;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1785
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1786 dp = &priv->fifo[1].pack;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1787 dp_offset = &priv->fifo[1].offset;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1788 buffer_size = &priv->fifo[1].buffer_size;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1789 broken = &priv->fifo[1].broken;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1790 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1791 else if(is_audio && (demuxer->audio->id == tss->pid))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1792 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1793 ds = demuxer->audio;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1794
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1795 dp = &priv->fifo[0].pack;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1796 dp_offset = &priv->fifo[0].offset;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1797 buffer_size = &priv->fifo[0].buffer_size;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1798 broken = &priv->fifo[0].broken;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1799 }
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1800 else if(is_sub
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1801 || (pid_type == SPU_DVD) || (pid_type == SPU_DVB))
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1802 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1803 //SUBS are infrequent, so the initial detection may fail
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1804 // and we may need to add them at play-time
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1805 if(demuxer->sub->id == -1)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1806 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1807 uint16_t p;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1808 p = progid_for_pid(priv, tss->pid, priv->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1809
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1810 if(p == priv->prog)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1811 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1812 int asgn = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1813 uint8_t *lang;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1814
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1815 if(!strcmp(dvdsub_lang, ""))
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1816 asgn = 1;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1817 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1818 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1819 lang = pid_lang_from_pmt(priv, pid);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1820 if(lang != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1821 asgn = (strncmp(lang, dvdsub_lang, 3) == 0);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1822 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1823 asgn = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1824 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1825
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1826 if(asgn)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1827 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1828 demuxer->sub->id = tss->pid;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1829 mp_msg(MSGT_DEMUX, MSGL_INFO, "CHOSEN SUBs pid 0x%x (%d) FROM PROG %d\n", tss->pid, tss->pid, priv->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1830 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1831 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1832 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1833 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1834 mp_msg(MSGT_DEMUX, MSGL_V, "DISCARDED SUBs pid 0x%x (%d) NOT CHOSEN OR NOT IN PROG %d\n", tss->pid, tss->pid, priv->prog);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1835 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1836 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1837
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1838 if(demuxer->sub->id == tss->pid)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1839 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1840 ds = demuxer->sub;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1841
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1842 dp = &priv->fifo[2].pack;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1843 dp_offset = &priv->fifo[2].offset;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1844 buffer_size = &priv->fifo[2].buffer_size;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1845 broken = &priv->fifo[2].broken;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1846 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1847 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1848 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1849 stream_skip(stream, buf_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1850 continue;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1851 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1852 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1853 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1854 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1855 stream_skip(stream, buf_size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1856 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1857 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1858
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1859 //IS IT TIME TO QUEUE DATA to the dp_packet?
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1860 if(is_start && (dp != NULL))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1861 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1862 retv = fill_packet(demuxer, ds, dp, dp_offset, broken);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1863 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1864
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1865
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1866 if(*dp == NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1867 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1868 *dp = new_demux_packet(*buffer_size); //es->size
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1869 *dp_offset = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1870 if(! *dp)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1871 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1872 fprintf(stderr, "fill_buffer, NEW_ADD_PACKET(%d)FAILED\n", *buffer_size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1873 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1874 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1875 mp_msg(MSGT_DEMUX, MSGL_DBG2, "CREATED DP(%d)\n", *buffer_size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1876 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1877
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1878 mp_msg(MSGT_DEMUX, MSGL_DBG2, "NOW PACKET_SIZE = %d, DP_OFFSET = %d\n", *buffer_size, *dp_offset);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1879 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1880
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1881
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1882
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1883 if(is_start)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1884 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1885 mp_msg(MSGT_DEMUX, MSGL_DBG2, "IS_START\n");
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1886
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1887 p = &packet[base];
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1888 stream_read(stream, p, buf_size);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1889
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1890 len = pes_parse2(p, buf_size, es, pid_type);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1891
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1892 if(len > 0)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1893 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1894 if(es->type == UNKNOWN)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1895 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1896
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1897 es->pid = tss->pid;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1898 tss->type = es->type;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1899
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1900 if((es->pts < tss->last_pts) && es->pts)
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1901 mp_msg(MSGT_DEMUX, MSGL_DBG2, "BACKWARDS PTS! : NEW: %f -> LAST: %f, PID %d\n", es->pts, tss->last_pts, tss->pid);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1902
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1903 if(es->pts == 0.0f)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1904 es->pts = tss->pts = tss->last_pts;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1905 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1906 tss->pts = tss->last_pts = es->pts;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1907
12049
5da6a113b6af fix wrong detection of mpeg4 as mpeg2 and wrong handling of discontinuities/transport error bit
nicodvb
parents: 11412
diff changeset
1908 mp_msg(MSGT_DEMUX, MSGL_DBG2, "ts_parse, NEW pid=%d, PSIZE: %u, type=%X, start=%p, len=%d\n",
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1909 es->pid, es->payload_size, es->type, es->start, es->size);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1910
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1911 tss->payload_size = es->payload_size;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1912
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1913 demuxer->filepos = stream_tell(demuxer->stream) - es->size;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1914
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1915 if(probe)
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1916 return 1; //es->size;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1917 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1918 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1919 *broken = 0;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1920 if(es->size > 0)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1921 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1922 if(*dp_offset + es->size > *buffer_size)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1923 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1924 *buffer_size = *dp_offset + es->size + TS_FEC_PACKET_SIZE;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1925 resize_demux_packet(*dp, *buffer_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1926 //we'll skip at least one RESIZE() in the next iteration of ts_parse()
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1927 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1928 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1929 memcpy(&((*dp)->buffer[*dp_offset]), es->start, es->size);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1930 *dp_offset += es->size;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1931 (*dp)->flags = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1932 (*dp)->pos = stream_tell(demuxer->stream);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1933 (*dp)->pts = es->pts;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1934 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1935
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1936 if(retv > 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1937 return retv;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1938 else
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1939 continue;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1940 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1941 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1942 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1943 return 0;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1944 }
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
1945 else
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
1946 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1947 uint16_t sz;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1948
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1949 if(tss->type == UNKNOWN)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1950 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1951 stream_skip(stream, buf_size);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1952 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1953 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1954
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1955
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1956 es->pid = tss->pid;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1957 es->type = tss->type;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1958 es->pts = tss->pts = tss->last_pts;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1959 es->start = &packet[base];
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1960
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1961
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1962 if(tss->payload_size > 0)
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1963 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1964 sz = min(tss->payload_size, buf_size);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1965 tss->payload_size -= sz;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1966 es->size = sz;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1967 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1968 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1969 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1970 if(is_video)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1971 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1972 sz = es->size = buf_size;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1973 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1974 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1975 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1976 stream_skip(stream, buf_size);
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1977 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1978 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1979 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1980
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1981
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1982 if(! probe)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1983 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1984 if(*dp_offset + sz > *buffer_size)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1985 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1986 *buffer_size = *dp_offset + sz + TS_FEC_PACKET_SIZE;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1987 resize_demux_packet(*dp, *buffer_size);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1988 //we'll skip at least one RESIZE() in the next iteration of ts_parse()
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1989 mp_msg(MSGT_DEMUX, MSGL_DBG2, "RESIZE DP TO %d\n", *buffer_size);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1990 //mp_msg(MSGT_DEMUX, MSGL_INFO, "SECOND TYPE=%x, bytes=%d, afc=%d, psize=%d, tell=%llu\n", es->type, sz, afc, tss->payload_size, (uint64_t) stream_tell(demuxer->stream));
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1991 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1992
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1993 stream_read(stream, &((*dp)->buffer[*dp_offset]), sz);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1994 *dp_offset += sz;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
1995
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1996 if(buf_size - sz > 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1997 {
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
1998 stream_skip(stream, buf_size - sz);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
1999 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2000
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2001 continue;
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2002 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2003 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2004 {
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2005 stream_read(stream, es->start, sz);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2006 if(buf_size - sz) stream_read(stream, tmp, buf_size-sz);
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2007
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2008 if(es->size)
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2009 return es->size;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2010 else
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2011 continue;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2012 }
10014
01a9af06319a fully reworked by Nico <nsabbi@libero.it>
alex
parents: 9638
diff changeset
2013 }
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2014 }
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2015
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2016 return 0;
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2017 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2018
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2019
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2020 extern void resync_audio_stream(sh_audio_t *sh_audio);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2021 extern void skip_audio_frame(sh_audio_t *sh_audio);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2022
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2023 static void reset_fifos(ts_priv_t* priv, int a, int v, int s)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2024 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2025 if(a)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2026 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2027 if(priv->fifo[0].pack != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2028 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2029 free_demux_packet(priv->fifo[0].pack);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2030 priv->fifo[0].pack = NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2031 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2032 priv->fifo[0].offset = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2033 priv->fifo[0].broken = 1;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2034 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2035
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2036 if(v)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2037 {
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2038 if(priv->fifo[1].pack != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2039 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2040 free_demux_packet(priv->fifo[1].pack);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2041 priv->fifo[1].pack = NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2042 }
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2043 priv->fifo[1].offset = 0;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2044 priv->fifo[1].broken = 1;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2045 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2046
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2047 if(s)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2048 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2049 if(priv->fifo[2].pack != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2050 {
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2051 free_demux_packet(priv->fifo[2].pack);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2052 priv->fifo[2].pack = NULL;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2053 }
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2054 priv->fifo[2].offset = 0;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2055 priv->fifo[2].broken = 1;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2056 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2057 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2058
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2059 extern int videobuf_code_len;
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2060 extern int sync_video_packet(demux_stream_t *);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2061 extern int skip_video_packet(demux_stream_t *);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2062
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2063 void demux_seek_ts(demuxer_t *demuxer, float rel_seek_secs, int flags)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2064 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2065 demux_stream_t *d_audio=demuxer->audio;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2066 demux_stream_t *d_video=demuxer->video;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2067 demux_stream_t *d_sub=demuxer->sub;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2068 sh_audio_t *sh_audio=d_audio->sh;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2069 sh_video_t *sh_video=d_video->sh;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2070 ts_priv_t * priv = (ts_priv_t*) demuxer->priv;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2071 int i, video_stats;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2072 off_t newpos;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2073
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2074 //================= seek in MPEG-TS ==========================
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2075
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2076 ts_dump_streams(demuxer->priv);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2077 reset_fifos(priv, sh_audio != NULL, sh_video != NULL, demuxer->sub->id > 0);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2078
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2079
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2080 if(sh_audio != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2081 ds_free_packs(d_audio);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2082 if(sh_video != NULL)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2083 ds_free_packs(d_video);
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2084 if(demuxer->sub->id > 0)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2085 ds_free_packs(d_sub);
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2086
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2087
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2088 video_stats = (sh_video != NULL);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2089 if(video_stats)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2090 video_stats = sh_video->i_bps;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2091
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2092 newpos = (flags & 1) ? demuxer->movi_start : demuxer->filepos;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2093 if(flags & 2) // float seek 0..1
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2094 newpos+=(demuxer->movi_end-demuxer->movi_start)*rel_seek_secs;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2095 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2096 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2097 // time seek (secs)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2098
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2099 if(! video_stats) // unspecified or VBR
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2100 newpos += 2324*75*rel_seek_secs; // 174.3 kbyte/sec
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2101 else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2102 newpos += video_stats*rel_seek_secs;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2103 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2104
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2105
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2106 if(newpos < demuxer->movi_start)
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2107 newpos = demuxer->movi_start; //begininng of stream
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2108
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2109 #ifdef _LARGEFILE_SOURCE
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2110 newpos &= ~((long long) (STREAM_BUFFER_SIZE - 1)); /* sector boundary */
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2111 #else
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2112 newpos &= ~(STREAM_BUFFER_SIZE - 1); /* sector boundary */
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2113 #endif
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2114
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2115 stream_seek(demuxer->stream, newpos);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2116
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2117 videobuf_code_len = 0;
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2118
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2119 if(sh_video != NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2120 ds_fill_buffer(d_video);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2121
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2122 if(sh_audio != NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2123 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2124 ds_fill_buffer(d_audio);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2125 resync_audio_stream(sh_audio);
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2126 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2127
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2128 while(sh_video != NULL)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2129 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2130 if(sh_audio && !d_audio->eof && d_video->pts && d_audio->pts)
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2131 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2132 float a_pts=d_audio->pts;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2133 a_pts+=(ds_tell_pts(d_audio)-sh_audio->a_in_buffer_len)/(float)sh_audio->i_bps;
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2134 if(d_video->pts > a_pts)
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2135 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2136 skip_audio_frame(sh_audio); // sync audio
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2137 continue;
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2138 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2139 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2140
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2141
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2142 i = sync_video_packet(d_video);
11190
dad43bc55cfc big demux_ts fix from Nico <nsabbi@libero.it>
attila
parents: 10841
diff changeset
2143 if((sh_video->format == VIDEO_MPEG1) || (sh_video->format == VIDEO_MPEG2))
10686
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2144 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2145 if(i==0x1B3 || i==0x1B8) break; // found it!
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2146 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2147 else //MPEG4
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2148 {
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2149 if(i==0x1B6) break; // found it!
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2150 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2151
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2152 if(!i || !skip_video_packet(d_video)) break; // EOF?
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2153 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2154 }
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2155
8eb690f0e342 - seek() is always synchronized to keyframes, so the decoders don't
arpi
parents: 10310
diff changeset
2156
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2157 int demux_ts_fill_buffer(demuxer_t * demuxer)
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2158 {
10253
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2159 ES_stream_t es;
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2160 char packet[TS_FEC_PACKET_SIZE];
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2161
978b12dcb9ef - open new_ds_[audio | video] only when the relative streams are really available
arpi
parents: 10242
diff changeset
2162 return -ts_parse(demuxer, &es, packet, 0);
9610
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2163 }
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2164
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2165
76c6d8f1ebf5 this is a combo patch that:
arpi
parents:
diff changeset
2166