home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 10 Tools / 10-Tools.zip / ool_main.zip / ool / source / util.c < prev    next >
Text File  |  1998-03-15  |  52KB  |  1,388 lines
  1. #define  INCL_GPIBITMAPS
  2. #define  INCL_WINSYS
  3. #include <os2.h>
  4.  
  5. #include "oolglib.h"
  6. #include "oolgltk.h"
  7.  
  8. #include "gbm.h"
  9. #include "gbmtrunc.h"
  10. #include "gbmerr.h"
  11. #include "gbmht.h"
  12. #include "gbmhist.h"
  13. #include "gbmmcut.h"
  14.  
  15. #include <stdio.h>
  16. #include <string.h>
  17.  
  18. #define       __XGLIBpstrLen__ 65536
  19. static char   __XGLIBpstr__ [__XGLIBpstrLen__];
  20.  
  21. ULONG CreateBitmapInfo (PBITMAPINFO2* os2, ULONG w, ULONG h, UCHAR bpp) {
  22.    ULONG bytes;
  23.  
  24.    if (bpp <= 1) bpp = 1; else
  25.    if (bpp <= 4) bpp = 4; else
  26.    if (bpp <= 8) bpp = 8; else bpp = 24;
  27.  
  28.    bytes = DATAOFFSET (bpp) + h * SCANLINEBYTES (w, bpp);
  29.    if (NULL == (*os2 = (PBITMAPINFO2) malloc (bytes)))
  30.       return (BFE_MEMORY | bytes);
  31.  
  32.    memset (*os2, 0, sizeof (BITMAPINFOHEADER2));
  33.    (*os2)->cbFix     = sizeof (BITMAPINFOHEADER2);
  34.    (*os2)->cx        = w;
  35.    (*os2)->cy        = h;
  36.    (*os2)->cPlanes   = 1;
  37.    (*os2)->cBitCount = bpp;
  38.    (*os2)->cbImage   = h * SCANLINEBYTES (w, bpp);
  39.    
  40.    return BFE_OK;
  41. }
  42.  
  43. void trunc_pal_8G (GBMRGB* pal) {
  44.    int n;
  45.    for (n = 0; n < 256; n++)
  46.       pal [n].r = pal [n].g = pal [n].b = n;
  47. }
  48.  
  49. void trunc_8G (GBM* gbm, PBYTE src24, PBYTE dst8) {
  50.    PBYTE srcData, srcLine = src24, 
  51.          dstData, dstLine = dst8;
  52.    int   srcDelta = SCANLINEBYTES (gbm->w, 24),
  53.          dstDelta = SCANLINEBYTES (gbm->w, 8);
  54.    int   x, y;
  55.  
  56.    for (y = 0; y < gbm->h; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  57.       srcData = srcLine;
  58.       dstData = dstLine; 
  59.       for (x = 0; x < gbm->w; x++)
  60.          *dstData++ = (*srcData++ * 154 + *srcData++ * 307 + *srcData++ *  51) >> 9;
  61.    }
  62. }
  63.  
  64. void trunc_pal_8Red (GBMRGB* pal) {
  65.    int n;
  66.    for (n = 0; n < 256; n++) {
  67.       pal [n].r = n; pal [n].g = pal [n].b = 0;
  68.    }
  69. }
  70.  
  71. void trunc_8Red (GBM* gbm, PBYTE src24, PBYTE dst8) {
  72.    PBYTE srcData, srcLine = src24, 
  73.          dstData, dstLine = dst8;
  74.    int   srcDelta = SCANLINEBYTES (gbm->w, 24),
  75.          dstDelta = SCANLINEBYTES (gbm->w, 8);
  76.    int   x, y;
  77.  
  78.    for (y = 0; y < gbm->h; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  79.       srcData = srcLine;
  80.       dstData = dstLine; 
  81.       for (x = 0; x < gbm->w; x++, srcData+= 3)
  82.          *dstData++ = ((RGB*) srcData)->bRed;
  83.    }
  84. }
  85.  
  86. void trunc_pal_8Green (GBMRGB* pal) {
  87.    int n;
  88.    for (n = 0; n < 256; n++) {
  89.       pal [n].g = n; pal [n].r = pal [n].b = 0;
  90.    }
  91. }
  92.  
  93. void trunc_8Green (GBM* gbm, PBYTE src24, PBYTE dst8) {
  94.    PBYTE srcData, srcLine = src24, 
  95.          dstData, dstLine = dst8;
  96.    int   srcDelta = SCANLINEBYTES (gbm->w, 24),
  97.          dstDelta = SCANLINEBYTES (gbm->w, 8);
  98.    int   x, y;
  99.  
  100.    for (y = 0; y < gbm->h; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  101.       srcData = srcLine;
  102.       dstData = dstLine; 
  103.       for (x = 0; x < gbm->w; x++, srcData+= 3)
  104.          *dstData++ = ((RGB*) srcData)->bGreen;
  105.    }
  106. }
  107.  
  108. void trunc_pal_8Blue (GBMRGB* pal) {
  109.    int n;
  110.    for (n = 0; n < 256; n++) {
  111.       pal [n].b = n; pal [n].r = pal [n].g = 0;
  112.    }
  113. }
  114.  
  115. void trunc_8Blue (GBM* gbm, PBYTE src24, PBYTE dst8) {
  116.    PBYTE srcData, srcLine = src24, 
  117.          dstData, dstLine = dst8;
  118.    int   srcDelta = SCANLINEBYTES (gbm->w, 24),
  119.          dstDelta = SCANLINEBYTES (gbm->w, 8);
  120.    int   x, y;
  121.  
  122.    for (y = 0; y < gbm->h; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  123.       srcData = srcLine;
  124.       dstData = dstLine; 
  125.       for (x = 0; x < gbm->w; x++, srcData+= 3)
  126.          *dstData++ = ((RGB*) srcData)->bBlue;
  127.    }
  128. }
  129.  
  130. ULONG TrueColorExpansion (PBITMAPINFO2* newBitmap, PBITMAPINFO2 oldBitmap) {
  131.    ULONG rc;
  132.    PBYTE srcData, dstData, srcLine, dstLine;
  133.    int   srcDelta = SCANLINEBYTES (oldBitmap->cx, oldBitmap->cBitCount),
  134.          dstDelta = SCANLINEBYTES (oldBitmap->cx, 24);
  135.  
  136.    if (BFP_BPP_TRUECOLOR == oldBitmap->cBitCount) {
  137.       *newBitmap = oldBitmap;
  138.       return BFE_OK;
  139.    }
  140.  
  141.    if (BFE_OK != (rc = CreateBitmapInfo (newBitmap, oldBitmap->cx, oldBitmap->cy, 24)))
  142.       return rc;
  143.  
  144.    srcLine = (PBYTE) (oldBitmap->argbColor + PALETTESIZE (oldBitmap->cBitCount));
  145.    dstLine = (PBYTE) ((*newBitmap)->argbColor);
  146.  
  147.    switch (oldBitmap->cBitCount) {
  148.    case BFP_BPP_MONOCHROME: {
  149.       int x, y;
  150.       for (y = 0; y < oldBitmap->cy; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  151.          BYTE b;
  152.          srcData = srcLine;
  153.          dstData = dstLine; 
  154.          for (x = 0; x < oldBitmap->cx; x++) {
  155.             if (0 == (x & 7))
  156.                b = *srcData++;
  157.             else
  158.                b <<= 1;
  159.  
  160.             *dstData++ = oldBitmap->argbColor [b >> 7].bRed;
  161.             *dstData++ = oldBitmap->argbColor [b >> 7].bGreen;
  162.             *dstData++ = oldBitmap->argbColor [b >> 7].bBlue;
  163.          }
  164.          ;
  165.       }
  166.       break; }
  167.    case BFP_BPP_EGA: {
  168.       int x, y;
  169.       for (y = 0; y < oldBitmap->cy; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  170.          srcData = srcLine;
  171.          dstData = dstLine; 
  172.          for (x = 0; x + 1 < oldBitmap->cx; x+=2, srcData++) {
  173.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bBlue;
  174.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bGreen;
  175.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bRed;
  176.             *dstData++ = oldBitmap->argbColor [*srcData & 15].bBlue;
  177.             *dstData++ = oldBitmap->argbColor [*srcData & 15].bGreen;
  178.             *dstData++ = oldBitmap->argbColor [*srcData & 15].bRed;
  179.          }
  180.          if (oldBitmap->cx & 1) {
  181.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bBlue;
  182.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bGreen;
  183.             *dstData++ = oldBitmap->argbColor [*srcData >> 4].bRed;
  184.          }
  185.       }
  186.       break; }
  187.    case BFP_BPP_VGA: {
  188.       int x, y;
  189.       for (y = 0; y < oldBitmap->cy; y++, srcLine+= srcDelta, dstLine+= dstDelta) {
  190.          srcData = srcLine;
  191.          dstData = dstLine; 
  192.          for (x = 0; x < oldBitmap->cx; x++, srcData++) {
  193.             *dstData++ = oldBitmap->argbColor [*srcData].bBlue;
  194.             *dstData++ = oldBitmap->argbColor [*srcData].bGreen;
  195.             *dstData++ = oldBitmap->argbColor [*srcData].bRed;
  196.          }
  197.       }
  198.       break; }
  199.    }
  200.    
  201.    return BFE_OK;
  202. }
  203.  
  204. UCHAR AdjustColorBits (UCHAR bppValue, UCHAR bppMask) {
  205. /* first try identical or next higher bpp-value */
  206.    if (BFP_BPP_MONOCHROME == bppValue && (BFF_PROCESS_1BPP & bppMask))
  207.       return BFP_BPP_MONOCHROME;
  208.    if (BFP_BPP_EGA        >= bppValue && (BFF_PROCESS_4BPP & bppMask))
  209.       return BFP_BPP_EGA;
  210.    if (BFP_BPP_VGA        >= bppValue && (BFF_PROCESS_8BPP & bppMask))
  211.       return BFP_BPP_VGA;
  212.    if (BFP_BPP_TRUECOLOR  >= bppValue && (BFF_PROCESS_24BPP & bppMask))
  213.       return BFP_BPP_TRUECOLOR;
  214.  
  215. /* and now next lower bpp-value */
  216.    if (BFP_BPP_VGA < bppValue && (BFF_PROCESS_8BPP & bppMask))
  217.       return BFP_BPP_VGA;
  218.    if (BFP_BPP_EGA < bppValue && (BFF_PROCESS_4BPP & bppMask))
  219.       return BFP_BPP_EGA;
  220.    return BFP_BPP_MONOCHROME;
  221. }
  222.  
  223. ULONG Remap (PBITMAPINFO2 source, PBITMAPINFO2* dest, XBitmapFilter* param) {
  224.    PBITMAPINFO2 trueColor;
  225.    GBMRGB       newPal [256];
  226.    GBM          gbmInfo;
  227.    PBYTE        srcData;
  228.    PBYTE        dstData;
  229.    ULONG        rc;
  230.    int          n;
  231.  
  232.    if (BFP_BPP_DONT_TOUCH == param->cBitCount) {
  233.       *dest = source;
  234.       return BFE_OK;
  235.    }
  236.  
  237.    if (BFP_PALETTE_DEFAULT == param->cPalette)
  238.       param->cPalette = 
  239.          GetDefaultPalette (param->cFilterID, param->cBitCount);
  240.  
  241.    if (!(GetDitheringMask (param->cFilterID, param->cBitCount) &
  242.       param->cDithering))
  243.       param->cDithering = BFP_DITHERING_NONE;
  244.  
  245. fprintf (stderr, "Remap bpp: %d->%d, pal: %d, alg: %d\n",
  246.    source->cBitCount, param->cBitCount, param->cPalette, param->cDithering);
  247.    if (BFE_OK != (rc = TrueColorExpansion (&trueColor, source))) {
  248.       return rc;
  249.    }
  250.  
  251.    if (BFE_OK != (rc = CreateBitmapInfo (dest, source->cx, source->cy, param->cBitCount))) {
  252.       return rc;
  253.    }
  254.    gbmInfo.w   = trueColor->cx;
  255.    gbmInfo.h   = trueColor->cy;
  256.    gbmInfo.bpp = trueColor->cBitCount;
  257.    dstData = (PBYTE) ((*dest)->argbColor + PALETTESIZE ((*dest)->cBitCount));
  258.    srcData = (PBYTE) (trueColor->argbColor);
  259.  
  260.    rc = TRUE;
  261.    switch (param->cBitCount) {
  262.    case BFP_BPP_MONOCHROME: /**************************************************/
  263.       switch (param->cDithering) {
  264.       case BFP_DITHERING_NONE:            /* MONO->Truncate */
  265.          gbm_trunc_pal_BW (newPal);
  266.          newPal [2] = newPal [1]; newPal [1] = newPal [0]; newPal [0] = newPal [2];
  267.          gbm_trunc_BW (&gbmInfo, srcData, dstData);
  268.          break;
  269.       case BFP_DITHERING_ERRORDIFFUSION:  /* MONO->Errordiffusion */
  270.          gbm_errdiff_pal_BW (newPal);
  271.          newPal [2] = newPal [1]; newPal [1] = newPal [0]; newPal [0] = newPal [2];
  272.          rc = gbm_errdiff_BW (&gbmInfo, srcData, dstData);
  273.          break;
  274.       }
  275.       break;
  276.    case BFP_BPP_EGA: /*********************************************************/
  277.       switch (param->cDithering) {
  278.       case BFP_DITHERING_NONE:            /* EGA->Truncate */
  279.          switch (param->cPalette) {
  280.          case BFP_PALETTE_GREYSCALE:
  281.             gbm_trunc_pal_4G (newPal);
  282.             gbm_trunc_4G (&gbmInfo, srcData, dstData);
  283.             break;
  284.          case BFP_PALETTE_4BIT_8_COLORS:
  285.             gbm_trunc_pal_8 (newPal);
  286.             gbm_trunc_8 (&gbmInfo, srcData, dstData);
  287.             break;
  288.          case BFP_PALETTE_4BIT_16_COLORS:
  289.             gbm_trunc_pal_VGA (newPal);
  290.             gbm_trunc_VGA (&gbmInfo, srcData, dstData);
  291.             break;
  292.          }
  293.          break;
  294.       case BFP_DITHERING_ERRORDIFFUSION:  /* EGA->Errordiffusion */
  295.          switch (param->cPalette) {
  296.          case BFP_PALETTE_GREYSCALE:
  297.             gbm_errdiff_pal_4G (newPal);
  298.             rc = gbm_errdiff_4G (&gbmInfo, srcData, dstData);
  299.             break;
  300.          case BFP_PALETTE_4BIT_8_COLORS:            gbm_errdiff_pal_8 (newPal);
  301.             rc = gbm_errdiff_8 (&gbmInfo, srcData, dstData);
  302.             break;
  303.          case BFP_PALETTE_4BIT_16_COLORS:
  304.             gbm_errdiff_pal_VGA (newPal);
  305.             rc = gbm_errdiff_VGA (&gbmInfo, srcData, dstData);
  306.             break;
  307.          }
  308.          break;
  309.       case BFP_DITHERING_SMALL_HALFTONE:  /* EGA->smallHalfTone */
  310.          switch (param->cPalette) {
  311.          case BFP_PALETTE_4BIT_8_COLORS:
  312.             gbm_ht_pal_8 (newPal);
  313.             gbm_ht_8_2x2 (&gbmInfo, srcData, dstData);
  314.             break;
  315.          case BFP_PALETTE_4BIT_16_COLORS:
  316.             gbm_ht_pal_VGA (newPal);
  317.             gbm_ht_VGA_2x2 (&gbmInfo, srcData, dstData);
  318.             break;
  319.          }
  320.          break;
  321.       case BFP_DITHERING_LARGE_HALFTONE:  /* EGA->largeHalfTone */
  322.          switch (param->cPalette) {
  323.          case BFP_PALETTE_4BIT_8_COLORS:
  324.             gbm_ht_pal_8 (newPal);
  325.             gbm_ht_8_3x3 (&gbmInfo, srcData, dstData);
  326.             break;
  327.          case BFP_PALETTE_4BIT_16_COLORS:
  328.             gbm_ht_pal_VGA (newPal);
  329.             gbm_ht_VGA_3x3 (&gbmInfo, srcData, dstData);
  330.             break;
  331.          }
  332.          break;
  333.       }
  334.       break;
  335.    case BFP_BPP_VGA: /*********************************************************/
  336.       switch (param->cDithering) {
  337.       case BFP_DITHERING_NONE:            /* VGA->Truncate */
  338.          switch (param->cPalette) {
  339.          case BFP_PALETTE_GREYSCALE:
  340.             trunc_pal_8G (newPal);
  341.             trunc_8G (&gbmInfo, srcData, dstData);
  342.             break;
  343.          case BFP_PALETTE_REDSCALE:
  344.             trunc_pal_8Red (newPal);
  345.             trunc_8Red (&gbmInfo, srcData, dstData);
  346.             break;
  347.          case BFP_PALETTE_GREENSCALE:
  348.             trunc_pal_8Green (newPal);
  349.             trunc_8Green (&gbmInfo, srcData, dstData);
  350.             break;
  351.          case BFP_PALETTE_BLUESCALE:
  352.             trunc_pal_8Blue (newPal);
  353.             trunc_8Blue (&gbmInfo, srcData, dstData);
  354.             break;
  355.          case BFP_PALETTE_8BIT_666:
  356.             gbm_trunc_pal_6R6G6B (newPal);
  357.             gbm_trunc_6R6G6B (&gbmInfo, srcData, dstData);
  358.             break;
  359.          case BFP_PALETTE_8BIT_784:
  360.             gbm_trunc_pal_7R8G4B (newPal);
  361.             gbm_trunc_7R8G4B (&gbmInfo, srcData, dstData);
  362.             break;
  363.          }
  364.          break;
  365.       case BFP_DITHERING_ERRORDIFFUSION:  /* VGA->ErrorDiffusion */
  366.          switch (param->cPalette) {
  367.          case BFP_PALETTE_8BIT_666:
  368.             gbm_errdiff_pal_6R6G6B (newPal);
  369.             rc = gbm_errdiff_6R6G6B (&gbmInfo, srcData, dstData);
  370.             break;
  371.          case BFP_PALETTE_8BIT_784:
  372.             gbm_errdiff_pal_7R8G4B (newPal);
  373.             rc = gbm_errdiff_7R8G4B (&gbmInfo, srcData, dstData);
  374.             break;
  375.          }
  376.          break;
  377.       case BFP_DITHERING_SMALL_HALFTONE:  /* VGA->SmallHalfTone */
  378.          switch (param->cPalette) {
  379.          case BFP_PALETTE_8BIT_666:
  380.             gbm_ht_pal_6R6G6B (newPal);
  381.             gbm_ht_6R6G6B_2x2 (&gbmInfo, srcData, dstData);
  382.             break;
  383.          case BFP_PALETTE_8BIT_784:
  384.             gbm_ht_pal_7R8G4B (newPal);
  385.             gbm_ht_7R8G4B_2x2 (&gbmInfo, srcData, dstData);
  386.             break;
  387.          }
  388.          break;
  389.       case BFP_DITHERING_OPTIMIZED:       /* VGA->HistoGraph */
  390.          rc = gbm_hist (&gbmInfo, srcData, newPal, dstData, param->cClrEntries, 
  391.             param->cRedBits, param->cGreenBits, param->cBlueBits);
  392.          break;
  393.       case BFP_DITHERING_MEDIANCUT:       /* VGA->MedianCut */
  394.          rc = gbm_mcut (&gbmInfo, srcData, newPal, dstData, param->cClrEntries);
  395.          break;
  396.       }
  397.       break;
  398.    case BFP_BPP_HIGHCOLOR: /**************************************************/
  399.       switch (param->cDithering) {
  400.       case BFP_DITHERING_NONE:
  401.          switch (param->cPalette) {       /* HighCol->Truncate */
  402.          case BFP_PALETTE_16BIT_555:
  403.             gbm_trunc_24 (&gbmInfo, srcData, dstData, 248, 248, 248);
  404.             break;
  405.          case BFP_PALETTE_16BIT_565:
  406.             gbm_trunc_24 (&gbmInfo, srcData, dstData, 248, 252, 248);
  407.             break;
  408.          }
  409.          break;
  410.       case BFP_DITHERING_ERRORDIFFUSION:
  411.          switch (param->cPalette) {       /* HighCol->ErrorDiffusion */
  412.          case BFP_PALETTE_16BIT_555:
  413.             rc = gbm_errdiff_24 (&gbmInfo, srcData, dstData, 248, 248, 248);
  414.             break;
  415.          case BFP_PALETTE_16BIT_565:
  416.             rc = gbm_errdiff_24 (&gbmInfo, srcData, dstData, 248, 252, 248);
  417.             break;
  418.          }
  419.          break;
  420.       case BFP_DITHERING_SMALL_HALFTONE:  /* HighCol->SmallHalfTone */
  421.          switch (param->cPalette) {       
  422.          case BFP_PALETTE_16BIT_555:
  423.             gbm_ht_24_2x2 (&gbmInfo, srcData, dstData, 248, 248, 248);
  424.             break;
  425.          case BFP_PALETTE_16BIT_565:
  426.             gbm_ht_24_2x2 (&gbmInfo, srcData, dstData, 248, 252, 248);
  427.             break;
  428.          }
  429.          break;
  430.       }
  431.       break;
  432.    case BFP_BPP_TRUECOLOR:
  433.    case BFP_BPP_DIRECTCOLOR:
  434.       free (*dest);
  435.       *dest = trueColor;
  436.       trueColor = NULL; /* free() has to be able to handle this */
  437.       break;
  438.    }
  439.    if (FALSE == rc) {
  440.       if (source != trueColor) free (trueColor);
  441.       free (*dest);
  442.       return (BFE_MAPPING_ERROR);
  443.    }
  444.  
  445.    for (n = 0; n < PALETTESIZE ((*dest)->cBitCount); n++) {
  446.       (*dest)->argbColor [n].bRed   = newPal [n].r;
  447.       (*dest)->argbColor [n].bGreen = newPal [n].g;
  448.       (*dest)->argbColor [n].bBlue  = newPal [n].b;
  449.    }
  450.  
  451.    if (source != trueColor) free (trueColor);
  452.    return BFE_OK;
  453. }
  454.  
  455. void InitFileTypeMapping (XBitmapFilterProfile* profile) {
  456.    gbm_guess_filetype ("oolglib.bmp", &profile->gbmFileType [BFT_Bitmap]);
  457.    gbm_guess_filetype ("oolglib.img", profile->gbmFileType + BFT_GEM);
  458.    gbm_guess_filetype ("oolglib.gif", profile->gbmFileType + BFT_GIF);
  459.    gbm_guess_filetype ("oolglib.pgm", profile->gbmFileType + BFT_Greymap);
  460.    gbm_guess_filetype ("oolglib.iax", profile->gbmFileType + BFT_IAX);
  461.    gbm_guess_filetype ("oolglib.lbm", profile->gbmFileType + BFT_ILBM);
  462.    gbm_guess_filetype ("oolglib.jpg", profile->gbmFileType + BFT_JPEG);
  463.    gbm_guess_filetype ("oolglib.kps", profile->gbmFileType + BFT_KIPS);
  464.    gbm_guess_filetype ("oolglib.pcx", profile->gbmFileType + BFT_PCX);
  465.    gbm_guess_filetype ("oolglib.ppm", profile->gbmFileType + BFT_Pixmap);
  466.    gbm_guess_filetype ("oolglib.cvp", profile->gbmFileType + BFT_Portrait);
  467.    gbm_guess_filetype ("oolglib.pse", profile->gbmFileType + BFT_PSeg);
  468.    gbm_guess_filetype ("oolglib.spr", profile->gbmFileType + BFT_Sprite);
  469.    gbm_guess_filetype ("oolglib.tga", profile->gbmFileType + BFT_Targa);
  470.    gbm_guess_filetype ("oolglib.tif", profile->gbmFileType + BFT_TIFF);
  471.    gbm_guess_filetype ("oolglib.xbm", profile->gbmFileType + BFT_XBitmap);
  472.    gbm_guess_filetype ("oolglib.vid", profile->gbmFileType + BFT_YUV12C);
  473. }
  474.  
  475. ULONG GetProfileSize () {
  476.    int                  n;
  477.    ULONG                ulMemSize = sizeof (XBitmapFilterProfile);
  478.    GBMFT                gbmInfo;
  479.    XBitmapFilterProfile tmpProf;
  480.  
  481.    InitFileTypeMapping (&tmpProf);
  482.    for (n = 0; n < BFT_COUNT; n++) {
  483.       gbm_query_filetype (tmpProf.gbmFileType [n], &gbmInfo);
  484.       ulMemSize+= strlen (gbmInfo.extensions) +
  485.                   strlen (gbmInfo.long_name) + 2;
  486.    }
  487.  
  488.    return ulMemSize;
  489. }
  490.  
  491. UCHAR GetFilterID (PSZ filename, XBitmapFilterProfile* profile) {
  492.    int   gbmType;
  493.    UCHAR cFilterID;
  494.    
  495.    if (GBM_ERR_OK != gbm_guess_filetype (filename, &gbmType))
  496.       return BFT_COUNT;
  497.    for (cFilterID = 0; profile->gbmFileType [cFilterID] != gbmType &&
  498.       cFilterID < BFT_COUNT; cFilterID++);
  499.    return cFilterID;
  500. }
  501.  
  502. ULONG GetDefaultPalette (UCHAR cFilterID, UCHAR cBitCount) {
  503.    switch (cFilterID) {
  504.    case BFT_Greymap:
  505.    case BFT_IAX:
  506.       return BFP_PALETTE_GREYSCALE;
  507.    default:
  508.       switch (cBitCount) {
  509.       case BFP_BPP_MONOCHROME:  return BFP_PALETTE_1BIT_2_COLORS;
  510.       case BFP_BPP_EGA:         return BFP_PALETTE_4BIT_16_COLORS;
  511.       case BFP_BPP_VGA:         return BFP_PALETTE_8BIT_666;
  512.       case BFP_BPP_HIGHCOLOR:   return BFP_PALETTE_16BIT_555;
  513.       case BFP_BPP_TRUECOLOR:   return BFP_PALETTE_TRUECOLORS;
  514.       case BFP_BPP_DIRECTCOLOR: return BFP_PALETTE_TRUECOLORS;
  515.       }
  516.    }
  517. }
  518.  
  519. ULONG GetPaletteMask (UCHAR cFilterID, UCHAR cBitCount, UCHAR cDitheringID) {
  520.    switch (cFilterID) {
  521.    case BFT_Greymap:
  522.    case BFT_IAX:
  523.       switch (cBitCount) {
  524.       case BFP_BPP_DONT_TOUCH:  return BFP_PALETTE_DEFAULT;
  525.       case BFP_BPP_VGA:         return BFP_PALETTE_DEFAULT | BFP_PALETTE_GREYSCALE |
  526.          BFP_PALETTE_REDSCALE | BFP_PALETTE_GREENSCALE | BFP_PALETTE_BLUESCALE;
  527.       default: return 0;
  528.       }
  529.    default:
  530.       switch (cBitCount) {
  531.       case BFP_BPP_DONT_TOUCH:  return BFP_PALETTE_DEFAULT;
  532.       case BFP_BPP_MONOCHROME:  return BFP_PALETTE_DEFAULT | BFP_PALETTE_1BIT_2_COLORS;
  533.       case BFP_BPP_EGA:         return BFP_PALETTE_DEFAULT | BFP_PALETTE_4BIT_8_COLORS | BFP_PALETTE_4BIT_16_COLORS
  534.          | ((BFP_DITHERING_NONE | BFP_DITHERING_ERRORDIFFUSION) & cDitheringID ? BFP_PALETTE_GREYSCALE : 0);
  535.       case BFP_BPP_VGA:         return BFP_PALETTE_DEFAULT | BFP_PALETTE_8BIT_666 | BFP_PALETTE_8BIT_784
  536.          | (BFP_DITHERING_NONE == cDitheringID ? BFP_PALETTE_GREYSCALE : 0);
  537.       case BFP_BPP_HIGHCOLOR:   return BFP_PALETTE_DEFAULT | BFP_PALETTE_16BIT_555 | BFP_PALETTE_16BIT_565;
  538.       case BFP_BPP_TRUECOLOR:   return BFP_PALETTE_DEFAULT | BFP_PALETTE_TRUECOLORS;
  539.       case BFP_BPP_DIRECTCOLOR: return BFP_PALETTE_DEFAULT | BFP_PALETTE_TRUECOLORS;
  540.       default: return 0;
  541.       }
  542.    }
  543. }
  544.  
  545. ULONG GetDitheringMask (UCHAR cFilterID, UCHAR cBitCount) {
  546.    switch (cFilterID) {
  547.    case BFT_Greymap:
  548.    case BFT_IAX:
  549.       return BFP_DITHERING_NONE;
  550.    default:
  551.       switch (cBitCount) {
  552.       case BFP_BPP_DONT_TOUCH:  return BFP_DITHERING_NONE;
  553.       case BFP_BPP_MONOCHROME:  return BFP_DITHERING_NONE | BFP_DITHERING_ERRORDIFFUSION;
  554.       case BFP_BPP_EGA:         return BFP_DITHERING_NONE | BFP_DITHERING_ERRORDIFFUSION  | BFP_DITHERING_SMALL_HALFTONE | BFP_DITHERING_LARGE_HALFTONE;
  555.       case BFP_BPP_VGA:         return BFP_DITHERING_NONE | BFP_DITHERING_ERRORDIFFUSION  | BFP_DITHERING_SMALL_HALFTONE | BFP_DITHERING_OPTIMIZED | BFP_DITHERING_MEDIANCUT;
  556.       case BFP_BPP_HIGHCOLOR:   return BFP_DITHERING_NONE | BFP_DITHERING_ERRORDIFFUSION  | BFP_DITHERING_SMALL_HALFTONE;
  557.       case BFP_BPP_TRUECOLOR:   return BFP_DITHERING_NONE;
  558.       case BFP_BPP_DIRECTCOLOR: return BFP_DITHERING_NONE;
  559.       default:                  return 0;
  560.       }
  561.    }
  562. }
  563.  
  564. ULONG CheckImportFilter (XBitmapFilter* param) {
  565.    int n, c;
  566.  
  567.    if (param->cbFix != GetImportFilterSize (param->cFilterID))
  568.       returnExtUL (BFE_INVALID_CBFIX, param->cbFix, GetImportFilterSize (param->cFilterID));
  569.    for (n = 0, c = 0; n < BFP_PALETTE_COUNT; n++)
  570.       if ((1 << n) & param->cPalette) c++;
  571.    if (c != 1 || param->cPalette >= (1 << BFP_PALETTE_COUNT))
  572.       returnUL (BFE_INVALID_PALETTE);
  573.    for (n = 0, c = 0; n < BFP_DITHERING_COUNT; n++)
  574.       if ((1 << n) & param->cDithering) c++;
  575.    if (c != 1 || param->cDithering >= (1 << BFP_DITHERING_COUNT))
  576.       returnUL (BFE_INVALID_DITHERING);
  577.  
  578.    switch (param->cFilterID) {
  579.    case BFT_Bitmap:   return CheckBitmapImportFilter (param);
  580.    case BFT_GEM:      return CheckGEMImportFilter (param);
  581.    case BFT_GIF:      return CheckGIFImportFilter (param);
  582.    case BFT_Greymap:  return CheckGreymapImportFilter (param);
  583.    case BFT_IAX:      return CheckIAXImportFilter (param);
  584.    case BFT_ILBM:     return CheckILBMImportFilter (param);
  585.    case BFT_JPEG:     return CheckJPEGImportFilter (param);
  586.    case BFT_KIPS:     return CheckKIPSImportFilter (param);
  587.    case BFT_PCX:      return CheckPCXImportFilter (param);
  588.    case BFT_Pixmap:   return CheckPixmapImportFilter (param);
  589.    case BFT_Portrait: return CheckPortraitImportFilter (param);
  590.    case BFT_PSeg:     return CheckPSegImportFilter (param);
  591.    case BFT_Sprite:   return CheckSpriteImportFilter (param);
  592.    case BFT_Targa:    return CheckTargaImportFilter (param);
  593.    case BFT_TIFF:     return CheckTIFFImportFilter (param);
  594.    case BFT_XBitmap:  return CheckXBitmapImportFilter (param);
  595.    case BFT_YUV12C:   return CheckYUV12CImportFilter (param);
  596.    default:           return BFE_OK;
  597.    }
  598. }
  599.  
  600. ULONG CheckExportFilter (XBitmapFilter* param) {
  601.    ULONG mask;
  602.  
  603.    if (param->cbFix != GetExportFilterSize (param->cFilterID))
  604.       returnExtUL (BFE_INVALID_CBFIX, param->cbFix, GetExportFilterSize (param->cFilterID));
  605.    mask = GetPaletteMask (param->cFilterID, param->cBitCount, param->cDithering);
  606.    if (0 == (param->cPalette & mask)) returnExtUL (BFE_INVALID_PALETTE, param->cPalette, mask);
  607.    mask = GetDitheringMask (param->cFilterID, param->cBitCount);
  608.    if (0 == (param->cDithering & mask)) returnExtUL (BFE_INVALID_DITHERING, param->cDithering, mask);
  609.  
  610.    switch (param->cFilterID) {
  611.    case BFT_Bitmap:   return CheckBitmapExportFilter (param);
  612.    case BFT_GEM:      return CheckGEMExportFilter (param);
  613.    case BFT_GIF:      return CheckGIFExportFilter (param);
  614.    case BFT_Greymap:  return CheckGreymapExportFilter (param);
  615.    case BFT_IAX:      return CheckIAXExportFilter (param);
  616.    case BFT_ILBM:     return CheckILBMExportFilter (param);
  617.    case BFT_JPEG:     return CheckJPEGExportFilter (param);
  618.    case BFT_KIPS:     return CheckKIPSExportFilter (param);
  619.    case BFT_PCX:      return CheckPCXExportFilter (param);
  620.    case BFT_Pixmap:   return CheckPixmapExportFilter (param);
  621.    case BFT_Portrait: return CheckPortraitExportFilter (param);
  622.    case BFT_PSeg:     return CheckPSegExportFilter (param);
  623.    case BFT_Sprite:   return CheckSpriteExportFilter (param);
  624.    case BFT_Targa:    return CheckTargaExportFilter (param);
  625.    case BFT_TIFF:     return CheckTIFFExportFilter (param);
  626.    case BFT_XBitmap:  return CheckXBitmapExportFilter (param);
  627.    case BFT_YUV12C:   return CheckYUV12CExportFilter (param);
  628.    default:           return BFE_OK;
  629.    }
  630. }
  631.  
  632. PSZ GetImportFilterString (XBitmapFilter* param) {
  633.    switch (param->cFilterID) {
  634.    case BFT_Bitmap:   return GetBitmapImportFilterString (param);
  635.    case BFT_GEM:      return GetGEMImportFilterString (param);
  636.    case BFT_GIF:      return GetGIFImportFilterString (param);
  637.    case BFT_Greymap:  return GetGreymapImportFilterString (param);
  638.    case BFT_IAX:      return GetIAXImportFilterString (param);
  639.    case BFT_ILBM:     return GetILBMImportFilterString (param);
  640.    case BFT_JPEG:     return GetJPEGImportFilterString (param);
  641.    case BFT_KIPS:     return GetKIPSImportFilterString (param);
  642.    case BFT_PCX:      return GetPCXImportFilterString (param);
  643.    case BFT_Pixmap:   return GetPixmapImportFilterString (param);
  644.    case BFT_Portrait: return GetPortraitImportFilterString (param);
  645.    case BFT_PSeg:     return GetPSegImportFilterString (param);
  646.    case BFT_Sprite:   return GetSpriteImportFilterString (param);
  647.    case BFT_Targa:    return GetTargaImportFilterString (param);
  648.    case BFT_TIFF:     return GetTIFFImportFilterString (param);
  649.    case BFT_XBitmap:  return GetXBitmapImportFilterString (param);
  650.    case BFT_YUV12C:   return GetYUV12CImportFilterString (param);
  651.    default:           return "";
  652.    }
  653. }
  654.  
  655. PSZ GetExportFilterString (XBitmapFilter* param) {
  656.    switch (param->cFilterID) {
  657.    case BFT_Bitmap:   return GetBitmapExportFilterString (param);
  658.    case BFT_GEM:      return GetGEMExportFilterString (param);
  659.    case BFT_GIF:      return GetGIFExportFilterString (param);
  660.    case BFT_Greymap:  return GetGreymapExportFilterString (param);
  661.    case BFT_IAX:      return GetIAXExportFilterString (param);
  662.    case BFT_ILBM:     return GetILBMExportFilterString (param);
  663.    case BFT_JPEG:     return GetJPEGExportFilterString (param);
  664.    case BFT_KIPS:     return GetKIPSExportFilterString (param);
  665.    case BFT_PCX:      return GetPCXExportFilterString (param);
  666.    case BFT_Pixmap:   return GetPixmapExportFilterString (param);
  667.    case BFT_Portrait: return GetPortraitExportFilterString (param);
  668.    case BFT_PSeg:     return GetPSegExportFilterString (param);
  669.    case BFT_Sprite:   return GetSpriteExportFilterString (param);
  670.    case BFT_Targa:    return GetTargaExportFilterString (param);
  671.    case BFT_TIFF:     return GetTIFFExportFilterString (param);
  672.    case BFT_XBitmap:  return GetXBitmapExportFilterString (param);
  673.    case BFT_YUV12C:   return GetYUV12CExportFilterString (param);
  674.    default:           return "";
  675.    }
  676. }
  677.  
  678. ULONG GetImportFilterSize (UCHAR cFilterID) {
  679.    switch (cFilterID) {
  680.    case BFT_Bitmap:   return sizeof (XBitmapImportFilter);
  681.    case BFT_GEM:      return sizeof (XGEMImportFilter);
  682.    case BFT_GIF:      return sizeof (XGIFImportFilter);
  683.    case BFT_Greymap:  return sizeof (XGreymapImportFilter);
  684.    case BFT_IAX:      return sizeof (XIAXImportFilter);
  685.    case BFT_ILBM:     return sizeof (XILBMImportFilter);
  686.    case BFT_JPEG:     return sizeof (XJPEGImportFilter);
  687.    case BFT_KIPS:     return sizeof (XKIPSImportFilter);
  688.    case BFT_PCX:      return sizeof (XPCXImportFilter);
  689.    case BFT_Pixmap:   return sizeof (XPixmapImportFilter);
  690.    case BFT_Portrait: return sizeof (XPortraitImportFilter);
  691.    case BFT_PSeg:     return sizeof (XPSegImportFilter);
  692.    case BFT_Sprite:   return sizeof (XSpriteImportFilter);
  693.    case BFT_Targa:    return sizeof (XTargaImportFilter);
  694.    case BFT_TIFF:     return sizeof (XTIFFImportFilter);
  695.    case BFT_XBitmap:  return sizeof (XXBitmapImportFilter);
  696.    case BFT_YUV12C:   return sizeof (XYUV12CImportFilter);
  697.    default:           return sizeof (XBitmapFilter);
  698.    }
  699. }
  700.  
  701. ULONG GetExportFilterSize (UCHAR cFilterID) {
  702.    switch (cFilterID) {
  703.    case BFT_Bitmap:   return sizeof (XBitmapExportFilter);
  704.    case BFT_GEM:      return sizeof (XGEMExportFilter);
  705.    case BFT_GIF:      return sizeof (XGIFExportFilter);
  706.    case BFT_Greymap:  return sizeof (XGreymapExportFilter);
  707.    case BFT_IAX:      return sizeof (XIAXExportFilter);
  708.    case BFT_ILBM:     return sizeof (XILBMExportFilter);
  709.    case BFT_JPEG:     return sizeof (XJPEGExportFilter);
  710.    case BFT_KIPS:     return sizeof (XKIPSExportFilter);
  711.    case BFT_PCX:      return sizeof (XPCXExportFilter);
  712.    case BFT_Pixmap:   return sizeof (XPixmapExportFilter);
  713.    case BFT_Portrait: return sizeof (XPortraitExportFilter);
  714.    case BFT_PSeg:     return sizeof (XPSegExportFilter);
  715.    case BFT_Sprite:   return sizeof (XSpriteExportFilter);
  716.    case BFT_Targa:    return sizeof (XTargaExportFilter);
  717.    case BFT_TIFF:     return sizeof (XTIFFExportFilter);
  718.    case BFT_XBitmap:  return sizeof (XXBitmapExportFilter);
  719.    case BFT_YUV12C:   return sizeof (XYUV12CExportFilter);
  720.    default:           return sizeof (XBitmapFilter);
  721.    }
  722. }
  723.  
  724. ULONG InitBitmapImportFilter (XBitmapFilter* generic, char* filename) {
  725.    XBitmapImportFilter* param = (XBitmapImportFilter*) generic;
  726.    param->uIndex          = 0;
  727.    param->cInversionMode  = BFP_BITMAP_INVERSE_NOTHING;
  728.    return BFE_OK;
  729. }
  730.  
  731. ULONG InitBitmapExportFilter (XBitmapFilter* generic, char* filename) {
  732.    XBitmapExportFilter* param = (XBitmapExportFilter*) generic;
  733.    param->cVersion        = BFP_BITMAP_WINDOWS;
  734.    param->cInversionMode  = BFP_BITMAP_INVERSE_NOTHING;
  735.    return BFE_OK;
  736. }
  737.  
  738. ULONG InitGEMImportFilter (XBitmapFilter* generic, char* filename) {
  739.    XGEMImportFilter* param = (XGEMImportFilter*) generic;
  740.    return BFE_OK;
  741. }
  742.  
  743. ULONG InitGEMExportFilter (XBitmapFilter* generic, char* filename) {
  744.    XGEMExportFilter* param = (XGEMExportFilter*) generic;
  745.    param->fGreyscaled     = FALSE;
  746.    param->fWritePalette   = FALSE;
  747.    param->uPixelWidth     = 85;
  748.    param->uPixelHeight    = 85;
  749.    return BFE_OK;
  750. }
  751.  
  752. ULONG InitGIFImportFilter (XBitmapFilter* generic, char* filename) {
  753.    XGIFImportFilter* param = (XGIFImportFilter*) generic;
  754.    param->uIndex          = 0;
  755.    param->fIgnoreErrors   = TRUE;
  756.    return BFE_OK;
  757. }
  758.  
  759. ULONG InitGIFExportFilter (XBitmapFilter* generic, char* filename) {
  760.    XGIFExportFilter* param = (XGIFExportFilter*) generic;
  761.    param->fInterlaced     = FALSE;
  762.    param->cTransColor     = BFP_GIF_TRANSCOLOR_NONE;
  763.    param->cBackColor      = 0;
  764.    param->ulPosX          = 0;
  765.    param->ulPosY          = 0;
  766.    param->ulScreenWidth   = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN);
  767.    param->ulScreenHeight  = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN);
  768.    return BFE_OK;
  769. }
  770.  
  771. ULONG InitGreymapImportFilter (XBitmapFilter* generic, char* filename) {
  772.    XGreymapImportFilter* param = (XGreymapImportFilter*) generic;
  773.    param->cShadingType    = BFP_GREYMAP_GREY_SHADE;
  774.    return BFE_OK;
  775. }
  776.  
  777. ULONG InitGreymapExportFilter (XBitmapFilter* generic, char* filename) {
  778.    XGreymapExportFilter* param = (XGreymapExportFilter*) generic;
  779.    return BFE_OK;
  780. }
  781.  
  782. ULONG InitIAXImportFilter (XBitmapFilter* generic, char* filename) {
  783.    XIAXImportFilter* param = (XIAXImportFilter*) generic;
  784.    param->cShadingType    = BFP_GREYMAP_GREY_SHADE;
  785.    param->ulWidth         = 512;
  786.    return BFE_OK;
  787. }
  788.  
  789. ULONG InitIAXExportFilter (XBitmapFilter* generic, char* filename) {
  790.    XIAXExportFilter* param = (XIAXExportFilter*) generic;
  791.    return BFE_OK;
  792. }
  793.  
  794. ULONG InitILBMImportFilter (XBitmapFilter* generic, char* filename) {
  795.    XILBMImportFilter* param = (XILBMImportFilter*) generic;
  796.    return BFE_OK;
  797. }
  798.  
  799. ULONG InitILBMExportFilter (XBitmapFilter* generic, char* filename) {
  800.    XILBMExportFilter* param = (XILBMExportFilter*) generic;
  801.    param->cTransColor     = BFP_ILBM_TRANSCOLOR_NONE;
  802.    param->fHAM6           = FALSE;
  803.    param->ulPosX          = 0;
  804.    param->ulPosY          = 0;
  805.    param->ulScreenWidth   = WinQuerySysValue (HWND_DESKTOP, SV_CXSCREEN);
  806.    param->ulScreenHeight  = WinQuerySysValue (HWND_DESKTOP, SV_CYSCREEN);
  807.    param->uXAspect        = 1.0;
  808.    param->uYAspect        = 1.0;
  809.    return BFE_OK;
  810. }
  811.  
  812. ULONG InitJPEGImportFilter (XBitmapFilter* generic, char* filename) {
  813.    XJPEGImportFilter* param = (XJPEGImportFilter*) generic;
  814.    return BFE_OK;
  815. }
  816.  
  817. ULONG InitJPEGExportFilter (XBitmapFilter* generic, char* filename) {
  818.    XJPEGExportFilter* param = (XJPEGExportFilter*) generic;
  819.    param->cQuality        = 75;
  820.    param->fProgressive    = FALSE;
  821.    return BFE_OK;
  822. }
  823.  
  824. ULONG InitKIPSImportFilter (XBitmapFilter* generic, char* filename) {
  825.    XKIPSImportFilter* param = (XKIPSImportFilter*) generic;
  826.    char tmpFN [strlen (filename)]; 
  827.    FILE* tmpFile;
  828.  
  829.    strcpy (tmpFN, filename);
  830.    strcpy (strrchr (tmpFN, '.'), ".kpl");
  831.    if (NULL != (tmpFile = fopen (tmpFN, "r"))) {
  832.       param->cPaletteFileExtension = BFP_KIPS_KPL_EXTENSION;
  833.       fclose (tmpFile);
  834.    } else
  835.       param->cPaletteFileExtension = BFP_KIPS_PAL_EXTENSION;
  836.  
  837.    return BFE_OK;
  838. }
  839.  
  840. ULONG InitKIPSExportFilter (XBitmapFilter* generic, char* filename) {
  841.    XKIPSExportFilter* param = (XKIPSExportFilter*) generic;
  842.    param->cPaletteFileExtension = BFP_KIPS_PAL_EXTENSION;
  843.    return BFE_OK;
  844. }
  845.  
  846. ULONG InitPCXImportFilter (XBitmapFilter* generic, char* filename) {
  847.    XPCXImportFilter* param = (XPCXImportFilter*) generic;
  848.    param->fFixLines       = TRUE;
  849.    return BFE_OK;
  850. }
  851.  
  852. ULONG InitPCXExportFilter (XBitmapFilter* generic, char* filename) {
  853.    XPCXExportFilter* param = (XPCXExportFilter*) generic;
  854.    return BFE_OK;
  855. }
  856.  
  857. ULONG InitPixmapImportFilter (XBitmapFilter* generic, char* filename) {
  858.    XPixmapImportFilter* param = (XPixmapImportFilter*) generic;
  859.    return BFE_OK;
  860. }
  861.  
  862. ULONG InitPixmapExportFilter (XBitmapFilter* generic, char* filename) {
  863.    XPixmapExportFilter* param = (XPixmapExportFilter*) generic;
  864.    return BFE_OK;
  865. }
  866.  
  867. ULONG InitPortraitImportFilter (XBitmapFilter* generic, char* filename) {
  868.    XPortraitImportFilter* param = (XPortraitImportFilter*) generic;
  869.    return BFE_OK;
  870. }
  871.  
  872. ULONG InitPortraitExportFilter (XBitmapFilter* generic, char* filename) {
  873.    XPortraitExportFilter* param = (XPortraitExportFilter*) generic;
  874.    return BFE_OK;
  875. }
  876.  
  877. ULONG InitPSegImportFilter (XBitmapFilter* generic, char* filename) {
  878.    XPSegImportFilter* param = (XPSegImportFilter*) generic;
  879.    param->fFixRecords     = TRUE;
  880.    return BFE_OK;
  881. }
  882.  
  883. ULONG InitPSegExportFilter (XBitmapFilter* generic, char* filename) {
  884.    XPSegExportFilter* param = (XPSegExportFilter*) generic;
  885.    param->fDoubleSized    = FALSE;
  886.    return BFE_OK;
  887. }
  888.  
  889. ULONG InitSpriteImportFilter (XBitmapFilter* generic, char* filename) {
  890.    XSpriteImportFilter* param = (XSpriteImportFilter*) generic;
  891.    param->uIndex          = 0;
  892.    return BFE_OK;
  893. }
  894.  
  895. ULONG InitSpriteExportFilter (XBitmapFilter* generic, char* filename) {
  896.    XSpriteExportFilter* param = (XSpriteExportFilter*) generic;
  897.    return BFE_OK;
  898. }
  899.  
  900. ULONG InitTargaImportFilter (XBitmapFilter* generic, char* filename) {
  901.    XTargaImportFilter* param = (XTargaImportFilter*) generic;
  902.    return BFE_OK;
  903. }
  904.  
  905. ULONG InitTargaExportFilter (XBitmapFilter* generic, char* filename) {
  906.    XTargaExportFilter* param = (XTargaExportFilter*) generic;
  907.    param->cDirection      = BFP_TARGA_START_AT_BOTTOM;
  908.    return BFE_OK;
  909. }
  910.  
  911. ULONG InitTIFFImportFilter (XBitmapFilter* generic, char* filename) {
  912.    XTIFFImportFilter* param = (XTIFFImportFilter*) generic;
  913.    param->uIndex          = 0;
  914.    return BFE_OK;
  915. }
  916.  
  917. ULONG InitTIFFExportFilter (XBitmapFilter* generic, char* filename) {
  918.    XTIFFExportFilter* param = (XTIFFExportFilter*) generic;
  919.    int n;
  920.  
  921.    param->fLZW            = FALSE;
  922.    param->fMonoPal        = FALSE;
  923.  
  924.    for (n = 0; n < BFP_TIFF_TAGCOUNT; n++) param->pszTagValue [n] = NULL;
  925.    param->pszTagValue [BFP_TIFF_SOFTWARE] = strdup ("OOLGLIB 1.0 for GBM");
  926.  
  927.    return BFE_OK;
  928. }
  929.  
  930. ULONG InitXBitmapImportFilter (XBitmapFilter* generic, char* filename) {
  931.    XXBitmapImportFilter* param = (XXBitmapImportFilter*) generic;
  932.    return BFE_OK;
  933. }
  934.  
  935. ULONG InitXBitmapExportFilter (XBitmapFilter* generic, char* filename) {
  936.    XXBitmapExportFilter* param = (XXBitmapExportFilter*) generic;
  937.    return BFE_OK;
  938. }
  939.  
  940. ULONG InitYUV12CImportFilter (XBitmapFilter* generic, char* filename) {
  941.    XYUV12CImportFilter* param = (XYUV12CImportFilter*) generic;
  942.    return BFE_OK;
  943. }
  944.  
  945. ULONG InitYUV12CExportFilter (XBitmapFilter* generic, char* filename) {
  946.    XYUV12CExportFilter* param = (XYUV12CExportFilter*) generic;
  947.    param->ulPosX          = 0;
  948.    param->ulPosY          = 0;
  949.    return BFE_OK;
  950. }
  951.  
  952. ULONG CheckBitmapImportFilter (XBitmapFilter* generic) {
  953.    XBitmapImportFilter* param = (XBitmapImportFilter*) generic;
  954.    if (param->cInversionMode > BFP_BITMAP_INVERSE_BITMAP) returnUL (BFE_INVALID_INVERSION);
  955.    return BFE_OK;
  956. }
  957.  
  958. ULONG CheckBitmapExportFilter (XBitmapFilter* generic) {
  959.    XBitmapExportFilter* param = (XBitmapExportFilter*) generic;
  960.    if (param->cVersion != BFP_BITMAP_OS2_11 &&
  961.        param->cVersion != BFP_BITMAP_OS2_20 &&
  962.        param->cVersion != BFP_BITMAP_WINDOWS) returnUL (BFE_INVALID_BITMAP_VERSION);
  963.    if (param->cInversionMode > BFP_BITMAP_INVERSE_BITMAP) returnUL (BFE_INVALID_INVERSION);
  964.    return BFE_OK;
  965. }
  966.  
  967. ULONG CheckGEMImportFilter (XBitmapFilter* generic) {
  968.    XGEMImportFilter* param = (XGEMImportFilter*) generic;
  969.    return BFE_OK;
  970. }
  971.  
  972. ULONG CheckGEMExportFilter (XBitmapFilter* generic) {
  973.    XGEMExportFilter* param = (XGEMExportFilter*) generic;
  974.    return BFE_OK;
  975. }
  976.  
  977. ULONG CheckGIFImportFilter (XBitmapFilter* generic) {
  978.    XGIFImportFilter* param = (XGIFImportFilter*) generic;
  979.    return BFE_OK;
  980. }
  981.  
  982. ULONG CheckGIFExportFilter (XBitmapFilter* generic) {
  983.    XGIFExportFilter* param = (XGIFExportFilter*) generic;
  984.    if (param->cTransColor < BFP_GIF_TRANSCOLOR_NONE ||
  985.        param->cTransColor > (1 << param->cBitCount) - 1) 
  986.       returnUL (BFE_INVALID_COLOR_INDEX);
  987.    return BFE_OK;
  988. }
  989.  
  990. ULONG CheckGreymapImportFilter (XBitmapFilter* generic) {
  991.    XGreymapImportFilter* param = (XGreymapImportFilter*) generic;
  992.    if (param->cShadingType != BFP_GREYMAP_GREY_SHADE &&
  993.        param->cShadingType != BFP_GREYMAP_RED_SHADE &&
  994.        param->cShadingType != BFP_GREYMAP_GREEN_SHADE &&
  995.        param->cShadingType != BFP_GREYMAP_BLUE_SHADE)  returnUL (BFE_INVALID_SHADE);
  996.    return BFE_OK;
  997. }
  998.  
  999. ULONG CheckGreymapExportFilter (XBitmapFilter* generic) {
  1000.    XGreymapExportFilter* param = (XGreymapExportFilter*) generic;
  1001.    return BFE_OK;
  1002. }
  1003.  
  1004. ULONG CheckIAXImportFilter (XBitmapFilter* generic) {
  1005.    XIAXImportFilter* param = (XIAXImportFilter*) generic;
  1006.    if (param->cShadingType != BFP_IAX_GREY_SHADE &&
  1007.        param->cShadingType != BFP_IAX_RED_SHADE &&
  1008.        param->cShadingType != BFP_IAX_GREEN_SHADE &&
  1009.        param->cShadingType != BFP_IAX_BLUE_SHADE)  returnUL (BFE_INVALID_SHADE);
  1010.    return BFE_OK;
  1011. }
  1012.  
  1013. ULONG CheckIAXExportFilter (XBitmapFilter* generic) {
  1014.    XIAXExportFilter* param = (XIAXExportFilter*) generic;
  1015.    return BFE_OK;
  1016. }
  1017.  
  1018. ULONG CheckILBMImportFilter (XBitmapFilter* generic) {
  1019.    XILBMImportFilter* param = (XILBMImportFilter*) generic;
  1020.    return BFE_OK;
  1021. }
  1022.  
  1023. ULONG CheckILBMExportFilter (XBitmapFilter* generic) {
  1024.    XILBMExportFilter* param = (XILBMExportFilter*) generic;
  1025.    if (param->cTransColor < BFP_ILBM_TRANSCOLOR_NONE ||
  1026.        param->cTransColor > (1 << param->cBitCount) - 1) 
  1027.       returnUL (BFE_INVALID_COLOR_INDEX);
  1028.    return BFE_OK;
  1029. }
  1030.  
  1031. ULONG CheckJPEGImportFilter (XBitmapFilter* generic) {
  1032.    XJPEGImportFilter* param = (XJPEGImportFilter*) generic;
  1033.    return BFE_OK;
  1034. }
  1035.  
  1036. ULONG CheckJPEGExportFilter (XBitmapFilter* generic) {
  1037.    XJPEGExportFilter* param = (XJPEGExportFilter*) generic;
  1038.    if (param->cQuality > 100) returnUL (BFE_INVALID_QUALITY);
  1039.    return BFE_OK;
  1040. }
  1041.  
  1042. ULONG CheckKIPSImportFilter (XBitmapFilter* generic) {
  1043.    XKIPSImportFilter* param = (XKIPSImportFilter*) generic;
  1044.    if (param->cPaletteFileExtension > BFP_KIPS_KPL_EXTENSION) returnUL (BFE_INVALID_EXTENSION);
  1045.    return BFE_OK;
  1046. }
  1047.  
  1048. ULONG CheckKIPSExportFilter (XBitmapFilter* generic) {
  1049.    XKIPSExportFilter* param = (XKIPSExportFilter*) generic;
  1050.    if (param->cPaletteFileExtension > BFP_KIPS_KPL_EXTENSION) returnUL (BFE_INVALID_EXTENSION);
  1051.    return BFE_OK;
  1052. }
  1053.  
  1054. ULONG CheckPCXImportFilter (XBitmapFilter* generic) {
  1055.    XPCXImportFilter* param = (XPCXImportFilter*) generic;
  1056.    return BFE_OK;
  1057. }
  1058.  
  1059. ULONG CheckPCXExportFilter (XBitmapFilter* generic) {
  1060.    XPCXExportFilter* param = (XPCXExportFilter*) generic;
  1061.    return BFE_OK;
  1062. }
  1063.  
  1064. ULONG CheckPixmapImportFilter (XBitmapFilter* generic) {
  1065.    XPixmapImportFilter* param = (XPixmapImportFilter*) generic;
  1066.    return BFE_OK;
  1067. }
  1068.  
  1069. ULONG CheckPixmapExportFilter (XBitmapFilter* generic) {
  1070.    XPixmapExportFilter* param = (XPixmapExportFilter*) generic;
  1071.    return BFE_OK;
  1072. }
  1073.  
  1074. ULONG CheckPortraitImportFilter (XBitmapFilter* generic) {
  1075.    XPortraitImportFilter* param = (XPortraitImportFilter*) generic;
  1076.    return BFE_OK;
  1077. }
  1078.  
  1079. ULONG CheckPortraitExportFilter (XBitmapFilter* generic) {
  1080.    XPortraitExportFilter* param = (XPortraitExportFilter*) generic;
  1081.    return BFE_OK;
  1082. }
  1083.  
  1084. ULONG CheckPSegImportFilter (XBitmapFilter* generic) {
  1085.    XPSegImportFilter* param = (XPSegImportFilter*) generic;
  1086.    return BFE_OK;
  1087. }
  1088.  
  1089. ULONG CheckPSegExportFilter (XBitmapFilter* generic) {
  1090.    XPSegExportFilter* param = (XPSegExportFilter*) generic;
  1091.    return BFE_OK;
  1092. }
  1093.  
  1094. ULONG CheckSpriteImportFilter (XBitmapFilter* generic) {
  1095.    XSpriteImportFilter* param = (XSpriteImportFilter*) generic;
  1096.    return BFE_OK;
  1097. }
  1098.  
  1099. ULONG CheckSpriteExportFilter (XBitmapFilter* generic) {
  1100.    XSpriteExportFilter* param = (XSpriteExportFilter*) generic;
  1101.    return BFE_OK;
  1102. }
  1103.  
  1104. ULONG CheckTargaImportFilter (XBitmapFilter* generic) {
  1105.    XTargaImportFilter* param = (XTargaImportFilter*) generic;
  1106.    return BFE_OK;
  1107. }
  1108.  
  1109. ULONG CheckTargaExportFilter (XBitmapFilter* generic) {
  1110.    XTargaExportFilter* param = (XTargaExportFilter*) generic;
  1111.    if (param->cDirection != BFP_TARGA_START_AT_BOTTOM &&
  1112.        param->cDirection != BFP_TARGA_START_AT_TOP) returnUL (BFE_INVALID_DIRECTION);
  1113.    return BFE_OK;
  1114. }
  1115.  
  1116. ULONG CheckTIFFImportFilter (XBitmapFilter* generic) {
  1117.    XTIFFImportFilter* param = (XTIFFImportFilter*) generic;
  1118.    return BFE_OK;
  1119. }
  1120.  
  1121. ULONG CheckTIFFExportFilter (XBitmapFilter* generic) {
  1122.    XTIFFExportFilter* param = (XTIFFExportFilter*) generic;
  1123.    return BFE_OK;
  1124. }
  1125.  
  1126. ULONG CheckXBitmapImportFilter (XBitmapFilter* generic) {
  1127.    XXBitmapImportFilter* param = (XXBitmapImportFilter*) generic;
  1128.    return BFE_OK;
  1129. }
  1130.  
  1131. ULONG CheckXBitmapExportFilter (XBitmapFilter* generic) {
  1132.    XXBitmapExportFilter* param = (XXBitmapExportFilter*) generic;
  1133.    return BFE_OK;
  1134. }
  1135.  
  1136. ULONG CheckYUV12CImportFilter (XBitmapFilter* generic) {
  1137.    XYUV12CImportFilter* param = (XYUV12CImportFilter*) generic;
  1138.    return BFE_OK;
  1139. }
  1140.  
  1141. ULONG CheckYUV12CExportFilter (XBitmapFilter* generic) {
  1142.    XYUV12CExportFilter* param = (XYUV12CExportFilter*) generic;
  1143.    return BFE_OK;
  1144. }
  1145.  
  1146. PSZ GetBitmapImportFilterString (XBitmapFilter* generic) {
  1147.    XBitmapImportFilter* param = (XBitmapImportFilter*) generic;
  1148.     sprintf (__XGLIBpstr__, "index=%i", param->uIndex);
  1149.     switch (param->cInversionMode) {
  1150.       case BFP_BITMAP_INVERSE_PALETTE: strcat (__XGLIBpstr__, " inv"); break;
  1151.       case BFP_BITMAP_INVERSE_BITMAP:  strcat (__XGLIBpstr__, " invb"); break;
  1152.       }
  1153.       return __XGLIBpstr__;
  1154. }
  1155.  
  1156. PSZ GetBitmapExportFilterString (XBitmapFilter* generic) {
  1157.    XBitmapExportFilter* param = (XBitmapExportFilter*) generic;
  1158.     sprintf (__XGLIBpstr__, "%s", param->cVersion == BFP_BITMAP_OS2_11 ? "1.1" : "2.0");
  1159.     switch (param->cInversionMode) {
  1160.       case BFP_BITMAP_INVERSE_PALETTE:    strcat (__XGLIBpstr__, " inv"); break;
  1161.       case BFP_BITMAP_INVERSE_BITMAP:    strcat (__XGLIBpstr__, " invb"); break;
  1162.       case BFP_BITMAP_FORCE_DARKFG:        strcat (__XGLIBpstr__, " darkfg"); break;
  1163.       case BFP_BITMAP_FORCE_LIGHTFG:    strcat (__XGLIBpstr__, " lightfg"); break;
  1164.       }
  1165.       return __XGLIBpstr__;
  1166. }
  1167.  
  1168. PSZ GetGEMImportFilterString (XBitmapFilter* generic) {
  1169.    XGEMImportFilter* param = (XGEMImportFilter*) generic;
  1170.    return "";
  1171. }
  1172.  
  1173. PSZ GetGEMExportFilterString (XBitmapFilter* generic) {
  1174.    XGEMExportFilter* param = (XGEMExportFilter*) generic;
  1175.    sprintf (__XGLIBpstr__, "pixw=%u pixh=%u%s%s", param->uPixelWidth, param->uPixelHeight,
  1176.       param->fGreyscaled ? "grey" : "", param->fWritePalette ? "pal" : "");
  1177.     return __XGLIBpstr__;
  1178. }
  1179.  
  1180. PSZ GetGIFImportFilterString (XBitmapFilter* generic) {
  1181.    XGIFImportFilter* param = (XGIFImportFilter*) generic;
  1182.     sprintf (__XGLIBpstr__, "index=%i%s", param->uIndex, 
  1183.          param->fIgnoreErrors ? " errok" : "");
  1184.     return __XGLIBpstr__;
  1185. }
  1186.  
  1187. PSZ GetGIFExportFilterString (XBitmapFilter* generic) {
  1188.    XGIFExportFilter* param = (XGIFExportFilter*) generic;
  1189.    char transStr [15];
  1190.     sprintf (transStr, BFP_GIF_TRANSCOLOR_NONE == param->cTransColor ? "" :
  1191.       (BFP_GIF_TRANSCOLOR_EDGE == param->cTransColor ? " transcol=edge" : " transcol=%u"), 
  1192.       param->cTransColor);
  1193.  
  1194.     sprintf (__XGLIBpstr__, "xscreen=%u yscreen=%u background=%u xpos=%u ypos=%u%s%s",
  1195.          param->ulScreenWidth, param->ulScreenHeight, param->cBackColor,
  1196.       param->ulPosX, param->ulPosY, param->fInterlaced ? " ilace" : "", transStr);
  1197.     return __XGLIBpstr__;
  1198. }
  1199.  
  1200. PSZ GetGreymapImportFilterString (XBitmapFilter* generic) {
  1201.    XGreymapImportFilter* param = (XGreymapImportFilter*) generic;
  1202.     sprintf (__XGLIBpstr__, "%c", param->cShadingType);
  1203.     return __XGLIBpstr__;
  1204. }
  1205.  
  1206. PSZ GetGreymapExportFilterString (XBitmapFilter* generic) {
  1207.    XGreymapExportFilter* param = (XGreymapExportFilter*) generic;
  1208.    switch (param->cPalette) {
  1209.    case BFP_PALETTE_GREYSCALE:  strcpy (__XGLIBpstr__, "k"); break;
  1210.    case BFP_PALETTE_REDSCALE:   strcpy (__XGLIBpstr__, "r"); break;
  1211.    case BFP_PALETTE_GREENSCALE: strcpy (__XGLIBpstr__, "g"); break;
  1212.    case BFP_PALETTE_BLUESCALE:  strcpy (__XGLIBpstr__, "b"); break;
  1213.    }
  1214.     return __XGLIBpstr__;
  1215. }
  1216.  
  1217. PSZ GetIAXImportFilterString (XBitmapFilter* generic) {
  1218.    XIAXImportFilter* param = (XIAXImportFilter*) generic;
  1219.     sprintf (__XGLIBpstr__, "WIDTH=%u %c", param->ulWidth, param->cShadingType);
  1220.     return __XGLIBpstr__;
  1221. }
  1222.  
  1223. PSZ GetIAXExportFilterString (XBitmapFilter* generic) {
  1224.    XIAXExportFilter* param = (XIAXExportFilter*) generic;
  1225.    switch (param->cPalette) {
  1226.    case BFP_PALETTE_GREYSCALE:  strcpy (__XGLIBpstr__, "k"); break;
  1227.    case BFP_PALETTE_REDSCALE:   strcpy (__XGLIBpstr__, "r"); break;
  1228.    case BFP_PALETTE_GREENSCALE: strcpy (__XGLIBpstr__, "g"); break;
  1229.    case BFP_PALETTE_BLUESCALE:  strcpy (__XGLIBpstr__, "b"); break;
  1230.    }
  1231.     return __XGLIBpstr__;
  1232. }
  1233.  
  1234. PSZ GetILBMImportFilterString (XBitmapFilter* generic) {
  1235.    XILBMImportFilter* param = (XILBMImportFilter*) generic;
  1236.    return "";
  1237. }
  1238.  
  1239. PSZ GetILBMExportFilterString (XBitmapFilter* generic) {
  1240.    XILBMExportFilter* param = (XILBMExportFilter*) generic;
  1241.     sprintf (__XGLIBpstr__, "xpos=%u ypos=%u transcol=%u xaspect=%f yaspect=%f"
  1242.        "xscreen=%u yscreen=%u %s",
  1243.          param->ulScreenWidth, param->ulScreenHeight, param->cTransColor,
  1244.         param->uXAspect, param->uYAspect, param->ulPosX, param->ulPosY, param->fHAM6 ? " ham6" : "");
  1245.     return __XGLIBpstr__;
  1246. }
  1247.  
  1248. PSZ GetJPEGImportFilterString (XBitmapFilter* generic) {
  1249.    XJPEGImportFilter* param = (XJPEGImportFilter*) generic;
  1250.    return "";
  1251. }
  1252.  
  1253. PSZ GetJPEGExportFilterString (XBitmapFilter* generic) {
  1254.    XJPEGExportFilter* param = (XJPEGExportFilter*) generic;
  1255.     sprintf (__XGLIBpstr__, "quality=%d%s", param->cQuality, 
  1256.         param->fProgressive ? " prog" : "");
  1257.     return __XGLIBpstr__;
  1258. }
  1259.  
  1260. PSZ GetKIPSImportFilterString (XBitmapFilter* generic) {
  1261.    XKIPSImportFilter* param = (XKIPSImportFilter*) generic;
  1262.    return (BFP_KIPS_KPL_EXTENSION == param->cPaletteFileExtension ? "kpl" : "pal");
  1263. }
  1264.  
  1265. PSZ GetKIPSExportFilterString (XBitmapFilter* generic) {
  1266.    XKIPSExportFilter* param = (XKIPSExportFilter*) generic;
  1267.    return (BFP_KIPS_KPL_EXTENSION == param->cPaletteFileExtension ? "kpl" : "pal");
  1268. }
  1269.  
  1270. PSZ GetPCXImportFilterString (XBitmapFilter* generic) {
  1271.    XPCXImportFilter* param = (XPCXImportFilter*) generic;
  1272.     return (param->fFixLines ? "trunc" : "");
  1273. }
  1274.  
  1275. PSZ GetPCXExportFilterString (XBitmapFilter* generic) {
  1276.    XPCXExportFilter* param = (XPCXExportFilter*) generic;
  1277.    return "";
  1278. }
  1279.  
  1280. PSZ GetPixmapImportFilterString (XBitmapFilter* generic) {
  1281.    XPixmapImportFilter* param = (XPixmapImportFilter*) generic;
  1282.    return "";
  1283. }
  1284.  
  1285. PSZ GetPixmapExportFilterString (XBitmapFilter* generic) {
  1286.    XPixmapExportFilter* param = (XPixmapExportFilter*) generic;
  1287.    return "";
  1288. }
  1289.  
  1290. PSZ GetPortraitImportFilterString (XBitmapFilter* generic) {
  1291.    XPortraitImportFilter* param = (XPortraitImportFilter*) generic;
  1292.    return "";
  1293. }
  1294.  
  1295. PSZ GetPortraitExportFilterString (XBitmapFilter* generic) {
  1296.    XPortraitExportFilter* param = (XPortraitExportFilter*) generic;
  1297.    return "";
  1298. }
  1299.  
  1300. PSZ GetPSegImportFilterString (XBitmapFilter* generic) {
  1301.    XPSegImportFilter* param = (XPSegImportFilter*) generic;
  1302.     return (param->fFixRecords ? "fixrec" : "");
  1303. }
  1304.  
  1305. PSZ GetPSegExportFilterString (XBitmapFilter* generic) {
  1306.    XPSegExportFilter* param = (XPSegExportFilter*) generic;
  1307.     return (param->fDoubleSized ? "double" : "");
  1308.    return "";
  1309. }
  1310.  
  1311. PSZ GetSpriteImportFilterString (XBitmapFilter* generic) {
  1312.    XSpriteImportFilter* param = (XSpriteImportFilter*) generic;
  1313.     sprintf (__XGLIBpstr__, "index=%i", param->uIndex);
  1314.     return __XGLIBpstr__;
  1315. }
  1316.  
  1317. PSZ GetSpriteExportFilterString (XBitmapFilter* generic) {
  1318.    XSpriteExportFilter* param = (XSpriteExportFilter*) generic;
  1319.    return "";
  1320. }
  1321.  
  1322. PSZ GetTargaImportFilterString (XBitmapFilter* generic) {
  1323.    XTargaImportFilter* param = (XTargaImportFilter*) generic;
  1324.    return "";
  1325. }
  1326.  
  1327. PSZ GetTargaExportFilterString (XBitmapFilter* generic) {
  1328.    XTargaExportFilter* param = (XTargaExportFilter*) generic;
  1329.     sprintf (__XGLIBpstr__, "%d%s", 
  1330.         16 >= param->cBitCount ? 16 : (24 >= param->cBitCount ? 24 : 32),
  1331.         BFP_TARGA_START_AT_BOTTOM == param->cDirection ? " up" : " down");
  1332.     return __XGLIBpstr__;
  1333. }
  1334.  
  1335. PSZ GetTIFFImportFilterString (XBitmapFilter* generic) {
  1336.    XTIFFImportFilter* param = (XTIFFImportFilter*) generic;
  1337.     sprintf (__XGLIBpstr__, "index=%i", param->uIndex);
  1338.     return __XGLIBpstr__;
  1339. }
  1340.  
  1341. #define AddTag(tag, name) if (NULL != param->pszTagValue [tag] && \
  1342.    strlen (param->pszTagValue [tag])) { \
  1343.    if (strlen (__XGLIBpstr__) + strlen (name) + \
  1344.       strlen (param->pszTagValue [tag]) >= __XGLIBpstrLen__) \
  1345.       return __XGLIBpstr__; \
  1346.    strcat (__XGLIBpstr__, name); \
  1347.    strcat (__XGLIBpstr__, param->pszTagValue [tag]); \
  1348. }
  1349.  
  1350. PSZ GetTIFFExportFilterString (XBitmapFilter* generic) {
  1351.    XTIFFExportFilter* param = (XTIFFExportFilter*) generic;
  1352.     sprintf (__XGLIBpstr__, "%s%s", param->fLZW ? "lzw" : "", param->fMonoPal ? " pal1bpp" : "");
  1353.    AddTag (BFP_TIFF_ARTIST,      " artist=");
  1354.    AddTag (BFP_TIFF_SOFTWARE,    " software=");
  1355. /*   AddTag (BFP_TIFF_MAKE,        " make="); */
  1356.    AddTag (BFP_TIFF_MODEL,       " model=");
  1357.    AddTag (BFP_TIFF_HOST,        " hostcomputer=");
  1358.    AddTag (BFP_TIFF_DOCNAME,     " documentname=");
  1359.    AddTag (BFP_TIFF_PAGENAME,    " pagename=");
  1360.    AddTag (BFP_TIFF_DESCRIPTION, " imagedescription=");
  1361.    return __XGLIBpstr__;
  1362. }
  1363.  
  1364. #undef AddTag
  1365.  
  1366. PSZ GetXBitmapImportFilterString (XBitmapFilter* generic) {
  1367.    XXBitmapImportFilter* param = (XXBitmapImportFilter*) generic;
  1368.    return "";
  1369. }
  1370.  
  1371. PSZ GetXBitmapExportFilterString (XBitmapFilter* generic) {
  1372.    XXBitmapExportFilter* param = (XXBitmapExportFilter*) generic;
  1373.    return "";
  1374. }
  1375.  
  1376. PSZ GetYUV12CImportFilterString (XBitmapFilter* generic) {
  1377.    XYUV12CImportFilter* param = (XYUV12CImportFilter*) generic;
  1378.    return "";
  1379. }
  1380.  
  1381. PSZ GetYUV12CExportFilterString (XBitmapFilter* generic) {
  1382.    XYUV12CExportFilter* param = (XYUV12CExportFilter*) generic;
  1383.     sprintf (__XGLIBpstr__, "xpos=%u ypos=%u", param->ulPosX, param->ulPosY);
  1384.     return __XGLIBpstr__;
  1385. }
  1386.  
  1387.  
  1388.