Tvheadend

#include <stdio.h>

#include <fcntl.h>

#include <memory.h>

#include <time.h>

#include <stdint.h>

#include <sys/ioctl.h>

#include <linux/dvb/frontend.h>

#include <linux/dvb/dmx.h>

#define LOWVAL 9750000

#define HIGHVAL 10600000

#define SWITCHVAL 11700000

#define BUFSIZE 4096

struct adapter_struct {

	const char *fe_name;

	const char *dvr_name;

	const char *dmx_name;

	int fe_fd;

	int dvr_fd;

	int dmx_fd;

	unsigned char buffer[BUFSIZE];

	unsigned long byte_counter;

};

struct adapter_struct adapter[2] = {

	{

		.fe_name = "/dev/dvb/adapter0/frontend0",

		.dvr_name = "/dev/dvb/adapter0/dvr0",

		.dmx_name = "/dev/dvb/adapter0/demux0"

	},

	{

		.fe_name = "/dev/dvb/adapter1/frontend0",

		.dvr_name = "/dev/dvb/adapter1/dvr0",

		.dmx_name = "/dev/dvb/adapter1/demux0"

	}

};

struct channel_struct {

	const unsigned int frontend;

	const unsigned int demux;

	const unsigned int sat_no;

	const unsigned int freq;

	const unsigned int pol;

	const unsigned int sr;

	const unsigned int vpid;

	const unsigned int apid;

	const int sid;

	const unsigned int delivery;

	const int modulation;

	const int fec;

	const int rolloff;

};

const struct channel_struct svt1_hd = {

	.frontend = 0,

	.demux = 0,

	.sat_no = 1,

	.freq = 10903000,

	.pol = 1,

	.sr = 25000000,

	.vpid = 512,

	.apid = 640,

	.sid = 1406,

	.delivery = 6,

	.modulation = 0,

	.fec = 9,

	.rolloff = 0,

};

const struct channel_struct viasat_hockey = {

	.frontend = 0,

	.demux = 0,

	.sat_no = 0,

	.freq = 11977000,

	.pol = 1,

	.sr = 27500000,

	.vpid = 2141,

	.apid = 2142,

	.sid = 2140,

	.delivery = 5,

	.modulation = 0,

	.fec = 9,

	.rolloff = 0,

};

const struct channel_struct *channel[3] = {

	&svt1_hd,

	&viasat_hockey

};

struct diseqc_cmd {

	struct dvb_diseqc_master_cmd cmd;

	uint32_t wait;

};

void diseqc_send_msg(int fd, fe_sec_voltage_t v, struct diseqc_cmd *cmd,

		     fe_sec_tone_mode_t t, fe_sec_mini_cmd_t b)

{

	if (ioctl(fd, FE_SET_TONE, SEC_TONE_OFF) == -1)

		perror("FE_SET_TONE failed");

	if (ioctl(fd, FE_SET_VOLTAGE, v) == -1)

		perror("FE_SET_VOLTAGE failed");

		usleep(15 * 1000);

	if (ioctl(fd, FE_DISEQC_SEND_MASTER_CMD, &cmd->cmd) == -1)

		perror("FE_DISEQC_SEND_MASTER_CMD failed");

		usleep(cmd->wait * 1000);

		usleep(15 * 1000);

	if (ioctl(fd, FE_DISEQC_SEND_BURST, b) == -1)

		perror("FE_DISEQC_SEND_BURST failed");

		usleep(15 * 1000);

	if (ioctl(fd, FE_SET_TONE, t) == -1)

		perror("FE_SET_TONE failed");

}

/* digital satellite equipment control,

 * specification is available from http://www.eutelsat.com/

 */

int diseqc(int secfd, int sat_no, int pol_vert, int hi_band)

{

	struct diseqc_cmd cmd =

		{ {{0xe0, 0x10, 0x38, 0xf0, 0x00, 0x00}, 4}, 0 };

	/**

	 * param: high nibble: reset bits, low nibble set bits,

	 * bits are: option, position, polarizaion, band

	 */

	cmd.cmd.msg[3] =

		0xf0 | (((sat_no * 4) & 0x0f) | (hi_band ? 1 : 0) | (pol_vert ? 0 : 2));

	diseqc_send_msg(secfd, pol_vert ? SEC_VOLTAGE_13 : SEC_VOLTAGE_18,

			&cmd, hi_band ? SEC_TONE_ON : SEC_TONE_OFF,

			(sat_no / 4) % 2 ? SEC_MINI_B : SEC_MINI_A);

	return 1;	//TRUE

}

int do_tune(int fefd, unsigned int ifreq, unsigned int sr, enum fe_delivery_system delsys,

		   int modulation, int fec, int rolloff)

{

	struct dvb_frontend_event ev;

	struct dtv_property p[] = {

		{ .cmd = DTV_DELIVERY_SYSTEM,	.u.data = delsys },

		{ .cmd = DTV_FREQUENCY,		.u.data = ifreq },

		{ .cmd = DTV_MODULATION,	.u.data = modulation },

		{ .cmd = DTV_SYMBOL_RATE,	.u.data = sr },

		{ .cmd = DTV_INNER_FEC,		.u.data = fec },

		{ .cmd = DTV_INVERSION,		.u.data = INVERSION_AUTO },

		{ .cmd = DTV_ROLLOFF,		.u.data = rolloff },

		{ .cmd = DTV_PILOT,		.u.data = PILOT_AUTO },

		{ .cmd = DTV_TUNE },

	};

	struct dtv_properties cmdseq = {

		.num = 9,

		.props = p

	};

	/* discard stale QPSK events */

	while (1) {

		if (ioctl(fefd, FE_GET_EVENT, &ev) == -1)

		break;

	}

	if ((ioctl(fefd, FE_SET_PROPERTY, &cmdseq)) == -1) {

		perror("FE_SET_PROPERTY failed");

		return 0;	//FALSE

	}

	return 1;	//TRUE

}

void print_frontend_status(struct adapter_struct *a)

{

	fe_status_t status;

	uint16_t snr, signal;

	uint32_t ber, uncorrected_blocks;

	int timeout = 0;

	if (ioctl(a->fe_fd, FE_READ_STATUS, &status) == -1)

		perror("FE_READ_STATUS failed");

	if (ioctl(a->fe_fd, FE_READ_SIGNAL_STRENGTH, &signal) == -1)

		signal = -2;

	if (ioctl(a->fe_fd, FE_READ_SNR, &snr) == -1)

		snr = -2;

	if (ioctl(a->fe_fd, FE_READ_BER, &ber) == -1)

		ber = -2;

	if (ioctl(a->fe_fd, FE_READ_UNCORRECTED_BLOCKS, &uncorrected_blocks) == -1)

		uncorrected_blocks = -2;

	printf ("%02x | %3u%% | %3u%% | %5d | %4d",

		status, (signal * 100) / 0xffff, (snr * 100) / 0xffff, ber, uncorrected_blocks);

}

void print_status()

{

	printf("%12ld | ", adapter[0].byte_counter);

	print_frontend_status(&adapter[0]);

	printf("   |||   ");

	printf("%12ld | ", adapter[1].byte_counter);

	print_frontend_status(&adapter[1]);

	printf("\n");

}

void open_adapter_devices(struct adapter_struct *a)

{

	a->fe_fd = open(a->fe_name, O_RDWR | O_NONBLOCK, 0);

	a->dvr_fd = open(a->dvr_name, O_RDONLY | O_NONBLOCK, 0);

	a->dmx_fd = open(a->dmx_name, O_RDWR, 0);

	if (a->fe_fd < 0 || a->dvr_fd < 0 || a->dmx_fd < 0)

		printf("Error opening adapter device.\n");

}

void close_adapter_devices(const struct adapter_struct *a)

{

	close(a->fe_fd);

	close(a->dvr_fd);

	close(a->dmx_fd);

}

void setup_diseqc_switch(const struct adapter_struct *a, const struct channel_struct *ch)

{

	int hiband = 0;

	if (ch->freq >= SWITCHVAL) hiband = 1;

	diseqc(a->fe_fd, ch->sat_no, ch->pol, hiband);

}

void tune(const struct adapter_struct *a, const struct channel_struct *ch)

{

	struct dtv_property p[] = {

		{ .cmd = DTV_CLEAR },

	};

	struct dtv_properties cmdseq = {

		.num = 1,

		.props = p

	};

	int hiband = 0;

	uint32_t ifreq;

	if (ch->freq >= SWITCHVAL) hiband = 1;

	if (hiband)

		ifreq = ch->freq - HIGHVAL;

	else {

		if (ch->freq < LOWVAL)

			ifreq = LOWVAL - ch->freq;

		else

			ifreq = ch->freq - LOWVAL;

	}

	/* Tune */

	if (ioctl(a->fe_fd, FE_SET_PROPERTY, &cmdseq) == -1)

		perror("FE_SET_PROPERTY failed");

	do_tune(a->fe_fd, ifreq, ch->sr, ch->delivery, ch->modulation, ch->fec, ch->rolloff);

}	

void configure_demuxer(const struct adapter_struct *a)

{

	struct dmx_pes_filter_params dmx_param;

	memset(&dmx_param, 0, sizeof(dmx_param));

  dmx_param.pid = 0x2000;

  dmx_param.input = DMX_IN_FRONTEND;

  dmx_param.output = DMX_OUT_TS_TAP;

  dmx_param.pes_type = DMX_PES_OTHER;

  dmx_param.flags = DMX_IMMEDIATE_START;

	if (ioctl(a->dmx_fd, DMX_SET_PES_FILTER, &dmx_param) == -1)

		perror("DMX_SET_PES_FILTER failed");

}

void test_loop_5s(void)

{

	int t, last_t, c;

  time_t start_time;

	start_time = time(NULL);

	last_t = -1;

 	adapter[0].byte_counter = 0;	

 	adapter[1].byte_counter = 0;	

	while((t = (time(NULL) - start_time)) < 5) {

	  c = read(adapter[0].dvr_fd, adapter[0].buffer, BUFSIZE);

    if (c > 0)

     	adapter[0].byte_counter += c;	

	  c = read(adapter[1].dvr_fd, adapter[1].buffer, BUFSIZE);

    if (c > 0)

     	adapter[1].byte_counter += c;	

		if (t > last_t) {

			print_status();

			last_t = t;			

		}

  }

  printf("adapter0: ");

  if (adapter[0].byte_counter == 0)

  	printf("FAIL    ");

  else

  	printf("OK      ");

  printf("adapter1: ");

  if (adapter[1].byte_counter == 0)

  	printf("FAIL    ");

  else

  	printf("OK      ");

  printf("\n");

}

int main()

{

	int i, s;

	for (i = 0; i < 6; i++) {

		s = i % 2;

		printf("Iteration: %d, sleep(%d)\n", i, s);

		open_adapter_devices(&adapter[0]);	

		sleep(s);	// Apparently sleep is required here

		open_adapter_devices(&adapter[1]);	

		/* First adapter  */

		setup_diseqc_switch(&adapter[0], channel[0]);

		tune(&adapter[0], channel[0]);

		configure_demuxer(&adapter[0]);

		/* Second adapter  */

		setup_diseqc_switch(&adapter[1], channel[1]);

		tune(&adapter[1], channel[1]);

		configure_demuxer(&adapter[1]);

		test_loop_5s();

		close_adapter_devices(&adapter[0]);

		close_adapter_devices(&adapter[1]);

	}

	return 0;	

}