Statistics
| Branch: | Revision:

ffmpeg / libavformat / mpegts.c @ 5cd62665

History | View | Annotate | Download (9.61 KB)

1
/*
2
 * MPEG2 transport stream (aka DVB) demux
3
 * Copyright (c) 2002 Fabrice Bellard.
4
 *
5
 * This library is free software; you can redistribute it and/or
6
 * modify it under the terms of the GNU Lesser General Public
7
 * License as published by the Free Software Foundation; either
8
 * version 2 of the License, or (at your option) any later version.
9
 *
10
 * This library is distributed in the hope that it will be useful,
11
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
12
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
13
 * Lesser General Public License for more details.
14
 *
15
 * You should have received a copy of the GNU Lesser General Public
16
 * License along with this library; if not, write to the Free Software
17
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
18
 */
19
#include "avformat.h"
20

    
21
#define TS_FEC_PACKET_SIZE 204
22
#define TS_PACKET_SIZE 188
23
#define NB_PID_MAX 8192
24

    
25
enum MpegTSState {
26
    MPEGTS_HEADER = 0,
27
    MPEGTS_PESHEADER_FILL,
28
    MPEGTS_PESHEADER_FLAGS,
29
    MPEGTS_PESHEADER_SIZE,
30
    MPEGTS_PESHEADER_READ,
31
    MPEGTS_PAYLOAD,
32
    MPEGTS_SKIP,
33
};
34

    
35
/* enough for PES header + length */
36
#define MAX_HEADER_SIZE 6
37

    
38
typedef struct MpegTSStream {
39
    int pid;
40
    enum MpegTSState state;
41
    int last_cc; /* last cc code (-1 if first packet) */
42
    /* used to get the format */
43
    int header_size;
44
    int payload_size;
45
    int pes_header_size;
46
    AVStream *st;
47
    unsigned char header[MAX_HEADER_SIZE];
48
} MpegTSStream;
49

    
50
typedef struct MpegTSContext {
51
    int raw_packet_size; /* raw packet size, including FEC if present */
52
    MpegTSStream *pids[NB_PID_MAX];
53
} MpegTSContext;
54

    
55
/* autodetect fec presence. Must have at least 1024 bytes  */
56
static int get_packet_size(const unsigned char *buf, int size)
57
{
58
    int i;
59

    
60
    if (size < (TS_FEC_PACKET_SIZE * 5 + 1))
61
        return -1;
62
    for(i=0;i<5;i++) {
63
        if (buf[i * TS_PACKET_SIZE] != 0x47)
64
            goto try_fec;
65
    }
66
    return TS_PACKET_SIZE;
67
 try_fec:
68
    for(i=0;i<5;i++) {
69
        if (buf[i * TS_FEC_PACKET_SIZE] != 0x47)
70
            return -1;
71
    }
72
    return TS_FEC_PACKET_SIZE;
73
}
74

    
75
static int mpegts_probe(AVProbeData *p)
76
{
77
    int size;
78
    size = get_packet_size(p->buf, p->buf_size);
79
    if (size < 0)
80
        return 0;
81
    return AVPROBE_SCORE_MAX - 1;
82
}
83

    
84
static int mpegts_read_header(AVFormatContext *s,
85
                              AVFormatParameters *ap)
86
{
87
    MpegTSContext *ts = s->priv_data;
88
    ByteIOContext *pb = &s->pb;
89
    unsigned char buf[1024];
90
    int len;
91
    int64_t pos;
92

    
93
    /* read the first 1024 bytes to get packet size */
94
    pos = url_ftell(pb);
95
    len = get_buffer(pb, buf, sizeof(buf));
96
    if (len != sizeof(buf))
97
        goto fail;
98
    ts->raw_packet_size = get_packet_size(buf, sizeof(buf));
99
    if (ts->raw_packet_size <= 0)
100
        goto fail;
101
    /* go again to the start */
102
    url_fseek(pb, pos, SEEK_SET);
103
    return 0;
104
 fail:
105
    return -1;
106
}
107

    
108
/* return non zero if a packet could be constructed */
109
static int mpegts_push_data(AVFormatContext *s, MpegTSStream *tss,
110
                            AVPacket *pkt,
111
                            const unsigned char *buf, int buf_size, int is_start)
112
{
113
    AVStream *st;
114
    const unsigned char *p;
115
    int len, code, codec_type, codec_id;
116

    
117
    if (is_start) {
118
        tss->state = MPEGTS_HEADER;
119
        tss->header_size = 0;
120
    }
121
    p = buf;
122
    while (buf_size > 0) {
123
        len = buf_size;
124
        switch(tss->state) {
125
        case MPEGTS_HEADER:
126
            if (len > MAX_HEADER_SIZE - tss->header_size)
127
                len = MAX_HEADER_SIZE - tss->header_size;
128
            memcpy(tss->header, p, len);
129
            tss->header_size += len;
130
            p += len;
131
            buf_size -= len;
132
            if (tss->header_size == MAX_HEADER_SIZE) {
133
                /* we got all the PES or section header. We can now
134
                   decide */
135
#if 0
136
                av_hex_dump(tss->header, tss->header_size);
137
#endif
138
                if (tss->header[0] == 0x00 && tss->header[1] == 0x00 &&
139
                    tss->header[2] == 0x01) {
140
                    /* it must be an mpeg2 PES stream */
141
                    /* XXX: add AC3 support */
142
                    code = tss->header[3] | 0x100;
143
                    if (!((code >= 0x1c0 && code <= 0x1df) ||
144
                          (code >= 0x1e0 && code <= 0x1ef)))
145
                        goto skip;
146
                    if (!tss->st) {
147
                        /* allocate stream */
148
                        if (code >= 0x1c0 && code <= 0x1df) {
149
                            codec_type = CODEC_TYPE_AUDIO;
150
                            codec_id = CODEC_ID_MP2;
151
                        } else {
152
                            codec_type = CODEC_TYPE_VIDEO;
153
                            codec_id = CODEC_ID_MPEG1VIDEO;
154
                        }
155
                        st = av_new_stream(s, tss->pid);
156
                        if (st) {
157
                            st->priv_data = tss;
158
                            st->codec.codec_type = codec_type;
159
                            st->codec.codec_id = codec_id;
160
                            tss->st = st;
161
                        }
162
                    }
163
                    tss->state = MPEGTS_PESHEADER_FILL;
164
                    tss->payload_size = (tss->header[4] << 8) | tss->header[5];
165
                    if (tss->payload_size == 0)
166
                        tss->payload_size = 65536;
167
                } else {
168
                    /* otherwise, it should be a table */
169
                    /* skip packet */
170
                skip:
171
                    tss->state = MPEGTS_SKIP;
172
                    continue;
173
                }
174
            }
175
            break;
176
            /**********************************************/
177
            /* PES packing parsing */
178
        case MPEGTS_PESHEADER_FILL:
179
            /* skip filling */
180
            code = *p++;
181
            buf_size--;
182
            tss->payload_size--;
183
            if (code != 0xff) {
184
                if ((code & 0xc0) != 0x80)
185
                    goto skip;
186
                tss->state = MPEGTS_PESHEADER_FLAGS;
187
            }
188
            break;
189
        case MPEGTS_PESHEADER_FLAGS:
190
            code = *p++;
191
            buf_size--;
192
            tss->payload_size--;
193
            tss->state = MPEGTS_PESHEADER_SIZE;
194
            break;
195
        case MPEGTS_PESHEADER_SIZE:
196
            tss->pes_header_size = *p++;
197
            buf_size--;
198
            tss->payload_size--;
199
            tss->state = MPEGTS_PESHEADER_READ;
200
            break;
201
        case MPEGTS_PESHEADER_READ:
202
            /* currently we do nothing except skipping */
203
            if (len > tss->pes_header_size)
204
                len = tss->pes_header_size;
205
            p += len;
206
            buf_size -= len;
207
            tss->pes_header_size -= len;
208
            tss->payload_size -= len;
209
            if (tss->pes_header_size == 0)
210
                tss->state = MPEGTS_PAYLOAD;
211
            break;
212
        case MPEGTS_PAYLOAD:
213
            if (len > tss->payload_size)
214
                len = tss->payload_size;
215
            if (len > 0) {
216
                if (tss->st && av_new_packet(pkt, buf_size) == 0) {
217
                    memcpy(pkt->data, p, buf_size);
218
                    pkt->stream_index = tss->st->index;
219
                    return 1;
220
                }
221
                tss->payload_size -= len;
222
            }
223
            buf_size = 0;
224
            break;
225
        case MPEGTS_SKIP:
226
            buf_size = 0;
227
            break;
228
        }
229
    }
230
    return 0;
231
}
232

    
233
static int mpegts_read_packet(AVFormatContext *s,
234
                              AVPacket *pkt)
235
{
236
    MpegTSContext *ts = s->priv_data;
237
    MpegTSStream *tss;
238
    ByteIOContext *pb = &s->pb;
239
    unsigned char packet[TS_FEC_PACKET_SIZE];
240
    int len, pid, cc, cc_ok, afc;
241
    const unsigned char *p;
242
    
243
    for(;;) {
244
        len = get_buffer(pb, packet, ts->raw_packet_size);
245
        if (len != ts->raw_packet_size)
246
            return AVERROR_IO;
247
        /* check paquet sync byte */
248
        /* XXX: accept to resync ? */
249
        if (packet[0] != 0x47)
250
            return AVERROR_INVALIDDATA;
251
        
252
        pid = ((packet[1] & 0x1f) << 8) | packet[2];
253
        tss = ts->pids[pid];
254
        if (tss == NULL) {
255
            /* if no pid found, then add a pid context */
256
            tss = av_mallocz(sizeof(MpegTSStream));
257
            if (!tss) 
258
                continue;
259
            ts->pids[pid] = tss;
260
            tss->pid = pid;
261
            tss->last_cc = -1;
262
            //            printf("new pid=0x%x\n", pid);
263
        }
264

    
265
        /* continuity check (currently not used) */
266
        cc = (packet[3] & 0xf);
267
        cc_ok = (tss->last_cc < 0) || ((((tss->last_cc + 1) & 0x0f) == cc));
268
        tss->last_cc = cc;
269
        
270
        /* skip adaptation field */
271
        afc = (packet[3] >> 4) & 3;
272
        p = packet + 4;
273
        if (afc == 0) /* reserved value */
274
            continue;
275
        if (afc == 2) /* adaptation field only */
276
            continue;
277
        if (afc == 3) {
278
            /* skip adapation field */
279
            p += p[0] + 1;
280
        }
281
        /* if past the end of packet, ignore */
282
        if (p >= packet + TS_PACKET_SIZE)
283
            continue;
284
    
285
        if (mpegts_push_data(s, tss, pkt, p, TS_PACKET_SIZE - (p - packet), 
286
                             packet[1] & 0x40))
287
            break;
288
    }
289
    return 0;
290
}
291

    
292
static int mpegts_read_close(AVFormatContext *s)
293
{
294
    MpegTSContext *ts = s->priv_data;
295
    int i;
296
    for(i=0;i<NB_PID_MAX;i++)
297
        av_free(ts->pids[i]);
298
    return 0;
299
}
300

    
301
AVInputFormat mpegts_demux = {
302
    "mpegts",
303
    "MPEG2 transport stream format",
304
    sizeof(MpegTSContext),
305
    mpegts_probe,
306
    mpegts_read_header,
307
    mpegts_read_packet,
308
    mpegts_read_close,
309
    .flags = AVFMT_NOHEADER | AVFMT_SHOW_IDS,
310
};
311

    
312
int mpegts_init(void)
313
{
314
    av_register_input_format(&mpegts_demux);
315
    return 0;
316
}