tmndec.c

H263的解码编码器

      getpicture(&framenum);
      
      framenum++;
    }

  } while (loopflag);

  close(base.infile);
  stopTime = clock();
  runtime = (stopTime - startTime) / 10;
  if (!quiet && runtime!=0)
	  printf("%d.%02d seconds, %d frames, %d.%02d fps\n",
	  runtime/100, runtime%100,
	  framenum, ((10000*framenum+runtime/2)/runtime)/100,
	  ((10000*framenum+runtime/2)/runtime)%100);
  
  if (icpClose(icpInst))
	  printf("Error: Can not close ICP ... \n");
  printf("Done \n");
  
  return 0;
}

static void initdecoder()
{
	int i, cc, size;
	FILE *cleared;
	
	/* clip table */
	if (!(clp=(unsigned char *)malloc(1024)))
		error("malloc failed\n");
	
	clp += 384;
	
	for (i=-384; i<640; i++)
		clp[i] = (i<0) ? 0 : ((i>255) ? 255 : i);
	
	/* MPEG-1 = TMN parameters */
	matrix_coefficients = 5;
	
	switch (source_format) 
	{
    case (SF_SQCIF):
		horizontal_size = 128;
		vertical_size = 96;
		break;
    case (SF_QCIF):
		horizontal_size = 176;
		vertical_size = 144;
		break;
    case (SF_CIF):
		horizontal_size = 352;
		vertical_size = 288;
		break;
    case (SF_4CIF):
		horizontal_size = 704;
		vertical_size = 576;
		break;
    case (SF_16CIF):
		horizontal_size = 1408;
		vertical_size = 1152;
		break;
    default:
		printf("ERROR: Illegal input format\n");
		exit(-1);
		break;
	}
	
	
	mb_width = horizontal_size/16;
	mb_height = vertical_size/16;
	coded_picture_width = horizontal_size;
	coded_picture_height = vertical_size;
	chrom_width =  coded_picture_width>>1;
	chrom_height = coded_picture_height>>1;
	blk_cnt = 6;
	
	for (cc=0; cc<3; cc++) 
	{
		if (cc==0)
			size = coded_picture_width*coded_picture_height;
		else
			size = chrom_width*chrom_height;
		
		if (!(refframe[cc] = (unsigned char *)malloc(size)))
			error("malloc failed\n");
		
		if (!(oldrefframe[cc] = (unsigned char *)malloc(size)))
			error("malloc failed\n");
		
		if (!(bframe[cc] = (unsigned char *)malloc(size)))
			error("malloc failed\n");
	}
	
	for (cc=0; cc<3; cc++) 
	{
		if (cc==0) 
		{
			size = (coded_picture_width+64)*(coded_picture_height+64);
			if (!(edgeframeorig[cc] = (unsigned char *)malloc(size)))
				error("malloc failed\n");
			edgeframe[cc] = edgeframeorig[cc] + (coded_picture_width+64) * 32 + 32;
		}
		else 
		{
			size = (chrom_width+32)*(chrom_height+32);
			if (!(edgeframeorig[cc] = (unsigned char *)malloc(size)))
				error("malloc failed\n");
			edgeframe[cc] = edgeframeorig[cc] + (chrom_width+32) * 16 + 16;
		}
	}
	
	if (expand)
	{
		for (cc=0; cc<3; cc++) 
		{
			if (cc==0)
				size = coded_picture_width*coded_picture_height*4;
			else
				size = chrom_width*chrom_height*4;
			
			if (!(exnewframe[cc] = (unsigned char *)malloc(size)))
				error("malloc failed\n");
		}
	}
	
	/* Clear output file for concatenated storing */
	if (outtype == T_YUV_CONC) 
	{
		if ((cleared = fopen(outputname,"wb")) == NULL) 
			error("couldn't clear outputfile\n");
		else
			fclose(cleared);
	}
	/* IDCT */
	init_idct();
	
	SetupICP(); 
	
}


void error(text)
char *text;
{
  fprintf(stderr,text);
  exit(1);
}

/* trace output */
void printbits(code,bits,len)
int code,bits,len;
{
  int i;
  for (i=0; i<len; i++)
    printf("%d",(code>>(bits-1-i))&1);
}

/* option processing */
static void options(argcp,argvp)
int *argcp;
char *argvp[];
{
 	while (*argcp>1 && (argvp)[1][0]=='-')
  {
    while ((argvp)[1][1])
    {
      switch (toupper((argvp)[1][1]))
      {
      case 'F':
        framerate = getval(argvp);
        break;
      case 'V':
        verbose = getval(argvp);
        break;
      case 'O':
        outtype = getval(argvp);
        break;
      case 'R':
        refidct = 1;
        break;
      case 'L':
        loopflag = 1;
        break;
      case 'X':
        expand = 1;
        break;
      case 'T':
        trace = 1;
        break;
      case 'Q':
        quiet = 1;
        break;
      default:
        fprintf(stderr,"undefined option -%c ignored\n",(argvp)[1][1]);
      }

      (argvp)[1]++;
    }

    (argvp)++;
    (*argcp)--;
  }


  if (outtype != T_X11 && outtype != T_WIN) 
  {
    loopflag = 0;  /* No looping for output to file */
    framerate = 0; /* No delay necessary when output to file */
  }
  if (outtype==T_X11)
  {
    (*argcp)++; /* fake outfile parameter */
  }
  if (outtype==T_WIN)
  {
    (*argcp)++; /* fake outfile parameter */
  }

  /*
  if (*argcp!=3 && *argcp!=4)
  {
    printf("\n%s\n",version);
    printf("Usage:   tmndecode {options} bitstream {outputfilename%%d}\n\
Options: -vn  verbose output (n: level)\n\
         -on  output format \n\
              n=0 : YUV\n\
              n=1 : SIF\n\
              n=2 : TGA\n\
              n=3 : PPM\n");
#ifdef DISPLAY
    printf("\
              n=4 : X11 Display\n");
#endif
    printf("\
              n=5 : YUV concatenated\n");
#ifdef WINDOWS
    printf("\
              n=6 : Windows 95/NT Display\n");
#endif
    printf("\
              You have to choose one output format!\n\
         -q   disable warnings to stderr\n\
         -r   use double precision reference IDCT\n\
         -t   enable low level tracing\n");
#ifdef DISPLAY
    printf("\
         -x   interpolate pictures to double size before display\n");
#endif
#ifdef USE_TIME
    printf("\
         -fn  frame rate\n\
              n=0  : as fast as possible\n\
              n=99 : read frame rate from bitstream (default)\n");
#endif    
#ifdef DISPLAY
    printf("\
         -l   loop sequence\n");
#endif
#ifdef WINDOWS
    printf("\
         -l   loop sequence\n");
#endif
	exit(0);
  }
  */
}

static int getval(argv)
char *argv[];
{
  int val;

  if (sscanf(argv[1]+2,"%d",&val)!=1)
    return 0;

  while (isdigit(argv[1][2]))
    argv[1]++;

  return val;
}


void doframerate(int pb)
{
  long currentTime;
  int diffTime;
  const float REF_FRAME_RATE = (float)29.97;

  /* Compute desired frame rate */
  if (framerate <= 0)
    return;
  
  if (framerate != 99) 
  {
    targetTime += 1000 / framerate;
  }
  else {
    if (pb) {
      targetTime += (int)(1000 / (REF_FRAME_RATE/trb));
    }
    else {
      targetTime += (int)(1000 / (REF_FRAME_RATE/(trd-trb)));
    }
  }

  /* this is where we are */
  currentTime = clock();

  
  diffTime = targetTime - currentTime;

  /* See if we are already lagging behind */
  if (diffTime <= 0)
    return;
  
  /* Spin for awhile */
  sleep(diffTime);   
     /* this is not a very accurate timer */
}