modules/audio_coding/codecs/g722/test/testG722.cc

/*
 *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
 *
 *  Use of this source code is governed by a BSD-style license
 *  that can be found in the LICENSE file in the root of the source
 *  tree. An additional intellectual property rights grant can be found
 *  in the file PATENTS.  All contributing project authors may
 *  be found in the AUTHORS file in the root of the source tree.
 */

/*
 * testG722.cpp : Defines the entry point for the console application.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "typedefs.h"  // NOLINT(build/include)

/* include API */
#include "modules/audio_coding/codecs/g722/g722_interface.h"

/* Runtime statistics */
#include <time.h>
#define CLOCKS_PER_SEC_G722  100000

// Forward declaration
typedef struct WebRtcG722EncInst    G722EncInst;
typedef struct WebRtcG722DecInst    G722DecInst;

/* function for reading audio data from PCM file */
bool readframe(int16_t *data, FILE *inp, size_t length)
{
    size_t rlen = fread(data, sizeof(int16_t), length, inp);
    if (rlen >= length)
      return false;
    memset(data + rlen, 0, (length - rlen) * sizeof(int16_t));
    return true;
}

int main(int argc, char* argv[])
{
    char inname[60], outbit[40], outname[40];
    FILE *inp, *outbitp, *outp;

    int framecnt;
    bool endfile;
    size_t framelength = 160;
    G722EncInst *G722enc_inst;
    G722DecInst *G722dec_inst;

    /* Runtime statistics */
    double starttime;
    double runtime = 0;
    double length_file;

    size_t stream_len = 0;
    int16_t shortdata[960];
    int16_t decoded[960];
    uint8_t streamdata[80 * 6];
    int16_t speechType[1];

    /* handling wrong input arguments in the command line */
    if (argc!=5)  {
        printf("\n\nWrong number of arguments or flag values.\n\n");

        printf("\n");
        printf("Usage:\n\n");
        printf("./testG722.exe framelength infile outbitfile outspeechfile \n\n");
        printf("with:\n");
        printf("framelength  :    Framelength in samples.\n\n");
        printf("infile       :    Normal speech input file\n\n");
        printf("outbitfile   :    Bitstream output file\n\n");
        printf("outspeechfile:    Speech output file\n\n");
        exit(0);

    }

    /* Get frame length */
    int framelength_int = atoi(argv[1]);
    if (framelength_int < 0) {
        printf("  G.722: Invalid framelength %d.\n", framelength_int);
        exit(1);
    }
    framelength = static_cast<size_t>(framelength_int);

    /* Get Input and Output files */
    sscanf(argv[2], "%s", inname);
    sscanf(argv[3], "%s", outbit);
    sscanf(argv[4], "%s", outname);

    if ((inp = fopen(inname,"rb")) == NULL) {
        printf("  G.722: Cannot read file %s.\n", inname);
        exit(1);
    }
    if ((outbitp = fopen(outbit,"wb")) == NULL) {
        printf("  G.722: Cannot write file %s.\n", outbit);
        exit(1);
    }
    if ((outp = fopen(outname,"wb")) == NULL) {
        printf("  G.722: Cannot write file %s.\n", outname);
        exit(1);
    }
    printf("\nInput:%s\nOutput bitstream:%s\nOutput:%s\n", inname, outbit, outname);

    /* Create and init */
    WebRtcG722_CreateEncoder((G722EncInst **)&G722enc_inst);
    WebRtcG722_CreateDecoder((G722DecInst **)&G722dec_inst);
    WebRtcG722_EncoderInit((G722EncInst *)G722enc_inst);
    WebRtcG722_DecoderInit((G722DecInst *)G722dec_inst);


    /* Initialize encoder and decoder */
    framecnt = 0;
    endfile = false;
    while (!endfile) {
        framecnt++;

        /* Read speech block */
        endfile = readframe(shortdata, inp, framelength);

        /* Start clock before call to encoder and decoder */
        starttime = clock()/(double)CLOCKS_PER_SEC_G722;

        /* G.722 encoding + decoding */
        stream_len = WebRtcG722_Encode((G722EncInst *)G722enc_inst, shortdata, framelength, streamdata);
        WebRtcG722_Decode(G722dec_inst, streamdata, stream_len, decoded,
                          speechType);

        /* Stop clock after call to encoder and decoder */
        runtime += (double)((clock()/(double)CLOCKS_PER_SEC_G722)-starttime);

        /* Write coded bits to file */
        if (fwrite(streamdata, sizeof(short), stream_len / 2, outbitp) !=
            stream_len / 2) {
          return -1;
        }
        /* Write coded speech to file */
        if (fwrite(decoded, sizeof(short), framelength, outp) !=
            framelength) {
          return -1;
        }
    }

    WebRtcG722_FreeEncoder((G722EncInst *)G722enc_inst);
    WebRtcG722_FreeDecoder((G722DecInst *)G722dec_inst);

    length_file = ((double)framecnt*(double)framelength/16000);
    printf("\n\nLength of speech file: %.1f s\n", length_file);
    printf("Time to run G.722:      %.2f s (%.2f %% of realtime)\n\n", runtime, (100*runtime/length_file));
    printf("---------------------END----------------------\n");

    fclose(inp);
    fclose(outbitp);
    fclose(outp);

    return 0;
}