home *** CD-ROM | disk | FTP | other *** search
/ PC Welt 2001 September / PC-WELT 9-2001.ISO / software / hw / brennen / flask_src.exe / Plugins.cpp < prev    next >
Encoding:
C/C++ Source or Header  |  2000-05-06  |  8.4 KB  |  293 lines
  1. /* 
  2.  *  Plugins.cpp
  3.  *
  4.  *    Copyright (C) Alberto Vigata - January 2000 - ultraflask@yahoo.com
  5.  *
  6.  *  This file is part of FlasKMPEG, a free MPEG to MPEG/AVI converter
  7.  *    
  8.  *  FlasKMPEG is free software; you can redistribute it and/or modify
  9.  *  it under the terms of the GNU General Public License as published by
  10.  *  the Free Software Foundation; either version 2, or (at your option)
  11.  *  any later version.
  12.  *   
  13.  *  FlasKMPEG is distributed in the hope that it will be useful,
  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16.  *  GNU General Public License for more details.
  17.  *   
  18.  *  You should have received a copy of the GNU General Public License
  19.  *  along with GNU Make; see the file COPYING.  If not, write to
  20.  *  the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. 
  21.  *
  22.  */
  23.  
  24. #include <windows.h>
  25. #include "flaskmpeg.h"
  26. #include "plugins.h"
  27. #include ".\Premiere\Premiere.h"
  28.  
  29. char load_directory[MAX_PATH];
  30. compStdParms        stdParms;
  31. compInfoRec                infoRec;                        //Retrieves info from plugin
  32. compFileInfoRec            fileInfoRec;                    //Retrieves supported formats
  33. compAudioInfoRec        audioInfoRec;
  34.  
  35. //    callbacks
  36. compCallbackFuncs   callbackFuncs;      //Callback functions from the plugin
  37. ClassDataFuncs        classFuncs;
  38. compAudioFuncs        audioFuncs;
  39. compVideoFuncs        videoFuncs;
  40. compMemoryFuncs        memoryFuncs;
  41. compProgressFuncs   progressFuncs;
  42. compDebugFuncs      debugFuncs;
  43. // piSuites and related callbacks
  44. piSuites            SuitesFunctions;
  45.     PlugMemoryFuncs PMMFunctions;
  46.     PlugWindowFuncs PWIFunctions;
  47.     PlugppixFuncs   PPXFuncs;
  48.     PlugUtilFuncs   PUTFuncs;
  49.  
  50.  
  51. //  Inits Premiere structures and Stubs
  52. void InitPremiereCallbacks(void)
  53. {
  54.     //Premiere Memory functions
  55.  
  56.     //Class Functions
  57.     classFuncs.setClassData=            fsetClassData;
  58.     classFuncs.getClassData=            fgetClassData;
  59.  
  60.     //Audio Functions
  61.     audioFuncs.getAudio=                fgetAudio;
  62.     audioFuncs.getBlipMax=                fgetBlipMax;
  63.  
  64.     //Video Functions
  65.     videoFuncs.getFrame=                fgetFrame;
  66.     videoFuncs.getFrameInfo=            fgetFrameInfo;
  67.     videoFuncs.histogramInit=            fhistogramInit;
  68.     videoFuncs.histogramFree=            fhistogramFree;
  69.     videoFuncs.histogramProcessPixels=    fhistogramProcessPixels;
  70.     videoFuncs.histogramToPalette=        fhistogramToPalette;
  71.     videoFuncs.histogramDisposePalette=    fhistogramDisposePalette;
  72.     videoFuncs.histogramReducePixels=    fhistogramReducePixels;
  73.  
  74.     //Memory Functions
  75.     memoryFuncs.newPtr=                    fnewPtr;
  76.     memoryFuncs.setPtrSize=                fsetPtrSize;
  77.     memoryFuncs.getPtrSize=                fgetPtrSize;
  78.     memoryFuncs.disposePtr=                fdisposePtr;
  79.  
  80.     //Fucking Progress Functions (not docced)
  81.     progressFuncs.setProgressStr=        fsetProgressStr;
  82.     progressFuncs.updateProgress=        fupdateProgress;
  83.  
  84.     // Debuggin
  85.     debugFuncs.debugStr         =       fdebugStr;
  86.     debugFuncs.startDebug       =       fstartDebug;
  87.  
  88.     SuitesFunctions.piInterfaceVer  =  COMPILEMOD_VERSION_1;
  89.  
  90.     PMMFunctions.newPtr         = fnewPtr;
  91.     PMMFunctions.setPtrSize     = f2setPtrSize;
  92.     PMMFunctions.getPtrSize     = fgetPtrSize;
  93.     PMMFunctions.disposePtr     = fdisposePtr;
  94.     PMMFunctions.newHandle      = fnewHandle;
  95.     PMMFunctions.setHandleSize  = fsetHandleSize;
  96.     PMMFunctions.getHandleSize  = fgetHandleSize;
  97.     PMMFunctions.disposeHandle  = fdisposeHandle;
  98.         SuitesFunctions.memFuncs   = &PMMFunctions;
  99.  
  100.     memset(&PWIFunctions,1,sizeof(PlugWindowFuncs));
  101.     PWIFunctions.updateAllWindows = fupdateAllWindows;
  102.     PWIFunctions.getMainWnd       = fgetMainWnd;
  103.         SuitesFunctions.windFuncs  =  &PWIFunctions;
  104.  
  105.     memset(&PPXFuncs,2,sizeof(PlugppixFuncs));
  106.         PPXFuncs.ppixGetPixels   = fppixGetPixels;
  107.         PPXFuncs.ppixGetBounds   = fppixGetBounds;
  108.         PPXFuncs.ppixGetRowbytes = fppixGetRowbytes;
  109.         SuitesFunctions.ppixFuncs = &PPXFuncs;
  110.     
  111.     memset(&PUTFuncs, 3, sizeof(PlugUtilFuncs));
  112.         PUTFuncs.getSettings = fgetSettings;
  113.         SuitesFunctions.utilFuncs = &PUTFuncs;
  114.     // Asignations
  115.     callbackFuncs.classFuncs=&classFuncs;
  116.     callbackFuncs.audioFuncs=&audioFuncs;
  117.     callbackFuncs.videoFuncs=&videoFuncs;
  118.     callbackFuncs.memoryFuncs=&memoryFuncs;
  119.     callbackFuncs.progressFuncs=&progressFuncs;
  120.     callbackFuncs.debugFuncs     =&debugFuncs;
  121. };
  122.  
  123.  
  124. int SaveSettings(TPlugins *plugs, int current, char *name){
  125.     char szTemp[1024];
  126.     FILE *file;
  127.  
  128.  
  129.     strcpy(szTemp, load_directory);
  130.     strcat(szTemp,"\\Settings" );
  131.     //Creating settings folder
  132.     CreateDirectory(szTemp, NULL);
  133.  
  134.     sprintf(szTemp, "%s\\%s.settings.flask", szTemp,name);
  135.     if(!(file=fopen(szTemp, "wb"))){
  136.         //Ooops
  137.         return 0;
  138.     }
  139.     else
  140.     {
  141.         fwrite( plugs->outPlugs[current].settings, OUT_PLUG_MEM, 1, file);
  142.         fclose(file);
  143.         return 1;
  144.     }
  145. }
  146. int FlushPluginSettings( TPlugins *plugs ){
  147.     int i;
  148.     for(i=0; i<plugs->OutPluginCount; i++){
  149.         if(plugs->outPlugs[i].settings!=NULL)
  150.             SaveSettings(plugs, i, plugs->outPlugs[i].ID);
  151.     }
  152.     return 0;
  153. }
  154. static int LoadSettings(TPlugins *plugs, int current, char *name)
  155. {
  156.     char szTemp[1024];
  157.     FILE *file;
  158.  
  159.     sprintf(szTemp, ".\\Settings\\%s.settings.flask", name);
  160.     if(!(file=fopen(szTemp, "rb"))){
  161.         //The file didn't exist
  162.         plugs->outPlugs[current].settings = NULL;
  163.     }
  164.     else
  165.     {
  166.         plugs->outPlugs[current].settings = (char *)malloc(OUT_PLUG_MEM);
  167.         fread( plugs->outPlugs[current].settings, OUT_PLUG_MEM, 1, file);
  168.         fclose(file);
  169.     }
  170.     return 1;
  171. }
  172. static int PluginStartup( TPlugins *plugs, char *filename ){
  173.  
  174.         int i;
  175.  
  176.         HINSTANCE            hinstLib; 
  177.         int                 current = plugs->OutPluginCount;
  178.         CompileEntryFunc    CompileEntry;
  179.  
  180.  
  181.  
  182.         hinstLib = LoadLibrary(filename); 
  183.         // If the handle is valid, try to get the function address.
  184.         if (!hinstLib)
  185.             return 0;
  186.  
  187.         plugs->outPlugs[current].hinstLib = hinstLib;
  188.  
  189.         CompileEntry = (CompileEntryFunc) GetProcAddress(hinstLib, "xCompileEntry");
  190.         if(!CompileEntry){
  191.             FreeLibrary(hinstLib);
  192.             plugs->outPlugs[current].hinstLib = NULL;
  193.             return 0;
  194.         }
  195.         //iNIT Premiere callbacks
  196.         InitPremiereCallbacks();
  197.  
  198.         //StdParms
  199.         stdParms.compInterfaceVer=1;
  200.         stdParms.funcs    =  &callbackFuncs;
  201.         stdParms.piSuites =  &SuitesFunctions;
  202.  
  203.         if((CompileEntry)(compStartup, &stdParms, (long)&infoRec,0)!=comp_ErrNone){
  204.              // Free the DLL module.
  205.             FreeLibrary(hinstLib);
  206.             plugs->outPlugs[current].hinstLib = NULL;
  207.             return 0;
  208.         }
  209.                 plugs->outPlugs[current].CompilerID = infoRec.compilerID;
  210.                 plugs->outPlugs[current].fileType   = infoRec.fileType;
  211.         strcpy( plugs->outPlugs[current].ID         , infoRec.compilerName );
  212.  
  213.                 LoadSettings(plugs, current, infoRec.compilerName);
  214.         //Now query for the supported formats
  215.         i=0;
  216.         while( (CompileEntry)(compGetIndFormat, &stdParms, (long)&fileInfoRec,i)!=comp_BadFormatIndex )
  217.         {
  218.             i++;
  219.             if(fileInfoRec.subtype==compUncompressed)
  220.                 break;
  221.         }//Just look for uncompressed data
  222.  
  223.         i=0;
  224.         while( (CompileEntry)(compGetAudioIndFormat, &stdParms, (long)&audioInfoRec,i)!=comp_BadFormatIndex )
  225.         {
  226.             i++;
  227.             if(fileInfoRec.subtype==compUncompressed)
  228.                 break;
  229.         }
  230.  
  231.         //Plugin options buffer
  232. /*                    if( o.bufferExists[MPEG_PAN] ){
  233.                         FilePrefsRec[MPEG_PAN].compilerPrefs =(char *) malloc(2048);
  234.                         memcpy( FilePrefsRec[MPEG_PAN].compilerPrefs, o.buffer[MPEG_PAN] ,2048);
  235.                     }
  236.                     else
  237.                         FilePrefsRec[MPEG_PAN].compilerPrefs=NULL;
  238. */
  239.         plugs->outPlugs[current].CompileEntry=CompileEntry;
  240.         return ++plugs->OutPluginCount;
  241. }
  242.  
  243. int LoadPlugins( TPlugins *plugs )
  244. {
  245.     WIN32_FIND_DATA find_data;
  246.     char            directory[MAX_PATH];
  247.     HANDLE          search_handle;
  248.     int i;
  249.     int loaded_ok=0;
  250.  
  251.     // StartUp stuff
  252.     for(i=0; i<MAX_OUT_PLUGINS; i++)
  253.     {
  254.         plugs->outPlugs[i].hinstLib = NULL;
  255.     }
  256.     
  257.     // try flaskmpegpeasopeich.dll for compatibility
  258.     if(PluginStartup( plugs,  "flaskmpegpeasopeich.dll" ))
  259.             loaded_ok++;
  260.  
  261.     GetCurrentDirectory(MAX_PATH, load_directory);    
  262.     sprintf(directory, "%s\\*.cm.flask", load_directory);
  263.  
  264.     i=0;
  265.     search_handle = FindFirstFile(directory, &find_data);
  266.     if(search_handle==INVALID_HANDLE_VALUE){
  267.         return loaded_ok;
  268.     }
  269.     else{
  270.         if(PluginStartup( plugs,  find_data.cFileName ))
  271.             loaded_ok++;
  272.  
  273.         while( FindNextFile(search_handle, &find_data ) ){
  274.             if(PluginStartup( plugs,  find_data.cFileName ))
  275.                 loaded_ok++;
  276.         }
  277.         FindClose(search_handle);
  278.     }
  279.  
  280.     return loaded_ok;
  281. }
  282.  
  283. int ClosePlugins(TPlugins *plugs)
  284. {
  285.     int i;
  286.     for(i=0; i<plugs->OutPluginCount; i++)
  287.     {
  288.         FreeLibrary(plugs->outPlugs[i].hinstLib);
  289.         if(plugs->outPlugs[i].settings)
  290.             free(plugs->outPlugs[i].settings);
  291.     }
  292.     return 0;
  293. }