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
24 #include "libavutil/avassert.h"
25 #include "libavutil/avstring.h"
26 #include "libavutil/channel_layout.h"
27 #include "libavutil/internal.h"
28 #include "libavutil/intreadwrite.h"
29 #include "libavutil/dict.h"
31 #include "avio_internal.h"
36 #define DEINT_ID_GENR MKTAG('g', 'e', 'n', 'r') ///< interleaving for Cooker/ATRAC
37 #define DEINT_ID_INT0 MKTAG('I', 'n', 't', '0') ///< no interleaving needed
38 #define DEINT_ID_INT4 MKTAG('I', 'n', 't', '4') ///< interleaving for 28.8
39 #define DEINT_ID_SIPR MKTAG('s', 'i', 'p', 'r') ///< interleaving for Sipro
40 #define DEINT_ID_VBRF MKTAG('v', 'b', 'r', 'f') ///< VBR case for AAC
41 #define DEINT_ID_VBRS MKTAG('v', 'b', 'r', 's') ///< VBR case for AAC
44 AVPacket pkt
; ///< place to store merged video frame / reordered audio data
45 int videobufsize
; ///< current assembled frame size
46 int videobufpos
; ///< position for the next slice in the video buffer
47 int curpic_num
; ///< picture number of current frame
48 int cur_slice
, slices
;
49 int64_t pktpos
; ///< first slice position in file
50 /// Audio descrambling matrix parameters
51 int64_t audiotimestamp
; ///< Audio packet timestamp
52 int sub_packet_cnt
; // Subpacket counter, used while reading
53 int sub_packet_size
, sub_packet_h
, coded_framesize
; ///< Descrambling parameters from container
54 int audio_framesize
; /// Audio frame size from container
55 int sub_packet_lengths
[16]; /// Length of each subpacket
56 int32_t deint_id
; ///< deinterleaver used in audio stream
64 int audio_stream_num
; ///< Stream number for audio packets
65 int audio_pkt_cnt
; ///< Output packet counter
68 static inline void get_strl(AVIOContext
*pb
, char *buf
, int buf_size
, int len
)
79 if (buf_size
> 0) *q
= '\0';
82 static void get_str8(AVIOContext
*pb
, char *buf
, int buf_size
)
84 get_strl(pb
, buf
, buf_size
, avio_r8(pb
));
87 static int rm_read_extradata(AVIOContext
*pb
, AVCodecContext
*avctx
, unsigned size
)
91 if (ff_get_extradata(avctx
, pb
, size
) < 0)
92 return AVERROR(ENOMEM
);
96 static void rm_read_metadata(AVFormatContext
*s
, AVIOContext
*pb
, int wide
)
101 for (i
=0; i
<FF_ARRAY_ELEMS(ff_rm_metadata
); i
++) {
102 int len
= wide
? avio_rb16(pb
) : avio_r8(pb
);
103 get_strl(pb
, buf
, sizeof(buf
), len
);
104 av_dict_set(&s
->metadata
, ff_rm_metadata
[i
], buf
, 0);
108 RMStream
*ff_rm_alloc_rmstream (void)
110 RMStream
*rms
= av_mallocz(sizeof(RMStream
));
111 rms
->curpic_num
= -1;
115 void ff_rm_free_rmstream (RMStream
*rms
)
117 av_free_packet(&rms
->pkt
);
120 static int rm_read_audio_stream_info(AVFormatContext
*s
, AVIOContext
*pb
,
121 AVStream
*st
, RMStream
*ast
, int read_all
)
128 version
= avio_rb16(pb
); /* version */
130 unsigned bytes_per_minute
;
131 int header_size
= avio_rb16(pb
);
132 int64_t startpos
= avio_tell(pb
);
134 bytes_per_minute
= avio_rb16(pb
);
136 rm_read_metadata(s
, pb
, 0);
137 if ((startpos
+ header_size
) >= avio_tell(pb
) + 2) {
138 // fourcc (should always be "lpcJ")
140 get_str8(pb
, buf
, sizeof(buf
));
142 // Skip extra header crap (this should never happen)
143 if ((startpos
+ header_size
) > avio_tell(pb
))
144 avio_skip(pb
, header_size
+ startpos
- avio_tell(pb
));
145 if (bytes_per_minute
)
146 st
->codec
->bit_rate
= 8LL * bytes_per_minute
/ 60;
147 st
->codec
->sample_rate
= 8000;
148 st
->codec
->channels
= 1;
149 st
->codec
->channel_layout
= AV_CH_LAYOUT_MONO
;
150 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
151 st
->codec
->codec_id
= AV_CODEC_ID_RA_144
;
152 ast
->deint_id
= DEINT_ID_INT0
;
154 int flavor
, sub_packet_h
, coded_framesize
, sub_packet_size
;
155 int codecdata_length
;
156 unsigned bytes_per_minute
;
157 /* old version (4) */
158 avio_skip(pb
, 2); /* unused */
159 avio_rb32(pb
); /* .ra4 */
160 avio_rb32(pb
); /* data size */
161 avio_rb16(pb
); /* version2 */
162 avio_rb32(pb
); /* header size */
163 flavor
= avio_rb16(pb
); /* add codec info / flavor */
164 ast
->coded_framesize
= coded_framesize
= avio_rb32(pb
); /* coded frame size */
165 avio_rb32(pb
); /* ??? */
166 bytes_per_minute
= avio_rb32(pb
);
168 if (bytes_per_minute
)
169 st
->codec
->bit_rate
= 8LL * bytes_per_minute
/ 60;
171 avio_rb32(pb
); /* ??? */
172 ast
->sub_packet_h
= sub_packet_h
= avio_rb16(pb
); /* 1 */
173 st
->codec
->block_align
= avio_rb16(pb
); /* frame size */
174 ast
->sub_packet_size
= sub_packet_size
= avio_rb16(pb
); /* sub packet size */
175 avio_rb16(pb
); /* ??? */
177 avio_rb16(pb
); avio_rb16(pb
); avio_rb16(pb
);
179 st
->codec
->sample_rate
= avio_rb16(pb
);
181 st
->codec
->channels
= avio_rb16(pb
);
183 ast
->deint_id
= avio_rl32(pb
);
184 avio_read(pb
, buf
, 4);
188 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
189 ast
->deint_id
= AV_RL32(buf
);
190 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
192 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
193 st
->codec
->codec_tag
= AV_RL32(buf
);
194 st
->codec
->codec_id
= ff_codec_get_id(ff_rm_codec_tags
,
195 st
->codec
->codec_tag
);
197 switch (st
->codec
->codec_id
) {
198 case AV_CODEC_ID_AC3
:
199 st
->need_parsing
= AVSTREAM_PARSE_FULL
;
201 case AV_CODEC_ID_RA_288
:
202 st
->codec
->extradata_size
= 0;
203 ast
->audio_framesize
= st
->codec
->block_align
;
204 st
->codec
->block_align
= coded_framesize
;
206 case AV_CODEC_ID_COOK
:
207 st
->need_parsing
= AVSTREAM_PARSE_HEADERS
;
208 case AV_CODEC_ID_ATRAC3
:
209 case AV_CODEC_ID_SIPR
:
211 codecdata_length
= 0;
213 avio_rb16(pb
); avio_r8(pb
);
216 codecdata_length
= avio_rb32(pb
);
217 if(codecdata_length
+ FF_INPUT_BUFFER_PADDING_SIZE
<= (unsigned)codecdata_length
){
218 av_log(s
, AV_LOG_ERROR
, "codecdata_length too large\n");
223 ast
->audio_framesize
= st
->codec
->block_align
;
224 if (st
->codec
->codec_id
== AV_CODEC_ID_SIPR
) {
226 av_log(s
, AV_LOG_ERROR
, "bad SIPR file flavor %d\n",
230 st
->codec
->block_align
= ff_sipr_subpk_size
[flavor
];
232 if(sub_packet_size
<= 0){
233 av_log(s
, AV_LOG_ERROR
, "sub_packet_size is invalid\n");
236 st
->codec
->block_align
= ast
->sub_packet_size
;
238 if ((ret
= rm_read_extradata(pb
, st
->codec
, codecdata_length
)) < 0)
242 case AV_CODEC_ID_AAC
:
243 avio_rb16(pb
); avio_r8(pb
);
246 codecdata_length
= avio_rb32(pb
);
247 if(codecdata_length
+ FF_INPUT_BUFFER_PADDING_SIZE
<= (unsigned)codecdata_length
){
248 av_log(s
, AV_LOG_ERROR
, "codecdata_length too large\n");
251 if (codecdata_length
>= 1) {
253 if ((ret
= rm_read_extradata(pb
, st
->codec
, codecdata_length
- 1)) < 0)
258 switch (ast
->deint_id
) {
260 if (ast
->coded_framesize
> ast
->audio_framesize
||
262 ast
->coded_framesize
* sub_packet_h
> (2 + (sub_packet_h
& 1)) * ast
->audio_framesize
)
263 return AVERROR_INVALIDDATA
;
264 if (ast
->coded_framesize
* sub_packet_h
!= 2*ast
->audio_framesize
) {
265 avpriv_request_sample(s
, "mismatching interleaver parameters");
266 return AVERROR_INVALIDDATA
;
270 if (ast
->sub_packet_size
<= 0 ||
271 ast
->sub_packet_size
> ast
->audio_framesize
)
272 return AVERROR_INVALIDDATA
;
273 if (ast
->audio_framesize
% ast
->sub_packet_size
)
274 return AVERROR_INVALIDDATA
;
282 av_log(s
, AV_LOG_ERROR
,"Unknown interleaver %"PRIX32
"\n", ast
->deint_id
);
283 return AVERROR_INVALIDDATA
;
285 if (ast
->deint_id
== DEINT_ID_INT4
||
286 ast
->deint_id
== DEINT_ID_GENR
||
287 ast
->deint_id
== DEINT_ID_SIPR
) {
288 if (st
->codec
->block_align
<= 0 ||
289 ast
->audio_framesize
* sub_packet_h
> (unsigned)INT_MAX
||
290 ast
->audio_framesize
* sub_packet_h
< st
->codec
->block_align
)
291 return AVERROR_INVALIDDATA
;
292 if (av_new_packet(&ast
->pkt
, ast
->audio_framesize
* sub_packet_h
) < 0)
293 return AVERROR(ENOMEM
);
300 rm_read_metadata(s
, pb
, 0);
307 ff_rm_read_mdpr_codecdata (AVFormatContext
*s
, AVIOContext
*pb
,
308 AVStream
*st
, RMStream
*rst
, int codec_data_size
, const uint8_t *mime
)
315 if (codec_data_size
< 0)
316 return AVERROR_INVALIDDATA
;
318 avpriv_set_pts_info(st
, 64, 1, 1000);
319 codec_pos
= avio_tell(pb
);
322 if (v
== MKBETAG('M', 'L', 'T', 'I')) {
323 int number_of_streams
= avio_rb16(pb
);
326 for (i
= 0; i
<number_of_streams
; i
++)
328 number_of_mdpr
= avio_rb16(pb
);
329 if (number_of_mdpr
!= 1) {
330 avpriv_request_sample(s
, "MLTI with multiple MDPR");
336 if (v
== MKTAG(0xfd, 'a', 'r', '.')) {
338 if (rm_read_audio_stream_info(s
, pb
, st
, rst
, 0))
340 } else if (v
== MKBETAG('L', 'S', 'D', ':')) {
341 avio_seek(pb
, -4, SEEK_CUR
);
342 if ((ret
= rm_read_extradata(pb
, st
->codec
, codec_data_size
)) < 0)
345 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
346 st
->codec
->codec_tag
= AV_RL32(st
->codec
->extradata
);
347 st
->codec
->codec_id
= ff_codec_get_id(ff_rm_codec_tags
,
348 st
->codec
->codec_tag
);
349 } else if(mime
&& !strcmp(mime
, "logical-fileinfo")){
350 int stream_count
, rule_count
, property_count
, i
;
351 ff_free_stream(s
, st
);
352 if (avio_rb16(pb
) != 0) {
353 av_log(s
, AV_LOG_WARNING
, "Unsupported version\n");
356 stream_count
= avio_rb16(pb
);
357 avio_skip(pb
, 6*stream_count
);
358 rule_count
= avio_rb16(pb
);
359 avio_skip(pb
, 2*rule_count
);
360 property_count
= avio_rb16(pb
);
361 for(i
=0; i
<property_count
; i
++){
362 uint8_t name
[128], val
[128];
364 if (avio_rb16(pb
) != 0) {
365 av_log(s
, AV_LOG_WARNING
, "Unsupported Name value property version\n");
366 goto skip
; //FIXME skip just this one
368 get_str8(pb
, name
, sizeof(name
));
369 switch(avio_rb32(pb
)) {
370 case 2: get_strl(pb
, val
, sizeof(val
), avio_rb16(pb
));
371 av_dict_set(&s
->metadata
, name
, val
, 0);
373 default: avio_skip(pb
, avio_rb16(pb
));
378 if (avio_rl32(pb
) != MKTAG('V', 'I', 'D', 'O')) {
380 av_log(s
, AV_LOG_WARNING
, "Unsupported stream type %08x\n", v
);
383 st
->codec
->codec_tag
= avio_rl32(pb
);
384 st
->codec
->codec_id
= ff_codec_get_id(ff_rm_codec_tags
,
385 st
->codec
->codec_tag
);
386 av_dlog(s
, "%X %X\n", st
->codec
->codec_tag
, MKTAG('R', 'V', '2', '0'));
387 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
)
389 st
->codec
->width
= avio_rb16(pb
);
390 st
->codec
->height
= avio_rb16(pb
);
391 avio_skip(pb
, 2); // looks like bits per sample
392 avio_skip(pb
, 4); // always zero?
393 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
394 st
->need_parsing
= AVSTREAM_PARSE_TIMESTAMPS
;
397 if ((ret
= rm_read_extradata(pb
, st
->codec
, codec_data_size
- (avio_tell(pb
) - codec_pos
))) < 0)
401 av_reduce(&st
->avg_frame_rate
.den
, &st
->avg_frame_rate
.num
,
402 0x10000, fps
, (1 << 30) - 1);
403 #if FF_API_R_FRAME_RATE
404 st
->r_frame_rate
= st
->avg_frame_rate
;
406 } else if (s
->error_recognition
& AV_EF_EXPLODE
) {
407 av_log(s
, AV_LOG_ERROR
, "Invalid framerate\n");
408 return AVERROR_INVALIDDATA
;
413 /* skip codec info */
414 size
= avio_tell(pb
) - codec_pos
;
415 avio_skip(pb
, codec_data_size
- size
);
420 /** this function assumes that the demuxer has already seeked to the start
421 * of the INDX chunk, and will bail out if not. */
422 static int rm_read_index(AVFormatContext
*s
)
424 AVIOContext
*pb
= s
->pb
;
425 unsigned int size
, n_pkts
, str_id
, next_off
, n
, pos
, pts
;
429 if (avio_rl32(pb
) != MKTAG('I','N','D','X'))
431 size
= avio_rb32(pb
);
435 n_pkts
= avio_rb32(pb
);
436 str_id
= avio_rb16(pb
);
437 next_off
= avio_rb32(pb
);
438 for (n
= 0; n
< s
->nb_streams
; n
++)
439 if (s
->streams
[n
]->id
== str_id
) {
443 if (n
== s
->nb_streams
) {
444 av_log(s
, AV_LOG_ERROR
,
445 "Invalid stream index %d for index at pos %"PRId64
"\n",
446 str_id
, avio_tell(pb
));
448 } else if ((avio_size(pb
) - avio_tell(pb
)) / 14 < n_pkts
) {
449 av_log(s
, AV_LOG_ERROR
,
450 "Nr. of packets in packet index for stream index %d "
451 "exceeds filesize (%"PRId64
" at %"PRId64
" = %"PRId64
")\n",
452 str_id
, avio_size(pb
), avio_tell(pb
),
453 (avio_size(pb
) - avio_tell(pb
)) / 14);
457 for (n
= 0; n
< n_pkts
; n
++) {
461 avio_skip(pb
, 4); /* packet no. */
463 av_add_index_entry(st
, pos
, pts
, 0, 0, AVINDEX_KEYFRAME
);
467 if (next_off
&& avio_tell(pb
) < next_off
&&
468 avio_seek(pb
, next_off
, SEEK_SET
) < 0) {
469 av_log(s
, AV_LOG_ERROR
,
470 "Non-linear index detected, not supported\n");
478 static int rm_read_header_old(AVFormatContext
*s
)
480 RMDemuxContext
*rm
= s
->priv_data
;
484 st
= avformat_new_stream(s
, NULL
);
487 st
->priv_data
= ff_rm_alloc_rmstream();
488 return rm_read_audio_stream_info(s
, s
->pb
, st
, st
->priv_data
, 1);
491 static int rm_read_header(AVFormatContext
*s
)
493 RMDemuxContext
*rm
= s
->priv_data
;
495 AVIOContext
*pb
= s
->pb
;
498 unsigned int start_time
, duration
;
499 unsigned int data_off
= 0, indx_off
= 0;
500 char buf
[128], mime
[128];
504 if (tag
== MKTAG('.', 'r', 'a', 0xfd)) {
505 /* very old .ra format */
506 return rm_read_header_old(s
);
507 } else if (tag
!= MKTAG('.', 'R', 'M', 'F')) {
511 tag_size
= avio_rb32(pb
);
512 avio_skip(pb
, tag_size
- 8);
518 tag_size
= avio_rb32(pb
);
520 av_dlog(s
, "tag=%c%c%c%c (%08x) size=%d\n",
527 if (tag_size
< 10 && tag
!= MKTAG('D', 'A', 'T', 'A'))
530 case MKTAG('P', 'R', 'O', 'P'):
532 avio_rb32(pb
); /* max bit rate */
533 avio_rb32(pb
); /* avg bit rate */
534 avio_rb32(pb
); /* max packet size */
535 avio_rb32(pb
); /* avg packet size */
536 avio_rb32(pb
); /* nb packets */
537 duration
= avio_rb32(pb
); /* duration */
538 s
->duration
= av_rescale(duration
, AV_TIME_BASE
, 1000);
539 avio_rb32(pb
); /* preroll */
540 indx_off
= avio_rb32(pb
); /* index offset */
541 data_off
= avio_rb32(pb
); /* data offset */
542 avio_rb16(pb
); /* nb streams */
543 flags
= avio_rb16(pb
); /* flags */
545 case MKTAG('C', 'O', 'N', 'T'):
546 rm_read_metadata(s
, pb
, 1);
548 case MKTAG('M', 'D', 'P', 'R'):
549 st
= avformat_new_stream(s
, NULL
);
551 return AVERROR(ENOMEM
);
552 st
->id
= avio_rb16(pb
);
553 avio_rb32(pb
); /* max bit rate */
554 st
->codec
->bit_rate
= avio_rb32(pb
); /* bit rate */
555 avio_rb32(pb
); /* max packet size */
556 avio_rb32(pb
); /* avg packet size */
557 start_time
= avio_rb32(pb
); /* start time */
558 avio_rb32(pb
); /* preroll */
559 duration
= avio_rb32(pb
); /* duration */
560 st
->start_time
= start_time
;
561 st
->duration
= duration
;
563 s
->duration
= AV_NOPTS_VALUE
;
564 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
565 get_str8(pb
, mime
, sizeof(mime
)); /* mimetype */
566 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
567 st
->priv_data
= ff_rm_alloc_rmstream();
568 if (ff_rm_read_mdpr_codecdata(s
, s
->pb
, st
, st
->priv_data
,
569 avio_rb32(pb
), mime
) < 0)
572 case MKTAG('D', 'A', 'T', 'A'):
575 /* unknown tag: skip it */
576 avio_skip(pb
, tag_size
- 10);
581 rm
->nb_packets
= avio_rb32(pb
); /* number of packets */
582 if (!rm
->nb_packets
&& (flags
& 4))
583 rm
->nb_packets
= 3600 * 25;
584 avio_rb32(pb
); /* next data header */
587 data_off
= avio_tell(pb
) - 18;
588 if (indx_off
&& pb
->seekable
&& !(s
->flags
& AVFMT_FLAG_IGNIDX
) &&
589 avio_seek(pb
, indx_off
, SEEK_SET
) >= 0) {
591 avio_seek(pb
, data_off
+ 18, SEEK_SET
);
597 static int get_num(AVIOContext
*pb
, int *len
)
609 return (n
<< 16) | n1
;
613 /* multiple of 20 bytes for ra144 (ugly) */
614 #define RAW_PACKET_SIZE 1000
616 static int rm_sync(AVFormatContext
*s
, int64_t *timestamp
, int *flags
, int *stream_index
, int64_t *pos
){
617 RMDemuxContext
*rm
= s
->priv_data
;
618 AVIOContext
*pb
= s
->pb
;
620 uint32_t state
=0xFFFFFFFF;
622 while(!avio_feof(pb
)){
624 *pos
= avio_tell(pb
) - 3;
625 if(rm
->remaining_len
> 0){
626 num
= rm
->current_stream
;
627 len
= rm
->remaining_len
;
628 *timestamp
= AV_NOPTS_VALUE
;
631 state
= (state
<<8) + avio_r8(pb
);
633 if(state
== MKBETAG('I', 'N', 'D', 'X')){
634 int n_pkts
, expected_len
;
637 n_pkts
= avio_rb32(pb
);
638 expected_len
= 20 + n_pkts
* 14;
640 /* some files don't add index entries to chunk size... */
642 else if (len
!= expected_len
)
643 av_log(s
, AV_LOG_WARNING
,
644 "Index size %d (%d pkts) is wrong, should be %d.\n",
645 len
, n_pkts
, expected_len
);
646 len
-= 14; // we already read part of the index header
650 } else if (state
== MKBETAG('D','A','T','A')) {
651 av_log(s
, AV_LOG_WARNING
,
652 "DATA tag in middle of chunk, file may be broken.\n");
655 if(state
> (unsigned)0xFFFF || state
<= 12)
661 *timestamp
= avio_rb32(pb
);
662 avio_r8(pb
); /* reserved */
663 *flags
= avio_r8(pb
); /* flags */
665 for(i
=0;i
<s
->nb_streams
;i
++) {
670 if (i
== s
->nb_streams
) {
672 /* skip packet if unknown number */
674 rm
->remaining_len
= 0;
684 static int rm_assemble_video_frame(AVFormatContext
*s
, AVIOContext
*pb
,
685 RMDemuxContext
*rm
, RMStream
*vst
,
686 AVPacket
*pkt
, int len
, int *pseq
,
690 int seq
= 0, pic_num
= 0, len2
= 0, pos
= 0; //init to silcense compiler warning
694 hdr
= avio_r8(pb
); len
--;
697 if(type
!= 3){ // not frame as a part of packet
698 seq
= avio_r8(pb
); len
--;
700 if(type
!= 1){ // not whole frame
701 len2
= get_num(pb
, &len
);
702 pos
= get_num(pb
, &len
);
703 pic_num
= avio_r8(pb
); len
--;
706 av_log(s
, AV_LOG_ERROR
, "Insufficient data\n");
709 rm
->remaining_len
= len
;
710 if(type
&1){ // frame, not slice
711 if(type
== 3){ // frame as a part of packet
715 if(rm
->remaining_len
< len
) {
716 av_log(s
, AV_LOG_ERROR
, "Insufficient remaining len\n");
719 rm
->remaining_len
-= len
;
720 if(av_new_packet(pkt
, len
+ 9) < 0)
723 AV_WL32(pkt
->data
+ 1, 1);
724 AV_WL32(pkt
->data
+ 5, 0);
725 if ((ret
= avio_read(pb
, pkt
->data
+ 9, len
)) != len
) {
727 av_log(s
, AV_LOG_ERROR
, "Failed to read %d bytes\n", len
);
728 return ret
< 0 ? ret
: AVERROR(EIO
);
732 //now we have to deal with single slice
735 if((seq
& 0x7F) == 1 || vst
->curpic_num
!= pic_num
){
736 if (len2
> ffio_limit(pb
, len2
)) {
737 av_log(s
, AV_LOG_ERROR
, "Impossibly sized packet\n");
738 return AVERROR_INVALIDDATA
;
740 vst
->slices
= ((hdr
& 0x3F) << 1) + 1;
741 vst
->videobufsize
= len2
+ 8*vst
->slices
+ 1;
742 av_free_packet(&vst
->pkt
); //FIXME this should be output.
743 if(av_new_packet(&vst
->pkt
, vst
->videobufsize
) < 0)
744 return AVERROR(ENOMEM
);
745 memset(vst
->pkt
.data
, 0, vst
->pkt
.size
);
746 vst
->videobufpos
= 8*vst
->slices
+ 1;
748 vst
->curpic_num
= pic_num
;
749 vst
->pktpos
= avio_tell(pb
);
752 len
= FFMIN(len
, pos
);
754 if(++vst
->cur_slice
> vst
->slices
) {
755 av_log(s
, AV_LOG_ERROR
, "cur slice %d, too large\n", vst
->cur_slice
);
759 return AVERROR(ENOMEM
);
760 AV_WL32(vst
->pkt
.data
- 7 + 8*vst
->cur_slice
, 1);
761 AV_WL32(vst
->pkt
.data
- 3 + 8*vst
->cur_slice
, vst
->videobufpos
- 8*vst
->slices
- 1);
762 if(vst
->videobufpos
+ len
> vst
->videobufsize
) {
763 av_log(s
, AV_LOG_ERROR
, "outside videobufsize\n");
766 if (avio_read(pb
, vst
->pkt
.data
+ vst
->videobufpos
, len
) != len
)
768 vst
->videobufpos
+= len
;
769 rm
->remaining_len
-= len
;
771 if (type
== 2 || vst
->videobufpos
== vst
->videobufsize
) {
772 vst
->pkt
.data
[0] = vst
->cur_slice
-1;
777 #if FF_API_DESTRUCT_PACKET
778 FF_DISABLE_DEPRECATION_WARNINGS
779 vst
->pkt
.destruct
= NULL
;
780 FF_ENABLE_DEPRECATION_WARNINGS
782 if(vst
->slices
!= vst
->cur_slice
) //FIXME find out how to set slices correct from the begin
783 memmove(pkt
->data
+ 1 + 8*vst
->cur_slice
, pkt
->data
+ 1 + 8*vst
->slices
,
784 vst
->videobufpos
- 1 - 8*vst
->slices
);
785 pkt
->size
= vst
->videobufpos
+ 8*(vst
->cur_slice
- vst
->slices
);
786 pkt
->pts
= AV_NOPTS_VALUE
;
787 pkt
->pos
= vst
->pktpos
;
796 rm_ac3_swap_bytes (AVStream
*st
, AVPacket
*pkt
)
801 if (st
->codec
->codec_id
== AV_CODEC_ID_AC3
) {
803 for (j
=0;j
<pkt
->size
;j
+=2) {
804 FFSWAP(int, ptr
[0], ptr
[1]);
810 static int readfull(AVFormatContext
*s
, AVIOContext
*pb
, uint8_t *dst
, int n
) {
811 int ret
= avio_read(pb
, dst
, n
);
813 if (ret
>= 0) memset(dst
+ ret
, 0, n
- ret
);
814 else memset(dst
, 0, n
);
815 av_log(s
, AV_LOG_ERROR
, "Failed to fully read block\n");
821 ff_rm_parse_packet (AVFormatContext
*s
, AVIOContext
*pb
,
822 AVStream
*st
, RMStream
*ast
, int len
, AVPacket
*pkt
,
823 int *seq
, int flags
, int64_t timestamp
)
825 RMDemuxContext
*rm
= s
->priv_data
;
828 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
829 rm
->current_stream
= st
->id
;
830 ret
= rm_assemble_video_frame(s
, pb
, rm
, ast
, pkt
, len
, seq
, ×tamp
);
832 return ret
< 0 ? ret
: -1; //got partial frame or error
833 } else if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
834 if ((ast
->deint_id
== DEINT_ID_GENR
) ||
835 (ast
->deint_id
== DEINT_ID_INT4
) ||
836 (ast
->deint_id
== DEINT_ID_SIPR
)) {
838 int sps
= ast
->sub_packet_size
;
839 int cfs
= ast
->coded_framesize
;
840 int h
= ast
->sub_packet_h
;
841 int y
= ast
->sub_packet_cnt
;
842 int w
= ast
->audio_framesize
;
845 y
= ast
->sub_packet_cnt
= 0;
847 ast
->audiotimestamp
= timestamp
;
849 switch (ast
->deint_id
) {
851 for (x
= 0; x
< h
/2; x
++)
852 readfull(s
, pb
, ast
->pkt
.data
+x
*2*w
+y
*cfs
, cfs
);
855 for (x
= 0; x
< w
/sps
; x
++)
856 readfull(s
, pb
, ast
->pkt
.data
+sps
*(h
*x
+((h
+1)/2)*(y
&1)+(y
>>1)), sps
);
859 readfull(s
, pb
, ast
->pkt
.data
+ y
* w
, w
);
863 if (++(ast
->sub_packet_cnt
) < h
)
865 if (ast
->deint_id
== DEINT_ID_SIPR
)
866 ff_rm_reorder_sipr_data(ast
->pkt
.data
, h
, w
);
868 ast
->sub_packet_cnt
= 0;
869 rm
->audio_stream_num
= st
->index
;
870 rm
->audio_pkt_cnt
= h
* w
/ st
->codec
->block_align
;
871 } else if ((ast
->deint_id
== DEINT_ID_VBRF
) ||
872 (ast
->deint_id
== DEINT_ID_VBRS
)) {
874 rm
->audio_stream_num
= st
->index
;
875 ast
->sub_packet_cnt
= (avio_rb16(pb
) & 0xf0) >> 4;
876 if (ast
->sub_packet_cnt
) {
877 for (x
= 0; x
< ast
->sub_packet_cnt
; x
++)
878 ast
->sub_packet_lengths
[x
] = avio_rb16(pb
);
879 rm
->audio_pkt_cnt
= ast
->sub_packet_cnt
;
880 ast
->audiotimestamp
= timestamp
;
884 av_get_packet(pb
, pkt
, len
);
885 rm_ac3_swap_bytes(st
, pkt
);
888 av_get_packet(pb
, pkt
, len
);
890 pkt
->stream_index
= st
->index
;
893 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
894 if(st
->codec
->codec_id
== AV_CODEC_ID_RV20
){
895 int seq
= 128*(pkt
->data
[2]&0x7F) + (pkt
->data
[3]>>1);
896 av_log(s
, AV_LOG_DEBUG
, "%d %"PRId64
" %d\n", *timestamp
, *timestamp
*512LL/25, seq
);
898 seq
|= (timestamp
&~0x3FFF);
899 if(seq
- timestamp
> 0x2000) seq
-= 0x4000;
900 if(seq
- timestamp
< -0x2000) seq
+= 0x4000;
905 pkt
->pts
= timestamp
;
907 pkt
->flags
|= AV_PKT_FLAG_KEY
;
909 return st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
? rm
->audio_pkt_cnt
: 0;
913 ff_rm_retrieve_cache (AVFormatContext
*s
, AVIOContext
*pb
,
914 AVStream
*st
, RMStream
*ast
, AVPacket
*pkt
)
916 RMDemuxContext
*rm
= s
->priv_data
;
918 av_assert0 (rm
->audio_pkt_cnt
> 0);
920 if (ast
->deint_id
== DEINT_ID_VBRF
||
921 ast
->deint_id
== DEINT_ID_VBRS
)
922 av_get_packet(pb
, pkt
, ast
->sub_packet_lengths
[ast
->sub_packet_cnt
- rm
->audio_pkt_cnt
]);
924 int ret
= av_new_packet(pkt
, st
->codec
->block_align
);
927 memcpy(pkt
->data
, ast
->pkt
.data
+ st
->codec
->block_align
* //FIXME avoid this
928 (ast
->sub_packet_h
* ast
->audio_framesize
/ st
->codec
->block_align
- rm
->audio_pkt_cnt
),
929 st
->codec
->block_align
);
932 if ((pkt
->pts
= ast
->audiotimestamp
) != AV_NOPTS_VALUE
) {
933 ast
->audiotimestamp
= AV_NOPTS_VALUE
;
934 pkt
->flags
= AV_PKT_FLAG_KEY
;
937 pkt
->stream_index
= st
->index
;
939 return rm
->audio_pkt_cnt
;
942 static int rm_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
944 RMDemuxContext
*rm
= s
->priv_data
;
945 AVStream
*st
= NULL
; // init to silence compiler warning
946 int i
, len
, res
, seq
= 1;
947 int64_t timestamp
, pos
;
951 if (rm
->audio_pkt_cnt
) {
952 // If there are queued audio packet return them first
953 st
= s
->streams
[rm
->audio_stream_num
];
954 res
= ff_rm_retrieve_cache(s
, s
->pb
, st
, st
->priv_data
, pkt
);
959 if (rm
->old_format
) {
964 timestamp
= AV_NOPTS_VALUE
;
965 len
= !ast
->audio_framesize
? RAW_PACKET_SIZE
:
966 ast
->coded_framesize
* ast
->sub_packet_h
/ 2;
967 flags
= (seq
++ == 1) ? 2 : 0;
968 pos
= avio_tell(s
->pb
);
970 len
= rm_sync(s
, ×tamp
, &flags
, &i
, &pos
);
975 if (len
<= 0 || avio_feof(s
->pb
))
978 res
= ff_rm_parse_packet (s
, s
->pb
, st
, st
->priv_data
, len
, pkt
,
979 &seq
, flags
, timestamp
);
982 if((flags
&2) && (seq
&0x7F) == 1)
983 av_add_index_entry(st
, pos
, timestamp
, 0, 0, AVINDEX_KEYFRAME
);
988 if( (st
->discard
>= AVDISCARD_NONKEY
&& !(flags
&2))
989 || st
->discard
>= AVDISCARD_ALL
){
998 static int rm_read_close(AVFormatContext
*s
)
1002 for (i
=0;i
<s
->nb_streams
;i
++)
1003 ff_rm_free_rmstream(s
->streams
[i
]->priv_data
);
1008 static int rm_probe(AVProbeData
*p
)
1010 /* check file header */
1011 if ((p
->buf
[0] == '.' && p
->buf
[1] == 'R' &&
1012 p
->buf
[2] == 'M' && p
->buf
[3] == 'F' &&
1013 p
->buf
[4] == 0 && p
->buf
[5] == 0) ||
1014 (p
->buf
[0] == '.' && p
->buf
[1] == 'r' &&
1015 p
->buf
[2] == 'a' && p
->buf
[3] == 0xfd))
1016 return AVPROBE_SCORE_MAX
;
1021 static int64_t rm_read_dts(AVFormatContext
*s
, int stream_index
,
1022 int64_t *ppos
, int64_t pos_limit
)
1024 RMDemuxContext
*rm
= s
->priv_data
;
1026 int stream_index2
, flags
, len
, h
;
1031 return AV_NOPTS_VALUE
;
1033 if (avio_seek(s
->pb
, pos
, SEEK_SET
) < 0)
1034 return AV_NOPTS_VALUE
;
1036 rm
->remaining_len
=0;
1041 len
= rm_sync(s
, &dts
, &flags
, &stream_index2
, &pos
);
1043 return AV_NOPTS_VALUE
;
1045 st
= s
->streams
[stream_index2
];
1046 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1047 h
= avio_r8(s
->pb
); len
--;
1049 seq
= avio_r8(s
->pb
); len
--;
1053 if((flags
&2) && (seq
&0x7F) == 1){
1054 av_dlog(s
, "%d %d-%d %"PRId64
" %d\n",
1055 flags
, stream_index2
, stream_index
, dts
, seq
);
1056 av_add_index_entry(st
, pos
, dts
, 0, 0, AVINDEX_KEYFRAME
);
1057 if(stream_index2
== stream_index
)
1061 avio_skip(s
->pb
, len
);
1067 static int rm_read_seek(AVFormatContext
*s
, int stream_index
,
1068 int64_t pts
, int flags
)
1070 RMDemuxContext
*rm
= s
->priv_data
;
1072 if (ff_seek_frame_binary(s
, stream_index
, pts
, flags
) < 0)
1074 rm
->audio_pkt_cnt
= 0;
1079 AVInputFormat ff_rm_demuxer
= {
1081 .long_name
= NULL_IF_CONFIG_SMALL("RealMedia"),
1082 .priv_data_size
= sizeof(RMDemuxContext
),
1083 .read_probe
= rm_probe
,
1084 .read_header
= rm_read_header
,
1085 .read_packet
= rm_read_packet
,
1086 .read_close
= rm_read_close
,
1087 .read_timestamp
= rm_read_dts
,
1088 .read_seek
= rm_read_seek
,
1091 AVInputFormat ff_rdt_demuxer
= {
1093 .long_name
= NULL_IF_CONFIG_SMALL("RDT demuxer"),
1094 .priv_data_size
= sizeof(RMDemuxContext
),
1095 .read_close
= rm_read_close
,
1096 .flags
= AVFMT_NOFILE
,