/*
 * FireWire DV media addon for Haiku
 *
 * Copyright (c) 2008, JiSheng Zhang (jszhang3@mail.ustc.edu.cn)
 * Distributed under the terms of the MIT License.
 *
 * Based on DVB media addon 
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 */


#include "FireWireDVNode.h"

#include <fcntl.h>
#include <malloc.h>
#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/uio.h>
#include <unistd.h>

#include <Autolock.h>
#include <Buffer.h>
#include <BufferGroup.h>
#include <Debug.h>
#include <Directory.h>
#include <Entry.h>
#include <MediaRoster.h>
#include <ParameterWeb.h>
#include <Path.h>
#include <TimeSource.h>
#include <String.h>

#include "FireWireDVNode.h"
#include "FireWireCard.h"
#include "debug.h"

#define REVISION		"unknown"
#define VERSION			"1.0"
#define BUILD	 		__DATE__ " " __TIME__

// debugging
#ifdef TRACE
#	undef TRACE
#endif
//#define TRACE_FIREWIRE_NODE
#ifdef TRACE_FIREWIRE_NODE
#	define TRACE(x...)		printf(x)
#else
#	define TRACE(x...)
#endif

#define RETURN_IF_ERROR(expr) { status_t e = (expr); if (e != B_OK) return e; }

#define M_REFRESH_PARAMETER_WEB 		(BTimedEventQueue::B_USER_EVENT + 1)

FireWireDVNode::FireWireDVNode(BMediaAddOn* addon, const char* name, 
	int32 internal_id, FireWireCard* card)
	: BMediaNode(name),
	BBufferProducer(B_MEDIA_ENCODED_VIDEO),	
	BControllable(),
	BMediaEventLooper(),
	fOutputEnabledEncVideo(false),
	fCard(card),
	fCaptureThreadsActive(false),
	fThreadIdCardReader(-1),
	fTerminateThreads(false),
	fBufferGroupEncVideo(0),
	fCaptureActive(false)
{
	CALLED();

	AddNodeKind(B_PHYSICAL_INPUT);
//	AddNodeKind(B_PHYSICAL_OUTPUT);

	fInternalID = internal_id;
	fAddOn = addon;
	
	fInitStatus = B_OK;
	
	fDefaultFormatEncVideo.type = B_MEDIA_ENCODED_VIDEO;
}


FireWireDVNode::~FireWireDVNode()
{
	CALLED();
	
	StopCapture();
	fWeb = NULL;	
}


/* BMediaNode */
BMediaAddOn*
FireWireDVNode::AddOn(int32* internal_id) const
{
	if (internal_id)
		*internal_id = fInternalID;
	return fAddOn;
}


status_t 
FireWireDVNode::HandleMessage(int32 message, const void* data, size_t size)
{
	return B_ERROR;
}


void 
FireWireDVNode::Preroll()
{
	/* This hook may be called before the node is started to give the hardware
	 * a chance to start. */
}


void
FireWireDVNode::SetTimeSource(BTimeSource* time_source)
{
	CALLED();
}


void
FireWireDVNode::SetRunMode(run_mode mode)
{
	CALLED();
	TRACE("FireWireDVNode::SetRunMode(%d)\n", mode);
}


/* BMediaEventLooper */
void 
FireWireDVNode::NodeRegistered()
{
	CALLED();

	fOutputEncVideo.node = Node();
	fOutputEncVideo.source.port = ControlPort();
	fOutputEncVideo.source.id = 0;
	fOutputEncVideo.destination = media_destination::null;
	fOutputEncVideo.format = fDefaultFormatEncVideo;
	strcpy(fOutputEncVideo.name, "encoded video");	
	
	RefreshParameterWeb();

	SetPriority(B_REAL_TIME_PRIORITY);
	Run();
}


void 
FireWireDVNode::HandleEvent(const media_timed_event* event,
	bigtime_t lateness, bool realTimeEvent)
{

	switch(event->type)
	{
		case M_REFRESH_PARAMETER_WEB:
			RefreshParameterWeb();
			break;
		case BTimedEventQueue::B_START:
			HandleStart(event->event_time);
			break;
		case BTimedEventQueue::B_STOP:
			HandleStop();
			break;
		case BTimedEventQueue::B_WARP:
			HandleTimeWarp(event->bigdata);
			break;
		case BTimedEventQueue::B_SEEK:
			HandleSeek(event->bigdata);
			break;
		case BTimedEventQueue::B_HANDLE_BUFFER:
		case BTimedEventQueue::B_DATA_STATUS:
		case BTimedEventQueue::B_PARAMETER:
		default:
			TRACE("FireWireDVNode::HandleEvent: Unhandled event -- %lx\n", event->type);
			break;
	}
}


/* BBufferProducer */
status_t 
FireWireDVNode::FormatChangeRequested(const media_source& source,
	const media_destination& destination, media_format* io_format,
	int32* _deprecated_)
{
	CALLED();

	// we don't support any other formats, so we just reject any format changes.
	return B_ERROR;
}


status_t 
FireWireDVNode::GetNextOutput(int32* cookie, media_output* out_output)
{
	CALLED();
	
	if (*cookie == 0) {
		*out_output = fOutputEncVideo;
		*cookie += 1;
		return B_OK;
	} else {
		return B_BAD_INDEX;
	}
}


status_t 
FireWireDVNode::DisposeOutputCookie(int32 cookie)
{
	CALLED();
	// do nothing because we don't use the cookie for anything special
	return B_OK;
}


status_t 
FireWireDVNode::SetBufferGroup(const media_source& source, BBufferGroup* group)
{
	CALLED();
	return B_ERROR;
}


status_t 
FireWireDVNode::VideoClippingChanged(const media_source& for_source,
	int16 num_shorts, int16* clip_data,
	const media_video_display_info& display, int32* _deprecated_)
{
	CALLED();
	return B_ERROR;
}


status_t 
FireWireDVNode::GetLatency(bigtime_t* out_latency)
{
	CALLED();
	
	*out_latency = EventLatency() + SchedulingLatency();
	return B_OK;
}


status_t 
FireWireDVNode::FormatSuggestionRequested(
	media_type type, int32 quality, media_format* format)
{
	CALLED();

	if (format == NULL) {
		fprintf(stderr, "\tERROR - NULL format pointer passed in!\n");
		return B_BAD_VALUE;
	}

	// this is the format we'll be returning (our preferred format)
	*format = fDefaultFormatEncVideo;

	// a wildcard type is okay; we can specialize it
	if (type == B_MEDIA_UNKNOWN_TYPE)
		type = B_MEDIA_ENCODED_VIDEO;

	if (type != B_MEDIA_ENCODED_VIDEO)
		return B_MEDIA_BAD_FORMAT;

	return B_OK;
}


status_t 
FireWireDVNode::FormatProposal(const media_source& source, 
	media_format* format)
{
	CALLED();	
	/* The connection process:
	 * we are here => BBufferProducer::FormatProposal
	 *                BBufferConsumer::AcceptFormat
	 *                BBufferProducer::PrepareToConnect
	 *                BBufferConsumer::Connected
	 *                BBufferProducer::Connect
	 *
	 * What we need to do:
	 * - if the format contains a wildcard AND we have a requirement for that
	 *   field, set it to the value we need.
	 * - if a field has a value that is not wildcard and not supported by us,
	 *   we don't change it, and return B_MEDIA_BAD_FORMAT
	 * - after we are done, the format may still contain wildcards.
	 */
	
	if (source.port != ControlPort()) {
		fprintf(stderr, "FireWireDVNode::FormatProposal returning "
			"B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}

	media_type requestedType = format->type;
	*format = fDefaultFormatEncVideo;

	if (requestedType != B_MEDIA_UNKNOWN_TYPE
		&& requestedType != B_MEDIA_ENCODED_VIDEO) {
		fprintf(stderr, "FireWireDVNode::FormatProposal returning "
			"B_MEDIA_BAD_FORMAT\n");
		return B_MEDIA_BAD_FORMAT;
	}
	
	// encoded video or wildcard type, either is okay by us
	return B_OK;
}


status_t 
FireWireDVNode::PrepareToConnect(const media_source& source,
	const media_destination& destination, media_format* format,
	media_source* out_source, char* out_name)
{
	/* The connection process:
	 *                BBufferProducer::FormatProposal
	 *                BBufferConsumer::AcceptFormat
	 * we are here => BBufferProducer::PrepareToConnect
	 *                BBufferConsumer::Connected
	 *                BBufferProducer::Connect
	 *
	 * At this point, the consumer's AcceptFormat() method has been called,
	 * and that node has potentially changed the proposed format. It may
	 * also have left wildcards in the format. PrepareToConnect()
	 * *must* fully specialize the format before returning!
	 */

	CALLED();
	// is the source valid?
	if (source.port != ControlPort() &&
			fCard->DetectRecvFn() != B_OK) {
		fprintf(stderr, "FireWireDVNode::PrepareToConnect returning "
			"B_MEDIA_BAD_SOURCE\n");
		return B_MEDIA_BAD_SOURCE;
	}

	// are we already connected?
	if (fOutputEncVideo.destination != media_destination::null)
		return B_MEDIA_ALREADY_CONNECTED;

	// the format may not yet be fully specialized (the consumer might have
	// passed back some wildcards).  Finish specializing it now, and return an
	// error if we don't support the requested format.
	if (format->type != B_MEDIA_RAW_AUDIO) {
		fprintf(stderr, "\tnon-raw-audio format?!\n");
		return B_MEDIA_BAD_FORMAT;
	}

	// reserve the connection by setting destination
	// set the output's format to the new format
	fOutputEncVideo.destination = destination;
	fOutputEncVideo.format = *format;

	// set source and suggest a name
	*out_source = source;
	strcpy(out_name, "encoded video");
	
	return B_OK;
}


void 
FireWireDVNode::Connect(status_t error, const media_source& source,
	const media_destination& destination, const media_format& format,
	char* io_name)
{
	/* The connection process:
	 *                BBufferProducer::FormatProposal
	 *                BBufferConsumer::AcceptFormat
	 *                BBufferProducer::PrepareToConnect
	 *                BBufferConsumer::Connected
	 * we are here => BBufferProducer::Connect
	 */

	CALLED();

	if (error != B_OK) {
		TRACE("Error during connecting\n");
		// if an error occured, unreserve the connection
		fOutputEncVideo.destination = media_destination::null;
		fOutputEncVideo.format = fDefaultFormatEncVideo;
		return;
	}

	// Since the destination is allowed to be changed by the
	// consumer, the one we got in PrepareToConnect() is no
	// longer correct, and must be updated here.
	fOutputEncVideo.destination = destination;
	fOutputEncVideo.format = format;

	// if the connection has no name, we set it now
	if (strlen(io_name) == 0)
		strcpy(io_name, "encoded video");

	#ifdef DEBUG
		bigtime_t latency;
		media_node_id ts;
		if (B_OK != FindLatencyFor(destination, &latency, &ts))
			TRACE("FindLatencyFor failed\n");
		else
			TRACE("downstream latency %lld\n", latency);
	#endif
}


void 
FireWireDVNode::Disconnect(const media_source &source,
	const media_destination& destination)
{
	CALLED();

	// unreserve the connection
	fOutputEncVideo.destination = media_destination::null;
	fOutputEncVideo.format = fDefaultFormatEncVideo;
}


void 
FireWireDVNode::LateNoticeReceived(const media_source& source,
	bigtime_t how_much, bigtime_t performance_time)
{
	TRACE("FireWireDVNode::LateNoticeReceived %lld late at %lld\n", how_much, performance_time);
}


void 
FireWireDVNode::EnableOutput(const media_source& source, bool enabled,
	int32* _deprecated_)
{
	CALLED();
	fOutputEnabledEncVideo = enabled;
}


void 
FireWireDVNode::AdditionalBufferRequested(const media_source& source,
	media_buffer_id prev_buffer, bigtime_t prev_time,
	const media_seek_tag* prev_tag)
{
	CALLED();
	// we don't support offline mode
	return;
}


/* FireWireDVNode */
void
FireWireDVNode::HandleTimeWarp(bigtime_t performance_time)
{
	TRACE("FireWireDVNode::HandleTimeWarp at %lld\n", performance_time);
}


void
FireWireDVNode::HandleSeek(bigtime_t performance_time)
{
	TRACE("FireWireDVNode::HandleSeek at %lld\n", performance_time);
}


void
FireWireDVNode::HandleStart(bigtime_t performance_time)
{
	CALLED();
	StartCapture();
}


void
FireWireDVNode::HandleStop(void)
{
	CALLED();
	StopCapture();
}	


status_t
FireWireDVNode::StartCapture()
{
	CALLED();

	if (fCaptureActive)
		return B_OK;
		
	RETURN_IF_ERROR(StopCaptureThreads());
	
	RETURN_IF_ERROR(StartCaptureThreads());
	
	fCaptureActive = true;

	RefreshParameterWeb();

	return B_OK;	
}


status_t
FireWireDVNode::StopCapture()
{
	CALLED();
	if (!fCaptureActive)
		return B_OK;

	StopCaptureThreads();
	
	fCaptureActive = false;
	return B_OK;
}


status_t
FireWireDVNode::StartCaptureThreads()
{
	CALLED();

	if (fCaptureThreadsActive)
		return B_OK;

	fTerminateThreads = false;

	fThreadIdCardReader = spawn_thread(_card_reader_thread_, "FireWire DV reader", 120, this);
	resume_thread(fThreadIdCardReader);
	
	fCaptureThreadsActive = true;
	return B_OK;
}


status_t
FireWireDVNode::StopCaptureThreads()
{
	CALLED();
	
	if (!fCaptureThreadsActive)
		return B_OK;
	
	fTerminateThreads = true;
	
	status_t dummy; // NULL as parameter does not work
	wait_for_thread(fThreadIdCardReader, &dummy);
	
	fCaptureThreadsActive = false;
	return B_OK;
}


int32
FireWireDVNode::_card_reader_thread_(void* arg)
{
	static_cast<FireWireDVNode *>(arg)->card_reader_thread();
	return 0;
}


void
FireWireDVNode::card_reader_thread()
{
	status_t err;
	size_t rbufsize;
	int rcount;

	fCard->GetBufInfo(&rbufsize, &rcount);
	delete fBufferGroupEncVideo;
	fBufferGroupEncVideo = new BBufferGroup(rbufsize, rcount);
	while (!fTerminateThreads) {
		void *data, *end;
		ssize_t sizeUsed = fCard->Read(&data);
		if (sizeUsed < 0) {
			TRACE("FireWireDVNode::%s: %s\n", __FUNCTION__,
				strerror(sizeUsed));
			continue;
		}

		end = (char*)data + sizeUsed;

		while (data < end) {
			BBuffer* buf = fBufferGroupEncVideo->RequestBuffer(rbufsize, 10000);
			if (!buf) {
				TRACE("OutVideo: request buffer timout\n");
				continue;
			}
			
			err = fCard->Extract(buf->Data(), &data, &sizeUsed);
			if (err) {
				buf->Recycle();
				printf("OutVideo Extract error %s\n", strerror(err));
				continue;
			}
	
			media_header* hdr = buf->Header();
			hdr->type = B_MEDIA_ENCODED_VIDEO;
			hdr->size_used = sizeUsed;
			hdr->time_source = TimeSource()->ID();	// set time source id
			//what should the start_time be?
			hdr->start_time = TimeSource()->PerformanceTimeFor(system_time());

			fLock.Lock();
			if (SendBuffer(buf, fOutputEncVideo.source,
					fOutputEncVideo.destination) != B_OK) {
				TRACE("OutVideo: sending buffer failed\n");
				buf->Recycle();
			} 
			fLock.Unlock();
		}
		
	}
}


void
FireWireDVNode::RefreshParameterWeb()
{
	TRACE("FireWireDVNode::RefreshParameterWeb enter\n");
	fWeb = CreateParameterWeb();
	SetParameterWeb(fWeb);
	TRACE("FireWireDVNode::RefreshParameterWeb finished\n");
}


void
FireWireDVNode::SetAboutInfo(BParameterGroup* about)
{
	//May need more useful infomation?
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "FireWireDV media_addon info:", B_GENERIC);
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Version " VERSION, B_GENERIC);
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Revision " REVISION, B_GENERIC);
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Build " BUILD, B_GENERIC);

	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "", B_GENERIC);
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Driver info:", B_GENERIC);
}


BParameterWeb *
FireWireDVNode::CreateParameterWeb()
{
	/* Set up the parameter web */
	BParameterWeb* web = new BParameterWeb();

	BString name;
	name << Name();
	
	BParameterGroup* main = web->MakeGroup(name.String());

	if (!fCaptureActive) {
		BParameterGroup* info = main->MakeGroup("Info");
		info->MakeNullParameter(0, B_MEDIA_NO_TYPE, info->Name(), B_GENERIC);
		BParameterGroup* about = main->MakeGroup("About");
		about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC);
		SetAboutInfo(about);
		info->MakeNullParameter(0, B_MEDIA_NO_TYPE, "Node is stopped", B_GENERIC);
		info->MakeNullParameter(0, B_MEDIA_NO_TYPE, "or tuning failed.", B_GENERIC);
		return web;
	}

	BParameterGroup* about = main->MakeGroup("About");
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC);
	SetAboutInfo(about);
	
	return web;
}


status_t 
FireWireDVNode::GetParameterValue(int32 id, bigtime_t* last_change, 
	void* value, size_t* size)
{
	TRACE("FireWireDVNode::GetParameterValue, id 0x%lx\n", id);
	//do we need Parameter for firewire dv?	
	return B_OK;
}


void
FireWireDVNode::SetParameterValue(int32 id, bigtime_t when, const void* value, 
	size_t size)
{
	TRACE("FireWireDVNode::SetParameterValue, id 0x%lx, size %ld, "
		"value 0x%lx\n", id, size, *(const int32*)value);
	//do we need parameter for firewire dv?
	TRACE("FireWireDVNode::SetParameterValue finished\n");
}