31     def __init__(self, dt, sr):  argument
33         self.dt = dt
34         self.sr = sr
36     def get_gain_offset(self, nbytes):  argument
38         sr_ind = self.sr if self.sr < T.SRATE_48K_HR \
39             else 4 + (self.sr - T.SRATE_48K_HR)
43         if self.sr >= T.SRATE_48K_HR:
48     def get_noise_indices(self, bw, xq, lastnz):  argument
50         nf_start = [  6, 12, 18, 24 ][self.dt]
51         nf_width = [  1,  1,  2,  3 ][self.dt]
53         bw_stop = T.I[self.dt][min(bw, T.SRATE_48K)][-1]
63     def __init__(self, dt, sr):  argument
67         self.reset_off  = 0
68         self.nbits_off  = 0
69         self.nbits_spec = 0
70         self.nbits_est  = 0
72         (self.g_idx, self.noise_factor, self.xq, self.lastnz,
73                 self.nbits_residual_max, self.xg) = \
76     def estimate_gain(self, x, nbytes, nbits_spec, nbits_off, g_off):  argument
82         hr = (self.sr >= T.SRATE_48K_HR)
86             dt = self.dt
87             sr = self.sr
149     def quantize(self, g_int, x):  argument
153         hr = (self.sr >= T.SRATE_48K_HR)
169     def compute_nbits(self, nbytes, x, lastnz, nbits_spec):  argument
171         mode = [ 0,   1 ][int(self.sr < T.SRATE_96K_HR and \
172                               nbytes >= 20 * (3 + min(self.sr, T.SRATE_48K)))]
173         rate = [ 0, 512 ][int(self.sr < T.SRATE_96K_HR and \
174                               nbytes >  20 * (1 + min(self.sr, T.SRATE_48K)))]
225         self.rate = rate
226         self.lsb_mode = mode == 1 and nbits_est > nbits_spec
228         return (nbits_est, nbits_trunc, lastnz_trunc, self.lsb_mode)
230     def adjust_gain(self, g_idx, nbits, nbits_spec):  argument
236         dt = self.dt
237         sr = self.sr
255         if self.sr >= T.SRATE_48K_HR and \
262         elif self.sr < T.SRATE_48K_HR and \
277     def estimate_noise(self, bw, xq, lastnz, x):  argument
279         i_nf = self.get_noise_indices(bw, xq, lastnz)
285     def run(self, bw, nbytes, nbits_bw, nbits_ltpf, nbits_sns, nbits_tns, x):  argument
287         sr = self.sr
291         hr = self.sr >= T.SRATE_48K_HR
305         nbits_off = self.nbits_off + self.nbits_spec - self.nbits_est
308         nbits_off = 0 if self.reset_off else \
309                     0.8 * self.nbits_off + 0.2 * nbits_off
311         g_off = self.get_gain_offset(nbytes)
313         (g_min, g_int, self.reset_off) = \
314             self.estimate_gain(x, nbytes, nbits_spec, nbits_off, g_off)
315         self.nbits_off = nbits_off
316         self.nbits_spec = nbits_spec
320         (xg, xq, lastnz) = self.quantize(g_int, x)
323             self.compute_nbits(nbytes, xq, lastnz, nbits_spec)
325         self.nbits_est = nbits_est
329         g_adj = self.adjust_gain(g_int - g_off, nbits_est, nbits_spec)
332         (xg, xq, lastnz) = self.quantize(g_adj, xg)
335             self.compute_nbits(nbytes, xq, lastnz, nbits_spec)
337         self.g_idx = g_int + g_adj - g_off
338         self.xq = xq
339         self.lastnz = lastnz_trunc
341         self.nbits_residual_max = nbits_spec - nbits_trunc + 4
342         self.xg = xg
346         self.noise_factor = self.estimate_noise(bw, xq, lastnz, x)
348         return (self.xq, self.lastnz, self.xg)
350     def store(self, b):  argument
352         ne = T.I[self.dt][self.sr][-1]
355         b.write_uint((self.lastnz >> 1) - 1, nbits_lastnz)
356         b.write_uint(self.lsb_mode, 1)
357         b.write_uint(self.g_idx, 8)
359     def encode(self, bits):  argument
363         bits.write_uint(self.noise_factor, 3)
369         x = self.xq
372         for n in range(0, self.lastnz, 2):
373             t = c + self.rate
386                 if lev == 0 and self.lsb_mode:
403             if lev > 0 and self.lsb_mode:
426         if self.lsb_mode == 0:
427             nbits_residual = min(bits.get_bits_left(), self.nbits_residual_max)
429             for i in range(len(self.xg)):
431                 if self.xq[i] == 0:
434                 bits.write_bit(self.xg[i] >= self.xq[i])
447     def __init__(self, dt, sr):  argument
451         (self.lastnz, self.lsb_mode, self.g_idx) = \
454     def fill_noise(self, bw, x, lastnz, f_nf, nf_seed):  argument
456         i_nf = self.get_noise_indices(bw, x, lastnz)
467     def load(self, b):  argument
469         ne = T.I[self.dt][self.sr][-1]
472         self.lastnz = (b.read_uint(nbits_lastnz) + 1) << 1
473         self.lsb_mode = b.read_uint(1)
474         self.g_idx = b.read_uint(8)
476         if self.lastnz > ne:
479     def decode(self, bits, bw, nbytes):  argument
487         ne = T.I[self.dt][self.sr][-1]
489         rate = [ 0, 512 ][int(self.sr < T.SRATE_96K_HR and \
490                               nbytes >  20 * (1 + min(self.sr, T.SRATE_48K)))]
495         for n in range(0, self.lastnz, 2):
511                 if self.lsb_mode == 0 or lev > 0:
543         if self.lsb_mode == 0:
590         zero_frame = (self.lastnz <= 2 and x[0] == 0 and x[1] == 0
591                       and self.g_idx <= 0 and f_nf >= 7)
593         if self.lsb_mode == 0:
603             x = self.fill_noise(bw, x, self.lastnz, f_nf, nf_seed)
607         g_int = self.get_gain_offset(nbytes) + self.g_idx