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