1 /*
2 * xWMA demuxer
3 * Copyright (c) 2011 Max Horn
4 *
5 * This file is part of FFmpeg.
6 *
7 * FFmpeg is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * FFmpeg is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with FFmpeg; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
20 */
21
22 #include <inttypes.h>
23
27
28 /*
29 * Demuxer for xWMA, a Microsoft audio container used by XAudio 2.
30 */
31
35
37 {
38 if (!memcmp(p->
buf,
"RIFF", 4) && !memcmp(p->
buf + 8,
"XWMA", 4))
40 return 0;
41 }
42
44 {
47 uint32_t dpds_table_size = 0;
48 uint32_t *dpds_table = 0;
53 int i;
54
55 /* The following code is mostly copied from wav.c, with some
56 * minor alterations.
57 */
58
59 /* check RIFF header */
61 if (tag !=
MKTAG(
'R',
'I',
'F',
'F'))
62 return -1;
65 if (tag !=
MKTAG(
'X',
'W',
'M',
'A'))
66 return -1;
67
68 /* parse fmt header */
70 if (tag !=
MKTAG(
'f',
'm',
't',
' '))
71 return -1;
74 if (!st)
76
78 if (ret < 0)
81
82 /* All xWMA files I have seen contained WMAv2 data. If there are files
83 * using WMA Pro or some other codec, then we need to figure out the right
84 * extradata for that. Thus, ask the user for feedback, but try to go on
85 * anyway.
86 */
90 } else {
91 /* In all xWMA files I have seen, there is no extradata. But the WMA
92 * codecs require extradata, so we provide our own fake extradata.
93 *
94 * First, check that there really was no extradata in the header. If
95 * there was, then try to use it, after asking the user to provide a
96 * sample of this unusual file.
97 */
99 /* Surprise, surprise: We *did* get some extradata. No idea
100 * if it will work, but just go on and try it, after asking
101 * the user for a sample.
102 */
105 } else {
110
111 /* setup extradata with our experimentally obtained value */
113 }
114 }
115
120 }
125 }
126
127 /* set the sample rate */
129
130 /* parse the remaining RIFF chunks */
131 for (;;) {
133 return -1;
134 /* read next chunk tag */
137 if (tag ==
MKTAG(
'd',
'a',
't',
'a')) {
138 /* We assume that the data chunk comes last. */
139 break;
140 }
else if (tag ==
MKTAG(
'd',
'p',
'd',
's')) {
141 /* Quoting the MSDN xWMA docs on the dpds chunk: "Contains the
142 * decoded packet cumulative data size array, each element is the
143 * number of bytes accumulated after the corresponding xWMA packet
144 * is decoded in order."
145 *
146 * Each packet has size equal to st->codec->block_align, which in
147 * all cases I saw so far was always 2230. Thus, we can use the
148 * dpds data to compute a seeking index.
149 */
150
151 /* Error out if there is more than one dpds chunk. */
152 if (dpds_table) {
154 return -1;
155 }
156
157 /* Compute the number of entries in the dpds chunk. */
158 if (size & 3) { /* Size should be divisible by four */
160 "dpds chunk size %"PRId64" not divisible by 4\n", size);
161 }
162 dpds_table_size = size / 4;
163 if (dpds_table_size == 0 || dpds_table_size >= INT_MAX / 4) {
165 "dpds chunk size %"PRId64" invalid\n", size);
166 return -1;
167 }
168
169 /* Allocate some temporary storage to keep the dpds data around.
170 * for processing later on.
171 */
172 dpds_table =
av_malloc(dpds_table_size *
sizeof(uint32_t));
173 if (!dpds_table) {
175 }
176
177 for (i = 0; i < dpds_table_size; ++i) {
179 size -= 4;
180 }
181 }
183 }
184
185 /* Determine overall data length */
186 if (size < 0)
187 return -1;
188 if (!size) {
190 } else
192
193
194 if (dpds_table && dpds_table_size) {
195 int64_t cur_pos;
196 const uint32_t bytes_per_sample
198
199 /* Estimate the duration from the total number of output bytes. */
200 const uint64_t total_decoded_bytes = dpds_table[dpds_table_size - 1];
201
202 if(!bytes_per_sample) {
205 }
206
207 st->
duration = total_decoded_bytes / bytes_per_sample;
208
209 /* Use the dpds data to build a seek table. We can only do this after
210 * we know the offset to the data chunk, as we need that to determine
211 * the actual offset to each input block.
212 * Note: If we allowed ourselves to assume that the data chunk always
213 * follows immediately after the dpds block, we could of course guess
214 * the data block's start offset already while reading the dpds chunk.
215 * I decided against that, just in case other chunks ever are
216 * discovered.
217 */
219 for (i = 0; i < dpds_table_size; ++i) {
220 /* From the number of output bytes that would accumulate in the
221 * output buffer after decoding the first (i+1) packets, we compute
222 * an offset / timestamp pair.
223 */
226 dpds_table[i] / bytes_per_sample, /* timestamp */
228 0, /* duration */
230 }
232 /* No dpds chunk was present (or only an empty one), so estimate
233 * the total duration using the average bits per sample and the
234 * total data length.
235 */
237 }
238
240
241 return 0;
242 }
243
245 {
247 int64_t left;
250
252
254 if (left <= 0) {
256 }
257
258 /* read a single block; the default block size is 2230. */
260 size =
FFMIN(size, left);
261
263 if (ret < 0)
265
268 }
269
277 };