Merge pull request #4306 from WXbet/softcsa-fixes

WanWizard · web-flow · commit 62674464e7cc · 2026-02-15T22:45:41.000Z
Softcsa fixes
diff --git a/lib/dvb/cahandler.cpp b/lib/dvb/cahandler.cpp
@@ -405,23 +405,24 @@ void eDVBCAHandler::newConnection(int socket)
 	ePMTClient *client = new ePMTClient(this, client_fd);
 	clients.push_back(client);
 
-	/* Always distribute current CAPMTs first (legacy format, works for all clients) */
-	distributeCAPMT();
-
-	/* Send CLIENT_INFO only when appropriate:
-	 * - Protocol-3 already established (OSCam reconnect): always send
-	 * - First connection ever: send to probe for Protocol-3 support
-	 * - Legacy client detected (no SERVER_INFO after first attempt): skip
-	 *   to avoid unnecessary errors in legacy softcam logs */
 	if (m_protocol3_established)
 	{
+		/* Protocol-3 reconnect: complete handshake first, distributeCAPMT()
+		 * will be called from processServerInfoPacket() */
 		client->sendClientInfo();
 	}
 	else if (!m_handshake_attempted)
 	{
+		/* First connection: send legacy CAPMTs, then probe for Protocol-3 */
+		distributeCAPMT();
 		client->sendClientInfo();
 		m_handshake_attempted = true;
 	}
+	else
+	{
+		/* Legacy softcam - send CAPMTs immediately */
+		distributeCAPMT();
+	}
 }
 
 void eDVBCAHandler::connectionLost(ePMTClient *client)
@@ -569,6 +570,25 @@ int eDVBCAHandler::unregisterService(const eServiceReferenceDVB &ref, int adapte
 			{
 				if (!used_demux_slots)  // no more used.. so we remove it
 				{
+					/*
+					 * Send CMD_NOT_SELECTED to tell the softcam to stop
+					 * descrambling this service before we delete it.
+					 * Without this, switching from an encrypted channel
+					 * to FTA/IPTV would leave the softcam in descrambling
+					 * state (e.g. ecm.info not removed).
+					 */
+					if (m_protocol3_established && caservice->getCAPMTVersion() >= 0)
+					{
+						for (ePtrList<ePMTClient>::iterator client_it = clients.begin(); client_it != clients.end(); ++client_it)
+						{
+							if (client_it->state() == eSocket::Connection)
+							{
+								eDebug("[eDVBCAHandler] sending CMD_NOT_SELECTED for service %s", caservice->toString().c_str());
+								caservice->writeCAPMTObject(*client_it, LIST_UPDATE, CMD_NOT_SELECTED);
+							}
+						}
+					}
+
 					delete it->second;
 					services.erase(it);
 
diff --git a/lib/dvb/csasession.cpp b/lib/dvb/csasession.cpp
@@ -141,10 +141,18 @@ void eDVBCSASession::startECMMonitor(iDVBDemux *demux, uint16_t ecm_pid, uint16_
 
 		if (info.is_csa_alt && !m_active)
 		{
-			eDebug("[eDVBCSASession] ECM Monitor: Activating from cache (CSA-ALT)");
 			m_ecm_analyzed = true;
 			m_csa_alt = true;
-			setActive(true);
+			if (shouldSuppressActivation && shouldSuppressActivation())
+			{
+				eDebug("[eDVBCSASession] ECM Monitor: CSA-ALT cached but activation suppressed (CI module)");
+				stopECMMonitor();
+			}
+			else
+			{
+				eDebug("[eDVBCSASession] ECM Monitor: Activating from cache (CSA-ALT)");
+				setActive(true);
+			}
 		}
 	}
 
@@ -235,7 +243,15 @@ void eDVBCSASession::ecmDataReceived(const uint8_t *data)
 			eDebug("[eDVBCSASession] CSA-ALT detected from ECM! Activating software descrambling");
 			if (!m_active)
 			{
-				setActive(true);
+				if (shouldSuppressActivation && shouldSuppressActivation())
+				{
+					eDebug("[eDVBCSASession] Activation suppressed (CI module handles decryption)");
+					stopECMMonitor();
+				}
+				else
+				{
+					setActive(true);
+				}
 			}
 		}
 		else
diff --git a/lib/dvb/csasession.h b/lib/dvb/csasession.h
@@ -5,6 +5,7 @@
 #include <lib/dvb/idvb.h>
 #include <lib/base/ebase.h>
 #include <sigc++/sigc++.h>
+#include <functional>
 
 class eDVBCSAEngine;
 class eDVBCAHandler;
@@ -91,6 +92,10 @@ class eDVBCSASession : public iServiceScrambled, public sigc::trackable
 	// Signal when first CW is received (for decoder start timing)
 	sigc::signal<void()> firstCwReceived;
 
+	// Optional callback to check if activation should be suppressed
+	// (e.g. CI module handles decryption). Return true to suppress.
+	std::function<bool()> shouldSuppressActivation;
+
 private:
 	eServiceReferenceDVB m_service_ref;
 	ePtr<eDVBCSAEngine> m_engine;
diff --git a/lib/dvb/cwhandler.cpp b/lib/dvb/cwhandler.cpp
@@ -257,6 +257,7 @@ void eDVBCWHandler::threadLoop()
 			const Connection& conn = conns_snapshot[i];
 
 			// Softcam → proxy_fd (and intercept CWs)
+			bool softcam_disconnected = false;
 			if (pfds[softcam_idx].revents & POLLIN)
 			{
 				ssize_t n = ::read(conn.softcam_fd, buf, sizeof(buf));
@@ -283,31 +284,40 @@ void eDVBCWHandler::threadLoop()
 						written += w;
 					}
 				}
+				else if (n == 0)
+				{
+					// EOF - softcam closed the connection
+					eDebug("[eDVBCWHandler] Softcam EOF on fd %d", conn.softcam_fd);
+					softcam_disconnected = true;
+				}
+				else if (errno != EINTR && errno != EAGAIN)
+				{
+					eDebug("[eDVBCWHandler] Softcam read error on fd %d: %m", conn.softcam_fd);
+					softcam_disconnected = true;
+				}
 			}
 
 			// Handle softcam disconnect
-			if (pfds[softcam_idx].revents & (POLLHUP | POLLERR))
+			if (softcam_disconnected || (pfds[softcam_idx].revents & (POLLHUP | POLLERR)))
 			{
-				if (!(pfds[softcam_idx].revents & POLLIN)) // Only if no data pending
+				eDebug("[eDVBCWHandler] Softcam disconnected on fd %d", conn.softcam_fd);
+				// Close proxy_fd so ePMTClient gets connectionLost
+				std::lock_guard<std::mutex> lock(m_connections_mutex);
+				for (auto it = m_connections.begin(); it != m_connections.end(); ++it)
 				{
-					eDebug("[eDVBCWHandler] Softcam disconnected on fd %d", conn.softcam_fd);
-					// Close proxy_fd so ePMTClient gets connectionLost
-					std::lock_guard<std::mutex> lock(m_connections_mutex);
-					for (auto it = m_connections.begin(); it != m_connections.end(); ++it)
+					if (it->softcam_fd == conn.softcam_fd)
 					{
-						if (it->softcam_fd == conn.softcam_fd)
-						{
-							::close(it->softcam_fd);
-							::close(it->proxy_fd);
-							m_connections.erase(it);
-							break;
-						}
+						::close(it->softcam_fd);
+						::close(it->proxy_fd);
+						m_connections.erase(it);
+						break;
 					}
-					continue;
 				}
+				continue;
 			}
 
 			// proxy_fd → softcam (CAPMT writes from ePMTClient)
+			bool proxy_disconnected = false;
 			if (pfds[proxy_idx].revents & POLLIN)
 			{
 				ssize_t n = ::read(conn.proxy_fd, buf, sizeof(buf));
@@ -330,24 +340,31 @@ void eDVBCWHandler::threadLoop()
 						written += w;
 					}
 				}
+				else if (n == 0)
+				{
+					eDebug("[eDVBCWHandler] ePMTClient EOF on proxy_fd %d", conn.proxy_fd);
+					proxy_disconnected = true;
+				}
+				else if (errno != EINTR && errno != EAGAIN)
+				{
+					eDebug("[eDVBCWHandler] ePMTClient read error on proxy_fd %d: %m", conn.proxy_fd);
+					proxy_disconnected = true;
+				}
 			}
 
 			// Handle ePMTClient disconnect
-			if (pfds[proxy_idx].revents & (POLLHUP | POLLERR))
+			if (proxy_disconnected || (pfds[proxy_idx].revents & (POLLHUP | POLLERR)))
 			{
-				if (!(pfds[proxy_idx].revents & POLLIN))
+				eDebug("[eDVBCWHandler] ePMTClient disconnected on proxy_fd %d", conn.proxy_fd);
+				std::lock_guard<std::mutex> lock(m_connections_mutex);
+				for (auto it = m_connections.begin(); it != m_connections.end(); ++it)
 				{
-					eDebug("[eDVBCWHandler] ePMTClient disconnected on proxy_fd %d", conn.proxy_fd);
-					std::lock_guard<std::mutex> lock(m_connections_mutex);
-					for (auto it = m_connections.begin(); it != m_connections.end(); ++it)
+					if (it->proxy_fd == conn.proxy_fd)
 					{
-						if (it->proxy_fd == conn.proxy_fd)
-						{
-							::close(it->softcam_fd);
-							::close(it->proxy_fd);
-							m_connections.erase(it);
-							break;
-						}
+						::close(it->softcam_fd);
+						::close(it->proxy_fd);
+						m_connections.erase(it);
+						break;
 					}
 				}
 			}
diff --git a/lib/dvb/pmt.cpp b/lib/dvb/pmt.cpp
@@ -182,8 +182,6 @@ void eDVBServicePMTHandler::PMTready(int error)
 			{
 				eDVBCIInterfaces::getInstance()->recheckPMTHandlers();
 				eDVBCIInterfaces::getInstance()->gotPMT(this);
-				if (isCiConnected())
-					serviceEvent(eventCIConnected);
 			}
 		}
 		if (m_ca_servicePtr)
diff --git a/lib/dvb/pmt.h b/lib/dvb/pmt.h
@@ -117,8 +117,6 @@ class eDVBServicePMTHandler: public eDVBPMTParser
 
 		eventStopped,
 		eventChannelAllocated,
-		eventStreamCorrupt,
-		eventCIConnected,  // a CI slot was assigned to this service after recheckPMTHandlers
 	};
 #ifndef SWIG
 	sigc::signal<void(int)> serviceEvent;
@@ -139,6 +137,7 @@ class eDVBServicePMTHandler: public eDVBPMTParser
 	void sendEventNoPatEntry();
 	void getHBBTVUrl(std::string &ret) const { ret = m_HBBTVUrl; }
 	void setCaDisable(bool disable) { m_ca_disabled = disable; }
+	bool isCiConnected();
 	void allocatePVRChannel();
 
 	enum serviceType
@@ -167,7 +166,6 @@ class eDVBServicePMTHandler: public eDVBPMTParser
 	void free();
 	void addCaHandler();
 	void removeCaHandler();
-	bool isCiConnected();
 private:
 	bool m_have_cached_program;
 	program m_cached_program;
diff --git a/lib/dvb_ci/dvbci.cpp b/lib/dvb_ci/dvbci.cpp
@@ -800,7 +800,6 @@ void eDVBCIInterfaces::gotPMT(eDVBServicePMTHandler *pmthandler)
 bool eDVBCIInterfaces::isCiConnected(eDVBServicePMTHandler *pmthandler)
 {
 	bool ret = false;
-	singleLock s(m_pmt_handler_lock);
 	PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(), m_pmt_handlers.end(), pmthandler);
 	if (it != m_pmt_handlers.end() && it->cislot)
 	{
diff --git a/lib/dvb_ci/dvbci.h b/lib/dvb_ci/dvbci.h
@@ -215,7 +215,6 @@ class eDVBCIInterfaces: public eMainloop, private eThread
 	void recheckPMTHandlers();
 	void executeRecheckPMTHandlersInMainloop();
 	void gotPMT(eDVBServicePMTHandler *pmthandler);
-	bool isCiConnected(eDVBServicePMTHandler *pmthandler);
 	void ciRemoved(eDVBCISlot *slot);
 	int getSlotState(int slot);
 
@@ -228,6 +227,7 @@ class eDVBCIInterfaces: public eMainloop, private eThread
 	int answerEnq(int slot, char *value);
 	int cancelEnq(int slot);
 	int getMMIState(int slot);
+	bool isCiConnected(eDVBServicePMTHandler *pmthandler);
 	int setInputSource(int tunerno, const std::string &source);
 	int setCIClockRate(int slot, int rate);
 	void setCIPlusRouting(int slotid);
diff --git a/lib/service/servicedvb.cpp b/lib/service/servicedvb.cpp
@@ -1308,14 +1308,6 @@ void eDVBServicePlay::serviceEvent(int event)
 	case eDVBServicePMTHandler::eventHBBTVInfo:
 		m_event((iPlayableService*)this, evHBBTVInfo);
 		break;
-	case eDVBServicePMTHandler::eventCIConnected:
-		if (m_csa_session && m_csa_session->isActive())
-		{
-			eDebug("[eDVBServicePlay] CI module connected - deactivating SoftCSA to save resources");
-			m_csa_session->stopECMMonitor();
-			m_csa_session->forceDeactivate();
-		}
-		break;
 	}
 }
 
@@ -4053,12 +4045,18 @@ void eDVBServicePlay::setupSpeculativeDescrambling()
 
 	// Create SoftDecoder (will start when session activates)
 	m_soft_decoder = new eDVBSoftDecoder(m_service_handler, m_dvb_service, m_decoder_index);
+	m_soft_decoder->setNoAudio(m_noaudio);
 	m_soft_decoder->setSession(m_csa_session);
 
 	// Connect to SoftDecoder's audio PID selection signal
 	m_soft_decoder->m_audio_pid_selected.connect(
 		sigc::mem_fun(*this, &eDVBServicePlay::onSoftDecoderAudioPidSelected));
 
+	// Suppress SoftCSA activation when CI module handles decryption
+	m_csa_session->shouldSuppressActivation = [this]() {
+		return m_service_handler.isCiConnected();
+	};
+
 	// Connect to session's activated signal for decoder handover
 	m_csa_session->activated.connect(
 		sigc::mem_fun(*this, &eDVBServicePlay::onSessionActivated));
diff --git a/lib/service/servicedvbfcc.cpp b/lib/service/servicedvbfcc.cpp
@@ -595,6 +595,11 @@ void eDVBServiceFCCPlay::setupSpeculativeDescrambling()
 	m_soft_decoder->m_audio_pid_selected.connect(
 		[this](int pid) { this->onSoftDecoderAudioPidSelected(pid); });
 
+	// Suppress SoftCSA activation when CI module handles decryption
+	m_csa_session->shouldSuppressActivation = [this]() {
+		return m_service_handler.isCiConnected();
+	};
+
 	// Connect to session's activated signal - use FCC-specific callback!
 	// This is the key difference from base class: we use onFCCSessionActivated
 	// which handles FCC decoder stop/start properly
diff --git a/lib/service/servicedvbsoftdecoder.cpp b/lib/service/servicedvbsoftdecoder.cpp
@@ -17,6 +17,7 @@ eDVBSoftDecoder::eDVBSoftDecoder(eDVBServicePMTHandler& source_handler,
 	, m_dvr_fd(-1)
 	, m_running(false)
 	, m_stopping(false)
+	, m_noaudio(false)
 	, m_decoder_started(false)
 	, m_last_pts(0)
 	, m_stall_count(0)
@@ -676,10 +677,13 @@ void eDVBSoftDecoder::updateDecoder(int vpid, int vpidtype, int pcrpid)
 				       apid, atype, audio_index, program.audioStreams.size());
 			}
 
-			m_decoder->setAudioPID(apid, atype);
+			if (!m_noaudio)
+			{
+				m_decoder->setAudioPID(apid, atype);
 
-			// Notify parent about selected audio PID
-			m_audio_pid_selected(apid);
+				// Notify parent about selected audio PID
+				m_audio_pid_selected(apid);
+			}
 		}
 
 		// Using explicit pcrpid breaks video on some HiSilicon devices (e.g. sf8008) in PVR loopback mode
@@ -751,6 +755,8 @@ int eDVBSoftDecoder::setTrickmode()
 
 int eDVBSoftDecoder::setAudioPID(int pid, int type)
 {
+	if (m_noaudio)
+		return 0;
 	if (m_decoder)
 		return m_decoder->setAudioPID(pid, type);
 	return -1;
diff --git a/lib/service/servicedvbsoftdecoder.h b/lib/service/servicedvbsoftdecoder.h
@@ -44,6 +44,9 @@ class eDVBSoftDecoder : public iObject, public sigc::trackable
 	int start();
 	void stop();
 
+	// Suppress audio output (PIP mode)
+	void setNoAudio(bool noaudio) { m_noaudio = noaudio; }
+
 	// Status
 	bool isRunning() const { return m_running; }
 
@@ -110,6 +113,7 @@ class eDVBSoftDecoder : public iObject, public sigc::trackable
 	int m_dvr_fd;
 	bool m_running;
 	bool m_stopping;
+	bool m_noaudio;  // When true, suppress audio (PIP mode)
 	std::set<int> m_pids_active;
 
 	// CW waiting: Timer-based decoder start

Original file line number	Diff line number	Diff line change
`@@ -257,6 +257,7 @@ void eDVBCWHandler::threadLoop()`
`257`	`257`	`const Connection& conn = conns_snapshot[i];`
`258`	`258`
`259`	`259`	`// Softcam → proxy_fd (and intercept CWs)`
	`260`	`+ bool softcam_disconnected = false;`
`260`	`261`	`if (pfds[softcam_idx].revents & POLLIN)`
`261`	`262`	`{`
`262`	`263`	`ssize_t n = ::read(conn.softcam_fd, buf, sizeof(buf));`
`@@ -283,31 +284,40 @@ void eDVBCWHandler::threadLoop()`
`283`	`284`	`written += w;`
`284`	`285`	`}`
`285`	`286`	`}`
	`287`	`+ else if (n == 0)`
	`288`	`+ {`
	`289`	`+ // EOF - softcam closed the connection`
	`290`	`+ eDebug("[eDVBCWHandler] Softcam EOF on fd %d", conn.softcam_fd);`
	`291`	`+ softcam_disconnected = true;`
	`292`	`+ }`
	`293`	`+ else if (errno != EINTR && errno != EAGAIN)`
	`294`	`+ {`
	`295`	`+ eDebug("[eDVBCWHandler] Softcam read error on fd %d: %m", conn.softcam_fd);`
	`296`	`+ softcam_disconnected = true;`
	`297`	`+ }`
`286`	`298`	`}`
`287`	`299`
`288`	`300`	`// Handle softcam disconnect`
`289`		`- if (pfds[softcam_idx].revents & (POLLHUP \| POLLERR))`
	`301`	`+ if (softcam_disconnected \|\| (pfds[softcam_idx].revents & (POLLHUP \| POLLERR)))`
`290`	`302`	`{`
`291`		`- if (!(pfds[softcam_idx].revents & POLLIN)) // Only if no data pending`
	`303`	`+ eDebug("[eDVBCWHandler] Softcam disconnected on fd %d", conn.softcam_fd);`
	`304`	`+ // Close proxy_fd so ePMTClient gets connectionLost`
	`305`	`+ std::lock_guard<std::mutex> lock(m_connections_mutex);`
	`306`	`+ for (auto it = m_connections.begin(); it != m_connections.end(); ++it)`
`292`	`307`	`{`
`293`		`- eDebug("[eDVBCWHandler] Softcam disconnected on fd %d", conn.softcam_fd);`
`294`		`- // Close proxy_fd so ePMTClient gets connectionLost`
`295`		`- std::lock_guard<std::mutex> lock(m_connections_mutex);`
`296`		`- for (auto it = m_connections.begin(); it != m_connections.end(); ++it)`
	`308`	`+ if (it->softcam_fd == conn.softcam_fd)`
`297`	`309`	`{`
`298`		`- if (it->softcam_fd == conn.softcam_fd)`
`299`		`- {`
`300`		`- ::close(it->softcam_fd);`
`301`		`- ::close(it->proxy_fd);`
`302`		`- m_connections.erase(it);`
`303`		`- break;`
`304`		`- }`
	`310`	`+ ::close(it->softcam_fd);`
	`311`	`+ ::close(it->proxy_fd);`
	`312`	`+ m_connections.erase(it);`
	`313`	`+ break;`
`305`	`314`	`}`
`306`		`- continue;`
`307`	`315`	`}`
	`316`	`+ continue;`
`308`	`317`	`}`
`309`	`318`
`310`	`319`	`// proxy_fd → softcam (CAPMT writes from ePMTClient)`
	`320`	`+ bool proxy_disconnected = false;`
`311`	`321`	`if (pfds[proxy_idx].revents & POLLIN)`
`312`	`322`	`{`
`313`	`323`	`ssize_t n = ::read(conn.proxy_fd, buf, sizeof(buf));`
`@@ -330,24 +340,31 @@ void eDVBCWHandler::threadLoop()`
`330`	`340`	`written += w;`
`331`	`341`	`}`
`332`	`342`	`}`
	`343`	`+ else if (n == 0)`
	`344`	`+ {`
	`345`	`+ eDebug("[eDVBCWHandler] ePMTClient EOF on proxy_fd %d", conn.proxy_fd);`
	`346`	`+ proxy_disconnected = true;`
	`347`	`+ }`
	`348`	`+ else if (errno != EINTR && errno != EAGAIN)`
	`349`	`+ {`
	`350`	`+ eDebug("[eDVBCWHandler] ePMTClient read error on proxy_fd %d: %m", conn.proxy_fd);`
	`351`	`+ proxy_disconnected = true;`
	`352`	`+ }`
`333`	`353`	`}`
`334`	`354`
`335`	`355`	`// Handle ePMTClient disconnect`
`336`		`- if (pfds[proxy_idx].revents & (POLLHUP \| POLLERR))`
	`356`	`+ if (proxy_disconnected \|\| (pfds[proxy_idx].revents & (POLLHUP \| POLLERR)))`
`337`	`357`	`{`
`338`		`- if (!(pfds[proxy_idx].revents & POLLIN))`
	`358`	`+ eDebug("[eDVBCWHandler] ePMTClient disconnected on proxy_fd %d", conn.proxy_fd);`
	`359`	`+ std::lock_guard<std::mutex> lock(m_connections_mutex);`
	`360`	`+ for (auto it = m_connections.begin(); it != m_connections.end(); ++it)`
`339`	`361`	`{`
`340`		`- eDebug("[eDVBCWHandler] ePMTClient disconnected on proxy_fd %d", conn.proxy_fd);`
`341`		`- std::lock_guard<std::mutex> lock(m_connections_mutex);`
`342`		`- for (auto it = m_connections.begin(); it != m_connections.end(); ++it)`
	`362`	`+ if (it->proxy_fd == conn.proxy_fd)`
`343`	`363`	`{`
`344`		`- if (it->proxy_fd == conn.proxy_fd)`
`345`		`- {`
`346`		`- ::close(it->softcam_fd);`
`347`		`- ::close(it->proxy_fd);`
`348`		`- m_connections.erase(it);`
`349`		`- break;`
`350`		`- }`
	`364`	`+ ::close(it->softcam_fd);`
	`365`	`+ ::close(it->proxy_fd);`
	`366`	`+ m_connections.erase(it);`
	`367`	`+ break;`
`351`	`368`	`}`
`352`	`369`	`}`
`353`	`370`	`}`
Original file line number	Diff line number	Diff line change
`@@ -182,8 +182,6 @@ void eDVBServicePMTHandler::PMTready(int error)`
`182`	`182`	`{`
`183`	`183`	`eDVBCIInterfaces::getInstance()->recheckPMTHandlers();`
`184`	`184`	`eDVBCIInterfaces::getInstance()->gotPMT(this);`
`185`		`- if (isCiConnected())`
`186`		`- serviceEvent(eventCIConnected);`
`187`	`185`	`}`
`188`	`186`	`}`
`189`	`187`	`if (m_ca_servicePtr)`
Original file line number	Diff line number	Diff line change
`@@ -800,7 +800,6 @@ void eDVBCIInterfaces::gotPMT(eDVBServicePMTHandler *pmthandler)`
`800`	`800`	`bool eDVBCIInterfaces::isCiConnected(eDVBServicePMTHandler *pmthandler)`
`801`	`801`	`{`
`802`	`802`	`bool ret = false;`
`803`		`- singleLock s(m_pmt_handler_lock);`
`804`	`803`	`PMTHandlerList::iterator it=std::find(m_pmt_handlers.begin(), m_pmt_handlers.end(), pmthandler);`
`805`	`804`	`if (it != m_pmt_handlers.end() && it->cislot)`
`806`	`805`	`{`