FFmpeg coverage

Directory: ../../../ffmpeg/
File: src/libavformat/scd.c
Date: 2025-07-28 20:30:09
Exec Total Coverage
Lines: 3 170 1.8%
Functions: 1 8 12.5%
Branches: 1 87 1.1%
Line Branch Exec Source
1 /*
2 * Square Enix SCD demuxer
3 * Copyright (C) 2021 Zane van Iperen (zane@zanevaniperen.com)
4 *
5 * Based off documentation:
6 * http://ffxivexplorer.fragmenterworks.com/research/scd%20files.txt
7 *
8 * This file is part of FFmpeg.
9 *
10 * FFmpeg is free software; you can redistribute it and/or
11 * modify it under the terms of the GNU Lesser General Public
12 * License as published by the Free Software Foundation; either
13 * version 2.1 of the License, or (at your option) any later version.
14 *
15 * FFmpeg is distributed in the hope that it will be useful,
16 * but WITHOUT ANY WARRANTY; without even the implied warranty of
17 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
18 * Lesser General Public License for more details.
19 *
20 * You should have received a copy of the GNU Lesser General Public
21 * License along with FFmpeg; if not, write to the Free Software
22 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
23 */
24
25 #include <stddef.h>
26
27 #include "libavutil/intreadwrite.h"
28 #include "libavutil/internal.h"
29 #include "libavutil/macros.h"
30 #include "libavutil/mem.h"
31 #include "libavformat/internal.h"
32 #include "avformat.h"
33 #include "avio_internal.h"
34 #include "demux.h"
35
36 #define SCD_MAGIC ((uint64_t)MKBETAG('S', 'E', 'D', 'B') << 32 | \
37 MKBETAG('S', 'S', 'C', 'F'))
38 #define SCD_MIN_HEADER_SIZE 20
39 #define SCD_OFFSET_HEADER_SIZE 28
40 #define SCD_TRACK_HEADER_SIZE 32
41
42 #define SCD_TRACK_ID_PCM 0
43 #define SCD_TRACK_ID_OGG 6
44 #define SCD_TRACK_ID_MP3 7
45 #define SCD_TRACK_ID_MS_ADPCM 12
46
47 typedef struct SCDOffsetTable {
48 uint16_t count;
49 uint32_t offset;
50 uint32_t *entries;
51 } SCDOffsetTable;
52
53 typedef struct SCDHeader {
54 uint64_t magic; /* SEDBSSCF */
55 uint32_t version; /* Verison number. We only know about 3. */
56 uint16_t unk1; /* Unknown, 260 in Drakengard 3, 1024 in FFXIV. */
57 uint16_t header_size; /* Total size of this header. */
58 uint32_t file_size; /* Is often 0, just ignore it. */
59
60 SCDOffsetTable table0; /* Table 0, no idea. 56 uint32's/entry. */
61 SCDOffsetTable table1; /* Table 1, contains the track info. */
62 SCDOffsetTable table2; /* Table 2, no idea. 40 uint32's/entry. */
63 uint16_t unk2; /* Unknown, not a count. */
64 uint32_t unk3; /* Unknown, not an offset. */
65 uint32_t unk4; /* Unknown, offset to offset. */
66 } SCDHeader;
67
68 typedef struct SCDTrackHeader {
69 uint32_t length;
70 uint32_t num_channels;
71 uint32_t sample_rate;
72 uint32_t data_type;
73 uint32_t loop_start;
74 uint32_t loop_end;
75 uint32_t data_offset; /* Offset to data + this header. */
76 uint32_t aux_count;
77
78 uint32_t absolute_offset;
79 uint32_t bytes_read;
80 } SCDTrackHeader;
81
82 typedef struct SCDDemuxContext {
83 SCDHeader hdr;
84 SCDTrackHeader *tracks;
85 int current_track;
86 } SCDDemuxContext;
87
88 7240 static int scd_probe(const AVProbeData *p)
89 {
90
1/2
✓ Branch 0 taken 7240 times.
✗ Branch 1 not taken.
 7240 if (AV_RB64(p->buf) != SCD_MAGIC)
91 7240 return 0;
92
93 ✗ return AVPROBE_SCORE_MAX;
94 }
95
96 ✗ static int scd_read_table(AVFormatContext *s, SCDOffsetTable *table)
97 {
98 int64_t ret;
99
100 ✗ if ((ret = avio_seek(s->pb, table->offset, SEEK_SET)) < 0)
101 ✗ return ret;
102
103 ✗ if ((table->entries = av_calloc(table->count, sizeof(uint32_t))) == NULL)
104 ✗ return ret;
105
106 ✗ if ((ret = avio_read(s->pb, (unsigned char*)table->entries, table->count * sizeof(uint32_t))) < 0)
107 ✗ return ret;
108
109 ✗ for (size_t i = 0; i < table->count; i++)
110 ✗ table->entries[i] = AV_RB32(table->entries + i);
111
112 ✗ av_log(s, AV_LOG_TRACE, "Table, size = %u, offset = %u\n", table->count, table->offset);
113 ✗ for (size_t i = 0; i < table->count; i++)
114 ✗ av_log(s, AV_LOG_TRACE, " [%02zu]: %u\n", i, table->entries[i]);
115
116 ✗ return 0;
117 }
118
119 ✗ static int scd_read_offsets(AVFormatContext *s)
120 {
121 int64_t ret;
122 ✗ SCDDemuxContext *ctx = s->priv_data;
123 uint8_t buf[SCD_OFFSET_HEADER_SIZE];
124
125 ✗ if ((ret = avio_read(s->pb, buf, SCD_OFFSET_HEADER_SIZE)) < 0)
126 ✗ return ret;
127
128 ✗ ctx->hdr.table0.count = AV_RB16(buf + 0);
129 ✗ ctx->hdr.table1.count = AV_RB16(buf + 2);
130 ✗ ctx->hdr.table2.count = AV_RB16(buf + 4);
131 ✗ ctx->hdr.unk2 = AV_RB16(buf + 6);
132 ✗ ctx->hdr.table0.offset = AV_RB32(buf + 8);
133 ✗ ctx->hdr.table1.offset = AV_RB32(buf + 12);
134 ✗ ctx->hdr.table2.offset = AV_RB32(buf + 16);
135 ✗ ctx->hdr.unk3 = AV_RB32(buf + 20);
136 ✗ ctx->hdr.unk4 = AV_RB32(buf + 24);
137
138 ✗ if ((ret = scd_read_table(s, &ctx->hdr.table0)) < 0)
139 ✗ return ret;
140
141 ✗ if ((ret = scd_read_table(s, &ctx->hdr.table1)) < 0)
142 ✗ return ret;
143
144 ✗ if ((ret = scd_read_table(s, &ctx->hdr.table2)) < 0)
145 ✗ return ret;
146
147 ✗ return 0;
148 }
149
150 ✗ static int scd_read_track(AVFormatContext *s, SCDTrackHeader *track, int index)
151 {
152 int64_t ret;
153 uint32_t hoffset;
154 AVStream *st;
155 AVCodecParameters *par;
156 ✗ SCDDemuxContext *ctx = s->priv_data;
157 uint8_t buf[SCD_TRACK_HEADER_SIZE];
158
159 /* Mark as experimental until I find more files from more than just one game. */
160 ✗ if (s->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
161 ✗ av_log(s, AV_LOG_ERROR, "SCD demuxing is experimental, "
162 "add '-strict %d' if you want to use it.\n",
163 FF_COMPLIANCE_EXPERIMENTAL);
164 ✗ return AVERROR_EXPERIMENTAL;
165 }
166
167 ✗ hoffset = ctx->hdr.table1.entries[index];
168
169 ✗ if ((ret = avio_seek(s->pb, hoffset, SEEK_SET)) < 0)
170 ✗ return ret;
171
172 ✗ if ((ret = avio_read(s->pb, buf, SCD_TRACK_HEADER_SIZE)) < 0)
173 ✗ return ret;
174
175 ✗ track->length = AV_RB32(buf + 0);
176 ✗ track->num_channels = AV_RB32(buf + 4);
177 ✗ track->sample_rate = AV_RB32(buf + 8);
178 ✗ track->data_type = AV_RB32(buf + 12);
179 ✗ track->loop_start = AV_RB32(buf + 16);
180 ✗ track->loop_end = AV_RB32(buf + 20);
181 ✗ track->data_offset = AV_RB32(buf + 24);
182 ✗ track->aux_count = AV_RB32(buf + 28);
183
184 /* Sanity checks */
185 ✗ if (track->num_channels > 8 || track->sample_rate >= 192000 ||
186 ✗ track->loop_start > track->loop_end)
187 ✗ return AVERROR_INVALIDDATA;
188
189 ✗ track->absolute_offset = hoffset + SCD_TRACK_HEADER_SIZE + track->data_offset;
190 ✗ track->bytes_read = 0;
191
192 /* Not sure what to do with these, it seems to be fine to ignore them. */
193 ✗ if (track->aux_count != 0)
194 ✗ av_log(s, AV_LOG_DEBUG, "[%d] Track has %u auxiliary chunk(s).\n", index, track->aux_count);
195
196 ✗ if ((st = avformat_new_stream(s, NULL)) == NULL)
197 ✗ return AVERROR(ENOMEM);
198
199 ✗ par = st->codecpar;
200 ✗ par->codec_type = AVMEDIA_TYPE_AUDIO;
201 ✗ par->ch_layout.nb_channels = (int)track->num_channels;
202 ✗ par->sample_rate = (int)track->sample_rate;
203 ✗ st->index = index;
204 ✗ st->start_time = 0;
205
206 /* TODO: Check this with other types. Drakengard 3 MP3s have 47999 instead of 48000. */
207 ✗ if (track->data_type == SCD_TRACK_ID_MP3)
208 ✗ par->sample_rate += 1;
209
210 ✗ avpriv_set_pts_info(st, 64, 1, par->sample_rate);
211
212 ✗ if (av_dict_set_int(&st->metadata, "start", track->absolute_offset, 0) < 0)
213 ✗ return AVERROR(ENOMEM);
214
215 ✗ if (av_dict_set_int(&st->metadata, "loop_start", track->loop_start, 0) < 0)
216 ✗ return AVERROR(ENOMEM);
217
218 ✗ if (av_dict_set_int(&st->metadata, "loop_end", track->loop_end, 0) < 0)
219 ✗ return AVERROR(ENOMEM);
220
221 ✗ switch(track->data_type) {
222 ✗ case SCD_TRACK_ID_PCM:
223 ✗ par->codec_id = AV_CODEC_ID_PCM_S16BE;
224 ✗ par->bits_per_coded_sample = 16;
225 ✗ par->block_align = par->bits_per_coded_sample * par->ch_layout.nb_channels / 8;
226 ✗ break;
227 ✗ case SCD_TRACK_ID_MP3:
228 ✗ par->codec_id = AV_CODEC_ID_MP3;
229 ✗ ffstream(st)->need_parsing = AVSTREAM_PARSE_FULL_RAW;
230 ✗ break;
231 ✗ case SCD_TRACK_ID_OGG:
232 case SCD_TRACK_ID_MS_ADPCM:
233 default:
234 ✗ par->codec_id = AV_CODEC_ID_NONE;
235 ✗ avpriv_request_sample(s, "data type %u", track->data_type);
236 }
237
238 ✗ return 0;
239 }
240
241 ✗ static int scd_read_header(AVFormatContext *s)
242 {
243 int64_t ret;
244 ✗ SCDDemuxContext *ctx = s->priv_data;
245 uint8_t buf[SCD_MIN_HEADER_SIZE];
246
247 ✗ if ((ret = ffio_read_size(s->pb, buf, SCD_MIN_HEADER_SIZE)) < 0)
248 ✗ return ret;
249
250 ✗ ctx->hdr.magic = AV_RB64(buf + 0);
251 ✗ ctx->hdr.version = AV_RB32(buf + 8);
252 ✗ ctx->hdr.unk1 = AV_RB16(buf + 12);
253 ✗ ctx->hdr.header_size = AV_RB16(buf + 14);
254 ✗ ctx->hdr.file_size = AV_RB32(buf + 16);
255
256 ✗ if (ctx->hdr.magic != SCD_MAGIC)
257 ✗ return AVERROR_INVALIDDATA;
258
259 ✗ if (ctx->hdr.version != 3) {
260 ✗ avpriv_request_sample(s, "SCD version %u", ctx->hdr.version);
261 ✗ return AVERROR_PATCHWELCOME;
262 }
263
264 ✗ if (ctx->hdr.header_size < SCD_MIN_HEADER_SIZE)
265 ✗ return AVERROR_INVALIDDATA;
266
267 ✗ if ((ret = avio_skip(s->pb, ctx->hdr.header_size - SCD_MIN_HEADER_SIZE)) < 0)
268 ✗ return ret;
269
270 ✗ if ((ret = scd_read_offsets(s)) < 0)
271 ✗ return ret;
272
273 ✗ ctx->tracks = av_calloc(ctx->hdr.table1.count, sizeof(SCDTrackHeader));
274 ✗ if (ctx->tracks == NULL)
275 ✗ return AVERROR(ENOMEM);
276
277 ✗ for (int i = 0; i < ctx->hdr.table1.count; i++) {
278 ✗ if ((ret = scd_read_track(s, ctx->tracks + i, i)) < 0)
279 ✗ return ret;
280 }
281
282 ✗ if (ctx->hdr.table1.count == 0)
283 ✗ return 0;
284
285 ✗ if ((ret = avio_seek(s->pb, ctx->tracks[0].absolute_offset, SEEK_SET)) < 0)
286 ✗ return ret;
287
288 ✗ return 0;
289 }
290
291 ✗ static int scd_read_packet(AVFormatContext *s, AVPacket *pkt)
292 {
293 ✗ SCDDemuxContext *ctx = s->priv_data;
294 AVCodecParameters *par;
295
296 /* Streams aren't interleaved, round-robin them. */
297 ✗ for (int i = 0; i < ctx->hdr.table1.count; i++) {
298 int64_t ret;
299 int size;
300 SCDTrackHeader *trk;
301
302 ✗ ctx->current_track %= ctx->hdr.table1.count;
303
304 ✗ trk = ctx->tracks + ctx->current_track;
305 ✗ par = s->streams[ctx->current_track]->codecpar;
306
307 ✗ if (trk->bytes_read >= trk->length)
308 ✗ continue;
309
310 ✗ if ((ret = avio_seek(s->pb, trk->absolute_offset + trk->bytes_read, SEEK_SET)) < 0)
311 ✗ return ret;
312
313 ✗ switch(trk->data_type) {
314 ✗ case SCD_TRACK_ID_PCM:
315 ✗ size = par->block_align;
316 ✗ break;
317 ✗ case SCD_TRACK_ID_MP3:
318 default:
319 ✗ size = FFMIN(trk->length - trk->bytes_read, 4096);
320 ✗ break;
321 }
322
323 ✗ ret = av_get_packet(s->pb, pkt, size);
324 ✗ if (ret == AVERROR_EOF) {
325 ✗ trk->length = trk->bytes_read;
326 ✗ continue;
327 ✗ } else if (ret < 0) {
328 ✗ return ret;
329 }
330
331 ✗ if (trk->data_type == SCD_TRACK_ID_PCM) {
332 ✗ pkt->pts = trk->bytes_read / (par->ch_layout.nb_channels * sizeof(uint16_t));
333 ✗ pkt->duration = size / (par->ch_layout.nb_channels * sizeof(int16_t));
334 }
335
336 ✗ trk->bytes_read += ret;
337 ✗ pkt->flags &= ~AV_PKT_FLAG_CORRUPT;
338 ✗ pkt->stream_index = ctx->current_track;
339
340 ✗ ctx->current_track++;
341 ✗ return 0;
342 }
343
344 ✗ return AVERROR_EOF;
345 }
346
347 ✗ static int scd_seek(AVFormatContext *s, int stream_index,
348 int64_t pts, int flags)
349 {
350 ✗ SCDDemuxContext *ctx = s->priv_data;
351
352 ✗ if (pts != 0)
353 ✗ return AVERROR(EINVAL);
354
355 ✗ for(int i = 0; i < ctx->hdr.table1.count; ++i)
356 ✗ ctx->tracks[i].bytes_read = 0;
357
358 ✗ return 0;
359 }
360
361 ✗ static int scd_read_close(AVFormatContext *s)
362 {
363 ✗ SCDDemuxContext *ctx = s->priv_data;
364
365 ✗ av_freep(&ctx->hdr.table0.entries);
366 ✗ av_freep(&ctx->hdr.table1.entries);
367 ✗ av_freep(&ctx->hdr.table2.entries);
368 ✗ av_freep(&ctx->tracks);
369 ✗ return 0;
370 }
371
372 const FFInputFormat ff_scd_demuxer = {
373 .p.name = "scd",
374 .p.long_name = NULL_IF_CONFIG_SMALL("Square Enix SCD"),
375 .priv_data_size = sizeof(SCDDemuxContext),
376 .flags_internal = FF_INFMT_FLAG_INIT_CLEANUP,
377 .read_probe = scd_probe,
378 .read_header = scd_read_header,
379 .read_packet = scd_read_packet,
380 .read_seek = scd_seek,
381 .read_close = scd_read_close,
382 };
383