arts/flow/audioionas.cpp

    /*

    Copyright (C) 2001 Jochen Hoenicke
                       jochen@gnu.org

    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

/**
 * only compile nas AudioIO class if libaudio was detected during
 * configure
 */
#ifdef HAVE_LIBAUDIONAS

#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 "audioio.h"
#include "audiosubsys.h"
#include "iomanager.h"
#include "dispatcher.h"

#include <audio/audiolib.h>

namespace Arts {

static AuBool
eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler);

class AudioIONAS : public AudioIO, public IONotify {
protected:
	AuServer *aud;
	AuDeviceID device;
	AuFlowID flow;
	AuElement elements[2];

	int freeBytes;

public:
	AudioIONAS();

	void setParam(AudioParam param, int& value);
	int getParam(AudioParam param);

	bool open();
	void close();
	void run();
	void notifyIO(int, int);
	int read(void *buffer, int size);
	int write(void *buffer, int size);

	friend AuBool 
	eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler);
};

REGISTER_AUDIO_IO(AudioIONAS,"nas","Network Audio System");
}

using namespace std;
using namespace Arts;

static AuBool
Arts::eventHandler(AuServer *, AuEvent *ev, AuEventHandlerRec *handler)
{
	AudioIONAS *nas = (AudioIONAS *) handler->data;
	if (ev->type == AuEventTypeElementNotify)
	{
		AuElementNotifyEvent *event = (AuElementNotifyEvent *) ev;
		
		switch (event->kind)
		{
		case AuElementNotifyKindLowWater:
			nas->freeBytes += event->num_bytes;
			AudioSubSystem::the()->handleIO
				(AudioSubSystem::ioWrite);
			break;
		case AuElementNotifyKindState:
			if (event->cur_state ==  AuStatePause
			    && event->reason != AuReasonUser)
			{
				nas->freeBytes += event->num_bytes;
				AudioSubSystem::the()->handleIO
					(AudioSubSystem::ioWrite);
			}
			break;
		}
	}
	return true;
}

AudioIONAS::AudioIONAS()
{
	/*
	 * default parameters
	 */
	param(samplingRate) = 11025;
	paramStr(deviceName) = "null";
	param(fragmentSize) = 1024;
	param(fragmentCount) = 7;
	param(format) = 16;
	param(channels) = 2;
	param(direction) = 2;
}

bool AudioIONAS::open()
{
	char *server_msg;
	
	int& _channels = param(channels);
	int& _direction = param(direction);
	int& _fragmentSize = param(fragmentSize);
	int& _fragmentCount = param(fragmentCount);
	int& _samplingRate = param(samplingRate);
	int& _format = param(format);
	string& _device = paramStr(deviceName);
	string& _error = paramStr(lastError);
	int  _buf_samples, i;

	if((_direction & directionRead))
	{
		_error = "no record audio device";
		return false;
	}

	aud = AuOpenServer(_device.compare("null") == 0 
			   ? NULL : _device.c_str(), 
			   0, NULL, 0, NULL, &server_msg);
	if(aud == NULL)
	{
		_error = "device ";
		_error += _device;
		_error += " can't be opened (";
		_error += server_msg;
		_error += ")";
		return false;
	}

	device = AuNone;
	for (i = 0; i < AuServerNumDevices(aud); i++) 
	{
		AuDeviceAttributes *devattr = AuServerDevice(aud, i);
		if (AuDeviceKind(devattr) == AuComponentKindPhysicalOutput
		    && AuDeviceNumTracks(devattr) == _channels)
		{
			device = AuDeviceIdentifier(devattr);
			break;
		}
	}
				  
	if (device == AuNone)
	{
		_error = "Couldn't find an output device";
		return false;
	}

	if (!(flow = AuCreateFlow(aud, NULL)))
	{
		_error = "Couldn't create flow";
		return false;
	}

	_buf_samples = _fragmentSize;
	AuMakeElementImportClient(&elements[0], _samplingRate,
				  _format == 8 ? AuFormatLinearUnsigned8
				  : AuFormatLinearSigned16LSB,
				  _channels, AuTrue,
				  _buf_samples * _fragmentCount,
				  _buf_samples * (_fragmentCount)/2,
				  0, NULL);
	AuMakeElementExportDevice(&elements[1], 0, device, _samplingRate,
				  AuUnlimitedSamples, 0, NULL);
	AuSetElements(aud, flow, AuTrue, 2, elements, NULL);
	AuRegisterEventHandler(aud, AuEventHandlerIDMask, 0, flow,
			       eventHandler, (AuPointer) this);

	freeBytes = 0;
	AuStartFlow(aud, flow, NULL);

	Dispatcher::the()->ioManager()->watchFD(aud->fd, IOType::read, this);

	AuHandleEvents(aud);
	return true;
}

void AudioIONAS::close()
{
	Dispatcher::the()->ioManager()->remove(this, IOType::all);
	AuWriteElement(aud, flow, 0, 0, NULL, AuTrue, NULL);
	AuCloseServer(aud);
	aud = NULL;
}

void AudioIONAS::setParam(AudioParam p, int& value)
{
	param(p) = value;
}

int AudioIONAS::getParam(AudioParam p)
{
	switch(p)
	{
	case canWrite:
		return freeBytes;
		
	default:
		return param(p);
	}
}

void AudioIONAS::notifyIO(int, int)
{
	AuHandleEvents(aud);
}

int AudioIONAS::read(void *, int )
{
	return 0;
}

int AudioIONAS::write(void *buffer, int size)
{
	if (size > freeBytes)
		size = freeBytes;
	if (size > 0)
		AuWriteElement(aud, flow, 0, size, buffer, AuFalse, NULL);
	freeBytes -= size;
	if (freeBytes > 0)
		AudioSubSystem::the()->handleIO(AudioSubSystem::ioWrite);
	return size;
}

#endif