Use standart section parsers and generators for TDT/TOT

Makefile

 	tsfuncs_nit.o tsfuncs_nit_desc.o \
 	tsfuncs_sdt.o tsfuncs_sdt_desc.o \
 	tsfuncs_eit.o tsfuncs_eit_desc.o \
-	tsfuncs_tdt.o \
+	tsfuncs_tdt.o tsfuncs_tdt_desc.o \
 	tsfuncs_pes.o tsfuncs_pes_data.o \
 	tsfuncs_pes_es.o
 PROG = libts.a

tsdata.h

 
 struct ts_tdt {
 	struct ts_header			ts_header;
-
-	uint8_t		pointer_field;
-
-	uint8_t		table_id;
-
-	uint16_t	section_syntax_indicator: 1,	// Section Syntax Indicator
-				reserved_1              : 1,	// 1 reserved bit
-				reserved_2              : 2,	// 2 reserved bits
-				section_length          : 12;	// Section lenth
+	struct ts_section_header	*section_header;
 
 	uint16_t	mjd;							// This both are part of one 40 bit field (UTC_time)
 	uint32_t	bcd;							// Only 24 bits are used
 	uint16_t	reserved_3				: 4,
 				descriptors_size        : 12;
 	uint8_t		*descriptors;
-	uint32_t	CRC;
 
 	// The variables bellow are nor part of the physical packet
-	uint8_t		*packet_data;
 	time_t		utc;	// decoded UTC_time
 	struct tm	tm;		// decoded UTC_time
 

tsfuncs.h

 int				ts_eit_add_extended_event_descriptor(struct ts_eit *eit, uint16_t event_id, uint8_t running, time_t start_time, int duration_sec, char *text);
 
 // TDT
+struct ts_tdt *	ts_tdt_alloc();
 struct ts_tdt *	ts_tdt_alloc_init	(time_t ts);
 struct ts_tdt *	ts_tot_alloc_init	(time_t ts);
 void			ts_tdt_free			(struct ts_tdt **tdt);
 
-int				ts_tdt_parse		(struct ts_tdt *tdt, uint8_t *ts_packet);
-void			ts_tdt_generate		(struct ts_tdt *tdt, uint8_t *ts_packet);
+int				ts_tdt_parse		(struct ts_tdt *tdt);
+struct ts_tdt *	ts_tdt_push_packet	(struct ts_tdt *tdt, uint8_t *ts_packet);
+void			ts_tdt_generate		(struct ts_tdt *tdt, uint8_t **ts_packets, int *num_packets);
 void			ts_tdt_dump			(struct ts_tdt *tdt);
 
 void			ts_tdt_set_time		(struct ts_tdt *tdt, time_t ts);
 
 void			ts_tot_set_localtime_offset			(struct ts_tdt *tdt, time_t now, time_t change_time, uint8_t polarity, uint16_t ofs, uint16_t ofs_next);
-void			ts_tot_set_localtime_offset_sofia	(struct ts_tdt *tdt);
+void			ts_tot_set_localtime_offset_sofia	(struct ts_tdt *tdt, time_t now);
 
 // Time
 uint32_t		ts_time_encode_bcd	(int duration_sec);

tsfuncs_tdt.c

 
 struct ts_tdt *ts_tdt_alloc() {
 	struct ts_tdt *tdt = calloc(1, sizeof(struct ts_tdt));
-	tdt->packet_data = malloc(TS_PACKET_SIZE);
-	memset(tdt->packet_data, 0x32, TS_PACKET_SIZE);
+	tdt->section_header	= ts_section_data_alloc();
 	return tdt;
 }
 
 void ts_tdt_free(struct ts_tdt **ptdt) {
 	struct ts_tdt *tdt = *ptdt;
 	if (tdt) {
-		FREE(tdt->packet_data);
+		ts_section_data_free(&tdt->section_header);
 		FREE(tdt->descriptors);
 		FREE(*ptdt);
 	}
 }
 
-static void ts_tdt_init_empty(struct ts_tdt *tdt, time_t ts, int tot) {
-	tdt->ts_header.pid            = 0x14;
-	tdt->ts_header.pusi           = 1;
-	tdt->ts_header.payload_field  = 1;
-	tdt->ts_header.payload_offset = 4;
-	tdt->ts_header.continuity     = 7;
-
-	tdt->table_id                 = 0x70;
-	tdt->section_syntax_indicator = 0;
-	tdt->reserved_1               = 1;
-	tdt->reserved_2               = 3;
-	tdt->section_length           = 5;
-
-	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &ts, NULL);
+static struct ts_tdt *ts_tdt_reset(struct ts_tdt *tdt) {
+	struct ts_tdt *newtdt = ts_tdt_alloc();
+	ts_tdt_free(&tdt);
+	return newtdt;
+}
+
+struct ts_tdt *ts_tdt_push_packet(struct ts_tdt *tdt, uint8_t *ts_packet) {
+	struct ts_header ts_header;
+	memset(&ts_header, 0, sizeof(struct ts_header));
+
+	if (ts_packet_header_parse(ts_packet, &ts_header)) {
+		// TDT/TOT should be with PID 0x11
+		if (ts_header.pid != 0x14)
+			goto OUT;
+		if (!tdt->ts_header.pusi)
+			tdt->ts_header = ts_header;
+	}
+
+	if (ts_header.pusi) {
+		struct ts_section_header section_header;
+		memset(&section_header, 0, sizeof(struct ts_section_header));
+
+		uint8_t *section_data = ts_section_header_parse(ts_packet, &tdt->ts_header, &section_header);
+		if (!section_data) {
+			memset(&tdt->ts_header, 0, sizeof(struct ts_header));
+			goto OUT;
+		}
+		//    table_id should be 0x70 (time_date_section)
+		// or table_id should be 0x73 (time_offset_section)
+		if (section_header.table_id != 0x70 && section_header.table_id != 0x73) {
+			memset(&tdt->ts_header, 0, sizeof(struct ts_header));
+			goto OUT;
+		}
+
+		// Set correct section_header
+		ts_section_header_parse(ts_packet, &tdt->ts_header, tdt->section_header);
+	}
+
+	if (!tdt->initialized) {
+		ts_section_add_packet(tdt->section_header, &ts_header, ts_packet);
+		if (tdt->section_header->initialized) {
+			if (!ts_tdt_parse(tdt))
+				goto ERROR;
+		}
+	}
+
+OUT:
+	return tdt;
+
+ERROR:
+	return ts_tdt_reset(tdt);
+}
+
+int ts_tdt_parse(struct ts_tdt *tdt) {
+	struct ts_section_header *sec = tdt->section_header;
+	uint8_t *data = sec->data;
+
+	tdt->mjd = (data[0] << 8) | data[1];
+	tdt->bcd = ((data[2] << 16) | (data[3] << 8)) | data[4];
+	data += 5;
+
 	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
 
-	if (tot) {
-		tdt->table_id            = 0x73;
-		tdt->reserved_3          = 0xf;
-		tdt->descriptors_size    = 0;
-		tdt->CRC                 = 0;
-		tdt->section_length     += 2 + 4;	// 2 bytes reserved+descripts_size
-	}
-
-	ts_tdt_generate(tdt, tdt->packet_data);
-
-	tdt->initialized = 1;
-}
-
-struct ts_tdt *ts_tdt_alloc_init(time_t ts) {
-	struct ts_tdt *tdt = ts_tdt_alloc();
-	ts_tdt_init_empty(tdt, ts, 0);
-	return tdt;
-}
-
-struct ts_tdt *ts_tot_alloc_init(time_t ts) {
-	struct ts_tdt *tdt = ts_tdt_alloc();
-	ts_tdt_init_empty(tdt, ts, 1);
-	return tdt;
-}
-
-static void ts_tdt_check_generator(struct ts_tdt *tdt) {
-	struct ts_tdt *tdt1 = ts_tdt_alloc();
-	ts_tdt_parse(tdt1, tdt->packet_data);
-	ts_compare_data("TDT/TOT (packet->data)", tdt1->packet_data, tdt->packet_data, TS_PACKET_SIZE);
-	ts_tdt_free(&tdt1);
-
-	uint8_t *tmp = malloc(TS_PACKET_SIZE);
-	ts_tdt_generate(tdt, tmp);
-	ts_compare_data("TDT/TOT (data->packet)", tdt->packet_data, tmp, TS_PACKET_SIZE);
-	free(tmp);
-}
-
-int ts_tdt_parse(struct ts_tdt *tdt, uint8_t *ts_packet) {
-	uint8_t *data = ts_packet_header_parse(ts_packet, &tdt->ts_header);
-
-	if (!data)
-		return 0;
-
-	if (tdt->ts_header.pid != 0x14) // TOT/TDT
-		return 0;
-
-	tdt->pointer_field = data[0];
-	data += tdt->pointer_field + 1;
-
-	if ((data + 8) - ts_packet > TS_PACKET_SIZE) {
-		ts_LOGf("!!! Section start outside of TS packet!\n");
-		return 0;
-	}
-
-	if (data[0] != 0x70 && data[0] != 0x73) { // TDT or TOT
-		ts_LOGf("Invalid TDT/TOT Table_ID 0x%02x\n", data[0]);
-		return 0;
-	}
-
-	tdt->table_id                 = data[0];
-	tdt->section_syntax_indicator = data[1] >> 7;			// x1111111
-	tdt->reserved_1               = (data[1] &~ 0xBF) >> 6;	// 1x111111
-	tdt->reserved_2               = (data[1] &~ 0xCF) >> 4;	// 11xx1111
-	tdt->section_length           = ((data[1] &~ 0xF0) << 8) | data[2]; // 1111xxxx xxxxxxxx
-	if (tdt->section_length > TS_MAX_PAYLOAD_SIZE - 8) {
-		ts_LOGf("TDT/TOT section length is too big: %d (max: %d)\n", tdt->section_length, TS_MAX_PAYLOAD_SIZE - 8);
-		return 0;
-	}
-
-	tdt->mjd       = (data[3] << 8) | data[4];
-	tdt->bcd       = ((data[5] << 16) | (data[6] << 8)) | data[7];
-
-	if (tdt->table_id == 0x73) { // TOT
-		tdt->reserved_3        = data[8] >> 4;		// xxxx1111
-		tdt->descriptors_size  = data[8] &~ 0xf0;	// 1111xxxx
-		tdt->descriptors_size |= data[9];			// xxxxxxxx
-		if (tdt->descriptors_size > TS_MAX_PAYLOAD_SIZE - 10) {
-			ts_LOGf("TDT/TOT descriptors_size is too big: %d (max: %d)\n", tdt->descriptors_size, TS_MAX_PAYLOAD_SIZE - 10);
-			return 0;
-		}
+	if (sec->table_id == 0x73) { // TOT
+		tdt->reserved_3        = data[0] >> 4;		// xxxx1111
+		tdt->descriptors_size  = data[0] &~ 0xf0;	// 1111xxxx
+		tdt->descriptors_size |= data[1];			// xxxxxxxx
+		data += 2;
 		if (tdt->descriptors_size) {
 			tdt->descriptors = malloc(tdt->descriptors_size);
-			memcpy(tdt->descriptors, &data[10], tdt->descriptors_size);
+			memcpy(tdt->descriptors, data, tdt->descriptors_size);
 		}
-		tdt->CRC = (tdt->CRC << 8) | data[10 + tdt->descriptors_size + 3];
-		tdt->CRC = (tdt->CRC << 8) | data[10 + tdt->descriptors_size + 2];
-		tdt->CRC = (tdt->CRC << 8) | data[10 + tdt->descriptors_size + 1];
-		tdt->CRC = (tdt->CRC << 8) | data[10 + tdt->descriptors_size + 0];
+		if (!ts_crc32_section_check(tdt->section_header, "TOT"))
+			return 0;
 	}
 
-	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
-
-	memcpy(tdt->packet_data, ts_packet, TS_PACKET_SIZE);
-
 	tdt->initialized = 1;
-
 	return 1;
 }
 
-void ts_tdt_generate(struct ts_tdt *tdt, uint8_t *ts_packet) {
-	ts_packet_header_generate(ts_packet, &tdt->ts_header);
+void ts_tdt_generate(struct ts_tdt *tdt, uint8_t **ts_packets, int *num_packets) {
+	uint8_t *secdata = ts_section_data_alloc_section();
+	ts_section_header_generate(secdata, tdt->section_header, 0);
+	int curpos = 3; // Compensate for the section header, first data byte is at offset 3
 
-	uint8_t start = 4;
-	ts_packet[start + 0]  = tdt->pointer_field;
-	start += tdt->pointer_field + 1;
+	secdata[curpos + 0]  = (tdt->mjd &~ 0x00ff) >> 8;
+	secdata[curpos + 1]  = (tdt->mjd &~ 0xff00);
 
-	ts_packet[start + 0]  = tdt->table_id;
-	ts_packet[start + 1]  = tdt->section_syntax_indicator << 7;		// x1111111
-	ts_packet[start + 1] |= tdt->reserved_1               << 6;		// 1x111111
-	ts_packet[start + 1] |= tdt->reserved_2               << 4;		// 11xx1111
-	ts_packet[start + 1] |= tdt->section_length           >> 8;		// 1111xxxx xxxxxxxx
-	ts_packet[start + 2]  = tdt->section_length           &~ 0xff00;	// 1111xxxx xxxxxxxx
+	secdata[curpos + 2]  = (tdt->bcd >> 16);
+	secdata[curpos + 3]  = (tdt->bcd >> 8) &~ 0xff00;
+	secdata[curpos + 4]  = (tdt->bcd << 16) >> 16;
+	curpos += 5; // For the fields above
 
-	ts_packet[start + 3]  = (tdt->mjd &~ 0x00ff) >> 8;
-	ts_packet[start + 4]  = (tdt->mjd &~ 0xff00);
+	if (tdt->section_header->table_id == 0x73) { // TOT
+		secdata[curpos + 0]  = tdt->reserved_3 << 4;
+		secdata[curpos + 0] |= tdt->descriptors_size >> 8;
+		secdata[curpos + 1]  = tdt->descriptors_size &~ 0xf00;
+		curpos += 2;
 
-	ts_packet[start + 5]  = (tdt->bcd >> 16);
-	ts_packet[start + 6]  = (tdt->bcd >> 8) &~ 0xff00;
-	ts_packet[start + 7]  = (tdt->bcd << 16) >> 16;
-
-	if (tdt->table_id == 0x73) { // TOT
-		ts_packet[start + 8]  = tdt->reserved_3 << 4;
-		ts_packet[start + 8] |= tdt->descriptors_size >> 8;
-		ts_packet[start + 9]  = tdt->descriptors_size &~ 0xf00;
-		if (tdt->descriptors_size) {
-			memcpy(&ts_packet[start + 10], tdt->descriptors, tdt->descriptors_size);
+		if (tdt->descriptors_size > 0) {
+			memcpy(secdata + curpos, tdt->descriptors, tdt->descriptors_size);
+			curpos += tdt->descriptors_size;
 		}
-		tdt->CRC = ts_section_data_calculate_crc(ts_packet + start, 10 + tdt->descriptors_size);
+
+		tdt->section_header->CRC = ts_section_data_calculate_crc(secdata, curpos);
+	    curpos += 4; // CRC
 	}
+
+    ts_section_data_gen_ts_packets(&tdt->ts_header, secdata, curpos, tdt->section_header->pointer_field, ts_packets, num_packets);
+
+    FREE(secdata);
+}
+
+void ts_tdt_check_generator(struct ts_tdt *tdt) {
+	struct ts_tdt *tdt1 = ts_tdt_alloc();
+	int i;
+
+	char *prefix1 = "TDT (tspacket->struct)";
+	char *prefix2 = "TDT (struct->tspacket)";
+	if (tdt->section_header->table_id == 0x73) {
+		prefix1[1] = 'O';
+		prefix2[1] = 'O';
+	}
+
+	for (i=0;i<tdt->section_header->num_packets;i++) {
+		tdt1 = ts_tdt_push_packet(tdt1, tdt->section_header->packet_data + (i * TS_PACKET_SIZE));
+	}
+
+	ts_compare_data(prefix1, // "TDT (tspacket->struct)",
+		tdt1->section_header->packet_data,
+		tdt->section_header->packet_data,
+		tdt->section_header->num_packets * TS_PACKET_SIZE);
+	ts_tdt_free(&tdt1);
+
+	uint8_t *ts_packets;
+	int num_packets;
+	ts_tdt_generate(tdt, &ts_packets, &num_packets);
+	if (num_packets != tdt->section_header->num_packets) {
+		ts_LOGf("ERROR: num_packets:%d != sec->num_packets:%d\n", num_packets, tdt->section_header->num_packets);
+	}
+	ts_compare_data(prefix2 /* "TDT (struct->tspacket)" */, tdt->section_header->packet_data, ts_packets, num_packets * TS_PACKET_SIZE);
+
+	free(ts_packets);
 }
 
 void ts_tdt_dump(struct ts_tdt *tdt) {
+	struct ts_section_header *sec = tdt->section_header;
 	struct tm tm;
 	time_t ts;
 	uint16_t mjd_check;
 	uint32_t bcd_check;
-	char *prefix = tdt->table_id == 0x70 ? "TDT" : "TOT"; // TDT table_id == 0x70, TOT table_id == 0x73
+
+	ts_section_dump(sec);
 
 	ts = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tm);
 	ts_time_encode_mjd(&mjd_check, &bcd_check, &ts, &tm);
 
-	ts_LOGf("%s packet dump\n", prefix);
-	ts_packet_header_dump(&tdt->ts_header);
-	ts_LOGf("    - Table id           : %03x (%d) %s\n", tdt->table_id, tdt->table_id, prefix);
-	ts_LOGf("    - Section length     : %03x (%d)\n", tdt->section_length, tdt->section_length);
-	ts_LOGf("  * %s data\n", prefix);
+	ts_LOGf("  * %s data\n", sec->table_id == 0x70 ? "TDT" : "TOT");
 	ts_LOGf("    - MJD                : 0x%04x   (%04d-%02d-%02d) unixts: %ld check:0x%04x\n",
 		tdt->mjd,
 		tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
 		tdt->bcd,
 		tm.tm_hour, tm.tm_min, tm.tm_sec,
 		bcd_check);
-	ts_LOGf("    - UTC Time           : %lu\n" , tdt->utc);
-	if (tdt->table_id == 0x73) { // TOT
-		if (tdt->descriptors) {
-			ts_descriptor_dump(tdt->descriptors, tdt->descriptors_size);
-		}
-		ts_LOGf("  * CRC 0x%04x\n", tdt->CRC);
+	ts_LOGf("    - UTC Time           : %lu (%04d-%02d-%02d %02d:%02d:%02d)\n" , tdt->utc,
+		tm.tm_year+1900, tm.tm_mon+1, tm.tm_mday,
+		tm.tm_hour, tm.tm_min, tm.tm_sec);
+	if (sec->table_id == 0x73 && tdt->descriptors_size) { // TOT
+		ts_descriptor_dump(tdt->descriptors, tdt->descriptors_size);
 	}
 
 	ts_tdt_check_generator(tdt);
 }
-
-void ts_tdt_set_time(struct ts_tdt *tdt, time_t now) {
-	tdt->ts_header.continuity++;
-	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &now, NULL);
-	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
-	ts_tdt_generate(tdt, tdt->packet_data);
-}
-
-void ts_tot_set_localtime_offset(struct ts_tdt *tdt, time_t now, time_t change_time, uint8_t polarity, uint16_t ofs, uint16_t ofs_next) {
-	if (tdt->table_id != 0x73)
-		return;
-	tdt->ts_header.continuity++;
-
-	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &now, NULL);
-	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
-
-	uint16_t mjd = 0;
-	uint32_t bcd = 0;
-	ts_time_encode_mjd(&mjd, &bcd, &change_time, NULL);
-
-	uint8_t *lto; // Local time offset
-	if (tdt->descriptors_size == 0) {
-		tdt->descriptors_size = 15;
-		tdt->descriptors = calloc(1, tdt->descriptors_size);
-		tdt->section_length += tdt->descriptors_size;
-	}
-	lto = tdt->descriptors;
-	lto[0     ]  = 0x58;		// Descriptor tag
-	lto[1     ]  = 13;			// 13 octets
-	lto[2 +  0]  = 'B';			// Country code
-	lto[2 +  1]  = 'U';
-	lto[2 +  2]  = 'L';
-	lto[2 +  3]  = 0;			// 111111xx (Country region,   6 bit)
-	lto[2 +  3] |= bit_2;		// xxxxxx1x (Reserved,         1 bit) !!!!
-	lto[2 +  3] |= polarity;	// xxxxxxx1 (Polarity,         1 bit, 0 +utc, 1 -utc) !!!!
-
-	lto[2 +  4]  = ofs >> 8;	// (LocalTime offset  16 bits, bcd)
-	lto[2 +  5]  = ofs &~ 0xff00;
-
-	lto[2 +  6]  = mjd >> 8;	// Time of change (40 bcd)
-	lto[2 +  7]  = mjd &~ 0xff00;
-	lto[2 +  8]  = bcd >> 16;
-	lto[2 +  9]  = bcd >> 8;
-	lto[2 + 10]  = bcd &~ 0xffff00;
-
-	lto[2 + 11]  = ofs_next >> 8; // Next time offset (16 bits, bcd)
-	lto[2 + 12]  = ofs_next &~ 0xff00;
-
-	ts_tdt_generate(tdt, tdt->packet_data);
-}
-
-// Calculate change time for European summer time, see:
-// http://en.wikipedia.org/wiki/European_Summer_Time
-static time_t euro_dst_start(int year) {
-	struct tm tm;
-	int dst_start_date;
-	memset(&tm, 0, sizeof(struct tm));
-	tm.tm_year = year - 1900;
-	tm.tm_mon  = 2; // March
-	tm.tm_mday = (31 - (5 * year / 4 + 4) % 7); // Sunday DST_START March   at 01:00 GMT
-	tm.tm_hour = 1;
-	dst_start_date = timegm(&tm);
-	//ts_LOGf("year: %d ts: %d dst_start: %s", year, dst_start_date, asctime(&tm));
-	return dst_start_date;
-}
-
-static time_t euro_dst_end(int year) {
-	struct tm tm;
-	int dst_end_date;
-	memset(&tm, 0, sizeof(struct tm));
-	tm.tm_year = year - 1900;
-	tm.tm_mon  = 9; // October
-	tm.tm_mday = (31 - (5 * year / 4 + 1) % 7); // Sunday DST_END   October at 01:00 GMT
-	tm.tm_hour = 1;
-	dst_end_date = timegm(&tm);
-	//ts_LOGf("year: %d ts: %d dst_end: %s", year, dst_end_date, asctime(&tm));
-	return dst_end_date;
-}
-
-void ts_tot_set_localtime_offset_sofia(struct ts_tdt *tdt) {
-	time_t   now = time(NULL);
-	uint8_t  polarity = 0;	// 0 == UTC + offset, 1 == UTC - offset
-	time_t   change_time;	// When the next DST change will be
-	uint16_t current_offset;
-	uint16_t next_offset;
-	struct tm tm;
-
-	gmtime_r(&now, &tm);
-	//ts_LOGf("nowts: %d now: %s", now, asctime(&tm));
-	int curyear  = tm.tm_year + 1900;
-	int dst_start_date = euro_dst_start(curyear);
-	int dst_end_date   = euro_dst_end(curyear);
-	if (now < dst_start_date) {
-		current_offset = 0x0200; // We are in winter time now
-		next_offset    = 0x0300; // Next is the summer
-		change_time    = dst_start_date;
-	} else {
-		if (now >= dst_start_date && now < dst_end_date) {
-			current_offset = 0x0300; // We are in summer time time
-			next_offset    = 0x0200; // Next time it should be winter
-			change_time    = dst_end_date;
-		} else {
-			current_offset = 0x0200; // We are in winter time
-			next_offset    = 0x0300; // Next time it should be summer
-			change_time    = euro_dst_start(curyear + 1);
-		}
-	}
-	//ts_LOGf("curofs: %04x next_ofs: %04x change_time:%d\n", current_offset, next_offset, change_time);
-	ts_tot_set_localtime_offset(tdt, time(NULL), change_time, polarity, current_offset, next_offset);
-}
-
-int parse_tdt(uint8_t *ts_packet, int dump) {
-	struct ts_tdt *tdt = ts_tdt_alloc();
-	int ret = ts_tdt_parse(tdt, ts_packet);
-	if (ret && dump)
-		ts_tdt_dump(tdt);
-	ts_tdt_free(&tdt);
-	return ret;
-}

tsfuncs_tdt_desc.c

+#include <stdio.h>
+#include <unistd.h>
+#include <netdb.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+
+#include "tsfuncs.h"
+
+static void ts_tdt_regenerate_packet_data(struct ts_tdt *tdt) {
+	uint8_t *ts_packets;
+	int num_packets;
+	ts_tdt_generate(tdt, &ts_packets, &num_packets);
+	memcpy(tdt->section_header->packet_data, ts_packets, num_packets * TS_PACKET_SIZE);
+	tdt->section_header->num_packets = num_packets;
+	free(ts_packets);
+}
+
+static struct ts_tdt *ts_tdt_init_empty(struct ts_tdt *tdt, time_t ts, int tot) {
+	tdt->ts_header.pid            = 0x14;
+	tdt->ts_header.pusi           = 1;
+	tdt->ts_header.payload_field  = 1;
+	tdt->ts_header.payload_offset = 4;
+
+	tdt->section_header->table_id                 = 0x70;
+	tdt->section_header->section_syntax_indicator = 0;
+	tdt->section_header->private_indicator        = 1;
+	tdt->section_header->reserved1                = 3;
+	tdt->section_header->section_length           = 5; // 5 bytes UTC_time
+
+	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &ts, NULL);
+	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
+
+	if (tot) {
+		tdt->section_header->table_id             = 0x73;
+		tdt->section_header->section_length       = 5 + 2 + 4;	// 5 bytes UTC_time, 2 bytes reserved & descripts_size, 4 bytes CRC
+		tdt->reserved_3           = 0xf;
+		tdt->descriptors_size     = 0;
+	}
+
+	tdt->initialized = 1;
+	ts_tdt_regenerate_packet_data(tdt);
+
+	return tdt;
+}
+
+struct ts_tdt *ts_tdt_alloc_init(time_t ts) {
+	return ts_tdt_init_empty(ts_tdt_alloc(), ts, 0);
+}
+
+struct ts_tdt *ts_tot_alloc_init(time_t ts) {
+	return ts_tdt_init_empty(ts_tdt_alloc(), ts, 1);
+}
+
+void ts_tdt_set_time(struct ts_tdt *tdt, time_t now) {
+	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &now, NULL);
+	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
+	ts_tdt_regenerate_packet_data(tdt);
+}
+
+void ts_tot_set_localtime_offset(struct ts_tdt *tdt, time_t now, time_t change_time, uint8_t polarity, uint16_t ofs, uint16_t ofs_next) {
+	if (tdt->section_header->table_id != 0x73)
+		return;
+
+	ts_time_encode_mjd(&tdt->mjd, &tdt->bcd, &now, NULL);
+	tdt->utc = ts_time_decode_mjd(tdt->mjd, tdt->bcd, &tdt->tm);
+
+	uint16_t mjd = 0;
+	uint32_t bcd = 0;
+	ts_time_encode_mjd(&mjd, &bcd, &change_time, NULL);
+
+	uint8_t *lto; // Local time offset
+	if (tdt->descriptors_size == 0) {
+		tdt->descriptors_size = 15;
+		tdt->descriptors = calloc(1, tdt->descriptors_size);
+		tdt->section_header->section_length += tdt->descriptors_size;
+	}
+	lto = tdt->descriptors;
+	lto[0     ]  = 0x58;		// Descriptor tag
+	lto[1     ]  = 13;			// 13 octets
+	lto[2 +  0]  = 'B';			// Country code
+	lto[2 +  1]  = 'U';
+	lto[2 +  2]  = 'L';
+	lto[2 +  3]  = 0;			// 111111xx (Country region,   6 bit)
+	lto[2 +  3] |= bit_2;		// xxxxxx1x (Reserved,         1 bit) !!!!
+	lto[2 +  3] |= polarity;	// xxxxxxx1 (Polarity,         1 bit, 0 +utc, 1 -utc) !!!!
+
+	lto[2 +  4]  = ofs >> 8;	// (LocalTime offset  16 bits, bcd)
+	lto[2 +  5]  = ofs &~ 0xff00;
+
+	lto[2 +  6]  = mjd >> 8;	// Time of change (40 bcd)
+	lto[2 +  7]  = mjd &~ 0xff00;
+	lto[2 +  8]  = bcd >> 16;
+	lto[2 +  9]  = bcd >> 8;
+	lto[2 + 10]  = bcd &~ 0xffff00;
+
+	lto[2 + 11]  = ofs_next >> 8; // Next time offset (16 bits, bcd)
+	lto[2 + 12]  = ofs_next &~ 0xff00;
+
+	ts_tdt_regenerate_packet_data(tdt);
+}
+
+// Calculate change time for European summer time, see:
+// http://en.wikipedia.org/wiki/European_Summer_Time
+static time_t euro_dst_start(int year) {
+	struct tm tm;
+	int dst_start_date;
+	memset(&tm, 0, sizeof(struct tm));
+	tm.tm_year = year - 1900;
+	tm.tm_mon  = 2; // March
+	tm.tm_mday = (31 - (5 * year / 4 + 4) % 7); // Sunday DST_START March   at 01:00 GMT
+	tm.tm_hour = 1;
+	dst_start_date = timegm(&tm);
+	//ts_LOGf("year: %d ts: %d dst_start: %s", year, dst_start_date, asctime(&tm));
+	return dst_start_date;
+}
+
+static time_t euro_dst_end(int year) {
+	struct tm tm;
+	int dst_end_date;
+	memset(&tm, 0, sizeof(struct tm));
+	tm.tm_year = year - 1900;
+	tm.tm_mon  = 9; // October
+	tm.tm_mday = (31 - (5 * year / 4 + 1) % 7); // Sunday DST_END   October at 01:00 GMT
+	tm.tm_hour = 1;
+	dst_end_date = timegm(&tm);
+	//ts_LOGf("year: %d ts: %d dst_end: %s", year, dst_end_date, asctime(&tm));
+	return dst_end_date;
+}
+
+void ts_tot_set_localtime_offset_sofia(struct ts_tdt *tdt, time_t now) {
+	uint8_t  polarity = 0;	// 0 == UTC + offset, 1 == UTC - offset
+	time_t   change_time;	// When the next DST change will be
+	uint16_t current_offset;
+	uint16_t next_offset;
+	struct tm tm;
+
+	gmtime_r(&now, &tm);
+	//ts_LOGf("nowts: %d now: %s", now, asctime(&tm));
+	int curyear  = tm.tm_year + 1900;
+	int dst_start_date = euro_dst_start(curyear);
+	int dst_end_date   = euro_dst_end(curyear);
+	if (now < dst_start_date) {
+		current_offset = 0x0200; // We are in winter time now
+		next_offset    = 0x0300; // Next is the summer
+		change_time    = dst_start_date;
+	} else {
+		if (now >= dst_start_date && now < dst_end_date) {
+			current_offset = 0x0300; // We are in summer time time
+			next_offset    = 0x0200; // Next time it should be winter
+			change_time    = dst_end_date;
+		} else {
+			current_offset = 0x0200; // We are in winter time
+			next_offset    = 0x0300; // Next time it should be summer
+			change_time    = euro_dst_start(curyear + 1);
+		}
+	}
+	//ts_LOGf("curofs: %04x next_ofs: %04x change_time:%d\n", current_offset, next_offset, change_time);
+	ts_tot_set_localtime_offset(tdt, now, change_time, polarity, current_offset, next_offset);
+}