wip - add back using rtpdump.c/.h to use the real RTPDUMP format (d897eacd) · Commits · IVAS Codec Public Collaboration / IVAS Codec

lib_util/ivas_rtp_file.c

+151 −2

Original line number	Diff line number	Diff line
		@@ -29,6 +29,9 @@
		the United Nations Convention on Contracts on the International Sales of Goods.

		*******************************************************************************************************/



		#include <stdlib.h>
		#include <string.h>
		#include <stdio.h>
		@@ -36,7 +39,11 @@
		#include <stdbool.h> // bool type
		#include "ivas_rtp_file.h"
		#include "ivas_error_utils.h"
		#ifdef USE_RTPDUMP
		#include "rtpdump.h"
		#endif

		#ifndef USE_RTPDUMP
		struct IVAS_RTP_FILE
		{
		bool isFileWriter;
		@@ -140,6 +147,7 @@ static ivas_error IvasRtpFile_Read(

		return IVAS_ERR_OK;
		}
		#endif

		static const char *const PiDataNames[IVAS_PI_MAX_ID] = {
		"SCENE_ORIENTATION", "DEVICE_ORIENTATION_COMPENSATED", "DEVICE_ORIENTATION_UNCOMPENSATED",
		@@ -770,6 +778,44 @@ void IVAS_RTP_Term(
		{
		if ( rtp->hPack != NULL )
		{
		#ifdef USE_RTPDUMP
		/* Flush any remaining RTP packets */
		while ( IVAS_RTP_PACK_GetNumFrames( rtp->hPack ) > 0 )
		{
		ivas_error error;
		uint32_t numFramesInPayload = 0;
		error = IVAS_RTP_PACK_GetPacket( rtp->hPack, &rtp->rtpPacket, &numFramesInPayload );
		if ( error != IVAS_ERR_OK )
		{
		fprintf( stderr, "\nError %s while packing RTP packet\n", ivas_error_to_string( error ) );
		break;
		}
		if ( numFramesInPayload > 0 )
		{
		RTPDUMP_RTPPACKET pkt;
		RTPDUMP_SetDefaultRtpPacketHeader( &pkt );

		unsigned len = rtp->rtpPacket.length;
		if ( len > sizeof( pkt.data ) )
		len = sizeof( pkt.data );
		memcpy( pkt.data, rtp->rtpPacket.buffer, len );
		RTPDUMP_ParseRTPHeader( &pkt );
		pkt.ssrc = rtp->ssrc;
		pkt.payloadTypeId = rtp->pt;
		pkt.payloadSize = (unsigned short) ( len - pkt.headerSize );
		/* override sequence number to enforce 1-step increments */
		pkt.sequenceNumber = rtp->nextSeq++;
		/* compute time offset in ms from RTP timestamp (16kHz clock) */
		uint32_t offset_ms = pkt.timeStamp / 16;
		RTPDUMP_ERROR werr = RTPDUMP_WritePacket( rtp->dump, &pkt, offset_ms );
		if ( werr != RTPDUMP_NO_ERROR )
		{
		fprintf( stderr, "\nError writing RTPDump packet: %d\n", werr );
		break;
		}
		}
		}
		#else
		/* Complete the last packet */
		if ( IVAS_RTP_PACK_GetNumFrames( rtp->hPack ) != 0 )
		{
		@@ -788,6 +834,7 @@ void IVAS_RTP_Term(
		}
		}
		}
		#endif
		IVAS_RTP_PACK_Close( &rtp->hPack );
		}

		@@ -809,10 +856,17 @@ void IVAS_RTP_Term(
		rtp->f_piExtOut = NULL;
		}

		#ifdef USE_RTPDUMP
		if ( rtp->dump )
		{
		RTPDUMP_Close( &rtp->dump, 1 );
		}
		#else
		if ( rtp->hRtpFile != NULL )
		{
		IvasRtpFile_Close( &rtp->hRtpFile );
		}
		#endif
		}
		}

		@@ -836,17 +890,40 @@ ivas_error IVAS_RTP_WRITER_Init(
		if ( error == IVAS_ERR_OK )
		{
		/* Open the output file for RTPDump writing */
		#ifdef USE_RTPDUMP
		{
		RTPDUMP_ERROR rderr = RTPDUMP_OpenForWriting( &rtp->dump, outputBitstreamFilename );
		if ( rderr != RTPDUMP_NO_ERROR )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_FILE_OPEN, "rtpdump open error %d", rderr );
		}
		/* start sequence numbering at zero */
		rtp->nextSeq = 0;
		}
		#else
		error = IvasRtpFile_Open( outputBitstreamFilename, true, &rtp->hRtpFile );
		if ( error != IVAS_ERR_OK )
		{
		return error;
		}
		#endif

		/* initialize RTP packer header sequence only in file-based mode */
		#ifndef USE_RTPDUMP
		#ifdef FIXED_RTP_SEQUENCE_NUM
		error = IVAS_RTP_PACK_UpdateHeader( rtp->hPack, seqNumInitVal, SSRC, 0, NULL, 0, 0, NULL );
		if ( error != IVAS_ERR_OK )
		{
		fprintf( stderr, "error in IVAS_RTP_PACK_UpdateHeader(): %d\n", error );
		}
		#endif
		#else
		rtp->ssrc = SSRC;
		rtp->pt = 96; /* hard-coded for now */
		#ifdef FIXED_RTP_SEQUENCE_NUM
		rtp->nextSeq = seqNumInitVal;
		#endif
		#endif
		}

		return error;
		@@ -871,11 +948,22 @@ ivas_error IVAS_RTP_READER_Init(
		error = IVAS_RTP_UNPACK_Open( &rtp->hUnpack, &rtp->unpackCfg );
		if ( error == IVAS_ERR_OK )
		{
		/* Open the output file for RTPDump writing */
		#ifdef USE_RTPDUMP
		{
		RTPDUMP_ERROR rderr = RTPDUMP_OpenForReading( &rtp->dump, inputBitstreamFilename );
		if ( rderr != RTPDUMP_NO_ERROR )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_FILE_OPEN, "rtpdump open failed %d", rderr );
		}
		}
		#else
		error = IvasRtpFile_Open( inputBitstreamFilename, false, &rtp->hRtpFile );
		if ( error != IVAS_ERR_OK )
		{
		return error;
		}
		#endif

		if ( piOutputFilename != NULL )
		{
		@@ -951,7 +1039,43 @@ ivas_error IVAS_RTP_WriteNextFrame(
		}
		rtp->nWrittenPiData--;
		}

		#ifdef USE_RTPDUMP
		/* flush packets when packet full or forced */
		if ( forcePacket \|\| IVAS_RTP_PACK_GetNumFrames( rtp->hPack ) == rtp->packCfg.maxFramesPerPacket )
		{
		while ( 1 )
		{
		uint32_t numFramesInPayload = 0;
		/* attempt to get a packet from packer */
		ivas_error pkErr = IVAS_RTP_PACK_GetPacket( rtp->hPack, &rtp->rtpPacket, &numFramesInPayload );
		if ( pkErr != IVAS_ERR_OK \|\| numFramesInPayload == 0 )
		{
		break;
		}
		/* write this packet via RTPDump */
		RTPDUMP_RTPPACKET pkt;
		memset( &pkt, 0, sizeof( pkt ) );
		unsigned len = rtp->rtpPacket.length;
		if ( len > sizeof( pkt.data ) )
		len = sizeof( pkt.data );
		memcpy( pkt.data, rtp->rtpPacket.buffer, len );
		RTPDUMP_ParseRTPHeader( &pkt );
		/* set proper header and payload sizes */
		pkt.headerSize = 12;
		pkt.payloadSize = (unsigned short) ( len - pkt.headerSize );
		/* override sequence number to enforce 1-step increments */
		pkt.sequenceNumber = rtp->nextSeq++;
		/* compute time offset in ms from RTP timestamp (16kHz clock) */
		uint32_t offset_ms = pkt.timeStamp / 16;
		RTPDUMP_ERROR werr = RTPDUMP_WritePacket( rtp->dump, &pkt, offset_ms );
		if ( werr != RTPDUMP_NO_ERROR )
		{
		fprintf( stderr, "\nError writing RTPDump packet: %d\n", werr );
		return IVAS_ERR_FAILED_FILE_OPEN;
		}
		}
		}
		#else
		if ( forcePacket \|\| IVAS_RTP_PACK_GetNumFrames( rtp->hPack ) == rtp->packCfg.maxFramesPerPacket )
		{
		uint32_t numFramesInPayload = 0;
		@@ -969,7 +1093,7 @@ ivas_error IVAS_RTP_WriteNextFrame(
		return error;
		}
		}

		#endif
		return error;
		}

		@@ -994,11 +1118,36 @@ ivas_error IVAS_RTP_ReadNextFrame(
		packedFrame.capacity = ( IVAS_MAX_BITS_PER_FRAME / 8 );
		if ( rtp->numFramesInPacket == 0 )
		{
		#ifdef USE_RTPDUMP
		/* Read next packet via RTPDUMP library */
		{
		RTPDUMP_RTPPACKET pd;
		uint32_t offset_ms;
		RTPDUMP_ERROR rderr = RTPDUMP_ReadPacket( rtp->dump, &pd, &offset_ms );
		if ( rderr == RTPDUMP_READ_ENDOFFILE )
		return IVAS_ERR_END_OF_FILE;
		if ( rderr != RTPDUMP_NO_ERROR )
		{
		return IVAS_ERROR( IVAS_ERR_FAILED_FILE_OPEN, "rtpdump read error %d", rderr );
		}
		/* copy raw data to unpack buffer */
		unsigned total = pd.headerSize + pd.payloadSize;
		if ( total > rtp->rtpPacket.capacity )
		{
		return IVAS_ERR_INVALID_OUTPUT_BUFFER_SIZE;
		}
		memcpy( rtp->rtpPacket.buffer, pd.data, total );
		rtp->rtpPacket.length = total;
		if ( nextPacketRcvTime_ms )
		*nextPacketRcvTime_ms = offset_ms;
		}
		#else
		rtp->rtpPacket.length = 0;
		if ( ( error = IvasRtpFile_Read( rtp->hRtpFile, rtp->rtpPacket.buffer, &rtp->rtpPacket.length, rtp->rtpPacket.capacity ) ) != IVAS_ERR_OK )
		{
		return error;
		}
		#endif

		if ( ( error = IVAS_RTP_UNPACK_PushPacket( rtp->hUnpack, &rtp->rtpPacket,
		&rtp->numFramesInPacket, &rtp->numPiDataInPacket,

lib_util/ivas_rtp_file.h

+11 −1

Original line number	Diff line number	Diff line
		@@ -33,10 +33,14 @@
		#ifndef IVAS_RTP_FILE_H
		#define IVAS_RTP_FILE_H

		#define USE_RTPDUMP 1

		#include "common_api_types.h"
		#include "ivas_rtp_api.h"
		#include "ivas_rtp_pi_data.h"

		#ifdef USE_RTPDUMP
		#include "rtpdump.h"
		#endif
		typedef struct IVAS_RTP_FILE *IVAS_RTP_FILE_HANDLE;

		typedef struct
		@@ -65,6 +69,12 @@ typedef struct
		IVAS_RTP_UNPACK_HANDLE hUnpack;
		IVAS_RTP_PACK_CONFIG packCfg;
		IVAS_RTP_UNPACK_CONFIG unpackCfg;
		#ifdef USE_RTPDUMP
		RTPDUMP_HANDLE dump;
		uint16_t nextSeq;
		uint32_t ssrc;
		uint8_t pt;
		#endif
		IVAS_RTP_SR_INFO srInfo;
		} IVAS_RTP;