Merge branch 'jbm_basop_updates' into 'main' (1a13687f) · Commits · SA4 / Audio / IVAS BASOP

lib_dec/jbm_jb4_circularbuffer.c

+480 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,485 @@
		#include "jbm_jb4_circularbuffer.h"


		#ifdef IVAS_FLOAT_FIXED
		/** Calculates percentile by selecting greatest elements.
		* This function partial sorts all given elements in the given buffer.
		* @param[in,out] elements ascending sorted buffer of selected greatest elements
		* @param[in,out] size size of elements buffer
		* @param[in] capacity maximum number of elements to buffer
		* @param[in] newElement element to insert in buffer IF great enough */
		static void JB4_CIRCULARBUFFER_calcPercentile( JB4_CIRCULARBUFFER_ELEMENT elements, UWord16 size, const UWord16 capacity, JB4_CIRCULARBUFFER_ELEMENT newElement );

		/** circular buffer (FIFO) with fixed capacity */
		struct JB4_CIRCULARBUFFER
		{
		/** elements of circular buffer */
		JB4_CIRCULARBUFFER_ELEMENT *data;
		/** maximum allowed number of elements plus one free element (to decide between full/empty buffer) */
		UWord16 capacity;
		/** position of next enque operation */
		UWord16 writePos;
		/** position of next deque operation */
		UWord16 readPos;
		};


		/* Creates a circular buffer (FIFO) */
		ivas_error JB4_CIRCULARBUFFER_Create(
		JB4_CIRCULARBUFFER_HANDLE *ph )
		{
		JB4_CIRCULARBUFFER_HANDLE h;

		IF ( ( h = malloc( sizeof( struct JB4_CIRCULARBUFFER ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for JBM\n" ) );
		}

		h->data = NULL;
		h->capacity = 0;
		move16();
		h->writePos = 0;
		move16();
		h->readPos = 0;
		move16();

		*ph = h;

		return IVAS_ERR_OK;
		}


		/* Destroys the circular buffer (FIFO) */
		void JB4_CIRCULARBUFFER_Destroy(
		JB4_CIRCULARBUFFER_HANDLE *ph )
		{
		JB4_CIRCULARBUFFER_HANDLE h;

		IF ( !ph )
		{
		return;
		}
		h = *ph;
		IF ( !h )
		{
		return;
		}

		IF ( h->data )
		{
		free( h->data );
		}
		free( h );
		*ph = NULL;

		return;
		}


		/* Initializes a circular buffer (FIFO) with a fixed maximum allowed number of elements */
		Word16 JB4_CIRCULARBUFFER_Init(
		JB4_CIRCULARBUFFER_HANDLE h,
		UWord16 capacity )
		{
		/* keep one element free to be able to decide between full/empty buffer */
		++capacity;

		IF ( ( h->data = malloc( capacity * sizeof( JB4_CIRCULARBUFFER_ELEMENT ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for JBM\n" ) );
		}

		h->capacity = capacity;
		move16();
		h->writePos = 0;
		move16();
		h->readPos = 0;
		move16();

		return IVAS_ERR_OK;
		}


		Word16 JB4_CIRCULARBUFFER_Enque(
		JB4_CIRCULARBUFFER_HANDLE h,
		JB4_CIRCULARBUFFER_ELEMENT element )
		{
		IF ( JB4_CIRCULARBUFFER_IsFull( h ) )
		{
		return -1;
		}

		h->data[h->writePos] = element;
		++h->writePos;
		IF ( h->writePos == h->capacity )
		{
		h->writePos = 0;
		move16();
		}

		return 0;
		}


		Word16 JB4_CIRCULARBUFFER_Deque(
		JB4_CIRCULARBUFFER_HANDLE h,
		JB4_CIRCULARBUFFER_ELEMENT *pElement )
		{
		IF ( JB4_CIRCULARBUFFER_IsEmpty( h ) )
		{
		return -1;
		}

		*pElement = h->data[h->readPos];
		++h->readPos;
		IF ( h->readPos == h->capacity )
		{
		h->readPos = 0;
		move16();
		}

		return 0;
		}


		/* Returns the first element. */
		JB4_CIRCULARBUFFER_ELEMENT JB4_CIRCULARBUFFER_Front(
		const JB4_CIRCULARBUFFER_HANDLE h )
		{
		JB4_CIRCULARBUFFER_ELEMENT ret;

		ret = h->data[h->readPos];
		move32();

		return ret;
		}

		/* Returns the last element. */
		JB4_CIRCULARBUFFER_ELEMENT JB4_CIRCULARBUFFER_Back(
		const JB4_CIRCULARBUFFER_HANDLE h )
		{
		JB4_CIRCULARBUFFER_ELEMENT ret;

		IF ( h->writePos != 0U )
		{
		ret = h->data[h->writePos - 1];
		move32();
		}
		ELSE
		{
		ret = h->data[h->capacity - 1];
		move32();
		}


		return ret;
		}


		Word16 JB4_CIRCULARBUFFER_IsEmpty(
		const JB4_CIRCULARBUFFER_HANDLE h )
		{
		Word16 ret;

		IF ( h->readPos == h->writePos )
		{
		ret = 1;
		move16();
		}
		ELSE
		{
		ret = 0;
		move16();
		}

		return ret;
		}


		Word16 JB4_CIRCULARBUFFER_IsFull(
		const JB4_CIRCULARBUFFER_HANDLE h )
		{
		Word16 ret;

		IF ( ( ( h->writePos + 1 ) % h->capacity ) == h->readPos )
		{
		ret = 1;
		move16();
		}
		ELSE
		{
		ret = 0;
		move16();
		}

		return ret;
		}


		UWord16 JB4_CIRCULARBUFFER_Size(
		const JB4_CIRCULARBUFFER_HANDLE h )
		{
		UWord16 ret;

		IF ( h->readPos <= h->writePos )
		{
		ret = h->writePos - h->readPos;
		}
		ELSE
		{
		/* wrap around */
		ret = h->writePos + h->capacity - h->readPos;
		}


		return ret;
		}


		/* Calculates statistics over all elements: min element */
		void JB4_CIRCULARBUFFER_Min(
		const JB4_CIRCULARBUFFER_HANDLE h,
		JB4_CIRCULARBUFFER_ELEMENT *pMin )
		{
		UWord16 i;
		JB4_CIRCULARBUFFER_ELEMENT minEle;

		/* init output variable */
		minEle = h->data[h->readPos];
		move32();

		IF ( h->readPos <= h->writePos )
		{
		/* no wrap around */
		/* calc statistics for [readPos;writePos[ */
		FOR ( i = h->readPos; i != h->writePos; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		}
		}
		ELSE
		{
		/* wrap around */
		/* calc statistics for [readPos;capacity[ */
		FOR ( i = h->readPos; i != h->capacity; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		}
		/* calc statistics for [0;writePos[ */
		FOR ( i = 0; i != h->writePos; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		}
		}

		*pMin = minEle;
		move32();
		}


		/* Calculates statistics over all elements: max element */
		void JB4_CIRCULARBUFFER_Max(
		const JB4_CIRCULARBUFFER_HANDLE h,
		JB4_CIRCULARBUFFER_ELEMENT *pMax )
		{
		UWord16 i;
		JB4_CIRCULARBUFFER_ELEMENT maxEle;

		/* init output variable */
		maxEle = h->data[h->readPos];
		move32();
		IF ( h->readPos <= h->writePos )
		{
		/* no wrap around */
		/* calc statistics for [readPos;writePos[ */
		FOR ( i = h->readPos; i != h->writePos; ++i )
		{
		IF ( GT_32( h->data[i], maxEle ) )
		{
		maxEle = h->data[i];
		move32();
		}
		}
		}
		ELSE
		{
		/* wrap around */
		/* calc statistics for [readPos;capacity[ */
		FOR ( i = h->readPos; i != h->capacity; ++i )
		{
		IF ( GT_32( h->data[i], maxEle ) )
		{
		maxEle = h->data[i];
		move32();
		}
		}
		/* calc statistics for [0;writePos[ */
		FOR ( i = 0; i != h->writePos; ++i )
		{
		IF ( GT_32( h->data[i], maxEle ) )
		{
		maxEle = h->data[i];
		move32();
		}
		}
		}

		*pMax = maxEle;
		move32();

		return;
		}

		#define JBM_MAX_CIRCULAR_ELEMENTS 100

		/* Calculates statistics over a considered fraction of all elements: min element and percentile */
		void JB4_CIRCULARBUFFER_MinAndPercentile(
		const JB4_CIRCULARBUFFER_HANDLE h,
		UWord16 nElementsToIgnore,
		JB4_CIRCULARBUFFER_ELEMENT *pMin,
		JB4_CIRCULARBUFFER_ELEMENT *pPercentile )
		{
		UWord16 i;
		JB4_CIRCULARBUFFER_ELEMENT maxElements[JBM_MAX_CIRCULAR_ELEMENTS];
		UWord16 maxElementsSize;
		UWord16 maxElementsCapacity;
		JB4_CIRCULARBUFFER_ELEMENT minEle;

		/* init output variables */
		minEle = h->data[h->readPos];

		/* To calculate the percentile, a number of elements with the highest values are collected in maxElements in
		* ascending sorted order. This array has a size of nElementsToIgnore plus one. This additional element is the
		* lowest of all maxElements, and is called the percentile of all elements. */

		maxElementsSize = 0;
		move16();
		maxElementsCapacity = nElementsToIgnore + 1;
		move16();
		assert( maxElementsCapacity <= JBM_MAX_CIRCULAR_ELEMENTS );
		IF ( h->readPos <= h->writePos )
		{
		/* no wrap around */
		/* calc statistics for [readPos;writePos[ */
		FOR ( i = h->readPos; i != h->writePos; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		JB4_CIRCULARBUFFER_calcPercentile( maxElements, &maxElementsSize, maxElementsCapacity, h->data[i] );
		}
		}
		ELSE
		{
		/* wrap around */
		/* calc statistics for [readPos;capacity[ */
		FOR ( i = h->readPos; i != h->capacity; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		JB4_CIRCULARBUFFER_calcPercentile( maxElements, &maxElementsSize, maxElementsCapacity, h->data[i] );
		}
		/* calc statistics for [0;writePos[ */
		FOR ( i = 0; i != h->writePos; ++i )
		{
		IF ( LT_32( h->data[i], minEle ) )
		{
		minEle = h->data[i];
		move32();
		}
		JB4_CIRCULARBUFFER_calcPercentile( maxElements, &maxElementsSize, maxElementsCapacity, h->data[i] );
		}
		}

		*pPercentile = maxElements[0];
		move32();
		*pMin = minEle;
		move32();

		return;
		}


		/* Calculates percentile by selecting greatest elements. */
		static void JB4_CIRCULARBUFFER_calcPercentile(
		JB4_CIRCULARBUFFER_ELEMENT *elements,
		UWord16 *size,
		const UWord16 capacity,
		JB4_CIRCULARBUFFER_ELEMENT newElement )
		{
		UWord16 i, j;

		/* insert newElement IF elements buffer is not yet full */
		IF ( *size < capacity )
		{
		FOR ( i = 0; i != *size; ++i )
		{
		IF ( LE_32( newElement, elements[i] ) )
		{
		/* insert newElement at index i */
		FOR ( j = *size; j > i; --j )
		{
		elements[j] = elements[j - 1];
		move32();
		}
		elements[i] = newElement;
		move32();
		++*size;
		return;
		}
		}
		/* newElement is maximum, just append it */
		elements[*size] = newElement;
		++*size;
		return;
		}

		/* check IF newElement is too small to be inserted in elements buffer */
		IF ( LE_32( newElement, elements[0] ) )
		{
		return;
		}

		/* select position to insert newElement to elements */
		FOR ( i = *size - 1; i != 0; --i )
		{
		IF ( GE_32( newElement, elements[i] ) )
		{
		/* insert newElement at index i */
		FOR ( j = 0; j < i; j++ )
		{
		elements[j] = elements[1 + j];
		move32();
		}
		elements[i] = newElement;
		move32();
		return;
		}
		}
		/* newElement is just greater than first on in elements buffer */
		elements[0] = newElement;
		move32();

		return;
		}
		#else
		/** Calculates percentile by selecting greatest elements.
		* This function partial sorts all given elements in the given buffer.
		* @param[in,out] elements ascending sorted buffer of selected greatest elements
		@@ -484,3 +963,4 @@ static void JB4_CIRCULARBUFFER_calcPercentile(

		return;
		}
		#endif /* IVAS_FLOAT_FIXED */

lib_dec/jbm_jb4_circularbuffer.h

+37 −0

Original line number	Diff line number	Diff line
		@@ -40,6 +40,41 @@
		#include "prot.h"
		#include "cnst.h"

		#ifdef IVAS_FLOAT_FIXED
		/** handle for circular buffer (FIFO) with fixed capacity */
		typedef struct JB4_CIRCULARBUFFER *JB4_CIRCULARBUFFER_HANDLE;

		/** type of circular buffer elements */
		typedef Word32 JB4_CIRCULARBUFFER_ELEMENT;


		ivas_error JB4_CIRCULARBUFFER_Create( JB4_CIRCULARBUFFER_HANDLE *ph );

		void JB4_CIRCULARBUFFER_Destroy( JB4_CIRCULARBUFFER_HANDLE *ph );

		Word16 JB4_CIRCULARBUFFER_Init( JB4_CIRCULARBUFFER_HANDLE h, UWord16 capacity );

		Word16 JB4_CIRCULARBUFFER_Enque( JB4_CIRCULARBUFFER_HANDLE h, JB4_CIRCULARBUFFER_ELEMENT element );

		Word16 JB4_CIRCULARBUFFER_Deque( JB4_CIRCULARBUFFER_HANDLE h, JB4_CIRCULARBUFFER_ELEMENT *pElement );

		JB4_CIRCULARBUFFER_ELEMENT JB4_CIRCULARBUFFER_Front( const JB4_CIRCULARBUFFER_HANDLE h );

		JB4_CIRCULARBUFFER_ELEMENT JB4_CIRCULARBUFFER_Back( const JB4_CIRCULARBUFFER_HANDLE h );

		Word16 JB4_CIRCULARBUFFER_IsEmpty( const JB4_CIRCULARBUFFER_HANDLE h );

		Word16 JB4_CIRCULARBUFFER_IsFull( const JB4_CIRCULARBUFFER_HANDLE h );

		UWord16 JB4_CIRCULARBUFFER_Size( const JB4_CIRCULARBUFFER_HANDLE h );

		void JB4_CIRCULARBUFFER_Min( const JB4_CIRCULARBUFFER_HANDLE h, JB4_CIRCULARBUFFER_ELEMENT *pMin );

		void JB4_CIRCULARBUFFER_Max( const JB4_CIRCULARBUFFER_HANDLE h, JB4_CIRCULARBUFFER_ELEMENT *pMax );

		void JB4_CIRCULARBUFFER_MinAndPercentile( const JB4_CIRCULARBUFFER_HANDLE h, UWord16 nElementsToIgnore, JB4_CIRCULARBUFFER_ELEMENT pMin, JB4_CIRCULARBUFFER_ELEMENT pPercentile );

		#else
		/** handle for circular buffer (FIFO) with fixed capacity */
		typedef struct JB4_CIRCULARBUFFER *JB4_CIRCULARBUFFER_HANDLE;

		@@ -73,4 +108,6 @@ void JB4_CIRCULARBUFFER_Max( const JB4_CIRCULARBUFFER_HANDLE h, JB4_CIRCULARBUFF

		void JB4_CIRCULARBUFFER_MinAndPercentile( const JB4_CIRCULARBUFFER_HANDLE h, uint16_t nElementsToIgnore, JB4_CIRCULARBUFFER_ELEMENT pMin, JB4_CIRCULARBUFFER_ELEMENT pPercentile );

		#endif /* IVAS_FLOAT_FIXED*/
		#endif /* JBM_JB4_CIRCULARBUFFER_H */

lib_dec/jbm_jb4_inputbuffer.c

+349 −0

Original line number	Diff line number	Diff line
		@@ -47,6 +47,354 @@
		#define WMC_TOOL_SKIP


		#ifdef IVAS_FLOAT_FIXED
		/** input buffer with fixed capacity */
		struct JB4_INPUTBUFFER
		{
		/** elements of input buffer */
		JB4_INPUTBUFFER_ELEMENT *data;
		/** maximum allowed number of elements plus one free element (to decide between full/empty buffer) */
		UWord16 capacity;
		/** position of next enque operation */
		UWord16 writePos;
		/** position of next deque operation */
		UWord16 readPos;
		/** function to compare two elements */
		Word16 ( compareFunction )( const JB4_INPUTBUFFER_ELEMENT first, const JB4_INPUTBUFFER_ELEMENT second, bool replaceWithNewElementIfEqual );
		};


		/* Creates a input buffer */
		ivas_error JB4_INPUTBUFFER_Create(
		JB4_INPUTBUFFER_HANDLE *ph )
		{
		JB4_INPUTBUFFER_HANDLE h;

		IF ( ( h = malloc( sizeof( struct JB4_INPUTBUFFER ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for JBM\n" ) );
		}

		h->data = NULL;
		h->capacity = 0;
		move16();
		h->writePos = 0;
		move16();
		h->readPos = 0;
		move16();
		h->compareFunction = NULL;

		*ph = h;

		return IVAS_ERR_OK;
		}


		/* Destroys the input buffer */
		void JB4_INPUTBUFFER_Destroy(
		JB4_INPUTBUFFER_HANDLE *ph )
		{
		JB4_INPUTBUFFER_HANDLE h;

		IF ( !ph )
		{
		return;
		}
		h = *ph;
		IF ( !h )
		{
		return;
		}

		IF ( h->data )
		{
		free( h->data );
		}

		free( h );
		*ph = NULL;

		return;
		}


		/* Initializes a input buffer with a fixed maximum allowed number of elements */
		ivas_error JB4_INPUTBUFFER_Init(
		JB4_INPUTBUFFER_HANDLE h,
		UWord16 capacity,
		Word16 ( compareFunction )( const JB4_INPUTBUFFER_ELEMENT first, const JB4_INPUTBUFFER_ELEMENT second, bool replaceWithNewElementIfEqual ) )
		{

		/* keep one element free to be able to decide between full/empty buffer */
		++capacity;
		IF ( ( h->data = malloc( capacity * sizeof( JB4_INPUTBUFFER_ELEMENT ) ) ) == NULL )
		{
		return ( IVAS_ERROR( IVAS_ERR_FAILED_ALLOC, "Can not allocate memory for JBM\n" ) );
		}

		h->capacity = capacity;
		move16();
		h->writePos = 0;
		move16();
		h->readPos = 0;
		move16();
		h->compareFunction = compareFunction;
		move16();

		return IVAS_ERR_OK;
		}


		Word16 JB4_INPUTBUFFER_Enque(
		JB4_INPUTBUFFER_HANDLE h,
		JB4_INPUTBUFFER_ELEMENT element,
		JB4_INPUTBUFFER_ELEMENT *replacedElement )
		{
		UWord16 j, size;
		Word16 low, high, middle, diff;
		UWord16 insertPos;
		UWord16 canMoveRight;
		UWord16 canMoveLeft;
		bool replace;

		*replacedElement = NULL;

		size = JB4_INPUTBUFFER_Size( h );
		IF ( size >= h->capacity - 1 )
		{
		return -1;
		}

		/* appending the first element is straight forward */
		IF ( size == 0U )
		{
		h->data[h->writePos] = element;
		++h->writePos;
		IF ( h->writePos == h->capacity )
		{
		h->writePos = 0;
		move16();
		}
		return 0;
		}

		/* there's a high probability that the new element can be appended at the back */
		IF ( GT_32( h->compareFunction( element, JB4_INPUTBUFFER_Back( h ), &replace ), 0 ) )
		{
		h->data[h->writePos] = element;
		++h->writePos;
		IF ( h->writePos == h->capacity )
		{
		h->writePos = 0;
		move16();
		}
		return 0;
		}

		/* out of order: use binary search to get the position to insert */
		low = 0;
		move16();
		high = size - 1;
		WHILE ( LE_16( low, high ) )
		{
		middle = add( low, shr( sub( high, low ), 1 ) );
		diff = h->compareFunction( element, JB4_INPUTBUFFER_Element( h, middle ), &replace );
		IF ( LT_16( diff, 0 ) )
		{
		high = sub( middle, 1 );
		}
		ELSE IF ( GT_16( diff, 0 ) )
		{
		low = add( middle, 1 );
		}
		ELSE /* an element with same index is already stored */
		{
		IF ( replace != 0 )
		{
		*replacedElement = h->data[( h->readPos + middle ) % h->capacity];
		h->data[( h->readPos + middle ) % h->capacity] = element;
		return 0;
		}
		return 1;
		}
		}


		insertPos = ( h->readPos + low ) % h->capacity;
		IF ( h->readPos < h->writePos )
		{
		canMoveRight = 1;
		move16();
		canMoveLeft = h->readPos > 0;
		move16();
		}
		ELSE
		{
		canMoveRight = insertPos < h->writePos;
		move16();
		canMoveLeft = insertPos > h->writePos;
		move16();
		}

		assert( canMoveRight != 0 \|\| canMoveLeft != 0 );

		IF ( canMoveRight )
		{
		/* move higher elements to the right and insert at insertPos */
		FOR ( j = h->writePos; j > insertPos; --j )
		{
		h->data[j] = h->data[j - 1];
		}

		h->data[insertPos] = element;
		++h->writePos;
		IF ( h->writePos == h->capacity )
		{
		h->writePos = 0;
		move16();
		}
		}
		ELSE
		{
		/* move lower elements to the left and insert before insertPos */
		FOR ( j = 0; j < low; j++ )
		{
		h->data[h->readPos - 1 + j] = h->data[h->readPos + j];
		}

		h->data[insertPos - 1] = element;
		--h->readPos;
		assert( (Word16) h->readPos >= 0 );
		}

		return 0;
		}


		Word16 JB4_INPUTBUFFER_Deque(
		JB4_INPUTBUFFER_HANDLE h,
		JB4_INPUTBUFFER_ELEMENT *pElement )
		{
		IF ( JB4_INPUTBUFFER_IsEmpty( h ) )
		{
		return -1;
		}

		*pElement = h->data[h->readPos];
		++h->readPos;
		IF ( h->readPos == h->capacity )
		{
		h->readPos = 0;
		move16();
		}

		return 0;
		}


		/* Returns the first element. */
		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Front(
		const JB4_INPUTBUFFER_HANDLE h )
		{
		JB4_INPUTBUFFER_ELEMENT ret;


		ret = h->data[h->readPos];

		return ret;
		}


		/* Returns the last element. */
		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Back(
		const JB4_INPUTBUFFER_HANDLE h )
		{
		JB4_INPUTBUFFER_ELEMENT ret;

		IF ( h->writePos != 0U )
		{
		ret = h->data[h->writePos - 1];
		}
		ELSE
		{
		ret = h->data[h->capacity - 1];
		}

		return ret;
		}


		/* Returns the element with the given index (0 means front element). */
		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Element(
		const JB4_INPUTBUFFER_HANDLE h,
		UWord16 index )
		{
		JB4_INPUTBUFFER_ELEMENT ret;

		/* return h->data[(h->readPos + index) % h->capacity] without error handling */
		IF ( h->readPos + index < h->capacity )
		{
		ret = h->data[h->readPos + index];
		}
		ELSE
		{
		/* wrap around */
		ret = h->data[h->readPos + index - h->capacity];
		}

		return ret;
		}


		Word16 JB4_INPUTBUFFER_IsEmpty(
		const JB4_INPUTBUFFER_HANDLE h )
		{
		Word16 ret;

		ret = h->readPos == h->writePos;
		move16();

		return ret;
		}


		Word16 JB4_INPUTBUFFER_IsFull(
		const JB4_INPUTBUFFER_HANDLE h )
		{
		Word16 ret;

		ret = 0;
		move16();
		IF ( JB4_INPUTBUFFER_Size( h ) == h->capacity - 1 )
		{
		ret = 1;
		move16();
		}

		return ret;
		}


		UWord16 JB4_INPUTBUFFER_Size(
		const JB4_INPUTBUFFER_HANDLE h )
		{
		UWord16 ret;

		IF ( h->readPos <= h->writePos )
		{
		ret = h->writePos - h->readPos;
		move16();
		}
		ELSE
		{
		/* wrap around */
		ret = h->writePos + h->capacity - h->readPos;
		move16();
		}

		return ret;
		}
		#else
		/** input buffer with fixed capacity */
		struct JB4_INPUTBUFFER
		{
		@@ -372,5 +720,6 @@ uint16_t JB4_INPUTBUFFER_Size(

		return ret;
		}
		#endif /* IVAS_FLOAT_FIXED */

		#undef WMC_TOOL_SKIP

lib_dec/jbm_jb4_inputbuffer.h

+29 −0

Original line number	Diff line number	Diff line
		@@ -44,6 +44,34 @@
		#include "options.h"


		#ifdef IVAS_FLOAT_FIXED
		typedef struct JB4_INPUTBUFFER *JB4_INPUTBUFFER_HANDLE;

		typedef void *JB4_INPUTBUFFER_ELEMENT;

		ivas_error JB4_INPUTBUFFER_Create( JB4_INPUTBUFFER_HANDLE *ph );

		void JB4_INPUTBUFFER_Destroy( JB4_INPUTBUFFER_HANDLE *ph );

		ivas_error JB4_INPUTBUFFER_Init( JB4_INPUTBUFFER_HANDLE h, UWord16 capacity, Word16 ( compareFunction )( const JB4_INPUTBUFFER_ELEMENT newElement, const JB4_INPUTBUFFER_ELEMENT arrayElement, bool replaceWithNewElementIfEqual ) );

		Word16 JB4_INPUTBUFFER_Enque( JB4_INPUTBUFFER_HANDLE h, JB4_INPUTBUFFER_ELEMENT element, JB4_INPUTBUFFER_ELEMENT *replacedElement );

		Word16 JB4_INPUTBUFFER_Deque( JB4_INPUTBUFFER_HANDLE h, JB4_INPUTBUFFER_ELEMENT *pElement );

		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Front( const JB4_INPUTBUFFER_HANDLE h );

		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Back( const JB4_INPUTBUFFER_HANDLE h );

		JB4_INPUTBUFFER_ELEMENT JB4_INPUTBUFFER_Element( const JB4_INPUTBUFFER_HANDLE h, UWord16 index );

		Word16 JB4_INPUTBUFFER_IsEmpty( const JB4_INPUTBUFFER_HANDLE h );

		Word16 JB4_INPUTBUFFER_IsFull( const JB4_INPUTBUFFER_HANDLE h );

		UWord16 JB4_INPUTBUFFER_Size( const JB4_INPUTBUFFER_HANDLE h );

		#else
		typedef struct JB4_INPUTBUFFER *JB4_INPUTBUFFER_HANDLE;

		typedef void *JB4_INPUTBUFFER_ELEMENT;
		@@ -70,4 +98,5 @@ int16_t JB4_INPUTBUFFER_IsFull( const JB4_INPUTBUFFER_HANDLE h );

		uint16_t JB4_INPUTBUFFER_Size( const JB4_INPUTBUFFER_HANDLE h );

		#endif /* IVAS_FLOAT_FIXED */
		#endif /* JBM_JB4_INPUTBUFFER_H */

lib_dec/jbm_jb4_jmf.c

+314 −0

File changed.

Preview size limit exceeded, changes collapsed.