int main(void) { int i; int ret = 0; ec_enc enc; ec_dec dec; ec_byte_buffer buf; unsigned char *ptr; int val[10000], decay[10000]; ALLOC_STACK; ptr = malloc(DATA_SIZE); ec_byte_writeinit_buffer(&buf, ptr, DATA_SIZE); //ec_byte_writeinit(&buf); ec_enc_init(&enc,&buf); val[0] = 3; decay[0] = 6000; val[1] = 0; decay[1] = 5800; val[2] = -1; decay[2] = 5600; for (i=3;i<10000;i++) { val[i] = rand()%15-7; decay[i] = rand()%11000+5000; } for (i=0;i<10000;i++) ec_laplace_encode(&enc, &val[i], decay[i]); ec_enc_done(&enc); ec_byte_readinit(&buf,ec_byte_get_buffer(&buf),ec_byte_bytes(&buf)); ec_dec_init(&dec,&buf); for (i=0;i<10000;i++) { int d = ec_laplace_decode(&dec, decay[i]); if (d != val[i]) { fprintf (stderr, "Got %d instead of %d\n", d, val[i]); ret = 1; } } return ret; }
int main(int _argc,char **_argv){ ec_enc enc; ec_dec dec; long nbits; long nbits2; double entropy; int ft; int ftb; int sz; int i; int ret; unsigned int sym; unsigned int seed; unsigned char *ptr; const char *env_seed; ret=0; entropy=0; if (_argc > 2) { fprintf(stderr, "Usage: %s [<seed>]\n", _argv[0]); return 1; } env_seed = getenv("SEED"); if (_argc > 1) seed = atoi(_argv[1]); else if (env_seed) seed = atoi(env_seed); else seed = time(NULL); /*Testing encoding of raw bit values.*/ ptr = (unsigned char *)malloc(DATA_SIZE); ec_enc_init(&enc,ptr, DATA_SIZE); for(ft=2;ft<1024;ft++){ for(i=0;i<ft;i++){ entropy+=log(ft)*M_LOG2E; ec_enc_uint(&enc,i,ft); } } /*Testing encoding of raw bit values.*/ for(ftb=1;ftb<16;ftb++){ for(i=0;i<(1<<ftb);i++){ entropy+=ftb; nbits=ec_tell(&enc); ec_enc_bits(&enc,i,ftb); nbits2=ec_tell(&enc); if(nbits2-nbits!=ftb){ fprintf(stderr,"Used %li bits to encode %i bits directly.\n", nbits2-nbits,ftb); ret=-1; } } } nbits=ec_tell_frac(&enc); ec_enc_done(&enc); fprintf(stderr, "Encoded %0.2lf bits of entropy to %0.2lf bits (%0.3lf%% wasted).\n", entropy,ldexp(nbits,-3),100*(nbits-ldexp(entropy,3))/nbits); fprintf(stderr,"Packed to %li bytes.\n",(long)ec_range_bytes(&enc)); ec_dec_init(&dec,ptr,DATA_SIZE); for(ft=2;ft<1024;ft++){ for(i=0;i<ft;i++){ sym=ec_dec_uint(&dec,ft); if(sym!=(unsigned)i){ fprintf(stderr,"Decoded %i instead of %i with ft of %i.\n",sym,i,ft); ret=-1; } } } for(ftb=1;ftb<16;ftb++){ for(i=0;i<(1<<ftb);i++){ sym=ec_dec_bits(&dec,ftb); if(sym!=(unsigned)i){ fprintf(stderr,"Decoded %i instead of %i with ftb of %i.\n",sym,i,ftb); ret=-1; } } } nbits2=ec_tell_frac(&dec); if(nbits!=nbits2){ fprintf(stderr, "Reported number of bits used was %0.2lf, should be %0.2lf.\n", ldexp(nbits2,-3),ldexp(nbits,-3)); ret=-1; } /*Testing an encoder bust prefers range coder data over raw bits. This isn't a general guarantee, will only work for data that is buffered in the encoder state and not yet stored in the user buffer, and should never get used in practice. It's mostly here for code coverage completeness.*/ /*Start with a 16-bit buffer.*/ ec_enc_init(&enc,ptr,2); /*Write 7 raw bits.*/ ec_enc_bits(&enc,0x55,7); /*Write 12.3 bits of range coder data.*/ ec_enc_uint(&enc,1,2); ec_enc_uint(&enc,1,3); ec_enc_uint(&enc,1,4); ec_enc_uint(&enc,1,5); ec_enc_uint(&enc,2,6); ec_enc_uint(&enc,6,7); ec_enc_done(&enc); ec_dec_init(&dec,ptr,2); if(!enc.error /*The raw bits should have been overwritten by the range coder data.*/ ||ec_dec_bits(&dec,7)!=0x05 /*And all the range coder data should have been encoded correctly.*/ ||ec_dec_uint(&dec,2)!=1 ||ec_dec_uint(&dec,3)!=1 ||ec_dec_uint(&dec,4)!=1 ||ec_dec_uint(&dec,5)!=1 ||ec_dec_uint(&dec,6)!=2 ||ec_dec_uint(&dec,7)!=6){ fprintf(stderr,"Encoder bust overwrote range coder data with raw bits.\n"); ret=-1; } srand(seed); fprintf(stderr,"Testing random streams... Random seed: %u (%.4X)\n", seed, rand() % 65536); for(i=0;i<409600;i++){ unsigned *data; unsigned *tell; unsigned tell_bits; int j; int zeros; ft=rand()/((RAND_MAX>>(rand()%11U))+1U)+10; sz=rand()/((RAND_MAX>>(rand()%9U))+1U); data=(unsigned *)malloc(sz*sizeof(*data)); tell=(unsigned *)malloc((sz+1)*sizeof(*tell)); ec_enc_init(&enc,ptr,DATA_SIZE2); zeros = rand()%13==0; tell[0]=ec_tell_frac(&enc); for(j=0;j<sz;j++){ if (zeros) data[j]=0; else data[j]=rand()%ft; ec_enc_uint(&enc,data[j],ft); tell[j+1]=ec_tell_frac(&enc); } if (rand()%2==0) while(ec_tell(&enc)%8 != 0) ec_enc_uint(&enc, rand()%2, 2); tell_bits = ec_tell(&enc); ec_enc_done(&enc); if(tell_bits!=(unsigned)ec_tell(&enc)){ fprintf(stderr,"ec_tell() changed after ec_enc_done(): %i instead of %i (Random seed: %u)\n", ec_tell(&enc),tell_bits,seed); ret=-1; } if ((tell_bits+7)/8 < ec_range_bytes(&enc)) { fprintf (stderr, "ec_tell() lied, there's %i bytes instead of %d (Random seed: %u)\n", ec_range_bytes(&enc), (tell_bits+7)/8,seed); ret=-1; } ec_dec_init(&dec,ptr,DATA_SIZE2); if(ec_tell_frac(&dec)!=tell[0]){ fprintf(stderr, "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n", 0,ec_tell_frac(&dec),tell[0],seed); } for(j=0;j<sz;j++){ sym=ec_dec_uint(&dec,ft); if(sym!=data[j]){ fprintf(stderr, "Decoded %i instead of %i with ft of %i at position %i of %i (Random seed: %u).\n", sym,data[j],ft,j,sz,seed); ret=-1; } if(ec_tell_frac(&dec)!=tell[j+1]){ fprintf(stderr, "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n", j+1,ec_tell_frac(&dec),tell[j+1],seed); } } free(tell); free(data); } /*Test compatibility between multiple different encode/decode routines.*/ for(i=0;i<409600;i++){ unsigned *logp1; unsigned *data; unsigned *tell; unsigned *enc_method; int j; sz=rand()/((RAND_MAX>>(rand()%9U))+1U); logp1=(unsigned *)malloc(sz*sizeof(*logp1)); data=(unsigned *)malloc(sz*sizeof(*data)); tell=(unsigned *)malloc((sz+1)*sizeof(*tell)); enc_method=(unsigned *)malloc(sz*sizeof(*enc_method)); ec_enc_init(&enc,ptr,DATA_SIZE2); tell[0]=ec_tell_frac(&enc); for(j=0;j<sz;j++){ data[j]=rand()/((RAND_MAX>>1)+1); logp1[j]=(rand()%15)+1; enc_method[j]=rand()/((RAND_MAX>>2)+1); switch(enc_method[j]){ case 0:{ ec_encode(&enc,data[j]?(1<<logp1[j])-1:0, (1<<logp1[j])-(data[j]?0:1),1<<logp1[j]); }break; case 1:{ ec_encode_bin(&enc,data[j]?(1<<logp1[j])-1:0, (1<<logp1[j])-(data[j]?0:1),logp1[j]); }break; case 2:{ ec_enc_bit_logp(&enc,data[j],logp1[j]); }break; case 3:{ unsigned char icdf[2]; icdf[0]=1; icdf[1]=0; ec_enc_icdf(&enc,data[j],icdf,logp1[j]); }break; } tell[j+1]=ec_tell_frac(&enc); } ec_enc_done(&enc); if((ec_tell(&enc)+7U)/8U<ec_range_bytes(&enc)){ fprintf(stderr,"tell() lied, there's %i bytes instead of %d (Random seed: %u)\n", ec_range_bytes(&enc),(ec_tell(&enc)+7)/8,seed); ret=-1; } ec_dec_init(&dec,ptr,DATA_SIZE2); if(ec_tell_frac(&dec)!=tell[0]){ fprintf(stderr, "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n", 0,ec_tell_frac(&dec),tell[0],seed); } for(j=0;j<sz;j++){ int fs; int dec_method; dec_method=rand()/((RAND_MAX>>2)+1); switch(dec_method){ case 0:{ fs=ec_decode(&dec,1<<logp1[j]); sym=fs>=(1<<logp1[j])-1; ec_dec_update(&dec,sym?(1<<logp1[j])-1:0, (1<<logp1[j])-(sym?0:1),1<<logp1[j]); }break; case 1:{ fs=ec_decode_bin(&dec,logp1[j]); sym=fs>=(1<<logp1[j])-1; ec_dec_update(&dec,sym?(1<<logp1[j])-1:0, (1<<logp1[j])-(sym?0:1),1<<logp1[j]); }break; case 2:{ sym=ec_dec_bit_logp(&dec,logp1[j]); }break; case 3:{ unsigned char icdf[2]; icdf[0]=1; icdf[1]=0; sym=ec_dec_icdf(&dec,icdf,logp1[j]); }break; } if(sym!=data[j]){ fprintf(stderr, "Decoded %i instead of %i with logp1 of %i at position %i of %i (Random seed: %u).\n", sym,data[j],logp1[j],j,sz,seed); fprintf(stderr,"Encoding method: %i, decoding method: %i\n", enc_method[j],dec_method); ret=-1; } if(ec_tell_frac(&dec)!=tell[j+1]){ fprintf(stderr, "Tell mismatch between encoder and decoder at symbol %i: %i instead of %i (Random seed: %u).\n", j+1,ec_tell_frac(&dec),tell[j+1],seed); } } free(enc_method); free(tell); free(data); free(logp1); } ec_enc_init(&enc,ptr,DATA_SIZE2); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,0,2); ec_enc_patch_initial_bits(&enc,3,2); if(enc.error){ fprintf(stderr,"patch_initial_bits failed"); ret=-1; } ec_enc_patch_initial_bits(&enc,0,5); if(!enc.error){ fprintf(stderr,"patch_initial_bits didn't fail when it should have"); ret=-1; } ec_enc_done(&enc); if(ec_range_bytes(&enc)!=1||ptr[0]!=192){ fprintf(stderr,"Got %d when expecting 192 for patch_initial_bits",ptr[0]); ret=-1; } ec_enc_init(&enc,ptr,DATA_SIZE2); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,0,1); ec_enc_bit_logp(&enc,1,6); ec_enc_bit_logp(&enc,0,2); ec_enc_patch_initial_bits(&enc,0,2); if(enc.error){ fprintf(stderr,"patch_initial_bits failed"); ret=-1; } ec_enc_done(&enc); if(ec_range_bytes(&enc)!=2||ptr[0]!=63){ fprintf(stderr,"Got %d when expecting 63 for patch_initial_bits",ptr[0]); ret=-1; } ec_enc_init(&enc,ptr,2); ec_enc_bit_logp(&enc,0,2); for(i=0;i<48;i++){ ec_enc_bits(&enc,0,1); } ec_enc_done(&enc); if(!enc.error){ fprintf(stderr,"Raw bits overfill didn't fail when it should have"); ret=-1; } ec_enc_init(&enc,ptr,2); for(i=0;i<17;i++){ ec_enc_bits(&enc,0,1); } ec_enc_done(&enc); if(!enc.error){ fprintf(stderr,"17 raw bits encoded in two bytes"); ret=-1; } free(ptr); return ret; }
int main(int _argc,char **_argv){ ec_byte_buffer buf; ec_enc enc; ec_dec dec; long nbits; long nbits2; double entropy; int ft; int ftb; int sym; int sz; int i; int ret; unsigned int seed; ret=0; entropy=0; unsigned char *ptr; if (_argc > 2) { fprintf(stderr, "Usage: %s [<seed>]\n", _argv[0]); return 1; } if (_argc > 1) seed = atoi(_argv[1]); else seed = (time(NULL) ^ (getpid()%(1<<16) << 16)); /*Testing encoding of raw bit values.*/ ptr = malloc(DATA_SIZE); ec_byte_writeinit_buffer(&buf, ptr, DATA_SIZE); ec_enc_init(&enc,&buf); for(ft=2;ft<1024;ft++){ for(i=0;i<ft;i++){ entropy+=log(ft)*M_LOG2E; ec_enc_uint(&enc,i,ft); } } /*Testing encoding of raw bit values.*/ for(ftb=0;ftb<16;ftb++){ for(i=0;i<(1<<ftb);i++){ entropy+=ftb; nbits=ec_enc_tell(&enc,0); ec_enc_bits(&enc,i,ftb); nbits2=ec_enc_tell(&enc,0); if(nbits2-nbits!=ftb){ fprintf(stderr,"Used %li bits to encode %i bits directly.\n", nbits2-nbits,ftb); ret=-1; } } } nbits=ec_enc_tell(&enc,4); ec_enc_done(&enc); fprintf(stderr, "Encoded %0.2lf bits of entropy to %0.2lf bits (%0.3lf%% wasted).\n", entropy,ldexp(nbits,-4),100*(nbits-ldexp(entropy,4))/nbits); fprintf(stderr,"Packed to %li bytes.\n",(long)(buf.ptr-buf.buf)); ec_byte_readinit(&buf,ptr,DATA_SIZE); ec_dec_init(&dec,&buf); for(ft=2;ft<1024;ft++){ for(i=0;i<ft;i++){ sym=ec_dec_uint(&dec,ft); if(sym!=i){ fprintf(stderr,"Decoded %i instead of %i with ft of %i.\n",sym,i,ft); ret=-1; } } } for(ftb=0;ftb<16;ftb++){ for(i=0;i<(1<<ftb);i++){ sym=ec_dec_bits(&dec,ftb); if(sym!=i){ fprintf(stderr,"Decoded %i instead of %i with ftb of %i.\n",sym,i,ftb); ret=-1; } } } nbits2=ec_dec_tell(&dec,4); if(nbits!=nbits2){ fprintf(stderr, "Reported number of bits used was %0.2lf, should be %0.2lf.\n", ldexp(nbits2,-4),ldexp(nbits,-4)); ret=-1; } ec_byte_writeclear(&buf); srand(seed); fprintf(stderr,"Testing random streams... Random seed: %u (%.4X)\n", seed, rand() % 65536); for(i=0;i<409600;i++){ unsigned *data; int j; int tell_bits; int zeros; ft=rand()/((RAND_MAX>>(rand()%11))+1)+10; sz=rand()/((RAND_MAX>>(rand()%9))+1); data=(unsigned *)malloc(sz*sizeof(*data)); ec_byte_writeinit_buffer(&buf, ptr, DATA_SIZE2); ec_enc_init(&enc,&buf); zeros = rand()%13==0; for(j=0;j<sz;j++){ if (zeros) data[j]=0; else data[j]=rand()%ft; ec_enc_uint(&enc,data[j],ft); } if (rand()%2==0) while(ec_enc_tell(&enc, 0)%8 != 0) ec_enc_uint(&enc, rand()%2, 2); tell_bits = ec_enc_tell(&enc, 0); ec_enc_done(&enc); if ((tell_bits+7)/8 < ec_byte_bytes(&buf)) { fprintf (stderr, "tell() lied, there's %li bytes instead of %d (Random seed: %u)\n", ec_byte_bytes(&buf), (tell_bits+7)/8,seed); ret=-1; } tell_bits -= 8*ec_byte_bytes(&buf); ec_byte_readinit(&buf,ptr,DATA_SIZE2); ec_dec_init(&dec,&buf); for(j=0;j<sz;j++){ sym=ec_dec_uint(&dec,ft); if(sym!=data[j]){ fprintf(stderr, "Decoded %i instead of %i with ft of %i at position %i of %i (Random seed: %u).\n", sym,data[j],ft,j,sz,seed); ret=-1; } } ec_byte_writeclear(&buf); free(data); } free(ptr); return ret; }
int main( int argc, char* argv[] ) { unsigned long int temp=0; clock_t start_cycles,stop_cycles; double filetime; size_t counter; SKP_int32 args, totPackets, ret, nBytes; double sumBytes,avg_rate; SKP_int16 in[ MAX_FRAME_LENGTH_MS * MAX_API_FS_KHZ * MAX_INPUT_FRAMES ]; char speechInFileName[ 150 ], bitOutFileName[ 150 ]; FILE *bitOutFile, *speechInFile; SKP_int32 encSizeBytes; void *psEnc; SKP_uint8 range_buf[ MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES ]; ec_enc range_enc_celt_state; /* default settings */ SKP_int32 API_fs_Hz = 48000; SKP_int32 max_internal_fs_Hz = 16000; SKP_int32 min_internal_fs_Hz = 8000; SKP_int32 targetRate_bps = 64000; SKP_int32 packetSize_ms = 20; SKP_int32 frameSizeReadFromFile_ms = 10; SKP_int32 complexity_mode = 2, smplsSinceLastPacket; SKP_int32 quiet = 0; SKP_SILK_SDK_EncControlStruct encControl; // Struct for input to encoder if( argc < 3 ) { print_usage( argv ); exit( 0 ); } /* get arguments */ args = 1; strcpy( speechInFileName, argv[ args ] ); args++; strcpy( bitOutFileName, argv[ args ] ); args++; while( args < argc ) { if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &API_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-Fs_maxInternal" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &max_internal_fs_Hz ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-plength" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &packetSize_ms ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-rate" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &targetRate_bps ); args += 2; } else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-complexity" ) == 0 ) { sscanf( argv[ args + 1 ], "%d", &complexity_mode ); args += 2; }else if( SKP_STR_CASEINSENSITIVE_COMPARE( argv[ args ], "-quiet" ) == 0 ) { quiet = 1; args++; } else { printf( "Error: unrecognized setting: %s\n\n", argv[ args ] ); print_usage( argv ); exit( 0 ); } } /* If no max internal set set to API fs */ if( max_internal_fs_Hz == 0 ) { max_internal_fs_Hz = API_fs_Hz; } /* Print options */ if( !quiet ) { printf("******************* Compiled for %d bit cpu ********* \n", (int)sizeof(void*) * 8 ); printf( "Input: %s\n", speechInFileName ); printf( "Output: %s\n", bitOutFileName ); printf( "API sampling rate: %d Hz\n", API_fs_Hz ); printf( "Maximum internal sampling rate: %d Hz\n", max_internal_fs_Hz ); printf( "Packet interval: %d ms\n", packetSize_ms ); printf( "Complexity: %d\n", complexity_mode ); printf( "Target bitrate: %d bps\n", targetRate_bps ); } /* Open files */ speechInFile = fopen( speechInFileName, "rb" ); if( speechInFile == NULL ) { printf( "Error: could not open input file %s\n", speechInFileName ); exit( 0 ); } bitOutFile = fopen( bitOutFileName, "wb" ); if( bitOutFile == NULL ) { printf( "Error: could not open output file %s\n", bitOutFileName ); exit( 0 ); } /* Create Encoder */ ret = SKP_Silk_SDK_Get_Encoder_Size( &encSizeBytes ); if( ret ) { printf( "\nSKP_Silk_create_encoder returned %d", ret ); } psEnc = malloc( encSizeBytes ); /* Reset Encoder */ ret = SKP_Silk_SDK_InitEncoder( psEnc, &encControl ); if( ret ) { printf( "\nSKP_Silk_reset_encoder returned %d", ret ); } /* Set Encoder parameters */ encControl.API_sampleRate = API_fs_Hz; encControl.maxInternalSampleRate = max_internal_fs_Hz; encControl.minInternalSampleRate = min_internal_fs_Hz; encControl.payloadSize_ms = packetSize_ms; encControl.complexity = complexity_mode; encControl.bitRate = ( targetRate_bps > 0 ? targetRate_bps : 0 ); if( API_fs_Hz > MAX_API_FS_KHZ * 1000 || API_fs_Hz < 0 ) { printf( "\nError: API sampling rate = %d out of range, valid range 8000 - 48000 \n \n", API_fs_Hz ); exit( 0 ); } /*Reset init */ totPackets = 0; // totActPackets = 0; smplsSinceLastPacket = 0; sumBytes = 0.0; // sumActBytes = 0.0; while( 1 ) { if( smplsSinceLastPacket == 0 ) { /* Init range coder */ ec_enc_init( &range_enc_celt_state, range_buf, MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES ); } /* Read input from file */ counter = fread( in, sizeof( SKP_int16 ), ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000, speechInFile ); /*check end of input file*/ if( (SKP_int)counter < ( ( frameSizeReadFromFile_ms * API_fs_Hz ) / 1000 ) ) { break; } /* max payload size */ nBytes = MAX_BYTES_PER_FRAME * MAX_INPUT_FRAMES; /////////////* Silk Encoder *///////////////////// start_cycles = clock(); ret = SKP_Silk_SDK_Encode( psEnc, &encControl, in, (SKP_int16)counter, &range_enc_celt_state, &nBytes, 0 ); stop_cycles = clock(); temp = temp + (stop_cycles - start_cycles); if( ret ) { printf( "\nSKP_Silk_Encode returned %d", ret ); break; } ////////////////////////////////////////////////// /* Get packet size */ packetSize_ms = encControl.payloadSize_ms; smplsSinceLastPacket += ( SKP_int )counter; if( ( ( 1000 * smplsSinceLastPacket ) / API_fs_Hz ) == packetSize_ms ) { /* Finish up the range coder */ ec_enc_done( &range_enc_celt_state ); /* Sends a dummy zero size packet in case of DTX period */ /* to make it work with the decoder test program. */ /* In practice should be handled by RTP sequence numbers */ totPackets++; sumBytes += nBytes; /* Write payload size */ fwrite( &nBytes, sizeof( SKP_int32 ), 1, bitOutFile ); /* Write payload */ fwrite( range_buf, sizeof( SKP_uint8 ), nBytes, bitOutFile ); smplsSinceLastPacket = 0; } } /* Write dummy because it can not end with 0 bytes */ nBytes = -1; /* Write payload size */ fwrite( &nBytes, sizeof( SKP_int32 ), 1, bitOutFile ); /* Free Encoder */ free( psEnc ); fclose( speechInFile ); fclose( bitOutFile ); filetime = totPackets * 1e-3 * packetSize_ms; avg_rate = 8.0 / packetSize_ms * sumBytes / totPackets; // act_rate = 8.0 / packetSize_ms * sumActBytes / totActPackets; if( !quiet ) { printf( "Took %ld cycles to decode...\n", temp); printf( "\nFile length: %.3f s\n", filetime ); printf( "\nAverage bitrate: %.3f kbps\n", avg_rate ); printf( "\rPackets encoded: %d\n", totPackets ); // printf( "\nActive bitrate: %.3f kbps", act_rate ); printf( "\n\n" ); } return 0; }