You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
arts/flow/audioionull.cc

185 lines
3.9 KiB

/*
Copyright (C) 2001 Stefan Westerfeld
stefan@space.twc.de
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library General Public
License as published by the Free Software Foundation; either
version 2 of the License, or (at your option) any later version.
This library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
Boston, MA 02110-1301, USA.
*/
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
#include <sys/types.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/stat.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <stdio.h>
#include <stdlib.h>
#include <unistd.h>
#include <iostream>
#include <algorithm>
#include <cstring>
#include "debug.h"
#include "audioio.h"
#include "audiosubsys.h"
#include "iomanager.h"
#include "dispatcher.h"
namespace Arts {
class AudioIONull : public AudioIO, public TimeNotify {
protected:
timeval start;
double samplesRead, samplesWritten, bytesPerSec;
public:
AudioIONull();
void notifyTime();
void setParam(AudioParam param, int& value);
int getParam(AudioParam param);
bool open();
void close();
int read(void *buffer, int size);
int write(void *buffer, int size);
};
REGISTER_AUDIO_IO(AudioIONull,"null","No Audio Input/Output");
}
using namespace std;
using namespace Arts;
AudioIONull::AudioIONull()
{
/*
* default parameters
*/
param(samplingRate) = 44100;
paramStr(deviceName) = "null";
param(fragmentSize) = 1024;
param(fragmentCount) = 7;
param(channels) = 2;
param(direction) = 2;
}
bool AudioIONull::open()
{
int& _channels = param(channels);
int& _fragmentSize = param(fragmentSize);
int& _fragmentCount = param(fragmentCount);
int& _samplingRate = param(samplingRate);
int& _format = param(format);
_format = 16;
/*
* don't allow unreasonable large fragmentSize/Count combinations,
* because "real" hardware also doesn't
*/
if(_fragmentSize > 1024*128) _fragmentSize = 1024*128;
while(_fragmentSize * _fragmentCount > 1024*128)
_fragmentCount--;
Dispatcher::the()->ioManager()->addTimer(10, this);
samplesRead = samplesWritten = 0.0;
bytesPerSec = _channels * 2 * _samplingRate;
gettimeofday(&start,0);
return true;
}
void AudioIONull::close()
{
Dispatcher::the()->ioManager()->removeTimer(this);
}
void AudioIONull::notifyTime()
{
int& _direction = param(direction);
int& _fragmentSize = param(fragmentSize);
for(;;)
{
int todo = 0;
if((_direction & directionRead) && getParam(canRead) >= _fragmentSize)
todo |= AudioSubSystem::ioRead;
if((_direction & directionWrite) && getParam(canWrite) >= _fragmentSize)
todo |= AudioSubSystem::ioWrite;
if(!todo)
return;
AudioSubSystem::the()->handleIO(todo);
}
}
void AudioIONull::setParam(AudioParam p, int& value)
{
param(p) = value;
}
int AudioIONull::getParam(AudioParam p)
{
timeval now;
double delta;
int bytes;
switch(p)
{
case canRead:
case canWrite:
gettimeofday(&now,0);
delta = (double)now.tv_sec + (double)now.tv_usec/1000000.0;
delta -= (double)start.tv_sec + (double)start.tv_usec/1000000.0;
bytes = (int)( (delta * bytesPerSec)
- ((p == canRead)?samplesRead:samplesWritten)
);
return bytes;
break;
default:
return param(p);
break;
}
}
int AudioIONull::read(void *buffer, int size)
{
samplesRead += size;
memset(buffer, 0, size);
return size;
}
int AudioIONull::write(void *, int size)
{
samplesWritten += size;
return size;
}