Introduce reusable gpudemod batch runner

cmd/sdrd/helpers.go

@@ -75,20 +75,20 @@ func extractSignalIQBatch(iq []complex64, sampleRate int, centerHz float64, sign
 		decimTarget = sampleRate
 	}
 
-	var eng *gpudemod.Engine
+	var runner *gpudemod.BatchRunner
 	if gpudemod.Available() {
-		if gpuEng, err := gpudemod.New(len(iq), sampleRate); err == nil {
-			eng = gpuEng
-			defer eng.Close()
+		if gpuRunner, err := gpudemod.NewBatchRunner(len(iq), sampleRate); err == nil {
+			runner = gpuRunner
+			defer runner.Close()
 		}
 	}
 
-	if eng != nil {
+	if runner != nil {
 		jobs := make([]gpudemod.ExtractJob, len(signals))
 		for i, sig := range signals {
 			jobs[i] = gpudemod.ExtractJob{OffsetHz: sig.CenterHz - centerHz, BW: sig.BWHz, OutRate: decimTarget}
 		}
-		if gpuOuts, _, err := eng.ShiftFilterDecimateBatch(iq, jobs); err == nil && len(gpuOuts) == len(signals) {
+		if gpuOuts, _, err := runner.ShiftFilterDecimateBatch(iq, jobs); err == nil && len(gpuOuts) == len(signals) {
 			for i := range gpuOuts {
 				out[i] = gpuOuts[i]
 			}

internal/demod/gpudemod/batch_runner.go

@@ -0,0 +1,28 @@
+package gpudemod
+
+type BatchRunner struct {
+	eng *Engine
+}
+
+func NewBatchRunner(maxSamples int, sampleRate int) (*BatchRunner, error) {
+	eng, err := New(maxSamples, sampleRate)
+	if err != nil {
+		return nil, err
+	}
+	return &BatchRunner{eng: eng}, nil
+}
+
+func (r *BatchRunner) Close() {
+	if r == nil || r.eng == nil {
+		return
+	}
+	r.eng.Close()
+	r.eng = nil
+}
+
+func (r *BatchRunner) ShiftFilterDecimateBatch(iq []complex64, jobs []ExtractJob) ([][]complex64, []int, error) {
+	if r == nil || r.eng == nil {
+		return nil, nil, ErrUnavailable
+	}
+	return r.eng.ShiftFilterDecimateBatch(iq, jobs)
+}

internal/demod/gpudemod/errors.go

@@ -0,0 +1,5 @@
+package gpudemod
+
+import "errors"
+
+var ErrUnavailable = errors.New("gpudemod batch runner unavailable")