hdvotest.c

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

		     hd1080UVPtr,
		     hd1080UVPtr+(HD_1080_UV_WIDTH*HD_1080_UV_HEIGHT/2));
      break;

    case INPUT_720:
      if (field == HDVO_TOP_FIELD) {
	set1280x720TopParameters(dspcpuContext);
      }
      else {
	set1280x720BottomParameters(dspcpuContext);
      }
      setupVideoPointers(dspcpuContext, hd720YPtr, 
			 hd720YPtr+(HD_720_Y_WIDTH*HD_720_Y_HEIGHT/2),
			 hd720UVPtr,
			 hd720UVPtr+(HD_720_UV_WIDTH*HD_720_UV_HEIGHT/2));
      break;

    case INPUT_480:
      if (field == HDVO_TOP_FIELD) {
	set704x480TopParameters(dspcpuContext);
      }
      else {
	set704x480BottomParameters(dspcpuContext);
      }
      setupVideoPointers(dspcpuContext, hd480YPtr, 
			 hd480YPtr+(HD_480_Y_WIDTH*HD_480_Y_HEIGHT/2),
			 hd480UVPtr,
			 hd480UVPtr+(HD_480_UV_WIDTH*HD_480_UV_HEIGHT/2));
      break;

    case INPUT_480NM:
      if (field == HDVO_TOP_FIELD) {
	set704x480NMTopParameters(dspcpuContext);
      }
      else {
	set704x480NMBottomParameters(dspcpuContext);
      }
      setupVideoPointers(dspcpuContext, nmYPtr, Null, nmUPtr, nmVPtr);
      break;

    default:
      printf("Error: invalid input type\n");
      exit(1);
    }

    /*
     * The dspcpu context has been updated to set the flag to indicate this
     * condition.
     */

    updatedContext = True;

    /* 
     * Wait for interrupt which indicates hdvo is starting to render its
     * next field.
     *
     * In a real system we would have the ISR signal a semaphore so that the
     * DSPCPU can do something useful instead of doing a busy-wait.
     */
    
    while (!receivedInterrupt) {
    }
    receivedInterrupt = 0;

#if VERBOSE
    printf("--- Received HDVO interrupt! (%d) ---\n",
	   totalNumberOfFields);
#endif

    totalNumberOfFields++;
    fieldCounter++;
    if (fieldCounter >= (NUMBER_FIELDS_PER_TYPE -1)) {
      printf("Changing input type: input buffer size is ");
      fieldCounter = 0;
      inputType++;;
      if (inputType >= NUMBER_INPUT_TYPES) {
	inputType = INPUT_1080;
      }
      
      switch (inputType) {
      case INPUT_1080:
	printf("1920x1080\n");
	printf("red, blue, yellow, green color bars should be displayed\n\n");
	break;

      case INPUT_720:
	printf("1280x720\n");
	printf("blue, yellow, green, red color bars should be displayed\n\n");
	break;

      case INPUT_480:
	printf("704x480\n");
	printf("yellow, green, red, blue color bars should be displayed\n\n");
	break;

      case INPUT_480NM:
	printf("704x480 Natural Motion\n");
	printf("green, red, blue, yellow color bars should be displayed\n\n");
	break;
      }
    }
  }

  /*
   * close the instance and free the context structure
   */
   rval = hdvoClose(hdvoInstance);
   tmAssert(rval == TMLIBDEV_OK, rval);

   _cache_free(dspcpuContext);
   _cache_free(mcpContext);

   _cache_free(hd1080YPtr);
   _cache_free(hd1080UVPtr);
   _cache_free(hd720YPtr);
   _cache_free(hd720UVPtr);
   _cache_free(hd480YPtr);
   _cache_free(hd480UVPtr);
   _cache_free(nmYPtr);
   _cache_free(nmUPtr);
   _cache_free(nmVPtr);
   
   _cache_free(gfxYPtr);
   _cache_free(gfxUPtr);
   _cache_free(gfxVPtr);
   _cache_free(gfxAPtr);

  printf("HDVO test completed\n");

  return rval;
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : hdvoISR
 *                   Example Interrupt service routine for HDVO.
 *
 *                   1. Acknowledges Interrupt
 *                   2. Updates the mcp context if required
 *                   3. Set the flag to indicate that an interrupt was received
 *
 * Parameters      : None
 */

static void 
_hdvoISR(void)
{
  UInt32 stmStatus;

  hdvoAckMCP_CTL1Ack_Interrupt_for_DSPCPU();

  /*
   * set the flag to indicate we have received an interrupt.
   * Then get the field status from HDVO se we know what field to render next.
   */

  receivedInterrupt = 1;

  stmStatus = hdvoGetMCP_RSEM();
  
  field = (stmStatus & HDVO_TOP_FIELD) ? HDVO_TOP_FIELD : HDVO_BOTTOM_FIELD;

  /*
   * If the DSPCPU has updated the context structure then we copy it to the
   * MCP structure and flush it out to SDRAM.
   */

  if (updatedContext) {
    memcpy(mcpContext, dspcpuContext, sizeof(hdvoContext_t));
    _cache_copyback(mcpContext, sizeof(hdvoContext_t));
    updatedContext = False;
  }

  return;
}

void 
hdvoISR(void)
{
#pragma TCS_handler
  AppModel_suspend_scheduling();
  AppModel_run_on_sstack((AppModel_Fun)_hdvoISR, Null);
  AppModel_resume_scheduling();
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set480NMTopParameters
 *                   
 *                   Sets the microcode parameters for 480 Natural Motion Top
 *                   field
 *
 * Parameters      : None
 */
void set704x480NMTopParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 704*480 Natural Motion top field\n");
#endif

  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_704x480nmipt_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_704x480nmipt_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_704x480nmipt_1920x1080i_g_text_start);

  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_704x480nmipt_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_704x480nmipt_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_704x480nmipt_1920x1080i_g_text_start);

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

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

/* ------------------------------------------------------------------------- */
/*
 * Function        : set704x480NMBottomParameters
 *                   
 *                   Sets the microcode parameters for 704x480 Natural Motion 
 *                   Bottom field
 *
 * Parameters      : None
 */
void set704x480NMBottomParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 704*480 Natural Motion bottom field\n");
#endif
  
  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_704x480nmipb_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_704x480nmipb_1920x1080i_g_text_start);
  
  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_704x480nmipb_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_704x480nmipb_1920x1080i_g_text_start);
  
  context->appsDataAddr3 =
    hdvoExtractAddr3(&_hdvo_ucode_80_704x480nmipb_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_704x480nmipb_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_704x480nmipb_1920x1080i_g_data_start);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set704x480TopParameters
 *                   
 *                   Sets the microcode parameters for 704x480 Top field
 *
 * Parameters      : None
 */
void set704x480TopParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 704*480 top field\n");
#endif

  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_704x480it_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_704x480it_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_704x480it_1920x1080i_g_text_start);

  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_704x480it_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_704x480it_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_704x480it_1920x1080i_g_text_start);

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

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

/* ------------------------------------------------------------------------- */
/*
 * Function        : set704x480BottomParameters
 *                   
 *                   Sets the microcode parameters for 704x480 Bottom field
 *
 * Parameters      : None
 */
void set704x480BottomParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 704*480 bottom field\n");
#endif
  
  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_704x480ib_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_704x480ib_1920x1080i_g_text_start);
  
  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_704x480ib_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_704x480ib_1920x1080i_g_text_start);
  
  context->appsDataAddr3 =
    hdvoExtractAddr3(&_hdvo_ucode_80_704x480ib_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_704x480ib_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_704x480ib_1920x1080i_g_data_start);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set1280x720TopParameters
 *                   
 *                   Sets the microcode parameters for 1280x720 Top field
 *
 * Parameters      : None
 */
void set1280x720TopParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 1280*720 top field\n");
#endif

  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_1280x720pt_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_1280x720pt_1920x1080i_g_text_start);
  
  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_1280x720pt_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_1280x720pt_1920x1080i_g_text_start);
  
  context->appsDataAddr3 =
    hdvoExtractAddr3(&_hdvo_ucode_80_1280x720pt_1920x1080i_g_data_start);
  context->appsDataAddr2 =
    hdvoExtractAddr2(&_hdvo_ucode_80_1280x720pt_1920x1080i_g_data_start);
  context->appsDataAddr1 =
    hdvoExtractAddr1(&_hdvo_ucode_80_1280x720pt_1920x1080i_g_data_start);
}

/* ------------------------------------------------------------------------- */
/*
 * Function        : set1280x720BottomParameters
 *                   
 *                   Sets the microcode parameters for 1280x720 Bottom field
 *
 * Parameters      : None
 */
void set1280x720BottomParameters (phdvoContext_t context)
{
#if VERBOSE
  printf("Setting parameters for 1280*720 bottom field\n");
#endif
  
  context->appsProg0Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode0_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg0Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode0_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg0Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode0_80_1280x720pb_1920x1080i_g_text_start);
  
  context->appsProg1Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode1_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg1Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode1_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg1Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode1_80_1280x720pb_1920x1080i_g_text_start);
  
  context->appsProg2Addr3 = 
    hdvoExtractAddr3(&_hdvo_ucode2_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg2Addr2 =
    hdvoExtractAddr2(&_hdvo_ucode2_80_1280x720pb_1920x1080i_g_text_start);
  context->appsProg2Addr1 =
    hdvoExtractAddr1(&_hdvo_ucode2_80_1280x720pb_1920x1080i_g_text_start);
  
  context->appsDataAddr3 =