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 avpriv_set_pts_info(st
, 64, 1, 1000);
316 codec_pos
= avio_tell(pb
);
319 if (v
== MKBETAG('M', 'L', 'T', 'I')) {
320 int number_of_streams
= avio_rb16(pb
);
323 for (i
= 0; i
<number_of_streams
; i
++)
325 number_of_mdpr
= avio_rb16(pb
);
326 if (number_of_mdpr
!= 1) {
327 avpriv_request_sample(s
, "MLTI with multiple MDPR");
333 if (v
== MKTAG(0xfd, 'a', 'r', '.')) {
335 if (rm_read_audio_stream_info(s
, pb
, st
, rst
, 0))
337 } else if (v
== MKBETAG('L', 'S', 'D', ':')) {
338 avio_seek(pb
, -4, SEEK_CUR
);
339 if ((ret
= rm_read_extradata(pb
, st
->codec
, codec_data_size
)) < 0)
342 st
->codec
->codec_type
= AVMEDIA_TYPE_AUDIO
;
343 st
->codec
->codec_tag
= AV_RL32(st
->codec
->extradata
);
344 st
->codec
->codec_id
= ff_codec_get_id(ff_rm_codec_tags
,
345 st
->codec
->codec_tag
);
346 } else if(mime
&& !strcmp(mime
, "logical-fileinfo")){
347 int stream_count
, rule_count
, property_count
, i
;
348 ff_free_stream(s
, st
);
349 if (avio_rb16(pb
) != 0) {
350 av_log(s
, AV_LOG_WARNING
, "Unsupported version\n");
353 stream_count
= avio_rb16(pb
);
354 avio_skip(pb
, 6*stream_count
);
355 rule_count
= avio_rb16(pb
);
356 avio_skip(pb
, 2*rule_count
);
357 property_count
= avio_rb16(pb
);
358 for(i
=0; i
<property_count
; i
++){
359 uint8_t name
[128], val
[128];
361 if (avio_rb16(pb
) != 0) {
362 av_log(s
, AV_LOG_WARNING
, "Unsupported Name value property version\n");
363 goto skip
; //FIXME skip just this one
365 get_str8(pb
, name
, sizeof(name
));
366 switch(avio_rb32(pb
)) {
367 case 2: get_strl(pb
, val
, sizeof(val
), avio_rb16(pb
));
368 av_dict_set(&s
->metadata
, name
, val
, 0);
370 default: avio_skip(pb
, avio_rb16(pb
));
375 if (avio_rl32(pb
) != MKTAG('V', 'I', 'D', 'O')) {
377 av_log(s
, AV_LOG_WARNING
, "Unsupported stream type %08x\n", v
);
380 st
->codec
->codec_tag
= avio_rl32(pb
);
381 st
->codec
->codec_id
= ff_codec_get_id(ff_rm_codec_tags
,
382 st
->codec
->codec_tag
);
383 av_dlog(s
, "%X %X\n", st
->codec
->codec_tag
, MKTAG('R', 'V', '2', '0'));
384 if (st
->codec
->codec_id
== AV_CODEC_ID_NONE
)
386 st
->codec
->width
= avio_rb16(pb
);
387 st
->codec
->height
= avio_rb16(pb
);
388 avio_skip(pb
, 2); // looks like bits per sample
389 avio_skip(pb
, 4); // always zero?
390 st
->codec
->codec_type
= AVMEDIA_TYPE_VIDEO
;
391 st
->need_parsing
= AVSTREAM_PARSE_TIMESTAMPS
;
394 if ((ret
= rm_read_extradata(pb
, st
->codec
, codec_data_size
- (avio_tell(pb
) - codec_pos
))) < 0)
398 av_reduce(&st
->avg_frame_rate
.den
, &st
->avg_frame_rate
.num
,
399 0x10000, fps
, (1 << 30) - 1);
400 #if FF_API_R_FRAME_RATE
401 st
->r_frame_rate
= st
->avg_frame_rate
;
403 } else if (s
->error_recognition
& AV_EF_EXPLODE
) {
404 av_log(s
, AV_LOG_ERROR
, "Invalid framerate\n");
405 return AVERROR_INVALIDDATA
;
410 /* skip codec info */
411 size
= avio_tell(pb
) - codec_pos
;
412 avio_skip(pb
, codec_data_size
- size
);
417 /** this function assumes that the demuxer has already seeked to the start
418 * of the INDX chunk, and will bail out if not. */
419 static int rm_read_index(AVFormatContext
*s
)
421 AVIOContext
*pb
= s
->pb
;
422 unsigned int size
, n_pkts
, str_id
, next_off
, n
, pos
, pts
;
426 if (avio_rl32(pb
) != MKTAG('I','N','D','X'))
428 size
= avio_rb32(pb
);
432 n_pkts
= avio_rb32(pb
);
433 str_id
= avio_rb16(pb
);
434 next_off
= avio_rb32(pb
);
435 for (n
= 0; n
< s
->nb_streams
; n
++)
436 if (s
->streams
[n
]->id
== str_id
) {
440 if (n
== s
->nb_streams
) {
441 av_log(s
, AV_LOG_ERROR
,
442 "Invalid stream index %d for index at pos %"PRId64
"\n",
443 str_id
, avio_tell(pb
));
445 } else if ((avio_size(pb
) - avio_tell(pb
)) / 14 < n_pkts
) {
446 av_log(s
, AV_LOG_ERROR
,
447 "Nr. of packets in packet index for stream index %d "
448 "exceeds filesize (%"PRId64
" at %"PRId64
" = %"PRId64
")\n",
449 str_id
, avio_size(pb
), avio_tell(pb
),
450 (avio_size(pb
) - avio_tell(pb
)) / 14);
454 for (n
= 0; n
< n_pkts
; n
++) {
458 avio_skip(pb
, 4); /* packet no. */
460 av_add_index_entry(st
, pos
, pts
, 0, 0, AVINDEX_KEYFRAME
);
464 if (next_off
&& avio_tell(pb
) < next_off
&&
465 avio_seek(pb
, next_off
, SEEK_SET
) < 0) {
466 av_log(s
, AV_LOG_ERROR
,
467 "Non-linear index detected, not supported\n");
475 static int rm_read_header_old(AVFormatContext
*s
)
477 RMDemuxContext
*rm
= s
->priv_data
;
481 st
= avformat_new_stream(s
, NULL
);
484 st
->priv_data
= ff_rm_alloc_rmstream();
485 return rm_read_audio_stream_info(s
, s
->pb
, st
, st
->priv_data
, 1);
488 static int rm_read_header(AVFormatContext
*s
)
490 RMDemuxContext
*rm
= s
->priv_data
;
492 AVIOContext
*pb
= s
->pb
;
495 unsigned int start_time
, duration
;
496 unsigned int data_off
= 0, indx_off
= 0;
497 char buf
[128], mime
[128];
501 if (tag
== MKTAG('.', 'r', 'a', 0xfd)) {
502 /* very old .ra format */
503 return rm_read_header_old(s
);
504 } else if (tag
!= MKTAG('.', 'R', 'M', 'F')) {
508 tag_size
= avio_rb32(pb
);
509 avio_skip(pb
, tag_size
- 8);
515 tag_size
= avio_rb32(pb
);
517 av_dlog(s
, "tag=%c%c%c%c (%08x) size=%d\n",
524 if (tag_size
< 10 && tag
!= MKTAG('D', 'A', 'T', 'A'))
527 case MKTAG('P', 'R', 'O', 'P'):
529 avio_rb32(pb
); /* max bit rate */
530 avio_rb32(pb
); /* avg bit rate */
531 avio_rb32(pb
); /* max packet size */
532 avio_rb32(pb
); /* avg packet size */
533 avio_rb32(pb
); /* nb packets */
534 duration
= avio_rb32(pb
); /* duration */
535 s
->duration
= av_rescale(duration
, AV_TIME_BASE
, 1000);
536 avio_rb32(pb
); /* preroll */
537 indx_off
= avio_rb32(pb
); /* index offset */
538 data_off
= avio_rb32(pb
); /* data offset */
539 avio_rb16(pb
); /* nb streams */
540 flags
= avio_rb16(pb
); /* flags */
542 case MKTAG('C', 'O', 'N', 'T'):
543 rm_read_metadata(s
, pb
, 1);
545 case MKTAG('M', 'D', 'P', 'R'):
546 st
= avformat_new_stream(s
, NULL
);
548 return AVERROR(ENOMEM
);
549 st
->id
= avio_rb16(pb
);
550 avio_rb32(pb
); /* max bit rate */
551 st
->codec
->bit_rate
= avio_rb32(pb
); /* bit rate */
552 avio_rb32(pb
); /* max packet size */
553 avio_rb32(pb
); /* avg packet size */
554 start_time
= avio_rb32(pb
); /* start time */
555 avio_rb32(pb
); /* preroll */
556 duration
= avio_rb32(pb
); /* duration */
557 st
->start_time
= start_time
;
558 st
->duration
= duration
;
560 s
->duration
= AV_NOPTS_VALUE
;
561 get_str8(pb
, buf
, sizeof(buf
)); /* desc */
562 get_str8(pb
, mime
, sizeof(mime
)); /* mimetype */
563 st
->codec
->codec_type
= AVMEDIA_TYPE_DATA
;
564 st
->priv_data
= ff_rm_alloc_rmstream();
565 if (ff_rm_read_mdpr_codecdata(s
, s
->pb
, st
, st
->priv_data
,
566 avio_rb32(pb
), mime
) < 0)
569 case MKTAG('D', 'A', 'T', 'A'):
572 /* unknown tag: skip it */
573 avio_skip(pb
, tag_size
- 10);
578 rm
->nb_packets
= avio_rb32(pb
); /* number of packets */
579 if (!rm
->nb_packets
&& (flags
& 4))
580 rm
->nb_packets
= 3600 * 25;
581 avio_rb32(pb
); /* next data header */
584 data_off
= avio_tell(pb
) - 18;
585 if (indx_off
&& pb
->seekable
&& !(s
->flags
& AVFMT_FLAG_IGNIDX
) &&
586 avio_seek(pb
, indx_off
, SEEK_SET
) >= 0) {
588 avio_seek(pb
, data_off
+ 18, SEEK_SET
);
594 static int get_num(AVIOContext
*pb
, int *len
)
606 return (n
<< 16) | n1
;
610 /* multiple of 20 bytes for ra144 (ugly) */
611 #define RAW_PACKET_SIZE 1000
613 static int sync(AVFormatContext
*s
, int64_t *timestamp
, int *flags
, int *stream_index
, int64_t *pos
){
614 RMDemuxContext
*rm
= s
->priv_data
;
615 AVIOContext
*pb
= s
->pb
;
617 uint32_t state
=0xFFFFFFFF;
619 while(!avio_feof(pb
)){
621 *pos
= avio_tell(pb
) - 3;
622 if(rm
->remaining_len
> 0){
623 num
= rm
->current_stream
;
624 len
= rm
->remaining_len
;
625 *timestamp
= AV_NOPTS_VALUE
;
628 state
= (state
<<8) + avio_r8(pb
);
630 if(state
== MKBETAG('I', 'N', 'D', 'X')){
631 int n_pkts
, expected_len
;
634 n_pkts
= avio_rb32(pb
);
635 expected_len
= 20 + n_pkts
* 14;
637 /* some files don't add index entries to chunk size... */
639 else if (len
!= expected_len
)
640 av_log(s
, AV_LOG_WARNING
,
641 "Index size %d (%d pkts) is wrong, should be %d.\n",
642 len
, n_pkts
, expected_len
);
643 len
-= 14; // we already read part of the index header
647 } else if (state
== MKBETAG('D','A','T','A')) {
648 av_log(s
, AV_LOG_WARNING
,
649 "DATA tag in middle of chunk, file may be broken.\n");
652 if(state
> (unsigned)0xFFFF || state
<= 12)
658 *timestamp
= avio_rb32(pb
);
659 avio_r8(pb
); /* reserved */
660 *flags
= avio_r8(pb
); /* flags */
662 for(i
=0;i
<s
->nb_streams
;i
++) {
667 if (i
== s
->nb_streams
) {
669 /* skip packet if unknown number */
671 rm
->remaining_len
= 0;
681 static int rm_assemble_video_frame(AVFormatContext
*s
, AVIOContext
*pb
,
682 RMDemuxContext
*rm
, RMStream
*vst
,
683 AVPacket
*pkt
, int len
, int *pseq
,
687 int seq
= 0, pic_num
= 0, len2
= 0, pos
= 0; //init to silcense compiler warning
691 hdr
= avio_r8(pb
); len
--;
694 if(type
!= 3){ // not frame as a part of packet
695 seq
= avio_r8(pb
); len
--;
697 if(type
!= 1){ // not whole frame
698 len2
= get_num(pb
, &len
);
699 pos
= get_num(pb
, &len
);
700 pic_num
= avio_r8(pb
); len
--;
703 av_log(s
, AV_LOG_ERROR
, "Insufficient data\n");
706 rm
->remaining_len
= len
;
707 if(type
&1){ // frame, not slice
708 if(type
== 3){ // frame as a part of packet
712 if(rm
->remaining_len
< len
) {
713 av_log(s
, AV_LOG_ERROR
, "Insufficient remaining len\n");
716 rm
->remaining_len
-= len
;
717 if(av_new_packet(pkt
, len
+ 9) < 0)
720 AV_WL32(pkt
->data
+ 1, 1);
721 AV_WL32(pkt
->data
+ 5, 0);
722 if ((ret
= avio_read(pb
, pkt
->data
+ 9, len
)) != len
) {
724 av_log(s
, AV_LOG_ERROR
, "Failed to read %d bytes\n", len
);
725 return ret
< 0 ? ret
: AVERROR(EIO
);
729 //now we have to deal with single slice
732 if((seq
& 0x7F) == 1 || vst
->curpic_num
!= pic_num
){
733 if (len2
> ffio_limit(pb
, len2
)) {
734 av_log(s
, AV_LOG_ERROR
, "Impossibly sized packet\n");
735 return AVERROR_INVALIDDATA
;
737 vst
->slices
= ((hdr
& 0x3F) << 1) + 1;
738 vst
->videobufsize
= len2
+ 8*vst
->slices
+ 1;
739 av_free_packet(&vst
->pkt
); //FIXME this should be output.
740 if(av_new_packet(&vst
->pkt
, vst
->videobufsize
) < 0)
741 return AVERROR(ENOMEM
);
742 memset(vst
->pkt
.data
, 0, vst
->pkt
.size
);
743 vst
->videobufpos
= 8*vst
->slices
+ 1;
745 vst
->curpic_num
= pic_num
;
746 vst
->pktpos
= avio_tell(pb
);
749 len
= FFMIN(len
, pos
);
751 if(++vst
->cur_slice
> vst
->slices
) {
752 av_log(s
, AV_LOG_ERROR
, "cur slice %d, too large\n", vst
->cur_slice
);
756 return AVERROR(ENOMEM
);
757 AV_WL32(vst
->pkt
.data
- 7 + 8*vst
->cur_slice
, 1);
758 AV_WL32(vst
->pkt
.data
- 3 + 8*vst
->cur_slice
, vst
->videobufpos
- 8*vst
->slices
- 1);
759 if(vst
->videobufpos
+ len
> vst
->videobufsize
) {
760 av_log(s
, AV_LOG_ERROR
, "outside videobufsize\n");
763 if (avio_read(pb
, vst
->pkt
.data
+ vst
->videobufpos
, len
) != len
)
765 vst
->videobufpos
+= len
;
766 rm
->remaining_len
-= len
;
768 if (type
== 2 || vst
->videobufpos
== vst
->videobufsize
) {
769 vst
->pkt
.data
[0] = vst
->cur_slice
-1;
774 #if FF_API_DESTRUCT_PACKET
775 FF_DISABLE_DEPRECATION_WARNINGS
776 vst
->pkt
.destruct
= NULL
;
777 FF_ENABLE_DEPRECATION_WARNINGS
779 if(vst
->slices
!= vst
->cur_slice
) //FIXME find out how to set slices correct from the begin
780 memmove(pkt
->data
+ 1 + 8*vst
->cur_slice
, pkt
->data
+ 1 + 8*vst
->slices
,
781 vst
->videobufpos
- 1 - 8*vst
->slices
);
782 pkt
->size
= vst
->videobufpos
+ 8*(vst
->cur_slice
- vst
->slices
);
783 pkt
->pts
= AV_NOPTS_VALUE
;
784 pkt
->pos
= vst
->pktpos
;
793 rm_ac3_swap_bytes (AVStream
*st
, AVPacket
*pkt
)
798 if (st
->codec
->codec_id
== AV_CODEC_ID_AC3
) {
800 for (j
=0;j
<pkt
->size
;j
+=2) {
801 FFSWAP(int, ptr
[0], ptr
[1]);
807 static int readfull(AVFormatContext
*s
, AVIOContext
*pb
, uint8_t *dst
, int n
) {
808 int ret
= avio_read(pb
, dst
, n
);
810 if (ret
>= 0) memset(dst
+ ret
, 0, n
- ret
);
811 else memset(dst
, 0, n
);
812 av_log(s
, AV_LOG_ERROR
, "Failed to fully read block\n");
818 ff_rm_parse_packet (AVFormatContext
*s
, AVIOContext
*pb
,
819 AVStream
*st
, RMStream
*ast
, int len
, AVPacket
*pkt
,
820 int *seq
, int flags
, int64_t timestamp
)
822 RMDemuxContext
*rm
= s
->priv_data
;
825 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
826 rm
->current_stream
= st
->id
;
827 ret
= rm_assemble_video_frame(s
, pb
, rm
, ast
, pkt
, len
, seq
, ×tamp
);
829 return ret
< 0 ? ret
: -1; //got partial frame or error
830 } else if (st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
) {
831 if ((ast
->deint_id
== DEINT_ID_GENR
) ||
832 (ast
->deint_id
== DEINT_ID_INT4
) ||
833 (ast
->deint_id
== DEINT_ID_SIPR
)) {
835 int sps
= ast
->sub_packet_size
;
836 int cfs
= ast
->coded_framesize
;
837 int h
= ast
->sub_packet_h
;
838 int y
= ast
->sub_packet_cnt
;
839 int w
= ast
->audio_framesize
;
842 y
= ast
->sub_packet_cnt
= 0;
844 ast
->audiotimestamp
= timestamp
;
846 switch (ast
->deint_id
) {
848 for (x
= 0; x
< h
/2; x
++)
849 readfull(s
, pb
, ast
->pkt
.data
+x
*2*w
+y
*cfs
, cfs
);
852 for (x
= 0; x
< w
/sps
; x
++)
853 readfull(s
, pb
, ast
->pkt
.data
+sps
*(h
*x
+((h
+1)/2)*(y
&1)+(y
>>1)), sps
);
856 readfull(s
, pb
, ast
->pkt
.data
+ y
* w
, w
);
860 if (++(ast
->sub_packet_cnt
) < h
)
862 if (ast
->deint_id
== DEINT_ID_SIPR
)
863 ff_rm_reorder_sipr_data(ast
->pkt
.data
, h
, w
);
865 ast
->sub_packet_cnt
= 0;
866 rm
->audio_stream_num
= st
->index
;
867 rm
->audio_pkt_cnt
= h
* w
/ st
->codec
->block_align
;
868 } else if ((ast
->deint_id
== DEINT_ID_VBRF
) ||
869 (ast
->deint_id
== DEINT_ID_VBRS
)) {
871 rm
->audio_stream_num
= st
->index
;
872 ast
->sub_packet_cnt
= (avio_rb16(pb
) & 0xf0) >> 4;
873 if (ast
->sub_packet_cnt
) {
874 for (x
= 0; x
< ast
->sub_packet_cnt
; x
++)
875 ast
->sub_packet_lengths
[x
] = avio_rb16(pb
);
876 rm
->audio_pkt_cnt
= ast
->sub_packet_cnt
;
877 ast
->audiotimestamp
= timestamp
;
881 av_get_packet(pb
, pkt
, len
);
882 rm_ac3_swap_bytes(st
, pkt
);
885 av_get_packet(pb
, pkt
, len
);
887 pkt
->stream_index
= st
->index
;
890 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
891 if(st
->codec
->codec_id
== AV_CODEC_ID_RV20
){
892 int seq
= 128*(pkt
->data
[2]&0x7F) + (pkt
->data
[3]>>1);
893 av_log(s
, AV_LOG_DEBUG
, "%d %"PRId64
" %d\n", *timestamp
, *timestamp
*512LL/25, seq
);
895 seq
|= (timestamp
&~0x3FFF);
896 if(seq
- timestamp
> 0x2000) seq
-= 0x4000;
897 if(seq
- timestamp
< -0x2000) seq
+= 0x4000;
902 pkt
->pts
= timestamp
;
904 pkt
->flags
|= AV_PKT_FLAG_KEY
;
906 return st
->codec
->codec_type
== AVMEDIA_TYPE_AUDIO
? rm
->audio_pkt_cnt
: 0;
910 ff_rm_retrieve_cache (AVFormatContext
*s
, AVIOContext
*pb
,
911 AVStream
*st
, RMStream
*ast
, AVPacket
*pkt
)
913 RMDemuxContext
*rm
= s
->priv_data
;
915 av_assert0 (rm
->audio_pkt_cnt
> 0);
917 if (ast
->deint_id
== DEINT_ID_VBRF
||
918 ast
->deint_id
== DEINT_ID_VBRS
)
919 av_get_packet(pb
, pkt
, ast
->sub_packet_lengths
[ast
->sub_packet_cnt
- rm
->audio_pkt_cnt
]);
921 if(av_new_packet(pkt
, st
->codec
->block_align
) < 0)
922 return AVERROR(ENOMEM
);
923 memcpy(pkt
->data
, ast
->pkt
.data
+ st
->codec
->block_align
* //FIXME avoid this
924 (ast
->sub_packet_h
* ast
->audio_framesize
/ st
->codec
->block_align
- rm
->audio_pkt_cnt
),
925 st
->codec
->block_align
);
928 if ((pkt
->pts
= ast
->audiotimestamp
) != AV_NOPTS_VALUE
) {
929 ast
->audiotimestamp
= AV_NOPTS_VALUE
;
930 pkt
->flags
= AV_PKT_FLAG_KEY
;
933 pkt
->stream_index
= st
->index
;
935 return rm
->audio_pkt_cnt
;
938 static int rm_read_packet(AVFormatContext
*s
, AVPacket
*pkt
)
940 RMDemuxContext
*rm
= s
->priv_data
;
941 AVStream
*st
= NULL
; // init to silence compiler warning
942 int i
, len
, res
, seq
= 1;
943 int64_t timestamp
, pos
;
947 if (rm
->audio_pkt_cnt
) {
948 // If there are queued audio packet return them first
949 st
= s
->streams
[rm
->audio_stream_num
];
950 res
= ff_rm_retrieve_cache(s
, s
->pb
, st
, st
->priv_data
, pkt
);
955 if (rm
->old_format
) {
960 timestamp
= AV_NOPTS_VALUE
;
961 len
= !ast
->audio_framesize
? RAW_PACKET_SIZE
:
962 ast
->coded_framesize
* ast
->sub_packet_h
/ 2;
963 flags
= (seq
++ == 1) ? 2 : 0;
964 pos
= avio_tell(s
->pb
);
966 len
=sync(s
, ×tamp
, &flags
, &i
, &pos
);
971 if(len
<0 || avio_feof(s
->pb
))
974 res
= ff_rm_parse_packet (s
, s
->pb
, st
, st
->priv_data
, len
, pkt
,
975 &seq
, flags
, timestamp
);
978 if((flags
&2) && (seq
&0x7F) == 1)
979 av_add_index_entry(st
, pos
, timestamp
, 0, 0, AVINDEX_KEYFRAME
);
984 if( (st
->discard
>= AVDISCARD_NONKEY
&& !(flags
&2))
985 || st
->discard
>= AVDISCARD_ALL
){
994 static int rm_read_close(AVFormatContext
*s
)
998 for (i
=0;i
<s
->nb_streams
;i
++)
999 ff_rm_free_rmstream(s
->streams
[i
]->priv_data
);
1004 static int rm_probe(AVProbeData
*p
)
1006 /* check file header */
1007 if ((p
->buf
[0] == '.' && p
->buf
[1] == 'R' &&
1008 p
->buf
[2] == 'M' && p
->buf
[3] == 'F' &&
1009 p
->buf
[4] == 0 && p
->buf
[5] == 0) ||
1010 (p
->buf
[0] == '.' && p
->buf
[1] == 'r' &&
1011 p
->buf
[2] == 'a' && p
->buf
[3] == 0xfd))
1012 return AVPROBE_SCORE_MAX
;
1017 static int64_t rm_read_dts(AVFormatContext
*s
, int stream_index
,
1018 int64_t *ppos
, int64_t pos_limit
)
1020 RMDemuxContext
*rm
= s
->priv_data
;
1022 int stream_index2
, flags
, len
, h
;
1027 return AV_NOPTS_VALUE
;
1029 if (avio_seek(s
->pb
, pos
, SEEK_SET
) < 0)
1030 return AV_NOPTS_VALUE
;
1032 rm
->remaining_len
=0;
1037 len
=sync(s
, &dts
, &flags
, &stream_index2
, &pos
);
1039 return AV_NOPTS_VALUE
;
1041 st
= s
->streams
[stream_index2
];
1042 if (st
->codec
->codec_type
== AVMEDIA_TYPE_VIDEO
) {
1043 h
= avio_r8(s
->pb
); len
--;
1045 seq
= avio_r8(s
->pb
); len
--;
1049 if((flags
&2) && (seq
&0x7F) == 1){
1050 av_dlog(s
, "%d %d-%d %"PRId64
" %d\n",
1051 flags
, stream_index2
, stream_index
, dts
, seq
);
1052 av_add_index_entry(st
, pos
, dts
, 0, 0, AVINDEX_KEYFRAME
);
1053 if(stream_index2
== stream_index
)
1057 avio_skip(s
->pb
, len
);
1063 static int rm_read_seek(AVFormatContext
*s
, int stream_index
,
1064 int64_t pts
, int flags
)
1066 RMDemuxContext
*rm
= s
->priv_data
;
1068 if (ff_seek_frame_binary(s
, stream_index
, pts
, flags
) < 0)
1070 rm
->audio_pkt_cnt
= 0;
1075 AVInputFormat ff_rm_demuxer
= {
1077 .long_name
= NULL_IF_CONFIG_SMALL("RealMedia"),
1078 .priv_data_size
= sizeof(RMDemuxContext
),
1079 .read_probe
= rm_probe
,
1080 .read_header
= rm_read_header
,
1081 .read_packet
= rm_read_packet
,
1082 .read_close
= rm_read_close
,
1083 .read_timestamp
= rm_read_dts
,
1084 .read_seek
= rm_read_seek
,
1087 AVInputFormat ff_rdt_demuxer
= {
1089 .long_name
= NULL_IF_CONFIG_SMALL("RDT demuxer"),
1090 .priv_data_size
= sizeof(RMDemuxContext
),
1091 .read_close
= rm_read_close
,
1092 .flags
= AVFMT_NOFILE
,