vgmstream/src/meta/hca.c

#include "meta.h"
#include "hca_keys.h"
#include "../coding/coding.h"

#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 */

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 * vgmstream = NULL;
    uint8_t 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 */
    clHCA * hca; /* HCA_Decoder context */
    unsigned int ciphKey1, ciphKey2;

    /* check extension, case insensitive */
    if ( !check_extensions(streamFile, "hca")) return NULL;


    /* test/init header (find real header size first) */
    if ( file_size < 8 ) goto fail;
    if ( read_streamfile(buffer, start, 8, streamFile) != 8 ) 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 */
    hca_data = (hca_codec_data *) calloc(1, sizeof(hca_codec_data) + clHCA_sizeof());
    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 */
    {
        uint8_t keybuf[8];
        if ( read_key_file(keybuf, 8, streamFile) ) {
            ciphKey2 = get_32bitBE(keybuf+0);
            ciphKey1 = get_32bitBE(keybuf+4);
        } else {
            find_hca_key(hca_data, hca, buffer, header_size, &ciphKey1, &ciphKey2);
        }
    }

    /* init decoder with key */
    clHCA_clear(hca, ciphKey1, ciphKey2);
    if ( clHCA_Decode(hca, buffer, header_size, 0) < 0 ) goto fail;
    if ( clHCA_getInfo(hca, &hca_data->info) < 0 ) goto fail;


    /* build the VGMSTREAM */
    vgmstream = allocate_vgmstream(hca_data->info.channelCount, hca_data->info.loopEnabled);
    if (!vgmstream) goto fail;

    vgmstream->sample_rate = hca_data->info.samplingRate;
    vgmstream->num_samples = hca_data->info.blockCount * clHCA_samplesPerBlock;
    vgmstream->loop_start_sample = hca_data->info.loopStart * clHCA_samplesPerBlock;
    vgmstream->loop_end_sample = hca_data->info.loopEnd * clHCA_samplesPerBlock;

    vgmstream->coding_type = coding_CRI_HCA;
    vgmstream->layout_type = layout_none;
    vgmstream->meta_type = meta_HCA;

    vgmstream->codec_data = hca_data;

    return vgmstream;

fail:
    free(hca_data);
    return NULL;
}


/* 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). */
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) {
    sample *testbuf = NULL, *temp;
    int i, j, bufsize = 0, tempsize;
    size_t keys_length = sizeof(hcakey_list) / sizeof(hcakey_info);

    int min_clip_count = -1;
    /* defaults to PSO2 key, most common */
    unsigned int best_key2 = 0xCC554639;
    unsigned int best_key1 = 0x30DBE1AB;


    /* find a candidate key */
    for (i = 0; i < keys_length; i++) {
        int clip_count = 0, sample_count = 0;
        int f = 0, s;

        unsigned int key1, key2;
        uint64_t key = hcakey_list[i].key;
        key2 = (key >> 32) & 0xFFFFFFFF;
        key1 = (key >>  0) & 0xFFFFFFFF;


        /* re-init HCA with the current key as buffer becomes invalid (probably can be simplified) */
        hca_data->curblock = 0;
        hca_data->sample_ptr = clHCA_samplesPerBlock;
        if ( read_streamfile(buffer, hca_data->start, header_size, hca_data->streamfile) != header_size ) continue;

        clHCA_clear(hca, key1, key2);
        if (clHCA_Decode(hca, buffer, header_size, 0) < 0) continue;
        if (clHCA_getInfo(hca, &hca_data->info) < 0) continue;
        if (hca_data->info.channelCount > 32) continue; /* nonsense don't alloc too much */

        tempsize = sizeof(sample) * clHCA_samplesPerBlock * hca_data->info.channelCount;
        if (tempsize > bufsize) { /* should happen once */
            temp = (sample *)realloc(testbuf, tempsize);
            if (!temp) goto end;
            testbuf = temp;
            bufsize = tempsize;
        }

        /* test enough frames, but not too many */
        while (f < HCA_KEY_MAX_TEST_FRAMES && f < hca_data->info.blockCount) {
            j = clHCA_samplesPerBlock;
            decode_hca(hca_data, testbuf, j, hca_data->info.channelCount);

            j *= hca_data->info.channelCount;
            for (s = 0; s < j; s++) {
                if (testbuf[s] != 0x0000 && testbuf[s] != 0xFFFF)
                    sample_count++; /* ignore upper/lower blank samples */

                if (testbuf[s] == 0x7FFF || testbuf[s] == 0x8000)
                    clip_count++; /* upper/lower clip */
            }

            if (clip_count > HCA_KEY_MAX_TEST_CLIPS)
                break; /* too many, don't bother */
            if (sample_count >= HCA_KEY_MAX_TEST_SAMPLES)
                break; /* enough non-blank samples tested */

            f++;
        }

        if (min_clip_count < 0 || clip_count < min_clip_count) {
            min_clip_count = clip_count;
            best_key2 = key2;
            best_key1 = key1;
        }

        if (min_clip_count == 0)
            break; /* can't get better than this */

        /* a few clips is normal, but some invalid keys may give low numbers too */
        //if (clip_count < 10)
        //    break;
    }

    /* reset HCA */
    hca_data->curblock = 0;
    hca_data->sample_ptr = clHCA_samplesPerBlock;
    read_streamfile(buffer, hca_data->start, header_size, hca_data->streamfile);

end:
    VGM_ASSERT(min_clip_count > 0, "HCA: best key=%08x%08x (clips=%i)\n", best_key2,best_key1, min_clip_count);
    *out_key2 = best_key2;
    *out_key1 = best_key1;
    free(testbuf);//free(temp);
}