text: /*
   * Copyright 2014, Haiku, Inc. All rights reserved.
   * Distributed under the terms of the MIT License.
   */
  #ifndef _MEDIA_RECORDER_H
  #define _MEDIA_RECORDER_H
  
  
  #include <MediaDefs.h>
  #include <MediaNode.h>
  
  
  namespace BPrivate { namespace media {
  class BMediaRecorderNode;
  }
  }
  
  
  class BMediaRecorder {
  public:
  	enum notification {
  		B_WILL_START = 1,	// performance_time
  		B_WILL_STOP,		// performance_time immediate
  		B_WILL_SEEK,		// performance_time media_time
  		B_WILL_TIMEWARP,	// real_time performance_time
  	};
  
  	typedef void				(*ProcessFunc)(void* cookie,
  									bigtime_t timestamp, void* data,
  									size_t size, const media_format& format);
  
  	typedef void				(*NotifyFunc)(void* cookie,
  									notification what, ...);
  
  public:
  								BMediaRecorder(const char* name,
  									media_type type
  										= B_MEDIA_UNKNOWN_TYPE);
  
  	virtual						~BMediaRecorder();
  
  			status_t			InitCheck() const;
  
  			status_t			SetHooks(ProcessFunc recordFunc = NULL,
  									NotifyFunc notifyFunc = NULL,
  									void* cookie = NULL);
  
  			void				SetAcceptedFormat(
  									const media_format& format);
  			const media_format&	AcceptedFormat() const;
  
  	virtual status_t			Start(bool force = false);
  	virtual status_t			Stop(bool force = false);
  
  	virtual status_t			Connect(const media_format& format);
  
  	virtual status_t			Connect(const dormant_node_info& dormantInfo,
  									const media_format& format);
  
  	virtual status_t			Connect(const media_node& node,
  									const media_output* output = NULL,
  									const media_format* format = NULL);
  
  	virtual status_t			Disconnect();
  
  			bool				IsConnected() const;
  			bool				IsRunning() const;
  
  			const media_format&	Format() const;
  
  protected:
  			// Get the producer node source
  			const media_source&	MediaSource() const;
  			// This is the our own input
  			const media_input	MediaInput() const;
  
  	virtual	void				BufferReceived(void* buffer, size_t size,
  									const media_header& header);
  
  			status_t			SetUpConnection(media_source outputSource);
  
  private:
  
  			status_t			_Connect(const media_node& mediaNode,
  									const media_output* output,
  									const media_format& format);
  
  	virtual	void				_ReservedMediaRecorder0();
  	virtual	void				_ReservedMediaRecorder1();
  	virtual	void				_ReservedMediaRecorder2();
  	virtual	void				_ReservedMediaRecorder3();
  	virtual	void				_ReservedMediaRecorder4();
  	virtual	void				_ReservedMediaRecorder5();
  	virtual	void				_ReservedMediaRecorder6();
  	virtual	void				_ReservedMediaRecorder7();
  
  			status_t			fInitErr;
  
  			bool				fConnected;
  			bool				fRunning;
  			bool				fReleaseOutputNode;
  
  			ProcessFunc			fRecordHook;
  			NotifyFunc			fNotifyHook;
  
  			media_node			fOutputNode;
  			media_source		fOutputSource;
  
  			BPrivate::media::BMediaRecorderNode* fNode;
  
  			void*				fBufferCookie;
  			uint32				fPadding[32];
  
  			friend class		BPrivate::media::BMediaRecorderNode;
  };
  
  #endif	//	_MEDIA_RECORDER_H
  