CPacket::Duplicate is a pure virtual function & other minor changes

src/cdvframepacket.h

@@ -66,7 +66,7 @@ public:
 	// identity
 	bool IsDvFrame(void) const              { return true; }
 #ifndef NO_XLX
-	bool HaveTranscodableAmbe(void) const   { return true; }
+	bool HasTranscodableAmbe(void) const   { return true; }
 #endif
 
 	// get

src/cdvlastframepacket.h

@@ -53,7 +53,7 @@ public:
 
 	// identity
 	bool IsLastPacket(void) const           { return true; }
-	bool HaveTranscodableAmbe(void) const   { return false; }
+	bool HasTranscodableAmbe(void) const   { return false; }
 };
 
 

src/cpacket.cpp

@@ -103,15 +103,6 @@ CPacket::CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid, uint
 	m_uiOriginId = ORIGIN_LOCAL;
 }
 
-////////////////////////////////////////////////////////////////////////////////////////
-// virtual duplication
-
-CPacket *CPacket::Duplicate(void) const
-{
-	return new CPacket(*this);
-}
-
-
 ////////////////////////////////////////////////////////////////////////////////////////
 // pid conversion
 

src/cpacket.h

@@ -46,16 +46,16 @@ public:
 	CPacket(uint16 sid, uint8 dstarpid, uint8 dmrpid, uint8 dmrsubpid, uint8 ysfpid, uint8 ysfsubpid, uint8 ysfsubpidmax);
 
 	// destructor
-	virtual ~CPacket() {};
+	virtual ~CPacket() {}
 
 	// virtual duplication
-	virtual CPacket *Duplicate(void) const;
+	virtual CPacket *Duplicate(void) const = 0;
 
 	// identity
 	virtual bool IsDvHeader(void) const             { return false; }
 	virtual bool IsDvFrame(void) const              { return false; }
 	virtual bool IsLastPacket(void) const           { return false; }
-	virtual bool HaveTranscodableAmbe(void) const   { return false; }
+	virtual bool HasTranscodableAmbe(void) const   { return false; }
 
 	// get
 	virtual bool IsValid(void) const                { return true; }

src/cpacketstream.cpp

@@ -95,7 +95,7 @@ void CPacketStream::Push(CPacket *Packet)
 		m_CodecStream->Lock();
 		{
 			// transcoder ready & frame need transcoding ?
-			if ( m_CodecStream->IsConnected() && Packet->HaveTranscodableAmbe() )
+			if ( m_CodecStream->IsConnected() && Packet->HasTranscodableAmbe() )
 			{
 				// yes, push packet to trancoder queue
 				// trancoder will push it after transcoding

src/creflector.cpp

@@ -114,7 +114,7 @@ bool CReflector::Start(void)
 	// start one thread per reflector module
 	for ( int i = 0; i < NB_OF_MODULES; i++ )
 	{
-		m_RouterFuture[i] = std::async(std::launch::async, &CReflector::RouterThread, this, &(m_Streams[i]));
+		m_RouterFuture[i] = std::async(std::launch::async, &CReflector::RouterThread, this, &(m_Stream[i]));
 	}
 
 	// start the reporting threads
@@ -241,11 +241,9 @@ CPacketStream *CReflector::OpenStream(CDvHeaderPacket *DvHeader, std::shared_ptr
 
 void CReflector::CloseStream(CPacketStream *stream)
 {
-	//
 	if ( stream != nullptr )
 	{
-		// wait queue is empty
+		// wait queue is empty. this waits forever
-		// this waits forever
 		bool bEmpty = false;
 		do
 		{
@@ -256,18 +254,12 @@ void CReflector::CloseStream(CPacketStream *stream)
 			bEmpty = stream->empty();
 			stream->Unlock();
 			if ( !bEmpty )
-			{
-				// wait a bit
 				CTimePoint::TaskSleepFor(10);
-			}
 		}
 		while (!bEmpty);
 
-		// lock clients
+		GetClients();	// lock clients
-		GetClients();
+		stream->Lock();	// lock stream
-
-		// lock stream
-		stream->Lock();
 
 		// get and check the master
 		std::shared_ptr<CClient>client = stream->GetOwnerClient();
@@ -277,7 +269,7 @@ void CReflector::CloseStream(CPacketStream *stream)
 			client->NotAMaster();
 
 			// notify
-			g_Reflector.OnStreamClose(stream->GetUserCallsign());
+			OnStreamClose(stream->GetUserCallsign());
 
 			std::cout << "Closing stream of module " << GetStreamModule(stream) << std::endl;
 		}
@@ -292,8 +284,6 @@ void CReflector::CloseStream(CPacketStream *stream)
 
 		// and stop the queue
 		stream->Close();
-
-
 	}
 }
 
@@ -552,37 +542,32 @@ int CReflector::GetModuleIndex(char module) const
 
 CPacketStream *CReflector::GetStream(char module)
 {
-	CPacketStream *stream = nullptr;
 	int i = GetModuleIndex(module);
 	if ( i >= 0 )
 	{
-		stream = &(m_Streams[i]);
+		return &(m_Stream[i]);
 	}
-	return stream;
+	return nullptr;
 }
 
 bool CReflector::IsStreamOpen(const CDvHeaderPacket *DvHeader)
 {
-	bool open = false;
+	for ( unsigned i = 0; i < m_Stream.size(); i++  )
-	for ( unsigned i = 0; (i < m_Streams.size()) && !open; i++  )
 	{
-		open =  ( (m_Streams[i].GetStreamId() == DvHeader->GetStreamId()) &&
+		if ( (m_Stream[i].GetStreamId() == DvHeader->GetStreamId()) && (m_Stream[i].IsOpen()) )
-				  (m_Streams[i].IsOpen()));
+			return true;
 	}
-	return open;
+	return false;
 }
 
 char CReflector::GetStreamModule(CPacketStream *stream)
 {
-	char module = ' ';
+	for ( unsigned i = 0; i < m_Stream.size(); i++ )
-	for ( unsigned i = 0; (i < m_Streams.size()) && (module == ' '); i++ )
 	{
-		if ( &(m_Streams[i]) == stream )
+		if ( &(m_Stream[i]) == stream )
-		{
+			return GetModuleLetter(i);
-			module = GetModuleLetter(i);
-		}
 	}
-	return module;
+	return ' ';
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////

src/creflector.h

@@ -152,7 +152,7 @@ protected:
 	CProtocols      m_Protocols;        // list of supported protocol handlers
 
 	// queues
-	std::array<CPacketStream, NB_OF_MODULES> m_Streams;
+	std::array<CPacketStream, NB_OF_MODULES> m_Stream;
 
 	// threads
 	std::atomic<bool> keep_running;

src/cysfprotocol.cpp

@@ -202,7 +202,7 @@ void CYsfProtocol::Task(void)
 		}
 		else if ( IsValidServerStatusPacket(Buffer) )
 		{
-			std::cout << "YSF server status enquiry from " << Ip   << std::endl;
+			std::cout << "YSF server status enquiry from " << Ip << std::endl;
 			// reply
 			EncodeServerStatusPacket(&Buffer);
 			Send(Buffer, Ip);