From fb16552f1d8841cf228011dc694e887ed421bbdb Mon Sep 17 00:00:00 2001 From: Maurice Kalinowski Date: Mon, 31 Mar 2008 21:23:38 +0000 Subject: [PATCH] * get reader.media_addon compiling (both gcc2 and 4)(used for testing BFileInterface node kind) * warning/style fixes * removed some dubious comments :) * no behaviour changes so far... git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@24714 a95241bf-73f2-0310-859d-f6bbb57e9c96 --- .../AbstractFileInterfaceAddOn.cpp | 141 +++--- .../AbstractFileInterfaceNode.cpp | 430 ++++++++++-------- .../media-add-ons/AbstractFileInterfaceNode.h | 11 +- src/add-ons/media/media-add-ons/Jamfile | 2 +- .../media/media-add-ons/reader/Jamfile | 9 +- .../media-add-ons/reader/MediaReader.cpp | 396 +++++++++------- .../media-add-ons/reader/MediaReaderAddOn.cpp | 108 +++-- 7 files changed, 623 insertions(+), 474 deletions(-) diff --git a/src/add-ons/media/media-add-ons/AbstractFileInterfaceAddOn.cpp b/src/add-ons/media/media-add-ons/AbstractFileInterfaceAddOn.cpp index a4ef43ae3e..b4b388b0ea 100644 --- a/src/add-ons/media/media-add-ons/AbstractFileInterfaceAddOn.cpp +++ b/src/add-ons/media/media-add-ons/AbstractFileInterfaceAddOn.cpp @@ -8,55 +8,49 @@ // AbstractFileInterfaceNode handles a file and a multistream -#include -#include -#include -#include -#include -#include - #include "AbstractFileInterfaceNode.h" #include "AbstractFileInterfaceAddOn.h" +#include "debug.h" + +#include +#include +#include +#include +#include +#include + #include #include #include -// instantiation function -extern "C" _EXPORT BMediaAddOn * make_media_addon(image_id image); -// { -// return new AbstractFileInterfaceAddOn(image); -// } - -// -------------------------------------------------------- // -// ctor/dtor -// -------------------------------------------------------- // AbstractFileInterfaceAddOn::~AbstractFileInterfaceAddOn() { } + AbstractFileInterfaceAddOn::AbstractFileInterfaceAddOn(image_id image) : BMediaAddOn(image) { - fprintf(stderr,"AbstractFileInterfaceAddOn::AbstractFileInterfaceAddOn\n"); + CALLED(); refCount = 0; } - + + // -------------------------------------------------------- // // BMediaAddOn impl // -------------------------------------------------------- // - status_t AbstractFileInterfaceAddOn::InitCheck( const char ** out_failure_text) { - fprintf(stderr,"AbstractFileInterfaceAddOn::InitCheck\n"); + CALLED(); return B_OK; } int32 AbstractFileInterfaceAddOn::CountFlavors() { - fprintf(stderr,"AbstractFileInterfaceAddOn::CountFlavors\n"); + CALLED(); return 1; } @@ -64,70 +58,77 @@ status_t AbstractFileInterfaceAddOn::GetFlavorAt( int32 n, const flavor_info ** out_info) { - fprintf(stderr,"AbstractFileInterfaceAddOn::GetFlavorAt\n"); + CALLED(); + if (out_info == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid - } + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash + } if (n != 0) { - fprintf(stderr,"<- B_BAD_INDEX\n"); + PRINT("\t<- B_BAD_INDEX\n"); return B_BAD_INDEX; } + flavor_info * infos = new flavor_info[1]; AbstractFileInterfaceNode::GetFlavor(&infos[0],n); (*out_info) = infos; return B_OK; } + status_t AbstractFileInterfaceAddOn::GetConfigurationFor( BMediaNode * your_node, BMessage * into_message) { - fprintf(stderr,"AbstractFileInterfaceAddOn::GetConfigurationFor\n"); + CALLED(); if (into_message == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash } AbstractFileInterfaceNode * node = dynamic_cast(your_node); if (node == 0) { - fprintf(stderr,"<- B_BAD_TYPE\n"); + PRINT("\t<- B_BAD_TYPE\n"); return B_BAD_TYPE; } return node->GetConfigurationFor(into_message); } + bool AbstractFileInterfaceAddOn::WantsAutoStart() { - fprintf(stderr,"AbstractFileInterfaceAddOn::WantsAutoStart\n"); + CALLED(); return false; } + status_t AbstractFileInterfaceAddOn::AutoStart( int in_count, BMediaNode ** out_node, int32 * out_internal_id, bool * out_has_more) { - fprintf(stderr,"AbstractFileInterfaceAddOn::AutoStart\n"); + CALLED(); return B_OK; } + // -------------------------------------------------------- // // BMediaAddOn impl for B_FILE_INTERFACE nodes // -------------------------------------------------------- // - status_t AbstractFileInterfaceAddOn::SniffRef( const entry_ref & file, BMimeType * io_mime_type, float * out_quality, int32 * out_internal_id) { - fprintf(stderr,"AbstractFileInterfaceAddOn::SniffRef\n"); + CALLED(); + if ((io_mime_type == 0) || (out_quality == 0) || (out_internal_id == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash } + *out_internal_id = 0; // only one flavor char mime_string[B_MIME_TYPE_LENGTH+1]; status_t status = AbstractFileInterfaceNode::StaticSniffRef(file,mime_string,out_quality); @@ -135,6 +136,7 @@ status_t AbstractFileInterfaceAddOn::SniffRef( return status; } + // even though I implemented SniffTypeKind below and this shouldn't get called, // I am going to implement it anyway. I'll use it later anyhow. status_t AbstractFileInterfaceAddOn::SniffType( @@ -142,16 +144,19 @@ status_t AbstractFileInterfaceAddOn::SniffType( float * out_quality, int32 * out_internal_id) { - fprintf(stderr,"AbstractFileInterfaceAddOn::SniffType\n"); + CALLED(); + if ((out_quality == 0) || (out_internal_id == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid - } + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash + } + *out_quality = 1.0; *out_internal_id = 0; return B_OK; } + // This function treats null pointers slightly differently than the others. // This is because a program could reasonably call this function with just // about any junk, get the out_read_items or out_write_items and then use @@ -168,23 +173,25 @@ status_t AbstractFileInterfaceAddOn::GetFileFormatList( int32 * out_read_items, void * _reserved) { - fprintf(stderr,"AbstractFileInterfaceAddOn::GetFileFormatList\n"); + CALLED(); + if (flavor_id != 0) { // this is a sanity check for now - fprintf(stderr,"<- B_BAD_INDEX\n"); + PRINT("\t<- B_BAD_INDEX\n"); return B_BAD_INDEX; } // see null check comment above - if (out_write_items != 0) { + if (out_write_items != 0) *out_write_items = 0; - } + // see null check comment above - if (out_read_items != 0) { + if (out_read_items != 0) *out_read_items = 0; - } + return B_OK; } + status_t AbstractFileInterfaceAddOn::SniffTypeKind( const BMimeType & type, uint64 in_kinds, @@ -193,10 +200,11 @@ status_t AbstractFileInterfaceAddOn::SniffTypeKind( int32 * out_internal_id, void * _reserved) { - fprintf(stderr,"AbstractFileInterfaceAddOn::SniffTypeKind\n"); + CALLED(); + if ((out_quality == 0) || (out_internal_id == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash } if (in_kinds & (io_kind | B_FILE_INTERFACE | B_CONTROLLABLE)) { return SniffType(type,out_quality,out_internal_id); @@ -205,11 +213,12 @@ status_t AbstractFileInterfaceAddOn::SniffTypeKind( // just in case they try to do something with it anyway (!) *out_quality = 0; *out_internal_id = -1; - fprintf(stderr,"<- B_BAD_TYPE\n"); + PRINT("\t<- B_BAD_TYPE\n"); return B_BAD_TYPE; } } + // -------------------------------------------------------- // // main // -------------------------------------------------------- // @@ -222,19 +231,19 @@ status_t AbstractFileInterfaceAddOn::SniffTypeKind( // stuffing // -------------------------------------------------------- // -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_0(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_1(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_2(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_3(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_4(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_5(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_6(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_7(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_8(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_9(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_10(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_11(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_12(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_13(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_14(void *) {}; -status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_15(void *) {}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_0(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_1(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_2(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_3(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_4(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_5(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_6(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_7(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_8(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_9(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_10(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_11(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_12(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_13(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_14(void *) {return B_ERROR;}; +status_t AbstractFileInterfaceAddOn::_Reserved_AbstractFileInterfaceAddOn_15(void *) {return B_ERROR;}; diff --git a/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.cpp b/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.cpp index 1cd5c66728..cbd46e197c 100644 --- a/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.cpp +++ b/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.cpp @@ -5,69 +5,68 @@ // The AbstractFileInterfaceNode class implements // the common functionality between MediaReader // and MediaWriter. +#include "AbstractFileInterfaceNode.h" +#include "debug.h" -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include - -#include "AbstractFileInterfaceNode.h" - #include #include -// -------------------------------------------------------- // -// ctor/dtor -// -------------------------------------------------------- // AbstractFileInterfaceNode::~AbstractFileInterfaceNode(void) { - fprintf(stderr,"AbstractFileInterfaceNode::~AbstractFileInterfaceNode\n"); + CALLED(); + // Stop the BMediaEventLooper thread Quit(); - if (fCurrentFile != 0) { + if (fCurrentFile != 0) delete fCurrentFile; - } } + AbstractFileInterfaceNode::AbstractFileInterfaceNode( - size_t defaultChunkSize = 8192, - float defaultBitRate = 800000, - const flavor_info * info = 0, - BMessage * config = 0, - BMediaAddOn * addOn = 0) + size_t defaultChunkSize, + float defaultBitRate, + const flavor_info * info, + BMessage * config, + BMediaAddOn * addOn) : BMediaNode("AbstractFileInterfaceNode"), BFileInterface(), BControllable(), BMediaEventLooper() { - fprintf(stderr,"AbstractFileInterfaceNode::AbstractFileInterfaceNode\n"); + 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 @@ -85,99 +84,108 @@ AbstractFileInterfaceNode::AbstractFileInterfaceNode( fInitCheckStatus = B_OK; } + status_t AbstractFileInterfaceNode::InitCheck(void) const { - fprintf(stderr,"AbstractFileInterfaceNode::InitCheck\n"); + CALLED(); return fInitCheckStatus; } + status_t AbstractFileInterfaceNode::GetConfigurationFor( BMessage * into_message) { - fprintf(stderr,"AbstractFileInterfaceNode::GetConfigurationFor\n"); + CALLED(); return B_OK; } + // -------------------------------------------------------- // // implementation of BMediaNode // -------------------------------------------------------- // - BMediaAddOn * AbstractFileInterfaceNode::AddOn( int32 * internal_id) const { - fprintf(stderr,"AbstractFileInterfaceNode::AddOn\n"); + 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) { + if (internal_id != 0) internal_id = 0; - } } return fAddOn; } + void AbstractFileInterfaceNode::Start( bigtime_t performance_time) { - fprintf(stderr,"AbstractFileInterfaceNode::Start(pt=%lld)\n",performance_time); + PRINT("AbstractFileInterfaceNode::Start(pt=%lld)\n",performance_time); BMediaEventLooper::Start(performance_time); } + void AbstractFileInterfaceNode::Stop( bigtime_t performance_time, bool immediate) { - if (immediate) { - fprintf(stderr,"AbstractFileInterfaceNode::Stop(pt=%lld,)\n",performance_time); - } else { - fprintf(stderr,"AbstractFileInterfaceNode::Stop(pt=%lld,)\n",performance_time); - } + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::Seek(mt=%lld,pt=%lld)\n",media_time,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) { - fprintf(stderr,"AbstractFileInterfaceNode::SetRunMode(%i)\n",mode); + PRINT("AbstractFileInterfaceNode::SetRunMode(%i)\n",mode); BMediaEventLooper::SetRunMode(mode); } + void AbstractFileInterfaceNode::TimeWarp( bigtime_t at_real_time, bigtime_t to_performance_time) { - fprintf(stderr,"AbstractFileInterfaceNode::TimeWarp(rt=%lld,pt=%lld)\n",at_real_time,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) { - fprintf(stderr,"AbstractFileInterfaceNode::Preroll\n"); + CALLED(); // XXX:Performance opportunity BMediaNode::Preroll(); } + void AbstractFileInterfaceNode::SetTimeSource( BTimeSource * time_source) { - fprintf(stderr,"AbstractFileInterfaceNode::SetTimeSource\n"); + CALLED(); BMediaNode::SetTimeSource(time_source); } + status_t AbstractFileInterfaceNode::HandleMessage( int32 message, const void * data, size_t size) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleMessage\n"); + CALLED(); + status_t status = B_OK; switch (message) { // no special messages for now @@ -186,6 +194,9 @@ status_t AbstractFileInterfaceNode::HandleMessage( 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; @@ -197,23 +208,26 @@ status_t AbstractFileInterfaceNode::HandleMessage( return status; } + status_t AbstractFileInterfaceNode::RequestCompleted( const media_request_info & info) { - fprintf(stderr,"AbstractFileInterfaceNode::RequestCompleted\n"); + CALLED(); return BMediaNode::RequestCompleted(info); } + status_t AbstractFileInterfaceNode::DeleteHook( BMediaNode * node) { - fprintf(stderr,"AbstractFileInterfaceNode::DeleteHook\n"); + CALLED(); return BMediaEventLooper::DeleteHook(node); } + void AbstractFileInterfaceNode::NodeRegistered(void) { - fprintf(stderr,"AbstractFileInterfaceNode::NodeRegistered\n"); + CALLED(); // set up our parameter web SetParameterWeb(MakeParameterWeb()); @@ -223,33 +237,36 @@ void AbstractFileInterfaceNode::NodeRegistered(void) Run(); } + status_t AbstractFileInterfaceNode::GetNodeAttributes( media_node_attribute * outAttributes, size_t inMaxCount) { - fprintf(stderr,"AbstractFileInterfaceNode::GetNodeAttributes\n"); + CALLED(); return BMediaNode::GetNodeAttributes(outAttributes,inMaxCount); } + status_t AbstractFileInterfaceNode::AddTimer( bigtime_t at_performance_time, int32 cookie) { - fprintf(stderr,"AbstractFileInterfaceNode::AddTimer\n"); + CALLED(); return BMediaEventLooper::AddTimer(at_performance_time,cookie); } -// protected: +// protected: BParameterWeb * AbstractFileInterfaceNode::MakeParameterWeb(void) { - fprintf(stderr,"AbstractFileInterfaceNode::MakeParameterWeb\n"); + 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 + // 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( @@ -277,76 +294,87 @@ BParameterWeb * AbstractFileInterfaceNode::MakeParameterWeb(void) return web; } + // -------------------------------------------------------- // // implementation of BFileInterface // -------------------------------------------------------- // - status_t AbstractFileInterfaceNode::GetNextFileFormat( int32 * cookie, media_file_format * out_format) { - fprintf(stderr,"AbstractFileInterfaceNode::GetNextFileFormat\n"); - // let's not crash even if they are stupid + CALLED(); + + // avoid crashes if (out_format == 0) { // no place to write! - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; } + if (cookie != 0) { // it's valid but they already got our 1 file format if (*cookie != 0) { - fprintf(stderr,"<- B_ERROR\n"); + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::DisposeFileFormatCookie\n"); + CALLED(); // nothing to do since our cookies are just integers } + status_t AbstractFileInterfaceNode::GetDuration( bigtime_t * out_time) { - fprintf(stderr,"AbstractFileInterfaceNode::GetDuration\n"); + CALLED(); if (out_time == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; } + if (fCurrentFile == 0) { - fprintf(stderr,"<- B_NO_INIT\n"); + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::SniffRef\n"); + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::SetRef\n"); + CALLED(); + if (out_time == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; // no crashes today thanks } + status_t status; f_current_ref = file; if (fCurrentFile == 0) { @@ -355,77 +383,88 @@ status_t AbstractFileInterfaceNode::SetRef( } else { status = fCurrentFile->SetTo(&f_current_ref,(openMode|(create?B_CREATE_FILE:0))); } + if (status != B_OK) { - fprintf(stderr,"<- failed BFile initialization\n"); + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::GetRef\n"); + CALLED(); + if ((out_ref == 0) || (out_mime_type == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // no crashes today thanks + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash } + if (fCurrentFile == 0) { - fprintf(stderr,"<- B_NO_INIT\n"); + 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 +// provided for BAbstractFileInterfaceNodeAddOn status_t AbstractFileInterfaceNode::StaticSniffRef( const entry_ref & file, char * out_mime_type, /* 256 bytes */ float * out_quality) { - fprintf(stderr,"AbstractFileInterfaceNode::StaticSniffRef\n"); + CALLED(); + if ((out_mime_type == 0) || (out_quality == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid - } + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash + } + BNode node(&file); status_t initCheck = node.InitCheck(); if (initCheck != B_OK) { - fprintf(stderr,"<- failed BNode::InitCheck()\n"); + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::GetParameterValue\n"); - if ((last_change == 0) || (value == 0) || (ioSize == 0)) { + CALLED(); + + if ((last_change == 0) || (value == 0) || (ioSize == 0)) return B_BAD_VALUE; // no crashing - } + switch (id) { case DEFAULT_CHUNK_SIZE_PARAM: if (*ioSize < sizeof(size_t)) { @@ -455,19 +494,22 @@ status_t AbstractFileInterfaceNode::GetParameterValue( break; default: - fprintf(stderr,"AbstractFileInterfaceNode::GetParameterValue unknown id (%i)\n",id); + PRINT("AbstractFileInterfaceNode::GetParameterValue unknown id (%ld)\n",id); return B_ERROR; } - return B_OK; + + return B_OK; } - + + void AbstractFileInterfaceNode::SetParameterValue( int32 id, bigtime_t when, const void * value, size_t size) { - fprintf(stderr,"AbstractFileInterfaceNode::SetParameterValue(id=%i,when=%lld,size=%i)\n",id,when,int32(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: @@ -481,28 +523,30 @@ void AbstractFileInterfaceNode::SetParameterValue( break; default: - fprintf(stderr,"AbstractFileInterfaceNode::SetParameterValue unknown id (%i)\n",id); + 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) { - BControllable::StartControlPanel(out_messenger); + CALLED(); + return BControllable::StartControlPanel(out_messenger); } + // -------------------------------------------------------- // // implementation for BMediaEventLooper // -------------------------------------------------------- // - void AbstractFileInterfaceNode::HandleEvent( const media_timed_event *event, bigtime_t lateness, - bool realTimeEvent = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleEvent\n"); + CALLED(); switch (event->type) { case BTimedEventQueue::B_START: HandleStart(event,lateness,realTimeEvent); @@ -528,32 +572,35 @@ void AbstractFileInterfaceNode::HandleEvent( HandleParameter(event,lateness,realTimeEvent); break; default: - fprintf(stderr," unknown event type: %i\n",event->type); + 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() { - fprintf(stderr,"AbstractFileInterfaceNode::OfflineTime\n"); + CALLED(); return BMediaEventLooper::OfflineTime(); -// XXX: do something else? -// if (inputFile == 0) { -// return 0; -// } else { -// return inputFile->Position(); -// } + // 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: */ @@ -562,80 +609,91 @@ void AbstractFileInterfaceNode::ControlLoop() { BMediaEventLooper::ControlLoop(); } -// protected: +// protected: status_t AbstractFileInterfaceNode::HandleStart( const media_timed_event *event, bigtime_t lateness, - bool realTimeEvent = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleStart()\n"); + 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); + // 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 = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleSeek(t=%lld,d=%i,bd=%lld)\n",event->event_time,event->data,event->bigdata); - if (fCurrentFile != 0) { - fCurrentFile->Seek(event->bigdata,SEEK_SET); - } + 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 = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleWarp\n"); + CALLED(); + return B_OK; } + status_t AbstractFileInterfaceNode::HandleStop( const media_timed_event *event, bigtime_t lateness, - bool realTimeEvent = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleStop\n"); + 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 = false) + bool realTimeEvent) { - fprintf(stderr,"AbstractFileInterfaceNode::HandleParameter"); + 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: - fprintf(stderr,"(DEFAULT_CHUNK_SIZE_PARAM,size=%i",dataSize); + PRINT("(DEFAULT_CHUNK_SIZE_PARAM,size=%ld",dataSize); if (dataSize < sizeof(size_t)) { - fprintf(stderr,")\n"); - fprintf(stderr,"<- B_BAD_VALUE\n",param); + PRINT("\ŧ<- B_BAD_VALUE: %lld\n",param); status = B_BAD_VALUE; } else { size_t newDefaultChunkSize = *((size_t*)event->user_data); - fprintf(stderr,",%i)\n",newDefaultChunkSize); + 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)) { - fprintf(stderr," got a new chunk size, old chunk size was %i\n",fDefaultChunkSizeParam); + PRINT("\tgot a new chunk size, old chunk size was %ld\n",fDefaultChunkSizeParam); fDefaultChunkSizeParam = newDefaultChunkSize; fDefaultChunkSizeParamChangeTime = TimeSource()->Now(); chunkSizeUpdated = true; @@ -648,11 +706,10 @@ status_t AbstractFileInterfaceNode::HandleParameter( // 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) { + if (fLastUpdatedParameter == DEFAULT_BIT_RATE_PARAM) fLeastRecentlyUpdatedParameter = DEFAULT_BUFFER_PERIOD_PARAM; - } else { + else fLeastRecentlyUpdatedParameter = DEFAULT_BIT_RATE_PARAM; - } } // we just got an update, so we are the new lastUpdatedParameter fLastUpdatedParameter = DEFAULT_CHUNK_SIZE_PARAM; @@ -679,17 +736,16 @@ status_t AbstractFileInterfaceNode::HandleParameter( } break; case DEFAULT_BIT_RATE_PARAM: - fprintf(stderr,"(DEFAULT_BIT_RATE_PARAM,size=%i",dataSize); + PRINT("(DEFAULT_BIT_RATE_PARAM,size=%ld",dataSize); if (dataSize < sizeof(float)) { - fprintf(stderr,")\n"); - fprintf(stderr,"<- B_BAD_VALUE\n",param); + PRINT("\t<- B_BAD_VALUE:lld\n",param); status = B_BAD_VALUE; } else { float newDefaultBitRate = *((float*)event->user_data); - fprintf(stderr,",%f)\n",newDefaultBitRate); + PRINT(",%f)\n",newDefaultBitRate); // ignore non positive bitrates if ((newDefaultBitRate > 0) && (newDefaultBitRate != fDefaultBitRateParam)) { - fprintf(stderr," got a new bit rate, old bit rate was %i\n",fDefaultBitRateParam); + PRINT("\tgot a new bit rate, old bit rate was %ld\n",fDefaultBitRateParam); fDefaultBitRateParam = newDefaultBitRate; fDefaultBitRateParamChangeTime = TimeSource()->Now(); bitRateUpdated = true; @@ -713,24 +769,28 @@ status_t AbstractFileInterfaceNode::HandleParameter( // 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); + 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); + 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); + 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); + fDefaultBitRateParam = + MAX(0.001,8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam); } else { fDefaultChunkSizeParam = MAX(1,int32(value)); } @@ -741,17 +801,17 @@ status_t AbstractFileInterfaceNode::HandleParameter( } break; case DEFAULT_BUFFER_PERIOD_PARAM: - fprintf(stderr,"(DEFAULT_BUFFER_PERIOD_PARAM,size=%i",dataSize); + PRINT("(DEFAULT_BUFFER_PERIOD_PARAM,size=%ld",dataSize); if (dataSize < sizeof(int32)) { - fprintf(stderr,")\n"); - fprintf(stderr,"<- B_BAD_VALUE\n",param); + PRINT("\t<- B_BAD_VALUE:%ld\n",param); status = B_BAD_VALUE; } else { int32 newBufferPeriod = *((int32*)event->user_data); - fprintf(stderr,",%i)\n",newBufferPeriod); + PRINT(",%ld)\n",newBufferPeriod); // ignore non positive buffer period if ((newBufferPeriod > 0) && (newBufferPeriod != fDefaultBufferPeriodParam)) { - fprintf(stderr," got a new buffer period, old buffer period was %i\n",fDefaultBufferPeriodParam); + PRINT("\tgot a new buffer period, old buffer period was %ld\n", + fDefaultBufferPeriodParam); fDefaultBufferPeriodParam = newBufferPeriod; fDefaultBufferPeriodParamChangeTime = TimeSource()->Now(); bufferPeriodUpdated = true; @@ -768,7 +828,8 @@ status_t AbstractFileInterfaceNode::HandleParameter( // 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); + fDefaultBitRateParam = + MAX(0.001,8000000/1024*fDefaultChunkSizeParam/fDefaultBufferPeriodParam); fDefaultBitRateParamChangeTime = fDefaultBufferPeriodParamChangeTime; bitRateUpdated = true; } else { // must have been chunk size @@ -777,7 +838,8 @@ status_t AbstractFileInterfaceNode::HandleParameter( // clamp to INT_MAX fDefaultChunkSizeParam = INT_MAX; // recompute buffer period - fDefaultBufferPeriodParam = size_t(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam); + fDefaultBufferPeriodParam = + size_t(8000000/1024*fDefaultChunkSizeParam/fDefaultBitRateParam); } else { fDefaultChunkSizeParam = MAX(1,int32(value)); } @@ -788,27 +850,27 @@ status_t AbstractFileInterfaceNode::HandleParameter( } break; default: - fprintf(stderr,"AbstractFileInterfaceNode::HandleParameter called with unknown param id (%i)\n",param); + 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) { - fprintf(stderr," chunk size parameter updated\n"); + PRINT("\tchunk size parameter updated\n"); BroadcastNewParameterValue(fDefaultChunkSizeParamChangeTime, DEFAULT_CHUNK_SIZE_PARAM, &fDefaultChunkSizeParam, sizeof(fDefaultChunkSizeParam)); } if (bitRateUpdated) { - fprintf(stderr," bit rate parameter updated\n"); + PRINT("\tbit rate parameter updated\n"); BroadcastNewParameterValue(fDefaultBitRateParamChangeTime, DEFAULT_BIT_RATE_PARAM, &fDefaultBitRateParam, sizeof(fDefaultBitRateParam)); } if (bufferPeriodUpdated) { - fprintf(stderr," buffer period parameter updated\n"); + PRINT("\tbuffer period parameter updated\n"); BroadcastNewParameterValue(fDefaultBufferPeriodParamChangeTime, DEFAULT_BUFFER_PERIOD_PARAM, &fDefaultBufferPeriodParam, @@ -817,20 +879,19 @@ status_t AbstractFileInterfaceNode::HandleParameter( return status; } + // -------------------------------------------------------- // // AbstractFileInterfaceNode specific functions // -------------------------------------------------------- // - -// public: - void AbstractFileInterfaceNode::GetFlavor(flavor_info * info, int32 id) { - fprintf(stderr,"AbstractFileInterfaceNode::GetFlavor\n"); - if (info == 0) { + CALLED(); + + if (info == 0) return; - } - info->name = "AbstractFileInterfaceNode"; - info->info = "A AbstractFileInterfaceNode node handles a file."; + + 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; @@ -842,24 +903,28 @@ void AbstractFileInterfaceNode::GetFlavor(flavor_info * info, int32 id) return; } + void AbstractFileInterfaceNode::GetFormat(media_format * outFormat) { - fprintf(stderr,"AbstractFileInterfaceNode::GetFormat\n"); - if (outFormat == 0) { + 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) { - fprintf(stderr,"AbstractFileInterfaceNode::GetFileFormat\n"); - if (outFileFormat == 0) { + CALLED(); + + if (outFileFormat == 0) return; - } + outFileFormat->capabilities = media_file_format::B_PERFECTLY_SEEKABLE | media_file_format::B_IMPERFECTLY_SEEKABLE @@ -879,8 +944,8 @@ void AbstractFileInterfaceNode::GetFileFormat(media_file_format * outFileFormat) outFileFormat->file_extension[7]='\0'; } -// protected: +// 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 @@ -912,15 +977,16 @@ status_t AbstractFileInterfaceNode::AddRequirements(media_format * format) 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) { - fprintf(stderr,"AbstractFileInterfaceNode::ResolveWildcards\n"); -// 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; -// } + 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; } @@ -936,23 +1002,23 @@ status_t AbstractFileInterfaceNode::ResolveWildcards(media_format * format) return B_OK; } + // -------------------------------------------------------- // // stuffing // -------------------------------------------------------- // - -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_0(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_1(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_2(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_3(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_4(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_5(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_6(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_7(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_8(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_9(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_10(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_11(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_12(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_13(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_14(void *) {} -status_t AbstractFileInterfaceNode::_Reserved_AbstractFileInterfaceNode_15(void *) {} +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; } diff --git a/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.h b/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.h index 7b62a85dbe..02578cd634 100644 --- a/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.h +++ b/src/add-ons/media/media-add-ons/AbstractFileInterfaceNode.h @@ -9,14 +9,15 @@ #if !defined(_ABSTRACT_FILE_INTERFACE_NODE_H) #define _ABSTRACT_FILE_INTERFACE_NODE_H +#include +#include +#include +#include +#include +#include #include #include -#include -#include #include -#include -#include -#include class AbstractFileInterfaceNode : public BFileInterface, diff --git a/src/add-ons/media/media-add-ons/Jamfile b/src/add-ons/media/media-add-ons/Jamfile index 5319ab2f2e..6d24f31ebf 100644 --- a/src/add-ons/media/media-add-ons/Jamfile +++ b/src/add-ons/media/media-add-ons/Jamfile @@ -1,7 +1,6 @@ SubDir HAIKU_TOP src add-ons media media-add-ons ; # SubInclude HAIKU_TOP src add-ons media media-add-ons demultiplexer ; -# SubInclude HAIKU_TOP src add-ons media media-add-ons reader ; # SubInclude HAIKU_TOP src add-ons media media-add-ons writer ; SubInclude HAIKU_TOP src add-ons media media-add-ons dvb ; SubInclude HAIKU_TOP src add-ons media media-add-ons esound_sink ; @@ -10,6 +9,7 @@ SubInclude HAIKU_TOP src add-ons media media-add-ons mixer ; SubInclude HAIKU_TOP src add-ons media media-add-ons multi_audio ; SubInclude HAIKU_TOP src add-ons media media-add-ons opensound ; SubInclude HAIKU_TOP src add-ons media media-add-ons radeon ; +SubInclude HAIKU_TOP src add-ons media media-add-ons reader ; SubInclude HAIKU_TOP src add-ons media media-add-ons tone_producer_demo ; SubInclude HAIKU_TOP src add-ons media media-add-ons usb_vision ; SubInclude HAIKU_TOP src add-ons media media-add-ons usb_webcam ; diff --git a/src/add-ons/media/media-add-ons/reader/Jamfile b/src/add-ons/media/media-add-ons/reader/Jamfile index d1903af933..9294c97452 100644 --- a/src/add-ons/media/media-add-ons/reader/Jamfile +++ b/src/add-ons/media/media-add-ons/reader/Jamfile @@ -2,12 +2,13 @@ SubDir HAIKU_TOP src add-ons media media-add-ons reader ; UsePrivateHeaders media ; -Addon reader.media_addon : - ../AbstractFileInterfaceNode.cpp - ../AbstractFileInterfaceAddOn.cpp +SEARCH_SOURCE += [ FDirName $(HAIKU_TOP) src add-ons media media-add-ons ] ; + +Application reader.media_addon : + AbstractFileInterfaceNode.cpp + AbstractFileInterfaceAddOn.cpp MediaReader.cpp MediaReaderAddOn.cpp misc.cpp : be media - : true ; diff --git a/src/add-ons/media/media-add-ons/reader/MediaReader.cpp b/src/add-ons/media/media-add-ons/reader/MediaReader.cpp index 6da6bfdc8f..55f26a275e 100644 --- a/src/add-ons/media/media-add-ons/reader/MediaReader.cpp +++ b/src/add-ons/media/media-add-ons/reader/MediaReader.cpp @@ -8,34 +8,32 @@ // which is a multistream. // // see also MediaReaderAddOn.cpp - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - #include "../AbstractFileInterfaceNode.h" #include "MediaReader.h" #include "misc.h" +#include "debug.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + + +#include #include #include -// -------------------------------------------------------- // -// ctor/dtor -// -------------------------------------------------------- // MediaReader::~MediaReader(void) { @@ -47,17 +45,19 @@ MediaReader::~MediaReader(void) } } + MediaReader::MediaReader( - size_t defaultChunkSize = 8192, - float defaultBitRate = 800000, - const flavor_info * info = 0, - BMessage * config = 0, - BMediaAddOn * addOn = 0) + size_t defaultChunkSize, + float defaultBitRate, + const flavor_info * info, + BMessage * config, + BMediaAddOn * addOn) : BMediaNode("MediaReader"), - AbstractFileInterfaceNode(defaultChunkSize,defaultBitRate,info,config,addOn), - BBufferProducer(B_MEDIA_MULTISTREAM) + BBufferProducer(B_MEDIA_MULTISTREAM), + AbstractFileInterfaceNode(defaultChunkSize, defaultBitRate, info, config, addOn) { - fprintf(stderr,"MediaReader::MediaReader\n"); + CALLED(); + // null some fields fBufferGroup = 0; // start enabled @@ -72,24 +72,27 @@ MediaReader::MediaReader( GetFormat(&output.format); } + // -------------------------------------------------------- // // implementation of BMediaNode // -------------------------------------------------------- // - void MediaReader::Preroll(void) { - fprintf(stderr,"MediaReader::Preroll\n"); + CALLED(); // XXX:Performance opportunity BMediaNode::Preroll(); } + status_t MediaReader::HandleMessage( int32 message, const void * data, size_t size) { - fprintf(stderr,"MediaReader::HandleMessage\n"); + CALLED(); + status_t status = B_OK; + switch (message) { // no special messages for now default: @@ -100,12 +103,14 @@ status_t MediaReader::HandleMessage( status = AbstractFileInterfaceNode::HandleMessage(message,data,size); break; } + return status; } + void MediaReader::NodeRegistered(void) { - fprintf(stderr,"MediaReader::NodeRegistered\n"); + CALLED(); // now we can do this output.node = Node(); @@ -116,27 +121,30 @@ void MediaReader::NodeRegistered(void) AbstractFileInterfaceNode::NodeRegistered(); } + // -------------------------------------------------------- // // implementation of BFileInterface // -------------------------------------------------------- // - status_t MediaReader::SetRef( const entry_ref & file, bool create, bigtime_t * out_time) { - fprintf(stderr,"MediaReader::SetRef\n"); + CALLED(); + status_t status = AbstractFileInterfaceNode::SetRef(file,B_READ_ONLY,create,out_time); if (status != B_OK) { - fprintf(stderr,"AbstractFileInterfaceNode::SetRef returned an error\n"); + PRINT("AbstractFileInterfaceNode::SetRef returned an error\n"); return status; } + if (output.destination == media_destination::null) { // reset the format, and set the requirements imposed by this file GetFormat(&output.format); AddRequirements(&output.format); return B_OK; } + // if we are connected we may have to re-negotiate the connection media_format format; GetFormat(&format); @@ -147,29 +155,30 @@ status_t MediaReader::SetRef( } // first try the easy way : SORRY DEPRECATED into private :-( // this code from MediaWriter would be different for MediaReader even if it worked... -// int32 change_tag = NewChangeTag(); -// status = this->BBufferConsumer::RequestFormatChange(output.source,output.destination,&format,&change_tag); -// if (status == B_OK) { -// fprintf(stderr," format change successful\n"); -// return B_OK; -// } + // int32 change_tag = NewChangeTag(); + // status = this->BBufferConsumer::RequestFormatChange(output.source,output.destination,&format,&change_tag); + // if (status == B_OK) { + // fprintf(stderr," format change successful\n"); + // return B_OK; + // } + // okay, the hard way requires we get the MediaRoster BMediaRoster * roster = BMediaRoster::Roster(&status); - if (roster == 0) { + if (roster == 0) return B_MEDIA_SYSTEM_FAILURE; - } - if (status != B_OK) { + + if (status != B_OK) return status; - } + // before disconnect one should always stop the nodes (bebook says) // requires run_state cast since the return type on RunState() is // wrong [int32] run_state destinationRunState = run_state(RunState()); - if (destinationRunState == BMediaEventLooper::B_STARTED) { + if (destinationRunState == BMediaEventLooper::B_STARTED) Stop(0,true); // stop us right now - } + // should also stop the destination if it is running, but how? -/* BMediaNode destinationNode = ?? + /* BMediaNode destinationNode = ?? run_state destinationRunState = destinationNode->??; status = destinationNode->StopNode(??,0,true); if (status != B_OK) { @@ -179,17 +188,17 @@ status_t MediaReader::SetRef( media_destination outputDestination = output.destination; status = roster->Disconnect(output.source.id,output.source, output.destination.id,output.destination); - if (status != B_OK) { + if (status != B_OK) return status; - } + // if that went okay, we'll try reconnecting media_output connectOutput; media_input connectInput; status = roster->Connect(output.source,outputDestination, &format,&connectOutput,&connectInput); - if (status != B_OK) { + if (status != B_OK) return status; - } + // now restart if necessary if (destinationRunState == BMediaEventLooper::B_STARTED) { Start(0); @@ -197,6 +206,7 @@ status_t MediaReader::SetRef( return status; } + // -------------------------------------------------------- // // implemention of BBufferProducer // -------------------------------------------------------- // @@ -209,20 +219,24 @@ status_t MediaReader::FormatSuggestionRequested( int32 quality, media_format * format) { - fprintf(stderr,"MediaReader::FormatSuggestionRequested\n"); + CALLED(); + if (format == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; // no crashing } + if ((type != B_MEDIA_MULTISTREAM) && (type != B_MEDIA_UNKNOWN_TYPE)) { - fprintf(stderr,"<- B_MEDIA_BAD_FORMAT\n"); + PRINT("\t<- B_MEDIA_BAD_FORMAT\n"); return B_MEDIA_BAD_FORMAT; } + GetFormat(format); AddRequirements(format); return B_OK; } + // They made an offer to us. We should make sure that the offer is // acceptable, and then we can add any requirements we have on top of // that. We leave wildcards for anything that we don't care about. @@ -230,16 +244,17 @@ status_t MediaReader::FormatProposal( const media_source & output_source, media_format * format) { - fprintf(stderr,"MediaReader::FormatProposal\n"); + CALLED(); + if (format == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; // no crashing } if (output.source != output_source) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return B_MEDIA_BAD_SOURCE; // we only have one output so that better be it } -/* media_format * myFormat = GetFormat(); + /* media_format * myFormat = GetFormat(); fprintf(stderr,"proposed format: "); print_media_format(format); fprintf(stderr,"\n"); @@ -247,17 +262,18 @@ status_t MediaReader::FormatProposal( print_media_format(myFormat); fprintf(stderr,"\n"); */ // Be's format_is_compatible doesn't work. -// if (!format_is_compatible(*format,*myFormat)) { + // if (!format_is_compatible(*format,*myFormat)) { media_format myFormat; GetFormat(&myFormat); if (!format_is_acceptible(*format,myFormat)) { - fprintf(stderr,"<- B_MEDIA_BAD_FORMAT\n"); + PRINT("\t<- B_MEDIA_BAD_FORMAT\n"); return B_MEDIA_BAD_FORMAT; } AddRequirements(format); return B_OK; } + // Presumably we have already agreed with them that this format is // okay. But just in case, we check the offer. (and complain if it // is invalid) Then as the last thing we do, we get rid of any @@ -268,39 +284,43 @@ status_t MediaReader::FormatChangeRequested( media_format * io_format, int32 * _deprecated_) { - fprintf(stderr,"MediaReader::FormatChangeRequested\n"); + CALLED(); + if (io_format == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; // no crashing } if (output.source != source) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return B_MEDIA_BAD_SOURCE; } status_t status = FormatProposal(source,io_format); if (status != B_OK) { - fprintf(stderr," error returned by FormatProposal\n"); + PRINT("\terror returned by FormatProposal\n"); GetFormat(io_format); return status; } + return ResolveWildcards(io_format); } + status_t MediaReader::GetNextOutput( /* cookie starts as 0 */ int32 * cookie, media_output * out_output) { - fprintf(stderr,"MediaReader::GetNextOutput\n"); + CALLED(); + // let's not crash even if they are stupid if (out_output == 0) { // no place to write! - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; } if (cookie != 0) { // it's valid but they already got our 1 output if (*cookie != 0) { - fprintf(stderr,"<- B_ERROR (no more outputs)\n"); + PRINT("\t<- B_ERROR (no more outputs)\n"); return B_ERROR; } // so next time they won't get the same output again @@ -310,27 +330,29 @@ status_t MediaReader::GetNextOutput( /* cookie starts as 0 */ return B_OK; } + status_t MediaReader::DisposeOutputCookie( int32 cookie) { - fprintf(stderr,"MediaReader::DisposeOutputCookie\n"); + CALLED(); // nothing to do since our cookies are just integers return B_OK; } + status_t MediaReader::SetBufferGroup( const media_source & for_source, BBufferGroup * group) { - fprintf(stderr,"MediaReader::SetBufferGroup\n"); + CALLED(); + if (output.source != for_source) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return B_MEDIA_BAD_SOURCE; // we only have one output so that better be it } if (fBufferGroup != 0) { - if (fBufferGroup == group) { + if (fBufferGroup == group) return B_OK; // time saver - } delete fBufferGroup; } if (group != 0) { @@ -352,32 +374,33 @@ status_t MediaReader::SetBufferGroup( return B_NO_INIT; } int32 count = int32(fDownstreamLatency/fBufferPeriod)+2; - fprintf(stderr," downstream latency = %lld, buffer period = %lld, buffer count = %i\n", - fDownstreamLatency,fBufferPeriod,count); + PRINT("\tdownstream latency = %lld, buffer period = %lld, buffer count = %ld\n", + fDownstreamLatency, fBufferPeriod, count); // allocate the buffers fBufferGroup = new BBufferGroup(output.format.u.multistream.max_chunk_size,count); if (fBufferGroup == 0) { - fprintf(stderr,"<- B_NO_MEMORY\n"); + PRINT("\t<- B_NO_MEMORY\n"); return B_NO_MEMORY; } status_t status = fBufferGroup->InitCheck(); if (status != B_OK) { - fprintf(stderr,"<- fBufferGroup initialization failed\n"); + PRINT("\t<- fBufferGroup initialization failed\n"); return status; } } return B_OK; } - /* Format of clipping is (as int16-s): . */ - /* Repeat for each line where the clipping is different from the previous line. */ - /* If is negative, use the data from line - (there are 0 pairs after */ - /* a negative . Yes, we only support 32k*32k frame buffers for clipping. */ - /* Any non-0 field of 'display' means that that field changed, and if you don't support */ - /* that change, you should return an error and ignore the request. Note that the buffer */ - /* offset values do not have wildcards; 0 (or -1, or whatever) are real values and must */ - /* be adhered to. */ + +/* Format of clipping is (as int16-s): . */ +/* Repeat for each line where the clipping is different from the previous line. */ +/* If is negative, use the data from line - (there are 0 pairs after */ +/* a negative . Yes, we only support 32k*32k frame buffers for clipping. */ +/* Any non-0 field of 'display' means that that field changed, and if you don't support */ +/* that change, you should return an error and ignore the request. Note that the buffer */ +/* offset values do not have wildcards; 0 (or -1, or whatever) are real values and must */ +/* be adhered to. */ status_t MediaReader::VideoClippingChanged( const media_source & for_source, int16 num_shorts, @@ -388,18 +411,21 @@ status_t MediaReader::VideoClippingChanged( return BBufferProducer::VideoClippingChanged(for_source,num_shorts,clip_data,display,_deprecated_); } + status_t MediaReader::GetLatency( bigtime_t * out_latency) { - fprintf(stderr,"MediaReader::GetLatency\n"); + CALLED(); + if (out_latency == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\t<- B_BAD_VALUE\n"); return B_BAD_VALUE; } *out_latency = EventLatency() + SchedulingLatency(); return B_OK; } + status_t MediaReader::PrepareToConnect( const media_source & what, const media_destination & where, @@ -407,29 +433,34 @@ status_t MediaReader::PrepareToConnect( media_source * out_source, char * out_name) { - fprintf(stderr,"MediaReader::PrepareToConnect\n"); + CALLED(); + if ((format == 0) || (out_source == 0) || (out_name == 0)) { - fprintf(stderr,"<- B_BAD_VALUE\n"); + PRINT("\ŧ<- B_BAD_VALUE\n"); return B_BAD_VALUE; // no crashes... } + if (output.source != what) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return B_MEDIA_BAD_SOURCE; } if (output.destination != media_destination::null) { - fprintf(stderr,"<- B_MEDIA_ALREADY_CONNECTED\n"); + PRINT("\t<- B_MEDIA_ALREADY_CONNECTED\n"); return B_MEDIA_ALREADY_CONNECTED; - } + } + status_t status = FormatChangeRequested(output.source,where,format,0); if (status != B_OK) { - fprintf(stderr,"<- MediaReader::FormatChangeRequested failed\n"); + PRINT("\t<- MediaReader::FormatChangeRequested failed\n"); return status; } + // last check for wildcards and general validity if (format->type != B_MEDIA_MULTISTREAM) { - fprintf(stderr,"<- B_MEDIA_BAD_FORMAT\n"); + PRINT("\t<- B_MEDIA_BAD_FORMAT\n"); return B_MEDIA_BAD_FORMAT; } + *out_source = output.source; output.destination = where; strncpy(out_name,output.name,B_MEDIA_NAME_LENGTH-1); @@ -437,6 +468,7 @@ status_t MediaReader::PrepareToConnect( return ResolveWildcards(format); } + void MediaReader::Connect( status_t error, const media_source & source, @@ -444,15 +476,16 @@ void MediaReader::Connect( const media_format & format, char * io_name) { - fprintf(stderr,"MediaReader::Connect\n"); + CALLED(); + if (error != B_OK) { - fprintf(stderr,"<- error already\n"); + PRINT("\t<- error already\n"); output.destination = media_destination::null; GetFormat(&output.format); return; } if (output.source != source) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); output.destination = media_destination::null; GetFormat(&output.format); return; @@ -473,7 +506,7 @@ void MediaReader::Connect( * output.format.u.multistream.max_chunk_size / output.format.u.multistream.max_bit_rate); - fprintf(stderr," max chunk size = %i, max bit rate = %f, buffer period = %lld\n", + PRINT("\tmax chunk size = %ld, max bit rate = %f, buffer period = %lld\n", output.format.u.multistream.max_chunk_size, output.format.u.multistream.max_bit_rate,fBufferPeriod); @@ -481,28 +514,32 @@ void MediaReader::Connect( if (fBufferGroup == 0) { status_t status = SetBufferGroup(output.source,0); if (status != B_OK) { - fprintf(stderr,"<- SetBufferGroup failed\n"); + PRINT("\t<- SetBufferGroup failed\n"); output.destination = media_destination::null; GetFormat(&output.format); return; } } + SetBufferDuration(fBufferPeriod); - + if (GetCurrentFile() != 0) { bigtime_t start, end; - uint8 * data = new uint8[output.format.u.multistream.max_chunk_size]; // <- buffer group buffer size + // buffer group buffer size + uint8 * data = new uint8[output.format.u.multistream.max_chunk_size]; BBuffer * buffer = 0; ssize_t bytesRead = 0; { // timed section start = TimeSource()->RealTime(); // first we try to use a real BBuffer - buffer = fBufferGroup->RequestBuffer(output.format.u.multistream.max_chunk_size,fBufferPeriod); + buffer = fBufferGroup->RequestBuffer( + output.format.u.multistream.max_chunk_size,fBufferPeriod); if (buffer != 0) { FillFileBuffer(buffer); } else { // didn't get a real BBuffer, try simulation by just a read from the disk - bytesRead = GetCurrentFile()->Read(data,output.format.u.multistream.max_chunk_size); + bytesRead = GetCurrentFile()->Read( + data, output.format.u.multistream.max_chunk_size); } end = TimeSource()->RealTime(); } @@ -515,10 +552,10 @@ void MediaReader::Connect( fInternalLatency = end - start; - fprintf(stderr," internal latency from disk read = %lld\n",fInternalLatency); + PRINT("\tinternal latency from disk read = %lld\n", fInternalLatency); } else { fInternalLatency = 100; // just guess - fprintf(stderr," internal latency guessed = %lld\n",fInternalLatency); + PRINT("\tinternal latency guessed = %lld\n", fInternalLatency); } SetEventLatency(fDownstreamLatency + fInternalLatency); @@ -526,19 +563,22 @@ void MediaReader::Connect( // XXX: do anything else? } + void MediaReader::Disconnect( const media_source & what, const media_destination & where) { - fprintf(stderr,"MediaReader::Disconnect\n"); + CALLED(); + if (output.destination != where) { - fprintf(stderr,"<- B_MEDIA_BAD_DESTINATION\n"); + PRINT("\t<- B_MEDIA_BAD_DESTINATION\n"); return; } if (output.source != what) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return; } + output.destination = media_destination::null; GetFormat(&output.format); if (fBufferGroup != 0) { @@ -548,12 +588,14 @@ void MediaReader::Disconnect( } } + void MediaReader::LateNoticeReceived( const media_source & what, bigtime_t how_much, bigtime_t performance_time) { - fprintf(stderr,"MediaReader::LateNoticeReceived\n"); + CALLED(); + if (what == output.source) { switch (RunMode()) { case B_OFFLINE: @@ -579,64 +621,72 @@ void MediaReader::LateNoticeReceived( // Okay you asked for it, we'll skip ahead in the file! // We'll drop 1 buffer's worth if (GetCurrentFile() == 0) { - fprintf(stderr,"MediaReader::LateNoticeReceived called without an GetCurrentFile() (!)\n"); + PRINT("MediaReader::LateNoticeReceived called without" + "an GetCurrentFile() (!)\n"); } else { GetCurrentFile()->Seek(output.format.u.multistream.max_chunk_size,SEEK_CUR); } break; default: // huh?? there aren't any more run modes. - fprintf(stderr,"MediaReader::LateNoticeReceived with unexpected run mode.\n"); + PRINT("MediaReader::LateNoticeReceived with unexpected run mode.\n"); break; } } } + void MediaReader::EnableOutput( const media_source & what, bool enabled, int32 * _deprecated_) { - fprintf(stderr,"MediaReader::EnableOutput\n"); + CALLED(); + if (output.source != what) { - fprintf(stderr,"<- B_MEDIA_BAD_SOURCE\n"); + PRINT("\t<- B_MEDIA_BAD_SOURCE\n"); return; } + fOutputEnabled = enabled; } + status_t MediaReader::SetPlayRate( int32 numer, int32 denom) { - BBufferProducer::SetPlayRate(numer,denom); // XXX: do something intelligent later + return BBufferProducer::SetPlayRate(numer,denom); // XXX: do something intelligent later } + void MediaReader::AdditionalBufferRequested( // used to be Reserved 0 const media_source & source, media_buffer_id prev_buffer, bigtime_t prev_time, const media_seek_tag * prev_tag) { - fprintf(stderr,"MediaReader::AdditionalBufferRequested\n"); + CALLED(); + if (output.source == source) { BBuffer * buffer; status_t status = GetFilledBuffer(&buffer); if (status != B_OK) { - fprintf(stderr,"MediaReader::AdditionalBufferRequested got an error from GetFilledBuffer.\n"); + PRINT("MediaReader::AdditionalBufferRequested got an error from GetFilledBuffer.\n"); return; // don't send the buffer } SendBuffer(buffer,output.destination); } } + void MediaReader::LatencyChanged( const media_source & source, const media_destination & destination, bigtime_t new_latency, uint32 flags) { - fprintf(stderr,"MediaReader::LatencyChanged\n"); + CALLED(); if ((output.source == source) && (output.destination == destination)) { fDownstreamLatency = new_latency; SetEventLatency(fDownstreamLatency + fInternalLatency); @@ -645,33 +695,33 @@ void MediaReader::LatencyChanged( // see SetBufferGroup } + // -------------------------------------------------------- // // implementation for BMediaEventLooper // -------------------------------------------------------- // - // protected: - status_t MediaReader::HandleBuffer( const media_timed_event *event, bigtime_t lateness, - bool realTimeEvent = false) + bool realTimeEvent) { - fprintf(stderr,"MediaReader::HandleBuffer\n"); - if (output.destination == media_destination::null) { + CALLED(); + + if (output.destination == media_destination::null) return B_MEDIA_NOT_CONNECTED; - } + status_t status = B_OK; BBuffer * buffer = fBufferGroup->RequestBuffer(output.format.u.multistream.max_chunk_size,fBufferPeriod); if (buffer != 0) { status = FillFileBuffer(buffer); if (status != B_OK) { - fprintf(stderr,"MediaReader::HandleEvent got an error from FillFileBuffer.\n"); + PRINT("MediaReader::HandleEvent got an error from FillFileBuffer.\n"); buffer->Recycle(); } else { if (fOutputEnabled) { status = SendBuffer(buffer,output.destination); if (status != B_OK) { - fprintf(stderr,"MediaReader::HandleEvent got an error from SendBuffer.\n"); + PRINT("MediaReader::HandleEvent got an error from SendBuffer.\n"); buffer->Recycle(); } } else { @@ -685,30 +735,31 @@ status_t MediaReader::HandleBuffer( return status; } + status_t MediaReader::HandleDataStatus( const media_timed_event *event, bigtime_t lateness, - bool realTimeEvent = false) + bool realTimeEvent) { - fprintf(stderr,"MediaReader::HandleDataStatus"); + CALLED(); return SendDataStatus(event->data,output.destination,event->event_time); } + // -------------------------------------------------------- // // MediaReader specific functions // -------------------------------------------------------- // - // static: - void MediaReader::GetFlavor(flavor_info * outInfo, int32 id) { - fprintf(stderr,"MediaReader::GetFlavor\n"); - if (outInfo == 0) { + CALLED(); + + if (outInfo == 0) return; - } + AbstractFileInterfaceNode::GetFlavor(outInfo,id); - outInfo->name = "OpenBeOS Media Reader"; - outInfo->info = "The OpenBeOS Media Reader reads a file and produces a multistream."; + outInfo->name = strdup("OpenBeOS Media Reader"); + outInfo->info = strdup("The OpenBeOS Media Reader reads a file and produces a multistream."); outInfo->kinds |= B_BUFFER_PRODUCER; outInfo->out_format_count = 1; // 1 output media_format * formats = new media_format[outInfo->out_format_count]; @@ -717,62 +768,71 @@ void MediaReader::GetFlavor(flavor_info * outInfo, int32 id) return; } + void MediaReader::GetFormat(media_format * outFormat) { - fprintf(stderr,"MediaReader::GetFormat\n"); - if (outFormat == 0) { + CALLED(); + + if (outFormat == 0) return; - } + AbstractFileInterfaceNode::GetFormat(outFormat); return; } + void MediaReader::GetFileFormat(media_file_format * outFileFormat) { - fprintf(stderr,"MediaReader::GetFileFormat\n"); - if (outFileFormat == 0) { + CALLED(); + + if (outFileFormat == 0) return; - } + AbstractFileInterfaceNode::GetFileFormat(outFileFormat); outFileFormat->capabilities |= media_file_format::B_READABLE; return; } -// protected: +// protected: status_t MediaReader::GetFilledBuffer( BBuffer ** outBuffer) { - fprintf(stderr,"MediaReader::GetFilledBuffer\n"); + CALLED(); + BBuffer * buffer = fBufferGroup->RequestBuffer(output.format.u.multistream.max_chunk_size,-1); if (buffer == 0) { // XXX: add a new buffer and get it - fprintf(stderr,"MediaReader::GetFilledBuffer needs a new buffer.\n"); + PRINT("MediaReader::GetFilledBuffer needs a new buffer.\n"); return B_ERROR; // don't send the buffer } + status_t status = FillFileBuffer(buffer); *outBuffer = buffer; return status; } + status_t MediaReader::FillFileBuffer( BBuffer * buffer) { - fprintf(stderr,"MediaReader::FillFileBuffer\n"); + CALLED(); + if (GetCurrentFile() == 0) { - fprintf(stderr,"<- B_NO_INIT\n"); + PRINT("\t<- B_NO_INIT\n"); return B_NO_INIT; } - fprintf(stderr," %i buffer bytes used, %i buffer bytes available\n", - buffer->SizeUsed(),buffer->SizeAvailable()); + PRINT("\t%ld buffer bytes used, %ld buffer bytes available\n", + buffer->SizeUsed(), buffer->SizeAvailable()); off_t position = GetCurrentFile()->Position(); ssize_t bytesRead = GetCurrentFile()->Read(buffer->Data(),buffer->SizeAvailable()); if (bytesRead < 0) { - fprintf(stderr,"<- B_FILE_ERROR\n"); + PRINT("\t<- B_FILE_ERROR\n"); return B_FILE_ERROR; // some sort of file related error } - fprintf(stderr," %i file bytes read at position %i.\n", - bytesRead,position); + PRINT("\t%ld file bytes read at position %ld.\n", + bytesRead, position); + buffer->SetSizeUsed(bytesRead); media_header * header = buffer->Header(); header->type = B_MEDIA_MULTISTREAM; @@ -785,23 +845,23 @@ status_t MediaReader::FillFileBuffer( return B_OK; } + // -------------------------------------------------------- // // stuffing // -------------------------------------------------------- // - -status_t MediaReader::_Reserved_MediaReader_0(void *) {} -status_t MediaReader::_Reserved_MediaReader_1(void *) {} -status_t MediaReader::_Reserved_MediaReader_2(void *) {} -status_t MediaReader::_Reserved_MediaReader_3(void *) {} -status_t MediaReader::_Reserved_MediaReader_4(void *) {} -status_t MediaReader::_Reserved_MediaReader_5(void *) {} -status_t MediaReader::_Reserved_MediaReader_6(void *) {} -status_t MediaReader::_Reserved_MediaReader_7(void *) {} -status_t MediaReader::_Reserved_MediaReader_8(void *) {} -status_t MediaReader::_Reserved_MediaReader_9(void *) {} -status_t MediaReader::_Reserved_MediaReader_10(void *) {} -status_t MediaReader::_Reserved_MediaReader_11(void *) {} -status_t MediaReader::_Reserved_MediaReader_12(void *) {} -status_t MediaReader::_Reserved_MediaReader_13(void *) {} -status_t MediaReader::_Reserved_MediaReader_14(void *) {} -status_t MediaReader::_Reserved_MediaReader_15(void *) {} +status_t MediaReader::_Reserved_MediaReader_0(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_1(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_2(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_3(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_4(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_5(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_6(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_7(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_8(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_9(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_10(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_11(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_12(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_13(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_14(void *) { return B_ERROR; } +status_t MediaReader::_Reserved_MediaReader_15(void *) { return B_ERROR; } diff --git a/src/add-ons/media/media-add-ons/reader/MediaReaderAddOn.cpp b/src/add-ons/media/media-add-ons/reader/MediaReaderAddOn.cpp index e83e8140c3..c76fc226a2 100644 --- a/src/add-ons/media/media-add-ons/reader/MediaReaderAddOn.cpp +++ b/src/add-ons/media/media-add-ons/reader/MediaReaderAddOn.cpp @@ -6,99 +6,108 @@ // that can make MediaReader nodes // // MediaReader nodes read a file into a multistream - - -#include -#include -#include -#include -#include -#include - #include "MediaReader.h" #include "MediaReaderAddOn.h" +#include "debug.h" + +#include +#include +#include +#include +#include +#include +#include + #include #include #include + // instantiation function extern "C" _EXPORT BMediaAddOn * make_media_addon(image_id image) { return new MediaReaderAddOn(image); } -// -------------------------------------------------------- // -// ctor/dtor -// -------------------------------------------------------- // MediaReaderAddOn::~MediaReaderAddOn() { } + MediaReaderAddOn::MediaReaderAddOn(image_id image) : AbstractFileInterfaceAddOn(image) { - fprintf(stderr,"MediaReaderAddOn::MediaReaderAddOn\n"); + CALLED(); } - + + // -------------------------------------------------------- // // BMediaAddOn impl // -------------------------------------------------------- // - status_t MediaReaderAddOn::GetFlavorAt( int32 n, const flavor_info ** out_info) { - fprintf(stderr,"MediaReaderAddOn::GetFlavorAt\n"); + CALLED(); + if (out_info == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash } if (n != 0) { - fprintf(stderr,"<- B_BAD_INDEX\n"); + PRINT("\t<- B_BAD_INDEX\n"); return B_BAD_INDEX; } + flavor_info * infos = new flavor_info[1]; MediaReader::GetFlavor(&infos[0],n); (*out_info) = infos; return B_OK; } + BMediaNode * MediaReaderAddOn::InstantiateNodeFor( const flavor_info * info, BMessage * config, status_t * out_error) { - fprintf(stderr,"MediaReaderAddOn::InstantiateNodeFor\n"); + CALLED(); + if (out_error == 0) { - fprintf(stderr,"<- NULL\n"); - return 0; // we refuse to crash because you were stupid + PRINT("\t<- NULL\n"); + return 0; // avoid crash } + // XXX: read from add-on's attributes size_t defaultChunkSize = size_t(8192); // 8192 bytes = 8 Kilobytes - float defaultBitRate = 2048; // = 2048 kilobits/millisec = 256000 Kilobytes/sec + // = 2048 kilobits/millisec = 256000 Kilobytes/sec + float defaultBitRate = 2048; MediaReader * node = new MediaReader(defaultChunkSize, defaultBitRate, info,config,this); if (node == 0) { *out_error = B_NO_MEMORY; - fprintf(stderr,"<- B_NO_MEMORY\n"); + PRINT("\t<- B_NO_MEMORY\n"); } else { *out_error = node->InitCheck(); } return node; } + status_t MediaReaderAddOn::GetConfigurationFor( BMediaNode * your_node, BMessage * into_message) { - fprintf(stderr,"MediaReaderAddOn::GetConfigurationFor\n"); + CALLED(); + if (into_message == 0) { - fprintf(stderr,"<- B_BAD_VALUE\n"); - return B_BAD_VALUE; // we refuse to crash because you were stupid - } + PRINT("\t<- B_BAD_VALUE\n"); + return B_BAD_VALUE; // avoid crash + } + MediaReader * node = dynamic_cast(your_node); if (node == 0) { @@ -108,6 +117,7 @@ status_t MediaReaderAddOn::GetConfigurationFor( return node->GetConfigurationFor(into_message); } + // -------------------------------------------------------- // // BMediaAddOn impl for B_FILE_INTERFACE nodes // -------------------------------------------------------- // @@ -133,10 +143,11 @@ status_t MediaReaderAddOn::GetFileFormatList( int32 * out_read_items, void * _reserved) { - fprintf(stderr,"MediaReaderAddOn::GetFileFormatList\n"); + CALLED(); + if (flavor_id != 0) { // this is a sanity check for now - fprintf(stderr,"<- B_BAD_INDEX\n"); + PRINT("\t<- B_BAD_INDEX\n"); return B_BAD_INDEX; } // see null check comment above @@ -156,6 +167,7 @@ status_t MediaReaderAddOn::GetFileFormatList( return B_OK; } + status_t MediaReaderAddOn::SniffTypeKind( const BMimeType & type, uint64 in_kinds, @@ -163,7 +175,7 @@ status_t MediaReaderAddOn::SniffTypeKind( int32 * out_internal_id, void * _reserved) { - fprintf(stderr,"MediaReaderAddOn::SniffTypeKind\n"); + CALLED(); return AbstractFileInterfaceAddOn::SniffTypeKind(type,in_kinds, B_BUFFER_PRODUCER, out_quality,out_internal_id, @@ -173,29 +185,29 @@ status_t MediaReaderAddOn::SniffTypeKind( // -------------------------------------------------------- // // main // -------------------------------------------------------- // - int main(int argc, char *argv[]) { fprintf(stderr,"main called for MediaReaderAddOn\n"); + return 0; } // -------------------------------------------------------- // // stuffing // -------------------------------------------------------- // -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_0(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_1(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_2(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_3(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_4(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_5(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_6(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_7(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_8(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_9(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_10(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_11(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_12(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_13(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_14(void *) {}; -status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_15(void *) {}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_0(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_1(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_2(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_3(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_4(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_5(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_6(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_7(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_8(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_9(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_10(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_11(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_12(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_13(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_14(void *) {return B_ERROR;}; +status_t MediaReaderAddOn::_Reserved_MediaReaderAddOn_15(void *) {return B_ERROR;};