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