mptest.c

用于TM1300/PNX1300系列DSP（主要用于视频处理）的外部设备的源码

  if(livp->mpEmpty){
    livp->mpEmpty = 0;
    refill_bitbuf((UInt32) livp);
  }

#endif
  if(TMLIBDEV_OK != (error = mpGetBits(livp->pipeInstance, n, &temp))){
    MY_DP(("mpGetBits failed \n"));
    exit(1);
  }
  return temp;
} /* get_bits() */

/**********************************************************/
/* read n VLD SR bits without shifing; 0 <= n <= 16) */
/**********************************************************/
static int show_bits(ptm2MpegDecInstVars_t livp,unsigned n)
{
  unsigned long temp,error;

#ifdef FILEIO
  if(livp->mpEmpty){
    livp->mpEmpty = 0;
    refill_bitbuf((UInt32) livp);
  }
#endif

  if(TMLIBDEV_OK != (error = mpShowBits(livp->pipeInstance, n, &temp))){
    PRINT(("mpShowBits failed %d\n",error));
    
  }
  return temp;
} /* show_bits() */

/**********************************************************/
/* search for next start code */
/**********************************************************/
unsigned long  find_start_code(ptm2MpegDecInstVars_t livp)
{
  unsigned long error,code;

#ifdef FILEIO
  if(livp->mpEmpty){
    livp->mpEmpty = 0;
    refill_bitbuf((UInt32) livp);
  }
  livp->mpDone = 0;
#endif
#ifdef FILEIO
  if(TMLIBDEV_OK != (error = mpNextStartCode(livp->pipeInstance,False))){
    PRINT(("vldNextStartCode failed %d\n",error));
    exit(1);
  }
  while(!livp->mpDone){
    if(livp->mpEmpty){
      livp->mpEmpty = 0;
      refill_bitbuf((UInt32) livp);
    }
  }
#else
  if(TMLIBDEV_OK != (error = mpNextStartCode(livp->pipeInstance,True ))){
    PRINT(("vldNextStartCode failed %d\n",error));
    exit(1);
  }
#endif
  code = 0x100|show_bits(livp,8);
  return code;
}

/**********************************************************/
/* search for next sequence start code */
/**********************************************************/
void  find_seq_start_code(ptm2MpegDecInstVars_t livp)

{
  UInt32 code;

#ifdef FILEIO
  if(TMLIBDEV_OK != mpNextGivenStartCode(livp->pipeInstance, SEQUENCE_HEADER_CODE & 0xff,False)){    
    code = 0x100|show_bits(livp,8);
    PRINT(("Unable to recognize stream type (%08x)\n", code));
    exit(1);
  }
  
  while(!livp->mpDone){
    if(livp->mpEmpty){
      livp->mpEmpty = 0;
      refill_bitbuf((UInt32) livp);
    }
  }

#else

  if(TMLIBDEV_OK != mpNextGivenStartCode(livp->pipeInstance, SEQUENCE_HEADER_CODE & 0xff, True)){
    code = 0x100|show_bits(livp,8);
    PRINT(("Unable to recognize stream type (%08x)\n", code));
    exit(1);
  }
#endif

}

/**********************************************************/
/* perform error concealment on picture */
/**********************************************************/
static void
conceal_error(ptm2MpegDecInstVars_t livp, unsigned long *startcode)
{
  unsigned long sr_cker,code;
  unsigned int start_row, start_col;

  MY_DP(("conceal_error mc_status %x\n",mpGetMC_STATUS()));
  start_col = mpGetMC_STATUS() & 0xff;
  start_col -= (start_col > 1) ? 2 : 0;
  start_row = (mpGetMC_STATUS() & 0xff00) >> 8;
  
  /* error handling */
  sr_cker = mpGetSR_VALUE();
  if(TMMPCALLBACK_OK !=
     mpResetAndRecover(livp->pipeInstance)) {
    PRINT(("Reset failed\n"));
    exit(1);
  }
  if(sr_cker != mpGetSR_VALUE()){
    exit(sr_cker);
  }
  MY_DP(("Reset done\n"));
  program_mmio(livp);
  livp->mpDone = 0;

#ifdef FILEIO

  mpNextStartCode(livp->pipeInstance, False);
  while(!livp->mpDone){
    if(livp->mpEmpty){
      livp->mpEmpty = 0;
      refill_bitbuf((UInt32) livp);
    }
  }

#else
  mpNextStartCode(livp->pipeInstance, True);
#endif
  *startcode = 0x100|show_bits(livp,8);
  code = *startcode;
  MY_DP(("Startcode = %x (last)slice_start_code =%x\n",code,livp->slice_start_code));
  if(code >= SLICE_START_CODE_MIN && code <= SLICE_START_CODE_MAX  && code > livp->slice_start_code) {
    MY_DP(("issue error con1 at %x %x \n",start_row,start_col));
    mpErrorCon(livp->pipeInstance, start_row, start_col, 0, 0);
  }
  
  else {

    MY_DP(("issue error con2 at %x %x \n",start_row,start_col));
    mpErrorCon(livp->pipeInstance, start_row, start_col, livp->pictureHeight, 0);
    MY_DP(("issue flush\n"));
    mpFlushPipe(livp->pipeInstance);

      /* We may have lost a picture header. Find the next*/
    if (code < livp->slice_start_code){
      livp->mpDone = 0;
      if(TMLIBDEV_OK != 
	 mpNextGivenStartCode(livp->pipeInstance, PICTURE_START_CODE & 0xff,False)){
	PRINT(("Invalid start code (%08x)\n", code));
	exit(1);
      }
      while(!livp->mpDone){
	if(livp->mpEmpty){
	  livp->mpEmpty = 0;
	  refill_bitbuf((UInt32) livp);
	}
      }
      code = 0x100|show_bits(livp,8);
    }
  }
}



/**************************************************************************
 main()
**************************************************************************/
void main(int argc, char **argv)
{
  unsigned long code;
  mpInstanceSetup_t mpISetup;
  tm2MpegDecInstVars_t linst, *ivp;
  int i,argcc;
  FILE *fp;

  int halfResMode     = 0;
  int noYVertHalfPel  = 0;
  int noUVVertHalfPel = 0;
  int noBackwardMC    = 0;

  DPsize(32000*10);

  i=1;
  argcc = argc;


#ifdef FILEIO
  printf("\nmptest:  mp (mpeg-pipe) device library example\n\n");

  if (argc <  3) {
    printf("Usage: -file <Bitstream file> OR -filelist <Bitstream file listing> [options]\n");
    printf("\nOptions: -s <framenum> start framestore at framenum\n");
    printf("         -z half res mode\n");
    printf("         -j No vertical interpolation for Y\n");
    printf("         -k No vertical interpolation for UV\n");
    printf("         -m No backward prediction for B pics\n");    
    exit(-1);
  }

  if (strcmp(argv[1], "-file") == 0) {
    strcpy(fn,argv[2]);
    for (i=0; (fn[i] != '.') && (fn[i] != 0) ; i++) {
      FrameName[i] = fn[i];
    }
    FrameName[i]=0;
  
    printf("Doing %s\n",FrameName);
    
    if (( bitsfile = open(fn, O_RDONLY | O_BINARY )) == -1 ) {
      printf("Error opening bitstream '%s'. Exiting \n",fn);
      exit(-1);
    }
    
  }
  else if (strcmp(argv[1], "-filelist") == 0) {
    strcpy(fn, argv[2]);
    filelist = 1;
  }
  else {
    printf("Invalid argument.%s Exiting\n",argv[1]);
    exit(1);
  }

  argcc -= 2;
  i=3;
  
  argcc -= 1;
  while(argcc > 0) {
    if (strcmp(argv[i], "-z") == 0) {
      PRINT(("Half res mode enabled\n"));
      halfResMode = 1;
      argcc--;
      i++;
    }
    else if (strcmp(argv[i], "-j") == 0) {
      PRINT(("No vertical interpolation for Y component enabled\n"));
      noYVertHalfPel = 1;
      argcc--;
      i++;
    }
    else if (strcmp(argv[i], "-k") == 0) {
      PRINT(("No vertical interpolation for UV component enabled\n"));
      noUVVertHalfPel = 1;
      argcc--;
      i++;
    }
    else if (strcmp(argv[i], "-m") == 0) {
      PRINT(("No backward prediction for B pictures enabled\n"));
      noBackwardMC = 1;
      argcc--;
      i++;
    }
    else if (strcmp(argv[i], "-s") == 0) {
      start_display = atoi(argv[i+1]);
      PRINT(("Start Display at %d\n",start_display));
      argcc-=2;
      i+=2;
    }

  }

#else
  PRINT(("\nmptest:  mp (mpeg-pipe) device library example\n\n"));
#endif

  ivp = &linst;
  memset(ivp, 0, sizeof(tm2MpegDecInstVars_t));

  if(TMLIBDEV_OK != mpOpen(&(ivp->pipeInstance))){
    PRINT(("MP open failed\n"));
    exit(1);
  }

  ivp->halfResMode     = halfResMode;
  ivp->noYVertHalfPel  = noYVertHalfPel;
  ivp->noUVVertHalfPel = noUVVertHalfPel;
  ivp->noBackwardMC    = noBackwardMC;
  ivp->IQSel0          = 0;
  ivp->IQSel1          = 0;

  mpISetup.parentID      = (UInt32) ivp;
#ifdef FILEIO
  mpISetup.mpEmptyFunc   = empty_stub;
#else
  mpISetup.mpEmptyFunc   = refill_bitbuf;
#endif
  mpISetup.mpErrorFunc   = handle_error;
  mpISetup.mpSuccessFunc = handle_success;
  /* Use default slice header parse in library */
  mpISetup.mpSliceFunc   = NULL;

  mpISetup.mpReqCompleteFunc = set_done_flag;
  mpInstanceSetup(ivp->pipeInstance, &mpISetup);

#ifdef FILEIO
  bits=(unsigned char*)_cache_malloc(BITBUFSIZE,1);
#endif

  while (1) {
    ivp->prevDMAAddr = &(bitstream[0]);
    ivp->prevDMACount = 0;
    refill_bitbuf((UInt32) ivp);
    ivp->mpEmpty = 0;

  PRINT(("TM2 MPEG Decoder: Finding sequence start code...\n"));

  ivp->mpDone = 0;

  find_seq_start_code(ivp);

  while(1) {
    unsigned int row,col;

    parse_headers(ivp,&(ivp->ph));
  
#ifdef FILEIO      
    if (sequence_done)
      if (input_done) { 
	if (filelist == 0){
#ifdef LOOP
	  break;
#else	  
	  close(bitsfile);
	  exit(0);
#endif
	}
	else {
	  close(bitsfile);
	  /* re-init */
	  bitsfile=0;
	  sequence_done = 0;
	  start_display = 0;
	  /* Be sure we start counting over */
	  ivp->secondField       = 0;
	  ivp->bitstreamFramenum = 0;
	  ivp->sequenceFramenum  = 0;  
	  if(TMMPCALLBACK_OK != mpReset(ivp->pipeInstance)) {
	    PRINT(("Reset failed\n"));
	    exit(1);
	  }
	  break;
	}
      }
      else {
      	sequence_done = 0;
	start_display = ivp->sequenceFramenum;
	find_seq_start_code(ivp);       
	continue;
      }

#endif

    program_mmio(ivp);
    
    code = 0x100|show_bits(ivp,8);
    /* wait for 1st slice of picture to kick off decoding of entire picture */
    if(code >= SLICE_START_CODE_MIN && code <= SLICE_START_CODE_MAX) {
      while(code >= SLICE_START_CODE_MIN && code <= SLICE_START_CODE_MAX) {
	parse_slice((UInt32) ivp);
	ivp->callbackError = VDEC_MPEG_CALLBACK_OK;
	ivp->mpDone = 0;

#ifdef FILEIO
	mpDecodeRows(ivp->pipeInstance, ivp->pictureHeight+1,False);
	
	while(!ivp->mpDone){
	  if(ivp->mpEmpty){
	    ivp->mpEmpty = 0;
	    refill_bitbuf((UInt32) ivp);
	  }
	}	
#else
	mpDecodeRows(ivp->pipeInstance,(code & ~0x100) + ivp->pictureHeight,True);
#endif

	code = 0x100|show_bits(ivp,8);
	switch(ivp->callbackError){
	case VDEC_MPEG_ERROR_FAIL:
	  PRINT(("Bitstream error detected. %x\n", ivp->sequenceFramenum));

#ifdef ERROR_CON
	  conceal_error(ivp,&code);
#else
	  exit(0);
#endif
	  break;
	case VDEC_MPEG_SLICE_FAIL:
	case VDEC_MPEG_CALLBACK_OK:
	  ivp->callbackError &= ~(VDEC_MPEG_SLICE_FAIL);
	  break;
	default:
	  PRINT(("Unknown MP callback error %d \n",ivp->callbackError));
	}
      }           
      col = mpGetMC_STATUS() & 0xff;
      row = (mpGetMC_STATUS() & 0xff00) >> 8;
      if((col != ivp->MBWidth - 1) || (row != ivp->pictureHeight - 1)){
	MY_DP(("row %d col %d ivp->MBWidth ivp->pictureHeight %d %d \n",row,col,ivp->MBWidth,ivp->pictureHeight));
      }

      PRINT(("Pic #%d complete\n",ivp->sequenceFramenum));

      if (ivp->sequenceFramenum>start_display) {
	  if(ivp->ph.picture_structure==FRAME_PICTURE || ivp->secondField) {
#ifdef SELF_CHECK
          program_vout_mmio(ivp);
#elif WRITE_TO_FILE
	  putpic(ivp);       
#else

#endif
	  }
      }
   
      if(ivp->ph.picture_structure!=FRAME_PICTURE)
        ivp->secondField = !ivp->secondField;

      if(!ivp->secondField) {
        ivp->bitstreamFramenum++;
        ivp->sequenceFramenum++;
      }
    }
  }
#ifdef LOOP
  input_done = 0;
  sequence_done = 0;
  start_display = 0;
  ivp->secondField       = 0;
  ivp->bitstreamFramenum = 0;
  ivp->sequenceFramenum  = 0;  
  if(TMMPCALLBACK_OK != mpReset(ivp->pipeInstance)) {
    PRINT(("Reset failed\n"));
    exit(1);
  }
  lseek(bitsfile,0,0);
#endif
  }
  exit(0);
} /* main() */