haiku.git

/*
 * Copyright (c) 2004-2007 Marcus Overhagen <marcus@overhagen.de>
 *
 * Permission is hereby granted, free of charge, to any person
 * obtaining a copy of this software and associated documentation
 * files (the "Software"), to deal in the Software without restriction, 
 * including without limitation the rights to use, copy, modify, 
 * merge, publish, distribute, sublicense, and/or sell copies of 
 * the Software, and to permit persons to whom the Software is 
 * furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be 
 * included in all copies or substantial portions of the Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES 
 * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND 
 * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT 
 * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, 
 * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 
 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR 
 * OTHER DEALINGS IN THE SOFTWARE.
 */


#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 <MediaRoster.h>
#include <Buffer.h>
#include <BufferGroup.h>
#include <ParameterWeb.h>
#include <TimeSource.h>
#include <String.h>
#include <Autolock.h>
#include <Debug.h>

#include <Directory.h>
#include <Entry.h>
#include <Path.h>

#include "MediaFormat.h"
#include "Packet.h"
#include "PacketQueue.h"
#include "pes.h"
#include "config.h"

//#define DUMP_VIDEO
//#define DUMP_AUDIO
//#define DUMP_RAW_AUDIO
//#define DUMP_MPEG_TS


#include "DVBMediaNode.h"

#define ENABLE_TRACE
//#define ENABLE_TRACE_TIMING

#undef TRACE

#ifdef ENABLE_TRACE
	#define TRACE printf
#else
	#define TRACE(a...)
#endif

#ifdef ENABLE_TRACE_TIMING
	#define TRACE_TIMING printf
#else
	#define TRACE_TIMING(a...)
#endif
		
#define RETURN_IF_ERROR(expr) { status_t e = (expr); if (e != B_OK) return e; }

#define ID_RAW_VIDEO	0
#define ID_RAW_AUDIO	1
#define ID_ENC_VIDEO	2
#define ID_ENC_AUDIO	3
#define ID_TS			4

// Timeouts for requesting buffers, if the system is busy,
// the output buffer queue is full, requesting a buffer will
// timeout, and we need to drop the current data
#define VIDEO_BUFFER_REQUEST_TIMEOUT	20000	
#define AUDIO_BUFFER_REQUEST_TIMEOUT	10000

// DVB data arrives early and with a timestamp, this is used to validate
// that the timestamp is correct and we don't get stuck
#define VIDEO_MAX_EARLY					3000000
	// up to 3 seconds too early
#define VIDEO_MAX_LATE					50000
	// no more than 50 ms too late
#define AUDIO_MAX_EARLY					3000000
	// up to 3 seconds too early
#define AUDIO_MAX_LATE					50000
	// no more than 50 ms too late

#define PROCESSING_LATENCY				1500
	// assumed latency for sending the buffer

#define STOP_CAPTURE_WHILE_TUNING		1

#define M_REFRESH_PARAMETER_WEB 		(BTimedEventQueue::B_USER_EVENT + 1)


DVBMediaNode::DVBMediaNode(
	BMediaAddOn *addon, const char *name,
	int32 internal_id, DVBCard *card)
 :	BMediaNode(name)
 ,	BBufferProducer(B_MEDIA_RAW_VIDEO)
 ,	BControllable()
 ,	BMediaEventLooper()
 ,	fStopDisabled(false)
 ,	fOutputEnabledRawVideo(false)
 ,	fOutputEnabledRawAudio(false)
 ,	fOutputEnabledEncVideo(false)
 ,	fOutputEnabledEncAudio(false)
 ,	fOutputEnabledTS(false)
 ,	fCardDataQueue(new PacketQueue(6))
 ,	fRawVideoQueue(new PacketQueue(56))
 ,	fRawAudioQueue(new PacketQueue(56))
 ,	fEncVideoQueue(new PacketQueue(56))
 ,	fEncAudioQueue(new PacketQueue(56))
 ,	fMpegTsQueue(new PacketQueue(16))
 ,	fCard(card)
 ,	fCaptureThreadsActive(false)
 ,	fThreadIdCardReader(-1)
 ,	fThreadIdMpegDemux(-1)
 ,	fThreadIdRawAudio(-1)
 ,	fThreadIdRawVideo(-1)
 ,	fThreadIdEncAudio(-1)
 ,	fThreadIdEncVideo(-1)
 ,	fThreadIdMpegTS(-1)
 ,	fTerminateThreads(false)
 ,	fDemux(new TransportStreamDemux(fRawVideoQueue, fRawAudioQueue,
 		fEncVideoQueue, fEncAudioQueue, fMpegTsQueue))
 ,	fBufferGroupRawVideo(0)
 ,	fBufferGroupRawAudio(0)
 ,	fInterfaceType(DVB_TYPE_UNKNOWN)
 ,	fAudioPid(-1)
 ,	fVideoPid(-1)
 ,	fPcrPid(-1)
 ,	fTuningSuccess(false)
 ,	fCaptureActive(false)
 ,	fVideoDelaySem(create_sem(0, "video delay sem"))
 ,	fAudioDelaySem(create_sem(0, "audio delay sem"))
 ,	fSelectedState(-1)
 ,	fSelectedRegion(-1)
 ,	fSelectedChannel(-1)
 ,	fSelectedAudio(-1)
 ,	fStateList(new StringList)
 ,	fRegionList(new StringList)
 ,	fChannelList(new StringList)
 ,	fAudioList(new StringList)
 ,	fVideoDecoder(0)
 ,	fAudioDecoder(0)
 ,	fCurrentVideoPacket(0)
 ,	fCurrentAudioPacket(0)
{
	TRACE("DVBMediaNode::DVBMediaNode\n");

	AddNodeKind(B_PHYSICAL_INPUT);

	fInternalID = internal_id;
	fAddOn = addon;
	
	fInitStatus = B_OK;
	
	InitDefaultFormats();

	// in the beginning, the required formats are the same as the defaults
	fRequiredFormatRawVideo = fDefaultFormatRawVideo;
	fRequiredFormatRawAudio = fDefaultFormatRawAudio;
	fRequiredFormatEncVideo = fDefaultFormatEncVideo;
	fRequiredFormatEncAudio = fDefaultFormatEncAudio;
	fRequiredFormatTS = fDefaultFormatTS;

	TRACE("current RunMode = %d\n", RunMode());

#ifdef DUMP_VIDEO
	fVideoFile = open("/boot/home/dvb-video.mpg", O_RDWR | O_CREAT | O_TRUNC);
#endif
#ifdef DUMP_AUDIO
	fAudioFile = open("/boot/home/dvb-audio.mpg", O_RDWR | O_CREAT | O_TRUNC);
#endif
#ifdef DUMP_RAW_AUDIO
	fRawAudioFile = open("/boot/home/dvb-audio.raw",
		O_RDWR | O_CREAT | O_TRUNC);
#endif
#ifdef DUMP_MPEG_TS
	fMpegTsFile = open("/boot/home/dvb-mpeg.ts", O_RDWR | O_CREAT | O_TRUNC);
#endif
}


DVBMediaNode::~DVBMediaNode()
{
	TRACE("DVBMediaNode::~DVBMediaNode\n");
	
	StopCapture();
	
	delete_sem(fVideoDelaySem);
	delete_sem(fAudioDelaySem);

	// fCard is owned by the media addon
	delete fCardDataQueue;
	delete fRawVideoQueue;
	delete fRawAudioQueue;
	delete fEncVideoQueue;
	delete fEncAudioQueue;
	delete fMpegTsQueue;

	delete fDemux;

	delete fBufferGroupRawVideo;
	delete fBufferGroupRawAudio;

	delete fStateList;
	delete fRegionList;
	delete fChannelList;
	delete fAudioList;
	
#ifdef DUMP_VIDEO
	close(fVideoFile);
#endif
#ifdef DUMP_AUDIO
	close(fAudioFile);
#endif
#ifdef DUMP_RAW_AUDIO
	close(fRawAudioFile);
#endif
#ifdef DUMP_MPEG_TS
	close(fMpegTsFile);
#endif

}


/* BMediaNode */


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


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


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


void
DVBMediaNode::SetTimeSource(BTimeSource *time_source)
{
	TRACE("DVBMediaNode::SetTimeSource\n");
	//printf("current RunMode = %d\n", RunMode());
	//printf("_m_recordDelay = %lld\n", _m_recordDelay);
}


void
DVBMediaNode::SetRunMode(run_mode mode)
{
	TRACE("DVBMediaNode::SetRunMode: %d\n", mode);
	TRACE("current RunMode = %d\n", RunMode());
	//printf("_m_recordDelay = %lld\n", _m_recordDelay);
}


/* BMediaEventLooper */


void 
DVBMediaNode::NodeRegistered()
{
	TRACE("DVBMediaNode::NodeRegistered\n");

	fOutputRawVideo.node = Node();
	fOutputRawVideo.source.port = ControlPort();
	fOutputRawVideo.source.id = ID_RAW_VIDEO;
	fOutputRawVideo.destination = media_destination::null;
	fOutputRawVideo.format = fDefaultFormatRawVideo;
	strcpy(fOutputRawVideo.name, SourceDefaultName(fOutputRawVideo.source));

	fOutputRawAudio.node = Node();
	fOutputRawAudio.source.port = ControlPort();
	fOutputRawAudio.source.id = ID_RAW_AUDIO;
	fOutputRawAudio.destination = media_destination::null;
	fOutputRawAudio.format = fDefaultFormatRawAudio;
	strcpy(fOutputRawAudio.name, SourceDefaultName(fOutputRawAudio.source));

	fOutputEncVideo.node = Node();
	fOutputEncVideo.source.port = ControlPort();
	fOutputEncVideo.source.id = ID_ENC_VIDEO;
	fOutputEncVideo.destination = media_destination::null;
	fOutputEncVideo.format = fDefaultFormatEncVideo;
	strcpy(fOutputEncVideo.name, SourceDefaultName(fOutputEncVideo.source));

	fOutputEncAudio.node = Node();
	fOutputEncAudio.source.port = ControlPort();
	fOutputEncAudio.source.id = ID_ENC_AUDIO;
	fOutputEncAudio.destination = media_destination::null;
	fOutputEncAudio.format = fDefaultFormatEncAudio;
	strcpy(fOutputEncAudio.name, SourceDefaultName(fOutputEncAudio.source));

	fOutputTS.node = Node();
	fOutputTS.source.port = ControlPort();
	fOutputTS.source.id = ID_TS;
	fOutputTS.destination = media_destination::null;
	fOutputTS.format = fDefaultFormatTS;
	strcpy(fOutputTS.name, SourceDefaultName(fOutputTS.source));

	fCard->GetCardType(&fInterfaceType);

	// set control thread priority	
	SetPriority(110);

	LoadSettings();
	
	RefreshParameterWeb();

	// this nodes operates in recording mode, so set it (will be done
	// asynchronously)
	BMediaRoster::Roster()->SetRunModeNode(Node(), B_RECORDING);
		// as it's a notification hook, calling this doesn't work:
		// SetRunMode(B_RECORDING);

	//printf("RunMode = %d\n", RunMode());
	//printf("_m_recordDelay = %lld\n", _m_recordDelay);

	Run();
}


void
DVBMediaNode::Stop(bigtime_t performance_time, bool immediate)
{
	if (fStopDisabled)
		return;
	else
		BMediaEventLooper::Stop(performance_time, immediate);
}


void 
DVBMediaNode::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("DVBMediaNode::HandleEvent: Unhandled event -- %lx\n",
				event->type);
			break;
	}
}


/* BBufferProducer */


status_t 
DVBMediaNode::FormatChangeRequested(const media_source &source,
		const media_destination &destination, media_format *io_format,
		int32 *_deprecated_)
{
	TRACE("DVBMediaNode::FormatChangeRequested denied: %s\n",
		SourceDefaultName(source));
	return B_ERROR;	
}


status_t 
DVBMediaNode::GetNextOutput(int32 *cookie, media_output *out_output)
{
	switch (*cookie) {
		case 0: *out_output = fOutputRawVideo;	break;
		case 1: *out_output = fOutputRawAudio;	break;
		case 2: *out_output = fOutputEncVideo;	break;
		case 3: *out_output = fOutputEncAudio;	break;
		case 4: *out_output = fOutputTS;		break;
		default:								return B_BAD_INDEX;
	}

	(*cookie) += 1;
	return B_OK;
}


status_t 
DVBMediaNode::DisposeOutputCookie(int32 cookie)
{
	return B_OK;
}


status_t 
DVBMediaNode::SetBufferGroup(const media_source &source, BBufferGroup *group)
{
	TRACE("DVBMediaNode::SetBufferGroup denied: %s\n",
		SourceDefaultName(source));
	return B_ERROR;
}


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


status_t 
DVBMediaNode::GetLatency(bigtime_t *out_latency)
{
	if (B_OK != BBufferProducer::GetLatency(out_latency))
		*out_latency = 50000;
		
	printf("DVBMediaNode::GetLatency: %lld\n", *out_latency);
	*out_latency += PROCESSING_LATENCY;
	return B_OK;
}


status_t 
DVBMediaNode::FormatSuggestionRequested(
		media_type type, int32 quality, media_format *format)
{
	TRACE("DVBMediaNode::FormatSuggestionRequested\n");
	
	switch (type) {
		case B_MEDIA_RAW_VIDEO:
			*format = fDefaultFormatRawVideo;
			break;

		case B_MEDIA_RAW_AUDIO:
			*format = fDefaultFormatRawAudio;
			break;

		case B_MEDIA_ENCODED_VIDEO:
			*format = fDefaultFormatEncVideo;
			break;

		case B_MEDIA_ENCODED_AUDIO:
			*format = fDefaultFormatEncAudio;
			break;

		case B_MEDIA_MULTISTREAM:
			*format = fDefaultFormatTS;
			break;

		default:
			TRACE("Bad type!\n");
			return B_MEDIA_BAD_FORMAT;
	}

	#ifdef DEBUG
		TRACE("suggested format: ");
		PrintFormat(*format);
	#endif

	return B_OK;
}


status_t 
DVBMediaNode::FormatProposal(const media_source &source, media_format *format)
{
	TRACE("DVBMediaNode::FormatProposal: %s\n", SourceDefaultName(source));
	
	/* 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())
		goto _bad_source;

	#ifdef DEBUG
		TRACE("proposed format: ");
		PrintFormat(*format);
		TRACE("required format: ");
		switch (source.id) {
			case ID_RAW_VIDEO:
				PrintFormat(fRequiredFormatRawVideo);
				break;

			case ID_RAW_AUDIO:
				PrintFormat(fRequiredFormatRawAudio);
				break;

			case ID_ENC_VIDEO:
				PrintFormat(fRequiredFormatEncVideo);
				break;

			case ID_ENC_AUDIO:
				PrintFormat(fRequiredFormatEncAudio);
				break;

			case ID_TS:
				PrintFormat(fRequiredFormatTS);
				break;
		}
	#endif

	switch (source.id) {
		case ID_RAW_VIDEO:
			// check if destination still available
			if (fOutputRawVideo.destination != media_destination::null)
				goto _bad_source;
			// set requirements and check if compatible
			color_space c;
			c = format->u.raw_video.display.format;
			format->SpecializeTo(&fRequiredFormatRawVideo);
			format->u.raw_video.display.format = c;
//			if (!format->Matches(&fRequiredFormatRawVideo))
//				goto _bad_format_1;
			if (!VerifyFormatRawVideo(format->u.raw_video))
				goto _bad_format_2;
			break;

		case ID_RAW_AUDIO:
			// check if destination still available
			if (fOutputRawAudio.destination != media_destination::null)
				goto _bad_source;
			// set requirements and check if compatible
			format->SpecializeTo(&fRequiredFormatRawAudio);
			if (!format->Matches(&fRequiredFormatRawAudio))
				goto _bad_format_1;
			if (!VerifyFormatRawAudio(format->u.raw_audio))
				goto _bad_format_2;
			break;

		case ID_ENC_VIDEO:
			// check if destination still available
			if (fOutputEncVideo.destination != media_destination::null)
				goto _bad_source;
			// set requirements and check if compatible
			format->SpecializeTo(&fRequiredFormatEncVideo);
			if (!format->Matches(&fRequiredFormatEncVideo))
				goto _bad_format_1;
			break;

		case ID_ENC_AUDIO:
			// check if destination still available
			if (fOutputEncAudio.destination != media_destination::null)
				goto _bad_source;
			// set requirements and check if compatible
			format->SpecializeTo(&fRequiredFormatEncAudio);
			if (!format->Matches(&fRequiredFormatEncAudio))
				goto _bad_format_1;
			break;

		case ID_TS:
			// check if destination still available
			if (fOutputTS.destination != media_destination::null)
				goto _bad_source;
			// set requirements and check if compatible
			format->SpecializeTo(&fRequiredFormatTS);
			if (!format->Matches(&fRequiredFormatTS))
				goto _bad_format_1;
			break;

		default:
			goto _bad_source;
	}

	#ifdef DEBUG
		TRACE("final format: ");
		PrintFormat(*format);
	#endif
	
	return B_OK;

_bad_source:
	TRACE("Error: bad source!\n");
	return B_MEDIA_BAD_SOURCE;

_bad_format_1:
	TRACE("Error, bad format (1): ");
	goto _bad_format;

_bad_format_2:
	TRACE("Error, bad format (2): ");
	goto _bad_format;

_bad_format:
	#ifdef DEBUG
		PrintFormat(*format);
	#endif
	return B_MEDIA_BAD_FORMAT;
}


status_t 
DVBMediaNode::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!
	 */

	TRACE("DVBMediaNode::PrepareToConnect: %s\n", SourceDefaultName(source));

	#ifdef DEBUG
		TRACE("connecting format: ");
		PrintFormat(*format);
		TRACE("required format: ");
		switch (source.id) {
			case ID_RAW_VIDEO:
				PrintFormat(fRequiredFormatRawVideo);
				break;

			case ID_RAW_AUDIO:
				PrintFormat(fRequiredFormatRawAudio);
				break;

			case ID_ENC_VIDEO:
				PrintFormat(fRequiredFormatEncVideo);
				break;

			case ID_ENC_AUDIO:
				PrintFormat(fRequiredFormatEncAudio);
				break;

			case ID_TS:
				PrintFormat(fRequiredFormatTS);
				break;
		}
	#endif
	
	// is the source valid?
	if (source.port != ControlPort())
		goto _bad_source;

	// 1) check if the output is still available,
	// 2) specialize and verify the format
	switch (source.id) {
		case ID_RAW_VIDEO:
			if (fOutputRawVideo.destination != media_destination::null)
				goto _already_connected;
			SpecializeFormatRawVideo(&format->u.raw_video);
//			if (!format->Matches(&fRequiredFormatRawVideo))
//				goto _bad_format;
			if (!VerifyFormatRawVideo(format->u.raw_video))
				goto _bad_format;
			break;

		case ID_RAW_AUDIO:
			if (fOutputRawAudio.destination != media_destination::null)
				goto _already_connected;
			SpecializeFormatRawAudio(&format->u.raw_audio);
			if (!format->Matches(&fRequiredFormatRawAudio))
				goto _bad_format;
			if (!VerifyFormatRawAudio(format->u.raw_audio))
				goto _bad_format;
			break;

		case ID_ENC_VIDEO:
			if (fOutputEncVideo.destination != media_destination::null)
				goto _already_connected;
			SpecializeFormatEncVideo(&format->u.encoded_video);
			if (!format->Matches(&fRequiredFormatEncVideo))
				goto _bad_format;
			break;

		case ID_ENC_AUDIO:
			if (fOutputEncAudio.destination != media_destination::null)
				goto _already_connected;
			SpecializeFormatEncAudio(&format->u.encoded_audio);
			if (!format->Matches(&fRequiredFormatRawVideo))
				goto _bad_format;
			break;

		case ID_TS:
			if (fOutputTS.destination != media_destination::null)
				goto _already_connected;
			SpecializeFormatTS(&format->u.multistream);
			if (!format->Matches(&fRequiredFormatTS))
				goto _bad_format;
			break;

		default:
			goto _bad_source;
	}

	#ifdef DEBUG
		TRACE("final format: ");
		PrintFormat(*format);
	#endif

	// reserve the connection by setting destination
	// set the output's format to the new format
	SetOutput(source, destination, *format);

	// set source and suggest a name
	*out_source = source;
	strcpy(out_name, SourceDefaultName(source));
	
	return B_OK;

_bad_source:
	TRACE("Error: bad source!\n");
	return B_MEDIA_BAD_SOURCE;

_bad_format:
	#ifdef DEBUG
		TRACE("Error, bad format: ");
		PrintFormat(*format);
	#endif
	return B_MEDIA_BAD_FORMAT;

_already_connected:
	TRACE("Error: already connected!\n");
	return B_MEDIA_ALREADY_CONNECTED;
}


void 
DVBMediaNode::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
	 */

	TRACE("DVBMediaNode::Connect: %s\n", SourceDefaultName(source));

	if (error != B_OK) {
		TRACE("Error during connecting\n");
		// if an error occured, unreserve the connection
		ResetOutput(source);
		return;
	}

	#ifdef DEBUG
		TRACE("connected format: ");
		PrintFormat(format);
	#endif

	// 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.
	SetOutput(source, destination, format);

	// Set output as connected
	switch (source.id) {
		case ID_RAW_VIDEO:
			fOutputEnabledRawVideo = true;
			break;

		case ID_RAW_AUDIO:
			fOutputEnabledRawAudio = true;
			break;

		case ID_ENC_VIDEO:
			fOutputEnabledEncVideo = true;
			break;

		case ID_ENC_AUDIO:
			fOutputEnabledEncAudio = true;
			break;

		case ID_TS:
			fOutputEnabledTS = true;
			break;

		default:
			break;
	}

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

	#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 
DVBMediaNode::Disconnect(const media_source &source,
		const media_destination &destination)
{
	TRACE("DVBMediaNode::Disconnect: %s\n", SourceDefaultName(source));
	
	// unreserve the connection
	ResetOutput(source);

	// Set output to disconnected
	switch (source.id) {
		case ID_RAW_VIDEO:
			fOutputEnabledRawVideo = false;
			break;

		case ID_RAW_AUDIO:
			fOutputEnabledRawAudio = false;
			break;

		case ID_ENC_VIDEO:
			fOutputEnabledEncVideo = false;
			break;

		case ID_ENC_AUDIO:
			fOutputEnabledEncAudio = false;
			break;

		case ID_TS:
			fOutputEnabledTS = false;
			break;

		default:
			break;
	}
}


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


void 
DVBMediaNode::EnableOutput(const media_source &source, bool enabled,
		int32 *_deprecated_)
{
	TRACE("DVBMediaNode::EnableOutput id = %ld, enabled = %d\n", source.id,
		enabled);
	/* not used yet
	switch (source.id) {
		case ID_RAW_VIDEO:	fOutputEnabledRawVideo = enabled; break;
		case ID_RAW_AUDIO:	fOutputEnabledRawAudio = enabled; break;
		case ID_ENC_VIDEO:	fOutputEnabledEncVideo = enabled; break;
		case ID_ENC_AUDIO:	fOutputEnabledEncAudio = enabled; break;
		case ID_TS:			fOutputEnabledTS = enabled; break;
		default:			break;
	}
	*/
}


status_t 
DVBMediaNode::SetPlayRate(int32 numer, int32 denom)
{

	return B_ERROR;
}


void 
DVBMediaNode::AdditionalBufferRequested(const media_source &source,
		media_buffer_id prev_buffer, bigtime_t prev_time,
		const media_seek_tag *prev_tag)
{
	TRACE("DVBMediaNode::AdditionalBufferRequested: %s\n",
		SourceDefaultName(source));
}


void 
DVBMediaNode::LatencyChanged(const media_source &source,
		const media_destination &destination, bigtime_t new_latency,
		uint32 flags)
{
	TRACE("DVBMediaNode::LatencyChanged to %lld\n", new_latency);
}

/* DVBMediaNode */


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


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


void
DVBMediaNode::InitDefaultFormats()
{
	// 720 * 576
	fDefaultFormatRawVideo.type = B_MEDIA_RAW_VIDEO;
	fDefaultFormatRawVideo.u.raw_video.display.format = B_RGB32;
	fDefaultFormatRawVideo.u.raw_video.display.line_width = 720;
	fDefaultFormatRawVideo.u.raw_video.display.line_count = 576;
	fDefaultFormatRawVideo.u.raw_video.last_active
		= fDefaultFormatRawVideo.u.raw_video.display.line_count - 1;
	fDefaultFormatRawVideo.u.raw_video.display.bytes_per_row
		= fDefaultFormatRawVideo.u.raw_video.display.line_width * 4;
	fDefaultFormatRawVideo.u.raw_video.field_rate = 0;
		// wildcard
	fDefaultFormatRawVideo.u.raw_video.interlace = 1;
	fDefaultFormatRawVideo.u.raw_video.first_active = 0;
	fDefaultFormatRawVideo.u.raw_video.orientation = B_VIDEO_TOP_LEFT_RIGHT;
	fDefaultFormatRawVideo.u.raw_video.pixel_width_aspect = 1;
	fDefaultFormatRawVideo.u.raw_video.pixel_height_aspect = 1;
	fDefaultFormatRawVideo.u.raw_video.display.pixel_offset = 0;
	fDefaultFormatRawVideo.u.raw_video.display.line_offset = 0;
	fDefaultFormatRawVideo.u.raw_video.display.flags = 0;

	fDefaultFormatRawAudio.type = B_MEDIA_RAW_AUDIO;
	fDefaultFormatRawAudio.u.raw_audio.frame_rate = 48000;
	fDefaultFormatRawAudio.u.raw_audio.channel_count = 2;
//  XXX broken in Haiku...
//	fDefaultFormatRawAudio.u.raw_audio.format = 0; // wildcard
	fDefaultFormatRawAudio.u.raw_audio.format
		= media_raw_audio_format::B_AUDIO_SHORT;
//  when set to 0, haiku mixer has problems when diung a format change
//  set to short and debug the buffer_size problem first!
	fDefaultFormatRawAudio.u.raw_audio.byte_order = B_MEDIA_HOST_ENDIAN;
//	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 0; // wildcard
//	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 0x1200;
//	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 0x1000;
	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 32768;
//	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 333 * 8;
//	fDefaultFormatRawAudio.u.raw_audio.buffer_size = 512;
//  when set to anything different from 32768 haiku mixer has problems

	fDefaultFormatEncVideo.type = B_MEDIA_ENCODED_VIDEO;
	fDefaultFormatEncAudio.type = B_MEDIA_ENCODED_AUDIO;
	fDefaultFormatTS.type = B_MEDIA_MULTISTREAM;
}


bool
DVBMediaNode::VerifyFormatRawVideo(const media_raw_video_format &format)
{
	if (format.display.format != 0 &&
		format.display.format != B_RGB32 &&
		format.display.format != B_YCbCr422)
		return false;
		
	return true;
}


bool
DVBMediaNode::VerifyFormatRawAudio(const media_multi_audio_format &format)
{
	if (format.format != 0 && 
		format.format != media_raw_audio_format::B_AUDIO_FLOAT &&
		format.format != media_raw_audio_format::B_AUDIO_SHORT)
		return false;

	return true;
}


void
DVBMediaNode::SpecializeFormatRawVideo(media_raw_video_format *format)
{
	// Here we need to specialize *all* remaining wildcard
	// fields that the consumer didn't set
	if (format->field_rate == 0.0)
		format->field_rate = 25;
		
	// XXX a lot is missing here...
}


void
DVBMediaNode::SpecializeFormatRawAudio(media_multi_audio_format *format)
{
	// Here we need to specialize *all* remaining wildcard
	// fields that the consumer didn't set
	if (format->format == 0)
		format->format = media_raw_audio_format::B_AUDIO_SHORT;

	if (format->buffer_size == 0)
		format->buffer_size = 333 * 8;

	// XXX a lot is missing here...
}


void
DVBMediaNode::SpecializeFormatEncVideo(media_encoded_video_format *format)
{
	// Here we need to specialize *all* remaining wildcard
	// fields that the consumer didn't set
}


void
DVBMediaNode::SpecializeFormatEncAudio(media_encoded_audio_format *format)
{
	// Here we need to specialize *all* remaining wildcard
	// fields that the consumer didn't set
}


void
DVBMediaNode::SpecializeFormatTS(media_multistream_format *format)
{
	// Here we need to specialize *all* remaining wildcard
	// fields that the consumer didn't set
}


status_t
DVBMediaNode::SetOutput(const media_source &source, 
	const media_destination &destination, const media_format &format)
{
	switch (source.id) {
		case ID_RAW_VIDEO:
			fOutputRawVideo.destination = destination;
			fOutputRawVideo.format = format;
			break;

		case ID_RAW_AUDIO:
			fOutputRawAudio.destination = destination;
			fOutputRawAudio.format = format;
			break;

		case ID_ENC_VIDEO:
			fOutputEncVideo.destination = destination;
			fOutputEncVideo.format = format;
			break;

		case ID_ENC_AUDIO:
			fOutputEncAudio.destination = destination;
			fOutputEncAudio.format = format;
			break;

		case ID_TS:
			fOutputTS.destination = destination;
			fOutputTS.format = format;
			break;

		default:
			return B_MEDIA_BAD_SOURCE;
	}
	return B_OK;
}


status_t
DVBMediaNode::ResetOutput(const media_source &source)
{
	switch (source.id) {
		case ID_RAW_VIDEO:
			fOutputRawVideo.destination = media_destination::null;
			fOutputRawVideo.format = fDefaultFormatRawVideo;
			break;

		case ID_RAW_AUDIO:
			fOutputRawAudio.destination = media_destination::null;
			fOutputRawAudio.format = fDefaultFormatRawAudio;
			break;
				
		case ID_ENC_VIDEO:
			fOutputEncVideo.destination = media_destination::null;
			fOutputEncVideo.format = fDefaultFormatEncVideo;
			break;
				
		case ID_ENC_AUDIO:
			fOutputEncAudio.destination = media_destination::null;
			fOutputEncAudio.format = fDefaultFormatEncAudio;
			break;
				
		case ID_TS:
			fOutputTS.destination = media_destination::null;
			fOutputTS.format = fDefaultFormatTS;
			break;
				
		default:
			return B_MEDIA_BAD_SOURCE;
	}
	return B_OK;
}


const char *
DVBMediaNode::SourceDefaultName(const media_source &source)
{
	switch (source.id) {
		case ID_RAW_VIDEO:
			return "raw video";

		case ID_RAW_AUDIO:
			return "raw audio";

		case ID_ENC_VIDEO:
			return "encoded video";

		case ID_ENC_AUDIO:
			return "encoded audio";

		case ID_TS:
			return "MPEG2 TS";

		default:
			return NULL;
	}
}


void
DVBMediaNode::HandleStart(bigtime_t performance_time)
{
	TRACE("DVBMediaNode::HandleStart\n");
	StartCapture();
}


void
DVBMediaNode::HandleStop(void)
{
	TRACE("DVBMediaNode::HandleStop\n");
	StopCapture();
}	


status_t
DVBMediaNode::Tune()
{
	TRACE("DVBMediaNode::Tune enter\n");

	TRACE("state %d, region %d, channel %d, audio %d\n",
		fSelectedState, fSelectedRegion, fSelectedChannel, fSelectedAudio);

	status_t err;
	bool needs_tuning = false;

	if (fSelectedChannel < 0 || fSelectedAudio < 0) {
		printf("DVBMediaNode::Tune: invalid tuning info\n");
		StopCapture();
		err = B_ERROR;
		goto end;
//		return B_ERROR;
	}
	
	const char *desc;
	
	dvb_tuning_parameters_t new_params;
	int new_video_pid;
	int new_audio_pid;
	int new_pcr_pid;

	desc = fChannelList->ItemAt(fSelectedChannel);
	err = ExtractTuningParams(desc, fSelectedAudio, &new_params,
		&new_video_pid, &new_audio_pid, &new_pcr_pid);

	if (err != B_OK) {
		printf("DVBMediaNode::Tune: getting tuning info failed\n");
		StopCapture();
		err = B_ERROR;
		goto end;
//		return B_ERROR;
	}
/*	
	if (fTuningParam.frequency == new_params.frequency) {
		printf("DVBMediaNode::Tune: frequency not changed\n");
		fVideoPid = new_video_pid;
		fAudioPid = new_audio_pid;
		fPcrPid = new_pcr_pid;
		fDemux->SetPIDs(fVideoPid, fAudioPid, fPcrPid);
		return B_OK;
	}
*/	
	switch (fInterfaceType) {
		case DVB_TYPE_DVB_T:
			needs_tuning = (fTuningParam.u.dvb_t.frequency
					!= new_params.u.dvb_t.frequency) || !fTuningSuccess;
			needs_tuning = true;
			break;

		case DVB_TYPE_DVB_S:
			printf("needs_tuning = %d, forcing tuning for DVB-S\n",
				needs_tuning);
			needs_tuning = true;
			break;

		default:
			needs_tuning = true;
			break;
	}
		
	fTuningParam = new_params;
	fVideoPid = new_video_pid;
	fAudioPid = new_audio_pid;
	fPcrPid = new_pcr_pid;
	
	if (needs_tuning) {
printf("about to stop capture 1\n");
#if STOP_CAPTURE_WHILE_TUNING
printf("about to stop capture 2\n");
		err = StopCapture();
		if (err) {
			printf("Tune: StopCapture failed\n");
			goto end;
		}
#endif
	} else {
#if STOP_CAPTURE_WHILE_TUNING
		StopCaptureThreads();
#endif
	}
	
	if (needs_tuning) {
		err = fCard->SetTuningParameter(fTuningParam);
		fTuningSuccess = err == B_OK;
	}

	fDemux->SetPIDs(fVideoPid, fAudioPid, fPcrPid);
	
	if (needs_tuning) {
		if (fTuningSuccess) {
			fCard->GetTuningParameter(&fTuningParam);
			err = StartCapture();
		}
	} else {
#if STOP_CAPTURE_WHILE_TUNING
		StartCaptureThreads();
#endif
	}
	
end:
	EventQueue()->AddEvent(media_timed_event(0, M_REFRESH_PARAMETER_WEB));
//	RefreshParameterWeb();

	TRACE("DVBMediaNode::Tune finished\n");
	return err;
}


status_t
DVBMediaNode::StartCapture()
{
	TRACE("DVBMediaNode::StartCapture\n");

	if (fCaptureActive)
		return B_OK;
		
	RETURN_IF_ERROR(StopCaptureThreads());
	
	if (!fTuningSuccess) {
		RETURN_IF_ERROR(Tune());
	}
	
	RETURN_IF_ERROR(StartCaptureThreads());
	
	fCard->CaptureStart();

	fCaptureActive = true;

	RefreshParameterWeb();

	return B_OK;	
}


status_t
DVBMediaNode::StopCapture()
{
	TRACE("DVBMediaNode::StopCapture\n");
	if (!fCaptureActive)
		return B_OK;

	StopCaptureThreads();
	
	fCard->CaptureStop();

	fCaptureActive = false;
	return B_OK;
}


status_t
DVBMediaNode::StartCaptureThreads()
{
	TRACE("DVBMediaNode::StartCaptureThreads\n");

	if (fCaptureThreadsActive)
		return B_OK;

	fTerminateThreads = false;

	fThreadIdCardReader = spawn_thread(_card_reader_thread_, "DVB card reader",
		120, this);
	fThreadIdMpegDemux = spawn_thread(_mpeg_demux_thread_, "DVB MPEG demux",
		110, this);
	fThreadIdEncAudio = spawn_thread(_enc_audio_thread_, "DVB audio streaming",
		110, this);
	fThreadIdEncVideo = spawn_thread(_enc_video_thread_, "DVB video streaming",
		110, this);
	fThreadIdMpegTS = spawn_thread(_mpeg_ts_thread_, "DVB MPEG TS streaming",
		110, this);
	fThreadIdRawAudio = spawn_thread(_raw_audio_thread_, "DVB audio decode",
		100, this);
	fThreadIdRawVideo = spawn_thread(_raw_video_thread_, "DVB video decode",
		85, this);
	resume_thread(fThreadIdCardReader);
	resume_thread(fThreadIdMpegDemux);
	resume_thread(fThreadIdEncAudio);
	resume_thread(fThreadIdEncVideo);
	resume_thread(fThreadIdMpegTS);
	resume_thread(fThreadIdRawAudio);
	resume_thread(fThreadIdRawVideo);
	
	fCaptureThreadsActive = true;
	return B_OK;
}


status_t
DVBMediaNode::StopCaptureThreads()
{
	TRACE("DVBMediaNode::StopCaptureThreads\n");
	
	if (!fCaptureThreadsActive)
		return B_OK;
	
	fTerminateThreads = true;

	fCardDataQueue->Terminate();
	fEncVideoQueue->Terminate();
	fEncAudioQueue->Terminate();
	fMpegTsQueue->Terminate();
	fRawVideoQueue->Terminate();
	fRawAudioQueue->Terminate();
	
	status_t dummy; // NULL as parameter does not work
	wait_for_thread(fThreadIdCardReader, &dummy);
	wait_for_thread(fThreadIdMpegDemux, &dummy);
	wait_for_thread(fThreadIdEncAudio, &dummy);
	wait_for_thread(fThreadIdEncVideo, &dummy);
	wait_for_thread(fThreadIdMpegTS, &dummy);
	wait_for_thread(fThreadIdRawAudio, &dummy);
	wait_for_thread(fThreadIdRawVideo, &dummy);

	fCardDataQueue->Restart();
	fEncVideoQueue->Restart();
	fEncAudioQueue->Restart();
	fMpegTsQueue->Restart();
	fRawVideoQueue->Restart();
	fRawAudioQueue->Restart();
	
	fCaptureThreadsActive = false;
	return B_OK;
}


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


int32
DVBMediaNode::_mpeg_demux_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->mpeg_demux_thread();
	return 0;
}


int32
DVBMediaNode::_raw_audio_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->raw_audio_thread();
	return 0;
}


int32
DVBMediaNode::_raw_video_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->raw_video_thread();
	return 0;
}


int32
DVBMediaNode::_enc_audio_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->enc_audio_thread();
	return 0;
}


int32
DVBMediaNode::_enc_video_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->enc_video_thread();
	return 0;
}


int32
DVBMediaNode::_mpeg_ts_thread_(void *arg)
{
	static_cast<DVBMediaNode *>(arg)->mpeg_ts_thread();
	return 0;
}


void
DVBMediaNode::card_reader_thread()
{
	while (!fTerminateThreads) {
		void *data;
		size_t size;
		status_t err;
		bigtime_t end_time;
		err = fCard->Capture(&data, &size, &end_time);
		if (err != B_OK) {
			TRACE("fCard->Capture failed, error %lx (%s)\n", err,
				strerror(err));
			continue;
		}

//		TRACE("captured %ld bytes\n", size);

		Packet *packet = new Packet(data, size, end_time);
		
		err = fCardDataQueue->Insert(packet);
		if (err != B_OK) {
			delete packet;
			TRACE("fCardDataQueue->Insert failed, error %lx\n", err);
			continue;
		}
	}
}


void
DVBMediaNode::mpeg_demux_thread()
{
	while (!fTerminateThreads) {
		status_t err;
		Packet *packet;
		err = fCardDataQueue->Remove(&packet);
		if (err != B_OK) {
			TRACE("fCardDataQueue->Remove failed, error %lx\n", err);
			continue;
		}
		
		// packet->TimeStamp() is the end time of the capture
		fDemux->AddData(packet);
	}
}


void
DVBMediaNode::mpeg_ts_thread()
{
	while (!fTerminateThreads) {
		status_t err;
		Packet *packet;
		err = fMpegTsQueue->Remove(&packet);
		if (err != B_OK) {
			TRACE("fMpegTsQueue->Remove failed, error %lx\n", err);
			continue;
		}

//		TRACE("mpeg ts   packet, size %6ld, start_time %14Ld\n",
//			packet->Size(), packet->TimeStamp());

#ifdef DUMP_MPEG_TS
		lock.Lock();
		write(fMpegTsFile, packet->Data(), packet->Size());
		lock.Unlock();
#endif

		delete packet;
	}
}


void
DVBMediaNode::enc_audio_thread()
{
	while (!fTerminateThreads) {
		status_t err;
		Packet *packet;
		err = fEncAudioQueue->Remove(&packet);
		if (err != B_OK) {
			TRACE("fEncAudioQueue->Remove failed, error %lx\n", err);
			continue;
		}
//		TRACE("enc audio packet, size %6ld, start_time %14Ld\n",
//			packet->Size(), packet->TimeStamp());

#ifdef DUMP_AUDIO
		const uint8 *data;
		size_t size;
		if (B_OK != pes_extract(packet->Data(), packet->Size(), &data,
				&size)) {
			TRACE("audio pes_extract failed\n");
			delete packet;
			return;
		}
		lock.Lock();
		write(fAudioFile, data, size);
		lock.Unlock();
#endif

		if (!fOutputEnabledEncAudio) {
			delete packet;
			continue;
		}

		// send encoded audio buffer


		delete packet;
	}
}


void
DVBMediaNode::enc_video_thread()
{
	while (!fTerminateThreads) {
		status_t err;
		Packet *packet;
		err = fEncVideoQueue->Remove(&packet);
		if (err != B_OK) {
			TRACE("fEncVideoQueue->Remove failed, error %lx\n", err);
			continue;
		}

//		TRACE("enc video packet, size %6ld, start_time %14Ld\n",
//			packet->Size(), packet->TimeStamp());


#ifdef DUMP_VIDEO
		int8 *data;
		size_t size;
		if (B_OK != pes_extract(packet->Data(), packet->Size(), &data,
				&size)) {
			TRACE("video pes_extract failed\n");
			delete packet;
			return;
		}
		lock.Lock();
		write(fVideoFile, data, size);
		lock.Unlock();
#endif

		if (!fOutputEnabledEncVideo) {
			delete packet;
			continue;
		}

		// send encoded video buffer

		delete packet;
	}
}


void
DVBMediaNode::raw_audio_thread()
{
	media_format format;
	status_t err;
	err = GetStreamFormat(fRawAudioQueue, &format);
	if (err) {
		printf("fAudioDecoder init error %s\n", strerror(err));
		return;
	}
	
	// create decoder interface

	fAudioDecoder = new MediaStreamDecoder(&_GetNextAudioChunk, this);
	
	err = fAudioDecoder->SetInputFormat(format);
	if (err) {
		printf("fAudioDecoder SetInputFormat error %s\n", strerror(err));
		return;
	}
	
	TRACE("requested audio decoder format: ");
	PrintFormat(fOutputRawAudio);
	
	media_format fmt = fOutputRawAudio.format;
	err = fAudioDecoder->SetOutputFormat(&fmt);
	if (err) {
		printf("fAudioDecoder SetOutputFormat error %s\n", strerror(err));
		return;
	}

	TRACE("final audio decoder format: ");
	PrintFormat(fmt);
		
	// change format of connection
	if (format_is_compatible(fmt, fOutputRawAudio.format)) {
		printf("audio formats are compatible\n");
		fOutputRawAudio.format = fmt;
	} else {
		printf("audio formats NOT compatible\n");
		lock.Lock();
		err = ChangeFormat(fOutputRawAudio.source,
						   fOutputRawAudio.destination,
						   &fmt);
		lock.Unlock();
		printf("format change result %lx (%s)\n", err, strerror(err));
		PrintFormat(fmt);
		fOutputRawAudio.format = fmt;
		if (err)
			return;
	}
	
	// decode data and send buffers
	
	delete fBufferGroupRawAudio;
	fBufferGroupRawAudio = new BBufferGroup(
		fOutputRawAudio.format.u.raw_audio.buffer_size * 3, 25);

	while (!fTerminateThreads) {
		int64 frameCount;
		media_header mh;
		
		if (!fOutputEnabledRawAudio) {
			fRawAudioQueue->Flush(40000);
			continue;
		}

		BBuffer* buf;
		buf = fBufferGroupRawAudio->RequestBuffer(
			fOutputRawAudio.format.u.raw_audio.buffer_size,
			AUDIO_BUFFER_REQUEST_TIMEOUT);
		if (!buf) {
			TRACE("audio: request buffer timout\n");
			continue;
		}

		err = fAudioDecoder->Decode(buf->Data(), &frameCount, &mh, NULL);
		if (err) {
			buf->Recycle();
			printf("fAudioDecoder Decode error %s\n", strerror(err));
			continue;
		}

#ifdef DUMP_RAW_AUDIO
		lock.Lock();
		write(fRawAudioFile, buf->Data(), mh.size_used);
		lock.Unlock();
#endif

		if (fOutputRawAudio.format.u.raw_audio.buffer_size != mh.size_used
			|| int(fOutputRawAudio.format.u.raw_audio.frame_rate)
				!= mh.u.raw_audio.frame_rate
			|| fOutputRawAudio.format.u.raw_audio.channel_count
				!= mh.u.raw_audio.channel_count) {
			TRACE("audio: decode format change: changed buffer_size from %ld"
				" to %ld\n", fOutputRawAudio.format.u.raw_audio.buffer_size,
				mh.size_used);
			TRACE("audio: decode format change: changed channel_count from %ld"
				" to %ld\n", fOutputRawAudio.format.u.raw_audio.channel_count,
				mh.u.raw_audio.channel_count);
			TRACE("audio: decode format change: changed frame_rate from %.0f"
				" to %.0f\n", fOutputRawAudio.format.u.raw_audio.frame_rate,
				mh.u.raw_audio.frame_rate);
			fOutputRawAudio.format.u.raw_audio.buffer_size = mh.size_used;
			fOutputRawAudio.format.u.raw_audio.frame_rate
				= mh.u.raw_audio.frame_rate;
			fOutputRawAudio.format.u.raw_audio.channel_count
				= mh.u.raw_audio.channel_count;
			lock.Lock();
			err = ChangeFormat(fOutputRawAudio.source,
				fOutputRawAudio.destination, &fOutputRawAudio.format);
			lock.Unlock();
			printf("format change result %lx (%s)\n", err, strerror(err));
			PrintFormat(fOutputRawAudio.format);
			if (err) {
				buf->Recycle();
				return; // we are dead!
			}
		}
	
		bigtime_t ts_perf_time;
		bigtime_t ts_sys_time;
		bigtime_t ts_offset;
		bigtime_t aud_time;
		bigtime_t start_time;

		// calculate start time of audio data

		fDemux->TimesourceInfo(&ts_perf_time, &ts_sys_time);
		ts_offset = ts_sys_time - ts_perf_time;
		aud_time = mh.start_time;	// measured in PCR time base
		start_time = TimeSource()->PerformanceTimeFor(aud_time + ts_offset);

		// calculate delay and wait

		bigtime_t delay;
		delay = start_time - TimeSource()->Now();
		TRACE_TIMING("audio delay is %lld\n", delay);
		if (delay < -AUDIO_MAX_LATE) {
			printf("audio: decoded packet is %lldms too late, dropped\n",
				-delay / 1000);
			buf->Recycle();
			continue;
		}
		if (delay < 0)
//			printf("audio: decoded packet is %lldms too late\n", -delay / 1000);

		if (delay > AUDIO_MAX_EARLY) {
			printf("audio: decoded packet is %lldms too early, dropped\n",
				delay / 1000);
			buf->Recycle();
			continue;
		}
		if (delay > 0)
//			printf("audio: decoded packet is %lldms too early\n", delay / 1000);

		delay -= PROCESSING_LATENCY;
		if (delay > 0) {
			if (acquire_sem_etc(fAudioDelaySem, 1, B_RELATIVE_TIMEOUT, delay)
				!= B_TIMED_OUT) {
				printf("audio: delay sem not timed out, dropped packet\n");
				buf->Recycle();
				continue;
			}
		}

		TRACE_TIMING("audio playback delay %lld\n",
			start_time - TimeSource()->Now());

		media_header* hdr;
		hdr = buf->Header();
		hdr->type = B_MEDIA_RAW_AUDIO;
		hdr->size_used = mh.size_used;
		hdr->time_source = TimeSource()->ID();
		hdr->start_time = start_time;
		lock.Lock();
		if (SendBuffer(buf, fOutputRawAudio.source,
			fOutputRawAudio.destination) != B_OK) {
			TRACE("audio: sending buffer failed\n");
			buf->Recycle();
		} 
		lock.Unlock();
	}

	delete fCurrentAudioPacket;
	fCurrentAudioPacket = 0;
}


void
DVBMediaNode::raw_video_thread()
{
	media_format format;
	status_t err;
	err = GetStreamFormat(fRawVideoQueue, &format);
	if (err) {
		printf("fVideoDecoder init error %s\n", strerror(err));
		return;
	}
	
	// create decoder interface

	fVideoDecoder = new MediaStreamDecoder(&_GetNextVideoChunk, this);
	
	err = fVideoDecoder->SetInputFormat(format);
	if (err) {
		printf("fVideoDecoder SetInputFormat error %s\n", strerror(err));
		return;
	}
	
	TRACE("requested video decoder format: ");
	PrintFormat(fOutputRawVideo);
	
	media_format fmt = fOutputRawVideo.format;
	err = fVideoDecoder->SetOutputFormat(&fmt);
	if (err) {
		printf("fVideoDecoder SetOutputFormat error %s\n", strerror(err));
		return;
	}

	TRACE("final video decoder format: ");
	PrintFormat(fmt);
		
	// change format of connection
	if (format_is_compatible(fmt, fOutputRawVideo.format)) {
		printf("video formats are compatible\n");
		fOutputRawVideo.format = fmt;
	} else {
		printf("video formats NOT compatible\n");
		lock.Lock();
		err = ChangeFormat(fOutputRawVideo.source,
						   fOutputRawVideo.destination,
						   &fmt);
		lock.Unlock();
		printf("format change result %lx (%s)\n", err, strerror(err));
		PrintFormat(fmt);
		fOutputRawVideo.format = fmt;
		if (err) {
			printf("video format change failed\n");
			return;
		}
	}
	
	// decode data and send buffers

	uint32 video_buffer_size_max = 720 * 576 * 4;
	uint32 video_buffer_size
		= fOutputRawVideo.format.u.raw_video.display.line_count
			* fOutputRawVideo.format.u.raw_video.display.bytes_per_row;
	
	delete fBufferGroupRawVideo;
	fBufferGroupRawVideo = new BBufferGroup(video_buffer_size_max, 4);

	while (!fTerminateThreads) {
		int64 frameCount;
		media_header mh;

		if (!fOutputEnabledRawVideo) {
			fRawVideoQueue->Flush(40000);
			continue;
		}

		// fetch a new buffer (always of maximum size as the stream may change)
		BBuffer* buf;
		buf = fBufferGroupRawVideo->RequestBuffer(video_buffer_size_max,
			VIDEO_BUFFER_REQUEST_TIMEOUT);
		if (!buf) {
			TRACE("video: request buffer timout\n");
			continue;
		}
		
		// decode one video frame into buffer
		err = fVideoDecoder->Decode(buf->Data(), &frameCount, &mh, NULL);
		if (err) {
			buf->Recycle();
			printf("fVideoDecoder Decode error %s\n", strerror(err));
			continue;
		}

		// check if the format of the stream has changed
		if (mh.u.raw_video.display_line_width
			!= fOutputRawVideo.format.u.raw_video.display.line_width
			|| mh.u.raw_video.display_line_count
				!= fOutputRawVideo.format.u.raw_video.display.line_count
			|| mh.u.raw_video.bytes_per_row
				!= fOutputRawVideo.format.u.raw_video.display.bytes_per_row
			|| mh.u.raw_video.pixel_width_aspect
				!= fOutputRawVideo.format.u.raw_video.pixel_width_aspect
			|| mh.u.raw_video.pixel_height_aspect
				!= fOutputRawVideo.format.u.raw_video.pixel_height_aspect
			|| mh.size_used != video_buffer_size) {
			printf("video format changed:\n");
			printf(" line_width %ld => %ld\n",
				fOutputRawVideo.format.u.raw_video.display.line_width,
				mh.u.raw_video.display_line_width);
			printf(" line_count %ld => %ld\n",
				fOutputRawVideo.format.u.raw_video.display.line_count,
				mh.u.raw_video.display_line_count);
			printf(" bytes_per_row %ld => %ld\n",
				fOutputRawVideo.format.u.raw_video.display.bytes_per_row,
				mh.u.raw_video.bytes_per_row);
			printf(" pixel_width_aspect %d => %d\n",
				fOutputRawVideo.format.u.raw_video.pixel_width_aspect,
				mh.u.raw_video.pixel_width_aspect);
			printf(" pixel_height_aspect %d => %d\n",
				fOutputRawVideo.format.u.raw_video.pixel_height_aspect,
				mh.u.raw_video.pixel_height_aspect);
			printf(" video_buffer_size %ld => %ld\n", video_buffer_size,
				mh.size_used);

			// recalculate video buffer size
			video_buffer_size
				= fOutputRawVideo.format.u.raw_video.display.line_count
					* fOutputRawVideo.format.u.raw_video.display.bytes_per_row;

			// perform a video format change
			fOutputRawVideo.format.u.raw_video.display.line_width
				= mh.u.raw_video.display_line_width;
			fOutputRawVideo.format.u.raw_video.display.line_count
				= mh.u.raw_video.display_line_count;
			fOutputRawVideo.format.u.raw_video.display.bytes_per_row
				= mh.u.raw_video.bytes_per_row;
			fOutputRawVideo.format.u.raw_video.pixel_width_aspect
				= mh.u.raw_video.pixel_width_aspect;
			fOutputRawVideo.format.u.raw_video.pixel_height_aspect
				= mh.u.raw_video.pixel_height_aspect;
			fOutputRawVideo.format.u.raw_video.last_active
				= mh.u.raw_video.display_line_count - 1;
			lock.Lock();
			err = ChangeFormat(fOutputRawVideo.source,
				fOutputRawVideo.destination, &fOutputRawVideo.format);
			lock.Unlock();
			printf("format change result %lx (%s)\n", err, strerror(err));
			PrintFormat(fOutputRawVideo.format);
			if (err) {
				buf->Recycle();
				printf("video format change failed\n");
				return; // we are dead
			}
		}
		
		// calculate start time for video
		bigtime_t ts_perf_time;
		bigtime_t ts_sys_time;
		bigtime_t ts_offset;
		bigtime_t pic_time;
		bigtime_t start_time;

		fDemux->TimesourceInfo(&ts_perf_time, &ts_sys_time);
		ts_offset = ts_sys_time - ts_perf_time;
		pic_time = mh.start_time;	// measured in PCR time base
		start_time = TimeSource()->PerformanceTimeFor(pic_time + ts_offset);

		// calculate delay and wait

		bigtime_t delay;
		delay = start_time - TimeSource()->Now();
		TRACE_TIMING("video delay %lld\n", delay);
		if (delay < -VIDEO_MAX_LATE) {
			printf("video: decoded packet is %lldms too late, dropped\n",
				-delay / 1000);
			buf->Recycle();
			continue;
		}
		if (delay > VIDEO_MAX_EARLY) {
			printf("video: decoded packet is %lldms too early, dropped\n",
				delay / 1000);
			buf->Recycle();
			continue;
		}
		delay -= PROCESSING_LATENCY;
		if (delay > 0) {
			if (acquire_sem_etc(fVideoDelaySem, 1, B_RELATIVE_TIMEOUT, delay)
				!= B_TIMED_OUT) {
				printf("video: delay sem not timed out, dropped packet\n");
				buf->Recycle();
				continue;
			}
		}

		TRACE_TIMING("video playback delay %lld\n", start_time 
			- TimeSource()->Now());

		media_header* hdr;
		hdr = buf->Header();
		hdr->type = B_MEDIA_RAW_VIDEO;
		hdr->size_used = video_buffer_size;
		hdr->time_source = TimeSource()->ID();
		hdr->start_time = start_time;
		lock.Lock();
		if (SendBuffer(buf, fOutputRawVideo.source,
				fOutputRawVideo.destination) != B_OK) {
			TRACE("video: sending buffer failed\n");
			buf->Recycle();
		} 
		lock.Unlock();
	}

	delete fCurrentVideoPacket;
	fCurrentVideoPacket = 0;
}


inline status_t
DVBMediaNode::GetNextVideoChunk(const void **chunkData, size_t *chunkLen,
	media_header *mh)
{
//	TRACE("DVBMediaNode::GetNextVideoChunk\n");

	delete fCurrentVideoPacket;
	
	status_t err;
	err = fRawVideoQueue->Remove(&fCurrentVideoPacket);
	if (err != B_OK) {
		TRACE("fRawVideoQueue->Remove failed, error %lx\n", err);
		fCurrentVideoPacket = 0;
		return B_ERROR;
	}

	const uint8 *data;
	size_t size;
			
	if (B_OK != pes_extract(fCurrentVideoPacket->Data(),
			fCurrentVideoPacket->Size(), &data, &size)) {
		TRACE("video pes_extract failed\n");
		return B_ERROR;
	}
	
	*chunkData = data;
	*chunkLen = size;
	// measured in PCR time base
	mh->start_time = fCurrentVideoPacket->TimeStamp();

	return B_OK;
}


inline status_t
DVBMediaNode::GetNextAudioChunk(const void **chunkData, size_t *chunkLen,
	media_header *mh)
{
//	TRACE("DVBMediaNode::GetNextAudioChunk\n");

	delete fCurrentAudioPacket;
	
	status_t err;
	err = fRawAudioQueue->Remove(&fCurrentAudioPacket);
	if (err != B_OK) {
		TRACE("fRawAudioQueue->Remove failed, error %lx\n", err);
		fCurrentAudioPacket = 0;
		return B_ERROR;
	}

	const uint8 *data;
	size_t size;
			
	if (B_OK != pes_extract(fCurrentAudioPacket->Data(),
			fCurrentAudioPacket->Size(), &data, &size)) {
		TRACE("audio pes_extract failed\n");
		return B_ERROR;
	}
	
	*chunkData = data;
	*chunkLen = size;
	// measured in PCR time base
	mh->start_time = fCurrentAudioPacket->TimeStamp();

//	printf("GetNextAudioChunk: done start_time %lld\n", mh->start_time);

	return B_OK;
}


status_t
DVBMediaNode::_GetNextVideoChunk(const void **chunkData, size_t *chunkLen,
	media_header *mh, void *cookie)
{
	return static_cast<DVBMediaNode *>(cookie)->GetNextVideoChunk(chunkData,
		chunkLen, mh);
}


status_t
DVBMediaNode::_GetNextAudioChunk(const void **chunkData, size_t *chunkLen,
	media_header *mh, void *cookie)
{
	return static_cast<DVBMediaNode *>(cookie)->GetNextAudioChunk(chunkData,
		chunkLen, mh);
}


status_t
DVBMediaNode::GetStreamFormat(PacketQueue *queue, media_format *format)
{
	status_t status;
	Packet *packet;
	const uint8 *data;
	size_t size;
	int stream_id;
	
	// get copy of the first packet from queue, and determine format
	status = queue->Peek(&packet);
	if (status != B_OK) {
		TRACE("queue->Peek failed, error %lx\n", status);
		return status;
	}
	status = pes_extract(packet->Data(), packet->Size(), &data, &size);
	if (status != B_OK) {
		TRACE("pes_extract failed\n");
		goto done;
	}
	status = pes_stream_id(packet->Data(), packet->Size(), &stream_id);
	if (status != B_OK) {
		TRACE("pes_stream_id failed\n");
		goto done;
	}
	status = GetHeaderFormat(format, data, size, stream_id);
	if (status != B_OK) {
		TRACE("GetHeaderFormat failed, error %lx\n", status);
		goto done;
	}

done:
	delete packet;
	return status;
}


enum {
	ID_STATE	= 11,
	ID_REGION	= 12,
	ID_CHANNEL	= 13,
	ID_AUDIO	= 14,
};


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


void
DVBMediaNode::SetAboutInfo(BParameterGroup *about)
{
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, "DVB 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);

	dvb_type_t type;
	char name[200];
	char info[200];
	
	fCard->GetCardType(&type);
	fCard->GetCardInfo(name, sizeof(name), info, sizeof(info));

	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, name, B_GENERIC);
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, info, B_GENERIC);
}


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

	char n[200], i[200];
	fCard->GetCardInfo(n, sizeof(n), i, sizeof(i));
	
	BString name;
	name << Name() << " - " << i;
	
	BParameterGroup *main = web->MakeGroup(name.String());
	
	BParameterGroup *ctrl = main->MakeGroup("Channel Selection");
	ctrl->MakeNullParameter(0, B_MEDIA_NO_TYPE, ctrl->Name(), B_GENERIC);

	BParameterGroup *pref = main->MakeGroup("Preferences");
	pref->MakeNullParameter(0, B_MEDIA_NO_TYPE, pref->Name(), B_GENERIC);

	BDiscreteParameter *state = pref->MakeDiscreteParameter(
			ID_STATE, B_MEDIA_RAW_VIDEO, "State", B_GENERIC);

	BDiscreteParameter *region = pref->MakeDiscreteParameter(
			ID_REGION, B_MEDIA_RAW_VIDEO, "Region", B_GENERIC);

	BDiscreteParameter *chan = ctrl->MakeDiscreteParameter(
			ID_CHANNEL, B_MEDIA_RAW_VIDEO, "Channel",
			/* B_TUNER_CHANNEL */ B_GENERIC);

	BDiscreteParameter *aud = ctrl->MakeDiscreteParameter(
			ID_AUDIO, B_MEDIA_RAW_VIDEO, "Audio", B_GENERIC);

	AddStateItems(state);
	AddRegionItems(region);
	AddChannelItems(chan);
	AddAudioItems(aud);


	if (!fTuningSuccess || !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,
//			fCaptureActive ? "Tuning failed" : "Node stopped", B_GENERIC);
		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 *info1 = main->MakeGroup("Info");
	info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, info1->Name(), B_GENERIC);
	BParameterGroup *info2 = main->MakeGroup("Info");
	info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, info2->Name(), B_GENERIC);
	BParameterGroup *about = main->MakeGroup("About");
	about->MakeNullParameter(0, B_MEDIA_NO_TYPE, about->Name(), B_GENERIC);
	SetAboutInfo(about);
	
	BString sInterfaceType = "Interface Type: ";
	BString sFrequency = "Frequency: ";
	BString sAudioPid = "Audio PID: ";
	BString sVideoPid = "Video PID: ";
	BString sPcrPid = "PCR PID: ";
	BString sInversion = "Inversion: ";
	BString sBandwidth = "Bandwith: ";
	BString sModulation = "Modulation: ";
	BString sHierarchy = "Hierarchy: ";
	BString sCodeRateHP = "Code Rate HP: ";
	BString sCodeRateLP = "Code Rate LP: ";
	BString sTransmissionMode = "Transmission Mode: ";
	BString sGuardInterval = "Guard Interval: ";
	
	BString sSymbolRate = "Symbol Rate: ";
	BString sPolarity = "Polarity: ";
	BString sAgcInversion = "AGC Inversion: ";

	switch (fInterfaceType) {
		case DVB_TYPE_DVB_C:
			sInterfaceType << "DVB-C";
			break;

		case DVB_TYPE_DVB_H:
			sInterfaceType << "DVB-H";
			break;

		case DVB_TYPE_DVB_S:
			sInterfaceType << "DVB-S";
			break;

		case DVB_TYPE_DVB_T:
			sInterfaceType << "DVB-T";
			break;

		default:
			sInterfaceType << "unknown";
			break;
	}

	sAudioPid << fAudioPid;
	sVideoPid << fVideoPid;
	sPcrPid << fPcrPid;
	
	if (fInterfaceType == DVB_TYPE_DVB_T) {

		sFrequency << fTuningParam.u.dvb_t.frequency / 1000000 << " MHz";

		switch (fTuningParam.u.dvb_t.inversion) {
			case DVB_INVERSION_AUTO:
				sInversion << "auto";
				break;

			case DVB_INVERSION_ON:
				sInversion << "on";
				break;

			case DVB_INVERSION_OFF:
				sInversion << "off";
				break;

			default:
				sInversion << "unknown";
				break;
		}

		switch (fTuningParam.u.dvb_t.bandwidth) {
			case DVB_BANDWIDTH_AUTO:
				sBandwidth << "auto";
				break;

			case DVB_BANDWIDTH_6_MHZ:
				sBandwidth << "6 MHz";
				break;

			case DVB_BANDWIDTH_7_MHZ:
				sBandwidth << "7 MHz";
				break;

			case DVB_BANDWIDTH_8_MHZ:
				sBandwidth << "8 MHz";
				break;

			default:
				sBandwidth << "unknown";
				break;
		}

		switch (fTuningParam.u.dvb_t.modulation) {
			case DVB_MODULATION_AUTO:
				sModulation << "auto";
				break;

			case DVB_MODULATION_QPSK:
				sModulation << "QPSK";
				break;

			case DVB_MODULATION_16_QAM:
				sModulation << "16 QAM";
				break;

			case DVB_MODULATION_32_QAM:
				sModulation << "32 QAM";
				break;

			case DVB_MODULATION_64_QAM:
				sModulation << "64 QAM";
				break;

			case DVB_MODULATION_128_QAM:
				sModulation << "128 QAM";
				break;

			case DVB_MODULATION_256_QAM:
				sModulation << "256 QAM";
				break;

			default:
				sModulation << "unknown";
				break;
		}
		
		switch (fTuningParam.u.dvb_t.hierarchy) {
			case DVB_HIERARCHY_AUTO:
				sHierarchy << "auto";
				break;

			case DVB_HIERARCHY_NONE:
				sHierarchy << "none";
				break;

			case DVB_HIERARCHY_1:
				sHierarchy << "1";
				break;

			case DVB_HIERARCHY_2:
				sHierarchy << "2";
				break;

			case DVB_HIERARCHY_4:
				sHierarchy << "4";
				break;

			default:
				sHierarchy << "unknown";
				break;
		}
		
		switch (fTuningParam.u.dvb_t.code_rate_hp) {
			case DVB_FEC_AUTO:
				sCodeRateHP << "auto";
				break;

			case DVB_FEC_NONE:
				sCodeRateHP << "none";
				break;

			case DVB_FEC_1_2:
				sCodeRateHP << "FEC 1/2";
				break;

			case DVB_FEC_2_3:
				sCodeRateHP << "FEC 2/3";
				break;

			case DVB_FEC_3_4:
				sCodeRateHP << "FEC 3/4";
				break;

			case DVB_FEC_4_5:
				sCodeRateHP << "FEC 4/5";
				break;

			case DVB_FEC_5_6:
				sCodeRateHP << "FEC 5/6";
				break;

			case DVB_FEC_6_7:
				sCodeRateHP << "FEC 6/7";
				break;

			case DVB_FEC_7_8:
				sCodeRateHP << "FEC 7/8";
				break;

			case DVB_FEC_8_9:
				sCodeRateHP << "FEC 8/9";
				break;

			default:
				sCodeRateHP << "unknown";
				break;
		}

		switch (fTuningParam.u.dvb_t.code_rate_lp) {
			case DVB_FEC_AUTO:
				sCodeRateLP << "auto";
				break;

			case DVB_FEC_NONE:
				sCodeRateLP << "none";
				break;

			case DVB_FEC_1_2:
				sCodeRateLP << "FEC 1/2";
				break;

			case DVB_FEC_2_3:
				sCodeRateLP << "FEC 2/3";
				break;

			case DVB_FEC_3_4:
				sCodeRateLP << "FEC 3/4";
				break;

			case DVB_FEC_4_5:
				sCodeRateLP << "FEC 4/5";
				break;

			case DVB_FEC_5_6:
				sCodeRateLP << "FEC 5/6";
				break;

			case DVB_FEC_6_7:
				sCodeRateLP << "FEC 6/7";
				break;

			case DVB_FEC_7_8:
				sCodeRateLP << "FEC 7/8";
				break;

			case DVB_FEC_8_9:
				sCodeRateLP << "FEC 8/9";
				break;

			default:
				sCodeRateLP << "unknown";
				break;
		}

		switch (fTuningParam.u.dvb_t.transmission_mode) {
			case DVB_TRANSMISSION_MODE_AUTO:
				sTransmissionMode << "auto";
				break;

			case DVB_TRANSMISSION_MODE_2K:
				sTransmissionMode << "2K";
				break;

			case DVB_TRANSMISSION_MODE_4K:
				sTransmissionMode << "4K";
				break;

			case DVB_TRANSMISSION_MODE_8K:
				sTransmissionMode << "8K";
				break;

			default:
				sTransmissionMode << "unknown";
				break;
		}

		switch (fTuningParam.u.dvb_t.guard_interval) {
			case DVB_GUARD_INTERVAL_AUTO:
				sGuardInterval << "auto";
				break;

			case DVB_GUARD_INTERVAL_1_4:
				sGuardInterval << "1/4";
				break;

			case DVB_GUARD_INTERVAL_1_8:
				sGuardInterval << "1/8";
				break;

			case DVB_GUARD_INTERVAL_1_16:
				sGuardInterval << "1/16";
				break;

			case DVB_GUARD_INTERVAL_1_32:
				sGuardInterval << "1/32";
				break;

			default:
				sGuardInterval << "unknown";
				break;
		}

		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sInterfaceType.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sFrequency.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sBandwidth.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sVideoPid.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sAudioPid.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sPcrPid.String(),
			B_GENERIC);

		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sModulation.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE,
			sTransmissionMode.String(), B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sGuardInterval.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sCodeRateHP.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sCodeRateLP.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sInversion.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sHierarchy.String(),
			B_GENERIC);
	}

	if (fInterfaceType == DVB_TYPE_DVB_S) {

		sFrequency << fTuningParam.u.dvb_s.frequency / 1000000 << " MHz";
		sSymbolRate << fTuningParam.u.dvb_s.symbolrate;

		switch (fTuningParam.u.dvb_s.inversion) {
			case DVB_INVERSION_AUTO:
				sInversion << "auto";
				break;

			case DVB_INVERSION_ON:
				sInversion << "on";
				break;

			case DVB_INVERSION_OFF:
				sInversion << "off";
				break;

			default:
				sInversion << "unknown";
				break;
		}
	
		switch (fTuningParam.u.dvb_s.polarity) {
			case DVB_POLARITY_VERTICAL:
				sPolarity << "vertical";
				break;

			case DVB_POLARITY_HORIZONTAL:
				sPolarity << "horizontal";
				break;

			default:
				sPolarity << "unknown";
				break;
		}

		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sInterfaceType.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sVideoPid.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sAudioPid.String(),
			B_GENERIC);
		info1->MakeNullParameter(0, B_MEDIA_NO_TYPE, sPcrPid.String(),
			B_GENERIC);

		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sFrequency.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sPolarity.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sSymbolRate.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sInversion.String(),
			B_GENERIC);
		info2->MakeNullParameter(0, B_MEDIA_NO_TYPE, sAgcInversion.String(),
			B_GENERIC);
	}

	return web;
}


void
DVBMediaNode::LoadSettings()
{
	TRACE("DVBMediaNode::LoadSettings\n");
	RefreshStateList();
	fSelectedState = 0;
	RefreshRegionList();
	fSelectedRegion = 0;
	RefreshChannelList();
	fSelectedChannel = 0;
	RefreshAudioList();
	fSelectedAudio = 0;
}


void
DVBMediaNode::RefreshStateList()
{
	TRACE("DVBMediaNode::RefreshStateList\n");

	fStateList->MakeEmpty();
	fSelectedState = -1;

	const char *dir;
	switch (fInterfaceType) {
		case DVB_TYPE_DVB_C:
			dir = "/boot/home/config/settings/Media/dvb/dvb-c channels";
			break;

		case DVB_TYPE_DVB_H:
			dir = "/boot/home/config/settings/Media/dvb/dvb-h channels";
			break;

		case DVB_TYPE_DVB_S:
			dir = "/boot/home/config/settings/Media/dvb/dvb-s channels";
			break;

		case DVB_TYPE_DVB_T:
			dir = "/boot/home/config/settings/Media/dvb/dvb-t channels";
			break;

		default:
			printf("DVBMediaNode::RefreshStateList unknown interface type\n");
			return;
	}
	
	TRACE("loading channel lists from dir = %s\n", dir);
	
	BDirectory d(dir);
	BEntry e;
	BPath p;
	while (B_OK == d.GetNextEntry(&e, false)) {
		if (B_OK != e.GetPath(&p))
			continue;
		fStateList->AddItem(p.Path());
	}
	
	if (fStateList->ItemAt(0))
		fSelectedState = 0;
}


void
DVBMediaNode::RefreshRegionList()
{
	TRACE("DVBMediaNode::RefreshRegionList\n");

	fRegionList->MakeEmpty();
	fSelectedRegion = -1;

	const char *dir = fStateList->ItemAt(fSelectedState);
	if (!dir)
		return;

	BDirectory d(dir);
	BEntry e;
	BPath p;
	while (B_OK == d.GetNextEntry(&e, false)) {
		if (B_OK != e.GetPath(&p))
			continue;
		fRegionList->AddItem(p.Path());
	}

	if (fRegionList->ItemAt(0))
		fSelectedRegion = 0;
}


void
DVBMediaNode::RefreshChannelList()
{
	TRACE("DVBMediaNode::RefreshChannelList\n");

	fChannelList->MakeEmpty();
	fSelectedChannel = -1;

	const char *path = fRegionList->ItemAt(fSelectedRegion);
	if (!path)
		return;
		
	TRACE("opening channel list file = %s\n", path);
	
	FILE *f = fopen(path, "r");
	if (!f)
		return;

	char line[1024];
	while (fgets(line, sizeof(line), f)) {
		if (line[0] == ':') // skip comments
			continue;
		if (strchr(line, ':') == NULL)	// skip empty lines
			continue;
		fChannelList->AddItem(line);
	}

	fclose(f);	

	if (fChannelList->ItemAt(0))
		fSelectedChannel = 0;
}


void
DVBMediaNode::RefreshAudioList()
{
	TRACE("DVBMediaNode::RefreshAudioList\n");

	fAudioList->MakeEmpty();	
	fSelectedAudio = -1;
	
	fAudioList->AddItem("default"); // XXX test
	
	if (fAudioList->ItemAt(0))
		fSelectedAudio = 0;
}


void
DVBMediaNode::AddStateItems(BDiscreteParameter *param)
{
	TRACE("DVBMediaNode::AddStateItems\n");
	
	const char *str;
	for (int i = 0; (str = fStateList->ItemAt(i)); i++) {
		str = strrchr(str, '/');
		if (!str)
			continue;
		str++;
		param->AddItem(i, str);
	}
	if (param->CountItems() == 0)
		param->AddItem(-1, "none");
}


void
DVBMediaNode::AddRegionItems(BDiscreteParameter *param)
{
	TRACE("DVBMediaNode::AddRegionItems\n");

	const char *str;
	for (int i = 0; (str = fRegionList->ItemAt(i)); i++) {
		str = strrchr(str, '/');
		if (!str)
			continue;
		str++;
		param->AddItem(i, str);
	}
	if (param->CountItems() == 0)
		param->AddItem(-1, "none");
}


void
DVBMediaNode::AddChannelItems(BDiscreteParameter *param)
{
	TRACE("DVBMediaNode::AddChannelItems\n");

	const char *str;
	for (int i = 0; (str = fChannelList->ItemAt(i)); i++) {
		char name[256];
//		sscanf(str, "%s:", name);
		sscanf(str, "%[^:]", name);
		param->AddItem(i, name);

	}
	if (param->CountItems() == 0)
		param->AddItem(-1, "none");
}


void
DVBMediaNode::AddAudioItems(BDiscreteParameter *param)
{
	TRACE("DVBMediaNode::AddAudioItems\n");

	if (param->CountItems() == 0)
		param->AddItem(-1, "default");
}


status_t 
DVBMediaNode::GetParameterValue(int32 id, bigtime_t *last_change, void *value,
	size_t *size)
{
//	TRACE("DVBMediaNode::GetParameterValue, id 0x%lx\n", id);
	
	switch (id) {
		case ID_STATE:
			*size = 4;
			*(int32 *)value = fSelectedState;
			break;

		case ID_REGION:
			*size = 4;
			*(int32 *)value = fSelectedRegion;
			break;

		case ID_CHANNEL:
			*size = 4;
			*(int32 *)value = fSelectedChannel;
			break;

		case ID_AUDIO:
			*size = 4;
			*(int32 *)value = fSelectedAudio;
			break;

		default:
			return B_ERROR;
	}
	return B_OK;
}


void
DVBMediaNode::SetParameterValue(int32 id, bigtime_t when, const void *value,
	size_t size)
{
	TRACE("DVBMediaNode::SetParameterValue, id 0x%lx, size %ld, value 0x%lx\n",
		id, size, *(const int32 *)value);
	
	switch (id) {
		case ID_STATE:
			fSelectedState = *(const int32 *)value;
			StopCapture();
			RefreshRegionList();
			RefreshChannelList();
			RefreshAudioList();
			EventQueue()->AddEvent(media_timed_event(0,
				M_REFRESH_PARAMETER_WEB));
//			Tune();
			break;
			
		case ID_REGION:  
			fSelectedRegion = *(const int32 *)value;
			StopCapture();
			RefreshChannelList();
			RefreshAudioList();
			EventQueue()->AddEvent(media_timed_event(0,
				M_REFRESH_PARAMETER_WEB));
//			Tune();
			break;
			
		case ID_CHANNEL: 
			fSelectedChannel = *(const int32 *)value;
			RefreshAudioList();
//			EventQueue()->AddEvent(media_timed_event(0,
//				M_REFRESH_PARAMETER_WEB));
			Tune();
			break;
			
		case ID_AUDIO:   
			fSelectedAudio = *(const int32 *)value;
			Tune();
			break;
			
		default:
			break;
	}
	TRACE("DVBMediaNode::SetParameterValue finished\n");
}


status_t
DVBMediaNode::ExtractTuningParams(const char *description, int audio_pid_index,
	dvb_tuning_parameters_t *tuning_param, int *video_pid, int *audio_pid,
	int *pcr_pid)
{
	if (!description)
		return B_ERROR;

	printf("ExtractTuningParams: \"%s\"\n", description);
		
	char name[50];
	char freq[50];
	char para[100];
	char src[50];
	char srate[50];
	char vpid[50];
	char apid[50];
	char tpid[50];
	char ca[50];
	char sid[50];
	char nid[50];
	char tid[50];
	char rid[50];
	
	sscanf(description, " %[^:] : %[^:] : %[^:] : %[^:] : %[^:] : %[^:] : %[^:]"
		" : %[^:] : %[^:] : %[^:] : %[^:] : %[^:] : %[^:] ", name, freq, para,
		src, srate, vpid, apid, tpid, ca, sid, nid, tid, rid);
		
	char *cpid = strchr(vpid, '+');
	if (cpid) cpid++;
		
	int _vpid = strtol(vpid, 0, 0);
	int _apid = strtol(apid, 0, 0);
//	int _tpid = strtol(tpid, 0, 0);
	int _cpid = cpid ? strtol(cpid, 0, 0) : _vpid;
	int _srate = strtol(srate, 0, 0);
	int64 _freq = strtol(freq, 0, 0);
	while (_freq && _freq <= 1000000)
		_freq *= 1000;

	if (fInterfaceType == DVB_TYPE_DVB_S && _freq < 950000000) {
		TRACE("workaround activated: type is DVB_S and frequency < 950 MHz,"
			" multiplying by 1000!\n");
		_freq *= 1000;
	}


	*video_pid = _vpid;
	*audio_pid = _apid;
	*pcr_pid   = _cpid;

	TRACE("parsing result: params: '%s'\n", para);
	
	TRACE("parsing result: video pid %d\n", _vpid);
	TRACE("parsing result: audio pid %d\n", _apid);
	TRACE("parsing result: PCR pid %d\n", _cpid);
	TRACE("parsing result: symbol rate %d\n", _srate);
	TRACE("parsing result: Frequency %lld Hz, %lld MHz\n", _freq, _freq / 1000000);

	if (fInterfaceType == DVB_TYPE_DVB_T) {

		dvb_t_tuning_parameters_t *param = &tuning_param->u.dvb_t;

		TRACE("Interface is DVB-T\n");
		param->frequency = _freq;
		param->inversion = DVB_INVERSION_OFF;
		param->bandwidth = DVB_BANDWIDTH_8_MHZ;
		param->modulation = DVB_MODULATION_16_QAM;
		param->hierarchy = DVB_HIERARCHY_NONE;
		param->code_rate_hp = DVB_FEC_2_3;
		param->code_rate_lp = DVB_FEC_2_3;
		param->transmission_mode = DVB_TRANSMISSION_MODE_8K;
		param->guard_interval = DVB_GUARD_INTERVAL_1_4;
	}

	if (fInterfaceType == DVB_TYPE_DVB_S) {
		dvb_s_tuning_parameters_t *param = &tuning_param->u.dvb_s;

		TRACE("Interface is DVB-S\n");

		const char *pInv = strchr(para, 'I');
		if (pInv == NULL)
			pInv = strchr(para, 'i');
		if (pInv != NULL && pInv[1] == '0') {
			TRACE("DVB_INVERSION_OFF\n");
			param->inversion = DVB_INVERSION_OFF;
		} else if (pInv != NULL && pInv[1] == '1') {
			TRACE("DVB_INVERSION_ON\n");
			param->inversion = DVB_INVERSION_ON;
		} else {
			TRACE("parse error, assuming DVB_INVERSION_OFF\n");
			param->inversion = DVB_INVERSION_OFF;
		}

		const char *pPolH = strchr(para, 'H');
		if (pPolH == NULL)
			pPolH = strchr(para, 'h');
		const char *pPolV = strchr(para, 'V');
		if (pPolV == NULL)
			pPolV = strchr(para, 'v');
		if (pPolH != NULL && pPolV == NULL) {
			TRACE("DVB_POLARITY_HORIZONTAL\n");
			param->polarity = DVB_POLARITY_HORIZONTAL;
		} else if (pPolH == NULL && pPolV != NULL) {
			TRACE("DVB_POLARITY_VERTICAL\n");
			param->polarity = DVB_POLARITY_VERTICAL;
		} else {
			TRACE("parse error, assuming DVB_POLARITY_HORIZONTAL\n");
			param->polarity = DVB_POLARITY_HORIZONTAL;
		}
		
		param->frequency = _freq;
		param->symbolrate = _srate;
	}
	
	return B_OK;
}