Split out the packet parsing from the main function body in rmdec.c
[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 #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 static 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);
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     int ssize;
458
459     hdr = get_byte(pb); len--;
460     type = hdr >> 6;
461     switch(type){
462     case 0: // slice
463     case 2: // last slice
464         seq = get_byte(pb); len--;
465         len2 = get_num(pb, &len);
466         pos = get_num(pb, &len);
467         pic_num = get_byte(pb); len--;
468         rm->remaining_len = len;
469         break;
470     case 1: //whole frame
471         seq = get_byte(pb); len--;
472         if(av_new_packet(pkt, len + 9) < 0)
473             return AVERROR(EIO);
474         pkt->data[0] = 0;
475         AV_WL32(pkt->data + 1, 1);
476         AV_WL32(pkt->data + 5, 0);
477         get_buffer(pb, pkt->data + 9, len);
478         rm->remaining_len = 0;
479         return 0;
480     case 3: //frame as a part of packet
481         len2 = get_num(pb, &len);
482         pos = get_num(pb, &len);
483         pic_num = get_byte(pb); len--;
484         rm->remaining_len = len - len2;
485         if(av_new_packet(pkt, len2 + 9) < 0)
486             return AVERROR(EIO);
487         pkt->data[0] = 0;
488         AV_WL32(pkt->data + 1, 1);
489         AV_WL32(pkt->data + 5, 0);
490         get_buffer(pb, pkt->data + 9, len2);
491         return 0;
492     }
493     //now we have to deal with single slice
494
495     if((seq & 0x7F) == 1 || rm->curpic_num != pic_num){
496         rm->slices = ((hdr & 0x3F) << 1) + 1;
497         ssize = len2 + 8*rm->slices + 1;
498         rm->videobuf = av_realloc(rm->videobuf, ssize);
499         rm->videobufsize = ssize;
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         pos = len2 - pos;
508     }
509
510     if(++rm->cur_slice > rm->cur_slice)
511         return 1;
512     AV_WL32(rm->videobuf - 7 + 8*rm->cur_slice, 1);
513     AV_WL32(rm->videobuf - 3 + 8*rm->cur_slice, rm->videobufpos - 8*rm->slices - 1);
514     if(rm->videobufpos + len > rm->videobufsize)
515         return 1;
516     if (get_buffer(pb, rm->videobuf + rm->videobufpos, len) != len)
517         return AVERROR(EIO);
518     rm->videobufpos += len,
519     rm->remaining_len-= len;
520
521     if(type == 2 || (rm->videobufpos) == rm->videobufsize){
522          //adjust slice headers
523          memmove(rm->videobuf + 1 + 8*rm->cur_slice, rm->videobuf + 1 + 8*rm->slices, rm->videobufsize - 1 - 8*rm->slices);
524          ssize = rm->videobufsize - 8*(rm->slices - rm->cur_slice);
525
526          rm->videobuf[0] = rm->cur_slice-1;
527          if(av_new_packet(pkt, ssize) < 0)
528              return AVERROR(ENOMEM);
529          memcpy(pkt->data, rm->videobuf, ssize);
530          pkt->pts = AV_NOPTS_VALUE;
531          pkt->pos = rm->pktpos;
532          return 0;
533     }
534
535     return 1;
536 }
537
538 static int
539 ff_rm_parse_packet (AVFormatContext *s, AVStream *st, int len, AVPacket *pkt,
540                     int *seq, int *flags, int64_t *timestamp)
541 {
542     ByteIOContext *pb = &s->pb;
543     RMContext *rm = s->priv_data;
544
545     if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
546         rm->current_stream= st->id;
547         if(rm_assemble_video_frame(s, rm, pkt, len) == 1)
548             return -1; //got partial frame
549     } else if (st->codec->codec_type == CODEC_TYPE_AUDIO) {
550         if ((st->codec->codec_id == CODEC_ID_RA_288) ||
551             (st->codec->codec_id == CODEC_ID_COOK) ||
552             (st->codec->codec_id == CODEC_ID_ATRAC3)) {
553             int x;
554             int sps = rm->sub_packet_size;
555             int cfs = rm->coded_framesize;
556             int h = rm->sub_packet_h;
557             int y = rm->sub_packet_cnt;
558             int w = rm->audio_framesize;
559
560             if (*flags & 2)
561                 y = rm->sub_packet_cnt = 0;
562             if (!y)
563                 rm->audiotimestamp = *timestamp;
564
565             switch(st->codec->codec_id) {
566                 case CODEC_ID_RA_288:
567                     for (x = 0; x < h/2; x++)
568                         get_buffer(pb, rm->audiobuf+x*2*w+y*cfs, cfs);
569                     break;
570                 case CODEC_ID_ATRAC3:
571                 case CODEC_ID_COOK:
572                     for (x = 0; x < w/sps; x++)
573                         get_buffer(pb, rm->audiobuf+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps);
574                     break;
575             }
576
577             if (++(rm->sub_packet_cnt) < h)
578                 return -1;
579             else {
580                 rm->sub_packet_cnt = 0;
581                 rm->audio_stream_num = st->index;
582                 rm->audio_pkt_cnt = h * w / st->codec->block_align - 1;
583                 // Release first audio packet
584                 av_new_packet(pkt, st->codec->block_align);
585                 memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
586                 *timestamp = rm->audiotimestamp;
587                 *flags = 2; // Mark first packet as keyframe
588             }
589         } else if (st->codec->codec_id == CODEC_ID_AAC) {
590             int x;
591             rm->audio_stream_num = st->index;
592             rm->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4;
593             if (rm->sub_packet_cnt) {
594                 for (x = 0; x < rm->sub_packet_cnt; x++)
595                     rm->sub_packet_lengths[x] = get_be16(pb);
596                 // Release first audio packet
597                 rm->audio_pkt_cnt = rm->sub_packet_cnt - 1;
598                 av_get_packet(pb, pkt, rm->sub_packet_lengths[0]);
599                 *flags = 2; // Mark first packet as keyframe
600             }
601         } else
602             av_get_packet(pb, pkt, len);
603
604     } else
605         av_get_packet(pb, pkt, len);
606
607     if(  (st->discard >= AVDISCARD_NONKEY && !(*flags&2))
608        || st->discard >= AVDISCARD_ALL){
609         av_free_packet(pkt);
610         return -1;
611     }
612
613     pkt->stream_index = st->index;
614
615 #if 0
616     if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
617         if(st->codec->codec_id == CODEC_ID_RV20){
618             int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1);
619             av_log(NULL, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq);
620
621             seq |= (*timestamp&~0x3FFF);
622             if(seq - *timestamp >  0x2000) seq -= 0x4000;
623             if(seq - *timestamp < -0x2000) seq += 0x4000;
624         }
625     }
626 #endif
627
628     pkt->pts= *timestamp;
629     if (*flags & 2)
630         pkt->flags |= PKT_FLAG_KEY;
631
632     return 0;
633 }
634
635 static int rm_read_packet(AVFormatContext *s, AVPacket *pkt)
636 {
637     RMContext *rm = s->priv_data;
638     ByteIOContext *pb = &s->pb;
639     AVStream *st;
640     int i, len, j;
641     int64_t timestamp, pos;
642     uint8_t *ptr;
643     int flags;
644
645     if (rm->audio_pkt_cnt) {
646         // If there are queued audio packet return them first
647         st = s->streams[rm->audio_stream_num];
648         if (st->codec->codec_id == CODEC_ID_AAC)
649             av_get_packet(pb, pkt, rm->sub_packet_lengths[rm->sub_packet_cnt - rm->audio_pkt_cnt]);
650         else {
651         av_new_packet(pkt, st->codec->block_align);
652         memcpy(pkt->data, rm->audiobuf + st->codec->block_align *
653                (rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - rm->audio_pkt_cnt),
654                st->codec->block_align);
655         }
656         rm->audio_pkt_cnt--;
657         pkt->flags = 0;
658         pkt->stream_index = rm->audio_stream_num;
659     } else if (rm->old_format) {
660         st = s->streams[0];
661         if (st->codec->codec_id == CODEC_ID_RA_288) {
662             int x, y;
663
664             for (y = 0; y < rm->sub_packet_h; y++)
665                 for (x = 0; x < rm->sub_packet_h/2; x++)
666                     if (get_buffer(pb, rm->audiobuf+x*2*rm->audio_framesize+y*rm->coded_framesize, rm->coded_framesize) <= 0)
667                         return AVERROR(EIO);
668             rm->audio_stream_num = 0;
669             rm->audio_pkt_cnt = rm->sub_packet_h * rm->audio_framesize / st->codec->block_align - 1;
670             // Release first audio packet
671             av_new_packet(pkt, st->codec->block_align);
672             memcpy(pkt->data, rm->audiobuf, st->codec->block_align);
673             pkt->flags |= PKT_FLAG_KEY; // Mark first packet as keyframe
674             pkt->stream_index = 0;
675         } else {
676             /* just read raw bytes */
677             len = RAW_PACKET_SIZE;
678             len= av_get_packet(pb, pkt, len);
679             pkt->stream_index = 0;
680             if (len <= 0) {
681                 return AVERROR(EIO);
682             }
683             pkt->size = len;
684         }
685     } else {
686         int seq=1;
687 resync:
688         len=sync(s, &timestamp, &flags, &i, &pos);
689         if(len<0)
690             return AVERROR(EIO);
691         st = s->streams[i];
692
693         if (ff_rm_parse_packet (s, st, len, pkt, &seq, &flags, &timestamp) < 0)
694             goto resync;
695
696         if(flags&2){
697             if((seq&0x7F) == 1)
698                 av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME);
699         }
700     }
701
702     /* for AC3, needs to swap bytes */
703     if (st->codec->codec_id == CODEC_ID_AC3) {
704         ptr = pkt->data;
705         for(j=0;j<pkt->size;j+=2) {
706             FFSWAP(int, ptr[0], ptr[1]);
707             ptr += 2;
708         }
709     }
710     return 0;
711 }
712
713 static int rm_read_close(AVFormatContext *s)
714 {
715     RMContext *rm = s->priv_data;
716
717     av_free(rm->audiobuf);
718     av_free(rm->videobuf);
719     return 0;
720 }
721
722 static int rm_probe(AVProbeData *p)
723 {
724     /* check file header */
725     if ((p->buf[0] == '.' && p->buf[1] == 'R' &&
726          p->buf[2] == 'M' && p->buf[3] == 'F' &&
727          p->buf[4] == 0 && p->buf[5] == 0) ||
728         (p->buf[0] == '.' && p->buf[1] == 'r' &&
729          p->buf[2] == 'a' && p->buf[3] == 0xfd))
730         return AVPROBE_SCORE_MAX;
731     else
732         return 0;
733 }
734
735 static int64_t rm_read_dts(AVFormatContext *s, int stream_index,
736                                int64_t *ppos, int64_t pos_limit)
737 {
738     RMContext *rm = s->priv_data;
739     int64_t pos, dts;
740     int stream_index2, flags, len, h;
741
742     pos = *ppos;
743
744     if(rm->old_format)
745         return AV_NOPTS_VALUE;
746
747     url_fseek(&s->pb, pos, SEEK_SET);
748     rm->remaining_len=0;
749     for(;;){
750         int seq=1;
751         AVStream *st;
752
753         len=sync(s, &dts, &flags, &stream_index2, &pos);
754         if(len<0)
755             return AV_NOPTS_VALUE;
756
757         st = s->streams[stream_index2];
758         if (st->codec->codec_type == CODEC_TYPE_VIDEO) {
759             h= get_byte(&s->pb); len--;
760             if(!(h & 0x40)){
761                 seq = get_byte(&s->pb); len--;
762             }
763         }
764
765         if((flags&2) && (seq&0x7F) == 1){
766 //            av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq);
767             av_add_index_entry(st, pos, dts, 0, 0, AVINDEX_KEYFRAME);
768             if(stream_index2 == stream_index)
769                 break;
770         }
771
772         url_fskip(&s->pb, len);
773     }
774     *ppos = pos;
775     return dts;
776 }
777
778 AVInputFormat rm_demuxer = {
779     "rm",
780     "rm format",
781     sizeof(RMContext),
782     rm_probe,
783     rm_read_header,
784     rm_read_packet,
785     rm_read_close,
786     NULL,
787     rm_read_dts,
788 };