/*

HaikuAudio.cpp:

Haiku real-time audio handling for Csound5

Copyright (C) 2012-2019 Peter J. Goodeve

This file is part of Csound.

The Csound Library is free software; you can redistribute it

and/or modify it under the terms of the GNU Lesser General Public

License as published by the Free Software Foundation; either

version 2.1 of the License, or (at your option) any later version.

Csound 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 Lesser General Public License for more details.

You should have received a copy of the GNU Lesser General Public

License along with Csound; if not, write to the Free Software

Foundation, Inc., 31 Milk Street, #960789, Boston, MA, 02196, USA

*/

#include <string.h>

#include <stdio.h>

#include <stdlib.h>

#include <math.h>

#include <media/BufferGroup.h>

#include <media/Buffer.h>

#include <media/TimeSource.h>

#include <media/MediaDefs.h>

#include <media/MediaRoster.h>

#include <media/BufferProducer.h>

#include <media/MediaEventLooper.h>

#include "haiku_audio.h"

#define XDPRINTF(x)

#define DPRINTF(x)

//#define DPRINTF(x) printf x

// ----------------

// A few global settings for convenience:

// change this to alter default

static BMediaNode::run_mode gRunMode = BMediaNode::B_RECORDING;

/// These have been kept for now:

static size_t gBufferSize = 1024; // specified by default

static bigtime_t gAddLatency = 0; // Added to computed latency

static int gXtraBuffers = 0;

///////////////////////////////////////////////////////////////////

class AudioProducer : public BBufferProducer,

public BMediaEventLooper

{

public:

AudioProducer(struct Generator *_gen, float sampleRate,

int nchans, size_t bufferSize);

~AudioProducer();

/// BMediaNode abstract method instantiation:

BMediaAddOn* AddOn( int32* internal_id) const {return NULL;}

/// BBufferProducer inheritance:

// Abstract method instantiations:

status_t FormatSuggestionRequested(

media_type type,

int32 quality,

media_format* format);

status_t FormatProposal(

const media_source& output,

media_format* format);

status_t FormatChangeRequested(

const media_source& source,

const media_destination& destination,

media_format* io_format,

int32* _deprecated_) {return B_ERROR;}

status_t GetNextOutput( /* cookie starts as 0 */

int32* cookie,

media_output* out_output);

status_t DisposeOutputCookie(int32 cookie) {return B_OK;}

status_t SetBufferGroup(

const media_source& for_source,

BBufferGroup* group);

status_t PrepareToConnect(

const media_source& what,

const media_destination& where,

media_format* format,

media_source* out_source,

char* out_name);

void Connect(

status_t error,

const media_source& source,

const media_destination& destination,

const media_format& format,

char* io_name);

void Disconnect(

const media_source& what,

const media_destination& where);

void LateNoticeReceived(

const media_source& what,

bigtime_t how_much,

bigtime_t performance_time);

void EnableOutput(

const media_source & what,

bool enabled,

int32* _deprecated_);

/// End of BBufferProducer Abstract instantiations ///

status_t GetLatency(

bigtime_t* out_latency);

status_t HandleMessage(

int32 message,

const void* data,

size_t size);

void LatencyChanged(

const media_source& source,

const media_destination& destination,

bigtime_t new_latency,

uint32 flags);

/// BMediaLooper inheritance:

/// Abstract instantiation:

void HandleEvent(

const media_timed_event* event,

bigtime_t lateness,

bool realTimeEvent = false);

////////////////////////////////////////

void NodeRegistered();

void Start(bigtime_t performance_time);

void SetRunMode(run_mode mode);

private:

void AllocateBuffers();

BBuffer* FillNextBuffer(bigtime_t event_time);

Generator *gen;

BBufferGroup* mBufferGroup;

bigtime_t mLatency, mInternalLatency;

media_output mOutput;

bool mOutputEnabled;

media_format mPreferredFormat;

size_t mBufferSize;

BMediaNode::run_mode mRunMode;

int mChans;

uint64 mSamplesSent;

bigtime_t mStartTime;

};

////////////////////////////////////////////////////////////////

AudioProducer::AudioProducer(Generator *_gen, float sampleRate,

int nchans, size_t bufferSize)

: BMediaNode("Csound"),

BBufferProducer(B_MEDIA_RAW_AUDIO),

BMediaEventLooper(),

gen(_gen),

mBufferGroup(NULL),

mLatency(0),

mInternalLatency(0),

mOutputEnabled(true),

mBufferSize(bufferSize),

mRunMode(gRunMode),

mChans(nchans)

{

mPreferredFormat.type = B_MEDIA_RAW_AUDIO;

mPreferredFormat.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;

mPreferredFormat.u.raw_audio.channel_count = mChans;

mPreferredFormat.u.raw_audio.frame_rate = sampleRate; // measured in Hertz

mPreferredFormat.u.raw_audio.byte_order =

(B_HOST_IS_BENDIAN) ? B_MEDIA_BIG_ENDIAN : B_MEDIA_LITTLE_ENDIAN;

if (mBufferSize)

mPreferredFormat.u.raw_audio.buffer_size = mBufferSize;

else

mPreferredFormat.u.raw_audio.buffer_size

= media_raw_audio_format::wildcard.buffer_size;

mOutput.destination = media_destination::null;

mOutput.format = mPreferredFormat;

}

AudioProducer::~AudioProducer()

{

Quit();

}

status_t

AudioProducer::FormatSuggestionRequested(media_type type, int32 /*quality*/,

media_format* format)

{

if (!format) return B_BAD_VALUE;

*format = mPreferredFormat;

if (type == B_MEDIA_UNKNOWN_TYPE) type = B_MEDIA_RAW_AUDIO;

if (type != B_MEDIA_RAW_AUDIO) return B_MEDIA_BAD_FORMAT;

else return B_OK;

}

status_t

AudioProducer::FormatProposal(const media_source& output, media_format* format)

{

if (output != mOutput.source)

return B_MEDIA_BAD_SOURCE;

media_type requestedType = format->type;

*format = mPreferredFormat;

if ((requestedType != B_MEDIA_UNKNOWN_TYPE) &&

(requestedType != B_MEDIA_RAW_AUDIO))

return B_MEDIA_BAD_FORMAT;

else return B_OK; // raw audio or wildcard type, either is okay by us

}

status_t

AudioProducer::GetNextOutput(int32* cookie, media_output* out_output)

{

if (0 == *cookie)

{

*out_output = mOutput;

*cookie += 1;

return B_OK;

}

else return B_BAD_INDEX;

}

status_t

AudioProducer::SetBufferGroup(const media_source& for_source,

BBufferGroup* newGroup)

{

if (for_source != mOutput.source) return B_MEDIA_BAD_SOURCE;

if (newGroup == mBufferGroup) return B_OK;

delete mBufferGroup; // waits for all buffers to recycle

if (newGroup != NULL)

mBufferGroup = newGroup;

else

{

size_t size = mOutput.format.u.raw_audio.buffer_size;

int32 count =

int32(mLatency / BufferDuration() + 1 + 1 + gXtraBuffers);

mBufferGroup = new BBufferGroup(size, count);

}

return B_OK;

}

status_t

AudioProducer::GetLatency(bigtime_t* out_latency)

{

*out_latency = EventLatency() + SchedulingLatency();

return B_OK;

}

status_t

AudioProducer::PrepareToConnect(const media_source& what,

const media_destination& where,

media_format* format, media_source* out_source,

char* out_name)

{

if (what != mOutput.source) return B_MEDIA_BAD_SOURCE;

if (mOutput.destination != media_destination::null)

return B_MEDIA_ALREADY_CONNECTED;

if (format->type != B_MEDIA_RAW_AUDIO)

return B_MEDIA_BAD_FORMAT;

else if (format->u.raw_audio.format !=

media_raw_audio_format::B_AUDIO_FLOAT)

return B_MEDIA_BAD_FORMAT;

if (format->u.raw_audio.buffer_size ==

media_raw_audio_format::wildcard.buffer_size)

format->u.raw_audio.buffer_size = mBufferSize;

mOutput.destination = where;

mOutput.format = *format;

*out_source = mOutput.source;

strncpy(out_name, mOutput.name, B_MEDIA_NAME_LENGTH);

return B_OK;

}

void

AudioProducer::Connect(status_t error, const media_source& source,

const media_destination& destination,

const media_format& format, char* io_name)

{

if (error)

{

mOutput.destination = media_destination::null;

mOutput.format = mPreferredFormat;

return;

}

mOutput.destination = destination;

mOutput.format = format;

strncpy(io_name, mOutput.name, B_MEDIA_NAME_LENGTH);

media_node_id id;

FindLatencyFor(mOutput.destination, &mLatency, &id);

size_t samplesPerBuffer

= mOutput.format.u.raw_audio.buffer_size / (sizeof(float)*mChans);

SetEventLatency(mLatency + gAddLatency); // ignore internal time for now

{

bigtime_t realtime, perftime;

float drift;

TimeSource()->GetTime(&perftime, &realtime, & drift);

}

bigtime_t duration

= bigtime_t(1000000) * samplesPerBuffer /

bigtime_t(mOutput.format.u.raw_audio.frame_rate);

SetBufferDuration(duration);

if (!mBufferGroup) AllocateBuffers();

}

void

AudioProducer::Disconnect(const media_source& what, const media_destination& where)

{

DPRINTF(("trying to disconnect AudioProducer\n");)

if ((where == mOutput.destination) && (what == mOutput.source))

{

mOutput.destination = media_destination::null;

mOutput.format = mPreferredFormat;

delete mBufferGroup;

mBufferGroup = NULL;

}

}

void

AudioProducer::LateNoticeReceived(const media_source& what, bigtime_t how_much,

bigtime_t performance_time)

{

if (what == mOutput.source)

{

if (RunMode() == B_RECORDING)

{

// nothing to do

}

else if (RunMode() == B_INCREASE_LATENCY)

{

mInternalLatency += how_much;

SetEventLatency(mLatency + mInternalLatency);

}

else

{

size_t nSamples

= mOutput.format.u.raw_audio.buffer_size /

(sizeof(float)*mChans);

mSamplesSent += nSamples;

}

}

}

void

AudioProducer::EnableOutput(const media_source& what, bool enabled,

int32* _deprecated_)

{

if (what == mOutput.source)

mOutputEnabled = enabled;

}

status_t

AudioProducer::HandleMessage(int32 message, const void* data, size_t size)

{

return B_ERROR;

}

void

AudioProducer::LatencyChanged(const media_source& source,

const media_destination& destination,

bigtime_t new_latency, uint32 flags)

{

if ((source == mOutput.source) && (destination == mOutput.destination))

{

mLatency = new_latency;

SetEventLatency(mLatency + mInternalLatency);

}

}

void

AudioProducer::NodeRegistered()

{

SetPriority(B_REAL_TIME_PRIORITY);

Run();

mOutput.source.port = ControlPort();

mOutput.source.id = 0;

mOutput.node = Node();

::strcpy(mOutput.name, "Csound Output");

}

void

AudioProducer::Start(bigtime_t performance_time)

{

BMediaRoster::Roster()->SetRunModeNode(Node(), mRunMode);

BMediaEventLooper::Start(performance_time);

}

void

AudioProducer::SetRunMode(run_mode mode)

{

if (B_OFFLINE == mode)

ReportError(B_NODE_FAILED_SET_RUN_MODE);

}

void

AudioProducer::HandleEvent(const media_timed_event* event,

bigtime_t lateness, bool realTimeEvent)

{

switch (event->type)

{

case BTimedEventQueue::B_START:

if (RunState() != B_STARTED)

{

mSamplesSent = 0;

mStartTime = event->event_time;

media_timed_event

firstBufferEvent(mStartTime,

BTimedEventQueue::B_HANDLE_BUFFER);

EventQueue()->AddEvent(firstBufferEvent);

}

break;

case BTimedEventQueue::B_STOP:

DPRINTF(("Stop event arrived\n");)

EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS,

true, BTimedEventQueue::B_HANDLE_BUFFER);

break;

case BTimedEventQueue::B_HANDLE_BUFFER:

{

if ((RunState() == BMediaEventLooper::B_STARTED)

&& (mOutput.destination != media_destination::null))

{

BBuffer* buffer = FillNextBuffer(event->event_time);

if (buffer)

{

status_t err = B_ERROR;

if (mOutputEnabled)

err = SendBuffer(buffer, mOutput.source,

mOutput.destination);

if (err) buffer->Recycle();

}

size_t nSamples =

mOutput.format.u.raw_audio.buffer_size /

(sizeof(float)*mChans);

mSamplesSent += nSamples;

bigtime_t nextEvent = mStartTime +

bigtime_t(cs_double(mSamplesSent) /

cs_double(mOutput.format.u.raw_audio.frame_rate)

* 1000000.0);

media_timed_event

nextBufferEvent(nextEvent,

BTimedEventQueue::B_HANDLE_BUFFER);

EventQueue()->AddEvent(nextBufferEvent);

}

}

break;

default:

break;

}

}

void

AudioProducer::AllocateBuffers()

{

size_t size = mOutput.format.u.raw_audio.buffer_size;

int32 count = int32(mLatency / BufferDuration() + 1 + 1 + gXtraBuffers);

mBufferGroup = new BBufferGroup(size, count);

}

static int nclr = 0;

BBuffer*

AudioProducer::FillNextBuffer(bigtime_t event_time)

{

BBuffer* buf =

mBufferGroup->RequestBuffer(mOutput.format.u.raw_audio.buffer_size,

BufferDuration());

if (!buf) {

DPRINTF(("Couldn't get buffer!\n");)

return NULL;

}

// number of samples (not frames) to be copied

int32 numSamples = gen->mXferSize / gen->mSampleSize;

float* data = (float*) buf->Data();

if (gen->mDataBuf) {

for (int32 indx=0; indx < numSamples; indx++)

*data++ = (float)gen->mDataBuf[indx];

gen->mDataBuf = NULL;

release_sem(gen->cs_sem);

} else {// I guess we've finished, so clear the buffers

memset(data, 0, mOutput.format.u.raw_audio.buffer_size);

DPRINTF(("cleared buffer %d\n", ++nclr);)

}

media_header* hdr = buf->Header();

hdr->type = B_MEDIA_RAW_AUDIO;

hdr->size_used = mOutput.format.u.raw_audio.buffer_size;

hdr->time_source = TimeSource()->ID();

bigtime_t stamp;

if (RunMode() == B_RECORDING)

stamp = event_time;

else

stamp = mStartTime + bigtime_t(cs_double(mSamplesSent) /

cs_double(mOutput.format.u.raw_audio.frame_rate) * 1000000.0);

hdr->start_time = stamp;

return buf;

}

///////////////////////////////////////////////////

struct Generator_Private {

media_node producer, consumer;

media_source source;

media_destination destination;

media_format format;

class AudioProducer* mAudioNode;

bool mIsConnected;

bool mIsRunning;

media_node mTimeSource;

};

static void ErrorCheck(status_t err, const char* msg)

{

if (err)

{

fprintf(stderr, "* FATAL ERROR (%s): %s\n", strerror(err), msg);

exit(1);

}

}

Generator::Generator(float sampleRate, int nchans, size_t bufferSize,

int32 sampleSize) :

mBufSize(bufferSize),

mFrameRate(sampleRate),

mChans(nchans),

mSampleSize(sampleSize),

mDataBuf(NULL),

mXferSize(mBufSize),

state(new Generator_Private())

{

cs_sem = create_sem(0, "Csound_wait"); // intially locked

}

Generator::~Generator()

{

BMediaRoster* r = BMediaRoster::Roster();

status_t err;

DPRINTF(("destructing Generator\n");)

if (state->mIsRunning) {

DPRINTF(("stopping producer node\n");)

err = r->StopNode(state->producer, 0, true);

if (err)

{

fprintf(stderr, "* Error stopping producer: %ld (%s)\n",

err, strerror(err));

}

}

if (state->mIsConnected)

{

DPRINTF(("disconnecting Generator\n");)

err = r->Disconnect(state->producer.node, state->source,

state->consumer.node, state->destination);

if (err)

{

fprintf(stderr, "* Error disconnecting nodes: %ld (%s)\n",

err, strerror(err));

}

DPRINTF(("releasing nodes\n");)

r->ReleaseNode(state->producer);

r->ReleaseNode(state->consumer);

delete state->mAudioNode;

}

DPRINTF(("Generator destructed\n");)

}

int Generator::RunAudio() {

status_t err;

BMediaRoster* r = BMediaRoster::Roster();

state->mAudioNode = new AudioProducer(this, mFrameRate, mChans, mBufSize);

err = r->RegisterNode(state->mAudioNode);

ErrorCheck(err, "unable to register Csound node!\n");

r->GetNodeFor(state->mAudioNode->Node().node, &state->producer);

err = r->GetAudioMixer(&state->consumer);

ErrorCheck(err, "unable to get the system mixer");

r->GetTimeSource(&state->mTimeSource);

r->SetTimeSourceFor(state->producer.node, state->mTimeSource.node);

media_input mixerInput;

media_output soundOutput;

int32 count = 1;

err = r->GetFreeOutputsFor(state->producer, &soundOutput, 1, &count);

ErrorCheck(err, "unable to get a free output from the producer node");

count = 1;

err = r->GetFreeInputsFor(state->consumer, &mixerInput, 1, &count);

ErrorCheck(err, "unable to get a free input to the mixer");

media_format format;

format.type = B_MEDIA_RAW_AUDIO;

format.u.raw_audio = media_raw_audio_format::wildcard;

err = r->Connect(soundOutput.source, mixerInput.destination,

&format, &soundOutput, &mixerInput);

ErrorCheck(err, "unable to connect nodes");

state->format = format;

state->source = soundOutput.source;

state->destination = mixerInput.destination;

state->mIsConnected = true;

r->SetRunModeNode(state->producer, gRunMode);

BTimeSource* ts = r->MakeTimeSourceFor(state->producer);

if (!ts)

{

fprintf(stderr,

"* ERROR - MakeTimeSourceFor(producer) returned NULL!\n");

exit(1);

}

bigtime_t latency = 0;

r->GetLatencyFor(state->producer, &latency);

r->StartNode(state->producer, ts->Now() + latency);

ts->Release();

state->mIsRunning = true;

return 0; // always for now...

}