xwma.c 9.64 KB
Newer Older
Max Horn's avatar
Max Horn committed
1 2 3 4
/*
 * xWMA demuxer
 * Copyright (c) 2011 Max Horn
 *
5
 * This file is part of FFmpeg.
Max Horn's avatar
Max Horn committed
6
 *
7
 * FFmpeg is free software; you can redistribute it and/or
Max Horn's avatar
Max Horn committed
8 9 10 11
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 *
12
 * FFmpeg is distributed in the hope that it will be useful,
Max Horn's avatar
Max Horn committed
13 14 15 16 17
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
18
 * License along with FFmpeg; if not, write to the Free Software
Max Horn's avatar
Max Horn committed
19 20 21
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

22
#include <inttypes.h>
23
#include <stdint.h>
24

Max Horn's avatar
Max Horn committed
25
#include "avformat.h"
26
#include "internal.h"
Max Horn's avatar
Max Horn committed
27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43
#include "riff.h"

/*
 * Demuxer for xWMA, a Microsoft audio container used by XAudio 2.
 */

typedef struct {
    int64_t data_end;
} XWMAContext;

static int xwma_probe(AVProbeData *p)
{
    if (!memcmp(p->buf, "RIFF", 4) && !memcmp(p->buf + 8, "XWMA", 4))
        return AVPROBE_SCORE_MAX;
    return 0;
}

44
static int xwma_read_header(AVFormatContext *s)
Max Horn's avatar
Max Horn committed
45
{
46
    int64_t size;
47
    int ret;
Max Horn's avatar
Max Horn committed
48
    uint32_t dpds_table_size = 0;
49
    uint32_t *dpds_table = NULL;
Max Horn's avatar
Max Horn committed
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73
    unsigned int tag;
    AVIOContext *pb = s->pb;
    AVStream *st;
    XWMAContext *xwma = s->priv_data;
    int i;

    /* The following code is mostly copied from wav.c, with some
     * minor alterations.
     */

    /* check RIFF header */
    tag = avio_rl32(pb);
    if (tag != MKTAG('R', 'I', 'F', 'F'))
        return -1;
    avio_rl32(pb); /* file size */
    tag = avio_rl32(pb);
    if (tag != MKTAG('X', 'W', 'M', 'A'))
        return -1;

    /* parse fmt header */
    tag = avio_rl32(pb);
    if (tag != MKTAG('f', 'm', 't', ' '))
        return -1;
    size = avio_rl32(pb);
74
    st = avformat_new_stream(s, NULL);
Max Horn's avatar
Max Horn committed
75 76 77
    if (!st)
        return AVERROR(ENOMEM);

78 79 80
    ret = ff_get_wav_header(pb, st->codec, size);
    if (ret < 0)
        return ret;
Max Horn's avatar
Max Horn committed
81 82 83 84 85 86 87
    st->need_parsing = AVSTREAM_PARSE_NONE;

    /* All xWMA files I have seen contained WMAv2 data. If there are files
     * using WMA Pro or some other codec, then we need to figure out the right
     * extradata for that. Thus, ask the user for feedback, but try to go on
     * anyway.
     */
88
    if (st->codec->codec_id != AV_CODEC_ID_WMAV2) {
89
        avpriv_request_sample(s, "Unexpected codec (tag 0x04%x; id %d)",
Max Horn's avatar
Max Horn committed
90 91 92 93 94 95
                              st->codec->codec_tag, st->codec->codec_id);
    } else {
        /* In all xWMA files I have seen, there is no extradata. But the WMA
         * codecs require extradata, so we provide our own fake extradata.
         *
         * First, check that there really was no extradata in the header. If
Max Horn's avatar
Max Horn committed
96
         * there was, then try to use it, after asking the user to provide a
Max Horn's avatar
Max Horn committed
97 98 99 100 101 102 103
         * sample of this unusual file.
         */
        if (st->codec->extradata_size != 0) {
            /* Surprise, surprise: We *did* get some extradata. No idea
             * if it will work, but just go on and try it, after asking
             * the user for a sample.
             */
104
            avpriv_request_sample(s, "Unexpected extradata (%d bytes)",
Max Horn's avatar
Max Horn committed
105 106 107 108 109 110 111 112 113 114 115 116
                                  st->codec->extradata_size);
        } else {
            st->codec->extradata_size = 6;
            st->codec->extradata      = av_mallocz(6 + FF_INPUT_BUFFER_PADDING_SIZE);
            if (!st->codec->extradata)
                return AVERROR(ENOMEM);

            /* setup extradata with our experimentally obtained value */
            st->codec->extradata[4] = 31;
        }
    }

117 118 119 120 121 122 123 124 125 126 127
    if (!st->codec->channels) {
        av_log(s, AV_LOG_WARNING, "Invalid channel count: %d\n",
               st->codec->channels);
        return AVERROR_INVALIDDATA;
    }
    if (!st->codec->bits_per_coded_sample) {
        av_log(s, AV_LOG_WARNING, "Invalid bits_per_coded_sample: %d\n",
               st->codec->bits_per_coded_sample);
        return AVERROR_INVALIDDATA;
    }

Max Horn's avatar
Max Horn committed
128
    /* set the sample rate */
129
    avpriv_set_pts_info(st, 64, 1, st->codec->sample_rate);
Max Horn's avatar
Max Horn committed
130 131 132

    /* parse the remaining RIFF chunks */
    for (;;) {
133 134 135 136
        if (pb->eof_reached) {
            ret = AVERROR_EOF;
            goto end;
        }
Max Horn's avatar
Max Horn committed
137 138 139 140 141 142 143 144 145 146
        /* read next chunk tag */
        tag = avio_rl32(pb);
        size = avio_rl32(pb);
        if (tag == MKTAG('d', 'a', 't', 'a')) {
            /* We assume that the data chunk comes last. */
            break;
        } else if (tag == MKTAG('d','p','d','s')) {
            /* Quoting the MSDN xWMA docs on the dpds chunk: "Contains the
             * decoded packet cumulative data size array, each element is the
             * number of bytes accumulated after the corresponding xWMA packet
Max Horn's avatar
Max Horn committed
147
             * is decoded in order."
Max Horn's avatar
Max Horn committed
148 149 150 151 152 153 154 155 156
             *
             * Each packet has size equal to st->codec->block_align, which in
             * all cases I saw so far was always 2230. Thus, we can use the
             * dpds data to compute a seeking index.
             */

            /* Error out if there is more than one dpds chunk. */
            if (dpds_table) {
                av_log(s, AV_LOG_ERROR, "two dpds chunks present\n");
157 158
                ret = AVERROR_INVALIDDATA;
                goto end;
Max Horn's avatar
Max Horn committed
159 160 161 162
            }

            /* Compute the number of entries in the dpds chunk. */
            if (size & 3) {  /* Size should be divisible by four */
163 164
                av_log(s, AV_LOG_WARNING,
                       "dpds chunk size %"PRId64" not divisible by 4\n", size);
Max Horn's avatar
Max Horn committed
165 166 167
            }
            dpds_table_size = size / 4;
            if (dpds_table_size == 0 || dpds_table_size >= INT_MAX / 4) {
168 169
                av_log(s, AV_LOG_ERROR,
                       "dpds chunk size %"PRId64" invalid\n", size);
170
                return AVERROR_INVALIDDATA;
Max Horn's avatar
Max Horn committed
171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
            }

            /* Allocate some temporary storage to keep the dpds data around.
             * for processing later on.
             */
            dpds_table = av_malloc(dpds_table_size * sizeof(uint32_t));
            if (!dpds_table) {
                return AVERROR(ENOMEM);
            }

            for (i = 0; i < dpds_table_size; ++i) {
                dpds_table[i] = avio_rl32(pb);
                size -= 4;
            }
        }
        avio_skip(pb, size);
    }

    /* Determine overall data length */
190 191 192 193
    if (size < 0) {
        ret = AVERROR_INVALIDDATA;
        goto end;
    }
Max Horn's avatar
Max Horn committed
194 195 196 197 198 199 200 201 202 203 204 205 206
    if (!size) {
        xwma->data_end = INT64_MAX;
    } else
        xwma->data_end = avio_tell(pb) + size;


    if (dpds_table && dpds_table_size) {
        int64_t cur_pos;
        const uint32_t bytes_per_sample
                = (st->codec->channels * st->codec->bits_per_coded_sample) >> 3;

        /* Estimate the duration from the total number of output bytes. */
        const uint64_t total_decoded_bytes = dpds_table[dpds_table_size - 1];
207

208 209 210 211
        if (!bytes_per_sample) {
            av_log(s, AV_LOG_ERROR,
                   "Invalid bits_per_coded_sample %d for %d channels\n",
                   st->codec->bits_per_coded_sample, st->codec->channels);
212 213
            ret = AVERROR_INVALIDDATA;
            goto end;
214 215
        }

Max Horn's avatar
Max Horn committed
216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247
        st->duration = total_decoded_bytes / bytes_per_sample;

        /* Use the dpds data to build a seek table.  We can only do this after
         * we know the offset to the data chunk, as we need that to determine
         * the actual offset to each input block.
         * Note: If we allowed ourselves to assume that the data chunk always
         * follows immediately after the dpds block, we could of course guess
         * the data block's start offset already while reading the dpds chunk.
         * I decided against that, just in case other chunks ever are
         * discovered.
         */
        cur_pos = avio_tell(pb);
        for (i = 0; i < dpds_table_size; ++i) {
            /* From the number of output bytes that would accumulate in the
             * output buffer after decoding the first (i+1) packets, we compute
             * an offset / timestamp pair.
             */
            av_add_index_entry(st,
                               cur_pos + (i+1) * st->codec->block_align, /* pos */
                               dpds_table[i] / bytes_per_sample,         /* timestamp */
                               st->codec->block_align,                   /* size */
                               0,                                        /* duration */
                               AVINDEX_KEYFRAME);
        }
    } else if (st->codec->bit_rate) {
        /* No dpds chunk was present (or only an empty one), so estimate
         * the total duration using the average bits per sample and the
         * total data length.
         */
        st->duration = (size<<3) * st->codec->sample_rate / st->codec->bit_rate;
    }

248
end:
Max Horn's avatar
Max Horn committed
249 250
    av_free(dpds_table);

251
    return ret;
Max Horn's avatar
Max Horn committed
252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280
}

static int xwma_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    int ret, size;
    int64_t left;
    AVStream *st;
    XWMAContext *xwma = s->priv_data;

    st = s->streams[0];

    left = xwma->data_end - avio_tell(s->pb);
    if (left <= 0) {
        return AVERROR_EOF;
    }

    /* read a single block; the default block size is 2230. */
    size = (st->codec->block_align > 1) ? st->codec->block_align : 2230;
    size = FFMIN(size, left);

    ret  = av_get_packet(s->pb, pkt, size);
    if (ret < 0)
        return ret;

    pkt->stream_index = 0;
    return ret;
}

AVInputFormat ff_xwma_demuxer = {
281 282 283 284 285 286
    .name           = "xwma",
    .long_name      = NULL_IF_CONFIG_SMALL("Microsoft xWMA"),
    .priv_data_size = sizeof(XWMAContext),
    .read_probe     = xwma_probe,
    .read_header    = xwma_read_header,
    .read_packet    = xwma_read_packet,
Max Horn's avatar
Max Horn committed
287
};