home *** CD-ROM | disk | FTP | other *** search
/ DTP Toolbox / DTPToolbox.iso / utilities / archiveutils / wmf.lha / src / amiga.c next >
Encoding:
C/C++ Source or Header  |  1995-12-04  |  11.2 KB  |  453 lines
  1. /* 
  2. * Amiga Graphics for Window Metafile Reader.
  3. *
  4. * $Log: amiga.c,v $
  5. *  Revision 1.9  1995/12/04  19:27:25  JFusco
  6. *  Added interlace flag to OpenScreen().
  7. *  Added debug statements.
  8. *
  9. *  Revision 1.8  1994/11/09  08:16:51  JFusco
  10. *  Does not print title if file is being saved.
  11. *
  12. *  Revision 1.7  1994/11/08  22:10:52  JFusco
  13. *  Added iff save.
  14. *
  15. *  Revision 1.6  1994/06/27  22:40:00  JFusco
  16. *  Reverted to 400x200 window for aspect ratio, which still needs work.
  17. *
  18. *  Revision 1.5  1994/06/26  18:03:53  JFusco
  19. *  Fixes color matching problems.
  20. *
  21. *  Revision 1.4  1994/06/25  02:28:03  JFusco
  22. *  Better fills (?).  Tries to match luminance of color values.
  23. *
  24. *  Revision 1.3  1994/06/20  23:22:21  JFusco
  25. *  Now does polygon filling (barely).
  26. *
  27. *  Revision 1.2  1994/06/19  22:59:55  JFusco
  28. *  Added still more machine dependent stuff.
  29. *
  30. *  Revision 1.1  1994/06/18  03:09:47  JFusco
  31. *  Initial revision
  32. *
  33. */
  34.  
  35. #include <stdio.h>
  36. #include <string.h>
  37. #undef memcmp
  38. #include <assert.h>
  39.  
  40. #define INTUI_V36_NAMES_ONLY
  41.  
  42. #include <exec/types.h>
  43. #include <exec/memory.h>
  44. #include <intuition/intuition.h>
  45. #include <graphics/copper.h>
  46. #include <graphics/display.h>
  47. #include <graphics/view.h>
  48. #include <time.h>
  49.  
  50. #include <clib/exec_protos.h>
  51. #include <clib/intuition_protos.h>
  52. #include <clib/graphics_protos.h>
  53.  
  54. #include "wmf.h"
  55. extern wmf_hdr_t FileHdr;
  56. extern char *filename, *savename;
  57.  
  58. #include "amiga.h"
  59.  
  60. #define ONE_TIME_WARNING(msg) { static warn=1;\
  61.   if (warn) {warn=0; fprintf(stderr,msg);}}
  62.  
  63. #ifdef DEBUG
  64. extern int RecCtr;
  65. #define DBGREC printf("RecCtr=%d\n",RecCtr)
  66. #else
  67. #define DBGREC
  68. #endif
  69.  
  70. static unsigned            numColors  = NUM_COLORS;
  71. static unsigned            ColorsUsed = 1;
  72. static RGB_color_t      ColorTable[NUM_COLORS];
  73.  
  74. #ifdef LATTICE
  75. int CXBRK(void)      {CleanExit(0);return 0;}
  76. /* void chkabort(void)  {return;} */
  77. #endif
  78.  
  79. struct Screen  *AmigaScreen = NULL;
  80. struct Window  *AmigaWindow = NULL;
  81. struct Library *IntuitionBase = NULL, *GfxBase = NULL;
  82.  
  83. static unsigned char *tmpRasBuf = NULL;
  84.  
  85. /* Virtual Window (for debug only) */
  86. extern short Top, Left, Bottom, Right;
  87.  
  88. /* Local Prototypes. */
  89. void OpenAmigaLibs();
  90. void GetCCIR( RGB_color_t *, unsigned long *, long *, long * );
  91. void OpenAmigaWindow();
  92. void SetRGBColor( RGB_color_t * );
  93.  
  94. void OpenAmigaLibs()
  95. {
  96.    if(!(IntuitionBase = OpenLibrary("intuition.library", 37L))) {
  97.       printf("Could not open intuition.library!\n");
  98.       exit(0);
  99.    }
  100.  
  101.    if(!(GfxBase = OpenLibrary("graphics.library",0))) {
  102.       printf("Could not open graphics.library!\n");
  103.       exit(0);
  104.    };
  105. } 
  106.  
  107. void CleanAmiga()
  108. {
  109.    int i;
  110. #ifdef DEBUG
  111.    printf("ColorsUsed=%d\n",ColorsUsed);
  112.    for(i=0;i<ColorsUsed;i++) {
  113.       printf("%2d r=%02x g=%02x b=%02x\n", i, 
  114.               ColorTable[i].Red, ColorTable[i].Green, ColorTable[i].Blue );
  115.    }
  116. #endif
  117.    if (tmpRasBuf) FreeMem( tmpRasBuf, BITPLANE_SIZE );
  118.    if (AmigaWindow)   CloseWindow(AmigaWindow);
  119.    if (AmigaScreen)   CloseScreen(AmigaScreen);
  120.    if (IntuitionBase) CloseLibrary(IntuitionBase);
  121.    if (GfxBase)       CloseLibrary(GfxBase);
  122. }
  123.  
  124. void OpenAmigaWindow()
  125. {
  126.    unsigned short *areabuffer = NULL;
  127.    static struct AreaInfo area_info;
  128.    static struct TmpRas tmp_ras;
  129.    static UWORD pens[] = { ~0 };
  130.    unsigned i;
  131.  
  132.    OpenAmigaLibs();
  133.  
  134.    AmigaScreen = OpenScreenTags( NULL,
  135.                                  SA_Width,      SCREENX,
  136.                                  SA_Height,     SCREENY,
  137.                                  SA_Depth,      SCREEN_DEPTH,
  138.                                  SA_Type,       CUSTOMSCREEN,
  139.                                  SA_Pens,       (ULONG) pens,
  140.                                  SA_DisplayID,  HIRES_KEY | LACE,
  141.                                  SA_Title,      filename,
  142.                                  SA_ShowTitle,  (ULONG)(savename==NULL),
  143.                                  TAG_DONE );
  144.    if (!(AmigaScreen)) {
  145.       perror("could not open screen.");
  146.       CleanAmiga();
  147.       exit(1);
  148.    };
  149.  
  150.    AmigaWindow = OpenWindowTags( NULL,
  151.                          WA_Left, 10,
  152.                          WA_Top, 10,
  153.                          WA_Width, WINDOWX,
  154.                          WA_Height, WINDOWY,
  155.                          WA_Borderless, TRUE,
  156.                          WA_Backdrop, TRUE,
  157.                          WA_CloseGadget, FALSE,
  158.                          WA_SizeGadget, TRUE,
  159.                          WA_DragBar, TRUE,
  160.                          WA_SmartRefresh, TRUE,
  161.                          WA_CustomScreen, AmigaScreen,
  162.                          WA_IDCMP, IDCMP_VANILLAKEY | IDCMP_MOUSEBUTTONS,
  163.                          TAG_DONE );
  164.  
  165.    if (!(AmigaWindow)) {
  166.       perror("could not open window.");
  167.       CleanAmiga();
  168.       exit(1);
  169.    };
  170.  
  171.    /* Default the color palette. */
  172.    for (i=0; i<numColors; i++) {
  173.       SetRGB4( &AmigaScreen->ViewPort, i,
  174.                (15-(i*(16/numColors))),
  175.                (15-(i*(16/numColors))),
  176.                (15-(i*(16/numColors))) );
  177.    }
  178.  
  179.    /* Set default value for pens and drawing mode. */
  180.    SetAPen(AmigaWindow->RPort,(numColors-1));
  181.    SetBPen(AmigaWindow->RPort,0);
  182.    SetDrMd(AmigaWindow->RPort,JAM2);
  183.  
  184.    /* Reserve pen 0 for background store 8-bit color regs. */
  185.    ColorTable[0].Type  = 0;
  186.    ColorTable[0].Red   = 0xff;
  187.    ColorTable[0].Green = 0xff;
  188.    ColorTable[0].Blue  = 0xff;
  189.    ColorsUsed = 1;
  190.  
  191.    /* Initialize AreaInfo - this should be way too much space! */
  192.    areabuffer = (unsigned short *) calloc(FileHdr.Largest, sizeof(unsigned short));
  193.    tmpRasBuf = AllocMem( BITPLANE_SIZE, MEMF_CLEAR | MEMF_CHIP );
  194.    assert( tmpRasBuf );
  195.    assert( areabuffer );
  196.    InitArea(&area_info, areabuffer,(FileHdr.Largest*sizeof(short))/5 ); 
  197.    InitTmpRas(&tmp_ras, tmpRasBuf, BITPLANE_SIZE );
  198.  
  199.    AmigaWindow->RPort->TmpRas = &tmp_ras;
  200.    AmigaWindow->RPort->AreaInfo = &area_info;
  201. }
  202.  
  203. MoveAmiga( short x, short y )
  204. {
  205.    Move( AmigaWindow->RPort, x, y );
  206. }
  207.  
  208. DrawAmiga( short x, short y )
  209. {
  210.    Draw( AmigaWindow->RPort, x, y );
  211. }
  212.  
  213. AmigaDelay( unsigned t )
  214. {
  215.    time_t time1;
  216.  
  217.    time1 = time(NULL);
  218.    while (time(NULL) - time1 < t);
  219. }
  220.  
  221. void AmigaWait()
  222. {
  223.    ULONG signalmask, signals = 0;
  224.  
  225.    signalmask = 1L << AmigaWindow->UserPort->mp_SigBit;
  226.  
  227.    while( !(signals & signalmask) ) {
  228.       signals = Wait(signalmask);
  229.    }
  230. }
  231.  
  232. void AmigaSave( char *fname )
  233. {
  234.    ScreenDump(AmigaScreen, fname);
  235. }
  236.  
  237. GetPixelAspect( int *x, int *y )
  238. {
  239.    /* Needs more, okay for now. */
  240.    if (INTERLACED) {
  241.       *x=1;
  242.       *y=1;
  243.    }
  244.    else {
  245.       *x=1;
  246.       *y=2;
  247.    }
  248. }
  249.  
  250. SetDrawingMode( unsigned short mode )
  251. {
  252.    switch( mode ) {
  253.    case 7:
  254.       DBGREC;
  255.       SetDrMd(AmigaWindow->RPort, JAM2 );
  256.       fprintf(stderr,"XOR drawing\n");
  257.       break;
  258.    case 13:
  259.       SetDrMd(AmigaWindow->RPort, JAM2 | INVERSVID);
  260.       break;
  261.    default:
  262.       DBGREC;
  263.       fprintf(stderr,"Unimplemented Drawing Mode %04hx\n", mode);
  264.       SetDrMd(AmigaWindow->RPort, JAM2 | INVERSVID);
  265.       break;
  266.    };
  267. }
  268.  
  269. PolygonMoveAmiga( short x, short y )
  270. {
  271.    AreaMove( AmigaWindow->RPort, x, y );
  272. }
  273.  
  274. PolygonDrawAmiga( short x, short y )
  275. {
  276.    AreaDraw( AmigaWindow->RPort, x, y );
  277. }
  278.  
  279. PolygonEndAmiga()
  280. {
  281.    if (AreaEnd( AmigaWindow->RPort ))
  282.    {
  283.       DBGREC;
  284.       fprintf(stderr,"Invalid area\n");
  285.    }
  286. }
  287.  
  288. SetBrushStyleAmiga( brush_t *Brush )
  289. {
  290.    SetRGBColor( &Brush->Color.RGB );
  291.    switch (Brush->Style) {
  292.    case 0: /* Solid */
  293.       SetDrMd(AmigaWindow->RPort,JAM2);
  294.       break;
  295.    case 1: /* Hollow */
  296.       SetDrMd(AmigaWindow->RPort,JAM2|COMPLEMENT);
  297.       break;
  298.    case 2:
  299.       ONE_TIME_WARNING("Cross hatched brush not supported\n");
  300.       break;
  301.    default:
  302.       ONE_TIME_WARNING("Unknown brush type.\n");
  303.       break;
  304.    }
  305. }
  306.  
  307. SetPenStyleAmiga( pen_t *Pen )
  308. {
  309.    static int warnings=0;
  310.    unsigned short pattern;
  311.  
  312.    if (Pen->Width>1) { 
  313.       ONE_TIME_WARNING("Only pen width of 1 supported.\n"); 
  314.    }
  315.  
  316.    switch( Pen->Style ) {
  317.    case 0:
  318.       pattern = 0xffff; /* Solid */
  319.       break;
  320.    case 1:
  321.       pattern = 0xcccc; /* Dashed */
  322.       break;
  323.    case 2:
  324.       pattern = 0xaaaa; /* Dotted */
  325.       break;
  326.    case 3:
  327.       pattern = 0xd6b5; /* Alternating Dot and Dash */
  328.       break;
  329.    case 4: 
  330.       pattern = 0xb5ad; /* Alternating Dash and two Dots */
  331.       break;
  332.    case 5: 
  333.       pattern = 0xffff; /* None ? */
  334.       break;
  335.    case 6:
  336.       /* Inside Frame. */
  337.       DBGREC;
  338.       fprintf(stderr,"Inside frame pen type is unimplemented.\n");
  339.       break;
  340.    default:
  341.       DBGREC;
  342.       fprintf(stderr,"Unrecognized pen style %hd assuming solid.\n",Pen->Style);
  343.       pattern = 0xffff;
  344.       break;
  345.    }
  346.    SetRGBColor( &Pen->Color.RGB );
  347. }
  348.  
  349. void SetRGBColor( RGB_color_t *Color )
  350. {
  351.    unsigned long lum, mlum;
  352.    long Cb, Cr, best, mCb, mCr, match, bestdiff;
  353.    unsigned idx, idx_match;
  354.  
  355.    if (Color->Type != 1) {
  356.  
  357.       /* Set to zero for memcmp. */
  358.       Color->Type = 0;
  359.  
  360.       /* Check to see if it's already in the color table. */
  361.       for( idx=0; idx<ColorsUsed; idx++) {
  362.  
  363.          if (memcmp( &ColorTable[idx], 
  364.                      Color, sizeof(RGB_color_t)) == 0 ) break;
  365.       }
  366.  
  367.       if (ColorsUsed && idx < ColorsUsed) {
  368.  
  369.          /* It's already in the color table. */
  370.          SetAPen(AmigaWindow->RPort,idx);
  371.       }
  372.  
  373.       else if ( ColorsUsed != numColors ) {
  374.  
  375.          /* Not in the color table, but there's room for a new entry. */
  376.          assert( ColorsUsed < numColors );
  377.          memcpy( &ColorTable[ColorsUsed], 
  378.                  Color, sizeof(RGB_color_t));
  379.          ColorTable[ColorsUsed].Type = 0;
  380.          SetRGB4( &AmigaScreen->ViewPort, 
  381.                   ColorsUsed,
  382.                   (ColorTable[ColorsUsed].Red   >> 4),
  383.                   (ColorTable[ColorsUsed].Green >> 4),
  384.                   (ColorTable[ColorsUsed].Blue  >> 4) );
  385.          SetAPen(AmigaWindow->RPort,ColorsUsed);
  386.          ColorsUsed++;
  387.       }
  388.  
  389.       else {
  390.  
  391.          /* Not in the table and there's no more room. */
  392.          /* Get the closest match.                     */
  393.          ONE_TIME_WARNING("Too many colors, will find closest match.\n");
  394.          GetCCIR( Color, &lum, &Cb, &Cr );
  395.  
  396.          for( idx=0; idx<ColorsUsed; idx++) {
  397.  
  398.             GetCCIR( &ColorTable[idx], &mlum, &mCb, &mCr );
  399.  
  400.         /* Compare the dot product of the two color 'vectors' */
  401.             match = lum * mlum + Cb * mCb + Cr * mCr;
  402.  
  403.             if (idx==0) {
  404.                idx_match = 0;
  405.                bestdiff = abs(match);
  406.                best = match;
  407.             }
  408.  
  409.             /* Take our best match and compare the difference. */
  410.         else if (bestdiff > abs(match-best)) {
  411.                idx_match = idx;
  412.            bestdiff = abs(match-best);
  413.                best = match;
  414.             }
  415.          }
  416.          SetAPen(AmigaWindow->RPort,idx_match);
  417.       }
  418.       SetBPen(AmigaWindow->RPort,0);
  419.    }
  420.    else {
  421.       Indexed_color_t *lu = (Indexed_color_t *)Color;
  422.       if (lu->Index < ColorsUsed) {
  423.          fprintf(stderr,"Using color index\n");
  424.          SetAPen(AmigaWindow->RPort,lu->Index);
  425.       }
  426.       else {
  427.          DBGREC;
  428.          fprintf(stderr,"Color index out of range (not supported)\n");
  429.       }
  430.    }
  431. }
  432.  
  433. /* Make a color vector. */
  434. void GetCCIR( RGB_color_t *Color, unsigned long *lum, 
  435.                              long *Cb, long *Cr )
  436. {
  437.    *lum =  Color->Red   * 30
  438.          + Color->Green * 59
  439.          + Color->Blue  * 11;
  440.  
  441.    *Cb  =  Color->Red   * 17
  442.          - Color->Green * 33
  443.          + Color->Blue  * 50;
  444.  
  445.    *Cr  =  Color->Red   * 50
  446.          - Color->Green * 42
  447.          - Color->Blue  *  8;
  448.  
  449.    *lum /= 100;
  450.    *Cb  /= 100;
  451.    *Cr  /= 100;
  452. }
  453.