Golang C.opus_int32函數代碼示例

func (e *Encoder) ctl_int32(request, arg int32) int {
	return int(C.azul3d_opus_encoder_ctl_int32(
		e.cptr(),
		C.int(request),
		C.opus_int32(arg),
	))
}

func (d *Decoder) Decode(data []byte, frameSize int, fec bool) ([]int16, error) {
	var dataPtr *C.uchar
	if len(data) > 0 {
		dataPtr = (*C.uchar)(unsafe.Pointer(&data[0]))
	}
	dataLen := C.opus_int32(len(data))

	output := make([]int16, d.channels*frameSize)
	outputPtr := (*C.opus_int16)(unsafe.Pointer(&output[0]))

	var cFec C.int
	if fec {
		cFec = 1
	} else {
		cFec = 0
	}

	cRet := C.opus_decode(d.cDecoder, dataPtr, dataLen, outputPtr, C.int(frameSize), cFec)
	ret := int(cRet)

	if ret < 0 {
		return nil, getErr(cRet)
	}
	return output[:ret*d.channels], nil
}

// Decode decodes a single Opus frame to floating point format. Stereo
// output will be interleaved. A null input frame indicates packet loss.
func (dec *Decoder) Decode(frame []byte, pksize int, isFec bool) (pcm []float32, err error) {
	var input *C.uchar
	if frame != nil {
		input = (*C.uchar)(&frame[0])
	}

	isfNum := 0
	if isFec {
		isfNum = 1
	}

	pcm = make([]float32, pksize*dec.chcnt)
	num := C.opus_decode_float(&dec.cee, input, C.opus_int32(len(frame)),
		(*C.float)(&pcm[0]), C.int(pksize), C.int(isfNum))
	if num < 0 {
		pcm = nil
		err = ErrUnspecified
		switch num {
		case C.OPUS_BAD_ARG:
			fmt.Println("OPUS_BAD_ARG")
		case C.OPUS_BUFFER_TOO_SMALL:
			fmt.Println("OPUS_BUFFER_TOO_SMALL")
		case C.OPUS_INVALID_PACKET:
			fmt.Println("OPUS_INVALID_PACKET")
		}
		return
	}
	pcm = pcm[:num*C.int(dec.chcnt)]
	return
}

func (this *Encoder) Init(sampleRate int, channels int, application Application) {
	C.opus_encoder_init(
		this.ptr,
		C.opus_int32(C.int(sampleRate)),
		C.int(channels),
		C.int(application),
	)
}

func CountFrames(data []byte) (int, error) {
	dataPtr := (*C.uchar)(unsafe.Pointer(&data[0]))
	cLen := C.opus_int32(len(data))

	cRet := C.opus_packet_get_nb_frames(dataPtr, cLen)
	if err := getErr(cRet); err != nil {
		return 0, err
	}
	return int(cRet), nil
}

func NewEncoder(sampleRate int, channels int, application Application) (*Encoder, error) {
	var err C.int
	encoder := C.opus_encoder_create(
		C.opus_int32(C.int(sampleRate)),
		C.int(channels),
		C.int(application),
		&err,
	)

	return &Encoder{encoder}, toError(err)
}

func NewEncoder(sampleRate, channels int, application Application) (*Encoder, error) {
	encoder := &Encoder{}
	encoder.data = make([]byte, int(C.opus_encoder_get_size(C.int(channels))))
	encoder.cEncoder = (*C.struct_OpusEncoder)(unsafe.Pointer(&encoder.data[0]))

	ret := C.opus_encoder_init(encoder.cEncoder, C.opus_int32(sampleRate), C.int(channels), C.int(application))
	if err := getErr(ret); err != nil {
		return nil, err
	}
	return encoder, nil
}

func NewDecoder(sampleRate, channels int) (*Decoder, error) {
	decoder := &Decoder{}
	decoder.data = make([]byte, int(C.opus_decoder_get_size(C.int(channels))))
	decoder.cDecoder = (*C.struct_OpusDecoder)(unsafe.Pointer(&decoder.data[0]))

	ret := C.opus_decoder_init(decoder.cDecoder, C.opus_int32(sampleRate), C.int(channels))
	if err := getErr(ret); err != nil {
		return nil, err
	}
	decoder.channels = channels

	return decoder, nil
}

// NewDecoder creates a new Opus decoder with the given sample rate
// and number of channels.
func NewDecoder(sampleRate int, chanCount int) (dec *Decoder, err error) {
	dec = new(Decoder)

	// allocate Opus decoder
	ecode := C.opus_decoder_init(&dec.cee, C.opus_int32(sampleRate),
		C.int(chanCount))
	if ecode != C.OPUS_OK {
		dec = nil
		err = ErrUnspecified
	}
	dec.chcnt = chanCount
	return
}

// EncodeFloat encodes an Opus frame from floating point input.
//
// pcm: the 32-bit float PCM input signal (interleaved if 2 channels). Whose
// length is frameSize*channels. Samples have a normal range of +/-1.0, but can
// have a range beyond that (but they will be clipped by decoders using the
// integer API and should only be used if it is known that the far end supports
// extended dynamic range).
//
// frameSize: the number of samples per channel in the input signal. This must
// be an Opus frame size for the encoder's sampling rate. For example at 48kHz
// the permitted values are 120, 240, 480, 960, 1920, and 2880. Passing in a
// duration of less than 10 ms (480 samples at 48 kHz) will prevent the encoder
// from using the LPC or hybrid modes.
//
// data: the slice to store the output payload in, containing len(data) bytes
// of space. The length of the slice may be used to impose an upper limit on
// the instant bitrate, but should not be used as the only bitrate control. Use
// SET_BITRATE to control the bitrate.
//
// returns: a slice of the data slice representing the encoded packet, OR nil
// and an error.
func (e *Encoder) EncodeFloat(pcm []float32, frameSize int, data []byte) ([]byte, error) {
	n := C.opus_encode_float(
		e.cptr(),
		(*C.float)(unsafe.Pointer(&pcm[0])),
		C.int(frameSize),
		(*C.uchar)(unsafe.Pointer(&data[0])),
		C.opus_int32(len(data)),
	)
	if n > 0 {
		return data[:n], nil
	}
	return nil, opusError(C.int(-n))
}

// Allocates and initializes an encoder state. There are three coding modes:
//
//  1. APPLICATION_VOIP gives best quality at a given bitrate for voice
//  signals. It enhances the  input signal by high-pass filtering and
//  emphasizing formants and harmonics. Optionally  it includes in-band forward
//  error correction to protect against packet loss. Use this mode for typical
//  VoIP applications. Because of the enhancement, even at high bitrates the
//  output may sound different from the input.
//
//  2. APPLICATION_AUDIO gives best quality at a given bitrate for most
//  non-voice signals like music. Use this mode for music and mixed
//  (music/voice) content, broadcast, and applications requiring less than 15
//  ms of coding delay.
//
//  3. APPLICATION_RESTRICTED_LOWDELAY configures low-delay mode that disables
//  the speech-optimized mode in exchange for slightly reduced delay. This mode
//  can only be set on an newly initialized or freshly reset encoder because it
//  changes the codec delay. This is useful when the caller knows that the
//  speech-optimized modes will not be needed (use with caution).
//
// Fs: Sampling rate of input signal (Hz). This must be one of 8000, 12000,
// 16000, 24000, or 48000.
//
// channels: Number of channels (1 or 2) in input signal
//
// application: Coding mode (APPLICATION_VOIP/APPLICATION_AUDIO/APPLICATION_RESTRICTED_LOWDELAY)
//
// note: Regardless of the sampling rate and number channels selected, the Opus
// encoder can switch to a lower audio bandwidth or number of channels if the
// bitrate selected is too low. This also means that it is safe to always use
// 48 kHz stereo input and let the encoder optimize the encoding.
func NewEncoder(Fs, channels, application int) (*Encoder, error) {
	enc := new(Encoder)
	err := opusError(C.opus_encoder_init(
		enc.cptr(),
		C.opus_int32(Fs),
		C.int(channels),
		C.int(application),
	))
	if err != nil {
		return nil, err
	}
	return enc, nil
}

func (e *Encoder) Encode(pcm []int16, frameSize, maxDataBytes int) ([]byte, error) {
	pcmPtr := (*C.opus_int16)(unsafe.Pointer(&pcm[0]))

	data := make([]byte, maxDataBytes)
	dataPtr := (*C.uchar)(unsafe.Pointer(&data[0]))

	encodedC := C.opus_encode(e.cEncoder, pcmPtr, C.int(frameSize), dataPtr, C.opus_int32(len(data)))
	encoded := int(encodedC)

	if encoded < 0 {
		return nil, getErr(C.int(encodedC))
	}
	return data[0:encoded], nil
}

// Init initializes a pre-allocated opus encoder. Unless the encoder has been
// created using NewEncoder, this method must be called exactly once in the
// life-time of this object, before calling any other methods.
func (enc *Encoder) Init(sample_rate int, channels int, application Application) error {
	if enc.p != nil {
		return fmt.Errorf("opus encoder already initialized")
	}
	if channels != 1 && channels != 2 {
		return fmt.Errorf("Number of channels must be 1 or 2: %d", channels)
	}
	size := C.opus_encoder_get_size(C.int(channels))
	enc.mem = make([]byte, size)
	enc.p = (*C.OpusEncoder)(unsafe.Pointer(&enc.mem[0]))
	errno := int(C.opus_encoder_init(
		enc.p,
		C.opus_int32(sample_rate),
		C.int(channels),
		C.int(application)))
	if errno != 0 {
		return opuserr(int(errno))
	}
	return nil
}

func (dec *Decoder) Init(sample_rate int, channels int) error {
	if dec.p != nil {
		return fmt.Errorf("opus decoder already initialized")
	}
	if channels != 1 && channels != 2 {
		return fmt.Errorf("Number of channels must be 1 or 2: %d", channels)
	}
	size := C.opus_decoder_get_size(C.int(channels))
	dec.sample_rate = sample_rate
	dec.mem = make([]byte, size)
	dec.p = (*C.OpusDecoder)(unsafe.Pointer(&dec.mem[0]))
	errno := C.opus_decoder_init(
		dec.p,
		C.opus_int32(sample_rate),
		C.int(channels))
	if errno != 0 {
		return opuserr(int(errno))
	}
	return nil
}

// Encode raw PCM data and store the result in the supplied buffer. On success,
// returns the number of bytes used up by the encoded data.
func (enc *Encoder) EncodeFloat32(pcm []float32, data []byte) (int, error) {
	if enc.p == nil {
		return 0, errEncUninitialized
	}
	if len(pcm) == 0 {
		return 0, fmt.Errorf("opus: no data supplied")
	}
	if len(data) == 0 {
		return 0, fmt.Errorf("opus: no target buffer")
	}
	n := int(C.opus_encode_float(
		enc.p,
		(*C.float)(&pcm[0]),
		C.int(len(pcm)),
		(*C.uchar)(&data[0]),
		C.opus_int32(cap(data))))
	if n < 0 {
		return 0, opuserr(n)
	}
	return n, nil
}