Mercurial > libavformat.hg
annotate rmdec.c @ 6169:47456957844f libavformat
Reindent
author | mstorsjo |
---|---|
date | Wed, 23 Jun 2010 11:26:43 +0000 |
parents | affa412d5500 |
children |
rev | line source |
---|---|
0 | 1 /* |
2103 | 2 * "Real" compatible demuxer. |
4251
77e0c7511d41
cosmetics: Remove pointless period after copyright statement non-sentences.
diego
parents:
4201
diff
changeset
|
3 * Copyright (c) 2000, 2001 Fabrice Bellard |
0 | 4 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
5 * This file is part of FFmpeg. |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
6 * |
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
7 * FFmpeg is free software; you can redistribute it and/or |
0 | 8 * modify it under the terms of the GNU Lesser General Public |
9 * License as published by the Free Software Foundation; either | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
10 * version 2.1 of the License, or (at your option) any later version. |
0 | 11 * |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
12 * FFmpeg is distributed in the hope that it will be useful, |
0 | 13 * but WITHOUT ANY WARRANTY; without even the implied warranty of |
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU | |
15 * Lesser General Public License for more details. | |
16 * | |
17 * You should have received a copy of the GNU Lesser General Public | |
1358
0899bfe4105c
Change license headers to say 'FFmpeg' instead of 'this program/this library'
diego
parents:
1350
diff
changeset
|
18 * License along with FFmpeg; if not, write to the Free Software |
896
edbe5c3717f9
Update licensing information: The FSF changed postal address.
diego
parents:
888
diff
changeset
|
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA |
0 | 20 */ |
3286 | 21 |
22 #include "libavutil/avstring.h" | |
4201
7d2f3f1b68d8
Fix build: Add intreadwrite.h and bswap.h #includes where necessary.
diego
parents:
4173
diff
changeset
|
23 #include "libavutil/intreadwrite.h" |
0 | 24 #include "avformat.h" |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
25 #include "riff.h" |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
26 #include "rm.h" |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
27 |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
28 struct RMStream { |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
29 AVPacket pkt; ///< place to store merged video frame / reordered audio data |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
30 int videobufsize; ///< current assembled frame size |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
31 int videobufpos; ///< position for the next slice in the video buffer |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
32 int curpic_num; ///< picture number of current frame |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
33 int cur_slice, slices; |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
34 int64_t pktpos; ///< first slice position in file |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
35 /// Audio descrambling matrix parameters |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
36 int64_t audiotimestamp; ///< Audio packet timestamp |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
37 int sub_packet_cnt; // Subpacket counter, used while reading |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
38 int sub_packet_size, sub_packet_h, coded_framesize; ///< Descrambling parameters from container |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
39 int audio_framesize; /// Audio frame size from container |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
40 int sub_packet_lengths[16]; /// Length of each subpacket |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
41 }; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
42 |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
43 typedef struct { |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
44 int nb_packets; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
45 int old_format; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
46 int current_stream; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
47 int remaining_len; |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
48 int audio_stream_num; ///< Stream number for audio packets |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
49 int audio_pkt_cnt; ///< Output packet counter |
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
50 } RMDemuxContext; |
0 | 51 |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
52 static const unsigned char sipr_swaps[38][2] = { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
53 { 0, 63 }, { 1, 22 }, { 2, 44 }, { 3, 90 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
54 { 5, 81 }, { 7, 31 }, { 8, 86 }, { 9, 58 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
55 { 10, 36 }, { 12, 68 }, { 13, 39 }, { 14, 73 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
56 { 15, 53 }, { 16, 69 }, { 17, 57 }, { 19, 88 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
57 { 20, 34 }, { 21, 71 }, { 24, 46 }, { 25, 94 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
58 { 26, 54 }, { 28, 75 }, { 29, 50 }, { 32, 70 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
59 { 33, 92 }, { 35, 74 }, { 38, 85 }, { 40, 56 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
60 { 42, 87 }, { 43, 65 }, { 45, 59 }, { 48, 79 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
61 { 49, 93 }, { 51, 89 }, { 55, 95 }, { 61, 76 }, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
62 { 67, 83 }, { 77, 80 } |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
63 }; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
64 |
5830
f8093c5208f6
export sipr_subpk_size for future use by matroska demuxer
aurel
parents:
5579
diff
changeset
|
65 const unsigned char ff_sipr_subpk_size[4] = { 29, 19, 37, 20 }; |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
66 |
2291 | 67 static inline void get_strl(ByteIOContext *pb, char *buf, int buf_size, int len) |
0 | 68 { |
2291 | 69 int i; |
2290
572f7077ba40
Fix get_str/get_str8() to also work if the target string is not long enough to
diego
parents:
2274
diff
changeset
|
70 char *q, r; |
0 | 71 |
72 q = buf; | |
73 for(i=0;i<len;i++) { | |
2290
572f7077ba40
Fix get_str/get_str8() to also work if the target string is not long enough to
diego
parents:
2274
diff
changeset
|
74 r = get_byte(pb); |
0 | 75 if (i < buf_size - 1) |
2290
572f7077ba40
Fix get_str/get_str8() to also work if the target string is not long enough to
diego
parents:
2274
diff
changeset
|
76 *q++ = r; |
0 | 77 } |
2290
572f7077ba40
Fix get_str/get_str8() to also work if the target string is not long enough to
diego
parents:
2274
diff
changeset
|
78 if (buf_size > 0) *q = '\0'; |
0 | 79 } |
80 | |
81 static void get_str8(ByteIOContext *pb, char *buf, int buf_size) | |
82 { | |
2291 | 83 get_strl(pb, buf, buf_size, get_byte(pb)); |
0 | 84 } |
85 | |
5438 | 86 static int rm_read_extradata(ByteIOContext *pb, AVCodecContext *avctx, unsigned size) |
87 { | |
88 if (size >= 1<<24) | |
89 return -1; | |
90 avctx->extradata = av_malloc(size + FF_INPUT_BUFFER_PADDING_SIZE); | |
91 if (!avctx->extradata) | |
5930
08cd1179a20d
Replace all remaining occurrences of AVERROR_NOMEM with
stefano
parents:
5926
diff
changeset
|
92 return AVERROR(ENOMEM); |
5438 | 93 avctx->extradata_size = get_buffer(pb, avctx->extradata, size); |
94 memset(avctx->extradata + avctx->extradata_size, 0, FF_INPUT_BUFFER_PADDING_SIZE); | |
95 if (avctx->extradata_size != size) | |
96 return AVERROR(EIO); | |
97 return 0; | |
98 } | |
99 | |
4522 | 100 static void rm_read_metadata(AVFormatContext *s, int wide) |
101 { | |
102 char buf[1024]; | |
103 int i; | |
104 for (i=0; i<FF_ARRAY_ELEMS(ff_rm_metadata); i++) { | |
105 int len = wide ? get_be16(s->pb) : get_byte(s->pb); | |
106 get_strl(s->pb, buf, sizeof(buf), len); | |
5982
f74198942337
Mark av_metadata_set() as deprecated, and use av_metadata_set2()
stefano
parents:
5930
diff
changeset
|
107 av_metadata_set2(&s->metadata, ff_rm_metadata[i], buf, 0); |
4522 | 108 } |
109 } | |
110 | |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
111 RMStream *ff_rm_alloc_rmstream (void) |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
112 { |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
113 RMStream *rms = av_mallocz(sizeof(RMStream)); |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
114 rms->curpic_num = -1; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
115 return rms; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
116 } |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
117 |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
118 void ff_rm_free_rmstream (RMStream *rms) |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
119 { |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
120 av_free_packet(&rms->pkt); |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
121 } |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
122 |
4036
1349c277efbd
Add ByteIOContext argument to public ff_rm_* functions so that we can
rbultje
parents:
4014
diff
changeset
|
123 static int rm_read_audio_stream_info(AVFormatContext *s, ByteIOContext *pb, |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
124 AVStream *st, RMStream *ast, int read_all) |
194 | 125 { |
886
7ed1351f8c7e
Fix for Real "old" files version 3 with no 4cc. Fixes thankyou144.ra
rtognimp
parents:
885
diff
changeset
|
126 char buf[256]; |
194 | 127 uint32_t version; |
5438 | 128 int ret; |
194 | 129 |
130 /* ra type header */ | |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
131 version = get_be16(pb); /* version */ |
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
132 if (version == 3) { |
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
133 int header_size = get_be16(pb); |
886
7ed1351f8c7e
Fix for Real "old" files version 3 with no 4cc. Fixes thankyou144.ra
rtognimp
parents:
885
diff
changeset
|
134 int64_t startpos = url_ftell(pb); |
4111
eed7d267ef66
Use get_buffer() and url_fskip() for some loops of get_byte()s. See discussion in ML thread
rbultje
parents:
4110
diff
changeset
|
135 url_fskip(pb, 14); |
4522 | 136 rm_read_metadata(s, 0); |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
137 if ((startpos + header_size) >= url_ftell(pb) + 2) { |
4075 | 138 // fourcc (should always be "lpcJ") |
139 get_byte(pb); | |
140 get_str8(pb, buf, sizeof(buf)); | |
886
7ed1351f8c7e
Fix for Real "old" files version 3 with no 4cc. Fixes thankyou144.ra
rtognimp
parents:
885
diff
changeset
|
141 } |
7ed1351f8c7e
Fix for Real "old" files version 3 with no 4cc. Fixes thankyou144.ra
rtognimp
parents:
885
diff
changeset
|
142 // Skip extra header crap (this should never happen) |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
143 if ((startpos + header_size) > url_ftell(pb)) |
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
144 url_fskip(pb, header_size + startpos - url_ftell(pb)); |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
145 st->codec->sample_rate = 8000; |
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
146 st->codec->channels = 1; |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
147 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
148 st->codec->codec_id = CODEC_ID_RA_144; |
194 | 149 } else { |
879 | 150 int flavor, sub_packet_h, coded_framesize, sub_packet_size; |
5435 | 151 int codecdata_length; |
194 | 152 /* old version (4) */ |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
153 url_fskip(pb, 2); /* unused */ |
194 | 154 get_be32(pb); /* .ra4 */ |
687
561f27e36bc4
ra288 demuxing support (doesnt really work, might be demuxer or decoder bug)
michael
parents:
652
diff
changeset
|
155 get_be32(pb); /* data size */ |
561f27e36bc4
ra288 demuxing support (doesnt really work, might be demuxer or decoder bug)
michael
parents:
652
diff
changeset
|
156 get_be16(pb); /* version2 */ |
194 | 157 get_be32(pb); /* header size */ |
687
561f27e36bc4
ra288 demuxing support (doesnt really work, might be demuxer or decoder bug)
michael
parents:
652
diff
changeset
|
158 flavor= get_be16(pb); /* add codec info / flavor */ |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
159 ast->coded_framesize = coded_framesize = get_be32(pb); /* coded frame size */ |
194 | 160 get_be32(pb); /* ??? */ |
161 get_be32(pb); /* ??? */ | |
162 get_be32(pb); /* ??? */ | |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
163 ast->sub_packet_h = sub_packet_h = get_be16(pb); /* 1 */ |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
164 st->codec->block_align= get_be16(pb); /* frame size */ |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
165 ast->sub_packet_size = sub_packet_size = get_be16(pb); /* sub packet size */ |
687
561f27e36bc4
ra288 demuxing support (doesnt really work, might be demuxer or decoder bug)
michael
parents:
652
diff
changeset
|
166 get_be16(pb); /* ??? */ |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
167 if (version == 5) { |
4110 | 168 get_be16(pb); get_be16(pb); get_be16(pb); |
169 } | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
170 st->codec->sample_rate = get_be16(pb); |
194 | 171 get_be32(pb); |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
172 st->codec->channels = get_be16(pb); |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
173 if (version == 5) { |
879 | 174 get_be32(pb); |
4111
eed7d267ef66
Use get_buffer() and url_fskip() for some loops of get_byte()s. See discussion in ML thread
rbultje
parents:
4110
diff
changeset
|
175 get_buffer(pb, buf, 4); |
887 | 176 buf[4] = 0; |
177 } else { | |
1441
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
178 get_str8(pb, buf, sizeof(buf)); /* desc */ |
ad3b03b7b142
reindentation, patch by From: Steve Lhomme, slhomme divxcorp com
diego
parents:
1415
diff
changeset
|
179 get_str8(pb, buf, sizeof(buf)); /* desc */ |
887 | 180 } |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
181 st->codec->codec_type = AVMEDIA_TYPE_AUDIO; |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
182 st->codec->codec_tag = AV_RL32(buf); |
6064
87e28edf7a98
Move rm_codec_tags to rm.c so muxer/demuxer can share it.
rbultje
parents:
6057
diff
changeset
|
183 st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags, |
87e28edf7a98
Move rm_codec_tags to rm.c so muxer/demuxer can share it.
rbultje
parents:
6057
diff
changeset
|
184 st->codec->codec_tag); |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
185 switch (st->codec->codec_id) { |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
186 case CODEC_ID_AC3: |
2585
ecd8a9aa182d
dnet audio needs avparser to work with the lavc ac3 decoder.
rtogni
parents:
2532
diff
changeset
|
187 st->need_parsing = AVSTREAM_PARSE_FULL; |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
188 break; |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
189 case CODEC_ID_RA_288: |
879 | 190 st->codec->extradata_size= 0; |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
191 ast->audio_framesize = st->codec->block_align; |
879 | 192 st->codec->block_align = coded_framesize; |
1079 | 193 |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
194 if(ast->audio_framesize >= UINT_MAX / sub_packet_h){ |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
195 av_log(s, AV_LOG_ERROR, "ast->audio_framesize * sub_packet_h too large\n"); |
1079 | 196 return -1; |
197 } | |
198 | |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
199 av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h); |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
200 break; |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
201 case CODEC_ID_COOK: |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
202 case CODEC_ID_ATRAC3: |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
203 case CODEC_ID_SIPR: |
879 | 204 get_be16(pb); get_byte(pb); |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
205 if (version == 5) |
879 | 206 get_byte(pb); |
207 codecdata_length = get_be32(pb); | |
1079 | 208 if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ |
209 av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); | |
210 return -1; | |
211 } | |
212 | |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
213 ast->audio_framesize = st->codec->block_align; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
214 if (st->codec->codec_id == CODEC_ID_SIPR) { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
215 if (flavor > 3) { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
216 av_log(s, AV_LOG_ERROR, "bad SIPR file flavor %d\n", |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
217 flavor); |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
218 return -1; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
219 } |
5830
f8093c5208f6
export sipr_subpk_size for future use by matroska demuxer
aurel
parents:
5579
diff
changeset
|
220 st->codec->block_align = ff_sipr_subpk_size[flavor]; |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
221 } else { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
222 if(sub_packet_size <= 0){ |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
223 av_log(s, AV_LOG_ERROR, "sub_packet_size is invalid\n"); |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
224 return -1; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
225 } |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
226 st->codec->block_align = ast->sub_packet_size; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
227 } |
5507
5ebeb34e4456
Use the correct ByteIOContext in extradata parsing.Fixes half of issue
rbultje
parents:
5444
diff
changeset
|
228 if ((ret = rm_read_extradata(pb, st->codec, codecdata_length)) < 0) |
5438 | 229 return ret; |
1079 | 230 |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
231 if(ast->audio_framesize >= UINT_MAX / sub_packet_h){ |
1079 | 232 av_log(s, AV_LOG_ERROR, "rm->audio_framesize * sub_packet_h too large\n"); |
233 return -1; | |
234 } | |
235 | |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
236 av_new_packet(&ast->pkt, ast->audio_framesize * sub_packet_h); |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
237 break; |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
238 case CODEC_ID_AAC: |
1105 | 239 get_be16(pb); get_byte(pb); |
5437
715290e41d72
RM audio stream version should be 16-bit followed by header size or reserved
kostya
parents:
5436
diff
changeset
|
240 if (version == 5) |
1105 | 241 get_byte(pb); |
242 codecdata_length = get_be32(pb); | |
1106 | 243 if(codecdata_length + FF_INPUT_BUFFER_PADDING_SIZE <= (unsigned)codecdata_length){ |
244 av_log(s, AV_LOG_ERROR, "codecdata_length too large\n"); | |
245 return -1; | |
246 } | |
1105 | 247 if (codecdata_length >= 1) { |
248 get_byte(pb); | |
5507
5ebeb34e4456
Use the correct ByteIOContext in extradata parsing.Fixes half of issue
rbultje
parents:
5444
diff
changeset
|
249 if ((ret = rm_read_extradata(pb, st->codec, codecdata_length - 1)) < 0) |
5438 | 250 return ret; |
1105 | 251 } |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
252 break; |
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
253 default: |
2189 | 254 av_strlcpy(st->codec->codec_name, buf, sizeof(st->codec->codec_name)); |
194 | 255 } |
256 if (read_all) { | |
257 get_byte(pb); | |
258 get_byte(pb); | |
259 get_byte(pb); | |
4522 | 260 rm_read_metadata(s, 0); |
194 | 261 } |
262 } | |
1106 | 263 return 0; |
194 | 264 } |
265 | |
2889 | 266 int |
4036
1349c277efbd
Add ByteIOContext argument to public ff_rm_* functions so that we can
rbultje
parents:
4014
diff
changeset
|
267 ff_rm_read_mdpr_codecdata (AVFormatContext *s, ByteIOContext *pb, |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
268 AVStream *st, RMStream *rst, int codec_data_size) |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
269 { |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
270 unsigned int v; |
3873
9a589ae59655
Use chunk-size in function calling mdpr_read_codecdata() rather than in the
rbultje
parents:
3497
diff
changeset
|
271 int size; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
272 int64_t codec_pos; |
5438 | 273 int ret; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
274 |
3874
d50c5556cb82
Move av_set_pts_info() inside the mdpr_read_codecdata() call, so that it is
rbultje
parents:
3873
diff
changeset
|
275 av_set_pts_info(st, 64, 1, 1000); |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
276 codec_pos = url_ftell(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
277 v = get_be32(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
278 if (v == MKTAG(0xfd, 'a', 'r', '.')) { |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
279 /* ra type header */ |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
280 if (rm_read_audio_stream_info(s, pb, st, rst, 0)) |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
281 return -1; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
282 } else { |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
283 int fps, fps2; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
284 if (get_le32(pb) != MKTAG('V', 'I', 'D', 'O')) { |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
285 fail1: |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
286 av_log(st->codec, AV_LOG_ERROR, "Unsupported video codec\n"); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
287 goto skip; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
288 } |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
289 st->codec->codec_tag = get_le32(pb); |
6064
87e28edf7a98
Move rm_codec_tags to rm.c so muxer/demuxer can share it.
rbultje
parents:
6057
diff
changeset
|
290 st->codec->codec_id = ff_codec_get_id(ff_rm_codec_tags, |
87e28edf7a98
Move rm_codec_tags to rm.c so muxer/demuxer can share it.
rbultje
parents:
6057
diff
changeset
|
291 st->codec->codec_tag); |
4511 | 292 // av_log(s, AV_LOG_DEBUG, "%X %X\n", st->codec->codec_tag, MKTAG('R', 'V', '2', '0')); |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
293 if (st->codec->codec_id == CODEC_ID_NONE) |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
294 goto fail1; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
295 st->codec->width = get_be16(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
296 st->codec->height = get_be16(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
297 st->codec->time_base.num= 1; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
298 fps= get_be16(pb); |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
299 st->codec->codec_type = AVMEDIA_TYPE_VIDEO; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
300 get_be32(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
301 fps2= get_be16(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
302 get_be16(pb); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
303 |
5507
5ebeb34e4456
Use the correct ByteIOContext in extradata parsing.Fixes half of issue
rbultje
parents:
5444
diff
changeset
|
304 if ((ret = rm_read_extradata(pb, st->codec, codec_data_size - (url_ftell(pb) - codec_pos))) < 0) |
5438 | 305 return ret; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
306 |
4511 | 307 // av_log(s, AV_LOG_DEBUG, "fps= %d fps2= %d\n", fps, fps2); |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
308 st->codec->time_base.den = fps * st->codec->time_base.num; |
5436
d2effdcafa28
Make RM demuxer look more like proper demuxer by introducing codec tags
kostya
parents:
5435
diff
changeset
|
309 //XXX: do we really need that? |
5444 | 310 switch(st->codec->extradata[4]>>4){ |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
311 case 1: st->codec->codec_id = CODEC_ID_RV10; break; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
312 case 2: st->codec->codec_id = CODEC_ID_RV20; break; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
313 case 3: st->codec->codec_id = CODEC_ID_RV30; break; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
314 case 4: st->codec->codec_id = CODEC_ID_RV40; break; |
5443
e0b458b3d1ae
Print extradata in case of failure. I had this in my local tree and it
michael
parents:
5440
diff
changeset
|
315 default: |
5444 | 316 av_log(st->codec, AV_LOG_ERROR, "extra:%02X %02X %02X %02X %02X\n", st->codec->extradata[0], st->codec->extradata[1], st->codec->extradata[2], st->codec->extradata[3], st->codec->extradata[4]); |
5443
e0b458b3d1ae
Print extradata in case of failure. I had this in my local tree and it
michael
parents:
5440
diff
changeset
|
317 goto fail1; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
318 } |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
319 } |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
320 |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
321 skip: |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
322 /* skip codec info */ |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
323 size = url_ftell(pb) - codec_pos; |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
324 url_fskip(pb, codec_data_size - size); |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
325 |
2719
6469205c08e4
Change ff_rm_read_mdpr_codecdata to get back to old behavior.
benoit
parents:
2707
diff
changeset
|
326 return 0; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
327 } |
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
328 |
4737
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
329 /** this function assumes that the demuxer has already seeked to the start |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
330 * of the INDX chunk, and will bail out if not. */ |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
331 static int rm_read_index(AVFormatContext *s) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
332 { |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
333 ByteIOContext *pb = s->pb; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
334 unsigned int size, n_pkts, str_id, next_off, n, pos, pts; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
335 AVStream *st; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
336 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
337 do { |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
338 if (get_le32(pb) != MKTAG('I','N','D','X')) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
339 return -1; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
340 size = get_be32(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
341 if (size < 20) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
342 return -1; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
343 url_fskip(pb, 2); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
344 n_pkts = get_be32(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
345 str_id = get_be16(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
346 next_off = get_be32(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
347 for (n = 0; n < s->nb_streams; n++) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
348 if (s->streams[n]->id == str_id) { |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
349 st = s->streams[n]; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
350 break; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
351 } |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
352 if (n == s->nb_streams) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
353 goto skip; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
354 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
355 for (n = 0; n < n_pkts; n++) { |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
356 url_fskip(pb, 2); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
357 pts = get_be32(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
358 pos = get_be32(pb); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
359 url_fskip(pb, 4); /* packet no. */ |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
360 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
361 av_add_index_entry(st, pos, pts, 0, 0, AVINDEX_KEYFRAME); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
362 } |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
363 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
364 skip: |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
365 if (next_off && url_ftell(pb) != next_off && |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
366 url_fseek(pb, next_off, SEEK_SET) < 0) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
367 return -1; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
368 } while (next_off); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
369 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
370 return 0; |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
371 } |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
372 |
194 | 373 static int rm_read_header_old(AVFormatContext *s, AVFormatParameters *ap) |
374 { | |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
375 RMDemuxContext *rm = s->priv_data; |
194 | 376 AVStream *st; |
377 | |
378 rm->old_format = 1; | |
379 st = av_new_stream(s, 0); | |
380 if (!st) | |
1106 | 381 return -1; |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
382 st->priv_data = ff_rm_alloc_rmstream(); |
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
383 return rm_read_audio_stream_info(s, s->pb, st, st->priv_data, 1); |
194 | 384 } |
385 | |
0 | 386 static int rm_read_header(AVFormatContext *s, AVFormatParameters *ap) |
387 { | |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
388 RMDemuxContext *rm = s->priv_data; |
0 | 389 AVStream *st; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
390 ByteIOContext *pb = s->pb; |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
391 unsigned int tag; |
3497 | 392 int tag_size; |
1350
f77cf5a063a8
Remove unused variables and the corresponding warnings along with them.
diego
parents:
1344
diff
changeset
|
393 unsigned int start_time, duration; |
4737
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
394 unsigned int data_off = 0, indx_off = 0; |
0 | 395 char buf[128]; |
396 int flags = 0; | |
397 | |
194 | 398 tag = get_le32(pb); |
399 if (tag == MKTAG('.', 'r', 'a', 0xfd)) { | |
400 /* very old .ra format */ | |
401 return rm_read_header_old(s, ap); | |
402 } else if (tag != MKTAG('.', 'R', 'M', 'F')) { | |
2274
b21c2af60bc9
Replace all occurrences of AVERROR_IO with AVERROR(EIO).
takis
parents:
2237
diff
changeset
|
403 return AVERROR(EIO); |
194 | 404 } |
0 | 405 |
406 get_be32(pb); /* header size */ | |
407 get_be16(pb); | |
408 get_be32(pb); | |
409 get_be32(pb); /* number of headers */ | |
885 | 410 |
0 | 411 for(;;) { |
412 if (url_feof(pb)) | |
3486 | 413 return -1; |
0 | 414 tag = get_le32(pb); |
415 tag_size = get_be32(pb); | |
416 get_be16(pb); | |
417 #if 0 | |
885 | 418 printf("tag=%c%c%c%c (%08x) size=%d\n", |
0 | 419 (tag) & 0xff, |
420 (tag >> 8) & 0xff, | |
421 (tag >> 16) & 0xff, | |
422 (tag >> 24) & 0xff, | |
423 tag, | |
424 tag_size); | |
425 #endif | |
736 | 426 if (tag_size < 10 && tag != MKTAG('D', 'A', 'T', 'A')) |
3486 | 427 return -1; |
0 | 428 switch(tag) { |
429 case MKTAG('P', 'R', 'O', 'P'): | |
430 /* file header */ | |
431 get_be32(pb); /* max bit rate */ | |
432 get_be32(pb); /* avg bit rate */ | |
433 get_be32(pb); /* max packet size */ | |
434 get_be32(pb); /* avg packet size */ | |
435 get_be32(pb); /* nb packets */ | |
436 get_be32(pb); /* duration */ | |
437 get_be32(pb); /* preroll */ | |
4737
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
438 indx_off = get_be32(pb); /* index offset */ |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
439 data_off = get_be32(pb); /* data offset */ |
0 | 440 get_be16(pb); /* nb streams */ |
441 flags = get_be16(pb); /* flags */ | |
442 break; | |
443 case MKTAG('C', 'O', 'N', 'T'): | |
4522 | 444 rm_read_metadata(s, 1); |
0 | 445 break; |
446 case MKTAG('M', 'D', 'P', 'R'): | |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
85
diff
changeset
|
447 st = av_new_stream(s, 0); |
0 | 448 if (!st) |
3486 | 449 return AVERROR(ENOMEM); |
0 | 450 st->id = get_be16(pb); |
451 get_be32(pb); /* max bit rate */ | |
820
feca73904e67
changing AVCodecContext codec -> *codec in AVStream so additions to AVCodecContext dont randomize AVStream and break binary compatibility
michael
parents:
775
diff
changeset
|
452 st->codec->bit_rate = get_be32(pb); /* bit rate */ |
0 | 453 get_be32(pb); /* max packet size */ |
454 get_be32(pb); /* avg packet size */ | |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
85
diff
changeset
|
455 start_time = get_be32(pb); /* start time */ |
0 | 456 get_be32(pb); /* preroll */ |
188
6c9d6422a2f6
update duration and start_time - add av_new_stream() usage
bellard
parents:
85
diff
changeset
|
457 duration = get_be32(pb); /* duration */ |
743 | 458 st->start_time = start_time; |
459 st->duration = duration; | |
0 | 460 get_str8(pb, buf, sizeof(buf)); /* desc */ |
461 get_str8(pb, buf, sizeof(buf)); /* mimetype */ | |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
462 st->codec->codec_type = AVMEDIA_TYPE_DATA; |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
463 st->priv_data = ff_rm_alloc_rmstream(); |
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
464 if (ff_rm_read_mdpr_codecdata(s, s->pb, st, st->priv_data, |
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
465 get_be32(pb)) < 0) |
2707
0199fcbb9d23
Split out the MDPR chunk reading into its own function.
benoit
parents:
2696
diff
changeset
|
466 return -1; |
0 | 467 break; |
468 case MKTAG('D', 'A', 'T', 'A'): | |
469 goto header_end; | |
470 default: | |
471 /* unknown tag: skip it */ | |
472 url_fskip(pb, tag_size - 10); | |
473 break; | |
474 } | |
475 } | |
476 header_end: | |
477 rm->nb_packets = get_be32(pb); /* number of packets */ | |
478 if (!rm->nb_packets && (flags & 4)) | |
479 rm->nb_packets = 3600 * 25; | |
480 get_be32(pb); /* next data header */ | |
4737
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
481 |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
482 if (!data_off) |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
483 data_off = url_ftell(pb) - 18; |
6101
affa412d5500
Do not read the RM index when input is streamed (since it requires seeking
reimar
parents:
6064
diff
changeset
|
484 if (indx_off && !url_is_streamed(pb) && !(s->flags & AVFMT_FLAG_IGNIDX) && |
affa412d5500
Do not read the RM index when input is streamed (since it requires seeking
reimar
parents:
6064
diff
changeset
|
485 url_fseek(pb, indx_off, SEEK_SET) >= 0) { |
4737
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
486 rm_read_index(s); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
487 url_fseek(pb, data_off + 18, SEEK_SET); |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
488 } |
1207c596d674
Parse index chunk so that seeking in modern .rm files becomes a lot faster.
rbultje
parents:
4736
diff
changeset
|
489 |
0 | 490 return 0; |
491 } | |
492 | |
493 static int get_num(ByteIOContext *pb, int *len) | |
494 { | |
495 int n, n1; | |
496 | |
497 n = get_be16(pb); | |
498 (*len)-=2; | |
2791
5d0fecceff17
Revert r10892, it's wrong and no longer needed to prevent crashes
rtogni
parents:
2771
diff
changeset
|
499 n &= 0x7FFF; |
0 | 500 if (n >= 0x4000) { |
501 return n - 0x4000; | |
502 } else { | |
503 n1 = get_be16(pb); | |
504 (*len)-=2; | |
505 return (n << 16) | n1; | |
506 } | |
507 } | |
508 | |
194 | 509 /* multiple of 20 bytes for ra144 (ugly) */ |
510 #define RAW_PACKET_SIZE 1000 | |
511 | |
613 | 512 static int sync(AVFormatContext *s, int64_t *timestamp, int *flags, int *stream_index, int64_t *pos){ |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
513 RMDemuxContext *rm = s->priv_data; |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
514 ByteIOContext *pb = s->pb; |
612 | 515 AVStream *st; |
632 | 516 uint32_t state=0xFFFFFFFF; |
612 | 517 |
518 while(!url_feof(pb)){ | |
5924 | 519 int len, num, i; |
3207 | 520 *pos= url_ftell(pb) - 3; |
612 | 521 if(rm->remaining_len > 0){ |
522 num= rm->current_stream; | |
523 len= rm->remaining_len; | |
524 *timestamp = AV_NOPTS_VALUE; | |
525 *flags= 0; | |
526 }else{ | |
632 | 527 state= (state<<8) + get_byte(pb); |
885 | 528 |
632 | 529 if(state == MKBETAG('I', 'N', 'D', 'X')){ |
4693
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
530 int n_pkts, expected_len; |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
531 len = get_be32(pb); |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
532 url_fskip(pb, 2); |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
533 n_pkts = get_be32(pb); |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
534 expected_len = 20 + n_pkts * 14; |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
535 if (len == 20) |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
536 /* some files don't add index entries to chunk size... */ |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
537 len = expected_len; |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
538 else if (len != expected_len) |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
539 av_log(s, AV_LOG_WARNING, |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
540 "Index size %d (%d pkts) is wrong, should be %d.\n", |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
541 len, n_pkts, expected_len); |
4de640349078
Correctly skip complete INDX chunks, i.e. read the 32-bit header correctly
rbultje
parents:
4692
diff
changeset
|
542 len -= 14; // we already read part of the index header |
632 | 543 if(len<0) |
544 continue; | |
545 goto skip; | |
5579
e5752e0e373d
Print a warning when DATA chunk is encountered in the middle of chunk.
kostya
parents:
5507
diff
changeset
|
546 } else if (state == MKBETAG('D','A','T','A')) { |
e5752e0e373d
Print a warning when DATA chunk is encountered in the middle of chunk.
kostya
parents:
5507
diff
changeset
|
547 av_log(s, AV_LOG_WARNING, |
e5752e0e373d
Print a warning when DATA chunk is encountered in the middle of chunk.
kostya
parents:
5507
diff
changeset
|
548 "DATA tag in middle of chunk, file may be broken.\n"); |
632 | 549 } |
885 | 550 |
4769
6fff7e0861fc
Don't allow to sync on packets of zero-size length, since these are never
rbultje
parents:
4768
diff
changeset
|
551 if(state > (unsigned)0xFFFF || state <= 12) |
612 | 552 continue; |
4768
667428b99cc3
Move "- 12" statement up a bit. See "[PATCH] rmdec.c: prevent zero-length
rbultje
parents:
4755
diff
changeset
|
553 len=state - 12; |
632 | 554 state= 0xFFFFFFFF; |
555 | |
612 | 556 num = get_be16(pb); |
557 *timestamp = get_be32(pb); | |
5924 | 558 get_byte(pb); /* reserved */ |
612 | 559 *flags = get_byte(pb); /* flags */ |
560 } | |
561 for(i=0;i<s->nb_streams;i++) { | |
562 st = s->streams[i]; | |
563 if (num == st->id) | |
564 break; | |
565 } | |
566 if (i == s->nb_streams) { | |
632 | 567 skip: |
612 | 568 /* skip packet if unknown number */ |
569 url_fskip(pb, len); | |
4692
71f1392ab8d4
Prevent (negative) overflow of rm->remaining_len. This evaluation really only
rbultje
parents:
4691
diff
changeset
|
570 rm->remaining_len = 0; |
612 | 571 continue; |
572 } | |
573 *stream_index= i; | |
885 | 574 |
612 | 575 return len; |
576 } | |
577 return -1; | |
578 } | |
579 | |
4036
1349c277efbd
Add ByteIOContext argument to public ff_rm_* functions so that we can
rbultje
parents:
4014
diff
changeset
|
580 static int rm_assemble_video_frame(AVFormatContext *s, ByteIOContext *pb, |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
581 RMDemuxContext *rm, RMStream *vst, |
4723
a2390c6a35e6
Fix index generation in the way that it was supposed to be used. See the
rbultje
parents:
4693
diff
changeset
|
582 AVPacket *pkt, int len, int *pseq) |
2653 | 583 { |
584 int hdr, seq, pic_num, len2, pos; | |
585 int type; | |
586 | |
587 hdr = get_byte(pb); len--; | |
588 type = hdr >> 6; | |
4142 | 589 |
590 if(type != 3){ // not frame as a part of packet | |
2653 | 591 seq = get_byte(pb); len--; |
4142 | 592 } |
593 if(type != 1){ // not whole frame | |
2653 | 594 len2 = get_num(pb, &len); |
4142 | 595 pos = get_num(pb, &len); |
596 pic_num = get_byte(pb); len--; | |
597 } | |
598 if(len<0) | |
599 return -1; | |
600 rm->remaining_len = len; | |
601 if(type&1){ // frame, not slice | |
602 if(type == 3) // frame as a part of packet | |
603 len= len2; | |
604 if(rm->remaining_len < len) | |
4141
657498d1307e
Add a few error checks to rm_assemble_video_frame()
michael
parents:
4140
diff
changeset
|
605 return -1; |
4142 | 606 rm->remaining_len -= len; |
2653 | 607 if(av_new_packet(pkt, len + 9) < 0) |
608 return AVERROR(EIO); | |
609 pkt->data[0] = 0; | |
610 AV_WL32(pkt->data + 1, 1); | |
611 AV_WL32(pkt->data + 5, 0); | |
612 get_buffer(pb, pkt->data + 9, len); | |
613 return 0; | |
614 } | |
615 //now we have to deal with single slice | |
616 | |
4723
a2390c6a35e6
Fix index generation in the way that it was supposed to be used. See the
rbultje
parents:
4693
diff
changeset
|
617 *pseq = seq; |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
618 if((seq & 0x7F) == 1 || vst->curpic_num != pic_num){ |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
619 vst->slices = ((hdr & 0x3F) << 1) + 1; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
620 vst->videobufsize = len2 + 8*vst->slices + 1; |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
621 av_free_packet(&vst->pkt); //FIXME this should be output. |
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
622 if(av_new_packet(&vst->pkt, vst->videobufsize) < 0) |
2763 | 623 return AVERROR(ENOMEM); |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
624 vst->videobufpos = 8*vst->slices + 1; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
625 vst->cur_slice = 0; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
626 vst->curpic_num = pic_num; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
627 vst->pktpos = url_ftell(pb); |
2653 | 628 } |
2766 | 629 if(type == 2) |
2653 | 630 len = FFMIN(len, pos); |
631 | |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
632 if(++vst->cur_slice > vst->slices) |
2653 | 633 return 1; |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
634 AV_WL32(vst->pkt.data - 7 + 8*vst->cur_slice, 1); |
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
635 AV_WL32(vst->pkt.data - 3 + 8*vst->cur_slice, vst->videobufpos - 8*vst->slices - 1); |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
636 if(vst->videobufpos + len > vst->videobufsize) |
2653 | 637 return 1; |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
638 if (get_buffer(pb, vst->pkt.data + vst->videobufpos, len) != len) |
2653 | 639 return AVERROR(EIO); |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
640 vst->videobufpos += len; |
2653 | 641 rm->remaining_len-= len; |
642 | |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
643 if(type == 2 || (vst->videobufpos) == vst->videobufsize){ |
4145 | 644 vst->pkt.data[0] = vst->cur_slice-1; |
645 *pkt= vst->pkt; | |
4173 | 646 vst->pkt.data= NULL; |
4145 | 647 vst->pkt.size= 0; |
648 if(vst->slices != vst->cur_slice) //FIXME find out how to set slices correct from the begin | |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
649 memmove(pkt->data + 1 + 8*vst->cur_slice, pkt->data + 1 + 8*vst->slices, |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
650 vst->videobufpos - 1 - 8*vst->slices); |
4146
af6cde9a76d1
10l set AVPacket.size to the true size of the returned data instead of
michael
parents:
4145
diff
changeset
|
651 pkt->size = vst->videobufpos + 8*(vst->cur_slice - vst->slices); |
4145 | 652 pkt->pts = AV_NOPTS_VALUE; |
653 pkt->pos = vst->pktpos; | |
5172
06b0c8fd923f
When resetting vst->pkt.data to NULL, also set vst->slices.
reimar
parents:
5120
diff
changeset
|
654 vst->slices = 0; |
4145 | 655 return 0; |
2653 | 656 } |
657 | |
658 return 1; | |
659 } | |
660 | |
2725 | 661 static inline void |
662 rm_ac3_swap_bytes (AVStream *st, AVPacket *pkt) | |
663 { | |
664 uint8_t *ptr; | |
665 int j; | |
666 | |
667 if (st->codec->codec_id == CODEC_ID_AC3) { | |
668 ptr = pkt->data; | |
669 for (j=0;j<pkt->size;j+=2) { | |
670 FFSWAP(int, ptr[0], ptr[1]); | |
671 ptr += 2; | |
672 } | |
673 } | |
674 } | |
675 | |
4785
f9bce80b9fee
Add a @todo with a comment from Kostya so we don't forget to optimize that at
rbultje
parents:
4769
diff
changeset
|
676 /** |
f9bce80b9fee
Add a @todo with a comment from Kostya so we don't forget to optimize that at
rbultje
parents:
4769
diff
changeset
|
677 * Perform 4-bit block reordering for SIPR data. |
f9bce80b9fee
Add a @todo with a comment from Kostya so we don't forget to optimize that at
rbultje
parents:
4769
diff
changeset
|
678 * @todo This can be optimized, e.g. use memcpy() if data blocks are aligned |
f9bce80b9fee
Add a @todo with a comment from Kostya so we don't forget to optimize that at
rbultje
parents:
4769
diff
changeset
|
679 */ |
5831
6ff00deb94fb
export rm_reorder_sipr_data() for future use by matroska demuxer
aurel
parents:
5830
diff
changeset
|
680 void ff_rm_reorder_sipr_data(uint8_t *buf, int sub_packet_h, int framesize) |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
681 { |
5831
6ff00deb94fb
export rm_reorder_sipr_data() for future use by matroska demuxer
aurel
parents:
5830
diff
changeset
|
682 int n, bs = sub_packet_h * framesize * 2 / 96; // nibbles per subpacket |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
683 |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
684 for (n = 0; n < 38; n++) { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
685 int j; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
686 int i = bs * sipr_swaps[n][0]; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
687 int o = bs * sipr_swaps[n][1]; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
688 |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
689 /* swap 4bit-nibbles of block 'i' with 'o' */ |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
690 for (j = 0; j < bs; j++, i++, o++) { |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
691 int x = (buf[i >> 1] >> (4 * (i & 1))) & 0xF, |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
692 y = (buf[o >> 1] >> (4 * (o & 1))) & 0xF; |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
693 |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
694 buf[o >> 1] = (x << (4 * (o & 1))) | |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
695 (buf[o >> 1] & (0xF << (4 * !(o & 1)))); |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
696 buf[i >> 1] = (y << (4 * (i & 1))) | |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
697 (buf[i >> 1] & (0xF << (4 * !(i & 1)))); |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
698 } |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
699 } |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
700 } |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
701 |
2889 | 702 int |
4036
1349c277efbd
Add ByteIOContext argument to public ff_rm_* functions so that we can
rbultje
parents:
4014
diff
changeset
|
703 ff_rm_parse_packet (AVFormatContext *s, ByteIOContext *pb, |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
704 AVStream *st, RMStream *ast, int len, AVPacket *pkt, |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
705 int *seq, int flags, int64_t timestamp) |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
706 { |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
707 RMDemuxContext *rm = s->priv_data; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
708 |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
709 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
710 rm->current_stream= st->id; |
4723
a2390c6a35e6
Fix index generation in the way that it was supposed to be used. See the
rbultje
parents:
4693
diff
changeset
|
711 if(rm_assemble_video_frame(s, pb, rm, ast, pkt, len, seq)) |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
712 return -1; //got partial frame |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
713 } else if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) { |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
714 if ((st->codec->codec_id == CODEC_ID_RA_288) || |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
715 (st->codec->codec_id == CODEC_ID_COOK) || |
3945 | 716 (st->codec->codec_id == CODEC_ID_ATRAC3) || |
717 (st->codec->codec_id == CODEC_ID_SIPR)) { | |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
718 int x; |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
719 int sps = ast->sub_packet_size; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
720 int cfs = ast->coded_framesize; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
721 int h = ast->sub_packet_h; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
722 int y = ast->sub_packet_cnt; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
723 int w = ast->audio_framesize; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
724 |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
725 if (flags & 2) |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
726 y = ast->sub_packet_cnt = 0; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
727 if (!y) |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
728 ast->audiotimestamp = timestamp; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
729 |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
730 switch(st->codec->codec_id) { |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
731 case CODEC_ID_RA_288: |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
732 for (x = 0; x < h/2; x++) |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
733 get_buffer(pb, ast->pkt.data+x*2*w+y*cfs, cfs); |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
734 break; |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
735 case CODEC_ID_ATRAC3: |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
736 case CODEC_ID_COOK: |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
737 for (x = 0; x < w/sps; x++) |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
738 get_buffer(pb, ast->pkt.data+sps*(h*x+((h+1)/2)*(y&1)+(y>>1)), sps); |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
739 break; |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
740 case CODEC_ID_SIPR: |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
741 get_buffer(pb, ast->pkt.data + y * w, w); |
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
742 break; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
743 } |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
744 |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
745 if (++(ast->sub_packet_cnt) < h) |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
746 return -1; |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
747 if (st->codec->codec_id == CODEC_ID_SIPR) |
5831
6ff00deb94fb
export rm_reorder_sipr_data() for future use by matroska demuxer
aurel
parents:
5830
diff
changeset
|
748 ff_rm_reorder_sipr_data(ast->pkt.data, h, w); |
4755
e8d5fa636916
Add byte reordering for the SIPRO audio codec. See "rmdec.c: add SIPR codec
rbultje
parents:
4741
diff
changeset
|
749 |
4738 | 750 ast->sub_packet_cnt = 0; |
751 rm->audio_stream_num = st->index; | |
752 rm->audio_pkt_cnt = h * w / st->codec->block_align; | |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
753 } else if (st->codec->codec_id == CODEC_ID_AAC) { |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
754 int x; |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
755 rm->audio_stream_num = st->index; |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
756 ast->sub_packet_cnt = (get_be16(pb) & 0xf0) >> 4; |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
757 if (ast->sub_packet_cnt) { |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
758 for (x = 0; x < ast->sub_packet_cnt; x++) |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
759 ast->sub_packet_lengths[x] = get_be16(pb); |
4734
dfcf66d4a613
Remove packet returning in ff_rm_parse_packet() if we're using the packet
rbultje
parents:
4733
diff
changeset
|
760 rm->audio_pkt_cnt = ast->sub_packet_cnt; |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
761 ast->audiotimestamp = timestamp; |
4734
dfcf66d4a613
Remove packet returning in ff_rm_parse_packet() if we're using the packet
rbultje
parents:
4733
diff
changeset
|
762 } else |
dfcf66d4a613
Remove packet returning in ff_rm_parse_packet() if we're using the packet
rbultje
parents:
4733
diff
changeset
|
763 return -1; |
2940 | 764 } else { |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
765 av_get_packet(pb, pkt, len); |
2753
b55dad23bfcb
Move dnet-ac3 byte-swapping code close to audio packet read code
rtogni
parents:
2725
diff
changeset
|
766 rm_ac3_swap_bytes(st, pkt); |
2940 | 767 } |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
768 } else |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
769 av_get_packet(pb, pkt, len); |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
770 |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
771 pkt->stream_index = st->index; |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
772 |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
773 #if 0 |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
774 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
775 if(st->codec->codec_id == CODEC_ID_RV20){ |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
776 int seq= 128*(pkt->data[2]&0x7F) + (pkt->data[3]>>1); |
4511 | 777 av_log(s, AV_LOG_DEBUG, "%d %"PRId64" %d\n", *timestamp, *timestamp*512LL/25, seq); |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
778 |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
779 seq |= (timestamp&~0x3FFF); |
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
780 if(seq - timestamp > 0x2000) seq -= 0x4000; |
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
781 if(seq - timestamp < -0x2000) seq += 0x4000; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
782 } |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
783 } |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
784 #endif |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
785 |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
786 pkt->pts= timestamp; |
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
787 if (flags & 2) |
5913
11bb10c37225
Replace all occurences of PKT_FLAG_KEY with AV_PKT_FLAG_KEY.
cehoyos
parents:
5910
diff
changeset
|
788 pkt->flags |= AV_PKT_FLAG_KEY; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
789 |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
790 return st->codec->codec_type == AVMEDIA_TYPE_AUDIO ? rm->audio_pkt_cnt : 0; |
2722
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
791 } |
65dcef6d93e1
Split out the packet parsing from the main function body in rmdec.c
benoit
parents:
2721
diff
changeset
|
792 |
4135
fd0fc1e26d82
Add audio_pkt_cnt return value to ff_rm_retrieve_cache(). See discussion in
rbultje
parents:
4133
diff
changeset
|
793 int |
4036
1349c277efbd
Add ByteIOContext argument to public ff_rm_* functions so that we can
rbultje
parents:
4014
diff
changeset
|
794 ff_rm_retrieve_cache (AVFormatContext *s, ByteIOContext *pb, |
4133
90a12fced519
Add RMStream object as function argument to public functions so that non-.rm
rbultje
parents:
4132
diff
changeset
|
795 AVStream *st, RMStream *ast, AVPacket *pkt) |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
796 { |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
797 RMDemuxContext *rm = s->priv_data; |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
798 |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
799 assert (rm->audio_pkt_cnt > 0); |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
800 |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
801 if (st->codec->codec_id == CODEC_ID_AAC) |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
802 av_get_packet(pb, pkt, ast->sub_packet_lengths[ast->sub_packet_cnt - rm->audio_pkt_cnt]); |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
803 else { |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
804 av_new_packet(pkt, st->codec->block_align); |
4144
4970ba98ca58
Replace buffer by AVPacket and avoid a memcpy() for video when the number
michael
parents:
4143
diff
changeset
|
805 memcpy(pkt->data, ast->pkt.data + st->codec->block_align * //FIXME avoid this |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
806 (ast->sub_packet_h * ast->audio_framesize / st->codec->block_align - rm->audio_pkt_cnt), |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
807 st->codec->block_align); |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
808 } |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
809 rm->audio_pkt_cnt--; |
4735
bf01c2a17c8d
Mark the first output audio frame as keyframe (separate patch from previous,
rbultje
parents:
4734
diff
changeset
|
810 if ((pkt->pts = ast->audiotimestamp) != AV_NOPTS_VALUE) { |
bf01c2a17c8d
Mark the first output audio frame as keyframe (separate patch from previous,
rbultje
parents:
4734
diff
changeset
|
811 ast->audiotimestamp = AV_NOPTS_VALUE; |
5913
11bb10c37225
Replace all occurences of PKT_FLAG_KEY with AV_PKT_FLAG_KEY.
cehoyos
parents:
5910
diff
changeset
|
812 pkt->flags = AV_PKT_FLAG_KEY; |
4735
bf01c2a17c8d
Mark the first output audio frame as keyframe (separate patch from previous,
rbultje
parents:
4734
diff
changeset
|
813 } else |
4736 | 814 pkt->flags = 0; |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
815 pkt->stream_index = st->index; |
4135
fd0fc1e26d82
Add audio_pkt_cnt return value to ff_rm_retrieve_cache(). See discussion in
rbultje
parents:
4133
diff
changeset
|
816 |
fd0fc1e26d82
Add audio_pkt_cnt return value to ff_rm_retrieve_cache(). See discussion in
rbultje
parents:
4133
diff
changeset
|
817 return rm->audio_pkt_cnt; |
2724
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
818 } |
1f752c3afdc8
Isolate caching of audio frames in its own function.
benoit
parents:
2723
diff
changeset
|
819 |
0 | 820 static int rm_read_packet(AVFormatContext *s, AVPacket *pkt) |
821 { | |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
822 RMDemuxContext *rm = s->priv_data; |
0 | 823 AVStream *st; |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
824 int i, len, res, seq = 1; |
613 | 825 int64_t timestamp, pos; |
5120
bda20c95dc0d
Remove old_flags variable, which is a duplicate of the flags variable.
rbultje
parents:
5119
diff
changeset
|
826 int flags; |
0 | 827 |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
828 for (;;) { |
4733 | 829 if (rm->audio_pkt_cnt) { |
830 // If there are queued audio packet return them first | |
831 st = s->streams[rm->audio_stream_num]; | |
832 ff_rm_retrieve_cache(s, s->pb, st, st->priv_data, pkt); | |
5925 | 833 flags = 0; |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
834 } else { |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
835 if (rm->old_format) { |
4733 | 836 RMStream *ast; |
4691 | 837 |
4733 | 838 st = s->streams[0]; |
839 ast = st->priv_data; | |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
840 timestamp = AV_NOPTS_VALUE; |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
841 len = !ast->audio_framesize ? RAW_PACKET_SIZE : |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
842 ast->coded_framesize * ast->sub_packet_h / 2; |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
843 flags = (seq++ == 1) ? 2 : 0; |
5926 | 844 pos = url_ftell(s->pb); |
4733 | 845 } else { |
846 len=sync(s, ×tamp, &flags, &i, &pos); | |
4741 | 847 if (len > 0) |
848 st = s->streams[i]; | |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
849 } |
888 | 850 |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
851 if(len<0 || url_feof(s->pb)) |
4691 | 852 return AVERROR(EIO); |
612 | 853 |
4733 | 854 res = ff_rm_parse_packet (s, s->pb, st, st->priv_data, len, pkt, |
5119
bb9cdd9ad9de
Don't use a pointer-to-flags/timestamp in ff_rm_parse_packet(); the function
rbultje
parents:
4885
diff
changeset
|
855 &seq, flags, timestamp); |
5120
bda20c95dc0d
Remove old_flags variable, which is a duplicate of the flags variable.
rbultje
parents:
5119
diff
changeset
|
856 if((flags&2) && (seq&0x7F) == 1) |
4733 | 857 av_add_index_entry(st, pos, timestamp, 0, 0, AVINDEX_KEYFRAME); |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
858 if (res) |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
859 continue; |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
860 } |
879 | 861 |
4686
83eb34995cfd
Move frame discarding out of the ff_rm_parse_packet() loop, and respect
rbultje
parents:
4523
diff
changeset
|
862 if( (st->discard >= AVDISCARD_NONKEY && !(flags&2)) |
83eb34995cfd
Move frame discarding out of the ff_rm_parse_packet() loop, and respect
rbultje
parents:
4523
diff
changeset
|
863 || st->discard >= AVDISCARD_ALL){ |
83eb34995cfd
Move frame discarding out of the ff_rm_parse_packet() loop, and respect
rbultje
parents:
4523
diff
changeset
|
864 av_free_packet(pkt); |
4732
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
865 } else |
0d7a569678a4
Merge code for packet reading in "old" (.ra, audio-only) Realmedia files and
rbultje
parents:
4723
diff
changeset
|
866 break; |
0 | 867 } |
868 | |
869 return 0; | |
870 } | |
871 | |
872 static int rm_read_close(AVFormatContext *s) | |
873 { | |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
874 int i; |
879 | 875 |
4132
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
876 for (i=0;i<s->nb_streams;i++) |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
877 ff_rm_free_rmstream(s->streams[i]->priv_data); |
4c732153892b
Implement RMStream stream-specific private data object in the RM demuxer.
rbultje
parents:
4111
diff
changeset
|
878 |
0 | 879 return 0; |
880 } | |
881 | |
882 static int rm_probe(AVProbeData *p) | |
883 { | |
884 /* check file header */ | |
194 | 885 if ((p->buf[0] == '.' && p->buf[1] == 'R' && |
886 p->buf[2] == 'M' && p->buf[3] == 'F' && | |
887 p->buf[4] == 0 && p->buf[5] == 0) || | |
888 (p->buf[0] == '.' && p->buf[1] == 'r' && | |
889 p->buf[2] == 'a' && p->buf[3] == 0xfd)) | |
0 | 890 return AVPROBE_SCORE_MAX; |
891 else | |
892 return 0; | |
893 } | |
894 | |
885 | 895 static int64_t rm_read_dts(AVFormatContext *s, int stream_index, |
612 | 896 int64_t *ppos, int64_t pos_limit) |
897 { | |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
898 RMDemuxContext *rm = s->priv_data; |
612 | 899 int64_t pos, dts; |
613 | 900 int stream_index2, flags, len, h; |
612 | 901 |
902 pos = *ppos; | |
885 | 903 |
612 | 904 if(rm->old_format) |
905 return AV_NOPTS_VALUE; | |
906 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
907 url_fseek(s->pb, pos, SEEK_SET); |
612 | 908 rm->remaining_len=0; |
909 for(;;){ | |
613 | 910 int seq=1; |
911 AVStream *st; | |
912 | |
913 len=sync(s, &dts, &flags, &stream_index2, &pos); | |
612 | 914 if(len<0) |
915 return AV_NOPTS_VALUE; | |
613 | 916 |
917 st = s->streams[stream_index2]; | |
5910
536e5527c1e0
Define AVMediaType enum, and use it instead of enum CodecType, which
stefano
parents:
5831
diff
changeset
|
918 if (st->codec->codec_type == AVMEDIA_TYPE_VIDEO) { |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
919 h= get_byte(s->pb); len--; |
613 | 920 if(!(h & 0x40)){ |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
921 seq = get_byte(s->pb); len--; |
612 | 922 } |
923 } | |
885 | 924 |
613 | 925 if((flags&2) && (seq&0x7F) == 1){ |
1443
404048ea11bc
Replace most of the %lld and %llx by their (cleaner) PRI*64 counterparts.
diego
parents:
1441
diff
changeset
|
926 // av_log(s, AV_LOG_DEBUG, "%d %d-%d %"PRId64" %d\n", flags, stream_index2, stream_index, dts, seq); |
979 | 927 av_add_index_entry(st, pos, dts, 0, 0, AVINDEX_KEYFRAME); |
613 | 928 if(stream_index2 == stream_index) |
929 break; | |
930 } | |
931 | |
2771
d52c718e83f9
Use dynamically allocated ByteIOContext in AVFormatContext
andoma
parents:
2770
diff
changeset
|
932 url_fskip(s->pb, len); |
612 | 933 } |
934 *ppos = pos; | |
935 return dts; | |
936 } | |
937 | |
1169 | 938 AVInputFormat rm_demuxer = { |
0 | 939 "rm", |
4465 | 940 NULL_IF_CONFIG_SMALL("RealMedia format"), |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
941 sizeof(RMDemuxContext), |
0 | 942 rm_probe, |
943 rm_read_header, | |
944 rm_read_packet, | |
945 rm_read_close, | |
612 | 946 NULL, |
947 rm_read_dts, | |
0 | 948 }; |
3902
5f9bec099c69
Add dynamic payload handlers to rdt.c. These follow the same API as the ones
rbultje
parents:
3874
diff
changeset
|
949 |
5f9bec099c69
Add dynamic payload handlers to rdt.c. These follow the same API as the ones
rbultje
parents:
3874
diff
changeset
|
950 AVInputFormat rdt_demuxer = { |
5f9bec099c69
Add dynamic payload handlers to rdt.c. These follow the same API as the ones
rbultje
parents:
3874
diff
changeset
|
951 "rdt", |
5f9bec099c69
Add dynamic payload handlers to rdt.c. These follow the same API as the ones
rbultje
parents:
3874
diff
changeset
|
952 NULL_IF_CONFIG_SMALL("RDT demuxer"), |
4097
f8a743bd2df8
Split RMContext into RMDemux/MuxContext and make them private in rmdec/enc.c.
rbultje
parents:
4096
diff
changeset
|
953 sizeof(RMDemuxContext), |
4366 | 954 NULL, |
955 NULL, | |
956 NULL, | |
957 rm_read_close, | |
3902
5f9bec099c69
Add dynamic payload handlers to rdt.c. These follow the same API as the ones
rbultje
parents:
3874
diff
changeset
|
958 }; |