← Back to branch summary

~ubuntu-branches/ubuntu/jaunty/xvidcap/jaunty-proposed

« back to all changes in this revision

Viewing changes to ffmpeg/libavformat/rmdec.c

  • Committer: Bazaar Package Importer
  • Author(s): Lionel Le Folgoc, Andrew Starr-Bochicchio, Lionel Le Folgoc
  • Date: 2008-12-26 00:10:06 UTC
  • mfrom: (1.1.2 upstream)
  • Revision ID: james.westby@ubuntu.com-20081226001006-2040ls9680bd1blt
Tags: 1.1.7-0.2ubuntu1
https://launchpad.net/bugs/298547
https://launchpad.net/bugs/311412
[ Andrew Starr-Bochicchio ]
* Merge from debian-multimedia (LP: #298547), Ubuntu Changes:
 - For ffmpeg-related build-deps, fix versionized dependencies
   as the ubuntu versioning is different than debian-multimedia's.

[ Lionel Le Folgoc ]
* LP: #311412 is fixed since the 1.1.7~rc1-0.1 revision.
* debian/patches/03_ffmpeg.diff: updated to fix FTBFS due to libswscale API
  change (cherry-pick from Gentoo #234383).

Show diffs side-by-side

added added

removed removed

Lines of Context:
ffmpeg/libavformat/rmdec.c
 
1
/*
 
2
 * "Real" compatible demuxer.
 
3
 * Copyright (c) 2000, 2001 Fabrice Bellard.
 
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
#include "avformat.h"
 
22
#include "rm.h"
 
23
#include "avstring.h"
 
24
 
 
25
static inline void get_strl(ByteIOContext *pb, char *buf, int buf_size, int len)
 
26
{
 
27
    int i;
 
28
    char *q, r;
 
29
 
 
30
    q = buf;
 
31
    for(i=0;i<len;i++) {
 
32
        r = get_byte(pb);
 
33
        if (i < buf_size - 1)
 
34
            *q++ = r;
 
35
    }
 
36
    if (buf_size > 0) *q = '\0';
 
37
}
 
38
 
 
39
static void get_str16(ByteIOContext *pb, char *buf, int buf_size)
 
40
{
 
41
    get_strl(pb, buf, buf_size, get_be16(pb));
 
42
}
 
43
 
 
44
static void get_str8(ByteIOContext *pb, char *buf, int buf_size)
 
45
{
 
46
    get_strl(pb, buf, buf_size, get_byte(pb));
 
47
}
 
48
 
 
49
static int rm_read_audio_stream_info(AVFormatContext *s, AVStream *st,
 
50
                                      int read_all)
 
51
{
 
52
    RMContext *rm = s->priv_data;
 
53
    ByteIOContext *pb = s->pb;
 
54
    char buf[256];
 
55
    uint32_t version;
 
56
    int i;
 
57
 
 
58
    /* ra type header */
 
59
    version = get_be32(pb); /* version */
 
60
    if (((version >> 16) & 0xff) == 3) {
 
61
        int64_t startpos = url_ftell(pb);
 
62
        /* very old version */
 
63
        for(i = 0; i < 14; i++)
 
64
            get_byte(pb);
 
65
        get_str8(pb, s->title, sizeof(s->title));
 
66
        get_str8(pb, s->author, sizeof(s->author));
 
67
        get_str8(pb, s->copyright, sizeof(s->copyright));
 
68
        get_str8(pb, s->comment, sizeof(s->comment));
 
69
        if ((startpos + (version & 0xffff)) >= url_ftell(pb) + 2) {
 
70
        // fourcc (should always be "lpcJ")
 
71
        get_byte(pb);
 
72
        get_str8(pb, buf, sizeof(buf));
 
73
        }
 
74
        // Skip extra header crap (this should never happen)
 
75
        if ((startpos + (version & 0xffff)) > url_ftell(pb))
 
76
            url_fskip(pb, (version & 0xffff) + startpos - url_ftell(pb));
 
77
        st->codec->sample_rate = 8000;
 
78
        st->codec->channels = 1;
 
79
        st->codec->codec_type = CODEC_TYPE_AUDIO;
 
80
        st->codec->codec_id = CODEC_ID_RA_144;
 
81
    } else {
 
82
        int flavor, sub_packet_h, coded_framesize, sub_packet_size;
 
83
        /* old version (4) */
 
84
        get_be32(pb); /* .ra4 */
 
85
        get_be32(pb); /* data size */
 
86
        get_be16(pb); /* version2 */
 
87
        get_be32(pb); /* header size */
 
88
        flavor= get_be16(pb); /* add codec info / flavor */
 
89
        rm->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */
 
90
        get_be32(pb); /* ??? */
 
91
        get_be32(pb); /* ??? */
 
92
        get_be32(pb); /* ??? */
 
93
        rm->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */
 
94
        st->codec->block_align= get_be16(pb); /* frame size */
 
95
        rm->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */
 
96
        get_be16(pb); /* ??? */
 
97
        if (((version >> 16) & 0xff) == 5) {
 
98
            get_be16(pb); get_be16(pb); get_be16(pb); }
 
99
        st->codec->sample_rate = get_be16(pb);
 
100
        get_be32(pb);
 
101
        st->codec->channels = get_be16(pb);
 
102
        if (((version >> 16) & 0xff) == 5) {
 
103
            get_be32(pb);
 
104
            buf[0] = get_byte(pb);
 
105
            buf[1] = get_byte(pb);
 
106
            buf[2] = get_byte(pb);
 
107
            buf[3] = get_byte(pb);
 
108
            buf[4] = 0;
 
109
        } else {
 
110
            get_str8(pb, buf, sizeof(buf)); /* desc */
 
111
            get_str8(pb, buf, sizeof(buf)); /* desc */
 
112
        }
 
113
        st->codec->codec_type = CODEC_TYPE_AUDIO;
 
114
        if (!strcmp(buf, "dnet")) {
 
115
            st->codec->codec_id = CODEC_ID_AC3;
 
116
            st->need_parsing = AVSTREAM_PARSE_FULL;
 
117
        } else if (!strcmp(buf, "28_8")) {
 
118
            st->codec->codec_id = CODEC_ID_RA_288;
 
119
            st->codec->extradata_size= 0;
 
120
            rm->audio_framesize = st->codec->block_align;
 
121
            st->codec->block_align = coded_framesize;
 
122
 
 
123
            if(rm->audio_framesize >= UINT_MAX / sub_packet_h){
 
124
                av_log(s, AV_LOG_ERROR, "rm->audio_framesize * sub_packet_h too large\n");
 
125
                return -1;
 
126
            }
 
127
 
 
128
            rm->audiobuf = av_malloc(rm->audio_framesize * sub_packet_h);
 
129
        } else if ((!strcmp(buf, "cook")) || (!strcmp(buf, "atrc"))) {
 
130
            int codecdata_length, i;
 
131
            get_be16(pb); get_byte(pb);
 
132
            if (((version >> 16) & 0xff) == 5)
 
133
                get_byte(pb);
 
134
            codecdata_length = get_be32(pb);
 
135
            if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
 
136
                av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
 
137
                return -1;
 
138
            }
 
139
 
 
140
            if (!strcmp(buf, "cook")) st->codec->codec_id = CODEC_ID_COOK;
 
141
            else st->codec->codec_id = CODEC_ID_ATRAC3;
 
142
            st->codec->extradata_size= codecdata_length;
 
143
            st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
144
            for(i = 0; i < codecdata_length; i++)
 
145
                ((uint8_t*)st->codec->extradata)[i] = get_byte(pb);
 
146
            rm->audio_framesize = st->codec->block_align;
 
147
            st->codec->block_align = rm->sub_packet_size;
 
148
 
 
149
            if(rm->audio_framesize >= UINT_MAX / sub_packet_h){
 
150
                av_log(s, AV_LOG_ERROR, "rm->audio_framesize * sub_packet_h too large\n");
 
151
                return -1;
 
152
            }
 
153
 
 
154
            rm->audiobuf = av_malloc(rm->audio_framesize * sub_packet_h);
 
155
        } else if (!strcmp(buf, "raac") || !strcmp(buf, "racp")) {
 
156
            int codecdata_length, i;
 
157
            get_be16(pb); get_byte(pb);
 
158
            if (((version >> 16) & 0xff) == 5)
 
159
                get_byte(pb);
 
160
            st->codec->codec_id = CODEC_ID_AAC;
 
161
            codecdata_length = get_be32(pb);
 
162
            if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){
 
163
                av_log(s, AV_LOG_ERROR, "codecdata_length too large\n");
 
164
                return -1;
 
165
            }
 
166
            if (codecdata_length >= 1) {
 
167
                st->codec->extradata_size = codecdata_length - 1;
 
168
                st->codec->extradata = av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
169
                get_byte(pb);
 
170
                for(i = 0; i < st->codec->extradata_size; i++)
 
171
                    ((uint8_t*)st->codec->extradata)[i] = get_byte(pb);
 
172
            }
 
173
        } else {
 
174
            st->codec->codec_id = CODEC_ID_NONE;
 
175
            av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name));
 
176
        }
 
177
        if (read_all) {
 
178
            get_byte(pb);
 
179
            get_byte(pb);
 
180
            get_byte(pb);
 
181
 
 
182
            get_str8(pb, s->title, sizeof(s->title));
 
183
            get_str8(pb, s->author, sizeof(s->author));
 
184
            get_str8(pb, s->copyright, sizeof(s->copyright));
 
185
            get_str8(pb, s->comment, sizeof(s->comment));
 
186
        }
 
187
    }
 
188
    return 0;
 
189
}
 
190
 
 
191
int
 
192
ff_rm_read_mdpr_codecdata (AVFormatContext *s, AVStream *st)
 
193
{
 
194
    ByteIOContext *pb = s->pb;
 
195
    unsigned int v;
 
196
    int codec_data_size, size;
 
197
    int64_t codec_pos;
 
198
 
 
199
    codec_data_size = get_be32(pb);
 
200
    codec_pos = url_ftell(pb);
 
201
    v = get_be32(pb);
 
202
    if (v == MKTAG(0xfd, 'a', 'r', '.')) {
 
203
        /* ra type header */
 
204
        if (rm_read_audio_stream_info(s, st, 0))
 
205
            return -1;
 
206
    } else {
 
207
        int fps, fps2;
 
208
        if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) {
 
209
        fail1:
 
210
            av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n");
 
211
            goto skip;
 
212
        }
 
213
        st->codec->codec_tag = get_le32(pb);
 
214
//        av_log(NULL, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0'));
 
215
        if (   st->codec->codec_tag != MKTAG('R', 'V', '1', '0')
 
216
            && st->codec->codec_tag != MKTAG('R', 'V', '2', '0')
 
217
            && st->codec->codec_tag != MKTAG('R', 'V', '3', '0')
 
218
            && st->codec->codec_tag != MKTAG('R', 'V', '4', '0'))
 
219
            goto fail1;
 
220
        st->codec->width = get_be16(pb);
 
221
        st->codec->height = get_be16(pb);
 
222
        st->codec->time_base.num= 1;
 
223
        fps= get_be16(pb);
 
224
        st->codec->codec_type = CODEC_TYPE_VIDEO;
 
225
        get_be32(pb);
 
226
        fps2= get_be16(pb);
 
227
        get_be16(pb);
 
228
 
 
229
        st->codec->extradata_size= codec_data_size - (url_ftell(pb) - codec_pos);
 
230
 
 
231
        if(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)st->codec->extradata_size){
 
232
            //check is redundant as get_buffer() will catch this
 
233
            av_log(s, AV_LOG_ERROR, "st->codec->extradata_size too large\n");
 
234
            return -1;
 
235
        }
 
236
        st->codec->extradata= av_mallocz(st->codec->extradata_size + FF_INPUT_BUFFER_PADDING_SIZE);
 
237
        get_buffer(pb, st->codec->extradata, st->codec->extradata_size);
 
238
 
 
239
//        av_log(NULL, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2);
 
240
        st->codec->time_base.den = fps * st->codec->time_base.num;
 
241
        switch(((uint8_t*)st->codec->extradata)[4]>>4){
 
242
        case 1: st->codec->codec_id = CODEC_ID_RV10; break;
 
243
        case 2: st->codec->codec_id = CODEC_ID_RV20; break;
 
244
        case 3: st->codec->codec_id = CODEC_ID_RV30; break;
 
245
        case 4: st->codec->codec_id = CODEC_ID_RV40; break;
 
246
        default: goto fail1;
 
247
        }
 
248
    }
 
249
 
 
250
skip:
 
251
    /* skip codec info */
 
252
    size = url_ftell(pb) - codec_pos;
 
253
    url_fskip(pb, codec_data_size - size);
 
254
 
 
255
    return 0;
 
256
}
 
257
 
 
258
 
 
259
static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap)
 
260
{
 
261
    RMContext *rm = s->priv_data;
 
262
    AVStream *st;
 
263
 
 
264
    rm->old_format = 1;
 
265
    st = av_new_stream(s, 0);
 
266
    if (!st)
 
267
        return -1;
 
268
    return rm_read_audio_stream_info(s, st, 1);
 
269
}
 
270
 
 
271
static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap)
 
272
{
 
273
    RMContext *rm = s->priv_data;
 
274
    AVStream *st;
 
275
    ByteIOContext *pb = s->pb;
 
276
    unsigned int tag;
 
277
    int tag_size, i;
 
278
    unsigned int start_time, duration;
 
279
    char buf[128];
 
280
    int flags = 0;
 
281
 
 
282
    tag = get_le32(pb);
 
283
    if (tag == MKTAG('.', 'r', 'a', 0xfd)) {
 
284
        /* very old .ra format */
 
285
        return rm_read_header_old(s, ap);
 
286
    } else if (tag != MKTAG('.', 'R', 'M', 'F')) {
 
287
        return AVERROR(EIO);
 
288
    }
 
289
 
 
290
    get_be32(pb); /* header size */
 
291
    get_be16(pb);
 
292
    get_be32(pb);
 
293
    get_be32(pb); /* number of headers */
 
294
 
 
295
    for(;;) {
 
296
        if (url_feof(pb))
 
297
            goto fail;
 
298
        tag = get_le32(pb);
 
299
        tag_size = get_be32(pb);
 
300
        get_be16(pb);
 
301
#if 0
 
302
        printf("tag=%c%c%c%c (%08x) size=%d\n",
 
303
               (tag) & 0xff,
 
304
               (tag >> 8) & 0xff,
 
305
               (tag >> 16) & 0xff,
 
306
               (tag >> 24) & 0xff,
 
307
               tag,
 
308
               tag_size);
 
309
#endif
 
310
        if (tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A'))
 
311
            goto fail;
 
312
        switch(tag) {
 
313
        case MKTAG('P', 'R', 'O', 'P'):
 
314
            /* file header */
 
315
            get_be32(pb); /* max bit rate */
 
316
            get_be32(pb); /* avg bit rate */
 
317
            get_be32(pb); /* max packet size */
 
318
            get_be32(pb); /* avg packet size */
 
319
            get_be32(pb); /* nb packets */
 
320
            get_be32(pb); /* duration */
 
321
            get_be32(pb); /* preroll */
 
322
            get_be32(pb); /* index offset */
 
323
            get_be32(pb); /* data offset */
 
324
            get_be16(pb); /* nb streams */
 
325
            flags = get_be16(pb); /* flags */
 
326
            break;
 
327
        case MKTAG('C', 'O', 'N', 'T'):
 
328
            get_str16(pb, s->title, sizeof(s->title));
 
329
            get_str16(pb, s->author, sizeof(s->author));
 
330
            get_str16(pb, s->copyright, sizeof(s->copyright));
 
331
            get_str16(pb, s->comment, sizeof(s->comment));
 
332
            break;
 
333
        case MKTAG('M', 'D', 'P', 'R'):
 
334
            st = av_new_stream(s, 0);
 
335
            if (!st)
 
336
                goto fail;
 
337
            st->id = get_be16(pb);
 
338
            get_be32(pb); /* max bit rate */
 
339
            st->codec->bit_rate = get_be32(pb); /* bit rate */
 
340
            get_be32(pb); /* max packet size */
 
341
            get_be32(pb); /* avg packet size */
 
342
            start_time = get_be32(pb); /* start time */
 
343
            get_be32(pb); /* preroll */
 
344
            duration = get_be32(pb); /* duration */
 
345
            st->start_time = start_time;
 
346
            st->duration = duration;
 
347
            get_str8(pb, buf, sizeof(buf)); /* desc */
 
348
            get_str8(pb, buf, sizeof(buf)); /* mimetype */
 
349
            st->codec->codec_type = CODEC_TYPE_DATA;
 
350
            av_set_pts_info(st, 64, 1, 1000);
 
351
            if (ff_rm_read_mdpr_codecdata(s, st) < 0)
 
352
                return -1;
 
353
            break;
 
354
        case MKTAG('D', 'A', 'T', 'A'):
 
355
            goto header_end;
 
356
        default:
 
357
            /* unknown tag: skip it */
 
358
            url_fskip(pb, tag_size - 10);
 
359
            break;
 
360
        }
 
361
    }
 
362
 header_end:
 
363
    rm->nb_packets = get_be32(pb); /* number of packets */
 
364
    if (!rm->nb_packets && (flags & 4))
 
365
        rm->nb_packets = 3600 * 25;
 
366
    get_be32(pb); /* next data header */
 
367
    rm->curpic_num = -1;
 
368
    return 0;
 
369
 
 
370
 fail:
 
371
    for(i=0;i<s->nb_streams;i++) {
 
372
        av_free(s->streams[i]);
 
373
    }
 
374
    return AVERROR(EIO);
 
375
}
 
376
 
 
377
static int get_num(ByteIOContext *pb, int *len)
 
378
{
 
379
    int n, n1;
 
380
 
 
381
    n = get_be16(pb);
 
382
    (*len)-=2;
 
383
    n &= 0x7FFF;
 
384
    if (n >= 0x4000) {
 
385
        return n - 0x4000;
 
386
    } else {
 
387
        n1 = get_be16(pb);
 
388
        (*len)-=2;
 
389
        return (n << 16) | n1;
 
390
    }
 
391
}
 
392
 
 
393
/* multiple of 20 bytes for ra144 (ugly) */
 
394
#define RAW_PACKET_SIZE 1000
 
395
 
 
396
static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){
 
397
    RMContext *rm = s->priv_data;
 
398
    ByteIOContext *pb = s->pb;
 
399
    int len, num, res, i;
 
400
    AVStream *st;
 
401
    uint32_t state=0xFFFFFFFF;
 
402
 
 
403
    while(!url_feof(pb)){
 
404
        *pos= url_ftell(pb) - 3;
 
405
        if(rm->remaining_len > 0){
 
406
            num= rm->current_stream;
 
407
            len= rm->remaining_len;
 
408
            *timestamp = AV_NOPTS_VALUE;
 
409
            *flags= 0;
 
410
        }else{
 
411
            state= (state<<8) + get_byte(pb);
 
412
 
 
413
            if(state == MKBETAG('I', 'N', 'D', 'X')){
 
414
                len = get_be16(pb) - 6;
 
415
                if(len<0)
 
416
                    continue;
 
417
                goto skip;
 
418
            }
 
419
 
 
420
            if(state > (unsigned)0xFFFF || state < 12)
 
421
                continue;
 
422
            len=state;
 
423
            state= 0xFFFFFFFF;
 
424
 
 
425
            num = get_be16(pb);
 
426
            *timestamp = get_be32(pb);
 
427
            res= get_byte(pb); /* reserved */
 
428
            *flags = get_byte(pb); /* flags */
 
429
 
 
430
 
 
431
            len -= 12;
 
432
        }
 
433
        for(i=0;i<s->nb_streams;i++) {
 
434
            st = s->streams[i];
 
435
            if (num == st->id)
 
436
                break;
 
437
        }
 
438
        if (i == s->nb_streams) {
 
439
skip:
 
440
            /* skip packet if unknown number */
 
441
            url_fskip(pb, len);
 
442
            rm->remaining_len -= len;
 
443
            continue;
 
444
        }
 
445
        *stream_index= i;
 
446
 
 
447
        return len;
 
448
    }
 
449
    return -1;
 
450
}
 
451
 
 
452
static int rm_assemble_video_frame(AVFormatContext *s, RMContext *rm, AVPacket *pkt, int len)
 
453
{
 
454
    ByteIOContext *pb = s->pb;
 
455
    int hdr, seq, pic_num, len2, pos;
 
456
    int type;
 
457
 
 
458
    hdr = get_byte(pb); len--;
 
459
    type = hdr >> 6;
 
460
    switch(type){
 
461
    case 0: // slice
 
462
    case 2: // last slice
 
463
        seq = get_byte(pb); len--;
 
464
        len2 = get_num(pb, &len);
 
465
        pos = get_num(pb, &len);
 
466
        pic_num = get_byte(pb); len--;
 
467
        rm->remaining_len = len;
 
468
        break;
 
469
    case 1: //whole frame
 
470
        seq = get_byte(pb); len--;
 
471
        if(av_new_packet(pkt, len + 9) < 0)
 
472
            return AVERROR(EIO);
 
473
        pkt->data[0] = 0;
 
474
        AV_WL32(pkt->data + 1, 1);
 
475
        AV_WL32(pkt->data + 5, 0);
 
476
        get_buffer(pb, pkt->data + 9, len);
 
477
        rm->remaining_len = 0;
 
478
        return 0;
 
479
    case 3: //frame as a part of packet
 
480
        len2 = get_num(pb, &len);
 
481
        pos = get_num(pb, &len);
 
482
        pic_num = get_byte(pb); len--;
 
483
        rm->remaining_len = len - len2;
 
484
        if(av_new_packet(pkt, len2 + 9) < 0)
 
485
            return AVERROR(EIO);
 
486
        pkt->data[0] = 0;
 
487
        AV_WL32(pkt->data + 1, 1);
 
488
        AV_WL32(pkt->data + 5, 0);
 
489
        get_buffer(pb, pkt->data + 9, len2);
 
490
        return 0;
 
491
    }
 
492
    //now we have to deal with single slice
 
493
 
 
494
    if((seq & 0x7F) == 1 || rm->curpic_num != pic_num){
 
495
        rm->slices = ((hdr & 0x3F) << 1) + 1;
 
496
        rm->videobufsize = len2 + 8*rm->slices + 1;
 
497
        av_free(rm->videobuf);
 
498
        if(!(rm->videobuf = av_malloc(rm->videobufsize)))
 
499
            return AVERROR(ENOMEM);
 
500
        rm->videobufpos = 8*rm->slices + 1;
 
501
        rm->cur_slice = 0;
 
502
        rm->curpic_num = pic_num;
 
503
        rm->pktpos = url_ftell(pb);
 
504
    }
 
505
    if(type == 2)
 
506
        len = FFMIN(len, pos);
 
507
 
 
508
    if(++rm->cur_slice > rm->slices)
 
509
        return 1;
 
510
    AV_WL32(rm->videobuf - 7 + 8*rm->cur_slice, 1);
 
511
    AV_WL32(rm->videobuf - 3 + 8*rm->cur_slice, rm->videobufpos - 8*rm->slices - 1);
 
512
    if(rm->videobufpos + len > rm->videobufsize)
 
513
        return 1;
 
514
    if (get_buffer(pb, rm->videobuf + rm->videobufpos, len) != len)
 
515
        return AVERROR(EIO);
 
516
    rm->videobufpos += len;
 
517
    rm->remaining_len-= len;
 
518
 
 
519
    if(type == 2 || (rm->videobufpos) == rm->videobufsize){
 
520
         rm->videobuf[0] = rm->cur_slice-1;
 
521
         if(av_new_packet(pkt, rm->videobufpos - 8*(rm->slices - rm->cur_slice)) < 0)
 
522
             return AVERROR(ENOMEM);
 
523
         memcpy(pkt->data, rm->videobuf, 1 + 8*rm->cur_slice);
 
524
         memcpy(pkt->data + 1 + 8*rm->cur_slice, rm->videobuf + 1 + 8*rm->slices,
 
525
                rm->videobufpos - 1 - 8*rm->slices);
 
526
         pkt->pts = AV_NOPTS_VALUE;
 
527
         pkt->pos = rm->pktpos;
 
528
         return 0;
 
529
    }
 
530
 
 
531
    return 1;
 
532
}
 
533
 
 
534
static inline void
 
535
rm_ac3_swap_bytes (AVStream *st, AVPacket *pkt)
 
536
{
 
537
    uint8_t *ptr;
 
538
    int j;
 
539
 
 
540
    if (st->codec->codec_id == CODEC_ID_AC3) {
 
541
        ptr = pkt->data;
 
542
        for (j=0;j<pkt->size;j+=2) {
 
543
            FFSWAP(int, ptr[0], ptr[1]);
 
544
            ptr += 2;
 
545
        }
 
546
    }
 
547
}
 
548
 
 
549
int
 
550
ff_rm_parse_packet (AVFormatContext *s, AVStream *st, int len, AVPacket *pkt,
 
551
                    int *seq, int *flags, int64_t *timestamp)
 
552
{
 
553
    ByteIOContext *pb = s->pb;
 
554
    RMContext *rm = s->priv_data;
 
555
 
 
556
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
 
557
        rm->current_stream= st->id;
 
558
        if(rm_assemble_video_frame(s, rm, pkt, len) == 1)
 
559
            return -1; //got partial frame
 
560
    } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
 
561
        if ((st->codec->codec_id == CODEC_ID_RA_288) ||
 
562
            (st->codec->codec_id == CODEC_ID_COOK) ||
 
563
            (st->codec->codec_id == CODEC_ID_ATRAC3)) {
 
564
            int x;
 
565
            int sps = rm->sub_packet_size;
 
566
            int cfs = rm->coded_framesize;
 
567
            int h = rm->sub_packet_h;
 
568
            int y = rm->sub_packet_cnt;
 
569
            int w = rm->audio_framesize;
 
570
 
 
571
            if (*flags & 2)
 
572
                y = rm->sub_packet_cnt = 0;
 
573
            if (!y)
 
574
                rm->audiotimestamp = *timestamp;
 
575
 
 
576
            switch(st->codec->codec_id) {
 
577
                case CODEC_ID_RA_288:
 
578
                    for (x = 0; x < h/2; x++)
 
579
                        get_buffer(pb, rm->audiobuf+x*2*w+y*cfs, cfs);
 
580
                    break;
 
581
                case CODEC_ID_ATRAC3:
 
582
                case CODEC_ID_COOK:
 
583
                    for (x = 0; x < w/sps; x++)
 
584
                        get_buffer(pb, rm->audiobuf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
 
585
                    break;
 
586
            }
 
587
 
 
588
            if (++(rm->sub_packet_cnt) < h)
 
589
                return -1;
 
590
            else {
 
591
                rm->sub_packet_cnt = 0;
 
592
                rm->audio_stream_num = st->index;
 
593
                rm->audio_pkt_cnt = h * w / st->codec->block_align - 1;
 
594
                // Release first audio packet
 
595
                av_new_packet(pkt, st->codec->block_align);
 
596
                memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
 
597
                *timestamp = rm->audiotimestamp;
 
598
                *flags = 2; // Mark first packet as keyframe
 
599
            }
 
600
        } else if (st->codec->codec_id == CODEC_ID_AAC) {
 
601
            int x;
 
602
            rm->audio_stream_num = st->index;
 
603
            rm->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4;
 
604
            if (rm->sub_packet_cnt) {
 
605
                for (x = 0; x < rm->sub_packet_cnt; x++)
 
606
                    rm->sub_packet_lengths[x] = get_be16(pb);
 
607
                // Release first audio packet
 
608
                rm->audio_pkt_cnt = rm->sub_packet_cnt - 1;
 
609
                av_get_packet(pb, pkt, rm->sub_packet_lengths[0]);
 
610
                *flags = 2; // Mark first packet as keyframe
 
611
            }
 
612
        } else {
 
613
            av_get_packet(pb, pkt, len);
 
614
            rm_ac3_swap_bytes(st, pkt);
 
615
        }
 
616
    } else
 
617
        av_get_packet(pb, pkt, len);
 
618
 
 
619
    if(  (st->discard >= AVDISCARD_NONKEY && !(*flags&2))
 
620
       || st->discard >= AVDISCARD_ALL){
 
621
        av_free_packet(pkt);
 
622
        return -1;
 
623
    }
 
624
 
 
625
    pkt->stream_index = st->index;
 
626
 
 
627
#if 0
 
628
    if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
 
629
        if(st->codec->codec_id == CODEC_ID_RV20){
 
630
            int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
 
631
            av_log(NULL, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq);
 
632
 
 
633
            seq |= (*timestamp&~0x3FFF);
 
634
            if(seq - *timestamp >  0x2000) seq -= 0x4000;
 
635
            if(seq - *timestamp < -0x2000) seq += 0x4000;
 
636
        }
 
637
    }
 
638
#endif
 
639
 
 
640
    pkt->pts= *timestamp;
 
641
    if (*flags & 2)
 
642
        pkt->flags |= PKT_FLAG_KEY;
 
643
 
 
644
    return 0;
 
645
}
 
646
 
 
647
void
 
648
ff_rm_retrieve_cache (AVFormatContext *s, AVStream *st, AVPacket *pkt)
 
649
{
 
650
    ByteIOContext *pb = s->pb;
 
651
    RMContext *rm = s->priv_data;
 
652
 
 
653
    assert (rm->audio_pkt_cnt > 0);
 
654
 
 
655
    if (st->codec->codec_id == CODEC_ID_AAC)
 
656
        av_get_packet(pb, pkt, rm->sub_packet_lengths[rm->sub_packet_cnt - rm->audio_pkt_cnt]);
 
657
    else {
 
658
        av_new_packet(pkt, st->codec->block_align);
 
659
        memcpy(pkt->data, rm->audiobuf + st->codec->block_align *
 
660
               (rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - rm->audio_pkt_cnt),
 
661
               st->codec->block_align);
 
662
    }
 
663
    rm->audio_pkt_cnt--;
 
664
    pkt->flags = 0;
 
665
    pkt->stream_index = st->index;
 
666
}
 
667
 
 
668
static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
 
669
{
 
670
    RMContext *rm = s->priv_data;
 
671
    ByteIOContext *pb = s->pb;
 
672
    AVStream *st;
 
673
    int i, len;
 
674
    int64_t timestamp, pos;
 
675
    int flags;
 
676
 
 
677
    if (rm->audio_pkt_cnt) {
 
678
        // If there are queued audio packet return them first
 
679
        st = s->streams[rm->audio_stream_num];
 
680
        ff_rm_retrieve_cache(s, st, pkt);
 
681
    } else if (rm->old_format) {
 
682
        st = s->streams[0];
 
683
        if (st->codec->codec_id == CODEC_ID_RA_288) {
 
684
            int x, y;
 
685
 
 
686
            for (y = 0; y < rm->sub_packet_h; y++)
 
687
                for (x = 0; x < rm->sub_packet_h/2; x++)
 
688
                    if (get_buffer(pb, rm->audiobuf+x*2*rm->audio_framesize+y*rm->coded_framesize, rm->coded_framesize) <= 0)
 
689
                        return AVERROR(EIO);
 
690
            rm->audio_stream_num = 0;
 
691
            rm->audio_pkt_cnt = rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - 1;
 
692
            // Release first audio packet
 
693
            av_new_packet(pkt, st->codec->block_align);
 
694
            memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
 
695
            pkt->flags |= PKT_FLAG_KEY; // Mark first packet as keyframe
 
696
            pkt->stream_index = 0;
 
697
        } else {
 
698
            /* just read raw bytes */
 
699
            len = RAW_PACKET_SIZE;
 
700
            len= av_get_packet(pb, pkt, len);
 
701
            pkt->stream_index = 0;
 
702
            if (len <= 0) {
 
703
                return AVERROR(EIO);
 
704
            }
 
705
            pkt->size = len;
 
706
        }
 
707
        rm_ac3_swap_bytes(st, pkt);
 
708
    } else {
 
709
        int seq=1;
 
710
resync:
 
711
        len=sync(s, &timestamp, &flags, &i, &pos);
 
712
        if(len<0)
 
713
            return AVERROR(EIO);
 
714
        st = s->streams[i];
 
715
 
 
716
        if (ff_rm_parse_packet (s, st, len, pkt, &seq, &flags, &timestamp) < 0)
 
717
            goto resync;
 
718
 
 
719
        if((flags&2) && (seq&0x7F) == 1)
 
720
            av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
 
721
    }
 
722
 
 
723
    return 0;
 
724
}
 
725
 
 
726
static int rm_read_close(AVFormatContext *s)
 
727
{
 
728
    RMContext *rm = s->priv_data;
 
729
 
 
730
    av_free(rm->audiobuf);
 
731
    av_free(rm->videobuf);
 
732
    return 0;
 
733
}
 
734
 
 
735
static int rm_probe(AVProbeData *p)
 
736
{
 
737
    /* check file header */
 
738
    if ((p->buf[0] == '.' && p->buf[1] == 'R' &&
 
739
         p->buf[2] == 'M' && p->buf[3] == 'F' &&
 
740
         p->buf[4] == 0 && p->buf[5] == 0) ||
 
741
        (p->buf[0] == '.' && p->buf[1] == 'r' &&
 
742
         p->buf[2] == 'a' && p->buf[3] == 0xfd))
 
743
        return AVPROBE_SCORE_MAX;
 
744
    else
 
745
        return 0;
 
746
}
 
747
 
 
748
static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
 
749
                               int64_t *ppos, int64_t pos_limit)
 
750
{
 
751
    RMContext *rm = s->priv_data;
 
752
    int64_t pos, dts;
 
753
    int stream_index2, flags, len, h;
 
754
 
 
755
    pos = *ppos;
 
756
 
 
757
    if(rm->old_format)
 
758
        return AV_NOPTS_VALUE;
 
759
 
 
760
    url_fseek(s->pb, pos, SEEK_SET);
 
761
    rm->remaining_len=0;
 
762
    for(;;){
 
763
        int seq=1;
 
764
        AVStream *st;
 
765
 
 
766
        len=sync(s, &dts, &flags, &stream_index2, &pos);
 
767
        if(len<0)
 
768
            return AV_NOPTS_VALUE;
 
769
 
 
770
        st = s->streams[stream_index2];
 
771
        if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
 
772
            h= get_byte(s->pb); len--;
 
773
            if(!(h & 0x40)){
 
774
                seq = get_byte(s->pb); len--;
 
775
            }
 
776
        }
 
777
 
 
778
        if((flags&2) && (seq&0x7F) == 1){
 
779
//            av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq);
 
780
            av_add_index_entry(st, pos, dts, 0, 0, AVINDEX_KEYFRAME);
 
781
            if(stream_index2 == stream_index)
 
782
                break;
 
783
        }
 
784
 
 
785
        url_fskip(s->pb, len);
 
786
    }
 
787
    *ppos = pos;
 
788
    return dts;
 
789
}
 
790
 
 
791
AVInputFormat rm_demuxer = {
 
792
    "rm",
 
793
    "rm format",
 
794
    sizeof(RMContext),
 
795
    rm_probe,
 
796
    rm_read_header,
 
797
    rm_read_packet,
 
798
    rm_read_close,
 
799
    NULL,
 
800
    rm_read_dts,
 
801
};