home *** CD-ROM | disk | FTP | other *** search
/ Phoenix Heaven Sunny 2 / APPARE2.BIN / oh_towns / tetujin / src.lzh / FFTSPT.C < prev    next >
Text File  |  1995-02-23  |  8KB  |  404 lines
  1. /*
  2.           YUV変換→YをFFT→μνデータ表示→フィルタ→逆FFT
  3. */
  4.  
  5. #include <stdio.h>
  6. #include <stdlib.h>
  7. #include <string.h>
  8. #include <winb.h>
  9. #include <te.h>
  10. #include <fntb.h>
  11. #include <gui.h>
  12. #include <egb.h>
  13. #include <math.h>
  14. #include "tetujin.h"
  15. #include "g_eff.h"
  16. #include "fft.h"
  17. #include "fftspt.h"
  18.  
  19. #define NOERR 0        /* no error */
  20.  
  21. static fftFlg = 0 ;    /* g_fft2実行後:1, g_fft2_inv実行後:2,
  22.                            g_fft2_clr実行後:0 */
  23.  
  24. // ワーク & バッファ
  25. static char *buffer ;
  26. static double *aReal, *aImag ;
  27. static double *bReal, *bImag ;
  28. static char *work ;
  29. static char *cb, *cr ;
  30. static int *a_mul ;
  31.  
  32. static int exp2 = 0, length ;
  33.  
  34. static int mx ;
  35. static int aSen ;
  36. static int mSen ;
  37. static int cMax ;
  38. static int aMax ;
  39. static int x1 ;
  40. static int y1 ;
  41. static int x2 ;
  42. static int y2 ;
  43. static int (*read1)() ;
  44. static int (*write)() ;
  45. static int (*mask)() ;
  46.  
  47. g_fft2_readFlg()
  48. {
  49.     return fftFlg ;
  50. }
  51.  
  52. g_fft2( BASICPARA *para, int ex )
  53. {
  54.     mx = para->mix ;
  55.     aSen = para->alphaSen ;
  56.     mSen = para->maskSen ;
  57.     cMax = para->colorMax ;
  58.     aMax = para->alphaMax ;
  59.     x1 = para->lupx ;
  60.     y1 = para->lupy ;
  61. //    x2 = para->rdwx ;
  62. //    y2 = para->rdwy ;
  63.     read1 = para->read1 ;
  64.     write = para->write ;
  65.     mask = para->mask ;
  66.  
  67.     int i, j, size ;
  68.  
  69.     length = 1 << ex ;
  70.     exp2 = ex ;
  71.  
  72.     if( fftFlg )
  73.         TL_free( buffer ) ;
  74.     fftFlg = 0 ;
  75.  
  76.     size = length*length*sizeof( double )* 4 + sizeof( double )*length*3
  77.          + length*length * 2 + length*length*sizeof( int ) ;
  78.  
  79.     if( (buffer = (char *)TL_malloc( size )) == NULL )
  80.         return OUT_OF_MEMORY ;
  81.  
  82.     aReal = (double *)buffer ;
  83.     aImag = aReal + length*length ;
  84.     bReal = aImag + length*length ;
  85.     bImag = bReal + length*length ;
  86.     work  = (char *)(bImag + length*length) ;
  87.     cb = work + sizeof( double )*length*3 ;
  88.     cr = cb + length*length ;
  89.     a_mul = (int *)( cr + length*length) ;
  90.  
  91.     fftFlg = 1 ;
  92.  
  93.     for( i=0 ; i<length ; i++ )
  94.     {
  95.         for( j=0 ; j<length ; j++ )
  96.         {
  97.             char a[4] ;
  98.             int y0, u0, v0 ;
  99.  
  100.             read1( x1+j, y1+i, a ) ;
  101.  
  102.             rgbToYuv( a[0], a[1], a[2], &y0, &u0, &v0, cMax ) ;
  103.  
  104.             aReal[ j + i*length ] = (double)y0 ;
  105.             aImag[ j + i*length ] = 0 ;
  106.  
  107.             cb[ j + i*length ] = u0 ;
  108.             cr[ j + i*length ] = v0 ;
  109.             a_mul[ j + i*length ] = 0x10000 ;
  110.         }
  111.     }
  112.  
  113.     fft_2( work, aReal, aImag, ex, 1 ) ;
  114.  
  115.     fdsp() ;
  116.  
  117.     return NOERR ;
  118. }
  119.  
  120. g_fft2_mul( BASICPARA *para, int rate )
  121. {
  122.     mx = para->mix ;
  123.     aSen = para->alphaSen ;
  124.     mSen = para->maskSen ;
  125.     cMax = para->colorMax ;
  126.     aMax = para->alphaMax ;
  127. //    x1 = para->lupx ;
  128. //    y1 = para->lupy ;
  129. //    x2 = para->rdwx ;
  130. //    y2 = para->rdwy ;
  131.     read1 = para->read1 ;
  132.     write = para->write ;
  133.     mask = para->mask ;
  134.  
  135.     int i, j, ex ;
  136.  
  137.     if( fftFlg == 0 )return NOERR ;
  138.  
  139.     ex = exp2 ;
  140.     if( ex == 0 )return NOERR ;
  141.  
  142.     for( i=0 ; i<length ; i++ )
  143.     {
  144.         for( j=0 ; j<length ; j++ )
  145.         {
  146.             int i2, j2 ;
  147.             char a[4] ;
  148.  
  149.             read1( x1+j, y1+i, a ) ;
  150.  
  151.             if( a[3] )
  152.             {
  153.                 a_mul[ j + i*length ] = 0x10000 * rate / 256 ;
  154.                 i2 = length - i ;
  155.                 j2 = length - j ;
  156.                 if( ( i2<length ) && ( j2<length ) )
  157.                     a_mul[ j2 + i2*length ] = a_mul[ j + i*length ] ;
  158.             }
  159.         }
  160.     }
  161.     fdsp() ;
  162.     fftFlg = 1 ;
  163.  
  164.     return NOERR ;
  165. }
  166.  
  167. g_fft2_fix( BASICPARA *para )
  168. {
  169.     mx = para->mix ;
  170.     aSen = para->alphaSen ;
  171.     mSen = para->maskSen ;
  172.     cMax = para->colorMax ;
  173.     aMax = para->alphaMax ;
  174. //    x1 = para->lupx ;
  175. //    y1 = para->lupy ;
  176. //    x2 = para->rdwx ;
  177. //    y2 = para->rdwy ;
  178.     read1 = para->read1 ;
  179.     write = para->write ;
  180.     mask = para->mask ;
  181.  
  182.     int i, j, ex ;
  183.  
  184.     if( fftFlg == 0 )return NOERR ;
  185.  
  186.     ex = exp2 ;
  187.     if( ex == 0 )return NOERR ;
  188.  
  189.     for( i=0 ; i<length ; i++ )
  190.     {
  191.         for( j=0 ; j<length ; j++ )
  192.         {
  193.             aReal[ j + i*length ]
  194.             = aReal[ j + i*length ] * a_mul[ j + i*length ] / 0x10000 ;
  195.  
  196.             aImag[ j + i*length ]
  197.             = aImag[ j + i*length ] * a_mul[ j + i*length ] / 0x10000 ;
  198.  
  199.             a_mul[ j + i*length ] = 0x10000 ;
  200.         }
  201.     }
  202.     fdsp() ;
  203.     fftFlg = 1 ;
  204.  
  205.     return NOERR ;
  206. }
  207.  
  208. g_fft2_can( BASICPARA *para )
  209. {
  210.     mx = para->mix ;
  211.     aSen = para->alphaSen ;
  212.     mSen = para->maskSen ;
  213.     cMax = para->colorMax ;
  214.     aMax = para->alphaMax ;
  215. //    x1 = para->lupx ;
  216. //    y1 = para->lupy ;
  217. //    x2 = para->rdwx ;
  218. //    y2 = para->rdwy ;
  219.     read1 = para->read1 ;
  220.     write = para->write ;
  221.     mask = para->mask ;
  222.  
  223.     int i, j, ex ;
  224.  
  225.     if( fftFlg == 0 )return NOERR ;
  226.  
  227.     ex = exp2 ;
  228.     if( ex == 0 )return NOERR ;
  229.  
  230.     for( i=0 ; i<length ; i++ )
  231.     {
  232.         for( j=0 ; j<length ; j++ )
  233.         {
  234.             a_mul[ j + i*length ] = 0x10000 ;
  235.         }
  236.     }
  237.     fdsp() ;
  238.     fftFlg = 1 ;
  239.  
  240.     return NOERR ;
  241. }
  242.  
  243. g_fft2_inv( BASICPARA *para )
  244. {
  245.     mx = para->mix ;
  246.     aSen = para->alphaSen ;
  247.     mSen = para->maskSen ;
  248.     cMax = para->colorMax ;
  249.     aMax = para->alphaMax ;
  250. //    x1 = para->lupx ;
  251. //    y1 = para->lupy ;
  252. //    x2 = para->rdwx ;
  253. //    y2 = para->rdwy ;
  254.     read1 = para->read1 ;
  255.     write = para->write ;
  256.     mask = para->mask ;
  257.  
  258.     int i, j, ex ;
  259.  
  260.     if( fftFlg != 1 )return NOERR ;
  261.  
  262.     ex = exp2 ;
  263.     if( ex == 0 )return NOERR ;
  264.  
  265.     for( i=0 ; i<length ; i++ )
  266.     {
  267.         for( j=0 ; j<length ; j++ )
  268.         {
  269.             bReal[ j + i*length ]
  270.             = aReal[ j + i*length ] * a_mul[ j + i*length ] / 0x10000 ;
  271.  
  272.             bImag[ j + i*length ]
  273.             = aImag[ j + i*length ] * a_mul[ j + i*length ] / 0x10000 ;
  274.         }
  275.     }
  276.  
  277.     fft_2( work, bReal, bImag, ex, -1 ) ;
  278.  
  279.     for( i=0 ; i<length ; i++ )
  280.     {
  281.         for( j=0 ; j<length ; j++ )
  282.         {
  283.             char a[4] ;
  284.             int y0, r0, g0, b0 ;
  285.  
  286.             y0 = bReal[ j + i*length ] ;
  287.             yuvToRgb( y0, cb[ j + i*length ], cr[ j + i*length ],
  288.                                             &r0, &g0, &b0, cMax ) ;
  289.             a[0] = r0 ;
  290.             a[1] = g0 ;
  291.             a[2] = b0 ;
  292.             a[3] = 0 ;
  293.  
  294.             write( x1+j, y1+i, a ) ;
  295.         }
  296.     }
  297.  
  298.     fftFlg = 2 ;
  299.  
  300.     return NOERR ;
  301. }
  302.  
  303. g_fft2_dsp( BASICPARA *para )
  304. {
  305.     mx = para->mix ;
  306.     aSen = para->alphaSen ;
  307.     mSen = para->maskSen ;
  308.     cMax = para->colorMax ;
  309.     aMax = para->alphaMax ;
  310. //    x1 = para->lupx ;
  311. //    y1 = para->lupy ;
  312. //    x2 = para->rdwx ;
  313. //    y2 = para->rdwy ;
  314.     read1 = para->read1 ;
  315.     write = para->write ;
  316.     mask = para->mask ;
  317.  
  318.     if( fftFlg != 2 )return NOERR ;
  319.  
  320.     fdsp() ;
  321.     fftFlg = 1 ;
  322.  
  323.     return NOERR ;
  324. }
  325.  
  326. g_fft2_clr()
  327. {
  328.     if( fftFlg )
  329.         TL_free( buffer ) ;
  330.     fftFlg = 0 ;
  331.  
  332.     return NOERR ;
  333. }
  334.  
  335. static int fdsp()
  336. {
  337.     int i, j ;
  338.  
  339.     for( i=0 ; i<length ; i++ )
  340.     {
  341.         for( j=0 ; j<length ; j++ )
  342.         {
  343.             char a[4] ;
  344.             double abs ;
  345.  
  346.             abs = aReal[ j + i*length ]*aReal[ j + i*length ]
  347.                  + aImag[ j + i*length ]*aImag[ j + i*length ] ;
  348.             abs = sqrt( abs ) * a_mul[ j + i*length ] / 0x10000 ;
  349.             abs = log( abs ) * 255 / log( 255.0 ) ;
  350.             if( abs > 255 )abs = 255 ;
  351.             if( abs < 0 )abs = 0 ;
  352.             a[0] = abs ;
  353.             a[1] = abs ;
  354.             a[2] = abs ;
  355.             write( x1+j, y1+i, a ) ;
  356.         }
  357.     }
  358.  
  359.     return NOERR ;
  360. }
  361.  
  362. static rgbToYuv( int r0, int g0, int b0, int *y0, int *u0, int *v0, int max )
  363. {
  364.     int y, cb, cr ;
  365.  
  366.     y  =  19595*r0 + 38470*g0 + 7471*b0 ;
  367.     cb = -11049*r0 - 21699*g0 + 32748*b0 ;
  368.     cr =  32755*r0 -27427*g0 -5328*b0 ;
  369.  
  370.     *y0 = ( ((y/max)*219) >> 16 ) + 16 ;
  371.     *u0 = ( ((cb/max)*224) >> 16 ) + 128 ;
  372.     *v0 = ( ((cr/max)*224) >> 16 ) + 128 ;
  373.  
  374.     if( *y0 < 0 )*y0 = 0 ;
  375.     if( *y0 > 255 )*y0 = 255 ;
  376.     if( *u0 < 0 )*u0 = 0 ;
  377.     if( *u0 > 255 )*u0 = 255 ;
  378.     if( *v0 < 0 )*v0 = 0 ;
  379.     if( *v0 > 255 )*v0 = 255 ;
  380.  
  381.     return NOERR ;
  382. }
  383.  
  384. static yuvToRgb( int y0, int u0, int v0, int *r0, int *g0, int *b0, int max )
  385. {
  386.     y0 = (( y0 - 16 ) * max )/219 ;
  387.     u0 = (( u0 -128 ) * max )/224 ;
  388.     v0 = (( v0 -128 ) * max )/224 ;
  389.  
  390.     *r0 = ( 65536*y0 + 4*u0 + 91920*v0 ) >> 16 ;
  391.     *g0 = ( 65536*y0 - 22569*u0 - 46819*v0 ) >> 16 ;
  392.     *b0 = ( 65536*y0 + 116198*u0 - 9*v0 ) >> 16 ;
  393.  
  394.     if( *r0 < 0 )*r0 = 0 ;
  395.     if( *r0 > max )*r0 = max ;
  396.     if( *g0 < 0 )*g0 = 0 ;
  397.     if( *g0 > max )*g0 = max ;
  398.     if( *b0 < 0 )*b0 = 0 ;
  399.     if( *b0 > max )*b0 = max ;
  400.  
  401.     return NOERR ;
  402. }
  403.  
  404.