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