tiertexseq.c 9.32 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
/*
 * Tiertex Limited SEQ File Demuxer
 * Copyright (c) 2006 Gregory Montoir (cyx@users.sourceforge.net)
 *
 * This file is part of FFmpeg.
 *
 * FFmpeg 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.1 of the License, or (at your option) any later version.
 *
 * FFmpeg 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 FFmpeg; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
 */

/**
23
 * @file
24 25 26
 * Tiertex Limited SEQ file demuxer
 */

27
#include "libavutil/channel_layout.h"
28
#include "avformat.h"
29
#include "internal.h"
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 59 60 61 62 63 64 65 66

#define SEQ_FRAME_SIZE         6144
#define SEQ_FRAME_W            256
#define SEQ_FRAME_H            128
#define SEQ_NUM_FRAME_BUFFERS  30
#define SEQ_AUDIO_BUFFER_SIZE  882
#define SEQ_SAMPLE_RATE        22050
#define SEQ_FRAME_RATE         25


typedef struct TiertexSeqFrameBuffer {
    int fill_size;
    int data_size;
    unsigned char *data;
} TiertexSeqFrameBuffer;

typedef struct SeqDemuxContext {
    int audio_stream_index;
    int video_stream_index;
    int current_frame_pts;
    int current_frame_offs;
    TiertexSeqFrameBuffer frame_buffers[SEQ_NUM_FRAME_BUFFERS];
    int frame_buffers_count;
    unsigned int current_audio_data_size;
    unsigned int current_audio_data_offs;
    unsigned int current_pal_data_size;
    unsigned int current_pal_data_offs;
    unsigned int current_video_data_size;
    unsigned char *current_video_data_ptr;
    int audio_buffer_full;
} SeqDemuxContext;


static int seq_probe(AVProbeData *p)
{
    int i;

67
    if (p->buf_size < 258)
68 69 70 71 72
        return 0;

    /* there's no real header in a .seq file, the only thing they have in common */
    /* is the first 256 bytes of the file which are always filled with 0 */
    for (i = 0; i < 256; i++)
Michael Niedermayer's avatar
Michael Niedermayer committed
73
        if (p->buf[i])
74 75
            return 0;

76 77 78
    if(p->buf[256]==0 && p->buf[257]==0)
        return 0;

79 80 81 82
    /* only one fourth of the score since the previous check is too naive */
    return AVPROBE_SCORE_MAX / 4;
}

83
static int seq_init_frame_buffers(SeqDemuxContext *seq, AVIOContext *pb)
84 85 86 87
{
    int i, sz;
    TiertexSeqFrameBuffer *seq_buffer;

88
    avio_seek(pb, 256, SEEK_SET);
89 90

    for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++) {
91
        sz = avio_rl16(pb);
92 93 94 95 96 97 98 99
        if (sz == 0)
            break;
        else {
            seq_buffer = &seq->frame_buffers[i];
            seq_buffer->fill_size = 0;
            seq_buffer->data_size = sz;
            seq_buffer->data = av_malloc(sz);
            if (!seq_buffer->data)
100
                return AVERROR(ENOMEM);
101 102 103 104 105 106
        }
    }
    seq->frame_buffers_count = i;
    return 0;
}

107
static int seq_fill_buffer(SeqDemuxContext *seq, AVIOContext *pb, int buffer_num, unsigned int data_offs, int data_size)
108 109 110 111 112 113 114
{
    TiertexSeqFrameBuffer *seq_buffer;

    if (buffer_num >= SEQ_NUM_FRAME_BUFFERS)
        return AVERROR_INVALIDDATA;

    seq_buffer = &seq->frame_buffers[buffer_num];
115
    if (seq_buffer->fill_size + data_size > seq_buffer->data_size || data_size <= 0)
116 117
        return AVERROR_INVALIDDATA;

118
    avio_seek(pb, seq->current_frame_offs + data_offs, SEEK_SET);
119
    if (avio_read(pb, seq_buffer->data + seq_buffer->fill_size, data_size) != data_size)
120
        return AVERROR(EIO);
121 122 123 124 125

    seq_buffer->fill_size += data_size;
    return 0;
}

126
static int seq_parse_frame_data(SeqDemuxContext *seq, AVIOContext *pb)
127 128 129
{
    unsigned int offset_table[4], buffer_num[4];
    TiertexSeqFrameBuffer *seq_buffer;
130
    int i, e, err;
131 132

    seq->current_frame_offs += SEQ_FRAME_SIZE;
133
    avio_seek(pb, seq->current_frame_offs, SEEK_SET);
134 135

    /* sound data */
136
    seq->current_audio_data_offs = avio_rl16(pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
137
    if (seq->current_audio_data_offs) {
138 139 140 141 142 143
        seq->current_audio_data_size = SEQ_AUDIO_BUFFER_SIZE * 2;
    } else {
        seq->current_audio_data_size = 0;
    }

    /* palette data */
144
    seq->current_pal_data_offs = avio_rl16(pb);
Michael Niedermayer's avatar
Michael Niedermayer committed
145
    if (seq->current_pal_data_offs) {
146 147 148 149 150 151 152
        seq->current_pal_data_size = 768;
    } else {
        seq->current_pal_data_size = 0;
    }

    /* video data */
    for (i = 0; i < 4; i++)
153
        buffer_num[i] = avio_r8(pb);
154 155

    for (i = 0; i < 4; i++)
156
        offset_table[i] = avio_rl16(pb);
157 158

    for (i = 0; i < 3; i++) {
Michael Niedermayer's avatar
Michael Niedermayer committed
159
        if (offset_table[i]) {
160
            for (e = i + 1; e < 3 && offset_table[e] == 0; e++);
161
            err = seq_fill_buffer(seq, pb, buffer_num[1 + i],
162 163
              offset_table[i],
              offset_table[e] - offset_table[i]);
Michael Niedermayer's avatar
Michael Niedermayer committed
164
            if (err)
165
                return err;
166 167 168 169
        }
    }

    if (buffer_num[0] != 255) {
170 171 172
        if (buffer_num[0] >= SEQ_NUM_FRAME_BUFFERS)
            return AVERROR_INVALIDDATA;

173 174 175 176 177 178 179 180 181 182 183 184
        seq_buffer = &seq->frame_buffers[buffer_num[0]];
        seq->current_video_data_size = seq_buffer->fill_size;
        seq->current_video_data_ptr  = seq_buffer->data;
        seq_buffer->fill_size = 0;
    } else {
        seq->current_video_data_size = 0;
        seq->current_video_data_ptr  = 0;
    }

    return 0;
}

185
static int seq_read_header(AVFormatContext *s)
186 187
{
    int i, rc;
188
    SeqDemuxContext *seq = s->priv_data;
189
    AVIOContext *pb = s->pb;
190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210
    AVStream *st;

    /* init internal buffers */
    rc = seq_init_frame_buffers(seq, pb);
    if (rc)
        return rc;

    seq->current_frame_offs = 0;

    /* preload (no audio data, just buffer operations related data) */
    for (i = 1; i <= 100; i++) {
        rc = seq_parse_frame_data(seq, pb);
        if (rc)
            return rc;
    }

    seq->current_frame_pts = 0;

    seq->audio_buffer_full = 0;

    /* initialize the video decoder stream */
211
    st = avformat_new_stream(s, NULL);
212
    if (!st)
213
        return AVERROR(ENOMEM);
214

215
    avpriv_set_pts_info(st, 32, 1, SEQ_FRAME_RATE);
216
    seq->video_stream_index = st->index;
217
    st->codec->codec_type = AVMEDIA_TYPE_VIDEO;
218
    st->codec->codec_id = AV_CODEC_ID_TIERTEXSEQVIDEO;
219 220 221 222 223
    st->codec->codec_tag = 0;  /* no fourcc */
    st->codec->width = SEQ_FRAME_W;
    st->codec->height = SEQ_FRAME_H;

    /* initialize the audio decoder stream */
224
    st = avformat_new_stream(s, NULL);
225
    if (!st)
226
        return AVERROR(ENOMEM);
227

228
    st->start_time = 0;
229
    avpriv_set_pts_info(st, 32, 1, SEQ_SAMPLE_RATE);
230
    seq->audio_stream_index = st->index;
231
    st->codec->codec_type = AVMEDIA_TYPE_AUDIO;
232
    st->codec->codec_id = AV_CODEC_ID_PCM_S16BE;
233 234
    st->codec->codec_tag = 0;  /* no tag */
    st->codec->channels = 1;
235
    st->codec->channel_layout = AV_CH_LAYOUT_MONO;
236
    st->codec->sample_rate = SEQ_SAMPLE_RATE;
237 238
    st->codec->bits_per_coded_sample = 16;
    st->codec->bit_rate = st->codec->sample_rate * st->codec->bits_per_coded_sample * st->codec->channels;
239
    st->codec->block_align = st->codec->channels * st->codec->bits_per_coded_sample / 8;
240 241 242 243 244 245 246

    return 0;
}

static int seq_read_packet(AVFormatContext *s, AVPacket *pkt)
{
    int rc;
247
    SeqDemuxContext *seq = s->priv_data;
248
    AVIOContext *pb = s->pb;
249 250 251 252 253 254 255 256 257

    if (!seq->audio_buffer_full) {
        rc = seq_parse_frame_data(seq, pb);
        if (rc)
            return rc;

        /* video packet */
        if (seq->current_pal_data_size + seq->current_video_data_size != 0) {
            if (av_new_packet(pkt, 1 + seq->current_pal_data_size + seq->current_video_data_size))
258
                return AVERROR(ENOMEM);
259 260

            pkt->data[0] = 0;
Michael Niedermayer's avatar
Michael Niedermayer committed
261
            if (seq->current_pal_data_size) {
262
                pkt->data[0] |= 1;
263
                avio_seek(pb, seq->current_frame_offs + seq->current_pal_data_offs, SEEK_SET);
264
                if (avio_read(pb, &pkt->data[1], seq->current_pal_data_size) != seq->current_pal_data_size)
265
                    return AVERROR(EIO);
266
            }
Michael Niedermayer's avatar
Michael Niedermayer committed
267
            if (seq->current_video_data_size) {
268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283
                pkt->data[0] |= 2;
                memcpy(&pkt->data[1 + seq->current_pal_data_size],
                  seq->current_video_data_ptr,
                  seq->current_video_data_size);
            }
            pkt->stream_index = seq->video_stream_index;
            pkt->pts = seq->current_frame_pts;

            /* sound buffer will be processed on next read_packet() call */
            seq->audio_buffer_full = 1;
            return 0;
       }
    }

    /* audio packet */
    if (seq->current_audio_data_offs == 0) /* end of data reached */
284
        return AVERROR(EIO);
285

286
    avio_seek(pb, seq->current_frame_offs + seq->current_audio_data_offs, SEEK_SET);
287 288 289 290 291
    rc = av_get_packet(pb, pkt, seq->current_audio_data_size);
    if (rc < 0)
        return rc;

    pkt->stream_index = seq->audio_stream_index;
292
    seq->current_frame_pts++;
293 294 295 296 297 298 299 300

    seq->audio_buffer_full = 0;
    return 0;
}

static int seq_read_close(AVFormatContext *s)
{
    int i;
301
    SeqDemuxContext *seq = s->priv_data;
302 303 304 305 306 307 308

    for (i = 0; i < SEQ_NUM_FRAME_BUFFERS; i++)
        av_free(seq->frame_buffers[i].data);

    return 0;
}

309
AVInputFormat ff_tiertexseq_demuxer = {
310
    .name           = "tiertexseq",
311
    .long_name      = NULL_IF_CONFIG_SMALL("Tiertex Limited SEQ"),
312 313 314 315 316
    .priv_data_size = sizeof(SeqDemuxContext),
    .read_probe     = seq_probe,
    .read_header    = seq_read_header,
    .read_packet    = seq_read_packet,
    .read_close     = seq_read_close,
317
};