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
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
|
/*
* Bethsoft VID format Demuxer
* Copyright (c) 2007 Nicholas Tung
*
* 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
*/
/**
* @file bethsoftvid.c
* @brief Bethesda Softworks VID (.vid) file demuxer
* @author Nicholas Tung [ntung (at. ntung com] (2007-03)
* @sa http://wiki.multimedia.cx/index.php?title=Bethsoft_VID
* @sa http://www.svatopluk.com/andux/docs/dfvid.html
*/
#include "avformat.h"
#include "bethsoftvideo.h"
typedef struct BVID_DemuxContext
{
int nframes;
/** delay value between frames, added to individual frame delay.
* custom units, which will be added to other custom units (~=16ms according
* to free, unofficial documentation) */
int bethsoft_global_delay;
/** video presentation time stamp.
* delay = 16 milliseconds * (global_delay + per_frame_delay) */
int64_t video_pts;
int is_finished;
} BVID_DemuxContext;
static int vid_probe(AVProbeData *p)
{
// little endian VID tag, file starts with "VID\0"
if (p->buf_size < 4 || AV_RL32(p->buf) != MKTAG('V', 'I', 'D', 0))
return 0;
return AVPROBE_SCORE_MAX;
}
static int vid_read_header(AVFormatContext *s,
AVFormatParameters *ap)
{
BVID_DemuxContext *vid = s->priv_data; // permanent data outside of function
ByteIOContext *pb = &s->pb; // io to file
AVStream *stream;
/* load main header. Contents:
* bytes: 'V' 'I' 'D'
* int16s: always_512, nframes, width, height, delay, always_14
*/
url_fseek(pb, 5, SEEK_CUR);
vid->nframes = get_le16(pb);
// FFmpeg central code will use this; don't need to return or anything
// initialize the bethsoft codec
stream = av_new_stream(s, 0);
if (!stream) { return AVERROR_NOMEM; }
av_set_pts_info(stream, 32, 1, 60); // 16 ms increments, i.e. 60 fps
stream->codec->codec_type = CODEC_TYPE_VIDEO;
stream->codec->codec_id = CODEC_ID_BETHSOFTVID;
stream->codec->width = get_le16(pb);
stream->codec->height = get_le16(pb);
stream->codec->pix_fmt = PIX_FMT_PAL8;
vid->bethsoft_global_delay = get_le16(pb);
get_le16(pb);
// done with video codec, set up audio codec
stream = av_new_stream(s, 0);
if (!stream) { return AVERROR_NOMEM; }
stream->codec->codec_type = CODEC_TYPE_AUDIO;
stream->codec->codec_id = CODEC_ID_PCM_U8;
stream->codec->channels = 1;
stream->codec->sample_rate = 11025;
stream->codec->bits_per_sample = 8;
stream->codec->bit_rate = stream->codec->channels * stream->codec->sample_rate * stream->codec->bits_per_sample;
return 0;
}
#define BUFFER_PADDING_SIZE 1000
static int read_frame(BVID_DemuxContext *vid, ByteIOContext *pb, AVPacket *pkt,
uint8_t block_type, AVFormatContext *s, int npixels)
{
uint8_t * vidbuf_start = NULL;
int vidbuf_nbytes = 0;
int rle_num_bytes;
int bytes_copied = 0;
int position;
size_t vidbuf_capacity;
vidbuf_start = av_malloc(vidbuf_capacity = BUFFER_PADDING_SIZE);
if(!vidbuf_start) { return AVERROR_NOMEM; }
// save the file position for the packet, include block type
position = url_ftell(pb) - 1;
// set the block type for the decoder
vidbuf_start[vidbuf_nbytes++] = block_type;
// get the video delay (next int16), and set the presentation time
vid->video_pts += vid->bethsoft_global_delay + get_le16(pb);
// set the y offset if it exists (decoder header data should be in data section)
if(block_type == VIDEO_YOFFSET_DIFFERENCE_FRAME_BLOCK)
{
if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], 2) != 2) { return AVERROR_IO; }
vidbuf_nbytes += 2;
}
do
{
vidbuf_start = av_fast_realloc(vidbuf_start, &vidbuf_capacity, vidbuf_nbytes + BUFFER_PADDING_SIZE);
if(!vidbuf_start) { return AVERROR_NOMEM; }
rle_num_bytes = get_byte(pb);
vidbuf_start[vidbuf_nbytes++] = rle_num_bytes;
if(rle_num_bytes > 0x80) // rle sequence
{
if(block_type == VIDEO_FULL_FRAME_BLOCK) { vidbuf_start[vidbuf_nbytes++] = get_byte(pb); }
bytes_copied += rle_num_bytes - 0x80;
}
else if(rle_num_bytes) // plain sequence
{
if(get_buffer(pb, &vidbuf_start[vidbuf_nbytes], rle_num_bytes) != rle_num_bytes)
return AVERROR_IO;
vidbuf_nbytes += rle_num_bytes;
bytes_copied += rle_num_bytes;
}
if(bytes_copied == npixels) // sometimes no stop character is given, need to keep track of bytes copied
{
// may contain a 0 byte even if read all pixels
if(get_byte(pb)) { url_fseek(pb, -1, SEEK_CUR); }
break;
}
if(bytes_copied > npixels) { return -1; } // error
} while(rle_num_bytes);
// copy data into packet
if(av_new_packet(pkt, vidbuf_nbytes)) { return AVERROR_NOMEM; }
memcpy(pkt->data, vidbuf_start, vidbuf_nbytes);
av_free(vidbuf_start);
pkt->pos = position;
pkt->stream_index = 0; // use the video decoder, which was initialized as the first stream
pkt->pts = vid->video_pts;
vid->nframes--; // used to check if all the frames were read
return vidbuf_nbytes;
}
static int vid_read_packet(AVFormatContext *s,
AVPacket *pkt)
{
BVID_DemuxContext *vid = s->priv_data; // permanent data outside of function
ByteIOContext *pb = &s->pb; // io to file
unsigned char block_type; // block type
int audio_length;
int ret_value;
av_log(s, AV_LOG_DEBUG, "[bethsoftvid demuxer read_packet]");
if(vid->is_finished || url_feof(pb)) { return AVERROR_IO; }
block_type = get_byte(pb);
switch(block_type)
{
case PALETTE_BLOCK:
av_log(s, AV_LOG_DEBUG, "palette block.\n");
url_fseek(pb, -1, SEEK_CUR); // include block type
ret_value = av_get_packet(pb, pkt, 3 * VID_PALETTE_NUMCOLORS + 1);
if(ret_value != 3 * VID_PALETTE_NUMCOLORS + 1) { av_free_packet(pkt); return AVERROR_IO; }
pkt->stream_index = 0;
return ret_value;
case FIRST_AUDIO_BLOCK:
av_log(s, AV_LOG_DEBUG, "first ");
get_le16(pb); // some unused constant
// soundblaster DAC used for sample rate, as on specification page (link above)
s->streams[1]->codec->sample_rate = 1000000 / (256 - get_byte(pb));
s->streams[1]->codec->bit_rate = s->streams[1]->codec->channels * s->streams[1]->codec->sample_rate * s->streams[1]->codec->bits_per_sample;
case AUDIO_BLOCK:
av_log(s, AV_LOG_DEBUG, "audio block.\n");
audio_length = get_le16(pb);
ret_value = av_get_packet(pb, pkt, audio_length);
pkt->stream_index = 1;
return (ret_value != audio_length ? AVERROR_IO : ret_value);
case VIDEO_DIFFERENCE_FRAME_BLOCK: av_log(s, AV_LOG_DEBUG, "non-");
case VIDEO_YOFFSET_DIFFERENCE_FRAME_BLOCK: av_log(s, AV_LOG_DEBUG, "offset ");
case VIDEO_FULL_FRAME_BLOCK: av_log(s, AV_LOG_DEBUG, "video block.\n");
return read_frame(vid, pb, pkt, block_type, s,
s->streams[0]->codec->width * s->streams[0]->codec->height);
case FINISHED_BLOCK:
if(vid->nframes != 0)
av_log(s, AV_LOG_VERBOSE, "reached terminating character but not all frames read.\n");
vid->is_finished = 1;
av_log(s, AV_LOG_DEBUG, "terminating block.\n");
return AVERROR_IO;
default:
av_log(s, AV_LOG_ERROR, "unknown block (character = %c, decimal = %d, hex = %x)!!!\n",
block_type, block_type, block_type); return -1;
}
return 0;
}
AVInputFormat bethsoftvid_demuxer = {
"bethsoftvid",
"Bethesda Softworks 'Daggerfall' VID format",
sizeof(BVID_DemuxContext),
vid_probe,
vid_read_header,
vid_read_packet,
};
|
