mixfile.cpp

Go to the documentation of this file.

/*
**  Command & Conquer Generals Zero Hour(tm)
**  Copyright 2025 Electronic Arts Inc.
**
**  This program is free software: you can redistribute it and/or modify
**  it under the terms of the GNU General Public License as published by
**  the Free Software Foundation, either version 3 of the License, or
**  (at your option) any later version.
**
**  This program is distributed in the hope that it will be useful,
**  but WITHOUT ANY WARRANTY; without even the implied warranty of
**  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
**  GNU General Public License for more details.
**
**  You should have received a copy of the GNU General Public License
**  along with this program.  If not, see <http://www.gnu.org/licenses/>.
*/
 
/*********************************************************************************************** 
 ***                            Confidential - Westwood Studios                              *** 
 *********************************************************************************************** 
 *                                                                                             * 
 *                 Project Name : Commando                                                     * 
 *                                                                                             * 
 *                     $Archive:: /Commando/Code/wwlib/mixfile.cpp                            $* 
 *                                                                                             * 
 *                      $Author:: Patrick                                                     $* 
 *                                                                                             * 
 *                     $Modtime:: 9/12/01 7:39p                                               $* 
 *                                                                                             * 
 *                    $Revision:: 4                                                           $* 
 *                                                                                             * 
 *---------------------------------------------------------------------------------------------* 
 * Functions:                                                                                  * 
 * - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
 
#include "mixfile.h"
#include "wwdebug.h"
#include "ffactory.h"
#include "wwfile.h"
#include "realcrc.h"
#include "rawfile.h"
#include "win.h"
#include "bittype.h"
 
/*
**
*/
typedef struct
{
    char    signature[4];
    long    header_offset;
    long    names_offset;
 
} MIXFILE_HEADER;
 
typedef struct
{
    long    file_count;
 
} MIXFILE_DATA_HEADER;
 
struct FileOffsetStruct {
        bool operator== (const FileOffsetStruct &src)    { return false; }
        bool operator!= (const FileOffsetStruct &src)    { return true; }
 
        StringClass  Filename;
        unsigned long Offset;
};
 
/*
**
*/                  
MixFileFactoryClass::MixFileFactoryClass( const char * mix_filename, FileFactoryClass * factory )   :
    FileCount (0),
    NamesOffset (0),
    IsValid (false),
    BaseOffset (0),
    Factory (NULL),
    IsModified (false)
{
//  WWDEBUG_SAY(( "MixFileFactory( %s )\n", mix_filename ));
    MixFilename = mix_filename;
    Factory     = factory;
    FilenameList.Set_Growth_Step (1000);
 
    // First, open the mix file
    FileClass * file = factory->Get_File( mix_filename );
 
//  WWASSERT( file );
 
    if ( file && file->Is_Available() ) {
 
        file->Open();
 
        IsValid = true;
 
        //
        //  Read the file header
        //
        MIXFILE_HEADER header = { 0 };
        IsValid = (file->Read( &header, sizeof( header ) ) == sizeof( header ));
 
        //
        //  Validate the file header
        //
        if ( IsValid ) {
            IsValid = (::memcmp( header.signature, "MIX1", sizeof ( header.signature ) ) == 0);
        }
 
        //
        //  Seek to the data start
        //
        FileCount = 0;
        if ( IsValid ) {
            file->Seek( header.header_offset, SEEK_SET );
            IsValid = ( file->Read( &FileCount, sizeof( FileCount ) ) == sizeof( FileCount ) );
        }
        
        //
        //  Read the array of data headers
        //
        if ( IsValid ) {
            FileInfo.Resize( FileCount );
            int size = FileCount * sizeof( FileInfoStruct );
            IsValid = ( file->Read( &FileInfo[0], size ) == size );
        }
 
        //
        //  Check for success
        //
        if ( IsValid ) {
            BaseOffset  = 0;
            NamesOffset = header.names_offset;
            WWDEBUG_SAY(( "MixFileFactory( %s ) loaded successfully  %d files\n", MixFilename, FileInfo.Length() ));
        } else {
            FileInfo.Resize(0);
        }   
 
        factory->Return_File( file );
 
    } else {
        WWDEBUG_SAY(( "MixFileFactory( %s ) FAILED\n", mix_filename ));
    }
}
 
MixFileFactoryClass::~MixFileFactoryClass( void )
{
    FileInfo.Resize(0);
}
 
bool    MixFileFactoryClass::Build_Filename_List (DynamicVectorClass<StringClass> &list)
{
    if (IsValid == false) {
        return false;
    }
 
    bool retval = false;
 
    //
    //  Attempt to open the file
    //
    RawFileClass *file = (RawFileClass *)Factory->Get_File( MixFilename );
    if ( file != NULL && file->Open ( RawFileClass::READ ) ) {
 
        //
        //  Seek to the names offset header
        //
        file->Seek (NamesOffset, SEEK_SET);
        retval = true;
        
        //
        //  Read the count of files
        //
        int file_count = 0;
        if (file->Read( &file_count, sizeof( file_count) ) == sizeof( file_count )) {
 
            //
            //  Loop over each saved filename
            //
            bool keep_going = true;
            for (int index = 0; index < file_count && keep_going; index ++) {
                keep_going = false;
                
                //
                //  Get the length of the filename
                //
                uint8 name_len = 0;
                if (file->Read( &name_len, sizeof( name_len ) ) == sizeof( name_len )) {
                    
                    //
                    //  Read the filename
                    //
                    StringClass filename;
                    if (file->Read( filename.Get_Buffer( name_len ), name_len ) == name_len ) {
                        
                        //
                        //  Add the filename to our list
                        //
                        list.Add( filename );
                        keep_going = true;
                    }
                }
            }
        }
 
        //
        //  Close the file
        //
        Factory->Return_File( file );
    }
 
    return retval;
}
 
FileClass * MixFileFactoryClass::Get_File( char const *filename )
{
    if ( FileInfo.Length() == 0 ) {
        return NULL;
    }
//  WWDEBUG_SAY(( "MixFileFactoryClass::Get_File( %s )\n", filename ));
 
    RawFileClass *file = NULL;
 
    //  Create the key block that will be used to binary search for the file.
    unsigned long crc = CRC_Stringi( filename );
 
    //  Binary search for the file in this mixfile. If it is found, then create the file
    FileInfoStruct * info = NULL;
    FileInfoStruct * base = &FileInfo[0];
    int stride = FileInfo.Length();
    while (stride > 0) {
        int pivot = stride / 2;
        FileInfoStruct * tryptr = base + pivot;
        if (crc < tryptr->CRC) {
            stride = pivot;
        } else {
            if (tryptr->CRC == crc) {
                info = tryptr;
                break;
            }
           base = tryptr + 1;
            stride -= pivot + 1;
        }
    }       
 
    if ( info != NULL) {
//      WWDEBUG_SAY(( "MixFileFactoryClass::Get_File( %s ) FOUND\n", filename ));
        file = (RawFileClass *)Factory->Get_File( MixFilename );
        if ( file ) {
            file->Bias( BaseOffset + info->Offset, info->Size );
        }
//      WWDEBUG_SAY(( "MixFileFactoryClass::Get_File( %s ) FOUND\n", filename ));
    } else {
//      WWDEBUG_SAY(( "MixFileFactoryClass::Get_File( %s ) NOT FOUND\n", filename ));
    }
 
    return file;
}
 
void    MixFileFactoryClass::Return_File( FileClass * file )
{
    if ( file != NULL ) {
        Factory->Return_File( file );
    }
}
 
 
/*
**
*/
void
MixFileFactoryClass::Add_File (const char *full_path, const char *filename)
{
    AddInfoStruct info;
    info.FullPath = full_path;
    info.Filename = filename;
    PendingAddFileList.Add (info);
    IsModified = true;
    return ;
}
 
 
/*
**
*/
void
MixFileFactoryClass::Delete_File (const char *filename)
{
    //
    //  Remove this file (if it exists) from our filename list
    //
    for (int list_index = 0; list_index < FilenameList.Count (); list_index ++) {
        if (FilenameList[list_index].Compare_No_Case (filename) == 0) {
            FilenameList.Delete (list_index);
            IsModified = true;
            break;
        }
    }
 
    return ;
}
 
 
/*
**
*/
void
MixFileFactoryClass::Flush_Changes (void)
{
    //
    //  Exit if there's nothing to do.
    //
    if (IsModified == false) {
        return ;
    }
 
    //
    //  Get the path of the mix file
    //
    char drive[_MAX_DRIVE] = { 0 };
    char dir[_MAX_DIR] = { 0 };
    ::_splitpath (MixFilename, drive, dir, NULL, NULL);
    StringClass path = drive;
    path                    += dir;
 
    //
    //  Try to find a temp filename
    //
    StringClass full_path;
    if (Get_Temp_Filename (path, full_path)) {
        MixFileCreator new_mix_file (full_path);
 
        //
        //  Add all the remaining files from our file set
        //
        for (int index = 0; index < FilenameList.Count (); index ++) {
            StringClass &filename = FilenameList[index];
 
            //
            //  Copy this file data to the mix file
            //
            FileClass *file_data = Get_File (filename);
            if (file_data != NULL) {
                file_data->Open ();
                new_mix_file.Add_File (filename, file_data);
                Return_File (file_data);
 
                //
                //  Remove this file from the pending list (if necessary)
                //
                for (int temp_index = 0; temp_index < PendingAddFileList.Count (); temp_index ++) {
                    if (filename.Compare_No_Case (PendingAddFileList[temp_index].Filename) == 0) {
                        PendingAddFileList.Delete (temp_index);
                        break;
                    }
                }
            }
        }
 
        //
        //  Add the new files that are pending
        //
        for (index = 0; index < PendingAddFileList.Count (); index ++) {
            new_mix_file.Add_File (PendingAddFileList[index].FullPath, PendingAddFileList[index].Filename);
        }
    }
 
    //
    //  Delete the old mix file and rename the new one
    //
    ::DeleteFile (MixFilename);
    ::MoveFile (full_path, MixFilename);
 
    //
    //  Reset the lists
    //
    IsModified = false; 
    PendingAddFileList.Delete_All ();
    return ;
}
 
 
/*
**
*/
bool
MixFileFactoryClass::Get_Temp_Filename (const char *path, StringClass &full_path)
{
    bool retval = false;
 
    StringClass temp_path    = path;
    temp_path                   += "_tmpmix";
    
    //
    //  Try to find a unique temp filename
    //
    for (int index = 0; index < 20; index ++) {
        full_path.Format ("%s%.2d.dat", (const char *)temp_path, index + 1);
        if (GetFileAttributes (full_path) == 0xFFFFFFFF) {
            retval = true;
            break;
        }
    }
 
    return retval;
}
 
 
//
// Comparison function, used by Build_Ordered_Filename_List
//
int MixFileFactoryClass::File_Offset_Compare(const void * a, const void * b) 
{
    unsigned int OffsetA = ((FileOffsetStruct*)a)->Offset;
    unsigned int OffsetB = ((FileOffsetStruct*)b)->Offset;
    if ( OffsetA < OffsetB ) return -1;
    if ( OffsetA > OffsetB ) return 1;
    return 0;
}
 
 
//
// Function builds a list of file names in the order that they are stored in the file
//
bool    MixFileFactoryClass::Build_Ordered_Filename_List (DynamicVectorClass<StringClass> &list)
{
    if (IsValid == false) {
        return false;
    }
 
    // get list of filenames
    DynamicVectorClass<StringClass> name_list;
    if (!Build_Filename_List(name_list)) {
        return false;
    }
 
    // associate offset with each name and add to list
    DynamicVectorClass<FileOffsetStruct>    local_file_info;
    local_file_info.Resize( name_list.Count());
    for (int i = 0; i < name_list.Count(); ++i) {
        // Here, we have to assume that the names in the list are in CRC order, just like FileInfo is.
        FileOffsetStruct temp;
        temp.Filename   = name_list[i];
        temp.Offset       = FileInfo[i].Offset;
        local_file_info.Add( temp );
    }
 
    // sort name/offset by offset
    if (local_file_info.Count() > 1) {
        qsort( &local_file_info[0], local_file_info.Count(), sizeof(local_file_info[0]), &File_Offset_Compare);
    }
 
    // add names to output parameter
    list.Clear();
    list.Resize( name_list.Count());
    for (i = 0; i < local_file_info.Count(); ++i) {
        list.Add(local_file_info[i].Filename);
    }
 
    return true;
}
 
/*
**
*/
SimpleFileFactoryClass _SimpleFileFactory;
 
MixFileCreator::MixFileCreator( const char * filename )
{
    WWDEBUG_SAY(( "Creating Mix File %s\n", filename ));
 
    MixFile = _SimpleFileFactory.Get_File(filename);
    if ( MixFile != NULL ) {
        MixFile->Open( FileClass::WRITE );
        MixFile->Write( "MIX1", 4 );
        long    header_offset = 0;
        MixFile->Write( &header_offset, sizeof( header_offset ) );
        long    names_offset = 0;
        MixFile->Write( &names_offset, sizeof( names_offset ) );
        long    unused = 0;
        MixFile->Write( &unused, sizeof( unused ) );
    }
}
 
int MixFileCreator::File_Info_Compare(const void * a, const void * b) 
{
    unsigned int CRCA = ((FileInfoStruct*)a)->CRC;
    unsigned int CRCB = ((FileInfoStruct*)b)->CRC;
    if ( CRCA < CRCB ) return -1;
    if ( CRCA > CRCB ) return 1;
    return 0;
//  return ((FileInfoStruct*)a)->CRC - ((FileInfoStruct*)b)->CRC;
}
 
MixFileCreator::~MixFileCreator( void )
{
    if ( MixFile != NULL ) {
 
        // Save Header Data
        int header_offset = MixFile->Tell();
 
        // Save file count
        int i,num_files = FileInfo.Count();
        WWDEBUG_SAY(( "Closing with %d files\n", num_files ));
        MixFile->Write( &num_files, sizeof( num_files ) );
 
        if ( num_files > 1 ) {
           qsort( &FileInfo[0], num_files, sizeof(FileInfo[0]), &File_Info_Compare);
        }
 
        // Save file info (CRC, Offset, Size )
        for ( i = 0; i < num_files; i++ ) {
            MixFile->Write( &FileInfo[i].CRC, 4 );
            MixFile->Write( &FileInfo[i].Offset, 4 );
            MixFile->Write( &FileInfo[i].Size, 4 );
//          WWDEBUG_SAY(( "Write CRC %08X\n", FileInfo[i].CRC ));
        }
 
        // ---------------------------------------
 
        // Save Names Data
        int names_offset = MixFile->Tell();
 
        // Save file count
        MixFile->Write( &num_files, sizeof( num_files ) );
 
        // Save file info
        for ( i = 0; i < num_files; i++ ) {
            const char * filename = FileInfo[i].Filename;
            int size = FileInfo[i].Filename.Get_Length()+1;
            WWASSERT( size < 255 );
            unsigned char csize = size;
            MixFile->Write( &csize, 1 );
            MixFile->Write( filename, size );
        }
 
        // ---------------------------------------
 
        MixFile->Seek( 4, SEEK_SET );
 
        // Save header offset
        WWDEBUG_SAY(( "Writing header offset %d (%08X)\n", header_offset, header_offset ));
        MixFile->Write( &header_offset, sizeof( header_offset ) );
 
        // Save names offset
        WWDEBUG_SAY(( "Writing names offset %d (%08X)\n", names_offset, names_offset ));
        MixFile->Write( &names_offset, sizeof( names_offset ) );
 
        // ---------------------------------------
 
        MixFile->Close();
 
        _SimpleFileFactory.Return_File(MixFile);
    }
}
 
void    MixFileCreator::Add_File( const char * source_filename, const char * saved_filename )
{
    if ( saved_filename == NULL ) {
        saved_filename = source_filename;
    }
 
    if ( MixFile != NULL ) {
 
        FileClass * file = _SimpleFileFactory.Get_File( source_filename );
 
        if ( file && file->Is_Available() ) {
 
            file->Open();
 
            MixFileCreator::FileInfoStruct info;
            info.CRC            = CRC_Stringi( saved_filename );
            info.Offset     = MixFile->Tell();
            info.Size       = file->Size();
            FileInfo.Add( info );
            FileInfo[ FileInfo.Count()-1 ].Filename = saved_filename;
 
            WWDEBUG_SAY(( "Saving File %s CRC %08X Offset %d (0x%08X) Size %d (0x%08X)\n",
                    saved_filename, info.CRC, info.Offset, info.Offset, info.Size, info.Size ));
 
            int size = file->Size();
            while ( size ) {
                char buffer[ 4096 ];
                int amount = MIN( sizeof( buffer ), size );
                size -= amount;
                file->Read( buffer, amount );
                if ( MixFile->Write( buffer, amount ) != amount ) {
                    WWDEBUG_SAY(( "Failed to write MixFile\n" ));
                }
            }
 
            // Pad the MixFile to make DWord Aligned
            int offset = MixFile->Tell();
            offset = (8-(offset & 7)) & 7;
            if ( offset != 0 ) {
                char zeros[8] = {0,0,0,0,0,0,0,0};
                if ( MixFile->Write( zeros, offset ) != offset ) {
                    WWDEBUG_SAY(( "Failed to write padding\n" ));
                }
            }
 
            file->Close();
            _SimpleFileFactory.Return_File( file );
 
        } else {
            WWDEBUG_SAY(( "MixFileCreator::Failed to open \"%s\"\n", source_filename ));
        }
    }
}
 
 
void    MixFileCreator::Add_File( const char * filename, FileClass *file )
{
    if ( MixFile != NULL ) {
 
        MixFileCreator::FileInfoStruct info;
        info.CRC            = CRC_Stringi( filename );
        info.Offset     = MixFile->Tell();
        info.Size       = file->Size();
        FileInfo.Add( info );
        FileInfo[ FileInfo.Count()-1 ].Filename = filename;
 
        WWDEBUG_SAY(( "Saving File %s CRC %08X Offset %d (0x%08X) Size %d (0x%08X)\n",
                filename, info.CRC, info.Offset, info.Offset, info.Size, info.Size ));
 
        int size = file->Size();
        while ( size ) {
            char buffer[ 4096 ];
            int amount = MIN( sizeof( buffer ), size );
            size -= amount;
            file->Read( buffer, amount );
            if ( MixFile->Write( buffer, amount ) != amount ) {
                WWDEBUG_SAY(( "Failed to write MixFile\n" ));
            }
        }
 
        // Pad the MixFile to make DWord Aligned
        int offset = MixFile->Tell();
        offset = (8-(offset & 7)) & 7;
        if ( offset != 0 ) {
            char zeros[8] = {0,0,0,0,0,0,0,0};
            if ( MixFile->Write( zeros, offset ) != offset ) {
                WWDEBUG_SAY(( "Failed to write padding\n" ));
            }
        }
    }
 
    return ;
}
 
 
/*
**
*/
void    Add_Files( const char * dir, MixFileCreator & mix )
{
    BOOL bcontinue = TRUE;
    HANDLE hfile_find;
    WIN32_FIND_DATA find_info = {0};
    StringClass path;
    path.Format( "data\\makemix\\%s*.*", dir );
    WWDEBUG_SAY(( "Adding files from %s\n", path ));
 
    for (hfile_find = ::FindFirstFile( path, &find_info);
         (hfile_find != INVALID_HANDLE_VALUE) && bcontinue;
          bcontinue = ::FindNextFile(hfile_find, &find_info)) {
        if ( find_info.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY ) {
            if ( find_info.cFileName[0] != '.' ) {
                StringClass  path;
                path.Format( "%s%s\\", dir, find_info.cFileName );
                Add_Files( path, mix );
            }
        } else {
            StringClass name;
            name.Format( "%s%s", dir, find_info.cFileName );
            StringClass  source;
            source.Format( "makemix\\%s", name );
            mix.Add_File( source, name );
//          WWDEBUG_SAY(( "Adding file from %s %s\n", source, name ));
        }
    }
}
 
void    Setup_Mix_File( void )
{
    _SimpleFileFactory.Set_Sub_Directory( "DATA\\" );
//  _SimpleFileFactory.Set_Strip_Path( true );
 
    WWDEBUG_SAY(( "Mix File Create .....\n" ));
 
    {
        MixFileCreator mix( "MAKEMIX.MIX" );
        Add_Files( "", mix );
    }
 
}