/****************************************************************************
Copyright (C) Cambridge Silicon Radio Ltd. 2005-2007

FILE NAME
    headset_auth.c        

DESCRIPTION
    This file contains the Authentication functionality for the AV Headset 
    Application

NOTES

*/

/****************************************************************************
    Header files
*/


#include "headset_a2dp_stream_control.h"
#include "headset_amp.h"
#include "headset_avrcp_event_handler.h"
#include "headset_debug.h"
#include "headset_statemanager.h"
#include "headset_volume.h"

#include <audio.h>
#include <bdaddr.h>
#include <csr_sbc_decoder_plugin.h>
#include <csr_mp3_decoder_plugin.h>


#ifdef DEBUG_A2DP_STREAM_CONTROL
    #define STREAM_DEBUG(x) DEBUG(x)    
#else
    #define STREAM_DEBUG(x) 
#endif   


/****************************************************************************
    LOCAL FUNCTION PROTOTYPES
*/



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


/**************************************************************************/
void streamControlCeaseA2dpStreaming(hsTaskData *app, bool send_suspend)
{				  
	STREAM_DEBUG(("streamControlCeaseA2dpStreaming %d\n",send_suspend));
	
	MessageCancelAll(&app->task, APP_RESUME_A2DP);
	
	if (app->dsp_process == dsp_process_a2dp)
	{		
		AudioDisconnect();
		app->dsp_process = dsp_process_none;
		STREAM_DEBUG(("CeaseStreaming - disconnect audio\n"));
		/* Turn the audio amp off after a delay */
		AmpOffLater(app);
	
    	if (app->a2dp.sink && send_suspend && (stateManagerIsA2dpStreaming()))
    	{
			STREAM_DEBUG(("CeaseStreaming - suspend audio\n"));
        	A2dpSuspend(app->a2dp.a2dp, app->a2dp.sink);
			if (!IsA2dpSourceAnAg(app))
			{
				if (stateManagerGetA2dpState() == headsetA2dpPaused)
				{
					/* Ensure music does not resume erroneously when the call ends */
					app->sendPlayOnConnection = FALSE;
				}
				else
				{
					/* Only send Pause if headset is currently playing music */
					if (app->autoSendAvrcp)
     					avrcpSendPause(app);
     				/* Ensure music is resumed when the call ends */
     				app->sendPlayOnConnection = TRUE;
 				}
				stateManagerEnterA2dpPausedState(app);
			}
    	}
	}
}


/**************************************************************************/
void streamControlConnectA2dpAudio(hsTaskData *app)
{	
	bool result;
	AUDIO_MODE_T mode = AUDIO_MODE_CONNECTED;
	Task audio_plugin;
	
	STREAM_DEBUG(("streamControlConnectA2dpAudio vol index[%d] vol gain[%d]\n",app->audioData.gAvVolumeLevel, VolumeRetrieveGain(app->audioData.gAvVolumeLevel, TRUE)));
	
	/* Turn the audio amp on */
	AmpOn(app);
	
	switch (app->a2dp.sep)
	{
		case a2dp_mpeg_audio:
			audio_plugin = (TaskData *)&csr_mp3_decoder_plugin;
			break;
		default:
			audio_plugin = (TaskData *)&csr_sbc_decoder_plugin;
			break;
	}
	
	result = AudioConnect(  audio_plugin ,	
		 				     app->a2dp.sink , 
							 app->theCodecTask,
							 VolumeRetrieveGain(app->audioData.gAvVolumeLevel, TRUE),
						   	 app->a2dp.rate,
						   	 TRUE ,
		 					 mode ,  
							 0 ); 	
	
	app->dsp_process = dsp_process_a2dp;
}


/**************************************************************************/
void streamControlResumeA2dpStreaming(hsTaskData *app, uint32 user_delay)
{				  
	STREAM_DEBUG(("streamControlResumeA2dpStreaming\n"));
	MessageCancelAll(&app->task, APP_RESUME_A2DP);
	if (!user_delay)
   		MessageSendLater(&app->task, APP_RESUME_A2DP, 0, A2DP_RESTART_DELAY);           
	else
		MessageSendLater(&app->task, APP_RESUME_A2DP, 0, user_delay);           
}


/**************************************************************************/
void streamControlCancelResumeA2dpStreaming(hsTaskData *app)
{
	STREAM_DEBUG(("streamControlCancelResumeA2dpStreaming\n"));
	MessageCancelAll(&app->task, APP_RESUME_A2DP);
}


/**************************************************************************/
void streamControlBeginA2dpStreaming(hsTaskData *app)
{				  
	if (app->sco_sink || (!app->a2dp.sink))
		return;
	
	STREAM_DEBUG(("streamControlBeginA2dpStreaming\n"));
	if (!stateManagerIsA2dpStreaming() && app->a2dpSourceSuspended)
	{
		STREAM_DEBUG(("Begin Streaming - start A2DP\n"));
		streamControlStartA2dp(app);			
	}
	
	if (stateManagerIsA2dpStreaming() && (app->dsp_process != dsp_process_a2dp))
	{
		STREAM_DEBUG(("Begin Streaming - connect audio\n"));
		streamControlConnectA2dpAudio(app);
	}
}


/**************************************************************************/
void streamControlSuspendA2dp(hsTaskData *app)
{				  
    if (app->a2dp.sink && stateManagerIsA2dpStreaming())
    {
		STREAM_DEBUG(("streamControlSuspendA2dp\n"));
        A2dpSuspend(app->a2dp.a2dp, app->a2dp.sink);
		if (!IsA2dpSourceAnAg(app))
		{
			if (app->autoSendAvrcp)
			{
     			avrcpSendPause(app);
				stateManagerEnterA2dpPausedState(app);
			}
		}
    }
}


/**************************************************************************/
void streamControlStartA2dp(hsTaskData *app)
{
	if (app->a2dp.sink && app->a2dpSourceSuspended && !app->sco_sink)
    {
		STREAM_DEBUG(("streamControlStartA2dp\n"));
        A2dpStart(app->a2dp.a2dp, app->a2dp.sink);
		if (!IsA2dpSourceAnAg(app) && (app->sendPlayOnConnection))
		{
			if (app->autoSendAvrcp)
     			avrcpSendPlay(app);
     		app->sendPlayOnConnection = FALSE;
 		}
		app->a2dpSourceSuspended = FALSE;
	}
}


/*****************************************************************************/
bool IsA2dpSourceAnAg(hsTaskData *app)
{
    bdaddr bdaddr_sig, bdaddr_slc;
    
    if (!SinkGetBdAddr(app->a2dp.sig_sink, &bdaddr_sig))
		return FALSE;
    if (!SinkGetBdAddr(app->slc_sink, &bdaddr_slc))
		return FALSE;
    if (BdaddrIsSame(&bdaddr_sig, &bdaddr_slc))
        return TRUE;
    
    return FALSE;
}