slave.c

ESS3890+SL原代码（1*16内存）

/* Copyright 2001, ESS Technology, Inc.	*/
/* SCCSID @(#)slave.c	4.8 02/19/03 */

#ifdef HOST_SLAVE
#include <stdio.h>

#include "common.h"
#include "mvd.h"
#include "constvar.h"
#include "const.h"
#include "timedef.h"
#include "ioport.h"
#include "util.h"
#include "sysinfo.h"
#include "micro.h"
#include "play.h"
#include "panel.h"
#include "ir.h"
#include "dsa.h"
#include "dsc.h"
#include "panelcmd.h"
#include "config.h"
#include "vfdshare.h"
#include "keydef.h"
#include "display.h"
#include "eq.h"
#include "filesys.h"
#include "vcxi.h"
#include "echo.h"
#include "cg.h"
#include "id3.h"
#ifdef CD_TEXT
#include "cd_text.h"
#endif
#include "mp3.h"

#include "slave.h"

#define BYTE_TRANSFER

#define host_OSD_clear_region(m)    
#define host_OSD_output   

   
unsigned char Receive_Buffer[RECEIVE_BUFFER_MAX];
unsigned char Recbak_Buffer[RECEIVE_BUFFER_MAX];
unsigned char Send_Buffer[SEND_BUFFER_MAX];

unsigned int Receive_Index=0;
volatile unsigned int Total_Byte=0;
volatile unsigned int Send_Index=0;
volatile unsigned int Receive_Flag=0;
unsigned char Check_Sum=0;

extern int STREAM_type;
extern int iso9660_file_cnt;
extern volatile unsigned int Receive_Flag;
extern CDINFO CDinfo;

#define MAX_RETRIES 5     /* Maximum Host-Slave Timeout Retry Value */

/* MP3 File Structure Related Command */

#define MSG_FILE_ID_LOW			0xCE00
#define MSG_FILE_ID_HIGH		0xCF00

#define MSG_NO_MORE_DIR			0xE000
#define MSG_NO_MORE_FILE		0xE001

#define MSG_FOLDER_NAME_SEND	        0xC100

extern struct DIR_REC *iso9660_dir;
extern unsigned char real_track[];
extern int real_track_cnt ;

extern struct {
    char    KeyBuffer[3];
    char    FireKey;
    unsigned char    Digit10Key;
} ObjectKey;

/* end of MP3 File Structure Related Command */

unsigned char disc_type2 =-1;
unsigned char disc_type_old =-1;

unsigned int Total_Track_Old = -1;
unsigned int Total_Time_Old = -1;

unsigned int cur_track_number_old = -1;
char  TV_Type_old =-1;
extern unsigned char audio_mode;
unsigned char audio_mode_old = 0;

unsigned char play_state_old  = -1;
unsigned char disc_status_old = -1;
unsigned int Playing_Time_Old;

unsigned char Disc_Status_Monitor;
unsigned char Play_Mode_Monitor;
unsigned char Play_Order_Monitor;

unsigned char kara_old_set = -1;

unsigned char Repeat_Mode_Old = -1;
unsigned char Display_Mode_Old = -1;
unsigned char Play_Order_Old = -1;

unsigned char  force_Disc_Info_flag = 0;
unsigned char  force_Track_Info_flag = 0;
unsigned char  force_Playing_Time_flag = 0;
unsigned char  force_Playing_State_flag = 0;
unsigned char  force_Play_Mode_flag = 0;
unsigned char  force_Karaoke_Setting_flag = 0;
unsigned char  force_System_Setting_flag = 0;
unsigned char  force_Send_MP3_songname_flag = 0;
unsigned char  force_Send_MP3_directory_name_flag =0;
unsigned char  force_osd_setting_flag = 0;
unsigned char  force_read_eaux_flag = 0;
unsigned char  force_version_number_flag = 0;
unsigned char  logo_flag = 0;
unsigned char  force_Servo_Info_flag=0;
unsigned char  force_mp3_title_flag = 0;
unsigned char  force_mp3_artist_flag = 0;
unsigned char  force_mp3_album_flag = 0;
unsigned char  force_mp3_year_flag = 0;
unsigned char  force_cdt_title_flag = 0;
unsigned char  force_cdt_artist_flag = 0;

int hs_cdt_track_num = -1;
int hs_cdt_track_num0 = -1;
unsigned char mp3_cur_dir_index;

unsigned char  host_OSD_mask = 0;

extern unsigned char PLAY_vcd_type;
extern unsigned int cur_track_number;
extern unsigned int current_time;
extern unsigned int cur_play_time;
extern unsigned char repeat_mode;
extern unsigned char repeat_a2b;
extern unsigned int TimeMode;
extern unsigned char audio_mode;

extern int play_item_begin_time;
extern int play_item_end_time;
extern unsigned char OSD_time_minute;
extern unsigned char OSD_time_second;

unsigned char Task_ID =0;
unsigned char Retry = 0;

/* MP3 File Structure Related Command */
char Page_Num;
/* int Name_Page_Num; */
/* int Parent_Page_Num; */

int  codeOperand=0;

unsigned char *mp3_file_name_ptr, *mp3_dir_name_ptr;
extern int get_track_index_from_mp3song(void);

/* End of MP3 File Structure Related Commands */
int Task_Disc_Info(int flag);
int Task_Track_Info(int flag);
int Task_Playing_Time(int flag);
int Task_Playing_State(int flag);
int Task_Play_Mode(int flag);
int Task_System_Setting(int flag);
int Task_MP3_Send_Song_Name(int flag);
int Task_MP3_Send_Dir_Name(int flag);
int Task_Servo_Info(int flag);
int Task_Karaoke_Setting(int flag);                      
int Task_OSD_Select_Setting(int flag);
int Task_Read_EAUX(int flag);
int Task_Version_Number(int flag);
int Task_mp3_title(int flag);
int Task_mp3_artist(int flag);
int Task_mp3_album(int flag);
int Task_mp3_year(int flag);
int Task_cdt_title(int flag);
int Task_cdt_artist(int flag);

void Make_Check_Sum(int Number);
void Slave_Receive_Command();

typedef int     (*POFI)(int flag); 
int             Task_Index=0;
PRIVATE	POFI	Current_Task;

PRIVATE	POFI	Task_Array[]={
                      Task_Disc_Info,      /* 0: Disc Information */
                      Task_Track_Info,     /* 1: Track Information */
                      Task_Playing_Time,
                      Task_Playing_State,
                      Task_Play_Mode,
                      Task_Karaoke_Setting,   /* 5*/
                      Task_System_Setting,
                      Task_MP3_Send_Song_Name,
                      Task_MP3_Send_Dir_Name,
                      Task_OSD_Select_Setting,
                      Task_Read_EAUX,
                      Task_Version_Number,
                      Task_Servo_Info,
                      Task_mp3_title,
                      Task_mp3_artist,
                      Task_mp3_album,
                      Task_mp3_year,
                      Task_cdt_title,
                      Task_cdt_artist
                      };

extern void AV_show_logo(int mode);

void Slave_answer_inquiry(unsigned op);
void Slave_Send_Error_Msg(unsigned short Message);
int Slave_Send_Name(unsigned char *mp3_name_ptr);
int mp3_search_song_name(char search_direction, unsigned char charactor);
unsigned char get_mp3_cur_dir_index(int cur_track_index);
int get_mp3_absolute_pos(unsigned char mp3_cur_dir_index);
int get_songs_num_in_cur_dir(unsigned char mp3_cur_dir_index);

extern volatile unsigned int receive_index;
void Slave_Message_Dispatch()
{
    unsigned char TempByte, Result;
#ifdef CD_TEXT
    if (CDT_started)return;
#endif

    if (Receive_Flag) {    /* command received */
        int i;
        Receive_Index = receive_index;
        Receive_Flag=receive_index = 0;
        for(i=0; i<RECEIVE_BUFFER_MAX; i++){
            Recbak_Buffer[i] = Receive_Buffer[i];
            Receive_Buffer[i] = 0;
        }
        Slave_Receive_Command();	  /* dispatch received command */
        Receive_Index=0;
        return;
    }	

#ifdef BYTE_TRANSFER		  	
    if (Total_Byte!=0) {    /* have data to send */
	TempByte=Send_Buffer[Send_Index++];
		
        Result=Send_Data(TempByte, (Send_Index==Total_Byte));
       /* Send_Index == Total_Byte //Last byte */

	/* If communication error occured, restart from the beginning.
           Assuming that the new sending is error free, the slave will
           receive a negative response from host  because of checksum 
           error. But if try again, the communication can return 
          to normal. Cooperation from host is necessary */
		  
	if(Result)  {
	   if (Send_Index==Total_Byte) {   /* Last byte? */
               Total_Byte=Send_Index=0;    /* Clear Sent Message. */
                      
               Current_Task(1);    /*  post sending processing */ 
            } else return;  
        } else {   /* error occured in communication */
            Send_Index=0;            /* if retry, from start */
	    if (Retry>= MAX_RETRIES) Retry=Total_Byte=0;    /* give up */
            else {
               Retry++;              /* Try again */
               return;
            }
        }    
    }
#else   /* BLOCK_TRANSFER */
    if (Total_Byte!=0) {   /* have data to send */
	Result=Send_Data();
	
        if (Result)  {
	   /* data successfully sent */
           Total_Byte=Retry=0;       /* No data  now */
           Current_Task(1);    /*  Post sending processing */ 
	 } else {  
	   if (Retry>= MAX_RETRIES)
	       Retry=Total_Byte=0;    /* give up */
           else {
               Retry++;              /* Try again */
               return;
           }
         }        
     }        
#endif /* BYTE_TRANSFER */	
         
     /* nothing to send, next task */
     if (Task_Index==(sizeof(Task_Array)/sizeof(Current_Task)))
         Task_Index=0;       /* rewind to first task */

     Current_Task=Task_Array[Task_Index];
     Current_Task(0);
     Task_Index++;

     return;
}

/** Disc Information **/
/*** Re-assignment of the disc type ***/
int Task_Disc_Info(int flag)
{
    unsigned char x1, x2;
      
    if (flag){
        disc_type_old = disc_type2;
        Total_Track_Old = CDinfo.lasttrack;
        Total_Time_Old = CDinfo.leadout;
        force_Disc_Info_flag = 0;
        return 1;
     }

     if (!initCD_done) return;
     disc_type2 = CDinfo.type;

     if (disc_type2 == CD_VCD){
         if (PLAY_vcd_type == VCD_TYPE_11) disc_type2 = 6;
         else if (PLAY_vcd_type == VCD_TYPE_20) disc_type2 = 7;
         else if (PLAY_vcd_type == VCD_TYPE_30) disc_type2 = 8;
         else disc_type2 = 6;
     }
     if (STREAM_type) disc_type2 = 5;

     if ((disc_type_old == disc_type2)
          &&(Total_Track_Old == CDinfo.lasttrack)
          &&(Total_Time_Old ==  CDinfo.leadout)
          && (force_Disc_Info_flag == 0))
          return 0;

     Send_Buffer[0] = mDISK_INFO;
     Send_Buffer[1] = (unsigned char )disc_type2;

     if (!STREAM_type) {
         Send_Buffer[2] = (unsigned char )CDinfo.firsttrack;        
	 Send_Buffer[3] = (unsigned char )CDinfo.lasttrack;
	 Send_Buffer[4] = (unsigned char )((CDinfo.leadout&0xff0000)>>16);
	 Send_Buffer[5] = (unsigned char )((CDinfo.leadout&0xff00)>>8);
	 Send_Buffer[6] = (unsigned char )((CDinfo.leadout&0xff));
	 Make_Check_Sum(7);
	 Total_Byte = 8;
      } else {
         parse_hundred (iso9660_file_cnt, &x1, &x2);
         Send_Buffer[2] = hex2bcd[x1];
         Send_Buffer[3] = hex2bcd[x2];

	 Make_Check_Sum(4);
	 Total_Byte = 5;
      }
      return 1;
}


/** Track Information **/
int Task_Track_Info(int flag)
{
    unsigned int temp;
    unsigned char x1, x2;
     
    if (flag) {
        cur_track_number_old = cur_track_number;
        force_Track_Info_flag = 0;
        return 1;
     }   
      
    if ((cur_track_number_old == cur_track_number)
         && (force_Track_Info_flag == 0))
         return 0;

    Send_Buffer[0] = mTRACK_INFO;

    if (!STREAM_type) {
        /* Send_Buffer[1] = hex2bcd[(unsigned char )cur_track_number];*/
        Send_Buffer[1] = (unsigned char )cur_track_number;
        temp = adjCDtime(play_item_end_time,play_item_begin_time,-1);
        Send_Buffer[2] = (unsigned char)((temp&0xff0000)>>16);
        Send_Buffer[3] = (unsigned char)((temp&0xff00)>>8);
        Send_Buffer[4] = 
             (unsigned char)((play_item_begin_time & 0xff0000)>>16);
        Send_Buffer[5] = (unsigned char)((play_item_begin_time & 0xff00)>>8);

        Make_Check_Sum(6);
        Total_Byte = 7;
     } else {
        parse_hundred(cur_track_number, &x1, &x2);
        Send_Buffer[1] = hex2bcd[x1];
        Send_Buffer[2] = hex2bcd[x2];
        Send_Buffer[3] = (iso9660_file[cur_track_index].loc>>24)&0xff;

        Make_Check_Sum(4);
	Total_Byte = 5;
     }

     return 1;
}


/** Playing Time **/
int Task_Playing_Time(int flag)
{

     if (flag) {
        Playing_Time_Old = ((OSD_time_minute<<8) | OSD_time_second);
        force_Playing_Time_flag = 0;
     }
	
     if ( PBC_on 
         || (Playing_Time_Old == ((OSD_time_minute<<8) | OSD_time_second))
         && (force_Playing_Time_flag == 0))
     return 0;

     Send_Buffer[0] = mPLAYING_TIME;
     Send_Buffer[1] = (unsigned char )(OSD_time_minute);
     Send_Buffer[2] = (unsigned char )(OSD_time_second);
     Make_Check_Sum(3);
     Total_Byte = 4;
     return 1;
}


/** Playing State **/
int Task_Playing_State(int flag)
{
    unsigned char temp;	    

    if (flag) {
        play_state_old = play_state;
        disc_status_old = Disc_Status_Monitor;
        force_Playing_State_flag = 0;
        return 1;
     }

    if ((play_state_old == play_state)
         &&(disc_status_old == Disc_Status_Monitor)
         && (force_Playing_State_flag == 0))
         return 0;

    Send_Buffer[0] = mPLAYING_STATE;