///////////////////////////////////////////////////////////////////////////////
// The following things were found by means of "revenge", "strings" and
// load_add_on()/get_image_symbol() on the Be's binary "bt848.media_addon".
///////////////////////////////////////////////////////////////////////////////


//--- Source's file names:
//------------------------
// 19x: GCC: (GNU) 2.9-beos-991026, meaning:
// 16 source files plus: init_term_dyn.c, crtbegin.o, crtend.o

bt848addon.cpp
Bt848Controllable.cpp
Bt848Source.cpp
Bt848AudioMux.cpp
Bt848I2C.cpp
Bt848Tuner.cpp
Bt848VideoControls.cpp
Bt848VideoMux.cpp

AudioMux.cpp
I2CBus.cpp
Tuner.cpp
VideoControls.cpp
VideoConversions.cpp
VideoImage.cpp
VideoMux.cpp
VideoSource.cpp


BT848Addon <--| BT848Controllable



// Tables on bt848.media_addon:
// =============================

const char* kVideoFormat[] = {
	"Unknown",
	"NTSC-M",
	"NTSC-J",
	"PAL-BDGHI",
	"PAL-M",
	"PAL-N",	// Missing PAL-Nc ?
	"SECAM"
}

const char* kTunerLocale[] = {
	"Unknown",
	"Australia Air",
	"Brazil Air",		// really necessary?
	"China Air",
	"Europe Air",
	"Europe Cable",
	"France Air",
	"France Cable",
	"Great Britain Air",
	"Great Britain Cable",
	"Japan Air",
	"Japan Cable",
	"US Air",		// These "US" are used all across the American continent.
	"US Cable",		// IRC = Intercarrier Related Channels
	"US Cable HRC",	// HRC = Harmonically Related Channels
	"FM Radio"
}

const char* kTunerBrand[] = {
	"No Tuner",
	"Alps",
	"Panasonic",
	"Philips",
	"Temic"
}

const char* kVideoSourceName[] = {
	"None"
	"Composite 1",
	"Composite 2",
	"Composite 3",
	"Composite 4",
	"Tuner",
	"SVideo",
	"Camera"		// Surveillance cards?
}

const char* kAudioSourceName[] = {
	"Mute",
	"External Jack",
	"Internal Jack",
	"Radio",
	"Microphone",
	"Main",
	"Second",
	"Both"
}

const char* kAudioMode[] = {
	"US NTSC FM",
	"PAL B/G FM",
	"PAL B/G NICAM",
	"PAL I NICAM",
	"FM RADIO",
	"Satellite FM Mono"
}

const char* kMspMode[] = {
	"AM (type 1)",
	"AM (type 2)"
}

const char* kImageSize[] = {
	"768x576",
	"720x576",
	"720x480",
	"640x480",
	"352x240",
	"320x240",
	"160x120"
}

const char* kColorspace[] = {
	"8 Bits/Pixel (Gray)",
	"15 Bits/Pixel",
	"16 Bits/Pixel",
	"32 Bits/Pixel"
}

// These tables hold a name/frequencies pairs.
//----------------------------------------------------------------
typedef struct channel {
	const char* name;
	uint32		freq;	// in Hz
}

channel* USNtscAir[] = {
	{  "2",  55250000 },
//	...
	{ "69", 801250000 }
}

channel* USNtscCableIRC[] = {
	{   "1",  73250000 },
//	...
	{ "125", 799250000 }
}

channel* USNtscCableHRC[] = {
	{   "1",  72000000 },
//	...
	{ "125", 798000000 }
}

// And the rest:
channel* JapanNtscAir[]
channel* JapanNtscCable[]
channel* EuropePalAir[]
channel* EuropePalCable[]
channel* GreatBritainPalAir[]
channel* GreatBritainPalCable[]
channel* FranceSecamAir[]
channel* FranceSecamCable[]
channel* ChinaPalAir[]
channel* BrazilPalAir[]
channel* AustraliaPalAir[]

// Believe it or Not: it's stored this way in the addon!!!
channel* FmRadio[] = {
	{  "64.0",  64000000 },
//	...
	{ "108.0", 108000000 }
}


// What's in here?
RGB8Map	// sizeof(RGB8MAP) == 1024
// looks like a conversion table.

//------------------------------------------------------------------------------
//
// Classes on bt848.media_addon:
// =============================
//
// The scope of methods is just my guess. Ditto for most return types.
//
//------------------------------------------------------------------------------

class BAudioMux
{
	public:
					BAudioMux(const char* name);
		virtual		~BAudioMux();

		const char*	Name()						const { return fName; };

		uint32		Source()					const { return fSource; };
		void		SetSource(uint32 source);

		uint32		NumberInputs() const;

		void		Mute();
		void		Unmute();

	private:
		void	SetMute(uint32);
		void	SetShift(uint32);

		virtual	void	_ReservedAudioMux1();
		virtual	void	_ReservedAudioMux2();
		virtual	void	_ReservedAudioMux3();

		const char*	fName;
		uint32		fSource;
}

class Bt848AudioMux
{
	public:
				Bt848AudioMux(const char* name, uint32 , bt848_config* );
		virtual	~Bt848AudioMux();

		uint32 NumberInputs() const;

		SetSource(uint32);

		void	Mute();
		void	Unmute();

	private:
		void	SetMute(uint32);
		void	SetShift(uint32);
}

//------------------------------------------------------------------------------

class BI2CBus
{
	public:
						BI2CBus(const char* name);
		virtual			~BI2CBus();

		const char*	Name()									{ return fName; };
		bool		I2CDevicePresent(uint8 address)			{ return false; };

		int		I2CReadByte(bool)								{ return 0; };
		int		I2CSendByte(uint8 value, bigtime_t timeout);	{ return 0; };

	protected:
		int		I2CRead(uint8 address)						{ return 0; };

		void	I2CWrite1(uint8 address, uint8 value)		{ };
		void	I2CWrite2(uint8 address, uint8 , uint8 )	{ };

	private:
		virtual	int		I2CAck()	= 0;
		virtual	int		I2CStatus()	= 0;

		virtual	void	I2COne()	= 0;
		virtual	void	I2CZero()	= 0;

		virtual	void	I2CReset()	= 0;
		virtual	void	I2CStart()	= 0;
		virtual	void	I2CStop()	= 0;

		virtual	void	_ReservedI2CBus1();
		virtual	void	_ReservedI2CBus2();
		virtual	void	_ReservedI2CBus3();

		const char*	fName;
}

class Bt848I2C
{
	public:
				Bt848I2C(const char* name, long, bt848_config* );
		virtual	~Bt848I2C();

		bool I2CDevicePresent(uint8 address);

		int	I2CReadByte(bool);
		int	I2CSendByte(uint8, bigtime_t timeout);

	protected:
		int	I2CRead(uint8 address);
		int	I2CWrite1(uint8, uint8);
		int	I2CWrite2(uint8, uint8, uint8);

	private:
		int		I2CAck();
		int		I2CStatus();

		void	I2COne();
		void	I2CZero();

		void	I2CReset();
		void	I2CStart();
		void	I2CStop();

		void	I2CBits();
		void	I2CSetBits(uint8 scl, uint8 sda)
}

//------------------------------------------------------------------------------

class BTuner
{
	public:
					BTuner(const char* name);
		virtual		~BTuner();

		const char*	Name()					{ return fName; };

		bool	FMRadioCapable()	const	{ return false; };
		bool	TVCapable()			const	{ return false; };
		bool	BTSCSAPCapable()	const	{ return false; };
		bool	BTSCStereoCapable()	const	{ return false; };

		uint8	BTSCAudioMode()				{ return fBTSAudioMode; };
		void	SetBTSCAudioMode(uint8);

		bool	BTSCSAPPresent()			{ return false; };
		bool	BTSCStereoPresent()			{ return false; };

		uint32	CurrentFrequency()	const	{ return fCurrentFreq;  };
		uint32	CurrentIndex()		const	{ return fCurrentIndex; };

		bool	TunerLocked()				{ return false; };
		int		TunerStatus()				{ return 0;     };

		uint32	FrequencyFor(uint32 channel_index)			const;
		uint32	FrequencyFor(char* channel_name)			const;
		uint32	IndexForChannelName(char* channel_name)		const;
		char*	ChannelNameForIndex(uint32 channel_index)	const;

		uint32	NumberChannels() const;

		void	NextChannel();
		void	PreviousChannel();
		void	FineTuneDown();
		void	FineTuneUp();
		void	ScanDown();
		void	ScanUp();

		bool	ValidFrequency(uint32 frequency) const;

		tuner_locale	TunerLocale() const { return fTunerLocale; };
		status_t		SetTunerLocale(tuner_locale);

		status_t	Tune(uint32 frequency);
		status_t	Tune(char* channel_name);
		status_t	TuneIndex(uint32 index);

	private:
		virtual	void	_ReservedTuner1();
		virtual	void	_ReservedTuner2();
		virtual	void	_ReservedTuner3();

		const char*		fName;
		uint32			fCurrentFreq;
		uint32			fCurrentIndex;
		tuner_locale	fTunerLocale;
		uint8			fBTSAudioMode;
}

//------------------------------------------------------------------------------

class Bt848Tuner
{
	public:
					Bt848Tuner(const char* name, uint32 ,
								bt848_config* , hw_info* ,
								BI2CBus* i2c_bus, BAudioMux* audio_mux);

		virtual		~Bt848Tuner();

		uint32 CurrentFrequency() const;
		uint32 CurrentIndex() const;

		void	FineTuneDown();
		void	FineTuneUp();

		void	NextChannel();
		void	PreviousChannel();

		void	ScanDown();
		void	ScanUp();

		status_t	Tune(char* channel_name);
		status_t	Tune(uint32 frequency);
		status_t	TuneIndex(uint32 index);

		bool	TunerLocked();
		int		TunerStatus();

		bool VideoPresent();
}

//------------------------------------------------------------------------------

class BVideoControls
{
	public:
				BVideoControls(const char* name);
		virtual	~BVideoControls();

		const char*		Name()	{ return fName; };

		virtual int32	Brightness()				const = 0;
		virtual int32	Contrast()					const = 0;
		virtual int32	Hue()						const = 0;
		virtual int32	Saturation()				const = 0;

		virtual bool	ChromaCombFilter()			const = 0;
		virtual bool	ErrorDiffusion()			const = 0;
		virtual bool	GammaCorrectionRemoval()	const = 0;
		virtual bool	LumaCombFilter()			const = 0;
		virtual bool	LumaCoring()				const = 0;

		virtual void	SetBrightness(int32 value)	= 0;
		virtual void	SetContrast(int32 value)	= 0;
		virtual void	SetHue(int32 value)		= 0;
		virtual void	SetSaturation(int32 value)	= 0;

		virtual void	SetChromaCombFilter(bool enabled)		= 0;
		virtual void	SetErrorDiffusion(bool enabled)			= 0;
		virtual void	SetGammaCorrectionRemoval(bool enabled)	= 0;
		virtual void	SetLumaCombFilter(bool enabled)			= 0;
		virtual void	SetLumaCoring(bool enabled)				= 0;

	private:
		virtual void	_ReservedVideoControls1();
		virtual void	_ReservedVideoControls2();
		virtual void	_ReservedVideoControls3();

		const char*		fName;
}

//------------------------------------------------------------------------------

class Bt848VideoControls
{
	public:
				Bt848VideoControls(const char* name, long , bt848_config* )
		virtual	~Bt848VideoControls()

		int32 Brightness()				const { return fBrightness; }
		int32 Contrast()				const { return fContrast; }
		int32 Hue()						const { return fHue; }
		int32 Saturation()				const { return fSaturation; }

		bool ChromaCombFilter()			const { return fChromaCombFilter; }
		bool ErrorDiffusion()			const { return fErrorDiffusion; }
		bool GammaCorrectionRemoval()	const { return fGammaCorrectionRemoval; }
		bool LumaCombFilter()			const { return fLumaCombFilter; }
		bool LumaCoring()				const { return fLumaCoring; }

		virtual void	SetBrightness(int32 value);
		virtual void	SetContrast(int32 value);
		virtual void	SetHue(int32 value);
		virtual void	SetSaturation(int32 value);

		virtual void	SetChromaCombFilter(bool enabled);
		virtual void	SetErrorDiffusion(bool enabled);
		virtual void	SetGammaCorrectionRemoval(bool enabled);
		virtual void	SetLumaCombFilter(bool enabled);
		virtual void	SetLumaCoring(bool enabled);

	private:
		int32 fBrightness;
		int32 fContrast;
		int32 fHue;
		int32 fSaturation;

		bool fChromaCombFilter;
		bool fErrorDiffusion;
		bool fGammaCorrectionRemoval;
		bool fLumaCombFilter;
		bool fLumaCoring;
}

//------------------------------------------------------------------------------

class BVideoImage
{
	public:
				BVideoImage(BPoint size, color_space cspace,
							video_layout vlayout,
							buffer_orientation orientation, bool xx);
		virtual	~BVideoImage();

		bool IsValid() const;

		uint8	BitsPerPixel();
		void*	Buffer() const;
		SetBuffer(const void* , bool);

		uint32 BytesPerRow() const;
		SetBytesPerRow(uint32 value);

		color_space ColorSpace() const;
		SetColorSpace(color_space value);

		uint32 FrameNumber() const;
		SetFrameNumber(uint32  value);

		BPoint ImageSize() const;
		SetImageSize(BPoint value);

		bool IsLogical() const;
		SetLogical(bool value);

		video_layout Layout() const;
		SetLayout(video_layout);

		buffer_orientation Orientation() const;
		SetOrientation(buffer_orientation);

		long Status(void) const;
		SetStatus(long);

		BTimecode Timecode() const;
		SetTimecode(BTimecode);

		bigtime_t Timestamp() const;
		SetTimestamp(bigtime_t time_stamp);

	private:
		virtual	void	_ReservedVideoImage1();
		virtual	void	_ReservedVideoImage2();
		virtual	void	_ReservedVideoImage3();
}

//------------------------------------------------------------------------------

class BVideoMux
{
	public:
					BVideoMux(const char* name);
		virtual		~BVideoMux();

		const char*	Name()	{ return fName; };

		uint32		NumberInputs();

		uint32		Source() const;		// BVideoSource* ?
		void		SetSource(uint32);

	private:
		virtual	void	_ReservedVideoMux1();
		virtual	void	_ReservedVideoMux2();
		virtual	void	_ReservedVideoMux3();

		const char*	fName;
}

//------------------------------------------------------------------------------

class Bt848VideoMux
{
	public:
				Bt848VideoMux(const char* name, uint32 , bt848_config* )
		virtual	~Bt848VideoMux();

		bool	ColorBars() const;
		SetColorBars(bool enabled);

		uint32 NumberInputs();

		SetSource(uint32 source);
}

//------------------------------------------------------------------------------

class BVideoSource
{
	public:
					BVideoSource(const char* name);
		virtual		~BVideoSource();

		const char*	Name()	{ return fName; };

		status_t InitCheck();

		// Interface to inner working classes.
		BAudioMux*		AudioMux()		const;	// it's * or & ???
		BI2CBus*		I2CBus()		const;
		BTuner*			Tuner()			const;
		BVideoMux*		VideoMux()		const;
		BVideoControls*	VideoControls()	const;

		uint32	CaptureMode() const;
		SetCaptureMode(uint32 capture_mode);

		ConfigureCapture(BVideoImage**, short** , uint32 , void** , BVideoImage** , short** )

		StartCapture(bool);
		StopCapture();
		ContinueCapture();
		RestartCapture();
		SwitchCapture();

		uint64	FramesDropped() const;

		LastFrame(uint32* );
		NextFrame(uint32* );
		NextFrameWithTimeout(bigtime_t , uint32* );

		video_format VideoFormat() const;
		SetVideoFormat(video_format);

	private:
		virtual	void	_ReservedVideoSource1();
		virtual	void	_ReservedVideoSource2();
		virtual	void	_ReservedVideoSource3();

		const char*	fName;
}

//------------------------------------------------------------------------------

class Bt848Source
{
	public:
				Bt848Source(const char* name)
		virtual	~Bt848Source();


		AddressType(video_field_specifier) const;
		AllocateCaptureBuffer(bt848_buffer* );

		BAudioMux*		AudioMux()		const;	// it's * or & ???
		BVideoMux*		VideoMux()		const;
		BI2CBus*		I2CBus()		const;
		BTuner*			Tuner()			const;
		BVideoControls*	VideoControls()	const;

		uint32	CaptureMode() const;
		SetCaptureMode(uint32);

		color_space	ColorSpace(video_field_specifier) const;
		SetColorSpace(color_space, video_field_specifier);

		bt848_tuner_mfg	TunerBrand() const;
		SetTunerBrand(bt848_tuner_mfg)

		video_format	VideoFormat() const;
		SetVideoFormat(video_format);

		uint32	Gpio();
		void	SetGpio(uint32 value);

		bool	Pll() const;
		void	SetPll(bool enabled);

		ConfigureCapture(BVideoImage** , short** , uint32 , void** , BVideoImage** , short** )
		ConfigureDualCapture(BVideoImage** , short** , BVideoImage** , short** , uint32 , void** )
		ConfigureSingleCapture(BVideoImage** , short** , uint32 , void** )

		StartCapture(bool);
		ContinueCapture();
		StopCapture();
		RestartCapture();

		uint32 Decimation() const;
		SetDecimation(uint32 decimation);

		uint16 DeviceID() const;

		FreeCaptureBuffer(bt848_buffer* );
		GetFrame(uint32);

		GpioInEnable(uint32);
		GpioOutEnable(uint32);

		status_t	InitCheck();

		LastFrame(uint32* );
		NextFrame(uint32* );
		NextFrameWithTimeout(bigtime_t, uint32* );

		bool Probe();
		SetAddressType(uint32, video_field_specifier);

		SwitchCapture(uint32* );
		bool VideoPresent();
		WaitForFrame(bigtime_t howLong, uint32* frame);
}

//------------------------------------------------------------------------------
// Media Kit Interfaces.

class BBt848Controllable
{
	// BControllable
	protected:
				BBt848Controllable(int , uint32 , const char*, const char* , BMediaAddOn* )
		virtual	~BBt848Controllable();

	public:

		virtual status_t	GetParameterValue(int32 parameterID,
											bigtime_t* lastChangeTime,
											void* value, size_t* ioSize);
		virtual void		SetParameterValue(int32 parameterID,
											bigtime_t changeTime,
											const void* value, size_t size);

	// BMediaEventLooper : BMediaNode
		virtual BMediaAddOn*	AddOn(int32* outInternalID) const;

		virtual void			NodeRegistered();

		virtual void			HandleEvent(const media_timed_event* event,
										bigtime_t lateness, bool realTimeEvent);

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

	protected:
		virtual status_t		DeleteHook(BMediaNode* node);

		virtual void			Preroll();

		virtual void			Start(bigtime_t performanceTime);
		virtual void			Stop(bigtime_t performanceTime, bool immediate);

		virtual void			SetRunMode(BMediaNode::run_mode mode);


	// BBufferProducer
	public:
		virtual status_t	AdditionalBufferRequested(const media_source& source,
											media_buffer_id previousBufferID,
											bigtime_t previousTime,
											const media_seek_tag* previousTag);

		virtual void		Connect(status_t status, const media_source& source,
									const media_destination& destination,
									const media_format& format, char* ioName);

		virtual void		Disconnect(const media_source& source,
										const media_destination &destination);

		virtual status_t	DisposeOutputCookie(int32 cookie);

		virtual void		EnableOutput(const media_source& whichOutput,
										bool enabled, int32 *_depreciated_);

		virtual status_t	FormatChangeRequested(const media_source& source,
												const media_destination& destination,
												media_format* ioFormat,
												int32 *_depreciated_);

		virtual status_t	FormatProposal(const media_source& output,
											media_format* format);
		virtual status_t	FormatSuggestionRequested(media_type type,
										int32 quality, media_format* format);

		virtual status_t	GetLatency(bigtime_t* outLatency);
		virtual status_t	GetNextOutput(int32* cookie, media_output* outOutput);

		virtual void		LateNoticeReceived(const media_source& whichSource,
												bigtime_t howLate,
												uint32 performanceTime);

		virtual status_t	PrepareToConnect(const media_source& whichSource,
									const media_destination& whichDestination,
									media_format* format,
									media_source* outSource, char* outName);

		virtual status_t	SetBufferGroup(const media_source& forSource, BBufferGroup* group);
		virtual status_t	SetPlayRate(int32 numerator, int32 denominator);

		virtual status_t	TimeSourceOp(const BTimeSource::time_source_op_info& op,
									void *_reserved);

		virtual status_t	VideoClippingChanged(const media_source& forSource,
										int16 numShorts,
										int16* clipData,
										const media_video_display_info& display,
										int32* outFromChangeTag);

	private:	// ?
		Initialize();
		Uninitialize();

		ReadFmFavorites();
		ReadTvFavorites();

		ConstructControlWeb();
		RequestNewWeb();

		FindIndex(const char**, const char*);

		HandleStart(bigtime_t);
		HandleStop(bigtime_t);

		PrepareBufferMap();
		MapCaptureBuffers(BBufferGroup* , const media_video_display_info&, BVideoImage **, uint32&);

		SendBuffers(BVideoImage*, uint32);

		SetUpSettings(const char*, const char*);
		QuitSettings();

		ReconfigureCapture();
		RestartCapture(bool);
		StartCapture();
		StopCapture();
		SwitchCapture();
}

//------------------------------------------------------------------------------

class Bt848MediaAddOn
{
	public:
							Bt848MediaAddOn(image_id image)
		virtual				~Bt848MediaAddOn()

		virtual status_t	AutoStart(int32 index, BMediaNode** outNode, int32* outInternalID, bool* outHasMore);
		virtual int32		CountFlavors();
		virtual status_t	GetConfigurationFor(BMediaNode* node, BMessage* config);
		virtual status_t	GetFlavorAt(int32 flavorNum, const flavor_info** outInfo);
		virtual status_t	InitCheck(char const** outFailureText)
		virtual BMediaNode*	InstantiateNodeFor(const flavor_info* info, BMessage* config, status_t* outError);
		virtual bool		WantsAutoStart();

	private: // ?
		SaveConfigInfo(BMediaNode* node, BMessage* config);
}

//------------------------------------------------------------------------------