Beta39

go-silk/silk.go

@@ -139,8 +139,8 @@ func EncodePcmBuffToSilk(src []byte, sampleRate, bitRate int, tencent bool) (dst
 	if ret != 0 {
 		return nil, fmt.Errorf("SKP_Silk_reset_encoder returned %d", ret)
 	}
-	var frameSize = sampleRate / 1000 * 20
-	fmt.Printf("包长:", frameSize)
+	var frameSize = sampleRate / 1000 * 40
+	fmt.Printf("包长:%v", frameSize)
 	var (
 		nBytes  = int16(250 * 5)
 		in      = make([]byte, frameSize)
@@ -188,3 +188,110 @@ func EncodePcmBuffToSilk(src []byte, sampleRate, bitRate int, tencent bool) (dst
 	dst = out.Bytes()
 	return
 }
+
+// Assuming necessary imports and definitions
+
+func EncodePcmBuffToSilkv2(src []byte, sampleRate, bitRate int, tencent, bigEndian bool, complexityMode int) (dst []byte, err error) {
+	var tls = libc.NewTLS()
+	var reader = bytes.NewBuffer(src)
+	var encControl sdk.SDK_EncControlStruct
+	var encStatus sdk.SDK_EncControlStruct
+	var packetSizeMs = int32(20)
+	var frameSizeReadFromFileMs = int32(20)
+
+	// Setting based on the complexity mode (could be passed as a parameter)
+	encControl.Fcomplexity = int32(complexityMode)
+
+	// Default settings
+	encControl.FAPI_sampleRate = int32(sampleRate)
+	encControl.FmaxInternalSampleRate = 24000
+	encControl.FpacketSize = (packetSizeMs * int32(sampleRate)) / 1000
+	encControl.FpacketLossPercentage = int32(0)
+	encControl.FuseInBandFEC = 0
+	encControl.FuseDTX = 0
+	encControl.FbitRate = int32(bitRate)
+
+	// Create Encoder
+	var encSizeBytes int32
+	ret := sdk.SDK_Get_Encoder_Size(tls, uintptr(unsafe.Pointer(&encSizeBytes)))
+	if ret != 0 {
+		return nil, fmt.Errorf("SKP_Silk_create_encoder returned %d", ret)
+	}
+
+	// Memory management
+	psEnc := libc.Xmalloc(tls, types.Size_t(encSizeBytes))
+	defer libc.Xfree(tls, psEnc)
+
+	// Reset Encoder
+	ret = sdk.SDK_InitEncoder(tls, psEnc, uintptr(unsafe.Pointer(&encStatus)))
+	if ret != 0 {
+		return nil, fmt.Errorf("SKP_Silk_reset_encoder returned %d", ret)
+	}
+
+	var (
+		nBytes  = int16(250 * 5)
+		in      = make([]byte, frameSizeReadFromFileMs*int32(sampleRate)/1000)
+		payload = make([]byte, nBytes)
+		out     = bytes.Buffer{}
+	)
+
+	// Add Silk header to stream
+	if tencent {
+		_, _ = out.Write([]byte("\x02#!SILK_V3"))
+	} else {
+		_, _ = out.Write([]byte("#!SILK_V3"))
+	}
+
+	// Encoding loop
+	var counter int
+	for {
+		counter, err = reader.Read(in)
+		if err != nil {
+			if err == io.EOF {
+				err = nil
+				break
+			}
+			return
+		}
+
+		if bigEndian {
+			SwapEndian(in)
+		}
+
+		nBytes = int16(1250)
+		ret = sdk.SDK_Encode(
+			tls,
+			psEnc,
+			uintptr(unsafe.Pointer(&encControl)),
+			uintptr(unsafe.Pointer(&in[0])),
+			int32(counter)/2,
+			uintptr(unsafe.Pointer(&payload[0])),
+			uintptr(unsafe.Pointer(&nBytes)),
+		)
+
+		if ret != 0 {
+			return nil, fmt.Errorf("SKP_Silk_Encode returned %d", ret)
+		}
+
+		_ = binary.Write(&out, binary.LittleEndian, nBytes)
+		_, _ = out.Write(payload[:nBytes])
+	}
+
+	if !tencent {
+		_ = binary.Write(&out, binary.LittleEndian, int16(-1))
+	}
+
+	dst = out.Bytes()
+	return
+}
+
+func SwapEndian(data []byte) {
+	if len(data)%2 != 0 {
+		panic("SwapEndian requires an even length byte slice")
+	}
+
+	for i := 0; i < len(data); i += 2 {
+		data[i], data[i+1] = data[i+1], data[i]
+	}
+}
+

silk/silk.go

@@ -128,7 +128,8 @@ func encode(record []byte, tempName string) (silkWav []byte) {
 		mylog.Printf("read pcm file err")
 		return nil
 	}
-	silkWav, err = silk.EncodePcmBuffToSilk(pcm, sampleRate, bitRate, false)
+	silkWav, err = silk.EncodePcmBuffToSilkv2(pcm, sampleRate, bitRate, true, false, 2)
+
 	if err != nil {
 		mylog.Printf("silk encode error")
 		return nil