// AbstractFileInterfaceNode.cpp
//
// Andrew Bachmann, 2002
//
// The AbstractFileInterfaceNode class implements
// the common functionality between MediaReader
// and MediaWriter.
#include "AbstractFileInterfaceNode.h"
#include "debug.h"

#include <Buffer.h>
#include <Controllable.h>
#include <Entry.h>
#include <Errors.h>
#include <File.h>
#include <FileInterface.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <TimeSource.h>
#include <ParameterWeb.h>
#include <limits.h>
#include <stdio.h>
#include <string.h>


AbstractFileInterfaceNode::~AbstractFileInterfaceNode(void)
{
        CALLED();

        // Stop the BMediaEventLooper thread
        Quit();
        if (fCurrentFile != 0)
                delete fCurrentFile;
}


AbstractFileInterfaceNode::AbstractFileInterfaceNode(
                                size_t defaultChunkSize,
                                float defaultBitRate,
                                const flavor_info * info,
                                BMessage * config,
                                BMediaAddOn * addOn)
        : BMediaNode("AbstractFileInterfaceNode"),
          BFileInterface(),
          BControllable(),
          BMediaEventLooper()
{
        CALLED();

        // keep our creator around for AddOn calls later
        fAddOn = addOn;
        // null some fields
        fCurrentFile = 0;
        f_current_mime_type[0] = '\0';

        // initialize the parameters
        if (defaultChunkSize <= 0) {
                fInitCheckStatus = B_BAD_VALUE;
                return;
        }

        fDefaultChunkSizeParam = defaultChunkSize;
        fDefaultChunkSizeParamChangeTime = 0;
        if (defaultBitRate <= 0) {
                fInitCheckStatus = B_BAD_VALUE;
                return;
        }

        fDefaultBitRateParam = defaultBitRate;
        fDefaultBitRateParamChangeTime = 0;
        // initialize parameter compute fields
        fLeastRecentlyUpdatedParameter = DEFAULT_BIT_RATE_PARAM;
        fLastUpdatedParameter = DEFAULT_BUFFER_PERIOD_PARAM;    
        // From the chunk size and bit rate we compute the buffer period.
        int64 value = int64(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam);
        if ((value <= 0) || (value > INT_MAX)) {
                fInitCheckStatus = B_BAD_VALUE;
                return;
        }
        fDefaultBufferPeriodParam = int32(value);
        fDefaultBufferPeriodParamChangeTime = 0;
        
        fInitCheckStatus = B_OK;
}


status_t AbstractFileInterfaceNode::InitCheck(void) const
{
        CALLED();
        return fInitCheckStatus;
}


status_t AbstractFileInterfaceNode::GetConfigurationFor(
                                BMessage * into_message)
{
        CALLED();
        return B_OK;
}


// -------------------------------------------------------- //
// implementation of BMediaNode
// -------------------------------------------------------- //
BMediaAddOn * AbstractFileInterfaceNode::AddOn(
                                int32 * internal_id) const
{
        CALLED();
        // BeBook says this only gets called if we were in an add-on.
        if (fAddOn != 0) {
                // If we get a null pointer then we just won't write.
                if (internal_id != 0)
                        internal_id = 0;
        }
        return fAddOn;
}


void AbstractFileInterfaceNode::Start(
                                bigtime_t performance_time)
{
        PRINT("AbstractFileInterfaceNode::Start(pt=%lld)\n",performance_time);
        BMediaEventLooper::Start(performance_time);
}


void AbstractFileInterfaceNode::Stop(
                                bigtime_t performance_time,
                                bool immediate)
{
        PRINT("AbstractFileInterfaceNode::Stop(pt=%lld, im=%d)\n",
                  performance_time, immediate);
        BMediaEventLooper::Stop(performance_time,immediate);
}


void AbstractFileInterfaceNode::Seek(
                                bigtime_t media_time,
                                bigtime_t performance_time)
{
        PRINT("AbstractFileInterfaceNode::Seek(mt=%lld,pt=%lld)\n",
                  media_time,performance_time);
        BMediaEventLooper::Seek(media_time,performance_time);
}


void AbstractFileInterfaceNode::SetRunMode(
                                run_mode mode)
{
        PRINT("AbstractFileInterfaceNode::SetRunMode(%i)\n",mode);
        BMediaEventLooper::SetRunMode(mode);
}


void AbstractFileInterfaceNode::TimeWarp(
                                bigtime_t at_real_time,
                                bigtime_t to_performance_time)
{
        PRINT("AbstractFileInterfaceNode::TimeWarp(rt=%lld,pt=%lld)\n",
                  at_real_time,to_performance_time);
        BMediaEventLooper::TimeWarp(at_real_time,to_performance_time);
}


void AbstractFileInterfaceNode::Preroll(void)
{
        CALLED();
        // XXX:Performance opportunity
        BMediaNode::Preroll();
}


void AbstractFileInterfaceNode::SetTimeSource(
                                BTimeSource * time_source)
{
        CALLED();
        BMediaNode::SetTimeSource(time_source);
}


status_t AbstractFileInterfaceNode::HandleMessage(
                                int32 message,
                                const void * data,
                                size_t size)
{
        CALLED();

        status_t status = B_OK;
        switch (message) {
                // no special messages for now
                default:
                        status = BFileInterface::HandleMessage(message,data,size);
                        if (status == B_OK) {
                                break;
                        }
                        status = BControllable::HandleMessage(message, data, size);
                        if (status == B_OK)
                                break;
                        status = BMediaNode::HandleMessage(message,data,size);
                        if (status == B_OK) {
                                break;
                        }
                        BMediaNode::HandleBadMessage(message,data,size);
                        status = B_ERROR;
                        break;
        }
        return status;
}


status_t AbstractFileInterfaceNode::RequestCompleted(
                                const media_request_info & info)
{
        CALLED();
        return BMediaNode::RequestCompleted(info);
}


status_t AbstractFileInterfaceNode::DeleteHook(
                                BMediaNode * node)
{
        CALLED();
        return BMediaEventLooper::DeleteHook(node);
}


void AbstractFileInterfaceNode::NodeRegistered(void)
{
        CALLED();
        
        // set up our parameter web
        SetParameterWeb(MakeParameterWeb());
        
        // start the BMediaEventLooper thread
        SetPriority(B_REAL_TIME_PRIORITY);
        Run();
}


status_t AbstractFileInterfaceNode::GetNodeAttributes(
                                media_node_attribute * outAttributes,
                                size_t inMaxCount)
{
        CALLED();
        return BMediaNode::GetNodeAttributes(outAttributes,inMaxCount);
}


status_t AbstractFileInterfaceNode::AddTimer(
                                        bigtime_t at_performance_time,
                                        int32 cookie)
{
        CALLED();
        return BMediaEventLooper::AddTimer(at_performance_time,cookie);
}


// protected:
BParameterWeb * AbstractFileInterfaceNode::MakeParameterWeb(void)
{
        CALLED();
        
        BParameterWeb * web = new BParameterWeb();
        BParameterGroup * mainGroup = web->MakeGroup("AbstractFileInterfaceNode Parameters");

        // these three are related:
        // DEFAULT_CHUNK_SIZE_PARAM = 
        // DEFAULT_BIT_RATE_PARAM / 1024 * DEFAULT_BUFFER_PERIOD_PARAM * 1000
        BParameterGroup * chunkSizeGroup = mainGroup->MakeGroup("Chunk Size Group");
        BContinuousParameter * chunkSizeParameter
           = chunkSizeGroup->MakeContinuousParameter(
             DEFAULT_CHUNK_SIZE_PARAM, B_MEDIA_MULTISTREAM,
                 "Chunk Size", B_GAIN, "bytes", 1024, 32*1024, 512);
        chunkSizeParameter->SetResponse(BContinuousParameter::B_LINEAR,1,0);
        chunkSizeParameter->SetValue(&fDefaultChunkSizeParam,sizeof(fDefaultChunkSizeParam),0);
        
        BParameterGroup * bitRateGroup = mainGroup->MakeGroup("Bit Rate Group");
        BContinuousParameter * bitRateParameter
           = bitRateGroup->MakeContinuousParameter(
             DEFAULT_BIT_RATE_PARAM, B_MEDIA_MULTISTREAM,
             "Bit Rate", B_GAIN, "kbits/sec", 1, 320000, 1);
        bitRateParameter->SetResponse(BContinuousParameter::B_LINEAR,.001,0);
        bitRateParameter->SetValue(&fDefaultBitRateParam,sizeof(fDefaultBitRateParam),0);
        
        BParameterGroup * bufferPeriodGroup = mainGroup->MakeGroup("Buffer Period Group");
        BContinuousParameter * bufferPeriodParameter
           = bufferPeriodGroup->MakeContinuousParameter(
             DEFAULT_BUFFER_PERIOD_PARAM, B_MEDIA_MULTISTREAM,
             "Buffer Period", B_GAIN, "ms", 1, 10000, 1);
        bufferPeriodParameter->SetResponse(BContinuousParameter::B_LINEAR,1,0);
        bufferPeriodParameter->SetValue(&fDefaultBufferPeriodParam,sizeof(fDefaultBufferPeriodParam),0);
        
        return web;
}


// -------------------------------------------------------- //
// implementation of BFileInterface
// -------------------------------------------------------- //
status_t AbstractFileInterfaceNode::GetNextFileFormat(
                                int32 * cookie,
                                media_file_format * out_format)
{
        CALLED();

        // it's valid but they already got our 1 file format
        if (*cookie != 0) {
                PRINT("\t<- B_ERROR\n");
                return B_ERROR;
        }

        // so next time they won't get the same format again
        *cookie = 1;
        GetFileFormat(out_format);
        return B_OK;
}


void AbstractFileInterfaceNode::DisposeFileFormatCookie(
                                int32 cookie)
{
        CALLED();
        // nothing to do since our cookies are just integers
}


status_t AbstractFileInterfaceNode::GetDuration(
                                bigtime_t * out_time)
{
        CALLED();
        if (out_time == 0) {
                PRINT("\t<- B_BAD_VALUE\n");
                return B_BAD_VALUE;
        }

        if (fCurrentFile == 0) {
                PRINT("\t<- B_NO_INIT\n");
                return B_NO_INIT;
        }       

        return fCurrentFile->GetSize(out_time);
}


status_t AbstractFileInterfaceNode::SniffRef(
                                const entry_ref & file,
                                char * out_mime_type,   /* 256 bytes */
                                float * out_quality)
{
        CALLED();
        return StaticSniffRef(file,out_mime_type,out_quality);
}


status_t AbstractFileInterfaceNode::SetRef(
                                const entry_ref & file,
                                uint32 openMode,
                                bool create,
                                bigtime_t * out_time)
{
        CALLED();

        status_t status;
        f_current_ref = file;
        if (fCurrentFile == 0) {
                fCurrentFile = new BFile(&f_current_ref,(openMode|(create?B_CREATE_FILE:0)));
                status = fCurrentFile->InitCheck();
        } else {
                status = fCurrentFile->SetTo(&f_current_ref,(openMode|(create?B_CREATE_FILE:0)));
        }

        if (status != B_OK) {
                PRINT("\t<- failed BFile initialization\n");
                return status;
        }

        // cache the mime type for later
        fCurrentFile->ReadAttr("BEOS:TYPE",0,0,f_current_mime_type,B_MIME_TYPE_LENGTH);
        // compute the duration and return any error
        return GetDuration(out_time);
}


status_t AbstractFileInterfaceNode::GetRef(
                                entry_ref * out_ref,
                                char * out_mime_type)
{
        CALLED();

        if (fCurrentFile == 0) {
                PRINT("\t<- B_NO_INIT\n");
                return B_NO_INIT; // the input_ref isn't valid yet either
        }

        *out_ref = f_current_ref;
        // they hopefully allocated enough space (no way to check :-/ )
        strcpy(out_mime_type,f_current_mime_type);
        return B_OK;
}


// provided for BAbstractFileInterfaceNodeAddOn
status_t AbstractFileInterfaceNode::StaticSniffRef(
                                const entry_ref & file,
                                char * out_mime_type,   /* 256 bytes */
                                float * out_quality)
{
        CALLED();

        BNode node(&file);
        status_t initCheck = node.InitCheck();
        if (initCheck != B_OK) {
                PRINT("\t<- failed BNode::InitCheck()\n");
                return initCheck;
        }

        // they hopefully allocated enough room
        node.ReadAttr("BEOS:TYPE",0,0,out_mime_type,B_MIME_TYPE_LENGTH);
        *out_quality = 1.0; // we handle all files perfectly!  we are so amazing!
        return B_OK;
}


// -------------------------------------------------------- //
// implementation for BControllable
// -------------------------------------------------------- //
const int32 AbstractFileInterfaceNode::DEFAULT_CHUNK_SIZE_PARAM = 1;
const int32 AbstractFileInterfaceNode::DEFAULT_BIT_RATE_PARAM = 2;
const int32 AbstractFileInterfaceNode::DEFAULT_BUFFER_PERIOD_PARAM = 3;


status_t AbstractFileInterfaceNode::GetParameterValue(
                                int32 id,
                                bigtime_t * last_change,
                                void * value,
                                size_t * ioSize)
{
        CALLED();

        switch (id) {
                case DEFAULT_CHUNK_SIZE_PARAM:
                        if (*ioSize < sizeof(size_t)) {
                                return B_ERROR; // not enough room
                        }
                        *last_change = fDefaultChunkSizeParamChangeTime;
                        *((size_t*)value) = fDefaultChunkSizeParam;
                        *ioSize = sizeof(size_t);
                        break;
                        
                case DEFAULT_BIT_RATE_PARAM:
                        if (*ioSize < sizeof(float)) {
                                return B_ERROR; // not enough room
                        }
                        *last_change = fDefaultBitRateParamChangeTime;
                        *((float*)value) = fDefaultBitRateParam;
                        *ioSize = sizeof(float);
                        break;
                
                case DEFAULT_BUFFER_PERIOD_PARAM:
                        if (*ioSize < sizeof(int32)) {
                                return B_ERROR; // not enough room
                        }
                        *last_change = fDefaultBufferPeriodParamChangeTime;
                        *((int32*)value) = fDefaultBufferPeriodParam;
                        *ioSize = sizeof(int32);
                        break;
                                
                default:
                        PRINT("AbstractFileInterfaceNode::GetParameterValue unknown id (%ld)\n",id);
                        return B_ERROR;
        }

        return B_OK;
}


void AbstractFileInterfaceNode::SetParameterValue(
                                int32 id,
                                bigtime_t when,
                                const void * value,
                                size_t size)
{
        PRINT("AbstractFileInterfaceNode::SetParameterValue(id=%ld,when=%lld,size=%ld)\n",id,when,int32(size));

        switch (id) {
                case DEFAULT_CHUNK_SIZE_PARAM:
                case DEFAULT_BIT_RATE_PARAM:
                case DEFAULT_BUFFER_PERIOD_PARAM:
                        {
                                media_timed_event event(when, BTimedEventQueue::B_PARAMETER,
                                                                                NULL, BTimedEventQueue::B_NO_CLEANUP,
                                                                                size, id, (char*) value, size);
                                EventQueue()->AddEvent(event);
                        }
                        break;
                        
                default:
                        PRINT("AbstractFileInterfaceNode::SetParameterValue unknown id (%ld)\n",id);
                        break;
        }
}                       


// the default implementation should call the add-on main()
status_t AbstractFileInterfaceNode::StartControlPanel(
                                BMessenger * out_messenger)
{
        CALLED();
        return BControllable::StartControlPanel(out_messenger);
}


// -------------------------------------------------------- //
// implementation for BMediaEventLooper
// -------------------------------------------------------- //
void AbstractFileInterfaceNode::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:
                        if (RunState() == BMediaEventLooper::B_STARTED) {
                                HandleBuffer(event,lateness,realTimeEvent);
                        }
                        break;
                case BTimedEventQueue::B_DATA_STATUS:
                        HandleDataStatus(event,lateness,realTimeEvent);
                        break;
                case BTimedEventQueue::B_PARAMETER:
                        HandleParameter(event,lateness,realTimeEvent);
                        break;
                default:
                        PRINT("  unknown event type: %ld\n",event->type);
                        break;
        }
}


/* override to clean up custom events you have added to your queue */
void AbstractFileInterfaceNode::CleanUpEvent(
                                const media_timed_event *event)
{
        BMediaEventLooper::CleanUpEvent(event);
}


/* called from Offline mode to determine the current time of the node */
/* update your internal information whenever it changes */
bigtime_t AbstractFileInterfaceNode::OfflineTime()
{
        CALLED();
        return BMediaEventLooper::OfflineTime();
        // XXX: do something else?
        //      if (inputFile == 0) {
        //              return 0;
        //      } else {
        //              return inputFile->Position();
        //      }
}


/* override only if you know what you are doing! */
/* otherwise much badness could occur */
/* the actual control loop function: */
/*      waits for messages, Pops events off the queue and calls DispatchEvent */
void AbstractFileInterfaceNode::ControlLoop() {
        BMediaEventLooper::ControlLoop();
}


// protected:
status_t AbstractFileInterfaceNode::HandleStart(
                                                const media_timed_event *event,
                                                bigtime_t lateness,
                                                bool realTimeEvent)
{
        CALLED();

        if (RunState() != B_STARTED) {
                // XXX: Either use the following line or the lines that are not commented.
                // There doesn't seem to be a practical difference that i can tell.
                //              HandleBuffer(event,lateness,realTimeEvent);
                media_timed_event firstBufferEvent(event->event_time, BTimedEventQueue::B_HANDLE_BUFFER);
                HandleEvent(&firstBufferEvent, 0, false);
                EventQueue()->AddEvent(firstBufferEvent);
        }
        return B_OK;
}


status_t AbstractFileInterfaceNode::HandleSeek(
                                                const media_timed_event *event,
                                                bigtime_t lateness,
                                                bool realTimeEvent)
{
        PRINT("AbstractFileInterfaceNode::HandleSeek(t=%lld,d=%ld,bd=%lld)\n",event->event_time,event->data,event->bigdata);

        if (fCurrentFile != 0)
                return fCurrentFile->Seek(event->bigdata,SEEK_SET);
        else
                return B_ERROR;
}
                                                

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


status_t AbstractFileInterfaceNode::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, BTimedEventQueue::B_HANDLE_BUFFER);
        return B_OK;
}


status_t AbstractFileInterfaceNode::HandleParameter(
                                const media_timed_event *event,
                                bigtime_t lateness,
                                bool realTimeEvent)
{
        CALLED();

        status_t status = B_OK;

        bool chunkSizeUpdated = false, bitRateUpdated = false, bufferPeriodUpdated = false;

        size_t dataSize = size_t(event->data);
        int64 param = int64(event->bigdata);

        switch (param) {
                case DEFAULT_CHUNK_SIZE_PARAM:
                        PRINT("(DEFAULT_CHUNK_SIZE_PARAM,size=%ld",dataSize);
                        if (dataSize < sizeof(size_t)) {
                                PRINT("\ŧ<- B_BAD_VALUE: %lld\n",param);
                                status = B_BAD_VALUE;
                        } else {
                                size_t newDefaultChunkSize = *((size_t*)event->user_data);
                                PRINT(",%ld)\n", newDefaultChunkSize);
                                // ignore non positive chunk sizes
                                // XXX: we may decide later that a 0 chunk size means ship the whole file in one chunk (!)
                                if ((newDefaultChunkSize > 0) && (newDefaultChunkSize != fDefaultChunkSizeParam)) {
                                        PRINT("\tgot a new chunk size, old chunk size was %ld\n",fDefaultChunkSizeParam);
                                        fDefaultChunkSizeParam = newDefaultChunkSize;
                                        fDefaultChunkSizeParamChangeTime = TimeSource()->Now();
                                        chunkSizeUpdated = true;
                                        if (fLeastRecentlyUpdatedParameter == DEFAULT_CHUNK_SIZE_PARAM) {
                                                // Okay we were the least recently updated parameter,
                                                // but we just got an update so we are no longer that.
                                                // Let's figure out who the new least recently updated
                                                // parameter is.  We are going to prefer to compute the
                                                // bit rate since you usually don't want to muck with
                                                // the buffer period.  However, if you just set the bitrate
                                                // then we are stuck with making the buffer period the new
                                                // parameter to be computed.
                                                if (fLastUpdatedParameter == DEFAULT_BIT_RATE_PARAM)
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_BUFFER_PERIOD_PARAM;
                                                else
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_BIT_RATE_PARAM;
                                        }
                                        // we just got an update, so we are the new lastUpdatedParameter
                                        fLastUpdatedParameter = DEFAULT_CHUNK_SIZE_PARAM;
                                        // now we have to compute the new value for the leastRecentlyUpdatedParameter
                                        // we use the chunk size change time to preserve "simultaneity" information
                                        if (fLeastRecentlyUpdatedParameter == DEFAULT_BUFFER_PERIOD_PARAM) {
                                                int64 value = int64(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam);
                                                if (value > INT_MAX) {
                                                        // clamp to INT_MAX
                                                        fDefaultBufferPeriodParam = INT_MAX;
                                                        // recompute chunk size
                                                        fDefaultChunkSizeParam = size_t(1024/8000000*fDefaultBitRateParam*fDefaultBufferPeriodParam);
                                                } else {
                                                        fDefaultBufferPeriodParam = MAX(1,value);
                                                }                                                       
                                                fDefaultBufferPeriodParamChangeTime = fDefaultChunkSizeParamChangeTime;
                                                bufferPeriodUpdated = true;
                                        } else { // must have been bit rate
                                                fDefaultBitRateParam = MAX(0.001,8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam);
                                                fDefaultBitRateParamChangeTime = fDefaultChunkSizeParamChangeTime;
                                                bitRateUpdated = true;
                                        }
                                }
                        }
                        break;          
                case DEFAULT_BIT_RATE_PARAM:
                        PRINT("(DEFAULT_BIT_RATE_PARAM,size=%ld",dataSize);
                        if (dataSize < sizeof(float)) {
                                PRINT("\t<- B_BAD_VALUE:lld\n",param);
                                status = B_BAD_VALUE;
                        } else {
                                float newDefaultBitRate = *((float*)event->user_data);
                                PRINT(",%f)\n",newDefaultBitRate);
                                // ignore non positive bitrates
                                if ((newDefaultBitRate > 0) && (newDefaultBitRate != fDefaultBitRateParam)) {
                                        PRINT("\tgot a new bit rate, old bit rate was %ld\n",fDefaultBitRateParam);
                                        fDefaultBitRateParam = newDefaultBitRate;
                                        fDefaultBitRateParamChangeTime = TimeSource()->Now();
                                        bitRateUpdated = true;
                                        if (fLeastRecentlyUpdatedParameter == DEFAULT_BIT_RATE_PARAM) {
                                                // Okay we were the least recently updated parameter,
                                                // but we just got an update so we are no longer that.
                                                // Let's figure out who the new least recently updated
                                                // parameter is.  We are going to prefer to compute the
                                                // chunk size since you usually don't want to muck with
                                                // the buffer period.  However, if you just set the chunk size
                                                // then we are stuck with making the buffer period the new
                                                // parameter to be computed.
                                                if (fLastUpdatedParameter == DEFAULT_CHUNK_SIZE_PARAM) {
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_BUFFER_PERIOD_PARAM;
                                                } else {
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_CHUNK_SIZE_PARAM;
                                                }
                                        }
                                        // we just got an update, so we are the new lastUpdatedParameter
                                        fLastUpdatedParameter = DEFAULT_BIT_RATE_PARAM;
                                        // now we have to compute the new value for the leastRecentlyUpdatedParameter
                                        // we use the bit rate change time to preserve "simultaneity" information
                                        if (fLeastRecentlyUpdatedParameter == DEFAULT_BUFFER_PERIOD_PARAM) {
                                                int64 value = 
                                                                int64(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam);
                                                if (value > INT_MAX) {
                                                        // clamp to INT_MAX
                                                        fDefaultBufferPeriodParam = INT_MAX;
                                                        // recompute bit rate
                                                        fDefaultBitRateParam = MAX(0.001,
                                                                                8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam);
                                                } else {
                                                        fDefaultBufferPeriodParam = MAX(1,int32(value));
                                                }
                                                fDefaultBufferPeriodParamChangeTime = fDefaultBitRateParamChangeTime;
                                                bufferPeriodUpdated = true;
                                        } else { // must have been chunk size
                                                int64 value = 
                                                                int64(1024/8000000*fDefaultBitRateParam*fDefaultBufferPeriodParam);
                                                if (value > INT_MAX) {
                                                        // clamp to INT_MAX
                                                        fDefaultChunkSizeParam = INT_MAX;
                                                        // recompute bit rate
                                                        fDefaultBitRateParam = 
                                                                        MAX(0.001,8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam);
                                                } else {
                                                        fDefaultChunkSizeParam = MAX(1,int32(value));
                                                }
                                                fDefaultChunkSizeParamChangeTime = fDefaultBitRateParamChangeTime;
                                                chunkSizeUpdated = true;
                                        }
                                }
                        }
                        break;          
                case DEFAULT_BUFFER_PERIOD_PARAM:
                        PRINT("(DEFAULT_BUFFER_PERIOD_PARAM,size=%ld",dataSize);
                        if (dataSize < sizeof(int32)) {
                                PRINT("\t<- B_BAD_VALUE:%ld\n",param);
                                status = B_BAD_VALUE;
                        } else {
                                int32 newBufferPeriod = *((int32*)event->user_data);
                                PRINT(",%ld)\n",newBufferPeriod);
                                // ignore non positive buffer period
                                if ((newBufferPeriod > 0) && (newBufferPeriod != fDefaultBufferPeriodParam)) {
                                        PRINT("\tgot a new buffer period, old buffer period was %ld\n",
                                                  fDefaultBufferPeriodParam);
                                        fDefaultBufferPeriodParam = newBufferPeriod;
                                        fDefaultBufferPeriodParamChangeTime = TimeSource()->Now();
                                        bufferPeriodUpdated = true;
                                        if (fLastUpdatedParameter == DEFAULT_BUFFER_PERIOD_PARAM) {
                                                // prefer to update bit rate, unless you just set it
                                                if (fLastUpdatedParameter == DEFAULT_BIT_RATE_PARAM) {
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_CHUNK_SIZE_PARAM;
                                                } else {
                                                        fLeastRecentlyUpdatedParameter = DEFAULT_BIT_RATE_PARAM;
                                                }
                                        }
                                        // we just got an update, so we are the new lastUpdatedParameter
                                        fLastUpdatedParameter = DEFAULT_BUFFER_PERIOD_PARAM;
                                        // now we have to compute the new value for the leastRecentlyUpdatedParameter
                                        // we use the buffer period change time to preserve "simultaneity" information
                                        if (fLeastRecentlyUpdatedParameter == DEFAULT_BIT_RATE_PARAM) {
                                                fDefaultBitRateParam = 
                                                                MAX(0.001,8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam);
                                                fDefaultBitRateParamChangeTime = fDefaultBufferPeriodParamChangeTime;
                                                bitRateUpdated = true;
                                        } else { // must have been chunk size
                                                int64 value = int64(1024/8000000*fDefaultBitRateParam*fDefaultBufferPeriodParam);
                                                if (value > INT_MAX) {
                                                        // clamp to INT_MAX
                                                        fDefaultChunkSizeParam = INT_MAX;
                                                        // recompute buffer period
                                                        fDefaultBufferPeriodParam = 
                                                                        size_t(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam);
                                                } else {
                                                        fDefaultChunkSizeParam = MAX(1,int32(value));
                                                }
                                                fDefaultChunkSizeParamChangeTime = fDefaultBufferPeriodParamChangeTime;
                                                chunkSizeUpdated = true;
                                        }                                       
                                }
                        }
                        break;  
                default:
                        PRINT("AbstractFileInterfaceNode::HandleParameter called with unknown param id (%ld)\n",param);
                        status = B_ERROR;
        }
        // send updates out for all the parameters that changed
        // in every case this should be two updates. (if I have not made an error :-) )
        if (chunkSizeUpdated) {
                PRINT("\tchunk size parameter updated\n");
                BroadcastNewParameterValue(fDefaultChunkSizeParamChangeTime,
                                                                   DEFAULT_CHUNK_SIZE_PARAM,
                                                                   &fDefaultChunkSizeParam,
                                                                   sizeof(fDefaultChunkSizeParam));
        }
        if (bitRateUpdated) {
                PRINT("\tbit rate parameter updated\n");
                BroadcastNewParameterValue(fDefaultBitRateParamChangeTime,
                                                                   DEFAULT_BIT_RATE_PARAM,
                                                                   &fDefaultBitRateParam,
                                                                   sizeof(fDefaultBitRateParam));
        }
        if (bufferPeriodUpdated) {
                PRINT("\tbuffer period parameter updated\n");
                BroadcastNewParameterValue(fDefaultBufferPeriodParamChangeTime,
                                                                   DEFAULT_BUFFER_PERIOD_PARAM,
                                                                   &fDefaultBufferPeriodParam,
                                                                   sizeof(fDefaultBufferPeriodParam));
        }
        return status;
}


// -------------------------------------------------------- //
// AbstractFileInterfaceNode specific functions
// -------------------------------------------------------- //
void AbstractFileInterfaceNode::GetFlavor(flavor_info * info, int32 id)
{
        CALLED();

        if (info == 0)
                return;

        info->name = strdup("AbstractFileInterfaceNode");
        info->info = strdup("A AbstractFileInterfaceNode node handles a file.");
        info->kinds = B_FILE_INTERFACE | B_CONTROLLABLE;
        info->flavor_flags = B_FLAVOR_IS_LOCAL;
        info->possible_count = INT_MAX;
        info->in_format_count = 0; // no inputs
        info->in_formats = 0;
        info->out_format_count = 0; // no outputs
        info->out_formats = 0;
        info->internal_id = id;
        return;
}


void AbstractFileInterfaceNode::GetFormat(media_format * outFormat)
{
        CALLED();

        if (outFormat == 0)
                return;

        outFormat->type = B_MEDIA_MULTISTREAM;
        outFormat->require_flags = B_MEDIA_MAUI_UNDEFINED_FLAGS;
        outFormat->deny_flags = B_MEDIA_MAUI_UNDEFINED_FLAGS;   
        outFormat->u.multistream = media_multistream_format::wildcard;
}


void AbstractFileInterfaceNode::GetFileFormat(media_file_format * outFileFormat)
{
        CALLED();

        if (outFileFormat == 0)
                return;

        outFileFormat->capabilities =
                          media_file_format::B_PERFECTLY_SEEKABLE
                        | media_file_format::B_IMPERFECTLY_SEEKABLE
                        | media_file_format::B_KNOWS_ANYTHING;
        /* I don't know what to initialize this to. (or if I should) */
        // format.id =
        outFileFormat->family = B_ANY_FORMAT_FAMILY;
        outFileFormat->version = 100;
        // see media_file_format in <MediaDefs.h> for limits
        strncpy(outFileFormat->mime_type,"",63);
        outFileFormat->mime_type[63]='\0';
        strncpy(outFileFormat->pretty_name,"any media file format",63);
        outFileFormat->pretty_name[63]='\0';
        strncpy(outFileFormat->short_name,"any",31);
        outFileFormat->short_name[31]='\0';
        strncpy(outFileFormat->file_extension,"",7);
        outFileFormat->file_extension[7]='\0';  
}


// protected:
// Here we make some guesses based on the file's mime type.
// We don't have enough information to add any other requirements.
// This function doesn't complain if you have already decided you want
// the stream to be considered a different one. (so you can say that you
// want to read that mpeg file as avi if you are so nutty.)
//
status_t AbstractFileInterfaceNode::AddRequirements(media_format * format)
{
        if (strcmp("video/x-msvideo",f_current_mime_type) == 0) {
                if (format->u.multistream.format == media_multistream_format::wildcard.format) {
                        format->u.multistream.format = media_multistream_format::B_AVI;
                }
        } else
        if (strcmp("video/mpeg",f_current_mime_type) == 0) {
                if (format->u.multistream.format == media_multistream_format::wildcard.format) {
                        format->u.multistream.format = media_multistream_format::B_MPEG1;
                }
        } else
        if (strcmp("video/quicktime",f_current_mime_type) == 0) {
                if (format->u.multistream.format == media_multistream_format::wildcard.format) {
                        format->u.multistream.format = media_multistream_format::B_QUICKTIME;
                }
        } else
        if (strcmp("audio/x-mpeg",f_current_mime_type) == 0) {
                if (format->u.multistream.format == media_multistream_format::wildcard.format) {
                        format->u.multistream.format = media_multistream_format::B_MPEG1;
                }
        }
        return B_OK;
}


// We need some sort of bit rate and chunk size, so if the other guy
// didn't care, we'll use our own defaults.
status_t AbstractFileInterfaceNode::ResolveWildcards(media_format * format)
{
        CALLED();
        // There isn't an unknown format. hmph.
        //      if (format->u.multistream.format == media_multistream_format::wildcard.format) {
        //              format->u.multistream.format = media_multistream_format::B_UNKNOWN;
        //      }
        if (format->u.multistream.max_bit_rate == media_multistream_format::wildcard.max_bit_rate) {
                format->u.multistream.max_bit_rate = fDefaultBitRateParam;
        }
        if (format->u.multistream.max_chunk_size == media_multistream_format::wildcard.max_chunk_size) {
                format->u.multistream.max_chunk_size = fDefaultChunkSizeParam;
        }
        if (format->u.multistream.avg_bit_rate == media_multistream_format::wildcard.avg_bit_rate) {
                format->u.multistream.avg_bit_rate = fDefaultBitRateParam;
        }
        if (format->u.multistream.avg_chunk_size == media_multistream_format::wildcard.avg_chunk_size) {
                format->u.multistream.avg_chunk_size = fDefaultChunkSizeParam;
        }
        return B_OK;
}


// -------------------------------------------------------- //
// stuffing
// -------------------------------------------------------- //
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_0(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_1(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_2(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_3(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_4(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_5(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_6(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_7(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_8(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_9(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_10(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_11(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_12(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_13(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_14(void *) { return B_ERROR; }
status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_15(void *) { return B_ERROR; }