code cleanup and i forget what other changes

code.go

@@ -11,7 +11,10 @@
 
 package gortty
 
-import "unicode"
+import (
+	"fmt"
+	"unicode"
+)
 
 const (
 	shiftUnknown = iota
@@ -27,60 +30,63 @@ var (
 		'[': '(',
 		']': ')',
 	}
-	// TDD Telecommunications Device for the Deaf standard
-	TDD = CodeSet{
-		Codes: [2][]rune{
-			{'\b', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
-			{'\b', '3', '\n', '-', ' ', ',', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '+', '\x0e', '.', '/', ';', '\x0f'},
+
+	codeSets = map[string]CodeSet{
+		// TDD Telecommunications Device for the Deaf standard
+		"TDD": CodeSet{
+			Codes: [2][]rune{
+				{'\b', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+				{'\b', '3', '\n', '-', ' ', ',', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '+', '\x0e', '.', '/', ';', '\x0f'},
+			},
+			Substitutes: defaultSubstitutes,
+			Fallback:    '\'',
+			ShiftCode:   0x1b,
+			UnshiftCode: 0x1f,
 		},
-		Substitutes: defaultSubstitutes,
-		Fallback:    '\'',
-		ShiftCode:   0x1b,
-		UnshiftCode: 0x1f,
-	}
-	// USTTY US Teletype Corporation
-	USTTY = CodeSet{
-		Codes: [2][]rune{
-			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
-			{'\x00', '3', '\n', '-', ' ', '\a', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '#', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', ';', '\x0f'},
+		// USTTY US Teletype Corporation
+		"USTTY": CodeSet{
+			Codes: [2][]rune{
+				{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+				{'\x00', '3', '\n', '-', ' ', '\a', '8', '7', '\r', '$', '4', '\'', ',', '!', ':', '(', '5', '"', ')', '2', '#', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', ';', '\x0f'},
+			},
+			Substitutes: defaultSubstitutes,
+			Fallback:    '-',
+			ShiftCode:   0x1b,
+			UnshiftCode: 0x1f,
 		},
-		Substitutes: defaultSubstitutes,
-		Fallback:    '-',
-		ShiftCode:   0x1b,
-		UnshiftCode: 0x1f,
-	}
-	// USITA2 USITA2
-	USITA2 = CodeSet{
-		Codes: [2][]rune{
-			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
-			{'\x00', '3', '\n', '-', ' ', '\'', '8', '7', '\r', '$', '4', '\a', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', '=', '\x0f'},
+		// USITA2 USITA2
+		"USITA2": CodeSet{
+			Codes: [2][]rune{
+				{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+				{'\x00', '3', '\n', '-', ' ', '\'', '8', '7', '\r', '$', '4', '\a', ',', '!', ':', '(', '5', '"', ')', '2', '=', '6', '0', '1', '9', '?', '&', '\x0e', '.', '/', '=', '\x0f'},
+			},
+			Substitutes: defaultSubstitutes,
+			Fallback:    '-',
+			ShiftCode:   0x1b,
+			UnshiftCode: 0x1f,
 		},
-		Substitutes: defaultSubstitutes,
-		Fallback:    '-',
-		ShiftCode:   0x1b,
-		UnshiftCode: 0x1f,
-	}
-	// Weather US Weather
-	Weather = CodeSet{
-		Codes: [2][]rune{
-			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
-			{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '↗', '4', '↙', '⦷', '→', '○', '←', '5', '+', '↖', '2', '↓', '6', '0', '1', '9', '⊕', '↘', '\x0e', '.', '/', '⦶', '\x0f'},
+		// Weather US Weather
+		"Weather": CodeSet{
+			Codes: [2][]rune{
+				{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+				{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '↗', '4', '↙', '⦷', '→', '○', '←', '5', '+', '↖', '2', '↓', '6', '0', '1', '9', '⊕', '↘', '\x0e', '.', '/', '⦶', '\x0f'},
+			},
+			Substitutes: defaultSubstitutes,
+			Fallback:    '-',
+			ShiftCode:   0x1b,
+			UnshiftCode: 0x1f,
 		},
-		Substitutes: defaultSubstitutes,
-		Fallback:    '-',
-		ShiftCode:   0x1b,
-		UnshiftCode: 0x1f,
-	}
-	// Fractions US Fractions
-	Fractions = CodeSet{
-		Codes: [2][]rune{
-			{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
-			{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '$', '4', '\'', '⅞', '¼', '⅛', '½', '5', '"', '¾', '2', ' ', '6', '0', '1', '9', '⅝', '&', '\x0e', '.', '/', '⅜', '\x0f'},
+		// Fractions US Fractions
+		"Fractions": CodeSet{
+			Codes: [2][]rune{
+				{'\x00', 'E', '\n', 'A', ' ', 'S', 'I', 'U', '\r', 'D', 'R', 'J', 'N', 'F', 'C', 'K', 'T', 'Z', 'L', 'W', 'H', 'Y', 'P', 'Q', 'O', 'B', 'G', '\x0e', 'M', 'X', 'V', '\x0f'},
+				{'\x00', '3', '\n', '↑', ' ', '\a', '8', '7', '\r', '$', '4', '\'', '⅞', '¼', '⅛', '½', '5', '"', '¾', '2', ' ', '6', '0', '1', '9', '⅝', '&', '\x0e', '.', '/', '⅜', '\x0f'},
+			},
+			Substitutes: defaultSubstitutes,
+			Fallback:    '-',
+			ShiftCode:   0x1b,
+			UnshiftCode: 0x1f,
 		},
-		Substitutes: defaultSubstitutes,
-		Fallback:    '-',
-		ShiftCode:   0x1b,
-		UnshiftCode: 0x1f,
 	}
 )
 
@@ -106,12 +112,17 @@ type code struct {
 	v     byte
 }
 
-//LoadCharset is fun
-func LoadCharset(cs *CodeSet) *CodeSet {
-	if !cs.initialized {
-		cs.initialize()
+//LoadCodeSet is fun
+func LoadCodeSet(n string) (*CodeSet, error) {
+	cs, ok := codeSets[n]
+
+	if !ok {
+		return nil, fmt.Errorf("Attempt to load nonexistent codeset: %s", n)
 	}
-	return cs
+
+	cs.initialize()
+
+	return &cs, nil
 }
 
 func (cs *CodeSet) initialize() *CodeSet {

common.go

@@ -27,13 +27,12 @@ const (
 	EventActive
 	// EventIdle is triggered after idle
 	EventIdle
-	
-	
+
 	// EventStartBit is triggered with the falling edge of the start bit when transmitting a character
 	EventStartBit
 	// EventStopBit is triggered with rising edge of the stop bit when transmitting a character
 	EventStopBit
-	
+
 	// EventEncodeStringComplete is fun
 	EventEncodeStringComplete
 )

decoder.go

@@ -11,7 +11,8 @@
 
 package gortty
 
-import(
+import (
+	"context"
 	"unicode/utf8"
 )
 
@@ -21,7 +22,7 @@ type Decoder struct {
 	input   chan byte
 	output  chan rune
 	charset *CodeSet
-	usos bool
+	usos    bool
 }
 
 // UnshiftOnSpace sets how the decoder behaves when a space is received while in figures
@@ -31,34 +32,44 @@ func (d *Decoder) UnshiftOnSpace(usos bool) {
 }
 
 // NewDecoder creates a new decoder.
-func NewDecoder(input chan byte, output chan rune, charset *CodeSet) *Decoder {
+func NewDecoder(ctx context.Context, input chan byte, output chan rune, charset *CodeSet) *Decoder {
 	d := new(Decoder)
 	d.input = input
-	d.output = output
+	if output == nil {
+		d.output = make(chan rune)
+	} else {
+		d.output = output
+	}
 	d.charset = charset
 
-	go d.run()
+	go d.run(ctx)
 	return d
 }
 
-func (d *Decoder) run() {
+func (d *Decoder) run(ctx context.Context) {
 	shift := shiftLetter
-	for c := range d.input {
-		switch c {
-		case d.charset.UnshiftCode:
-			shift = shiftLetter
-			//TODO: Trigger EventDemodCase
-		case d.charset.ShiftCode:
-			shift = shiftFigure
-			//TODO: Trigger EventDemodCase
-		default:
-			r := d.charset.toRune(shift, c)
-			if d.usos && shift == shiftFigure && r == ' ' {
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case c := <-d.input:
+			switch c {
+			case d.charset.UnshiftCode:
 				shift = shiftLetter
-				//TODO: Trigger EventUnshiftOnSpace
+				//TODO: Trigger EventDemodCase
+			case d.charset.ShiftCode:
+				shift = shiftFigure
+				//TODO: Trigger EventDemodCase
+			default:
+				r := d.charset.toRune(shift, c)
+				if d.usos && shift == shiftFigure && r == ' ' {
+					shift = shiftLetter
+					//TODO: Trigger EventUnshiftOnSpace
+				}
+				d.output <- d.charset.toRune(shift, c)
+				//TODO: Trigger EventDemodChar
 			}
-			d.output <- d.charset.toRune(shift, c)
-			//TODO: Trigger EventDemodChar
 		}
 	}
 }
@@ -67,4 +78,4 @@ func (d *Decoder) Read(p []byte) (n int, err error) {
 	r := <-d.output
 	l := utf8.EncodeRune(p, r)
 	return l, nil
-}
+}

demodulator.go

@@ -13,6 +13,7 @@ package gortty
 
 import (
 	//"fmt"
+	"context"
 	"math"
 )
 
@@ -46,9 +47,8 @@ type Demodulator struct {
 	}
 }
 
-
 // NewDemodulator is fun
-func NewDemodulator(s *ModemSettings, input chan int16, output chan byte) *Demodulator {
+func NewDemodulator(ctx context.Context, s *ModemSettings, input chan int16, output chan byte) *Demodulator {
 
 	d := new(Demodulator)
 	d.input = input
@@ -71,7 +71,7 @@ func NewDemodulator(s *ModemSettings, input chan int16, output chan byte) *Demod
 	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
 
 	d.autobaud.estimate = d.settings.Baud
-	go d.run()
+	go d.run(ctx)
 	return d
 
 }
@@ -80,7 +80,7 @@ func (d *Demodulator) Inhibit(i bool) {
 	d.inhibitOutput = i
 }
 
-func (d *Demodulator) run() {
+func (d *Demodulator) run(ctx context.Context) {
 
 	var nextState int
 	var sample int  // down counter for sampling instant
@@ -97,151 +97,156 @@ func (d *Demodulator) run() {
 		autobaudState = autobaudStateDisabled
 	}
 	count := 0
-	for sam := range d.input {
-		count++
-		if count%d.div > 0 {
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case sam := <-d.input:
 
-			continue
-		}
-		//	d.dsp.demod(d.l.update(float64(sam)))
-		d.dsp.demod(float64(sam))
-
-		if d.sigOut {
-			m0, m1, m2 := d.dsp.level()
-			d.sigOutput <- [3]float64{m0, m1, m2}
-
-		} else {
-			//fmt.Println(d.dsp.level())
-			nextState = state
-
-			switch state {
-			case demodStateWaitStart:
-				// The demodulator sits in this state when it
-				// is waiting for a start bit.  When a
-				// "0" start-bit is detected that is
-				// above a minimum threshold it transitions
-				// out of this state.
-
-				if d.dsp.space() {
-					sample = int(float64(d.samplerate) / d.settings.Baud * 1.5)
-					baudot = 0
-					bit = 0
-					nextState = demodStateSample
-					//	fmt.Println("demodStateSample")
+			count++
+			if count%d.div > 0 {
 
-				}
+				continue
+			}
+			//	d.dsp.demod(d.l.update(float64(sam)))
+			d.dsp.demod(float64(sam))
+
+			if d.sigOut {
+				m0, m1, m2 := d.dsp.level()
+				d.sigOutput <- [3]float64{m0, m1, m2}
+
+			} else {
+				//fmt.Println(d.dsp.level())
+				nextState = state
+
+				switch state {
+				case demodStateWaitStart:
+					// The demodulator sits in this state when it
+					// is waiting for a start bit.  When a
+					// "0" start-bit is detected that is
+					// above a minimum threshold it transitions
+					// out of this state.
+
+					if d.dsp.space() {
+						sample = int(float64(d.samplerate) / d.settings.Baud * 1.5)
+						baudot = 0
+						bit = 0
+						nextState = demodStateSample
+						//	fmt.Println("demodStateSample")
 
-			case demodStateSample:
+					}
+
+				case demodStateSample:
 
-				sample--
-				if sample == 0 {
-					if d.dsp.mark() {
-						baudot |= (1 << uint(bit))
+					sample--
+					if sample == 0 {
+						if d.dsp.mark() {
+							baudot |= (1 << uint(bit))
+						}
+						bit++
+						if bit == d.settings.DataBits {
+							// complete baudot char has been received
+							sample = int(float64(d.samplerate) / d.settings.Baud)
+							nextState = demodStateWaitStop
+							if !d.inhibitOutput {
+								d.output <- baudot
+							}
+						} else {
+							/* sample next bit 1 bit-period later */
+							sample = int(float64(d.samplerate) / d.settings.Baud)
+						}
 					}
-					bit++
-					if bit == d.settings.DataBits {
-						// complete baudot char has been received
-						sample = int(float64(d.samplerate) / d.settings.Baud)
-						nextState = demodStateWaitStop
-						if !d.inhibitOutput {
-							d.output <- baudot
+
+					/* check for d.sampleRateK signal drop out */
+
+					if !d.dsp.carrier() {
+						d.minSigTimeout++
+
+						/* If signal drops out for approx one bit period
+						   assume we have lost d.sampleRateK signal */
+						if d.minSigTimeout > d.samplesPerBit {
+							nextState = demodStateWaitStart
+							//fmt.Println("demodStateWaitStart")
+
 						}
 					} else {
-						/* sample next bit 1 bit-period later */
-						sample = int(float64(d.samplerate) / d.settings.Baud)
+						d.minSigTimeout = 0
 					}
-				}
 
-				/* check for d.sampleRateK signal drop out */
+				case demodStateWaitStop:
 
-				if !d.dsp.carrier() {
-					d.minSigTimeout++
+					/* wait until we are in the middle of stop bit */
 
-					/* If signal drops out for approx one bit period
-					   assume we have lost d.sampleRateK signal */
-					if d.minSigTimeout > d.samplesPerBit {
+					sample--
+					if sample == 0 {
 						nextState = demodStateWaitStart
 						//fmt.Println("demodStateWaitStart")
-
 					}
-				} else {
-					d.minSigTimeout = 0
-				}
 
-			case demodStateWaitStop:
-
-				/* wait until we are in the middle of stop bit */
-
-				sample--
-				if sample == 0 {
-					nextState = demodStateWaitStart
-					//fmt.Println("demodStateWaitStart")
 				}
 
-			}
-
-			state = nextState
+				state = nextState
 
-			// auto baud detection state machine
-			// This deviates quite a bit from the original C implementation.
-			// Starts a counter at falling edge that marks the
-			// beginning of the start bit.  Measures time to
-			// next rising edge.  This time is presumably from
-			// 1 to 6 bit periods long, so the remainder from divinging
-			// the time span by a numbe of bit periods for different baud
-			// rates is accumulated. The baud rate that divides the most
-			// evenly into all measured bit periods is the estimated baud rate.
+				// auto baud detection state machine
+				// This deviates quite a bit from the original C implementation.
+				// Starts a counter at falling edge that marks the
+				// beginning of the start bit.  Measures time to
+				// next rising edge.  This time is presumably from
+				// 1 to 6 bit periods long, so the remainder from divinging
+				// the time span by a numbe of bit periods for different baud
+				// rates is accumulated. The baud rate that divides the most
+				// evenly into all measured bit periods is the estimated baud rate.
 
-			nextState = autobaudState
+				nextState = autobaudState
 
-			switch autobaudState {
-			case autobaudStateWaitStart:
-				/* start bit kicks off this state machine */
-				if state == demodStateSample {
-					nextState = autobaudStateWaitZeroX
-					zeroX = 0
-					remainders = map[int]int{45: 0, 47: 0, 50: 0, 75: 0}
+				switch autobaudState {
+				case autobaudStateWaitStart:
+					/* start bit kicks off this state machine */
+					if state == demodStateSample {
+						nextState = autobaudStateWaitZeroX
+						zeroX = 0
+						remainders = map[int]int{45: 0, 47: 0, 50: 0, 75: 0}
 
-				}
-			case autobaudStateWaitZeroX:
+					}
+				case autobaudStateWaitZeroX:
 
-				zeroX++
+					zeroX++
 
-				if d.dsp.edgeDetected() {
+					if d.dsp.edgeDetected() {
 
-					estimate := 45 // pick one as a starting point
-					minRemainder := remainders[estimate]
+						estimate := 45 // pick one as a starting point
+						minRemainder := remainders[estimate]
 
-					for b, t := range remainders {
-						q := t + (zeroX % (d.samplerate / b))
-						remainders[b] = q
-						if q < minRemainder {
-							minRemainder = q
-							estimate = b
+						for b, t := range remainders {
+							q := t + (zeroX % (d.samplerate / b))
+							remainders[b] = q
+							if q < minRemainder {
+								minRemainder = q
+								estimate = b
+							}
 						}
-					}
 
-					d.autobaud.estimate = float64(estimate)
-					nextState = autobaudStateWaitStop
-				}
+						d.autobaud.estimate = float64(estimate)
+						nextState = autobaudStateWaitStop
+					}
 
-				// reset autobaud state machine, e.g. if signal drops out before
-				// we get a zero crossing
+					// reset autobaud state machine, e.g. if signal drops out before
+					// we get a zero crossing
 
-				if state != demodStateSample {
-					nextState = autobaudStateWaitStop
-				}
+					if state != demodStateSample {
+						nextState = autobaudStateWaitStop
+					}
 
-			case autobaudStateWaitStop:
-				if state == demodStateWaitStop {
-					nextState = autobaudStateWaitStart
-				}
+				case autobaudStateWaitStop:
+					if state == demodStateWaitStop {
+						nextState = autobaudStateWaitStart
+					}
 
-			case autobaudStateDisabled:
+				case autobaudStateDisabled:
 
+				}
+				autobaudState = nextState
 			}
-			autobaudState = nextState
 		}
 	}
-
 }

dsp.go

@@ -77,7 +77,7 @@ func (d *dsp) lpfVal() float64 {
 }
 
 func (d *dsp) threshVal() float64 {
-	return d.demTotal*d.minThresh
+	return d.demTotal * d.minThresh
 }
 
 func (d *dsp) level() (float64, float64, float64) {

encoder.go

@@ -12,8 +12,9 @@
 package gortty
 
 import (
-	"fmt"
 	"bytes"
+	"context"
+	"fmt"
 )
 
 // Encoder is fun
@@ -30,15 +31,19 @@ type Encoder struct {
 }
 
 // NewEncoder is fun
-func NewEncoder(input chan rune, output chan byte, charset *CodeSet) *Encoder {
+func NewEncoder(ctx context.Context, input chan rune, output chan byte, charset *CodeSet) *Encoder {
 	e := new(Encoder)
-	e.input = input
+	if input == nil {
+		e.input = make(chan rune)
+	} else {
+		e.input = input
+	}
 	e.output = output
 	e.charset = charset
 	e.crlfThresh = 60
 	e.crlfForceThresh = 72
 	e.shiftThresh = 70
-	go e.run()
+	go e.run(ctx)
 	return e
 }
 
@@ -60,113 +65,118 @@ func (e *Encoder) SetCallback(callback Callback) {
 	e.callback = callback
 }
 
-func (e *Encoder) run() {
+func (e *Encoder) run(ctx context.Context) {
 
 	var modCase int           // current Letters/Figures state
 	var charsWithoutCRLF int  // number of chars we have handled without inserting a CR-LF
 	var charsWithoutShift int // number of chars we have handled without seeing a shift
-	for r := range e.input {
-		c := e.charset.toCode(r)
-
-		/*this rune can either be rendered as a Figures character,
-		  a Letters character or WHITESPACE which can be rendered by
-		  either character set*/
-		if r == '\r' || r == '\n' {
-			charsWithoutCRLF = 0
-		}
-
-		/*see if we need to first insert a case character*/
-		if c.shift == shiftWhitespace {
-			/*we have white space, we don't need to insert
-			a Letters/Figures case character.  We will insert
-			a case character when we transition from white
-			space to some other case.  The only exception to this
-			is when we are just starting to transmit, in which case
-			we must send something, so we'll choose the more common
-			Letters case*/
-			if modCase == shiftUnknown {
-				e.output <- e.charset.unshift()
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case r := <-e.input:
+			c := e.charset.toCode(r)
+
+			/*this rune can either be rendered as a Figures character,
+			  a Letters character or WHITESPACE which can be rendered by
+			  either character set*/
+			if r == '\r' || r == '\n' {
+				charsWithoutCRLF = 0
 			}
 
-			modCase = shiftWhitespace
-		} else if c.shift != modCase {
-			/*case is either Letters or Figures and doesn't match
-			  our modulator's current state, so add a new case char
-			  here*/
-			if c.shift == shiftLetter {
-				e.output <- e.charset.unshift()
-			} else {
-				e.output <- e.charset.shift()
-			}
+			/*see if we need to first insert a case character*/
+			if c.shift == shiftWhitespace {
+				/*we have white space, we don't need to insert
+				a Letters/Figures case character.  We will insert
+				a case character when we transition from white
+				space to some other case.  The only exception to this
+				is when we are just starting to transmit, in which case
+				we must send something, so we'll choose the more common
+				Letters case*/
+				if modCase == shiftUnknown {
+					e.output <- e.charset.unshift()
+				}
 
-			/*and save our current state*/
-			modCase = c.shift
+				modCase = shiftWhitespace
+			} else if c.shift != modCase {
+				/*case is either Letters or Figures and doesn't match
+				  our modulator's current state, so add a new case char
+				  here*/
+				if c.shift == shiftLetter {
+					e.output <- e.charset.unshift()
+				} else {
+					e.output <- e.charset.shift()
+				}
 
-			/*and update our counter*/
-			//fmt.Println("charsWithoutShift", charsWithoutShift)
-			charsWithoutShift = 0
-		}
+				/*and save our current state*/
+				modCase = c.shift
 
-		/*we need to perform a little logic here to check for some
-		 * boundry conditions in the protocol*/
-		/* We need to ensure that we re-send the current case character
-		   at least every 72 characters. */
-		if charsWithoutShift > e.shiftThresh {
-			if modCase == shiftWhitespace {
-				e.output <- e.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
-			} else if modCase == shiftLetter {
-				e.output <- e.charset.unshift()
-			} else {
-				e.output <- e.charset.shift()
+				/*and update our counter*/
+				//fmt.Println("charsWithoutShift", charsWithoutShift)
+				charsWithoutShift = 0
 			}
-			//fmt.Println("charsWithoutShift", charsWithoutShift)
 
-			charsWithoutShift = 0
-		}
-
-		/* we need to ensure that we send a carriage return/linefeed
-		 * at least every 72 characters, but we start looking for a
-		 * space character starting at 60 characters */
-		if !e.autoWrap {
-			/*we just insert our regular character*/
-			e.output <- c.toByte()
-
-			if e.autoCRLF {
-				if r == '\n' {
-					e.output <- e.charset.toByte('\r')
-				} else if r == '\r' {
-					e.output <- e.charset.toByte('\n')
+			/*we need to perform a little logic here to check for some
+			 * boundry conditions in the protocol*/
+			/* We need to ensure that we re-send the current case character
+			   at least every 72 characters. */
+			if charsWithoutShift > e.shiftThresh {
+				if modCase == shiftWhitespace {
+					e.output <- e.charset.unshift() /*doesn't matter which, so how 'bout LETR*/
+				} else if modCase == shiftLetter {
+					e.output <- e.charset.unshift()
+				} else {
+					e.output <- e.charset.shift()
 				}
+				//fmt.Println("charsWithoutShift", charsWithoutShift)
+
+				charsWithoutShift = 0
 			}
 
-		} else if (charsWithoutCRLF > e.crlfThresh) && (modCase == shiftWhitespace) {
-			/*insert the cr-lf instead of the space character*/
-			e.output <- e.charset.toByte('\r')
-			e.output <- e.charset.toByte('\n')
-			charsWithoutCRLF = 0
-		} else if charsWithoutCRLF > e.crlfForceThresh {
-			/*insert the cr-lf followed by the character*/
-			e.output <- e.charset.toByte('\r')
-			e.output <- e.charset.toByte('\n')
-			e.output <- c.toByte()
-			charsWithoutCRLF = 0
-		} else {
-			/*we just insert our regular character*/
-			e.output <- c.toByte()
-
-			if e.autoCRLF {
-				if r == '\n' {
-					e.output <- e.charset.toByte('\r')
-				} else if r == '\r' {
-					e.output <- e.charset.toByte('\n')
+			/* we need to ensure that we send a carriage return/linefeed
+			 * at least every 72 characters, but we start looking for a
+			 * space character starting at 60 characters */
+			if !e.autoWrap {
+				/*we just insert our regular character*/
+				e.output <- c.toByte()
+
+				if e.autoCRLF {
+					if r == '\n' {
+						e.output <- e.charset.toByte('\r')
+					} else if r == '\r' {
+						e.output <- e.charset.toByte('\n')
+					}
 				}
-			}
 
-		}
+			} else if (charsWithoutCRLF > e.crlfThresh) && (modCase == shiftWhitespace) {
+				/*insert the cr-lf instead of the space character*/
+				e.output <- e.charset.toByte('\r')
+				e.output <- e.charset.toByte('\n')
+				charsWithoutCRLF = 0
+			} else if charsWithoutCRLF > e.crlfForceThresh {
+				/*insert the cr-lf followed by the character*/
+				e.output <- e.charset.toByte('\r')
+				e.output <- e.charset.toByte('\n')
+				e.output <- c.toByte()
+				charsWithoutCRLF = 0
+			} else {
+				/*we just insert our regular character*/
+				e.output <- c.toByte()
+
+				if e.autoCRLF {
+					if r == '\n' {
+						e.output <- e.charset.toByte('\r')
+					} else if r == '\r' {
+						e.output <- e.charset.toByte('\n')
+					}
+				}
 
-		charsWithoutShift++
-		charsWithoutCRLF++
+			}
+
+			charsWithoutShift++
+			charsWithoutCRLF++
 
+		}
 	}
 
 }
@@ -176,10 +186,9 @@ func (e *Encoder) Write(p []byte) (n int, err error) {
 	runes := bytes.Runes(p)
 
 	fmt.Print(string(runes))
-	
+
 	for _, r := range runes {
 		e.input <- r
 	}
 	return len(p), nil
 }
-

modulator.go

@@ -11,7 +11,10 @@
 
 package gortty
 
-import "math"
+import (
+	"context"
+	"math"
+)
 
 const (
 	modStateIdle = iota
@@ -38,12 +41,12 @@ type Modulator struct {
 	wZeroQ16        uint16  // scaled zero freq 0..2math.Pi -> 0..65536
 	sinLutQ15       []int16 // sine lookup table
 	callback        Callback
-	
+
 	idleDelay int
 }
 
 // NewModulator is fun
-func NewModulator(s *ModemSettings, input chan byte, output chan int16) *Modulator {
+func NewModulator(ctx context.Context, s *ModemSettings, input chan byte, output chan int16) *Modulator {
 
 	m := new(Modulator)
 
@@ -66,7 +69,7 @@ func NewModulator(s *ModemSettings, input chan byte, output chan int16) *Modulat
 	for i := 0; i < 16384; i++ {
 		m.sinLutQ15[i] = int16(32767 * math.Sin(2.0*math.Pi*float64(i)/float64(16384)))
 	}
-	go m.run()
+	go m.run(ctx)
 	return m
 }
 
@@ -75,7 +78,7 @@ func (m *Modulator) SetCallback(callback Callback) {
 	m.callback = callback
 }
 
-// SetIdleDelay sets how long (in samples) that the modulator must be in the ready state 
+// SetIdleDelay sets how long (in samples) that the modulator must be in the ready state
 // before switching to the idle state
 func (m *Modulator) SetIdleDelay(d int) {
 	m.idleDelay = d
@@ -105,7 +108,7 @@ func (m *Modulator) SetAmplitude(amplitude int16) {
 	m.amplitude = amplitude
 }
 
-func (m *Modulator) run() {
+func (m *Modulator) run(ctx context.Context) {
 
 	var modState int  // modulator state machine
 	var nextState int // next state of state machine
@@ -122,13 +125,15 @@ func (m *Modulator) run() {
 			fallthrough
 		case modStateIdle:
 			select {
+			case <-ctx.Done():
+				return
 			case c = <-m.input:
 				modSample = 0
 				nextState = modStateStart
 				idleSamples = 0
 				if m.callback != nil {
 					m.callback(EventStartBit, 0)
-					if (modState == modStateIdle) {
+					if modState == modStateIdle {
 						m.callback(EventActive, 0)
 					}
 				}

rawdemodulator.go

@@ -12,29 +12,28 @@
 package gortty
 
 import (
+	"context"
 	"math"
 )
 
-
-
 // RawDemodulator is fun
 type RawDemodulator struct {
-	input         chan int16
-	output        chan DCSignal  
-	dsp           *dsp
-	settings      *ModemSettings
-	sigOut        bool
-	samplerate    int
-	div           int
+	input      chan int16
+	output     chan DCSignal
+	dsp        *dsp
+	settings   *ModemSettings
+	sigOut     bool
+	samplerate int
+	div        int
 }
 
 // NewRawDemodulator is fun
-func NewRawDemodulator(s *ModemSettings, input chan int16, output chan DCSignal) *RawDemodulator {
+func NewRawDemodulator(ctx context.Context, s *ModemSettings, input chan int16, output chan DCSignal) *RawDemodulator {
 
 	d := new(RawDemodulator)
 	d.input = input
 	d.output = output
-	
+
 	d.settings = s
 
 	// the bandpass filter is picky about the sample rate, and the output is perfectly
@@ -49,47 +48,48 @@ func NewRawDemodulator(s *ModemSettings, input chan int16, output chan DCSignal)
 	}
 
 	d.samplerate = d.settings.SampleRate / d.div
-	
+
 	d.dsp = newDsp(d.settings.OneFreq, d.settings.ZeroFreq, d.samplerate)
 
-	go d.run()
+	go d.run(ctx)
 	return d
 }
 
-func (d *RawDemodulator) run() {
+func (d *RawDemodulator) run(ctx context.Context) {
 
 	count := 0
-	for sam := range d.input {
-	
-		// sample rate reduction
-		count++
-		if count%d.div > 0 {
-			continue
+	for {
+		select {
+		case <-ctx.Done():
+			return
+		case sam := <-d.input:
+			// sample rate reduction
+			count++
+			if count%d.div > 0 {
+				continue
+			}
+
+			d.dsp.demod(float64(sam))
+
+			var signal int8
+			var quality int8
+
+			if math.Abs(d.dsp.demLpf) > d.dsp.demTotal*d.dsp.minThresh && d.dsp.demTotal*d.dsp.minThresh != 0 {
+				quality = 1
+			} else {
+				quality = 0
+			}
+
+			if d.dsp.demLpf-d.dsp.minThresh*d.dsp.demTotal > 0 {
+				signal = 1 * quality
+			} else {
+				signal = -1 * quality
+			}
+
+			d.output <- DCSignal{
+				Signal:  signal,
+				Quality: quality,
+			}
 		}
-
-		d.dsp.demod(float64(sam))
-
-		var signal int8
-		var quality int8
-		
-
-		if math.Abs(d.dsp.demLpf) > d.dsp.demTotal*d.dsp.minThresh && d.dsp.demTotal*d.dsp.minThresh != 0 {
-			quality = 1
-		} else {
-			quality = 0
-		}
-
-		if d.dsp.demLpf - d.dsp.minThresh*d.dsp.demTotal > 0 {
-			signal = 1*quality
-		} else {
-			signal = -1*quality
-		}	
-				
-		d.output <-  DCSignal {
-			Signal: signal,
-			Quality: quality,
-		}
-		
 	}
-
 }

rawmodulator.go

@@ -11,11 +11,13 @@
 
 package gortty
 
-import "math"
-//import "fmt"
+import (
+	"context"
+	"math"
+)
 
 type DCSignal struct {
-	Signal int8
+	Signal  int8
 	Quality int8
 }
 
@@ -26,16 +28,16 @@ type RawModulator struct {
 
 	settings *ModemSettings
 
-	phaseQ16        uint16  // phase acc 0..2math.Pi -> 0..65536
-	amplitude       int16   // peak RawModulator amplitude for one tone
-	wOneQ16         uint16  // scaled one freq 0..2math.Pi -> 0..65536
-	wZeroQ16        uint16  // scaled zero freq 0..2math.Pi -> 0..65536
-	sinLutQ15       []int16 // sine lookup table
-	callback        Callback
+	phaseQ16  uint16  // phase acc 0..2math.Pi -> 0..65536
+	amplitude int16   // peak RawModulator amplitude for one tone
+	wOneQ16   uint16  // scaled one freq 0..2math.Pi -> 0..65536
+	wZeroQ16  uint16  // scaled zero freq 0..2math.Pi -> 0..65536
+	sinLutQ15 []int16 // sine lookup table
+	callback  Callback
 }
 
 // NewRawModulator is fun
-func NewRawModulator(s *ModemSettings, input chan DCSignal, output chan int16) *RawModulator {
+func NewRawModulator(ctx context.Context, s *ModemSettings, input chan DCSignal, output chan int16) *RawModulator {
 
 	m := new(RawModulator)
 
@@ -55,7 +57,7 @@ func NewRawModulator(s *ModemSettings, input chan DCSignal, output chan int16) *
 	for i := 0; i < 16384; i++ {
 		m.sinLutQ15[i] = int16(32767 * math.Sin(2.0*math.Pi*float64(i)/float64(16384)))
 	}
-	go m.run()
+	go m.run(ctx)
 	return m
 }
 
@@ -68,11 +70,13 @@ func (m *RawModulator) SetAmplitude(amplitude int16) {
 	m.amplitude = amplitude
 }
 
-func (m *RawModulator) run() {
+func (m *RawModulator) run(ctx context.Context) {
 
 	var lut uint16
 	for {
 		select {
+		case <-ctx.Done():
+			return
 		case s := <-m.input:
 			if s.Signal > 0 {
 				lut = m.wOneQ16
@@ -86,7 +90,7 @@ func (m *RawModulator) run() {
 				m.output <- 0
 			}
 		}
-		
-	}			
+
+	}
 
 }