Lothario
/
axmol
mirror of https://github.com/axmolengine/axmol.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

updated for Windows 8.1

This commit is contained in:
Dale Stammen 2014-10-14 14:13:14 -07:00
parent ec5af7ae90
commit 52fc6d618b
5 changed files with 362 additions and 303 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

185
cocos/audio/winrt/Audio.cpp
View File

@ -1,47 +1,30 @@
//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF /*
//// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO * cocos2d-x http://www.cocos2d-x.org
//// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A *
//// PARTICULAR PURPOSE. * Copyright (c) 2010-2011 - cocos2d-x community
//// *
//// Copyright (c) Microsoft Corporation. All rights reserved * Portions Copyright (c) Microsoft Open Technologies, Inc.
* All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and limitations under the License.
*/
#include "pch.h"
#include "Audio.h" #include "Audio.h"
#include "MediaStreamer.h" #include "MediaStreamer.h"
//#include "CCCommon.h"
static std::wstring CCUtf8ToUnicode(const char * pszUtf8Str, unsigned len/* = -1*/) inline void ThrowIfFailed(HRESULT hr)
{
std::wstring ret;
do
{
if (! pszUtf8Str) break;
// get UTF8 string length
if (-1 == len)
{
len = strlen(pszUtf8Str);
}
if (len <= 0) break;
// get UTF16 string length
int wLen = MultiByteToWideChar(CP_UTF8, 0, pszUtf8Str, len, 0, 0);
if (0 == wLen || 0xFFFD == wLen) break;
// convert string
wchar_t * pwszStr = new wchar_t[wLen + 1];
if (! pwszStr) break;
pwszStr[wLen] = 0;
MultiByteToWideChar(CP_UTF8, 0, pszUtf8Str, len, pwszStr, wLen + 1);
ret = pwszStr;
if(pwszStr) { delete[] (pwszStr);};
} while (0);
return ret;
}
static inline void ThrowIfFailed(HRESULT hr)
{ {
if (FAILED(hr)) if (FAILED(hr))
{ {
// Set a breakpoint on this line to catch DirectX API errors // Set a breakpoint on this line to catch DX API errors.
throw Platform::Exception::CreateException(hr); throw Platform::Exception::CreateException(hr);
} }
} }
@ -55,14 +38,14 @@ void AudioEngineCallbacks::Initialize(Audio *audio)
// to be closed down and restarted. The error code is given in error. // to be closed down and restarted. The error code is given in error.
void _stdcall AudioEngineCallbacks::OnCriticalError(HRESULT Error) void _stdcall AudioEngineCallbacks::OnCriticalError(HRESULT Error)
{ {
UNUSED_PARAM(Error);
m_audio->SetEngineExperiencedCriticalError(); m_audio->SetEngineExperiencedCriticalError();
}; };
Audio::Audio() : Audio::Audio() :
m_backgroundID(0), m_backgroundID(0),
m_soundEffctVolume(1.0), m_soundEffctVolume(1.0f),
m_backgroundMusicVolume(1.0f) m_backgroundMusicVolume(1.0f)
{ {
} }
@ -220,8 +203,10 @@ void Audio::StopBackgroundMusic(bool bReleaseData)
StopSoundEffect(m_backgroundID); StopSoundEffect(m_backgroundID);
if (bReleaseData) if (bReleaseData){
UnloadSoundEffect(m_backgroundID); UnloadSoundEffect(m_backgroundID);
RemoveFromList(m_backgroundID);
}
} }
void Audio::PauseBackgroundMusic() void Audio::PauseBackgroundMusic()
@ -328,9 +313,6 @@ void Audio::PlaySoundEffect(unsigned int sound)
m_soundEffects[sound].m_soundEffectSourceVoice->SubmitSourceBuffer(&m_soundEffects[sound].m_audioBuffer) m_soundEffects[sound].m_soundEffectSourceVoice->SubmitSourceBuffer(&m_soundEffects[sound].m_audioBuffer)
); );
XAUDIO2_BUFFER buf = {0};
XAUDIO2_VOICE_STATE state = {0};
if (m_engineExperiencedCriticalError) { if (m_engineExperiencedCriticalError) {
// If there's an error, then we'll recreate the engine on the next render pass // If there's an error, then we'll recreate the engine on the next render pass
return; return;
@ -426,7 +408,8 @@ void Audio::PauseAllSoundEffects()
EffectList::iterator iter; EffectList::iterator iter;
for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++) for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++)
{ {
PauseSoundEffect(iter->first); if (iter->first != m_backgroundID)
PauseSoundEffect(iter->first);
} }
} }
@ -439,11 +422,12 @@ void Audio::ResumeAllSoundEffects()
EffectList::iterator iter; EffectList::iterator iter;
for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++) for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++)
{ {
ResumeSoundEffect(iter->first); if (iter->first != m_backgroundID)
ResumeSoundEffect(iter->first);
} }
} }
void Audio::StopAllSoundEffects() void Audio::StopAllSoundEffects(bool bReleaseData)
{ {
if (m_engineExperiencedCriticalError) { if (m_engineExperiencedCriticalError) {
return; return;
@ -452,8 +436,27 @@ void Audio::StopAllSoundEffects()
EffectList::iterator iter; EffectList::iterator iter;
for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++) for (iter = m_soundEffects.begin(); iter != m_soundEffects.end(); iter++)
{ {
StopSoundEffect(iter->first); if (iter->first != m_backgroundID){
StopSoundEffect(iter->first);
if (bReleaseData)
{
UnloadSoundEffect(iter->first);
}
}
} }
if (bReleaseData)
{
for (iter = m_soundEffects.begin(); iter != m_soundEffects.end();)
{
if (iter->first != m_backgroundID){
m_soundEffects.erase(iter++);
}
else
{
iter++;
}
}
}
} }
bool Audio::IsSoundEffectStarted(unsigned int sound) bool Audio::IsSoundEffectStarted(unsigned int sound)
@ -464,39 +467,66 @@ bool Audio::IsSoundEffectStarted(unsigned int sound)
return m_soundEffects[sound].m_soundEffectStarted; return m_soundEffects[sound].m_soundEffectStarted;
} }
std::wstring CCUtf8ToUnicode(const char * pszUtf8Str)
{
std::wstring ret;
do
{
if (! pszUtf8Str) break;
size_t len = strlen(pszUtf8Str);
if (len <= 0) break;
++len;
wchar_t * pwszStr = new wchar_t[len];
if (! pwszStr) break;
pwszStr[len - 1] = 0;
MultiByteToWideChar(CP_UTF8, 0, pszUtf8Str, len, pwszStr, len);
ret = pwszStr;
if(pwszStr) {
delete[] (pwszStr);
(pwszStr) = 0;
}
} while (0);
return ret;
}
std::string CCUnicodeToUtf8(const wchar_t* pwszStr)
{
std::string ret;
do
{
if(! pwszStr) break;
size_t len = wcslen(pwszStr);
if (len <= 0) break;
char * pszUtf8Str = new char[len*3 + 1];
WideCharToMultiByte(CP_UTF8, 0, pwszStr, len+1, pszUtf8Str, len*3 + 1, 0, 0);
ret = pszUtf8Str;
if(pszUtf8Str) {
delete[] (pszUtf8Str);
(pszUtf8Str) = 0;
}
}while(0);
return ret;
}
void Audio::PreloadSoundEffect(const char* pszFilePath, bool isMusic) void Audio::PreloadSoundEffect(const char* pszFilePath, bool isMusic)
{ {
if (m_engineExperiencedCriticalError) { if (m_engineExperiencedCriticalError) {
return; return;
} }
int sound = Hash(pszFilePath); int sound = Hash(pszFilePath);
if (m_soundEffects.end() != m_soundEffects.find(sound))
{
return;
}
MediaStreamer mediaStreamer; MediaStreamer mediaStreamer;
mediaStreamer.Initialize(CCUtf8ToUnicode(pszFilePath, -1).c_str()); mediaStreamer.Initialize(CCUtf8ToUnicode(pszFilePath).c_str());
m_soundEffects[sound].m_soundID = sound; m_soundEffects[sound].m_soundID = sound;
uint32 bufferLength = mediaStreamer.GetMaxStreamLengthInBytes(); uint32 bufferLength = mediaStreamer.GetMaxStreamLengthInBytes();
if (m_soundEffects.find(sound) != m_soundEffects.end())
{
if (m_soundEffects[sound].m_soundEffectBufferData)
{
delete[] m_soundEffects[sound].m_soundEffectBufferData;
m_soundEffects[sound].m_soundEffectBufferData = NULL;
}
}
else
{
m_soundEffects[sound].m_soundEffectBufferData = NULL;
}
m_soundEffects[sound].m_soundEffectBufferData = new byte[bufferLength]; m_soundEffects[sound].m_soundEffectBufferData = new byte[bufferLength];
mediaStreamer.ReadAll(m_soundEffects[sound].m_soundEffectBufferData, bufferLength, &m_soundEffects[sound].m_soundEffectBufferLength); mediaStreamer.ReadAll(m_soundEffects[sound].m_soundEffectBufferData, bufferLength, &m_soundEffects[sound].m_soundEffectBufferLength);
@ -549,6 +579,8 @@ void Audio::UnloadSoundEffect(const char* pszFilePath)
int sound = Hash(pszFilePath); int sound = Hash(pszFilePath);
UnloadSoundEffect(sound); UnloadSoundEffect(sound);
RemoveFromList(sound);
} }
void Audio::UnloadSoundEffect(unsigned int sound) void Audio::UnloadSoundEffect(unsigned int sound)
@ -562,15 +594,18 @@ void Audio::UnloadSoundEffect(unsigned int sound)
m_soundEffects[sound].m_soundEffectSourceVoice->DestroyVoice(); m_soundEffects[sound].m_soundEffectSourceVoice->DestroyVoice();
if (m_soundEffects[sound].m_soundEffectBufferData) if(m_soundEffects[sound].m_soundEffectBufferData)
{ delete [] m_soundEffects[sound].m_soundEffectBufferData;
delete[] m_soundEffects[sound].m_soundEffectBufferData;
m_soundEffects[sound].m_soundEffectBufferData = NULL;
}
m_soundEffects[sound].m_soundEffectBufferData = nullptr;
m_soundEffects[sound].m_soundEffectSourceVoice = nullptr; m_soundEffects[sound].m_soundEffectSourceVoice = nullptr;
m_soundEffects[sound].m_soundEffectStarted = false;// m_soundEffects[sound].m_soundEffectStarted = false;
ZeroMemory(&m_soundEffects[sound].m_audioBuffer, sizeof(m_soundEffects[sound].m_audioBuffer)); ZeroMemory(&m_soundEffects[sound].m_audioBuffer, sizeof(m_soundEffects[sound].m_audioBuffer));
}
void Audio::RemoveFromList( unsigned int sound )
{
m_soundEffects.erase(sound); m_soundEffects.erase(sound);
} }

25
cocos/audio/winrt/Audio.h
View File

@ -5,14 +5,25 @@
//// ////
//// Copyright (c) Microsoft Corporation. All rights reserved //// Copyright (c) Microsoft Corporation. All rights reserved
// For licensing information relating to this distribution please see Third Party Notices file.
#pragma once #pragma once
#include "pch.h" #include <wrl.h>
#include <d3d11_1.h>
#include <agile.h>
#include <DirectXMath.h>
#include <memory>
#define XAUDIO2_HELPER_FUNCTIONS 1
#include <xaudio2.h>
#include <map> #include <map>
static const int STREAMING_BUFFER_SIZE = 65536; static const int STREAMING_BUFFER_SIZE = 65536;
static const int MAX_BUFFER_COUNT = 3; static const int MAX_BUFFER_COUNT = 3;
#define UNUSED_PARAM(unusedparam) (void)unusedparam
struct SoundEffectData struct SoundEffectData
{ {
unsigned int m_soundID; unsigned int m_soundID;
@ -85,10 +96,11 @@ private:
StreamingVoiceContext m_voiceContext; StreamingVoiceContext m_voiceContext;
typedef std::map<unsigned int, SoundEffectData> EffectList; typedef std::map<unsigned int, SoundEffectData> EffectList;
EffectList m_soundEffects; typedef std::pair<unsigned int, SoundEffectData> Effect;
EffectList m_soundEffects;
unsigned int m_backgroundID; unsigned int m_backgroundID;
std::string m_backgroundFile; std::string m_backgroundFile;
bool m_backgroundLoop; bool m_backgroundLoop;
float m_soundEffctVolume; float m_soundEffctVolume;
@ -144,9 +156,12 @@ public:
void PauseAllSoundEffects(); void PauseAllSoundEffects();
void ResumeAllSoundEffects(); void ResumeAllSoundEffects();
void StopAllSoundEffects(); void StopAllSoundEffects(bool bReleaseData);
void PreloadSoundEffect(const char* pszFilePath, bool isMusic = false); void PreloadSoundEffect(const char* pszFilePath, bool isMusic = false);
void UnloadSoundEffect(const char* pszFilePath); void UnloadSoundEffect(const char* pszFilePath);
void UnloadSoundEffect(unsigned int sound); void UnloadSoundEffect(unsigned int sound);
private:
void RemoveFromList(unsigned int sound);
}; };

314
cocos/audio/winrt/MediaStreamer.cpp
View File

@ -1,49 +1,126 @@
//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF /*
//// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO * cocos2d-x http://www.cocos2d-x.org
//// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A *
//// PARTICULAR PURPOSE. * Copyright (c) 2010-2011 - cocos2d-x community
//// *
//// Copyright (c) Microsoft Corporation. All rights reserved * Portions Copyright (c) Microsoft Open Technologies, Inc.
* All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and limitations under the License.
*/
#include "pch.h"
#include "MediaStreamer.h" #include "MediaStreamer.h"
using namespace Windows::ApplicationModel; #include <Mfidl.h>
#include <Mfreadwrite.h>
#include <Mfapi.h>
static inline void ThrowIfFailed(HRESULT hr) #include <wrl\wrappers\corewrappers.h>
#include <ppltasks.h>
using namespace Microsoft::WRL;
using namespace Windows::Storage;
using namespace Windows::Storage::FileProperties;
using namespace Windows::Storage::Streams;
using namespace Windows::Foundation;
using namespace Windows::ApplicationModel;
using namespace Concurrency;
#ifndef MAKEFOURCC
#define MAKEFOURCC(ch0, ch1, ch2, ch3) \
((uint32)(byte)(ch0) | ((uint32)(byte)(ch1) << 8) | \
((uint32)(byte)(ch2) << 16) | ((uint32)(byte)(ch3) << 24 ))
#endif /* defined(MAKEFOURCC) */
inline void ThrowIfFailed(HRESULT hr)
{ {
if (FAILED(hr)) if (FAILED(hr))
{ {
// Set a breakpoint on this line to catch DirectX API errors // Set a breakpoint on this line to catch DX API errors.
throw Platform::Exception::CreateException(hr); throw Platform::Exception::CreateException(hr);
} }
} }
MediaStreamer::MediaStreamer() :
MediaStreamer::MediaStreamer() m_offset(0)
{ {
m_reader = nullptr;
m_audioType = nullptr;
ZeroMemory(&m_waveFormat, sizeof(m_waveFormat)); ZeroMemory(&m_waveFormat, sizeof(m_waveFormat));
m_location = Package::Current->InstalledLocation;
m_installedLocation = Package::Current->InstalledLocation; m_locationPath = Platform::String::Concat(m_location->Path, "\\Assets\\Resources\\");
m_installedLocationPath = Platform::String::Concat(m_installedLocation->Path, "\\Assets\\Resources\\");
} }
MediaStreamer::~MediaStreamer() MediaStreamer::~MediaStreamer()
{ {
} }
Platform::Array<byte>^ MediaStreamer::ReadData(
_In_ Platform::String^ filename
)
{
CREATEFILE2_EXTENDED_PARAMETERS extendedParams = {0};
extendedParams.dwSize = sizeof(CREATEFILE2_EXTENDED_PARAMETERS);
extendedParams.dwFileAttributes = FILE_ATTRIBUTE_NORMAL;
extendedParams.dwFileFlags = FILE_FLAG_SEQUENTIAL_SCAN;
extendedParams.dwSecurityQosFlags = SECURITY_ANONYMOUS;
extendedParams.lpSecurityAttributes = nullptr;
extendedParams.hTemplateFile = nullptr;
Wrappers::FileHandle file(
CreateFile2(
filename->Data(),
GENERIC_READ,
FILE_SHARE_READ,
OPEN_EXISTING,
&extendedParams
)
);
if (file.Get()==INVALID_HANDLE_VALUE)
{
throw ref new Platform::FailureException();
}
FILE_STANDARD_INFO fileInfo = {0};
if (!GetFileInformationByHandleEx(
file.Get(),
FileStandardInfo,
&fileInfo,
sizeof(fileInfo)
))
{
throw ref new Platform::FailureException();
}
if (fileInfo.EndOfFile.HighPart != 0)
{
throw ref new Platform::OutOfMemoryException();
}
Platform::Array<byte>^ fileData = ref new Platform::Array<byte>(fileInfo.EndOfFile.LowPart);
if (!ReadFile(
file.Get(),
fileData->Data,
fileData->Length,
nullptr,
nullptr
) )
{
throw ref new Platform::FailureException();
}
return fileData;
}
void MediaStreamer::Initialize(__in const WCHAR* url) void MediaStreamer::Initialize(__in const WCHAR* url)
{ {
Microsoft::WRL::ComPtr<IMFMediaType> outputMediaType;
Microsoft::WRL::ComPtr<IMFMediaType> mediaType;
ThrowIfFailed(
MFStartup(MF_VERSION)
);
WCHAR filePath[MAX_PATH] = {0}; WCHAR filePath[MAX_PATH] = {0};
if ((wcslen(url) > 1 && url[1] == ':')) if ((wcslen(url) > 1 && url[1] == ':'))
{ {
// path start with "x:", is absolute path // path start with "x:", is absolute path
@ -53,163 +130,92 @@ void MediaStreamer::Initialize(__in const WCHAR* url)
&& (L'/' == url[0] || L'\\' == url[0])) && (L'/' == url[0] || L'\\' == url[0]))
{ {
// path start with '/' or '\', is absolute path without driver name // path start with '/' or '\', is absolute path without driver name
wcscat_s(filePath, m_installedLocationPath->Data()); wcscat_s(filePath, m_locationPath->Data());
// remove '/' or '\\' // remove '/' or '\\'
wcscat_s(filePath, (const WCHAR*)url[1]); wcscat_s(filePath, (const WCHAR*)url[1]);
}else }else
{ {
wcscat_s(filePath, m_installedLocationPath->Data()); wcscat_s(filePath, m_locationPath->Data());
wcscat_s(filePath, url); wcscat_s(filePath, url);
} }
ThrowIfFailed(
MFCreateSourceReaderFromURL(filePath, nullptr, &m_reader)
);
// Set the decoded output format as PCM Platform::Array<byte>^ data = ReadData(ref new Platform::String(filePath));
// XAudio2 on Windows can process PCM and ADPCM-encoded buffers. UINT32 length = data->Length;
// When using MF, this sample always decodes into PCM. const byte * dataPtr = data->Data;
UINT32 offset = 0;
ThrowIfFailed( DWORD riffDataSize = 0;
MFCreateMediaType(&mediaType)
);
ThrowIfFailed( auto ReadChunk = [&length, &offset, &dataPtr, &riffDataSize](DWORD fourcc, DWORD& outChunkSize, DWORD& outChunkPos) -> HRESULT
mediaType->SetGUID(MF_MT_MAJOR_TYPE, MFMediaType_Audio) {
); while (true)
{
if (offset + sizeof(DWORD) * 2 >= length)
{
return E_FAIL;
}
ThrowIfFailed( // Read two DWORDs.
mediaType->SetGUID(MF_MT_SUBTYPE, MFAudioFormat_PCM) DWORD chunkType = *reinterpret_cast<const DWORD *>(&dataPtr[offset]);
); DWORD chunkSize = *reinterpret_cast<const DWORD *>(&dataPtr[offset + sizeof(DWORD)]);
offset += sizeof(DWORD) * 2;
ThrowIfFailed( if (chunkType == MAKEFOURCC('R', 'I', 'F', 'F'))
m_reader->SetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, mediaType.Get()) {
); riffDataSize = chunkSize;
chunkSize = sizeof(DWORD);
outChunkSize = sizeof(DWORD);
outChunkPos = offset;
}
else
{
outChunkSize = chunkSize;
outChunkPos = offset;
}
// Get the complete WAVEFORMAT from the Media Type offset += chunkSize;
ThrowIfFailed(
m_reader->GetCurrentMediaType(MF_SOURCE_READER_FIRST_AUDIO_STREAM, &outputMediaType)
);
uint32 formatSize = 0; if (chunkType == fourcc)
WAVEFORMATEX* waveFormat; {
ThrowIfFailed( return S_OK;
MFCreateWaveFormatExFromMFMediaType(outputMediaType.Get(), &waveFormat, &formatSize) }
); }
CopyMemory(&m_waveFormat, waveFormat, sizeof(m_waveFormat)); };
CoTaskMemFree(waveFormat);
// Get the total length of the stream in bytes // Locate riff chunk, check the file type.
PROPVARIANT var; DWORD chunkSize = 0;
ThrowIfFailed( DWORD chunkPos = 0;
m_reader->GetPresentationAttribute(MF_SOURCE_READER_MEDIASOURCE, MF_PD_DURATION, &var)
);
LONGLONG duration = var.uhVal.QuadPart;
double durationInSeconds = (duration / static_cast<double>(10000000)); // duration is in 100ns units, convert to seconds
m_maxStreamLengthInBytes = static_cast<unsigned int>(durationInSeconds * m_waveFormat.nAvgBytesPerSec);
// Round up the buffer size to the nearest four bytes ThrowIfFailed(ReadChunk(MAKEFOURCC('R', 'I', 'F', 'F'), chunkSize, chunkPos));
m_maxStreamLengthInBytes = (m_maxStreamLengthInBytes + 3) / 4 * 4; if (*reinterpret_cast<const DWORD *>(&dataPtr[chunkPos]) != MAKEFOURCC('W', 'A', 'V', 'E')) ThrowIfFailed(E_FAIL);
}
bool MediaStreamer::GetNextBuffer(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength) // Locate 'fmt ' chunk, copy to WAVEFORMATEXTENSIBLE.
{ ThrowIfFailed(ReadChunk(MAKEFOURCC('f', 'm', 't', ' '), chunkSize, chunkPos));
Microsoft::WRL::ComPtr<IMFSample> sample; ThrowIfFailed((chunkSize <= sizeof(m_waveFormat)) ? S_OK : E_FAIL);
Microsoft::WRL::ComPtr<IMFMediaBuffer> mediaBuffer; CopyMemory(&m_waveFormat, &dataPtr[chunkPos], chunkSize);
BYTE *audioData = nullptr;
DWORD sampleBufferLength = 0;
DWORD flags = 0;
*bufferLength = 0; // Locate the 'data' chunk and copy its contents to a buffer.
ThrowIfFailed(ReadChunk(MAKEFOURCC('d', 'a', 't', 'a'), chunkSize, chunkPos));
m_data.resize(chunkSize);
CopyMemory(m_data.data(), &dataPtr[chunkPos], chunkSize);
if (m_reader == nullptr) m_offset = 0;
{
return false;
}
ThrowIfFailed(
m_reader->ReadSample(MF_SOURCE_READER_FIRST_AUDIO_STREAM, 0, nullptr, &flags, nullptr, &sample)
);
if (sample == nullptr)
{
if (flags & MF_SOURCE_READERF_ENDOFSTREAM)
{
return true;
}
else
{
return false;
}
}
ThrowIfFailed(
sample->ConvertToContiguousBuffer(&mediaBuffer)
);
ThrowIfFailed(
mediaBuffer->Lock(&audioData, nullptr, &sampleBufferLength)
);
// If buffer isn't large enough, dump sample
if (sampleBufferLength <= maxBufferSize)
{
CopyMemory(buffer, audioData, sampleBufferLength);
*bufferLength = sampleBufferLength;
}
else
{
#if defined(COCOS2D_DEBUG)
OutputDebugString(L"Sample buffer dumped");
#endif
}
if (flags & MF_SOURCE_READERF_ENDOFSTREAM)
{
return true;
}
else
{
return false;
}
} }
void MediaStreamer::ReadAll(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength) void MediaStreamer::ReadAll(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength)
{ {
uint32 valuesWritten = 0; UINT32 toCopy = m_data.size() - m_offset;
uint32 sampleBufferLength = 0; if (toCopy > maxBufferSize) toCopy = maxBufferSize;
if (m_reader == nullptr) CopyMemory(buffer, m_data.data(), toCopy);
{ *bufferLength = toCopy;
return;
}
*bufferLength = 0; m_offset += toCopy;
// If buffer isn't large enough, return if (m_offset > m_data.size()) m_offset = m_data.size();
if (maxBufferSize < m_maxStreamLengthInBytes)
{
return;
}
while (!GetNextBuffer(buffer + valuesWritten, maxBufferSize - valuesWritten, &sampleBufferLength))
{
valuesWritten += sampleBufferLength;
}
*bufferLength = valuesWritten + sampleBufferLength;
} }
void MediaStreamer::Restart() void MediaStreamer::Restart()
{ {
if (m_reader == nullptr) m_offset = 0;
{
return;
}
PROPVARIANT var = {0};
var.vt = VT_I8;
ThrowIfFailed(
m_reader->SetCurrentPosition(GUID_NULL, var)
);
} }

53
cocos/audio/winrt/MediaStreamer.h
View File

@ -1,28 +1,46 @@
//// THIS CODE AND INFORMATION IS PROVIDED "AS IS" WITHOUT WARRANTY OF /*
//// ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING BUT NOT LIMITED TO * cocos2d-x http://www.cocos2d-x.org
//// THE IMPLIED WARRANTIES OF MERCHANTABILITY AND/OR FITNESS FOR A *
//// PARTICULAR PURPOSE. * Copyright (c) 2010-2011 - cocos2d-x community
//// *
//// Copyright (c) Microsoft Corporation. All rights reserved * Portions Copyright (c) Microsoft Open Technologies, Inc.
* All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and limitations under the License.
*/
#pragma once #pragma once
#include "pch.h"
class MediaStreamer #include <wrl.h>
#include <xaudio2.h>
#include <vector>
ref class MediaStreamer
{ {
private: private:
WAVEFORMATEX m_waveFormat; WAVEFORMATEX m_waveFormat;
uint32 m_maxStreamLengthInBytes; uint32 m_maxStreamLengthInBytes;
Windows::Storage::StorageFolder^ m_installedLocation; std::vector<byte> m_data;
Platform::String^ m_installedLocationPath; UINT32 m_offset;
Platform::Array<byte>^ ReadData(
_In_ Platform::String^ filename
);
internal:
Windows::Storage::StorageFolder^ m_location;
Platform::String^ m_locationPath;
public: public:
Microsoft::WRL::ComPtr<IMFSourceReader> m_reader; virtual ~MediaStreamer();
Microsoft::WRL::ComPtr<IMFMediaType> m_audioType;
public: internal:
MediaStreamer(); MediaStreamer();
~MediaStreamer();
WAVEFORMATEX& GetOutputWaveFormatEx() WAVEFORMATEX& GetOutputWaveFormatEx()
{ {
@ -31,11 +49,10 @@ public:
UINT32 GetMaxStreamLengthInBytes() UINT32 GetMaxStreamLengthInBytes()
{ {
return m_maxStreamLengthInBytes; return m_data.size();
} }
void Initialize(_In_ const WCHAR* url); void Initialize(_In_ const WCHAR* url);
bool GetNextBuffer(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength);
void ReadAll(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength); void ReadAll(uint8* buffer, uint32 maxBufferSize, uint32* bufferLength);
void Restart(); void Restart();
}; };

88
cocos/audio/winrt/SimpleAudioEngine.cpp
View File

@ -1,52 +1,51 @@
/**************************************************************************** /*
Copyright (c) 2010-2013 cocos2d-x.org * cocos2d-x http://www.cocos2d-x.org
Copyright (c) Microsoft Open Technologies, Inc. *
* Copyright (c) 2010-2011 - cocos2d-x community
*
* Portions Copyright (c) Microsoft Open Technologies, Inc.
* All Rights Reserved
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an
* "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and limitations under the License.
*/
http://www.cocos2d-x.org
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
****************************************************************************/
#include "SimpleAudioEngine.h" #include "SimpleAudioEngine.h"
#include "Audio.h" #include "Audio.h"
#include <map> #include <map>
//#include "CCCommon.h" //#include "CCCommon.h"
using namespace std; using namespace std;
namespace CocosDenshion { namespace CocosDenshion {
Audio* s_audioController = NULL; Audio* s_audioController = NULL;
// a flag that if the s_audioController should be re-initialiezed bool s_initialized = false;
// see also in SimpleAudioEngine::end() in this file
bool s_bAudioControllerNeedReInitialize = true; SimpleAudioEngine* SimpleAudioEngine::getInstance()
{
static SimpleAudioEngine s_SharedEngine;
return &s_SharedEngine;
}
static Audio* sharedAudioController() static Audio* sharedAudioController()
{ {
if ((! s_audioController) || s_bAudioControllerNeedReInitialize) if (! s_audioController || !s_initialized)
{ {
s_audioController = new Audio; if(s_audioController == NULL)
{
s_audioController = new Audio;
}
s_audioController->Initialize(); s_audioController->Initialize();
s_audioController->CreateResources(); s_audioController->CreateResources();
s_bAudioControllerNeedReInitialize = false; s_initialized = true;
} }
return s_audioController; return s_audioController;
@ -60,29 +59,16 @@ SimpleAudioEngine::~SimpleAudioEngine()
{ {
} }
SimpleAudioEngine* SimpleAudioEngine::sharedEngine()
{
static SimpleAudioEngine s_SharedEngine;
return &s_SharedEngine;
}
void SimpleAudioEngine::end() void SimpleAudioEngine::end()
{ {
sharedAudioController()->StopBackgroundMusic(true); sharedAudioController()->StopBackgroundMusic(true);
sharedAudioController()->StopAllSoundEffects(); sharedAudioController()->StopAllSoundEffects(true);
sharedAudioController()->ReleaseResources(); sharedAudioController()->ReleaseResources();
//set here to tell the s_bAudioControllerNeedReInitialize should be re-initialized s_initialized = false;
s_bAudioControllerNeedReInitialize = true;
} }
#if 0
void SimpleAudioEngine::render()
{
sharedAudioController()->Render();
}
#endif
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
// BackgroundMusic // BackgroundMusic
@ -132,11 +118,11 @@ bool SimpleAudioEngine::isBackgroundMusicPlaying()
// effect function // effect function
////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////
unsigned int SimpleAudioEngine::playEffect(const char* pszFilePath, bool bLoop) unsigned int SimpleAudioEngine::playEffect(const char* pszFilePath, bool bLoop,float pitch, float pan, float gain)
{ {
unsigned int sound; unsigned int sound;
sharedAudioController()->PlaySoundEffect(pszFilePath, bLoop, sound); sharedAudioController()->PlaySoundEffect(pszFilePath, bLoop, sound);
// TODO: need to support playEffect parameters
return sound; return sound;
} }
@ -172,12 +158,12 @@ void SimpleAudioEngine::resumeAllEffects()
void SimpleAudioEngine::stopAllEffects() void SimpleAudioEngine::stopAllEffects()
{ {
sharedAudioController()->StopAllSoundEffects(); sharedAudioController()->StopAllSoundEffects(false);
} }
void SimpleAudioEngine::preloadBackgroundMusic(const char* pszFilePath) void SimpleAudioEngine::preloadBackgroundMusic(const char* pszFilePath)
{ {
UNUSED_PARAM(pszFilePath);
} }
void SimpleAudioEngine::unloadEffect(const char* pszFilePath) void SimpleAudioEngine::unloadEffect(const char* pszFilePath)