Пример #1
0
/*
 * DirectSoundを初期化する
 */
BOOL DSInitialize(HWND hWnd)
{
	HRESULT hRet;
	uintptr_t t;

	/* IDirectSoundのインスタンスを取得して初期化する */
	hRet = CoCreateInstance(&CLSID_DirectSound,
							NULL,
							CLSCTX_INPROC_SERVER,
							&IID_IDirectSound,
							(void **)&pDS);
	if(hRet != S_OK || pDS == NULL)
		return FALSE;

	/* COMオブジェクトを初期化する */
	IDirectSound_Initialize(pDS, NULL);

	/* 協調レベルを設定する */
	hRet = IDirectSound_SetCooperativeLevel(pDS, hWnd, DSSCL_PRIORITY);
	if(hRet != DS_OK)
		return FALSE;

	/* プライマリバッファのフォーマットを設定する */
	if(!CreatePrimaryBuffer())
		return FALSE;

	/* セカンダリバッファを作成する */
	if(!CreateSecondaryBuffers())
		return FALSE;

	/* イベントスレッドへの終了通知用のイベントを作成する */
	hQuitEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
	if(hQuitEvent == NULL)
		return FALSE;

	/* DirectSoundの再生位置通知を受け取るスレッドを開始する */
	t = _beginthread(EventThread, 0, NULL);
	if(t == (unsigned long)-1)
		return FALSE;

	hEventThread = (HANDLE)t;
	return TRUE;
}
Пример #2
0
static void InitializeAudio(uint32_t freq)
{
    WriteTrace(TraceAudioInitShutdown, TraceDebug, "Start (freq: %d)",freq);
    if (freq < 4000)
    {
        WriteTrace(TraceAudioInitShutdown, TraceInfo, "Sometimes a bad frequency is requested so ignore it (freq: %d)",freq);
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }

    if (g_GameFreq == freq && g_primaryBuffer != NULL)
    {
        WriteTrace(TraceAudioInitShutdown, TraceInfo, "we are already using this frequency, so ignore it (freq: %d)",freq);
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }

    if (g_critical_failure)
    {
        WriteTrace(TraceAudioInitShutdown, TraceInfo, "had a critical failure in setting up plugin, so ignore init");
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }

    /* This is important for the sync */
    g_GameFreq = freq;

#ifdef ANDROID
    SLuint32 sample_rate;
    if((freq/1000) <= 11)
    {
        g_OutputFreq = 11025;
        sample_rate = SL_SAMPLINGRATE_11_025;
    }
    else if((freq/1000) <= 22)
    {
        g_OutputFreq = 22050;
        sample_rate = SL_SAMPLINGRATE_22_05;
    }
    else if((freq/1000) <= 32)
    {
        g_OutputFreq = 32000;
        sample_rate = SL_SAMPLINGRATE_32;
    }
    else
    {
        g_OutputFreq = 44100;
        sample_rate = SL_SAMPLINGRATE_44_1;
    }
#endif

    WriteTrace(TraceAudioInitShutdown, TraceInfo, "Requesting frequency: %iHz.", g_OutputFreq);

    /* reload these because they gets re-assigned from data below, and InitializeAudio can be called more than once */
    g_PrimaryBufferSize = GetSetting(Buffer_PrimarySize);
    g_SecondaryBufferSize = GetSetting(Buffer_SecondarySize);
    g_SecondaryBufferNbr = GetSetting(Buffer_SecondaryNbr);

    /* Close everything because InitializeAudio can be called more than once */
    CloseAudio();

    /* Create primary buffer */
    if(!CreatePrimaryBuffer())
    {
        WriteTrace(TraceAudioInitShutdown, TraceError, "CreatePrimaryBuffer failed");
        CloseAudio();
        g_critical_failure = true;
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }

    /* Create secondary buffers */
    if(!CreateSecondaryBuffers())
    {
        WriteTrace(TraceAudioInitShutdown, TraceError, "CreateSecondaryBuffers failed");
        CloseAudio();
        g_critical_failure = true;
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }

#ifdef ANDROID
    /* Create thread Locks to ensure synchronization between callback and processing code */
    if (pthread_mutex_init(&(g_lock.mutex), (pthread_mutexattr_t*) NULL) != 0)
	{
        WriteTrace(TraceAudioInitShutdown, TraceError, "pthread_mutex_init failed");
        CloseAudio();
        g_critical_failure = true;
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
	}
    if (pthread_cond_init(&(g_lock.cond), (pthread_condattr_t*) NULL) != 0)
    {
        WriteTrace(TraceAudioInitShutdown, TraceError, "pthread_cond_init failed");
        CloseAudio();
        g_critical_failure = true;
        WriteTrace(TraceAudioInitShutdown, TraceDebug, "Done");
        return;
    }
    pthread_mutex_lock(&(g_lock.mutex));
    g_lock.value = g_lock.limit = g_SecondaryBufferNbr;
    pthread_mutex_unlock(&(g_lock.mutex));

    /* Engine object */
    SLresult result = slCreateEngine(&g_engineObject, 0, NULL, 0, NULL, NULL);
    if(result != SL_RESULT_SUCCESS)
    {
        WriteTrace(TraceAudioInitShutdown, TraceError, "slCreateEngine failed (result: %d)",result);
    }

    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_engineObject)->Realize(g_engineObject, SL_BOOLEAN_FALSE);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "slCreateEngine->Realize failed (result: %d)",result);
        }
    }

    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_engineObject)->GetInterface(g_engineObject, SL_IID_ENGINE, &g_engineEngine);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "slCreateEngine->GetInterface failed (result: %d)",result);
        }
    }

    if(result == SL_RESULT_SUCCESS)
    {
        /* Output mix object */
        result = (*g_engineEngine)->CreateOutputMix(g_engineEngine, &g_outputMixObject, 0, NULL, NULL);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "slCreateEngine->CreateOutputMix failed (result: %d)",result);
        }
    }

    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_outputMixObject)->Realize(g_outputMixObject, SL_BOOLEAN_FALSE);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_outputMixObject->Realize failed (result: %d)",result);
        }
    }

    if(result == SL_RESULT_SUCCESS)
    {
        SLDataLocator_AndroidSimpleBufferQueue loc_bufq = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE, g_SecondaryBufferNbr};

        SLDataFormat_PCM format_pcm = {SL_DATAFORMAT_PCM,2, sample_rate, SL_PCMSAMPLEFORMAT_FIXED_16, SL_PCMSAMPLEFORMAT_FIXED_16,
                       (SL_SPEAKER_FRONT_LEFT | SL_SPEAKER_FRONT_RIGHT), SL_BYTEORDER_LITTLEENDIAN};

        SLDataSource audioSrc = {&loc_bufq, &format_pcm};

        /* Configure audio sink */
        SLDataLocator_OutputMix loc_outmix = {SL_DATALOCATOR_OUTPUTMIX, g_outputMixObject};
        SLDataSink audioSnk = {&loc_outmix, NULL};

        /* Create audio player */
        const SLInterfaceID ids1[] = {SL_IID_ANDROIDSIMPLEBUFFERQUEUE};
        const SLboolean req1[] = {SL_BOOLEAN_TRUE};
        result = (*g_engineEngine)->CreateAudioPlayer(g_engineEngine, &(g_playerObject), &audioSrc, &audioSnk, 1, ids1, req1);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_engineEngine->CreateAudioPlayer failed (result: %d)",result);
        }
    }

    /* Realize the player */
    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_playerObject)->Realize(g_playerObject, SL_BOOLEAN_FALSE);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_playerObject->Realize failed (result: %d)",result);
        }
    }

    /* Get the play interface */
    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_playerObject)->GetInterface(g_playerObject, SL_IID_PLAY, &(g_playerPlay));
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_playerObject->GetInterface(SL_IID_PLAY) failed (result: %d)",result);
        }
    }

    /* Get the buffer queue interface */
    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_playerObject)->GetInterface(g_playerObject, SL_IID_ANDROIDSIMPLEBUFFERQUEUE, &(g_bufferQueue));
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_playerObject->GetInterface(SL_IID_ANDROIDSIMPLEBUFFERQUEUE) failed (result: %d)",result);
        }
    }

    /* register callback on the buffer queue */
    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_bufferQueue)->RegisterCallback(g_bufferQueue, queueCallback, &g_lock);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "bufferQueue->RegisterCallback() failed (result: %d)",result);
        }
    }

    /* set the player's state to playing */
    if(result == SL_RESULT_SUCCESS)
    {
        result = (*g_playerPlay)->SetPlayState(g_playerPlay, SL_PLAYSTATE_PLAYING);
        if(result != SL_RESULT_SUCCESS)
        {
            WriteTrace(TraceAudioInitShutdown, TraceError, "g_playerPlay->SetPlayState(SL_PLAYSTATE_PLAYING) failed (result: %d)",result);
        }
    }

    if(result != SL_RESULT_SUCCESS)
    {
        WriteTrace(TraceAudioInitShutdown, TraceNotice, "Couldn't open OpenSLES audio");
        CloseAudio();
        g_critical_failure = true;
    }
#endif
    WriteTrace(TraceAudioInitShutdown, TraceNotice, "Done");
}