emerging-ezaudio

Search uses release 0.4.0.0 · 1,035 definitions

Releases (3)

0.4.0.0 indexed
0.3.0.0 unindexed
0.2.9.0 unindexed

Definitions (1,035)

src/mp3_syn.bend

def sc.v6row 3, column ii+1
def sc.v5row 3, column ii
def sc.v4row 2, column ii+1
def sc.v3row 2, column ii
def sc.v2row 1, column ii+1
def sc.v1row 1, column ii
def sc.v0row 0, column ii, then the six neighbour slots
def sc.valsthe seven samples of column ii, each an Array.get
type Scspectrum Array beside the rows Array
def sc.bandsfour band values from the seven column samples
def sc.put4store the four bands and hand both Arrays back
def sc.putwrite one scatter group from the seven samples
def sc.onescatter one group of four bands into the spectrum Array
def sc.goseven scatter steps; the eighth is the tail
type Sfrow 0, 1, 2 and 3 of column 7
def sc.e3fourth tail sample, index 31
def sc.e2third tail sample, index 23
def sc.e1second tail sample, index 15
def sc.e0first tail sample, index 7, then the other three rows
def sc.tsetfour tail bands.
def sc.tenddrop the rows Array once the four tail samples have been read
def sc.taillast scatter group, which has no i+1 neighbour.
def sc.runscatter every band of frequency bin kk
def dc.rowsbutterfly the gathered rows, then scatter them back into the spectrum
def dc.scatscatter one frequency bin.
def dc.oneone frequency bin of the 32-point DCT-II.
def dc.runDCT-II of 18 frequency bins.
type Laone F32 read from the polyphase delay Array
def la.of
def ln.at
def ln.set
def ln.fill
def ln.pullpull one sample into an accumulator; hop is remaining after this read
def ln.listfirst hop+1 slots of an Array as a list
type Macfour running polyphase sums, a and b
type MkMAC state plus the delay line handle mac.* only reads
def mac.avmode 0 replaces, mode 2 flips the a product, otherwise both add
def mac.wrapply one lane of a window load
def mac.jyone of the four lanes, y slot
def mac.jzone of the four lanes, z slot
def mac.jone of the four lanes
def mac.js_nextfour lanes of one load, advance one lane
def mac.jsfour lanes of one load
def mac.mode3odd or even load
def mac.mode2pick the load mode
def mac.modek = 0 replaces, odd k uses mode 2, other even k uses mode 1
def mac.poswindow-coefficient index for block row ii and load kk
type Swone window coefficient handed back beside the table Array.get just read
def sw.of
def sw.at
def sw.tab242 synthesis-window coefficients.
type MwMAC state plus the window table the next load still reads
def mac.step2second coefficient, then the eight-lane load
def mac.step1first coefficient, then its neighbour
def mac.stepone of the eight loads.
def mac.keight loads
def mac.scscale a polyphase sum into a sample
def mac.p8write the eight samples this row produces
def mac.putstore the row
def mac.zfresh accumulators
def blk.offchannel offset: the right channel starts at 576 when there are two
type Gaone F32 read from the post-DCT granule Array
def ga.of
def ga.at
type Lgdelay line handed back beside the granule Array a write just read
def blk.ixsubband index.
def blk.rd
def blk.w4dfourth sample of a four-lane write
def blk.w4cthird sample: band 0, this channel's left slot
def blk.w4bsecond sample: the right channel of this band
def blk.w4afirst sample: the left channel of this band
def blk.w4write the four samples at zlin + 4*slot
def blk.w2bright channel of a two-lane write
def blk.w2aleft channel of a two-lane write
def blk.w2the second write of a row uses band (1+ii), not band 0
def blk.pre2second preamble write: band 16 at the next time
def blk.prepreamble: bands 16 and 0 at the current and next time
def blk.histindex of the history write, which steps back 16 slots
def blk.wsdfourth lane: this band at the next time, right channel
def blk.wscthird lane: this band at the next time, left channel
def blk.wsbsecond lane: this band at this time, right channel
def blk.wsafirst lane: this band at this time, left channel
def blk.wssame band at this time and the next, four lanes
def blk.i1current-slot writes for row ii
def blk.i2bhistory write, after the next-slot write has returned the granule
def blk.i2next-slot and history writes for row ii
def blk.ibhistory writes, after the current-slot write has returned the granule
def blk.iboth writes for row ii
def sp.a1a3(z+896) - z, times 29
def sp.a1a2
def sp.a1a
def sp.a1b2slots 1 and 13, times 213
def sp.a1b1
def sp.a1b
def sp.a1c2slots 12 and 2, times 459
def sp.a1c1
def sp.a1c
def sp.a1d2slots 3 and 11, times 2037
def sp.a1d1
def sp.a1d