/*
 * 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 <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <fcntl.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <errno.h> // required on BeOS R5
#include <OS.h>

#include "DVBCard.h"


DVBCard::DVBCard(const char *path)
 :	fInitStatus(B_OK)
 ,	fDev(-1)
{
	printf("DVBCard opening %s\n", path);

	fDev = open(path, O_RDWR);
	if (fDev < 0) {
		printf("DVBCard opening %s failed\n", path);
		fInitStatus = B_ERROR;
		return;
	}
	
	dvb_frequency_info_t info;
	if (do_ioctl(fDev, DVB_GET_FREQUENCY_INFO, &info) < 0) {
		printf("DVB_GET_FREQUENCY_INFO failed with error %s\n", strerror(errno));
//		close(fDev);
//		fDev = -1;
//		return;
	}

	fFreqMin  = info.frequency_min;
	fFreqMax  = info.frequency_max;
	fFreqStep = info.frequency_step;
	
	fCaptureActive = false;
}


DVBCard::~DVBCard()
{
	if (fDev > 0)
		close(fDev);
}


status_t
DVBCard::InitCheck()
{
	return fInitStatus;
}
	

status_t
DVBCard::GetCardType(dvb_type_t *type)
{
	dvb_interface_info_t info;
	
	if (do_ioctl(fDev, DVB_GET_INTERFACE_INFO, &info) < 0) {
		printf("DVB_GET_INTERFACE_INFO failed with error %s\n", strerror(errno));
		return errno;
	}

	if (info.version < 1) {
		printf("DVBCard::GetCardInfo wrong API version\n");
		return B_ERROR;
	}

	*type = info.type;
	return B_OK;
}


status_t
DVBCard::GetCardInfo(char *_name, int max_name_len, char *_info, int max_info_len)
{
	dvb_interface_info_t info;
	
	if (do_ioctl(fDev, DVB_GET_INTERFACE_INFO, &info) < 0) {
		printf("DVB_GET_INTERFACE_INFO failed with error %s\n", strerror(errno));
		return errno;
	}
	
//	strlcpy(_name, info.name, max_name_len);
//	strlcpy(_info, info.info, max_info_len);
	strcpy(_name, info.name);
	strcpy(_info, info.info);

	if (info.version < 1) {
		printf("DVBCard::GetCardInfo wrong API version\n");
		return B_ERROR;
	}

	return B_OK;
}


status_t
DVBCard::SetTuningParameter(const dvb_tuning_parameters_t& param)
{
	if (fDev < 0)
		return B_NO_INIT;
		
	printf("DVBCard::SetTuningParameter:\n");
/*
	printf("frequency %lld\n", param.frequency);
	printf("inversion %d\n", param.inversion);
	printf("bandwidth %d\n", param.bandwidth);
	printf("modulation %d\n", param.modulation);
	printf("hierarchy %d\n", param.hierarchy);
	printf("code_rate_hp %d\n", param.code_rate_hp);
	printf("code_rate_lp %d\n", param.code_rate_lp);
	printf("transmission_mode %d\n", param.transmission_mode);
	printf("guard_interval %d\n", param.guard_interval);
	printf("symbolrate %d\n", param.symbolrate);
	printf("polarity %d\n", param.polarity);
	printf("agc_inversion %d\n", param.agc_inversion);
*/
	params = param;// XXX temporary!
	
//	if (do_ioctl(fDev, DVB_SET_TUNING_PARAMETERS, const_cast<void *>(&param)) < 0) {
//	if (do_ioctl(fDev, DVB_SET_TUNING_PARAMETERS, (void *)(&param)) < 0) {
	if (ioctl(fDev, DVB_SET_TUNING_PARAMETERS, (void *)(&param)) < 0) {
		printf("DVB_SET_TUNING_PARAMETERS failed with error %s\n", strerror(errno));
		return errno;		
	}
	
	dvb_status_t status;
	
	bigtime_t start = system_time();
	bool has_lock = false;
	bool has_signal = false;
	bool has_carrier = false;
	do {
		if (do_ioctl(fDev, DVB_GET_STATUS, &status) < 0) {
			printf("DVB_GET_STATUS failed with error %s\n", strerror(errno));
			return errno;
		}
		if (!has_signal && status & DVB_STATUS_SIGNAL) {
			has_signal = true;
			printf("got signal after %.6f\n", (system_time() - start) / 1e6);
		}
		if (!has_carrier && status & DVB_STATUS_CARRIER) {
			has_carrier = true;
			printf("got carrier after %.6f\n", (system_time() - start) / 1e6);
		}
		if (!has_lock && status & DVB_STATUS_LOCK) {
			has_lock = true;
			printf("got lock after %.6f\n", (system_time() - start) / 1e6);
		}
		
		if ((status & (DVB_STATUS_SIGNAL|DVB_STATUS_CARRIER|DVB_STATUS_LOCK)) == (DVB_STATUS_SIGNAL|DVB_STATUS_CARRIER|DVB_STATUS_LOCK))
			break;
		snooze(25000);
	} while ((system_time() - start) < 5000000);


	if ((status & (DVB_STATUS_SIGNAL|DVB_STATUS_CARRIER|DVB_STATUS_LOCK)) != (DVB_STATUS_SIGNAL|DVB_STATUS_CARRIER|DVB_STATUS_LOCK)) {
		printf("DVB tuning failed! need these status flags: DVB_STATUS_SIGNAL, DVB_STATUS_CARRIER, DVB_STATUS_LOCK\n");
		return B_ERROR;
	}
	
	return B_OK;
}


status_t
DVBCard::GetTuningParameter(dvb_tuning_parameters_t *param)
{
	// XXX get from CARD
	*param = params;
	return B_OK;
}


status_t
DVBCard::GetSignalInfo(uint32 *ss, uint32 *ber, uint32 *snr)
{
	if (do_ioctl(fDev, DVB_GET_SS, ss) < 0) {
		printf("DVB_GET_SS failed with error %s\n", strerror(errno));
		return errno;
	}
	if (do_ioctl(fDev, DVB_GET_BER, ber) < 0) {
		printf("DVB_GET_BER failed with error %s\n", strerror(errno));
		return errno;
	}
	if (do_ioctl(fDev, DVB_GET_SNR, snr) < 0) {
		printf("DVB_GET_SNR failed with error %s\n", strerror(errno));
		return errno;
	}

	printf("ss %08lx, ber %08lx, snr %08lx\n", *ss, *ber, *snr);
	printf("ss %lu%%, ber %lu%%, snr %lu%%\n", *ss / (0xffffffff / 100), *ber / (0xffffffff / 100), *snr / (0xffffffff / 100));
	return B_OK;
}


status_t
DVBCard::CaptureStart()
{
	printf("DVBCard::CaptureStart\n");
	
	if (fCaptureActive) {
		printf("CaptureStart already called, doing nothing\n");
		return B_OK;
	}
	
	if (do_ioctl(fDev, DVB_START_CAPTURE, 0) < 0) {
		printf("DVB_START_CAPTURE failed with error %s\n", strerror(errno));
		return errno;
	}
	
	fCaptureActive = true;
	return B_OK;
}


status_t
DVBCard::CaptureStop()
{
	printf("DVBCard::CaptureStop\n");

	if (!fCaptureActive) {
		printf("CaptureStop already called, doing nothing\n");
		return B_OK;
	}

	if (do_ioctl(fDev, DVB_STOP_CAPTURE, 0) < 0) {
		printf("DVB_STOP_CAPTURE failed with error %s\n", strerror(errno));
		return errno;
	}

	fCaptureActive = false;
	return B_OK;
}


status_t
DVBCard::Capture(void **data, size_t *size, bigtime_t *end_time)
{
	dvb_capture_t cap;

	if (ioctl(fDev, DVB_CAPTURE, &cap) < 0) 
		return errno;

	*data	  = cap.data;
	*size	  = cap.size;
	*end_time = cap.end_time;

	return B_OK;
}


int
DVBCard::do_ioctl(int fDev, ulong op, void *arg)
{
	int res = 0; // silence stupid compiler warning
	int i;
	for (i = 0; i < 20; i++) {
		res = ioctl(fDev, op, arg);
		if (res >= 0)
			break;
	}
	if (i != 0)	printf("ioctl %lx repeated %d times\n", op, i);
	return res;
}