// A MediaFileProducer is a node that // implements FileInterface and BBufferProducer. // it produces one output, a multistream #if !defined(_MEDIA_FILE_PRODUCER_H) #define _MEDIA_FILE_PRODUCER_H #include #include #include #include class MediaFileProducer : public BFileInterface, public BBufferProducer { protected: MediaFileProducer(); virtual ~MediaFileProducer(); /*************************/ /* begin from BMediaNode */ public: /* 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 */ protected: /* 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); protected: /* Called when requests have completed, or failed. */ virtual status_t RequestCompleted( /* reserved 0 */ const media_request_info & info); 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); /* end from BMediaNode */ /***********************/ /*****************************/ /* begin from BFileInterface */ protected: //included from BMediaNode //virtual status_t HandleMessage( // int32 message, // const void * data, // size_t size); virtual status_t GetNextFileFormat( int32 * cookie, media_file_format * out_format) = 0; virtual void DisposeFileFormatCookie( int32 cookie) = 0; virtual status_t GetDuration( bigtime_t * out_time) = 0; virtual status_t SniffRef( const entry_ref & file, char * out_mime_type, /* 256 bytes */ float * out_quality) = 0; virtual status_t SetRef( const entry_ref & file, bool create, bigtime_t * out_time) = 0; virtual status_t GetRef( entry_ref * out_ref, char * out_mime_type) = 0; /* end from BFileInterface */ /***************************/ /******************************/ /* begin from BBufferProducer */ protected: /* functionality of BBufferProducer */ virtual status_t FormatSuggestionRequested( media_type type, int32 quality, media_format * format) = 0; virtual status_t FormatProposal( const media_source & output, media_format * format) = 0; /* If the format isn't good, put a good format into *io_format and return error */ /* If format has wildcard, specialize to what you can do (and change). */ /* If you can change the format, return OK. */ /* The request comes from your destination sychronously, so you cannot ask it */ /* whether it likes it -- you should assume it will since it asked. */ virtual status_t FormatChangeRequested( const media_source & source, const media_destination & destination, media_format * io_format, int32 * _deprecated_) = 0; virtual status_t GetNextOutput( /* cookie starts as 0 */ int32 * cookie, media_output * out_output) = 0; virtual status_t DisposeOutputCookie( int32 cookie) = 0; /* In this function, you should either pass on the group to your upstream guy, */ /* or delete your current group and hang on to this group. Deleting the previous */ /* group (unless you passed it on with the reclaim flag set to false) is very */ /* important, else you will 1) leak memory and 2) block someone who may want */ /* to reclaim the buffers living in that group. */ virtual status_t SetBufferGroup( const media_source & for_source, BBufferGroup * group) = 0; /* 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. */ virtual status_t VideoClippingChanged( const media_source & for_source, int16 num_shorts, int16 * clip_data, const media_video_display_info & display, int32 * _deprecated_); /* Iterates over all outputs and maxes the latency found */ virtual status_t GetLatency( bigtime_t * out_lantency); virtual status_t PrepareToConnect( const media_source & what, const media_destination & where, media_format * format, media_source * out_source, char * out_name) = 0; virtual void Connect( status_t error, const media_source & source, const media_destination & destination, const media_format & format, char * io_name) = 0; virtual void Disconnect( const media_source & what, const media_destination & where) = 0; virtual void LateNoticeReceived( const media_source & what, bigtime_t how_much, bigtime_t performance_time) = 0; virtual void EnableOutput( const media_source & what, bool enabled, int32 * _deprecated_) = 0; virtual status_t SetPlayRate( int32 numer, int32 denom); virtual status_t HandleMessage( /* call this from the thread that listens to the port */ int32 message, const void * data, size_t size); virtual void 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); // may be NULL virtual void LatencyChanged( // used to be Reserved 1 const media_source & source, const media_destination & destination, bigtime_t new_latency, uint32 flags); /* end from BBufferProducer */ /****************************/ private: MediaFileProducer( /* private unimplemented */ const MediaFileProducer & clone); MediaFileProducer & operator=( const MediaFileProducer & clone); /* Mmmh, stuffing! */ virtual status_t _Reserved_MediaFileProducer_0(void *); virtual status_t _Reserved_MediaFileProducer_1(void *); virtual status_t _Reserved_MediaFileProducer_2(void *); virtual status_t _Reserved_MediaFileProducer_3(void *); virtual status_t _Reserved_MediaFileProducer_4(void *); virtual status_t _Reserved_MediaFileProducer_5(void *); virtual status_t _Reserved_MediaFileProducer_6(void *); virtual status_t _Reserved_MediaFileProducer_7(void *); virtual status_t _Reserved_MediaFileProducer_8(void *); virtual status_t _Reserved_MediaFileProducer_9(void *); virtual status_t _Reserved_MediaFileProducer_10(void *); virtual status_t _Reserved_MediaFileProducer_11(void *); virtual status_t _Reserved_MediaFileProducer_12(void *); virtual status_t _Reserved_MediaFileProducer_13(void *); virtual status_t _Reserved_MediaFileProducer_14(void *); virtual status_t _Reserved_MediaFileProducer_15(void *); uint32 _reserved_media_file_node_[16]; }; #endif /* _MEDIA_FILE_PRODUCER_H */