text: 
  /*--------------------------------------------------------------------------
  Copyright (c) 2010-2014, 2017-2018 The Linux Foundation. All rights reserved.
  
  Redistribution and use in source and binary forms, with or without
  modification, are permitted provided that the following conditions are met:
      * Redistributions of source code must retain the above copyright
        notice, this list of conditions and the following disclaimer.
      * Redistributions in binary form must reproduce the above copyright
        notice, this list of conditions and the following disclaimer in the
        documentation and/or other materials provided with the distribution.
      * Neither the name of The Linux Foundation nor
        the names of its contributors may be used to endorse or promote
        products derived from this software without specific prior written
        permission.
  
  THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
  AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NON-INFRINGEMENT ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR
  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
  EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
  PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
  OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
  WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
  OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  --------------------------------------------------------------------------*/
  
  
  /*
      An Open max test application ....
  */
  
  #include <stdio.h>
  #include <string.h>
  #include <stdlib.h>
  #include <unistd.h>
  #include <fcntl.h>
  #include <sys/types.h>
  #include <sys/mman.h>
  #include <time.h>
  #include <sys/ioctl.h>
  #include "OMX_Core.h"
  #include "OMX_Component.h"
  #include "pthread.h"
  #include <signal.h>
  
  #include <stdio.h>
  #include <stdlib.h>
  #include <fcntl.h>
  #include <stdint.h>
  #include <sys/mman.h>
  #include <sys/ioctl.h>
  #include<unistd.h>
  #include<string.h>
  #include <pthread.h>
  #include "QOMX_AudioExtensions.h"
  #include "QOMX_AudioIndexExtensions.h"
  #include <errno.h>
  
  #include <linux/ioctl.h>
  
  typedef unsigned char uint8;
  typedef unsigned char byte;
  typedef unsigned int  uint32;
  typedef unsigned int  uint16;
  QOMX_AUDIO_STREAM_INFO_DATA streaminfoparam;
  /* maximum ADTS frame header length                */
  void Release_Encoder();
  
  uint32_t samplerate = 8000;
  uint32_t channels = 1;
  uint32_t min_bitrate = 0;
  uint32_t max_bitrate = 0;
  uint32_t cdmarate = 0;
  uint32_t rectime = 0;
  uint32_t recpath = 0;
  int32_t pcmplayback = 0;
  uint32_t tunnel      = 0;
  uint32_t format = 1;
  #define DEBUG_PRINT printf
  unsigned to_idle_transition = 0;
  unsigned long total_pcm_bytes;
  
  /************************************************************************/
  /*                GLOBAL INIT                    */
  /************************************************************************/
  
  /************************************************************************/
  /*                #DEFINES                            */
  /************************************************************************/
  #define false 0
  #define true 1
  
  #define CONFIG_VERSION_SIZE(param) \
      param.nVersion.nVersion = CURRENT_OMX_SPEC_VERSION;\
      param.nSize = sizeof(param);
  
  #define QCP_HEADER_SIZE sizeof(struct qcp_header)
  #define MIN_BITRATE 4 /* Bit rate 1 - 13.6 , 2 - 6.2 , 3 - 2.7 , 4 - 1.0 kbps*/
  #define MAX_BITRATE 4
  
  #define FAILED(result) (result != OMX_ErrorNone)
  
  #define SUCCEEDED(result) (result == OMX_ErrorNone)
  
  /************************************************************************/
  /*                GLOBAL DECLARATIONS                     */
  /************************************************************************/
  
  pthread_mutex_t lock;
  pthread_cond_t cond;
  pthread_mutex_t elock;
  pthread_cond_t econd;
  pthread_cond_t fcond;
  pthread_mutex_t etb_lock;
  pthread_mutex_t etb_lock1;
  pthread_cond_t etb_cond;
  FILE * inputBufferFile;
  FILE * outputBufferFile;
  OMX_PARAM_PORTDEFINITIONTYPE inputportFmt;
  OMX_PARAM_PORTDEFINITIONTYPE outputportFmt;
  OMX_AUDIO_PARAM_EVRCTYPE evrcparam;
  OMX_AUDIO_PARAM_PCMMODETYPE    pcmparam;
  OMX_PORT_PARAM_TYPE portParam;
  OMX_PORT_PARAM_TYPE portFmt;
  OMX_ERRORTYPE error;
  
  
  
  
  #define ID_RIFF 0x46464952
  #define ID_WAVE 0x45564157
  #define ID_FMT  0x20746d66
  #define ID_DATA 0x61746164
  
  #define FORMAT_PCM 1
  
  struct wav_header {
    uint32_t riff_id;
    uint32_t riff_sz;
    uint32_t riff_fmt;
    uint32_t fmt_id;
    uint32_t fmt_sz;
    uint16_t audio_format;
    uint16_t num_channels;
    uint32_t sample_rate;
    uint32_t byte_rate;       /* sample_rate * num_channels * bps / 8 */
    uint16_t block_align;     /* num_channels * bps / 8 */
    uint16_t bits_per_sample;
    uint32_t data_id;
    uint32_t data_sz;
  };
  struct enc_meta_out{
          unsigned int offset_to_frame;
          unsigned int frame_size;
          unsigned int encoded_pcm_samples;
          unsigned int msw_ts;
          unsigned int lsw_ts;
          unsigned int nflags;
  } __attribute__ ((packed));
  
  struct qcp_header {
          /* RIFF Section */
          char riff[4];
          unsigned int s_riff;
          char qlcm[4];
  
          /* Format chunk */
          char fmt[4];
          unsigned int s_fmt;
          char mjr;
          char mnr;
          unsigned int data1;         /* UNIQUE ID of the codec */
          unsigned short data2;
          unsigned short data3;
          char data4[8];
          unsigned short ver;         /* Codec Info */
          char name[80];
          unsigned short abps;    /* average bits per sec of the codec */
          unsigned short bytes_per_pkt;
          unsigned short samp_per_block;
          unsigned short samp_per_sec;
          unsigned short bits_per_samp;
          unsigned char vr_num_of_rates;         /* Rate Header fmt info */
          unsigned char rvd1[3];
          unsigned short vr_bytes_per_pkt[8];
          unsigned int rvd2[5];
  
          /* Vrat chunk */
          unsigned char vrat[4];
          unsigned int s_vrat;
          unsigned int v_rate;
          unsigned int size_in_pkts;
  
          /* Data chunk */
          unsigned char data[4];
          unsigned int s_data;
  } __attribute__ ((packed));
  
   /* Common part */
   static struct qcp_header append_header = {
           {'R', 'I', 'F', 'F'}, 0, {'Q', 'L', 'C', 'M'},
           {'f', 'm', 't', ' '}, 150, 1, 0, 0, 0, 0,{0}, 0, {0},0,0,160,8000,16,0,{0},{0},{0},
           {'v','r','a','t'},0, 0, 0,{'d','a','t','a'},0
   };
  
  static int totaldatalen = 0;
  static int framecnt = 0;
  /************************************************************************/
  /*                GLOBAL INIT                    */
  /************************************************************************/
  
  unsigned int input_buf_cnt = 0;
  unsigned int output_buf_cnt = 0;
  int used_ip_buf_cnt = 0;
  volatile int event_is_done = 0;
  volatile int ebd_event_is_done = 0;
  volatile int fbd_event_is_done = 0;
  volatile int etb_event_is_done = 0;
  int ebd_cnt;
  int bInputEosReached = 0;
  int bOutputEosReached = 0;
  int bInputEosReached_tunnel = 0;
  static int etb_done = 0;
  int bFlushing = false;
  int bPause    = false;
  const char *in_filename;
  const char *out_filename;
  
  int timeStampLfile = 0;
  int timestampInterval = 100;
  
  //* OMX Spec Version supported by the wrappers. Version = 1.1 */
  const OMX_U32 CURRENT_OMX_SPEC_VERSION = 0x00000101;
  OMX_COMPONENTTYPE* evrc_enc_handle = 0;
  
  OMX_BUFFERHEADERTYPE  **pInputBufHdrs = NULL;
  OMX_BUFFERHEADERTYPE  **pOutputBufHdrs = NULL;
  
  /************************************************************************/
  /*                GLOBAL FUNC DECL                        */
  /************************************************************************/
  int Init_Encoder(char*);
  int Play_Encoder();
  OMX_STRING aud_comp;
  
  typedef enum {
      UINTMAX = 1,
      UCHARMAX,
      USHRTMAX
  }datatype;
  
  /**************************************************************************/
  /*                STATIC DECLARATIONS                       */
  /**************************************************************************/
  
  static int open_audio_file ();
  static int Read_Buffer(OMX_BUFFERHEADERTYPE  *pBufHdr );
  static OMX_ERRORTYPE Allocate_Buffer ( OMX_COMPONENTTYPE *evrc_enc_handle,
                                         OMX_BUFFERHEADERTYPE  ***pBufHdrs,
                                         OMX_U32 nPortIndex,
                                         unsigned int bufCntMin, unsigned int bufSize);
  
  
  static OMX_ERRORTYPE EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
                                    OMX_IN OMX_PTR pAppData,
                                    OMX_IN OMX_EVENTTYPE eEvent,
                                    OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2,
                                    OMX_IN OMX_PTR pEventData);
  static OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                       OMX_IN OMX_PTR pAppData,
                                       OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
  
  static OMX_ERRORTYPE FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                       OMX_IN OMX_PTR pAppData,
                                       OMX_IN OMX_BUFFERHEADERTYPE* pBuffer);
  static OMX_ERRORTYPE  parse_pcm_header();
  
  int get_input_and_validate(char *input, datatype type)
  {
      unsigned long int value = 0;
      char *ptr = NULL;
      int status = 0;
  
      errno = 0;
  
      if (input == NULL){
          DEBUG_PRINT("No input is given\n");
          status = -1;
          goto exit;
      }
      /* Check for negative input */
      if (*input == '-') {
          DEBUG_PRINT("Negative Number is not allowed\n");
          status = -1;
          goto exit;
      }
      /* Convert string to unsigned long int */
      value = strtoul(input, &ptr, 10);
      if (errno != 0){
          perror("strtoul");
          status = errno;
          goto exit;
      }
      /* check if number input is zero or string or string##number or viceversa */
      if (value == 0 || *ptr != '\0'){
          DEBUG_PRINT("Input is string+number or Zero or string = %s\n", input);
          status = -1;
          goto exit;
      }
      /* check for out of range */
      switch(type) {
      case 1 :if (value > UINT_MAX) {
                  DEBUG_PRINT("Input is Out of range\n");
                  status = -1;
              }
              break;
      case 2 :if (value > UCHAR_MAX) {
                  DEBUG_PRINT("Input is Out of range\n");
                  status = -1;
                  }
              break;
      case 3 :if (value > USHRT_MAX) {
                  DEBUG_PRINT("Input is Out of range\n");
                  status = -1;
              }
              break;
      }
  exit:
      if (status != 0)
          exit(0);
      return value;
  }
  
  void wait_for_event(void)
  {
      pthread_mutex_lock(&lock);
      DEBUG_PRINT("%s: event_is_done=%d", __FUNCTION__, event_is_done);
      while (event_is_done == 0) {
          pthread_cond_wait(&cond, &lock);
      }
      event_is_done = 0;
      pthread_mutex_unlock(&lock);
  }
  
  void event_complete(void )
  {
      pthread_mutex_lock(&lock);
      if (event_is_done == 0) {
          event_is_done = 1;
          pthread_cond_broadcast(&cond);
      }
      pthread_mutex_unlock(&lock);
  }
  
  void etb_wait_for_event(void)
  {
      pthread_mutex_lock(&etb_lock1);
      DEBUG_PRINT("%s: etb_event_is_done=%d", __FUNCTION__, etb_event_is_done);
      while (etb_event_is_done == 0) {
          pthread_cond_wait(&etb_cond, &etb_lock1);
      }
      etb_event_is_done = 0;
      pthread_mutex_unlock(&etb_lock1);
  }
  
  void etb_event_complete(void )
  {
      pthread_mutex_lock(&etb_lock1);
      if (etb_event_is_done == 0) {
          etb_event_is_done = 1;
          pthread_cond_broadcast(&etb_cond);
      }
      pthread_mutex_unlock(&etb_lock1);
  }
  
  static void create_qcp_header(int Datasize, int Frames)
  {
          append_header.s_riff = (unsigned)(Datasize + (int)QCP_HEADER_SIZE - 8);
          /* exclude riff id and size field */
      append_header.data1 = 0xe689d48d;
      append_header.data2 = 0x9076;
      append_header.data3 = 0x46b5;
      append_header.data4[0] = 0x91;
      append_header.data4[1] = 0xef;
      append_header.data4[2] = 0x73;
      append_header.data4[3] = 0x6a;
      append_header.data4[4] = 0x51;
      append_header.data4[5] = 0x00;
      append_header.data4[6] = 0xce;
      append_header.data4[7] = 0xb4;
      append_header.ver = 0x0001;
      memcpy(append_header.name, "TIA IS-127 Enhanced Variable Rate Codec, Speech Service Option 3", 64);
      append_header.abps = 9600;
      append_header.bytes_per_pkt = 23;
      append_header.vr_num_of_rates = 4;
      append_header.vr_bytes_per_pkt[0] = 0x0416;
      append_header.vr_bytes_per_pkt[1] = 0x030a;
      append_header.vr_bytes_per_pkt[2] = 0x0200;
      append_header.vr_bytes_per_pkt[3] = 0x0102;
      append_header.s_vrat = 0x00000008;
      append_header.v_rate = 0x00000001;
          append_header.size_in_pkts = (unsigned)Frames;
          append_header.s_data = (unsigned)Datasize;
          return;
  }
  
  OMX_ERRORTYPE EventHandler(OMX_IN OMX_HANDLETYPE hComponent,
                             OMX_IN OMX_PTR pAppData,
                             OMX_IN OMX_EVENTTYPE eEvent,
                             OMX_IN OMX_U32 nData1, OMX_IN OMX_U32 nData2,
                             OMX_IN OMX_PTR pEventData)
  {
      DEBUG_PRINT("Function %s \n", __FUNCTION__);
  
      /* To remove warning for unused variable to keep prototype same */
      (void)hComponent;
      (void)pAppData;
      (void)pEventData;
      switch(eEvent) {
          case OMX_EventCmdComplete:
          DEBUG_PRINT("\n OMX_EventCmdComplete event=%d data1=%u data2=%u\n",(OMX_EVENTTYPE)eEvent,
                                                                                 nData1,nData2);
              event_complete();
          break;
          case OMX_EventError:
          DEBUG_PRINT("\n OMX_EventError \n");
          break;
           case OMX_EventBufferFlag:
               DEBUG_PRINT("\n OMX_EventBufferFlag \n");
               bOutputEosReached = true;
               event_complete();
               break;
          case OMX_EventPortSettingsChanged:
          DEBUG_PRINT("\n OMX_EventPortSettingsChanged \n");
          break;
          default:
          DEBUG_PRINT("\n Unknown Event \n");
          break;
      }
      return OMX_ErrorNone;
  }
  
  OMX_ERRORTYPE FillBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                OMX_IN OMX_PTR pAppData,
                                OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
  {
      size_t bytes_writen = 0;
      size_t total_bytes_writen = 0;
      size_t len = 0;
      struct enc_meta_out *meta = NULL;
      OMX_U8 *src = pBuffer->pBuffer;
      unsigned int num_of_frames = 1;
  
      /* To remove warning for unused variable to keep prototype same */
      (void)pAppData;
  
          if(((pBuffer->nFlags & OMX_BUFFERFLAG_EOS) == OMX_BUFFERFLAG_EOS)) {
              DEBUG_PRINT("FBD::EOS on output port\n ");
              bOutputEosReached = true;
              return OMX_ErrorNone;
          }
          if(bInputEosReached_tunnel || bOutputEosReached)
          {
              DEBUG_PRINT("EOS REACHED NO MORE PROCESSING OF BUFFERS\n");
              return OMX_ErrorNone;
          }
          if(num_of_frames != src[0]){
  
              printf("Data corrupt\n");
              return OMX_ErrorNone;
          }
          /* Skip the first bytes */
  
  
  
          src += sizeof(unsigned char);
          meta = (struct enc_meta_out *)src;
          while (num_of_frames > 0) {
              meta = (struct enc_meta_out *)src;
              /*printf("offset=%d framesize=%d encoded_pcm[%d] msw_ts[%d]lsw_ts[%d] nflags[%d]\n",
                                                                         meta->offset_to_frame,
                                                                         meta->frame_size,
                            meta->encoded_pcm_samples, meta->msw_ts, meta->lsw_ts, meta->nflags);*/
              len = meta->frame_size;
  
              bytes_writen = fwrite(pBuffer->pBuffer + sizeof(unsigned char) + meta->offset_to_frame,1,len,outputBufferFile);
              if(bytes_writen < len)
              {
                  DEBUG_PRINT("error: invalid EVRC encoded data \n");
                  return OMX_ErrorNone;
              }
              src += sizeof(struct enc_meta_out);
              num_of_frames--;
              total_bytes_writen += len;
          }
          DEBUG_PRINT(" FillBufferDone size writen to file  %zu count %d\n",total_bytes_writen, framecnt);
          totaldatalen = totaldatalen + (int)total_bytes_writen;
      framecnt++;
  
          DEBUG_PRINT(" FBD calling FTB\n");
          OMX_FillThisBuffer(hComponent,pBuffer);
  
          return OMX_ErrorNone;
  }
  
  OMX_ERRORTYPE EmptyBufferDone(OMX_IN OMX_HANDLETYPE hComponent,
                                OMX_IN OMX_PTR pAppData,
                                OMX_IN OMX_BUFFERHEADERTYPE* pBuffer)
  {
      int readBytes =0;
  
      /* To remove warning for unused variable to keep prototype same */
      (void)pAppData;
  
      ebd_cnt++;
      used_ip_buf_cnt--;
      pthread_mutex_lock(&etb_lock);
      if(!etb_done)
      {
          DEBUG_PRINT("\n*********************************************\n");
          DEBUG_PRINT("Wait till first set of buffers are given to component\n");
          DEBUG_PRINT("\n*********************************************\n");
          etb_done++;
          pthread_mutex_unlock(&etb_lock);
          etb_wait_for_event();
      }
      else
      {
          pthread_mutex_unlock(&etb_lock);
      }
  
  
      if(bInputEosReached)
      {
          DEBUG_PRINT("\n*********************************************\n");
          DEBUG_PRINT("   EBD::EOS on input port\n ");
          DEBUG_PRINT("*********************************************\n");
          return OMX_ErrorNone;
      }else if (bFlushing == true) {
        DEBUG_PRINT("omx_evrc13_adec_test: bFlushing is set to TRUE used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
        if (used_ip_buf_cnt == 0) {
          bFlushing = false;
        } else {
          DEBUG_PRINT("omx_evrc13_adec_test: more buffer to come back used_ip_buf_cnt=%d\n",used_ip_buf_cnt);
          return OMX_ErrorNone;
        }
      }
  
      if((readBytes = Read_Buffer(pBuffer)) > 0) {
          pBuffer->nFilledLen = (OMX_U32)readBytes;
          used_ip_buf_cnt++;
          OMX_EmptyThisBuffer(hComponent,pBuffer);
      }
      else{
          pBuffer->nFlags |= OMX_BUFFERFLAG_EOS;
          used_ip_buf_cnt++;
          bInputEosReached = true;
          pBuffer->nFilledLen = 0;
          OMX_EmptyThisBuffer(hComponent,pBuffer);
          DEBUG_PRINT("EBD..Either EOS or Some Error while reading file\n");
      }
      return OMX_ErrorNone;
  }
  
  void signal_handler(int sig_id) {
  
    /* Flush */
    if (sig_id == SIGUSR1) {
      DEBUG_PRINT("%s Initiate flushing\n", __FUNCTION__);
      bFlushing = true;
      OMX_SendCommand(evrc_enc_handle, OMX_CommandFlush, OMX_ALL, NULL);
    } else if (sig_id == SIGUSR2) {
      if (bPause == true) {
        DEBUG_PRINT("%s resume record\n", __FUNCTION__);
        bPause = false;
        OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateExecuting, NULL);
      } else {
        DEBUG_PRINT("%s pause record\n", __FUNCTION__);
        bPause = true;
        OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StatePause, NULL);
      }
    }
  }
  
  int main(int argc, char **argv)
  {
       unsigned int bufCnt=0;
       OMX_ERRORTYPE result;
  
      struct sigaction sa;
  
      memset(&sa, 0, sizeof(sa));
      sa.sa_handler = &signal_handler;
      sigaction(SIGABRT, &sa, NULL);
      sigaction(SIGUSR1, &sa, NULL);
      sigaction(SIGUSR2, &sa, NULL);
  
     (void) signal(SIGINT, Release_Encoder);
  
      pthread_cond_init(&cond, 0);
      pthread_mutex_init(&lock, 0);
      pthread_cond_init(&etb_cond, 0);
      pthread_mutex_init(&etb_lock, 0);
      pthread_mutex_init(&etb_lock1, 0);
  
      if (argc >= 9) {
          in_filename = argv[1];
          out_filename = argv[2];
  	if (in_filename == NULL || out_filename == NULL) {
  		DEBUG_PRINT("Invalid %s filename\n", in_filename ? "Output":"Input");
  		return 0;
  	}
  	tunnel =  (uint32_t)atoi(argv[3]);
          min_bitrate  = (uint32_t)atoi(argv[4]);
          max_bitrate  = (uint32_t)atoi(argv[5]);
          cdmarate     = (uint32_t)atoi(argv[6]);
          recpath      = (uint32_t)atoi(argv[7]); // No configuration support yet..
          rectime      = (uint32_t)get_input_and_validate(argv[8], UINTMAX);
  
      } else {
            DEBUG_PRINT(" invalid format: \n");
            DEBUG_PRINT("ex: ./mm-aenc-omxevrc-test INPUTFILE OUTPUTFILE Tunnel MINRATE MAXRATE CDMARATE RECORDPATH RECORDTIME\n");
            DEBUG_PRINT("MINRATE MAXRATE and CDMARATE 1 to 4\n");
            DEBUG_PRINT("RECORDPATH 0(TX),1(RX),2(BOTH),3(MIC)\n");
            DEBUG_PRINT("RECORDTIME in seconds for AST Automation\n");
            return 0;
      }
      if(recpath != 3) {
            DEBUG_PRINT("For RECORDPATH Only MIC supported\n");
            return 0;
      }
      if(tunnel == 0)
          aud_comp = "OMX.qcom.audio.encoder.evrc";
      else
          aud_comp = "OMX.qcom.audio.encoder.tunneled.evrc";
      if(Init_Encoder(aud_comp)!= 0x00)
      {
          DEBUG_PRINT("Decoder Init failed\n");
          return -1;
      }
  
      fcntl(0, F_SETFL, O_NONBLOCK);
  
      if(Play_Encoder() != 0x00)
      {
          DEBUG_PRINT("Play_Decoder failed\n");
          return -1;
      }
  
      // Wait till EOS is reached...
          if(rectime && tunnel)
          {
              sleep(rectime);
              rectime = 0;
              bInputEosReached_tunnel = 1;
              DEBUG_PRINT("\EOS ON INPUT PORT\n");
          }
          else
          {
              wait_for_event();
          }
  
          if((bInputEosReached_tunnel) || ((bOutputEosReached) && !tunnel))
          {
  
              DEBUG_PRINT("\nMoving the decoder to idle state \n");
              OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateIdle,0);
              wait_for_event();
  
              DEBUG_PRINT("\nMoving the encoder to loaded state \n");
              OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateLoaded,0);
              sleep(1);
              if (!tunnel)
              {
                  DEBUG_PRINT("\nFillBufferDone: Deallocating i/p buffers \n");
                  for(bufCnt=0; bufCnt < input_buf_cnt; ++bufCnt) {
                      OMX_FreeBuffer(evrc_enc_handle, 0, pInputBufHdrs[bufCnt]);
                  }
              }
  
              DEBUG_PRINT ("\nFillBufferDone: Deallocating o/p buffers \n");
              for(bufCnt=0; bufCnt < output_buf_cnt; ++bufCnt) {
                  OMX_FreeBuffer(evrc_enc_handle, 1, pOutputBufHdrs[bufCnt]);
              }
              wait_for_event();
              create_qcp_header(totaldatalen, framecnt);
          fseek(outputBufferFile, 0,SEEK_SET);
              fwrite(&append_header,1,QCP_HEADER_SIZE,outputBufferFile);
  
  
              result = OMX_FreeHandle(evrc_enc_handle);
              if (result != OMX_ErrorNone) {
                  DEBUG_PRINT ("\nOMX_FreeHandle error. Error code: %d\n", result);
              }
  
              /* Deinit OpenMAX */
              OMX_Deinit();
              ebd_cnt=0;
              bOutputEosReached = false;
              bInputEosReached_tunnel = false;
              bInputEosReached = 0;
              evrc_enc_handle = NULL;
              pthread_cond_destroy(&cond);
              pthread_mutex_destroy(&lock);
              fclose(outputBufferFile);
              DEBUG_PRINT("*****************************************\n");
              DEBUG_PRINT("******...EVRC ENC TEST COMPLETED...***************\n");
              DEBUG_PRINT("*****************************************\n");
          }
          return 0;
  }
  
  void Release_Encoder()
  {
      static int cnt=0;
      OMX_ERRORTYPE result;
  
      DEBUG_PRINT("END OF EVRC ENCODING: EXITING PLEASE WAIT\n");
      bInputEosReached_tunnel = 1;
      event_complete();
      cnt++;
      if(cnt > 1)
      {
          /* FORCE RESET  */
          evrc_enc_handle = NULL;
          ebd_cnt=0;
          bInputEosReached_tunnel = false;
  
          result = OMX_FreeHandle(evrc_enc_handle);
          if (result != OMX_ErrorNone) {
              DEBUG_PRINT ("\nOMX_FreeHandle error. Error code: %d\n", result);
          }
  
          /* Deinit OpenMAX */
  
          OMX_Deinit();
  
          pthread_cond_destroy(&cond);
          pthread_mutex_destroy(&lock);
              DEBUG_PRINT("*****************************************\n");
              DEBUG_PRINT("******...EVRC ENC TEST COMPLETED...***************\n");
              DEBUG_PRINT("*****************************************\n");
          exit(0);
      }
  }
  
  int Init_Encoder(OMX_STRING audio_component)
  {
      DEBUG_PRINT("Inside %s \n", __FUNCTION__);
      OMX_ERRORTYPE omxresult;
      OMX_U32 total = 0;
      typedef OMX_U8* OMX_U8_PTR;
      char *role ="audio_encoder";
  
      static OMX_CALLBACKTYPE call_back = {
          &EventHandler,&EmptyBufferDone,&FillBufferDone
      };
  
      /* Init. the OpenMAX Core */
      DEBUG_PRINT("\nInitializing OpenMAX Core....\n");
      omxresult = OMX_Init();
  
      if(OMX_ErrorNone != omxresult) {
          DEBUG_PRINT("\n Failed to Init OpenMAX core");
            return -1;
      }
      else {
          DEBUG_PRINT("\nOpenMAX Core Init Done\n");
      }
  
      /* Query for audio decoders*/
      DEBUG_PRINT("Evrc_test: Before entering OMX_GetComponentOfRole");
      OMX_GetComponentsOfRole(role, &total, 0);
      DEBUG_PRINT ("\nTotal components of role=%s :%u", role, total);
  
  
      omxresult = OMX_GetHandle((OMX_HANDLETYPE*)(&evrc_enc_handle),
                          (OMX_STRING)audio_component, NULL, &call_back);
      if (FAILED(omxresult)) {
          DEBUG_PRINT("\nFailed to Load the component:%s\n", audio_component);
      return -1;
      }
      else
      {
          DEBUG_PRINT("\nComponent %s is in LOADED state\n", audio_component);
      }
  
      /* Get the port information */
      CONFIG_VERSION_SIZE(portParam);
      omxresult = OMX_GetParameter(evrc_enc_handle, OMX_IndexParamAudioInit,
                                  (OMX_PTR)&portParam);
  
      if(FAILED(omxresult)) {
          DEBUG_PRINT("\nFailed to get Port Param\n");
      return -1;
      }
      else
      {
          DEBUG_PRINT("\nportParam.nPorts:%u\n", portParam.nPorts);
      DEBUG_PRINT("\nportParam.nStartPortNumber:%u\n",
                                               portParam.nStartPortNumber);
      }
  
      if(OMX_ErrorNone != omxresult)
      {
          DEBUG_PRINT("Set parameter failed");
      }
  
      return 0;
  }
  
  int Play_Encoder()
  {
      unsigned int i;
      int Size=0;
      DEBUG_PRINT("Inside %s \n", __FUNCTION__);
      OMX_ERRORTYPE ret;
      OMX_INDEXTYPE index;
  #ifdef __LP64__
      DEBUG_PRINT("sizeof[%ld]\n", sizeof(OMX_BUFFERHEADERTYPE));
  #else
      DEBUG_PRINT("sizeof[%d]\n", sizeof(OMX_BUFFERHEADERTYPE));
  #endif
  
      /* open the i/p and o/p files based on the video file format passed */
      if(open_audio_file()) {
          DEBUG_PRINT("\n Returning -1");
      return -1;
      }
  
      /* Query the encoder input min buf requirements */
      CONFIG_VERSION_SIZE(inputportFmt);
  
      /* Port for which the Client needs to obtain info */
      inputportFmt.nPortIndex = portParam.nStartPortNumber;
  
      OMX_GetParameter(evrc_enc_handle,OMX_IndexParamPortDefinition,&inputportFmt);
      DEBUG_PRINT ("\nEnc Input Buffer Count %u\n", inputportFmt.nBufferCountMin);
      DEBUG_PRINT ("\nEnc: Input Buffer Size %u\n", inputportFmt.nBufferSize);
  
      if(OMX_DirInput != inputportFmt.eDir) {
          DEBUG_PRINT ("\nEnc: Expect Input Port\n");
      return -1;
      }
  
      pcmparam.nPortIndex   = 0;
      pcmparam.nChannels    =  channels;
      pcmparam.nSamplingRate = samplerate;
      OMX_SetParameter(evrc_enc_handle,OMX_IndexParamAudioPcm,&pcmparam);
  
  
      /* Query the encoder outport's min buf requirements */
      CONFIG_VERSION_SIZE(outputportFmt);
      /* Port for which the Client needs to obtain info */
      outputportFmt.nPortIndex = portParam.nStartPortNumber + 1;
  
      OMX_GetParameter(evrc_enc_handle,OMX_IndexParamPortDefinition,&outputportFmt);
      DEBUG_PRINT ("\nEnc: Output Buffer Count %u\n", outputportFmt.nBufferCountMin);
      DEBUG_PRINT ("\nEnc: Output Buffer Size %u\n", outputportFmt.nBufferSize);
  
      if(OMX_DirOutput != outputportFmt.eDir) {
          DEBUG_PRINT ("\nEnc: Expect Output Port\n");
      return -1;
      }
  
  
      CONFIG_VERSION_SIZE(evrcparam);
  
      evrcparam.nPortIndex   =  1;
      evrcparam.nChannels    =  channels; //2 ; /* 1-> mono 2-> stereo*/
      evrcparam.nMinBitRate = min_bitrate;
      evrcparam.nMaxBitRate = max_bitrate;
      OMX_SetParameter(evrc_enc_handle,OMX_IndexParamAudioEvrc,&evrcparam);
      OMX_GetExtensionIndex(evrc_enc_handle,"OMX.Qualcomm.index.audio.sessionId",&index);
      OMX_GetParameter(evrc_enc_handle,index,&streaminfoparam);
  
      DEBUG_PRINT ("\nOMX_SendCommand Encoder -> IDLE\n");
      OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateIdle,0);
      /* wait_for_event(); should not wait here event complete status will
         not come until enough buffer are allocated */
      if (tunnel == 0)
      {
          input_buf_cnt = inputportFmt.nBufferCountActual; //  inputportFmt.nBufferCountMin + 5;
          DEBUG_PRINT("Transition to Idle State succesful...\n");
          /* Allocate buffer on decoder's i/p port */
          error = Allocate_Buffer(evrc_enc_handle, &pInputBufHdrs, inputportFmt.nPortIndex,
                              input_buf_cnt, inputportFmt.nBufferSize);
          if (error != OMX_ErrorNone || pInputBufHdrs == NULL) {
              DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer error\n");
          return -1;
      }
      else {
          DEBUG_PRINT ("\nOMX_AllocateBuffer Input buffer success\n");
      }
      }
      output_buf_cnt = outputportFmt.nBufferCountMin ;
  
      /* Allocate buffer on encoder's O/Pp port */
      error = Allocate_Buffer(evrc_enc_handle, &pOutputBufHdrs, outputportFmt.nPortIndex,
                              output_buf_cnt, outputportFmt.nBufferSize);
      if (error != OMX_ErrorNone || pOutputBufHdrs == NULL) {
          DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer error\n");
      return -1;
      }
      else {
          DEBUG_PRINT ("\nOMX_AllocateBuffer Output buffer success\n");
      }
  
      wait_for_event();
  
  
      if (tunnel == 1)
      {
          DEBUG_PRINT ("\nOMX_SendCommand to enable TUNNEL MODE during IDLE\n");
          OMX_SendCommand(evrc_enc_handle, OMX_CommandPortDisable,0,0); // disable input port
          wait_for_event();
      }
  
      DEBUG_PRINT ("\nOMX_SendCommand encoder -> Executing\n");
      OMX_SendCommand(evrc_enc_handle, OMX_CommandStateSet, OMX_StateExecuting,0);
      wait_for_event();
  
      DEBUG_PRINT(" Start sending OMX_FILLthisbuffer\n");
  
      for(i=0; i < output_buf_cnt; i++) {
          DEBUG_PRINT ("\nOMX_FillThisBuffer on output buf no.%d\n",i);
          pOutputBufHdrs[i]->nOutputPortIndex = 1;
          pOutputBufHdrs[i]->nFlags = pOutputBufHdrs[i]->nFlags & (unsigned)~OMX_BUFFERFLAG_EOS;
          ret = OMX_FillThisBuffer(evrc_enc_handle, pOutputBufHdrs[i]);
          if (OMX_ErrorNone != ret) {
              DEBUG_PRINT("OMX_FillThisBuffer failed with result %d\n", ret);
      }
          else {
              DEBUG_PRINT("OMX_FillThisBuffer success!\n");
      }
      }
  
  if(tunnel == 0)
  {
      DEBUG_PRINT(" Start sending OMX_emptythisbuffer\n");
      for (i = 0;i < input_buf_cnt;i++) {
          DEBUG_PRINT ("\nOMX_EmptyThisBuffer on Input buf no.%d\n",i);
          pInputBufHdrs[i]->nInputPortIndex = 0;
          Size = Read_Buffer(pInputBufHdrs[i]);
          if(Size <=0 ){
            DEBUG_PRINT("NO DATA READ\n");
            bInputEosReached = true;
            pInputBufHdrs[i]->nFlags= OMX_BUFFERFLAG_EOS;
          }
          pInputBufHdrs[i]->nFilledLen = (OMX_U32)Size;
          pInputBufHdrs[i]->nInputPortIndex = 0;
          used_ip_buf_cnt++;
          ret = OMX_EmptyThisBuffer(evrc_enc_handle, pInputBufHdrs[i]);
          if (OMX_ErrorNone != ret) {
              DEBUG_PRINT("OMX_EmptyThisBuffer failed with result %d\n", ret);
          }
          else {
              DEBUG_PRINT("OMX_EmptyThisBuffer success!\n");
          }
          if(Size <=0 ){
              break;//eos reached
          }
      }
      pthread_mutex_lock(&etb_lock);
      if(etb_done)
  {
          DEBUG_PRINT("Component is waiting for EBD to be released.\n");
          etb_event_complete();
      }
      else
      {
          DEBUG_PRINT("\n****************************\n");
          DEBUG_PRINT("EBD not yet happened ...\n");
          DEBUG_PRINT("\n****************************\n");
          etb_done++;
      }
      pthread_mutex_unlock(&etb_lock);
  }
  
      return 0;
  }
  
  
  
  static OMX_ERRORTYPE Allocate_Buffer ( OMX_COMPONENTTYPE *avc_enc_handle,
                                         OMX_BUFFERHEADERTYPE  ***pBufHdrs,
                                         OMX_U32 nPortIndex,
                                         unsigned int bufCntMin, unsigned int bufSize)
  {
      DEBUG_PRINT("Inside %s \n", __FUNCTION__);
      OMX_ERRORTYPE error=OMX_ErrorNone;
      unsigned int bufCnt=0;
  
      /* To remove warning for unused variable to keep prototype same */
      (void)avc_enc_handle;
      *pBufHdrs= (OMX_BUFFERHEADERTYPE **)
                     malloc(sizeof(OMX_BUFFERHEADERTYPE*)*bufCntMin);
  
      for(bufCnt=0; bufCnt < bufCntMin; ++bufCnt) {
          DEBUG_PRINT("\n OMX_AllocateBuffer No %d \n", bufCnt);
          error = OMX_AllocateBuffer(evrc_enc_handle, &((*pBufHdrs)[bufCnt]),
                                     nPortIndex, NULL, bufSize);
      }
  
      return error;
  }
  
  
  
  
  static int Read_Buffer (OMX_BUFFERHEADERTYPE  *pBufHdr )
  {
  
      size_t bytes_read=0;
  
  
      pBufHdr->nFilledLen = 0;
      pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
  
       bytes_read = fread(pBufHdr->pBuffer, 1, pBufHdr->nAllocLen , inputBufferFile);
  
        pBufHdr->nFilledLen = (OMX_U32)bytes_read;
        // Time stamp logic
      ((OMX_BUFFERHEADERTYPE *)pBufHdr)->nTimeStamp = \
  
      (OMX_TICKS) ((total_pcm_bytes * 1000)/(samplerate * channels *2));
  
         DEBUG_PRINT ("\n--time stamp -- %ld\n",  (unsigned long)((OMX_BUFFERHEADERTYPE *)pBufHdr)->nTimeStamp);
          if(bytes_read == 0)
          {
            pBufHdr->nFlags |= OMX_BUFFERFLAG_EOS;
            DEBUG_PRINT ("\nBytes read zero\n");
          }
          else
          {
              pBufHdr->nFlags = pBufHdr->nFlags & (unsigned)~OMX_BUFFERFLAG_EOS;
  
              total_pcm_bytes = (unsigned)(total_pcm_bytes + bytes_read);
          }
  
      return (int)bytes_read;;
  }
  
  
  
  //In Encoder this Should Open a PCM or WAV file for input.
  
  static int open_audio_file ()
  {
      int error_code = 0;
  
      if (!tunnel)
      {
          DEBUG_PRINT("Inside %s filename=%s\n", __FUNCTION__, in_filename);
          inputBufferFile = fopen (in_filename, "rb");
          if (inputBufferFile == NULL) {
              DEBUG_PRINT("\ni/p file %s could NOT be opened\n",
                                           in_filename);
              return -1;
          }
          if(parse_pcm_header() != 0x00)
          {
              DEBUG_PRINT("PCM parser failed \n");
              return -1;
          }
      }
  
      DEBUG_PRINT("Inside %s filename=%s\n", __FUNCTION__, out_filename);
      outputBufferFile = fopen (out_filename, "wb");
      if (outputBufferFile == NULL) {
          DEBUG_PRINT("\ni/p file %s could NOT be opened\n",
                                           out_filename);
      error_code = -1;
      return error_code;
      }
      fseek(outputBufferFile, QCP_HEADER_SIZE, SEEK_SET);
      return error_code;
  }
  
  static OMX_ERRORTYPE parse_pcm_header()
  {
      struct wav_header hdr;
  
      DEBUG_PRINT("\n***************************************************************\n");
      if(fread(&hdr, 1, sizeof(hdr),inputBufferFile)!=sizeof(hdr))
      {
          DEBUG_PRINT("Wav file cannot read header\n");
          return -1;
      }
  
      if ((hdr.riff_id != ID_RIFF) ||
          (hdr.riff_fmt != ID_WAVE)||
          (hdr.fmt_id != ID_FMT))
      {
          DEBUG_PRINT("Wav file is not a riff/wave file\n");
          return -1;
      }
  
      if (hdr.audio_format != FORMAT_PCM)
      {
          DEBUG_PRINT("Wav file is not adpcm format %d and fmt size is %d\n",
                        hdr.audio_format, hdr.fmt_sz);
          return -1;
      }
  
      DEBUG_PRINT("Samplerate is %d\n", hdr.sample_rate);
      DEBUG_PRINT("Channel Count is %d\n", hdr.num_channels);
      DEBUG_PRINT("\n***************************************************************\n");
  
      samplerate = hdr.sample_rate;
      channels = hdr.num_channels;
      total_pcm_bytes = 0;
  
      return OMX_ErrorNone;
  }
  