Add ts_XXX_clear() functions for all objects

tsfuncs.h

 uint8_t *					ts_section_data_alloc_packet	();
 
 struct ts_section_header *	ts_section_data_alloc			();
+void						ts_section_data_clear			(struct ts_section_header *sec);
 void						ts_section_data_free			(struct ts_section_header **ts_section_header);
 
 void						ts_section_data_copy			(struct ts_section_header *src, struct ts_section_header *dst);
 struct ts_pat *	ts_pat_alloc		();
 struct ts_pat * ts_pat_alloc_init	(uint16_t transport_stream_id);
 struct ts_pat *	ts_pat_push_packet	(struct ts_pat *pat, uint8_t *ts_packet);
+void            ts_pat_clear		(struct ts_pat *pat);
 void            ts_pat_free			(struct ts_pat **pat);
 int				ts_pat_parse		(struct ts_pat *pat);
 void            ts_pat_dump			(struct ts_pat *pat);
 // CAT
 struct ts_cat *	ts_cat_alloc		();
 struct ts_cat *	ts_cat_push_packet	(struct ts_cat *cat, uint8_t *ts_packet);
+void            ts_cat_clear		(struct ts_cat *cat);
 void            ts_cat_free			(struct ts_cat **cat);
 int				ts_cat_parse		(struct ts_cat *cat);
 void            ts_cat_dump			(struct ts_cat *cat);
 struct ts_pmt *	ts_pmt_alloc		();
 struct ts_pmt * ts_pmt_alloc_init	(uint16_t org_network_id, uint16_t transport_stream_id);
 struct ts_pmt *	ts_pmt_push_packet	(struct ts_pmt *pmt, uint8_t *ts_packet);
+void            ts_pmt_clear		(struct ts_pmt *pmt);
 void            ts_pmt_free			(struct ts_pmt **pmt);
 int				ts_pmt_parse		(struct ts_pmt *pmt);
 void            ts_pmt_dump			(struct ts_pmt *pmt);
 struct ts_nit * ts_nit_alloc		();
 struct ts_nit * ts_nit_alloc_init	(uint16_t network_id);
 struct ts_nit *	ts_nit_push_packet	(struct ts_nit *nit, uint8_t *ts_packet);
+void			ts_nit_clear		(struct ts_nit *nit);
 void			ts_nit_free			(struct ts_nit **nit);
 int				ts_nit_parse		(struct ts_nit *nit);
 void			ts_nit_dump			(struct ts_nit *nit);
 struct ts_sdt *	ts_sdt_alloc		();
 struct ts_sdt * ts_sdt_alloc_init	(uint16_t org_network_id, uint16_t transport_stream_id);
 struct ts_sdt *	ts_sdt_push_packet	(struct ts_sdt *sdt, uint8_t *ts_packet);
+void            ts_sdt_clear		(struct ts_sdt *sdt);
 void            ts_sdt_free			(struct ts_sdt **sdt);
 int				ts_sdt_parse		(struct ts_sdt *sdt);
 void            ts_sdt_dump			(struct ts_sdt *sdt);
 
 struct ts_eit *	ts_eit_push_packet	(struct ts_eit *eit, uint8_t *ts_packet);
 
+void			ts_eit_clear		(struct ts_eit *eit);
 void			ts_eit_free			(struct ts_eit **eit);
 int				ts_eit_parse		(struct ts_eit *eit);
 void			ts_eit_dump			(struct ts_eit *eit);
 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_clear		(struct ts_tdt *tdt);
 void			ts_tdt_free			(struct ts_tdt **tdt);
 
 int				ts_tdt_parse		(struct ts_tdt *tdt);
 
 // Private section
 struct ts_privsec *	ts_privsec_alloc();
+void				ts_privsec_clear		(struct ts_privsec *pprivsec);
 void				ts_privsec_free			(struct ts_privsec **pprivsec);
 
 struct ts_privsec *	ts_privsec_push_packet	(struct ts_privsec *privsec, uint8_t *ts_packet);

tsfuncs_cat.c

 	return cat;
 }
 
+void ts_cat_clear(struct ts_cat *cat) {
+	if (!cat)
+		return;
+	// save
+	struct ts_section_header *section_header = cat->section_header;
+	// free
+	FREE(cat->program_info);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(cat, 0, sizeof(struct ts_cat));
+	// restore
+	cat->section_header = section_header;
+}
+
 void ts_cat_free(struct ts_cat **pcat) {
 	struct ts_cat *cat = *pcat;
 	if (cat) {
 	}
 }
 
-static struct ts_cat *ts_cat_reset(struct ts_cat *cat) {
-	struct ts_cat *newcat = ts_cat_alloc();
-	ts_cat_free(&cat);
-	return newcat;
-}
-
 struct ts_cat *ts_cat_push_packet(struct ts_cat *cat, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return cat;
 
 ERROR:
-	return ts_cat_reset(cat);
+	ts_cat_clear(cat);
+	return cat;
 }
 
 int ts_cat_parse(struct ts_cat *cat) {

tsfuncs_eit.c

 	return eit;
 }
 
+static void ts_eit_streams_data_free(struct ts_eit *eit) {
+	int i;
+	for (i=0;i<eit->streams_num;i++) {
+		if (eit->streams[i]) {
+			FREE(eit->streams[i]->descriptor_data);
+			FREE(eit->streams[i]);
+		}
+	}
+}
+
+void ts_eit_clear(struct ts_eit *eit) {
+	if (!eit)
+		return;
+	// save
+	struct ts_section_header *section_header = eit->section_header;
+	struct ts_eit_stream **streams = eit->streams;
+	int streams_max = eit->streams_max;
+	// free
+	ts_eit_streams_data_free(eit);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(eit, 0, sizeof(struct ts_eit));
+	// restore
+	eit->section_header = section_header;
+	eit->streams = streams;
+	eit->streams_max = streams_max;
+}
+
 void ts_eit_free(struct ts_eit **peit) {
 	struct ts_eit *eit = *peit;
 	if (eit) {
-		int i;
 		ts_section_data_free(&eit->section_header);
-		for (i=0;i<eit->streams_num;i++) {
-			if (eit->streams[i]) {
-				FREE(eit->streams[i]->descriptor_data);
-				FREE(eit->streams[i]);
-			}
-		}
+		ts_eit_streams_data_free(eit);
 		FREE(eit->streams);
 		FREE(*peit);
 	}
 }
 
-static struct ts_eit *ts_eit_reset(struct ts_eit *eit) {
-	struct ts_eit *neweit = ts_eit_alloc();
-	ts_eit_free(&eit);
-	return neweit;
-}
-
 struct ts_eit *ts_eit_push_packet(struct ts_eit *eit, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return eit;
 
 ERROR:
-	return ts_eit_reset(eit);
+	ts_eit_clear(eit);
+	return eit;
 }
 
 

tsfuncs_nit.c

 	return nit;
 }
 
+static void ts_nit_streams_data_free(struct ts_nit *nit) {
+	int i;
+	for (i=0;i<nit->streams_num;i++) {
+		if (nit->streams[i]) {
+			FREE(nit->streams[i]->descriptor_data);
+			FREE(nit->streams[i]);
+		}
+	}
+}
+
+void ts_nit_clear(struct ts_nit *nit) {
+	if (!nit)
+		return;
+	// save
+	struct ts_section_header *section_header = nit->section_header;
+	struct ts_nit_stream **streams = nit->streams;
+	int streams_max = nit->streams_max;
+	// free
+	ts_nit_streams_data_free(nit);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(nit, 0, sizeof(struct ts_nit));
+	// restore
+	nit->section_header = section_header;
+	nit->streams = streams;
+	nit->streams_max = streams_max;
+}
+
 void ts_nit_free(struct ts_nit **pnit) {
 	struct ts_nit *nit = *pnit;
-	int i;
 	if (nit) {
 		ts_section_data_free(&nit->section_header);
 		FREE(nit->network_info);
-		for (i=0;i<nit->streams_num;i++) {
-			if (nit->streams[i]) {
-				FREE(nit->streams[i]->descriptor_data);
-				FREE(nit->streams[i]);
-			}
-		}
+		ts_nit_streams_data_free(nit);
 		FREE(nit->streams);
 		FREE(*pnit);
 	}
 }
 
-static struct ts_nit *ts_nit_reset(struct ts_nit *nit) {
-	struct ts_nit *newnit = ts_nit_alloc();
-	ts_nit_free(&nit);
-	return newnit;
-}
-
 struct ts_nit *ts_nit_push_packet(struct ts_nit *nit, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return nit;
 
 ERROR:
-	return ts_nit_reset(nit);
+	ts_nit_clear(nit);
+	return nit;
 }
 
 

tsfuncs_pat.c

 	return pat;
 }
 
+static void ts_pat_programs_data_free(struct ts_pat *pat) {
+	int i;
+	for (i=0;i<pat->programs_num;i++) {
+		if (pat->programs[i]) {
+			FREE(pat->programs[i]);
+		}
+	}
+}
+
+void ts_pat_clear(struct ts_pat *pat) {
+	if (!pat)
+		return;
+	// save
+	struct ts_section_header *section_header = pat->section_header;
+	struct ts_pat_program **programs = pat->programs;
+	int programs_max = pat->programs_max;
+	// free
+	ts_pat_programs_data_free(pat);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(pat, 0, sizeof(struct ts_pat));
+	// restore
+	pat->section_header = section_header;
+	pat->programs = programs;
+	pat->programs_max = programs_max;
+}
+
 void ts_pat_free(struct ts_pat **ppat) {
 	struct ts_pat *pat = *ppat;
-	int i;
 	if (pat) {
 		ts_section_data_free(&pat->section_header);
-		for (i=0;i<pat->programs_num;i++) {
-			FREE(pat->programs[i]);
-		}
+		ts_pat_programs_data_free(pat);
 		FREE(pat->programs);
 		FREE(*ppat);
 	}
 }
 
-static struct ts_pat *ts_pat_reset(struct ts_pat *pat) {
-	struct ts_pat *newpat = ts_pat_alloc();
-	ts_pat_free(&pat);
-	return newpat;
-}
-
 struct ts_pat *ts_pat_push_packet(struct ts_pat *pat, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return pat;
 
 ERROR:
-	return ts_pat_reset(pat);
+	ts_pat_clear(pat);
+	return pat;
 }
 
 int ts_pat_parse(struct ts_pat *pat) {

tsfuncs_pmt.c

 	return pmt;
 }
 
+static void ts_pmt_streams_data_free(struct ts_pmt *pmt) {
+	int i;
+	for (i=0;i<pmt->streams_num;i++) {
+		if (pmt->streams[i]) {
+			FREE(pmt->streams[i]->ES_info);
+			FREE(pmt->streams[i]);
+		}
+	}
+}
+
+void ts_pmt_clear(struct ts_pmt *pmt) {
+	if (!pmt)
+		return;
+	// save
+	struct ts_section_header *section_header = pmt->section_header;
+	struct ts_pmt_stream **streams = pmt->streams;
+	int streams_max = pmt->streams_max;
+	// free
+	FREE(pmt->program_info);
+	ts_pmt_streams_data_free(pmt);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(pmt, 0, sizeof(struct ts_pmt));
+	// restore
+	pmt->section_header = section_header;
+	pmt->streams = streams;
+	pmt->streams_max = streams_max;
+}
+
+
 void ts_pmt_free(struct ts_pmt **ppmt) {
 	struct ts_pmt *pmt = *ppmt;
-	int i;
 	if (pmt) {
 		ts_section_data_free(&pmt->section_header);
-		for (i=0;i<pmt->streams_num;i++) {
-			FREE(pmt->streams[i]->ES_info);
-			FREE(pmt->streams[i]);
-		}
+		ts_pmt_streams_data_free(pmt);
 		FREE(pmt->program_info);
 		FREE(pmt->streams);
 		FREE(*ppmt);
 	}
 }
 
-static struct ts_pmt *ts_pmt_reset(struct ts_pmt *pmt) {
-	struct ts_pmt *newpmt = ts_pmt_alloc();
-	ts_pmt_free(&pmt);
-	return newpmt;
-}
-
 struct ts_pmt *ts_pmt_push_packet(struct ts_pmt *pmt, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return pmt;
 
 ERROR:
-	return ts_pmt_reset(pmt);
+	ts_pmt_clear(pmt);
+	return pmt;
 }
 
 int ts_pmt_parse(struct ts_pmt *pmt) {

tsfuncs_privsec.c

 	return privsec;
 }
 
+void ts_privsec_clear(struct ts_privsec *privsec) {
+	if (!privsec)
+		return;
+	// save
+	struct ts_section_header *section_header = privsec->section_header;
+	// clear
+	ts_section_data_clear(section_header);
+	memset(privsec, 0, sizeof(struct ts_privsec));
+	// restore
+	privsec->section_header = section_header;
+}
+
 void ts_privsec_free(struct ts_privsec **pprivsec) {
 	struct ts_privsec *privsec = *pprivsec;
 	if (privsec) {

tsfuncs_sdt.c

 	return sdt;
 }
 
+static void ts_sdt_streams_data_free(struct ts_sdt *sdt) {
+	int i;
+	for (i=0;i<sdt->streams_num;i++) {
+		if (sdt->streams[i]) {
+			FREE(sdt->streams[i]->descriptor_data);
+			FREE(sdt->streams[i]);
+		}
+	}
+}
+
+void ts_sdt_clear(struct ts_sdt *sdt) {
+	if (!sdt)
+		return;
+	// save
+	struct ts_section_header *section_header = sdt->section_header;
+	struct ts_sdt_stream **streams = sdt->streams;
+	int streams_max = sdt->streams_max;
+	// free
+	ts_sdt_streams_data_free(sdt);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(sdt, 0, sizeof(struct ts_sdt));
+	// restore
+	sdt->section_header = section_header;
+	sdt->streams = streams;
+	sdt->streams_max = streams_max;
+}
+
 void ts_sdt_free(struct ts_sdt **psdt) {
 	struct ts_sdt *sdt = *psdt;
-	int i;
 	if (sdt) {
 		ts_section_data_free(&sdt->section_header);
-		for (i=0;i<sdt->streams_num;i++) {
-			FREE(sdt->streams[i]->descriptor_data);
-			FREE(sdt->streams[i]);
-		}
+		ts_sdt_streams_data_free(sdt);
 		FREE(sdt->streams);
 		FREE(*psdt);
 	}
 }
 
-static struct ts_sdt *ts_sdt_reset(struct ts_sdt *sdt) {
-	struct ts_sdt *newsdt = ts_sdt_alloc();
-	ts_sdt_free(&sdt);
-	return newsdt;
-}
-
 struct ts_sdt *ts_sdt_push_packet(struct ts_sdt *sdt, uint8_t *ts_packet) {
 	struct ts_header ts_header;
 	memset(&ts_header, 0, sizeof(struct ts_header));
 	return sdt;
 
 ERROR:
-	return ts_sdt_reset(sdt);
+	ts_sdt_clear(sdt);
+	return sdt;
 }
 
 int ts_sdt_parse(struct ts_sdt *sdt) {

tsfuncs_section_data.c

 	return section_data;
 }
 
+void ts_section_data_clear(struct ts_section_header *sec) {
+	if (!sec)
+		return;
+	// save
+	uint8_t *section_data = sec->section_data;
+	uint8_t *packet_data = sec->packet_data;
+	// clear
+	memset(section_data, 0x30, 4096);
+	memset(packet_data , 0x31, 5120);
+	memset(sec, 0, sizeof(struct ts_section_header));
+	// restore
+	sec->section_data = section_data;
+	sec->packet_data  = packet_data;
+}
+
 void ts_section_data_free(struct ts_section_header **psection_data) {
 	struct ts_section_header *section_data = *psection_data;
 	if (section_data) {

tsfuncs_tdt.c

 	return tdt;
 }
 
+void ts_tdt_clear(struct ts_tdt *tdt) {
+	if (!tdt)
+		return;
+	// save
+	struct ts_section_header *section_header = tdt->section_header;
+	// free
+	FREE(tdt->descriptors);
+	// clear
+	ts_section_data_clear(section_header);
+	memset(tdt, 0, sizeof(struct ts_tdt));
+	// restore
+	tdt->section_header = section_header;
+}
+
 void ts_tdt_free(struct ts_tdt **ptdt) {
 	struct ts_tdt *tdt = *ptdt;
 	if (tdt) {
 	}
 }
 
-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));
 	return tdt;
 
 ERROR:
-	return ts_tdt_reset(tdt);
+	ts_tdt_clear(tdt);
+	return tdt;
 }
 
 int ts_tdt_parse(struct ts_tdt *tdt) {