Statistics
| Branch: | Revision:

ffmpeg / libavformat / rtmppkt.c @ 59b6482a

History | View | Annotate | Download (8.51 KB)

1
/*
2
 * RTMP input format
3
 * Copyright (c) 2009 Kostya Shishkov
4
 *
5
 * This file is part of FFmpeg.
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
8
 * modify it under the terms of the GNU Lesser General Public
9
 * License as published by the Free Software Foundation; either
10
 * version 2.1 of the License, or (at your option) any later version.
11
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
13
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
15
 * Lesser General Public License for more details.
16
 *
17
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
19
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20
 */
21

    
22
#include "libavcodec/bytestream.h"
23
#include "libavutil/avstring.h"
24
#include "avformat.h"
25

    
26
#include "rtmppkt.h"
27
#include "flv.h"
28

    
29
void ff_amf_write_bool(uint8_t **dst, int val)
30
{
31
    bytestream_put_byte(dst, AMF_DATA_TYPE_BOOL);
32
    bytestream_put_byte(dst, val);
33
}
34

    
35
void ff_amf_write_number(uint8_t **dst, double val)
36
{
37
    bytestream_put_byte(dst, AMF_DATA_TYPE_NUMBER);
38
    bytestream_put_be64(dst, av_dbl2int(val));
39
}
40

    
41
void ff_amf_write_string(uint8_t **dst, const char *str)
42
{
43
    bytestream_put_byte(dst, AMF_DATA_TYPE_STRING);
44
    bytestream_put_be16(dst, strlen(str));
45
    bytestream_put_buffer(dst, str, strlen(str));
46
}
47

    
48
void ff_amf_write_null(uint8_t **dst)
49
{
50
    bytestream_put_byte(dst, AMF_DATA_TYPE_NULL);
51
}
52

    
53
void ff_amf_write_object_start(uint8_t **dst)
54
{
55
    bytestream_put_byte(dst, AMF_DATA_TYPE_OBJECT);
56
}
57

    
58
void ff_amf_write_field_name(uint8_t **dst, const char *str)
59
{
60
    bytestream_put_be16(dst, strlen(str));
61
    bytestream_put_buffer(dst, str, strlen(str));
62
}
63

    
64
void ff_amf_write_object_end(uint8_t **dst)
65
{
66
    /* first two bytes are field name length = 0,
67
     * AMF object should end with it and end marker
68
     */
69
    bytestream_put_be24(dst, AMF_DATA_TYPE_OBJECT_END);
70
}
71

    
72
int ff_rtmp_packet_read(URLContext *h, RTMPPacket *p,
73
                        int chunk_size, RTMPPacket *prev_pkt)
74
{
75
    uint8_t hdr, t, buf[16];
76
    int channel_id, timestamp, data_size, offset = 0;
77
    uint32_t extra = 0;
78
    enum RTMPPacketType type;
79

    
80
    if (url_read(h, &hdr, 1) != 1)
81
        return AVERROR(EIO);
82
    channel_id = hdr & 0x3F;
83

    
84
    if (channel_id < 2) { //special case for channel number >= 64
85
        buf[1] = 0;
86
        if (url_read_complete(h, buf, channel_id + 1) != channel_id + 1)
87
            return AVERROR(EIO);
88
        channel_id = AV_RL16(buf) + 64;
89
    }
90
    data_size = prev_pkt[channel_id].data_size;
91
    type      = prev_pkt[channel_id].type;
92
    extra     = prev_pkt[channel_id].extra;
93

    
94
    hdr >>= 6;
95
    if (hdr == RTMP_PS_ONEBYTE) {
96
        timestamp = prev_pkt[channel_id].timestamp;
97
    } else {
98
        if (url_read_complete(h, buf, 3) != 3)
99
            return AVERROR(EIO);
100
        timestamp = AV_RB24(buf);
101
        if (hdr != RTMP_PS_FOURBYTES) {
102
            if (url_read_complete(h, buf, 3) != 3)
103
                return AVERROR(EIO);
104
            data_size = AV_RB24(buf);
105
            if (url_read_complete(h, buf, 1) != 1)
106
                return AVERROR(EIO);
107
            type = buf[0];
108
            if (hdr == RTMP_PS_TWELVEBYTES) {
109
                if (url_read_complete(h, buf, 4) != 4)
110
                    return AVERROR(EIO);
111
                extra = AV_RL32(buf);
112
            }
113
        }
114
        if (timestamp == 0xFFFFFF) {
115
            if (url_read_complete(h, buf, 4) != 4)
116
                return AVERROR(EIO);
117
            timestamp = AV_RB32(buf);
118
        }
119
    }
120
    if (ff_rtmp_packet_create(p, channel_id, type, timestamp, data_size))
121
        return -1;
122
    p->extra = extra;
123
    // save history
124
    prev_pkt[channel_id].channel_id = channel_id;
125
    prev_pkt[channel_id].type       = type;
126
    prev_pkt[channel_id].data_size  = data_size;
127
    prev_pkt[channel_id].timestamp  = timestamp;
128
    prev_pkt[channel_id].extra      = extra;
129
    while (data_size > 0) {
130
        int toread = FFMIN(data_size, chunk_size);
131
        if (url_read_complete(h, p->data + offset, toread) != toread) {
132
            ff_rtmp_packet_destroy(p);
133
            return AVERROR(EIO);
134
        }
135
        data_size -= chunk_size;
136
        offset    += chunk_size;
137
        if (data_size > 0) {
138
            url_read_complete(h, &t, 1); //marker
139
            if (t != (0xC0 + channel_id))
140
                return -1;
141
        }
142
    }
143
    return 0;
144
}
145

    
146
int ff_rtmp_packet_write(URLContext *h, RTMPPacket *pkt,
147
                         int chunk_size, RTMPPacket *prev_pkt)
148
{
149
    uint8_t pkt_hdr[16], *p = pkt_hdr;
150
    int mode = RTMP_PS_TWELVEBYTES;
151
    int off = 0;
152

    
153
    //TODO: header compression
154
    bytestream_put_byte(&p, pkt->channel_id | (mode << 6));
155
    if (mode != RTMP_PS_ONEBYTE) {
156
        bytestream_put_be24(&p, pkt->timestamp >= 0xFFFFFF ? 0xFFFFFF : pkt->timestamp);
157
        if (mode != RTMP_PS_FOURBYTES) {
158
            bytestream_put_be24(&p, pkt->data_size);
159
            bytestream_put_byte(&p, pkt->type);
160
            if (mode == RTMP_PS_TWELVEBYTES)
161
                bytestream_put_le32(&p, pkt->extra);
162
        }
163
        if (pkt->timestamp >= 0xFFFFFF)
164
            bytestream_put_be32(&p, pkt->timestamp);
165
    }
166
    url_write(h, pkt_hdr, p-pkt_hdr);
167
    while (off < pkt->data_size) {
168
        int towrite = FFMIN(chunk_size, pkt->data_size - off);
169
        url_write(h, pkt->data + off, towrite);
170
        off += towrite;
171
        if (off < pkt->data_size) {
172
            uint8_t marker = 0xC0 | pkt->channel_id;
173
            url_write(h, &marker, 1);
174
        }
175
    }
176
    return 0;
177
}
178

    
179
int ff_rtmp_packet_create(RTMPPacket *pkt, int channel_id, RTMPPacketType type,
180
                          int timestamp, int size)
181
{
182
    pkt->data = av_malloc(size);
183
    if (!pkt->data)
184
        return AVERROR(ENOMEM);
185
    pkt->data_size  = size;
186
    pkt->channel_id = channel_id;
187
    pkt->type       = type;
188
    pkt->timestamp  = timestamp;
189
    pkt->extra      = 0;
190

    
191
    return 0;
192
}
193

    
194
void ff_rtmp_packet_destroy(RTMPPacket *pkt)
195
{
196
    if (!pkt)
197
        return;
198
    av_freep(&pkt->data);
199
    pkt->data_size = 0;
200
}
201

    
202
int ff_amf_tag_size(const uint8_t *data, const uint8_t *data_end)
203
{
204
    const uint8_t *base = data;
205

    
206
    if (data >= data_end)
207
        return -1;
208
    switch (*data++) {
209
    case AMF_DATA_TYPE_NUMBER:      return 9;
210
    case AMF_DATA_TYPE_BOOL:        return 2;
211
    case AMF_DATA_TYPE_STRING:      return 3 + AV_RB16(data);
212
    case AMF_DATA_TYPE_LONG_STRING: return 5 + AV_RB32(data);
213
    case AMF_DATA_TYPE_NULL:        return 1;
214
    case AMF_DATA_TYPE_ARRAY:
215
        data += 4;
216
    case AMF_DATA_TYPE_OBJECT:
217
        for (;;) {
218
            int size = bytestream_get_be16(&data);
219
            int t;
220
            if (!size) {
221
                data++;
222
                break;
223
            }
224
            if (data + size >= data_end || data + size < data)
225
                return -1;
226
            data += size;
227
            t = ff_amf_tag_size(data, data_end);
228
            if (t < 0 || data + t >= data_end)
229
                return -1;
230
            data += t;
231
        }
232
        return data - base;
233
    case AMF_DATA_TYPE_OBJECT_END:  return 1;
234
    default:                        return -1;
235
    }
236
}
237

    
238
int ff_amf_get_field_value(const uint8_t *data, const uint8_t *data_end,
239
                           const uint8_t *name, uint8_t *dst, int dst_size)
240
{
241
    int namelen = strlen(name);
242
    int len;
243

    
244
    while (*data != AMF_DATA_TYPE_OBJECT && data < data_end) {
245
        len = ff_amf_tag_size(data, data_end);
246
        if (len < 0)
247
            len = data_end - data;
248
        data += len;
249
    }
250
    if (data_end - data < 3)
251
        return -1;
252
    data++;
253
    for (;;) {
254
        int size = bytestream_get_be16(&data);
255
        if (!size)
256
            break;
257
        if (data + size >= data_end || data + size < data)
258
            return -1;
259
        data += size;
260
        if (size == namelen && !memcmp(data-size, name, namelen)) {
261
            switch (*data++) {
262
            case AMF_DATA_TYPE_NUMBER:
263
                snprintf(dst, dst_size, "%g", av_int2dbl(AV_RB64(data)));
264
                break;
265
            case AMF_DATA_TYPE_BOOL:
266
                snprintf(dst, dst_size, "%s", *data ? "true" : "false");
267
                break;
268
            case AMF_DATA_TYPE_STRING:
269
                len = bytestream_get_be16(&data);
270
                av_strlcpy(dst, data, FFMIN(len+1, dst_size));
271
                break;
272
            default:
273
                return -1;
274
            }
275
            return 0;
276
        }
277
        len = ff_amf_tag_size(data, data_end);
278
        if (len < 0 || data + len >= data_end || data + len < data)
279
            return -1;
280
        data += len;
281
    }
282
    return -1;
283
}