Subversion Repositories ipe_artfile_utils

/**

 * ART file packer by Daniel Marschall, ViaThinkSoft (C) 2014-2018

 * Supports:

 * - Panic in the Park - The Interactive Game by Imagination Pilots

 * - Where's Waldo? At the Circus (Waldo1)

 * Revision: 2018-02-15

 **/

#include <stdio.h>

#include <stdlib.h>

#include <stdbool.h>

#include <string.h>

#include <math.h>

#include "ipe_artfile_packer_ipe16_pip.h"

#include "ipe16_artfile.h"

#include "ipe16_bmpimport.h"

#include "ipe16_lzw_encoder.h"

#define MAX_FILE 256

bool pip_pack_art(const char* szSrcFolder, FILE* fobArt, const int verbosity) {

        bool bEverythingOK = true;

        char szIndexFilename[MAX_FILE];

        sprintf(szIndexFilename, "%s/index.txt", szSrcFolder);

        FILE* fitIndex = fopen(szIndexFilename, "rt");

        if (!fitIndex) {

                fprintf(stderr, "Cannot open %s\n", szIndexFilename);

                return false;

        }

        #define MAX_LINE 1024

        char line[MAX_LINE];

        int cItems = 0;

        while (fgets(line, sizeof(line), fitIndex)) {

                if (strlen(line) == 0) continue;

                ++cItems;

        }

        if (verbosity >= 1) printf("%s contains %d entries\n", szIndexFilename, cItems); // TODO: don't print double /

        Ipe16FileHeader bfh;

        memset(&bfh, 0x00, sizeof(bfh));

        strcpy(bfh.magic, IPE16_MAGIC_ART);

        bfh.dummy = IPE16_MAGIC_DUMMY;

        bfh.numHeaderEntries = cItems+1;

        Ipe16PictureEntryHeader peh[cItems];

        memset(&peh, 0x00, sizeof(peh));

        PipPictureHeader ph[cItems];

        memset(&ph,  0x00, sizeof(ph));

        // We need to write the (still empty) headers, so we can use ftell() to determine the offsets correctly

        // These headers are currently just dummies. They will be rewritten after all pictures are processed

        fwrite(&bfh, sizeof(bfh), 1, fobArt);

        fwrite(&peh, sizeof(peh), 1, fobArt);

        fseek(fitIndex, 0, SEEK_SET);

        int curItem = 0;

        Ipe16LZWEncoder* lzwEncoder = NULL;

        while (fgets(line, sizeof(line), fitIndex)) {

                // If something fails, we discard the item, but continue in building the file!

                #define FAIL_CONTINUE { memset(&peh[curItem], 0x00, sizeof(peh[curItem])); bEverythingOK=false; continue; }

                const char* szDelimiters = " \t\r\n";

                char* szPaletteType     = strtok(&line[0], szDelimiters);

                char* szCompressionType = strtok(NULL, szDelimiters);

                char* szName            = strtok(NULL, szDelimiters);

                char* szFilename        = strtok(NULL, szDelimiters);

                char* szOffsetX         = strtok(NULL, szDelimiters);

                int iOffsetX            = (szOffsetX != NULL) ? atoi(szOffsetX) : 0;

                char* szOffsetY         = strtok(NULL, szDelimiters);

                int iOffsetY            = (szOffsetY != NULL) ? atoi(szOffsetY) : 0;

                if (strlen(szPaletteType) != 1) {

                        fprintf(stderr, "ERROR: Palette type (argument 1) at line %d is not valid (must be 1 char)\n", curItem+1);

                        FAIL_CONTINUE;

                }

                const char chPaletteType = *szPaletteType;

                if ((chPaletteType != IPE16_PALETTETYPE_ATTACHED) && (chPaletteType != IPE16_PALETTETYPE_PARENT)) {

                        fprintf(stderr, "ERROR: Unknown palette type '%c' at line %d\n", chPaletteType, curItem+1);

                        FAIL_CONTINUE;

                }

                if (strlen(szCompressionType) != 1) {

                        fprintf(stderr, "ERROR: Compression type (argument 2) at line %d is not valid (must be 1 char)\n", curItem+1);

                        FAIL_CONTINUE;

                }

                const char chCompressionType = *szCompressionType;

                if (strlen(szName) > IPE16_NAME_SIZE) {

                        fprintf(stderr, "ERROR: Name %s is too long (max %d chars allowed)\n", szName, IPE16_NAME_SIZE);

                        FAIL_CONTINUE;

                }

                strcpy(peh[curItem].name, szName);

                peh[curItem].paletteType = chPaletteType;

                peh[curItem].offset = ftell(fobArt);

                peh[curItem].size = 0; // will be increased later

                if (verbosity >= 1) printf("Process %s at offset %x\n", szName, peh[curItem].offset);

                // Read bitmap

                const bool colorTableExisting = (chPaletteType == IPE16_PALETTETYPE_ATTACHED);

                char szBitmapFilename[MAX_FILE];

                sprintf(szBitmapFilename, "%s/%s", szSrcFolder, szFilename);

                FILE* fibBitmap = fopen(szBitmapFilename, "rb");

                if (!fibBitmap) {

                        fprintf(stderr, "ERROR: cannot open '%s'\n", szFilename);

                        FAIL_CONTINUE;

                }

                Ipe16BmpImportData result={0};

                if (!ipe16_bmp_import(fibBitmap, &result)) {

                        fprintf(stderr, "Error at %s: %s\n", szFilename, result.error);

                        fclose(fibBitmap);

                        ipe16_free_bmpimport_result(&result);

                        FAIL_CONTINUE;

                }

                ph[curItem].compressionType = chCompressionType;

                ph[curItem].offsetX = iOffsetX;

                ph[curItem].offsetY = iOffsetY;

                ph[curItem].width = result.width;

                ph[curItem].height = result.height;

                fwrite(&ph[curItem], sizeof(ph[curItem]), 1, fobArt);

                peh[curItem].size += sizeof(ph[curItem]);

                // Write picture data

                size_t tmpBefore = ftell(fobArt);

                if (chCompressionType == PIP_COMPRESSIONTYPE_LZW) {

                        if (!lzwEncoder) lzwEncoder = new_ipe16lzw_encoder();

                        ipe16lzw_encode(fobArt, lzwEncoder, result.bmpData, result.bmpDataSize);

                } else if (chCompressionType == PIP_COMPRESSIONTYPE_NONE) {

                        fwrite(result.bmpData, result.bmpDataSize, 1, fobArt);

                } else {

                        fprintf(stderr, "Unknown compression type '%c' at line %d\n", chCompressionType, curItem+1);

                        fclose(fibBitmap);

                        ipe16_free_bmpimport_result(&result);

                        FAIL_CONTINUE;

                }

                peh[curItem].size += ftell(fobArt)-tmpBefore;

                if (colorTableExisting) {

                        fwrite(result.colorTable, sizeof(*result.colorTable), 1, fobArt);

                        peh[curItem].size += sizeof(*result.colorTable);

                }

                // Free and continue

                fclose(fibBitmap);

                ipe16_free_bmpimport_result(&result);

                ++curItem;

        }

        if (lzwEncoder) del_ipe16lzw_encoder(lzwEncoder);

        fclose(fitIndex);

        bfh.totalFileSize = ftell(fobArt);

        fseek(fobArt, 0, SEEK_SET);

        fwrite(&bfh, sizeof(bfh), 1, fobArt);

        fwrite(&peh, sizeof(peh), 1, fobArt);

        fclose(fobArt);

        return bEverythingOK;

}