/*
 * Copyright (c) 2015, Dario Casalinuovo
 * Copyright (c) 2002, 2003 Marcus Overhagen <Marcus@Overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person obtaining
 * a copy of this software and associated documentation files or portions
 * thereof (the "Software"), to deal in the Software without restriction,
 * including without limitation the rights to use, copy, modify, merge,
 * publish, distribute, sublicense, and/or sell copies of the Software,
 * and to permit persons to whom the Software is furnished to do so, subject
 * to the following conditions:
 *
 *  * Redistributions of source code must retain the above copyright notice,
 *    this list of conditions and the following disclaimer.
 *
 *  * Redistributions in binary form must reproduce the above copyright notice
 *    in the  binary, as well as this list of conditions and the following
 *    disclaimer in the documentation and/or other materials provided with
 *    the distribution.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
 * OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
 * THE SOFTWARE.
 *
 */


#include <BufferConsumer.h>
#include <BufferProducer.h>
#include <Controllable.h>
#include <FileInterface.h>
#include <MediaRoster.h>
#include <MediaNode.h>
#include <SupportDefs.h>
#include <TimeSource.h>

#include <string.h>

#include "DataExchange.h"
#include "MediaDebug.h"
#include "MediaMisc.h"
#include "MediaRosterEx.h"
#include "Notifications.h"
#include "ServerInterface.h"
#include "TimeSourceObject.h"
#include "TimeSourceObjectManager.h"

using std::nothrow;
using std::nothrow_t;

#undef TRACE
//#define TRACE_MEDIA_NODE
#ifdef TRACE_MEDIA_NODE
  #define TRACE printf
#else
  #define TRACE(x...)
#endif

// Don't rename this one, it's used and exported for binary compatibility
int32 BMediaNode::_m_changeTag = 0;

// media_node

const media_node media_node::null;

media_node::media_node()
        :
        node(-1),
        port(-1),
        kind(0)
{
}


media_node::~media_node()
{
}

// media_input

media_input::media_input()
{
        name[0] = '\0';
}


media_input::~media_input()
{
}

// media_output

media_output::media_output()
{
        name[0] = '\0';
}


media_output::~media_output()
{
}

// live_node_info

live_node_info::live_node_info()
        :
        hint_point(0.0f, 0.0f)
{
        name[0] = '\0';
}


live_node_info::~live_node_info()
{
}

// BMediaNode

BMediaNode::~BMediaNode()
{
        CALLED();
        // BeBook: UnregisterNode() unregisters a node from the Media Server.
        // It's called automatically by the BMediaNode destructor, but it might
        // be convenient to call it sometime before you delete your node instance,
        // depending on your implementation and circumstances.

        // First we remove the time source
        if (fTimeSource) {
                fTimeSource->RemoveMe(this);
                fTimeSource->Release();
                fTimeSource = NULL;
        }

        // Attention! We do not delete their control ports, since they are only a
        // shadow object, and the real one still exists
        if ((fKinds & NODE_KIND_SHADOW_TIMESOURCE) == 0) {
                if (fControlPort > 0)
                        delete_port(fControlPort);
        } else {
                TRACE("BMediaNode::~BMediaNode: shadow timesource,"
                        " not unregistering\n");
        }
}


BMediaNode*
BMediaNode::Acquire()
{
        CALLED();
        if (atomic_add(&fRefCount,1) == 0) {
                status_t status = B_ERROR;
                BMediaRoster* roster = BMediaRoster::Roster(&status);
                if (roster != NULL && status == B_OK)
                        MediaRosterEx(roster)->RegisterLocalNode(this);
        }
        return this;
}


BMediaNode*
BMediaNode::Release()
{
        CALLED();
        if (atomic_add(&fRefCount, -1) == 1) {
                status_t status = B_ERROR;
                BMediaRoster* roster = BMediaRoster::Roster(&status);
                if (roster != NULL && status == B_OK) {
                        MediaRosterEx(roster)->UnregisterLocalNode(this);

                        // Only addons needs the configuration to be saved.
                        int32 id;
                        if (AddOn(&id) != NULL) {
                                TRACE("BMediaNode::Release() saving node %" B_PRId32
                                        " configuration\n", fNodeID);
                                MediaRosterEx(roster)->SaveNodeConfiguration(this);
                        }

                        if (DeleteHook(this) != B_OK) {
                                ERROR("BMediaNode::Release(): DeleteHook failed\n");
                                return Acquire();
                        }
                        return NULL;
                }
                TRACE("BMediaRoster::Release() the media roster is NULL!");
        }
        return this;
}


const char*
BMediaNode::Name() const
{
        CALLED();
        return fName;
}


media_node_id
BMediaNode::ID() const
{
        CALLED();
        return fNodeID;
}


uint64
BMediaNode::Kinds() const
{
        CALLED();
        return fKinds & NODE_KIND_USER_MASK;
}


media_node
BMediaNode::Node() const
{
        CALLED();
        media_node temp;
        temp.node = ID();
        // We *must* call ControlPort(), some derived nodes
        // use it to start the port read thread!
        temp.port = ControlPort();
        temp.kind = Kinds();
        return temp;
}


BMediaNode::run_mode
BMediaNode::RunMode() const
{
        CALLED();
        return fRunMode;
}


BTimeSource*
BMediaNode::TimeSource() const
{
        PRINT(7, "CALLED BMediaNode::TimeSource()\n");

        // Return the currently assigned time source
        if (fTimeSource != 0)
                return fTimeSource;

        TRACE("BMediaNode::TimeSource node %" B_PRId32 " enter\n", ID());

        // If the node doesn't have a time source object, we need to create one.
        // If the node is still unregistered, we can't call MakeTimeSourceFor(),
        // but since the node does still have the default system time source, we
        // can use GetSystemTimeSource

        BMediaNode* self = const_cast<BMediaNode*>(this);
        self->fTimeSource = MediaRosterEx(
                BMediaRoster::Roster())->MakeTimeSourceObject(fTimeSourceID);

        ASSERT(fTimeSource == self->fTimeSource);

        if (fTimeSource == 0) {
                ERROR("BMediaNode::TimeSource: MakeTimeSourceFor failed\n");
        } else {
                ASSERT(fTimeSourceID == fTimeSource->ID());
                fTimeSource->AddMe(self);
        }

        TRACE("BMediaNode::TimeSource node %" B_PRId32 " leave\n", ID());

        return fTimeSource;
}


port_id
BMediaNode::ControlPort() const
{
        PRINT(7, "CALLED BMediaNode::ControlPort()\n");
        return fControlPort;
}


status_t
BMediaNode::ReportError(node_error what, const BMessage* info)
{
        CALLED();

        // Sanity check the what value
        switch (what) {
                case BMediaNode::B_NODE_FAILED_START:
                case BMediaNode::B_NODE_FAILED_STOP:
                case BMediaNode::B_NODE_FAILED_SEEK:
                case BMediaNode::B_NODE_FAILED_SET_RUN_MODE:
                case BMediaNode::B_NODE_FAILED_TIME_WARP:
                case BMediaNode::B_NODE_FAILED_PREROLL:
                case BMediaNode::B_NODE_FAILED_SET_TIME_SOURCE_FOR:
                case BMediaNode::B_NODE_IN_DISTRESS:
                        break;
                default:
                        ERROR("BMediaNode::ReportError: invalid what!\n");
                        return B_BAD_VALUE;
        }

        // Transmits the error code specified by what to anyone
        // that's receiving notifications from this node
        return BPrivate::media::notifications::ReportError(Node(), what, info);
}


status_t
BMediaNode::NodeStopped(bigtime_t whenPerformance)
{
        UNIMPLEMENTED();
        // Called by derived classes when they have
        // finished handling a stop request.

        // Notify anyone who is listening for stop notifications!
        BPrivate::media::notifications::NodeStopped(Node(), whenPerformance);

        // NOTE: If your node is a BBufferProducer, downstream consumers
        // will be notified that your node stopped (automatically, no less) through
        // the BBufferConsumer::ProducerDataStatus(B_PRODUCER_STOPPED) call.

        return B_OK;
}


/*
 * Used in couple with AddTimer, this will cause the BMediaRoster::SyncToNode()
 * call that requested the timer to return to the caller with an appropriate
 * value.
 */
void
BMediaNode::TimerExpired(bigtime_t notifyPoint, int32 cookie, status_t error)
{
        CALLED();
        if (write_port((port_id)cookie, 0, &error, sizeof(error)) < 0) {
                TRACE("BMediaNode::TimerExpired: error writing port %" B_PRId32
                        ", at notifyPoint %" B_PRId64 "\n", cookie, notifyPoint);
        }
}


BMediaNode::BMediaNode(const char* name)
{
        TRACE("BMediaNode::BMediaNode: name '%s'\n", name);
        _InitObject(name, NODE_JUST_CREATED_ID, 0);
}


status_t
BMediaNode::WaitForMessage(bigtime_t waitUntil, uint32 flags,
        void* _reserved_)
{
        TRACE("entering: BMediaNode::WaitForMessage()\n");

        // This function waits until either real time specified by
        // waitUntil or a message is received on the control port.
        // The flags are currently unused and should be 0.
        // Note: about 16 KByte stack used
        char data[B_MEDIA_MESSAGE_SIZE];
        int32 message;
        ssize_t size;

        while (true) {
                size = read_port_etc(ControlPort(), &message, data,
                        sizeof(data), B_ABSOLUTE_TIMEOUT, waitUntil);

                if (size >= 0)
                        break;

                status_t error = (status_t)size;
                if (error == B_INTERRUPTED)
                        continue;

                if (error != B_TIMED_OUT && error != B_BAD_PORT_ID) {
                        ERROR("BMediaNode::WaitForMessage: read_port_etc error: %s\n",
                                strerror(error));
                }

                return error;
        }

        TRACE("BMediaNode::WaitForMessage request is: %#" B_PRIx32 ", node %"
                B_PRId32 ", this %p\n", message, fNodeID, this);

        if (message == GENERAL_PURPOSE_WAKEUP)
                return B_OK;

        if (message > NODE_MESSAGE_START && message < NODE_MESSAGE_END) {
                TRACE("BMediaNode::WaitForMessage calling BMediaNode\n");

                if (B_OK == BMediaNode::HandleMessage(message, data, size))
                        return B_OK;
        }

        if (message > PRODUCER_MESSAGE_START && message < PRODUCER_MESSAGE_END) {
                if (!fProducerThis)
                        fProducerThis = dynamic_cast<BBufferProducer*>(this);

                TRACE("BMediaNode::WaitForMessage calling BBufferProducer %p\n",
                        fProducerThis);

                if (fProducerThis && fProducerThis->BBufferProducer::HandleMessage(
                                message, data, size) == B_OK) {
                        return B_OK;
                }
        }

        if (message > CONSUMER_MESSAGE_START && message < CONSUMER_MESSAGE_END) {
                if (!fConsumerThis)
                        fConsumerThis = dynamic_cast<BBufferConsumer*>(this);

                TRACE("BMediaNode::WaitForMessage calling BBufferConsumer %p\n",
                        fConsumerThis);

                if (fConsumerThis && fConsumerThis->BBufferConsumer::HandleMessage(
                        message, data, size) == B_OK) {
                        return B_OK;
                }
        }

        if (message > FILEINTERFACE_MESSAGE_START
                && message < FILEINTERFACE_MESSAGE_END) {
                if (!fFileInterfaceThis)
                        fFileInterfaceThis = dynamic_cast<BFileInterface*>(this);

                TRACE("BMediaNode::WaitForMessage calling BFileInterface %p\n",
                        fFileInterfaceThis);

                if (fFileInterfaceThis
                        && fFileInterfaceThis->BFileInterface::HandleMessage(
                                message, data, size) == B_OK) {
                        return B_OK;
                }
        }

        if (message > CONTROLLABLE_MESSAGE_START
                && message < CONTROLLABLE_MESSAGE_END) {
                if (!fControllableThis)
                        fControllableThis = dynamic_cast<BControllable*>(this);

                TRACE("BMediaNode::WaitForMessage calling BControllable %p\n",
                        fControllableThis);

                if (fControllableThis
                        && fControllableThis->BControllable::HandleMessage(
                                message, data, size) == B_OK) {
                        return B_OK;
                }
        }

        if (message > TIMESOURCE_MESSAGE_START
                && message < TIMESOURCE_MESSAGE_END) {
                if (!fTimeSourceThis)
                        fTimeSourceThis = dynamic_cast<BTimeSource*>(this);

                TRACE("BMediaNode::WaitForMessage calling BTimeSource %p\n",
                        fTimeSourceThis);

                if (fTimeSourceThis && fTimeSourceThis->BTimeSource::HandleMessage(
                                message, data, size) == B_OK) {
                        return B_OK;
                }
        }

        TRACE("BMediaNode::WaitForMessage calling default HandleMessage\n");
        if (HandleMessage(message, data, size) == B_OK)
                return B_OK;

        HandleBadMessage(message, data, size);

        return B_ERROR;
}


void
BMediaNode::Start(bigtime_t performance_time)
{
        CALLED();
        // This hook function is called when a node is started
        // by a call to the BMediaRoster. The specified
        // performanceTime, the time at which the node
        // should start running, may be in the future.
        // It may be overriden by derived classes.
        // The BMediaEventLooper class handles this event!
        // The BMediaNode class does nothing here.
}


void
BMediaNode::Stop(bigtime_t performance_time, bool immediate)
{
        CALLED();
        // This hook function is called when a node is stopped
        // by a call to the BMediaRoster. The specified
        // performanceTime, the time at which the node
        // should stop running, may be in the future.
        // It may be overriden by derived classes.
        // The BMediaEventLooper class handles this event!
        // The BMediaNode class does nothing here.
}


void
BMediaNode::Seek(bigtime_t media_time, bigtime_t performance_time)
{
        CALLED();
        // This hook function is called when a node is asked
        // to seek to the specified mediaTime by a call to
        // the BMediaRoster. The specified performanceTime,
        // the time at which the node should begin the seek
        // operation, may be in the future.
        // It may be overriden by derived classes.
        // The BMediaEventLooper class handles this event!
        // The BMediaNode class does nothing here.
}


void
BMediaNode::SetRunMode(run_mode mode)
{
        CALLED();

        // This is a hook function, and
        // may be overriden by derived classes.

        // The functionality here is only to
        // support those people that don't
        // use the roster to set the run mode
        fRunMode = mode;
}


void
BMediaNode::TimeWarp(bigtime_t at_real_time, bigtime_t to_performance_time)
{
        CALLED();
        // May be overriden by derived classes.
}


void
BMediaNode::Preroll()
{
        CALLED();
        // May be overriden by derived classes.
}


void
BMediaNode::SetTimeSource(BTimeSource* time_source)
{
        CALLED();
        // This is a hook function, and
        // may be overriden by derived classes.

        if (time_source == NULL || time_source == fTimeSource)
                return;

        // We just trip into debugger, code that tries to do this is broken.
        debugger("BMediaNode::SetTimeSource() can't be used to set a timesource, "
                "use BMediaRoster::SetTimeSourceFor()!\n");
}


status_t
BMediaNode::HandleMessage(int32 message, const void* data, size_t size)
{
        TRACE("BMediaNode::HandleMessage %#" B_PRIx32", node %" B_PRId32 "\n",
                message, fNodeID);
        switch (message) {
                case NODE_FINAL_RELEASE:
                {
                        TRACE("BMediaNode::HandleMessage NODE_FINAL_RELEASE, this %p\n",
                                this);

                        // This is called by the media server to delete the object
                        // after is has been released by all nodes that are using it.
                        // We forward the function to the BMediaRoster, since the
                        // deletion must be done from a different thread, or the
                        // outermost destructor that will exit the thread that is
                        // reading messages from the port (this thread contex) will
                        // quit, and ~BMediaNode destructor won't be called ever.
                        BMessage msg(NODE_FINAL_RELEASE);
                        msg.AddPointer("node", this);
                        BMediaRoster::Roster()->PostMessage(&msg);
                        return B_OK;
                }

                case NODE_START:
                {
                        const node_start_command* command
                                = static_cast<const node_start_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_START, node %" B_PRId32 "\n",
                                fNodeID);
                        Start(command->performance_time);
                        return B_OK;
                }

                case NODE_STOP:
                {
                        const node_stop_command* command
                                = static_cast<const node_stop_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_STOP, node %" B_PRId32 "\n",
                                fNodeID);
                        Stop(command->performance_time, command->immediate);
                        return B_OK;
                }

                case NODE_SEEK:
                {
                        const node_seek_command* command
                                = static_cast<const node_seek_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_SEEK, node %" B_PRId32 "\n",
                                fNodeID);
                        Seek(command->media_time, command->performance_time);
                        return B_OK;
                }

                case NODE_SET_RUN_MODE:
                {
                        const node_set_run_mode_command* command
                                = static_cast<const node_set_run_mode_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_SET_RUN_MODE,"
                                " node %" B_PRId32 "\n", fNodeID);
                        // Need to change PRODUCER_SET_RUN_MODE_DELAY
                        fRunMode = command->mode;
                        SetRunMode(fRunMode);
                        return B_OK;
                }

                case NODE_TIME_WARP:
                {
                        const node_time_warp_command* command
                                = static_cast<const node_time_warp_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_TIME_WARP,"
                                " node %" B_PRId32 "\n", fNodeID);
                        TimeWarp(command->at_real_time, command->to_performance_time);
                        return B_OK;
                }

                case NODE_PREROLL:
                {
                        TRACE("BMediaNode::HandleMessage NODE_PREROLL, "
                                " node %" B_PRId32 "\n", fNodeID);
                        Preroll();
                        return B_OK;
                }

                case NODE_ROLL:
                {
                        const node_roll_command* command
                                = static_cast<const node_roll_command*>(data);

                        TRACE("BMediaNode::HandleMessage NODE_ROLL, node %" B_PRId32 "\n",
                                fNodeID);

                        if (command->seek_media_time != B_INFINITE_TIMEOUT)
                                Seek(command->seek_media_time,
                                        command->start_performance_time);

                        Start(command->start_performance_time);
                        Stop(command->stop_performance_time, false);
                        return B_OK;
                }

                case NODE_SYNC_TO:
                {
                        const node_sync_to_request* request
                                = static_cast<const node_sync_to_request*>(data);
                        node_sync_to_reply reply;

                        TRACE("BMediaNode::HandleMessage NODE_SYNC_TO, node %" B_PRId32
                                "\n", fNodeID);

                        // If AddTimer return an error the caller will know that the node
                        // doesn't support this feature or there was a problem when adding
                        // it, this will result in SyncToNode returning immediately
                        // to the caller with an error.
                        status_t status = AddTimer(request->performance_time,
                                request->port);

                        request->SendReply(status, &reply, sizeof(reply));
                        return B_OK;
                }

                case NODE_SET_TIMESOURCE:
                {
                        const node_set_timesource_command* command
                                = static_cast<const node_set_timesource_command*>(data);

                        TRACE("BMediaNode::HandleMessage NODE_SET_TIMESOURCE,"
                                " node %" B_PRId32 ", timesource %" B_PRId32 " enter\n",
                                fNodeID, command->timesource_id);

                        fTimeSourceID = command->timesource_id;

                        if (fTimeSource) {
                                // As this node already had a timesource, to remove this node
                                // from time source control
                                fTimeSource->RemoveMe(this);
                                // Release the time source
                                fTimeSource->Release();
                                // Force next call to TimeSource() to create a new object
                                fTimeSource = 0;
                        }

                        // Create new time source object and call the SetTimeSource
                        // hook function to notify any derived class
                        fTimeSource = TimeSource();
                        SetTimeSource(fTimeSource);

                        TRACE("BMediaNode::HandleMessage NODE_SET_TIMESOURCE, node %"
                                B_PRId32 ", timesource %" B_PRId32 " leave\n", fNodeID,
                                command->timesource_id);

                        return B_OK;
                }

                case NODE_GET_TIMESOURCE:
                {
                        const node_get_timesource_request* request
                                = static_cast<const node_get_timesource_request*>(data);

                        TRACE("BMediaNode::HandleMessage NODE_GET_TIMESOURCE,"
                                " node %" B_PRId32 "\n", fNodeID);

                        node_get_timesource_reply reply;
                        reply.timesource_id = fTimeSourceID;
                        request->SendReply(B_OK, &reply, sizeof(reply));
                        return B_OK;
                }

                case NODE_GET_ATTRIBUTES_FOR:
                {
                        const node_get_attributes_for_request *request =
                                (const node_get_attributes_for_request*) data;

                        TRACE("BMediaNode::HandleMessage NODE_GET_ATTRIBUTES_FOR,"
                                "node %" B_PRId32 "\n", fNodeID);

                        node_get_attributes_for_reply reply;

                        media_node_attribute* addr;
                        area_id dataArea = clone_area("client attributes area",
                                (void**)&addr, B_ANY_ADDRESS, B_WRITE_AREA,
                                request->area);

                        if (dataArea < 0) {
                                ERROR("NODE_GET_ATTRIBUTES_FOR can't clone area\n");
                                return B_NO_MEMORY;
                        }

                        status_t status = GetNodeAttributes(addr, request->count);
                        if (status == B_OK) {
                                // NOTE: we do it because there's not an easy way
                                // to guess the number of attributes filled.
                                size_t i;
                                for (i = 0; i < request->count; i++) {
                                        if (addr[i].what <= 0)
                                                break;
                                }
                                reply.filled_count = i;
                        }
                        request->SendReply(status, &reply, sizeof(reply));
                        delete_area(dataArea);
                        return B_OK;
                }

                case NODE_REQUEST_COMPLETED:
                {
                        const node_request_completed_command* command
                                = static_cast<const node_request_completed_command*>(data);
                        TRACE("BMediaNode::HandleMessage NODE_REQUEST_COMPLETED,"
                                " node %" B_PRId32 "\n", fNodeID);
                        RequestCompleted(command->info);
                        return B_OK;
                }

                default:
                        return B_ERROR;

        }
        return B_ERROR;
}


void
BMediaNode::HandleBadMessage(int32 code, const void* buffer, size_t size)
{
        CALLED();

        TRACE("BMediaNode::HandleBadMessage: code %#08" B_PRIx32 ", buffer %p, size %"
                B_PRIuSIZE "\n", code, buffer, size);
        if (code < NODE_MESSAGE_START || code > TIMESOURCE_MESSAGE_END) {
                ERROR("BMediaNode::HandleBadMessage: unknown code!\n");
        } else {
                 // All messages targeted to nodes should be handled here,
                 // messages targetted to the wrong node should be handled
                 // by returning an error, not by stalling the sender.
                const request_data* request = static_cast<const request_data* >(buffer);
                reply_data reply;
                request->SendReply(B_ERROR, &reply, sizeof(reply));
        }
}


void
BMediaNode::AddNodeKind(uint64 kind)
{
        TRACE("BMediaNode::AddNodeKind: node %" B_PRId32 ", this %p\n", fNodeID,
                this);
        fKinds |= kind;
}


void*
BMediaNode::operator new(size_t size)
{
        CALLED();
        return ::operator new(size);
}


void*
BMediaNode::operator new(size_t size, const nothrow_t&) throw()
{
        CALLED();
        return ::operator new(size, nothrow);
}


void
BMediaNode::operator delete(void* ptr)
{
        CALLED();
        ::operator delete(ptr);
}


void
BMediaNode::operator delete(void* ptr, const nothrow_t&) throw()
{
        CALLED();
        ::operator delete(ptr, nothrow);
}


status_t
BMediaNode::RequestCompleted(const media_request_info& info)
{
        CALLED();
        // This function is called whenever
        // a request issued by the node is completed.
        // May be overriden by derived classes.
        // info.change_tag can be used to match up requests against
        // the accompaning calles from
        // BBufferConsumer::RequestFormatChange()
        // BBufferConsumer::SetOutputBuffersFor()
        // BBufferConsumer::SetOutputEnabled()
        // BBufferConsumer::SetVideoClippingFor()
        return B_OK;
}


status_t
BMediaNode::DeleteHook(BMediaNode* node)
{
        CALLED();
        // Attention! We do not unregister TimeSourceObject nodes,
        // since they are only a shadow object, and the real one still exists
        if ((fKinds & NODE_KIND_SHADOW_TIMESOURCE) == 0)
                BMediaRoster::Roster()->UnregisterNode(this);
        delete this; // delete "this" or "node", both are the same
        return B_OK;
}


void
BMediaNode::NodeRegistered()
{
        CALLED();
        // The Media Server calls this hook function
        // after the node has been registered.
        // May be overriden by derived classes.
}


status_t
BMediaNode::GetNodeAttributes(media_node_attribute* outAttributes,
        size_t inMaxCount)
{
        CALLED();
        // This is implemented by derived classes that fills
        // it's own attributes to a max of inMaxCount elements.
        return B_ERROR;
}


status_t
BMediaNode::AddTimer(bigtime_t at_performance_time, int32 cookie)
{
        CALLED();
        return B_ERROR;
}


status_t BMediaNode::_Reserved_MediaNode_0(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_1(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_2(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_3(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_4(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_5(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_6(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_7(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_8(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_9(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_10(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_11(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_12(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_13(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_14(void*) { return B_ERROR; }
status_t BMediaNode::_Reserved_MediaNode_15(void*) { return B_ERROR; }

/*
private unimplemented
BMediaNode::BMediaNode()
BMediaNode::BMediaNode(const BMediaNode &clone)
BMediaNode &BMediaNode::operator=(const BMediaNode &clone)
*/

void
BMediaNode::_InitObject(const char* name, media_node_id id, uint64 kinds)
{
        TRACE("BMediaNode::_InitObject: nodeid %" B_PRId32 ", this %p\n", id,
                this);

        fNodeID = id;
        fRefCount = 1;
        fName[0] = 0;
        if (name)
                strlcpy(fName, name, B_MEDIA_NAME_LENGTH);
        fRunMode = B_INCREASE_LATENCY;
        fKinds = kinds;
        fProducerThis = 0;
        fConsumerThis = 0;
        fFileInterfaceThis = 0;
        fControllableThis = 0;
        fTimeSourceThis = 0;

        // Create control port
        fControlPort = create_port(64, fName);

        // Nodes are assigned the system time source by default
        fTimeSourceID = NODE_SYSTEM_TIMESOURCE_ID;

        // We can't create the timesource object here, because
        // every timesource is a BMediaNode, which would result
        // in infinite recursions
        fTimeSource = NULL;
}


BMediaNode::BMediaNode(const char* name, media_node_id id, uint32 kinds)
{
        TRACE("BMediaNode::BMediaNode: name '%s', nodeid %" B_PRId32 ", kinds %#"
                B_PRIx32 "\n", name, id, kinds);
        _InitObject(name, id, kinds);
}


int32
BMediaNode::NewChangeTag()
{
        CALLED();
        // Change tags have been used in BeOS R4 to match up
        // format change requests between producer and consumer,
        // This has changed starting with R4.5
        // now "change tags" are used with the following functions:
        // BMediaNode::RequestCompleted()
        // BBufferConsumer::RequestFormatChange()
        // BBufferConsumer::SetOutputBuffersFor()
        // BBufferConsumer::SetOutputEnabled()
        // BBufferConsumer::SetVideoClippingFor()
        return atomic_add(&BMediaNode::_m_changeTag,1);
}

// BeOS R4 deprecated API

int32
BMediaNode::IncrementChangeTag()
{
        CALLED();
        // Only present in BeOS R4
        // Obsoleted in BeOS R4.5 and later
        // "updates the change tag, so that downstream consumers
        // know that the node is in a new state."
        // not supported, only for binary compatibility
        return 0;
}


int32
BMediaNode::ChangeTag()
{
        UNIMPLEMENTED();
        // Only present in BeOS R4
        // Obsoleted in BeOS R4.5 and later
        // "returns the node's current change tag value."
        // not supported, only for binary compatibility
        return 0;
}


int32
BMediaNode::MintChangeTag()
{
        UNIMPLEMENTED();
        // Only present in BeOS R4
        // Obsoleted in BeOS R4.5 and later
        // "mints a new, reserved, change tag."
        // "Call ApplyChangeTag() to apply it to the node"
        // not supported, only for binary compatibility
        return 0;
}


status_t
BMediaNode::ApplyChangeTag(int32 previously_reserved)
{
        UNIMPLEMENTED();
        // Only present in BeOS R4
        // Obsoleted in BeOS R4.5 and later
        // "this returns B_OK if the new change tag is"
        // "successfully applied, or B_MEDIA_STALE_CHANGE_TAG if the new change"
        // "count you tried to apply is already obsolete."
        // not supported, only for binary compatibility
        return B_OK;
}