Exemple #1
0
double VDAudioOutputWaveOutW32::GetPositionTime() {
	MMTIME mmtime;

	if (mCurState != kStatePlaying) return -1;

	mmtime.wType = TIME_MS;

	MMRESULT res;

	vdsynchronized(mcsWaveDevice) {
		res = waveOutGetPosition(mhWaveOut, &mmtime, sizeof mmtime);
	}

	if (MMSYSERR_NOERROR != res)
		return -1;

	switch(mmtime.wType) {
	case TIME_BYTES:
		return (double)mmtime.u.cb / (double)mAvgBytesPerSec;
	case TIME_MS:
		return (double)mmtime.u.ms / 1000.0;
	case TIME_SAMPLES:
		return (double)mmtime.u.sample / (double)mSamplesPerSec;
	}

	return -1;
}
Exemple #2
0
_int64 pcm_get_buffering_time()
{
        if (!wout) return 1;

        MMTIME mmt;
        mmt.wType = TIME_BYTES;
        waveOutGetPosition(wout, &mmt, sizeof(mmt));
        return (_int64)(total_bytes - mmt.u.cb) * 1000000 / cb_per_sec;
}
ULONG GetPos(MADDriverRec *WinMADDriver)
{
	MMTIME mmt;
	mmt.wType = TIME_BYTES;
	
	waveOutGetPosition(WinMADDriver->hWaveOut, &mmt,sizeof(MMTIME));
	
	return(mmt.u.cb & 0xfffffff0);		// A cause du 16 bits??
}
Exemple #4
0
long msys_soundGetPosInSamples( void )
{
    MMTIME  mmt;

    mmt.wType = TIME_SAMPLES;
    waveOutGetPosition( h, &mmt, sizeof(MMTIME) );

	return mmt.u.cb;
}
long getPosition(Audio *audio)
{
   MMTIME mmtime;
   MMRESULT rc;
    
   mmtime.wType = TIME_MS;
   if (audio->whdr != NULL) {
      rc = waveOutGetPosition(audio->hwo, &mmtime, sizeof(mmtime));
      return mmtime.u.ms;
   } else {
      return 0;
   }
}
uint32_t AudioPlayback::QueryStreamPosition()
{
    uint32_t pos = 0;
    if (hWaveOut && _sound)
    {
        MMTIME mmTime = {};
        mmTime.wType = TIME_BYTES;
        if (MMSYSERR_NOERROR == waveOutGetPosition(hWaveOut, &mmTime, sizeof(mmTime)))
        {
            pos = mmTime.u.cb;
        }
    }
    return pos;
}
DWORD AudioPlayback::QueryPosition(DWORD scope)
{
    DWORD pos = 0;
    if (hWaveOut && _sound)
    {
        MMTIME mmTime = {};
        mmTime.wType = TIME_BYTES;
        if (MMSYSERR_NOERROR == waveOutGetPosition(hWaveOut, &mmTime, sizeof(mmTime)))
        {
            pos = (scope * mmTime.u.cb / _sound->DigitalSamplePCM.size());
        }
    }
    return pos;
}
Exemple #8
0
static void DrawWave(struct client *pc, HDC hdc, WPARAM wParam){
#if 0
	int k;
	MMTIME mmtime;
	RECT rr = {320, 320, 320 + 32, 320 + 32};
	mmtime.wType = TIME_SAMPLES;
	waveOutGetPosition(pc->hwo, &mmtime, sizeof mmtime);
	SetBkColor(hdc, !mmtime.u.sample ? RGB(255,0,0) : RGB(0,255,0));
	ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rr, NULL, 0, NULL);
	rr.left += 32;
	rr.right += 32;
	for(k = 0; k < 2; k++){
		SetBkColor(hdc, (~(whs[k].dwFlags | ~(/*WHDR_PREPARED |*/ WHDR_DONE))) | (whs[k].dwFlags & WHDR_INQUEUE) ? RGB(255,0,0) : RGB(0,255,0));
		rr.left += k * 32;
		rr.right += k * 32;
		ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rr, NULL, 0, NULL);
	}
#endif
#if 1
	int i, t;
	{
		MMTIME mmt;
		mmt.wType = TIME_SAMPLES;
		waveOutGetPosition(pc->hwo, &mmt, sizeof mmt);
		t = mmt.u.sample % numof(soundbuf[0]);
	}
	SetBkColor(hdc, RGB(127, 127, 127));
	RECT rr = {320, 320, 320 + 256, 320 + 256};
	ExtTextOut(hdc, 0, 0, ETO_OPAQUE, &rr, NULL, 0, NULL);
	for(i = 0; i < 256; i++){
		if(i == t * numof(soundbuf[0]) / 256)
			SelectObject(hdc, GetStockObject(WHITE_PEN));
		MoveToEx(hdc, 320 + i, 320 + 128, NULL);
		LineTo(hdc, 320 + i, 320 + ((BYTE*)((WAVEHDR*)wParam)->lpData)[i * numof(soundbuf[0]) / 256]);
	}
#endif
}
Exemple #9
0
float WaveLib_PlaybackTime(HWAVEOUT hWaveOut)
{
	//PWAVELIB pWaveLib = NULL;
	FLOAT time;
	//int total_playtime = WaveFileHeader.

	playbacktime.wType = TIME_MS;				 //Make sure time is in the smpte section of the mmtime struct
	playbacktime_size = sizeof(playbacktime);
	waveOutGetPosition(hWaveOut, &playbacktime, playbacktime_size);

	time = (float)playbacktime.u.ms / 100000;
	//printf("Elapsed Time: %0.4f",time);
	return time;
	//printf("Elapsed Time: %d:%",playbacktime.u.smpte.min, playbacktime.u.smpte.sec);
}
Exemple #10
0
DWORD COutput::GetCurrent()
{
	CAutoLock lock(&m_csecDevice);
	if (!m_hwo)
		return 0;

	if (m_fDoubleBuf)
		return m_dwTotalSamples;

	MMTIME time;
	memset(&time, 0, sizeof(MMTIME));
	time.wType = TIME_SAMPLES;
	waveOutGetPosition(m_hwo, &time, sizeof(MMTIME));
	return time.u.sample;
}
Exemple #11
0
int
cubeb_stream_get_position(cubeb_stream * stm, uint64_t * position)
{
  MMRESULT r;
  MMTIME time;

  time.wType = TIME_SAMPLES;
  r = waveOutGetPosition(stm->waveout, &time, sizeof(time));
  assert(r == MMSYSERR_NOERROR);
  assert(time.wType == TIME_SAMPLES);

  *position = time.u.sample;

  return CUBEB_OK;
}
/** sync/timing */
int sa_stream_get_position(sa_stream_t *s, sa_position_t position, int64_t *pos) {
	int status;
  MMTIME  mm;

  ERROR_IF_NO_INIT(s);

  if (position != SA_POSITION_WRITE_HARDWARE) {
    return SA_ERROR_NOT_SUPPORTED;
  }
  // request playback progress in bytes
  mm.wType = TIME_BYTES;		
	status = waveOutGetPosition(s->hWaveOut, &mm, sizeof(MMTIME));
  HANDLE_WAVE_ERROR(status, "reading audio buffer position");
  *pos = (int64_t)mm.u.cb;

	return SA_SUCCESS;
}
Exemple #13
0
static int
winmm_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
{
  MMRESULT r;
  MMTIME time;
  uint64_t written;

  EnterCriticalSection(&stm->lock);
  time.wType = TIME_SAMPLES;
  r = waveOutGetPosition(stm->waveout, &time, sizeof(time));
  written = stm->written;
  LeaveCriticalSection(&stm->lock);

  *latency = written - time.u.sample;

  return CUBEB_OK;
}
Exemple #14
0
/*
	[DESCRIPTION]

	[PARAMETERS]
 
	[RETURN_VALUE]

	[REMARKS]

	[SEE_ALSO]
*/
DWORD FSOUND_Software_DoubleBufferThread(LPDWORD lpdwParam)
{
	int totalblocks; 

	FSOUND_Software_ThreadFinished = FALSE;

	totalblocks = FSOUND_BufferSize / FSOUND_BlockSize; 

	while (!FSOUND_Software_Exit)
	{
		int		cursorpos,cursorblock,prevblock;
		MMTIME	mmt;

		mmt.wType = TIME_BYTES;
		waveOutGetPosition(FSOUND_WaveOutHandle, &mmt, sizeof(MMTIME));
		mmt.u.cb >>= 2;
		cursorpos = mmt.u.cb;

		cursorpos %= FSOUND_BufferSize;
		cursorblock = cursorpos / FSOUND_BlockSize;

		prevblock = cursorblock - 1;
		if (prevblock < 0)
			prevblock = totalblocks - 1;

		while (FSOUND_Software_FillBlock != cursorblock)
		{
			FSOUND_Software_UpdateMutex = TRUE;

			FSOUND_Software_Fill();
	
			FSOUND_Software_RealBlock++;
			if (FSOUND_Software_RealBlock >= totalblocks)
				FSOUND_Software_RealBlock = 0;

			FSOUND_Software_UpdateMutex = FALSE;
		}

		Sleep(5);
	};

	FSOUND_Software_ThreadFinished = TRUE;

	return 0;
}
Exemple #15
0
static pa_usec_t sink_get_latency(struct userdata *u) {
    uint32_t free_frags;
    MMTIME mmt;
    pa_assert(u);
    pa_assert(u->sink);

    memset(&mmt, 0, sizeof(mmt));
    mmt.wType = TIME_BYTES;
    if (waveOutGetPosition(u->hwo, &mmt, sizeof(mmt)) == MMSYSERR_NOERROR)
        return pa_bytes_to_usec(u->written_bytes - mmt.u.cb, &u->sink->sample_spec);
    else {
        EnterCriticalSection(&u->crit);
        free_frags = u->free_ofrags;
        LeaveCriticalSection(&u->crit);

        return pa_bytes_to_usec((u->fragments - free_frags) * u->fragment_size, &u->sink->sample_spec);
    }
}
Exemple #16
0
	UINT64 GetPos() {
		static const DWORD WRAP_BITS = 27;
		static const UINT64 WRAP_MASK = (1 << 27) - 1;
		static const int WRAP_THRESHOLD = 1 << (WRAP_BITS - 1);

		// Taking a snapshot to avoid possible thread interference
		UINT64 playPositionSnapshot = prevPlayPosition;
		DWORD wrapCount = DWORD(playPositionSnapshot >> WRAP_BITS);
		DWORD wrappedPosition = DWORD(playPositionSnapshot & WRAP_MASK);

		MMTIME mmTime;
		mmTime.wType = TIME_SAMPLES;

		if (waveOutGetPosition(hWaveOut, &mmTime, sizeof(MMTIME)) != MMSYSERR_NOERROR) {
			MessageBox(NULL, L"Failed to get current playback position", L"MT32", MB_OK | MB_ICONEXCLAMATION);
			return 10;
		}
		if (mmTime.wType != TIME_SAMPLES) {
			MessageBox(NULL, L"Failed to get # of samples played", L"MT32", MB_OK | MB_ICONEXCLAMATION);
			return 10;
		}
		mmTime.u.sample &= WRAP_MASK;

		// Deal with waveOutGetPosition() wraparound. For 16-bit stereo output, it equals 2^27,
		// presumably caused by the internal 32-bit counter of bits played.
		// The output of that nasty waveOutGetPosition() isn't monotonically increasing
		// even during 2^27 samples playback, so we have to ensure the difference is big enough...
		int delta = mmTime.u.sample - wrappedPosition;
		if (delta < -WRAP_THRESHOLD) {
#ifdef ENABLE_DEBUG_OUTPUT
			std::cout << "MT32: GetPos() wrap: " << delta << "\n";
#endif
			++wrapCount;
		} else if (delta < 0) {
			// This ensures the return is monotonically increased
#ifdef ENABLE_DEBUG_OUTPUT
			std::cout << "MT32: GetPos() went back by " << delta << " samples\n";
#endif
			return playPositionSnapshot;
		}
		prevPlayPosition = playPositionSnapshot = mmTime.u.sample + (wrapCount << WRAP_BITS);
		return playPositionSnapshot;
	}
int
cubeb_stream_get_position(cubeb_stream * stm, uint64_t * position)
{
  MMRESULT r;
  MMTIME time;

  EnterCriticalSection(&stm->lock);
  time.wType = TIME_SAMPLES;
  r = waveOutGetPosition(stm->waveout, &time, sizeof(time));
  LeaveCriticalSection(&stm->lock);

  if (r != MMSYSERR_NOERROR || time.wType != TIME_SAMPLES) {
    return CUBEB_ERROR;
  }

  *position = time.u.sample;

  return CUBEB_OK;
}
Exemple #18
0
BOOL COXSound::GetCurrentPosition(MMTIME* pMMTime) const
{
	if(!m_hWaveOut)
	{
		return FALSE;
	}

	if(!IsPlaying())
	{
		return FALSE;
	}

	ASSERT(pMMTime != NULL);

	// Return time in milliseconds
	pMMTime->wType=TIME_MS;

	MMRESULT hResult;
	hResult=waveOutGetPosition(m_hWaveOut,pMMTime,sizeof(MMTIME));

	return (hResult==MMSYSERR_NOERROR);
}
Exemple #19
0
static int
winmm_stream_get_latency(cubeb_stream * stm, uint32_t * latency)
{
  MMRESULT r;
  MMTIME time;
  uint64_t written;

  EnterCriticalSection(&stm->lock);
  time.wType = TIME_SAMPLES;
  r = waveOutGetPosition(stm->waveout, &time, sizeof(time));
  written = stm->written;
  LeaveCriticalSection(&stm->lock);

  if (r != MMSYSERR_NOERROR || time.wType != TIME_SAMPLES) {
    return CUBEB_ERROR;
  }

  XASSERT(written - time.u.sample <= UINT32_MAX);
  *latency = (uint32_t) (written - time.u.sample);

  return CUBEB_OK;
}
Exemple #20
0
CADENCII_MEDIA_HELPER_API(double, SoundGetPosition)() {
    if ( NULL == wave_out ) {
        return 0.0;
    }

    MMTIME mmt;
    mmt.wType = TIME_MS;
    EnterCriticalSection( &locker );
    waveOutGetPosition( wave_out, &mmt, sizeof( MMTIME ) );
    LeaveCriticalSection( &locker );
    float ms = 0.0f;
    switch ( mmt.wType ) {
        case TIME_MS:
            return mmt.u.ms * 0.001;
        case TIME_SAMPLES:
            return (double)mmt.u.sample / (double)wave_format.nSamplesPerSec;
        case TIME_BYTES:
            return (double)mmt.u.cb / (double)wave_format.nAvgBytesPerSec;
        default:
            return 0.0;
    }
    return 0.0;
}
Exemple #21
0
void SoundCardPMO::HandleTimeInfoEvent(PMOTimeInfoEvent *pEvent)
{
   MediaTimeInfoEvent *pmtpi;
   int32               hours, minutes, seconds;
   int                 iTotalTime = 0;
   MMTIME              sTime;

   if (m_iBaseTime == MAXINT32)
   {
       if (!pEvent)
          return;
          
       m_iBaseTime = (pEvent->GetFrameNumber() * m_samples_per_frame) / 
                      m_samples_per_second;

       sTime.wType = TIME_BYTES;
       if (waveOutGetPosition(m_hwo, &sTime, sizeof(sTime)) != MMSYSERR_NOERROR)
           return;
   
       m_iBaseTime -= (sTime.u.cb / (m_samples_per_second * m_iBytesPerSample));
	   m_iLastTime = 0;
   }

   if (m_samples_per_second <= 0)
      return;

   sTime.wType = TIME_BYTES;
   if (waveOutGetPosition(m_hwo, &sTime, sizeof(sTime)) != MMSYSERR_NOERROR)
       return;
   
   iTotalTime = (sTime.u.cb / (m_samples_per_second * m_iBytesPerSample)) +
                m_iBaseTime;

   // Time needs to be greater or equal to the last time for each pass,
   // otherwise we have a break in playback, in which case we need to
   // reset the base time. After a break in playback the waveOutGetPosition()
   // function will reset back to 0. 
   // Alternatively, if m_iBaseTime gets messed up (i.e. its more than 24 hours!)
   // force a reset as well.
   if (iTotalTime < m_iLastTime || (m_iBaseTime > 86400 && m_iBaseTime < MAXINT32))
   {
	   Debug_v("Reset: %d %d %d", iTotalTime, m_iLastTime, m_iBaseTime);
	   m_iBaseTime = MAXINT32;
	   return;
   }
      
   hours = iTotalTime / 3600;
   minutes = (iTotalTime - 
                (hours * 3600)) / 60;
   seconds = iTotalTime - 
                (hours * 3600) - 
                (minutes * 60);

   // If something became wonky, reset.
   if (minutes < 0 || minutes > 59 || 
	   seconds < 0 || seconds > 59 || 
	   hours < 0 || hours > 24)
   {
	  m_iBaseTime = MAXINT32;
      return;
   }

   pmtpi = new MediaTimeInfoEvent(hours, minutes, seconds, 0,
                                  (float)iTotalTime, 0);
   m_pTarget->AcceptEvent(pmtpi);
   m_iLastTime = iTotalTime;
}
void entrypoint( void )
{
    // full screen
#ifdef SETRESOLUTION
    if( ChangeDisplaySettings(&screenSettings,CDS_FULLSCREEN)!=DISP_CHANGE_SUCCESSFUL) return;
#endif
    // create window
    HWND hWnd = CreateWindow( "static",0,WS_POPUP|WS_VISIBLE|WS_MAXIMIZE,0,0,0,0,0,0,0,0);
    HDC hDC = GetDC(hWnd);

    // initalize opengl
    if( !SetPixelFormat(hDC,ChoosePixelFormat(hDC,&pfd),&pfd) ) return;

    HGLRC tempOpenGLContext;
    tempOpenGLContext = wglCreateContext(hDC);
    wglMakeCurrent(hDC, tempOpenGLContext);
    // create openGL functions
    for (int i=0; i<NUM_GL_NAMES; i++) glFP[i] = (GenFP)wglGetProcAddress(glnames[i]);
    HGLRC hRC = wglCreateContextAttribsARB(hDC, NULL, glAttribs);
    // Remove temporary context and set new one
    wglMakeCurrent(NULL, NULL);
    wglDeleteContext(tempOpenGLContext);
    wglMakeCurrent(hDC, hRC);

    // init intro
    intro_init();

    // open audio device
    waveOutOpen(&hWaveOut, WAVE_MAPPER, &wfx, 0, 0, CALLBACK_NULL);
    // create music block
    mzk_init();
    // prepare and play music block
    header[0].lpData = (char *)myMuzikBlock[0];
    header[1].lpData = (char *)myMuzikBlock[1];
    header[0].dwBufferLength = AUDIO_BUFFER_SIZE * MZK_NUMCHANNELS * 2;
    header[1].dwBufferLength = AUDIO_BUFFER_SIZE * MZK_NUMCHANNELS * 2;
    waveOutPrepareHeader(hWaveOut, &(header[0]), sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &(header[0]), sizeof(WAVEHDR));
    waveOutPrepareHeader(hWaveOut, &(header[1]), sizeof(WAVEHDR));
    waveOutWrite(hWaveOut, &(header[1]), sizeof(WAVEHDR));

    timer.wType = TIME_SAMPLES;
    do
    {
        MSG msg;
        PeekMessage(&msg, NULL, 0, 0, PM_REMOVE);

        ShowCursor(0);
        waveOutGetPosition(hWaveOut, &timer, sizeof(timer));
        DWORD t = timer.u.sample;

        intro_do(t);
        //SwapBuffers ( hDC );
        wglSwapLayerBuffers( hDC, WGL_SWAP_MAIN_PLANE );

        // Try to unprepare header
        if (waveOutUnprepareHeader(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR))
                != WAVERR_STILLPLAYING)
        {
            mzk_prepare_block(myMuzikBlock[nextPlayBlock]);
            waveOutPrepareHeader(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR));
            waveOutWrite(hWaveOut, &(header[nextPlayBlock]), sizeof(WAVEHDR));
            nextPlayBlock = 1 - nextPlayBlock;
        }
    } while ( !(GetAsyncKeyState(VK_ESCAPE) || GetAsyncKeyState(VK_F4)));

    sndPlaySound(0,0);

    ExitProcess(0);
}
Exemple #23
0
LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	int wmId, wmEvent;
	char file[512];
	WAVEHDR * pwhOut;
	MMTIME mmt;
	unsigned long * framebuf;

	switch (message) // switch selon le message
	{
		case WM_CREATE:
			SetTimer(hWnd,0,10,NULL);
		break;

		case WM_DROPFILES:
			file[0] = 0;
			DragQueryFile((HDROP)wParam, 0, (char*)file, sizeof(file));
			loadmod(file);
		break;

		case WM_TIMER:
			mmt.wType = TIME_SAMPLES;
			if(waveOutGetPosition(wout,&mmt,sizeof(MMTIME)) == MMSYSERR_NOERROR)
			{
				file[0] = 0;

				if(IsWindowVisible(hWnd) && fg)
				{
					if(mmt.u.sample&NBSTEREO16BITSAMPLES)
					{
						framebuf = fg_generateFrame(fg,&trackbuf_state2,mmt.u.sample&(NBSTEREO16BITSAMPLES-1));
					}
					else
					{
						framebuf = fg_generateFrame(fg,&trackbuf_state1,mmt.u.sample&(NBSTEREO16BITSAMPLES-1));
					}

					updateScreen(hWnd, framebuf, fg->xres,fg->yres);
				}
			}
		break;
		case WM_COMMAND:	//Action sur un menu
			wmId    = LOWORD(wParam);
			wmEvent = HIWORD(wParam);
			switch(wmId)
			{
				case IDI_PLAY:
					waveOutRestart(wout);
				break;
				case IDI_PAUSE:
					waveOutPause(wout);
				break;
				case IDI_EJECT:
					file[0] = 0;
					if(fileselector(hWnd,file,"Load mod file","*.mod","*.mod",0,0))
					{
						loadmod(file);
					}
				break;
				case IDI_INFO:
				break;
				case IDI_FILTER:
				break;
				case IDI_STEREO:
				break;

				case IDI_QUIT:
					PostQuitMessage(0);
				break;

			}
		break;

		case WM_DESTROY:
		break;

		case WM_USER: //Message venant de l'icone de la barre des taches
			switch(lParam)
			{
				case WM_LBUTTONDOWN:
					if(GetFocus() == hWnd)
					{
						ShowWindow(hWnd,SW_HIDE);
					}
					else
					{
						ShowWindow(hWnd,SW_SHOWNORMAL);
						SetFocus(hWnd);
					}
				break;
				case WM_RBUTTONDOWN:
					ListPopup(hWnd);
				break;
			}

		break;

		case WM_USER+1:
		break;

		case WM_CLOSE: //message de fermeture
			ShowWindow(hWnd,SW_HIDE);
		break;

		case WM_MOUSEMOVE:
		break;

		case MM_WOM_OPEN:
		break;

		case MM_WOM_CLOSE:
		break;

		case MM_WOM_DONE:
			pwhOut = (struct wavehdr_tag *)lParam;
		
			if(pwhOut->lpData == (char*)&sndbuffer1)
			{
				trackbuf_state1.nb_of_state = 0;
				hxcmod_fillbuffer(&modloaded,(unsigned short*)pwhOut->lpData, pwhOut->dwBufferLength /4,&trackbuf_state1);
			}
			else
			{
				trackbuf_state2.nb_of_state = 0;
				hxcmod_fillbuffer(&modloaded,(unsigned short*)pwhOut->lpData, pwhOut->dwBufferLength /4,&trackbuf_state2);
			}

			waveOutWrite((HWAVEOUT)wParam,pwhOut,sizeof(WAVEHDR));
			nb_wr_block++;

		break;

		case WM_KEYDOWN:
		break;

		default: // traitement par defaut de l'evenement (gerer par windows)
			return DefWindowProc(hWnd, message, wParam, lParam);
	}
	return 0;
}
Exemple #24
0
int GetCurrentSample()
{
	waveOutGetPosition(hWaveOut, &MMTime, sizeof(MMTIME));
	return MMTime.u.sample;
}
Exemple #25
-1
DWORD PlayWavStream::GetCurrentTime()
{
	DWORD dwResult = 0;

	m_mtWavOut.Lock();

	if (	m_pWavOut &&
			NULL != m_pWavOut->GetHwave() )
	{
		MMTIME		mmt;
		MMRESULT	mmr;

		mmt.wType = TIME_BYTES;

		mmr = waveOutGetPosition( m_pWavOut->GetHwave(), &mmt, sizeof( mmt ) ); 

		if ( m_WavFormat.nAvgBytesPerSec )
		{
			dwResult = (DWORD)( mmt.u.cb * 1000.0 / m_WavFormat.nAvgBytesPerSec );
		}
	}

	m_mtWavOut.Unlock();

	return dwResult;
} 
Exemple #26
-1
// Return the time in milliseconds corresponding to the  currently playing audio sample, or -1 if no audio is playing.
LONG CALLBACK aviaudioTime(void)
{
	MMTIME      mmtime;

	if (audioPlayable <= 0)
		return -1;

	if (!sfPlaying)
		return -1;

	//not sure
	if (recalc) {
		streamEnd = AVIStreamEnd(spavi);
		streamStart = AVIStreamStart(spavi);
		recalc = 0;
		//ErrMsg("recalc");
	}

	if ((streamEnd<=streamStart) || (streamEnd<=0))
		return -1;

	mmtime.wType = TIME_SAMPLES;

	waveOutGetPosition(shWaveOut, &mmtime, sizeof(mmtime));

	if (mmtime.wType == TIME_SAMPLES)
		return AVIStreamSampleToTime(spavi, slBegin) + muldiv32(mmtime.u.sample, 1000, sdwSamplesPerSec);
	else if (mmtime.wType == TIME_BYTES)
		return AVIStreamSampleToTime(spavi, slBegin) + muldiv32(mmtime.u.cb, 1000, sdwBytesPerSec);
	else
		return -1;
}
Exemple #27
-1
sint32 VDAudioOutputWaveOutW32::GetPositionBytes() {
	MMTIME mmtime;

	if (mCurState != kStatePlaying) return -1;

	mmtime.wType = TIME_BYTES;

	MMRESULT res;

	vdsynchronized(mcsWaveDevice) {
		res = waveOutGetPosition(mhWaveOut, &mmtime, sizeof mmtime);
	}

	if (MMSYSERR_NOERROR != res)
		return -1;

	switch(mmtime.wType) {
	case TIME_BYTES:
		return mmtime.u.cb;
	case TIME_MS:
		return MulDiv(mmtime.u.ms, mAvgBytesPerSec, 1000);
	case TIME_SAMPLES:
		return MulDiv(mmtime.u.sample, mAvgBytesPerSec, mSamplesPerSec);
	}

	return -1;
}
int64_t RageSoundDriver_WaveOut::GetPosition() const
{
	MMTIME tm;
	tm.wType = TIME_SAMPLES;
	MMRESULT ret = waveOutGetPosition( m_hWaveOut, &tm, sizeof(tm) );
  	if( ret != MMSYSERR_NOERROR )
		FAIL_M( wo_ssprintf(ret, "waveOutGetPosition failed") );

	return tm.u.sample;
}
Exemple #29
-1
	MMRESULT TinyWaveOut::GetPosition(LPMMTIME pmmt)
	{
		if (hWaveOut == NULL || pmmt == NULL) return S_FALSE;
		MMRESULT hRes = waveOutGetPosition(hWaveOut, pmmt, sizeof(WAVEOUTCAPS));
		if (hRes != MMSYSERR_NOERROR)
		{
			waveOutClose(hWaveOut);
			hWaveOut = NULL;
		}
		return hRes;
	}
Exemple #30
-1
	void flip()
	{
		MMTIME	time;
		int		err;

		if (playing==0) return;
		if (timeout)
		{
			if (--timeout) return;
			buffer.play(device);
		}
		memset(&time,0,sizeof(MMTIME));
   		time.wType=TIME_BYTES;
		err=waveOutGetPosition(device,&time,sizeof(MMTIME));		

		if (time.wType!=TIME_BYTES) err=-666;else if (time.u.cb>0x10000000) err=-6667;
		if (err) {
//			printf("waveOutGetPosition failed err=%d\n",err);fflush(stdout);
			waveOutReset(device);
			mixpos=0;
			memset(buffer.data,0,buffersize*samplesize*32);
			buffer.play(device);
			return;
		}
		
		int wavepos=time.u.cb/samplesize;
		int writeahead=buffersize*lagbuffers;
		if (wavepos && wavepos+buffersize*2>mixpos)
		{
			timeout=250;
			memset(buffer.data,0,buffersize*samplesize*32);
			waveOutReset(device);
			if (lagbuffers<10) lagbuffers+=2;
			mixpos=buffersize*lagbuffers*2;
//			printf("collision");fflush(stdout);
			return;			
		}
		int seek=wavepos+writeahead;				
		while (mixpos<seek)
		{
			int f=(mixpos/buffersize)&31;
			if (mode==0) 
			{
				mix->mix8(buffer.data+f*buffersize);
			}
			else
			{
				mix->mix16((short *)buffer.data+f*buffersize);
			}
			mixpos+=buffersize;	
		}
	}