haiku.git

/*
 * Copyright 1998-1999 Be, Inc. All Rights Reserved.
 * Copyright 2003-2019 Haiku, Inc. All rights reserved.
 * Distributed under the terms of the MIT License.
 */
#ifndef VIDEO_CONSUMER_H
#define VIDEO_CONSUMER_H


#include <Bitmap.h>
#include <BufferConsumer.h>
#include <MediaEventLooper.h>
#include <MediaNode.h>
#include <TimedEventQueue.h>
#include <TranslatorRoster.h>
#include <View.h>
#include <Window.h>


typedef struct {
	port_id		port;
	bigtime_t	rate;
	uint32		imageFormat;
	int32		translator;
	int32		uploadClient;
	bool		passiveFtp;
	char		fileNameText[64];
	char		serverText[64];
	char		loginText[64];
	char		passwordText[64];
	char		directoryText[64];
} ftp_msg_info;

#define FTP_INFO 0x60000001

class BStringView;



class VideoConsumer : public BMediaEventLooper, public BBufferConsumer {
public:
								VideoConsumer(const char* name, BView* view,
									BStringView* statusLine, BMediaAddOn *addon,
									const uint32 internalId);
								~VideoConsumer();

/*	BMediaNode */
public:
	virtual	BMediaAddOn* 		AddOn(int32* cookie) const;

protected:
	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 				TimeWarp(bigtime_t atRealTime,
									bigtime_t toPerformanceTime);

	virtual void 				NodeRegistered();
	virtual	status_t 			RequestCompleted(
									const media_request_info& info);

	virtual	status_t 			HandleMessage(int32 message, const void* data,
									size_t size);

	virtual status_t 			DeleteHook(BMediaNode* node);

/*  BMediaEventLooper */
protected:
		virtual void 			HandleEvent(const media_timed_event* event,
									bigtime_t lateness, bool realTimeEvent);

/*	BBufferConsumer */
public:
	virtual	status_t 			AcceptFormat(const media_destination& dest,
									media_format* format);

	virtual	status_t 			GetNextInput(int32* cookie,
									media_input* outInput);

	virtual	void 				DisposeInputCookie(int32 cookie);

protected:
	virtual	void 				BufferReceived(BBuffer* buffer);

private:
	virtual	void 				ProducerDataStatus(
									const media_destination &forWhom,
									int32 status, bigtime_t atMediaTime);

	virtual	status_t 			GetLatencyFor(const media_destination& forWhom,
									bigtime_t* outLatency,
									media_node_id* outId);

	virtual	status_t 			Connected(const media_source& producer,
									const media_destination& where,
									const media_format& withFormat,
									media_input* outInput);

	virtual	void 				Disconnected(const media_source& producer,
									const media_destination& where);

	virtual	status_t 			FormatChanged(const media_source& producer,
									const media_destination& consumer,
									int32 fromChangeCount,
									const media_format& format);

/*	implementation */

public:
			status_t 			CreateBuffers(const media_format& withFormat);

			void 				DeleteBuffers();

	static 	status_t 			FtpRun(void* data);

			void 				FtpThread();

			void 				UpdateFtpStatus(const char* status);

			status_t 			LocalSave(char* filename, BBitmap* bitmap);

			status_t 			FtpSave(char* filename);

private:
			BStringView*		fStatusLine;
			int32				fInternalID;
			BMediaAddOn*		fAddOn;

			thread_id			fFtpThread;

			bool				fConnectionActive;
			media_input			fIn;
			media_destination	fDestination;
			bigtime_t			fMyLatency;

			BWindow*			fWindow;
			BView*				fView;
			BBitmap*			fBitmap[3];
			bool				fOurBuffers;
			BBufferGroup*		fBuffers;
			BBuffer*			fBufferMap[3];

			BBitmap*			fFtpBitmap;
			volatile bool		fTimeToFtp;
			volatile bool		fFtpComplete;

			bigtime_t			fRate;
			uint32				fImageFormat;
			int32				fTranslator;
			int32				fUploadClient;
			bool				fPassiveFtp;
			char				fFileNameText[64];
			char				fServerText[64];
			char				fLoginText[64];
			char				fPasswordText[64];
			char				fDirectoryText[64];
};

#endif	// VIDEO_CONSUMER_H