1/*
2 * xWMA demuxer
3 * Copyright (c) 2011 Max Horn
4 *
5 * This file is part of Libav.
6 *
7 * Libav 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 * Libav 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 Libav; 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
24#include "avformat.h"
25#include "internal.h"
26#include "riff.h"
27
28/*
29 * Demuxer for xWMA, a Microsoft audio container used by XAudio 2.
30 */
31
32typedef struct {
33    int64_t data_end;
34} XWMAContext;
35
36static int xwma_probe(AVProbeData *p)
37{
38    if (!memcmp(p->buf, "RIFF", 4) && !memcmp(p->buf + 8, "XWMA", 4))
39        return AVPROBE_SCORE_MAX;
40    return 0;
41}
42
43static int xwma_read_header(AVFormatContext *s, AVFormatParameters *ap)
44{
45    int64_t size, av_uninit(data_size);
46    int ret;
47    uint32_t dpds_table_size = 0;
48    uint32_t *dpds_table = 0;
49    unsigned int tag;
50    AVIOContext *pb = s->pb;
51    AVStream *st;
52    XWMAContext *xwma = s->priv_data;
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 */
60    tag = avio_rl32(pb);
61    if (tag != MKTAG('R', 'I', 'F', 'F'))
62        return -1;
63    avio_rl32(pb); /* file size */
64    tag = avio_rl32(pb);
65    if (tag != MKTAG('X', 'W', 'M', 'A'))
66        return -1;
67
68    /* parse fmt header */
69    tag = avio_rl32(pb);
70    if (tag != MKTAG('f', 'm', 't', ' '))
71        return -1;
72    size = avio_rl32(pb);
73    st = avformat_new_stream(s, NULL);
74    if (!st)
75        return AVERROR(ENOMEM);
76
77    ret = ff_get_wav_header(pb, st->codec, size);
78    if (ret < 0)
79        return ret;
80    st->need_parsing = AVSTREAM_PARSE_NONE;
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     */
87    if (st->codec->codec_id != CODEC_ID_WMAV2) {
88        av_log(s, AV_LOG_WARNING, "unexpected codec (tag 0x04%x; id %d)\n",
89                              st->codec->codec_tag, st->codec->codec_id);
90        av_log_ask_for_sample(s, NULL);
91    } else {
92        /* In all xWMA files I have seen, there is no extradata. But the WMA
93         * codecs require extradata, so we provide our own fake extradata.
94         *
95         * First, check that there really was no extradata in the header. If
96         * there was, then try to use it, after asking the user to provide a
97         * sample of this unusual file.
98         */
99        if (st->codec->extradata_size != 0) {
100            /* Surprise, surprise: We *did* get some extradata. No idea
101             * if it will work, but just go on and try it, after asking
102             * the user for a sample.
103             */
104            av_log(s, AV_LOG_WARNING, "unexpected extradata (%d bytes)\n",
105                                  st->codec->extradata_size);
106            av_log_ask_for_sample(s, NULL);
107        } else {
108            st->codec->extradata_size = 6;
109            st->codec->extradata      = av_mallocz(6 + FF_INPUT_BUFFER_PADDING_SIZE);
110            if (!st->codec->extradata)
111                return AVERROR(ENOMEM);
112
113            /* setup extradata with our experimentally obtained value */
114            st->codec->extradata[4] = 31;
115        }
116    }
117
118    if (!st->codec->channels) {
119        av_log(s, AV_LOG_WARNING, "Invalid channel count: %d\n",
120               st->codec->channels);
121        return AVERROR_INVALIDDATA;
122    }
123    if (!st->codec->bits_per_coded_sample) {
124        av_log(s, AV_LOG_WARNING, "Invalid bits_per_coded_sample: %d\n",
125               st->codec->bits_per_coded_sample);
126        return AVERROR_INVALIDDATA;
127    }
128
129    /* set the sample rate */
130    avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
131
132    /* parse the remaining RIFF chunks */
133    for (;;) {
134        if (pb->eof_reached)
135            return -1;
136        /* read next chunk tag */
137        tag = avio_rl32(pb);
138        size = avio_rl32(pb);
139        if (tag == MKTAG('d', 'a', 't', 'a')) {
140            /* We assume that the data chunk comes last. */
141            break;
142        } else if (tag == MKTAG('d','p','d','s')) {
143            /* Quoting the MSDN xWMA docs on the dpds chunk: "Contains the
144             * decoded packet cumulative data size array, each element is the
145             * number of bytes accumulated after the corresponding xWMA packet
146             * is decoded in order."
147             *
148             * Each packet has size equal to st->codec->block_align, which in
149             * all cases I saw so far was always 2230. Thus, we can use the
150             * dpds data to compute a seeking index.
151             */
152
153            /* Error out if there is more than one dpds chunk. */
154            if (dpds_table) {
155                av_log(s, AV_LOG_ERROR, "two dpds chunks present\n");
156                return -1;
157            }
158
159            /* Compute the number of entries in the dpds chunk. */
160            if (size & 3) {  /* Size should be divisible by four */
161                av_log(s, AV_LOG_WARNING,
162                       "dpds chunk size %"PRId64" not divisible by 4\n", size);
163            }
164            dpds_table_size = size / 4;
165            if (dpds_table_size == 0 || dpds_table_size >= INT_MAX / 4) {
166                av_log(s, AV_LOG_ERROR,
167                       "dpds chunk size %"PRId64" invalid\n", size);
168                return -1;
169            }
170
171            /* Allocate some temporary storage to keep the dpds data around.
172             * for processing later on.
173             */
174            dpds_table = av_malloc(dpds_table_size * sizeof(uint32_t));
175            if (!dpds_table) {
176                return AVERROR(ENOMEM);
177            }
178
179            for (i = 0; i < dpds_table_size; ++i) {
180                dpds_table[i] = avio_rl32(pb);
181                size -= 4;
182            }
183        }
184        avio_skip(pb, size);
185    }
186
187    /* Determine overall data length */
188    if (size < 0)
189        return -1;
190    if (!size) {
191        xwma->data_end = INT64_MAX;
192    } else
193        xwma->data_end = avio_tell(pb) + size;
194
195
196    if (dpds_table && dpds_table_size) {
197        int64_t cur_pos;
198        const uint32_t bytes_per_sample
199                = (st->codec->channels * st->codec->bits_per_coded_sample) >> 3;
200
201        /* Estimate the duration from the total number of output bytes. */
202        const uint64_t total_decoded_bytes = dpds_table[dpds_table_size - 1];
203        st->duration = total_decoded_bytes / bytes_per_sample;
204
205        /* Use the dpds data to build a seek table.  We can only do this after
206         * we know the offset to the data chunk, as we need that to determine
207         * the actual offset to each input block.
208         * Note: If we allowed ourselves to assume that the data chunk always
209         * follows immediately after the dpds block, we could of course guess
210         * the data block's start offset already while reading the dpds chunk.
211         * I decided against that, just in case other chunks ever are
212         * discovered.
213         */
214        cur_pos = avio_tell(pb);
215        for (i = 0; i < dpds_table_size; ++i) {
216            /* From the number of output bytes that would accumulate in the
217             * output buffer after decoding the first (i+1) packets, we compute
218             * an offset / timestamp pair.
219             */
220            av_add_index_entry(st,
221                               cur_pos + (i+1) * st->codec->block_align, /* pos */
222                               dpds_table[i] / bytes_per_sample,         /* timestamp */
223                               st->codec->block_align,                   /* size */
224                               0,                                        /* duration */
225                               AVINDEX_KEYFRAME);
226        }
227    } else if (st->codec->bit_rate) {
228        /* No dpds chunk was present (or only an empty one), so estimate
229         * the total duration using the average bits per sample and the
230         * total data length.
231         */
232        st->duration = (size<<3) * st->codec->sample_rate / st->codec->bit_rate;
233    }
234
235    av_free(dpds_table);
236
237    return 0;
238}
239
240static int xwma_read_packet(AVFormatContext *s, AVPacket *pkt)
241{
242    int ret, size;
243    int64_t left;
244    AVStream *st;
245    XWMAContext *xwma = s->priv_data;
246
247    st = s->streams[0];
248
249    left = xwma->data_end - avio_tell(s->pb);
250    if (left <= 0) {
251        return AVERROR_EOF;
252    }
253
254    /* read a single block; the default block size is 2230. */
255    size = (st->codec->block_align > 1) ? st->codec->block_align : 2230;
256    size = FFMIN(size, left);
257
258    ret  = av_get_packet(s->pb, pkt, size);
259    if (ret < 0)
260        return ret;
261
262    pkt->stream_index = 0;
263    return ret;
264}
265
266AVInputFormat ff_xwma_demuxer = {
267    .name           = "xwma",
268    .long_name      = NULL_IF_CONFIG_SMALL("Microsoft xWMA"),
269    .priv_data_size = sizeof(XWMAContext),
270    .read_probe     = xwma_probe,
271    .read_header    = xwma_read_header,
272    .read_packet    = xwma_read_packet,
273};
274