refactor sender

amodem/send.py

@@ -19,67 +19,66 @@ modem = dsp.MODEM(config)
 
 
 class Writer(object):
-    def __init__(self):
-        self.last = time.time()
+    def __init__(self, fd):
+        self.last_timestamp = time.time()
         self.offset = 0
+        self.fd = fd
 
-    def write(self, fd, sym, n=1):
+    def write(self, sym, n=1):
         sym = np.array(sym)
         data = common.dumps(sym, n)
-        fd.write(data)
+        self.fd.write(data)
         self.offset += len(data)
-        if time.time() > self.last + 1:
-            log.debug('%10.3f seconds of data audio',
-                      self.offset / wave.bytes_per_second)
-            self.last += 1
+        if time.time() > self.last_timestamp + 1:
+            data_duration = self.offset / wave.bytes_per_second
+            log.debug('%10.3f seconds of data audio sent', data_duration)
+            self.last_timestamp += 1
 
-writer = Writer()
+    def start(self):
+        carrier = modem.carriers[config.carrier_index]
+        for value in train.prefix:
+            self.write(carrier * value)
 
+        silence = np.zeros(train.silence_length * config.Nsym)
+        symbols = equalizer.train_symbols(train.equalizer_length)
+        signal = equalizer.modulator(symbols)
+        self.write(silence)
+        self.write(signal)
+        self.write(silence)
 
-def start(fd, c):
-    for value in train.prefix:
-        writer.write(fd, c * value)
-
-    silence = [0] * (train.silence_length * config.Nsym)
-    writer.write(fd, silence)
-    symbols = equalizer.train_symbols(train.equalizer_length)
-    signal = equalizer.modulator(symbols)
-    writer.write(fd, signal)
-    writer.write(fd, silence)
-
-
-def modulate(fd, bits):
-    symbols_iter = modem.qam.encode(bits)
-    symbols_iter = itertools.chain(symbols_iter, itertools.repeat(0))
-    carriers = modem.carriers / config.Nfreq
-    while True:
-        symbols = itertools.islice(symbols_iter, config.Nfreq)
-        symbols = np.array(list(symbols))
-        writer.write(fd, np.dot(symbols, carriers))
-        if all(symbols == 0):  # EOF marker
-            break
-
+    def modulate(self, bits):
+        symbols_iter = modem.qam.encode(bits)
+        symbols_iter = itertools.chain(symbols_iter, itertools.repeat(0))
+        carriers = modem.carriers / config.Nfreq
+        while True:
+            symbols = itertools.islice(symbols_iter, config.Nfreq)
+            symbols = np.array(list(symbols))
+            self.write(np.dot(symbols, carriers))
+            if all(symbols == 0):  # EOF marker
+                break
 
 def main(args):
     log.info('Running MODEM @ {:.1f} kbps'.format(modem.modem_bps / 1e3))
 
-    # padding audio with silence
-    writer.write(args.output, np.zeros(int(config.Fs * args.silence_start)))
+    writer = Writer(args.output)
 
-    start(args.output, modem.carriers[config.carrier_index])
+    # pre-padding audio with silence
+    writer.write(np.zeros(int(config.Fs * args.silence_start)))
+
+    writer.start()
 
     training_size = writer.offset
-    log.info('%.3f seconds of training audio',
-             training_size / wave.bytes_per_second)
+    training_duration = training_size / wave.bytes_per_second
+    log.info('%.3f seconds of training audio', training_duration)
 
     reader = stream.Reader(args.input, bufsize=(64 << 10), eof=True)
     data = itertools.chain.from_iterable(reader)
     encoded = itertools.chain.from_iterable(ecc.encode(data))
-    modulate(args.output, bits=common.to_bits(encoded))
+    writer.modulate(bits=common.to_bits(encoded))
 
     data_size = writer.offset - training_size
     log.info('%.3f seconds of data audio, for %.3f kB of data',
              data_size / wave.bytes_per_second, reader.total / 1e3)
 
-    # padding audio with silence
-    writer.write(args.output, np.zeros(int(config.Fs * args.silence_stop)))
+    # post-padding audio with silence
+    writer.write(np.zeros(int(config.Fs * args.silence_stop)))