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
);
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
)
299 ByteIOContext
*pb
= s
->pb
;
300 unsigned int size
, n_pkts
, str_id
, next_off
, n
, pos
, pts
;
304 if (get_le32(pb
) != MKTAG('I','N','D','X'))
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
) {
318 if (n
== s
->nb_streams
)
321 for (n
= 0; n
< n_pkts
; n
++) {
325 url_fskip(pb
, 4); /* packet no. */
327 av_add_index_entry(st
, pos
, pts
, 0, 0, AVINDEX_KEYFRAME
);
331 if (next_off
&& url_ftell(pb
) != next_off
&&
332 url_fseek(pb
, next_off
, SEEK_SET
) < 0)
339 static int rm_read_header_old(AVFormatContext
*s
, AVFormatParameters
*ap
)
341 RMDemuxContext
*rm
= s
->priv_data
;
345 st
= av_new_stream(s
, 0);
348 st
->priv_data
= ff_rm_alloc_rmstream();
349 return rm_read_audio_stream_info(s
, s
->pb
, st
, st
->priv_data
, 1);
352 static int rm_read_header(AVFormatContext
*s
, AVFormatParameters
*ap
)
354 RMDemuxContext
*rm
= s
->priv_data
;
356 ByteIOContext
*pb
= s
->pb
;
359 unsigned int start_time
, duration
;
360 unsigned int data_off
= 0, indx_off
= 0;
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')) {
372 get_be32(pb
); /* header size */
375 get_be32(pb
); /* number of headers */
381 tag_size
= get_be32(pb
);
384 printf("tag=%c%c%c%c (%08x) size=%d\n",
392 if (tag_size
< 10 && tag
!= MKTAG('D', 'A', 'T', 'A'))
395 case MKTAG('P', 'R', 'O', 'P'):
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 */
409 case MKTAG('C', 'O', 'N', 'T'):
410 rm_read_metadata(s
, 1);
412 case MKTAG('M', 'D', 'P', 'R'):
413 st
= av_new_stream(s
, 0);
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
,
434 case MKTAG('D', 'A', 'T', 'A'):
437 /* unknown tag: skip it */
438 url_fskip(pb
, tag_size
- 10);
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 */
449 data_off
= url_ftell(pb
) - 18;
450 if (indx_off
&& url_fseek(pb
, indx_off
, SEEK_SET
) >= 0) {
452 url_fseek(pb
, data_off
+ 18, SEEK_SET
);
458 static int get_num(ByteIOContext
*pb
, int *len
)
470 return (n
<< 16) | n1
;
474 /* multiple of 20 bytes for ra144 (ugly) */
475 #define RAW_PACKET_SIZE 1000
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
;
482 uint32_t state
=0xFFFFFFFF;
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
;
492 state
= (state
<<8) + get_byte(pb
);
494 if(state
== MKBETAG('I', 'N', 'D', 'X')){
495 int n_pkts
, expected_len
;
498 n_pkts
= get_be32(pb
);
499 expected_len
= 20 + n_pkts
* 14;
501 /* some files don't add index entries to chunk size... */
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
513 if(state
> (unsigned)0xFFFF || state
< 12)
519 *timestamp
= get_be32(pb
);
520 res
= get_byte(pb
); /* reserved */
521 *flags
= get_byte(pb
); /* flags */
526 for(i
=0;i
<s
->nb_streams
;i
++) {
531 if (i
== s
->nb_streams
) {
533 /* skip packet if unknown number */
535 rm
->remaining_len
= 0;
545 static int rm_assemble_video_frame(AVFormatContext
*s
, ByteIOContext
*pb
,
546 RMDemuxContext
*rm
, RMStream
*vst
,
547 AVPacket
*pkt
, int len
, int *pseq
)
549 int hdr
, seq
, pic_num
, len2
, pos
;
552 hdr
= get_byte(pb
); len
--;
555 if(type
!= 3){ // not frame as a part of packet
556 seq
= get_byte(pb
); len
--;
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
--;
565 rm
->remaining_len
= len
;
566 if(type
&1){ // frame, not slice
567 if(type
== 3) // frame as a part of packet
569 if(rm
->remaining_len
< len
)
571 rm
->remaining_len
-= len
;
572 if(av_new_packet(pkt
, len
+ 9) < 0)
575 AV_WL32(pkt
->data
+ 1, 1);
576 AV_WL32(pkt
->data
+ 5, 0);
577 get_buffer(pb
, pkt
->data
+ 9, len
);
580 //now we have to deal with single slice
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;
591 vst
->curpic_num
= pic_num
;
592 vst
->pktpos
= url_ftell(pb
);
595 len
= FFMIN(len
, pos
);
597 if(++vst
->cur_slice
> vst
->slices
)
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
)
603 if (get_buffer(pb
, vst
->pkt
.data
+ vst
->videobufpos
, len
) != len
)
605 vst
->videobufpos
+= len
;
606 rm
->remaining_len
-= len
;
608 if(type
== 2 || (vst
->videobufpos
) == vst
->videobufsize
){
609 vst
->pkt
.data
[0] = vst
->cur_slice
-1;
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
;
626 rm_ac3_swap_bytes (AVStream
*st
, AVPacket
*pkt
)
631 if (st
->codec
->codec_id
== CODEC_ID_AC3
) {
633 for (j
=0;j
<pkt
->size
;j
+=2) {
634 FFSWAP(int, ptr
[0], ptr
[1]);
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
)
645 RMDemuxContext
*rm
= s
->priv_data
;
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
)) {
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
;
664 y
= ast
->sub_packet_cnt
= 0;
666 ast
->audiotimestamp
= *timestamp
;
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
);
673 case CODEC_ID_ATRAC3
:
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
);
680 if (++(ast
->sub_packet_cnt
) < h
)
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
) {
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
;
697 av_get_packet(pb
, pkt
, len
);
698 rm_ac3_swap_bytes(st
, pkt
);
701 av_get_packet(pb
, pkt
, len
);
703 pkt
->stream_index
= st
->index
;
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
);
711 seq
|= (*timestamp
&~0x3FFF);
712 if(seq
- *timestamp
> 0x2000) seq
-= 0x4000;
713 if(seq
- *timestamp
< -0x2000) seq
+= 0x4000;
718 pkt
->pts
= *timestamp
;
720 pkt
->flags
|= PKT_FLAG_KEY
;
722 return st
->codec
->codec_type
== CODEC_TYPE_AUDIO
? rm
->audio_pkt_cnt
: 0;
726 ff_rm_retrieve_cache (AVFormatContext
*s
, ByteIOContext
*pb
,
727 AVStream
*st
, RMStream
*ast
, AVPacket
*pkt
)
729 RMDemuxContext
*rm
= s
->priv_data
;
731 assert (rm
->audio_pkt_cnt
> 0);
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
]);
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
);
742 if ((pkt
->pts
= ast
->audiotimestamp
) != AV_NOPTS_VALUE
) {
743 ast
->audiotimestamp
= AV_NOPTS_VALUE
;
744 pkt
->flags
= PKT_FLAG_KEY
;
747 pkt
->stream_index
= st
->index
;
749 return rm
->audio_pkt_cnt
;
752 static int rm_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
754 RMDemuxContext
*rm
= s
->priv_data
;
756 int i
, len
, res
, seq
= 1;
757 int64_t timestamp
, pos
;
758 int old_flags
, flags
;
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
);
766 if (rm
->old_format
) {
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;
776 len
=sync(s
, ×tamp
, &flags
, &i
, &pos
);
781 if(len
<0 || url_feof(s
->pb
))
785 res
= ff_rm_parse_packet (s
, s
->pb
, st
, st
->priv_data
, len
, pkt
,
786 &seq
, &flags
, ×tamp
);
787 if((old_flags
&2) && (seq
&0x7F) == 1)
788 av_add_index_entry(st
, pos
, timestamp
, 0, 0, AVINDEX_KEYFRAME
);
793 if( (st
->discard
>= AVDISCARD_NONKEY
&& !(flags
&2))
794 || st
->discard
>= AVDISCARD_ALL
){
803 static int rm_read_close(AVFormatContext
*s
)
807 for (i
=0;i
<s
->nb_streams
;i
++)
808 ff_rm_free_rmstream(s
->streams
[i
]->priv_data
);
813 static int rm_probe(AVProbeData
*p
)
815 /* check file header */
816 if ((p
->buf
[0] == '.' && p
->buf
[1] == 'R' &&
817 p
->buf
[2] == 'M' && p
->buf
[3] == 'F' &&
818 p
->buf
[4] == 0 && p
->buf
[5] == 0) ||
819 (p
->buf
[0] == '.' && p
->buf
[1] == 'r' &&
820 p
->buf
[2] == 'a' && p
->buf
[3] == 0xfd))
821 return AVPROBE_SCORE_MAX
;
826 static int64_t rm_read_dts(AVFormatContext
*s
, int stream_index
,
827 int64_t *ppos
, int64_t pos_limit
)
829 RMDemuxContext
*rm
= s
->priv_data
;
831 int stream_index2
, flags
, len
, h
;
836 return AV_NOPTS_VALUE
;
838 url_fseek(s
->pb
, pos
, SEEK_SET
);
844 len
=sync(s
, &dts
, &flags
, &stream_index2
, &pos
);
846 return AV_NOPTS_VALUE
;
848 st
= s
->streams
[stream_index2
];
849 if (st
->codec
->codec_type
== CODEC_TYPE_VIDEO
) {
850 h
= get_byte(s
->pb
); len
--;
852 seq
= get_byte(s
->pb
); len
--;
856 if((flags
&2) && (seq
&0x7F) == 1){
857 // av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq);
858 av_add_index_entry(st
, pos
, dts
, 0, 0, AVINDEX_KEYFRAME
);
859 if(stream_index2
== stream_index
)
863 url_fskip(s
->pb
, len
);
869 AVInputFormat rm_demuxer
= {
871 NULL_IF_CONFIG_SMALL("RealMedia format"),
872 sizeof(RMDemuxContext
),
881 AVInputFormat rdt_demuxer
= {
883 NULL_IF_CONFIG_SMALL("RDT demuxer"),
884 sizeof(RMDemuxContext
),