slave.c

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

void Reset_VFD_Variables()
{
    disc_type2 =-1;
    disc_type_old =-1;
    CDinfo.type = 0;

    cur_track_number_old = -1;
    TV_Type_old =-1;
    audio_mode_old = -1;

    play_state_old  = -1;
    disc_status_old = -1;

    Disc_Status_Monitor = -1;
    Play_Mode_Monitor = -1;
    Play_Order_Monitor = -1;

    Repeat_Mode_Old = -1;
    Display_Mode_Old = -1;
    Play_Order_Old = -1;
}

unsigned char mp3_dir_mode = 0;
void Slave_Receive_Command()
{
    unsigned int temp, mask;
    int song_name_ID, mp3_first_song_pos;
    int songnum_in_curdir;
    unsigned short want_num_of_songs;
    unsigned char i, x, remain_byte;

    if (Recbak_Buffer[0] < 0x40) {
       codeIR = 0x100 + Recbak_Buffer[0];
       codeOperand = Recbak_Buffer[1];
       return;
    } else {
      switch(Recbak_Buffer[0]){		   	
        case HOST_INQUIRY:
             Slave_answer_inquiry(Recbak_Buffer[1]);
             break;

	case HOST_OSD_DISPLAY:
             remain_byte=(Receive_Index-4)+(Recbak_Buffer[1]-1);
             for (i=remain_byte+3; i<20; i++) Recbak_Buffer[i] = ' ';
             remain_byte=(Receive_Index-4)+(Recbak_Buffer[1]-1);
             x=Receive_Index -1;
	     for (i=0; i<(Receive_Index-4); i++)
                  Recbak_Buffer[remain_byte--] = Recbak_Buffer[x--];
	     for (i=0; i<(Recbak_Buffer[1]-1); i++)
	 	  Recbak_Buffer[i+3] = ' ';

             mask=0x01;
             temp = (unsigned int) (Recbak_Buffer[2]-1);
             /* take out the offset value */
                                               
             if (((mask << temp) & host_OSD_mask) == 0x00)
                  break;    /*   The OSD privilege not belong to host */
             if (Recbak_Buffer[2]) {
                 unsigned char area = Recbak_Buffer[2];
                 if( area <=5 ){
                    area = 3*(area-1) + 1;
                    host_OSD_clear_region(area+1);
                    host_OSD_clear_region(area+2);
                    host_OSD_output(area, &Recbak_Buffer[3]);

                 }
             }
	     break;

	case HOST_CLEAR_OSD_DISPLAY:
             mask=0x01;

             /* take out the offset value */
             temp = (unsigned int) (Recbak_Buffer[1]-1);
             /* The OSD privalage not belong to host */
             if (((mask << temp) & host_OSD_mask) == 0x00) break;

             if (Recbak_Buffer[1]) {
                 unsigned char area = Recbak_Buffer[1];
                 if( area <=5 ){
                    area = 3*(area-1) + 1;
                    host_OSD_clear_region(area);
                    host_OSD_clear_region(area+1);
                    host_OSD_clear_region(area+2);
                 }
             }
 	     break;

	case HOST_OSD_SELECT:
             host_OSD_mask = (unsigned int) (Recbak_Buffer[1] <<8);
	     host_OSD_mask =
                host_OSD_mask | ((unsigned int) (Recbak_Buffer[2]&0xFF));
             break;

	case HOST_SHOW_LOGO:
            /* Make sure that host didn't send this command during
               VCD non-ENTRY state */
             if ((CDinfo.type == CD_VCD) && (play_state != ENTRY_STATE)) break;

             if (Recbak_Buffer[1] == 1) {
                 if ((CDinfo.type == CD_DATA) && (play_state != ENTRY_STATE))
                      break;
                 else logo_flag = 1;
             }
             if (Recbak_Buffer[1] == 2) fill_screen(COLOR_BLACK);
             if (Recbak_Buffer[1] == 3) fill_screen(COLOR_BLUE);
             break;

	case HOST_SET_EAUX:
             {  unsigned char op;

                op = Recbak_Buffer[1];
                if ( op&0x01) HS_SET_PIN0; 
                else HS_CLEAR_PIN0;
                if ( op&0x02) HS_SET_PIN1; 
                else HS_CLEAR_PIN1;
                if ( op&0x04) HS_SET_PIN2; 
                else HS_CLEAR_PIN2;
             }
             break;

	default:
	    break;
     } /* end of switch */
    
#ifdef MP3   
     if (!STREAM_type)         return;	
 
     switch(Recbak_Buffer[0])  {
	case COM_SELECT_FIRST_DIR: /*MP3 Command: Get MP3 song name*/
	   /* ID = the number of song, Max songs number = 0xff(255) */

            song_name_ID = (((Recbak_Buffer[1]<<8) & 0xff00)
                             | (Recbak_Buffer[2] & 0xff)) - 1;
            /*here is 16 bits ID*/
            if (song_name_ID < iso9660_file_cnt) {
                cur_track_index = song_name_ID;
                force_Send_MP3_songname_flag = 1;
	     } else { /* no such song */
	        Slave_Send_Error_Msg(0xabcd);
             }
             break;

	case COM_SELECT_NEXT_NAME: /*Get next song or dir name 0x41 + Num */
	case COM_SELECT_PREV_NAME: /* Get Prev, song/dir name 0x42 + num     */
             if (Recbak_Buffer[0] == COM_SELECT_NEXT_NAME) 
                 MP3_item(Recbak_Buffer[1]);
             else MP3_item(-Recbak_Buffer[1]); 
	     if (!mp3_dir_mode) { /* get next Num of song names */
                  cur_track_index = MP3_song()-1;
                  force_Send_MP3_songname_flag = 1;
	       }
	       if (mp3_dir_mode) {  /* get next Num of directory names */
                  mp3_cur_dir_index = mp3_dir;
                  force_Send_MP3_directory_name_flag = 1;
	       }
	       break;

        /*Get next songs starts with specific character . 0x43 + Char */
        /*Get previous songs starts with specific character. 0x44 + Char */
	case COM_SEND_NEXT_SONG: 
        case COM_SEND_PREV_SONG:
             { int search_dir;
               search_dir = (Recbak_Buffer[0] == COM_SEND_NEXT_SONG)? \
                            FORWARD_SEARCH : BACKWARD_SEARCH;

	       if (cur_track_index == iso9660_file_cnt 
                   || !cur_track_index) {
	  	   Slave_Send_Error_Msg(0xabcd); /* This is the last song. */
	       } else {
		   song_name_ID = 
                       mp3_search_song_name(search_dir, Recbak_Buffer[1]);
                   cur_track_index = song_name_ID;
                   force_Send_MP3_songname_flag = 1;
	       }
             }
	     break;
             
 	case COM_FILE_NAME_HIGH:
        /*MP3 Command: Get the top song name in one directory. 0x45 + num . */
        /* the MAX number of songs is 0xffff */
   	     mp3_cur_dir_index = get_mp3_cur_dir_index(cur_track_index);
	     mp3_first_song_pos = get_mp3_absolute_pos(mp3_cur_dir_index);
	     songnum_in_curdir = get_songs_num_in_cur_dir(mp3_cur_dir_index);
             want_num_of_songs = (((Recbak_Buffer[1]<<8) & 0xff00) 
                                    | (Recbak_Buffer[2] & 0xff));

	     if (want_num_of_songs > songnum_in_curdir) {
		 Slave_Send_Error_Msg(0xabcd);/* no such many of songs */
             } else {
                 for(i=mp3_first_song_pos; 
                     i<(mp3_first_song_pos+want_num_of_songs); i++){
                     mp3_file_name_ptr = (unsigned char *) iso9660_file[i].name;
                     Slave_Send_Name(mp3_file_name_ptr);
		 }
	      }
	      break;

	case COM_DIRECTORY_MOVE: /*MP3 Command: Directory Up  0x46 + num    */
	     if(!mp3_dir_mode) break;
         
	     if( (Recbak_Buffer[1]&0xFF) == DIRECTORY_UP/*0*/) {
		 if (mp3_cur_dir_index) {
		     mp3_cur_dir_index = 
                          iso9660_dir[mp3_cur_dir_index].parent_dir;
					/*Page_Num = Parent_Page_Num-1;*/
		 } else {
		     mp3_cur_dir_index = 0; /*	Page_Num = 0; */
	         }
	      }

	      mp3_first_song_pos = get_mp3_absolute_pos(mp3_cur_dir_index);
              want_num_of_songs = (((Recbak_Buffer[2]<<8) & 0xff00) 
                                   | (Recbak_Buffer[3] & 0xff));

	      if (want_num_of_songs > songnum_in_curdir) {
			 /* no such many of songs */
		  Slave_Send_Error_Msg(0xabcd);
               } else {
                  for(i=mp3_first_song_pos; 
                      i<(mp3_first_song_pos+want_num_of_songs); i++){
                      mp3_file_name_ptr = 
                          (unsigned char *) iso9660_file[i].name;
                      Slave_Send_Name(mp3_file_name_ptr);
		  }
	       }
	       break;

         case MP3_DIR_FILE_MODE: 
         /*MP3 Command: Dir./File operation mode setting*/
         /* Opcode=0x47,  Parameter= 00 directory operation mode
 	     Parameter= 01 file operation mode*/
	     song_name_ID = 0;
	     if ((Recbak_Buffer[1]&0xff) == MP3_DIRECTORY_OPERATION_MODE) {
                  mp3_osd_back_root();
		  mp3_dir_mode = 1;  /* directory operation mode */
	     }
     	      else if ((Recbak_Buffer[1]&0xff) == MP3_FILE_OPERATION_MODE) {
                  mp3_osd_enter_subdir();
		  mp3_dir_mode = 0;  /* file operation mode */
	     } else { /* Wrong parameter */
		  Slave_Send_Error_Msg(0xabcd);
	     }
	     break;

	case MP3_SELECT_FILE:
        /*MP3 Command: Select File to enter.Not play!*/
        /* Opcode=0x48,   Parameter=FILE_ID(16bits),0001-0400(BCD)*/
             mp3_song =(Recbak_Buffer[1]* 100) + bcd2hex[Recbak_Buffer[2]];
             mp3_osd_change();
             break;

	case MP3_SELECT_DIRECTORY:
        /*MP3 Command: Select directory to enter.*/
	/* Opcode=0x49: Parameter=DIR_ID(16bits),0001-0400(BCD)*/
             temp = (Recbak_Buffer[1]* 100) + bcd2hex[Recbak_Buffer[2]];
             if(temp < 1) break;
             /* received dir_ID  base is 1, change to base 0: */
             temp = temp -1;
             if (temp < real_track_cnt ) { /* select dir to enter */
                 mp3_osd_change_dir(temp);
		 /* enter into this dir and show the file name? */
	      }  else { /* no such many of directorys. */
		 Slave_Send_Error_Msg(0xabcd);
	      }
              break;
	  default:
	       break;
        }
#endif  /* MP3 */		   
    }
}


void Slave_answer_inquiry(unsigned op)
{
    /* new added command for servo home position */
    switch(op){
        case  mHOME_POSITION:
              force_Servo_Info_flag = 1; break;
        case  mDISK_INFO:
              force_Disc_Info_flag = 1; break;
        case  mTRACK_INFO:
              force_Track_Info_flag = 1; break;
        case  mPLAYING_TIME:
              force_Playing_Time_flag = 1; break;
        case  mPLAYING_STATE:
              force_Playing_State_flag = 1; break;
        case  mPLAYING_MODE:
              force_Play_Mode_flag = 1; break;
        case  mKARAOKE:
              force_Karaoke_Setting_flag = 1; break;
        case  mSYSTEM:
              force_System_Setting_flag = 1; break;
        case  mOSD_SELECT_SETTING:
              force_osd_setting_flag = 1; break;
        case  mREAD_EAUX:
              force_read_eaux_flag = 1; break;
        case  mVERSION_NUMBER:
              force_version_number_flag = 1; break;
        case  mMP3_SONG_TITLE:
              force_mp3_title_flag = 1; break;
        case  mMP3_ARTIST:
              force_mp3_artist_flag = 1; break;
        case  mMP3_ALBUM:
              force_mp3_album_flag = 1; break;
        case  mMP3_YEAR:
              force_mp3_year_flag = 1; break;
        case  mCDT_TRACK_TITLE:
              force_cdt_title_flag = 1; break;
        case  mCDT_TRACK_ARTIST:
              force_cdt_artist_flag = 1; break;
        case  mMP3_DIRECTORY_NAME:
              if (!play_state)   /* in ENTRY_STATE */
                  cur_track_index = get_track_index_from_mp3song();
              mp3_cur_dir_index  =  get_mp3_cur_dir_index(cur_track_index);
              force_Send_MP3_directory_name_flag =1;
              break;
        case  mMP3_SONG_NAME:
              if (!play_state)  /* in ENTRY_STATE */
                  cur_track_index = get_track_index_from_mp3song();
              force_Send_MP3_songname_flag = 1;
              break; 
        default:
              break;
        }
        return;
}


/********************************************************/
/* Function: Slave_Send_Error_Msg()                            */
/* Each time send two Bytes.                            */
/********************************************************/
void Slave_Send_Error_Msg(unsigned short Message)
{
    Send_Buffer[0] = (unsigned char)((Message & 0xff00)>>8);
    Send_Buffer[1] = (unsigned char)(Message & 0xff);
    Make_Check_Sum(2);
    Total_Byte = 3;
    return;
}


int Slave_Send_Name(unsigned char *mp3_name_ptr)
{
   int i;

   for (i=0; (i<32)&&(*mp3_name_ptr); i++) {
	    Send_Buffer[i] = (unsigned char) *mp3_name_ptr;
	    mp3_name_ptr++;
    }

    Make_Check_Sum(i);
    Total_Byte = i+1;

    return 1;
}


/************************************************************/
/* input: search_dircetion, charactor want to be searched   */
/* output: mp3_song_name_ID which has been found.           */
/*         if not found return 0xffff.                      */
/************************************************************/
int mp3_search_song_name(char direction, unsigned char charactor)
{
    int i;

    if (direction == FORWARD_SEARCH){
	for (i=cur_track_index; i<iso9660_file_cnt; i++)
	     if (charactor ==  *iso9660_file[i].name) return i;
    } else {
        for (i=cur_track_index; i>0; i--)
	     if (charactor == *iso9660_file[i].name) return i;
    }
    return -1;
}


/***************************************************************************/
/* Function Description: give a mp3 song's ID, get the dir ID of this song.*/
/* input : mp3 song's number                                               */
/* output: mp3 directory index of this song. if error retiun 0xff.         */
/***************************************************************************/
unsigned char get_mp3_cur_dir_index(int cur_track_index)
{
    unsigned char i;
    int sum;

    for (i=0,sum=0; (i<real_track_cnt)&&(cur_track_index<sum); i++) {
         sum += iso9660_dir[real_track[i]].dir;
    }
    return (i-1);
}


/***************************************************************************/
/* Function Description: give a mp3 song's dir ID,			   */
/*                       get the first song's ID of this dir.              */
/* input : mp3 song's dir ID.                                              */
/* output: first mp3 song's ID of this dir.                                */
/***************************************************************************/
int get_mp3_absolute_pos(unsigned char mp3_cur_dir_index)
{
    int i;
    int temp_song_num=0;

    for (i=0; i < mp3_cur_dir_index; i++) {
         temp_song_num += iso9660_dir[i].dir; /* number of songs in this dir */
    }

    return temp_song_num;
}


/***************************************************************************/
/* Function Description: give a mp3 song's dir ID, 			   */
/*                       get the song's number of this dir.                */
/* input : mp3 song's dir ID                                               */
/* output: mp3 song's number of this dir.                                  */
/***************************************************************************/
int get_songs_num_in_cur_dir(unsigned char mp3_cur_dir_index)
{
     return iso9660_dir[mp3_cur_dir_index].dir; 
    /* number of songs in this dir */
}

parse_hundred(int number, unsigned char *hundred, unsigned char *ten_unit)
{
    *hundred = (unsigned char) (number/100);
    *ten_unit = (unsigned char) (number%100);
}
#endif /* HOST_SLAVE */