hdvotest.c

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

    hdvoExtractAddr3(&_hdvo_ucode_80_1280x720pb_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_1280x720pb_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_1280x720pb_1920x1080i_g_data_start);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set1920x1080TopParameters
 *                   
 *                   Sets the microcode parameters for 1920x1080 top field
 *
 * Parameters      : None
 */
void set1920x1080TopParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 1920*1920x1080 top field\n");
#endif

  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_1920x1080ipt_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
   hdvoExtractAddr1(&_hdvo_ucode1_80_1920x1080ipt_1920x1080i_g_text_start);

  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_1920x1080ipt_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_1920x1080ipt_1920x1080i_g_text_start);

  context->appsDataAddr3 =
    hdvoExtractAddr3(&_hdvo_ucode_80_1920x1080ipt_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_1920x1080ipt_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_1920x1080ipt_1920x1080i_g_data_start);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set1920x1080BottomParameters
 *                   
 *                   Sets the microcode parameters for 1920x1080 bottom field
 *
 * Parameters      : None
 */
void set1920x1080BottomParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 1920*1080 bottom field\n");
#endif

  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_1920x1080ipb_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
   hdvoExtractAddr1(&_hdvo_ucode1_80_1920x1080ipb_1920x1080i_g_text_start);

  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_1920x1080ipb_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_1920x1080ipb_1920x1080i_g_text_start);

  context->appsDataAddr3 =
    hdvoExtractAddr3(&_hdvo_ucode_80_1920x1080ipb_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_1920x1080ipb_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_1920x1080ipb_1920x1080i_g_data_start);
}


/* ------------------------------------------------------------------------- */
/*
 * Function        : setVideoPointers
 *                   
 *                   Sets the video pointers for the application microcode
 *
 * Parameters      : None
 */
void setupVideoPointers(phdvoContext_t context,
			UInt8 *hdYTopPtr, UInt8 *hdYBottomPtr,
			UInt8 *hdUVTopPtr, UInt8 *hdUVBottomPtr)
{
  context->hdYTopAddr3 = hdvoExtractAddr3(hdYTopPtr);
  context->hdYTopAddr2 = hdvoExtractAddr2(hdYTopPtr);
  context->hdYTopAddr1 = hdvoExtractAddr1(hdYTopPtr);

  context->hdYBottomAddr3 = hdvoExtractAddr3(hdYBottomPtr);
  context->hdYBottomAddr2 = hdvoExtractAddr2(hdYBottomPtr);
  context->hdYBottomAddr1 = hdvoExtractAddr1(hdYBottomPtr);

  context->hdUVTopAddr3 = hdvoExtractAddr3(hdUVTopPtr);
  context->hdUVTopAddr2 = hdvoExtractAddr2(hdUVTopPtr);
  context->hdUVTopAddr1 = hdvoExtractAddr1(hdUVTopPtr);

  context->hdUVBottomAddr3 = hdvoExtractAddr3(hdUVBottomPtr);
  context->hdUVBottomAddr2 = hdvoExtractAddr2(hdUVBottomPtr);
  context->hdUVBottomAddr1 = hdvoExtractAddr1(hdUVBottomPtr);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : fillYUVBuffer
 *                   
 *                   Fill video buffer with color bars
 *
 * Parameters      : 1. Pointer to Y buffer
 *                   2. Pointer to UV buffer
 *                   3. buffer height
 *                   4. buffer width (stride)
 *                   5. column 1 Y value
 *                   6. column 2 Y value
 *                   7. column 3 Y value
 *                   8. column 4 Y value
 *                   9. column 1 U value
 *                  10. column 2 U value
 *                  11. column 3 U value
 *                  12. column 4 U value
 *                  13. column 1 V value
 *                  14. column 2 V value
 *                  15. column 3 V value
 *                  16. column 4 V value
 */
void fillYUVBuffer(UInt8 * yPtr, UInt8 * uvPtr,
		   UInt16 height, UInt16 width,
		   UInt8 yCol1, UInt8 yCol2, UInt8 yCol3, UInt8 yCol4,
		   UInt8 uCol1, UInt8 uCol2, UInt8 uCol3, UInt8 uCol4,
		   UInt8 vCol1, UInt8 vCol2, UInt8 vCol3, UInt8 vCol4)
{
  int x, y;
  UInt8 * ptr = yPtr;
#if VERBOSE
  printf("Setting HD Y\n");
#endif
  for (y=0;y<height;y++) {
    for (x=0;x<width/4;x++)
      *ptr++ = yCol1;   /* column 1 */
    
    for (x=0;x<width/4;x++)
      *ptr++ = yCol2;   /* column 2 */
    
    for (x=0;x<width/4;x++)
      *ptr++ = yCol3;   /* columm 3 */
    
    for (x=0;x<width/4;x++)
      *ptr++ = yCol4;   /* column 4 */
  }

#if VERBOSE
  printf("about to copyback Y...\n");
#endif
  _cache_copyback(yPtr, width*height);

#if VERBOSE
  printf("Setting HD UV\n");
#endif
  ptr = uvPtr;
  for (y=0;y<height/2;y++) {
    for (x=0;x<width/4;x+=2) {
      *ptr++ = uCol1;   /* column 1 */
      *ptr++ = vCol1;
    }
    
    for (x=0;x<width/4;x+=2) {
      *ptr++ = uCol2;   /* column 2 */
      *ptr++ = vCol2;
    }
    
    for (x=0;x<width/4;x+=2) {
      *ptr++ = uCol3;   /* columm 3 */
      *ptr++ = vCol3;
    }
    
    for (x=0;x<width/4;x+=2) {
      *ptr++ = uCol4;   /* column 4 */
      *ptr++ = vCol4;
    }
  }

#if VERBOSE
  printf("about to copyback UV...\n");
#endif
  _cache_copyback(uvPtr, width*height/2);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : fillNMBuffer
 *                   
 *                   Fill Natural Motion video buffer with color bars
 *
 * Parameters      : 1. Pointer to Y buffer
 *                   2. Pointer to U buffer
 *                   3. Pointer to V buffer
 *                   4. buffer Y height
 *                   5. buffer Y width (stride)
 *                   6. buffer U/V height
 *                   7. buffer U/V width (stride)
 *                   8. column 1 Y value
 *                   9. column 2 Y value
 *                  10. column 3 Y value
 *                  11. column 4 Y value
 *                  12. column 1 U value
 *                  13. column 2 U value
 *                  14. column 3 U value
 *                  15. column 4 U value
 *                  16. column 1 V value
 *                  17. column 2 V value
 *                  18. column 3 V value
 *                  19. column 4 V value
 */
void fillNMBuffer(UInt8 * yPtr, UInt8 * uPtr, UInt8 * vPtr,
		  UInt16 height, UInt16 width,
		  UInt16 uvHeight, UInt16 uvWidth,
		  UInt8 yCol1, UInt8 yCol2, UInt8 yCol3, UInt8 yCol4,
		  UInt8 uCol1, UInt8 uCol2, UInt8 uCol3, UInt8 uCol4,
		  UInt8 vCol1, UInt8 vCol2, UInt8 vCol3, UInt8 vCol4)
{
  int x, y;
  UInt8 * ptr = yPtr;
#if VERBOSE
  printf("Setting NM Y\n");
#endif
  for (y=0;y<height;y++) {
    for (x=0;x<width/4;x++)
      *ptr++ = yCol1;

    for (x=0;x<width/4;x++)
      *ptr++ = yCol2;

    for (x=0;x<width/4;x++)
      *ptr++ = yCol3;

    for (x=0;x<width/4;x++)
      *ptr++ = yCol4;
  }
#if VERBOSE
  printf("about to copyback Y...\n");
#endif
  _cache_copyback(yPtr, height*width);

#if VERBOSE
  printf("Setting NM U\n");
#endif
  ptr = uPtr;
  for (y=0;y<uvHeight;y++) {
    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = uCol1;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = uCol2;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = uCol3;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = uCol4;
    }
  }
#if VERBOSE
  printf("about to copyback U...\n");
#endif
  _cache_copyback(uPtr, uvHeight*uvWidth);

#if VERBOSE
  printf("Setting NM V\n");
#endif
  ptr = vPtr;
  for (y=0;y<uvHeight;y++) {
    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = vCol1;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = vCol2;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = vCol3;
    }

    for (x=0;x<uvWidth/4;x++) {
      *ptr++ = vCol4;
    }
  }
#if VERBOSE
  printf("about to copyback V...\n");
#endif
  _cache_copyback(vPtr, uvHeight*uvWidth);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : fillGFXBuffer
 *                   
 *                   Fill Graphics buffer
 *
 * Parameters      : 1. Pointer to Y buffer
 *                   2. Pointer to U buffer
 *                   3. Pointer to V buffer
 *                   4. Pointer to Alpha buffer
 */

void fillGFXBuffer(UInt8 *gfxYPtr, UInt8 *gfxUPtr, UInt8 *gfxVPtr,
		   UInt8 *gfxAPtr)
{
  int x, y;
  UInt8 * ptr = gfxYPtr;

#if VERBOSE
  printf("Setting GFX Y\n");
#endif
  ptr = gfxYPtr;
  for (y=0;y<GFX_Y_HEIGHT/3;y++) {
    for (x=0;x<GFX_Y_WIDTH;x++) {
      *ptr++ = 0x85;   /* green */
    }
  }
  for (y=0;y<GFX_Y_HEIGHT/3;y++) {
    for (x=0;x<GFX_Y_WIDTH;x++) {
      *ptr++ = 0xae;   /* yellow */
    }
  }
  for (y=0;y<GFX_Y_HEIGHT/3;y++) {
    for (x=0;x<GFX_Y_WIDTH;x++) {
      *ptr++ = 0x96;   /* blue */
    }
  }
  
  _cache_copyback(gfxYPtr, GFX_Y_WIDTH*GFX_Y_HEIGHT);

#if VERBOSE
  printf("Setting GFX U\n");
#endif
  ptr = gfxUPtr;
  for (y=0;y<GFX_U_HEIGHT/3;y++) {
    for (x=0;x<GFX_U_WIDTH;x++) {
      *ptr++ = 0x37;
    }
  }
  for (y=0;y<GFX_U_HEIGHT/3;y++) {
    for (x=0;x<GFX_U_WIDTH;x++) {
      *ptr++ = 0x20;
    }
  }
  for (y=0;y<GFX_U_HEIGHT/3;y++) {
    for (x=0;x<GFX_U_WIDTH;x++) {
      *ptr++ = 0x95;
    }
  }
  _cache_copyback(gfxUPtr, GFX_U_WIDTH*GFX_U_HEIGHT);
  
#if VERBOSE
  printf("Setting GFX V\n");
#endif
  ptr = gfxVPtr;
  for (y=0;y<GFX_V_HEIGHT/3;y++) {
    for (x=0;x<GFX_V_WIDTH;x++) {
      *ptr++ = 0x2b;
    }
  }
  for (y=0;y<GFX_V_HEIGHT/3;y++) {
    for (x=0;x<GFX_V_WIDTH;x++) {
      *ptr++ = 0x8a;
    }
  }
  for (y=0;y<GFX_V_HEIGHT/3;y++) {
    for (x=0;x<GFX_V_WIDTH;x++) {
      *ptr++ = 0x20;
    }
  }
  _cache_copyback(gfxVPtr, GFX_V_WIDTH*GFX_V_HEIGHT);
  
#if VERBOSE
  printf("Setting GFX A\n");
#endif
  ptr = gfxAPtr;
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0xff;
    }
  }
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0xcc;
    }
  }
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0x99;
    }
  }
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0x66;
    }
  }
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0x33;
    }
  }
  for (y=0;y<GFX_A_HEIGHT/6;y++) {
    for (x=0;x<GFX_A_WIDTH;x++) {
      *ptr++ = 0x00;
    }
  }
    _cache_copyback(gfxAPtr, GFX_A_WIDTH*GFX_A_HEIGHT);
}