backup
/
gps
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
gps/GPSResources/tcpmp/common/win32/waveout_win32.c

1132 lines
26 KiB
C
Raw Normal View History

Init Projects
2019-05-01 12:32:35 +00:00
/*****************************************************************************
*
* This program is free software ; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*
* $Id: waveout_win32.c 543 2006-01-07 22:06:24Z picard $
*
* The Core Pocket Media Player
* Copyright (c) 2004-2005 Gabor Kovacs
*
****************************************************************************/
#include "../common.h"
#include <math.h>
#if defined(TARGET_WIN32) || defined(TARGET_WINCE)
#define BUFFER_MUSIC 1*TICKSPERSEC
#define BUFFER_VIDEO 2*TICKSPERSEC
#ifndef STRICT
#define STRICT
#endif
#include <windows.h>
#define BENCH_SIZE 32
struct waveout;
typedef struct wavebuffer
{
WAVEHDR Head;
planes Planes;
struct wavebuffer* Next; //next in chain
struct wavebuffer* GlobalNext;
tick_t RefTime;
tick_t EstRefTime;
int Bytes;
block Block;
} wavebuffer;
typedef struct waveout
{
node Node;
node Timer;
pin Pin;
packetformat Input;
packetformat Output;
packetprocess Process;
wavebuffer* Buffers; // global chain
wavebuffer* FreeFirst;
wavebuffer* FreeLast;
int BufferLength; // one buffer length (waveout format)
tick_t BufferScaledTime; // scaled time of one waveout buffer (BufferLength)
int BufferScaledAdjust; // waveout bytes to scaled time convert (12bit fixed point)
int Total; // source format
int Dropped; // dropped packets
int Bytes; // output format
int FillPos;
int Skip;
wavebuffer* FillFirst;
wavebuffer* FillLast;
wavebuffer** Pausing;
tick_t FillLastTime;
HWAVEOUT Handle;
CRITICAL_SECTION Section;
void* PCM;
int PCMSpeed;
int BufferLimit;
int BufferLimitFull;
tick_t Tick;
int TimeRef;
LONG Waiting; // number of waiting buffers in WaveOut
LONG Used; // number of used buffers (waiting or in fill chain)
bool_t Play;
fraction Speed;
fraction SpeedTime;
int AdjustedRate;
bool_t Dither;
bool_t BufferMode;
int Stereo;
int Quality;
bool_t ForcePriority;
bool_t SoftwareVolume;
bool_t MonoVol;
bool_t Mute;
int PreAmp;
int VolumeDev; // backup value when mute is turned on
int VolumeSoft;
int VolumeSoftLog;
int VolumeRamp;
WAVEFORMATEX Format;
int BenchWait[BENCH_SIZE];
int BenchSum[BENCH_SIZE];
int BenchCurrSum;
int BenchAvg;
int BenchAdj;
size_t BenchAvgLimit;
int BenchSpeedAvg;
int BenchWaitPos;
} waveout;
#define WAVEOUT(p) ((waveout*)((char*)(p)-OFS(waveout,Timer)))
static void Pause(waveout* p);
static void Write(waveout* p, tick_t CurrTime);
static int SetVolumeSoft(waveout* p,int v,bool_t m)
{
int OldVolumeSoftLog = p->VolumeSoftLog;
bool_t OldSkip = p->Mute || p->VolumeSoft==0;
p->VolumeSoft = v;
p->Mute = m;
if (p->SoftwareVolume || p->PreAmp)
{
if (p->SoftwareVolume && p->Handle && (p->Mute || p->VolumeSoft==0)!=OldSkip)
{
if (!OldSkip)
Pause(p);
else
if (p->Play)
{
// adjust tick so packets without RefTime won't mess up timing
EnterCriticalSection(&p->Section);
p->Tick += Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
p->TimeRef = GetTimeTick();
LeaveCriticalSection(&p->Section);
}
}
v += p->PreAmp;
if (v<-40) v=-40;
p->VolumeSoftLog = (int)(pow(10,(50+v)/62.3));
if (p->VolumeSoftLog < 3)
p->VolumeSoftLog = 3;
}
else
p->VolumeSoftLog = 256;
if (p->Handle)
{
int Adjust = ScaleRound(p->VolumeSoftLog,256,OldVolumeSoftLog);
if (Adjust != 256)
{
wavebuffer* List;
EnterCriticalSection(&p->Section);
for (List=p->Buffers;List;List=List->GlobalNext)
VolumeMul(Adjust,(void*)List->Block.Ptr,p->BufferLength,&p->Output.Format.Audio);
LeaveCriticalSection(&p->Section);
}
}
return ERR_NONE;
}
static int GetVolume(waveout* p)
{
if (!p->SoftwareVolume)
{
DWORD Value;
if (waveOutGetVolume(NULL,&Value) == MMSYSERR_NOERROR)
{
if (p->MonoVol)
{
Value &= 0xFFFF;
Value |= Value << 16;
}
if (Value)
p->Mute = 0;
if (!p->Mute)
p->VolumeDev = ((LOWORD(Value)+HIWORD(Value)+600)*100) / (0xFFFF*2);
}
return p->VolumeDev;
}
return p->VolumeSoft;
}
static tick_t Time(waveout* p)
{
if (p->Speed.Num==0)
return TIME_BENCH;
if (p->Play)
{
tick_t t;
EnterCriticalSection(&p->Section);
t = p->Tick + Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
LeaveCriticalSection(&p->Section);
return t;
}
return p->Tick;
}
static int TimerGet(void* pt, int No, void* Data, int Size)
{
waveout* p = WAVEOUT(pt);
int Result = ERR_INVALID_PARAM;
switch (No)
{
case TIMER_PLAY: GETVALUE(p->Play,bool_t); break;
case TIMER_SPEED: GETVALUE(p->Speed,fraction); break;
case TIMER_TIME: GETVALUE(Time(p),tick_t); break;
}
return Result;
}
static int Get(waveout* p, int No, void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case OUT_INPUT: GETVALUE(p->Pin,pin); break;
case OUT_INPUT|PIN_FORMAT: GETVALUE(p->Input,packetformat); break;
case OUT_INPUT|PIN_PROCESS: GETVALUE(p->Process,packetprocess); break;
case OUT_OUTPUT|PIN_FORMAT: GETVALUE(p->Output,packetformat); break;
case OUT_TOTAL:GETVALUE(p->Total,int); break;
case OUT_DROPPED:GETVALUE(p->Dropped,int); break;
case AOUT_VOLUME: GETVALUE(GetVolume(p),int); break;
case AOUT_MUTE: GETVALUE(p->Mute,bool_t); break;
case AOUT_PREAMP: GETVALUE(p->PreAmp,int); break;
case AOUT_STEREO: GETVALUE(p->Stereo,int); break;
case AOUT_MODE: GETVALUE(p->BufferMode,bool_t); break;
case AOUT_QUALITY: GETVALUE(p->Quality,int); break;
case AOUT_TIMER: GETVALUE(&p->Timer,node*); break;
}
return Result;
}
static void UpdateBenchAvg(waveout* p)
{
int n;
p->BenchAvg += 4;
p->BenchAdj = (24*16) / p->BenchAvg;
p->BenchSpeedAvg = SPEED_ONE/(p->BenchAvg*BENCH_SIZE);
n = p->Input.Format.Audio.Bits >> 3;
if (!(p->Input.Format.Audio.Flags & PCM_PLANES))
n *= p->Input.Format.Audio.Channels;
n = p->Output.Format.Audio.SampleRate;
if (n>0)
p->BenchAvgLimit = (n * p->BenchAvg) / 160;
else
p->BenchAvgLimit = MAX_INT;
p->BenchCurrSum += 2 * BENCH_SIZE;
for (n=0;n<BENCH_SIZE;++n)
{
p->BenchSum[n] += 2 * BENCH_SIZE;
p->BenchWait[n] += 2;
}
}
static void ReleaseBuffer(waveout* p,wavebuffer* Buffer,bool_t UpdateTick)
{
EnterCriticalSection(&p->Section);
if (UpdateTick)
{
tick_t Old;
int Time = GetTimeTick();
Old = p->Tick + Scale(Time-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
if (Buffer->RefTime >= 0)
p->Tick = Buffer->RefTime + p->BufferScaledTime;
else
p->Tick += p->BufferScaledTime;
p->TimeRef = Time;
//DEBUG_MSG2(-1,T("WaveOutTime: %d %d"),Old,p->Tick);
// if difference is little then just adjust (because GetTimeTick() is more linear)
if (abs(Old - p->Tick) < TICKSPERSEC/2)
p->Tick = Old + ((p->Tick - Old) >> 2);
}
Buffer->Next = NULL;
if (p->FreeLast)
p->FreeLast->Next = Buffer;
else
p->FreeFirst = Buffer;
p->FreeLast = Buffer;
p->Used--;
LeaveCriticalSection(&p->Section);
}
static void Reset(waveout* p)
{
int n;
// release buffers already sended to device
if (p->Handle)
{
tick_t OldTick = p->Tick;
waveOutReset(p->Handle);
p->Tick = OldTick;
}
if (p->FillLast && p->FillLast->RefTime >= 0)
p->FillLastTime = p->FillLast->RefTime;
// release fill chain
while (p->FillFirst)
{
wavebuffer* Buffer = p->FillFirst;
p->FillFirst = Buffer->Next;
ReleaseBuffer(p,Buffer,0);
}
p->FillLast = NULL;
p->FillPos = p->BufferLength;
p->Skip = 0;
p->Bytes = 0;
p->BufferLimit = p->BufferLimitFull;
p->BenchAvg = 16-4;
UpdateBenchAvg(p);
p->BenchWaitPos = 0;
p->BenchCurrSum = p->BenchAvg * BENCH_SIZE;
for (n=0;n<BENCH_SIZE;++n)
{
p->BenchSum[n] = p->BenchCurrSum;
p->BenchWait[n] = p->BenchAvg;
}
PCMReset(p->PCM); // init dither and subsample position
}
static wavebuffer* GetBuffer(waveout* p)
{
wavebuffer* Buffer;
// try to find a free buffer
EnterCriticalSection(&p->Section);
Buffer = p->FreeFirst;
if (Buffer)
{
p->FreeFirst = Buffer->Next;
if (Buffer == p->FreeLast)
p->FreeLast = NULL;
}
if (!Buffer)
{
block Block;
if (AllocBlock(p->BufferLength,&Block,p->Used>=20,HEAP_DYNAMIC))
{
Buffer = (wavebuffer*)malloc(sizeof(wavebuffer));
if (!Buffer)
FreeBlock(&Block);
}
if (Buffer)
{
Buffer->Block = Block;
Buffer->Planes[0] = (uint8_t*)Block.Ptr;
Buffer->Next = NULL;
memset(&Buffer->Head,0,sizeof(WAVEHDR));
Buffer->Head.lpData = (char*)Buffer->Block.Ptr;
Buffer->Head.dwUser = (DWORD)Buffer;
Buffer->Head.dwBufferLength = p->BufferLength;
Buffer->Head.dwBytesRecorded = p->BufferLength;
if (waveOutPrepareHeader(p->Handle, &Buffer->Head, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
{
FreeBlock(&Buffer->Block);
free(Buffer);
Buffer = NULL;
}
else
{
Buffer->GlobalNext = p->Buffers;
p->Buffers = Buffer;
}
}
else
{
p->BufferLimitFull = p->Used;
if (p->BufferLimit > p->Used)
p->BufferLimit = p->Used;
else
if (p->BufferLimit > 4)
p->BufferLimit--;
}
}
if (Buffer)
{
p->Used++;
Buffer->RefTime = -1;
Buffer->Next =NULL;
}
LeaveCriticalSection(&p->Section);
return Buffer;
}
static void Write(waveout* p, tick_t CurrTime)
{
if (p->Play)
{
while (p->FillFirst != p->FillLast)
{
wavebuffer* Buffer = p->FillFirst;
if (!p->Waiting && CurrTime >= 0 && Buffer->EstRefTime >= 0 && Buffer->EstRefTime > CurrTime + SHOWAHEAD)
break;
p->FillFirst = Buffer->Next;
if (p->SoftwareVolume && (p->Mute || p->VolumeSoft==0))
ReleaseBuffer(p,Buffer,0);
else
{
if (waveOutWrite(p->Handle, &Buffer->Head, sizeof(WAVEHDR)) != MMSYSERR_NOERROR)
ReleaseBuffer(p,Buffer,0);
else
InterlockedIncrement(&p->Waiting);
}
}
}
}
static int Send(waveout* p, const constplanes Planes, int Length, tick_t RefTime, tick_t CurrTime, int Speed)
{
wavebuffer* Buffer;
int DstLength;
int SrcLength;
planes DstPlanes;
constplanes SrcPlanes;
p->Total += Length;
SrcPlanes[0] = Planes[0];
SrcPlanes[1] = Planes[1];
if (p->Skip > 0)
{
SrcLength = min(p->Skip,Length);
SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
Length -= SrcLength;
p->Skip -= SrcLength;
}
while (Length > 0)
{
if (p->FillPos >= p->BufferLength)
{
// allocate new buffer
Buffer = GetBuffer(p);
if (!Buffer)
break;
if (p->FillLast)
{
wavebuffer* Last = p->FillLast;
if (Last->RefTime>=0)
p->FillLastTime = Last->EstRefTime = Last->RefTime;
else
{
if (p->FillLastTime>=0)
p->FillLastTime += p->BufferScaledTime;
Last->EstRefTime = p->FillLastTime;
}
Last->Next = Buffer;
}
else
p->FillFirst = Buffer;
p->FillLast = Buffer;
p->FillPos = 0;
Buffer->Bytes = p->Bytes;
}
else
Buffer = p->FillLast;
if (RefTime >= 0)
{
Buffer->RefTime = RefTime - ((p->FillPos * p->BufferScaledAdjust) >> 12);
if (Buffer->RefTime < 0)
Buffer->RefTime = 0;
RefTime = TIME_UNKNOWN;
}
SrcLength = Length;
DstLength = p->BufferLength - p->FillPos;
DstPlanes[0] = (uint8_t*)Buffer->Block.Ptr + p->FillPos;
PCMConvert(p->PCM,DstPlanes,SrcPlanes,&DstLength,&SrcLength,Speed,p->VolumeSoftLog);
if (p->VolumeRamp < RAMPLIMIT)
p->VolumeRamp = VolumeRamp(p->VolumeRamp,DstPlanes[0],DstLength,&p->Output.Format.Audio);
p->Bytes += DstLength;
p->FillPos += DstLength;
SrcPlanes[0] = (uint8_t*)SrcPlanes[0] + SrcLength;
SrcPlanes[1] = (uint8_t*)SrcPlanes[1] + SrcLength;
Length -= SrcLength;
if (!SrcLength)
break;
}
if (Length && p->Input.Format.Audio.BlockAlign>0)
p->Skip = p->Input.Format.Audio.BlockAlign - Length % p->Input.Format.Audio.BlockAlign;
Write(p,CurrTime);
return ERR_NONE;
}
static void CALLBACK WaveProc(HWAVEOUT hwo, UINT uMsg, DWORD dwInstance,
DWORD dwParam1, DWORD dwParam2)
{
if (uMsg == WOM_DONE)
{
wavebuffer* Buffer = (wavebuffer*)(((WAVEHDR*)dwParam1)->dwUser);
waveout* p = (waveout*)dwInstance;
if (p->ForcePriority)
{
void* Thread = GetCurrentThread();
if (GetThreadPriority(Thread)!=THREAD_PRIORITY_HIGHEST)
SetThreadPriority(Thread,THREAD_PRIORITY_HIGHEST);
}
if (p->Pausing)
{
// add buffer to fill chain
Buffer->Next = *p->Pausing;
*p->Pausing = Buffer;
p->Pausing = &Buffer->Next;
}
else
ReleaseBuffer(p,Buffer,1);
InterlockedDecrement(&p->Waiting);
}
}
static int UpdatePCM(waveout* p,const audio* InputFormat)
{
p->SpeedTime = p->Speed;
p->SpeedTime.Num *= TICKSPERSEC;
p->SpeedTime.Den *= GetTimeFreq();
p->BufferScaledTime = Scale(TICKSPERSEC,p->Speed.Num*p->BufferLength,p->Speed.Den*p->Format.nAvgBytesPerSec);
if (p->BufferLength)
p->BufferScaledAdjust = (p->BufferScaledTime*4096) / p->BufferLength;
else
p->BufferScaledAdjust = 0;
if (!p->Speed.Num)
p->PCMSpeed = SPEED_ONE;
else
p->PCMSpeed = Scale(SPEED_ONE,p->Speed.Num,p->Speed.Den);
p->AdjustedRate = Scale(p->Output.Format.Audio.SampleRate,p->Speed.Den,p->Speed.Num);
PCMRelease(p->PCM);
p->PCM = PCMCreate(&p->Output.Format.Audio,InputFormat,p->Dither,p->SoftwareVolume || p->PreAmp);
return ERR_NONE;
}
static int UpdateBufferTime(waveout* p)
{
p->BufferLimit = Scale(p->BufferMode?BUFFER_VIDEO:BUFFER_MUSIC,p->Format.nAvgBytesPerSec,p->BufferLength*TICKSPERSEC);
p->BufferLimitFull = p->BufferLimit;
return ERR_NONE;
}
static int Process(waveout* p,const packet* Packet,const flowstate* State)
{
if (!Packet)
{
if (State->DropLevel)
++p->Dropped;
else
Write(p,State->CurrTime);
return (p->Waiting<=0 || p->Speed.Num==0) ? ERR_NONE : ERR_BUFFER_FULL;
}
if (p->Speed.Num==0) // benchmark mode (auto adjust speed)
{
int Pos = p->BenchWaitPos;
int OldSum;
int Speed;
if (p->Play)
{
while (Packet->Length > p->BenchAvgLimit)
UpdateBenchAvg(p);
p->BenchCurrSum -= p->BenchWait[Pos];
p->BenchWait[Pos] = (p->Waiting * p->BufferLength) >> 12;
p->BenchCurrSum += p->BenchWait[Pos];
OldSum = p->BenchSum[Pos];
p->BenchSum[Pos] = p->BenchCurrSum;
if (++Pos == BENCH_SIZE)
Pos = 0;
p->BenchWaitPos = Pos;
if (p->BenchCurrSum < 2*BENCH_SIZE*p->BenchAvg)
Speed = (p->BenchCurrSum+1) * p->BenchSpeedAvg;
else
Speed = 2*SPEED_ONE+(p->BenchCurrSum-2*BENCH_SIZE*p->BenchAvg+1) * 4*p->BenchSpeedAvg;
Speed -= p->BenchAdj*(p->BenchCurrSum - OldSum);
if (p->Waiting < 3)
Speed -= SPEED_ONE/5;
}
else
Speed = SPEED_ONE;
//DEBUG_MSG3(-1,T("Audio speed:%d length:%d (wait:%d)"),Speed,Packet->Length,p->Waiting);
return Send(p,Packet->Data,Packet->Length,Packet->RefTime,State->CurrTime,Speed);
}
if (State->DropLevel)
return ERR_NONE;
if (p->Used >= p->BufferLimit)
{
Write(p,State->CurrTime);
return ERR_BUFFER_FULL;
}
DEBUG_MSG3(DEBUG_AUDIO,T("Waveout reftime:%d used:%d waiting:%d"),Packet->RefTime,p->Used,p->Waiting);
return Send(p,Packet->Data,Packet->Length,Packet->RefTime,State->CurrTime,p->PCMSpeed);
}
static bool_t FreeBuffers(waveout* p);
static int UpdateInput(waveout* p)
{
Reset(p);
FreeBuffers(p);
if (p->Handle)
{
waveOutClose(p->Handle);
p->Handle = NULL;
}
p->Total = 0;
p->Dropped = 0;
p->Process = DummyProcess;
if (p->Input.Type == PACKET_AUDIO)
{
MMRESULT MMResult;
int Try;
if (p->Input.Format.Audio.Format != AUDIOFMT_PCM)
{
PacketFormatClear(&p->Input);
return ERR_INVALID_DATA;
}
if (p->Input.Format.Audio.Channels == 0 ||
p->Input.Format.Audio.SampleRate == 0)
return ERR_NONE; // probably initialized later
p->Output.Type = PACKET_AUDIO;
p->Output.Format.Audio = p->Input.Format.Audio;
p->Output.Format.Audio.Flags = 0;
p->Dither = 0;
if (p->Stereo==STEREO_SWAPPED)
p->Output.Format.Audio.Flags |= PCM_SWAPPEDSTEREO;
else
if (p->Stereo!=STEREO_NORMAL)
{
p->Output.Format.Audio.Channels = 1;
if (p->Stereo==STEREO_LEFT)
p->Output.Format.Audio.Flags |= PCM_ONLY_LEFT;
if (p->Stereo==STEREO_RIGHT)
p->Output.Format.Audio.Flags |= PCM_ONLY_RIGHT;
}
switch (p->Quality)
{
case 0: // low quality for very poor devices
p->Output.Format.Audio.Bits = 8;
p->Output.Format.Audio.FracBits = 7;
p->Output.Format.Audio.Channels = 1;
p->Output.Format.Audio.SampleRate = 22050;
break;
case 1: // no dither and only standard samplerate
p->Output.Format.Audio.Bits = 16;
p->Output.Format.Audio.FracBits = 15;
if (p->Output.Format.Audio.SampleRate >= 44100)
p->Output.Format.Audio.SampleRate = 44100;
else
p->Output.Format.Audio.SampleRate = 22050;
break;
default:
case 2: // original samplerate
p->Output.Format.Audio.Bits = 16;
p->Output.Format.Audio.FracBits = 15;
p->Dither = 1;
break;
}
Try = 0;
do
{
if (p->Output.Format.Audio.Bits <= 8)
p->Output.Format.Audio.Flags |= PCM_UNSIGNED;
p->Format.wFormatTag = WAVE_FORMAT_PCM;
p->Format.nChannels = (WORD)p->Output.Format.Audio.Channels;
p->Format.nSamplesPerSec = p->Output.Format.Audio.SampleRate;
p->Format.wBitsPerSample = (WORD)p->Output.Format.Audio.Bits;
p->Format.nBlockAlign = (WORD)((p->Format.nChannels * p->Format.wBitsPerSample) >> 3);
p->Format.nAvgBytesPerSec = p->Format.nSamplesPerSec * p->Format.nBlockAlign;
p->Format.cbSize = 0;
MMResult = waveOutOpen(&p->Handle, WAVE_MAPPER, &p->Format,(DWORD)WaveProc,
(DWORD)p,CALLBACK_FUNCTION);
if (MMResult==WAVERR_BADFORMAT)
{
++Try;
if (Try==1)
{
if (p->Output.Format.Audio.SampleRate > 35000)
p->Output.Format.Audio.SampleRate = 44100;
else
++Try;
}
if (Try==2)
{
if (p->Output.Format.Audio.SampleRate != 22050)
p->Output.Format.Audio.SampleRate = 22050;
else
++Try;
}
if (Try==3)
{
if (p->Output.Format.Audio.Channels > 1)
p->Output.Format.Audio.Channels = 1;
else
++Try;
}
if (Try==4)
{
if (p->Output.Format.Audio.Bits != 8)
{
p->Output.Format.Audio.Bits = 8;
p->Output.Format.Audio.FracBits = 7;
}
else
++Try;
}
if (Try==5)
break;
}
}
while (MMResult==WAVERR_BADFORMAT);
if (p->Handle)
{
p->Process = Process;
p->TimeRef = GetTimeTick();
p->BufferLength = 4096;
if (p->Format.nAvgBytesPerSec > 65536)
p->BufferLength *= 2;
if (p->Format.nAvgBytesPerSec > 2*65536)
p->BufferLength *= 2;
UpdateBufferTime(p);
p->FillPos = p->BufferLength;
p->VolumeRamp = 0;
UpdatePCM(p,&p->Input.Format.Audio);
Reset(p);
}
else
{
PacketFormatClear(&p->Input);
ShowError(p->Node.Class,ERR_ID,ERR_DEVICE_ERROR);
return ERR_DEVICE_ERROR;
}
}
else
if (p->Input.Type != PACKET_NONE)
return ERR_INVALID_DATA;
return ERR_NONE;
}
static int Update(waveout* p)
{
wavebuffer *OldFirst;
wavebuffer *OldLast;
audio OldFormat;
wavebuffer* OldBuffers;
wavebuffer* OldFill;
int OldFillPos;
int OldUsed;
bool_t OldVolume;
int OldPreAmp;
wavebuffer *Buffer,*Next;
EnterCriticalSection(&p->Section);
OldVolume = p->SoftwareVolume;
OldPreAmp = p->PreAmp;
OldUsed = p->Used;
OldFirst = p->FreeFirst;
OldLast = p->FreeLast;
OldFormat = p->Output.Format.Audio;
OldFormat.SampleRate = p->AdjustedRate;
OldFill = p->FillFirst;
OldFillPos = p->FillPos;
p->FillFirst = NULL;
p->FillLast = NULL;
p->FillPos = p->BufferLength;
p->FreeFirst = NULL;
p->FreeLast = NULL;
LeaveCriticalSection(&p->Section);
Reset(p);
OldBuffers = p->FreeFirst;
if (p->FreeLast)
p->FreeLast->Next = OldFill;
else
OldBuffers = OldFill;
if (OldBuffers)
p->FillLastTime = OldBuffers->EstRefTime - p->BufferScaledTime;
p->PreAmp = 0;
p->SoftwareVolume = 0;
p->Used = OldUsed;
p->FreeFirst = OldFirst;
p->FreeLast = OldLast;
// setup temporary format
UpdatePCM(p,&OldFormat);
for (Buffer=OldBuffers;Buffer;Buffer=Next)
{
Next = Buffer->Next;
Send(p,Buffer->Planes,Next ? p->BufferLength:OldFillPos,Buffer->RefTime,-1,p->PCMSpeed);
ReleaseBuffer(p,Buffer,0);
}
p->SoftwareVolume = OldVolume;
p->PreAmp = OldPreAmp;
UpdatePCM(p,&p->Input.Format.Audio);
return ERR_NONE;
}
static bool_t FreeBuffers(waveout* p)
{
wavebuffer** Ptr;
wavebuffer* Buffer;
bool_t Changed = 0;
while (p->FreeFirst)
{
Buffer = p->FreeFirst;
p->FreeFirst = Buffer->Next;
// remove from global chain
Ptr = &p->Buffers;
while (*Ptr && *Ptr != Buffer)
Ptr = &(*Ptr)->GlobalNext;
if (*Ptr == Buffer)
*Ptr = Buffer->Next;
waveOutUnprepareHeader(p->Handle, &Buffer->Head, sizeof(WAVEHDR));
FreeBlock(&Buffer->Block);
free(Buffer);
Changed = 1;
}
p->FreeLast = NULL;
return Changed;
}
static int Hibernate(waveout* p,int Mode)
{
bool_t Changed = 0;
EnterCriticalSection(&p->Section);
Changed = FreeBuffers(p);
LeaveCriticalSection(&p->Section);
return Changed ? ERR_NONE : ERR_OUT_OF_MEMORY;
}
static void Pause(waveout* p)
{
p->Pausing = &p->FillFirst;
waveOutReset(p->Handle);
p->Pausing = NULL;
p->FillLast = p->FillFirst;
if (p->FillLast)
while (p->FillLast->Next) p->FillLast = p->FillLast->Next;
}
static int UpdatePlay(waveout* p)
{
if (p->Play)
{
p->TimeRef = GetTimeTick();
if (p->Handle)
Write(p,p->Tick);
}
else
{
if (!p->Waiting)
p->Tick += Scale(GetTimeTick()-p->TimeRef,p->SpeedTime.Num,p->SpeedTime.Den);
else
if (p->Handle)
Pause(p);
}
return ERR_NONE;
}
static int SetVolumeDev(waveout* p,int v)
{
p->VolumeDev = v;
if (p->Mute)
waveOutSetVolume(NULL,0);
else
waveOutSetVolume(NULL,0x10001 * ((0xFFFF * p->VolumeDev) / 100));
return ERR_NONE;
}
static int TimerSet(void* pt, int No, const void* Data, int Size)
{
waveout* p = WAVEOUT(pt);
int Result = ERR_INVALID_PARAM;
switch (No)
{
case TIMER_PLAY: SETVALUECMP(p->Play,bool_t,UpdatePlay(p),EqBool); break;
case TIMER_SPEED: SETVALUECMP(p->Speed,fraction,Update(p),EqFrac); break;
case TIMER_TIME:
assert(Size == sizeof(tick_t));
EnterCriticalSection(&p->Section);
p->Tick = *(tick_t*)Data;
p->TimeRef = GetTimeTick();
LeaveCriticalSection(&p->Section);
Result = ERR_NONE;
break;
}
return Result;
}
static void UpdateSoftwareVolume(waveout* p)
{
bool_t SoftwareVolume = !QueryAdvanced(ADVANCED_SYSTEMVOLUME);
if (SoftwareVolume != p->SoftwareVolume)
{
p->SoftwareVolume = SoftwareVolume;
SetVolumeSoft(p,p->VolumeSoft,p->Mute);
if (p->Handle)
UpdatePCM(p,&p->Input.Format.Audio);
}
}
static int UpdatePreAmp(waveout* p)
{
SetVolumeSoft(p,p->VolumeSoft,p->Mute);
if (p->Handle)
UpdatePCM(p,&p->Input.Format.Audio);
return ERR_NONE;
}
static int Set(waveout* p, int No, const void* Data, int Size)
{
int Result = ERR_INVALID_PARAM;
switch (No)
{
case OUT_INPUT|PIN_FORMAT:
if (PacketFormatSimilarAudio(&p->Input,(const packetformat*)Data))
{
PacketFormatCopy(&p->Input,(const packetformat*)Data);
Result = UpdatePCM(p,&p->Input.Format.Audio);
}
else
SETPACKETFORMATCMP(p->Input,packetformat,UpdateInput(p));
break;
case OUT_INPUT: SETVALUE(p->Pin,pin,ERR_NONE); break;
case OUT_TOTAL: SETVALUE(p->Total,int,ERR_NONE); break;
case OUT_DROPPED: SETVALUE(p->Dropped,int,ERR_NONE); break;
case AOUT_VOLUME:
assert(Size==sizeof(int));
UpdateSoftwareVolume(p);
if (p->SoftwareVolume)
Result = SetVolumeSoft(p,*(int*)Data,p->Mute);
else
Result = SetVolumeDev(p,*(int*)Data);
break;
case AOUT_PREAMP: SETVALUECMP(p->PreAmp,int,UpdatePreAmp(p),EqInt); break;
case AOUT_MUTE:
assert(Size==sizeof(bool_t));
UpdateSoftwareVolume(p);
if (p->SoftwareVolume)
Result = SetVolumeSoft(p,p->VolumeSoft,*(bool_t*)Data);
else
{
if (!p->Mute) GetVolume(p); // save old volume to p->VolumeDev
p->Mute = *(bool_t*)Data;
Result = SetVolumeDev(p,p->VolumeDev);
}
break;
case AOUT_STEREO: SETVALUECMP(p->Stereo,int,UpdateInput(p),EqInt); break;
case AOUT_QUALITY: SETVALUECMP(p->Quality,int,UpdateInput(p),EqInt); break;
case AOUT_MODE: SETVALUE(p->BufferMode,bool_t,UpdateBufferTime(p)); break;
case FLOW_FLUSH:
Reset(p);
p->FillLastTime = TIME_UNKNOWN;
p->VolumeRamp = 0;
Result = ERR_NONE;
break;
case NODE_SETTINGSCHANGED:
p->ForcePriority = QueryAdvanced(ADVANCED_WAVEOUTPRIORITY);
break;
case NODE_HIBERNATE:
assert(Size == sizeof(int));
Result = Hibernate(p,*(int*)Data);
break;
}
return Result;
}
static int Create(waveout* p)
{
WAVEOUTCAPS Caps;
if (waveOutGetNumDevs()==0)
return ERR_NOT_SUPPORTED;
waveOutGetDevCaps(WAVE_MAPPER,&Caps,sizeof(Caps));
p->Node.Get = (nodeget)Get;
p->Node.Set = (nodeset)Set;
p->Timer.Class = TIMER_CLASS;
p->Timer.Enum = TimerEnum;
p->Timer.Get = TimerGet;
p->Timer.Set = TimerSet;
p->VolumeDev = 70; //default when device is muted
p->VolumeSoftLog = 256;
p->Quality = 2;
p->Speed.Den = p->Speed.Num = 1;
p->SpeedTime.Num = TICKSPERSEC;
p->SpeedTime.Den = GetTimeFreq();
p->MonoVol = (Caps.dwSupport & WAVECAPS_LRVOLUME) == 0;
InitializeCriticalSection(&p->Section);
return ERR_NONE;
}
static void Delete(waveout* p)
{
PacketFormatClear(&p->Input);
PCMRelease(p->PCM);
DeleteCriticalSection(&p->Section);
}
static const nodedef WaveOut =
{
sizeof(waveout)|CF_GLOBAL,
WAVEOUT_ID,
AOUT_CLASS,
PRI_DEFAULT,
(nodecreate)Create,
(nodedelete)Delete,
};
void WaveOut_Init()
{
NodeRegisterClass(&WaveOut);
}
void WaveOut_Done()
{
NodeUnRegisterClass(WAVEOUT_ID);
}
#endif