WebSVN – filter_foundry – Diff – /trunk/read.c


/*
    This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
    Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au
    Copyright (C) 2018-2021 Daniel Marschall, ViaThinkSoft
 
    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 2 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, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
*/
 
#include "ff.h"
 
#include "file_compat.h"
 
#ifdef MAC_ENV
#include <Endian.h>
#else
int EndianS32_LtoN(int num) {
        return ((num>>24)&0xff) +      // move byte 3 to byte 0
               ((num<<8)&0xff0000) +   // move byte 1 to byte 2
               ((num>>8)&0xff00) +     // move byte 2 to byte 1
               ((num<<24)&0xff000000); // byte 0 to byte 3
}
#endif
 
enum{
        BUFSIZE = 4L<<10,
        MAXLINE = 0x200,
};
 
Boolean readparams_afs_pff(Handle h,char **reason){
        Boolean res = false;
        char linebuf[MAXLINE+1],curexpr[MAXEXPR+1],*p,*dataend,*q;
        char c;
        int linecnt, lineptr, exprcnt;
 
        if(!h){
                *reason = _strdup("readparams: Null parameter handle.");
                return false;
        }
 
        p = PILOCKHANDLE(h,false);
        dataend = p + PIGETHANDLESIZE(h);
 
        q = curexpr;
        linecnt = exprcnt = lineptr = 0;
 
        //*reason = _strdup("File was too short.");
        while(p < dataend){
 
                c = *p++;
 
                if(c==CR || c==LF){ /* detected end of line */
 
                        /* look ahead to see if we need to skip a line feed (DOS CRLF EOL convention) */
                        if(p < dataend && c == CR && *p == LF)
                                ++p;
 
                        linebuf[lineptr] = 0; /* add terminating NUL to line buffer */
 
                        /* process complete line */
                        if(linecnt==0){
                                if(strcmp(linebuf,"%RGB-1.0")){
                                        // *reason = _strdup("This doesn't look like a Filter Factory file (first line is not \"%RGB-1.0\").");
                                        break;
                                }
                        }else if(linecnt<=8){
                                slider[linecnt-1] = atoi(linebuf);
                        }else{
                                if(lineptr){
                                        /* it's not an empty line; append it to current expr string */
                                        if( q+lineptr > curexpr+MAXEXPR ){
                                                *reason = _strdup("Found an expression longer than 1024 characters.");
                                                break;
                                        }
                                        q = cat(q,linebuf);
                                }else{
                                        /* it's an empty line: we've completed the expr string */
                                        if(expr[exprcnt])
                                                free(expr[exprcnt]);
                                        *q = 0;
                                        if(!(expr[exprcnt] = my_strdup(curexpr))){
                                                *reason = _strdup("Could not get memory for expression.");
                                                break;
                                        }
 
                                        if(++exprcnt == 4){
                                                res = true;
                                                break; /* got everything we want */
                                        }
 
                                        q = curexpr; /* empty current expr, ready for next one */
                                }
                        }
 
                        ++linecnt;
                        lineptr = 0;
                }else{
                        /* store character */
                        if(c=='\\'){ /* escape sequence */
                                if(p < dataend){
                                        c = *p++;
                                        switch(c){
                                        case 'r':
                                                #if WIN_ENV
                                                c = CR;
                                                if (lineptr < MAXLINE)
                                                        linebuf[lineptr++] = c;
                                                c = LF;
                                                #else
                                                c = CR;
                                                #endif
                                                break;
                                        case '\\': break;
                                        //default:
                                        //      if(alerts) alertuser((TCHAR*)TEXT("Warning:"),TEXT("Unknown escape sequence in input."));
                                        }
                                }//else if(alerts) alertuser((TCHAR*)TEXT("Warning:"),TEXT("truncated escape sequence ends input"));
                        }
 
                        if(lineptr < MAXLINE)
                                linebuf[lineptr++] = c;
                }
        }
 
        PIUNLOCKHANDLE(h);
 
        return res;
}
 
void convert_premiere_to_photoshop(PARM_T* photoshop, PARM_T_PREMIERE* premiere) {
        int i;
 
        photoshop->cbSize = sizeof(PARM_T);
        photoshop->standalone = premiere->standalone;
        for (i=0;i<8;++i)
                photoshop->val[i] = premiere->val[i];
        photoshop->popDialog = premiere->popDialog;
        photoshop->unknown1 = premiere->unknown1;
        photoshop->unknown2 = premiere->unknown2;
        photoshop->unknown3 = premiere->unknown3;
        for (i=0;i<4;++i)
                photoshop->map_used[i] = premiere->map_used[i];
        for (i=0;i<8;++i)
                photoshop->ctl_used[i] = premiere->ctl_used[i];
        sprintf(photoshop->szCategory, "Filter Factory"); // Premiere plugins do not have a category attribute
        photoshop->iProtected = 0; // Premiere plugins do not have a protect flag
        memcpy((void*)photoshop->szTitle, (void*)premiere->szTitle, sizeof(photoshop->szTitle));
        memcpy((void*)photoshop->szCopyright, (void*)premiere->szCopyright, sizeof(photoshop->szCopyright));
        memcpy((void*)photoshop->szAuthor, (void*)premiere->szAuthor, sizeof(photoshop->szAuthor));
        for (i=0;i<4;++i)
                memcpy((void*)photoshop->szMap[i], (void*)premiere->szMap[i], sizeof(photoshop->szMap[i]));
        for (i=0;i<8;++i)
                memcpy((void*)photoshop->szCtl[i], (void*)premiere->szCtl[i], sizeof(photoshop->szCtl[i]));
 
        if (premiere->singleExpression) {
                memcpy((void*)photoshop->szFormula[0], (void*)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
                memcpy((void*)photoshop->szFormula[1], (void*)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
                memcpy((void*)photoshop->szFormula[2], (void*)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
                memcpy((void*)photoshop->szFormula[3], (void*)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
        } else {
                memcpy((void*)photoshop->szFormula[0], (void*)premiere->szFormula[2], sizeof(photoshop->szFormula[2]));
                memcpy((void*)photoshop->szFormula[1], (void*)premiere->szFormula[1], sizeof(photoshop->szFormula[1]));
                memcpy((void*)photoshop->szFormula[2], (void*)premiere->szFormula[0], sizeof(photoshop->szFormula[0]));
                memcpy((void*)photoshop->szFormula[3], (void*)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
        }
}
 
char* _ffx_read_str(char** q) {
        uint32_t len;
        char* val;
 
        len = *((uint32_t*)*q);
        *q += sizeof(uint32_t);
        val = (char*)malloc(len + 1);
        if (val != NULL) {
                memcpy(val, (char*)*q, len);
                val[len] = 0;
        }
        *q += len;
        return val;
}
 
Boolean readfile_ffx(StandardFileReply* sfr, char** reason) {
        Handle h;
        Boolean res = false;
        FILEREF refnum;
        uint32_t len;
        char* val;
        int format_version = -1;
        int i;
 
        UNREFERENCED_PARAMETER(reason);
 
        if (FSpOpenDF(&sfr->sfFile, fsRdPerm, &refnum) == noErr) {
                if ((h = readfileintohandle(refnum))) {
                        char* q = (char*)PILOCKHANDLE(h, false);
 
                        len = *((uint32_t*)q);
                        if (len == 6) {
                                val = _ffx_read_str(&q);
                                if (strcmp(val, "FFX1.0") == 0) format_version = 10;
                                else if (strcmp(val, "FFX1.1") == 0) format_version = 11;
                                else if (strcmp(val, "FFX1.2") == 0) format_version = 12;
                                free(val);
                                if (format_version > 0) {
                                        simplewarning((TCHAR*)TEXT("Attention! You are loading a \"Filters Unlimited\" file. Please note that Filter Foundry only implements the basic Filter Factory functions. Therefore, most \"Filters Unlimited\" filters won't work with Filter Foundry."));
 
                                        val = _ffx_read_str(&q);
                                        strcpy(gdata->parm.szTitle, val);
                                        free(val);
 
                                        val = _ffx_read_str(&q);
                                        strcpy(gdata->parm.szCategory, val);
                                        free(val);
 
                                        val = _ffx_read_str(&q);
                                        strcpy(gdata->parm.szAuthor, val);
                                        free(val);
 
                                        val = _ffx_read_str(&q);
                                        strcpy(gdata->parm.szCopyright, val);
                                        free(val);
 
                                        // Channels I, R, G, B, A
                                        for (i = 0; i < 4; i++) {
                                                val = _ffx_read_str(&q);
                                                if (i == 0) {
                                                        char* val2 = _ffx_read_str(&q);
                                                        if (strcmp(val, "0") != 0) {
                                                                // "Intro channel" existing
                                                                // C++ wrong warning: Using uninitialized memory "val2" (C6001)
                                                                #pragma warning(suppress : 6001)
                                                                char* combined = (char*)malloc(strlen(val) + strlen(",") + strlen(val2) + 1);
                                                                if (combined != NULL) {
                                                                        sprintf(combined, "%s,%s", val, val2);
                                                                        free(val);
                                                                        free(val2);
                                                                        val = combined;
                                                                }
                                                        }
                                                        else {
                                                                free(val);
                                                                val = val2;
                                                        }
                                                }
                                                if (strlen(val) >= sizeof(gdata->parm.szFormula[i])) {
                                                        if (i == 0) {
                                                                simplealert((TCHAR*)TEXT("Attention! The formula for channel I/R was too long (longer than 1023 characters) and was truncated."));
                                                        }
                                                        else if (i == 1) {
                                                                simplealert((TCHAR*)TEXT("Attention! The formula for channel G was too long (longer than 1023 characters) and was truncated."));
                                                        }
                                                        else if (i == 2) {
                                                                simplealert((TCHAR*)TEXT("Attention! The formula for channel B was too long (longer than 1023 characters) and was truncated."));
                                                        }
                                                        else if (i == 3) {
                                                                simplealert((TCHAR*)TEXT("Attention! The formula for channel A was too long (longer than 1023 characters) and was truncated."));
                                                        }
                                                        // C++ wrong warning: Buffer overflow (C6386)
                                                        #pragma warning(suppress : 6386)
                                                        val[sizeof(gdata->parm.szFormula[i]) - 1] = '\0';
                                                }
                                                if (expr[i]) free(expr[i]);
                                                expr[i] = my_strdup(val);
                                                strcpy(gdata->parm.szFormula[i], val);
                                                free(val);
                                        }
 
                                        // Sliders
                                        for (i = 0; i < 8; i++) {
                                                char* sliderName;
                                                val = _ffx_read_str(&q);
                                                sliderName = val;
                                                if (format_version >= 12) {
                                                        // Format FFX1.2 has prefixes {S} = Slider, {C} = Checkbox, none = Slider
                                                        if ((sliderName[0] == '{') && (sliderName[1] == 'S') && (sliderName[2] == '}')) sliderName += 3;
                                                        else if ((sliderName[0] == '{') && (sliderName[1] == 'C') && (sliderName[2] == '}')) sliderName += 3;
                                                }
                                                strcpy(gdata->parm.szCtl[i], sliderName);
                                                free(val);
                                                gdata->parm.ctl_used[i] = (bool32_t)*((byte*)q);
                                                q += sizeof(byte);
                                                gdata->parm.val[i] = *((uint32_t*)q);
                                                slider[i] = *((uint32_t*)q);
                                                q += sizeof(uint32_t);
                                        }
 
                                        // Maps (are not part of the format!)
                                        strcpy(gdata->parm.szMap[0], "Map 0:");
                                        strcpy(gdata->parm.szMap[1], "Map 1:");
                                        strcpy(gdata->parm.szMap[2], "Map 2:");
                                        strcpy(gdata->parm.szMap[3], "Map 3:");
 
                                        res = true;
                                }
                        }
                        PIDISPOSEHANDLE(h);
                }
                FSClose(refnum);
        }
 
        if (res) gdata->obfusc = false;
        return res;
}
 
Boolean readfile_8bf(StandardFileReply *sfr,char **reason){
        unsigned char magic[2];
        FILECOUNT count;
        Handle h;
        Boolean res = false;
        FILEREF refnum;
 
        if(FSpOpenDF(&sfr->sfFile,fsRdPerm,&refnum) == noErr){
                // check DOS EXE magic number
                count = 2;
                if(FSRead(refnum,&count,magic) == noErr /*&& magic[0]=='M' && magic[1]=='Z'*/){
                        if(GetEOF(refnum,(FILEPOS*)&count) == noErr && count < 4096L<<10){ // sanity check file size < 4MiB (note that "Debug" builds can have approx 700 KiB while "Release" builds have approx 300 KiB)
                                if( (h = readfileintohandle(refnum)) ){
                                        long *q = (long*)PILOCKHANDLE(h,false);
 
                                        // look for signature at start of valid PARM resource
                                        // This signature is observed in Filter Factory standalones.
                                        for( count /= 4 ; count >= PARM_SIZE/4 ; --count, ++q )
                                        {
                                                res = readPARM(&gdata->parm, (Ptr)q);
                                                if (res) break;
                                        }
 
                                        PIDISPOSEHANDLE(h);
                                }
                        }
                } // else no point in proceeding
                FSClose(refnum);
        }else
                *reason = _strdup("Could not open file.");
 
        if (res) gdata->obfusc = false;
        return res;
}
 
Boolean readPARM(PARM_T* pparm, Ptr p){
        int i;
        Boolean towin, tomac, fromwin, frommac;
        unsigned int signature = *((unsigned int*)p);
        unsigned int standalone = *((unsigned int*)p+1);
 
        // Find out our OS ("reader") the OS of the plugin ("source")
        #ifdef MAC_ENV
        towin = false;
        tomac = true;
        fromwin = ((EndianS32_LtoN(signature) == PARM_SIZE) ||
                (EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) ||
                (EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;
        frommac = ((signature == PARM_SIZE) ||
                (signature == PARM_SIZE_PREMIERE) ||
                (signature == PARM_SIG_MAC)) && standalone == 1;
        #else
        towin = true;
        tomac = false;
        fromwin = ((signature == PARM_SIZE) ||
                (signature == PARM_SIZE_PREMIERE) ||
                (signature == PARM_SIG_MAC)) && standalone == 1;
        frommac = ((EndianS32_LtoN(signature) == PARM_SIZE) ||
                (EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) ||
                (EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;
        #endif
 
        // Is it a valid signature?
        if (!fromwin && !frommac) {
                // No valid signature found
                return false;
        }
 
        // Does it come from Premiere or Photoshop?
        // Initialize pparm
        if ((signature == PARM_SIZE_PREMIERE) || (EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE)) {
                // It comes from Premiere. Swap R and B channel and convert to a Photoshop PARM_T
                convert_premiere_to_photoshop(pparm, (PARM_T_PREMIERE*)p);
        } else {
                // It is already Photoshop. Just copy to pparm.
                memcpy(pparm, p, sizeof(PARM_T));
        }
 
        // Do we need to do string conversion?
        if (frommac) {
                /* Mac PARM resource stores Pascal strings - convert to C strings, since this is what we work internally with (regardles of OS) */
                myp2cstr((unsigned char*)pparm->szCategory);
                myp2cstr((unsigned char*)pparm->szTitle);
                myp2cstr((unsigned char*)pparm->szCopyright);
                myp2cstr((unsigned char*)pparm->szAuthor);
                for (i = 0; i < 4; ++i)
                        myp2cstr((unsigned char*)pparm->szMap[i]);
                for (i = 0; i < 8; ++i)
                        myp2cstr((unsigned char*)pparm->szCtl[i]);
        }
 
        // Case #1: Mac is reading Windows (Win16/32/64) plugin
        if (fromwin && tomac) {
                size_t i;
 
                // Convert copyright CRLF to CR (actually, just removing LF)
                char copyrightCRLF[256];
                char* p = &copyrightCRLF[0];
                for (i = 0; i < strlen(pparm->szCopyright); i++) {
                        if (pparm->szCopyright[i] != LF) {
                                *p++ = pparm->szCopyright[i];
                        }
                }
                *p++ = '\0';
                strcpy(pparm->szCopyright, copyrightCRLF);
 
                // these are the only numeric fields we *have* to swap
                // all the rest are bool_t flags which (if we're careful) will work in either ordering
                for (i = 0; i < 8; ++i)
                        pparm->val[i] = EndianS32_LtoN(pparm->val[i]);
        }
 
        // Case #2: Mac is reading Mac (in case the normal resource extraction didn't work)
        // Nothing to do
 
        // Case #3: Windows is reading a Windows plugin (if Resource API failed, e.g. Win64 tries to open Win16 NE file or Win32 tries to open Win64 file)
        // Nothing to do
 
        // Case #4: Windows is reading an old FilterFactory Mac file
        // Note: You must read the ".rsrc" resource fork, not the standalone binary!
        if (frommac && towin) {
                size_t i;
 
                // Convert CR in the copyright field to CRLF.
                char copyrightCRLF[256];
                char* p = &copyrightCRLF[0];
                for (i = 0; i < strlen(pparm->szCopyright); i++) {
                        *p++ = pparm->szCopyright[i];
                        if (pparm->szCopyright[i] == CR) {
                                *p++ = LF;
                        }
                }
                *p++ = '\0';
                strcpy(pparm->szCopyright, copyrightCRLF);
 
                // these are the only numeric fields we *have* to swap
                // all the rest are bool_t flags which (if we're careful) will work in either ordering
                for (i = 0; i < 8; ++i)
                        pparm->val[i] = EndianS32_LtoN(pparm->val[i]);
        }
 
        // Now set the values in pparm into the working variables expr[] and slider[], so that they are visible in the GUI
 
        for(i = 0; i < 4; ++i){
                if(expr[i]) free(expr[i]);
                expr[i] = my_strdup(pparm->szFormula[i]);
        }
 
        for (i = 0; i < 8; ++i) {
                slider[i] = (uint8_t)pparm->val[i];
                /*
                if (slider[i] > 0xFF) {
                        // Wrong endianess (e.g. reading a Mac rsrc on Windows)
                        // Should not happen since we did the stuff above
                        slider[i] = (uint8_t)EndianS32_LtoN(slider[i]);
                }
                */
        }
 
        return true;
}
 
Handle readfileintohandle(FILEREF r){
        FILEPOS n;
        Handle h;
        Ptr p;
 
        if( GetEOF(r,&n) == noErr && (h = PINEWHANDLE(n)) ){
                p = PILOCKHANDLE(h,false);
                if(SetFPos(r,fsFromStart,0) == noErr && FSRead(r,(FILECOUNT*)&n,p) == noErr){
                        PIUNLOCKHANDLE(h);
                        return h;
                }
                PIDISPOSEHANDLE(h);
        }
        return NULL;
}
 
Boolean _picoLineContainsKey(char* line, char** content, const char* searchkey/*=NULL*/) {
        size_t i;
        for (i = 0; i < strlen(line); i++) {
                if (line[i] == '?') break; // avoid that "a?b:c" is detected as key
                if (line[i] == ':') {
                        // Note: We are ignoring whitespaces, i.e. " A :" != "A:" (TODO: should we change this?)
                        if ((searchkey == NULL) || ((i == strlen(searchkey)) && (memcmp(line, searchkey, i) == 0))) {
                                i++; // jump over ':' char
                                //while ((line[i] == ' ') || (line[i] == TAB)) i++; // Trim value left
                                *content = line + i;
                                return true;
                        }
                }
        }
        *content = line;
        return false;
}
 
void _ffdcomp_removebrackets(char* x, char* maxptr) {
        char* closingBracketPos = NULL;
        Boolean openingBracketFound = false;
        if (x[0] == '[') {
                openingBracketFound = true;
        }
        x[0] = ':';
        x++;
        while (x < maxptr) {
                if ((!openingBracketFound) && (x[0] == '[')) {
                        openingBracketFound = true;
                        x[0] = ' ';
                }
                else if (openingBracketFound) {
                        if (x[0] == ']') {
                                closingBracketPos = x;
                        }
                        else if ((x[0] == CR) || (x[0] == LF)) {
                                if (closingBracketPos) closingBracketPos[0] = ' '; // last closing pos before CR/LF
                                break;
                        }
                }
                x++;
        }
}
 
// isFormula=false => outputFile is C string. TXT linebreaks become spaces.
// isFormula=true  => outputFile is C string. TXT line breaks become CRLF line breaks
Boolean _picoReadProperty(char* inputFile, int maxInput, const char* property, char* outputFile, size_t maxOutput, Boolean isFormula) {
        int i;
        char* outputwork;
        char* sline;
        char* svalue;
        char* inputwork;
        char* inputworkinitial;
        outputwork = outputFile;
        sline = NULL;
        svalue = NULL;
        // Check parameters
        if (maxOutput == 0) return false;
        if (inputFile == 0) return false;
        // Let input memory be read-only, +1 for terminal zero
        //char* inputwork = inputFile;
        inputwork = (char*)malloc(maxInput + 1);
        inputworkinitial = inputwork;
        if (inputwork == 0) return false;
        memcpy(inputwork, inputFile, maxInput);
        inputwork[maxInput] = 0; // otherwise strstr() will crash
 
        // Transform "FFDecomp" TXT file into the similar "PluginCommander" TXT file
        if (strstr(inputwork, "Filter Factory Plugin Information:")) {
                char* x;
                char* k1;
                char* k2;
                // Metadata:
                x = strstr(inputwork, "CATEGORY:");
                if (x) memcpy(x, "Category:", strlen("Category:"));
                x = strstr(inputwork, "TITLE:");
                if (x) memcpy(x, "Title:", strlen("Title:"));
                x = strstr(inputwork, "COPYRIGHT:");
                if (x) memcpy(x, "Copyright:", strlen("Copyright:"));
                x = strstr(inputwork, "AUTHOR:");
                if (x) memcpy(x, "Author:", strlen("Author:"));
                // Controls:
                for (i = 0; i < 8; i++) {
                        k1 = (char*)malloc(strlen("Control X:") + 1);
                        sprintf(k1, "Control %d:", i);
                        x = strstr(inputwork, k1);
                        if (x) {
                                k2 = (char*)malloc(strlen("ctl[X]:   ") + 1);
                                sprintf(k2, "ctl[%d]:   ", i);
                                memcpy(x, k2, strlen(k2));
                                x += strlen("ctl[X]");
                                _ffdcomp_removebrackets(x, inputwork + maxInput - 1);
                                free(k2);
                        }
                        free(k1);
                }
                // Maps:
                for (i = 0; i < 4; i++) {
                        k1 = (char*)malloc(strlen("Map X:") + 1);
                        sprintf(k1, "Map %d:", i);
                        x = strstr(inputwork, k1);
                        if (x) {
                                k2 = (char*)malloc(strlen("map[X]:") + 1);
                                sprintf(k2, "map[%d]:", i);
                                memcpy(x, k2, strlen(k2));
                                x += strlen("map[X]");
                                _ffdcomp_removebrackets(x, inputwork + maxInput - 1);
                                free(k2);
                        }
                        free(k1);
                }
                // Convert all '\r' to '\n' for the next step to be easier
                for (i = 0; i < maxInput; i++) {
                        if (inputworkinitial[i] == CR) inputworkinitial[i] = LF;
                }
                x = strstr(inputwork, "\nR=\n");
                if (x) memcpy(x, "\nR:\n", strlen("\nR:\n"));
                x = strstr(inputwork, "\nG=\n");
                if (x) memcpy(x, "\nG:\n", strlen("\nG:\n"));
                x = strstr(inputwork, "\nB=\n");
                if (x) memcpy(x, "\nB:\n", strlen("\nB:\n"));
                x = strstr(inputwork, "\nA=\n");
                if (x) memcpy(x, "\nA:\n", strlen("\nA:\n"));
        }
        // Replace all \r and \n with \0, so that we can parse easier
        for (i = 0; i < maxInput; i++) {
                if (inputworkinitial[i] == CR) inputworkinitial[i] = 0;
                else if (inputworkinitial[i] == LF) inputworkinitial[i] = 0;
        }
 
        // Find line that contains out key
        inputwork = inputworkinitial;
        do {
                if (inputwork > inputworkinitial + maxInput) {
                        // Key not found. Set output to empty string
                        outputwork[0] = 0;
                        free(inputworkinitial);
                        return false;
                }
                sline = inputwork;
                inputwork += strlen(sline) + 1;
                if (inputwork - 1 > inputworkinitial + maxInput) {
                        // Key not found. Set output to empty string
                        // TODO: will that be ever called?
                        outputwork[0] = 0;
                        free(inputworkinitial);
                        return false;
                }
        } while (!_picoLineContainsKey(sline, &svalue, property));
 
        // Read line(s) until we find a line with another key, or the line end
        do {
                while ((svalue[0] == ' ') || (svalue[0] == TAB)) svalue++; // Trim left
                while ((svalue[strlen(svalue) - 1] == ' ') || (svalue[strlen(svalue) - 1] == TAB)) svalue[strlen(svalue) - 1] = 0; // Trim right
 
                if (strlen(svalue) > 0) {
                        if (outputwork + strlen(svalue) + (isFormula ? 3/*CRLF+NUL*/ : 2/*space+NUL*/) > outputFile + maxOutput) {
                                size_t remaining = maxOutput - (outputwork - outputFile) - 1;
                                //printf("BUFFER FULL (remaining = %d)\n", remaining);
                                memcpy(outputwork, svalue, remaining);
                                outputwork += remaining;
                                outputwork[0] = 0;
                                free(inputworkinitial);
                                return true;
                        }
                        else {
                                memcpy(outputwork, svalue, strlen(svalue));
                                outputwork += strlen(svalue);
                                if (isFormula) {
                                        // Formulas: TXT line break stays line break (important if you have comments!)
                                        outputwork[0] = CR;
                                        outputwork[1] = LF;
                                        outputwork += 2;
                                }
                                else {
                                        // Everything else: TXT line breaks becomes single whitespace
                                        outputwork[0] = ' ';
                                        outputwork++;
                                }
                        }
                }
                outputwork[0] = 0;
 
                // Process next line
                if (inputwork > inputworkinitial + maxInput) break;
                sline = inputwork;
                inputwork += strlen(sline) + 1;
                if (inputwork - 1 > inputworkinitial + maxInput) break; // TODO: will that be ever called?
        } while (!_picoLineContainsKey(sline, &svalue, NULL));
 
        // Remove trailing whitespace
        if (outputwork > outputFile) {
                outputwork -= 1;
                outputwork[0] = 0;
        }
        free(inputworkinitial);
        return true;
}
 
Boolean readfile_picotxt(StandardFileReply* sfr, char** reason) {
        extern int ctls[], maps[];
 
        Handle h;
        Boolean res = false;
        FILEREF refnum;
 
        UNREFERENCED_PARAMETER(reason);
 
        if (!fileHasExtension(sfr, TEXT(".txt"))) return false;
 
        if (FSpOpenDF(&sfr->sfFile, fsRdPerm, &refnum) == noErr) {
                if ((h = readfileintohandle(refnum))) {
                        FILECOUNT count = PIGETHANDLESIZE(h);
                        char* q = PILOCKHANDLE(h, false);
 
                        char out[256];
                        if (_picoReadProperty(q, count, "Title", out, sizeof(out), false)) {
                                int i;
 
                                // Plugin infos
                                _picoReadProperty(q, count, "Title", gdata->parm.szTitle, sizeof(gdata->parm.szTitle), false);
                                _picoReadProperty(q, count, "Category", gdata->parm.szCategory, sizeof(gdata->parm.szCategory), false);
                                _picoReadProperty(q, count, "Author", gdata->parm.szAuthor, sizeof(gdata->parm.szAuthor), false);
                                _picoReadProperty(q, count, "Copyright", gdata->parm.szCopyright, sizeof(gdata->parm.szCopyright), false);
                                //_picoReadProperty(q, count, "Filename", gdata->parm.xxx, sizeof(gdata->parm.xxx), false);
 
                                // Expressions
                                if (!_picoReadProperty(q, count, "R", gdata->parm.szFormula[0], sizeof(gdata->parm.szFormula[0]), true))
                                        strcpy(gdata->parm.szFormula[0], "r");
                                if (!_picoReadProperty(q, count, "G", gdata->parm.szFormula[1], sizeof(gdata->parm.szFormula[1]), true))
                                        strcpy(gdata->parm.szFormula[1], "g");
                                if (!_picoReadProperty(q, count, "B", gdata->parm.szFormula[2], sizeof(gdata->parm.szFormula[2]), true))
                                        strcpy(gdata->parm.szFormula[2], "b");
                                if (!_picoReadProperty(q, count, "A", gdata->parm.szFormula[3], sizeof(gdata->parm.szFormula[3]), true))
                                        strcpy(gdata->parm.szFormula[3], "a");
                                for (i = 0; i < 4; i++) {
                                        if (expr[i]) free(expr[i]);
                                        expr[i] = my_strdup(gdata->parm.szFormula[i]);
                                }
 
                                // Slider names
                                for (i = 0; i < 8; i++) {
                                        char keyname[7];
                                        sprintf(keyname, "ctl[%d]", i);
                                        _picoReadProperty(q, count, keyname, gdata->parm.szCtl[i], sizeof(gdata->parm.szCtl[i]), false);
                                }
 
                                // Slider values
                                for (i = 0; i < 8; i++) {
                                        char keyname[7], tmp[5];
                                        sprintf(keyname, "val[%d]", i);
                                        if (!_picoReadProperty(q, count, keyname, tmp, sizeof(tmp), false)) {
                                                sprintf(keyname, "def[%d]", i);
                                                if (!_picoReadProperty(q, count, keyname, tmp, sizeof(tmp), false)) {
                                                        strcpy(tmp,"0");
                                                }
                                        }
                                        gdata->parm.val[i] = slider[i] = atoi(tmp);
                                }
 
                                // Map names
                                for (i = 0; i < 4; i++) {
                                        char keyname[7];
                                        sprintf(keyname, "map[%d]", i);
                                        _picoReadProperty(q, count, keyname, gdata->parm.szMap[i], sizeof(gdata->parm.szMap[i]), false);
                                }
 
                                //These will be set when the expressions are evaluated anyway. So this part is optional:
                                checksliders(4, ctls, maps);
                                for (i = 0; i < 8; i++) gdata->parm.ctl_used[i] = ctls[i];
                                for (i = 0; i < 4; i++) gdata->parm.map_used[i] = maps[i];
 
                                res = true;
                        }
 
                        PIUNLOCKHANDLE(h);
                        PIDISPOSEHANDLE(h);
                }
                FSClose(refnum);
        }
 
        return res;
}
 
Boolean readfile_afs_pff(StandardFileReply *sfr,char **reason){
        FILEREF r;
        Handle h;
        Boolean res = false;
 
        if(FSpOpenDF(&sfr->sfFile,fsRdPerm,&r) == noErr){
                if( (h = readfileintohandle(r)) ){
                        if( (res = readparams_afs_pff(h,reason)) ) {
                                gdata->standalone = false; // so metadata fields will default, if user chooses Make...
 
                                if (fileHasExtension(sfr, TEXT(".pff"))) {
                                        // If it is a Premiere settings file, we need to swap the channels red and blue
                                        // We just swap the pointers!
                                        char* tmp;
                                        tmp = expr[0];
                                        expr[0] = expr[2];
                                        expr[2] = tmp;
                                }
                        }
 
                        PIDISPOSEHANDLE(h);
                }
                FSClose(r);
        }else
                *reason = _strdup("Could not open the file.");
 
        return res;
}
 

Rev 433	Rev 444
1	/*	1	/*
2	This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop	2	This file is part of "Filter Foundry", a filter plugin for Adobe Photoshop
3	Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au	3	Copyright (C) 2003-2009 Toby Thain, toby@telegraphics.com.au
4	Copyright (C) 2018-2021 Daniel Marschall, ViaThinkSoft	4	Copyright (C) 2018-2021 Daniel Marschall, ViaThinkSoft
5		5
6	This program is free software; you can redistribute it and/or modify	6	This program is free software; you can redistribute it and/or modify
7	it under the terms of the GNU General Public License as published by	7	it under the terms of the GNU General Public License as published by
8	the Free Software Foundation; either version 2 of the License, or	8	the Free Software Foundation; either version 2 of the License, or
9	(at your option) any later version.	9	(at your option) any later version.
10		10
11	This program is distributed in the hope that it will be useful,	11	This program is distributed in the hope that it will be useful,
12	but WITHOUT ANY WARRANTY; without even the implied warranty of	12	but WITHOUT ANY WARRANTY; without even the implied warranty of
13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the	13	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	GNU General Public License for more details.	14	GNU General Public License for more details.
15		15
16	You should have received a copy of the GNU General Public License	16	You should have received a copy of the GNU General Public License
17	along with this program; if not, write to the Free Software	17	along with this program; if not, write to the Free Software
18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA	18	Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/	19	*/
20		20
21	#include "ff.h"	21	#include "ff.h"
22		22
23	#include "file_compat.h"	23	#include "file_compat.h"
24		24
25	#ifdef MAC_ENV	25	#ifdef MAC_ENV
26	#include <Endian.h>	26	#include <Endian.h>
27	#else	27	#else
28	int EndianS32_LtoN(int num) {	28	int EndianS32_LtoN(int num) {
29	return ((num>>24)&0xff) + // move byte 3 to byte 0	29	return ((num>>24)&0xff) + // move byte 3 to byte 0
30	((num<<8)&0xff0000) + // move byte 1 to byte 2	30	((num<<8)&0xff0000) + // move byte 1 to byte 2
31	((num>>8)&0xff00) + // move byte 2 to byte 1	31	((num>>8)&0xff00) + // move byte 2 to byte 1
32	((num<<24)&0xff000000); // byte 0 to byte 3	32	((num<<24)&0xff000000); // byte 0 to byte 3
33	}	33	}
34	#endif	34	#endif
35		35
36	enum{	36	enum{
37	BUFSIZE = 4L<<10,	37	BUFSIZE = 4L<<10,
38	MAXLINE = 0x200,	38	MAXLINE = 0x200,
39	};	39	};
40		40
41	Boolean readparams_afs_pff(Handle h,char **reason){	41	Boolean readparams_afs_pff(Handle h,char **reason){
42	Boolean res = false;	42	Boolean res = false;
43	char linebuf[MAXLINE+1],curexpr[MAXEXPR+1],p,dataend,*q;	43	char linebuf[MAXLINE+1],curexpr[MAXEXPR+1],p,dataend,*q;
44	char c;	44	char c;
45	int linecnt, lineptr, exprcnt;	45	int linecnt, lineptr, exprcnt;
46		46
47	if(!h){	47	if(!h){
48	*reason = _strdup("readparams: Null parameter handle.");	48	*reason = _strdup("readparams: Null parameter handle.");
49	return false;	49	return false;
50	}	50	}
51		51
52	p = PILOCKHANDLE(h,false);	52	p = PILOCKHANDLE(h,false);
53	dataend = p + PIGETHANDLESIZE(h);	53	dataend = p + PIGETHANDLESIZE(h);
54		54
55	q = curexpr;	55	q = curexpr;
56	linecnt = exprcnt = lineptr = 0;	56	linecnt = exprcnt = lineptr = 0;
57		57
58	//*reason = _strdup("File was too short.");	58	//*reason = _strdup("File was too short.");
59	while(p < dataend){	59	while(p < dataend){
60		60
61	c = *p++;	61	c = *p++;
62		62
63	if(c==CR \|\| c==LF){ /* detected end of line */	63	if(c==CR \|\| c==LF){ /* detected end of line */
64		64
65	/* look ahead to see if we need to skip a line feed (DOS CRLF EOL convention) */	65	/* look ahead to see if we need to skip a line feed (DOS CRLF EOL convention) */
66	if(p < dataend && c == CR && *p == LF)	66	if(p < dataend && c == CR && *p == LF)
67	++p;	67	++p;
68		68
69	linebuf[lineptr] = 0; /* add terminating NUL to line buffer */	69	linebuf[lineptr] = 0; /* add terminating NUL to line buffer */
70		70
71	/* process complete line */	71	/* process complete line */
72	if(linecnt==0){	72	if(linecnt==0){
73	if(strcmp(linebuf,"%RGB-1.0")){	73	if(strcmp(linebuf,"%RGB-1.0")){
74	// *reason = _strdup("This doesn't look like a Filter Factory file (first line is not \"%RGB-1.0\").");	74	// *reason = _strdup("This doesn't look like a Filter Factory file (first line is not \"%RGB-1.0\").");
75	break;	75	break;
76	}	76	}
77	}else if(linecnt<=8){	77	}else if(linecnt<=8){
78	slider[linecnt-1] = atoi(linebuf);	78	slider[linecnt-1] = atoi(linebuf);
79	}else{	79	}else{
80	if(lineptr){	80	if(lineptr){
81	/* it's not an empty line; append it to current expr string */	81	/* it's not an empty line; append it to current expr string */
82	if( q+lineptr > curexpr+MAXEXPR ){	82	if( q+lineptr > curexpr+MAXEXPR ){
83	*reason = _strdup("Found an expression longer than 1024 characters.");	83	*reason = _strdup("Found an expression longer than 1024 characters.");
84	break;	84	break;
85	}	85	}
86	q = cat(q,linebuf);	86	q = cat(q,linebuf);
87	}else{	87	}else{
88	/* it's an empty line: we've completed the expr string */	88	/* it's an empty line: we've completed the expr string */
89	if(expr[exprcnt])	89	if(expr[exprcnt])
90	free(expr[exprcnt]);	90	free(expr[exprcnt]);
91	*q = 0;	91	*q = 0;
92	if(!(expr[exprcnt] = my_strdup(curexpr))){	92	if(!(expr[exprcnt] = my_strdup(curexpr))){
93	*reason = _strdup("Could not get memory for expression.");	93	*reason = _strdup("Could not get memory for expression.");
94	break;	94	break;
95	}	95	}
96		96
97	if(++exprcnt == 4){	97	if(++exprcnt == 4){
98	res = true;	98	res = true;
99	break; /* got everything we want */	99	break; /* got everything we want */
100	}	100	}
101		101
102	q = curexpr; /* empty current expr, ready for next one */	102	q = curexpr; /* empty current expr, ready for next one */
103	}	103	}
104	}	104	}
105		105
106	++linecnt;	106	++linecnt;
107	lineptr = 0;	107	lineptr = 0;
108	}else{	108	}else{
109	/* store character */	109	/* store character */
110	if(c=='\\'){ /* escape sequence */	110	if(c=='\\'){ /* escape sequence */
111	if(p < dataend){	111	if(p < dataend){
112	c = *p++;	112	c = *p++;
113	switch(c){	113	switch(c){
114	case 'r':	114	case 'r':
115	#if WIN_ENV	115	#if WIN_ENV
116	c = CR;	116	c = CR;
117	if (lineptr < MAXLINE)	117	if (lineptr < MAXLINE)
118	linebuf[lineptr++] = c;	118	linebuf[lineptr++] = c;
119	c = LF;	119	c = LF;
120	#else	120	#else
121	c = CR;	121	c = CR;
122	#endif	122	#endif
123	break;	123	break;
124	case '\\': break;	124	case '\\': break;
125	//default:	125	//default:
126	// if(alerts) alertuser(_strdup("Warning:"),_strdup("Unknown escape sequence in input."));	126	// if(alerts) alertuser((TCHAR*)TEXT("Warning:"),TEXT("Unknown escape sequence in input."));
127	}	127	}
128	}//else if(alerts) alertuser(_strdup("Warning:"),_strdup("truncated escape sequence ends input"));	128	}//else if(alerts) alertuser((TCHAR*)TEXT("Warning:"),TEXT("truncated escape sequence ends input"));
129	}	129	}
130		130
131	if(lineptr < MAXLINE)	131	if(lineptr < MAXLINE)
132	linebuf[lineptr++] = c;	132	linebuf[lineptr++] = c;
133	}	133	}
134	}	134	}
135		135
136	PIUNLOCKHANDLE(h);	136	PIUNLOCKHANDLE(h);
137		137
138	return res;	138	return res;
139	}	139	}
140		140
141	void convert_premiere_to_photoshop(PARM_T* photoshop, PARM_T_PREMIERE* premiere) {	141	void convert_premiere_to_photoshop(PARM_T* photoshop, PARM_T_PREMIERE* premiere) {
142	int i;	142	int i;
143		143
144	photoshop->cbSize = sizeof(PARM_T);	144	photoshop->cbSize = sizeof(PARM_T);
145	photoshop->standalone = premiere->standalone;	145	photoshop->standalone = premiere->standalone;
146	for (i=0;i<8;++i)	146	for (i=0;i<8;++i)
147	photoshop->val[i] = premiere->val[i];	147	photoshop->val[i] = premiere->val[i];
148	photoshop->popDialog = premiere->popDialog;	148	photoshop->popDialog = premiere->popDialog;
149	photoshop->unknown1 = premiere->unknown1;	149	photoshop->unknown1 = premiere->unknown1;
150	photoshop->unknown2 = premiere->unknown2;	150	photoshop->unknown2 = premiere->unknown2;
151	photoshop->unknown3 = premiere->unknown3;	151	photoshop->unknown3 = premiere->unknown3;
152	for (i=0;i<4;++i)	152	for (i=0;i<4;++i)
153	photoshop->map_used[i] = premiere->map_used[i];	153	photoshop->map_used[i] = premiere->map_used[i];
154	for (i=0;i<8;++i)	154	for (i=0;i<8;++i)
155	photoshop->ctl_used[i] = premiere->ctl_used[i];	155	photoshop->ctl_used[i] = premiere->ctl_used[i];
156	sprintf(photoshop->szCategory, "Filter Factory"); // Premiere plugins do not have a category attribute	156	sprintf(photoshop->szCategory, "Filter Factory"); // Premiere plugins do not have a category attribute
157	photoshop->iProtected = 0; // Premiere plugins do not have a protect flag	157	photoshop->iProtected = 0; // Premiere plugins do not have a protect flag
158	memcpy((void)photoshop->szTitle, (void)premiere->szTitle, sizeof(photoshop->szTitle));	158	memcpy((void)photoshop->szTitle, (void)premiere->szTitle, sizeof(photoshop->szTitle));
159	memcpy((void)photoshop->szCopyright, (void)premiere->szCopyright, sizeof(photoshop->szCopyright));	159	memcpy((void)photoshop->szCopyright, (void)premiere->szCopyright, sizeof(photoshop->szCopyright));
160	memcpy((void)photoshop->szAuthor, (void)premiere->szAuthor, sizeof(photoshop->szAuthor));	160	memcpy((void)photoshop->szAuthor, (void)premiere->szAuthor, sizeof(photoshop->szAuthor));
161	for (i=0;i<4;++i)	161	for (i=0;i<4;++i)
162	memcpy((void)photoshop->szMap[i], (void)premiere->szMap[i], sizeof(photoshop->szMap[i]));	162	memcpy((void)photoshop->szMap[i], (void)premiere->szMap[i], sizeof(photoshop->szMap[i]));
163	for (i=0;i<8;++i)	163	for (i=0;i<8;++i)
164	memcpy((void)photoshop->szCtl[i], (void)premiere->szCtl[i], sizeof(photoshop->szCtl[i]));	164	memcpy((void)photoshop->szCtl[i], (void)premiere->szCtl[i], sizeof(photoshop->szCtl[i]));
165		165
166	if (premiere->singleExpression) {	166	if (premiere->singleExpression) {
167	memcpy((void)photoshop->szFormula[0], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));	167	memcpy((void)photoshop->szFormula[0], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
168	memcpy((void)photoshop->szFormula[1], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));	168	memcpy((void)photoshop->szFormula[1], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
169	memcpy((void)photoshop->szFormula[2], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));	169	memcpy((void)photoshop->szFormula[2], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
170	memcpy((void)photoshop->szFormula[3], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));	170	memcpy((void)photoshop->szFormula[3], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
171	} else {	171	} else {
172	memcpy((void)photoshop->szFormula[0], (void)premiere->szFormula[2], sizeof(photoshop->szFormula[2]));	172	memcpy((void)photoshop->szFormula[0], (void)premiere->szFormula[2], sizeof(photoshop->szFormula[2]));
173	memcpy((void)photoshop->szFormula[1], (void)premiere->szFormula[1], sizeof(photoshop->szFormula[1]));	173	memcpy((void)photoshop->szFormula[1], (void)premiere->szFormula[1], sizeof(photoshop->szFormula[1]));
174	memcpy((void)photoshop->szFormula[2], (void)premiere->szFormula[0], sizeof(photoshop->szFormula[0]));	174	memcpy((void)photoshop->szFormula[2], (void)premiere->szFormula[0], sizeof(photoshop->szFormula[0]));
175	memcpy((void)photoshop->szFormula[3], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));	175	memcpy((void)photoshop->szFormula[3], (void)premiere->szFormula[3], sizeof(photoshop->szFormula[3]));
176	}	176	}
177	}	177	}
178		178
179	char* _ffx_read_str(char** q) {	179	char* _ffx_read_str(char** q) {
180	uint32_t len;	180	uint32_t len;
181	char* val;	181	char* val;
182		182
183	len = ((uint32_t)*q);	183	len = ((uint32_t)*q);
184	*q += sizeof(uint32_t);	184	*q += sizeof(uint32_t);
185	val = (char*)malloc(len + 1);	185	val = (char*)malloc(len + 1);
186	if (val != NULL) {	186	if (val != NULL) {
187	memcpy(val, (char)q, len);	187	memcpy(val, (char)q, len);
188	val[len] = 0;	188	val[len] = 0;
189	}	189	}
190	*q += len;	190	*q += len;
191	return val;	191	return val;
192	}	192	}
193		193
194	Boolean readfile_ffx(StandardFileReply* sfr, char** reason) {	194	Boolean readfile_ffx(StandardFileReply* sfr, char** reason) {
195	Handle h;	195	Handle h;
196	Boolean res = false;	196	Boolean res = false;
197	FILEREF refnum;	197	FILEREF refnum;
198	uint32_t len;	198	uint32_t len;
199	char* val;	199	char* val;
200	int format_version = -1;	200	int format_version = -1;
201	int i;	201	int i;
202		202
203	UNREFERENCED_PARAMETER(reason);	203	UNREFERENCED_PARAMETER(reason);
204		204
205	if (FSpOpenDF(&sfr->sfFile, fsRdPerm, &refnum) == noErr) {	205	if (FSpOpenDF(&sfr->sfFile, fsRdPerm, &refnum) == noErr) {
206	if ((h = readfileintohandle(refnum))) {	206	if ((h = readfileintohandle(refnum))) {
207	char* q = (char*)PILOCKHANDLE(h, false);	207	char* q = (char*)PILOCKHANDLE(h, false);
208		208
209	len = ((uint32_t)q);	209	len = ((uint32_t)q);
210	if (len == 6) {	210	if (len == 6) {
211	val = _ffx_read_str(&q);	211	val = _ffx_read_str(&q);
212	if (strcmp(val, "FFX1.0") == 0) format_version = 10;	212	if (strcmp(val, "FFX1.0") == 0) format_version = 10;
213	else if (strcmp(val, "FFX1.1") == 0) format_version = 11;	213	else if (strcmp(val, "FFX1.1") == 0) format_version = 11;
214	else if (strcmp(val, "FFX1.2") == 0) format_version = 12;	214	else if (strcmp(val, "FFX1.2") == 0) format_version = 12;
215	free(val);	215	free(val);
216	if (format_version > 0) {	216	if (format_version > 0) {
217	simplewarning(_strdup("Attention! You are loading a \"Filters Unlimited\" file. Please note that Filter Foundry only implements the basic Filter Factory functions. Therefore, most \"Filters Unlimited\" filters won't work with Filter Foundry."));	217	simplewarning((TCHAR*)TEXT("Attention! You are loading a \"Filters Unlimited\" file. Please note that Filter Foundry only implements the basic Filter Factory functions. Therefore, most \"Filters Unlimited\" filters won't work with Filter Foundry."));
218		218
219	val = _ffx_read_str(&q);	219	val = _ffx_read_str(&q);
220	strcpy(gdata->parm.szTitle, val);	220	strcpy(gdata->parm.szTitle, val);
221	free(val);	221	free(val);
222		222
223	val = _ffx_read_str(&q);	223	val = _ffx_read_str(&q);
224	strcpy(gdata->parm.szCategory, val);	224	strcpy(gdata->parm.szCategory, val);
225	free(val);	225	free(val);
226		226
227	val = _ffx_read_str(&q);	227	val = _ffx_read_str(&q);
228	strcpy(gdata->parm.szAuthor, val);	228	strcpy(gdata->parm.szAuthor, val);
229	free(val);	229	free(val);
230		230
231	val = _ffx_read_str(&q);	231	val = _ffx_read_str(&q);
232	strcpy(gdata->parm.szCopyright, val);	232	strcpy(gdata->parm.szCopyright, val);
233	free(val);	233	free(val);
234		234
235	// Channels I, R, G, B, A	235	// Channels I, R, G, B, A
236	for (i = 0; i < 4; i++) {	236	for (i = 0; i < 4; i++) {
237	val = _ffx_read_str(&q);	237	val = _ffx_read_str(&q);
238	if (i == 0) {	238	if (i == 0) {
239	char* val2 = _ffx_read_str(&q);	239	char* val2 = _ffx_read_str(&q);
240	if (strcmp(val, "0") != 0) {	240	if (strcmp(val, "0") != 0) {
241	// "Intro channel" existing	241	// "Intro channel" existing
242	// C++ wrong warning: Using uninitialized memory "val2" (C6001)	242	// C++ wrong warning: Using uninitialized memory "val2" (C6001)
243	#pragma warning(suppress : 6001)	243	#pragma warning(suppress : 6001)
244	char* combined = (char*)malloc(strlen(val) + strlen(",") + strlen(val2) + 1);	244	char* combined = (char*)malloc(strlen(val) + strlen(",") + strlen(val2) + 1);
245	if (combined != NULL) {	245	if (combined != NULL) {
246	sprintf(combined, "%s,%s", val, val2);	246	sprintf(combined, "%s,%s", val, val2);
247	free(val);	247	free(val);
248	free(val2);	248	free(val2);
249	val = combined;	249	val = combined;
250	}	250	}
251	}	251	}
252	else {	252	else {
253	free(val);	253	free(val);
254	val = val2;	254	val = val2;
255	}	255	}
256	}	256	}
257	if (strlen(val) >= sizeof(gdata->parm.szFormula[i])) {	257	if (strlen(val) >= sizeof(gdata->parm.szFormula[i])) {
258	if (i == 0) {	258	if (i == 0) {
259	simplealert(_strdup("Attention! The formula for channel I/R was too long (longer than 1023 characters) and was truncated."));	259	simplealert((TCHAR*)TEXT("Attention! The formula for channel I/R was too long (longer than 1023 characters) and was truncated."));
260	}	260	}
261	else if (i == 1) {	261	else if (i == 1) {
262	simplealert(_strdup("Attention! The formula for channel G was too long (longer than 1023 characters) and was truncated."));	262	simplealert((TCHAR*)TEXT("Attention! The formula for channel G was too long (longer than 1023 characters) and was truncated."));
263	}	263	}
264	else if (i == 2) {	264	else if (i == 2) {
265	simplealert(_strdup("Attention! The formula for channel B was too long (longer than 1023 characters) and was truncated."));	265	simplealert((TCHAR*)TEXT("Attention! The formula for channel B was too long (longer than 1023 characters) and was truncated."));
266	}	266	}
267	else if (i == 3) {	267	else if (i == 3) {
268	simplealert(_strdup("Attention! The formula for channel A was too long (longer than 1023 characters) and was truncated."));	268	simplealert((TCHAR*)TEXT("Attention! The formula for channel A was too long (longer than 1023 characters) and was truncated."));
269	}	269	}
270	// C++ wrong warning: Buffer overflow (C6386)	270	// C++ wrong warning: Buffer overflow (C6386)
271	#pragma warning(suppress : 6386)	271	#pragma warning(suppress : 6386)
272	val[sizeof(gdata->parm.szFormula[i]) - 1] = '\0';	272	val[sizeof(gdata->parm.szFormula[i]) - 1] = '\0';
273	}	273	}
274	if (expr[i]) free(expr[i]);	274	if (expr[i]) free(expr[i]);
275	expr[i] = my_strdup(val);	275	expr[i] = my_strdup(val);
276	strcpy(gdata->parm.szFormula[i], val);	276	strcpy(gdata->parm.szFormula[i], val);
277	free(val);	277	free(val);
278	}	278	}
279		279
280	// Sliders	280	// Sliders
281	for (i = 0; i < 8; i++) {	281	for (i = 0; i < 8; i++) {
282	char* sliderName;	282	char* sliderName;
283	val = _ffx_read_str(&q);	283	val = _ffx_read_str(&q);
284	sliderName = val;	284	sliderName = val;
285	if (format_version >= 12) {	285	if (format_version >= 12) {
286	// Format FFX1.2 has prefixes {S} = Slider, {C} = Checkbox, none = Slider	286	// Format FFX1.2 has prefixes {S} = Slider, {C} = Checkbox, none = Slider
287	if ((sliderName[0] == '{') && (sliderName[1] == 'S') && (sliderName[2] == '}')) sliderName += 3;	287	if ((sliderName[0] == '{') && (sliderName[1] == 'S') && (sliderName[2] == '}')) sliderName += 3;
288	else if ((sliderName[0] == '{') && (sliderName[1] == 'C') && (sliderName[2] == '}')) sliderName += 3;	288	else if ((sliderName[0] == '{') && (sliderName[1] == 'C') && (sliderName[2] == '}')) sliderName += 3;
289	}	289	}
290	strcpy(gdata->parm.szCtl[i], sliderName);	290	strcpy(gdata->parm.szCtl[i], sliderName);
291	free(val);	291	free(val);
292	gdata->parm.ctl_used[i] = (bool32_t)((byte)q);	292	gdata->parm.ctl_used[i] = (bool32_t)((byte)q);
293	q += sizeof(byte);	293	q += sizeof(byte);
294	gdata->parm.val[i] = ((uint32_t)q);	294	gdata->parm.val[i] = ((uint32_t)q);
295	slider[i] = ((uint32_t)q);	295	slider[i] = ((uint32_t)q);
296	q += sizeof(uint32_t);	296	q += sizeof(uint32_t);
297	}	297	}
298		298
299	// Maps (are not part of the format!)	299	// Maps (are not part of the format!)
300	strcpy(gdata->parm.szMap[0], "Map 0:");	300	strcpy(gdata->parm.szMap[0], "Map 0:");
301	strcpy(gdata->parm.szMap[1], "Map 1:");	301	strcpy(gdata->parm.szMap[1], "Map 1:");
302	strcpy(gdata->parm.szMap[2], "Map 2:");	302	strcpy(gdata->parm.szMap[2], "Map 2:");
303	strcpy(gdata->parm.szMap[3], "Map 3:");	303	strcpy(gdata->parm.szMap[3], "Map 3:");
304		304
305	res = true;	305	res = true;
306	}	306	}
307	}	307	}
308	PIDISPOSEHANDLE(h);	308	PIDISPOSEHANDLE(h);
309	}	309	}
310	FSClose(refnum);	310	FSClose(refnum);
311	}	311	}
312		312
313	if (res) gdata->obfusc = false;	313	if (res) gdata->obfusc = false;
314	return res;	314	return res;
315	}	315	}
316		316
317	Boolean readfile_8bf(StandardFileReply sfr,char *reason){	317	Boolean readfile_8bf(StandardFileReply sfr,char *reason){
318	unsigned char magic[2];	318	unsigned char magic[2];
319	FILECOUNT count;	319	FILECOUNT count;
320	Handle h;	320	Handle h;
321	Boolean res = false;	321	Boolean res = false;
322	FILEREF refnum;	322	FILEREF refnum;
323		323
324	if(FSpOpenDF(&sfr->sfFile,fsRdPerm,&refnum) == noErr){	324	if(FSpOpenDF(&sfr->sfFile,fsRdPerm,&refnum) == noErr){
325	// check DOS EXE magic number	325	// check DOS EXE magic number
326	count = 2;	326	count = 2;
327	if(FSRead(refnum,&count,magic) == noErr /&& magic[0]=='M' && magic[1]=='Z'/){	327	if(FSRead(refnum,&count,magic) == noErr /&& magic[0]=='M' && magic[1]=='Z'/){
328	if(GetEOF(refnum,(FILEPOS*)&count) == noErr && count < 4096L<<10){ // sanity check file size < 4MiB (note that "Debug" builds can have approx 700 KiB while "Release" builds have approx 300 KiB)	328	if(GetEOF(refnum,(FILEPOS*)&count) == noErr && count < 4096L<<10){ // sanity check file size < 4MiB (note that "Debug" builds can have approx 700 KiB while "Release" builds have approx 300 KiB)
329	if( (h = readfileintohandle(refnum)) ){	329	if( (h = readfileintohandle(refnum)) ){
330	long q = (long)PILOCKHANDLE(h,false);	330	long q = (long)PILOCKHANDLE(h,false);
331		331
332	// look for signature at start of valid PARM resource	332	// look for signature at start of valid PARM resource
333	// This signature is observed in Filter Factory standalones.	333	// This signature is observed in Filter Factory standalones.
334	for( count /= 4 ; count >= PARM_SIZE/4 ; --count, ++q )	334	for( count /= 4 ; count >= PARM_SIZE/4 ; --count, ++q )
335	{	335	{
336	res = readPARM(&gdata->parm, (Ptr)q);	336	res = readPARM(&gdata->parm, (Ptr)q);
337	if (res) break;	337	if (res) break;
338	}	338	}
339		339
340	PIDISPOSEHANDLE(h);	340	PIDISPOSEHANDLE(h);
341	}	341	}
342	}	342	}
343	} // else no point in proceeding	343	} // else no point in proceeding
344	FSClose(refnum);	344	FSClose(refnum);
345	}else	345	}else
346	*reason = _strdup("Could not open file.");	346	*reason = _strdup("Could not open file.");
347		347
348	if (res) gdata->obfusc = false;	348	if (res) gdata->obfusc = false;
349	return res;	349	return res;
350	}	350	}
351		351
352	Boolean readPARM(PARM_T* pparm, Ptr p){	352	Boolean readPARM(PARM_T* pparm, Ptr p){
353	int i;	353	int i;
354	Boolean towin, tomac, fromwin, frommac;	354	Boolean towin, tomac, fromwin, frommac;
355	unsigned int signature = ((unsigned int)p);	355	unsigned int signature = ((unsigned int)p);
356	unsigned int standalone = ((unsigned int)p+1);	356	unsigned int standalone = ((unsigned int)p+1);
357		357
358	// Find out our OS ("reader") the OS of the plugin ("source")	358	// Find out our OS ("reader") the OS of the plugin ("source")
359	#ifdef MAC_ENV	359	#ifdef MAC_ENV
360	towin = false;	360	towin = false;
361	tomac = true;	361	tomac = true;
362	fromwin = ((EndianS32_LtoN(signature) == PARM_SIZE) \|\|	362	fromwin = ((EndianS32_LtoN(signature) == PARM_SIZE) \|\|
363	(EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) \|\|	363	(EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) \|\|
364	(EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;	364	(EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;
365	frommac = ((signature == PARM_SIZE) \|\|	365	frommac = ((signature == PARM_SIZE) \|\|
366	(signature == PARM_SIZE_PREMIERE) \|\|	366	(signature == PARM_SIZE_PREMIERE) \|\|
367	(signature == PARM_SIG_MAC)) && standalone == 1;	367	(signature == PARM_SIG_MAC)) && standalone == 1;
368	#else	368	#else
369	towin = true;	369	towin = true;
370	tomac = false;	370	tomac = false;
371	fromwin = ((signature == PARM_SIZE) \|\|	371	fromwin = ((signature == PARM_SIZE) \|\|
372	(signature == PARM_SIZE_PREMIERE) \|\|	372	(signature == PARM_SIZE_PREMIERE) \|\|
373	(signature == PARM_SIG_MAC)) && standalone == 1;	373	(signature == PARM_SIG_MAC)) && standalone == 1;
374	frommac = ((EndianS32_LtoN(signature) == PARM_SIZE) \|\|	374	frommac = ((EndianS32_LtoN(signature) == PARM_SIZE) \|\|
375	(EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) \|\|	375	(EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE) \|\|
376	(EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;	376	(EndianS32_LtoN(signature) == PARM_SIG_MAC)) && EndianS32_LtoN(standalone) == 1;
377	#endif	377	#endif
378		378
379	// Is it a valid signature?	379	// Is it a valid signature?
380	if (!fromwin && !frommac) {	380	if (!fromwin && !frommac) {
381	// No valid signature found	381	// No valid signature found
382	return false;	382	return false;
383	}	383	}
384		384
385	// Does it come from Premiere or Photoshop?	385	// Does it come from Premiere or Photoshop?
386	// Initialize pparm	386	// Initialize pparm
387	if ((signature == PARM_SIZE_PREMIERE) \|\| (EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE)) {	387	if ((signature == PARM_SIZE_PREMIERE) \|\| (EndianS32_LtoN(signature) == PARM_SIZE_PREMIERE)) {
388	// It comes from Premiere. Swap R and B channel and convert to a Photoshop PARM_T	388	// It comes from Premiere. Swap R and B channel and convert to a Photoshop PARM_T
389	convert_premiere_to_photoshop(pparm, (PARM_T_PREMIERE*)p);	389	convert_premiere_to_photoshop(pparm, (PARM_T_PREMIERE*)p);
390	} else {	390	} else {
391	// It is already Photoshop. Just copy to pparm.	391	// It is already Photoshop. Just copy to pparm.
392	memcpy(pparm, p, sizeof(PARM_T));	392	memcpy(pparm, p, sizeof(PARM_T));
393	}	393	}
394		394
395	// Do we need to do string conversion?	395	// Do we need to do string conversion?
396	if (frommac) {	396	if (frommac) {
397	/* Mac PARM resource stores Pascal strings - convert to C strings, since this is what we work internally with (regardles of OS) */	397	/* Mac PARM resource stores Pascal strings - convert to C strings, since this is what we work internally with (regardles of OS) */
398	myp2cstr((unsigned char*)pparm->szCategory);	398	myp2cstr((unsigned char*)pparm->szCategory);
399	myp2cstr((unsigned char*)pparm->szTitle);	399	myp2cstr((unsigned char*)pparm->szTitle);
400	myp2cstr((unsigned char*)pparm->szCopyright);	400	myp2cstr((unsigned char*)pparm->szCopyright);
401	myp2cstr((unsigned char*)pparm->szAuthor);	401	myp2cstr((unsigned char*)pparm->szAuthor);
402	for (i = 0; i < 4; ++i)	402	for (i = 0; i < 4; ++i)
403	myp2cstr((unsigned char*)pparm->szMap[i]);	403	myp2cstr((unsigned char*)pparm->szMap[i]);
404	for (i = 0; i < 8; ++i)	404	for (i = 0; i < 8; ++i)
405	myp2cstr((unsigned char*)pparm->szCtl[i]);	405	myp2cstr((unsigned char*)pparm->szCtl[i]);
406	}	406	}
407		407
408	// Case #1: Mac is reading Windows (Win16/32/64) plugin	408	// Case #1: Mac is reading Windows (Win16/32/64) plugin
409	if (fromwin && tomac) {	409	if (fromwin && tomac) {
410	size_t i;	410	size_t i;
411		411
412	// Convert copyright CRLF to CR (actually, just removing LF)	412	// Convert copyright CRLF to CR (actually, just removing LF)
413	char copyrightCRLF[256];	413	char copyrightCRLF[256];
414	char* p = &copyrightCRLF[0];	414	char* p = &copyrightCRLF[0];
415	for (i = 0; i < strlen(pparm->szCopyright); i++) {	415	for (i = 0; i < strlen(pparm->szCopyright); i++) {
416	if (pparm->szCopyright[i] != LF) {	416	if (pparm->szCopyright[i] != LF) {
417	*p++ = pparm->szCopyright[i];	417	*p++ = pparm->szCopyright[i];
418	}	418	}
419	}	419	}
420	*p++ = '\0';	420	*p++ = '\0';
421	strcpy(pparm->szCopyright, copyrightCRLF);	421	strcpy(pparm->szCopyright, copyrightCRLF);
422		422
423	// these are the only numeric fields we have to swap	423	// these are the only numeric fields we have to swap
424	// all the rest are bool_t flags which (if we're careful) will work in either ordering	424	// all the rest are bool_t flags which (if we're careful) will work in either ordering
425	for (i = 0; i < 8; ++i)	425	for (i = 0; i < 8; ++i)
426	pparm->val[i] = EndianS32_LtoN(pparm->val[i]);	426	pparm->val[i] = EndianS32_LtoN(pparm->val[i]);
427	}	427	}
428		428
429	// Case #2: Mac is reading Mac (in case the normal resource extraction didn't work)	429	// Case #2: Mac is reading Mac (in case the normal resource extraction didn't work)
430	// Nothing to do	430	// Nothing to do
431		431
432	// Case #3: Windows is reading a Windows plugin (if Resource API failed, e.g. Win64 tries to open Win16 NE file or Win32 tries to open Win64 file)	432	// Case #3: Windows is reading a Windows plugin (if Resource API failed, e.g. Win64 tries to open Win16 NE file or Win32 tries to open Win64 file)
433	// Nothing to do	433	// Nothing to do
434		434
435	// Case #4: Windows is reading an old FilterFactory Mac file	435	// Case #4: Windows is reading an old FilterFactory Mac file
436	// Note: You must read the ".rsrc" resource fork, not the standalone binary!	436	// Note: You must read the ".rsrc" resource fork, not the standalone binary!
437	if (frommac && towin) {	437	if (frommac && towin) {
438	size_t i;	438	size_t i;
439		439
440	// Convert CR in the copyright field to CRLF.	440	// Convert CR in the copyright field to CRLF.
441	char copyrightCRLF[256];	441	char copyrightCRLF[256];
442	char* p = &copyrightCRLF[0];	442	char* p = &copyrightCRLF[0];
443	for (i = 0; i < strlen(pparm->szCopyright); i++) {	443	for (i = 0; i < strlen(pparm->szCopyright); i++) {
444	*p++ = pparm->szCopyright[i];	444	*p++ = pparm->szCopyright[i];
445	if (pparm->szCopyright[i] == CR) {	445	if (pparm->szCopyright[i] == CR) {
446	*p++ = LF;	446	*p++ = LF;
447	}	447	}
448	}	448	}
449	*p++ = '\0';	449	*p++ = '\0';
450	strcpy(pparm->szCopyright, copyrightCRLF);	450	strcpy(pparm->szCopyright, copyrightCRLF);
451		451
452	// these are the only numeric fields we have to swap	452	// these are the only numeric fields we have to swap
453	// all the rest are bool_t flags which (if we're careful) will work in either ordering	453	// all the rest are bool_t flags which (if we're careful) will work in either ordering
454	for (i = 0; i < 8; ++i)	454	for (i = 0; i < 8; ++i)
455	pparm->val[i] = EndianS32_LtoN(pparm->val[i]);	455	pparm->val[i] = EndianS32_LtoN(pparm->val[i]);
456	}	456	}
457		457
458	// Now set the values in pparm into the working variables expr[] and slider[], so that they are visible in the GUI	458	// Now set the values in pparm into the working variables expr[] and slider[], so that they are visible in the GUI
459		459
460	for(i = 0; i < 4; ++i){	460	for(i = 0; i < 4; ++i){
461	if(expr[i]) free(expr[i]);	461	if(expr[i]) free(expr[i]);
462	expr[i] = my_strdup(pparm->szFormula[i]);	462	expr[i] = my_strdup(pparm->szFormula[i]);
463	}	463	}
464		464
465	for (i = 0; i < 8; ++i) {	465	for (i = 0; i < 8; ++i) {
466	slider[i] = (uint8_t)pparm->val[i];	466	slider[i] = (uint8_t)pparm->val[i];
467	/*	467	/*
468	if (slider[i] > 0xFF) {	468	if (slider[i] > 0xFF) {
469	// Wrong endianess (e.g. reading a Mac rsrc on Windows)	469	// Wrong endianess (e.g. reading a Mac rsrc on Windows)
470	// Should not happen since we did the stuff above	470	// Should not happen since we did the stuff above
471	slider[i] = (uint8_t)EndianS32_LtoN(slider[i]);	471	slider[i] = (uint8_t)EndianS32_LtoN(slider[i]);
472	}	472	}
473	*/	473	*/
474	}	474	}
475		475
476	return true;	476	return true;
477	}	477	}
478		478
479	Handle readfileintohandle(FILEREF r){	479	Handle readfileintohandle(FILEREF r){
480	FILEPOS n;	480	FILEPOS n;
481	Handle h;	481	Handle h;
482	Ptr p;	482	Ptr p;
483		483
484	if( GetEOF(r,&n) == noErr && (h = PINEWHANDLE(n)) ){	484	if( GetEOF(r,&n) == noErr && (h = PINEWHANDLE(n)) ){
485	p = PILOCKHANDLE(h,false);	485	p = PILOCKHANDLE(h,false);
486	if(SetFPos(r,fsFromStart,0) == noErr && FSRead(r,(FILECOUNT*)&n,p) == noErr){	486	if(SetFPos(r,fsFromStart,0) == noErr && FSRead(r,(FILECOUNT*)&n,p) == noErr){
487	PIUNLOCKHANDLE(h);	487	PIUNLOCKHANDLE(h);
488	return h;	488	return h;
489	}	489	}
490	PIDISPOSEHANDLE(h);	490	PIDISPOSEHANDLE(h);
491	}	491	}
492	return NULL;	492	return NULL;
493	}	493	}
494		494
495	Boolean _picoLineContainsKey(char* line, char** content, const char* searchkey/=NULL/) {	495	Boolean _picoLineContainsKey(char* line, char** content, const char* searchkey/=NULL/) {
496	size_t i;	496	size_t i;
497	for (i = 0; i < strlen(line); i++) {	497	for (i = 0; i < strlen(line); i++) {
498	if (line[i] == '?') break; // avoid that "a?b:c" is detected as key	498	if (line[i] == '?') break; // avoid that "a?b:c" is detected as key
499	if (line[i] == ':') {	499	if (line[i] == ':') {
500	// Note: We are ignoring whitespaces, i.e. " A :" != "A:" (TODO: should we change this?)	500	// Note: We are ignoring whitespaces, i.e. " A :" != "A:" (TODO: should we change this?)

Subversion Repositories filter_foundry

filter_foundry/trunk/read.c – Rev 433 → 444