coder.c

AMR-NB 的编码实现,纯C, VC下建立工程即可用.

 
#include "string.h"
#include "errno.h"
#include "typedef.h"

#include "amrcode_public.h"
#include "time.h"

#include "prm2bits.h"



/*
 * read_mode  read next mode from mode file
 *
 * return 0 on success, EOF on end of file, 1 on other error
 */
int read_mode(FILE *file_modes,   Mode *mode)
{
    char buf[10];
    
    if (fscanf(file_modes, "%9s\n", buf) != 1) 
   {
        if (feof(file_modes))
            return EOF;

        fprintf(stderr, "\nerror reading mode control file: %s\n",
                strerror(errno));
        return 1;
    }

    if (str2mode(buf, mode) != 0 || *mode == MRDTX)
   {
        fprintf(stderr, "\ninvalid amr_mode found in mode control file: '%s'\n",
                buf);
        return 1;
    }

    return 0;
}


/*
*****************************************************************************
*                             MAIN PROGRAM 
*****************************************************************************
*/
int main (int argc, char *argv[])
{
  char *progname = argv[0];
  char *modeStr = NULL;
  char *usedModeStr = NULL;
  char *fileName = NULL;
  char *modefileName = NULL;
  char *serialFileName = NULL;
  
  FILE *file_speech = NULL;                  /* File of speech data               */
  FILE *file_serial = NULL;                    /* File of coded bits                */
  FILE *file_modes = NULL;                  /* File with mode information        */
  FILE *datafile = NULL;
  
  Word16 new_speech[160];         /* Pointer to new speech data        */
  Word16 serial[250];    /* Output bitstream buffer           */

#ifdef MMS_IO
  UWord8 packed_bits[MAX_PACKED_SIZE];
  Word16 packed_size;
#endif

  Word32 frame;
  Word16 dtx = 0;                                 /* enable encoder DTX                */
  clock_t  time1 = 0 ,time2= 0 ;
  Word32 a=0,b=0;
  
  /* changed eedodr */

     int i=0,j=0;
    Mode mode;
    Mode used_mode;
    TXFrameType tx_type;

  int useModeFile = 0;
  
  //Speech_Encode_FrameState *speech_encoder_state = NULL;
  //sid_syncState *sid_state = NULL;
 void *speech_encoder_state = NULL;
 void *sid_state = NULL;
 void * amrcoder = NULL;


  unsigned char bitstr[MAX_BYTES];
 
 

 
  /*----------------------------------------------------------------------*
   * Process command line options                                         *
   *----------------------------------------------------------------------*/
  while (argc > 1)
  {
      if (strcmp(argv[1], "-dtx") == 0) {
          dtx = 1;
      } else if (strncmp(argv[1], "-modefile=", 10) == 0) {
          useModeFile = 1;
          modefileName = argv[1]+10;
      } else
          break;
      argc--;
      argv++;
  }
  
  /*----------------------------------------------------------------------*
   * Check number of arguments                                            *
   *----------------------------------------------------------------------*/
  if (    (argc != 4 && !useModeFile)
      || (argc != 3 &&  useModeFile))
  {
    fprintf (stderr,
      " Usage:\n\n"
      "   %s [-dtx] amr_mode            speech_file  bitstream_file\n\n"
      " or \n\n"
      "   %s [-dtx] -modefile=mode_file speech_file  bitstream_file\n\n"
      " -dtx                enables DTX mode\n"
      " -modefile=mode_file reads AMR modes from text file (one line per frame)\n\n",
             progname, progname);
      exit (1);
  }

  /*----------------------------------------------------------------------*
   * Open mode file or convert mode string                                *
   *----------------------------------------------------------------------*/
  if (useModeFile) 
  {
      fileName = argv[1];
      serialFileName = argv[2];
      
      /* Open mode control file */
      if (strcmp(modefileName, "-") == 0) {
          file_modes = stdin;
      }
      else if ((file_modes = fopen (modefileName, "rt")) == NULL)
      {
          fprintf (stderr, "Error opening mode control file  %s !!\n",
                   modefileName);
          exit (1);
      }
      fprintf (stderr, " Mode control file:      %s\n", modefileName);

  } else {
      
      modeStr = argv[1];
      fileName = argv[2];
      serialFileName = argv[3];
      
      /* check and convert mode string */
      if (str2mode(modeStr, &mode) != 0 && mode != MRDTX) 
      {
          fprintf(stderr, "Invalid amr_mode specified: '%s'\n",
                  modeStr);
          exit(1);
      }
  }
  

  /*----------------------------------------------------------------------*
   * Open speech file and result file (output serial bit stream)          *
   *----------------------------------------------------------------------*/
  if (strcmp(fileName, "-") == 0) {
     file_speech = stdin;
  }
  else if ((file_speech = fopen (fileName, "rb")) == NULL)
  {
      fprintf (stderr, "Error opening input file  %s !!\n", fileName);
      exit (1);
  }
  fprintf (stderr, " Input speech file:      %s\n", fileName);

  if (strcmp(serialFileName, "-") == 0) {
     file_serial = stdout;
  }
  else if ((file_serial = fopen (serialFileName, "wb")) == NULL)
  {
      fprintf (stderr,"Error opening output bitstream file %s !!\n",serialFileName);
      exit (1);
  }
  fprintf (stderr, " Output bitstream file:  %s\n", serialFileName);

   datafile = fopen("E:\\AMR\\decindata\\speechdata.txt", "wb");
   if(NULL  == datafile )
      printf("open decindata file faily! \n");
   else 
     printf("open decindata file successfully! \n");

  /*-----------------------------------------------------------------------*
   * Initialisation of the coder.                                          *
   *-----------------------------------------------------------------------*/

  
 // if (   Speech_Encode_Frame_init(&speech_encoder_state, dtx, &sid_state))
  if (   Speech_Encode_Frame_init(&amrcoder, dtx))
      exit(-1);



#ifdef MMS_IO
  /* write magic number to indicate single channel AMR file storage format */
  fwrite(AMR_MAGIC_NUMBER, sizeof(UWord8), strlen(AMR_MAGIC_NUMBER), file_serial);
#endif

  /*-----------------------------------------------------------------------*
   * Process speech frame by frame                                         *
   *-----------------------------------------------------------------------*/

  //memset(new_speech, 0 ,320);

  frame = 0;
  while (fread (new_speech, sizeof (Word16), L_FRAME, file_speech) == L_FRAME)
  {

	
    frame++;
    if(frame > 400 ) break;

#if 1
     /* read new mode string from file if required */
     if (useModeFile) 
     {
         int res;
         if ((res = read_mode(file_modes, &mode)) == EOF) 
	  {
             fprintf(stderr, "\nend of mode control file reached");
             break;
         } else if (res == 1)
             exit(-1);
     }
	 
      

     
     /* zero flags and parameter bits */
    //    for (i = 0; i < 250; i++)
    //       serial[i] = 0;



     /* encode speech */
     time1 = clock();
    // a = GetTickCount();


      Speech_Encode_Frame(amrcoder, mode, new_speech, &bitstr[0], &used_mode,&tx_type); 

     time2 += clock() - time1;
  


#ifndef MMS_IO

#if 1
  for(i = 0; i<32; i++)
  	{

	  if(i%64 == 0) fprintf(datafile, "\n\r"); fflush(datafile);
  	   
  	   fprintf(datafile, "%d,", bitstr[i]); fflush(datafile);	   
  	}
  
#else
   if (fwrite (bitstr, sizeof (unsigned char), 32, file_serial)!= 32)
   {
         fprintf(stderr, "\nerror writing output file: %s\n",
                 strerror(errno));
         exit(-1);
     }
#endif



#else

     packed_size = PackBits(used_mode, mode, tx_type, &serial[1], packed_bits);



     /* write file storage format bitstream to output file */
     if (fwrite (packed_bits, sizeof (UWord8), packed_size, file_serial)
         != packed_size) {
         fprintf(stderr, "\nerror writing output file: %s\n",
                 strerror(errno));
         exit(-1);
     }
#endif

     fflush(file_serial);

     /* perform homing if homing frame was detected at encoder input */
#if 0
     if (reset_flag != 0)
     {
         Speech_Encode_Frame_reset(speech_encoder_state);
         sid_sync_reset(sid_state);
     }
#endif	 

#endif
  }
  
  fprintf (stderr, "\n%d frame(s) processed\n", frame);
  
  printf("Fist: time for %d  frame is : %d , for eache frame is % f  \n", frame, time2, (double) time2/(frame *CLOCKS_PER_SEC));
 
  /*-----------------------------------------------------------------------*
   * Close down speech coder                                               *
   *-----------------------------------------------------------------------*/
 // Speech_Encode_Frame_exit(&speech_encoder_state,&sid_state);
    Speech_Encode_Frame_exit(&amrcoder);
  
  return (0);
}