/******************************************************************************* / / File: MediaNode.h / / Description: BMediaNode is the indirect base class for all Media Kit participants. / However, you should use the more specific BBufferConsumer, BBufferProducer / and others rather than BMediaNode directly. It's OK to multiply inherit. / / Copyright 1997-98, Be Incorporated, All Rights Reserved / *******************************************************************************/ #if !defined(_MEDIA_NODE_H) #define _MEDIA_NODE_H #include #include #include class BBufferConsumer; class BBufferProducer; class BControllable; class BFileInterface; class BMediaAddOn; class BTimeSource; class media_node { public: media_node(); ~media_node(); media_node_id node; port_id port; uint32 kind; static media_node null; private: uint32 _reserved_[3]; }; struct media_input { media_input(); ~media_input(); media_node node; media_source source; media_destination destination; media_format format; char name[B_MEDIA_NAME_LENGTH]; private: uint32 _reserved_media_input_[4]; }; struct media_output { media_output(); ~media_output(); media_node node; media_source source; media_destination destination; media_format format; char name[B_MEDIA_NAME_LENGTH]; private: uint32 _reserved_media_output_[4]; }; struct live_node_info { live_node_info(); ~live_node_info(); media_node node; BPoint hint_point; char name[B_MEDIA_NAME_LENGTH]; private: char reserved[160]; }; struct media_request_info { enum what_code { B_SET_VIDEO_CLIPPING_FOR = 1, B_REQUEST_FORMAT_CHANGE, B_SET_OUTPUT_ENABLED, B_SET_OUTPUT_BUFFERS_FOR, B_FORMAT_CHANGED = 4097 }; what_code what; int32 change_tag; status_t status; int32 cookie; void * user_data; media_source source; media_destination destination; media_format format; uint32 _reserved_[32]; }; struct media_node_attribute { enum { B_R40_COMPILED = 1, // has this attribute if compiled using R4.0 headers B_USER_ATTRIBUTE_NAME = 0x1000000, B_FIRST_USER_ATTRIBUTE }; uint32 what; uint32 flags; // per attribute int64 data; // per attribute }; namespace BPrivate { namespace media { class TimeSourceObject; class SystemTimeSourceObject; class BMediaRosterEx; } } // BPrivate::media class BMediaNode { protected: /* this has to be on top rather than bottom to force a vtable in mwcc */ virtual ~BMediaNode(); /* should be called through Release() */ public: enum run_mode { B_OFFLINE = 1, /* data accurate, no realtime constraint */ B_DECREASE_PRECISION, /* when slipping, try to catch up */ B_INCREASE_LATENCY, /* when slipping, increase playout delay */ B_DROP_DATA, /* when slipping, skip data */ B_RECORDING /* you're on the receiving end of recording; buffers are guaranteed to be late */ }; BMediaNode * Acquire(); /* return itself */ BMediaNode * Release(); /* release will decrement refcount, and delete if 0 */ const char * Name() const; media_node_id ID() const; uint64 Kinds() const; media_node Node() const; run_mode RunMode() const; BTimeSource * TimeSource() const; /* this port is what a media node listens to for commands */ virtual port_id ControlPort() const; virtual BMediaAddOn* AddOn( int32 * internal_id) const = 0; /* Who instantiated you -- or NULL for app class */ /* These will be sent to anyone watching the MediaRoster. */ /* The message field "be:node_id" will contain the node ID. */ enum node_error { /* Note that these belong with the notifications in MediaDefs.h! */ /* They are here to provide compiler type checking in ReportError(). */ B_NODE_FAILED_START = 'TRI0', B_NODE_FAILED_STOP, // TRI1 B_NODE_FAILED_SEEK, // TRI2 B_NODE_FAILED_SET_RUN_MODE, // TRI3 B_NODE_FAILED_TIME_WARP, // TRI4 B_NODE_FAILED_PREROLL, // TRI5 B_NODE_FAILED_SET_TIME_SOURCE_FOR, // TRI6 /* display this node with a blinking exclamation mark or something */ B_NODE_IN_DISTRESS // TRI7 /* TRIA and up are used in MediaDefs.h */ }; protected: /* Send one of the above codes to anybody who's watching. */ status_t ReportError( node_error what, const BMessage * info = NULL); /* String "message" for instance */ /* When you've handled a stop request, call this function. If anyone is */ /* listening for stop information from you, they will be notified. Especially */ /* important for offline capable Nodes. */ status_t NodeStopped( bigtime_t whenPerformance); // performance time void TimerExpired( bigtime_t notifyPoint, // performance time int32 cookie, status_t error = B_OK); explicit BMediaNode( /* constructor sets refcount to 1 */ const char * name); status_t WaitForMessage( bigtime_t waitUntil, uint32 flags = 0, void * _reserved_ = 0); /* These don't return errors; instead, they use the global error condition reporter. */ /* A node is required to have a queue of at least one pending command (plus TimeWarp) */ /* and is recommended to allow for at least one pending command of each type. */ /* Allowing an arbitrary number of outstanding commands might be nice, but apps */ /* cannot depend on that happening. */ virtual void Start( bigtime_t performance_time); virtual void Stop( bigtime_t performance_time, bool immediate); virtual void Seek( bigtime_t media_time, bigtime_t performance_time); virtual void SetRunMode( run_mode mode); virtual void TimeWarp( bigtime_t at_real_time, bigtime_t to_performance_time); virtual void Preroll(); virtual void SetTimeSource( BTimeSource * time_source); public: virtual status_t HandleMessage( int32 message, const void * data, size_t size); void HandleBadMessage( /* call this with messages you and your superclasses don't recognize */ int32 code, const void * buffer, size_t size); /* Called from derived system classes; you don't need to */ void AddNodeKind( uint64 kind); // These were not in 4.0. // We added them in 4.1 for future use. They just call // the default global versions for now. void * operator new( size_t size); void * operator new( size_t size, const std::nothrow_t &) throw(); void operator delete( void * ptr); #if !__MWERKS__ // there's a bug in MWCC under R4.1 and earlier void operator delete( void * ptr, const std::nothrow_t &) throw(); #endif protected: /* Called when requests have completed, or failed. */ virtual status_t RequestCompleted( /* reserved 0 */ const media_request_info & info); private: friend class BTimeSource; friend class BMediaRoster; friend class BBufferProducer; // for getting _mNodeID friend class BPrivate::media::TimeSourceObject; friend class BPrivate::media::SystemTimeSourceObject; friend class BPrivate::media::BMediaRosterEx; // Deprecated in 4.1 int32 IncrementChangeTag(); int32 ChangeTag(); int32 MintChangeTag(); status_t ApplyChangeTag( int32 previously_reserved); /* Mmmh, stuffing! */ protected: virtual status_t DeleteHook(BMediaNode * node); /* reserved 1 */ virtual void NodeRegistered(); /* reserved 2 */ public: /* fill out your attributes in the provided array, returning however many you have. */ virtual status_t GetNodeAttributes( /* reserved 3 */ media_node_attribute * outAttributes, size_t inMaxCount); virtual status_t AddTimer( bigtime_t at_performance_time, int32 cookie); private: status_t _Reserved_MediaNode_0(void *); /* DeleteHook() */ status_t _Reserved_MediaNode_1(void *); /* RequestCompletionHook() */ status_t _Reserved_MediaNode_2(void *); /* NodeRegistered() */ status_t _Reserved_MediaNode_3(void *); /* GetNodeAttributes() */ status_t _Reserved_MediaNode_4(void *); /* AddTimer() */ virtual status_t _Reserved_MediaNode_5(void *); virtual status_t _Reserved_MediaNode_6(void *); virtual status_t _Reserved_MediaNode_7(void *); virtual status_t _Reserved_MediaNode_8(void *); virtual status_t _Reserved_MediaNode_9(void *); virtual status_t _Reserved_MediaNode_10(void *); virtual status_t _Reserved_MediaNode_11(void *); virtual status_t _Reserved_MediaNode_12(void *); virtual status_t _Reserved_MediaNode_13(void *); virtual status_t _Reserved_MediaNode_14(void *); virtual status_t _Reserved_MediaNode_15(void *); BMediaNode(); /* private unimplemented */ BMediaNode( const BMediaNode & clone); BMediaNode & operator=( const BMediaNode & clone); BMediaNode( /* constructor sets refcount to 1 */ const char * name, media_node_id id, uint32 kinds); void _InitObject(const char *, media_node_id, uint64); media_node_id fNodeID; BTimeSource * fTimeSource; int32 fRefCount; char fName[B_MEDIA_NAME_LENGTH]; run_mode fRunMode; int32 _mChangeCount; // deprecated int32 _mChangeCountReserved; // deprecated uint64 fKinds; media_node_id fTimeSourceID; BBufferProducer * fProducerThis; BBufferConsumer * fConsumerThis; BFileInterface * fFileInterfaceThis; BControllable * fControllableThis; BTimeSource * fTimeSourceThis; bool _mReservedBool[4]; mutable port_id fControlPort; uint32 _reserved_media_node_[8]; protected: static int32 NewChangeTag(); // for use by BBufferConsumer, mostly private: // dont' rename this one, it's static and needed for binary compatibility static int32 _m_changeTag; // not to be confused with _mChangeCount }; #endif /* _MEDIA_NODE_H */