scan.c

linux dvb的文件

int test_bit (uint8_t *bitfield, int bit)
{
	return (bitfield[bit/8] >> (bit % 8)) & 1;
}

static
void set_bit (uint8_t *bitfield, int bit)
{
	bitfield[bit/8] |= 1 << (bit % 8);
}


/**
 *   returns 0 when more sections are expected
 *	   1 when all sections are read on this pid
 *	   -1 on invalid table id
 */
static
int parse_section (struct section_buf *s)
{
	const unsigned char *buf = s->buf;
	int table_id;
	int section_length;
	int id;
	int section_version_number;
	int section_number;
	int last_section_number;
	int i, j;

	table_id = buf[0];

	for (i=0; i<3; i++)
		if (s->table_id[i] == table_id)
			break;

	if (i > 2)
		return -1;

	section_length = (((buf[1] & 0x0f) << 8) | buf[2]) - 11;

	id = (buf[3] << 8) | buf[4];
	section_version_number = (buf[5] >> 1) & 0x1f;
	section_number = buf[6];
	last_section_number = buf[7];

	if (s->section_version_number[i] != section_version_number ||
	    s->id[i] != id)
	{
		s->id[i] = id;
		s->section_version_number[i] = section_version_number;
		s->start_section_number[i] = section_number;
		s->sectionfilter_done[i] = 0;
		memset (s->section_done[i], 0, sizeof(s->section_done[i]));
	}

	buf += 8;

//	if (!test_bit(s->section_done[i], section_number)) {
	{			
		set_bit (s->section_done[i], section_number);

		MSG("pid 0x%02x tid 0x%02x id 0x%04x, "
		    "%i/%i (version %i, start %i)",
		    s->pid, table_id, id, section_number,
		    last_section_number, section_version_number,
		    s->start_section_number[i]);

		switch (table_id) {
		case 0x00:
			parse_pat (buf, section_length, id);
			break;

		case 0x02:
			parse_pmt (buf, section_length, id);
			break;

		case 0x40:
		case 0x41:
			MSG("NIT (%s TS)\n", table_id == 0x40 ? "actual":"other");
			parse_nit (buf, section_length, id);
			break;

		case 0x42:
		case 0x46:
			MSG("SDT (%s TS)\n", table_id == 0x42 ? "actual":"other");
			parse_sdt (buf, section_length, id);
			break;

		default:
			;
		};

		for (j=0; j<=last_section_number; j++)
			if (test_bit (s->section_done[i], section_number) == 0)
				break;

		if (j > last_section_number)
			s->sectionfilter_done[i] = 1;
	}

	if (s->sectionfilter_done[0] &&
	    s->sectionfilter_done[1] &&
	    s->sectionfilter_done[2])
		return 1;

	return 0;
}


static
int read_sections (struct section_buf *s)
{
	int section_length, count;

	if (s->sectionfilter_done[0] &&
	    s->sectionfilter_done[1] &&
	    s->sectionfilter_done[2])
		return 1;

	if ((count = read (s->fd, s->buf, 1024 - s->bytes_in_buf)) < 0)
		if ((count = read (s->fd, s->buf, 1024 - s->bytes_in_buf)) < 0)
			return -1;

	s->bytes_in_buf += count;

	if (s->bytes_in_buf >= 1024)
		s->bytes_in_buf = 0;

	if (s->bytes_in_buf < 4)
		return -1;

	section_length = ((s->buf[1] & 0x0f) << 8) | s->buf[2];

	if (s->bytes_in_buf > section_length + 3)
		s->bytes_in_buf = 0;

	if (section_length == s->bytes_in_buf - 3)
		if (parse_section (s) == 1)
			return 1;

	return 0;
}


static LIST_HEAD(running_filters);
static LIST_HEAD(waiting_filters);


static
void setup_filter (struct section_buf* s, const char *dmx_devname,
		   int pid, int tid0, int tid1, int tid2,
		   int run_once, int timeout)
{
	int i;

	memset (s, 0, sizeof(struct section_buf));

	s->dmx_devname = dmx_devname;
	s->pid = pid;
	s->table_id[0] = tid0;
	s->table_id[1] = tid1;
	s->table_id[2] = tid2;

	s->run_once = run_once;
	s->timeout = timeout;

	for (i=0; i<3; i++) {
		s->id[i] = -1;
		s->section_version_number[i] = -1;
		s->start_section_number[i] = -1;
	}

	memset (s->section_done, 0, sizeof(s->section_done));

	INIT_LIST_HEAD (&s->list_head);
}


static
int start_filter (struct section_buf* s)
{
	struct dmx_sct_filter_params f;
	int i;

	s->bytes_in_buf = 0;

	if ((s->fd = open (s->dmx_devname, O_RDWR | O_NONBLOCK)) < 0)
		goto err0;

	MSG("start filter pid 0x%04x\n", s->pid);

	memset(&f, 0, sizeof(struct dmx_sct_filter_params));

	f.pid = (uint16_t) s->pid;

	if (s->table_id[1] == -1 && s->table_id[2] == -1 &&
	    s->table_id[0] < 0x100 && s->table_id[0] > 0)
	{
       		f.filter.filter[0] = (uint8_t) s->table_id[0];
	       	f.filter.mask[0]   = 0xff;
	}

	for (i=0; i<3; i++)
		if (s->table_id[i] == -1)
			s->sectionfilter_done[i] = 1;
		else
			s->sectionfilter_done[i] = 0;

	f.timeout = 0;
	f.flags = DMX_IMMEDIATE_START | DMX_CHECK_CRC;

	if (ioctl(s->fd, DMX_SET_FILTER, &f) == -1) {
		PERROR ("ioctl DMX_SET_FILTER failed");
		goto err1;
	}

	time (&s->start_time);

	list_del_init (&s->list_head);  /* might be in waiting filter list */
	list_add (&s->list_head, &running_filters);

	return 0;

err1:
	ioctl (s->fd, DMX_STOP);
	close (s->fd);
err0:
	return -1;
}


static
void stop_filter (struct section_buf *s)
{
	ioctl (s->fd, DMX_STOP);
	close (s->fd);
	list_del (&s->list_head);
	s->running_time += time(NULL) - s->start_time;
}


void add_filter (struct section_buf *s)
{
	MSG("add filter pid 0x%04x\n", s->pid);
	if (start_filter (s))
		list_add_tail (&s->list_head, &waiting_filters);
}


void remove_filter (struct section_buf *s)
{
	stop_filter (s);

	while (!list_empty(&waiting_filters)) {
		struct list_head *next = waiting_filters.next;
		s = list_entry (next, struct section_buf, list_head);
		if (start_filter (s))
			break;
	};
}


void reschedule_filter (struct section_buf *s)
{
	remove_filter (s);
	add_filter (s);
}


void read_filters (void)
{
	struct list_head *p, *n;

	list_for_each_safe (p, n, &running_filters) {
		struct section_buf *s;
		int done;

		s = list_entry (p, struct section_buf, list_head);

		done = read_sections (s) == 1;

		if (done || time(NULL) > s->start_time + s->timeout) {
			if (s->run_once) {
				if (done)
					MSG("filter done pid 0x%04x\n", s->pid);
				else
					MSG("filter timeout pid 0x%04x\n", s->pid);
				remove_filter (s);
			} else
				reschedule_filter(s);
		}
	}
}


static
int mem_is_zero (const void *mem, int size)
{
	const char *p = mem;

	while (size) {
		if (*p != 0x00)
			return 0;
		p++;
	}

	return 1;
}


#define SWITCHFREQ 11700000
#define LOF_HI     10600000
#define LOF_LO      9750000

static int switch_pos = 0;

static
int __tune_to_transponder (int frontend_fd, struct transponder *t)
{
	struct dvb_frontend_parameters p;
	int i;

	if (mem_is_zero (&t->param, sizeof(struct dvb_frontend_parameters)))
		return -1;

	memcpy (&p, &t->param, sizeof(struct dvb_frontend_parameters));

	MSG(">>> tune to: ");
	dump_dvb_parameters (stderr, t->type, &p);
	if (t->scan_done)
		fprintf (stderr, " (done)");
	if (t->last_tuning_failed)
		fprintf (stderr, " (tuning failed)");
	MSG("\n");

	if (t->type == FE_QPSK) {
		int hiband = (p.frequency >= SWITCHFREQ);

		setup_switch (frontend_fd,
			      switch_pos,
			      t->polarisation == POLARISATION_VERTICAL ? 0 : 1,
			      hiband);
		if (hiband)
			p.frequency -= LOF_HI;
		else
			p.frequency -= LOF_LO;
	}

	ioctl(frontend_fd, FE_SET_FRONTEND, &p);

	for (i=0; i<3; i++) {
		fe_status_t s;

		ioctl(frontend_fd, FE_READ_STATUS, &s);

		MSG(">>> tuning status == 0x%02x!!!", s);

		if (s & FE_HAS_LOCK) {
			t->last_tuning_failed = 0;
			return 0;
		}

		usleep (500000);
	}

	MSG(">>> tuning failed!!!\n");

	t->last_tuning_failed = 1;

	return -1;
}

static
int tune_to_transponder (int frontend_fd, struct transponder *t)
{
	if (__tune_to_transponder (frontend_fd, t) == 0)
		return 0;

	return __tune_to_transponder (frontend_fd, t);
}


#include "initial.h"

static
int tune_initial (int frontend_fd)
{
	struct dvb_frontend_info fe_info;
	struct transponder *initial_list;
	int list_size;
	static int index = 0;

	ioctl(frontend_fd, FE_GET_INFO, &fe_info);

	switch (fe_info.type) {
	case FE_QPSK:
		initial_list = qpsk_probes;
		list_size = sizeof(qpsk_probes)/sizeof(struct transponder);
		break;
	case FE_QAM:
		initial_list = qam_probes;
		list_size = sizeof(qam_probes)/sizeof(struct transponder);
		break;
	case FE_OFDM:
		initial_list = ofdm_probes;
		list_size = sizeof(ofdm_probes)/sizeof(struct transponder);
		break;
	default:
		WARN("FE_GET_INFO returned unknown frontend type!");
		return -1;
	};

	while (index < list_size) {
		struct transponder *t = &initial_list[index];

		if (tune_to_transponder (frontend_fd, t) == 0)
			return 0;

		index++;
	}

	index = 0;

	return -1;
}


static
int tune_to_next_transponder (int frontend_fd)
{
	struct transponder *t;
	int ret;
	int i=0;

	while (1) {
		if (!(t = find_nth_entry (&transponder_list, i)))
			return -1;
		if (!(t->scan_done || t->last_tuning_failed))
			break;
		i++;
	};

	t->scan_done = 1;

	ret = tune_to_transponder (frontend_fd, t);

	if (ret == 0)
		return 0;

	return tune_to_next_transponder (frontend_fd);
}



static
void scan_tp (const char *demux_devname)
{
	struct section_buf s0;
	struct section_buf s1;
	struct section_buf s2;
	int i;

	/**
	 *  filter timeouts > min repetition rates specified in ETR211
	 */
	setup_filter (&s0, demux_devname, 0x00, 0x00, -1, -1, 1, 5);
	setup_filter (&s1, demux_devname, 0x10, 0x40, -1, -1, 1, 15);
	setup_filter (&s2, demux_devname, 0x11, 0x42, -1, -1, 1, 5);

	add_filter (&s0);
	add_filter (&s1);
	add_filter (&s2);

	do {
		read_filters ();

		for (i=0; i<service_list.count; i++) {
			struct service *s;

			s = find_nth_entry (&service_list, i);

			if (!s->priv && s->pmt_pid) {
				s->priv = malloc(sizeof(struct section_buf));
				setup_filter(s->priv,
					     "/dev/dvb/adapter0/demux0",
					     s->pmt_pid, 0x02,
					     -1, -1, 1, 5);

				add_filter (s->priv);
			}
		}
	} while (!(list_empty(&running_filters) &&
		   list_empty(&waiting_filters)));
}

static
void scan_network (const char *frontend_devname, const char *demux_devname)
{
	int frontend_fd;

	MSG ("using '%s' and '%s'\n", frontend_devname, demux_devname);

	if ((frontend_fd = open (frontend_devname, O_RDWR)) < 0)
		PERROR("failed opening '%s'", frontend_devname);

	if (tune_initial (frontend_fd) < 0) {
		MSG("initial tuning failed!");
		return;
	}

	do {
		scan_tp(demux_devname);
	} while (tune_to_next_transponder(frontend_fd) == 0);

	close (frontend_fd);
}


static
void dump_lists (void)
{
	int i;

	for (i=0; i<service_list.count; i++) {
		struct service *s = find_nth_entry (&service_list, i);
		struct transponder *t;
		struct network *n;

		t = find_entry_by_id (&transponder_list, -1,
				      s->transport_stream_id);

		if (t) {
			n = find_entry_by_id (&network_list, -1,
					      t->network_id);

			dump_service_parameter_set (stdout,
						    s->service_name,
						    t->type,
						    &t->param,
						    s->video_pid,
						    s->audio_pid);
		}
	}
}


static const char *usage = "\nusage: %s [-c] [-a adapter_num] [-f frontend_id] [-d demux_id] [-s switch_pos]\n\t-c\tscan on currently tuned transponder only\n\n";


int main (int argc, char **argv)
{
	char frontend_devname [80];
	char demux_devname [80];
	int adapter = 0, frontend = 0, demux = 0;
	int opt, current_tp_only = 0;

	while ((opt = getopt(argc, argv, "ca:f:d:s:")) != -1) {
		switch (opt) {
		case 'a':
			adapter = strtoul(optarg, NULL, 0);
			break;
		case 'f':
			frontend = strtoul(optarg, NULL, 0);
			break;
		case 'd':
			demux = strtoul(optarg, NULL, 0);
			break;
		case 's':
			switch_pos = strtoul(optarg, NULL, 0);
			break;
		case 'c':
			current_tp_only = 1;
			break;
		default:
			fprintf (stderr, usage, argv[0]);
			return -1;
		};
	}

	if (switch_pos >= 4) {
		fprintf (stderr, "switch position needs to be < 4!\n");
		return -1;
	}

	snprintf (frontend_devname, sizeof(frontend_devname),
		  "/dev/dvb/adapter%i/frontend%i", adapter, frontend);

	snprintf (demux_devname, sizeof(demux_devname),
		  "/dev/dvb/adapter%i/demux%i", adapter, demux);

	if (current_tp_only)
		scan_tp (demux_devname);
	else
		scan_network (frontend_devname, demux_devname);

	dump_lists ();

	return 0;
}