tc.y

用于TM1300/PNX1300系列DSP（主要用于视频处理）的各种滤波器源码

%token <i>	VERBOSE BLOCKS RESET RANDOM IEEE1180 H263 PRINT RANGE STATE INTEGERS
%token <d>	FCON INF
%token <i>	ICON
%token <i>	RND MIN MAX TRANSPOSE SHUFFLE REDIR
%token <i>	DC AC DCT INV FAST DCT2 SEP  COMMENT
%token <i>	VAR SCALE WIDTH _BEGIN END
%token <s>	SHELL ROWS COLS LS RS _4POINT _8POINT STRING DATA LET SET DUMP  OPTION

%type <d> fcon
%left MIN MAX RND
%left '*' '/' '+' '-'
%left DCT INV TRANSPOSE SHUFFLE
%left AC
%left DC

%type <v>	scalar_expr_list
%type <v>	expr
%type <i>	o_mode o_fwd	


%{
#include <stdio.h>
#include "tc.h"
VALU	varnames[MAXVAR];

void	dct1d();
void	fdct2d();
void	idct2d();
void	fast_8x8dct();
void	fast_8x8idct();
void	dct2dsep();
void	dct4();
void	fixdct8();
void	floatdct8();
void	dct8x8();
void	not_a_dct();
char	*toname();
int myround(double *tabval, double *ptres, double fact);
FILE *fileout = stdout;


struct {
	int lwb;
	int upb;
	int sign;
} opt;

static void (*mapfunc[])() =
{
  idct2d, fdct2d,
  dct1d,  dct1d,
  fast_8x8idct, fast_8x8dct,
  floatdct8,	floatdct8,
  dct2dsep, dct2dsep,
  dct4, dct4,
};

%}

%%
program:
	  line
	| line program
	;

line:
	  command o_redir
	    { if (fileout != stdout) fclose(fileout); fileout = stdout; }
		'\n'
	;

o_redir:
	  REDIR
	|
	;

command:
	 VAR '=' expr
	    {
	      varnames[$1] = $3; 
              fprintf(fileout, "e%d =", $1, $3);		
	      printfloat($3.v, 0, $3.dim[0], $3.dim[1], fileout);
	    } 
	| DUMP STRING expr 
	    {
             FILE *fp;
	     if ((fp = fopen($2, "w"))) {
	       printfloat($3.v, 0, $3.dim[0], $3.dim[1], fp);
	       fclose(fp);
             }
	    }
	|	/* null line */
	| _BEGIN STRING
	    {
		extern FILE *yyin;

		if (yyin == stdin) {
		  if ((yyin = fopen($2, "r")) == 0) {
			fprintf(stderr, "Cannot open input %s\n", $2);
			yyin = stdin;
		  } else
		    ungetc('\n', yyin);
		} else
		  fprintf(stderr, "begin nesting not allowed\n");
	    } 
	| END
	    {
		extern FILE *yyin;
		if (yyin != stdin) {
		  fclose(yyin);
		  yyin = stdin;
		} else
		  exit(0);
	    }
	| expr
	    {
	      varnames[varno = (varno+1) % MAXVAR] = $1; 
              fprintf(fileout, "e%d =", varno);		
	      printfloat($1.v, 0, $1.dim[0], $1.dim[1], fileout);
	    } 
	| VAR
	    {
	      int vn;
	      vn = $1;
              fprintf(fileout, "e%d =", vn);		

	      printfloat(varnames[vn].v, 0,
			 varnames[vn].dim[0],
			 varnames[vn].dim[1], fileout);
	    }
	| SET OPTION ICON
	    {
	      if (!strcmp($2, "scale"))
		state->scale = $3;
	      else if (!strcmp($2, "width"))
		state->width = $3;
	      else if (!strcmp($2, "verbose"))
		state->verbose = $3;		
	      else if (!strcmp($2, "blocks"))
		state->nblocks = $3;
	      else if (!strcmp($2, "clip"))
		state->clip = $3;
	      else if (!strcmp($2, "onepass"))
		state->onepass = $3;
	      else
		fprintf(fileout, "Unknown option %s\n");
	    }		
	| RESET		{ reset(); }
	| SET
	  {
	     fprintf(fileout, "set -scale %d\n", state->scale);  
	     fprintf(fileout, "set -width %d\n", state->width);  
	     fprintf(fileout, "set -verbose %d\n", state->verbose);
	     fprintf(fileout, "set -blocks %d\n", state->nblocks);
	     fprintf(fileout, "set -clip %d\n", state->clip);  
	     fprintf(fileout, "set -onepass %d\n", state->onepass);  
	   }
	| SHELL	{ system(&$1[1]); }
	| COMMENT { fprintf(fileout, "%s\n", $1); }
	| IEEE1180 option_list
	  {
	    VALU input, fwd, ref, test;
	    int i, j;
	    const	char	*con[2]	= {"succeeded", "failed"};
	    double	b_f[64], b_t[64], b_r[64], b_i[64];
	    double	b_e[64], b_s[64];	/* error and square of current block */
	    double	peak_e[64], peak_s[64];	/* peak values along blocks */ 
	    double	cum_e[64], cum_s[64];	/* cumulative values along blocks */ 
	    double	mean_e[64], mean_s[64];	/* mean values along blocks */
	    double	overall_e, overall_s;	/* overall mean values */
	    double	peak_p_e, peak_mean_e, peak_mean_s;
	    int	failed_p_p_e	= 0; 	/* a pixel peak error is too large */
	    int exit_code;
	    FILE *fp1, *fp2;
	    short buf_t[64], buf_r[64];

	    for(i=0; i<64; i++)
	      peak_e[i] = cum_e[i] = cum_s[i] = 0;

	    for (j=0; j<state->nblocks; j++) {
	      for(i=0; i<64; i++)
		b_i[i] = rand_dct(-opt.lwb, opt.upb) * opt.sign ;
	      fdct2d(b_i, b_f, 8, 8, 0);
	      myround(b_f, b_f, 1.0);

	      idct2d(b_f, b_r, 8, 8, 0);

	      myround(b_r, b_r, 1.0);
	      blockmin(b_r, b_r, -state->clip-1);
	      blockmax(b_r, b_r,  state->clip);

	      fast_8x8idct(b_f, b_t, 8, 8, 0);

	      for(i=0; i<64; i++) {
		b_e[i] = b_t[i] - b_r[i];
		b_s[i] = b_e[i] * b_e[i];
		peak_e[i] = max(peak_e[i], fabs(b_e[i]));
		cum_e[i] += b_e[i];
		cum_s[i] += b_s[i];
	      }
	    }


	    peak_p_e = peak_mean_e = peak_mean_s = 0.0;
	    overall_e = overall_s = 0.0;

	    for (i=0; i<64; i++) {
	      mean_e[i] = cum_e[i] / state->nblocks;
	      mean_s[i] = cum_s[i] / state->nblocks;
	      peak_p_e	= max(peak_p_e, peak_e[i]);
	      peak_mean_s = max(peak_mean_s, mean_s[i]);
	      peak_mean_e = max(peak_mean_e, fabs(mean_e[i]));
	      overall_s += mean_s[i];
	      overall_e += mean_e[i];
	    }

	    overall_e	/= 64.;
	    overall_s	/= 64.;

	    /* check thresholds */

	    exit_code = 0;
	    if (peak_p_e > THR_PIXEL_PEAK_ERROR) exit_code |= failed_p_p_e ;
	    if (peak_mean_s > THR_PIXEL_MEAN_SQUARE_ERROR) exit_code |= failed_p_m_s ;
	    if (overall_s > THR_OVERALL_MEAN_SQUARE_ERROR) exit_code |= failed_o_m_s ;
	    if (peak_mean_e > THR_PIXEL_ABS_MEAN_ERROR   ) exit_code |= failed_p_m_e ;
	    if(fabs(overall_e)>THR_OVERALL_ABS_MEAN_ERROR) exit_code |= failed_o_m_e ;

	    fprintf(fileout, "\n************************************************************\n\
 dataset characteristics: \n\tsize : \t%d blocks\n\
\trange:\t[%d:%d]\n\tsign:\t%s\n",
		     state->nblocks,opt.lwb,opt.upb,toname(opt.sign));

	    /* print dct maps */

	    if	(state->verbose) {
		fprintf(fileout, "\nDCT maps\n________\n");
		fprintf(fileout, "\n___________________________________________\n\n");
		printfloat(peak_e, "peak error", 8, 8, fileout);
		fprintf(fileout, "\n___________________________________________\n\n");
		printfloat(mean_s, "pixel mean square error", 8, 8, fileout);
		fprintf(fileout, "\n___________________________________________\n\n");
		printfloat(mean_e, "pixel mean error", 8, 8, fileout);
	      }

	    /* print conclusion */
	    /* print summary */

	    fprintf(fileout, "\nResults\n_______\n");
	    fprintf(fileout, "\nmeasure\t\t\t\tresult\tthreshold\tconclusion\n\n");
	    fprintf(fileout, "pixel peak error\t\t%.0f\t%.0f\t\t%s\n",
		   peak_p_e, THR_PIXEL_PEAK_ERROR, iserr(failed_p_p_e));
	    fprintf(fileout, "pixel mean square error\t\t%.3lf\t%.3lf\t\t%s\n",
		   peak_mean_s, THR_PIXEL_MEAN_SQUARE_ERROR, iserr(failed_p_m_s));
	    fprintf(fileout, "overall mean square error\t%.3lf\t%.3lf\t\t%s\n",
		   overall_s, THR_OVERALL_MEAN_SQUARE_ERROR, iserr(failed_o_m_s));
	    fprintf(fileout, "pixel mean error\t\t%.3lf\t%.3lf\t\t%s\n",
		   peak_mean_e, THR_PIXEL_ABS_MEAN_ERROR, iserr(failed_p_m_e));
	    fprintf(fileout, "overall mean error\t\t%.4lf\t%.4lf\t\t%s\n",
		   overall_e, THR_OVERALL_ABS_MEAN_ERROR, iserr(failed_o_m_e));
	    if (exit_code)
	      fprintf	(fileout, "\n\n*** Inverse DCT does NOT comply with accuracy requirements\n");
	    else
	      fprintf (fileout, "\n\n- Inverse DCT complies with accuracy requirements\n");	
	  }
	| error
	;

option_list:
	  option
	| option option_list
	;

option:
	  OPTION ICON
	    { 	
	      if (!strcmp($1, "lwb"))
		opt.lwb = $2;
	      else if (!strcmp($1, "upb"))
			opt.upb = $2;
	      else if (!strcmp($1, "sgn"))
			opt.sign = $2;
	    }
	;

expr:
	  DC ICON
	  {
	    int i, j;
            $$.dim[0] = 1;
	    $$.dim[1] = $2;	     
	    for (i=0; i<$2; i++)
		$$.v[i] = 1;
	  }
	| ICON DC ICON
	  {
	   int i, j;
            $$.dim[0] = $1;
	    $$.dim[1] = $3;
	    for (i=0; i<$1; i++)
	      for (j=0; j<$3; j++)
		$$.v[i*$1+j] = 1;

	  }
	| expr ROWS ICON
	  {
	    $$ = $1;
	    if ($$.dim[0] != 1  || ($$.dim[1]%$3)) {
		fprintf(stderr, "ill formed matrix");
            } else {
		$$.dim[0] =  $3;
	        $$.dim[1] = $$.dim[1] / $3;
	    }
	  } 
	| expr COLS ICON
	  {
	    $$ = $1;
	    if ($$.dim[0] != 1  || ($$.dim[1]%$3)) {
		fprintf(stderr, "ill formed matrix");
            } else {
		$$.dim[0] = $$.dim[1] / $3;
	        $$.dim[1] = $3;
	    }
	  } 
	| DATA STRING
	   {
             FILE *fp;
	     char delim;
	     int n, ix, wd;

	     char buf[512];	
	     $$.dim[0] = 0;
	     $$.dim[1] = 0;  
	     ix = 0;
	     if ((fp = fopen($2, "r"))) {
	       while (fscanf(fp, "%d%c", &wd, &delim) == 2) {
		 $$.v[ix++] = wd; 
		 if (delim=='\n') {
		   $$.dim[0]++; 
		   if ($$.dim[1]==0)
		     $$.dim[1] = ix;
		   else if (ix % $$.dim[1] != 0)
		     fprintf(stderr, "ill formed dimension, line %d\n",
			     $$.dim[0]);
		 }
	       }
	     } else
	       fprintf(stderr, "Cannot open %s\n", $2);
	     fclose(fp);
          }
	| INTEGERS ICON 
	  {
	     int i;
	     $$.dim[0] = 1;
	     $$.dim[1] = $2;
	     for (i=1; i<=$2; i++)
		$$.v[i] = i;
	   }
	| expr RS ICON
	  {
	    $$ = $1;
	    if ($$.dim[0] != 1) {
		fprintf(stderr, "ill formed vector");
            } else {
		$3 = ($3 + $$.dim[1]) % $$.dim[1]; 
		reflect($$.v, $$.dim[1]);
		reflect($$.v, $3);
		reflect($$.v + $3, $$.dim[1] - $3);
	    }
	  } 
	| expr LS ICON
	  {
	    $$ = $1;
	    if ($$.dim[0] != 1) {
		fprintf(stderr, "ill formed vector");
            } else {
		$3 = ($$.dim[1] - $3) % $$.dim[1]; 
		reflect($$.v, $$.dim[1]);
		reflect($$.v, $3);
		reflect($$.v + $3, $$.dim[1] - $3);
	    }
	  } 
	| '(' expr ')'
	  {
	    $$ = $2;
	  }
	| ICON AC ICON 
	  {
            int i, j;

            $$.dim[0] = $$.dim[1] = 8;	     
	    for (i=0; i<8; i++)
	      for (j=0; j<8; j++)
		$$.v[i*8+j] = (i^j)& 1 ? $3 : $1;
	  }
	| o_mode o_fwd DCT expr
	  {
	    void (*func)();
	    int o_dim;
            int ix;

	    o_dim = $4.dim[0]==1 ? O_DIM1D : 0;
	    $$ = $4;
	    ix = $1|$2|o_dim;	
	    func = mapfunc[ix];
	    (*func)($4.v, $$.v, $4.dim[0], $4.dim[1], $2);
	  }
	| TRANSPOSE expr
	  {
	     int i, j;
	     
	     $$ = $2;
	     $$.dim[0] = $2.dim[1];
	     $$.dim[1] = $2.dim[0];
	    for (i=0; i<$$.dim[0]; i++)
	      for (j=0; j<$$.dim[1]; j++)
		$$.v[i*$$.dim[1] + j] = $2.v[j*$$.dim[0] + i];
	  }
	| expr MIN fcon
	  {
	    $$ = $1;
	    blockmin($1.v, $$.v, $3);
	  }
	| expr MAX fcon
	  {
	    $$ = $1;
	    blockmax($1.v, $$.v, $3);
	  }
	| expr RND fcon
	    {
	      $$ = $1;
	      myround($1.v, $$.v, $3);
            }
	| expr '*' fcon
	    {
	      int i;
	      $$ = $1;
	      for (i=0; i<64; i++)
		$$.v[i] = $1.v[i] * $3;
            }
	| expr '+' fcon
	    {
	      int i;
	      $$ = $1;
	      for (i=0; i<64; i++)
		$$.v[i] = $1.v[i] + $3;
            }
	| expr '-' fcon
	    {
	      int i;
	      $$ = $1;
	      for (i=0; i<64; i++)
		$$.v[i] = $1.v[i] - $3;
            }
	| expr '/' fcon
	    {
	      int i;

	      $$ = $1;
	      for (i=0; i<64; i++)
		$$.v[i] = $1.v[i] / $3;
            }
	| expr '*' expr
	    {
	      int i, j, dim1, dim2;

	      $$.dim[0] = max($1.dim[0], $3.dim[0]);