Merge branch 'dev_sprint_25_2' into feature/VPLAY-12164_http-404

Author: sayanurag

.github/workflows/L1-tests.yml

@@ -22,6 +22,7 @@ jobs:
       - name: Run unit tests
         working-directory: ./test/utests
         run: |
+          set -o pipefail
           ./run.sh 2>&1 | tee utest_run.log
 
       # Generate pretty test run output
@@ -62,6 +63,7 @@ jobs:
       - name: Run Middleware L1 unit tests
         working-directory: ./middleware/test/utests
         run: |
+          set -o pipefail
           ./run.sh 2>&1 | tee utest_run.log
           
       # Publish Middleware test results

AampGrowableBuffer.cpp

@@ -18,23 +18,22 @@
  */
 
 /**
- * @file AampGrowableBuffer.h
- * @brief Header file of helper functions for Growable Buffer class
+ * @file AampGrowableBuffer.cpp
+ * @brief Implementation file of helper functions for Growable Buffer class
  */
 
 #include "AampGrowableBuffer.h"
 #include "AampConfig.h"
+#include "AampLogManager.h"
 #include <assert.h>
-#include <glib.h>
 
 bool AampGrowableBuffer::gbEnableLogging = false;
 int AampGrowableBuffer::gNetMemoryCount = 0;
 int AampGrowableBuffer::gNetMemoryHighWatermark = 0;
 
-
-void AampGrowableBuffer::EnableLogging( bool enable )
+void AampGrowableBuffer::EnableLogging(bool enable)
 {
-    gbEnableLogging = enable;
+	gbEnableLogging = enable;
 }
 
 AampGrowableBuffer::~AampGrowableBuffer( void )
@@ -47,89 +46,87 @@ AampGrowableBuffer::~AampGrowableBuffer( void )
  */
 void AampGrowableBuffer::Free( void )
 {
-	if( ptr )
+	if( buffer.capacity() > 0 )
 	{
 		NETMEMORY_MINUS();
-        if( gbEnableLogging )
-        {
-            printf("AampGrowableBuffer::%s(%s:%d)\n", "Free",name,gNetMemoryCount);
-        }
-		g_free(ptr);
-		ptr = NULL;
+		if( gbEnableLogging )
+		{
+			printf("AampGrowableBuffer::%s(%s:%d)\n", "Free",name,gNetMemoryCount);
+		}
+		buffer.clear();
 	}
-	len = 0;
-	avail = 0;
+	buffer.shrink_to_fit();  // Release the allocated memory
 }
 
 void AampGrowableBuffer::ReserveBytes( size_t numBytes )
 {
-	assert( ptr==NULL && avail == 0 );
-	ptr = (char *)g_malloc( numBytes );
-	if( ptr )
+	assert( buffer.empty() && buffer.capacity() == 0 );
+	if( numBytes > 0 )
 	{
-		NETMEMORY_PLUS();
-		if( gbEnableLogging )
+		try {
+			buffer.reserve(numBytes);
+			NETMEMORY_PLUS();
+			if( gbEnableLogging )
+			{
+				printf("AampGrowableBuffer::%s(%s:%d)\n", "ReserveBytes",name,gNetMemoryCount);
+			}
+		}
+		catch (const std::bad_alloc&)
 		{
-			printf("AampGrowableBuffer::%s(%s:%d)\n", "ReserveBytes",name,gNetMemoryCount);
+			AAMPLOG_ERR("Memory allocation failed!! Requested capacity: %zu", numBytes);
 		}
-		avail = numBytes;
 	}
 }
 
 void AampGrowableBuffer::AppendBytes( const void *srcPtr, size_t srcLen )
 {
-	size_t required = len + srcLen;
-	if( avail < required )
-	{ // more memory needed - grow
-		size_t numBytes = avail*2; // first try doubling size of existing reserved memory
-		if( numBytes < required )
-		{ // if still not enough, reallocate based on required
-			numBytes = required*2;
+	if( srcLen == 0 )
+	{
+		return;
+	}
+
+	bool isFirstAllocation = buffer.empty() && (buffer.capacity() == 0);
+	size_t required = buffer.size() + srcLen;
+
+	if( buffer.capacity() < required )
+	{ // more memory needed - grow with same strategy as original implementation
+		size_t newCapacity = buffer.capacity() * 2; // first try doubling
+		if( newCapacity < required )
+		{ // if still not enough, allocate double what's required
+			newCapacity = required * 2;
 		}
-		gpointer mem = g_realloc(ptr, numBytes );
-		if( mem )
+
+		try
 		{
-			if( !ptr )
-			{ // first allocation
+			buffer.reserve(newCapacity);
+
+			if( isFirstAllocation )
+			{
 				NETMEMORY_PLUS();
 				if( gbEnableLogging )
 				{
 					printf("AampGrowableBuffer::%s(%s:%d)\n", "AppendBytes",name,gNetMemoryCount);
 				}
 			}
-			ptr = mem;
-			avail = numBytes;
 		}
-		else if (numBytes != 0)
+		catch (const std::bad_alloc&)
 		{
-			AAMPLOG_ERR("Memory re-allocation failed!! Requested numBytes: %zu", numBytes);
+			AAMPLOG_ERR("Memory re-allocation failed!! Requested capacity: %zu", newCapacity);
+			return;
 		}
 	}
-	if( ptr )
-	{
-		memcpy( len + (char *)ptr, srcPtr, srcLen);
-		len = required;
-	}
-}
 
-/**
- * @brief replace contents of AampGrowableBuffer
- * @param srcPtr pointer to memory (may be subset of existing AampGrowableBuffer)
- * @param srcLen new logical size for AampGrowableBuffer reflecting memory being copied/moved
- */
-void AampGrowableBuffer::MoveBytes( const void *srcPtr, size_t srcLen )
-{ // this API assumes AampGrowableBuffer is already big enough to fit
-	assert( ptr && srcPtr && avail >= srcLen );
-	memmove( ptr, srcPtr, srcLen );
-	len = srcLen;
+	// Append the data (reserve guarantees this won't throw or reallocate)
+	const uint8_t* bytes = static_cast<const uint8_t*>(srcPtr);
+	buffer.insert(buffer.end(), bytes, bytes + srcLen);
 }
 
 /**
  * @brief reset AampGrowableBuffer logical length without releasing reserved memory
  */
 void AampGrowableBuffer::Clear( void )
 {
-	len = 0;
+	buffer.clear();
 }
 
 /**
@@ -138,31 +135,35 @@ void AampGrowableBuffer::Clear( void )
  */
 void AampGrowableBuffer::Replace( AampGrowableBuffer *src )
 {
-	assert( ptr == NULL ); // only replace if empty!
-	ptr = src->GetPtr();
-	len = src->GetLen();
-	avail = src->GetAvail();
-	
-	src->ptr = NULL;
-	src->len = 0;
-	src->avail = 0;
+	buffer = std::move(src->buffer);
+	src->buffer.clear();
+	src->buffer.shrink_to_fit();
 }
 
 /**
- * @brief called when internal memory is transferred (i.e. as part of GStreamer injection)
+ * @brief Extract the internal vector for ownership transfer to external code (e.g., GStreamer)
+ * @return vector object (moved) containing the buffer data
+ * @note The internal buffer is moved out and the AampGrowableBuffer is reset to known empty state
  */
-void AampGrowableBuffer::Transfer( void )
+std::vector<uint8_t> AampGrowableBuffer::ExtractVector( void )
 {
-	assert( ptr );
-	if( ptr )
+	assert( !buffer.empty() );
+
+	if( buffer.capacity() > 0 )
 	{
 		NETMEMORY_MINUS();
 		if( gbEnableLogging )
 		{
-			printf("AampGrowableBuffer::%s(%s:%d)\n", "Transfer",name,gNetMemoryCount);
+			printf("AampGrowableBuffer::%s(%s:%d)\n", "ExtractVector",name,gNetMemoryCount);
 		}
 	}
-	ptr = NULL;
-	len = 0;
-	avail = 0;
+
+	// Move our data into a temporary vector for return
+	std::vector<uint8_t> extracted(std::move(buffer));
+
+	// Explicitly clear to ensure known empty state (not just moved-from state)
+	buffer.clear();
+	buffer.shrink_to_fit();
+
+	return extracted; // Move constructor will be used for efficient return
 }

AampGrowableBuffer.h

@@ -30,75 +30,67 @@
 #include <utility>
 #include <assert.h>
 #include <stdio.h>
-#include <mutex>
+#include <vector>
+#include <cstdint>
 
 class AampGrowableBuffer
 {
 public:
-	AampGrowableBuffer( const char *name="?" ):ptr(NULL),len(0),avail(0),name(name){}
+	AampGrowableBuffer( const char *name="?" ):buffer(),name(name){}
 	~AampGrowableBuffer();
-
+	
 	// Copy constructor
 	AampGrowableBuffer(const AampGrowableBuffer & other)
-	 : ptr(nullptr),
-	len{other.len},
-	avail(0),name{other.name}
+	: buffer(other.buffer),
+	name{other.name}
 	{ // never reached/used?
-		ReserveBytes(len); // allocate the pointer and set avail
-		std::memcpy(ptr, other.ptr, len); // populate
 	}
+	
 	// Copy assignment
 	AampGrowableBuffer& operator=(const AampGrowableBuffer & other)
 	{ // never reached/used?
-		Free();
-		len = other.len;
-		ReserveBytes(len);
-		std::memcpy(ptr, other.ptr, len);
+		buffer = other.buffer;
 		return *this;
 	}
-
+	
 	// Move constructor
 	AampGrowableBuffer(AampGrowableBuffer && other) noexcept
-		: ptr {other.ptr},
-		len {other.len},
-		avail{other.avail},
-		name{other.name}
+	: buffer(std::move(other.buffer)),
+	name{other.name}
 	{ // never reached/used
-		other.ptr = nullptr;
-		other.len = 0;
-		other.avail = 0;
 	}
+	
 	// Move assignment
 	AampGrowableBuffer& operator=(AampGrowableBuffer && other) noexcept
 	{ // never reached/used
-		Free();
-		std::swap(ptr, other.ptr);
-		std::swap(len, other.len);
-		std::swap(avail, other.avail);
+		buffer = std::move(other.buffer);
 		return *this;
 	}
-
+	
 	void Free( void );
 	void ReserveBytes( size_t len );
 	void AppendBytes( const void *ptr, size_t len ); // append passed binary data to end of growable buffer, increasing underlying storage if required
-	void MoveBytes( const void *ptr, size_t len );
 	void Clear( void ); // sets logical buffer size back to zero, without releasing available pre-allocated memory; allows a growable buffer to be recycled
 	void Replace( AampGrowableBuffer *src );
-	void Transfer( void );
+
+	/**
+	 * @brief Extract the internal vector for ownership transfer
+	 * @return vector object (moved, not copied) containing the buffer data
+	 * @note The internal buffer is cleared after extraction. Uses move semantics for zero-copy transfer.
+	 */
+	std::vector<uint8_t> ExtractVector( void );
 
-	char *GetPtr( void ) { return (char *)ptr; } // accessor function for current growable buffer binary payload
-	const char *GetPtr( void ) const { return static_cast<const char *>(ptr); } // accessor function for current growable buffer binary payload
-	size_t GetLen( void ) const { return len; } // accessor function for current logical growable buffer size
-	size_t GetAvail( void ) const { return avail; } // should be opaque, but used in logging
-	void SetLen( size_t l ) { assert(l<=avail); len = l; }
+	char *GetPtr( void ) { return buffer.empty() ? nullptr : reinterpret_cast<char*>(buffer.data()); }
+	const char *GetPtr( void ) const { return buffer.empty() ? nullptr : reinterpret_cast<const char*>(buffer.data()); }
+	size_t GetLen( void ) const { return buffer.size(); } // accessor function for current logical growable buffer size
+	size_t GetAvail( void ) const { return buffer.capacity(); } // should be opaque, but used in logging
+	void SetLen( size_t l ) { assert(l<=buffer.capacity()); buffer.resize(l); }
 
     static void EnableLogging( bool enable );
 
 private:
     const char *name;
-	void *ptr;      /**< Pointer to buffer's memory location (gpointer) */
-	size_t len;     /**< Subset of allocated buffer that is populated and in use */
-	size_t avail;   /**< Available buffer size */
+	std::vector<uint8_t> buffer;  /**< Vector holding buffer data */
 
     static bool gbEnableLogging;
 	static int gNetMemoryCount;

AampStreamSinkInactive.h

@@ -55,18 +55,20 @@ class AampStreamSinkInactive : public StreamSink
      *   @fn SendCopy
 	 *   @brief stub implementation for Inactive aamp instance
 	 */
-	virtual bool SendCopy( AampMediaType mediaType, const void *ptr, size_t len, double fpts, double fdts, double duration)
+	virtual bool SendCopy( AampMediaType mediaType, std::vector<uint8_t>&& buffer, double fpts, double fdts, double duration)
 	{
 		AAMPLOG_WARN("Called AAMPGstPlayer()::%s stub", __FUNCTION__);
+		// buffer will be automatically destroyed (RAII)
 		return false;
 	}
 	/**
      *   @fn SendTransfer
 	 *   @brief stub implementation for Inactive aamp instance
 	 */
-	virtual bool SendTransfer( AampMediaType mediaType, void *ptr, size_t len, double fpts, double fdts, double duration, double fragmentPTSoffset, bool initFragment = false, bool discontinuity = false)
+	virtual bool SendTransfer( AampMediaType mediaType, std::vector<uint8_t>&& buffer, double fpts, double fdts, double duration, double fragmentPTSoffset, bool initFragment = false, bool discontinuity = false)
 	{
 		AAMPLOG_WARN("Called AAMPGstPlayer()::%s stub", __FUNCTION__);
+		// buffer will be automatically destroyed (RAII)
 		return false;
 	}
 	/**