// Data ID constants

#define FZX_ROM_BAD    0

#define FZX_ROM_J      1

#define FZX_ROM_U      2

#define FZX_ROM_P      3

#define FZX_ROM_HACK   4 



// ROM version/format constants

#define FZX_VER_BAD   0

#define FZX_VER_JZ    1

#define FZX_VER_UZ    2

#define FZX_VER_PZ    3

#define FZX_VER_JV    4

#define FZX_VER_UV    5

#define FZX_VER_PV    6



// Function prototypes

void fzxByteSwap(unsigned char *, unsigned long);

char fzxCheckROM(unsigned char *, char);

unsigned char *fzxLoadROM(char *, unsigned long *);

char fzxROMVersion(unsigned char *, unsigned long);

// Includes

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include "fzxROM.h"



// CRCs

#define FZX_CRC_J   0x6B1CEF83

#define FZX_CRC_U   0x0B561FBA

#define FZX_CRC_P   0x2D6F7E8B



// Generates a CRC 8-bit lookup table

void crcGenTable(unsigned int *CRCTable, unsigned int Poly) {

    unsigned int A, B, Reg;

    

    // Cycle through indexes

    for (A = 0; A < 256; A++) {

        Reg = A;

        

        // Cycle through bits

        for (B = 0; B < 8; B++) {

            if (Reg & 1) // Shift and XOR with mask

                Reg = (Reg >> 1) ^ Poly;

            else         // Just shift right

                Reg >>= 1;

        }

        

        // Set value in table

        CRCTable[A] = Reg;

    }



    return;

}

    

// Calculate the CRC of a range of bytes

unsigned int crcCalculate(unsigned char *Buff, unsigned long Leng,

                          unsigned int *Lookup) {

    unsigned int CRC = 0xFFFFFFFF; // 0xFFFF for NDS CRC-16

    unsigned long I;



    // Process bytes of input data

    for (I = 0; I < Leng; I++)

        // HighBytes XOR Lookup[LowByte XOR Input]

        CRC = (CRC >> 8) ^ Lookup[(CRC & 0xFF) ^ Buff[I]];

    

    return CRC ^ 0xFFFFFFFF; // Omit the XOr operation for NDS CRC-16.

}



// Calculates the CRC of an F-Zero X ROM

unsigned int fzxCRC(unsigned char *ROMData) {

    unsigned int Lookup[256];



    // Generate the lookup table.

    // This should ideally be done once and with a global array.

    crcGenTable(Lookup, 0xEDB88320); // 0x04C11DB7 backwards in binary

      //CRCGenTable(Lookup, 0xA001); // 0x8005 for CRC-16



    // Caluclate the CRC

    return crcCalculate(ROMData, 0x1000000, Lookup);

}



// Byte-swaps a ROM

void fzxByteSwap(unsigned char *ROMData, unsigned long ROMSize) {

    unsigned long index = 0;

    unsigned char temp;



    // Swap bytes in pairs

    while (index < ROMSize) {

        temp = ROMData[index];

        ROMData[index] = ROMData[index + 1];

        ROMData[index + 1] = temp;

        index += 2;

    }



    return;

}



// Checks a ROM for hackage

char fzxCheckROM(unsigned char *ROMData, char Version) {

    switch (Version) {



    // Check for Japanese version

    case FZX_VER_JZ: case FZX_VER_JV:

        if (fzxCRC(ROMData) == FZX_CRC_J)

            return FZX_ROM_J;

        else

            return FZX_ROM_HACK;



    // Check for North American version

    case FZX_VER_UZ: case FZX_VER_UV:

        if (fzxCRC(ROMData) == FZX_CRC_U)

            return FZX_ROM_U;

        else

            return FZX_ROM_HACK;



    // Check for PAL version

    case FZX_VER_PZ: case FZX_VER_PV:

        if (fzxCRC(ROMData) == FZX_CRC_P)

            return FZX_ROM_P;

        else

            return FZX_ROM_HACK;

    }



    // Everything else

    return FZX_ROM_BAD;

}



// Reads the contents of a file into memory

unsigned char *fzxLoadROM(char *Filename, unsigned long *FileSize) {

    FILE *FilePtr = NULL;

    unsigned char *Buffer;



    // Open the file

    FilePtr = fopen(Filename, "rb");

    if (FilePtr == NULL)

        return NULL; 



    // Seek to the end of the file

    if (fseek(FilePtr, 0, SEEK_END))

        { fclose(FilePtr); return NULL; }



    // Get the file size

    *FileSize = ftell(FilePtr);

    if (!*FileSize) // Bad file size

        { fclose(FilePtr); return NULL; }



    // Seek back to the beginning of the file

    if (fseek(FilePtr, 0, SEEK_SET))

        { fclose(FilePtr); return NULL; }



    // Allocate the memory

    Buffer = malloc(*FileSize);

    if (Buffer == NULL)

        { fclose(FilePtr); return NULL; }



    // Read the data from the file into the memory

    if (!fread(Buffer, 1, *FileSize, FilePtr))

        { free(Buffer); fclose(FilePtr); return NULL; }



    // Close the file and exit

    fclose(FilePtr);

    return Buffer;

}



// Detects the version and format of an F-Zero X ROM

char fzxROMVersion(unsigned char *ROMData, unsigned long ROMSize) {

    char NameString[21] = "";

    char Temp = 0, V = 0;



    // Check ROM size

    if (ROMSize != 0x1000000)

        return FZX_VER_BAD;



    // Check ROM name string

    strncpy(NameString, &(ROMData[0x20]), 20);

    if (!strcmp(NameString, "F-ZERO X            ")) Temp = 4; // Z64

    if (!strcmp(NameString, "-FEZORX             ")) Temp = 3; // V64

    if (!Temp) // Name string invalid

        return FZX_VER_BAD;



    // Get region ID

    V = Temp & 3;

    if (!V) Temp = ROMData[0x3E]; // Z64

    else    Temp = ROMData[0x3F]; // V64



    // Check region ID

    switch (Temp) {

        case 'J': return FZX_VER_JZ + V;

        case 'E': return FZX_VER_UZ + V;

        case 'P': return FZX_VER_PZ + V;

    }



    // Bad region ID if we get here

    return FZX_VER_BAD;

}

#include <stdio.h>

#include <stdlib.h>

#include "fzxROM.h"



int main(int argc, char **argv) {

    unsigned char *ROM = NULL;

    unsigned long ROMSize;

    char Version;



    // Display usage if incorrect format

    if (argc != 2) {

        printf("Usage: fzxROM <filename>\n");

        return 0;

    }



    // Load the ROM

    ROM = fzxLoadROM(argv[1], &ROMSize);

    if (ROM == NULL) {

        printf("Error loading file.\n");

        return 1;

    }



    // Like a loading screen, but not quite

    printf("ROM Version: ...\rROM Version: ");



    // Get ROM version and byte-swap data if need be

    Version = fzxROMVersion(ROM, ROMSize);

    if (Version > FZX_VER_PZ)

        fzxByteSwap(ROM, ROMSize);

    Version = fzxCheckROM(ROM, Version);



    // Deallocate the memory

    free(ROM);



    // Output ROM version

    switch (Version) {

        case FZX_ROM_BAD:  printf("(Not F-Zero X)\n"); break;

        case FZX_ROM_J:    printf("Japanese\n");       break;

        case FZX_ROM_U:    printf("North American\n"); break;

        case FZX_ROM_P:    printf("PAL\n");            break;

        case FZX_ROM_HACK: printf("(Hacked ROM)\n");   break;

    }



    return 0;

}