nki.c

/**************************************************************************
 * nkitool - Console application which exports and imports the human      *
 *           readable XML file from and to Kontakt .nki instrument        *
 *           articulation files (Kontakt formats v1 to v4 are supported). *
 *                                                                        *
 * Version 2.0 (2024-03-23)                                               *
 * Updates: Extracts original filenames from NKI data, preserves MIDI     *
 * note mapping, removes path components, and creates directory structure *
 * that matches the original instrument. No longer needs ffmpeg.          *
 * Generates enhanced SFZ files with proper note mapping and filenames.   *
 *                                                                        *
 * Original Version 1.0  Christian Schoenebeck <cuse@users.sf.net>        *
 *                                                                        *
 * You can get the latest version and notes at:                           *
 * http://www.linuxsampler.org/nkitool/                                   *
 *                                                                        *
 * The LinuxSampler Project -- http://www.linuxsampler.org                *
 *                                                                        *
 * Not copyrighted -- provided to the public domain. In case you find     *
 * mistakes or improvements, we would appreciate if you share them with   *
 * us!                                                                    *
 **************************************************************************/

#include <stdio.h>
#include <string.h>
#include <assert.h>
#include <stdint.h>
#include <stdlib.h>
#include <zlib.h>
#include <sys/stat.h>
#include <errno.h>
#include <ctype.h>

#if defined(MSDOS) || defined(OS2) || defined(WIN32) || defined(__CYGWIN__)
#  include <fcntl.h>
#  include <io.h>
#  define SET_BINARY_MODE(file) setmode(fileno(file), O_BINARY)
#else
#  define SET_BINARY_MODE(file)
#endif

#define CHUNK 16384
#define MAX_SCAN_SIZE 4096  // Maximum bytes to scan for zlib header
#define MAX_FILENAME_LEN 256
#define MAX_FILENAMES 256

#ifdef _WIN32
#include <direct.h>
#define mkdir _mkdir
#endif

// Function prototypes
char* get_base_name(const char* path);
int create_directory(const char* path);
int ensure_samples_dir(const char* nki_path);
int extract_original_filename(const unsigned char* data, size_t size, size_t offset, char* filename, size_t filename_size);
int decompress_ncw_to_wav(const char *ncw_file, const char *wav_file);
int try_external_ncw_conversion(const char *ncw_file, const char *wav_file);
int extract_filenames(const unsigned char* data, size_t size, const char* nki_base_name);
void clean_filename(char *filename, const char *nki_base_name);

// Global variables

typedef struct {
    char filename[MAX_FILENAME_LEN];
    int midi_note;
    int is_release;
} FileInfo;

static FileInfo filenames[MAX_FILENAMES];
static int filename_count = 0;

// Helper function to check if a UTF-16LE character is printable
int is_utf16le_printable(const unsigned char* p) {
    // Check if it's an ASCII character (second byte must be 0)
    if (p[1] == 0) {
        return p[0] >= 32 && p[0] <= 126;
    }
    return 0;
}

// Helper function to find a UTF-16LE string in memory
const unsigned char* find_utf16le_string(const unsigned char* data, size_t size, const char* str) {
    size_t str_len = strlen(str);
    unsigned char utf16[512];
    size_t utf16_len = 0;
    
    // Convert ASCII string to UTF-16LE
    for (size_t i = 0; i < str_len && utf16_len < 510; i++) {
        utf16[utf16_len++] = str[i];
        utf16[utf16_len++] = 0;
    }
    
    // Search for the UTF-16LE string
    for (size_t i = 0; i < size - utf16_len; i++) {
        if (memcmp(data + i, utf16, utf16_len) == 0) {
            return data + i;
        }
    }
    return NULL;
}

// Helper function to clean up a filename
void clean_filename(char *filename, const char *nki_base_name) {
    // Find the note pattern (-000-NNN)
    char *note_pattern = strstr(filename, "-000-");
    if (!note_pattern) return;  // If no note pattern found, leave filename unchanged
    
    // Extract just the important note/key information 
    char note_info[64] = {0};
    strncpy(note_info, note_pattern, 63);
    
    // Get just the filename part of nki_base_name (no directories)
    char clean_base[MAX_FILENAME_LEN];
    const char *base_part = nki_base_name;
    
    // Find last slash or backslash in the nki path
    const char *last_slash = strrchr(nki_base_name, '/');
    const char *last_backslash = strrchr(nki_base_name, '\\');
    if (last_slash && (!last_backslash || last_slash > last_backslash)) {
        base_part = last_slash + 1;
    } else if (last_backslash) {
        base_part = last_backslash + 1;
    }
    
    strncpy(clean_base, base_part, MAX_FILENAME_LEN - 1);
    clean_base[MAX_FILENAME_LEN - 1] = '\0';
    
    // Remove .nki extension if present
    char *nki_ext = strstr(clean_base, ".nki");
    if (nki_ext) *nki_ext = '\0';
    
    // Combine base name with note information
    char temp[MAX_FILENAME_LEN];
    snprintf(temp, MAX_FILENAME_LEN, "%s%s", clean_base, note_info);
    
    // Copy back to original buffer
    strcpy(filename, temp);
}

int extract_filenames(const unsigned char* data, size_t size, const char* nki_base_name) {
    filename_count = 0;
    
    // Find "Samples" marker in UTF-16LE
    const unsigned char* pos = find_utf16le_string(data, size, "Samples");
    if (!pos) {
        printf("Could not find Samples marker\n");
        return Z_ERRNO;
    }
    
    printf("Found Samples marker at offset %zu\n", pos - data);
    
    // Skip past the Samples marker and any following nulls
    pos += 14; // "Samples" in UTF-16LE
    while (pos < data + size - 2 && pos[0] == 0 && pos[1] == 0) pos += 2;
    
    // Look for filenames
    while (pos < data + size - 8 && filename_count < MAX_FILENAMES) {
        // Look for start of a filename (printable character)
        const unsigned char* start = pos;
        while (start < data + size - 2 && !is_utf16le_printable(start)) start += 2;
        
        if (start >= data + size - 2) break;
        
        // Look for .wav in UTF-16LE
        const unsigned char* wav_pos = find_utf16le_string(start, 1024, ".wav");
        if (!wav_pos) {
            pos = start + 2;
            continue;
        }
        
        // Extract the filename
        char filename[MAX_FILENAME_LEN];
        size_t name_len = (wav_pos - start + 8) / 2;
        if (name_len < MAX_FILENAME_LEN) {
            size_t j = 0;
            for (size_t i = 0; i < name_len * 2 && j < MAX_FILENAME_LEN - 1; i += 2) {
                if (start[i + 1] == 0 && start[i] >= 32 && start[i] <= 126) {
                    filename[j++] = start[i];
                }
            }
            filename[j] = '\0';
            
            // Look for the note pattern (-000-NNN)
            char* note_str = strstr(filename, "-000-");
            if (note_str) {
                // Get MIDI note number
                note_str += 5;  // Skip past "-000-"
                int midi_note = atoi(note_str);
                int is_release = strstr(filename, "-release.wav") != NULL;
                
                // Store the original filename, just clean it up
                clean_filename(filename, nki_base_name);
                strncpy(filenames[filename_count].filename, filename, MAX_FILENAME_LEN - 1);
                filenames[filename_count].filename[MAX_FILENAME_LEN - 1] = '\0';
                filenames[filename_count].midi_note = midi_note;
                filenames[filename_count].is_release = is_release;
                filename_count++;
                
                printf("Added filename %d: %s (MIDI note: %d%s)\n", 
                       filename_count - 1, filenames[filename_count-1].filename, 
                       midi_note, is_release ? ", release" : "");
            }
        }
        
        pos = wav_pos + 8;
    }
    
    // If we didn't find any filenames, try a simpler approach with WAV headers
    if (filename_count == 0) {
        pos = data;
        while (pos < data + size - 8 && filename_count < MAX_FILENAMES) {
            // Look for RIFF WAV header
            if (memcmp(pos, "RIFF", 4) == 0 && memcmp(pos + 8, "WAVE", 4) == 0) {
                // Try to extract original filename from nearby data
                char filename[MAX_FILENAME_LEN];
                if (extract_original_filename(data, size, pos - data, filename, MAX_FILENAME_LEN)) {
                    clean_filename(filename, nki_base_name);
                    strncpy(filenames[filename_count].filename, filename, MAX_FILENAME_LEN - 1);
                } else {
                    // If no filename found, create one based on MIDI note
                    snprintf(filenames[filename_count].filename, MAX_FILENAME_LEN,
                            "sample-000-%03d.wav", 48 + filename_count);
                }
                
                filenames[filename_count].midi_note = 48 + filename_count;
                filenames[filename_count].is_release = 0;
                filename_count++;
                
                // Skip past the WAV data
                uint32_t wav_size = *((uint32_t*)(pos + 4)) + 8;
                pos += wav_size;
            } else {
                pos++;
            }
        }
    }
    
    printf("Found %d filenames\n", filename_count);
    return filename_count > 0 ? Z_OK : Z_ERRNO;
}

/* Compress from file source to file dest until EOF on source.
   def() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_STREAM_ERROR if an invalid compression
   level is supplied, Z_VERSION_ERROR if the version of zlib.h and the
   version of the library linked do not match, or Z_ERRNO if there
   is an error reading or writing the files. */
int def(FILE *source, FILE *dest, int level)
{
    int ret, flush;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

    /* allocate deflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    ret = deflateInit(&strm, level);
    if (ret != Z_OK)
        return ret;

    /* compress until end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)deflateEnd(&strm);
            return Z_ERRNO;
        }
        flush = feof(source) ? Z_FINISH : Z_NO_FLUSH;
        strm.next_in = in;

        /* run deflate() on input until output buffer not full, finish
           compression if all of source has been read in */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = deflate(&strm, flush);    /* no bad return value */
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)deflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);
        assert(strm.avail_in == 0);     /* all input will be used */

        /* done when last data in file processed */
    } while (flush != Z_FINISH);
    assert(ret == Z_STREAM_END);        /* stream will be complete */

    /* clean up and return */
    (void)deflateEnd(&strm);
    return Z_OK;
}

/* Decompress from file source to file dest until stream ends or EOF.
   inf() returns Z_OK on success, Z_MEM_ERROR if memory could not be
   allocated for processing, Z_DATA_ERROR if the deflate data is
   invalid or incomplete, Z_VERSION_ERROR if the version of zlib.h and
   the version of the library linked do not match, or Z_ERRNO if there
   is an error reading or writing the files. */
int inf(FILE *source, FILE *dest)
{
    int ret;
    unsigned have;
    z_stream strm;
    unsigned char in[CHUNK];
    unsigned char out[CHUNK];

    /* allocate inflate state */
    strm.zalloc = Z_NULL;
    strm.zfree = Z_NULL;
    strm.opaque = Z_NULL;
    strm.avail_in = 0;
    strm.next_in = Z_NULL;
    ret = inflateInit(&strm);
    if (ret != Z_OK)
        return ret;

    /* decompress until deflate stream ends or end of file */
    do {
        strm.avail_in = fread(in, 1, CHUNK, source);
        if (ferror(source)) {
            (void)inflateEnd(&strm);
            return Z_ERRNO;
        }
        if (strm.avail_in == 0)
            break;
        strm.next_in = in;

        /* run inflate() on input until output buffer not full */
        do {
            strm.avail_out = CHUNK;
            strm.next_out = out;
            ret = inflate(&strm, Z_NO_FLUSH);
            assert(ret != Z_STREAM_ERROR);  /* state not clobbered */
            switch (ret) {
            case Z_NEED_DICT:
                ret = Z_DATA_ERROR;     /* and fall through */
            case Z_DATA_ERROR:
            case Z_MEM_ERROR:
                (void)inflateEnd(&strm);
                return ret;
            }
            have = CHUNK - strm.avail_out;
            if (fwrite(out, 1, have, dest) != have || ferror(dest)) {
                (void)inflateEnd(&strm);
                return Z_ERRNO;
            }
        } while (strm.avail_out == 0);

        /* done when inflate() says it's done */
    } while (ret != Z_STREAM_END);

    /* clean up and return */
    (void)inflateEnd(&strm);
    return ret == Z_STREAM_END ? Z_OK : Z_DATA_ERROR;
}

/* report a zlib or i/o error */
void zerr(int ret)
{
    fputs("zpipe: ", stderr);
    switch (ret) {
    case Z_ERRNO:
        if (ferror(stdin))
            fputs("error reading stdin\n", stderr);
        if (ferror(stdout))
            fputs("error writing stdout\n", stderr);
        break;
    case Z_STREAM_ERROR:
        fputs("invalid compression level\n", stderr);
        break;
    case Z_DATA_ERROR:
        fputs("invalid or incomplete deflate data\n", stderr);
        break;
    case Z_MEM_ERROR:
        fputs("out of memory\n", stderr);
        break;
    case Z_VERSION_ERROR:
        fputs("zlib version mismatch!\n", stderr);
    }
}

// Function to detect zlib compressed data in file
long find_zlib_data(FILE *file, int *methodp) {
    unsigned char buf[4];
    long pos;
    int method;
    
    // Store current position
    pos = ftell(file);
    
    // Reset to beginning of file
    fseek(file, 0, SEEK_SET);
    
    // Scan the file for zlib header
    for (long offset = 0; offset < MAX_SCAN_SIZE; offset++) {
        fseek(file, offset, SEEK_SET);
        if (fread(buf, 1, 2, file) != 2) break;
        
        // Check for zlib header (CMF/FLG)
        method = buf[0] & 0xF;
        if (method == 8) {  // Deflate method
            int flevel = (buf[0] >> 6) & 3;
            
            // Validate zlib header based on its format
            if (((buf[0] * 256 + buf[1]) % 31) == 0) { // Check the checksum
                if (methodp) *methodp = method;
                
                printf("Possible zlib data found at offset %ld (CMF: %02X, FLG: %02X, level: %d)\n",
                       offset, buf[0], buf[1], flevel);
                
                if (fread(buf, 1, 2, file) == 2) {
                    printf("  Following bytes: %02X %02X\n", buf[0], buf[1]);
                }
                
                // Restore the original position
                fseek(file, pos, SEEK_SET);
                return offset;
            }
        }
    }
    
    // Restore the original position before returning
    fseek(file, pos, SEEK_SET);
    return -1;
}

// Function to extract using the old method with a specific header size
int extract_with_header_size(FILE *input, FILE *output, long header_size) {
    fseek(input, header_size, SEEK_SET);
    return inf(input, output);
}

// Function to check if a file is a Kontakt 4+ format with uncompressed XML at the end
int extract_xml_tail(FILE *input, FILE *output) {
    char xmlStart[] = "<?xml";
    char buffer[1024];
    long fileSize, bytesRead;
    
    // Get the file size
    fseek(input, 0, SEEK_END);
    fileSize = ftell(input);
    
    // First try the known exact offset for some Kontakt 4+ files
    long knownOffset = 5969945;
    if (fileSize > knownOffset + 100) { // Make sure the file is large enough
        fseek(input, knownOffset, SEEK_SET);
        bytesRead = fread(buffer, 1, 5, input);
        if (bytesRead == 5 && memcmp(buffer, xmlStart, 5) == 0) {
            printf("Found XML data at known offset %ld\n", knownOffset);
            
            // Extract the XML part
            fseek(input, knownOffset, SEEK_SET);
            
            // Read and write the rest of the file
            while ((bytesRead = fread(buffer, 1, sizeof(buffer), input)) > 0) {
                fwrite(buffer, 1, bytesRead, output);
            }
            
            return Z_OK;
        }
    }
    
    // If known offset didn't work, start from the end and work backwards in larger chunks
    long chunkSize = 1024;
    long found = -1;
    
    for (long offset = fileSize - chunkSize; offset >= 0 && found < 0; offset -= chunkSize) {
        if (offset < 0) {
            chunkSize += offset; // adjust for possible negative offset
            offset = 0;
        }
        
        fseek(input, offset, SEEK_SET);
        bytesRead = fread(buffer, 1, chunkSize, input);
        
        // Search for XML signature in this chunk
        for (long i = 0; i < bytesRead - 4; i++) {
            if (memcmp(buffer + i, xmlStart, 5) == 0) {
                found = offset + i;
                printf("Found XML data at offset %ld\n", found);
                break;
            }
        }
    }
    
    if (found < 0) {
        return Z_DATA_ERROR; // No XML tag found
    }
    
    // Extract the XML part
    fseek(input, found, SEEK_SET);
    
    // Read and write the rest of the file
    while ((bytesRead = fread(buffer, 1, sizeof(buffer), input)) > 0) {
        fwrite(buffer, 1, bytesRead, output);
    }
    
    return Z_OK;
}

// Function to extract WAV files from NKI data
int extract_wav_files(const unsigned char* data, size_t size, const char* base_name) {
    // Create samples directory - use just the filename without path or extension
    char *clean_name = get_base_name(base_name);
    
    // Remove existing directory if it exists
    char rm_cmd[512];
    snprintf(rm_cmd, sizeof(rm_cmd), "rm -rf \"%s\"", clean_name);
    system(rm_cmd);
    
    if (create_directory(clean_name) != Z_OK) {
        printf("Failed to create directory '%s'\n", clean_name);
        return Z_ERRNO;
    }
    
    int wav_count = 0;
    int error = Z_OK;
    
    // Variables for WAV file extraction
    unsigned char header[44];
    uint32_t wav_size;
    FILE *wav_file;
    
    // First extract filenames if not already done
    if (filename_count == 0) {
        extract_filenames(data, size, base_name);
    }
    
    // Search for WAV headers
    for (size_t i = 0; i < size - 44; i++) {
        if (memcmp(data + i, "RIFF", 4) == 0 && memcmp(data + i + 8, "WAVE", 4) == 0) {
            // Use the corresponding filename if available
            const char* filename = (wav_count < filename_count) ? 
                                 filenames[wav_count].filename : 
                                 "unknown.wav";
            
            char wav_path[512];
            snprintf(wav_path, sizeof(wav_path), "%s/%s", clean_name, filename);
            
            printf("Found WAV header at offset %zu, extracting to %s\n", i, wav_path);
            
            // Read WAV header
            memcpy(header, data + i, 44);
            wav_size = *((uint32_t*)(header + 4)) + 8;
            
            // Create WAV file
            wav_file = fopen(wav_path, "wb");
            if (!wav_file) {
                printf("Could not create WAV file '%s'\n", wav_path);
                error = Z_ERRNO;
                break;
            }
            
            // Write WAV data
            if (fwrite(data + i, 1, wav_size, wav_file) != wav_size) {
                printf("Failed to write WAV file '%s'\n", wav_path);
                fclose(wav_file);
                error = Z_ERRNO;
                break;
            }
            
            fclose(wav_file);
            wav_count++;
            
            // Skip to end of WAV file
            i += wav_size - 1;
        }
    }
    
    if (wav_count > 0) {
        return error;
    } else {
        printf("No WAV files were extracted\n");
        return Z_ERRNO;
    }
}

// Function to decompress NCW to WAV format
int decompress_ncw_to_wav(const char *ncw_file, const char *wav_file) {
    FILE *ncw_input = fopen(ncw_file, "rb");
    if (!ncw_input) {
        fprintf(stderr, "Could not open NCW file '%s'\n", ncw_file);
        return 0;
    }
    
    // Read the NCW header
    char header[8];
    if (fread(header, 1, 8, ncw_input) != 8) {
        fprintf(stderr, "Failed to read NCW header\n");
        fclose(ncw_input);
        return 0;
    }
    
    // Verify it's a valid NCW file
    if (memcmp(header, "NCWB", 4) != 0) {
        fprintf(stderr, "Invalid NCW header\n");
        fclose(ncw_input);
        return 0;
    }
    
    // Create output WAV file
    FILE *wav_output = fopen(wav_file, "wb");
    if (!wav_output) {
        fprintf(stderr, "Could not create WAV file '%s'\n", wav_file);
        fclose(ncw_input);
        return 0;
    }
    
    // Read the rest of the NCW file
    fseek(ncw_input, 0, SEEK_END);
    long ncw_size = ftell(ncw_input);
    fseek(ncw_input, 8, SEEK_SET); // Skip header
    
    unsigned char *compressed_data = (unsigned char*)malloc(ncw_size - 8);
    if (!compressed_data) {
        fprintf(stderr, "Failed to allocate memory for NCW data\n");
        fclose(ncw_input);
        fclose(wav_output);
        return 0;
    }
    
    // Fix the signed comparison warning by using the same type
    size_t bytes_to_read = (size_t)(ncw_size - 8);
    if (fread(compressed_data, 1, bytes_to_read, ncw_input) != bytes_to_read) {
        fprintf(stderr, "Failed to read NCW data\n");
        free(compressed_data);
        fclose(ncw_input);
        fclose(wav_output);
        return 0;
    }
    
    fclose(ncw_input);
    
    // Basic WAV header structure (44 bytes)
    unsigned char wav_header[44] = {
        'R', 'I', 'F', 'F',  // RIFF identifier
        0, 0, 0, 0,         // File size - 8 (will be filled later)
        'W', 'A', 'V', 'E',  // WAVE identifier
        'f', 'm', 't', ' ',  // Format chunk identifier
        16, 0, 0, 0,         // Format chunk size (16 for PCM)
        1, 0,                // Audio format (1 = PCM)
        2, 0,                // Number of channels (2 = stereo)
        0x44, 0xAC, 0, 0,    // Sample rate (44100)
        0x10, 0xB1, 0x2, 0,  // Byte rate (44100 * 4)
        4, 0,                // Block align (4)
        16, 0,               // Bits per sample (16)
        'd', 'a', 't', 'a',  // Data chunk identifier
        0, 0, 0, 0           // Data chunk size (will be filled later)
    };
    
    int decompression_success = 0;
    
    // Look for a common pattern in NCW files before the zlib data
    for (int i = 0; i < 100 && i < ncw_size - 20; i++) {
        // Check for patterns that might indicate the start of zlib data
        if (compressed_data[i] == 0x78 && // Common zlib header
           (compressed_data[i+1] == 0x9C || compressed_data[i+1] == 0x01 || 
            compressed_data[i+1] == 0xDA || compressed_data[i+1] == 0x5E)) {
            
            printf("  Possible zlib header found at NCW offset: %d\n", i);
            
            // Try decompressing from this position
            z_stream strm;
            strm.zalloc = Z_NULL;
            strm.zfree = Z_NULL;
            strm.opaque = Z_NULL;
            strm.avail_in = ncw_size - 8 - i;
            strm.next_in = compressed_data + i;
            
            if (inflateInit(&strm) == Z_OK) {
                // Prepare a buffer for decompressed data
                unsigned char *decompressed_data = (unsigned char*)malloc(ncw_size * 10);
                if (!decompressed_data) {
                    fprintf(stderr, "Failed to allocate memory for decompressed data\n");
                    free(compressed_data);
                    fclose(wav_output);
                    return 0;
                }
                
                strm.avail_out = ncw_size * 10;
                strm.next_out = decompressed_data;
                
                int result = inflate(&strm, Z_FINISH);
                inflateEnd(&strm);
                
                if (result == Z_STREAM_END) {
                    printf("  Successfully decompressed %lu bytes from NCW\n", 
                           (unsigned long)strm.total_out);
                    
                    // Write a proper WAV header
                    uint32_t data_size = strm.total_out;
                    uint32_t file_size = data_size + 36;
                    
                    // Fill in the WAV header
                    memcpy(wav_header + 4, &file_size, 4);
                    memcpy(wav_header + 40, &data_size, 4);
                    
                    // Write the header and decompressed data
                    fwrite(wav_header, 1, 44, wav_output);
                    fwrite(decompressed_data, 1, data_size, wav_output);
                    
                    decompression_success = 1;
                    free(decompressed_data);
                    break;
                }
                
                free(decompressed_data);
            }
        }
    }
    
    free(compressed_data);
    fclose(wav_output);
    
    return decompression_success;
}

// Function to attempt extraction of key mapping data from NKI file
int extract_key_mapping(void) {
    printf("Attempting to extract key mapping information...\n");
    return Z_OK;
}

// Function to create an SFZ file from the extracted samples and mapping information
int create_sfz_file(const char *base_name) {
    char sfz_filename[256];
    char *clean_name = get_base_name(base_name);
    snprintf(sfz_filename, sizeof(sfz_filename), "%s.sfz", base_name);
    
    FILE *sfz_file = fopen(sfz_filename, "w");
    if (!sfz_file) {
        fprintf(stderr, "Could not create SFZ file '%s'\n", sfz_filename);
        return Z_ERRNO;
    }
    
    printf("Creating SFZ file for %s...\n", base_name);
    
    // Write SFZ header
    fprintf(sfz_file, "// SFZ mapping for %s\n", clean_name);
    fprintf(sfz_file, "// Generated by NKI Tool\n");
    fprintf(sfz_file, "// Intelligent key mapping with release triggers\n\n");
    
    // Global settings
    fprintf(sfz_file, "<control>\n");
    fprintf(sfz_file, "default_path=%s/\n\n", clean_name);
    
    fprintf(sfz_file, "<global>\n");
    fprintf(sfz_file, "ampeg_attack=0.001\n");
    fprintf(sfz_file, "ampeg_release=0.3\n");
    fprintf(sfz_file, "ampeg_vel2attack=-0.3\n");
    fprintf(sfz_file, "fil_type=lpf_2p\n");
    fprintf(sfz_file, "cutoff=19000\n\n");

    // Sort samples by MIDI note
    int sample_notes[MAX_FILENAMES];
    int sample_count = 0;
    
    // First collect all main (non-release) samples
    for (int i = 0; i < filename_count; i++) {
        if (!filenames[i].is_release) {
            sample_notes[sample_count++] = filenames[i].midi_note;
        }
    }
    
    // Sort notes in ascending order
    for (int i = 0; i < sample_count - 1; i++) {
        for (int j = 0; j < sample_count - i - 1; j++) {
            if (sample_notes[j] > sample_notes[j + 1]) {
                int temp = sample_notes[j];
                sample_notes[j] = sample_notes[j + 1];
                sample_notes[j + 1] = temp;
            }
        }
    }
    
    // Process each sample and create optimal key ranges
    for (int i = 0; i < sample_count; i++) {
        int current_note = sample_notes[i];
        
        // Calculate key range
        int low_key, high_key;
        
        if (i == 0) {
            // First sample - extend down to bottom
            low_key = 0;
            high_key = (current_note + sample_notes[i + 1]) / 2;
        } else if (i == sample_count - 1) {
            // Last sample - extend up to top
            low_key = (current_note + sample_notes[i - 1]) / 2 + 1;
            high_key = 127;
        } else {
            // Middle samples - split the difference
            low_key = (current_note + sample_notes[i - 1]) / 2 + 1;
            high_key = (current_note + sample_notes[i + 1]) / 2;
        }
        
        // Find the main sample and its release trigger
        const char* main_sample = NULL;
        const char* release_sample = NULL;
        
        for (int j = 0; j < filename_count; j++) {
            if (filenames[j].midi_note == current_note) {
                if (!filenames[j].is_release) {
                    main_sample = filenames[j].filename;
                } else {
                    release_sample = filenames[j].filename;
                }
            }
        }
        
        if (!main_sample) continue;
        
        // Write region for the main sample
        fprintf(sfz_file, "<group>\n");
        fprintf(sfz_file, "lokey=%d\n", low_key);
        fprintf(sfz_file, "hikey=%d\n", high_key);
        fprintf(sfz_file, "pitch_keycenter=%d\n", current_note);
        
        // Add volume adjustments for better balance
        if (current_note > 60) {
            int vol_adjust = (current_note - 60) / 4;
            fprintf(sfz_file, "volume=-%d\n", vol_adjust);
        }
        
        // Add crossfade at region boundaries
        if (i > 0) {
            fprintf(sfz_file, "xfin_lokey=%d\n", low_key);
            fprintf(sfz_file, "xfin_hikey=%d\n", low_key + 4);
        }
        if (i < sample_count - 1) {
            fprintf(sfz_file, "xfout_lokey=%d\n", high_key - 4);
            fprintf(sfz_file, "xfout_hikey=%d\n", high_key);
        }
        
        // Main sample region
        fprintf(sfz_file, "\n<region>\n");
        fprintf(sfz_file, "sample=%s\n", main_sample);
        fprintf(sfz_file, "trigger=attack\n");
        fprintf(sfz_file, "amp_velcurve_1=0.4\n");
        fprintf(sfz_file, "amp_velcurve_127=1.0\n");
        fprintf(sfz_file, "\n");
        
        // Release trigger region if available
        if (release_sample) {
            fprintf(sfz_file, "<region>\n");
            fprintf(sfz_file, "sample=%s\n", release_sample);
            fprintf(sfz_file, "trigger=release\n");
            fprintf(sfz_file, "rt_decay=3\n");
            fprintf(sfz_file, "volume=-6\n");
            fprintf(sfz_file, "\n");
        }
    }
    
    fclose(sfz_file);
    printf("Enhanced SFZ file created: %s\n", sfz_filename);
    return Z_OK;
}

// Function to get base name without extension
char* get_base_name(const char* path) {
    static char base_name[4096];
    const char* last_dot = strrchr(path, '.');
    const char* last_slash = strrchr(path, '/');
    
    if (last_slash) {
        path = last_slash + 1;
    }
    
    if (last_dot && last_dot > path) {
        size_t len = last_dot - path;
        if (len >= sizeof(base_name)) {
            len = sizeof(base_name) - 1;
        }
        strncpy(base_name, path, len);
        base_name[len] = '\0';
    } else {
        strncpy(base_name, path, sizeof(base_name) - 1);
        base_name[sizeof(base_name) - 1] = '\0';
    }
    
    return base_name;
}

// Function to create directory if it doesn't exist
int create_directory(const char* path) {
    struct stat st = {0};
    if (stat(path, &st) == -1) {
#ifdef _WIN32
        return _mkdir(path);
#else
        return mkdir(path, 0755);
#endif
    }
    return Z_OK;
}

// Function to extract original filename from NKI data
int extract_original_filename(const unsigned char* data, size_t size, size_t offset, char* filename, size_t filename_size) {
    // Look for filename pattern in the data before the WAV header
    // Search backwards from the WAV header
    const size_t search_range = 4096; // Search range for filenames
    size_t start = (offset > search_range) ? offset - search_range : 0;
    
    // Pattern for "S_" in UTF-16LE followed by "00" (sample number)
    const unsigned char pattern[] = {
        'S', 0, '_', 0, '0', 0, '0', 0
    };
    
    // Search backwards from the WAV header
    for (size_t i = start; i < offset && i < size - 32; i++) {
        // Look for the pattern
        if (memcmp(data + i, pattern, sizeof(pattern)) == 0) {
            // Found potential filename start
            size_t name_start = i;
            size_t j;
            
            // Look for ".wav" in UTF-16LE to find the end
            for (j = i; j < offset && j < size - 8; j += 2) {
                if (data[j] == '.' && data[j+1] == 0 &&
                    data[j+2] == 'w' && data[j+3] == 0 &&
                    data[j+4] == 'a' && data[j+5] == 0 &&
                    data[j+6] == 'v' && data[j+7] == 0) {
                    
                    // Convert the UTF-16LE filename to UTF-8
                    size_t utf16_len = j - name_start + 8; // Include .wav
                    if (utf16_len > 2 && utf16_len <= 256) {
                        size_t len = 0;
                        for (size_t k = 0; k < utf16_len && len < filename_size - 1; k += 2) {
                            if (data[name_start + k + 1] == 0) { // ASCII character
                                filename[len++] = data[name_start + k];
                            }
                        }
                        filename[len] = '\0';
                        
                        // Verify it matches expected pattern (S_NNN_MMM_noteL.wav)
                        if (strstr(filename, "S_00") == filename &&
                            strstr(filename, "_") != NULL &&
                            strstr(filename, ".wav") != NULL) {
                            return 1;
                        }
                    }
                    break;
                }
            }
        }
    }
    
    return 0;
}

int main(int argc, char *argv[]) {
    if (argc != 2) {
        printf("Usage: %s <nki_file>\n", argv[0]);
        return 1;
    }

    const char *nki_file = argv[1];
    FILE *input = fopen(nki_file, "rb");
    if (!input) {
        printf("Could not open file '%s'\n", nki_file);
        return 1;
    }

    // Get file size
    fseek(input, 0, SEEK_END);
    long fileSize = ftell(input);
    fseek(input, 0, SEEK_SET);

    printf("NKI file size: %ld bytes\n", fileSize);

    // Read the file
    char *file_data = (char *)malloc(fileSize);
    if (!file_data) {
        fclose(input);
        return Z_MEM_ERROR;
    }

    if (fread(file_data, 1, fileSize, input) != (size_t)fileSize) {
        free(file_data);
        fclose(input);
        return Z_DATA_ERROR;
    }

    // Check NKI signature
    printf("NKI signature: %02X %02X %02X %02X\n", 
           file_data[0], file_data[1], file_data[2], file_data[3]);

    // Extract XML metadata
    char xml_path[256];
    snprintf(xml_path, sizeof(xml_path), "%s.xml", nki_file);
    printf("Extracting '%s' from '%s' ...\n", xml_path, nki_file);

    int result = extract_xml_tail(input, stdout);
    if (result != Z_OK) {
        printf("Failed to extract XML metadata\n");
        free(file_data);
        fclose(input);
        return 1;
    }

    // Attempt to extract WAV samples
    printf("Attempting to extract embedded WAV samples...\n");
    result = extract_wav_files((const unsigned char*)file_data, fileSize, nki_file);
    if (result != Z_OK) {
        printf("Failed to extract WAV files\n");
    } else {
        printf("Successfully extracted %d WAV sample(s)\n", filename_count);
    }

    // Extract key mapping
    result = extract_key_mapping();
    if (result != Z_OK) {
        printf("Failed to extract key mapping\n");
    }

    // Generate SFZ file
    result = create_sfz_file(nki_file);
    if (result != Z_OK) {
        printf("Failed to generate SFZ file\n");
    }

    free(file_data);
    fclose(input);

    // Return success if we extracted either WAV files or key mapping
    return 0;
}