idroq.c 8.74 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58
/*
 * Id RoQ (.roq) File Demuxer
 * Copyright (c) 2003 The ffmpeg Project
 *
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2 of the License, or (at your option) any later version.
 *
 * This library is distributed in the hope that it will be useful,
 * 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
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/**
 * @file idroq.c
 * Id RoQ format file demuxer
 * by Mike Melanson (melanson@pcisys.net)
 * for more information on the .roq file format, visit:
 *   http://www.csse.monash.edu.au/~timf/
 */

#include "avformat.h"

#define RoQ_MAGIC_NUMBER 0x1084
#define RoQ_CHUNK_PREAMBLE_SIZE 8
#define RoQ_AUDIO_SAMPLE_RATE 22050
#define RoQ_CHUNKS_TO_SCAN 30

#define RoQ_INFO           0x1001
#define RoQ_QUAD_CODEBOOK  0x1002
#define RoQ_QUAD_VQ        0x1011
#define RoQ_SOUND_MONO     0x1020
#define RoQ_SOUND_STEREO   0x1021

typedef struct RoqDemuxContext {

    int width;
    int height;
    int audio_channels;
    int framerate;
    int frame_pts_inc;

    int video_stream_index;
    int audio_stream_index;

    int64_t video_pts;
    unsigned int audio_frame_count;

} RoqDemuxContext;

static int roq_probe(AVProbeData *p)
{
59 60 61
    if (p->buf_size < 6)
        return 0;

62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80
    if ((LE_16(&p->buf[0]) != RoQ_MAGIC_NUMBER) ||
        (LE_32(&p->buf[2]) != 0xFFFFFFFF))
        return 0;

    return AVPROBE_SCORE_MAX;
}

static int roq_read_header(AVFormatContext *s,
                           AVFormatParameters *ap)
{
    RoqDemuxContext *roq = s->priv_data;
    ByteIOContext *pb = &s->pb;
    AVStream *st;
    unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE];
    int i;
    unsigned int chunk_size;
    unsigned int chunk_type;

    /* get the main header */
81
    if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
82 83 84 85 86 87
        RoQ_CHUNK_PREAMBLE_SIZE)
        return AVERROR_IO;
    roq->framerate = LE_16(&preamble[6]);
    roq->frame_pts_inc = 90000 / roq->framerate;

    /* init private context parameters */
88
    roq->width = roq->height = roq->audio_channels = roq->video_pts =
89 90 91 92
    roq->audio_frame_count = 0;

    /* scan the first n chunks searching for A/V parameters */
    for (i = 0; i < RoQ_CHUNKS_TO_SCAN; i++) {
93
        if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
94 95 96 97 98 99 100 101 102 103
            RoQ_CHUNK_PREAMBLE_SIZE)
            return AVERROR_IO;

        chunk_type = LE_16(&preamble[0]);
        chunk_size = LE_32(&preamble[2]);

        switch (chunk_type) {

        case RoQ_INFO:
            /* fetch the width and height; reuse the preamble bytes */
104
            if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127
                RoQ_CHUNK_PREAMBLE_SIZE)
                return AVERROR_IO;
            roq->width = LE_16(&preamble[0]);
            roq->height = LE_16(&preamble[2]);
            break;

        case RoQ_QUAD_CODEBOOK:
        case RoQ_QUAD_VQ:
            /* ignore during this scan */
            url_fseek(pb, chunk_size, SEEK_CUR);
            break;

        case RoQ_SOUND_MONO:
            roq->audio_channels = 1;
            url_fseek(pb, chunk_size, SEEK_CUR);
            break;

        case RoQ_SOUND_STEREO:
            roq->audio_channels = 2;
            url_fseek(pb, chunk_size, SEEK_CUR);
            break;

        default:
128
            av_log(s, AV_LOG_ERROR, " unknown RoQ chunk type (%04X)\n", LE_16(&preamble[0]));
129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144
            return AVERROR_INVALIDDATA;
            break;
        }

        /* if all necessary parameters have been gathered, exit early */
        if ((roq->width && roq->height) && roq->audio_channels)
            break;
    }

    /* seek back to the first chunk */
    url_fseek(pb, RoQ_CHUNK_PREAMBLE_SIZE, SEEK_SET);

    /* initialize the decoders */
    st = av_new_stream(s, 0);
    if (!st)
        return AVERROR_NOMEM;
145 146
    /* set the pts reference (1 pts = 1/90000) */
    av_set_pts_info(st, 33, 1, 90000);
147
    roq->video_stream_index = st->index;
148 149 150 151 152
    st->codec->codec_type = CODEC_TYPE_VIDEO;
    st->codec->codec_id = CODEC_ID_ROQ;
    st->codec->codec_tag = 0;  /* no fourcc */
    st->codec->width = roq->width;
    st->codec->height = roq->height;
153 154 155 156 157

    if (roq->audio_channels) {
        st = av_new_stream(s, 0);
        if (!st)
            return AVERROR_NOMEM;
158
        av_set_pts_info(st, 33, 1, 90000);
159
        roq->audio_stream_index = st->index;
160 161 162 163 164 165 166 167 168
        st->codec->codec_type = CODEC_TYPE_AUDIO;
        st->codec->codec_id = CODEC_ID_ROQ_DPCM;
        st->codec->codec_tag = 0;  /* no tag */
        st->codec->channels = roq->audio_channels;
        st->codec->sample_rate = RoQ_AUDIO_SAMPLE_RATE;
        st->codec->bits_per_sample = 16;
        st->codec->bit_rate = st->codec->channels * st->codec->sample_rate *
            st->codec->bits_per_sample;
        st->codec->block_align = st->codec->channels * st->codec->bits_per_sample;
169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189
    }

    return 0;
}

static int roq_read_packet(AVFormatContext *s,
                           AVPacket *pkt)
{
    RoqDemuxContext *roq = s->priv_data;
    ByteIOContext *pb = &s->pb;
    int ret = 0;
    unsigned int chunk_size;
    unsigned int chunk_type;
    unsigned int codebook_size;
    unsigned char preamble[RoQ_CHUNK_PREAMBLE_SIZE];
    int packet_read = 0;
    offset_t codebook_offset;

    while (!packet_read) {

        if (url_feof(&s->pb))
190
            return AVERROR_IO;
191 192

        /* get the next chunk preamble */
193
        if ((ret = get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE)) !=
194
            RoQ_CHUNK_PREAMBLE_SIZE)
195
            return AVERROR_IO;
196 197 198

        chunk_type = LE_16(&preamble[0]);
        chunk_size = LE_32(&preamble[2]);
199 200
        if(chunk_size > INT_MAX)
            return AVERROR_INVALIDDATA;
201 202 203 204 205 206 207 208 209 210 211 212 213

        switch (chunk_type) {

        case RoQ_INFO:
            /* don't care about this chunk anymore */
            url_fseek(pb, RoQ_CHUNK_PREAMBLE_SIZE, SEEK_CUR);
            break;

        case RoQ_QUAD_CODEBOOK:
            /* packet needs to contain both this codebook and next VQ chunk */
            codebook_offset = url_ftell(pb) - RoQ_CHUNK_PREAMBLE_SIZE;
            codebook_size = chunk_size;
            url_fseek(pb, codebook_size, SEEK_CUR);
214
            if (get_buffer(pb, preamble, RoQ_CHUNK_PREAMBLE_SIZE) !=
215
                RoQ_CHUNK_PREAMBLE_SIZE)
216
                return AVERROR_IO;
217
            chunk_size = LE_32(&preamble[2]) + RoQ_CHUNK_PREAMBLE_SIZE * 2 +
218 219 220 221 222 223
                codebook_size;

            /* rewind */
            url_fseek(pb, codebook_offset, SEEK_SET);

            /* load up the packet */
Michael Niedermayer's avatar
Michael Niedermayer committed
224 225
            ret= av_get_packet(pb, pkt, chunk_size);
            if (ret != chunk_size)
226
                return AVERROR_IO;
227 228 229 230 231 232 233 234 235 236 237 238
            pkt->stream_index = roq->video_stream_index;
            pkt->pts = roq->video_pts;

            roq->video_pts += roq->frame_pts_inc;
            packet_read = 1;
            break;

        case RoQ_SOUND_MONO:
        case RoQ_SOUND_STEREO:
        case RoQ_QUAD_VQ:
            /* load up the packet */
            if (av_new_packet(pkt, chunk_size + RoQ_CHUNK_PREAMBLE_SIZE))
239
                return AVERROR_IO;
240 241 242 243 244 245 246 247 248 249 250 251 252 253 254
            /* copy over preamble */
            memcpy(pkt->data, preamble, RoQ_CHUNK_PREAMBLE_SIZE);

            if (chunk_type == RoQ_QUAD_VQ) {
                pkt->stream_index = roq->video_stream_index;
                pkt->pts = roq->video_pts;
                roq->video_pts += roq->frame_pts_inc;
            } else {
                pkt->stream_index = roq->audio_stream_index;
                pkt->pts = roq->audio_frame_count;
                pkt->pts *= 90000;
                pkt->pts /= RoQ_AUDIO_SAMPLE_RATE;
                roq->audio_frame_count += (chunk_size / roq->audio_channels);
            }

Michael Niedermayer's avatar
Michael Niedermayer committed
255
            pkt->pos= url_ftell(pb);
256 257
            ret = get_buffer(pb, pkt->data + RoQ_CHUNK_PREAMBLE_SIZE,
                chunk_size);
258
            if (ret != chunk_size)
259
                ret = AVERROR_IO;
260 261 262 263 264

            packet_read = 1;
            break;

        default:
265
            av_log(s, AV_LOG_ERROR, "  unknown RoQ chunk (%04X)\n", chunk_type);
266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295
            return AVERROR_INVALIDDATA;
            break;
        }
    }

    return ret;
}

static int roq_read_close(AVFormatContext *s)
{
//    RoqDemuxContext *roq = (RoqDemuxContext *)s->priv_data;

    return 0;
}

static AVInputFormat roq_iformat = {
    "RoQ",
    "Id RoQ format",
    sizeof(RoqDemuxContext),
    roq_probe,
    roq_read_header,
    roq_read_packet,
    roq_read_close,
};

int roq_init(void)
{
    av_register_input_format(&roq_iformat);
    return 0;
}