audio_encoder.c

TI workshop 培训资料。 是关于如何创建DAVINCI平台下codec engine

/* 
 * 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;
}