mirror of
https://github.com/vgmstream/vgmstream.git
synced 2024-12-24 12:24:50 +01:00
281 lines
10 KiB
C
281 lines
10 KiB
C
#ifndef _EA_EAAC_STREAMFILE_H_
|
|
#define _EA_EAAC_STREAMFILE_H_
|
|
#include "../streamfile.h"
|
|
|
|
#define XMA_FRAME_SIZE 0x800
|
|
|
|
typedef struct {
|
|
/* config */
|
|
int version;
|
|
int codec;
|
|
int streamed;
|
|
int stream_number;
|
|
int stream_count;
|
|
off_t stream_offset;
|
|
|
|
/* state */
|
|
off_t logical_offset; /* offset that corresponds to physical_offset */
|
|
off_t physical_offset; /* actual file offset */
|
|
|
|
uint32_t block_flag; /* current block flags */
|
|
size_t block_size; /* current block size */
|
|
size_t skip_size; /* size to skip from a block start to reach data start */
|
|
size_t data_size; /* logical size of the block */
|
|
size_t extra_size; /* extra padding/etc size of the block */
|
|
|
|
size_t logical_size;
|
|
} eaac_io_data;
|
|
|
|
|
|
/* Reads skipping EA's block headers, so the resulting data is smaller or larger than physical data.
|
|
* physical/logical_offset will be at the start of a block and only advance when a block is done */
|
|
static size_t eaac_io_read(STREAMFILE *streamfile, uint8_t *dest, off_t offset, size_t length, eaac_io_data* data) {
|
|
size_t total_read = 0;
|
|
|
|
/* ignore bad reads */
|
|
if (offset < 0 || offset > data->logical_size) {
|
|
return total_read;
|
|
}
|
|
|
|
/* previous offset: re-start as we can't map logical<>physical offsets
|
|
* (kinda slow as it trashes buffers, but shouldn't happen often) */
|
|
if (offset < data->logical_offset) {
|
|
data->physical_offset = data->stream_offset;
|
|
data->logical_offset = 0x00;
|
|
data->data_size = 0;
|
|
data->extra_size = 0;
|
|
}
|
|
|
|
/* read blocks, one at a time */
|
|
while (length > 0) {
|
|
|
|
/* ignore EOF (implicitly handles block end flags) */
|
|
if (data->logical_offset >= data->logical_size) {
|
|
break;
|
|
}
|
|
|
|
/* process new block */
|
|
if (data->data_size == 0) {
|
|
data->block_flag = (uint8_t)read_8bit(data->physical_offset+0x00,streamfile);
|
|
data->block_size = read_32bitBE(data->physical_offset+0x00,streamfile) & 0x00FFFFFF;
|
|
|
|
/* ignore header block */
|
|
if (data->version == 1 && data->block_flag == 0x48) {
|
|
data->physical_offset += data->block_size;
|
|
continue;
|
|
}
|
|
|
|
switch(data->codec) {
|
|
case 0x03: { /* EA-XMA */
|
|
/* block format: 0x04=num-samples, (size*4 + N XMA packets) per stream (with 1/2ch XMA headers) */
|
|
int i;
|
|
|
|
data->skip_size = 0x04 + 0x04;
|
|
for (i = 0; i < data->stream_number; i++) {
|
|
data->skip_size += read_32bitBE(data->physical_offset+data->skip_size, streamfile) / 4;
|
|
}
|
|
data->data_size = read_32bitBE(data->physical_offset+data->skip_size, streamfile) / 4; /* why size*4...? */
|
|
data->skip_size += 0x04; /* skip mini header */
|
|
data->data_size -= 0x04; /* remove mini header */
|
|
if (data->data_size % XMA_FRAME_SIZE)
|
|
data->extra_size = XMA_FRAME_SIZE - (data->data_size % XMA_FRAME_SIZE);
|
|
break;
|
|
}
|
|
|
|
case 0x05: /* EALayer3 v1 */
|
|
case 0x06: /* EALayer3 v2 "PCM" */
|
|
case 0x07: /* EALayer3 v2 "Spike" */
|
|
case 0x0b: /* EAMP3 */
|
|
case 0x0c: /* EAOpus */
|
|
data->skip_size = 0x08;
|
|
data->data_size = data->block_size - data->skip_size;
|
|
break;
|
|
|
|
case 0x0a: /* EATrax */
|
|
data->skip_size = 0x08;
|
|
data->data_size = read_32bitBE(data->physical_offset+0x04,streamfile); /* also block_size - 0x08 */
|
|
break;
|
|
|
|
default:
|
|
return total_read;
|
|
}
|
|
}
|
|
|
|
/* move to next block */
|
|
if (offset >= data->logical_offset + data->data_size + data->extra_size) {
|
|
data->physical_offset += data->block_size;
|
|
data->logical_offset += data->data_size + data->extra_size;
|
|
data->data_size = 0;
|
|
data->extra_size = 0;
|
|
continue;
|
|
}
|
|
|
|
/* read data */
|
|
{
|
|
size_t bytes_consumed, bytes_done, to_read;
|
|
|
|
bytes_consumed = offset - data->logical_offset;
|
|
|
|
switch(data->codec) {
|
|
case 0x03: { /* EA-XMA */
|
|
if (bytes_consumed < data->data_size) { /* offset falls within actual data */
|
|
to_read = data->data_size - bytes_consumed;
|
|
if (to_read > length)
|
|
to_read = length;
|
|
bytes_done = read_streamfile(dest, data->physical_offset + data->skip_size + bytes_consumed, to_read, streamfile);
|
|
}
|
|
else { /* offset falls within logical padded data */
|
|
to_read = data->data_size + data->extra_size - bytes_consumed;
|
|
if (to_read > length)
|
|
to_read = length;
|
|
memset(dest, 0xFF, to_read); /* no real need though, padding is ignored */
|
|
bytes_done = to_read;
|
|
}
|
|
break;
|
|
}
|
|
|
|
default:
|
|
to_read = data->data_size - bytes_consumed;
|
|
if (to_read > length)
|
|
to_read = length;
|
|
bytes_done = read_streamfile(dest, data->physical_offset + data->skip_size + bytes_consumed, to_read, streamfile);
|
|
break;
|
|
}
|
|
|
|
total_read += bytes_done;
|
|
dest += bytes_done;
|
|
offset += bytes_done;
|
|
length -= bytes_done;
|
|
|
|
if (bytes_done != to_read || bytes_done == 0) {
|
|
break; /* error/EOF */
|
|
}
|
|
}
|
|
}
|
|
|
|
return total_read;
|
|
}
|
|
|
|
|
|
static size_t eaac_io_size(STREAMFILE *streamfile, eaac_io_data* data) {
|
|
off_t physical_offset, max_physical_offset;
|
|
size_t logical_size = 0;
|
|
|
|
if (data->logical_size)
|
|
return data->logical_size;
|
|
|
|
physical_offset = data->stream_offset;
|
|
max_physical_offset = get_streamfile_size(streamfile);
|
|
|
|
/* get size of the logical stream */
|
|
while (physical_offset < max_physical_offset) {
|
|
uint32_t block_flag, block_size, data_size, skip_size;
|
|
int i;
|
|
|
|
block_flag = (uint8_t)read_8bit(physical_offset+0x00,streamfile);
|
|
block_size = read_32bitBE(physical_offset+0x00,streamfile) & 0x00FFFFFF;
|
|
|
|
if (block_size == 0)
|
|
break; /* bad data */
|
|
|
|
if (data->version == 0 && block_flag != 0x00 && block_flag != 0x80)
|
|
break; /* unknown block */
|
|
|
|
if (data->version == 1 && block_flag == 0x48) {
|
|
physical_offset += block_size;
|
|
continue; /* skip header block */
|
|
}
|
|
if (data->version == 1 && block_flag == 0x45)
|
|
break; /* stop on last block (always empty) */
|
|
if (data->version == 1 && block_flag != 0x44)
|
|
break; /* unknown block */
|
|
|
|
switch(data->codec) {
|
|
case 0x03: /* EA-XMA */
|
|
skip_size = 0x04 + 0x04;
|
|
for (i = 0; i < data->stream_number; i++) {
|
|
skip_size += read_32bitBE(physical_offset + skip_size, streamfile) / 4; /* why size*4...? */
|
|
}
|
|
data_size = read_32bitBE(physical_offset + skip_size, streamfile) / 4;
|
|
skip_size += 0x04; /* skip mini header */
|
|
data_size -= 0x04; /* remove mini header */
|
|
if (data_size % XMA_FRAME_SIZE)
|
|
data_size += XMA_FRAME_SIZE - (data_size % XMA_FRAME_SIZE); /* extra padding */
|
|
break;
|
|
|
|
case 0x05: /* EALayer3 v1 */
|
|
case 0x06: /* EALayer3 v2 "PCM" */
|
|
case 0x07: /* EALayer3 v2 "Spike" */
|
|
case 0x0b: /* EAMP3 */
|
|
case 0x0c: /* EAOpus */
|
|
data_size = block_size - 0x08;
|
|
break;
|
|
|
|
case 0x0a: /* EATrax */
|
|
data_size = read_32bitBE(physical_offset+0x04,streamfile); /* also block_size - 0x08 */
|
|
break;
|
|
|
|
default:
|
|
return 0;
|
|
}
|
|
|
|
physical_offset += block_size;
|
|
logical_size += data_size;
|
|
|
|
if (data->version == 0 && (!data->streamed || block_flag == 0x80))
|
|
break; /* stop on last block */
|
|
}
|
|
|
|
/* logical size can be bigger in EA-XMA though */
|
|
if (physical_offset > get_streamfile_size(streamfile)) {
|
|
VGM_LOG("EA EAAC: wrong size\n");
|
|
return 0;
|
|
}
|
|
|
|
data->logical_size = logical_size;
|
|
return data->logical_size;
|
|
}
|
|
|
|
|
|
/* Prepares custom IO for some blocked EAAudioCore formats, that need clean reads without block headers:
|
|
* - EA-XMA: deflated XMA in multistreams (separate 1/2ch packets)
|
|
* - EALayer3: MPEG granule 1 can go in the next block (in V2"P" mainly, others could use layout blocked_sns)
|
|
* - EATrax: ATRAC9 frames can be split between blooks
|
|
* - EAOpus: multiple Opus packets of frame size + Opus data per block
|
|
*/
|
|
static STREAMFILE* setup_eaac_streamfile(STREAMFILE *streamFile, int version, int codec, int streamed, int stream_number, int stream_count, off_t stream_offset) {
|
|
STREAMFILE *temp_streamFile = NULL, *new_streamFile = NULL;
|
|
eaac_io_data io_data = {0};
|
|
size_t io_data_size = sizeof(eaac_io_data);
|
|
|
|
io_data.version = version;
|
|
io_data.codec = codec;
|
|
io_data.streamed = streamed;
|
|
io_data.stream_number = stream_number;
|
|
io_data.stream_count = stream_count;
|
|
io_data.stream_offset = stream_offset;
|
|
io_data.physical_offset = stream_offset;
|
|
io_data.logical_size = eaac_io_size(streamFile, &io_data); /* force init */
|
|
|
|
/* setup subfile */
|
|
new_streamFile = open_wrap_streamfile(streamFile);
|
|
if (!new_streamFile) goto fail;
|
|
temp_streamFile = new_streamFile;
|
|
|
|
new_streamFile = open_io_streamfile(temp_streamFile, &io_data,io_data_size, eaac_io_read,eaac_io_size);
|
|
if (!new_streamFile) goto fail;
|
|
temp_streamFile = new_streamFile;
|
|
|
|
new_streamFile = open_buffer_streamfile(new_streamFile,0);
|
|
if (!new_streamFile) goto fail;
|
|
temp_streamFile = new_streamFile;
|
|
|
|
return temp_streamFile;
|
|
|
|
fail:
|
|
close_streamfile(temp_streamFile);
|
|
return NULL;
|
|
}
|
|
|
|
#endif /* _EA_EAAC_STREAMFILE_H_ */
|