qcelp_a.c

高通的cmda语音压缩算法is96a源代码. 针对自己的dsp将最耗时的c改成汇编就几乎是商用代码了.

/**********************************************************************/
/* QCELP Variable Rate Speech Codec - Simulation of TIA IS96-A, service */
/*     option one for TIA IS95, North American Wideband CDMA Digital  */
/*     Cellular Telephony.                                            */
/*                                                                    */
/* (C) Copyright 1993, 1994 QUALCOMM Incorporated                     */
/* QUALCOMM Incorporated                                              */
/* 10555 Sorrento Valley Road                                         */
/* San Diego, CA 92121                                                */
/*                                                                    */
/* Note:  Reproduction and use of this software for the design and    */
/*     development of North American Wideband CDMA Digital            */
/*     Cellular Telephony Standards is authorized by                  */
/*     QUALCOMM Incorporated.  QUALCOMM Incorporated does not         */
/*     authorize the use of this software for any other purpose.      */
/*                                                                    */
/*     The availability of this software does not provide any license */
/*     by implication, estoppel, or otherwise under any patent rights */
/*     of QUALCOMM Incorporated or others covering any use of the     */
/*     contents herein.                                               */
/*                                                                    */
/*     Any copies of this software or derivative works must include   */
/*     this and all other proprietary notices.                        */
/**********************************************************************/
/* qcelp.c - main qcelp program */
 
#include <stdio.h>
#include"struct.h"

char *prog;
char prog_desc[] = "QCELP Variable Rate Speech Coder - Ver 2.02";

main(argc, argv)
INTTYPE  argc;
char *argv[];
{
    INTTYPE   i;
    char  fn_inspeech[80], fn_outspeech[80], fn_signal[80];
    INTTYPE   fin, fout, fsig;
    float in_speech[FSIZE+LPCOFFSET];
    float out_speech[FSIZE];
    INTTYPE   frame_num;
    INTTYPE   numread;

    struct ENCODER_MEM     encoder_memory;
    struct DECODER_MEM     decoder_memory;
    struct PACKET          packet;
    struct CONTROL         control;
    struct SIGNAL_DATA     *sig_ptr;

    prog=argv[0];
    print_welcome_message();

    parse_command_line(argc, argv, fn_inspeech, fn_outspeech, fn_signal,
		       &control);
    
    initialize_encoder_and_decoder(&encoder_memory, &decoder_memory, 
				   &control);
    
    if (control.signal_file==YES) {
	get_signaling_data(fn_signal, &(sig_ptr));
    }

    frame_num=0;

    open_binary_input_file(&fin, fn_inspeech);
    open_binary_output_file(&fout, fn_outspeech);

    if (control.decode_only==NO) {
	if ((numread=read_samples(fin, in_speech, LPCOFFSET))
	    !=LPCOFFSET) {
	    printf("Not even enough samples for 1 frame!\n");
	    usage(&control);
	}
	numread=read_samples(fin, &in_speech[LPCOFFSET], FSIZE);
	dc_block(in_speech, &(encoder_memory.dc_block_mem), 
		 LPCOFFSET, &control);
    }
    else {
	if ((numread=read_data(fin, packet.data, WORDS_PER_PACKET))
	    !=WORDS_PER_PACKET) {
	    printf("Not even one full packet in input file\n");
	    usage(&control);
	}
    }

    /* while the input file is not empty, encode and decode a frame */
    while ((numread>0)&&
	   ((control.num_frames==UNLIMITED)||(frame_num<control.num_frames))) {

	if (control.decode_only==NO) {
	    for (i=numread; i<FSIZE; i++) {
		in_speech[LPCOFFSET+i]=0;
	    }
	    encoder(in_speech, &packet, &control, &(sig_ptr), 
		    &encoder_memory, out_speech, frame_num);
	}

	if (control.encode_only==NO) {
	    decoder(out_speech, &packet, &control, 
		    &decoder_memory);
	    write_samples(fout, out_speech, FSIZE);
	}
	else {
	    write_data(fout, packet.data, WORDS_PER_PACKET);
	}

	if (control.decode_only==NO) {
	    numread=read_samples(fin, &in_speech[LPCOFFSET], FSIZE);
	}
	else {
	    numread=read_data(fin, packet.data, WORDS_PER_PACKET);
	}

	frame_num++;
    }

    close(fin);
    close(fout);

}

print_welcome_message() {
    printf("\n%s: %s\n",prog, prog_desc);
    printf("Copyright QUALCOMM Incorporated 1993, 1994\n\n");
}

/* parse_command_line - command line arguments processed here */
char prog_opts[] = "s:l:h:edp:f:i:o:"; /* command line flags */
extern char *optarg;
extern INTTYPE  optind;

parse_command_line(argc, argv, fn_inspeech, fn_outspeech, fn_signal, control) 
INTTYPE  argc;
char *argv[];
char *fn_inspeech, *fn_outspeech, *fn_signal;
struct CONTROL  *control;
{
    INTTYPE i,err;

    control->encode_only=NO;
    control->decode_only=NO;
    control->pf_flag    =PF_ON;
    control->num_frames =UNLIMITED;
    control->max_rate   =4;
    control->min_rate   =1;
    control->signal_file=NO;

    err=0;
    while ((i = getopt(argc, argv, prog_opts)) != EOF) switch (i) {
    case 'd':
	control->decode_only=YES;
	control->encode_only=NO;
	break;
    case 'e':
	control->encode_only=YES;
	control->decode_only=NO;
	break;
    case 'f':
	sscanf(argv[optind-1],"%d",&(control->num_frames));
	printf("Will only process up to %d frames\n",control->num_frames);
	break;
    case 'h':
	sscanf(argv[optind-1],"%d",&(control->max_rate));
	printf("Highest rate allowed is %d\n",control->max_rate);
	break;
    case 'l':
	sscanf(argv[optind-1],"%d",&(control->min_rate));
	printf("Lowest rate allowed is %d\n",control->min_rate);
	break;
    case 'p':
	sscanf(argv[optind-1],"%d",&(control->pf_flag));
	if (control->pf_flag==YES) {
	    printf("Postfilter enabled\n");
	}
	else if (control->pf_flag==NO) {
	    printf("Postfilter disabled\n");
	}
	else {
	    printf("Unknown postfilter flag\n");
	    usage(control);
	}
	break;
    case 'i':
	err++;
	sprintf(fn_inspeech,"%s",argv[optind-1]);
	break;
    case 's':
	control->signal_file=YES;
	sprintf(fn_signal,"%s",argv[optind-1]);
	break;
    case 'o':
	err++;
	sprintf(fn_outspeech,"%s",argv[optind-1]);
	break;
    default:
	usage(control);
    }
    if (err<2) {
	printf("%s: Some required command line arguments missing\n", prog);
	usage(control);
    }
}

usage(control)
struct CONTROL *control;
{
    
    printf("Usage : %s -i infn -o outfn [-d] [-e] [-h max] [-l min] [-f frames] [-p flag] [-s sigfn]\n", prog);
    printf("\t-i\tinfn\t: input file\n");
    printf("\t-o\toutfn\t: output file\n");
    printf("\t-d\t\t: decode only (input file is packet file)\n");
    printf("\t-e\t\t: encode only (output file is packet file)\n");
    printf("\t-h\tmax\t: highest rate allowed set to max\n"); 
    printf("\t-l\tmin\t: lowest rate allowed set to min\n"); 
    printf("\t\t\t  for the -h and -l command line arguments,\n");
    printf("\t\t\t  \"Rate 1\" is %d, \"Rate 1/2\" is %d,\n", FULL, HALF);
    printf("\t\t\t  \"Rate 1/4\" is %d, \"Rate 1/8\" is %d.\n", 
	   QUARTER, EIGHTH);
    printf("\t-f\tframes\t: stop after `frames' frames have been processed\n");
    printf("\t-p\tflag\t: postfilter enable/disable: %d to enable, %d to disable\n",YES, NO);
    printf("\t\t\t  current setting at break time is %d\n",control->pf_flag);
    printf("\t-s\tsigfn\t: signaling file name\n");
    printf("\n");
    exit(-1);
}