haiku.git

/*
 * Copyright 2010, Axel Dörfler, axeld@pinc-software.de.
 * Copyright 2000-2010, Stephan Aßmus <superstippi@gmx.de>,
 * Copyright 2000-2008, Ingo Weinhold <ingo_weinhold@gmx.de>,
 * All Rights Reserved. Distributed under the terms of the MIT license.
 *
 * Copyright (c) 1998-99, Be Incorporated, All Rights Reserved.
 * Distributed under the terms of the Be Sample Code license.
 */


#include "AudioProducer.h"

#include <math.h>
#include <string.h>
#include <stdio.h>

#include <BufferGroup.h>
#include <Buffer.h>
#include <MediaDefs.h>
#include <ParameterWeb.h>
#include <TimeSource.h>

#include "AudioSupplier.h"
#include "EventQueue.h"
#include "MessageEvent.h"

#define DEBUG_TO_FILE 0

#if DEBUG_TO_FILE
# include <Entry.h>
# include <MediaFormats.h>
# include <MediaFile.h>
# include <MediaTrack.h>
#endif // DEBUG_TO_FILE


// debugging
//#define TRACE_AUDIO_PRODUCER
#ifdef TRACE_AUDIO_PRODUCER
#	define TRACE(x...)		printf(x)
#	define TRACE_BUFFER(x...)
#	define ERROR(x...)		fprintf(stderr, x)
#else
#	define TRACE(x...)
#	define TRACE_BUFFER(x...)
#	define ERROR(x...)		fprintf(stderr, x)
#endif


const static bigtime_t kMaxLatency = 150000;
	// 150 ms is the maximum latency we publish


#if DEBUG_TO_FILE
static BMediaFile*
init_media_file(media_format format, BMediaTrack** _track)
{
	static BMediaFile* file = NULL;
	static BMediaTrack* track = NULL;
	if (file == NULL) {
		entry_ref ref;
		get_ref_for_path("/boot/home/Desktop/test.wav", &ref);

		media_file_format fileFormat;
		int32 cookie = 0;
		while (get_next_file_format(&cookie, &fileFormat) == B_OK) {
			if (strcmp(fileFormat.short_name, "wav") == 0)
				break;
		}
		file = new BMediaFile(&ref, &fileFormat);

		media_codec_info info;
		cookie = 0;
		while (get_next_encoder(&cookie, &info) == B_OK) {
			if (strcmp(info.short_name, "raw-audio") == 0
				|| strcmp(info.short_name, "pcm") == 0) {
				break;
			}
		}

		track = file->CreateTrack(&format, &info);
		if (track == NULL)
			printf("failed to create track\n");

		file->CommitHeader();
	}
	*_track = track;
	return track != NULL ? file : NULL;
}
#endif // DEBUG_TO_FILE


static bigtime_t
estimate_internal_latency(const media_format& format)
{
	bigtime_t startTime = system_time();
	// calculate the number of samples per buffer
	int32 sampleSize = format.u.raw_audio.format
		& media_raw_audio_format::B_AUDIO_SIZE_MASK;
	int32 sampleCount = format.u.raw_audio.buffer_size / sampleSize;
	// alloc float buffers of this size
	const int bufferCount = 10;	// number of input buffers
	float* buffers[bufferCount + 1];
	for (int32 i = 0; i < bufferCount + 1; i++)
		buffers[i] = new float[sampleCount];
	float* outBuffer = buffers[bufferCount];
	// fill all buffers save the last one with arbitrary data and merge them
	// into the last one
	for (int32 i = 0; i < bufferCount; i++) {
		for (int32 k = 0; k < sampleCount; k++) {
			buffers[i][k] = ((float)i * (float)k)
				/ float(bufferCount * sampleCount);
		}
	}
	for (int32 k = 0; k < sampleCount; k++) {
		outBuffer[k] = 0;
		for (int32 i = 0; i < bufferCount; i++)
			outBuffer[k] += buffers[i][k];
		outBuffer[k] /= bufferCount;
	}
	// cleanup
	for (int32 i = 0; i < bufferCount + 1; i++)
		delete[] buffers[i];
	return system_time() - startTime;
}


// #pragma mark -


AudioProducer::AudioProducer(const char* name, AudioSupplier* supplier,
		bool lowLatency)
	:
	BMediaNode(name),
	BBufferProducer(B_MEDIA_RAW_AUDIO),
	BMediaEventLooper(),

	fBufferGroup(NULL),
	fLatency(0),
	fInternalLatency(0),
	fLastLateNotice(0),
	fNextScheduledBuffer(0),
	fLowLatency(lowLatency),
	fOutputEnabled(true),
	fFramesSent(0),
	fStartTime(0),
	fSupplier(supplier),

	fPeakListener(NULL)
{
	TRACE("%p->AudioProducer::AudioProducer(%s, %p, %d)\n", this, name,
		supplier, lowLatency);

	// initialize our preferred format object
	fPreferredFormat.type = B_MEDIA_RAW_AUDIO;
	fPreferredFormat.u.raw_audio.format
		= media_raw_audio_format::B_AUDIO_FLOAT;
//		= media_raw_audio_format::B_AUDIO_SHORT;
	fPreferredFormat.u.raw_audio.byte_order
		= (B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;
#if 0
	fPreferredFormat.u.raw_audio.channel_count = 2;
	fPreferredFormat.u.raw_audio.frame_rate = 44100.0;

	// NOTE: the (buffer_size * 1000000) needs to be dividable by
	// fPreferredFormat.u.raw_audio.frame_rate!
	fPreferredFormat.u.raw_audio.buffer_size = 441 * 4
		* (fPreferredFormat.u.raw_audio.format
			& media_raw_audio_format::B_AUDIO_SIZE_MASK);

	if (!fLowLatency)
		fPreferredFormat.u.raw_audio.buffer_size *= 3;
#else
	fPreferredFormat.u.raw_audio.channel_count = 0;
	fPreferredFormat.u.raw_audio.frame_rate = 0.0;
	fPreferredFormat.u.raw_audio.buffer_size = 0;
#endif

	// we're not connected yet
	fOutput.destination = media_destination::null;
	fOutput.format = fPreferredFormat;

	// init the audio supplier
	if (fSupplier != NULL) {
		fSupplier->SetAudioProducer(this);
		SetInitialLatency(fSupplier->InitialLatency());
	}
}


AudioProducer::~AudioProducer()
{
	TRACE("%p->AudioProducer::~AudioProducer()\n", this);

#if DEBUG_TO_FILE
	BMediaTrack* track;
	if (BMediaFile* file = init_media_file(fPreferredFormat, &track)) {
		printf("deleting file...\n");
		track->Flush();
		file->ReleaseTrack(track);
		file->CloseFile();
		delete file;
	}
#endif // DEBUG_TO_FILE

	// Stop the BMediaEventLooper thread
	Quit();
	TRACE("AudioProducer::~AudioProducer() done\n");
}


BMediaAddOn*
AudioProducer::AddOn(int32* internalId) const
{
	return NULL;
}


status_t
AudioProducer::FormatSuggestionRequested(media_type type, int32 quality,
	media_format* _format)
{
	TRACE("%p->AudioProducer::FormatSuggestionRequested()\n", this);

	if (!_format)
		return B_BAD_VALUE;

	// This is the format we'll be returning (our preferred format)
	*_format = fPreferredFormat;

	// A wildcard type is okay; we can specialize it, otherwise only raw audio
	// is supported
	if (type != B_MEDIA_UNKNOWN_TYPE && type != B_MEDIA_RAW_AUDIO)
		return B_MEDIA_BAD_FORMAT;

	return B_OK;
}

status_t
AudioProducer::FormatProposal(const media_source& output, media_format* format)
{
	TRACE("%p->AudioProducer::FormatProposal()\n", this);

	// is this a proposal for our one output?
	if (output != fOutput.source) {
		TRACE("  -> B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}

	// Raw audio or wildcard type, either is okay by us. If the format is
	// anything else, overwrite it with our preferred format. Also, we only support
	// floating point audio in the host native byte order at the moment.
	if ((format->type != B_MEDIA_UNKNOWN_TYPE
			&& format->type != B_MEDIA_RAW_AUDIO)
		|| (format->u.raw_audio.format
				!= media_raw_audio_format::wildcard.format
			&& format->u.raw_audio.format
				!= fPreferredFormat.u.raw_audio.format)
		|| (format->u.raw_audio.byte_order
				!= media_raw_audio_format::wildcard.byte_order
			&& format->u.raw_audio.byte_order
				!= fPreferredFormat.u.raw_audio.byte_order)) {
		TRACE("  -> B_MEDIA_BAD_FORMAT\n");
		*format = fPreferredFormat;
		return B_MEDIA_BAD_FORMAT;
	}

	format->type = B_MEDIA_RAW_AUDIO;
	format->u.raw_audio.format = fPreferredFormat.u.raw_audio.format;
	format->u.raw_audio.byte_order = fPreferredFormat.u.raw_audio.byte_order;

	return B_OK;
}


status_t
AudioProducer::FormatChangeRequested(const media_source& source,
	const media_destination& destination, media_format* ioFormat,
	int32* _deprecated_)
{
	TRACE("%p->AudioProducer::FormatChangeRequested()\n", this);

	if (destination != fOutput.destination) {
		TRACE("  -> B_MEDIA_BAD_DESTINATION\n");
		return B_MEDIA_BAD_DESTINATION;
	}

	if (source != fOutput.source) {
		TRACE("  -> B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}

// TODO: Maybe we are supposed to specialize here only and not actually change yet?
//	status_t ret = _SpecializeFormat(ioFormat);

	return ChangeFormat(ioFormat);
}


status_t
AudioProducer::GetNextOutput(int32* cookie, media_output* _output)
{
	TRACE("%p->AudioProducer::GetNextOutput(%ld)\n", this, *cookie);

	// we have only a single output; if we supported multiple outputs, we'd
	// iterate over whatever data structure we were using to keep track of
	// them.
	if (0 == *cookie) {
		*_output = fOutput;
		*cookie += 1;
		return B_OK;
	}

	return B_BAD_INDEX;
}


status_t
AudioProducer::DisposeOutputCookie(int32 cookie)
{
	// do nothing because we don't use the cookie for anything special
	return B_OK;
}


status_t
AudioProducer::SetBufferGroup(const media_source& forSource,
	BBufferGroup* newGroup)
{
	TRACE("%p->AudioProducer::SetBufferGroup()\n", this);

	if (forSource != fOutput.source)
		return B_MEDIA_BAD_SOURCE;

	if (newGroup == fBufferGroup)
		return B_OK;

	if (fUsingOurBuffers && fBufferGroup)
		delete fBufferGroup;	// waits for all buffers to recycle

	if (newGroup != NULL) {
		// we were given a valid group; just use that one from now on
		fBufferGroup = newGroup;
		fUsingOurBuffers = false;
	} else {
		// we were passed a NULL group pointer; that means we construct
		// our own buffer group to use from now on
		size_t size = fOutput.format.u.raw_audio.buffer_size;
		int32 count = int32(fLatency / BufferDuration() + 1 + 1);
		fBufferGroup = new BBufferGroup(size, count);
		fUsingOurBuffers = true;
	}

	return B_OK;
}


status_t
AudioProducer::GetLatency(bigtime_t* _latency)
{
	TRACE("%p->AudioProducer::GetLatency()\n", this);

	// report our *total* latency:  internal plus downstream plus scheduling
	*_latency = EventLatency() + SchedulingLatency();
	return B_OK;
}


status_t
AudioProducer::PrepareToConnect(const media_source& what,
	const media_destination& where, media_format* format,
	media_source* _source, char* _name)
{
	TRACE("%p->AudioProducer::PrepareToConnect()\n", this);

	// trying to connect something that isn't our source?
	if (what != fOutput.source) {
		TRACE("  -> B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}

	// are we already connected?
	if (fOutput.destination != media_destination::null) {
		TRACE("  -> B_MEDIA_ALREADY_CONNECTED\n");
		return B_MEDIA_ALREADY_CONNECTED;
	}

	status_t ret = _SpecializeFormat(format);
	if (ret != B_OK) {
		TRACE("  -> format error: %s\n", strerror(ret));
		return ret;
	}

	// Now reserve the connection, and return information about it
	fOutput.destination = where;
	fOutput.format = *format;

	if (fSupplier != NULL)
		fSupplier->SetFormat(fOutput.format);

	*_source = fOutput.source;
	strncpy(_name, fOutput.name, B_MEDIA_NAME_LENGTH);
	TRACE("  -> B_OK\n");
	return B_OK;
}


void
AudioProducer::Connect(status_t error, const media_source& source,
	 const media_destination& destination, const media_format& format,
	 char* _name)
{
	TRACE("AudioProducer::Connect(%s)\n", strerror(error));

	// If something earlier failed, Connect() might still be called, but with
	// a non-zero error code.  When that happens we simply unreserve the
	// connection and do nothing else.
	if (error != B_OK) {
		fOutput.destination = media_destination::null;
		fOutput.format = fPreferredFormat;
		return;
	}

	// Okay, the connection has been confirmed.  Record the destination and
	// format that we agreed on, and report our connection name again.
	fOutput.destination = destination;
	fOutput.format = format;
	strncpy(_name, fOutput.name, B_MEDIA_NAME_LENGTH);

	// tell our audio supplier about the format
	if (fSupplier) {
		TRACE("AudioProducer::Connect() fSupplier->SetFormat()\n");
		fSupplier->SetFormat(fOutput.format);
	}

	TRACE("AudioProducer::Connect() FindLatencyFor()\n");

	// Now that we're connected, we can determine our downstream latency.
	// Do so, then make sure we get our events early enough.
	media_node_id id;
	FindLatencyFor(fOutput.destination, &fLatency, &id);

	// Use a dry run to see how long it takes me to fill a buffer of data
	size_t sampleSize = fOutput.format.u.raw_audio.format
		& media_raw_audio_format::B_AUDIO_SIZE_MASK;
	size_t samplesPerBuffer
		= fOutput.format.u.raw_audio.buffer_size / sampleSize;
	fInternalLatency = estimate_internal_latency(fOutput.format);
	if (!fLowLatency)
		fInternalLatency *= 32;
	SetEventLatency(fLatency + fInternalLatency);

	// reset our buffer duration, etc. to avoid later calculations
	bigtime_t duration = bigtime_t(1000000)
		* samplesPerBuffer / bigtime_t(fOutput.format.u.raw_audio.frame_rate
		* fOutput.format.u.raw_audio.channel_count);
	TRACE("AudioProducer::Connect() SetBufferDuration(%lld)\n", duration);
	SetBufferDuration(duration);

	TRACE("AudioProducer::Connect() _AllocateBuffers()\n");

	// Set up the buffer group for our connection, as long as nobody handed
	// us a buffer group (via SetBufferGroup()) prior to this.  That can
	// happen, for example, if the consumer calls SetOutputBuffersFor() on
	// us from within its Connected() method.
	if (fBufferGroup == NULL)
		_AllocateBuffers(fOutput.format);

	TRACE("AudioProducer::Connect() done\n");
}


void
AudioProducer::Disconnect(const media_source& what,
	const media_destination& where)
{
	TRACE("%p->AudioProducer::Disconnect()\n", this);

	// Make sure that our connection is the one being disconnected
	if (where == fOutput.destination && what == fOutput.source) {
		fOutput.destination = media_destination::null;
		fOutput.format = fPreferredFormat;
		TRACE("AudioProducer:  deleting buffer group...\n");
		// Always delete the buffer group, even if it is not ours.
		// (See BeBook::SetBufferGroup()).
		delete fBufferGroup;
		TRACE("AudioProducer:  buffer group deleted\n");
		fBufferGroup = NULL;
	}

	TRACE("%p->AudioProducer::Disconnect() done\n", this);
}


void
AudioProducer::LateNoticeReceived(const media_source& what, bigtime_t howMuch,
	bigtime_t performanceTime)
{
	TRACE("%p->AudioProducer::LateNoticeReceived(%lld, %lld)\n", this, howMuch,
		performanceTime);
	// If we're late, we need to catch up. Respond in a manner appropriate
	// to our current run mode.
	if (what == fOutput.source) {
		// Ignore the notices for buffers we already send out (or scheduled
		// their event) before we processed the last notice
		if (fLastLateNotice > performanceTime)
			return;

		fLastLateNotice = fNextScheduledBuffer;

		if (RunMode() == B_RECORDING) {
			// ...
		} else if (RunMode() == B_INCREASE_LATENCY) {
			fInternalLatency += howMuch;

			// At some point a too large latency can get annoying
			if (fInternalLatency > kMaxLatency)
				fInternalLatency = kMaxLatency;

			SetEventLatency(fLatency + fInternalLatency);
		} else {
			// Skip one buffer ahead in the audio data.
			size_t sampleSize
				= fOutput.format.u.raw_audio.format
					& media_raw_audio_format::B_AUDIO_SIZE_MASK;
			size_t samplesPerBuffer
				= fOutput.format.u.raw_audio.buffer_size / sampleSize;
			size_t framesPerBuffer
				= samplesPerBuffer / fOutput.format.u.raw_audio.channel_count;
			fFramesSent += framesPerBuffer;
		}
	}
}


void
AudioProducer::EnableOutput(const media_source& what, bool enabled,
	int32* _deprecated_)
{
	TRACE("%p->AudioProducer::EnableOutput(%d)\n", this, enabled);

	if (what == fOutput.source)
		fOutputEnabled = enabled;
}


status_t
AudioProducer::SetPlayRate(int32 numer, int32 denom)
{
	return B_ERROR;
}


status_t
AudioProducer::HandleMessage(int32 message, const void *data, size_t size)
{
	TRACE("%p->AudioProducer::HandleMessage()\n", this);
	return B_ERROR;
}


void
AudioProducer::AdditionalBufferRequested(const media_source& source,
	media_buffer_id prevBuffer, bigtime_t prevTime,
	const media_seek_tag *prevTag)
{
	TRACE("%p->AudioProducer::AdditionalBufferRequested()\n", this);
}


void
AudioProducer::LatencyChanged(const media_source& source,
	const media_destination& destination, bigtime_t newLatency, uint32 flags)
{
	TRACE("%p->AudioProducer::LatencyChanged(%lld)\n", this, newLatency);

	if (source == fOutput.source && destination == fOutput.destination) {
		fLatency = newLatency;
		SetEventLatency(fLatency + fInternalLatency);
	}
}


void
AudioProducer::NodeRegistered()
{
	TRACE("%p->AudioProducer::NodeRegistered()\n", this);

	// set up as much information about our output as we can
	fOutput.source.port = ControlPort();
	fOutput.source.id = 0;
	fOutput.node = Node();
	::strcpy(fOutput.name, Name());

	// Start the BMediaEventLooper thread
	SetPriority(B_REAL_TIME_PRIORITY);
	Run();
}


void
AudioProducer::SetRunMode(run_mode mode)
{
	TRACE("%p->AudioProducer::SetRunMode()\n", this);

	if (B_OFFLINE == mode)
		ReportError(B_NODE_FAILED_SET_RUN_MODE);
	else
		BBufferProducer::SetRunMode(mode);
}


void
AudioProducer::HandleEvent(const media_timed_event* event, bigtime_t lateness,
	bool realTimeEvent)
{
	TRACE_BUFFER("%p->AudioProducer::HandleEvent()\n", this);

	switch (event->type) {
		case BTimedEventQueue::B_START:
			TRACE("AudioProducer::HandleEvent(B_START)\n");
			if (RunState() != B_STARTED) {
				fFramesSent = 0;
				fStartTime = event->event_time + fSupplier->InitialLatency();
				media_timed_event firstBufferEvent(
					fStartTime - fSupplier->InitialLatency(),
					BTimedEventQueue::B_HANDLE_BUFFER);
				EventQueue()->AddEvent(firstBufferEvent);
			}
			TRACE("AudioProducer::HandleEvent(B_START) done\n");
			break;

		case BTimedEventQueue::B_STOP:
			TRACE("AudioProducer::HandleEvent(B_STOP)\n");
			EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
				BTimedEventQueue::B_HANDLE_BUFFER);
			TRACE("AudioProducer::HandleEvent(B_STOP) done\n");
			break;

		case BTimedEventQueue::B_HANDLE_BUFFER:
		{
			TRACE_BUFFER("AudioProducer::HandleEvent(B_HANDLE_BUFFER)\n");
			if (RunState() == BMediaEventLooper::B_STARTED
				&& fOutput.destination != media_destination::null) {
				BBuffer* buffer = _FillNextBuffer(event->event_time);
				if (buffer != NULL) {
					status_t err = B_ERROR;
					if (fOutputEnabled) {
						err = SendBuffer(buffer, fOutput.source,
							fOutput.destination);
					}
					if (err != B_OK)
						buffer->Recycle();
				}
				size_t sampleSize = fOutput.format.u.raw_audio.format
						& media_raw_audio_format::B_AUDIO_SIZE_MASK;

				size_t nFrames = fOutput.format.u.raw_audio.buffer_size
					/ (sampleSize * fOutput.format.u.raw_audio.channel_count);
				fFramesSent += nFrames;

				fNextScheduledBuffer = fStartTime
					+ bigtime_t(double(fFramesSent) * 1000000.0
						/ double(fOutput.format.u.raw_audio.frame_rate));
				media_timed_event nextBufferEvent(fNextScheduledBuffer,
					BTimedEventQueue::B_HANDLE_BUFFER);
				EventQueue()->AddEvent(nextBufferEvent);
			} else {
				ERROR("B_HANDLE_BUFFER, but not started!\n");
			}
			TRACE_BUFFER("AudioProducer::HandleEvent(B_HANDLE_BUFFER) done\n");
			break;
		}
		default:
			break;
	}
}


void
AudioProducer::SetPeakListener(BHandler* handler)
{
	fPeakListener = handler;
}


status_t
AudioProducer::ChangeFormat(media_format* format)
{
	TRACE("AudioProducer::ChangeFormat()\n");

	format->u.raw_audio.buffer_size
		= media_raw_audio_format::wildcard.buffer_size;

	status_t ret = _SpecializeFormat(format);
	if (ret != B_OK) {
		TRACE("  _SpecializeFormat(): %s\n", strerror(ret));
		return ret;
	}

	ret = BBufferProducer::ProposeFormatChange(format, fOutput.destination);
	if (ret != B_OK) {
		TRACE("  ProposeFormatChange(): %s\n", strerror(ret));
		return ret;
	}

	ret = BBufferProducer::ChangeFormat(fOutput.source, fOutput.destination,
		format);
	if (ret != B_OK) {
		TRACE("  ChangeFormat(): %s\n", strerror(ret));
		return ret;
	}

	return _ChangeFormat(*format);
}


// #pragma mark -


status_t
AudioProducer::_SpecializeFormat(media_format* format)
{
	// the format may not yet be fully specialized (the consumer might have
	// passed back some wildcards).  Finish specializing it now, and return an
	// error if we don't support the requested format.
	if (format->type != B_MEDIA_RAW_AUDIO) {
		TRACE("  not raw audio\n");
		return B_MEDIA_BAD_FORMAT;
// TODO: we might want to support different audio formats
	} else if (format->u.raw_audio.format
			!= fPreferredFormat.u.raw_audio.format) {
		TRACE("  format does not match\n");
		return B_MEDIA_BAD_FORMAT;
	}

	if (format->u.raw_audio.channel_count
			== media_raw_audio_format::wildcard.channel_count) {
		format->u.raw_audio.channel_count = 2;
		TRACE("  -> adjusting channel count, it was wildcard\n");
	}

	if (format->u.raw_audio.frame_rate
			== media_raw_audio_format::wildcard.frame_rate) {
		format->u.raw_audio.frame_rate = 44100.0;
		TRACE("  -> adjusting frame rate, it was wildcard\n");
	}

	// check the buffer size, which may still be wildcarded
	if (format->u.raw_audio.buffer_size
			== media_raw_audio_format::wildcard.buffer_size) {
		// pick something comfortable to suggest
		TRACE("  -> adjusting buffer size, it was wildcard\n");

		// NOTE: the (buffer_size * 1000000) needs to be dividable by
		// format->u.raw_audio.frame_rate! (We assume frame rate is a multiple of
		// 25, which it usually is.)
		format->u.raw_audio.buffer_size
			= uint32(format->u.raw_audio.frame_rate / 25.0)
				* format->u.raw_audio.channel_count
				* (format->u.raw_audio.format
					& media_raw_audio_format::B_AUDIO_SIZE_MASK);

		if (!fLowLatency)
			format->u.raw_audio.buffer_size *= 3;
	}

	return B_OK;
}


status_t
AudioProducer::_ChangeFormat(const media_format& format)
{
	fOutput.format = format;

	// notify our audio supplier of the format change
	if (fSupplier)
		fSupplier->SetFormat(format);

	return _AllocateBuffers(format);
}


status_t
AudioProducer::_AllocateBuffers(const media_format& format)
{
	TRACE("%p->AudioProducer::_AllocateBuffers()\n", this);

	if (fBufferGroup && fUsingOurBuffers) {
		delete fBufferGroup;
		fBufferGroup = NULL;
	}
	size_t size = format.u.raw_audio.buffer_size;
	int32 bufferDuration = BufferDuration();
	int32 count = 0;
	if (bufferDuration > 0) {
		count = (int32)((fLatency + fInternalLatency)
			/ bufferDuration + 2);
	}

	fBufferGroup = new BBufferGroup(size, count);
	fUsingOurBuffers = true;
	return fBufferGroup->InitCheck();
}


BBuffer*
AudioProducer::_FillNextBuffer(bigtime_t eventTime)
{
	fBufferGroup->WaitForBuffers();
	BBuffer* buffer = fBufferGroup->RequestBuffer(
		fOutput.format.u.raw_audio.buffer_size, BufferDuration());

	if (buffer == NULL) {
		static bool errorPrinted = false;
		if (!errorPrinted) {
			ERROR("AudioProducer::_FillNextBuffer() - no buffer "
				"(size: %" B_PRIuSIZE ", duration: %" B_PRIiBIGTIME ")\n",
				fOutput.format.u.raw_audio.buffer_size, BufferDuration());
			errorPrinted = true;
		}
		return NULL;
	}

	size_t sampleSize = fOutput.format.u.raw_audio.format
		& media_raw_audio_format::B_AUDIO_SIZE_MASK;
	size_t numSamples = fOutput.format.u.raw_audio.buffer_size / sampleSize;
		// number of sample in the buffer

	// fill in the buffer header
	media_header* header = buffer->Header();
	header->type = B_MEDIA_RAW_AUDIO;
	header->time_source = TimeSource()->ID();
	buffer->SetSizeUsed(fOutput.format.u.raw_audio.buffer_size);

	// fill in data from audio supplier
	int64 frameCount = numSamples / fOutput.format.u.raw_audio.channel_count;
	bigtime_t startTime = bigtime_t(double(fFramesSent)
		* 1000000.0 / fOutput.format.u.raw_audio.frame_rate);
	bigtime_t endTime = bigtime_t(double(fFramesSent + frameCount)
		* 1000000.0 / fOutput.format.u.raw_audio.frame_rate);

	if (fSupplier == NULL || fSupplier->InitCheck() != B_OK
		|| fSupplier->GetFrames(buffer->Data(), frameCount, startTime,
			endTime) != B_OK) {
		ERROR("AudioProducer::_FillNextBuffer() - supplier error -> silence\n");
		memset(buffer->Data(), 0, buffer->SizeUsed());
	}

	// stamp buffer
	if (RunMode() == B_RECORDING)
		header->start_time = eventTime;
	else
		header->start_time = fStartTime + startTime;

#if DEBUG_TO_FILE
	BMediaTrack* track;
	if (init_media_file(fOutput.format, &track) != NULL)
		track->WriteFrames(buffer->Data(), frameCount);
#endif // DEBUG_TO_FILE

	if (fPeakListener
		&& fOutput.format.u.raw_audio.format
			== media_raw_audio_format::B_AUDIO_FLOAT) {
		// TODO: extend the peak notifier for other sample formats
		int32 channels = fOutput.format.u.raw_audio.channel_count;
		float max[channels];
		float min[channels];
		for (int32 i = 0; i < channels; i++) {
			max[i] = -1.0;
			min[i] = 1.0;
		}
		float* sample = (float*)buffer->Data();
		for (uint32 i = 0; i < frameCount; i++) {
			for (int32 k = 0; k < channels; k++) {
				if (*sample < min[k])
					min[k] = *sample;
				if (*sample > max[k])
					max[k] = *sample;
				sample++;
			}
		}
		BMessage message(MSG_PEAK_NOTIFICATION);
		for (int32 i = 0; i < channels; i++) {
			float maxAbs = max_c(fabs(min[i]), fabs(max[i]));
			message.AddFloat("max", maxAbs);
		}
		bigtime_t realTime = TimeSource()->RealTimeFor(
			fStartTime + startTime, 0);
		MessageEvent* event = new (std::nothrow) MessageEvent(realTime,
			fPeakListener, message);
		if (event != NULL)
			EventQueue::Default().AddEvent(event);
	}

	return buffer;
}