home *** CD-ROM | disk | FTP | other *** search
/ DOS/V Power Report 1997 March / VPR9703A.ISO / VPR_DATA / DOGA / SOURCES / REND.LZH / REND / PICOUT.C < prev    next >
C/C++ Source or Header  |  1996-07-21  |  24KB  |  998 lines
  1. #include <stdio.h>
  2. #include <stdlib.h>
  3. #ifndef DJ
  4. #ifndef UNIX
  5.     #include <conio.h>
  6. #endif
  7. #endif
  8. #include <string.h>
  9.  
  10. #include "reader.h"
  11. #include "glib.h"
  12. #include "rend.h"
  13. #ifndef NO_PICLIB
  14. #include "piclib.h"
  15. #endif
  16. #define CTRL_Z    0x1A
  17.  
  18. static    int            picline ;        /*    画面のライン    */
  19. #ifdef NO_PICLIB
  20. static    FILE        *fp = NULL ;    /*    ファイルポインタ    */
  21. static    long        ftp ;            /*    画像データ領域のトップ    */
  22. static    long        size ;            /*    画像データのサイズ    */
  23. static    ColorCode    code ;            /*    カラーコード    */
  24. static    unsigned short    len ;        /*    レングス        */
  25. #else
  26. static    PicData        *pd = NULL;
  27. static    Pixel        *pix = NULL;
  28. #endif
  29. static unsigned short *errorbuf;    /*    誤差バッファ    */
  30. static unsigned short *errorbufnext;
  31. static    ColorCode    *antibuf[10] ;    /*    アンチエリアシング用のバッファ    */
  32.  
  33. /*
  34.     proto -s picout.c > temp
  35. */
  36. static    void    picerror( char* );
  37. static    void    putshort( int );
  38. static    void    putlong( long );
  39.  
  40.  
  41. FILE    *picinit( picfile )
  42. char    *picfile ;
  43. {
  44.     int        i ;
  45.  
  46.     picline = 0 ;
  47. #ifdef NO_PICLIB
  48.     len = 0 ;
  49.     size = 0 ;
  50. #endif
  51.  
  52.     /*    アンチエリアシングバッファの確保  */
  53.     if ( antibuf[0] == NULL )
  54.     {
  55.         for( i = 0 ; i < antiareas ; ++i )
  56.             antibuf[i] =(ColorCode*)tempalloc( sizeof( ColorCode ) * XPixel );
  57.     }
  58.  
  59.     if (fullcolorditherflag == ERRORDIFUSION || fullcolorditherflag == ERRORDIFUSION2) {
  60.         if (errorbuf == NULL) {
  61.             errorbuf = (unsigned short*)tempalloc(sizeof(short)*(XPixel/antiareas+2))+1;
  62.             errorbufnext = (unsigned short*)tempalloc(sizeof(short)*(XPixel/antiareas+2))+1;
  63.         }
  64.         for (i = 0; i < XPixel/antiareas; ++i) {
  65.             errorbuf[i] = errorbufnext[i] = 0;
  66.         }
  67.     }
  68.  
  69.     if ( nflag == 1 )
  70.         return NULL;
  71.  
  72. #ifdef NO_PICLIB
  73.     if ( fp != NULL )
  74.         picerror( "画像ファイルをクローズしていません。" );
  75.  
  76.     fp = fopen( picfile, "wb" );
  77.     if ( fp == NULL )
  78.     {
  79.         picerrorflag = TRUE ;
  80.         picerror( "画像ファイルがオープンできません。" );
  81.         return( NULL );
  82.     }
  83.     fprintf( stderr, "Writing Picture File : %s\n", picfile );
  84.     fprintf( fp, "image\x0d\x0a" ) ;
  85.     fprintf( fp, "mod rln\x0d\x0a" );
  86. #ifndef HIVISION
  87.     fprintf( fp, "pxn %d %d\x0d\x0a", XPixel/antiareas, YPixel/antiareas );
  88. #else
  89.     {
  90.         int x, y;
  91.         switch (PixelMode) {
  92.             case P256x256:    x =  256;    y =  256;    break;
  93.             case P320x200:    x =  320;    y =  200;    break;
  94.             case P512x512:    x =  512;    y =  512;    break;
  95.             case P640x400:    x =  640;    y =  400;    break;
  96.             case P640x480:    x =  640;    y =  480;    break;
  97.             case P1024x1024:    x = 1024;    y = 1024;    break;
  98.             case P1920x1125:    x = 1920;    y = 1125;    break;
  99.             case P2048x2048:    x = 2048;    y = 2048;    break;
  100.             case P4096x4096:    x = 4096;    y = 4096;    break;
  101.             default:    x =  256;    y =  256;    break;
  102.         }
  103.     fprintf( fp, "pxn %d %d\x0d\x0a", x, y);
  104.     }
  105. #endif
  106. #ifdef HIVISION
  107.     switch (PixelMode) {
  108.         case P256x256:
  109.         case P512x512:
  110.         case P1024x1024:
  111.         case P2048x2048:
  112.         case P4096x4096:
  113.             fprintf( fp, "pxs 4 3\x0d\x0a" );
  114.             break;
  115.         case P640x400:
  116.         case P640x480:
  117.         case P1920x1125:
  118.             fprintf( fp, "pxs 1 1\x0d\x0a" );
  119.             break;
  120.         default:
  121.             ;
  122.     }
  123. #else
  124.     fprintf( fp, "pxs 4 3\x0d\x0a" );
  125. #endif
  126.     fprintf( fp, "pnt 0 0\x0d\x0a" );
  127.     fprintf( fp, "frm 1\x0d\x0a" );
  128.     if (fullcoloroutflag) {
  129.         fprintf( fp, "cst {\x0d\x0a" );
  130.         fprintf( fp, "       grn 8\x0d\x0a" );
  131.         fprintf( fp, "       red 8\x0d\x0a" );
  132.         fprintf( fp, "       blu 8\x0d\x0a" );
  133.         fprintf( fp, "       trp 1\x0d\x0a" );
  134.         fprintf( fp, "     }\x0d\x0a" );
  135.         fprintf( fp, "dst {\x0d\x0a" );
  136.         fprintf( fp, "       col 25\x0d\x0a" );
  137.         fprintf( fp, "       len 7\x0d\x0a" );
  138.         fprintf( fp, "      }\x0d\x0a" );
  139.     } else {
  140.         fprintf( fp, "cst {\x0d\x0a" );
  141.         fprintf( fp, "       grn 5\x0d\x0a" );
  142.         fprintf( fp, "       red 5\x0d\x0a" );
  143.         fprintf( fp, "       blu 5\x0d\x0a" );
  144.         fprintf( fp, "       trp 1\x0d\x0a" );
  145.         fprintf( fp, "     }\x0d\x0a" );
  146.         fprintf( fp, "dst {\x0d\x0a" );
  147.         fprintf( fp, "       col 16\x0d\x0a" );
  148.         fprintf( fp, "       len 16\x0d\x0a" );
  149.         fprintf( fp, "      }\x0d\x0a" );
  150.     }
  151.     fputc( CTRL_Z, fp );
  152.  
  153.     ftp = ftell( fp );
  154.     fprintf( fp, "1234" );    /*    ４バイトあけておく    */
  155.  
  156.     if ( ferror( fp ) )
  157.         picerror( "画像ファイル出力でエラーが発生しました。" );
  158. #ifdef HIVISION
  159.     {
  160.         long prelength;
  161.         int ysize;
  162.         switch (PixelMode) {
  163.             case P256x256:    ysize =  256;    break;
  164.             case P512x512:    ysize =  512;    break;
  165.             case P640x400:    ysize =    0;    break;
  166.             case P640x480:    ysize =    0;    break;
  167.             case P1024x1024:    ysize = 1024;    break;
  168.             case P1920x1125:    ysize =    0;    break;
  169.             case P2048x2048:    ysize = 2048;    break;
  170.             case P4096x4096:    ysize = 4096;    break;
  171.             default:    ysize =    0;    break;
  172.         }
  173.         if (ysize > 0) {
  174.             prelength = ysize * YPosition + XPosition;
  175.             if (prelength > 0) {
  176.                 if (fullcoloroutflag) {
  177.                     while (prelength > 127) {
  178.                         putlong(0x000000ffL);
  179.                         prelength -= 127;
  180.                     }
  181.                     putlong(0x00000080L + prelength);
  182.                 } else {
  183.                     while (prelength > 65535L) {
  184.                         putshort(1);
  185.                         putshort(65535U);
  186.                         prelength -= 65535L;
  187.                     }
  188.                     putshort(1);
  189.                     putshort((unsigned short)prelength );
  190.                 }
  191.             }
  192.         }
  193.     }
  194. #endif
  195.     return( fp );
  196. #else
  197.     if ( pd != NULL )
  198.         picerror( "画像ファイルをクローズしていません。" );
  199.     {
  200.         int mode = 0;
  201.         int x, y;
  202.         long prelength;
  203.         int ysize;
  204.         int l;
  205.         l = strlen(picfile);
  206.         if (strcmpi(picfile+l-4, ".PIC") != 0) {
  207.             PixelMode = -1;
  208.         }
  209.         switch (PixelMode) {
  210.             case P256x256:    x =  256;    y =  256;    break;
  211.             case P320x200:    x =  320;    y =  200;    break;
  212.             case P512x512:    x =  512;    y =  512;    break;
  213.             case P640x400:    x =  640;    y =  400;    break;
  214.             case P640x480:    x =  640;    y =  480;    break;
  215.             case P1024x1024:    x = 1024;    y = 1024;    break;
  216.             case P1920x1125:    x = 1920;    y = 1125;    break;
  217.             case P2048x2048:    x = 2048;    y = 2048;    break;
  218.             case P4096x4096:    x = 4096;    y = 4096;    break;
  219.             default:
  220.                 x =  XPosition + XPixel/antiareas;
  221.                 y =  YPosition + YPixel/antiareas;
  222.                 break;
  223.         }
  224.         if (PixelMode == -1) {
  225.             if (fullcoloroutflag || fullcolorditherflag == DITHERNONE) {
  226.                 mode = BMP_TRUECOLOR;
  227.             } else {
  228.                 mode = BMP_PALETTE;
  229.             }
  230.         } else if (fullcoloroutflag) {
  231.             mode = COMPRESS_TRUECOLOR;
  232.         } else {
  233.             switch (fullcolorditherflag) {
  234.             case DITHERNONE:        mode = COMPRESS_NORMAL; break;
  235.             case ORDEREDDITHER4:    mode = COMPRESS_DITHER_ORDERD; break;
  236.             case ORDEREDDITHER8:    mode = COMPRESS_DITHER_ORDERD; break;
  237.             case RANDOMDITHER:        mode = COMPRESS_DITHER_RANDOM; break;
  238.             case ERRORDIFUSION:        mode = COMPRESS_DITHER_ERROR; break;
  239.             case ERRORDIFUSION2:    mode = COMPRESS_DITHER_ERROR216; break;
  240.             }
  241.         }
  242.         if (pix == NULL) {
  243.             pix = (Pixel*)tempalloc( sizeof(Pixel) * x);
  244.         }
  245.         pd = PicWriteOpen(picfile, x, y, mode);
  246.         if (pd == NULL) {
  247.             picerrorflag = TRUE ;
  248.             picerror( "画像ファイルがオープンできません。" );
  249.             return( NULL );
  250.         }
  251.         fprintf( stderr, "Writing Picture File : %s\n", picfile );
  252.         switch (PixelMode) {
  253.             case P256x256:    ysize =  256;    break;
  254.             case P512x512:    ysize =  512;    break;
  255.             case P640x400:    ysize =    0;    break;
  256.             case P640x480:    ysize =    0;    break;
  257.             case P1024x1024:    ysize = 1024;    break;
  258.             case P1920x1125:    ysize =    0;    break;
  259.             case P2048x2048:    ysize = 2048;    break;
  260.             case P4096x4096:    ysize = 4096;    break;
  261.             default:    ysize =    0;    break;
  262.         }
  263.         memset(pix, 0, sizeof(Pixel) * pd->pixelX);
  264.         if (ysize > 0) {
  265.             for (i = 0; i < YPosition; ++i) {
  266.                 if (PicOutputLine(pd, pix) == FALSE) {
  267.                     picerror( "画像ファイル出力でエラーが発生しました。" );
  268.                 }
  269.             }
  270.         }
  271.     }
  272.     return (FILE*)pd;
  273. #endif
  274. }
  275.  
  276. void    picout( framebuf )
  277. ColorCode    *framebuf ;
  278. {
  279.     int        i, j, n, x, r, g, b, a, f;
  280.     ColorCode c ;
  281.     ColorCode    *cp[16] ;
  282.     static const int dither_map[4][4] =
  283.                 {{0,6,1,7}, {4,2,5,3}, {1,7,0,6}, {5,3,4,2}};
  284.     static int dither_y = 0;
  285.     unsigned short *shortp ;
  286.     ColorCode *p;
  287. #ifdef EDGEANTI
  288.     int f0;
  289. #endif
  290.     unsigned short realbuf[MAXLINE];
  291. #ifdef HIVISION
  292.     int    xysize;
  293.  
  294.     switch (PixelMode) {
  295.         case P256x256:    xysize =  256;    break;
  296.         case P512x512:    xysize =  512;    break;
  297.         case P640x400:    xysize =    0;    break;
  298.         case P640x480:    xysize =    0;    break;
  299.         case P1024x1024:    xysize = 1024;    break;
  300.         case P1920x1125:    xysize =    0;    break;
  301.         case P2048x2048:    xysize = 2048;    break;
  302.         case P4096x4096:    xysize = 4096;    break;
  303.         default:    xysize =    0;    break;
  304.     }
  305. #endif
  306.  
  307.     (*interrupt)();
  308.  
  309.     n = XPixel / antiareas ;
  310.  
  311.     /*    アンチエリアシングバッファにコピー    */
  312.     memcpy( (char *)antibuf[ picline % antiareas ], (char *)framebuf,
  313.                     sizeof( ColorCode ) * XPixel );
  314.     picline++ ;
  315.  
  316.     /*    アンチエリアシングのチェック  */
  317.     if ( picline % antiareas != 0 )
  318.         return ;
  319. #ifdef HIVISION
  320.     if (xysize > 0 && YPosition + picline / antiareas > xysize) {
  321.         return;
  322.     }
  323. #endif
  324.  
  325.     /*    アンチエリアシング    */
  326.     if ( antiareas != 1 )
  327.     {
  328.         a = antiareas * antiareas ;
  329.  
  330.         for( i = 0 ; i < antiareas ; ++i )
  331.             cp[i] = antibuf[i] ;
  332.         for( x = 0 ; x < n ; ++x )
  333.         {
  334.             /*    すべて同じ色かどうかチェックする  */
  335.             f = 1 ;
  336.             for( i = 0 ; i < antiareas && f ; ++i )
  337.             {
  338.                 c = *(cp[0]) ;
  339.                 for( j = 0 ; j < antiareas && f ; ++j )
  340.                 {
  341.                     if ( cp[i][j] != c ) {
  342.                         f = 0 ;
  343.                         break;
  344.                     }
  345.                 }
  346.             }
  347.             if ( f )
  348.             {
  349.                 framebuf[x] = c ;
  350.                 for( j = 0 ; j < antiareas ; ++j )
  351.                     cp[j] += antiareas ;
  352.                 continue ;
  353.             }
  354.             /*    同じ色でなければアンチエリアシング    */
  355.             r = g = b = 0 ;
  356.             f = 0;
  357. #ifdef EDGEANTI
  358.             f0 = FALSE;
  359. #endif
  360.             for( i = 0 ; i < antiareas ; ++i )
  361.             {
  362.                 for( j = 0 ; j < antiareas ; ++j )
  363.                 {
  364.                     r += (int)(( *(cp[j]) >> 16 ) & 255);
  365.                     g += (int)(( *(cp[j]) >> 24 ) & 255);
  366.                     b += (int)(( *(cp[j]) >>  8 ) & 255);
  367.                     f += (int)(( *(cp[j])       ) & 255);
  368. #ifdef EDGEANTI
  369.                     if ((( *(cp[j])       ) & 255) == 255) {
  370.                         f0 = TRUE;
  371.                     }
  372. #endif
  373.                     ++ ( cp[j] ) ;
  374.                 }
  375.             }
  376. #ifdef EDGEANTI
  377.             if (EdgeAntiFlag == FALSE && f0 != FALSE) {
  378.                 f = 255 * a;
  379.             }
  380. #endif
  381.             framebuf[x] = ( (long)( r / a ) << 16)
  382.                         + ( (long)( g / a ) << 24)
  383.                         + ( (long)( b / a ) <<  8)
  384.                         + ( (long)( f / a )      );
  385.         }
  386.     }
  387.  
  388.     switch (fullcolorditherflag) {
  389.     case ERRORDIFUSION2:
  390.     {
  391.         int er = 0, eg = 0, eb = 0, ee;
  392.         unsigned short *ppp;
  393.         ppp = errorbuf;
  394.         errorbuf = errorbufnext;
  395.         errorbufnext = ppp;
  396.         for (x = 0; x < n; ++x) {
  397.             errorbufnext[x] = 0;
  398.         }
  399.         for (x = 0; x < n; ++x) {
  400.             ee = (int)((framebuf[x] >> 16) & 0xff) + er +((errorbuf[x]>>11) & 0x1f);
  401.             r = (ee >> 3)&0x3c;    er = ee & 31;
  402.             ee = (er * 3 + 4) / 8;
  403.             errorbufnext[x] += ee << 11;
  404.             errorbufnext[x+1] += (er - ee * 2) << 11;
  405.             er = ee;
  406.  
  407.             ee = (int)((framebuf[x] >> 24) & 0xff) +eg+ ((errorbuf[x]>> 6) & 0x1f);
  408.             g = (ee >> 3)&0x3c;    eg = ee & 31;
  409.             ee = (eg * 3 + 4) / 8;
  410.             errorbufnext[x] += ee << 6;
  411.             errorbufnext[x+1] += (eg - ee * 2) << 6;
  412.             eg = ee;
  413.  
  414.             ee = (int)((framebuf[x] >>  8) & 0xff) + eb+ ((errorbuf[x]    ) & 0x3f);
  415.             b = (ee >> 3)&0x3f;    eb = ee & 63;
  416.             ee = (eb * 3 + 4) / 8;
  417.             errorbufnext[x] += ee ;
  418.             errorbufnext[x+1] += (eb - ee * 2);
  419.             eb = ee;
  420.             if (r > 31)    r = 31;
  421.             if (g > 31)    g = 31;
  422.             if (b > 31)    b = 31;
  423.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  424.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  425.         }
  426.         break;
  427.     }
  428.     case ERRORDIFUSION:
  429.     {
  430.         int er = 0, eg = 0, eb = 0, ee;
  431.         unsigned short *ppp;
  432.         ppp = errorbuf;
  433.         errorbuf = errorbufnext;
  434.         errorbufnext = ppp;
  435.         for (x = 0; x < n; ++x) {
  436.             errorbufnext[x] = 0;
  437.         }
  438.         for (x = 0; x < n; ++x) {
  439.             ee = (int)((framebuf[x] >> 16) & 0xff) + er +((errorbuf[x]>>8) & 0x0f);
  440.             r = ee >> 3;    ee &= 7;
  441.             er = (ee * 3 + 4)/8;
  442.             errorbufnext[x  ] += er << 8;
  443.             errorbufnext[x+1] += (ee-er*2) << 8;
  444.  
  445.             ee = (int)((framebuf[x] >> 24) & 0xff) +eg+ ((errorbuf[x]>> 4) & 0x0f);
  446.             g = ee >> 3;    ee &= 7;
  447.             eg = (ee * 3 + 4)/8;
  448.             errorbufnext[x  ] += eg << 4;
  449.             errorbufnext[x+1] += (ee-eg*2) << 4;
  450.  
  451.             ee = (int)((framebuf[x] >>  8) & 0xff) + eb+ ((errorbuf[x]    ) & 0x0f);
  452.             b = ee >> 3;    ee &= 7;
  453.             eb = (ee * 3 + 4)/8;
  454.             errorbufnext[x  ] += eb;
  455.             errorbufnext[x+1] += (ee-eb*2);
  456.  
  457.             if (r > 31)    r = 31;
  458.             if (g > 31)    g = 31;
  459.             if (b > 31)    b = 31;
  460.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  461.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  462.         }
  463.         break;
  464.     }
  465.     case RANDOMDITHER:
  466.         for (x = 0; x < n; ++x) {
  467.             int diff;
  468.             diff = (rand()>>12)%8;
  469.             r = (int)(((framebuf[x] >> 16) & 0xff) + diff) >> 3;
  470.             g = (int)(((framebuf[x] >> 24) & 0xff) + diff) >> 3;
  471.             b = (int)(((framebuf[x] >>  8) & 0xff) + diff) >> 3;
  472.             if (r > 31)    r = 31;
  473.             if (g > 31)    g = 31;
  474.             if (b > 31)    b = 31;
  475.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  476.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  477.         }
  478.         break;
  479.     case ORDEREDDITHER4:
  480.         for (x = 0; x < n; ++x) {
  481.             r = (int)(((framebuf[x]>>16) & 0xff) + dither_map[x&1][dither_y&1])>>3;
  482.             g = (int)(((framebuf[x]>>24) & 0xff) + dither_map[x&1][dither_y&1])>>3;
  483.             b = (int)(((framebuf[x]>> 8) & 0xff) + dither_map[x&1][dither_y&1])>>3;
  484.             if (r > 31)    r = 31;
  485.             if (g > 31)    g = 31;
  486.             if (b > 31)    b = 31;
  487.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  488.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  489.         }
  490.         break;
  491.     case ORDEREDDITHER8:
  492.         for (x = 0; x < n; ++x) {
  493.             r = (int)(((framebuf[x]>>16) & 0xff) + dither_map[x&3][dither_y&3])>>3;
  494.             g = (int)(((framebuf[x]>>24) & 0xff) + dither_map[x&3][dither_y&3])>>3;
  495.             b = (int)(((framebuf[x]>> 8) & 0xff) + dither_map[x&3][dither_y&3])>>3;
  496.             if (r > 31)    r = 31;
  497.             if (g > 31)    g = 31;
  498.             if (b > 31)    b = 31;
  499.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  500.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  501.         }
  502.         break;
  503.     case DITHERNONE:
  504.     default:
  505.         for (x = 0; x < n; ++x) {
  506.             r = (int)((framebuf[x] >> 19) & 0x1f);
  507.             g = (int)((framebuf[x] >> 27) & 0x1f);
  508.             b = (int)((framebuf[x] >> 11) & 0x1f);
  509.             realbuf[x] = (r << 6) + (g << 11) + (b << 1)
  510.                        + ((framebuf[x]&0xff)>0xfc?1:0);
  511. /*
  512.         ggggggggrrrrrrrrbbbbbbbb.......a
  513.                         gggggrrrrrbbbbba
  514.             realbuf[x] = ((framebuf[x]>>13)&0xf800)
  515.                        | ((framebuf[x]>>16)&0x07c0)
  516.                        | ((framebuf[x]>>10)&0x003e);
  517. */
  518.         }
  519.     }
  520.     dither_y++;
  521. #if 0
  522. if (picline == 100) {
  523.     int i;
  524.     ColorCode *p;
  525.     FILE *fp;
  526.     p = framebuf;
  527.     fp = fopen("c:/tmp.log", "w");
  528.     if (fp != NULL) {
  529.         for (i = XPixel/4; i > 0; --i) {
  530.             fprintf(fp, "%08x\n", *p);
  531.             p += 4;
  532.         }
  533.         fclose(fp);
  534.     }
  535. }
  536. #endif
  537.  
  538. #ifdef HIVISION
  539.     if ( !uflag) {
  540. #ifdef CRTFULLCOLOR
  541.         if (xysize > 0) {
  542.             crtout24( framebuf, XPosition + n <= xysize ? n : xysize - XPosition, picline/antiareas - 1 );
  543.             crtout( realbuf, XPosition + n <= xysize ? n : xysize - XPosition, picline/antiareas - 1 );
  544.         } else {
  545.             crtout24( framebuf, n, picline/antiareas - 1 );
  546.             crtout( realbuf, n, picline/antiareas - 1 );
  547.         }
  548. #else
  549.         if (xysize > 0) {
  550.             crtout( realbuf, XPosition + n <= xysize ? n : xysize - XPosition, picline/antiareas - 1 );
  551.         } else {
  552.             crtout( realbuf, n, picline/antiareas - 1 );
  553.         }
  554. #endif
  555.     }
  556. #else
  557.     if ( ! uflag )
  558.         crtout( realbuf, n, picline/antiareas - 1 );
  559. #endif
  560.     p = framebuf;
  561.     shortp = realbuf;
  562.     if ( nflag == 1 )
  563.     {
  564. #ifndef WINDOWS
  565. #ifdef    XC
  566.         if ( picline == YPixel && ! BackGroundJob )
  567. #else
  568.         if ( picline == YPixel )
  569. #endif
  570.         {
  571.             fprintf( stderr, "\n何かキーを押して下さい。" );
  572. #if defined(DJ) || defined(UNIX)
  573.             fgetc(stdin);
  574. #else
  575.             getch() ;
  576. #endif
  577.             fprintf( stderr, "\n" );
  578.  
  579.         }
  580. #endif
  581.         return ;
  582.     }
  583.  
  584. #ifdef    NO_PICLIB
  585.     /*    ファイル出力  */
  586. #ifdef HIVISION
  587.     for( i = 0 ; i < n && (xysize == 0 || i + XPosition < xysize) ; ++i )
  588. #else
  589.     for( i = 0 ; i < n ; ++i )
  590. #endif
  591.     {
  592.         if ( len == 0 ) /*    ファイルの初め    */
  593.         {
  594.             len = 1 ;
  595.             if (fullcoloroutflag) {
  596.                 code = *p++ ;
  597.             } else {
  598.                 code = *shortp++;
  599.             }
  600.             continue ;
  601.         }
  602.         if (
  603.             (fullcoloroutflag == TRUE  &&      *p == code && len < 127) ||
  604.             (fullcoloroutflag == FALSE && *shortp == code && len < 32767))
  605.             ++len ;
  606.         else
  607.         {
  608.             if (fullcoloroutflag) {
  609.                 putlong(( code  & 0xffffff00L) | ((code&0xff)>0xfc?0x80:0x00) | len );
  610.                 code = *p;
  611.             } else {
  612.                 putshort( (unsigned short)code );
  613.                 putshort( (unsigned short)len );
  614.                 code = *shortp;
  615.             }
  616.             len = 1 ;
  617.         }
  618.         p ++ ;
  619.         shortp++;
  620.     }
  621. #ifdef HIVISION
  622.     if (!(xysize == 0 ||
  623.           picline == YPixel ||
  624.           YPosition + picline / antiareas == xysize)) {
  625.         if (fullcoloroutflag) {
  626.             putlong(( code  & 0xffffff00L) | ((code&0xff)>0xfc?0x80:0x00) | len );
  627.         } else {
  628.             putshort( (unsigned short)code );
  629.             putshort( len );
  630.         }
  631.         code = 1;
  632.         if (n + XPosition < xysize) {
  633.             len = xysize - n;
  634.         } else {
  635.             len = XPosition;
  636.         }
  637.         if (fullcoloroutflag) {
  638.             while ( len > 127) {
  639.                 putlong(0x00000080L | 127 );
  640.                 len -= 127;
  641.             }
  642.         }
  643.     }
  644. /*    len = n <= 256 ? 256 - n : 512 - n;*/
  645. #endif
  646.     if ( ferror( fp ) )
  647.         picerror( "画像ファイル出力でエラーが発生しました。" );
  648. #ifdef HIVISION
  649.     if (picline == YPixel || YPosition + picline / antiareas == xysize)
  650. #else
  651.     if ( picline == YPixel )    /*    ファイル終了  */
  652. #endif
  653.     {
  654.         fprintf( stderr, "\n" );
  655.             if (fullcoloroutflag) {
  656.                 putlong(( code  & 0xffffff00L) | ((code&0xff)>0xfc?0x80:0x00) | len );
  657.             } else {
  658.                 putshort( (unsigned short)code );
  659.                 putshort( len );
  660.             }
  661. #ifdef HIVISION
  662.         if (xysize != 0) {
  663.             long lastlength;
  664.             int ny;
  665.             ny = YPixel / antiareas;
  666. /*            lastlength = (ny <= 256 ? 256 - ny : 512 - ny) * (n <= 256 ? 256 : 512);*/
  667.             lastlength = (xysize - ny - YPosition) * (xysize) + (xysize-XPosition-n);
  668.             if (fullcoloroutflag) {
  669.                 if (lastlength > 0) {
  670.                     while (lastlength > 127) {
  671.                         putlong(0x000000ffL);
  672.                         lastlength -= 127;
  673.                     }
  674.                     putlong(0x00000080L + lastlength);
  675.                 }
  676.             } else {
  677.                 if (lastlength > 0) {
  678.                     while (lastlength > 65535L) {
  679.                         putshort( 1 );
  680.                         putshort( 65535U );
  681.                         lastlength -= 65535L;
  682.                     }
  683.                     putshort( 1 );
  684.                     putshort( (unsigned short)lastlength );
  685.                 }
  686.             }
  687.         }
  688. #endif
  689.         fseek( fp, ftp, 0 );
  690.         putlong( size );
  691.  
  692.         if ( ferror( fp ) )
  693.             picerror( "画像ファイル出力でエラーが発生しました。" );
  694.         fclose( fp );
  695.         fp = NULL ;
  696.     }
  697. #else
  698.     /*    ファイル出力  */
  699.  
  700.     if (pd->pixelX == XPixel/antiareas) {
  701.         if (PicOutputLine(pd, framebuf) == FALSE) {
  702.             picerror( "画像ファイル出力でエラーが発生しました。" );
  703.         }
  704.     } else {
  705.         memcpy(pix + XPosition, framebuf, sizeof(Pixel) * (XPixel/antiareas));
  706.         if (PicOutputLine(pd, pix) == FALSE) {
  707.             picerror( "画像ファイル出力でエラーが発生しました。" );
  708.         }
  709.     }
  710.     if (picline == YPixel || YPosition + picline / antiareas == xysize)
  711.     {
  712.         long lastlength;
  713.         int ny;
  714.         fprintf( stderr, "\n" );
  715.         ny = YPixel / antiareas;
  716.         lastlength = (xysize - ny - YPosition);
  717.         memset(pix, 0, sizeof(Pixel) * pd->pixelX);
  718.         for (; lastlength > 0; --lastlength) {
  719.             if (PicOutputLine(pd, pix) == FALSE) {
  720.                 picerror( "画像ファイル出力でエラーが発生しました。" );
  721.             }
  722.         }
  723.         if (PicClose(pd) == FALSE) {
  724.             picerror( "画像ファイル出力でエラーが発生しました。" );
  725.         }
  726.         pd = NULL ;
  727.     }
  728. #endif
  729. }
  730.  
  731. void    piclineout( x1, y1, x2, y2 )
  732. int        x1, y1, x2, y2 ;
  733. {
  734.     crtline( x1/antiareas, y1/antiareas, x2/antiareas, y2/antiareas );
  735. }
  736.  
  737. static    void    picerror( msg )
  738. char    *msg ;
  739. {
  740. #ifdef MESSAGE
  741.     extern int printwarning(const char *format, ...);
  742. #endif
  743.     if (picerrorflag) return;
  744. #ifdef MESSAGE
  745.     printwarning( "%s", msg);
  746. #endif
  747.     picerrorflag = TRUE ;
  748.     fprintf( stderr, "\n%s\n", msg );
  749.     perror("");
  750. /*
  751.     exit( 1 );
  752. */
  753. }
  754.  
  755. #ifdef NO_PICLIB
  756. static    inline void    putshort( n )
  757. int        n ;
  758. {
  759.     size += 2 ;
  760.     fputc( ( n >> 8 ) & 255, fp );
  761.     fputc( n & 255, fp );
  762. }
  763.  
  764. static    inline void    putlong( n )
  765. long    n ;
  766. {
  767.     putshort( (short)( ( n >> 16 ) & 0xffffL ) );
  768.     putshort( (short)( n & 0xffffL ) );
  769. }
  770. #endif
  771.  
  772. #ifdef WIREVIEW
  773. #ifndef X68000
  774. #err "WIREVIEW is only X68000"
  775. #endif
  776.  
  777. void    wirelineout( x1, y1, x2, y2, color )
  778. int        x1, y1, x2, y2 ;
  779. unsigned short color;
  780. {
  781.     crtlinecolor( x1/antiareas, y1/antiareas, x2/antiareas, y2/antiareas, color );
  782. }
  783. #define PIC_COL( col )    ( ( col == 0 || col == 1 ) ? 1 : ( col & 0xfffe ) )
  784.  
  785. static    inline int    putww( fp, i )
  786. FILE    *fp ;
  787. int    i ;
  788. {
  789.     fputc( ( i >> 8 ) & 255, fp );
  790.     fputc( ( i & 255 ), fp );
  791.     return( 0 );
  792. }
  793.  
  794. static    inline int    putll( fp, i )
  795. FILE    *fp ;
  796. long    i ;
  797. {
  798.     fputc( (int)(( i >> 24 ) & 255), fp ) ;
  799.     fputc( (int)(( i >> 16 ) & 255), fp ) ;
  800.     fputc( (int)(( i >>  8 ) & 255), fp ) ;
  801.     fputc( (int)(  i         & 255), fp ) ;
  802.     return( 0 );
  803. }
  804.  
  805. static int    inline getll( fp )
  806. FILE    *fp ;
  807. {
  808.     int    i ;
  809.  
  810.     i  = fgetc( fp ) << 24 ;
  811.     i += fgetc( fp ) << 16 ;
  812.     i += fgetc( fp ) << 8 ;
  813.     i += fgetc( fp ) ;
  814.  
  815.     return( i );
  816. }
  817.  
  818. static inline unsigned short anti_color(unsigned short *p)
  819. {
  820.     long int  c1, c2, c3, c4;
  821.     long int  r1, r2, r3, r4;
  822.     c1 = p[0];
  823.     c2 = p[1];
  824.     c3 = p[512];
  825.     c4 = p[513];
  826.     if (c1 == c2 && c1 == c3 && c1 == c4) {
  827.         return PIC_COL(c1);
  828.     }
  829.     r1 = (c1 & 0xf83e) + (c2 & 0xf83e) + (c3 & 0xf83e) + (c4 & 0xf83e);
  830.     r2 = (c1 & 0x07c0) + (c2 & 0x07c0) + (c3 & 0x07c0) + (c4 & 0x07c0);
  831.     r3 = (c1 & c2 & c3 & c4 & 0x0001);
  832.     r4 = ((r1/4) & 0xf83e) | ((r2/4) & 0x7c0) | r3;
  833.     return PIC_COL(r4);
  834. }
  835.  
  836. static inline unsigned short white_color(unsigned short *p)
  837. {
  838.     unsigned short c;
  839.     c = p[0];
  840.     if (c < p[1])        c = p[1];
  841.     if (c < p[512])        c = p[512];
  842.     if (c < p[513])        c = p[513];
  843.     return c;
  844. #if 0
  845.     long int  c1, c2, c3, c4;
  846.     long int  r1, r2, r3, r4;
  847.     c1 = p[0] & 0xfffe;
  848.     c2 = p[1] & 0xfffe;
  849.     c3 = p[512] & 0xfffe;
  850.     c4 = p[513] & 0xfffe;
  851.     if (c1 || c2 || c3 || c4) {
  852.         return 0xfffe;
  853.     } else {
  854.         return 1;
  855.     }
  856. #endif
  857. }
  858.  
  859. /*By Taka2*/
  860. #define SAVE_GRAPHIC_256    0
  861. #define SAVE_GRAPHIC_ANTI    1
  862. #define SAVE_GRAPHIC_512    2
  863.  
  864. /*
  865. **           file    screen
  866. **    msb = 1 -> toumei, futoumei
  867. */
  868. #define    CTRL_Z        0x1A
  869. #define    G_RAM_ADDRESS    0xc00000
  870. #define    OUT_SIZE    256
  871.  
  872. int    wiresave(void)
  873. {
  874.     int    sp ;
  875.     long    end ;
  876.     int save_graphic_mode;
  877.  
  878.     unsigned short    int    *lp, *p ;
  879.     int    x, y, col, col2, count, step ;
  880.     int out_size = 256;
  881.     if (XPixel / antiareas > 256) {
  882.         save_graphic_mode = SAVE_GRAPHIC_512;
  883.         out_size = 512;
  884.     } else if (antiareas == 1) {
  885.         save_graphic_mode = SAVE_GRAPHIC_256;
  886.     } else {
  887.         save_graphic_mode = SAVE_GRAPHIC_ANTI;
  888.     }
  889.     lp = p =(unsigned short *) G_RAM_ADDRESS ;
  890.     step = 2 ;
  891.  
  892.     y = 0 ;
  893.     x = 0 ;
  894.  
  895.     while(0) ;
  896. #ifndef RENDXVI
  897.     sp = SUPER( 0 ) ;
  898. #endif
  899.     while(0) ;
  900.  
  901.     switch(save_graphic_mode) {
  902.     case SAVE_GRAPHIC_256 :
  903.         for (x = 256 * 256; x > 0;) {
  904.             col = white_color(p);
  905.             count = 1;
  906.             p+=2;
  907.             if ((--x & 255) == 0) {
  908.                 p += 512;
  909.             }
  910.             while (x > 0 && col == (col2 = white_color(p))) {
  911.                 count++;
  912.                 if (count == 65536) {
  913.                     putww( fp, col );
  914.                     putww( fp, 65535 );
  915.                     count = 1;
  916.                 }
  917.                 p+=2;
  918.                 if ((--x & 255) == 0) {
  919.                     p += 512;
  920.                 }
  921.             }
  922.             putww( fp, col );
  923.             putww( fp, count );
  924.         }
  925.         break;
  926.     case SAVE_GRAPHIC_ANTI :
  927.         for (x = 256 * 256; x > 0;) {
  928.             col = anti_color(p);
  929.             count = 1;
  930.             p+=2;
  931.             if ((--x & 255) == 0) {
  932.                 p += 512;
  933.             }
  934.             while (x > 0 && col == (col2 = anti_color(p))) {
  935.                 count++;
  936.                 if (count == 65536) {
  937.                     putww( fp, col );
  938.                     putww( fp, 65535 );
  939.                     count = 1;
  940.                 }
  941.                 p+=2;
  942.                 if ((--x & 255) == 0) {
  943.                     p += 512;
  944.                 }
  945.             }
  946.             putww( fp, col );
  947.             putww( fp, count );
  948.         }
  949.         break;
  950.     case SAVE_GRAPHIC_512 :
  951.         for (x = 512 * 512; x > 0;) {
  952.             col = PIC_COL(*p);
  953.             count = 1;
  954.             x--;
  955.             p++;
  956.             while (x > 0 && col == (col2 = PIC_COL(*p))) {
  957.                 count++;
  958.                 if (count == 65536) {
  959.                     putww( fp, col );
  960.                     putww( fp, 65535 );
  961.                     count = 1;
  962.                 }
  963.                 x--;
  964.                 p++;
  965.             }
  966.             putww( fp, col );
  967.             putww( fp, count );
  968.         }
  969.         break;
  970.     }
  971.      while(0) ;
  972. #ifndef RENDXVI
  973.     STACK_ADJUST:
  974.     SUPER( sp ) ;
  975. #endif
  976.     while(0) ;
  977.  
  978.     end = ftell( fp );
  979.     fseek( fp, ftp, 0 );
  980.     putll( fp, end - ftp );
  981. /*
  982.     fseek( fp, top, 0 );
  983.     putll( fp, end-top );
  984.     fseek( fp, end, 0 );
  985. */
  986.     if ( ferror( fp ) )    {
  987.         picerrorflag = TRUE;
  988.     } else {
  989.         picerrorflag = FALSE;
  990.     }
  991.     fclose( fp ) ;
  992.     fp = NULL;
  993.     return 0;
  994. }
  995.  
  996. #endif
  997.  
  998.