Cool_Tools/vgmstream
1
0
Fork 0
mirror of https://github.com/vgmstream/vgmstream.git synced 2025-01-30 11:57:27 +01:00
Code Issues Packages Projects Releases Wiki Activity

Clean HCA meta/decoder for future changes

Browse Source
This commit is contained in:
bnnm 2018-08-29 20:05:31 +02:00
parent 5afd33d62a
commit 411fa498bb
5 changed files with 135 additions and 109 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/coding/coding.h
View File

@ -170,7 +170,8 @@ void seek_ea_mt(VGMSTREAM * vgmstream, int32_t num_sample);
void free_ea_mt(ea_mt_codec_data *data); void free_ea_mt(ea_mt_codec_data *data);
/* hca_decoder */ /* hca_decoder */
void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do, int channels); hca_codec_data *init_hca(STREAMFILE *streamFile);
void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do);
void reset_hca(VGMSTREAM *vgmstream); void reset_hca(VGMSTREAM *vgmstream);
void loop_hca(VGMSTREAM *vgmstream); void loop_hca(VGMSTREAM *vgmstream);
void free_hca(hca_codec_data * data); void free_hca(hca_codec_data * data);

107
src/coding/hca_decoder.c
View File

@ -1,12 +1,45 @@
#include "coding.h" #include "coding.h"
void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do, int channels) {
/* init a HCA stream; STREAMFILE will be duplicated for internal use. */
hca_codec_data * init_hca(STREAMFILE *streamFile) {
char filename[PATH_LIMIT];
hca_codec_data * data = NULL; /* vgmstream HCA context */
/* init vgmstream context */
data = calloc(1, sizeof(hca_codec_data));
if (!data) goto fail;
/* init library handle */
data->handle = calloc(1, clHCA_sizeof());
data->sample_ptr = clHCA_samplesPerBlock;
/* load streamfile for reads */
get_streamfile_name(streamFile,filename, sizeof(filename));
data->streamfile = open_streamfile(streamFile,filename);
if (!data->streamfile) goto fail;
return data;
fail:
free_hca(data);
return NULL;
}
void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do) {
int samples_done = 0; int samples_done = 0;
int32_t samples_remain = clHCA_samplesPerBlock - data->sample_ptr; int32_t samples_remain = clHCA_samplesPerBlock - data->sample_ptr;
void *hca_data = NULL; //todo improve (can't be done on init since data->info is only read after setting key)
if (!data->data_buffer) {
clHCA *hca; data->data_buffer = malloc(data->info.blockSize);
if (!data->data_buffer) return;
data->sample_buffer = malloc(sizeof(signed short) * data->info.channelCount * clHCA_samplesPerBlock);
if (!data->sample_buffer) return;
}
if ( data->samples_discard ) { if ( data->samples_discard ) {
if ( samples_remain <= data->samples_discard ) { if ( samples_remain <= data->samples_discard ) {
@ -20,41 +53,45 @@ void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do, i
} }
} }
if ( samples_remain > samples_to_do ) samples_remain = samples_to_do; if (samples_remain > samples_to_do)
samples_remain = samples_to_do;
memcpy( outbuf, data->sample_buffer + data->sample_ptr * data->info.channelCount, samples_remain * data->info.channelCount * sizeof(sample) ); memcpy(outbuf, data->sample_buffer + data->sample_ptr * data->info.channelCount, samples_remain * data->info.channelCount * sizeof(sample));
outbuf += samples_remain * data->info.channelCount; outbuf += samples_remain * data->info.channelCount;
data->sample_ptr += samples_remain; data->sample_ptr += samples_remain;
samples_done += samples_remain; samples_done += samples_remain;
hca_data = malloc( data->info.blockSize );
if ( !hca_data ) return;
hca = (clHCA *)(data + 1);
/* feed */
while ( samples_done < samples_to_do ) { while ( samples_done < samples_to_do ) {
const unsigned int blockSize = data->info.blockSize; const unsigned int blockSize = data->info.blockSize;
const unsigned int channelCount = data->info.channelCount; const unsigned int channelCount = data->info.channelCount;
const unsigned int address = data->info.dataOffset + data->curblock * blockSize; const unsigned int address = data->info.dataOffset + data->curblock * blockSize;
int status;
size_t bytes;
/* EOF/error */
if (data->curblock >= data->info.blockCount) { if (data->curblock >= data->info.blockCount) {
memset(outbuf, 0, (samples_to_do - samples_done) * channelCount * sizeof(sample)); memset(outbuf, 0, (samples_to_do - samples_done) * channelCount * sizeof(sample));
break; break;
} }
if ( read_streamfile((uint8_t*) hca_data, data->start + address, blockSize, data->streamfile) != blockSize )
break;
if ( clHCA_Decode( hca, hca_data, blockSize, address ) < 0 )
break;
++data->curblock;
clHCA_DecodeSamples16( hca, data->sample_buffer ); /* read frame */
bytes = read_streamfile(data->data_buffer, address, blockSize, data->streamfile);
if (bytes != blockSize) {
VGM_LOG("HCA: read %x vs expected %x bytes at %x\n", bytes, blockSize, address);
break;
}
/* decode frame */
status = clHCA_Decode(data->handle, (void*)(data->data_buffer), blockSize, address);
if (status < 0) {
VGM_LOG("HCA: decode fail at %x", address);
break;
}
data->curblock++;
/* extract samples */
clHCA_DecodeSamples16(data->handle, data->sample_buffer);
samples_remain = clHCA_samplesPerBlock; samples_remain = clHCA_samplesPerBlock;
data->sample_ptr = 0; data->sample_ptr = 0;
@ -70,14 +107,13 @@ void decode_hca(hca_codec_data * data, sample * outbuf, int32_t samples_to_do, i
} }
} }
if ( samples_remain > samples_to_do - samples_done ) samples_remain = samples_to_do - samples_done; if (samples_remain > samples_to_do - samples_done)
memcpy( outbuf, data->sample_buffer, samples_remain * channelCount * sizeof(sample) ); samples_remain = samples_to_do - samples_done;
memcpy(outbuf, data->sample_buffer, samples_remain * channelCount * sizeof(sample));
samples_done += samples_remain; samples_done += samples_remain;
outbuf += samples_remain * channelCount; outbuf += samples_remain * channelCount;
data->sample_ptr = samples_remain; data->sample_ptr = samples_remain;
} }
free( hca_data );
} }
@ -101,10 +137,11 @@ void loop_hca(VGMSTREAM *vgmstream) {
void free_hca(hca_codec_data * data) { void free_hca(hca_codec_data * data) {
if (data) { if (data) {
clHCA *hca = (clHCA *)(data + 1); close_streamfile(data->streamfile);
clHCA_done(hca); clHCA_done(data->handle);
if (data->streamfile) free(data->handle);
close_streamfile(data->streamfile); free(data->data_buffer);
free(data->sample_buffer);
free(data); free(data);
} }
} }

127
src/meta/hca.c
View File

@ -2,76 +2,59 @@
#include "hca_keys.h" #include "hca_keys.h"
#include "../coding/coding.h" #include "../coding/coding.h"
#define HCA_KEY_MAX_TEST_CLIPS 400 /* hopefully nobody masters files with more that a handful... */ static void find_hca_key(hca_codec_data * hca_data, uint8_t * header_buffer, int header_size, unsigned int * out_keycode_upper, unsigned int * out_keycode_lower);
#define HCA_KEY_MAX_TEST_FRAMES 100 /* ~102400 samples */
#define HCA_KEY_MAX_TEST_SAMPLES 10240 /* ~10 frames of non-blank samples */
static void find_hca_key(hca_codec_data * hca_data, clHCA * hca, uint8_t * buffer, int header_size, unsigned int * out_key1, unsigned int * out_key2);
VGMSTREAM * init_vgmstream_hca(STREAMFILE *streamFile) { VGMSTREAM * init_vgmstream_hca(STREAMFILE *streamFile) {
VGMSTREAM * vgmstream = NULL; VGMSTREAM * vgmstream = NULL;
uint8_t buffer[0x8000]; /* hca header buffer data (probably max ~0x400) */ uint8_t header_buffer[0x8000]; /* hca header buffer data (probably max ~0x400) */
char filename[PATH_LIMIT];
off_t start = 0;
size_t file_size = streamFile->get_size(streamFile);
int header_size;
hca_codec_data * hca_data = NULL; /* vgmstream HCA context */ hca_codec_data * hca_data = NULL; /* vgmstream HCA context */
clHCA * hca; /* HCA_Decoder context */ unsigned int keycode_upper, keycode_lower;
unsigned int ciphKey1, ciphKey2; int header_size;
/* check extension, case insensitive */ /* checks */
if ( !check_extensions(streamFile, "hca")) return NULL; if ( !check_extensions(streamFile, "hca"))
return NULL;
/* init header */
if (read_streamfile(header_buffer, 0x00, 0x08, streamFile) != 0x08)
goto fail;
header_size = clHCA_isOurFile0(header_buffer);
if (header_size < 0 || header_size > 0x8000) goto fail;
/* test/init header (find real header size first) */ if (read_streamfile(header_buffer, 0x00, header_size, streamFile) != header_size) goto fail;
if ( file_size < 8 ) goto fail; if (clHCA_isOurFile1(header_buffer, header_size) < 0)
if ( read_streamfile(buffer, start, 8, streamFile) != 8 ) goto fail; goto fail;
header_size = clHCA_isOurFile0(buffer);
if ( header_size < 0 || header_size > 0x8000 ) goto fail;
if ( read_streamfile(buffer, start, header_size, streamFile) != header_size ) goto fail;
if ( clHCA_isOurFile1(buffer, header_size) < 0 ) goto fail;
/* init vgmstream context */ /* init vgmstream context */
hca_data = (hca_codec_data *) calloc(1, sizeof(hca_codec_data) + clHCA_sizeof()); hca_data = init_hca(streamFile);
if (!hca_data) goto fail;
//hca_data->size = file_size;
hca_data->start = 0;
hca_data->sample_ptr = clHCA_samplesPerBlock;
/* HCA_Decoder context memory goes right after our codec data (reserved in alloc'ed) */
hca = (clHCA *)(hca_data + 1);
/* pre-load streamfile so the hca_data is ready before key detection */
streamFile->get_name( streamFile, filename, sizeof(filename) );
hca_data->streamfile = streamFile->open(streamFile, filename, STREAMFILE_DEFAULT_BUFFER_SIZE);
if (!hca_data->streamfile) goto fail;
/* find decryption key in external file or preloaded list */ /* find decryption key in external file or preloaded list */
{ {
uint8_t keybuf[8]; uint8_t keybuf[8];
if (read_key_file(keybuf, 8, streamFile) == 8) { if (read_key_file(keybuf, 8, streamFile) == 8) {
ciphKey2 = get_32bitBE(keybuf+0); keycode_upper = get_32bitBE(keybuf+0);
ciphKey1 = get_32bitBE(keybuf+4); keycode_lower = get_32bitBE(keybuf+4);
} else { } else {
find_hca_key(hca_data, hca, buffer, header_size, &ciphKey1, &ciphKey2); find_hca_key(hca_data, header_buffer, header_size, &keycode_upper, &keycode_lower);
} }
} }
/* init decoder with key */ /* re-init decoder with key (as it must be supplied on header read) */
clHCA_clear(hca, ciphKey1, ciphKey2); clHCA_clear(hca_data->handle, keycode_lower, keycode_upper);
if ( clHCA_Decode(hca, buffer, header_size, 0) < 0 ) goto fail; if (clHCA_Decode(hca_data->handle, header_buffer, header_size, 0) < 0) /* read header at 0x00 */
if ( clHCA_getInfo(hca, &hca_data->info) < 0 ) goto fail; goto fail;
if (clHCA_getInfo(hca_data->handle, &hca_data->info) < 0) /* copy important header values to info struct */
goto fail;
/* build the VGMSTREAM */ /* build the VGMSTREAM */
vgmstream = allocate_vgmstream(hca_data->info.channelCount, hca_data->info.loopEnabled); vgmstream = allocate_vgmstream(hca_data->info.channelCount, hca_data->info.loopEnabled);
if (!vgmstream) goto fail; if (!vgmstream) goto fail;
vgmstream->meta_type = meta_HCA;
vgmstream->sample_rate = hca_data->info.samplingRate; vgmstream->sample_rate = hca_data->info.samplingRate;
vgmstream->num_samples = hca_data->info.blockCount * clHCA_samplesPerBlock; vgmstream->num_samples = hca_data->info.blockCount * clHCA_samplesPerBlock;
vgmstream->loop_start_sample = hca_data->info.loopStart * clHCA_samplesPerBlock; vgmstream->loop_start_sample = hca_data->info.loopStart * clHCA_samplesPerBlock;
@ -79,64 +62,68 @@ VGMSTREAM * init_vgmstream_hca(STREAMFILE *streamFile) {
vgmstream->coding_type = coding_CRI_HCA; vgmstream->coding_type = coding_CRI_HCA;
vgmstream->layout_type = layout_none; vgmstream->layout_type = layout_none;
vgmstream->meta_type = meta_HCA;
vgmstream->codec_data = hca_data; vgmstream->codec_data = hca_data;
return vgmstream; return vgmstream;
fail: fail:
free(hca_data); free_hca(hca_data);
return NULL; return NULL;
} }
#define HCA_KEY_MAX_TEST_CLIPS 400 /* hopefully nobody masters files with more that a handful... */
#define HCA_KEY_MAX_TEST_FRAMES 100 /* ~102400 samples */
#define HCA_KEY_MAX_TEST_SAMPLES 10240 /* ~10 frames of non-blank samples */
/* Tries to find the decryption key from a list. Simply decodes a few frames and checks if there aren't too many /* Tries to find the decryption key from a list. Simply decodes a few frames and checks if there aren't too many
* clipped samples, as it's common for invalid keys (though possible with valid keys in poorly mastered files). */ * clipped samples, as it's common for invalid keys (though possible with valid keys in poorly mastered files). */
static void find_hca_key(hca_codec_data * hca_data, clHCA * hca, uint8_t * buffer, int header_size, unsigned int * out_key1, unsigned int * out_key2) { static void find_hca_key(hca_codec_data * hca_data, uint8_t * header_buffer, int header_size, unsigned int * out_keycode_upper, unsigned int * out_keycode_lower) {
sample *testbuf = NULL, *temp; sample *testbuf = NULL;
int i, j, bufsize = 0, tempsize; int i, j, bufsize = 0, tempsize;
size_t keys_length = sizeof(hcakey_list) / sizeof(hcakey_info); size_t keys_length = sizeof(hcakey_list) / sizeof(hcakey_info);
int min_clip_count = -1; int min_clip_count = -1;
/* defaults to PSO2 key, most common */ /* defaults to PSO2 key, most common */
unsigned int best_key2 = 0xCC554639; unsigned int best_keycode_upper = 0xCC554639;
unsigned int best_key1 = 0x30DBE1AB; unsigned int best_keycode_lower = 0x30DBE1AB;
/* find a candidate key */ /* find a candidate key */
for (i = 0; i < keys_length; i++) { for (i = 0; i < keys_length; i++) {
int clip_count = 0, sample_count = 0; int clip_count = 0, sample_count = 0;
int f = 0, s; int frame = 0, s;
unsigned int key1, key2; unsigned int keycode_upper, keycode_lower;
uint64_t key = hcakey_list[i].key; uint64_t key = hcakey_list[i].key;
key2 = (key >> 32) & 0xFFFFFFFF; keycode_upper = (key >> 32) & 0xFFFFFFFF;
key1 = (key >> 0) & 0xFFFFFFFF; keycode_lower = (key >> 0) & 0xFFFFFFFF;
/* re-init HCA with the current key as buffer becomes invalid (probably can be simplified) */ /* re-init HCA with the current key as buffer becomes invalid (probably can be simplified) */
hca_data->curblock = 0; hca_data->curblock = 0;
hca_data->sample_ptr = clHCA_samplesPerBlock; hca_data->sample_ptr = clHCA_samplesPerBlock;
if ( read_streamfile(buffer, hca_data->start, header_size, hca_data->streamfile) != header_size ) continue; if (read_streamfile(header_buffer, hca_data->start, header_size, hca_data->streamfile) != header_size)
continue;
clHCA_clear(hca, key1, key2); clHCA_clear(hca_data->handle, keycode_lower, keycode_upper);
if (clHCA_Decode(hca, buffer, header_size, 0) < 0) continue; if (clHCA_Decode(hca_data->handle, header_buffer, header_size, 0) < 0)
if (clHCA_getInfo(hca, &hca_data->info) < 0) continue; continue;
if (hca_data->info.channelCount > 32) continue; /* nonsense don't alloc too much */ if (clHCA_getInfo(hca_data->handle, &hca_data->info) < 0)
continue;
tempsize = sizeof(sample) * clHCA_samplesPerBlock * hca_data->info.channelCount; tempsize = sizeof(sample) * clHCA_samplesPerBlock * hca_data->info.channelCount;
if (tempsize > bufsize) { /* should happen once */ if (tempsize > bufsize) { /* should happen once */
temp = (sample *)realloc(testbuf, tempsize); sample *temp = (sample *)realloc(testbuf, tempsize);
if (!temp) goto end; if (!temp) goto end;
testbuf = temp; testbuf = temp;
bufsize = tempsize; bufsize = tempsize;
} }
/* test enough frames, but not too many */ /* test enough frames, but not too many */
while (f < HCA_KEY_MAX_TEST_FRAMES && f < hca_data->info.blockCount) { while (frame < HCA_KEY_MAX_TEST_FRAMES && frame < hca_data->info.blockCount) {
j = clHCA_samplesPerBlock; j = clHCA_samplesPerBlock;
decode_hca(hca_data, testbuf, j, hca_data->info.channelCount); decode_hca(hca_data, testbuf, j);
j *= hca_data->info.channelCount; j *= hca_data->info.channelCount;
for (s = 0; s < j; s++) { for (s = 0; s < j; s++) {
@ -152,13 +139,13 @@ static void find_hca_key(hca_codec_data * hca_data, clHCA * hca, uint8_t * buffe
if (sample_count >= HCA_KEY_MAX_TEST_SAMPLES) if (sample_count >= HCA_KEY_MAX_TEST_SAMPLES)
break; /* enough non-blank samples tested */ break; /* enough non-blank samples tested */
f++; frame++;
} }
if (min_clip_count < 0 || clip_count < min_clip_count) { if (min_clip_count < 0 || clip_count < min_clip_count) {
min_clip_count = clip_count; min_clip_count = clip_count;
best_key2 = key2; best_keycode_upper = keycode_upper;
best_key1 = key1; best_keycode_lower = keycode_lower;
} }
if (min_clip_count == 0) if (min_clip_count == 0)
@ -172,11 +159,11 @@ static void find_hca_key(hca_codec_data * hca_data, clHCA * hca, uint8_t * buffe
/* reset HCA */ /* reset HCA */
hca_data->curblock = 0; hca_data->curblock = 0;
hca_data->sample_ptr = clHCA_samplesPerBlock; hca_data->sample_ptr = clHCA_samplesPerBlock;
read_streamfile(buffer, hca_data->start, header_size, hca_data->streamfile); read_streamfile(header_buffer, hca_data->start, header_size, hca_data->streamfile);
end: end:
VGM_ASSERT(min_clip_count > 0, "HCA: best key=%08x%08x (clips=%i)\n", best_key2,best_key1, min_clip_count); VGM_ASSERT(min_clip_count > 0, "HCA: best key=%08x%08x (clips=%i)\n", best_keycode_upper,best_keycode_lower, min_clip_count);
*out_key2 = best_key2; *out_keycode_upper = best_keycode_upper;
*out_key1 = best_key1; *out_keycode_lower = best_keycode_lower;
free(testbuf);//free(temp); free(testbuf);
} }

2
src/vgmstream.c
View File

@ -1676,7 +1676,7 @@ void decode_vgmstream(VGMSTREAM * vgmstream, int samples_written, int samples_to
#endif #endif
case coding_CRI_HCA: case coding_CRI_HCA:
decode_hca(vgmstream->codec_data, buffer+samples_written*vgmstream->channels, decode_hca(vgmstream->codec_data, buffer+samples_written*vgmstream->channels,
samples_to_do,vgmstream->channels); samples_to_do);
break; break;
#ifdef VGM_USE_FFMPEG #ifdef VGM_USE_FFMPEG
case coding_FFmpeg: case coding_FFmpeg:

5
src/vgmstream.h
View File

@ -1097,8 +1097,9 @@ typedef struct {
unsigned int curblock; unsigned int curblock;
unsigned int sample_ptr; unsigned int sample_ptr;
unsigned int samples_discard; unsigned int samples_discard;
signed short sample_buffer[clHCA_samplesPerBlock * 16]; signed short *sample_buffer;
//clHCA * hca exists here (pre-alloc'ed) void* handle;
void* data_buffer;
} hca_codec_data; } hca_codec_data;
#ifdef VGM_USE_FFMPEG #ifdef VGM_USE_FFMPEG