haiku/headers/os/media/MediaRoster.h

/*******************************************************************************
/
/	File:			MediaRoster.h
/
/   Description:   The BMediaRoster is the main application interface to the Media Kit
/
/	Copyright 1997-98, Be Incorporated, All Rights Reserved
/
*******************************************************************************/

#if !defined(_MEDIA_ROSTER_H)
#define _MEDIA_ROSTER_H

#include <map>
#include <MediaDefs.h>
#include <MediaNode.h>
#include <config_manager.h>

class BMimeType;
struct dormant_flavor_info;
class BMediaAddOn;

namespace BPrivate { namespace media {
	class DefaultDeleter;
	class BMediaRosterEx;
} } // BPrivate::media

class BMediaRoster : public BLooper
{
public:

		status_t GetVideoInput(
				media_node * out_node);
		status_t GetAudioInput(
				media_node * out_node);
		status_t GetVideoOutput(
				media_node * out_node);
		status_t GetAudioMixer(
				media_node * out_node);
		status_t GetAudioOutput(
				media_node * out_node);	/* Use the mixer rather than the output for most needs! */
		status_t GetAudioOutput(
				media_node * out_node,
				int32 * out_input_id,
				BString * out_input_name);
		status_t GetTimeSource(
				media_node * out_node);

		status_t SetVideoInput(
				const media_node & producer);
		status_t SetVideoInput(
				const dormant_node_info & producer);
		status_t SetAudioInput(
				const media_node & producer);
		status_t SetAudioInput(
				const dormant_node_info & producer);
		status_t SetVideoOutput(
				const media_node & consumer);
		status_t SetVideoOutput(
				const dormant_node_info & consumer);
		status_t SetAudioOutput(
				const media_node & consumer);
		status_t SetAudioOutput(
				const media_input & input_to_output);
		status_t SetAudioOutput(
				const dormant_node_info & consumer);

		/* Get a media_node from a node ID -- this is how you reference your own nodes! */
		status_t GetNodeFor(
				media_node_id node,
				media_node * clone);
		status_t GetSystemTimeSource(	/* typically, you want to use GetTimeSource() */
				media_node * clone);
		status_t ReleaseNode(	/* might shut down Node if you're last */
				const media_node & node);

		BTimeSource * MakeTimeSourceFor(	/* Release() the object when done */
				const media_node & for_node);

		/* note that the media_source and media_destination found in */
		/* out_output and out_input are the ones actually used; from and to */
		/* are only "hints" that the app should not use once a real connection */
		/* has been established */
		status_t Connect(
				const media_source & from,
				const media_destination & to,
				media_format * io_format,
				media_output * out_output,
				media_input * out_input);
		enum connect_flags {
			B_CONNECT_MUTED = 0x1
		};
		status_t Connect(
				const media_source & from,
				const media_destination & to,
				media_format * io_format,
				media_output * out_output,
				media_input * out_input,
				uint32 in_flags,
				void * _reserved = 0);
		status_t Disconnect(
				media_node_id source_node,
				const media_source & source,
				media_node_id destination_node,
				const media_destination & destination);

		status_t StartNode(
				const media_node & node,
				bigtime_t at_performance_time);
		status_t StopNode(
				const media_node & node,
				bigtime_t at_performance_time,
				bool immediate = false);	/* immediate -> at_time is insignificant */
		status_t SeekNode(
				const media_node & node,
				bigtime_t to_media_time,
				bigtime_t at_performance_time = 0 /* if running */ );

		status_t StartTimeSource(
				const media_node & node,
				bigtime_t at_real_time);
		status_t StopTimeSource(
				const media_node & node,
				bigtime_t at_real_time,
				bool immediate = false);
		status_t SeekTimeSource(
				const media_node & node,
				bigtime_t to_performance_time,
				bigtime_t at_real_time);

		status_t SyncToNode(
				const media_node & node,
				bigtime_t at_time,
				bigtime_t timeout = B_INFINITE_TIMEOUT);
		status_t SetRunModeNode(
				const media_node & node,
				BMediaNode::run_mode mode);
		status_t PrerollNode(	/* synchronous */
				const media_node & node);

		status_t RollNode(
				const media_node & node, 
				bigtime_t startPerformance,
				bigtime_t stopPerformance,
				bigtime_t atMediaTime = -B_INFINITE_TIMEOUT);

		status_t SetProducerRunModeDelay(	/* should only be used with B_RECORDING */
				const media_node & node,
				bigtime_t delay,
				BMediaNode::run_mode mode = BMediaNode::B_RECORDING);
		status_t SetProducerRate(	/* not necessarily supported by node */
				const media_node & producer,
				int32 numer,
				int32 denom);

	/* Nodes will have available inputs/outputs as long as they are capable */
	/* of accepting more connections. The node may create an additional */
	/* output or input as the currently available is taken into usage. */
		status_t GetLiveNodeInfo(
				const media_node & node,
				live_node_info * out_live_info);
		status_t GetLiveNodes(
				live_node_info * out_live_nodes,
				int32 * io_total_count,
				const media_format * has_input = NULL,
				const media_format * has_output = NULL,
				const char * name = NULL,
				uint64 node_kinds = 0);	/* B_BUFFER_PRODUCER etc */

		status_t GetFreeInputsFor(
				const media_node & node,
				media_input * out_free_inputs,
				int32 buf_num_inputs,
				int32 * out_total_count,
				media_type filter_type = B_MEDIA_UNKNOWN_TYPE);
		status_t GetConnectedInputsFor(
				const media_node & node,
				media_input * out_active_inputs,
				int32 buf_num_inputs,
				int32 * out_total_count);
		status_t GetAllInputsFor(
				const media_node & node,
				media_input * out_inputs,
				int32 buf_num_inputs,
				int32 * out_total_count);
		status_t GetFreeOutputsFor(
				const media_node & node,
				media_output * out_free_outputs,
				int32 buf_num_outputs,
				int32 * out_total_count,
				media_type filter_type = B_MEDIA_UNKNOWN_TYPE);
		status_t GetConnectedOutputsFor(
				const media_node & node,
				media_output * out_active_outputs,
				int32 buf_num_outputs,
				int32 * out_total_count);
		status_t GetAllOutputsFor(
				const media_node & node,
				media_output * out_outputs,
				int32 buf_num_outputs,
				int32 * out_total_count);

		status_t StartWatching(
				const BMessenger & where);
		status_t StartWatching(
				const BMessenger & where,
				int32 notificationType);
		status_t StartWatching(
				const BMessenger & where,
				const media_node & node,
				int32 notificationType);
		status_t StopWatching(
				const BMessenger & where);
		status_t StopWatching(
				const BMessenger & where,
				int32 notificationType);
		status_t StopWatching(
				const BMessenger & where,
				const media_node & node,
				int32 notificationType);

		status_t RegisterNode(
				BMediaNode * node);
		status_t UnregisterNode(
				BMediaNode * node);

static	BMediaRoster * Roster(					//	will create if there isn't one
				status_t * out_error = NULL);	//	thread safe for multiple calls to Roster()
static	BMediaRoster * CurrentRoster();			//	won't create it if there isn't one
												//	not thread safe if you call Roster() at the same time
		status_t SetTimeSourceFor(
				media_node_id node,
				media_node_id time_source);

		status_t GetParameterWebFor(
				const media_node & node, 
				BParameterWeb ** out_web);
		status_t StartControlPanel(
				const media_node & node,
				BMessenger * out_messenger = NULL);

		status_t GetDormantNodes(
				dormant_node_info * out_info,
				int32 * io_count,
				const media_format * has_input = NULL,
				const media_format * has_output = NULL,
				const char * name = NULL,
				uint64 require_kinds = 0,
				uint64 deny_kinds = 0);
		status_t InstantiateDormantNode(
				const dormant_node_info & in_info,
				media_node * out_node,
				uint32 flags /* currently B_FLAVOR_IS_GLOBAL or B_FLAVOR_IS_LOCAL */ );
		status_t InstantiateDormantNode(
				const dormant_node_info & in_info,
				media_node * out_node);
		status_t GetDormantNodeFor(
				const media_node & node,
				dormant_node_info * out_info);
		status_t GetDormantFlavorInfoFor(
				const dormant_node_info & in_dormant,
				dormant_flavor_info * out_flavor);

		status_t GetLatencyFor(
				const media_node & producer,
				bigtime_t * out_latency);
		status_t GetInitialLatencyFor(
				const media_node & producer,
				bigtime_t * out_latency,
				uint32 * out_flags = 0);
		status_t GetStartLatencyFor(
				const media_node & time_source,
				bigtime_t * out_latency);

		status_t GetFileFormatsFor(
				const media_node & file_interface, 
				media_file_format * out_formats,
				int32 * io_num_infos);
		status_t SetRefFor(
				const media_node & file_interface,
				const entry_ref & file,
				bool create_and_truncate,
				bigtime_t * out_length);	/* if create is false */
		status_t GetRefFor(
				const media_node & node,
				entry_ref * out_file,
				BMimeType * mime_type = NULL);
		status_t SniffRefFor(
				const media_node & file_interface,
				const entry_ref & file,
				BMimeType * mime_type,
				float * out_capability);
		/* This is the generic "here's a file, now can someone please play it" interface */
		status_t SniffRef(
				const entry_ref & file,
				uint64 require_node_kinds,		/* if you need an EntityInterface or BufferConsumer or something */
				dormant_node_info * out_node,
				BMimeType * mime_type = NULL);
		status_t GetDormantNodeForType(
				const BMimeType & type,
				uint64 require_node_kinds,
				dormant_node_info * out_node);
		status_t GetReadFileFormatsFor(
				const dormant_node_info & in_node,
				media_file_format * out_read_formats,
				int32 in_read_count,
				int32 * out_read_count);
		status_t GetWriteFileFormatsFor(
				const dormant_node_info & in_node,
				media_file_format * out_write_formats,
				int32 in_write_count,
				int32 * out_write_count);

		status_t GetFormatFor(
				const media_output & output,
				media_format * io_format,
				uint32 flags = 0);
		status_t GetFormatFor(
				const media_input & input,
				media_format * io_format,
				uint32 flags = 0);
		status_t GetFormatFor(
				const media_node & node,
				media_format * io_format,
				float quality = B_MEDIA_ANY_QUALITY);
		ssize_t GetNodeAttributesFor(
				const media_node & node,
				media_node_attribute * outArray,
				size_t inMaxCount);
		media_node_id NodeIDFor(
				port_id source_or_destination_port);
		status_t GetInstancesFor(
				media_addon_id addon,
				int32 flavor,
				media_node_id * out_id,
				int32 * io_count = 0);	//	default to 1


		status_t SetRealtimeFlags(
				uint32 in_enabled);
		status_t GetRealtimeFlags(
				uint32 * out_enabled);
		ssize_t AudioBufferSizeFor(
				int32 channel_count,
				uint32 sample_format,
				float frame_rate,
				bus_type bus_kind);

		/* Use MediaFlags to inquire about specific features of the Media Kit. */
		/* Returns < 0 for "not present", positive size for output data size. */
		/* 0 means that the capability is present, but no data about it. */
static	ssize_t MediaFlags(
				media_flags cap,
				void * buf,
				size_t maxSize);

		/* BLooper overrides */
virtual		void MessageReceived(
				BMessage * message);

virtual		bool QuitRequested();

virtual		BHandler * ResolveSpecifier(
				BMessage *msg,
				int32 index,
				BMessage *specifier,
				int32 form,
				const char *property);
virtual		status_t GetSupportedSuites(
				BMessage *data);

			~BMediaRoster();

private:

		//	deprecated call
		status_t SetOutputBuffersFor(
				const media_source & output,
				BBufferGroup * group,
				bool will_reclaim = false);

		/* FBC stuffing (Mmmh, Stuffing!) */
virtual		status_t _Reserved_MediaRoster_0(void *);
virtual		status_t _Reserved_MediaRoster_1(void *);
virtual		status_t _Reserved_MediaRoster_2(void *);
virtual		status_t _Reserved_MediaRoster_3(void *);
virtual		status_t _Reserved_MediaRoster_4(void *);
virtual		status_t _Reserved_MediaRoster_5(void *);
virtual		status_t _Reserved_MediaRoster_6(void *);
virtual		status_t _Reserved_MediaRoster_7(void *);

friend class BPrivate::media::DefaultDeleter;
friend class BPrivate::media::BMediaRosterEx;

static	bool _isMediaServer;

		BMediaRoster();

static	port_id _mReplyPort;
static	int32 _mReplyPortRes;
static	int32 _mReplyPortUnavailCount;

		uint32 _reserved_media_roster_[67];


static	BMediaRoster * _sDefault;

static	status_t ParseCommand(
				BMessage & reply);

		status_t GetDefaultInfo(
				media_node_id for_default,
				BMessage & out_config);
		status_t SetRunningDefault(
				media_node_id for_default,
				const media_node & node);
		
static	port_id checkout_reply_port(
				const char * name = NULL);
static	void checkin_reply_port(
				port_id port);

};


#endif /* _MEDIA_ROSTER_H */