/*  * audio_encoder.c *//* Standard Linux headers */#include <stdio.h>            // always include stdio.h#include <stdlib.h>           // always include stdlib.h#include <string.h>	      // memset, memcopy, strcmp, strcpy/* Codec Engine headers */#include <xdc/std.h>			// xdc base definitions. Must come 1st#include <ti/sdo/ce/Engine.h>		// Engine_open, Engine_Handle, etc.#include <ti/sdo/ce/audio/audenc.h>	// AUDENC_create, AUDENC_Handle, etc./* Application headers */#include "audio_encoder.h"    // must be preceded by Engine.h and audenc.h#include "debug.h"            // defines debug routines/* Macro for clearing structures */#define CLEAR(x) memset (&(x), 0, sizeof (x))/****************************************************************************** * audio_encoder_setup ******************************************************************************//*  input parameters:                                                         *//*      Engine_Handle engineHandle  --  handle to the codec engine            *//*	char *encoderName          --  name of decoder to open                *//*      AUDENC_Handle *encoderHandleByRef -- A speech encoder handle, passed  *//*                                   by reference. It is used to return the   *//*                                   handle of the encoder created by this    *//*                                   function.                                *//*                                                                            *//*                                                                            *//*  return value:                                                             *//*      int  --  AENC_SUCCESS or AENC_FAILURE as defined in audio_encoder.h   *//*                                                                            *//******************************************************************************/int audio_encoder_setup(Engine_Handle engineHandle, char *encoderName,				AUDENC_Handle *encoderHandleByRef){    AUDENC_Handle encoderHandle;    /* Create speech encoder instance */    /* Null attributes value specifies default attributes */    encoderHandle = AUDENC_create(engineHandle, encoderName, NULL);    if (encoderHandle == NULL) {        ERR("Failed to create audio instance of %s\n", encoderName);        return AENC_FAILURE;    }    DBG("Created audio encoder instance of %s\n", encoderName);    DBG("\tWith handle %#0lx\n", (unsigned long) encoderHandle);    DBG("\tUsing default static and dynamic parameters\n");						    /* return speech encoder handle through encoderHandleByRef pointer */    *encoderHandleByRef = encoderHandle;    /* return AENC_SUCCESS if AUDENC_create executes successfully */    return AENC_SUCCESS;}/****************************************************************************** * encode_audio ******************************************************************************//*  input parameters:                                                         *//*      AUDENC_Handle encoderHandle  --  handle to the speech encoder as      *//*                                       returned by audio_encoder_setup      *//*      char *inputBuffer            --  buffer containing video input frame  *//*      int inputSize                --  size of inputBuffer in bytes         *//*      char *outputBuffer           --  buffer for output encoded data       *//*      int outputSizeByRef    --  Used as both an input and output argument  *//*                                 on input -- specifies the size of outbuf   *//*                                 on output -- specifies size of encoded buf *//*                                                                            *//*                                                                            *//*  return value:                                                             *//*      int  --  AENC_SUCCESS or AENC_FAILURE as defined in audio_encoder.h   *//*                                                                            *//******************************************************************************/int encode_audio(AUDENC_Handle encoderHandle, char *inputBuffer, 			int inputSize, char *outputBuffer, int *outputSizeByRef){/* Declare arguments and return value for AUDENC_process */    AUDENC_InArgs           inArgs;	// input args for AUDENC_process    AUDENC_OutArgs          outArgs;	// output (return) from AUDENC_process    XDM_BufDesc             inBufDesc;  // buffer descriptor for input buffer    XDM_BufDesc             outBufDesc;	// buffer descriptor for output buffer    XDAS_Int32              status;     // status of AUDENC_process call/* Declare Buffer Descriptor elements */    XDAS_Int32              inBufSizeArray[1];	// inBufDesc.bufSizes    XDAS_Int32              outBufSizeArray[1];	// outBufDesc.bufSizes/* Fill in input buffer descriptor */    inBufSizeArray[0]       = inputSize;    inBufDesc.numBufs       = 1;			// one input buffer    inBufDesc.bufSizes      = inBufSizeArray;		// of this size    inBufDesc.bufs          = (XDAS_Int8 **) &inputBuffer;  // located here/* Fill in output buffer descriptor */    outBufSizeArray[0]      = *outputSizeByRef;    outBufDesc.numBufs      = 1;			// one output buffer    outBufDesc.bufSizes     = outBufSizeArray;		// of this size    outBufDesc.bufs         = (XDAS_Int8 **) &outputBuffer;  // located here    /* Fill in input arguments structure */    inArgs.size             = sizeof(AUDENC_InArgs);    /* Specify size of output arguments (return) structure */    outArgs.size            = sizeof(AUDENC_OutArgs);    /* Encode speech buffer */    status = AUDENC_process(encoderHandle, &inBufDesc, &outBufDesc,                            &inArgs, &outArgs);    if (status != AUDENC_EOK) {        ERR("AUDENC_process() failed in encode_audio()\n");	ERR("\twith extended error mask %#0x\n", 				(unsigned int) outArgs.extendedError);        return AENC_FAILURE;    }    /* return encoded buffer size through outputSizeByRef pointer */    *outputSizeByRef = outArgs.bytesGenerated;    /* return AENC_SUCCESS if AUDENC_process executes successfully */    return AENC_SUCCESS;}/****************************************************************************** * audio_encoder_cleanup ******************************************************************************//*  input parameters:                                                         *//*      AUDENC_Handle encoderHandle  --  handle to the audio encoder as       *//*			       		 returned by audio_encoder_setup      *//*                                                                            *//*                                                                            *//*  return value:                                                             *//*      int  --  always returns AENC_SUCCESS as defined in audio_encoder.h    *//*                                                                            *//******************************************************************************/int audio_encoder_cleanup(AUDENC_Handle encoderHandle){    AUDENC_Status status;    AUDENC_DynamicParams dynParams;    /*  Zero out the status and dynParams structures */    CLEAR(status);    CLEAR(dynParams);    /*  Set size field of status and dynParams */    status.size = sizeof(AUDENC_Status);    dynParams.size = sizeof(AUDENC_DynamicParams);    /*  Query encoder for status */    AUDENC_control(encoderHandle, XDM_GETSTATUS, &dynParams, &status);    /*  Delete encoder instance */    AUDENC_delete(encoderHandle);    /*  Report any errors */    if(status.extendedError){	ERR("Deleted audio encoder instance with handle %#0lx\n", 					(unsigned long) encoderHandle);	ERR("\tEncoder exited with error mask %#0x\n", 					(unsigned int) status.extendedError );    }    else{        DBG("Deleted audio encoder instance with handle %#0lx\n", 					(unsigned long) encoderHandle);	DBG("\tEncoder exited with no errors\n");    }    /* Return success */    return AENC_SUCCESS;}