2 * "Real" compatible demuxer.
3 * Copyright (c) 2000, 2001 Fabrice Bellard
5 * This file is part of FFmpeg.
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.
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.
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
22 #include "libavutil/avstring.h"
23 #include "libavutil/intreadwrite.h"
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
47 int audio_stream_num
; ///< Stream number for audio packets
48 int audio_pkt_cnt
; ///< Output packet counter
51 static inline void get_strl(ByteIOContext
*pb
, char *buf
, int buf_size
, int len
)
62 if (buf_size
> 0) *q
= '\0';
65 static void get_str8(ByteIOContext
*pb
, char *buf
, int buf_size
)
67 get_strl(pb
, buf
, buf_size
, get_byte(pb
));
70 static void rm_read_metadata(AVFormatContext
*s
, int wide
)
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
);
81 RMStream
*ff_rm_alloc_rmstream (void)
83 RMStream
*rms
= av_mallocz(sizeof(RMStream
));
88 void ff_rm_free_rmstream (RMStream
*rms
)
90 av_free_packet(&rms
->pkt
);
93 static int rm_read_audio_stream_info(AVFormatContext
*s
, ByteIOContext
*pb
,
94 AVStream
*st
, RMStream
*ast
, int read_all
)
100 version
= get_be32(pb
); /* version */
101 if (((version
>> 16) & 0xff) == 3) {
102 int64_t startpos
= url_ftell(pb
);
104 rm_read_metadata(s
, 0);
105 if ((startpos
+ (version
& 0xffff)) >= url_ftell(pb
) + 2) {
106 // fourcc (should always be "lpcJ")
108 get_str8(pb
, buf
, sizeof(buf
));
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
;
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
);
136 st
->codec
->sample_rate
= get_be16(pb
);
138 st
->codec
->channels
= get_be16(pb
);
139 if (((version
>> 16) & 0xff) == 5) {
141 get_buffer(pb
, buf
, 4);
144 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
145 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
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
;
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");
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)
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");
174 if(sub_packet_size
<= 0){
175 av_log(s
, AV_LOG_ERROR
, "sub_packet_size is invalid\n");
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
;
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");
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)
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");
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
);
209 get_buffer(pb
, st
->codec
->extradata
, st
->codec
->extradata_size
);
212 st
->codec
->codec_id
= CODEC_ID_NONE
;
213 av_strlcpy(st
->codec
->codec_name
, buf
, sizeof(st
->codec
->codec_name
));
219 rm_read_metadata(s
, 0);
226 ff_rm_read_mdpr_codecdata (AVFormatContext
*s
, ByteIOContext
*pb
,
227 AVStream
*st
, RMStream
*rst
, int codec_data_size
)
233 av_set_pts_info(st
, 64, 1, 1000);
234 codec_pos
= url_ftell(pb
);
236 if (v
== MKTAG(0xfd, 'a', 'r', '.')) {
238 if (rm_read_audio_stream_info(s
, pb
, st
, rst
, 0))
242 if (get_le32(pb
) != MKTAG('V', 'I', 'D', 'O')) {
244 av_log(st
->codec
, AV_LOG_ERROR
, "Unsupported video codec\n");
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'))
255 st
->codec
->width
= get_be16(pb
);
256 st
->codec
->height
= get_be16(pb
);
257 st
->codec
->time_base
.num
= 1;
259 st
->codec
->codec_type
= CODEC_TYPE_VIDEO
;
264 st
->codec
->extradata_size
= codec_data_size
- (url_ftell(pb
) - codec_pos
);
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");
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
);
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;
288 /* skip codec info */
289 size
= url_ftell(pb
) - codec_pos
;
290 url_fskip(pb
, codec_data_size
- size
);
296 static int rm_read_header_old(AVFormatContext
*s
, AVFormatParameters
*ap
)
298 RMDemuxContext
*rm
= s
->priv_data
;
302 st
= av_new_stream(s
, 0);
305 st
->priv_data
= ff_rm_alloc_rmstream();
306 return rm_read_audio_stream_info(s
, s
->pb
, st
, st
->priv_data
, 1);
309 static int rm_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
311 RMDemuxContext
*rm
= s
->priv_data
;
313 ByteIOContext
*pb
= s
->pb
;
316 unsigned int start_time
, duration
;
321 if (tag
== MKTAG('.', 'r', 'a', 0xfd)) {
322 /* very old .ra format */
323 return rm_read_header_old(s
, ap
);
324 } else if (tag
!= MKTAG('.', 'R', 'M', 'F')) {
328 get_be32(pb
); /* header size */
331 get_be32(pb
); /* number of headers */
337 tag_size
= get_be32(pb
);
340 printf("tag=%c%c%c%c (%08x) size=%d\n",
348 if (tag_size
< 10 && tag
!= MKTAG('D', 'A', 'T', 'A'))
351 case MKTAG('P', 'R', 'O', 'P'):
353 get_be32(pb
); /* max bit rate */
354 get_be32(pb
); /* avg bit rate */
355 get_be32(pb
); /* max packet size */
356 get_be32(pb
); /* avg packet size */
357 get_be32(pb
); /* nb packets */
358 get_be32(pb
); /* duration */
359 get_be32(pb
); /* preroll */
360 get_be32(pb
); /* index offset */
361 get_be32(pb
); /* data offset */
362 get_be16(pb
); /* nb streams */
363 flags
= get_be16(pb
); /* flags */
365 case MKTAG('C', 'O', 'N', 'T'):
366 rm_read_metadata(s
, 1);
368 case MKTAG('M', 'D', 'P', 'R'):
369 st
= av_new_stream(s
, 0);
371 return AVERROR(ENOMEM
);
372 st
->id
= get_be16(pb
);
373 get_be32(pb
); /* max bit rate */
374 st
->codec
->bit_rate
= get_be32(pb
); /* bit rate */
375 get_be32(pb
); /* max packet size */
376 get_be32(pb
); /* avg packet size */
377 start_time
= get_be32(pb
); /* start time */
378 get_be32(pb
); /* preroll */
379 duration
= get_be32(pb
); /* duration */
380 st
->start_time
= start_time
;
381 st
->duration
= duration
;
382 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
383 get_str8(pb
, buf
, sizeof(buf
)); /* mimetype */
384 st
->codec
->codec_type
= CODEC_TYPE_DATA
;
385 st
->priv_data
= ff_rm_alloc_rmstream();
386 if (ff_rm_read_mdpr_codecdata(s
, s
->pb
, st
, st
->priv_data
,
390 case MKTAG('D', 'A', 'T', 'A'):
393 /* unknown tag: skip it */
394 url_fskip(pb
, tag_size
- 10);
399 rm
->nb_packets
= get_be32(pb
); /* number of packets */
400 if (!rm
->nb_packets
&& (flags
& 4))
401 rm
->nb_packets
= 3600 * 25;
402 get_be32(pb
); /* next data header */
406 static int get_num(ByteIOContext
*pb
, int *len
)
418 return (n
<< 16) | n1
;
422 /* multiple of 20 bytes for ra144 (ugly) */
423 #define RAW_PACKET_SIZE 1000
425 static int sync(AVFormatContext
*s
, int64_t *timestamp
, int *flags
, int *stream_index
, int64_t *pos
){
426 RMDemuxContext
*rm
= s
->priv_data
;
427 ByteIOContext
*pb
= s
->pb
;
428 int len
, num
, res
, i
;
430 uint32_t state
=0xFFFFFFFF;
432 while(!url_feof(pb
)){
433 *pos
= url_ftell(pb
) - 3;
434 if(rm
->remaining_len
> 0){
435 num
= rm
->current_stream
;
436 len
= rm
->remaining_len
;
437 *timestamp
= AV_NOPTS_VALUE
;
440 state
= (state
<<8) + get_byte(pb
);
442 if(state
== MKBETAG('I', 'N', 'D', 'X')){
443 int n_pkts
, expected_len
;
446 n_pkts
= get_be32(pb
);
447 expected_len
= 20 + n_pkts
* 14;
449 /* some files don't add index entries to chunk size... */
451 else if (len
!= expected_len
)
452 av_log(s
, AV_LOG_WARNING
,
453 "Index size %d (%d pkts) is wrong, should be %d.\n",
454 len
, n_pkts
, expected_len
);
455 len
-= 14; // we already read part of the index header
461 if(state
> (unsigned)0xFFFF || state
< 12)
467 *timestamp
= get_be32(pb
);
468 res
= get_byte(pb
); /* reserved */
469 *flags
= get_byte(pb
); /* flags */
474 for(i
=0;i
<s
->nb_streams
;i
++) {
479 if (i
== s
->nb_streams
) {
481 /* skip packet if unknown number */
483 rm
->remaining_len
= 0;
493 static int rm_assemble_video_frame(AVFormatContext
*s
, ByteIOContext
*pb
,
494 RMDemuxContext
*rm
, RMStream
*vst
,
495 AVPacket
*pkt
, int len
, int *pseq
)
497 int hdr
, seq
, pic_num
, len2
, pos
;
500 hdr
= get_byte(pb
); len
--;
503 if(type
!= 3){ // not frame as a part of packet
504 seq
= get_byte(pb
); len
--;
506 if(type
!= 1){ // not whole frame
507 len2
= get_num(pb
, &len
);
508 pos
= get_num(pb
, &len
);
509 pic_num
= get_byte(pb
); len
--;
513 rm
->remaining_len
= len
;
514 if(type
&1){ // frame, not slice
515 if(type
== 3) // frame as a part of packet
517 if(rm
->remaining_len
< len
)
519 rm
->remaining_len
-= len
;
520 if(av_new_packet(pkt
, len
+ 9) < 0)
523 AV_WL32(pkt
->data
+ 1, 1);
524 AV_WL32(pkt
->data
+ 5, 0);
525 get_buffer(pb
, pkt
->data
+ 9, len
);
528 //now we have to deal with single slice
531 if((seq
& 0x7F) == 1 || vst
->curpic_num
!= pic_num
){
532 vst
->slices
= ((hdr
& 0x3F) << 1) + 1;
533 vst
->videobufsize
= len2
+ 8*vst
->slices
+ 1;
534 av_free_packet(&vst
->pkt
); //FIXME this should be output.
535 if(av_new_packet(&vst
->pkt
, vst
->videobufsize
) < 0)
536 return AVERROR(ENOMEM
);
537 vst
->videobufpos
= 8*vst
->slices
+ 1;
539 vst
->curpic_num
= pic_num
;
540 vst
->pktpos
= url_ftell(pb
);
543 len
= FFMIN(len
, pos
);
545 if(++vst
->cur_slice
> vst
->slices
)
547 AV_WL32(vst
->pkt
.data
- 7 + 8*vst
->cur_slice
, 1);
548 AV_WL32(vst
->pkt
.data
- 3 + 8*vst
->cur_slice
, vst
->videobufpos
- 8*vst
->slices
- 1);
549 if(vst
->videobufpos
+ len
> vst
->videobufsize
)
551 if (get_buffer(pb
, vst
->pkt
.data
+ vst
->videobufpos
, len
) != len
)
553 vst
->videobufpos
+= len
;
554 rm
->remaining_len
-= len
;
556 if(type
== 2 || (vst
->videobufpos
) == vst
->videobufsize
){
557 vst
->pkt
.data
[0] = vst
->cur_slice
-1;
561 if(vst
->slices
!= vst
->cur_slice
) //FIXME find out how to set slices correct from the begin
562 memmove(pkt
->data
+ 1 + 8*vst
->cur_slice
, pkt
->data
+ 1 + 8*vst
->slices
,
563 vst
->videobufpos
- 1 - 8*vst
->slices
);
564 pkt
->size
= vst
->videobufpos
+ 8*(vst
->cur_slice
- vst
->slices
);
565 pkt
->pts
= AV_NOPTS_VALUE
;
566 pkt
->pos
= vst
->pktpos
;
574 rm_ac3_swap_bytes (AVStream
*st
, AVPacket
*pkt
)
579 if (st
->codec
->codec_id
== CODEC_ID_AC3
) {
581 for (j
=0;j
<pkt
->size
;j
+=2) {
582 FFSWAP(int, ptr
[0], ptr
[1]);
589 ff_rm_parse_packet (AVFormatContext
*s
, ByteIOContext
*pb
,
590 AVStream
*st
, RMStream
*ast
, int len
, AVPacket
*pkt
,
591 int *seq
, int *flags
, int64_t *timestamp
)
593 RMDemuxContext
*rm
= s
->priv_data
;
595 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
596 rm
->current_stream
= st
->id
;
597 if(rm_assemble_video_frame(s
, pb
, rm
, ast
, pkt
, len
, seq
))
598 return -1; //got partial frame
599 } else if (st
->codec
->codec_type
== CODEC_TYPE_AUDIO
) {
600 if ((st
->codec
->codec_id
== CODEC_ID_RA_288
) ||
601 (st
->codec
->codec_id
== CODEC_ID_COOK
) ||
602 (st
->codec
->codec_id
== CODEC_ID_ATRAC3
) ||
603 (st
->codec
->codec_id
== CODEC_ID_SIPR
)) {
605 int sps
= ast
->sub_packet_size
;
606 int cfs
= ast
->coded_framesize
;
607 int h
= ast
->sub_packet_h
;
608 int y
= ast
->sub_packet_cnt
;
609 int w
= ast
->audio_framesize
;
612 y
= ast
->sub_packet_cnt
= 0;
614 ast
->audiotimestamp
= *timestamp
;
616 switch(st
->codec
->codec_id
) {
617 case CODEC_ID_RA_288
:
618 for (x
= 0; x
< h
/2; x
++)
619 get_buffer(pb
, ast
->pkt
.data
+x
*2*w
+y
*cfs
, cfs
);
621 case CODEC_ID_ATRAC3
:
623 for (x
= 0; x
< w
/sps
; x
++)
624 get_buffer(pb
, ast
->pkt
.data
+sps
*(h
*x
+((h
+1)/2)*(y
&1)+(y
>>1)), sps
);
628 if (++(ast
->sub_packet_cnt
) < h
)
631 ast
->sub_packet_cnt
= 0;
632 rm
->audio_stream_num
= st
->index
;
633 rm
->audio_pkt_cnt
= h
* w
/ st
->codec
->block_align
- 1;
634 // Release first audio packet
635 av_new_packet(pkt
, st
->codec
->block_align
);
636 memcpy(pkt
->data
, ast
->pkt
.data
, st
->codec
->block_align
); //FIXME avoid this
637 *timestamp
= ast
->audiotimestamp
;
638 *flags
= 2; // Mark first packet as keyframe
640 } else if (st
->codec
->codec_id
== CODEC_ID_AAC
) {
642 rm
->audio_stream_num
= st
->index
;
643 ast
->sub_packet_cnt
= (get_be16(pb
) & 0xf0) >> 4;
644 if (ast
->sub_packet_cnt
) {
645 for (x
= 0; x
< ast
->sub_packet_cnt
; x
++)
646 ast
->sub_packet_lengths
[x
] = get_be16(pb
);
647 // Release first audio packet
648 rm
->audio_pkt_cnt
= ast
->sub_packet_cnt
- 1;
649 av_get_packet(pb
, pkt
, ast
->sub_packet_lengths
[0]);
650 *flags
= 2; // Mark first packet as keyframe
653 av_get_packet(pb
, pkt
, len
);
654 rm_ac3_swap_bytes(st
, pkt
);
657 av_get_packet(pb
, pkt
, len
);
659 pkt
->stream_index
= st
->index
;
662 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
663 if(st
->codec
->codec_id
== CODEC_ID_RV20
){
664 int seq
= 128*(pkt
->data
[2]&0x7F) + (pkt
->data
[3]>>1);
665 av_log(s
, AV_LOG_DEBUG
, "%d %"PRId64
" %d\n", *timestamp
, *timestamp
*512LL/25, seq
);
667 seq
|= (*timestamp
&~0x3FFF);
668 if(seq
- *timestamp
> 0x2000) seq
-= 0x4000;
669 if(seq
- *timestamp
< -0x2000) seq
+= 0x4000;
674 pkt
->pts
= *timestamp
;
676 pkt
->flags
|= PKT_FLAG_KEY
;
678 return st
->codec
->codec_type
== CODEC_TYPE_AUDIO
? rm
->audio_pkt_cnt
: 0;
682 ff_rm_retrieve_cache (AVFormatContext
*s
, ByteIOContext
*pb
,
683 AVStream
*st
, RMStream
*ast
, AVPacket
*pkt
)
685 RMDemuxContext
*rm
= s
->priv_data
;
687 assert (rm
->audio_pkt_cnt
> 0);
689 if (st
->codec
->codec_id
== CODEC_ID_AAC
)
690 av_get_packet(pb
, pkt
, ast
->sub_packet_lengths
[ast
->sub_packet_cnt
- rm
->audio_pkt_cnt
]);
692 av_new_packet(pkt
, st
->codec
->block_align
);
693 memcpy(pkt
->data
, ast
->pkt
.data
+ st
->codec
->block_align
* //FIXME avoid this
694 (ast
->sub_packet_h
* ast
->audio_framesize
/ st
->codec
->block_align
- rm
->audio_pkt_cnt
),
695 st
->codec
->block_align
);
699 pkt
->stream_index
= st
->index
;
701 return rm
->audio_pkt_cnt
;
704 static int rm_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
706 RMDemuxContext
*rm
= s
->priv_data
;
707 ByteIOContext
*pb
= s
->pb
;
710 int64_t timestamp
, pos
;
711 int old_flags
, flags
;
713 if (rm
->audio_pkt_cnt
) {
714 // If there are queued audio packet return them first
715 st
= s
->streams
[rm
->audio_stream_num
];
716 ff_rm_retrieve_cache(s
, s
->pb
, st
, st
->priv_data
, pkt
);
717 } else if (rm
->old_format
) {
722 if (st
->codec
->codec_id
== CODEC_ID_RA_288
) {
725 for (y
= 0; y
< ast
->sub_packet_h
; y
++)
726 for (x
= 0; x
< ast
->sub_packet_h
/2; x
++)
727 if (get_buffer(pb
, ast
->pkt
.data
+x
*2*ast
->audio_framesize
+y
*ast
->coded_framesize
, ast
->coded_framesize
) <= 0)
729 rm
->audio_stream_num
= 0;
730 rm
->audio_pkt_cnt
= ast
->sub_packet_h
* ast
->audio_framesize
/ st
->codec
->block_align
- 1;
731 // Release first audio packet
732 av_new_packet(pkt
, st
->codec
->block_align
);
733 memcpy(pkt
->data
, ast
->pkt
.data
, st
->codec
->block_align
); //FIXME avoid this
734 pkt
->flags
|= PKT_FLAG_KEY
; // Mark first packet as keyframe
735 pkt
->stream_index
= 0;
737 /* just read raw bytes */
738 len
= RAW_PACKET_SIZE
;
739 len
= av_get_packet(pb
, pkt
, len
);
740 pkt
->stream_index
= 0;
746 rm_ac3_swap_bytes(st
, pkt
);
750 len
=sync(s
, ×tamp
, &flags
, &i
, &pos
);
756 res
= ff_rm_parse_packet (s
, s
->pb
, st
, st
->priv_data
, len
, pkt
,
757 &seq
, &flags
, ×tamp
);
758 if((old_flags
&2) && (seq
&0x7F) == 1)
759 av_add_index_entry(st
, pos
, timestamp
, 0, 0, AVINDEX_KEYFRAME
);
763 if( (st
->discard
>= AVDISCARD_NONKEY
&& !(flags
&2))
764 || st
->discard
>= AVDISCARD_ALL
){
766 while (rm
->audio_pkt_cnt
> 0) {
767 ff_rm_retrieve_cache(s
, s
->pb
, st
, st
->priv_data
, pkt
);
777 static int rm_read_close(AVFormatContext
*s
)
781 for (i
=0;i
<s
->nb_streams
;i
++)
782 ff_rm_free_rmstream(s
->streams
[i
]->priv_data
);
787 static int rm_probe(AVProbeData
*p
)
789 /* check file header */
790 if ((p
->buf
[0] == '.' && p
->buf
[1] == 'R' &&
791 p
->buf
[2] == 'M' && p
->buf
[3] == 'F' &&
792 p
->buf
[4] == 0 && p
->buf
[5] == 0) ||
793 (p
->buf
[0] == '.' && p
->buf
[1] == 'r' &&
794 p
->buf
[2] == 'a' && p
->buf
[3] == 0xfd))
795 return AVPROBE_SCORE_MAX
;
800 static int64_t rm_read_dts(AVFormatContext
*s
, int stream_index
,
801 int64_t *ppos
, int64_t pos_limit
)
803 RMDemuxContext
*rm
= s
->priv_data
;
805 int stream_index2
, flags
, len
, h
;
810 return AV_NOPTS_VALUE
;
812 url_fseek(s
->pb
, pos
, SEEK_SET
);
818 len
=sync(s
, &dts
, &flags
, &stream_index2
, &pos
);
820 return AV_NOPTS_VALUE
;
822 st
= s
->streams
[stream_index2
];
823 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
824 h
= get_byte(s
->pb
); len
--;
826 seq
= get_byte(s
->pb
); len
--;
830 if((flags
&2) && (seq
&0x7F) == 1){
831 // av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq);
832 av_add_index_entry(st
, pos
, dts
, 0, 0, AVINDEX_KEYFRAME
);
833 if(stream_index2
== stream_index
)
837 url_fskip(s
->pb
, len
);
843 AVInputFormat rm_demuxer
= {
845 NULL_IF_CONFIG_SMALL("RealMedia format"),
846 sizeof(RMDemuxContext
),
855 AVInputFormat rdt_demuxer
= {
857 NULL_IF_CONFIG_SMALL("RDT demuxer"),
858 sizeof(RMDemuxContext
),