main.c

完整的EVRC压缩解压缩算法源码,附带一个简单的例子程序。

			case 'p':
				eargs->post_filter = (Shortword) atoi(argv[optind - 1]);
				if (eargs->post_filter != 0)
					eargs->post_filter = 1;
				eargs->post_filter_default = 0;
				break;
			case 'n':
				eargs->noise_suppression = (Shortword) atoi(argv[optind - 1]);
				if (eargs->noise_suppression != 0)
					eargs->noise_suppression = 1;
				eargs->noise_suppression_default = 0;
				break;
			case 'f':
				eargs->max_frames = (Shortword) atoi(argv[optind - 1]);
				break;
            case 't':
                tty_option = (short)atoi(argv[optind-1]);
                break;
            case 'D':
                tty_debug_print_flag = (short) atoi(argv[optind-1]) & TTY_DEBUG_PRINT;
                tty_debug_flag = (short) atoi(argv[optind-1]) & TTY_DEBUG_DUMP;
                break;
            case 's':
				eargs->signaling_filename = argv[optind-1];
                eargs->fp_signaling = fopen(argv[optind-1],"rb");
				if( eargs->fp_signaling == NULL )
				{
					fprintf(stderr,"Error opening signaling file %s\n",argv[optind-1]);
					exit(-1);
				}
				break;
            }
		}
		if (eargs->min_rate > eargs->max_rate)
		{
			eargs->min_rate = eargs->max_rate;
		}
	}
	return (eargs);
}

/*======================================================================*/
/*         ..Returns number of frames in a binary file.                 */
/*----------------------------------------------------------------------*/

Shortword GetNumFrames(	  FILE * fp,
						  Shortword blocksize)
{
	/*....(local) variables.... */
	Shortword position;
	Shortword numFrames;

	/*....execute.... */
	position = ftell(fp);
	fseek(fp, 0L, 2);
	numFrames = ftell(fp) / blocksize;
	fseek(fp, position, 0);
	return (numFrames);
}

void reset_op_stats(op_struct *op_stat, char *name)
{
    op_stat->avg_ops=0;
    op_stat->max_ops=0;
    op_stat->min_ops=0x7fffffffL;
    strcpy(op_stat->name,name);
}

void update_op_stats(op_struct *op_stat, Longword ops, Longword fnum)
{
    op_stat->avg_ops+=ops;

    if (ops > op_stat->max_ops)
    {
        op_stat->max_ops=ops;
        op_stat->max_fnum=fnum;
    }
    if (ops < op_stat->min_ops)
    {
        op_stat->min_ops=ops;
        op_stat->min_fnum=fnum;
    }
}

void print_op_stats(FILE *fp, op_struct *op_stat, Longword fnum)
{
    float avg;
    float avg_mops;

    avg = op_stat->avg_ops/(float)fnum;
    avg_mops = avg*50.0*1.0e-6;

    fprintf(fp,"%s Average OPS/Frame : %6.0f\n",op_stat->name,avg);
    fprintf(fp,"%s Average MOPS      : %2.03f\n",op_stat->name,avg_mops);
    fprintf(fp,"%s Max OPS/Frame     : %ld\n",op_stat->name,op_stat->max_ops);
    fprintf(fp,"%s Max OPS at Frame #: %ld\n",op_stat->name,op_stat->max_fnum);
    fprintf(fp,"%s Min OPS/Frame     : %ld\n",op_stat->name,op_stat->min_ops);
    fprintf(fp,"%s Min OPS at Frame #: %ld\n\n",op_stat->name,op_stat->min_fnum);
}

/*======================================================================*/
/*         ..Speech encoder.                                            */
/*----------------------------------------------------------------------*/
void Encode(
			   Shortword rate,
			   Shortword * obuffer
)
{
	/*....execute.... */
	encode(rate, obuffer);
	post_encode();
}

/*======================================================================*/
/*         ..Speech decoder.                                            */
/*----------------------------------------------------------------------*/
void Decode(
			   Shortword * ibuffer,
			   Shortword rate,
			   Shortword post_filter,
			   Shortword * obuffer
)
{
	/*....execute.... */
	decode(ibuffer, rate, post_filter, obuffer);
}
//char *argv[] = {"test_is127","-i","ddddddd.d","-o","pcm687change.pcm","-d","-p", "0"};
//int argc = 8;
/*======================================================================*/
/*         ..Main.                                                      */
/*----------------------------------------------------------------------*/
int main(int argc, char *argv[])//
{
	/*....(local) variables.... */
	EvrcArgs *eargs;

    op_struct encode_ops;
    op_struct decode_ops;
    op_struct ns_ops;
    op_struct rda_ops;
    op_struct hpf_ops;
    op_struct pe_ops;

	FILE *ifileP;
	FILE *ofileP;

	Shortword buf[SPEECH_BUFFER_LEN];
    Shortword buf16[BITSTREAM_BUFFER_LEN];

	Shortword buf_count;
	Shortword ibuf_len;
	Shortword obuf_len;
    Shortword j;
	Shortword rate;
	Shortword beta;
    float rate_sum;
    float avg_rate;
	Longword R[17];
    Shortword min_rate;
	Shortword max_rate;
	char signaling;

    Shortword k;

   	unsigned char pread[24] = {0};
	unsigned char read_rate;
	int i;
	Shortword buf_UP[SPEECH_BUFFER_LEN];
	Shortword buf_DOWN[SPEECH_BUFFER_LEN];
    /*....execute.... */
	/*...get arguments and check usage... */
	if ((eargs = get_eargs(argc, argv)) == NULL)
	{
		usage(stdout, argv[0]);
		exit(-1);
	}
	print_eargs(stdout, eargs);

	/*...open files... */
	if ((ifileP = fopen(eargs->input_filename, "rb")) == NULL)
	{
		fprintf(stderr, "%s:  ERROR - Unable to open input file \"%s\".\n",
				argv[0],
				eargs->input_filename
			);
		exit(-1);
	}
	if ((ofileP = fopen(eargs->output_filename, "wb")) == NULL)
	{
		fprintf(stderr, "%s:  ERROR - Unable to open output file \"%s\".\n",
				argv[0],
				eargs->output_filename
			);
		exit(-1);
	}

	/*...loop counter max... */
	if (eargs->decode_only)
	{
		buf_count = GetNumFrames(ifileP, sizeof(Shortword) * BITSTREAM_BUFFER_LEN);
	}
	else
	{
		buf_count = GetNumFrames(ifileP, sizeof(Shortword) * SPEECH_BUFFER_LEN);
	}


    /*...processing loop... */
    reset_op_stats(&encode_ops,"Encode\0");
    reset_op_stats(&decode_ops,"Decode\0");
    reset_op_stats(&pe_ops,"Pre-Encode\0");
    reset_op_stats(&ns_ops,"Noise Supression\0");
    reset_op_stats(&hpf_ops,"BQIIR\0");
    reset_op_stats(&rda_ops,"RDA\0");

	InitEncoder();
	InitDecoder();

    if( tty_option == TTY_NO_GAIN )
    {
        init_tty_enc( &tty_enc_char, &tty_enc_header, &tty_enc_baud_rate);
        init_tty_dec();
        tty_debug();
    }

	rate_sum = 0.0;
	avg_rate = 0.0;

	ibuf_len = eargs->ibuf_len;
	obuf_len = eargs->obuf_len;
	j = 1;

	if (!eargs->decode_only)
	{
        while (((fread(buf, sizeof(Shortword), ibuf_len, ifileP)) == ibuf_len)
				&& (j<=eargs->max_frames))
		{
		    OP_RESET;
		    bqiir(buf);
		    update_op_stats(&hpf_ops,op_counter,j);

            if( tty_option == TTY_NO_GAIN )
            {
                tty_enc_flag = tty_enc( &tty_enc_char,
                                        &tty_enc_header,
                                        &tty_enc_baud_rate,
                                        buf,
                                        FrameSize );
            }

            if( (tty_option == TTY_DISABLED || tty_enc_flag == 0)
                && eargs->noise_suppression)
            {
                OP_RESET;
                noise_suprs(buf);
                noise_suprs(buf + ibuf_len / 2);
            }
            else
            {
                for (k=0; k<ibuf_len; k++)
                {
                    buf[k] = shift_r(buf[k],-1);
                }
            }

            update_op_stats(&ns_ops,op_counter,j);
            OP_RESET;

			beta = pre_encode(buf, R);
            update_op_stats(&pe_ops,op_counter,j);
            OP_RESET;

            if( tty_option == TTY_NO_GAIN && tty_enc_flag != 0 )
            {
                /* Force to full rate for TTY packets */
                min_rate = MIN(4,eargs->max_rate);
            }
            else
            {
                min_rate = eargs->min_rate;
            }
            
			max_rate = eargs->max_rate;
			if( eargs->fp_signaling != NULL )
			{
				k = fread(&signaling, sizeof(char), 1, eargs->fp_signaling);
				if( k == 0 )
				{
					fseek(eargs->fp_signaling,0,0);
					k = fread(&signaling, sizeof(char), 1, eargs->fp_signaling);
					if( k == 0 )
					{
						fprintf(stderr,"Error reading signaling file %s: File Empty!\n",eargs->signaling_filename);
						exit(-1);
					}
				}
				if( signaling )
				{
					max_rate = MIN(3,eargs->max_rate);
				}
			}
                
            rate = select_rate(R, max_rate, min_rate, beta);
            update_op_stats(&rda_ops,op_counter,j);
            OP_RESET;

			switch (rate)
			{
			case 1:
				rate_sum += 1;
				break;
			case 3:
				rate_sum += 4;
				break;
			default:
				rate_sum += 8;
				break;
			}
			avg_rate = (rate_sum / (float) j) * 1.2;

            Encode(rate, buf16);
            update_op_stats(&encode_ops, op_counter, j);
            OP_RESET;

            if (eargs->encode_only)
			{
				fwrite(&rate, sizeof(Shortword), 1, ofileP);
                fwrite(buf16, sizeof(Shortword), obuf_len, ofileP);
				fprintf(stderr, "Encoding %d of %d   avg_rate= %6.2f\r", j, buf_count, avg_rate);
			}
			else
			{

                Decode(buf16, rate, eargs->post_filter, buf);
                update_op_stats(&decode_ops, op_counter, j);
                fwrite(buf, sizeof(Shortword), obuf_len, ofileP);
				fprintf(stderr, "Encoding/Decoding %d of %d   avg_rate= %6.2f\r", j, buf_count, avg_rate);
			}
			j++;
		}
	}
	else
	{
	/*	while ((fread(&rate, sizeof(Shortword), 1, ifileP)) == 1)
		{
            if ((fread(buf16, sizeof(Shortword), ibuf_len, ifileP)) == ibuf_len)
			{
                OP_RESET;
                Decode(buf16, rate, eargs->post_filter, buf);
                update_op_stats(&decode_ops, op_counter, j);

                fprintf(stderr, "Decoding %d of %d\r", j, buf_count);
                fwrite(buf, sizeof(Shortword), obuf_len, ofileP);
				j++;
			}
		}*/
		while (!feof(ifileP))
		{
			fread(&read_rate, 1, 1, ifileP);
			*pread = read_rate;
			if(read_rate == 1)
			{
				fread(pread + 1, 1, 22, ifileP);
				rate = format_change(pread, buf16);
			}
			else if(read_rate == 2)
			{
				fread(pread + 1, 1, 10, ifileP);
				rate = format_change(pread, buf16);
			}
			else
			{
				fread(pread + 1, 1, 2, ifileP);
				rate = format_change(pread, buf16);
			}
			    OP_RESET;
                Decode(buf16, rate, eargs->post_filter, buf);
                update_op_stats(&decode_ops, op_counter, j);

                fprintf(stderr, "Decoding %d of %d\r", j, buf_count);
				if(j%2)
				{
					memcpy(buf_DOWN, buf, SPEECH_BUFFER_LEN * 2);
				}
				else
				{
					memcpy(buf_UP, buf, SPEECH_BUFFER_LEN * 2);
				}
				if(j%2)
				{
				for(i = 0; i < SPEECH_BUFFER_LEN; i++)
				*(buf + i) = ((*(buf_DOWN + i) >> 1) + (*(buf_DOWN + i) >> 3) + (*(buf_DOWN + i) >> 4)) + ((*(buf_UP + i) >> 1) +( *(buf_UP + i) >> 3) + (*(buf_DOWN + i) >> 4));
				fwrite(buf, sizeof(Shortword), obuf_len, ofileP);
				}
                
				j++;
		}
	}

	if (eargs->fp_signaling != NULL)
	   fclose(eargs->fp_signaling);

	fprintf(stderr, "\n");
	exit(0);
}