headset_soundmanager.c

bluelab的一个很好的例程

/****************************************************************************
Copyright (C) Cambridge Silicon Radio Ltd. 2004

FILE NAME
    headset_soundmanager.c
    
DESCRIPTION
    module responsible for tone generation and playback
    
*/

#include "headset_private.h"

#include "headset_configmanager.h"
#include "headset_events.h"

#include "headset_soundmanager.h"
#include "headset_tones.h"
#include "headset_volume.h"
#include "headset_audio.h"


#include <csrtypes.h>
#include <stddef.h>

/****************************************************************************
VARIABLES      
*/

#define SOM_RING_TONE 0x60FF 

/****************************************************************************
Local Functions
*/

/****************************************************************************
FUNCTIONS
*/

/****************************************************************************
NAME 
 soundManagerInit

DESCRIPTION
 Initialises sound manager

RETURNS
 void
    
*/
void soundManagerInit ( hsTaskData * pApp ) 
{
    uint16 lNote = 0 ;
    
    uint16 lSize =0 ;
    
    SOM_DEBUG (("SOM Init : \n")) ;  
    
    /*need to create the space for the event mapping and the vol tone mapping*/
    lSize = (EVENTS_MAX_EVENTS * sizeof ( HeadsetTone_t ) ) ;
    
    SOM_DEBUG(("SOM: sz[%x] \n",lSize)) ;
    
        /*allocate the total space*/
    pApp->theSoundTask.gEventTones = ( HeadsetTone_t * ) mallocPanic ( lSize ) ;
        
        /*malloc the volume Mappings*/
    lSize = (SOM_NUM_VOL_SETTINGS * sizeof (VolMapping_t) ) ;
        
    pApp->theSoundTask.gVolMaps = (VolMapping_t *) mallocPanic ( lSize ) ;
        
    for ( lNote =  0 ; lNote  < EVENTS_MAX_EVENTS ; lNote ++ )
    {
        pApp->theSoundTask.gEventTones[ lNote ] = TONE_NOT_DEFINED ;
    }
   
    for (lNote = 0 ; lNote  < SOM_NUM_VOL_SETTINGS ; lNote ++ )
    {
        pApp->theSoundTask.gVolMaps [ lNote ].IncVol  = 0 ;
        pApp->theSoundTask.gVolMaps [ lNote ].DecVol  = 0 ;
        
        pApp->theSoundTask.gVolMaps [ lNote ].Mic  = SOM_DEFAULT_MIC_LEVEL ;
        pApp->theSoundTask.gVolMaps [ lNote ].Tone = TONE_NOT_DEFINED ;
    }
    
        /*initialise*/
    pApp->theSoundTask.gVolButtonsInverted = FALSE ;
    
        /*init the tones routines*/
    TonesInit( pApp ) ;    
  
        /*now we are set up - default our internal vol setting*/
    VolumeDefault ( pApp , SOM_DEFAULT_VOLUME_LEVEL) ;   
}

/****************************************************************************
NAME 
 soundManagerIndicateEvent

DESCRIPTION
 function to indaicate an event by playing its associated tone uses underlying
    tones playback

RETURNS
 void
    
*/
void soundManagerIndicateEvent ( hsTaskData * pApp,  headsetEvents_t pEvent )
{    
    uint16 lEventIndex = pEvent - EVENTS_EVENT_BASE ;
    
        /*if the tone is present*/
    if (pApp->theSoundTask.gEventTones [ lEventIndex ] != TONE_NOT_DEFINED )
    {
        SOM_DEBUG(("SOM: EvPl[%x][%x][%x]\n", pEvent, lEventIndex , (int) pApp->theSoundTask.gEventTones [ lEventIndex]  )) ;
        
        soundManagerPlayTone (pApp ,  pApp->theSoundTask.gEventTones [ lEventIndex] ) ;
    }
    else
    {
        SOM_DEBUG(("SOM: NoPl[%x]\n", pEvent)) ;
    }

        
} 


/*-- Abstraction layer for the volume functions --*/

/****************************************************************************
NAME 
 soundManagerVolumeUp

DESCRIPTION
 Increment volume

RETURNS
 void
    
*/
void soundManagerVolumeUp ( hsTaskData   * pApp ) 
{
    if ( pApp->theSoundTask.gVolButtonsInverted )
    {
        SOM_DEBUG(("SOM: Vol Inverted Up->Down\n"));
        VolumeDown( pApp ) ;
    }
    else
    {
        VolumeUp ( pApp ) ;
    }
}


/****************************************************************************
NAME 
 soundManagerVolumeDown

DESCRIPTION
 Deccrement volume

RETURNS
 void
    
*/
void soundManagerVolumeDown ( hsTaskData * pApp ) 
{

    if ( pApp->theSoundTask.gVolButtonsInverted )
    {
        SOM_DEBUG(("SOM: Vol Inverted Down->Up\n"));
        VolumeUp( pApp ) ;
    }
    else
    {
        VolumeDown ( pApp ) ;
    }
}


/****************************************************************************
NAME 
 soundManagerVolumeDefault

DESCRIPTION
 Set default volume

RETURNS
 void
    
*/
void soundManagerVolumeDefault (const bdaddr* bd_addr) 
{
 /* Get the default volume level */
 VolumeGetStoredAGVolumeLevel(bd_addr);
}


/****************************************************************************
NAME 
 soundManagerHandleVolumeLevel

DESCRIPTION
 Handle message containing the volume level of the requested AG

RETURNS
 void
    
*/
void soundManagerHandleVolumeLevel(hsTaskData* pApp, CL_SM_GET_ATTRIBUTE_CFM_T* cfm)
{
 uint16 level;
 
 if(cfm->status == success)
  level = cfm->psdata[0];
 else
  level = SOM_DEFAULT_VOLUME_LEVEL;
 
 VolumeDefault(pApp, level);
}


/****************************************************************************
NAME 
 soundManagerToggleMute

DESCRIPTION
 Toggle mute

RETURNS
 void
    
*/
void soundManagerToggleMute ( hsTaskData * pApp )
{
    VolumeToggleMute ( pApp ) ;
}


/****************************************************************************
NAME 
 VolumeMuteOn

DESCRIPTION
 Enables Mute

RETURNS
 void
    
*/
void soundManagerMuteOn ( hsTaskData * pApp ) 
{
    VolumeMuteOn ( pApp )  ;
}

/****************************************************************************
NAME 
 soundManagerMuteOff

DESCRIPTION
 Disables Mute

RETURNS
 void
    
*/
void soundManagerMuteOff ( hsTaskData * pApp ) 
{
    VolumeMuteOff ( pApp ) ;
}
/****************************************************************************
NAME 
 soundManagerCompleteUnmute

DESCRIPTION
 Finish the unmute action

RETURNS
 void
    
*/
void soundManagerCompleteUnmute ( hsTaskData * pApp ) 
{
    VolumeCompleteUnmuteMicrophone ( pApp ) ;
}

/****************************************************************************
NAME 
 soundManagerHandleVolumeInd

DESCRIPTION
 Volume change indication from connected AG

RETURNS
 void
    
*/
void soundManagerHandleVolumeInd ( hsTaskData * pApp , uint16 pProfileVolume ) 
{
    VolumeHandleVolumeInd ( pApp , pProfileVolume ) ;
}


/****************************************************************************
NAME 
 soundManagerHandleMicInd

DESCRIPTION
 Microphone gain increment

RETURNS
 void
    
*/
void soundManagerHandleMicInd ( hsTaskData * pApp , uint16 pMicGain ) 
{
        /*if we were muted then unmute via the event so as to play tones and cancel reminder etc*/
    if (pApp->theSoundTask.gMuted == VOL_MUTED )
    {
        MessageSend ( &pApp->task , EventMuteOff , 0 ) ;
    }
    
    VolumeSetMicLevel ( pApp , pMicGain ) ;
}


/****************************************************************************
NAME 
 soundManagerConfigureVolumeSettings

DESCRIPTION
 Configure local volume related settings

RETURNS
 void
    
*/
void soundManagerConfigureVolumeSettings ( hsTaskData * pApp ,
                                           uint16 pProfileVolume , 
                                           uint16 pIncLevel , 
                                           uint16 pDecLevel ,
                                           uint16 pMicLevel , 
                                           HeadsetTone_t pTone ,
                                           uint16 pVolGain ,
                                           uint16 pMicGain)  
{
   VolumeConfigureVolumeSettings ( pApp , pProfileVolume ,pIncLevel ,pDecLevel , pMicLevel , pTone , pVolGain , pMicGain ) ;
}


/* -- Abstraction layer for tones functions --*/

/****************************************************************************
NAME 
 soundManagerConfigureEventTone

DESCRIPTION
 Configure tone event

RETURNS
 void
    
*/
void soundManagerConfigureEventTone ( hsTaskData * pApp ,headsetEvents_t pEvent , HeadsetTone_t pTone ) 
{
    
    if (pEvent == SOM_RING_TONE )
    {   
        if ( ToneIsDefined ( pTone ) ) 
        {
            SOM_DEBUG(("SOM: ConfRingTone [%x]\n" , pTone)) ;
            
            pApp->RingInfo.RingTone = pTone ;
        }    
    }
    else
    {
        TonesConfigureEvent ( pApp , pEvent , pTone ) ;
    }        
}


/****************************************************************************
NAME 
 soundManagerPlayTone

DESCRIPTION
 Play tone

RETURNS
	void
    
*/
void soundManagerPlayTone ( hsTaskData * pApp , HeadsetTone_t pTone )
{
    TonesPlayTone ( pApp , pTone ) ;
}


/****************************************************************************
NAME 
 soundManagerIsToneDefined

DESCRIPTION
 Check if tone is defined

RETURNS
 void
    
*/
bool soundManagerIsToneDefined ( HeadsetTone_t pTone ) 
{
    return ( ToneIsDefined ( pTone ) ) ;
}



/****************************************************************************
NAME 
 soundManagerStoreVolumeLevel

DESCRIPTION
 Persistently store the current volume level

RETURNS
 void
    
*/
void soundManagerStoreVolumeLevel(hsTaskData * pApp, const bdaddr* bd_addr)
{
 VolumeSetStoredAGVolumeLevel(bd_addr, pApp->theSoundTask.gSMVolumeLevel);
}



void soundManagerOutOfBandRing ( hsTaskData * pApp )
{
     if (! pApp->RingInfo.InBandRingEnabled )
     {
        SOM_DEBUG(("SOM: OutBandRing[%x]\n" , pApp->RingInfo.RingTone)) ;

        /* Play ring tone from configuration */
        TonesPlayTone ( pApp , pApp->RingInfo.RingTone );
     }
     else
     {
        SOM_DEBUG(("SOM: InBandRing \n")) ;  
     }
}


/****************************************************************************
NAME 
 soundManagerMuteRemind

DESCRIPTION
 Sends a mute reminder message
 
RETURNS
 
*/
void soundManagerMuteRemind ( hsTaskData * pApp ) 
{
    VolumeMuteRemind ( pApp ) ;
}


/****************************************************************************
NAME 
 soundManagerSendAndSetCurrentVolume

DESCRIPTION
Sends and sets the current volume to the headset
 
RETURNS
 
*/
void soundManagerSendAndSetCurrentVolume ( hsTaskData * pApp )
{
        /*get the curent volume Level*/
    uint16 lLevel = pApp->theSoundTask.gSMVolumeLevel ;
    
    VolumeDefault (pApp , lLevel ) ;
}