void CTestPage::StopPlayback( void )
/////////////////////////////////////////////////////////////////////////////
{
PHALWAVEDEVICE pHD;
if( m_nPlayMode != MODE_RUN )
return;
DPF(("Stopping Play Device %d\n", m_nPlayDevice ));
pHD = m_pHalAdapter->GetWaveOutDevice( m_nPlayDevice );
//DPF(("Stop\n"));
if( pHD->Stop() )
{
DPF(("Stop Failed!\n"));
}
m_nPlayMode = MODE_STOP;
m_WavePlayFile.Close();
free( m_pPlayBuffer );
ReleasePhysicalPages( m_pPlayBuffer, m_ulPlayBufferSize, m_ulPlayBufferPages );
// change the button to play
SetDlgItemText( IDC_PLAY, "Play" );
SetDlgItemText( IDC_PLAY_SAMPLECOUNT, "" );
if( m_bRepeat )
StartPlayback();
}
void SpotifyServer::StartPlaybackLater(const QString& uri, quint16 port) {
QTimer* timer = new QTimer(this);
connect(timer, SIGNAL(timeout()), timer, SLOT(deleteLater()));
timer->start(100); // lol
NewClosure(timer, SIGNAL(timeout()), this,
SLOT(StartPlayback(QString, quint16)), uri, port);
}
void CTestPage::OnPlay()
/////////////////////////////////////////////////////////////////////////////
{
static char BASED_CODE szFilter[] = "Wave Files(*.wav)|*.wav|All Files(*.*)|*.*||";
char szInitialDir[ _MAX_PATH ];
char szFileName[ _MAX_PATH ];
UpdateData( TRUE ); // Get data from the controls
if( !m_pHalAdapter->IsOpen() )
{
MessageBox( "Must Open Adapter First!" );
return;
}
if( m_nPlayMode == MODE_STOP )
{
// Pop up the file dialog box
CFileDialog dlg( TRUE, NULL, NULL, OFN_HIDEREADONLY | OFN_PATHMUSTEXIST, szFilter, this );
if( m_szFileName[0] )
{
char szDrive[ _MAX_DRIVE ];
char szDir[ _MAX_DIR ];
char szBaseName[ _MAX_FNAME ];
char szExt[ _MAX_EXT ];
_splitpath( m_szFileName, szDrive, szDir, szBaseName, szExt );
sprintf( szInitialDir, "%s%s", szDrive, szDir );
sprintf( szFileName, "%s%s", szBaseName, szExt );
dlg.m_ofn.lpstrInitialDir = szInitialDir;
dlg.m_ofn.lpstrFile = szFileName;
}
else
dlg.m_ofn.lpstrInitialDir = "D:\\Audio";
if( dlg.DoModal() == IDCANCEL )
return;
CString PathName;
PathName = dlg.GetPathName();
strcpy( m_szFileName, PathName.GetBuffer( _MAX_PATH - 1 ) );
PathName.ReleaseBuffer();
StartPlayback();
}
else
{
m_bRepeat = FALSE;
UpdateData(FALSE); // Send data to the controls
StopPlayback();
}
}
UINT8 PlayMusic(VGM_FILE* vgmFile)
{
VGM_PBK* vgmPb = &vgmPbMusic;
if (! vgmPb->vgmEnd)
StopPlayback(vgmPb);
vgmPb->file = vgmFile;
StartPlayback(vgmPb);
return 0x00;
}
// Start playback from paused or stopped.
void Player_::play( ev::Play const& ev)
{
/* if (m_state != Paused && m_state != Stopped)
{
THROW_IF_ERR(MF_E_INVALIDREQUEST);
}*/
if (!m_pSession || !m_pSource)
{
THROW_IF_ERR(E_UNEXPECTED);
}
StartPlayback();
OnStart()(static_cast<this_type&>(*this));
}
void
MythPianoService::NextSong()
{
StopPlayback();
if (m_Playlist != NULL) {
m_CurrentSong = m_CurrentSong->next;
}
if (m_CurrentSong == NULL) {
GetPlaylist();
}
StartPlayback();
}
HRESULT CPlayer::OnTopologyStatus(IMFMediaEvent *pEvent)
{
UINT32 status;
HRESULT hr = pEvent->GetUINT32(MF_EVENT_TOPOLOGY_STATUS, &status);
if (SUCCEEDED(hr) && (status == MF_TOPOSTATUS_READY))
{
SafeRelease(&m_pVideoDisplay);
hr = StartPlayback();
hr = Pause();
}
return hr;
}
/** Pauses playback */
void FImfVideoPlayer::PausePlayback( bool Pause )
{
/* TODO: */
/* Not every media source can pause. If a media source can pause, the IMFMediaSource::GetCharacteristics method returns the MFMEDIASOURCE_CAN_PAUSE flag. */
HRESULT HResult = S_OK;
if( Pause )
{
HResult = MediaSession->Pause( );
check( SUCCEEDED( HResult ) );
}
else
{
StartPlayback( );
}
}
void
MythPianoService::heartbeat(void)
{
if (m_Player.mode >= audioPlayer::PLAYER_FINISHED_PLAYBACK ||
m_Player.mode == audioPlayer::PLAYER_FREED) {
if (m_Playlist != NULL) {
m_CurrentSong = m_CurrentSong->next;
}
if (m_CurrentSong == NULL) {
GetPlaylist();
}
StartPlayback();
}
}
HRESULT CPlayer::Play()
{
TRACE((L"CPlayer::Play\n"));
if (m_state != Paused && m_state != Stopped)
{
return MF_E_INVALIDREQUEST;
}
if (m_pSession == NULL || m_pSource == NULL)
{
return E_UNEXPECTED;
}
HRESULT hr = StartPlayback();
return hr;
}
UINT8 PlaySFX(VGM_FILE* vgmFile, UINT8 sfxChnID)
{
VGM_PBK* vgmPb;
if (sfxChnID >= SFX_CHN_COUNT)
return 0xFF;
vgmPb = &vgmPbSFX[sfxChnID];
if (! vgmPb->vgmEnd)
StopPlayback(vgmPb);
vgmPb->file = vgmFile;
StartPlayback(vgmPb);
return 0x00;
}
HRESULT CPlayer::OnTopologyReady(IMFMediaEvent *pEvent)
{
TRACE((L"CPlayer::OnTopologyReady\n"));
// Ask for the IMFVideoDisplayControl interface.
// This interface is implemented by the EVR and is
// exposed by the media session as a service.
// Note: This call is expected to fail if the source
// does not have video.
MFGetService(
m_pSession,
MR_VIDEO_RENDER_SERVICE,
__uuidof(IMFVideoDisplayControl),
(void**)&m_pVideoDisplay
);
HRESULT hr = StartPlayback();
return S_OK;
}
void MIDIStreamer::Play(bool looping, int subsong)
{
DWORD tid;
EMidiDevice devtype;
m_Status = STATE_Stopped;
m_Looping = looping;
EndQueued = 0;
VolumeChanged = false;
Restarting = true;
InitialPlayback = true;
assert(MIDI == NULL);
devtype = SelectMIDIDevice(DeviceType);
if (DumpFilename.IsNotEmpty())
{
if (devtype == MDEV_GUS)
{
MIDI = new TimidityWaveWriterMIDIDevice(DumpFilename, 0);
}
}
else
{
MIDI = CreateMIDIDevice(devtype);
}
#ifndef _WIN32
assert(MIDI == NULL || MIDI->NeedThreadedCallback() == false);
#endif
if (MIDI == NULL || 0 != MIDI->Open(Callback, this))
{
Printf(PRINT_BOLD, "Could not open MIDI out device\n");
return;
}
SetMIDISubsong(subsong);
CheckCaps(MIDI->GetTechnology());
if (MIDI->Preprocess(this, looping))
{
StartPlayback();
if (MIDI == NULL)
{ // The MIDI file had no content and has been automatically closed.
return;
}
}
if (0 != MIDI->Resume())
{
Printf ("Starting MIDI playback failed\n");
Stop();
}
else
{
#ifdef _WIN32
if (MIDI->NeedThreadedCallback())
{
PlayerThread = CreateThread(NULL, 0, PlayerProc, this, 0, &tid);
if (PlayerThread == NULL)
{
Printf ("Creating MIDI thread failed\n");
Stop();
}
else
{
m_Status = STATE_Playing;
}
}
else
#endif
{
m_Status = STATE_Playing;
}
}
}
void VDAudioOutputDirectSoundW32::ThreadRun() {
if (!InitDirectSound()) {
ShutdownDirectSound();
mMutex.Lock();
mbThreadInited = true;
mbThreadInitSucceeded = false;
mMutex.Unlock();
mUpdateEvent.signal();
return;
}
ThreadState threadState = kThreadStateStop;
uint32 lastInitCount = 0;
bool underflow = false;
bool playing = false;
uint32 dsStreamWritePosition = 0;
if (!InitPlayback()) {
ShutdownDirectSound();
mMutex.Lock();
mbThreadInited = true;
mbThreadInitSucceeded = false;
mMutex.Unlock();
mUpdateEvent.signal();
return;
}
mMutex.Lock();
mbThreadInited = true;
mbThreadInitSucceeded = true;
mUpdateEvent.signal();
mMutex.Unlock();
for(;;) {
if (playing)
mUpdateEvent.tryWait(10);
else
mUpdateEvent.wait();
mMutex.Lock();
threadState = (ThreadState)mThreadState;
mMutex.Unlock();
if (threadState == kThreadStatePlay) {
if (!underflow) {
StartPlayback();
playing = true;
}
} else {
StopPlayback();
playing = false;
}
if (threadState == kThreadStateExit)
break;
if (!playing)
continue;
Cursors cursors;
if (!ReadCursors(cursors))
continue;
uint32 level;
mMutex.Lock();
level = mBufferLevel;
// Compute current buffering level.
sint32 bufferedLevel = mDSWriteCursor - cursors.mPlayCursor;
if (bufferedLevel > (sint32)mDSBufferSizeHalf)
bufferedLevel -= mDSBufferSize;
else if (bufferedLevel < -(sint32)mDSBufferSizeHalf)
bufferedLevel += mDSBufferSize;
if (bufferedLevel < 0) {
bufferedLevel = 0;
mDSWriteCursor = cursors.mWriteCursor;
}
// Compute the stream play position. This should never go backward. If it
// has, we have underflowed.
uint32 newDSStreamPlayPos = dsStreamWritePosition - bufferedLevel;
if (newDSStreamPlayPos < mDSStreamPlayPosition) {
mDSStreamPlayPosition = dsStreamWritePosition;
bufferedLevel = 0;
}
mDSBufferedBytes = bufferedLevel;
mMutex.Unlock();
if (!level) {
if (!underflow && playing) {
// Check for underflow.
if (!bufferedLevel) {
StopPlayback();
playing = false;
}
}
continue;
}
// compute how many bytes to copy
uint32 toCopy = level;
if (toCopy + bufferedLevel > mDSBufferSizeHalf)
toCopy = mDSBufferSizeHalf - bufferedLevel;
if (!toCopy)
continue;
// update local write position
dsStreamWritePosition += toCopy;
// lock and copy into DirectSound buffer
const uint8 *src = mBuffer.data();
uint32 consumed = 0;
while(toCopy > 0) {
const uint32 tc2 = std::min<uint32>(toCopy, mBufferSize - mBufferReadOffset);
const uint32 tc3 = std::min<uint32>(tc2, mDSBufferSize - mDSWriteCursor);
WriteAudio(mDSWriteCursor, src + mBufferReadOffset, tc3);
mBufferReadOffset += tc3;
if (mBufferReadOffset >= mBufferSize)
mBufferReadOffset = 0;
mDSWriteCursor += tc3;
if (mDSWriteCursor >= mDSBufferSize)
mDSWriteCursor = 0;
toCopy -= tc3;
consumed += tc3;
}
mMutex.Lock();
mBufferLevel -= consumed;
mMutex.Unlock();
// restart playback if we were in underflow state
if (underflow && !playing) {
underflow = false;
playing = true;
StartPlayback();
}
mResponseEvent.signal();
}
ShutdownPlayback();
ShutdownDirectSound();
}
/** Asyncronous callback */
HRESULT FImfVideoPlayer::Invoke( IMFAsyncResult* AsyncResult )
{
IMFMediaEvent* Event = NULL;
HRESULT HResult = MediaSession->EndGetEvent( AsyncResult, &Event );
if( FAILED( HResult ) )
{
Event->Release( );
return S_OK;
}
MediaEventType EventType = MEUnknown;
HResult = Event->GetType( &EventType );
//Moving lower because it is referenced below to GetStatus if there was a problem: Event->Release( );
if( FAILED( HResult ) )
{
Event->Release( );
return S_OK;
}
/* Closed */
if( EventType == MESessionClosed )
{
MovieIsFinished.Set( 1 );
CloseIsPosted.Set( 1 );
}
else
{
HResult = MediaSession->BeginGetEvent( this, NULL );
if( FAILED( HResult ) )
{
Event->Release( );
return S_OK;
}
if( MovieIsRunning( ) )
{
/* End of clip */
if( EventType == MEEndOfPresentation )
{
if( Looping )
StartPlayback( );
else
MovieIsFinished.Set( 1 );
}
/* Unknown error, dont continue */
else if( EventType == MEError )
{
HRESULT HReturnCode = S_OK;
Event->GetStatus( &HReturnCode );
/* Log error HResult */
UE_LOG( LogImfVideoPlayer, Log, TEXT( "ImfVideoPlayer error recieved: %i" ), HReturnCode );
MovieIsFinished.Set( 1 );
CloseIsPosted.Set( 1 );
}
}
/* DEBUG: Displays all event ID's in log */
//UE_LOG( LogImfVideoPlayer, Log, TEXT( "ImfVideoPlayer event id: %i" ), EventType );
}
Event->Release( );
return S_OK;
}
