fp_handler.c

Zoran V966 DVD 解码 Soc芯片的源程序

							{
								ready_blink_time--;
								VFD_Set_Str(VFD_SVCD_Str);
								VFD_Refresh_Display(g_vfd_grid_buffer);
								return;
							}
#endif
							VFD_SET_BIT(VFD_VCD);
							VFD_SET_BIT(VFD_V);
							VFD_SET_BIT(VFD_SUPER);
							if(SI_SVCD_IS_PBC_ON)
								VFD_SET_BIT(VFD_PBC);
							break;
#ifdef DVD_AUDIO_SUPPORT
						case MEDIA_TYPE_DVD_AUDIO:
#endif
						case MEDIA_TYPE_DVD_VIDEO:
#ifdef DVD_VR_SUPPORT						
						case MEDIA_TYPE_DVDVR:
#endif						
#ifdef D_FP_DVP3040
							if (ready_blink_time > 0)
							{
								ready_blink_time--;
								VFD_Set_Str(VFD_DVD_Str);
								VFD_Refresh_Display(g_vfd_grid_buffer);
								return;
							}
#endif
							VFD_SET_BIT(VFD_DVD);
#if defined(DVD_AUDIO_SUPPORT)&&defined(WATERMARK_SUPPORT)
							if(SI_DVDA_WATERMARK_MUTE)
							{
								Set_String("NO COPY\0", g_vfd_grid_buffer);
								VFD_Refresh_Display(g_vfd_grid_buffer);
								return;
							}
#endif
							break;
					}

					if (CoreAPI_IsFullStop())
					{
						VFD_Set_Str(VFD_Stop_Str);
#if VFD_S_NUM
						VFD_Set_S_Total();
#endif
						VFD_Refresh_Display(g_vfd_grid_buffer);
						return;
					}
				
					switch(CoreAPI_GetPlayState())
					{
						case PST_STILL:
//						        g_vfd_grid_buffer[G1] |= VFD_LED_S;
#if VFD_S_NUM
							VFD_Set_S_Total();
#endif
							break;
						case PST_PAUSE:
							VFD_SET_BIT(VFD_PAUSE);
	                            //fall through
						case PST_STOP:
//						        g_vfd_grid_buffer[G1] |= VFD_LED_S;
#if VFD_S_NUM
							VFD_Set_S_Total();
#endif
							break;
						case PST_PLAY:
#if VFD_S_NUM
							spin_speed = (spin_speed + 1)%2;
							if (spin_speed == 0)
								spin_state  = (spin_state + 1)%VFD_S_NUM;
				        		VFD_Set_S_Single(spin_state, 1);
#endif
							VFD_SET_BIT(VFD_PLAY);
							break;
						case PST_SCAN:
#if VFD_S_NUM
							spin_state  = (spin_state + 1)%VFD_S_NUM;
							if(CoreAPI_GetScanSpeed())
							{
				        			VFD_Set_S_Single(spin_state, 1);
					    		}
					    		else
							{
				        			VFD_Set_S_Single(spin_state, 0);
							}
#endif
							break;
//						case PST_SCAN|PST_REVERSE:
//							spin_state  = (spin_state + 1)%13;
//							g_vfd_grid_buffer[G1] |= (VFD_LED_S & (~(VFD_LED_S1 << spin_state)));
//							break;
						case PST_SLOW:
#if VFD_S_NUM					
							spin_speed = (spin_speed + 1)%5;
							if (0 == spin_speed)
							{
								spin_state  = (spin_state + 1)%VFD_S_NUM;
							}
							if(CoreAPI_GetSlowSpeed())
							{
				        			VFD_Set_S_Single(spin_state, 1);
					    		}
					    		else
							{
				        			VFD_Set_S_Single(spin_state, 0);
							}
#endif
							break;
//						case PST_SLOW|PST_REVERSE:
//							spin_speed = (spin_speed + 1)%5;//12;
//							if (spin_speed == 0)
//							{
//								spin_state  = (spin_state + 1)%13;
//							}
//						       g_vfd_grid_buffer[G1] |= (VFD_LED_S & (~(VFD_LED_S12 >> spin_state)));
//							break;
					}
                    
#ifdef EXTERNAL_KARAOKE
					if(CoreAPI_IsKaraokeOn())//gc_Karaoke_mode == KARAOKE_ON)
						VFD_SET_BIT(VFD_KARAOKE);
#endif

					if(!IS_UNLOCKED)// 	(gps->parental_password == INITIAL_PASSWORD)
						VFD_SET_BIT(VFD_LOCK);
                    
					switch (CoreAPI_GetAudioCodingMode(NULL))//gcst.mAudioStream)
					{
						case AUDIO_STREAM_AC3:
							VFD_SET_BIT(VFD_DOLBY);
							VFD_SET_BIT(VFD_DIGITAL);
							break;
						case AUDIO_STREAM_DTS:
							VFD_SET_BIT(VFD_DTS);
							break;
					}
                    
					if(PM_PLAYBACK_PROGRAM == CoreAPI_GetPlaybackMode())
						VFD_SET_BIT(VFD_PROGRAM);

					if(CoreAPI_IsRepeatSingle() || CoreAPI_IsRepeatFolderOrALL())
						VFD_SET_BIT(VFD_REPEAT);
					
					if(CoreAPI_IsRepeatFolderOrALL())
					{
						VFD_SET_BIT(VFD_REPEAT);
						VFD_SET_BIT(VFD_ALL);
					}
					time = CoreAPI_GetElapseTime();
					if(ERROR_TIME == time)
						time = 0;
				
					//total_time = CoreAPI_GetTotalTime();
					
					/*current_title = CoreAPI_GetCurrentTitleGroupNum();
					    if(ERROR_TITLE_NUM == current_title)
						current_title = 0;*/

					current_chapter = CoreAPI_GetCurrentChapterTrackNum();
					if(ERROR_CHAPTER_NUM == current_chapter)
						current_chapter = 0;

					total_chapters = CoreAPI_GetTotalChapterTrackNum(current_title);
					if(ERROR_CHAPTER_NUM == total_chapters)
						total_chapters = 0;
 #ifdef D_GUI_ITEM_ACCESS
					if(MEDIA_TYPE_CLIPS == CoreAPI_GetCurrentMediaType())
					{
 #ifdef D_DIVX6_SUPPORT
						if(CoreAPI_IsCurrItemDivX6())
							break;
#endif//D_DIVX6_SUPPORT
#ifdef IS_MP4_CAPABLE
						if (eClipType_MP4 == CoreAPI_GetCurrentClipType())
							break;
#endif//IS_MP4_CAPABLE
						current_chapter = CoreAPI_GetUiItemIndexCurrent();
						if(ERROR_CHAPTER_NUM == current_chapter)
						current_chapter = 0;

						total_chapters = CoreAPI_GetUiItemIndexTotal();
						if(ERROR_CHAPTER_NUM == total_chapters)
						total_chapters = 0;
					}
#endif//D_GUI_ITEM_ACCESS
                       
					eMediaType = CoreAPI_GetCurrentMediaType();
					if ( MEDIA_TYPE_DVD_VIDEO == eMediaType
#ifdef DVD_AUDIO_SUPPORT
					||MEDIA_TYPE_DVD_AUDIO== eMediaType
#endif
#ifdef DVD_VR_SUPPORT							        
					||(MEDIA_TYPE_DVDVR== eMediaType)
#endif							        
					)
					{
						UINT16 wTotalAngleNum = CoreAPI_GetTotalAngleNum();
						if ((wTotalAngleNum!= ERROR_ANGLE_NUM && wTotalAngleNum>1)
							&&(PST_STOP != CoreAPI_GetPlayState()))
						{
							VFD_SET_BIT(VFD_ANGLE);
						}
					}       //end of if DVD
#if D_SUPPORT_SACD  // TODO:  check after SACD finished.
				else if(MEDIA_TYPE_SACD == eMediaType)//g_disc_type==DEC_DISC_TYPE_SACD)
					{
						current_chapter = SACD_CUR_TRACK;
						total_chapters = (WORD)SACD_NUM_OF_TRACKS;
						//total_time = 0; //jerry cai todo: check later.
						time = SACD_CUR_PLAY_TIME;

					}
#endif
                
					//if(current_chapter!=0)
					{
						if (time > 36000L) // time is large than 10 hours
							time = 0;
						hour = (WORD)(time/3600);
						min = (WORD)((time/60)%60);
						sec = (WORD)(time%60);

					switch(CoreAPI_GetCurrentMediaType())
					{
						case MEDIA_TYPE_CLIPS:	
							if(eClipType_JPEG == CoreAPI_GetCurrentClipType())
							{
								VFD_Set_Str(VFD_Jpeg_Str);
							}
							if ((VFD_CDR_TRACK_FOUR > 0))
							{
								if (current_chapter > 999)
								{
									VFD_Set_Char(VFD_CDR_TRACK_FOUR, VFD_Digit_Table[current_chapter/1000]);
									VFD_Set_Char(VFD_CDR_TRACK_THREE, VFD_Digit_Table[(current_chapter%1000)/100]);
									VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[(current_chapter%100)/10]);
									VFD_Set_Char(VFD_CDR_TRACK_ONE, VFD_Digit_Table[current_chapter%10]);
								}
								else if (current_chapter > 99)
								{
									VFD_Set_Char(VFD_CDR_TRACK_FOUR, VFD_Digit_Table[(current_chapter%1000)/100]);
									VFD_Set_Char(VFD_CDR_TRACK_THREE, VFD_Digit_Table[(current_chapter%100)/10]);
									VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[current_chapter%10]);
									VFD_SET_BIT(VFD_CDR_TRACK_COL);
								}
								else
								{
									VFD_Set_Char(VFD_CDR_TRACK_THREE, VFD_Digit_Table[(current_chapter%100)/10]);
									VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[current_chapter%10]);
									VFD_SET_BIT(VFD_CDR_TRACK_COL);
								}
							}
							else if (VFD_CDR_TRACK_THREE > 0)
							{
								if (current_chapter > 99)
								{
									VFD_Set_Char(VFD_CDR_TRACK_THREE, VFD_Digit_Table[(current_chapter%1000)/100]);
									VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[(current_chapter%100)/10]);
									VFD_Set_Char(VFD_CDR_TRACK_ONE, VFD_Digit_Table[current_chapter%10]);
								}
								else
								{
									VFD_Set_Char(VFD_CDR_TRACK_THREE, VFD_Digit_Table[(current_chapter%100)/10]);
									VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[current_chapter%10]);
									VFD_SET_BIT(VFD_CDR_TRACK_COL);
								}
							}
							else if (VFD_CDR_TRACK_TWO > 0)
							{
								VFD_Set_Char(VFD_CDR_TRACK_TWO, VFD_Digit_Table[(current_chapter%100)/10]);
								VFD_Set_Char(VFD_CDR_TRACK_ONE, VFD_Digit_Table[current_chapter%10]);
								VFD_SET_BIT(VFD_CDR_TRACK_COL);
							}							
							if(eClipType_JPEG != CoreAPI_GetCurrentClipType())
							{
								if (time > 36000L) // time is large than 10 hours
									time = 0;
								min = (WORD)((time/60)%100);
								sec = (WORD)(time%60);
								if (VFD_MIN_LO > 0)
								{
									VFD_Set_Char(VFD_MIN_HI, VFD_Digit_Table[min/10]);
									VFD_Set_Char(VFD_MIN_LO, VFD_Digit_Table[min%10]);
									VFD_SET_BIT(VFD_CD_MIN_COL);
								}
								if (VFD_SEC_LO > 0)
								{
									sec = (WORD)(time%60);
									VFD_Set_Char(VFD_SEC_HI, VFD_Digit_Table[sec/10]);
									VFD_Set_Char(VFD_SEC_LO, VFD_Digit_Table[sec%10]);
								}
							}							
							break;

						default://DVD SVCD VCD
							VFD_Set_Char(VFD_CD_TRACK_HI, VFD_Digit_Table[(current_chapter%100)/10]);
							VFD_Set_Char(VFD_CD_TRACK_LO, VFD_Digit_Table[current_chapter%10]);
							VFD_SET_BIT(VFD_CD_TRACK_COL);
							VFD_SET_BIT(VFD_TRACK_COL);
							if (VFD_CD_HOUR > 0)
							{
								hour = (WORD)(time/3600);
								min = (WORD)((time/60)%60);
								VFD_Set_Char(VFD_CD_HOUR, VFD_Digit_Table[hour%10]);
								VFD_SET_BIT(VFD_CD_HOUR_COL);
							}
							else
							{
								min = (WORD)((time/60)%100);
							}
							if (VFD_MIN_LO > 0)
							{
								VFD_Set_Char(VFD_MIN_HI, VFD_Digit_Table[min/10]);
								VFD_Set_Char(VFD_MIN_LO, VFD_Digit_Table[min%10]);
								VFD_SET_BIT(VFD_CD_MIN_COL);
							}
							if (VFD_SEC_LO > 0)
							{
								sec = (WORD)(time%60);
								VFD_Set_Char(VFD_SEC_HI, VFD_Digit_Table[sec/10]);
								VFD_Set_Char(VFD_SEC_LO, VFD_Digit_Table[sec%10]);
							}
							break;
					}
				}
				//#endif
				}
				break;//end of case MST_DISC_READY
			}  //end of switch(gcs.mstate)
		} // end of default
	}
	VFD_Refresh_Display(g_vfd_grid_buffer);
#endif
}

/**********************************************************************************
 * Name			:
 *
 * Purpose		:
 *
 * Input			:
 *
 * Return Value	:
 *
 * Description		:
 *
 * Comments		:
 *
**********************************************************************************/
static void VFD_Set_Char(char pos, unsigned int Letter)
{
  char cur_pos;

	cur_pos = 0;  
	while (Letter)
	{
		if (Letter & 0x0001)
		{
			VFD_SET_BIT(VFD_Char_Segments[pos - 1][cur_pos]);

		}
		cur_pos++;
		Letter >>= 1;
		if (cur_pos > 15)
			break;
	}
}

static void VFD_Set_Str(LPCSTR str)
{
	CHAR pos;
	CHAR letter_index;
	
	for(pos = 1; pos <= MAX_DIGIT; pos++)
	{
		if (*str)
		{
			if ( ((*str)>='A') && ((*str)<='Z'))
	{
				letter_index = (*str)-'A';
				VFD_Set_Char(pos, VFD_Letter_Table[letter_index]);
			}
			else if ( ((*str)>='0') && ((*str)<='9'))
			{
				letter_index = (*str)-'0';
				VFD_Set_Char(pos, VFD_Digit_Table[letter_index]);
			}
			else if ( (*str) == '-' )
		{
				VFD_Set_Char(pos, CHAR__);
			}
			str++;
		}
	}
}

void VFD_Loading(void)
{
	BYTE i;
//	BYTE g_vfd_grid_buffer[VFD_BUFF_SIZE];
	
	for(i=0; i<VFD_BUFF_SIZE; i++)
		g_vfd_grid_buffer[i] = 0;
	g_vfd_grid_count = MAX_GRID;
#ifdef D_TEST		
	first_key = 0xffff;
	cur_grid = 1;
	cur_seg = 1;
#endif
#if VFD_S_NUM
	VFD_Set_S_Total();
#endif
	VFD_Set_Str(VFD_Load_Str);
	VFD_Refresh_Display(g_vfd_grid_buffer);
}

/**********************************************************************************
 * Name			:		FP_ForceDisplayPowerOff
 *
 * Purpose		:		Display -OFF- on VFD
 *
 * Input		:		none
 *
 * Return Value	:		none
 *
 * Description	:		Display -OFF- on VFD
 *
 * Comments		:		this func will be called in Core Task before power off
 *
**********************************************************************************/
void FP_ForceDisplayPowerOff(void)
{
//	WORD g_vfd_grid_buffer[VFD_BUFFER_SIZE];
	BYTE i;
	
	for (i = 0; i<VFD_BUFF_SIZE; i++)
		g_vfd_grid_buffer[i] = 0;
	VFD_Set_Str(VFD_Standby_Str);
	VFD_Refresh_Display(g_vfd_grid_buffer);
#ifdef D_FP_DVP3040
	loading_blink_time = LOADING_BLINK_TIME_COUNT;
	delay_us(1000000UL);
	for (i = 0; i<VFD_BUFFER_SIZE; i++)
		g_vfd_grid_buffer[i] = 0;
	VFD_Refresh_Display(g_vfd_grid_buffer);
	delay_us(1000000UL);
	VFD_Set_Str(VFD_Standby_Str);
	VFD_Refresh_Display(g_vfd_grid_buffer);
	delay_us(1000000UL);
	for (i = 0; i<VFD_BUFFER_SIZE; i++)
		g_vfd_grid_buffer[i] = 0;
	VFD_Refresh_Display(g_vfd_grid_buffer);
	delay_us(1000000UL);
#endif
}

/**********************************************************************************
 * Name			:
 *
 * Purpose		:
 *
 * Input			:
 *
 * Return Value	:
 *
 * Description		:
 *
 * Comments		:
 *
**********************************************************************************/
#pragma argsused 
int FP_EventHandler(HDLR_OP op, EVENT event, void *param)
{
	if ((op == HDLR_ENTER) && IS_POWER_ON ){
		/* only get this message once at first call */
		return 0;
	}

	switch ( event )
	{
		case IE_UI_STATE_CHANGE:
			break;

		case IE_UI_TICK_200:
			_KeyScanHandler();

			_DisplayUpdateHandler();	
			break;

		case IE_UI_FORCE_FP_UPDATE:
			_DisplayUpdateHandler();			
			break;
	}

	return 0;
}