Merge branch 'master' of /home/tmbinc/enigma2-git

9 files changed, 402 insertions, 454 deletions

diff --git a/lib/dvb/db.cpp b/lib/dvb/db.cpp
index e5a94392..e6108ab5 100644
--- a/lib/dvb/db.cpp
+++ b/lib/dvb/db.cpp
@@ -327,10 +327,10 @@ void eDVBDB::loadServicelist(const char *file)
 				eDVBFrontendParametersSatellite sat;
 				int frequency, symbol_rate, polarisation, fec, orbital_position, inversion,
 					flags=0,
-					system=eDVBFrontendParametersSatellite::System::DVB_S,
-					modulation=eDVBFrontendParametersSatellite::Modulation::QPSK,
-					rolloff=eDVBFrontendParametersSatellite::RollOff::alpha_0_35,
-					pilot=eDVBFrontendParametersSatellite::Pilot::Unknown;
+					system=eDVBFrontendParametersSatellite::System_DVB_S,
+					modulation=eDVBFrontendParametersSatellite::Modulation_QPSK,
+					rolloff=eDVBFrontendParametersSatellite::RollOff_alpha_0_35,
+					pilot=eDVBFrontendParametersSatellite::Pilot_Unknown;
 				if (version == 3)
 					sscanf(line+3, "%d:%d:%d:%d:%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &polarisation, &fec, &orbital_position, &inversion, &system, &modulation, &rolloff, &pilot);
 				else
@@ -368,9 +368,9 @@ void eDVBDB::loadServicelist(const char *file)
 			{
 				eDVBFrontendParametersCable cab;
 				int frequency, symbol_rate,
-					inversion=eDVBFrontendParametersCable::Inversion::Unknown,
-					modulation=eDVBFrontendParametersCable::Modulation::Auto,
-					fec_inner=eDVBFrontendParametersCable::FEC::fAuto,
+					inversion=eDVBFrontendParametersCable::Inversion_Unknown,
+					modulation=eDVBFrontendParametersCable::Modulation_Auto,
+					fec_inner=eDVBFrontendParametersCable::FEC_Auto,
 					flags=0;
 				sscanf(line+3, "%d:%d:%d:%d:%d:%d", &frequency, &symbol_rate, &inversion, &modulation, &fec_inner, &flags);
 				cab.frequency = frequency;
@@ -495,7 +495,7 @@ void eDVBDB::saveServicelist(const char *file)
 		ch.m_frontendParameters->getFlags(flags);
 		if (!ch.m_frontendParameters->getDVBS(sat))
 		{
-			if (sat.system == eDVBFrontendParametersSatellite::System::DVB_S2)
+			if (sat.system == eDVBFrontendParametersSatellite::System_DVB_S2)
 			{
 				fprintf(f, "\ts %d:%d:%d:%d:%d:%d:%d:%d:%d:%d:%d\n",
 					sat.frequency, sat.symbol_rate,
@@ -842,15 +842,15 @@ PyObject *eDVBDB::readSatellites(ePyObject sat_list, ePyObject sat_dict, ePyObje
 //				eDebug("\telement: %s", (*it)->name().c_str());
 				const AttributeList &tp_attributes = (*it)->getAttributeList();
 				AttributeConstIterator end = tp_attributes.end();
-				modulation = 1; // QPSK default
-				system = 0; // DVB-S default
+				modulation = eDVBFrontendParametersSatellite::Modulation_QPSK;
+				system = eDVBFrontendParametersSatellite::System_DVB_S;
 				freq = 0;
 				sr = 0;
 				pol = -1;
-				fec = 0; // AUTO default
-				inv = 2; // AUTO default
-				pilot = 2; // AUTO default
-				rolloff = 0; // alpha 0.35
+				fec = eDVBFrontendParametersSatellite::FEC_Auto;
+				inv = eDVBFrontendParametersSatellite::Inversion_Unknown;
+				pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
+				rolloff = eDVBFrontendParametersSatellite::RollOff_alpha_0_35;
 				tsid = -1;
 				onid = -1;
 
@@ -981,8 +981,8 @@ PyObject *eDVBDB::readCables(ePyObject cab_list, ePyObject tp_dict)
 //				eDebug("\telement: %s", (*it)->name().c_str());
 				const AttributeList &tp_attributes = (*it)->getAttributeList();
 				AttributeConstIterator end = tp_attributes.end();
-				modulation = 3; // QAM64 default
-				fec = 0; // AUTO default
+				modulation = eDVBFrontendParametersCable::Modulation_QAM64;
+				fec = eDVBFrontendParametersCable::FEC_Auto;
 				freq = 0;
 				sr = 0;
 				for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it)
@@ -1095,14 +1095,14 @@ PyObject *eDVBDB::readTerrestrials(ePyObject ter_list, ePyObject tp_dict)
 				const AttributeList &tp_attributes = (*it)->getAttributeList();
 				AttributeConstIterator end = tp_attributes.end();
 				freq = 0;
-				bw = 3; // AUTO
-				constellation = 1; // AUTO
-				crh = 5; // AUTO
-				crl = 5; // AUTO
-				guard = 4; // AUTO
-				transm = 2; // AUTO
-				hierarchy = 4; // AUTO
-				inv = 2; // AUTO
+				bw = eDVBFrontendParametersTerrestrial::Bandwidth_Auto;
+				constellation = eDVBFrontendParametersTerrestrial::Modulation_Auto;
+				crh = eDVBFrontendParametersTerrestrial::FEC_Auto;
+				crl = eDVBFrontendParametersTerrestrial::FEC_Auto;
+				guard = eDVBFrontendParametersTerrestrial::GuardInterval_Auto;
+				transm = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto;
+				hierarchy = eDVBFrontendParametersTerrestrial::Hierarchy_Auto;
+				inv = eDVBFrontendParametersTerrestrial::Inversion_Unknown;
 				for (AttributeConstIterator it(tp_attributes.begin()); it != end; ++it)
 				{
 //					eDebug("\t\tattr: %s", at->name().c_str());
diff --git a/lib/dvb/decoder.cpp b/lib/dvb/decoder.cpp
index 8bc07e60..065a49c2 100644
--- a/lib/dvb/decoder.cpp
+++ b/lib/dvb/decoder.cpp
@@ -187,11 +187,15 @@ int eDVBAudio::startPid(int pid, int type)
 	case aAC3:
 		bypass = 0;
 		break;
-		/*
 	case aDTS:
 		bypass = 2;
 		break;
-		*/
+	case aAAC:
+		bypass = 8;
+		break;
+	case aAACHE:
+		bypass = 9;
+		break;
 	}
 
 	eDebugNoNewLine("AUDIO_SET_BYPASS - ");
@@ -334,6 +338,10 @@ eDVBVideo::eDVBVideo(eDVBDemux *demux, int dev)
 // not finally values i think.. !!
 #define VIDEO_STREAMTYPE_MPEG2 0
 #define VIDEO_STREAMTYPE_MPEG4_H264 1
+#define VIDEO_STREAMTYPE_VC1 3
+#define VIDEO_STREAMTYPE_MPEG4_Part2 4
+#define VIDEO_STREAMTYPE_VC1_SM 5
+#define VIDEO_STREAMTYPE_MPEG1 6
 
 #if HAVE_DVB_API_VERSION < 3
 int eDVBVideo::setPid(int pid)
@@ -395,13 +403,36 @@ int eDVBVideo::stopPid()
 #else
 int eDVBVideo::startPid(int pid, int type)
 {
+	int streamtype = VIDEO_STREAMTYPE_MPEG2;
+
 	if ((m_fd < 0) || (m_fd_demux < 0))
 		return -1;
 	dmx_pes_filter_params pes;
 
-	eDebugNoNewLine("VIDEO_SET_STREAMTYPE %d - ",type == MPEG4_H264 ? VIDEO_STREAMTYPE_MPEG4_H264 : VIDEO_STREAMTYPE_MPEG2);
-	if (::ioctl(m_fd, VIDEO_SET_STREAMTYPE,
-		type == MPEG4_H264 ? VIDEO_STREAMTYPE_MPEG4_H264 : VIDEO_STREAMTYPE_MPEG2) < 0)
+	switch(type)
+	{
+	default:
+	case MPEG2:
+		break;
+	case MPEG4_H264:
+		streamtype = VIDEO_STREAMTYPE_MPEG4_H264;
+		break;
+	case MPEG1:
+		streamtype = VIDEO_STREAMTYPE_MPEG1;
+		break;
+	case MPEG4_Part2:
+		streamtype = VIDEO_STREAMTYPE_MPEG4_Part2;
+		break;
+	case VC1:
+		streamtype = VIDEO_STREAMTYPE_VC1;
+		break;
+	case VC1_SM:
+		streamtype = VIDEO_STREAMTYPE_VC1_SM;
+		break;
+	}
+
+	eDebugNoNewLine("VIDEO_SET_STREAMTYPE %d - ", streamtype);
+	if (::ioctl(m_fd, VIDEO_SET_STREAMTYPE, streamtype) < 0)
 		eDebug("failed (%m)");
 	else
 		eDebug("ok");
diff --git a/lib/dvb/decoder.h b/lib/dvb/decoder.h
index 5b9d352a..f2e10bb9 100644
--- a/lib/dvb/decoder.h
+++ b/lib/dvb/decoder.h
@@ -13,7 +13,7 @@ private:
 	ePtr<eDVBDemux> m_demux;
 	int m_fd, m_fd_demux, m_dev, m_is_freezed;
 public:
-	enum { aMPEG, aAC3, aDTS, aAAC };
+	enum { aMPEG, aAC3, aDTS, aAAC, aAACHE };
 	eDVBAudio(eDVBDemux *demux, int dev);
 	enum { aMonoLeft, aStereo, aMonoRight };
 	void setChannel(int channel);
@@ -49,7 +49,7 @@ private:
 	Signal1<void, struct iTSMPEGDecoder::videoEvent> m_event;
 	int m_width, m_height, m_framerate, m_aspect, m_progressive;
 public:
-	enum { MPEG2, MPEG4_H264 };
+	enum { MPEG2, MPEG4_H264, MPEG1, MPEG4_Part2, VC1, VC1_SM };
 	eDVBVideo(eDVBDemux *demux, int dev);
 	void stop();
 #if HAVE_DVB_API_VERSION < 3
diff --git a/lib/dvb/epgcache.cpp b/lib/dvb/epgcache.cpp
index 9bb8dfc6..a8eca85b 100644
--- a/lib/dvb/epgcache.cpp
+++ b/lib/dvb/epgcache.cpp
@@ -2171,20 +2171,32 @@ PyObject *eEPGCache::search(ePyObject arg)
 							int title_len = data[5];
 							if ( querytype == 1 )
 							{
+								int offs = 6;
+								// skip DVB-Text Encoding!
+								if (data[6] == 0x10)
+								{
+									offs+=3;
+									title_len-=3;
+								}
+								else if(data[6] > 0 && data[6] < 0x20)
+								{
+									offs+=1;
+									title_len-=1;
+								}
 								if (title_len != textlen)
 									continue;
 								if ( casetype )
 								{
-									if ( !strncasecmp((const char*)data+6, str, title_len) )
+									if ( !strncasecmp((const char*)data+offs, str, title_len) )
 									{
-//										std::string s((const char*)data+6, title_len);
+//										std::string s((const char*)data+offs, title_len);
 //										eDebug("match1 %s %s", str, s.c_str() );
 										descr[++descridx] = it->first;
 									}
 								}
-								else if ( !strncmp((const char*)data+6, str, title_len) )
+								else if ( !strncmp((const char*)data+offs, str, title_len) )
 								{
-//									std::string s((const char*)data+6, title_len);
+//									std::string s((const char*)data+offs, title_len);
 //									eDebug("match2 %s %s", str, s.c_str() );
 									descr[++descridx] = it->first;
 								}
diff --git a/lib/dvb/frontend.cpp b/lib/dvb/frontend.cpp
index aae7bbc2..5fe3799d 100644
--- a/lib/dvb/frontend.cpp
+++ b/lib/dvb/frontend.cpp
@@ -1,4 +1,5 @@
 #include <lib/dvb/dvb.h>
+#include <lib/dvb/frontendparms.h>
 #include <lib/base/eerror.h>
 #include <lib/base/nconfig.h> // access to python config
 #include <errno.h>
@@ -148,10 +149,10 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
 	symbol_rate  = descriptor.getSymbolRate() * 100;
 	polarisation = descriptor.getPolarization();
 	fec = descriptor.getFecInner();
-	if ( fec != FEC::fNone && fec > FEC::f9_10 )
-		fec = FEC::fAuto;
-	inversion = Inversion::Unknown;
-	pilot = Pilot::Unknown;
+	if ( fec != eDVBFrontendParametersSatellite::FEC_None && fec > eDVBFrontendParametersSatellite::FEC_9_10 )
+		fec = eDVBFrontendParametersSatellite::FEC_Auto;
+	inversion = eDVBFrontendParametersSatellite::Inversion_Unknown;
+	pilot = eDVBFrontendParametersSatellite::Pilot_Unknown;
 	orbital_position  = ((descriptor.getOrbitalPosition() >> 12) & 0xF) * 1000;
 	orbital_position += ((descriptor.getOrbitalPosition() >> 8) & 0xF) * 100;
 	orbital_position += ((descriptor.getOrbitalPosition() >> 4) & 0xF) * 10;
@@ -160,13 +161,13 @@ void eDVBFrontendParametersSatellite::set(const SatelliteDeliverySystemDescripto
 		orbital_position = 3600 - orbital_position;
 	system = descriptor.getModulationSystem();
 	modulation = descriptor.getModulation();
-	if (system == System::DVB_S && modulation == Modulation::M8PSK)
+	if (system == eDVBFrontendParametersSatellite::System_DVB_S && modulation == eDVBFrontendParametersSatellite::Modulation_8PSK)
 	{
 		eDebug("satellite_delivery_descriptor non valid modulation type.. force QPSK");
-		modulation=QPSK;
+		modulation=eDVBFrontendParametersSatellite::Modulation_QPSK;
 	}
 	rolloff = descriptor.getRollOff();
-	if (system == System::DVB_S2)
+	if (system == eDVBFrontendParametersSatellite::System_DVB_S2)
 	{
 		eDebug("SAT DVB-S2 freq %d, %s, pos %d, sr %d, fec %d, modulation %d, rolloff %d",
 			frequency,
@@ -192,11 +193,11 @@ void eDVBFrontendParametersCable::set(const CableDeliverySystemDescriptor &descr
 	symbol_rate = descriptor.getSymbolRate() * 100;
 	fec_inner = descriptor.getFecInner();
 	if ( fec_inner == 0xF )
-		fec_inner = FEC::fNone;
+		fec_inner = eDVBFrontendParametersCable::FEC_None;
 	modulation = descriptor.getModulation();
 	if ( modulation > 0x5 )
-		modulation = Modulation::Auto;
-	inversion = Inversion::Unknown;
+		modulation = eDVBFrontendParametersCable::Modulation_Auto;
+	inversion = eDVBFrontendParametersCable::Inversion_Unknown;
 	eDebug("Cable freq %d, mod %d, sr %d, fec %d",
 		frequency,
 		modulation, symbol_rate, fec_inner);
@@ -207,24 +208,24 @@ void eDVBFrontendParametersTerrestrial::set(const TerrestrialDeliverySystemDescr
 	frequency = descriptor.getCentreFrequency() * 10;
 	bandwidth = descriptor.getBandwidth();
 	if ( bandwidth > 2 ) // 5Mhz forced to auto
-		bandwidth = Bandwidth::BwAuto;
+		bandwidth = eDVBFrontendParametersTerrestrial::Bandwidth_Auto;
 	code_rate_HP = descriptor.getCodeRateHpStream();
 	if (code_rate_HP > 4)
-		code_rate_HP = FEC::fAuto;
+		code_rate_HP = eDVBFrontendParametersTerrestrial::FEC_Auto;
 	code_rate_LP = descriptor.getCodeRateLpStream();
 	if (code_rate_LP > 4)
-		code_rate_LP = FEC::fAuto;
+		code_rate_LP = eDVBFrontendParametersTerrestrial::FEC_Auto;
 	transmission_mode = descriptor.getTransmissionMode();
 	if (transmission_mode > 1) // TM4k forced to auto
-		transmission_mode = TransmissionMode::TMAuto;
+		transmission_mode = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto;
 	guard_interval = descriptor.getGuardInterval();
 	if (guard_interval > 3)
-		guard_interval = GuardInterval::GI_Auto;
+		guard_interval = eDVBFrontendParametersTerrestrial::GuardInterval_Auto;
 	hierarchy = descriptor.getHierarchyInformation()&3;
 	modulation = descriptor.getConstellation();
 	if (modulation > 2)
-		modulation = Modulation::Auto;
-	inversion = Inversion::Unknown;
+		modulation = eDVBFrontendParametersTerrestrial::Modulation_Auto;
+	inversion = eDVBFrontendParametersTerrestrial::Inversion_Unknown;
 	eDebug("Terr freq %d, bw %d, cr_hp %d, cr_lp %d, tm_mode %d, guard %d, hierarchy %d, const %d",
 		frequency, bandwidth, code_rate_HP, code_rate_LP, transmission_mode,
 		guard_interval, hierarchy, modulation);
@@ -316,9 +317,9 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
 			diff = 1<<29;
 		else if (sat.polarisation != osat.polarisation)
 			diff = 1<<28;
-		else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC::fAuto && osat.fec != eDVBFrontendParametersSatellite::FEC::fAuto)
+		else if (exact && sat.fec != osat.fec && sat.fec != eDVBFrontendParametersSatellite::FEC_Auto && osat.fec != eDVBFrontendParametersSatellite::FEC_Auto)
 			diff = 1<<27;
-		else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation::Auto)
+		else if (exact && sat.modulation != osat.modulation && sat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto && osat.modulation != eDVBFrontendParametersSatellite::Modulation_Auto)
 			diff = 1<<27;
 		else
 		{
@@ -333,10 +334,10 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
 			return -2;
 
 		if (exact && cable.modulation != ocable.modulation
-			&& cable.modulation != eDVBFrontendParametersCable::Modulation::Auto
-			&& ocable.modulation != eDVBFrontendParametersCable::Modulation::Auto)
+			&& cable.modulation != eDVBFrontendParametersCable::Modulation_Auto
+			&& ocable.modulation != eDVBFrontendParametersCable::Modulation_Auto)
 			diff = 1 << 29;
-		else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto && ocable.fec_inner != eDVBFrontendParametersCable::FEC::fAuto)
+		else if (exact && cable.fec_inner != ocable.fec_inner && cable.fec_inner != eDVBFrontendParametersCable::FEC_Auto && ocable.fec_inner != eDVBFrontendParametersCable::FEC_Auto)
 			diff = 1 << 27;
 		else
 		{
@@ -350,32 +351,32 @@ RESULT eDVBFrontendParameters::calculateDifference(const iDVBFrontendParameters
 			return -2;
 
 		if (exact && oterrestrial.bandwidth != terrestrial.bandwidth &&
-			oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto &&
-			terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto)
+			oterrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto &&
+			terrestrial.bandwidth != eDVBFrontendParametersTerrestrial::Bandwidth_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.modulation != terrestrial.modulation &&
-			oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto &&
-			terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation::Auto)
+			oterrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto &&
+			terrestrial.modulation != eDVBFrontendParametersTerrestrial::Modulation_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.transmission_mode != terrestrial.transmission_mode &&
-			oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto &&
-			terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto)
+			oterrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto &&
+			terrestrial.transmission_mode != eDVBFrontendParametersTerrestrial::TransmissionMode_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.guard_interval != terrestrial.guard_interval &&
-			oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto &&
-			terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto)
+			oterrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto &&
+			terrestrial.guard_interval != eDVBFrontendParametersTerrestrial::GuardInterval_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.hierarchy != terrestrial.hierarchy &&
-			oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto &&
-			terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy::HAuto)
+			oterrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto &&
+			terrestrial.hierarchy != eDVBFrontendParametersTerrestrial::Hierarchy_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.code_rate_LP != terrestrial.code_rate_LP &&
-			oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
-			terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+			oterrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto &&
+			terrestrial.code_rate_LP != eDVBFrontendParametersTerrestrial::FEC_Auto)
 			diff = 1 << 30;
 		else if (exact && oterrestrial.code_rate_HP != terrestrial.code_rate_HP &&
-			oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto &&
-			terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC::fAuto)
+			oterrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto &&
+			terrestrial.code_rate_HP != eDVBFrontendParametersTerrestrial::FEC_Auto)
 			diff = 1 << 30;
 		else
 			diff = abs(terrestrial.frequency - oterrestrial.frequency);
@@ -963,120 +964,79 @@ void PutToDict(ePyObject &dict, const char*key, const char *value)
 void fillDictWithSatelliteData(ePyObject dict, const FRONTENDPARAMETERS &parm, eDVBFrontend *fe)
 {
 	long freq_offset=0;
-	const char *tmp=0;
+	long tmp=0;
 	fe->getData(eDVBFrontend::FREQ_OFFSET, freq_offset);
 	int frequency = parm_frequency + freq_offset;
 	PutToDict(dict, "frequency", frequency);
 	PutToDict(dict, "symbol_rate", parm_u_qpsk_symbol_rate);
 	switch(parm_u_qpsk_fec_inner)
 	{
-	case FEC_1_2:
-		tmp = "FEC_1_2";
-		break;
-	case FEC_2_3:
-		tmp = "FEC_2_3";
-		break;
-	case FEC_3_4:
-		tmp = "FEC_3_4";
-		break;
-	case FEC_5_6:
-		tmp = "FEC_5_6";
-		break;
-	case FEC_7_8:
-		tmp = "FEC_7_8";
-		break;
-	case FEC_NONE:
-		tmp = "FEC_NONE";
+	case FEC_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break;
+	case FEC_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break;
+	case FEC_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break;
+	case FEC_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break;
+	case FEC_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
+	case FEC_NONE: tmp = eDVBFrontendParametersSatellite::FEC_None; break;
 	default:
-	case FEC_AUTO:
-		tmp = "FEC_AUTO";
-		break;
+	case FEC_AUTO: tmp = eDVBFrontendParametersSatellite::FEC_Auto; break;
 #if HAVE_DVB_API_VERSION >=3
-	case FEC_S2_8PSK_1_2:
-	case FEC_S2_QPSK_1_2:
-		tmp = "FEC_1_2";
-		break;
+	case FEC_S2_8PSK_1_2: 
+	case FEC_S2_QPSK_1_2: tmp = eDVBFrontendParametersSatellite::FEC_1_2; break;
 	case FEC_S2_8PSK_2_3:
-	case FEC_S2_QPSK_2_3:
-		tmp = "FEC_2_3";
-		break;
+	case FEC_S2_QPSK_2_3: tmp = eDVBFrontendParametersSatellite::FEC_2_3; break;
 	case FEC_S2_8PSK_3_4:
-	case FEC_S2_QPSK_3_4:
-		tmp = "FEC_3_4";
-		break;
+	case FEC_S2_QPSK_3_4: tmp = eDVBFrontendParametersSatellite::FEC_3_4; break;
 	case FEC_S2_8PSK_5_6:
-	case FEC_S2_QPSK_5_6:
-		tmp = "FEC_5_6";
-		break;
+	case FEC_S2_QPSK_5_6: tmp = eDVBFrontendParametersSatellite::FEC_5_6; break;
 	case FEC_S2_8PSK_7_8:
-	case FEC_S2_QPSK_7_8:
-		tmp = "FEC_7_8";
-		break;
+	case FEC_S2_QPSK_7_8: tmp = eDVBFrontendParametersSatellite::FEC_7_8; break;
 	case FEC_S2_8PSK_8_9:
-	case FEC_S2_QPSK_8_9:
-		tmp = "FEC_8_9";
-		break;
+	case FEC_S2_QPSK_8_9: tmp = eDVBFrontendParametersSatellite::FEC_8_9; break;
 	case FEC_S2_8PSK_3_5:
-	case FEC_S2_QPSK_3_5:
-		tmp = "FEC_3_5";
-		break;
+	case FEC_S2_QPSK_3_5: tmp = eDVBFrontendParametersSatellite::FEC_3_5; break;
 	case FEC_S2_8PSK_4_5:
-	case FEC_S2_QPSK_4_5:
-		tmp = "FEC_4_5";
-		break;
+	case FEC_S2_QPSK_4_5: tmp = eDVBFrontendParametersSatellite::FEC_4_5; break;
 	case FEC_S2_8PSK_9_10:
-	case FEC_S2_QPSK_9_10:
-		tmp = "FEC_9_10";
-		break;
+	case FEC_S2_QPSK_9_10: tmp = eDVBFrontendParametersSatellite::FEC_9_10; break;
 #endif
 	}
 	PutToDict(dict, "fec_inner", tmp);
 #if HAVE_DVB_API_VERSION >=3
 	PutToDict(dict, "modulation",
-		parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ? "8PSK": "QPSK" );
+		parm_u_qpsk_fec_inner > FEC_S2_QPSK_9_10 ?
+			eDVBFrontendParametersSatellite::Modulation_8PSK :
+			eDVBFrontendParametersSatellite::Modulation_QPSK );
 	if (parm_u_qpsk_fec_inner > FEC_AUTO)
 	{
 		switch(parm_inversion & 0xc)
 		{
 		default: // unknown rolloff
-		case 0: // 0.35
-			tmp = "ROLLOFF_0_35";
-			break;
-		case 4: // 0.25
-			tmp = "ROLLOFF_0_25";
-			break;
-		case 8: // 0.20
-			tmp = "ROLLOFF_0_20";
-			break;
+		case 0: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_35; break;
+		case 4: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_25; break;
+		case 8: tmp = eDVBFrontendParametersSatellite::RollOff_alpha_0_20; break;
 		}
 		PutToDict(dict, "rolloff", tmp);
 		switch(parm_inversion & 0x30)
 		{
-		case 0: // pilot off
-			tmp = "PILOT_OFF";
-			break;
-		case 0x10: // pilot on
-			tmp = "PILOT_ON";
-			break;
-		case 0x20: // pilot auto
-			tmp = "PILOT_AUTO";
-			break;
+		case 0: tmp = eDVBFrontendParametersSatellite::Pilot_Off; break;
+		case 0x10: tmp = eDVBFrontendParametersSatellite::Pilot_On; break;
+		case 0x20: tmp = eDVBFrontendParametersSatellite::Pilot_Unknown; break;
 		}
 		PutToDict(dict, "pilot", tmp);
-		tmp = "DVB-S2";
+		tmp = eDVBFrontendParametersSatellite::System_DVB_S2;
 	}
 	else
-		tmp = "DVB-S";
+		tmp = eDVBFrontendParametersSatellite::System_DVB_S;
 #else
-	PutToDict(dict, "modulation", "QPSK" );
-	tmp = "DVB-S";
+	PutToDict(dict, "modulation", eDVBFrontendParametersSatellite::Modulation_QPSK );
+	tmp = eDVBFrontendParametersSatellite::System_DVB_S;
 #endif
 	PutToDict(dict, "system", tmp);
 }
 
 void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)
 {
-	const char *tmp=0;
+	long tmp=0;
 #if HAVE_DVB_API_VERSION < 3
 	PutToDict(dict, "frequency", parm_frequency);
 #else
@@ -1085,196 +1045,102 @@ void fillDictWithCableData(ePyObject dict, const FRONTENDPARAMETERS &parm)
 	PutToDict(dict, "symbol_rate", parm_u_qam_symbol_rate);
 	switch(parm_u_qam_fec_inner)
 	{
-	case FEC_NONE:
-		tmp = "FEC_NONE";
-		break;
-	case FEC_1_2:
-		tmp = "FEC_1_2";
-		break;
-	case FEC_2_3:
-		tmp = "FEC_2_3";
-		break;
-	case FEC_3_4:
-		tmp = "FEC_3_4";
-		break;
-	case FEC_5_6:
-		tmp = "FEC_5_6";
-		break;
-	case FEC_7_8:
-		tmp = "FEC_7_8";
-		break;
+	case FEC_NONE: tmp = eDVBFrontendParametersCable::FEC_None; break;
+	case FEC_1_2: tmp = eDVBFrontendParametersCable::FEC_1_2; break;
+	case FEC_2_3: tmp = eDVBFrontendParametersCable::FEC_2_3; break;
+	case FEC_3_4: tmp = eDVBFrontendParametersCable::FEC_3_4; break;
+	case FEC_5_6: tmp = eDVBFrontendParametersCable::FEC_5_6; break;
+	case FEC_7_8: tmp = eDVBFrontendParametersCable::FEC_7_8; break;
 #if HAVE_DVB_API_VERSION >= 3
-	case FEC_8_9:
-		tmp = "FEC_8_9";
-		break;
+	case FEC_8_9: tmp = eDVBFrontendParametersCable::FEC_7_8; break;
 #endif
 	default:
-	case FEC_AUTO:
-		tmp = "FEC_AUTO";
-		break;
+	case FEC_AUTO: tmp = eDVBFrontendParametersCable::FEC_Auto; break;
 	}
 	PutToDict(dict, "fec_inner", tmp);
 	switch(parm_u_qam_modulation)
 	{
-	case QAM_16:
-		tmp = "QAM_16";
-		break;
-	case QAM_32:
-		tmp = "QAM_32";
-		break;
-	case QAM_64:
-		tmp = "QAM_64";
-		break;
-	case QAM_128:
-		tmp = "QAM_128";
-		break;
-	case QAM_256:
-		tmp = "QAM_256";
-		break;
+	case QAM_16: tmp = eDVBFrontendParametersCable::Modulation_QAM16; break;
+	case QAM_32: tmp = eDVBFrontendParametersCable::Modulation_QAM32; break;
+	case QAM_64: tmp = eDVBFrontendParametersCable::Modulation_QAM64; break;
+	case QAM_128: tmp = eDVBFrontendParametersCable::Modulation_QAM128; break;
+	case QAM_256: tmp = eDVBFrontendParametersCable::Modulation_QAM256; break;
 	default:
-	case QAM_AUTO:
-		tmp = "QAM_AUTO";
-		break;
+	case QAM_AUTO:   tmp = eDVBFrontendParametersCable::Modulation_Auto; break;
 	}
 	PutToDict(dict, "modulation", tmp);
 }
 
 void fillDictWithTerrestrialData(ePyObject dict, const FRONTENDPARAMETERS &parm)
 {
-	const char *tmp=0;
+	long tmp=0;
 	PutToDict(dict, "frequency", parm_frequency);
 	switch (parm_u_ofdm_bandwidth)
 	{
-	case BANDWIDTH_8_MHZ:
-		tmp = "BANDWIDTH_8_MHZ";
-		break;
-	case BANDWIDTH_7_MHZ:
-		tmp = "BANDWIDTH_7_MHZ";
-		break;
-	case BANDWIDTH_6_MHZ:
-		tmp = "BANDWIDTH_6_MHZ";
-		break;
+	case BANDWIDTH_8_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_8MHz; break;
+	case BANDWIDTH_7_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_7MHz; break;
+	case BANDWIDTH_6_MHZ: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_6MHz; break;
 	default:
-	case BANDWIDTH_AUTO:
-		tmp = "BANDWIDTH_AUTO";
-		break;
+	case BANDWIDTH_AUTO: tmp = eDVBFrontendParametersTerrestrial::Bandwidth_Auto; break;
 	}
 	PutToDict(dict, "bandwidth", tmp);
 	switch (parm_u_ofdm_code_rate_LP)
 	{
-	case FEC_1_2:
-		tmp = "FEC_1_2";
-		break;
-	case FEC_2_3:
-		tmp = "FEC_2_3";
-		break;
-	case FEC_3_4:
-		tmp = "FEC_3_4";
-		break;
-	case FEC_5_6:
-		tmp = "FEC_5_6";
-		break;
-	case FEC_7_8:
-		tmp = "FEC_7_8";
-		break;
+	case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break;
+	case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break;
+	case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break;
+	case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break;
+	case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break;
 	default:
-	case FEC_AUTO:
-		tmp = "FEC_AUTO";
-		break;
+	case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break;
 	}
 	PutToDict(dict, "code_rate_lp", tmp);
 	switch (parm_u_ofdm_code_rate_HP)
 	{
-	case FEC_1_2:
-		tmp = "FEC_1_2";
-		break;
-	case FEC_2_3:
-		tmp = "FEC_2_3";
-		break;
-	case FEC_3_4:
-		tmp = "FEC_3_4";
-		break;
-	case FEC_5_6:
-		tmp = "FEC_5_6";
-		break;
-	case FEC_7_8:
-		tmp = "FEC_7_8";
-		break;
+	case FEC_1_2: tmp = eDVBFrontendParametersTerrestrial::FEC_1_2; break;
+	case FEC_2_3: tmp = eDVBFrontendParametersTerrestrial::FEC_2_3; break;
+	case FEC_3_4: tmp = eDVBFrontendParametersTerrestrial::FEC_3_4; break;
+	case FEC_5_6: tmp = eDVBFrontendParametersTerrestrial::FEC_5_6; break;
+	case FEC_7_8: tmp = eDVBFrontendParametersTerrestrial::FEC_7_8; break;
 	default:
-	case FEC_AUTO:
-		tmp = "FEC_AUTO";
-		break;
+	case FEC_AUTO: tmp = eDVBFrontendParametersTerrestrial::FEC_Auto; break;
 	}
 	PutToDict(dict, "code_rate_hp", tmp);
 	switch (parm_u_ofdm_constellation)
 	{
-	case QPSK:
-		tmp = "QPSK";
-		break;
-	case QAM_16:
-		tmp = "QAM_16";
-		break;
-	case QAM_64:
-		tmp = "QAM_64";
-		break;
+	case QPSK: tmp = eDVBFrontendParametersTerrestrial::Modulation_QPSK; break;
+	case QAM_16: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM16; break;
+	case QAM_64: tmp = eDVBFrontendParametersTerrestrial::Modulation_QAM64; break;
 	default:
-	case QAM_AUTO:
-		tmp = "QAM_AUTO";
-		break;
+	case QAM_AUTO: tmp = eDVBFrontendParametersTerrestrial::Modulation_Auto; break;
 	}
 	PutToDict(dict, "constellation", tmp);
 	switch (parm_u_ofdm_transmission_mode)
 	{
-	case TRANSMISSION_MODE_2K:
-		tmp = "TRANSMISSION_MODE_2K";
-		break;
-	case TRANSMISSION_MODE_8K:
-		tmp = "TRANSMISSION_MODE_8K";
-		break;
+	case TRANSMISSION_MODE_2K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_2k; break;
+	case TRANSMISSION_MODE_8K: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_8k; break;
 	default:
-	case TRANSMISSION_MODE_AUTO:
-		tmp = "TRANSMISSION_MODE_AUTO";
-		break;
+	case TRANSMISSION_MODE_AUTO: tmp = eDVBFrontendParametersTerrestrial::TransmissionMode_Auto; break;
 	}
 	PutToDict(dict, "transmission_mode", tmp);
 	switch (parm_u_ofdm_guard_interval)
 	{
-		case GUARD_INTERVAL_1_32:
-			tmp = "GUARD_INTERVAL_1_32";
-			break;
-		case GUARD_INTERVAL_1_16:
-			tmp = "GUARD_INTERVAL_1_16";
-			break;
-		case GUARD_INTERVAL_1_8:
-			tmp = "GUARD_INTERVAL_1_8";
-			break;
-		case GUARD_INTERVAL_1_4:
-			tmp = "GUARD_INTERVAL_1_4";
-			break;
+		case GUARD_INTERVAL_1_32: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_32; break;
+		case GUARD_INTERVAL_1_16: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_16; break;
+		case GUARD_INTERVAL_1_8: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_8; break;
+		case GUARD_INTERVAL_1_4: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_1_4; break;
 		default:
-		case GUARD_INTERVAL_AUTO:
-			tmp = "GUARD_INTERVAL_AUTO";
-			break;
+		case GUARD_INTERVAL_AUTO: tmp = eDVBFrontendParametersTerrestrial::GuardInterval_Auto; break;
 	}
 	PutToDict(dict, "guard_interval", tmp);
 	switch (parm_u_ofdm_hierarchy_information)
 	{
-		case HIERARCHY_NONE:
-			tmp = "HIERARCHY_NONE";
-			break;
-		case HIERARCHY_1:
-			tmp = "HIERARCHY_1";
-			break;
-		case HIERARCHY_2:
-			tmp = "HIERARCHY_2";
-			break;
-		case HIERARCHY_4:
-			tmp = "HIERARCHY_4";
-			break;
+		case HIERARCHY_NONE: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_None; break;
+		case HIERARCHY_1: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_1; break;
+		case HIERARCHY_2: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_2; break;
+		case HIERARCHY_4: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_4; break;
 		default:
-		case HIERARCHY_AUTO:
-			tmp = "HIERARCHY_AUTO";
-			break;
+		case HIERARCHY_AUTO: tmp = eDVBFrontendParametersTerrestrial::Hierarchy_Auto; break;
 	}
 	PutToDict(dict, "hierarchy_information", tmp);
 }
@@ -1342,20 +1208,18 @@ void eDVBFrontend::getTransponderData(ePyObject dest, bool original)
 				}
 				{
 					const FRONTENDPARAMETERS &parm = original || m_simulate ? this->parm : front;
-					const char *tmp = "INVERSION_AUTO";
+					long tmp = eDVBFrontendParametersSatellite::Inversion_Unknown;
 					switch(parm_inversion & 3)
 					{
 						case INVERSION_ON:
-							tmp = "INVERSION_ON";
+							tmp = eDVBFrontendParametersSatellite::Inversion_On;
 							break;
 						case INVERSION_OFF:
-							tmp = "INVERSION_OFF";
-							break;
+							tmp = eDVBFrontendParametersSatellite::Inversion_Off;
 						default:
 							break;
 					}
-					if (tmp)
-						PutToDict(dest, "inversion", tmp);
+					PutToDict(dest, "inversion", tmp);
 
 					switch(m_type)
 					{
@@ -1889,41 +1753,41 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
 		parm_u_qpsk_symbol_rate = feparm.symbol_rate;
 		switch (feparm.inversion)
 		{
-			case eDVBFrontendParametersSatellite::Inversion::On:
+			case eDVBFrontendParametersSatellite::Inversion_On:
 				parm_inversion = INVERSION_ON;
 				break;
-			case eDVBFrontendParametersSatellite::Inversion::Off:
+			case eDVBFrontendParametersSatellite::Inversion_Off:
 				parm_inversion = INVERSION_OFF;
 				break;
 			default:
-			case eDVBFrontendParametersSatellite::Inversion::Unknown:
+			case eDVBFrontendParametersSatellite::Inversion_Unknown:
 				parm_inversion = INVERSION_AUTO;
 				break;
 		}
-		if (feparm.system == eDVBFrontendParametersSatellite::System::DVB_S)
+		if (feparm.system == eDVBFrontendParametersSatellite::System_DVB_S)
 			switch (feparm.fec)
 			{
-				case eDVBFrontendParametersSatellite::FEC::fNone:
+				case eDVBFrontendParametersSatellite::FEC_None:
 					parm_u_qpsk_fec_inner = FEC_NONE;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f1_2:
+				case eDVBFrontendParametersSatellite::FEC_1_2:
 					parm_u_qpsk_fec_inner = FEC_1_2;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f2_3:
+				case eDVBFrontendParametersSatellite::FEC_2_3:
 					parm_u_qpsk_fec_inner = FEC_2_3;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f3_4:
+				case eDVBFrontendParametersSatellite::FEC_3_4:
 					parm_u_qpsk_fec_inner = FEC_3_4;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f5_6:
+				case eDVBFrontendParametersSatellite::FEC_5_6:
 					parm_u_qpsk_fec_inner = FEC_5_6;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f7_8:
+				case eDVBFrontendParametersSatellite::FEC_7_8:
 					parm_u_qpsk_fec_inner = FEC_7_8;
 					break;
 				default:
 					eDebugNoSimulate("no valid fec for DVB-S set.. assume auto");
-				case eDVBFrontendParametersSatellite::FEC::fAuto:
+				case eDVBFrontendParametersSatellite::FEC_Auto:
 					parm_u_qpsk_fec_inner = FEC_AUTO;
 					break;
 			}
@@ -1932,31 +1796,31 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
 		{
 			switch (feparm.fec)
 			{
-				case eDVBFrontendParametersSatellite::FEC::f1_2:
+				case eDVBFrontendParametersSatellite::FEC_1_2:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_1_2;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f2_3:
+				case eDVBFrontendParametersSatellite::FEC_2_3:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_2_3;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f3_4:
+				case eDVBFrontendParametersSatellite::FEC_3_4:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_4;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f3_5:
+				case eDVBFrontendParametersSatellite::FEC_3_5:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_3_5;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f4_5:
+				case eDVBFrontendParametersSatellite::FEC_4_5:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_4_5;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f5_6:
+				case eDVBFrontendParametersSatellite::FEC_5_6:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_5_6;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f7_8:
+				case eDVBFrontendParametersSatellite::FEC_7_8:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_7_8;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f8_9:
+				case eDVBFrontendParametersSatellite::FEC_8_9:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_8_9;
 					break;
-				case eDVBFrontendParametersSatellite::FEC::f9_10:
+				case eDVBFrontendParametersSatellite::FEC_9_10:
 					parm_u_qpsk_fec_inner = FEC_S2_QPSK_9_10;
 					break;
 				default:
@@ -1965,7 +1829,7 @@ RESULT eDVBFrontend::prepare_sat(const eDVBFrontendParametersSatellite &feparm,
 			}
 			parm_inversion |= (feparm.rolloff << 2); // Hack.. we use bit 2..3 of inversion param for rolloff
 			parm_inversion |= (feparm.pilot << 4); // Hack.. we use bit 4..5 of inversion param for pilot
-			if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation::M8PSK) {
+			if (feparm.modulation == eDVBFrontendParametersSatellite::Modulation_8PSK) {
 				parm_u_qpsk_fec_inner = (fe_code_rate_t)((int)parm_u_qpsk_fec_inner+9);
 				// 8PSK fec driver values are decimal 9 bigger
 			}
@@ -1992,66 +1856,66 @@ RESULT eDVBFrontend::prepare_cable(const eDVBFrontendParametersCable &feparm)
 	parm_u_qam_symbol_rate = feparm.symbol_rate;
 	switch (feparm.modulation)
 	{
-	case eDVBFrontendParametersCable::Modulation::QAM16:
+	case eDVBFrontendParametersCable::Modulation_QAM16:
 		parm_u_qam_modulation = QAM_16;
 		break;
-	case eDVBFrontendParametersCable::Modulation::QAM32:
+	case eDVBFrontendParametersCable::Modulation_QAM32:
 		parm_u_qam_modulation = QAM_32;
 		break;
-	case eDVBFrontendParametersCable::Modulation::QAM64:
+	case eDVBFrontendParametersCable::Modulation_QAM64:
 		parm_u_qam_modulation = QAM_64;
 		break;
-	case eDVBFrontendParametersCable::Modulation::QAM128:
+	case eDVBFrontendParametersCable::Modulation_QAM128:
 		parm_u_qam_modulation = QAM_128;
 		break;
-	case eDVBFrontendParametersCable::Modulation::QAM256:
+	case eDVBFrontendParametersCable::Modulation_QAM256:
 		parm_u_qam_modulation = QAM_256;
 		break;
 	default:
-	case eDVBFrontendParametersCable::Modulation::Auto:
+	case eDVBFrontendParametersCable::Modulation_Auto:
 		parm_u_qam_modulation = QAM_AUTO;
 		break;
 	}
 	switch (feparm.inversion)
 	{
-	case eDVBFrontendParametersCable::Inversion::On:
+	case eDVBFrontendParametersCable::Inversion_On:
 		parm_inversion = INVERSION_ON;
 		break;
-	case eDVBFrontendParametersCable::Inversion::Off:
+	case eDVBFrontendParametersCable::Inversion_Off:
 		parm_inversion = INVERSION_OFF;
 		break;
 	default:
-	case eDVBFrontendParametersCable::Inversion::Unknown:
+	case eDVBFrontendParametersCable::Inversion_Unknown:
 		parm_inversion = INVERSION_AUTO;
 		break;
 	}
 	switch (feparm.fec_inner)
 	{
-	case eDVBFrontendParametersCable::FEC::fNone:
+	case eDVBFrontendParametersCable::FEC_None:
 		parm_u_qam_fec_inner = FEC_NONE;
 		break;
-	case eDVBFrontendParametersCable::FEC::f1_2:
+	case eDVBFrontendParametersCable::FEC_1_2:
 		parm_u_qam_fec_inner = FEC_1_2;
 		break;
-	case eDVBFrontendParametersCable::FEC::f2_3:
+	case eDVBFrontendParametersCable::FEC_2_3:
 		parm_u_qam_fec_inner = FEC_2_3;
 		break;
-	case eDVBFrontendParametersCable::FEC::f3_4:
+	case eDVBFrontendParametersCable::FEC_3_4:
 		parm_u_qam_fec_inner = FEC_3_4;
 		break;
-	case eDVBFrontendParametersCable::FEC::f5_6:
+	case eDVBFrontendParametersCable::FEC_5_6:
 		parm_u_qam_fec_inner = FEC_5_6;
 		break;
-	case eDVBFrontendParametersCable::FEC::f7_8:
+	case eDVBFrontendParametersCable::FEC_7_8:
 		parm_u_qam_fec_inner = FEC_7_8;
 		break;
 #if HAVE_DVB_API_VERSION >= 3
-	case eDVBFrontendParametersCable::FEC::f8_9:
+	case eDVBFrontendParametersCable::FEC_8_9:
 		parm_u_qam_fec_inner = FEC_8_9;
 		break;
 #endif
 	default:
-	case eDVBFrontendParametersCable::FEC::fAuto:
+	case eDVBFrontendParametersCable::FEC_Auto:
 		parm_u_qam_fec_inner = FEC_AUTO;
 		break;
 	}
@@ -2070,141 +1934,141 @@ RESULT eDVBFrontend::prepare_terrestrial(const eDVBFrontendParametersTerrestrial
 
 	switch (feparm.bandwidth)
 	{
-	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw8MHz:
+	case eDVBFrontendParametersTerrestrial::Bandwidth_8MHz:
 		parm_u_ofdm_bandwidth = BANDWIDTH_8_MHZ;
 		break;
-	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw7MHz:
+	case eDVBFrontendParametersTerrestrial::Bandwidth_7MHz:
 		parm_u_ofdm_bandwidth = BANDWIDTH_7_MHZ;
 		break;
-	case eDVBFrontendParametersTerrestrial::Bandwidth::Bw6MHz:
+	case eDVBFrontendParametersTerrestrial::Bandwidth_6MHz:
 		parm_u_ofdm_bandwidth = BANDWIDTH_6_MHZ;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::Bandwidth::BwAuto:
+	case eDVBFrontendParametersTerrestrial::Bandwidth_Auto:
 		parm_u_ofdm_bandwidth = BANDWIDTH_AUTO;
 		break;
 	}
 	switch (feparm.code_rate_LP)
 	{
-	case eDVBFrontendParametersTerrestrial::FEC::f1_2:
+	case eDVBFrontendParametersTerrestrial::FEC_1_2:
 		parm_u_ofdm_code_rate_LP = FEC_1_2;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f2_3:
+	case eDVBFrontendParametersTerrestrial::FEC_2_3:
 		parm_u_ofdm_code_rate_LP = FEC_2_3;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f3_4:
+	case eDVBFrontendParametersTerrestrial::FEC_3_4:
 		parm_u_ofdm_code_rate_LP = FEC_3_4;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f5_6:
+	case eDVBFrontendParametersTerrestrial::FEC_5_6:
 		parm_u_ofdm_code_rate_LP = FEC_5_6;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f7_8:
+	case eDVBFrontendParametersTerrestrial::FEC_7_8:
 		parm_u_ofdm_code_rate_LP = FEC_7_8;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::FEC::fAuto:
+	case eDVBFrontendParametersTerrestrial::FEC_Auto:
 		parm_u_ofdm_code_rate_LP = FEC_AUTO;
 		break;
 	}
 	switch (feparm.code_rate_HP)
 	{
-	case eDVBFrontendParametersTerrestrial::FEC::f1_2:
+	case eDVBFrontendParametersTerrestrial::FEC_1_2:
 		parm_u_ofdm_code_rate_HP = FEC_1_2;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f2_3:
+	case eDVBFrontendParametersTerrestrial::FEC_2_3:
 		parm_u_ofdm_code_rate_HP = FEC_2_3;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f3_4:
+	case eDVBFrontendParametersTerrestrial::FEC_3_4:
 		parm_u_ofdm_code_rate_HP = FEC_3_4;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f5_6:
+	case eDVBFrontendParametersTerrestrial::FEC_5_6:
 		parm_u_ofdm_code_rate_HP = FEC_5_6;
 		break;
-	case eDVBFrontendParametersTerrestrial::FEC::f7_8:
+	case eDVBFrontendParametersTerrestrial::FEC_7_8:
 		parm_u_ofdm_code_rate_HP = FEC_7_8;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::FEC::fAuto:
+	case eDVBFrontendParametersTerrestrial::FEC_Auto:
 		parm_u_ofdm_code_rate_HP = FEC_AUTO;
 		break;
 	}
 	switch (feparm.modulation)
 	{
-	case eDVBFrontendParametersTerrestrial::Modulation::QPSK:
+	case eDVBFrontendParametersTerrestrial::Modulation_QPSK:
 		parm_u_ofdm_constellation = QPSK;
 		break;
-	case eDVBFrontendParametersTerrestrial::Modulation::QAM16:
+	case eDVBFrontendParametersTerrestrial::Modulation_QAM16:
 		parm_u_ofdm_constellation = QAM_16;
 		break;
-	case eDVBFrontendParametersTerrestrial::Modulation::QAM64:
+	case eDVBFrontendParametersTerrestrial::Modulation_QAM64:
 		parm_u_ofdm_constellation = QAM_64;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::Modulation::Auto:
+	case eDVBFrontendParametersTerrestrial::Modulation_Auto:
 		parm_u_ofdm_constellation = QAM_AUTO;
 		break;
 	}
 	switch (feparm.transmission_mode)
 	{
-	case eDVBFrontendParametersTerrestrial::TransmissionMode::TM2k:
+	case eDVBFrontendParametersTerrestrial::TransmissionMode_2k:
 		parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_2K;
 		break;
-	case eDVBFrontendParametersTerrestrial::TransmissionMode::TM8k:
+	case eDVBFrontendParametersTerrestrial::TransmissionMode_8k:
 		parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_8K;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::TransmissionMode::TMAuto:
+	case eDVBFrontendParametersTerrestrial::TransmissionMode_Auto:
 		parm_u_ofdm_transmission_mode = TRANSMISSION_MODE_AUTO;
 		break;
 	}
 	switch (feparm.guard_interval)
 	{
-		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_32:
+		case eDVBFrontendParametersTerrestrial::GuardInterval_1_32:
 			parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_32;
 			break;
-		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_16:
+		case eDVBFrontendParametersTerrestrial::GuardInterval_1_16:
 			parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_16;
 			break;
-		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_8:
+		case eDVBFrontendParametersTerrestrial::GuardInterval_1_8:
 			parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_8;
 			break;
-		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_1_4:
+		case eDVBFrontendParametersTerrestrial::GuardInterval_1_4:
 			parm_u_ofdm_guard_interval = GUARD_INTERVAL_1_4;
 			break;
 		default:
-		case eDVBFrontendParametersTerrestrial::GuardInterval::GI_Auto:
+		case eDVBFrontendParametersTerrestrial::GuardInterval_Auto:
 			parm_u_ofdm_guard_interval = GUARD_INTERVAL_AUTO;
 			break;
 	}
 	switch (feparm.hierarchy)
 	{
-		case eDVBFrontendParametersTerrestrial::Hierarchy::HNone:
+		case eDVBFrontendParametersTerrestrial::Hierarchy_None:
 			parm_u_ofdm_hierarchy_information = HIERARCHY_NONE;
 			break;
-		case eDVBFrontendParametersTerrestrial::Hierarchy::H1:
+		case eDVBFrontendParametersTerrestrial::Hierarchy_1:
 			parm_u_ofdm_hierarchy_information = HIERARCHY_1;
 			break;
-		case eDVBFrontendParametersTerrestrial::Hierarchy::H2:
+		case eDVBFrontendParametersTerrestrial::Hierarchy_2:
 			parm_u_ofdm_hierarchy_information = HIERARCHY_2;
 			break;
-		case eDVBFrontendParametersTerrestrial::Hierarchy::H4:
+		case eDVBFrontendParametersTerrestrial::Hierarchy_4:
 			parm_u_ofdm_hierarchy_information = HIERARCHY_4;
 			break;
 		default:
-		case eDVBFrontendParametersTerrestrial::Hierarchy::HAuto:
+		case eDVBFrontendParametersTerrestrial::Hierarchy_Auto:
 			parm_u_ofdm_hierarchy_information = HIERARCHY_AUTO;
 			break;
 	}
 	switch (feparm.inversion)
 	{
-	case eDVBFrontendParametersTerrestrial::Inversion::On:
+	case eDVBFrontendParametersTerrestrial::Inversion_On:
 		parm_inversion = INVERSION_ON;
 		break;
-	case eDVBFrontendParametersTerrestrial::Inversion::Off:
+	case eDVBFrontendParametersTerrestrial::Inversion_Off:
 		parm_inversion = INVERSION_OFF;
 		break;
 	default:
-	case eDVBFrontendParametersTerrestrial::Inversion::Unknown:
+	case eDVBFrontendParametersTerrestrial::Inversion_Unknown:
 		parm_inversion = INVERSION_AUTO;
 		break;
 	}
@@ -2514,10 +2378,10 @@ int eDVBFrontend::isCompatibleWith(ePtr<iDVBFrontendParameters> &feparm)
 		eDVBFrontendParametersSatellite sat_parm;
 		int ret = feparm->getDVBS(sat_parm);
 		ASSERT(!ret);
-		if (sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S2 && !m_can_handle_dvbs2)
+		if (sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S2 && !m_can_handle_dvbs2)
 			return 0;
 		ret = m_sec->canTune(sat_parm, this, 1 << m_slotid);
-		if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System::DVB_S && m_can_handle_dvbs2)
+		if (ret > 1 && sat_parm.system == eDVBFrontendParametersSatellite::System_DVB_S && m_can_handle_dvbs2)
 			ret -= 1;
 		return ret;
 	}
diff --git a/lib/dvb/frontendparms.h b/lib/dvb/frontendparms.h
index 961dfd00..b537963f 100644
--- a/lib/dvb/frontendparms.h
+++ b/lib/dvb/frontendparms.h
@@ -12,42 +12,35 @@ struct eDVBFrontendParametersSatellite
 #ifndef SWIG
 	void set(const SatelliteDeliverySystemDescriptor  &);
 #endif
-	struct Polarisation {
-		enum {
-			Horizontal, Vertical, CircularLeft, CircularRight
-		};
+	enum {
+		Polarisation_Horizontal, Polarisation_Vertical, Polarisation_CircularLeft, Polarisation_CircularRight
 	};
-	struct Inversion {
-		enum {
-			Off, On, Unknown
-		};
+
+	enum {
+		Inversion_Off, Inversion_On, Inversion_Unknown
 	};
-	struct FEC {
-		enum {
-			fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, f3_5, f4_5, f9_10, fNone=15
-		};
+
+	enum {
+		FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_3_5, FEC_4_5, FEC_9_10, FEC_None=15
 	};
-	struct System {
-		enum {
-			DVB_S, DVB_S2
-		};
+
+	enum {
+		System_DVB_S, System_DVB_S2
 	};
-	struct Modulation {
-		enum {
-			Auto, QPSK, M8PSK, QAM_16
-		};
+
+	enum {
+		Modulation_Auto, Modulation_QPSK, Modulation_8PSK, Modulation_QAM16
 	};
+
 	// dvb-s2
-	struct RollOff {
-		enum {
-			alpha_0_35, alpha_0_25, alpha_0_20
-		};
+	enum {
+		RollOff_alpha_0_35, RollOff_alpha_0_25, RollOff_alpha_0_20
 	};
-	struct Pilot {  
-		enum {
-			Off, On, Unknown
-		};
+
+	enum {
+		Pilot_Off, Pilot_On, Pilot_Unknown
 	};
+
 	bool no_rotor_command_on_tune;
 	unsigned int frequency, symbol_rate;
 	int polarisation, fec, inversion, orbital_position, system, modulation, rolloff, pilot;
@@ -59,21 +52,18 @@ struct eDVBFrontendParametersCable
 #ifndef SWIG
 	void set(const CableDeliverySystemDescriptor  &);
 #endif
-	struct Inversion {
-		enum {
-			Off, On, Unknown
-		};
+	enum {
+		Inversion_Off, Inversion_On, Inversion_Unknown
 	};
-	struct FEC {
-		enum {
-			fAuto, f1_2, f2_3, f3_4, f5_6, f7_8, f8_9, fNone=15
-		};
+
+	enum {
+		FEC_Auto, FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_8_9, FEC_None=15
 	};
-	struct Modulation {
-		enum {
-			Auto, QAM16, QAM32, QAM64, QAM128, QAM256
-		};
+
+	enum {
+		Modulation_Auto, Modulation_QAM16, Modulation_QAM32, Modulation_QAM64, Modulation_QAM128, Modulation_QAM256
 	};
+
 	unsigned int frequency, symbol_rate;
 	int modulation, inversion, fec_inner;
 };
@@ -84,42 +74,34 @@ struct eDVBFrontendParametersTerrestrial
 #ifndef SWIG
 	void set(const TerrestrialDeliverySystemDescriptor  &);
 #endif
-	struct Bandwidth {
-		enum {
-			Bw8MHz, Bw7MHz, Bw6MHz, /*Bw5MHz,*/ BwAuto
-		}; // Bw5Mhz nyi (compatibilty with enigma1)
-	};
-	struct FEC {
-		enum {
-			f1_2, f2_3, f3_4, f5_6, f7_8, fAuto
-		};
-	};
-	struct TransmissionMode {
-		enum {
-			TM2k, TM8k, /*TM4k,*/ TMAuto
-		}; // TM4k nyi (compatibility with enigma1)
+	enum {
+		Bandwidth_8MHz, Bandwidth_7MHz, Bandwidth_6MHz, /*Bandwidth_5MHz,*/ Bandwidth_Auto
+	}; // Bw5Mhz nyi (compatibilty with enigma1)
+
+	enum {
+		FEC_1_2, FEC_2_3, FEC_3_4, FEC_5_6, FEC_7_8, FEC_Auto
 	};
-	struct GuardInterval {
-		enum {
-			GI_1_32, GI_1_16, GI_1_8, GI_1_4, GI_Auto
-		};
+
+	enum {
+		TransmissionMode_2k, TransmissionMode_8k, /*TransmissionMode_4k,*/ TransmissionMode_Auto
+	}; // TM4k nyi (compatibility with enigma1)
+
+	enum {
+		GuardInterval_1_32, GuardInterval_1_16, GuardInterval_1_8, GuardInterval_1_4, GuardInterval_Auto
 	};
-	struct Hierarchy {
-		enum {
-			HNone, H1, H2, H4, HAuto
-		};
+
+	enum {
+		Hierarchy_None, Hierarchy_1, Hierarchy_2, Hierarchy_4, Hierarchy_Auto
 	};
-	struct Modulation {
-		enum {
-			QPSK, QAM16, QAM64, Auto
-		};
+
+	enum {
+		Modulation_QPSK, Modulation_QAM16, Modulation_QAM64, Modulation_Auto
 	};
-	struct Inversion
-	{
-		enum {
-			Off, On, Unknown
-		};
+
+	enum {
+		Inversion_Off, Inversion_On, Inversion_Unknown
 	};
+
 	unsigned int frequency;
 	int bandwidth;
 	int code_rate_HP, code_rate_LP;
diff --git a/lib/dvb/pmt.cpp b/lib/dvb/pmt.cpp
index 0c21272a..279ec74f 100644
--- a/lib/dvb/pmt.cpp
+++ b/lib/dvb/pmt.cpp
@@ -16,6 +16,7 @@
 #include <dvbsi++/stream_identifier_descriptor.h>
 #include <dvbsi++/subtitling_descriptor.h>
 #include <dvbsi++/teletext_descriptor.h>
+#include <dvbsi++/video_stream_descriptor.h>
 
 eDVBServicePMTHandler::eDVBServicePMTHandler()
 	:m_ca_servicePtr(0), m_dvb_scan(0), m_decode_demux_num(0xFF)
@@ -217,25 +218,49 @@ int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 					audioStream audio;
 					audio.component_tag=video.component_tag=-1;
 					video.type = videoStream::vtMPEG2;
+					audio.type = audioStream::atMPEG;
 
 					switch ((*es)->getType())
 					{
 					case 0x1b: // AVC Video Stream (MPEG4 H264)
 						video.type = videoStream::vtMPEG4_H264;
+						isvideo = 1;
+						//break; fall through !!!
+					case 0x10: // MPEG 4 Part 2
+						if (!isvideo)
+						{
+							video.type = videoStream::vtMPEG4_Part2;
+							isvideo = 1;
+						}
+						//break; fall through !!!
 					case 0x01: // MPEG 1 video
+						if (!isvideo)
+							video.type = videoStream::vtMPEG1;
+						//break; fall through !!!
 					case 0x02: // MPEG 2 video
 						isvideo = 1;
 						//break; fall through !!!
 					case 0x03: // MPEG 1 audio
 					case 0x04: // MPEG 2 audio:
 						if (!isvideo)
+							isaudio = 1;
+						//break; fall through !!!
+					case 0x0f: // MPEG 2 AAC
+						if (!isvideo && !isaudio)
 						{
 							isaudio = 1;
-							audio.type = audioStream::atMPEG;
+							audio.type = audioStream::atAAC;
 						}
 						//break; fall through !!!
+					case 0x11: // MPEG 4 AAC
+						if (!isvideo && !isaudio)
+						{
+							isaudio = 1;
+							audio.type = audioStream::atAACHE;
+						}
 					case 0x06: // PES Private
 					case 0x81: // user private
+					case 0xEA: // TS_PSI_ST_SMPTE_VC1
 						for (DescriptorConstIterator desc = (*es)->getDescriptors()->begin();
 								desc != (*es)->getDescriptors()->end(); ++desc)
 						{
@@ -246,6 +271,17 @@ int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 								   check descriptors to get the exakt type. */
 								switch (tag)
 								{
+								case AUDIO_STREAM_DESCRIPTOR:
+									isaudio = 1;
+									break;
+								case VIDEO_STREAM_DESCRIPTOR:
+								{
+									isvideo = 1;
+									VideoStreamDescriptor *d = (VideoStreamDescriptor*)(*desc);
+									if (d->getMpeg1OnlyFlag())
+										video.type = videoStream::vtMPEG1;
+									break;
+								}
 								case SUBTITLING_DESCRIPTOR:
 								{
 									SubtitlingDescriptor *d = (SubtitlingDescriptor*)(*desc);
@@ -304,9 +340,14 @@ int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 									isaudio = 1;
 									audio.type = audioStream::atDTS;
 									break;
+								case 0x2B: // TS_PSI_DT_MPEG2_AAC
+									isaudio = 1;
+									audio.type = audioStream::atAAC; // MPEG2-AAC
+									break;
+								case 0x1C: // TS_PSI_DT_MPEG4_Audio
 								case AAC_DESCRIPTOR:
 									isaudio = 1;
-									audio.type = audioStream::atAAC;
+									audio.type = audioStream::atAACHE; // MPEG4-AAC
 									break;
 								case AC3_DESCRIPTOR:
 									isaudio = 1;
@@ -315,7 +356,7 @@ int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 								case REGISTRATION_DESCRIPTOR: /* some services don't have a separate AC3 descriptor */
 								{
 										/* libdvbsi++ doesn't yet support this descriptor type, so work around. */
-									if ((*desc)->getLength() != 4)
+									if ((*desc)->getLength() < 4)
 										break;
 									unsigned char descr[6];
 									(*desc)->writeToBuffer(descr);
@@ -326,11 +367,29 @@ int eDVBServicePMTHandler::getProgramInfo(struct program &program)
 										isaudio = 1;
 										audio.type = audioStream::atAC3;
 										break;
+									case 0x56432d31:
+										if (descr[6] == 0x01) // subdescriptor tag
+										{
+											if (descr[7] >= 0x90) // profile_level
+												video.type = videoStream::vtVC1; // advanced profile
+											else
+												video.type = videoStream::vtVC1_SM; // simple main
+											isvideo = 1;
+										}
+										break;
 									default:
 										break;
 									}
 									break;
 								}
+								case 0x28: // TS_PSI_DT_AVC
+									isvideo = 1;
+									video.type = videoStream::vtMPEG4_H264;
+									break;
+								case 0x1B: // TS_PSI_DT_MPEG4_Video
+									isvideo = 1;
+									video.type = videoStream::vtMPEG4_Part2;
+									break;
 								default:
 									break;
 								}
diff --git a/lib/dvb/pmt.h b/lib/dvb/pmt.h
index ff0ef046..3e22174b 100644
--- a/lib/dvb/pmt.h
+++ b/lib/dvb/pmt.h
@@ -135,14 +135,14 @@ public:
 	{
 		int pid;
 		int component_tag;
-		enum { vtMPEG2, vtMPEG4_H264 };
+		enum { vtMPEG2, vtMPEG4_H264, vtMPEG1, vtMPEG4_Part2, vtVC1, vtVC1_SM };
 		int type;
 	};
 	
 	struct audioStream
 	{
 		int pid;
-		enum { atMPEG, atAC3, atDTS, atAAC };
+		enum { atMPEG, atAC3, atDTS, atAAC, atAACHE };
 		int type; // mpeg2, ac3, dts, ...
 		
 		int component_tag;
diff --git a/lib/dvb/sec.cpp b/lib/dvb/sec.cpp
index 6f64cf56..ac1a2028 100644
--- a/lib/dvb/sec.cpp
+++ b/lib/dvb/sec.cpp
@@ -99,7 +99,7 @@ int eDVBSatelliteEquipmentControl::canTune(const eDVBFrontendParametersSatellite
 
 				if ( sat.frequency > lnb_param.m_lof_threshold )
 					band |= 1;
-				if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+				if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical))
 					band |= 2;
 
 				if (di_param.m_diseqc_mode >= eDVBSatelliteDiseqcParameters::V1_0)
@@ -373,7 +373,7 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 
 			if ( sat.frequency > lnb_param.m_lof_threshold )
 				band |= 1;
-			if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical))
+			if (!(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical))
 				band |= 2;
 
 			int lof = (band&1)?lnb_param.m_lof_hi:lnb_param.m_lof_lo;
@@ -390,11 +390,11 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 				frontend.setData(eDVBFrontend::FREQ_OFFSET, sat.frequency - parm.FREQUENCY);
 
 				if ( voltage_mode == eDVBSatelliteSwitchParameters::_14V
-					|| ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical
+					|| ( sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical
 						&& voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
 					voltage = VOLTAGE(13);
 				else if ( voltage_mode == eDVBSatelliteSwitchParameters::_18V
-					|| ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation::Vertical)
+					|| ( !(sat.polarisation & eDVBFrontendParametersSatellite::Polarisation_Vertical)
 						&& voltage_mode == eDVBSatelliteSwitchParameters::HV )  )
 					voltage = VOLTAGE(18);
 				if ( (sw_param.m_22khz_signal == eDVBSatelliteSwitchParameters::ON)
@@ -936,12 +936,12 @@ RESULT eDVBSatelliteEquipmentControl::prepare(iDVBFrontend &frontend, FRONTENDPA
 	eDebugNoSimulate("found no useable satellite configuration for %s freq %d%s %s on orbital position (%d)",
 		sat.system ? "DVB-S2" : "DVB-S",
 		sat.frequency,
-		sat.polarisation == eDVBFrontendParametersSatellite::Polarisation::Horizontal ? "H" :
-			eDVBFrontendParametersSatellite::Polarisation::Vertical ? "V" :
-			eDVBFrontendParametersSatellite::Polarisation::CircularLeft ? "CL" : "CR",
-		sat.modulation == eDVBFrontendParametersSatellite::Modulation::Auto ? "AUTO" :
-			eDVBFrontendParametersSatellite::Modulation::QPSK ? "QPSK" :
-			eDVBFrontendParametersSatellite::Modulation::M8PSK ? "8PSK" : "QAM16",
+		sat.polarisation == eDVBFrontendParametersSatellite::Polarisation_Horizontal ? "H" :
+			eDVBFrontendParametersSatellite::Polarisation_Vertical ? "V" :
+			eDVBFrontendParametersSatellite::Polarisation_CircularLeft ? "CL" : "CR",
+		sat.modulation == eDVBFrontendParametersSatellite::Modulation_Auto ? "AUTO" :
+			eDVBFrontendParametersSatellite::Modulation_QPSK ? "QPSK" :
+			eDVBFrontendParametersSatellite::Modulation_8PSK ? "8PSK" : "QAM16",
 		sat.orbital_position );
 	return -1;
 }