296 lines
10 KiB
JavaScript
296 lines
10 KiB
JavaScript
// ==========================================================
|
|
// ========= / THE CODE COMPILED BY EMCC ENDS HERE ==========
|
|
// ==========================================================
|
|
|
|
asm$ =
|
|
{
|
|
malloc: function(type, size)
|
|
{
|
|
real_size=size*type.BYTES_PER_ELEMENT;
|
|
pointer = Module._malloc(real_size);
|
|
heap = new Uint8Array(Module.HEAPU8.buffer, pointer, real_size);
|
|
return {
|
|
asm$: true,
|
|
ptr: heap.byteOffset,
|
|
free: function() { Module._free(this.ptr); },
|
|
arr: new type(heap.buffer, heap.byteOffset, size),
|
|
size: size
|
|
};
|
|
},
|
|
cpy: function(dst, dst_offset, src, src_offset, size)
|
|
{
|
|
if(typeof dst.asm$!='undefined') dst=dst.arr;
|
|
if(typeof src.asm$!='undefined') src=src.arr;
|
|
for(var i=0;i<size;i++)
|
|
dst[dst_offset+i]=src[src_offset+i];
|
|
}
|
|
};
|
|
|
|
// void firdes_lowpass_f(float *output, int length, float cutoff_rate, window_t window)
|
|
firdes_lowpass_f = Module.cwrap('firdes_lowpass_f', null, ['number', 'number', 'number', 'number']);
|
|
|
|
// rational_resampler_ff_t rational_resampler_ff(float *input, float *output, int input_size, int interpolation, int decimation, float *taps, int taps_length, int last_taps_delay)
|
|
rational_resampler_ff = Module.cwrap('rational_resampler_ff', 'struct', ['number', 'number', 'number', 'number', 'number', 'number', 'number', 'number']);
|
|
|
|
|
|
rational_resampler_ff=function(pinput,poutput,input_length,interpolation,decimation,ptaps,taps_length,last_taps_delay )
|
|
{ stackbase=STACKTOP;
|
|
STACKTOP+=4*3;
|
|
_rational_resampler_ff(stackbase, pinput, poutput, input_length, interpolation, decimation, ptaps, taps_length,last_taps_delay);
|
|
returnstruct={ input_processed: getValue(stackbase,'i32'), output_size: getValue(stackbase+4,'i32'), last_taps_delay: getValue(stackbase+8,'i32') };
|
|
STACKTOP=stackbase;
|
|
return returnstruct;
|
|
}
|
|
|
|
sdrjs={};
|
|
|
|
sdrjs.WINDOW_BOXCAR=0;
|
|
sdrjs.WINDOW_BLACKMAN=1;
|
|
sdrjs.WINDOW_HAMMING=2;
|
|
|
|
//this will be impportant whil converting arrays
|
|
//http://stackoverflow.com/questions/25839216/convert-float32array-to-int16array
|
|
|
|
/*sdrjs.prototype.FirdesLowpassF=function(taps_length,transition_bw,window)
|
|
{
|
|
this.calculate=function(){}
|
|
this.get_output=function(){}
|
|
this.get_output_heap=function(){}
|
|
};*/
|
|
|
|
|
|
sdrjs.ConvertI16_F=function(i16data)
|
|
{
|
|
var f32data=new Float32Array(i16data.length);
|
|
for(var i=0;i<i16data.length;i++) f32data[i]=i16data[i]/32768;
|
|
return f32data;
|
|
}
|
|
|
|
ima_adpcm_codec=function(encode,pinput,poutput,input_length,state)
|
|
{
|
|
myfunc=(encode)?_encode_ima_adpcm_i16_u8:_decode_ima_adpcm_u8_i16;
|
|
stackbase=STACKTOP;
|
|
STACKTOP+=4*2; //sizeof(int)*2
|
|
myfunc(stackbase, pinput, poutput, input_length, state.ptr);
|
|
state.arr[0]=getValue(stackbase+0,'i32');
|
|
state.arr[1]=getValue(stackbase+4,'i32');
|
|
STACKTOP=stackbase;
|
|
};
|
|
|
|
sdrjs.ImaAdpcm=function()
|
|
{
|
|
this.BUFSIZE=1024*64;
|
|
this.ima_adpcm_state=asm$.malloc(Int32Array,2);
|
|
this.i16_buffer=asm$.malloc(Int16Array,this.BUFSIZE*2);
|
|
this.u8_buffer=asm$.malloc(Uint8Array,this.BUFSIZE);
|
|
this.ima_adpcm_state.arr[0]=0;
|
|
this.ima_adpcm_state.arr[1]=0;
|
|
|
|
this.encode=function(data)
|
|
{
|
|
//not_tested_yet
|
|
asm$.cpy(this.i16_buffer.arr,0,data,0,data.length);
|
|
ima_adpcm_codec(true,this.i16_buffer.ptr,this.u8_buffer.ptr,data.length,this.ima_adpcm_state);
|
|
out=new Uint8Array(data.length/2);
|
|
asm$.cpy(out,0,this.u8_buffer,0,data.length/2);
|
|
return out;
|
|
};
|
|
|
|
this.decode=function(data)
|
|
{
|
|
asm$.cpy(this.u8_buffer.arr,0,data,0,data.length);
|
|
ima_adpcm_codec(false,this.u8_buffer.ptr,this.i16_buffer.ptr,data.length,this.ima_adpcm_state);
|
|
out=new Int16Array(data.length*2);
|
|
asm$.cpy(out,0,this.i16_buffer.arr,0,data.length*2);
|
|
return out;
|
|
};
|
|
this.reset=function() { this.ima_adpcm_state.arr[0]=this.ima_adpcm_state.arr[1]=0|0; }
|
|
};
|
|
|
|
sdrjs.REBUFFER_FIXED=0; //rebuffer should return arrays of fixed size
|
|
sdrjs.REBUFFER_MAX=1; //rebuffer should return arrays with a maximal size of the parameter size
|
|
|
|
sdrjs.Rebuffer=function(size,mode)
|
|
{
|
|
this.mode=mode;
|
|
this.size=size;
|
|
this.total_size=0;
|
|
this.arrays=[];
|
|
this.last_arr=[];
|
|
this.last_arr_offset=0;
|
|
this.push=function(data)
|
|
{
|
|
this.total_size+=data.length;
|
|
this.arrays.push(data);
|
|
};
|
|
this.remaining=function()
|
|
{
|
|
var fixed_bufs_num=Math.floor(this.total_size/this.size);
|
|
if(!this.mode) return fixed_bufs_num;
|
|
else return fixed_bufs_num+(!!(this.total_size-fixed_bufs_num*this.size)); //if REBUFFER_MAX, add one if we could return one more buffer (smaller than the fixed size)
|
|
};
|
|
this.take=function() { var a=this._take(); /*console.log(a);*/ return a; };
|
|
this._take=function()
|
|
{
|
|
var remain=this.size;
|
|
var offset=0;
|
|
var obuf=new Float32Array(size);
|
|
//console.log("==== get new obuf ====", size);
|
|
while(remain)
|
|
{
|
|
if(this.last_arr_offset==this.last_arr.length)
|
|
{
|
|
if(this.arrays.length==0)
|
|
{
|
|
//console.log("this should not happen");
|
|
if(this.mode) //REBUFFER_MAX
|
|
{
|
|
this.total_size=0;
|
|
return obuf.subarray(0,offset);
|
|
}
|
|
else return new Float32Array(0); //REBUFFER_FIXED
|
|
}
|
|
//console.log("pick new last_arr");
|
|
this.last_arr=this.arrays.shift();
|
|
this.last_arr_offset=0;
|
|
}
|
|
var rwithin=this.last_arr.length-this.last_arr_offset;
|
|
//console.log("b :: ","remain", remain, "rwithin",rwithin,"last_arr.length",this.last_arr.length,"larroffset",this.last_arr_offset,"offset",offset);
|
|
if(remain<rwithin)
|
|
{
|
|
//console.log("remain < rwithin"); //seems problematic @Andris
|
|
for(var i=0;i<remain;i++) obuf[offset++]=this.last_arr[this.last_arr_offset++];
|
|
remain=0;
|
|
}
|
|
else
|
|
{
|
|
//console.log("remain > rwithin");
|
|
for(var i=0;i<rwithin;i++) obuf[offset++]=this.last_arr[this.last_arr_offset++];
|
|
remain-=rwithin;
|
|
}
|
|
//console.log("e :: ","remain", remain, "rwithin",rwithin,"last_arr.length",this.last_arr.length,"larroffset",this.last_arr_offset,"offset",offset);
|
|
}
|
|
|
|
this.total_size-=obuf.length;
|
|
//console.log("return _take");
|
|
return obuf;
|
|
};
|
|
};
|
|
|
|
sdrjs.RationalResamplerFF=function(interpolation,decimation,transition_bw,window)
|
|
{
|
|
this.interpolation=interpolation;
|
|
this.decimation=decimation;
|
|
this.transition_bw = (typeof transition_bw=='undefined')?0.05:transition_bw;
|
|
this.window = (typeof window=='undefined')?1:window;
|
|
this.buffer_size=1024*512;
|
|
this.output_buffer_size=Math.floor((this.buffer_size*interpolation)/decimation);
|
|
this.input_buffer = asm$.malloc(Float32Array,this.buffer_size);
|
|
this.output_buffer = asm$.malloc(Float32Array,this.output_buffer_size);
|
|
//Calculate filter
|
|
this.taps_length = Math.floor(4/this.transition_bw);
|
|
this.taps = asm$.malloc(Float32Array,this.taps_length);
|
|
var cutoff_for_interpolation=1.0/interpolation;
|
|
var cutoff_for_decimation=1.0/decimation;
|
|
var cutoff = (cutoff_for_interpolation<cutoff_for_decimation)?cutoff_for_interpolation:cutoff_for_decimation; //get the lower
|
|
firdes_lowpass_f(this.taps.ptr, this.taps_length, cutoff/2, window);
|
|
|
|
this.remain = 0;
|
|
this.remain_offset=0;
|
|
this.last_taps_delay=0;
|
|
|
|
this.process=function(input)
|
|
{
|
|
|
|
if(input.length+this.remain > this.buffer_size)
|
|
{
|
|
return new Float32Array(0); console.log("sdrjs.RationalResamplerFF: critical audio buffering error"); //This should not happen...
|
|
/* console.log("RationalResamplerFF: splitting..."); //TODO: this branch has not been checked
|
|
output_buffers=Array();
|
|
new_buffer_size=this.buffer_size/2;
|
|
i=0;
|
|
//process the input in chunks of new_buffer_size, and add the output product Float32Array-s to output_buffers.
|
|
while((i++)*new_buffer_size<=input.length)
|
|
{
|
|
output_buffers.push(this._process_noheapcheck(input.subarray(i*new_buffer_size,(i+1)*new_buffer_size)));
|
|
}
|
|
//add up the sizes of the output_buffer-s.
|
|
total_output_length=0;
|
|
output_buffers.forEach(function(a){total_output_length+=a.length;});
|
|
//create one big buffer from concatenating the output_buffer-s
|
|
output=new Float32Array(total_output_length);
|
|
output_pos=0;
|
|
output_buffers.forEach(function(a){
|
|
asm$.cpy(output,output_pos,a,0,a.length);
|
|
output_pos+=a.length;
|
|
});
|
|
return output;*/
|
|
}
|
|
else return this._process_noheapcheck(input);
|
|
};
|
|
this._process_noheapcheck=function(input) //if we are sure we have enough space in the buffers
|
|
{
|
|
asm$.cpy(this.input_buffer.arr,0,this.input_buffer.arr,this.remain_offset,this.remain);
|
|
asm$.cpy(this.input_buffer.arr, this.remain, input, 0, input.length);
|
|
var total_input_size=input.length+this.remain;
|
|
d=rational_resampler_ff(this.input_buffer.ptr, this.output_buffer.ptr, total_input_size, this.interpolation, this.decimation, this.taps.ptr, this.taps_length, this.last_taps_delay);
|
|
this.last_taps_delay=d.last_taps_delay;
|
|
this.remain=total_input_size-d.input_processed;
|
|
this.remain_offset=d.input_processed;
|
|
var output_copy_arr=new Float32Array(d.output_size);
|
|
asm$.cpy(output_copy_arr,0,this.output_buffer.arr,0,d.output_size);
|
|
return output_copy_arr;
|
|
};
|
|
};
|
|
|
|
|
|
_sdrjs_logb=function(what) { document.body.innerHTML+=what+"<br />"; }
|
|
|
|
|
|
function test_firdes_lowpass_f_original()
|
|
{
|
|
//Original method explained over here:
|
|
//http://kapadia.github.io/emscripten/2013/09/13/emscripten-pointers-and-pointers.html
|
|
_sdrjs_logb("test_firdes_lowpass_f_original():");
|
|
_sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js...");
|
|
_sdrjs_logb("output should be the same as: <strong>csdr firdes_lowpass_f 0.1 101 HAMMING</strong>");
|
|
|
|
var outputSize = 101*4;
|
|
var outputPtr = Module._malloc(outputSize);
|
|
var outputHeap = new Uint8Array(Module.HEAPU8.buffer, outputPtr, outputSize);
|
|
firdes_lowpass_f(outputHeap.byteOffset,101,0.1,2);
|
|
var output = new Float32Array(outputHeap.buffer, outputHeap.byteOffset, 101);
|
|
outputStr=String();
|
|
for(i=0;i<output.length;i++) outputStr+=output[i].toFixed(6)+", ";
|
|
Module._free(outputHeap.byteOffset);
|
|
_sdrjs_logb(outputStr);
|
|
}
|
|
|
|
|
|
function test_firdes_lowpass_f_new()
|
|
{
|
|
//This is much simpler, using asm$
|
|
_sdrjs_logb("test_firdes_lowpass_f_new():");
|
|
_sdrjs_logb("Now designing FIR filter with firdes_lowpass_f in sdr.js...");
|
|
_sdrjs_logb("output should be the same as: <strong>csdr firdes_lowpass_f 0.1 101 HAMMING</strong>");
|
|
|
|
output=asm$.malloc(Float32Array,101);
|
|
firdes_lowpass_f(output.ptr,101,0.1,2);
|
|
outputStr=String();
|
|
for(i=0;i<output.arr.length;i++) outputStr+=(output.arr[i]).toFixed(6)+", ";
|
|
output.free();
|
|
_sdrjs_logb(outputStr);
|
|
}
|
|
|
|
function test_struct_return_value()
|
|
{
|
|
v=STACKTOP;
|
|
STACKTOP+=4*3;
|
|
_shift_addition_init(v,0.2);
|
|
console.log(
|
|
"sinval=", getValue(v,'float'),
|
|
"cosval=", getValue(v+4,'float'),
|
|
"rate=", getValue(v+8,'float')
|
|
);
|
|
STACKTOP=v;
|
|
}
|