callbacks.go

package hackrf

// This file holds the //export trampolines invoked by libhackrf's transfer
// thread. cgo forbids C function definitions in the preamble of a file that
// contains //export directives, so the C wrappers live in streaming.go and the
// preamble here is limited to the header (declarations only).

// #include <libhackrf/hackrf.h>
import "C"

import (
	"runtime/cgo"
	"unsafe"
)

// deviceFromCtx recovers the *Device from an opaque user-context void* that
// carries a cgo.Handle value.
func deviceFromCtx(ctx unsafe.Pointer) *Device {
	if ctx == nil {
		return nil
	}
	v := cgo.Handle(uintptr(ctx)).Value()
	d, _ := v.(*Device)
	return d
}

// wrapTransfer builds a Go Transfer aliasing the C buffer.
func wrapTransfer(d *Device, ct *C.hackrf_transfer) *Transfer {
	var buf []byte
	if ct.buffer != nil && ct.buffer_length > 0 {
		buf = unsafe.Slice((*byte)(unsafe.Pointer(ct.buffer)), int(ct.buffer_length))
	}
	return &Transfer{
		Device:       d,
		Buffer:       buf,
		BufferLength: int(ct.buffer_length),
		ValidLength:  int(ct.valid_length),
	}
}

//export goHackRFTransferCallback
func goHackRFTransferCallback(ct *C.hackrf_transfer) C.int {
	ctx := unsafe.Pointer(ct.rx_ctx)
	if ctx == nil {
		ctx = unsafe.Pointer(ct.tx_ctx)
	}
	d := deviceFromCtx(ctx)
	if d == nil || d.transferCallback == nil {
		return 0
	}
	t := wrapTransfer(d, ct)
	ret := d.transferCallback(t)
	// Propagate any TX valid_length change back to libhackrf.
	ct.valid_length = C.int(t.ValidLength)
	return C.int(ret)
}

//export goHackRFTxBlockCompleteCallback
func goHackRFTxBlockCompleteCallback(ct *C.hackrf_transfer, success C.int) {
	d := deviceFromCtx(unsafe.Pointer(ct.tx_ctx))
	if d == nil || d.blockCompleteCallback == nil {
		return
	}
	d.blockCompleteCallback(wrapTransfer(d, ct), int(success))
}

//export goHackRFFlushCallback
func goHackRFFlushCallback(flushCtx unsafe.Pointer, success C.int) {
	d := deviceFromCtx(flushCtx)
	if d == nil || d.flushCallback == nil {
		return
	}
	d.flushCallback(int(success))
}