haiku.git

/*	Copyright (c) 1998-99, Be Incorporated, All Rights Reserved.
 *	Distributed under the terms of the Be Sample Code license.
 *
 *	Copyright (c) 2000-2008, Ingo Weinhold <ingo_weinhold@gmx.de>,
 *	Copyright (c) 2000-2008, Stephan Aßmus <superstippi@gmx.de>,
 *	All Rights Reserved. Distributed under the terms of the MIT license.
 */
#ifndef _VIDEO_PRODUCER_H
#define _VIDEO_PRODUCER_H


#include <BufferProducer.h>
#include <Controllable.h>
#include <Locker.h>
#include <MediaDefs.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <OS.h>
#include <Rect.h>


class NodeManager;
class VideoSupplier;


class VideoProducer : public virtual BMediaEventLooper,
					  public virtual BBufferProducer {
public:
							VideoProducer(BMediaAddOn* addon, const char* name,
								int32 internalId, NodeManager* manager,
								VideoSupplier* supplier);
	virtual					~VideoProducer();
	
	virtual	status_t		InitCheck() const
								{ return fInitStatus; }
	
	// BMediaNode interface
public:
	virtual	BMediaAddOn*	AddOn(int32* _internalId) const;
	virtual	status_t	 	HandleMessage(int32 message, const void* data,
								size_t size);
protected:	
	virtual void			SetTimeSource(BTimeSource* timeSource);
	
	// BMediaEventLooper interface
protected:
	virtual	void 			NodeRegistered();
	virtual void			Start(bigtime_t performanceTime);
	virtual void			Stop(bigtime_t performanceTime, bool immediate);
	virtual void			Seek(bigtime_t mediaTime,
								bigtime_t performanceTime);
	virtual void			HandleEvent(const media_timed_event* event,
								bigtime_t lateness,
								bool realTimeEvent = false);
	virtual status_t		DeleteHook(BMediaNode* node);
	
	// BBufferProducer interface
protected:
	virtual	status_t		FormatSuggestionRequested(media_type type,
								int32 quality, media_format* format);
	virtual	status_t 		FormatProposal(const media_source &output,
								media_format* format);
	virtual	status_t		FormatChangeRequested(const media_source& source,
								const media_destination& destination,
								media_format* ioFormat, int32* _deprecated_);
	virtual	status_t 		GetNextOutput(int32* cookie,
								media_output* outOutput);
	virtual	status_t		DisposeOutputCookie(int32 cookie);
	virtual	status_t		SetBufferGroup(const media_source& forSource,
								BBufferGroup* group);
	virtual	status_t 		VideoClippingChanged(const media_source& forSource,
								int16 numShorts, int16* clipData,
								const media_video_display_info& display,
								int32* _deprecated_);
	virtual	status_t		GetLatency(bigtime_t* out_latency);
	virtual	status_t		PrepareToConnect(const media_source& what,
								const media_destination& where,
								media_format* format, media_source* outSource,
								char* out_name);
	virtual	void			Connect(status_t error, const media_source& source,
								const media_destination& destination,
								const media_format& format, char* ioName);
	virtual	void 			Disconnect(const media_source& what,
								const media_destination& where);
	virtual	void 			LateNoticeReceived(const media_source& what,
								bigtime_t howMuch, bigtime_t performanceTime);
	virtual	void 			EnableOutput(const media_source& what, bool enabled,
								int32* _deprecated_);
	virtual	status_t		SetPlayRate(int32 numer, int32 denom);
	virtual	void 			AdditionalBufferRequested(
								const media_source& source,
								media_buffer_id prevBuffer,
								bigtime_t prevTime,
								const media_seek_tag* prevTag);
	virtual	void			LatencyChanged(const media_source& source,
								const media_destination& destination,
								bigtime_t newLatency, uint32 flags);
	
 private:
			void			_HandleStart(bigtime_t performance_time);
			void			_HandleStop();
			void			_HandleTimeWarp(bigtime_t performance_time);
			void			_HandleSeek(bigtime_t performance_time);

	static	int32			_FrameGeneratorThreadEntry(void* data);
			int32			_FrameGeneratorThread();

		status_t			fInitStatus;

		int32				fInternalID;
		BMediaAddOn*		fAddOn;

		BLocker				fLock;
		BBufferGroup*		fBufferGroup;
		BBufferGroup*		fUsedBufferGroup;

		thread_id			fThread;
		sem_id				fFrameSync;

		// The remaining variables should be declared volatile, but they
		// are not here to improve the legibility of the sample code.
		int64				fFrame;
		int64				fFrameBase;
		bigtime_t			fPerformanceTimeBase;
		bigtime_t			fBufferDuration;
		bigtime_t			fBufferLatency;
		media_output		fOutput;
		media_raw_video_format	fConnectedFormat;
		bool				fRunning;
		bool				fConnected;
		bool				fEnabled;

		NodeManager*		fManager;
		VideoSupplier*		fSupplier;
};

#endif // VIDEO_PRODUCER_H