audio_support.c

本程序为ST公司开发的源代码

/**************************************************
 *
 * audio_support.c
 *
 * CVS ID:   $Id: audio_support.c,v 1.47 2007/09/21 05:25:09 hara Exp $
 * Author:   Ondrej Kutik [OK] - STM
 * Date:     $Date: 2007/09/21 05:25:09 $
 * Revision: $Revision: 1.47 $
 * 
 * Description:
 * 
 *   Support for non compressed audio tracks
 *
 ***************************************************
 * 
 * COPYRIGHT (C) ST Microelectronics  2005
 *            All Rights Reserved
 *
 ****************************************************
 *
 * STM CVS Log:
 *
 * $Log: audio_support.c,v $
 * Revision 1.47  2007/09/21 05:25:09  hara
 * Initial implementation for WMDRM feature into A+.
 *
 * Revision 1.46  2007/02/13 11:01:46  sedmik
 * shuffle marks array rearrangement
 *
 * Revision 1.45  2007/02/08 15:56:49  trubac
 * Optimization of song indexing
 *
 * Revision 1.44  2007/01/18 15:01:18  trubac
 * Preparation for 15000 files
 *
 * Revision 1.43  2006/12/13 14:29:25  trubac
 * Fixed changing directories with respect of playable contents
 *
 * Revision 1.42  2006/12/12 19:13:01  trubac
 * New functions for dir numbering, should be tested
 *
 * Revision 1.41  2006/11/25 08:10:22  belardi
 * Ununsed function removal to free code space
 *
 * Revision 1.40  2006/11/22 15:56:42  sedmik
 * FindDirNrForIndex - prevents everlasting loop when improper input index
 *
 * Revision 1.39  2006/11/16 16:33:57  sedmik
 * fix in FindIndexForItemNr
 *
 * Revision 1.38  2006/11/16 13:21:18  trubac
 * CountFilesForDevice/Volume changed parameter t_SearchMode
 *
 * Revision 1.37  2006/11/07 10:55:29  belardi
 * Removed unused variable to get rid of compiler warning
 *
 * Revision 1.36  2006/11/02 17:00:24  trubac
 * Finding song/playlist from item number fixed
 *
 * Revision 1.35  2006/11/01 13:03:47  trubac
 * Finding song nr. functions changed to be faster and to allow playlists
 *
 * Revision 1.34  2006/10/27 15:09:35  sedmik
 * fix in FindDirNrForIndex
 *
 * Revision 1.33  2006/10/23 14:22:47  trubac
 * FindSongNrForIndex optimized for speed
 *
 * Revision 1.32  2006/10/17 09:43:53  trubac
 * get_track_endtime deleted
 *
 * Revision 1.31  2006/09/18 09:55:20  belardi
 * Corrected CVS keyword usage
 *
 * Revision 1.30  2006/09/18 09:22:36  belardi
 * Added Log CVS keyword into file header
 *
 * Revision 1.29  2006/09/15 20:17:25  belardi
 * Added Log CVS keyword into file header
 *
 *
 ***************************************************/


#include "gendef.h"
#include "toc.h"
#include "xfile.h"
#include "audio_support.h"
#include <string.h>
#include "player.h"


uint8	  AudioTracksMarks[AUDIO_TRACKS_MARKS_BUFFER_SIZE];				//JS, bitarray for marking played audio tracks(max 100) in shuffle mode. 

#if 0 // [RB] commented out to get rid of compiler warning

/******************************************************************************/
/* Function:  set_play_speed                                                 */
/*                                                                            */
/*! \brief
 *  \param    uint8 param_speed
 *  \return   RETVAL
 *  \remark
 */
/******************************************************************************/

RETVAL set_play_speed(uint8 param_speed)
{
  switch (param_speed)
  {
  case MCVAL_SPEED_CLV_2X:
    param_speed = (CLV | CLV_2X);
    servo_cnf_speed = MCVAL_SPEED_CLV_2X;
    break;

//case MCVAL_SPEED_CLV_1X:
  default:
    param_speed = (CLV | CLV_1X);
    servo_cnf_speed = MCVAL_SPEED_CLV_1X;
    break;
  }
  return decoder_set_speed_cmd(param_speed);
}

#endif


/******************************************************************************/
/* Function:  skip_track_type                                                 */
/*                                                                            */
/*! \brief
 *  \param    t_track_type track_type
 *  \return   t_bool
 *  \remark
 */
/******************************************************************************/


t_bool skip_track_type(t_track_type track_type)
{
////****  if (LOCAL_CNF_SKIP_DATA_TRACK_ON && (TRACK_TYPE_DATA == track_type))
////****  {
////****    return TRUE;
////****  }
////****  else if (LOCAL_CNF_SKIP_AUDIO_TRACK_ON && (TRACK_TYPE_AUDIO == track_type))
////****  {
////****    return TRUE;
////****  }

  // [RB] uncommented to deal someway with mixed-mode CD where the first track
  // is a CDROM track and other are audio
  if (TRACK_TYPE_DATA == track_type)
  {
    return TRUE;
  }
  else
  {
    return FALSE;
  }
}

/******************************************************************************/
/* Function:  check_track                                                     */
/*                                                                            */
/*! \brief
 *  \param    t_track track
 *  \return   t_track
 *  \remark
 */
/******************************************************************************/
#if 0 // [RB] unused
t_track check_track(t_track track)
{
  if (track < TOC_MIN_TRACK)
  {
    track = TOC_MIN_TRACK;
  }
  else if (track > TOC_MAX_TRACK)
  {
    track = TOC_MAX_TRACK;
  }
  return track;
}
#endif

/******************************************************************************/
/* Function:  get_next_track                                                  */
/*                                                                            */
/*! \brief
 *  \param    t_track track, t_direction direction
 *  \return   t_track
 *  \remark
 */
/******************************************************************************/

t_track get_next_track(t_track track, t_direction direction)
{
  if (FORWARD == direction)
  {
    track++;
    if (track < TOC_MIN_TRACK)
    {
      track = TOC_MIN_TRACK;
    }
  }
  else
  {
    track--;
    if (track > TOC_MAX_TRACK)
    {
      track = TOC_MAX_TRACK;
    }
  }

  while ((track >= TOC_MIN_TRACK) && (track <= TOC_MAX_TRACK))
  {
    if (!skip_track_type(TOC_TRACK_TYPE(track)))
    {
      return track;
    }
    if (FORWARD == direction)
    {
      track++;
    }
    else
    {
      track--;
    }
  }
  return 0;
}


/******************************************************************************/
/* Function:  find_next_track                                                 */
/*                                                                            */
/*! \brief
 *  \param    t_track track, t_direction direction, t_bool repeat_disc
 *  \return   t_track
 *  \remark
 */
/******************************************************************************/

t_track find_next_track(t_track track,
                               t_direction direction,
                               t_bool repeat_disc)
{
  if (TOC_IS_KNOWN)
  {
    track = get_next_track(track, direction);
    if ((0 == track) && repeat_disc)
    {
      if (FORWARD == direction)
      {
        track = get_next_track(0, direction);
      }
      else
      {
        track = get_next_track(T_TRACK_MAX, direction);
      }
    }
    return track;
  }
  return 0;
}


/******************************************************************************/
/* Function:  get_track_time                                                  */
/*                                                                            */
/*! \brief
 *  \param    t_track track
 *  \return   t_time
 *  \remark
 */
/******************************************************************************/
#if 0 // [RB] unused
t_time get_track_time(t_track track)
{
  track = check_track(track);

  return TOC_TRACK_TIME(track);
}
#endif

/******************************************************************************/
// Preparation for playlist for audio tracks
/******************************************************************************/

void MarkAudioTrack(uint16 index, uint8 * array)
{
	uint8 byte_index = index >>3;
	uint8 bitmask = 1<<(index & 0x7);
	array[byte_index] |= bitmask;
}

t_bool IsMarkedAudioTrack(uint16 index, uint8 * array)
{
	uint8 byte_index = index >>3;
	uint8 bitmask = 1<<(index & 0x7);
	if (bitmask & array[byte_index])
		return b_TRUE;
	else
		return b_FALSE;
}


t_bool IsSongAlreadyPlayed(t_XItem song_index, t_player_playlist * player_playlist)
{ 
  if ((player_playlist->enabled) && (player_playlist->parsed))
  {
    return (IsMarkedAudioTrack(song_index, player_playlist->shuffle_marks));
  }

  if (XAR_NodeType(song_index) == XTYPE_TRACK)
  {
    return (IsMarkedAudioTrack(song_index, AudioTracksMarks));
  }
  else
  {
    if ( X_array[song_index].nodetype.i & XFLAG_FILE_PLAYED)
      return b_TRUE;
    else
      return b_FALSE;      
  }
}

void MarkSongAsPlayed(t_XItem song_index, t_player_playlist * player_playlist)
{
  if ((player_playlist->enabled)  && (player_playlist->parsed))
  {
    MarkAudioTrack(song_index, player_playlist->shuffle_marks);
  }
  else if (XAR_NodeType(song_index) == XTYPE_TRACK)
  {
    MarkAudioTrack(song_index, AudioTracksMarks);
  }
  else
  {
    X_array[song_index].nodetype.i |= XFLAG_FILE_PLAYED;
  }
}


void ClearAudioTracksMarks(uint8 * array, uint8 size)
{
	memset(array, 0x0, size); // sizeof(AUDIO_TRACKS_SET/8));
}


void ClearSongMarks(t_XItem current_song, t_player_params * player_params, t_player_playlist * player_playlist)
{
  t_XItem song_index;
  uint32  count;
  t_XItem vol = 0;
  t_volume_selection_struct volume_selection_struct;
  
  switch (player_params->range)
  {
    case RANGE_DIRECTORY:
    case RANGE_SUBDIRS:
    case RANGE_VOLUME:
      if (XAR_NodeType(current_song) == XTYPE_TRACK)     //audio tracks range
      {
        ClearAudioTracksMarks(AudioTracksMarks, AUDIO_TRACKS_MARKS_BUFFER_SIZE);
      }
      else                            //data tracks range
      {
        vol = XAR_VolumeForItem(current_song);   
        song_index = player_params->range_from;
        
        for (count = 0; count< player_params->range_num; count++ )
        {
          X_array[song_index].nodetype.i &= ~XFLAG_FILE_PLAYED; 
          song_index = XAR_NextSong(vol, song_index,0);
        }  
      }
      break;
    case RANGE_DEVICE:
      volume_selection_struct.volume = vol;
      volume_selection_struct.direction = FORWARD;
      volume_selection_struct.audio_first = b_TRUE;
      volume_selection_struct.repeat = REPEAT_OFF;
      volume_selection_struct.device = player_params->device;
      while(1)
      {
        vol = XAR_FindNextVolume(&volume_selection_struct); //find volume for did
        volume_selection_struct.volume = vol;
        if (vol)          
        {   
          if (1==vol)
            ClearAudioTracksMarks(AudioTracksMarks, AUDIO_TRACKS_MARKS_BUFFER_SIZE);
          else
          {            
            song_index = XAR_VolumeNode(vol);
            count = X_array[song_index].data.xvolume.nodes_num;
            while (count>0)
            {
              song_index++;
              if (XAR_DirRecordIsFile(song_index))
                X_array[song_index].nodetype.i &= ~XFLAG_FILE_PLAYED;                 
              count--;
            }
          }
                      
        }  
        else     //unable to find next volume for device 
          return;  
      }           
    case RANGE_PLAYLIST:
//old approach marks are done in X_array
#if 0    
      for (count = 0; count < (player_playlist->array_items); count++)
      {
        song_index = player_playlist->array[count] + player_playlist->first_volume_node; 
        X_array[song_index].type &= ~XFLAG_FILE_PLAYED;
      }            
#endif 
      ClearAudioTracksMarks(player_playlist->shuffle_marks, PLAYLIST_TRACKS_MARKS_BUFFER_SIZE);     
      break;
    case RANGE_ALL_VOLUMES:
      //tbd
      break;
      
    
  }
}



uint32 CountFilesForVolume(uint32 vol,t_SearchMode search)
{
  t_XItem index = 0;
  uint32 count = 0;
  uint32 nodes_num;
  // uint8 xtype; // [RB] unused

  if (S_TRUE == XAR_IsActiveVolume(vol))
  {
    if (1 == vol) //special case (audio tracks volume) 
    { 
    /*
    //count real number of files
      index = 0;          
      while(1)
      {
        index = find_next_track(index, FORWARD, FALSE);
        if (index)
          count++;
        else
          break;        
      }
    */
      if(search != SEARCH_PLAYABLE)
           return 0;
      count = find_next_track(0, BACKWARD, TRUE);      //count is an absolute track number (including possible data track)
      return count;
    }
    else
    {      
      //all other volumes      
      index = XAR_VolumeNode(vol);
      nodes_num = X_array[index].data.xvolume.nodes_num + index;     //add offset
      index++;   //goto root dir index
      while(1)   //go forward in dirs and count files num 
      { 
      	switch(XAR_XNodeType(index))
      	{
      	    case PLAYLIST_PLS:
      	    case PLAYLIST_M3U:
      	    //case PLAYLIST_WPL:
      	    //case PLAYLIST_ASX:
#if (0 != HAVE_WMDRM)
            case PLAYLIST_PLA:
#endif            
      	        if(search==SEARCH_PLAYLISTS)		//||(search==SEARCH_ALL))
      			    count++;
      			break;
      		case CAFILE_MP3:
      		case CAFILE_AAC:
      		case CAFILE_WMA:
      		    if(search==SEARCH_PLAYABLE)			//||(search==SEARCH_ALL))
      		    	count++;
      		    break;
      		case DATA_FILE:
      			if(search==SEARCH_SPECIAL)			//||(search==SEARCH_ALL))
      			    count++;