/*
 * Copyright 2002-2010, Haiku.
 * Distributed under the terms of the MIT License.
 *
 * Authors:
 *              Marcus Overhagen
 *              Jérôme Duval
 */


/*!     This is the BBufferProducer used internally by BSoundPlayer.
*/


#include "SoundPlayNode.h"

#include <string.h>
#include <stdlib.h>
#include <unistd.h>

#include <TimeSource.h>
#include <MediaRoster.h>
#include "MediaDebug.h"


#define SEND_NEW_BUFFER_EVENT (BTimedEventQueue::B_USER_EVENT + 1)


namespace BPrivate {


SoundPlayNode::SoundPlayNode(const char* name, BSoundPlayer* player)
        :
        BMediaNode(name),
        BBufferProducer(B_MEDIA_RAW_AUDIO),
        BMediaEventLooper(),
        fPlayer(player),
        fInitStatus(B_OK),
        fOutputEnabled(true),
        fBufferGroup(NULL),
        fFramesSent(0),
        fTooEarlyCount(0)
{
        CALLED();
        fOutput.format.type = B_MEDIA_RAW_AUDIO;
        fOutput.format.u.raw_audio = media_multi_audio_format::wildcard;
}


SoundPlayNode::~SoundPlayNode()
{
        CALLED();
        Quit();
}


bool
SoundPlayNode::IsPlaying()
{
        return RunState() == B_STARTED;
}


bigtime_t
SoundPlayNode::CurrentTime()
{
        int frameRate = (int)fOutput.format.u.raw_audio.frame_rate;
        return frameRate == 0 ? 0
                : bigtime_t((1000000LL * fFramesSent) / frameRate);
}


media_multi_audio_format
SoundPlayNode::Format() const
{
        return fOutput.format.u.raw_audio;
}


// #pragma mark - implementation of BMediaNode


BMediaAddOn*
SoundPlayNode::AddOn(int32* _internalID) const
{
        CALLED();
        // This only gets called if we are in an add-on.
        return NULL;
}


void
SoundPlayNode::Preroll()
{
        CALLED();
        // TODO: Performance opportunity
        BMediaNode::Preroll();
}


status_t
SoundPlayNode::HandleMessage(int32 message, const void* data, size_t size)
{
        CALLED();
        return B_ERROR;
}


void
SoundPlayNode::NodeRegistered()
{
        CALLED();

        if (fInitStatus != B_OK) {
                ReportError(B_NODE_IN_DISTRESS);
                return;
        }

        SetPriority(B_URGENT_PRIORITY);

        fOutput.format.type = B_MEDIA_RAW_AUDIO;
        fOutput.format.u.raw_audio = media_multi_audio_format::wildcard;
        fOutput.destination = media_destination::null;
        fOutput.source.port = ControlPort();
        fOutput.source.id = 0;
        fOutput.node = Node();
        strcpy(fOutput.name, Name());

        Run();
}


status_t
SoundPlayNode::RequestCompleted(const media_request_info& info)
{
        CALLED();
        return B_OK;
}


void
SoundPlayNode::SetTimeSource(BTimeSource* timeSource)
{
        CALLED();
        BMediaNode::SetTimeSource(timeSource);
}


void
SoundPlayNode::SetRunMode(run_mode mode)
{
        TRACE("SoundPlayNode::SetRunMode mode:%i\n", mode);
        BMediaNode::SetRunMode(mode);
}


// #pragma mark - implementation for BBufferProducer


status_t
SoundPlayNode::FormatSuggestionRequested(media_type type, int32 /*quality*/,
        media_format* format)
{
        // FormatSuggestionRequested() is not necessarily part of the format
        // negotiation process; it's simply an interrogation -- the caller wants
        // to see what the node's preferred data format is, given a suggestion by
        // the caller.
        CALLED();

        // a wildcard type is okay; but we only support raw audio
        if (type != B_MEDIA_RAW_AUDIO && type != B_MEDIA_UNKNOWN_TYPE)
                return B_MEDIA_BAD_FORMAT;

        // this is the format we'll be returning (our preferred format)
        format->type = B_MEDIA_RAW_AUDIO;
        format->u.raw_audio = media_multi_audio_format::wildcard;

        return B_OK;
}


status_t
SoundPlayNode::FormatProposal(const media_source& output, media_format* format)
{
        // FormatProposal() is the first stage in the BMediaRoster::Connect()
        // process. We hand out a suggested format, with wildcards for any
        // variations we support.
        CALLED();

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

        // if wildcard, change it to raw audio
        if (format->type == B_MEDIA_UNKNOWN_TYPE)
                format->type = B_MEDIA_RAW_AUDIO;

        // if not raw audio, we can't support it
        if (format->type != B_MEDIA_RAW_AUDIO) {
                TRACE("SoundPlayNode::FormatProposal returning B_MEDIA_BAD_FORMAT\n");
                return B_MEDIA_BAD_FORMAT;
        }

#if DEBUG >0
        char buf[100];
        string_for_format(*format, buf, sizeof(buf));
        TRACE("SoundPlayNode::FormatProposal: format %s\n", buf);
#endif

        return B_OK;
}


status_t
SoundPlayNode::FormatChangeRequested(const media_source& source,
        const media_destination& destination, media_format* _format,
        int32* /* deprecated */)
{
        CALLED();

        // we don't support any other formats, so we just reject any format changes.
        return B_ERROR;
}


status_t
SoundPlayNode::GetNextOutput(int32* cookie, media_output* _output)
{
        CALLED();

        if (*cookie == 0) {
                *_output = fOutput;
                *cookie += 1;
                return B_OK;
        } else {
                return B_BAD_INDEX;
        }
}


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


status_t
SoundPlayNode::SetBufferGroup(const media_source& forSource,
        BBufferGroup* newGroup)
{
        CALLED();

        // is this our output?
        if (forSource != fOutput.source) {
                TRACE("SoundPlayNode::SetBufferGroup returning B_MEDIA_BAD_SOURCE\n");
                return B_MEDIA_BAD_SOURCE;
        }

        // Are we being passed the buffer group we're already using?
        if (newGroup == fBufferGroup)
                return B_OK;

        // Ahh, someone wants us to use a different buffer group. At this point we
        // delete the one we are using and use the specified one instead.
        // If the specified group is NULL, we need to recreate one ourselves, and
        // use *that*. Note that if we're caching a BBuffer that we requested
        // earlier, we have to Recycle() that buffer *before* deleting the buffer
        // group, otherwise we'll deadlock waiting for that buffer to be recycled!
        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;
                return B_OK;
        }

        // we were passed a NULL group pointer; that means we construct
        // our own buffer group to use from now on
        return AllocateBuffers();
}


status_t
SoundPlayNode::GetLatency(bigtime_t* _latency)
{
        CALLED();

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


status_t
SoundPlayNode::PrepareToConnect(const media_source& what,
        const media_destination& where, media_format* format,
        media_source* _source, char* _name)
{
        // PrepareToConnect() is the second stage of format negotiations that
        // happens inside BMediaRoster::Connect(). At this point, the consumer's
        // AcceptFormat() method has been called, and that node has potentially
        // changed the proposed format. It may also have left wildcards in the
        // format. PrepareToConnect() *must* fully specialize the format before
        // returning!
        CALLED();

        // is this our output?
        if (what != fOutput.source)     {
                TRACE("SoundPlayNode::PrepareToConnect returning "
                        "B_MEDIA_BAD_SOURCE\n");
                return B_MEDIA_BAD_SOURCE;
        }

        // are we already connected?
        if (fOutput.destination != media_destination::null)
                return B_MEDIA_ALREADY_CONNECTED;

        // 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 DEBUG > 0
        char buf[100];
        string_for_format(*format, buf, sizeof(buf));
        TRACE("SoundPlayNode::PrepareToConnect: input format %s\n", buf);
#endif

        // if not raw audio, we can't support it
        if (format->type != B_MEDIA_UNKNOWN_TYPE
                && format->type != B_MEDIA_RAW_AUDIO) {
                TRACE("SoundPlayNode::PrepareToConnect: non raw format, returning "
                        "B_MEDIA_BAD_FORMAT\n");
                return B_MEDIA_BAD_FORMAT;
        }

        // the haiku mixer might have a hint
        // for us, so check for it
        #define FORMAT_USER_DATA_TYPE           0x7294a8f3
        #define FORMAT_USER_DATA_MAGIC_1        0xc84173bd
        #define FORMAT_USER_DATA_MAGIC_2        0x4af62b7d
        uint32 channel_count = 0;
        float frame_rate = 0;
        if (format->user_data_type == FORMAT_USER_DATA_TYPE
                && *(uint32 *)&format->user_data[0] == FORMAT_USER_DATA_MAGIC_1
                && *(uint32 *)&format->user_data[44] == FORMAT_USER_DATA_MAGIC_2) {
                channel_count = *(uint32 *)&format->user_data[4];
                frame_rate = *(float *)&format->user_data[20];
                TRACE("SoundPlayNode::PrepareToConnect: found mixer info: "
                        "channel_count %" B_PRId32 " , frame_rate %.1f\n", channel_count, frame_rate);
        }

        media_format default_format;
        default_format.type = B_MEDIA_RAW_AUDIO;
        default_format.u.raw_audio.frame_rate = frame_rate > 0 ? frame_rate : 44100;
        default_format.u.raw_audio.channel_count = channel_count > 0
                ? channel_count : 2;
        default_format.u.raw_audio.format = media_raw_audio_format::B_AUDIO_FLOAT;
        default_format.u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
        default_format.u.raw_audio.buffer_size = 0;
        format->SpecializeTo(&default_format);

        if (format->u.raw_audio.buffer_size == 0) {
                format->u.raw_audio.buffer_size
                        = BMediaRoster::Roster()->AudioBufferSizeFor(
                                format->u.raw_audio.channel_count, format->u.raw_audio.format,
                                format->u.raw_audio.frame_rate);
        }

#if DEBUG > 0
        string_for_format(*format, buf, sizeof(buf));
        TRACE("SoundPlayNode::PrepareToConnect: output format %s\n", buf);
#endif

        // Now reserve the connection, and return information about it
        fOutput.destination = where;
        fOutput.format = *format;
        *_source = fOutput.source;
        strcpy(_name, Name());
        return B_OK;
}


void
SoundPlayNode::Connect(status_t error, const media_source& source,
        const media_destination& destination, const media_format& format,
        char* name)
{
        CALLED();

        // is this our output?
        if (source != fOutput.source) {
                TRACE("SoundPlayNode::Connect returning\n");
                return;
        }

        // 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) {
                fOutput.destination = media_destination::null;
                fOutput.format.type = B_MEDIA_RAW_AUDIO;
                fOutput.format.u.raw_audio = media_multi_audio_format::wildcard;
                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;
        strcpy(name, Name());

        // 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);
        TRACE("SoundPlayNode::Connect: downstream latency = %" B_PRId64 "\n",
                fLatency);

        // reset our buffer duration, etc. to avoid later calculations
        bigtime_t duration = ((fOutput.format.u.raw_audio.buffer_size * 1000000LL)
                / ((fOutput.format.u.raw_audio.format
                                & media_raw_audio_format::B_AUDIO_SIZE_MASK)
                        * fOutput.format.u.raw_audio.channel_count))
                / (int32)fOutput.format.u.raw_audio.frame_rate;
        SetBufferDuration(duration);
        TRACE("SoundPlayNode::Connect: buffer duration is %" B_PRId64 "\n",
                duration);

        fInternalLatency = (3 * BufferDuration()) / 4;
        TRACE("SoundPlayNode::Connect: using %" B_PRId64 " as internal latency\n",
                fInternalLatency);
        SetEventLatency(fLatency + fInternalLatency);

        // 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)
                AllocateBuffers();
}


void
SoundPlayNode::Disconnect(const media_source& what,
        const media_destination& where)
{
        CALLED();

        // is this our output?
        if (what != fOutput.source) {
                TRACE("SoundPlayNode::Disconnect returning\n");
                return;
        }

        // Make sure that our connection is the one being disconnected
        if (where == fOutput.destination && what == fOutput.source) {
                fOutput.destination = media_destination::null;
                fOutput.format.type = B_MEDIA_RAW_AUDIO;
                fOutput.format.u.raw_audio = media_multi_audio_format::wildcard;
                delete fBufferGroup;
                fBufferGroup = NULL;
        } else {
                fprintf(stderr, "\tDisconnect() called with wrong source/destination "
                        "(%" B_PRId32 "/%" B_PRId32 "), ours is (%" B_PRId32 "/%" B_PRId32
                        ")\n", what.id, where.id, fOutput.source.id,
                        fOutput.destination.id);
        }
}


void
SoundPlayNode::LateNoticeReceived(const media_source& what, bigtime_t howMuch,
        bigtime_t performanceTime)
{
        CALLED();

        TRACE("SoundPlayNode::LateNoticeReceived, %" B_PRId64 " too late at %"
                B_PRId64 "\n", howMuch, performanceTime);

        // is this our output?
        if (what != fOutput.source) {
                TRACE("SoundPlayNode::LateNoticeReceived returning\n");
                return;
        }

        if (RunMode() != B_DROP_DATA) {
                // We're late, and our run mode dictates that we try to produce buffers
                // earlier in order to catch up.  This argues that the downstream nodes are
                // not properly reporting their latency, but there's not much we can do about
                // that at the moment, so we try to start producing buffers earlier to
                // compensate.

                fInternalLatency += howMuch;

                if (fInternalLatency > 30000)   // avoid getting a too high latency
                        fInternalLatency = 30000;

                SetEventLatency(fLatency + fInternalLatency);
                TRACE("SoundPlayNode::LateNoticeReceived: increasing latency to %"
                        B_PRId64 "\n", fLatency + fInternalLatency);
        } else {
                // The other run modes dictate various strategies for sacrificing data quality
                // in the interests of timely data delivery.  The way *we* do this is to skip
                // a buffer, which catches us up in time by one buffer duration.

                size_t nFrames = fOutput.format.u.raw_audio.buffer_size
                        / ((fOutput.format.u.raw_audio.format & media_raw_audio_format::B_AUDIO_SIZE_MASK)
                        * fOutput.format.u.raw_audio.channel_count);

                fFramesSent += nFrames;

                TRACE("SoundPlayNode::LateNoticeReceived: skipping a buffer to try to catch up\n");
        }
}


void
SoundPlayNode::EnableOutput(const media_source& what, bool enabled,
        int32* /* deprecated */)
{
        CALLED();

        // If I had more than one output, I'd have to walk my list of output
        // records to see which one matched the given source, and then
        // enable/disable that one.
        // But this node only has one output, so I just make sure the given source
        // matches, then set the enable state accordingly.

        // is this our output?
        if (what != fOutput.source) {
                fprintf(stderr, "SoundPlayNode::EnableOutput returning\n");
                return;
        }

        fOutputEnabled = enabled;
}


void
SoundPlayNode::AdditionalBufferRequested(const media_source& source,
        media_buffer_id previousBuffer, bigtime_t previousTime,
        const media_seek_tag* previousTag)
{
        CALLED();
        // we don't support offline mode
        return;
}


void
SoundPlayNode::LatencyChanged(const media_source& source,
        const media_destination& destination, bigtime_t newLatency, uint32 flags)
{
        CALLED();

        TRACE("SoundPlayNode::LatencyChanged: new_latency %" B_PRId64 "\n",
                newLatency);

        // something downstream changed latency, so we need to start producing
        // buffers earlier (or later) than we were previously.  Make sure that the
        // connection that changed is ours, and adjust to the new downstream
        // latency if so.
        if (source == fOutput.source && destination == fOutput.destination) {
                fLatency = newLatency;
                SetEventLatency(fLatency + fInternalLatency);
        } else {
                TRACE("SoundPlayNode::LatencyChanged: ignored\n");
        }
}


// #pragma mark - implementation for BMediaEventLooper


void
SoundPlayNode::HandleEvent(const media_timed_event* event, bigtime_t lateness,
        bool realTimeEvent)
{
        CALLED();
        switch (event->type) {
                case BTimedEventQueue::B_START:
                        HandleStart(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_SEEK:
                        HandleSeek(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_WARP:
                        HandleWarp(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_STOP:
                        HandleStop(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_HANDLE_BUFFER:
                        // we don't get any buffers
                        break;
                case SEND_NEW_BUFFER_EVENT:
                        if (RunState() == BMediaEventLooper::B_STARTED)
                                SendNewBuffer(event, lateness, realTimeEvent);
                        break;
                case BTimedEventQueue::B_DATA_STATUS:
                        HandleDataStatus(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_PARAMETER:
                        HandleParameter(event,lateness,realTimeEvent);
                        break;
                default:
                        fprintf(stderr," unknown event type: %" B_PRId32 "\n", event->type);
                        break;
        }
}


// #pragma mark - protected methods


// how should we handle late buffers?  drop them?
// notify the producer?
status_t
SoundPlayNode::SendNewBuffer(const media_timed_event* event,
        bigtime_t lateness, bool realTimeEvent)
{
        CALLED();
        // TRACE("latency = %12Ld, event = %12Ld, sched = %5Ld, arrive at %12Ld, now %12Ld, current lateness %12Ld\n", EventLatency() + SchedulingLatency(), EventLatency(), SchedulingLatency(), event->event_time, TimeSource()->Now(), lateness);

        // make sure we're both started *and* connected before delivering a buffer
        if (RunState() != BMediaEventLooper::B_STARTED
                || fOutput.destination == media_destination::null)
                return B_OK;

        // The event->event_time is the time at which the buffer we are preparing
        // here should arrive at it's destination. The MediaEventLooper should have
        // scheduled us early enough (based on EventLatency() and the
        // SchedulingLatency()) to make this possible.
        // lateness is independent of EventLatency()!

        if (lateness > (BufferDuration() / 3) ) {
                TRACE("SoundPlayNode::SendNewBuffer, event scheduled much too late, "
                        "lateness is %" B_PRId64 "\n", lateness);
        }

        // skip buffer creation if output not enabled
        if (fOutputEnabled) {

                // Get the next buffer of data
                BBuffer* buffer = FillNextBuffer(event->event_time);

                if (buffer) {

                        // If we are ready way too early, decrase internal latency
/*
                        bigtime_t how_early = event->event_time - TimeSource()->Now() - fLatency - fInternalLatency;
                        if (how_early > 5000) {

                                TRACE("SoundPlayNode::SendNewBuffer, event scheduled too early, how_early is %lld\n", how_early);

                                if (fTooEarlyCount++ == 5) {
                                        fInternalLatency -= how_early;
                                        if (fInternalLatency < 500)
                                                fInternalLatency = 500;
                                        TRACE("SoundPlayNode::SendNewBuffer setting internal latency to %lld\n", fInternalLatency);
                                        SetEventLatency(fLatency + fInternalLatency);
                                        fTooEarlyCount = 0;
                                }
                        }
*/
                        // send the buffer downstream if and only if output is enabled
                        if (SendBuffer(buffer, fOutput.source, fOutput.destination)
                                        != B_OK) {
                                // we need to recycle the buffer
                                // if the call to SendBuffer() fails
                                TRACE("SoundPlayNode::SendNewBuffer: Buffer sending "
                                        "failed\n");
                                buffer->Recycle();
                        }
                }
        }

        // track how much media we've delivered so far
        size_t nFrames = fOutput.format.u.raw_audio.buffer_size
                / ((fOutput.format.u.raw_audio.format
                        & media_raw_audio_format::B_AUDIO_SIZE_MASK)
                * fOutput.format.u.raw_audio.channel_count);
        fFramesSent += nFrames;

        // The buffer is on its way; now schedule the next one to go
        // nextEvent is the time at which the buffer should arrive at it's
        // destination
        bigtime_t nextEvent = fStartTime + bigtime_t((1000000LL * fFramesSent)
                / (int32)fOutput.format.u.raw_audio.frame_rate);
        media_timed_event nextBufferEvent(nextEvent, SEND_NEW_BUFFER_EVENT);
        EventQueue()->AddEvent(nextBufferEvent);

        return B_OK;
}


status_t
SoundPlayNode::HandleDataStatus(const media_timed_event* event,
        bigtime_t lateness, bool realTimeEvent)
{
        TRACE("SoundPlayNode::HandleDataStatus status: %" B_PRId32 ", lateness: %"
                B_PRId64 "\n", event->data, lateness);

        switch (event->data) {
                case B_DATA_NOT_AVAILABLE:
                        break;
                case B_DATA_AVAILABLE:
                        break;
                case B_PRODUCER_STOPPED:
                        break;
                default:
                        break;
        }
        return B_OK;
}


status_t
SoundPlayNode::HandleStart(const media_timed_event* event, bigtime_t lateness,
        bool realTimeEvent)
{
        CALLED();
        // don't do anything if we're already running
        if (RunState() != B_STARTED) {
                // We want to start sending buffers now, so we set up the buffer-sending
                // bookkeeping and fire off the first "produce a buffer" event.

                fFramesSent = 0;
                fStartTime = event->event_time;
                media_timed_event firstBufferEvent(event->event_time,
                        SEND_NEW_BUFFER_EVENT);

                // Alternatively, we could call HandleEvent() directly with this event,
                // to avoid a trip through the event queue, like this:
                //
                //              this->HandleEvent(&firstBufferEvent, 0, false);
                //
                EventQueue()->AddEvent(firstBufferEvent);
        }
        return B_OK;
}


status_t
SoundPlayNode::HandleSeek(const media_timed_event* event, bigtime_t lateness,
        bool realTimeEvent)
{
        CALLED();
        TRACE("SoundPlayNode::HandleSeek(t=%" B_PRId64 ", d=%" B_PRId32 ", bd=%"
                B_PRId64 ")\n", event->event_time, event->data, event->bigdata);
        return B_OK;
}


status_t
SoundPlayNode::HandleWarp(const media_timed_event* event, bigtime_t lateness,
        bool realTimeEvent)
{
        CALLED();
        return B_OK;
}


status_t
SoundPlayNode::HandleStop(const media_timed_event* event, bigtime_t lateness,
        bool realTimeEvent)
{
        CALLED();
        // flush the queue so downstreamers don't get any more
        EventQueue()->FlushEvents(0, BTimedEventQueue::B_ALWAYS, true,
                SEND_NEW_BUFFER_EVENT);

        return B_OK;
}


status_t
SoundPlayNode::HandleParameter(const media_timed_event* event,
        bigtime_t lateness, bool realTimeEvent)
{
        CALLED();
        return B_OK;
}


status_t
SoundPlayNode::AllocateBuffers()
{
        CALLED();

        // allocate enough buffers to span our downstream latency, plus one
        size_t size = fOutput.format.u.raw_audio.buffer_size;
        int32 count = int32(fLatency / BufferDuration() + 1 + 1);

        TRACE("SoundPlayNode::AllocateBuffers: latency = %" B_PRId64 ", buffer "
                "duration = %" B_PRId64 ", count %" B_PRId32 "\n", fLatency,
                BufferDuration(), count);

        if (count < 3)
                count = 3;

        TRACE("SoundPlayNode::AllocateBuffers: creating group of %" B_PRId32
                " buffers, size = %" B_PRIuSIZE "\n", count, size);

        fBufferGroup = new BBufferGroup(size, count);
        if (fBufferGroup->InitCheck() != B_OK) {
                ERROR("SoundPlayNode::AllocateBuffers: BufferGroup::InitCheck() "
                        "failed\n");
        }

        return fBufferGroup->InitCheck();
}


BBuffer*
SoundPlayNode::FillNextBuffer(bigtime_t eventTime)
{
        CALLED();

        // get a buffer from our buffer group
        BBuffer* buffer = fBufferGroup->RequestBuffer(
                fOutput.format.u.raw_audio.buffer_size, BufferDuration() / 2);

        // If we fail to get a buffer (for example, if the request times out), we
        // skip this buffer and go on to the next, to avoid locking up the control
        // thread
        if (buffer == NULL) {
                ERROR("SoundPlayNode::FillNextBuffer: RequestBuffer failed\n");
                return NULL;
        }

        if (fPlayer->HasData()) {
                fPlayer->PlayBuffer(buffer->Data(),
                        fOutput.format.u.raw_audio.buffer_size, fOutput.format.u.raw_audio);
        } else
                memset(buffer->Data(), 0, fOutput.format.u.raw_audio.buffer_size);

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

        return buffer;
}


}       // namespace BPrivate