srs/trunk/3rdparty/srs-bench/vendor/github.com/yapingcat/gomedia/codec/opus.go

package codec

import (
	"encoding/binary"
	"errors"
)

// rfc6716 https://datatracker.ietf.org/doc/html/rfc6716
//
// TOC byte
// 0
// 0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+
// | config  |s| c |
// +-+-+-+-+-+-+-+-+

// +-----------------------+-----------+-----------+-------------------+
// | Configuration         | Mode      | Bandwidth | Frame Sizes       |
// | Number(s)             |           |           |                   |
// +-----------------------+-----------+-----------+-------------------+
// | 0...3                 | SILK-only | NB        | 10, 20, 40, 60 ms |
// |                       |           |           |                   |
// | 4...7                 | SILK-only | MB        | 10, 20, 40, 60 ms |
// |                       |           |           |                   |
// | 8...11                | SILK-only | WB        | 10, 20, 40, 60 ms |
// |                       |           |           |                   |
// | 12...13               | Hybrid    | SWB       | 10, 20 ms         |
// |                       |           |           |                   |
// | 14...15               | Hybrid    | FB        | 10, 20 ms         |
// |                       |           |           |                   |
// | 16...19               | CELT-only | NB        | 2.5, 5, 10, 20 ms |
// |                       |           |           |                   |
// | 20...23               | CELT-only | WB        | 2.5, 5, 10, 20 ms |
// |                       |           |           |                   |
// | 24...27               | CELT-only | SWB       | 2.5, 5, 10, 20 ms |
// |                       |           |           |                   |
// | 28...31               | CELT-only | FB        | 2.5, 5, 10, 20 ms |
// +-----------------------+-----------+-----------+-------------------+

// s: with 0 indicating mono and 1 indicating stereo.
//
// c : codes 0 to 3
// 0: 1 frame in the packet
// 1: 2 frames in the packet, each with equal compressed size
// 2: 2 frames in the packet, with different compressed sizes
// 3: an arbitrary number of frames in the packet

// Frame Length Coding
// 0: No frame (Discontinuous Transmission (DTX) or lost packet)
// 1...251: Length of the frame in bytes
// 252...255: A second byte is needed.  The total length is (second_byte*4)+first_byte

// Code 0:
//  0                   1                   2                   3
//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | config  |s|0|0|                                               |
// +-+-+-+-+-+-+-+-+                                               |
// |                    Compressed frame 1 (N-1 bytes)...          :
// :                                                               |
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

// Code 1:
//  0                   1                   2                   3
//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | config  |s|0|1|                                               |
// +-+-+-+-+-+-+-+-+                                               :
// |             Compressed frame 1 ((N-1)/2 bytes)...             |
// :                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                               |                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               :
// |             Compressed frame 2 ((N-1)/2 bytes)...             |
// :                                               +-+-+-+-+-+-+-+-+
// |                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

// Code 2:
//  0                   1                   2                   3
//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | config  |s|1|0| N1 (1-2 bytes):                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               :
// |               Compressed frame 1 (N1 bytes)...                |
// :                               +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                               |                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+                               |
// |                     Compressed frame 2...                     :
// :                                                               |
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

//Code 3:
//  Frame Count Byte
//  0
//  0 1 2 3 4 5 6 7
// +-+-+-+-+-+-+-+-+
// |v|p|     M     |
// +-+-+-+-+-+-+-+-+
// v: 0 - CBR 1 - VBR
// p: 0 - no padding 1 - padding after frame
// M: frame count

// A CBR Code 3 Packet
//  0                   1                   2                   3
//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | config  |s|1|1|0|p|     M     |  Padding length (Optional)    :
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :               Compressed frame 1 (R/M bytes)...               :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :               Compressed frame 2 (R/M bytes)...               :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :                              ...                              :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :               Compressed frame M (R/M bytes)...               :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// :                  Opus Padding (Optional)...                   |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//

//
//  A VBR Code 3 Packet
//  0                   1                   2                   3
//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | config  |s|1|1|1|p|     M     | Padding length (Optional)     :
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// : N1 (1-2 bytes): N2 (1-2 bytes):     ...       :     N[M-1]    |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :               Compressed frame 1 (N1 bytes)...                :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :               Compressed frame 2 (N2 bytes)...                :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :                              ...                              :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                                                               |
// :                     Compressed frame M...                     :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// :                  Opus Padding (Optional)...                   |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

var (
	/// 10ms,20ms,40ms,60ms, samplerate 48000
	//  sample num per millisecond
	//  48000 / 1000ms * 10 = 480 ...
	SLKOpusSampleSize    [4]int = [4]int{480, 960, 1920, 2880}
	HybridOpusSampleSize [4]int = [4]int{480, 960}
	CELTOpusSampleSize   [4]int = [4]int{120, 210, 480, 960}
)

func OpusPacketDuration(packet []byte) uint64 {
	config := int(packet[0] >> 3)
	code := packet[0] & 0x03
	frameCount := 0
	var duration uint64
	if code == 0 {
		frameCount = 1
	} else if code == 1 || code == 2 {
		frameCount = 2
	} else if code == 3 {
		frameCount = int(packet[1] & 0x1F)
	} else {
		panic("code must <= 3")
	}

	switch {
	case config >= 0 && config < 12:
		duration = uint64(frameCount * SLKOpusSampleSize[config%4])
	case config >= 12 && config < 16:
		duration = uint64(frameCount * HybridOpusSampleSize[config%2])
	case config >= 16 && config < 32:
		duration = uint64(frameCount * CELTOpusSampleSize[config%4])
	default:
		panic("unkown opus config")
	}

	return duration
}

//ffmpeg opus.h OpusPacket
type OpusPacket struct {
	Code       int
	Config     int
	Stereo     int
	Vbr        int
	FrameCount int
	FrameLen   []uint16
	Frame      []byte
	Duration   uint64
}

func DecodeOpusPacket(packet []byte) *OpusPacket {
	pkt := &OpusPacket{}
	pkt.Code = int(packet[0] & 0x03)
	pkt.Stereo = int((packet[0] >> 2) & 0x01)
	pkt.Config = int(packet[0] >> 3)

	switch pkt.Code {
	case 0:
		pkt.FrameCount = 1
		pkt.FrameLen = make([]uint16, 1)
		pkt.FrameLen[0] = uint16(len(packet) - 1)
		pkt.Frame = packet[1:]
	case 1:
		pkt.FrameCount = 2
		pkt.FrameLen = make([]uint16, 1)
		pkt.FrameLen[0] = uint16(len(packet)-1) / 2
		pkt.Frame = packet[1:]
	case 2:
		pkt.FrameCount = 2
		hdr := 1
		N1 := int(packet[1])
		if N1 >= 252 {
			N1 = N1 + int(packet[2]*4)
			hdr = 2
		}
		pkt.FrameLen = make([]uint16, 2)
		pkt.FrameLen[0] = uint16(N1)
		pkt.FrameLen[1] = uint16(len(packet)-hdr) - uint16(N1)
	case 3:
		hdr := 2
		pkt.Vbr = int(packet[1] >> 7)
		padding := packet[1] >> 6
		pkt.FrameCount = int(packet[1] & 0x1F)
		paddingLen := 0
		if padding == 1 {
			for packet[hdr] == 255 {
				paddingLen += 254
				hdr++
			}
			paddingLen += int(packet[hdr])
		}

		if pkt.Vbr == 0 {
			pkt.FrameLen = make([]uint16, 1)
			pkt.FrameLen[0] = uint16(len(packet)-hdr-paddingLen) / uint16(pkt.FrameCount)
			pkt.Frame = packet[hdr : hdr+int(pkt.FrameLen[0]*uint16(pkt.FrameCount))]
		} else {
			n := 0
			for i := 0; i < int(pkt.FrameCount)-1; i++ {
				N1 := int(packet[hdr])
				hdr += 1
				if N1 >= 252 {
					N1 = N1 + int(packet[hdr]*4)
					hdr += 1
				}
				n += N1
				pkt.FrameLen = append(pkt.FrameLen, uint16(N1))
			}
			lastFrameLen := len(packet) - hdr - paddingLen - n
			pkt.FrameLen = append(pkt.FrameLen, uint16(lastFrameLen))
			pkt.Frame = packet[hdr : hdr+n+lastFrameLen]
		}
	default:
		panic("Error C must <= 3")
	}
	OpusPacketDuration(packet)
	return pkt
}

const (
	LEFT_CHANNEL  = 0
	RIGHT_CHANNEL = 1
)

var (
	vorbisChanLayoutOffset [8][8]byte = [8][8]byte{
		{0},
		{0, 1},
		{0, 2, 1},
		{0, 1, 2, 3},
		{0, 2, 1, 3, 4},
		{0, 2, 1, 5, 3, 4},
		{0, 2, 1, 6, 5, 3, 4},
		{0, 2, 1, 7, 5, 6, 3, 4},
	}
)

type ChannelOrder func(channels int, idx int) int

func defalutOrder(channels int, idx int) int {
	return idx
}

func vorbisOrder(channels int, idx int) int {
	return int(vorbisChanLayoutOffset[channels-1][idx])
}

type ChannelMap struct {
	StreamIdx  int
	ChannelIdx int
	Silence    bool
	Copy       bool
	CopyFrom   int
}

type OpusContext struct {
	Preskip           int
	SampleRate        int
	ChannelCount      int
	StreamCount       int
	StereoStreamCount int
	OutputGain        uint16
	MapType           uint8
	ChannelMaps       []ChannelMap
}

// opus ID Head
// 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |      'O'      |      'p'      |      'u'      |      's'      |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |      'H'      |      'e'      |      'a'      |      'd'      |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |  Version = 1  | Channel Count |           Pre-skip            |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |                     Input Sample Rate (Hz)                    |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// |   Output Gain (Q7.8 in dB)    | Mapping Family|               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+               :
// |                                                               |
// :               Optional Channel Mapping Table...               :
// |                                                               |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+

//  0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
//                                                 +-+-+-+-+-+-+-+-+
//                                                 | Stream Count  |
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
// | Coupled Count |              Channel Mapping...               :
// +-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
//
func (ctx *OpusContext) ParseExtranData(extraData []byte) error {
	if string(extraData[0:8]) != "OpusHead" {
		return errors.New("magic signature must equal OpusHead")
	}

	_ = extraData[8] // version
	ctx.ChannelCount = int(extraData[9])
	ctx.Preskip = int(binary.LittleEndian.Uint16(extraData[10:]))
	ctx.SampleRate = int(binary.LittleEndian.Uint32(extraData[12:]))
	ctx.OutputGain = binary.LittleEndian.Uint16(extraData[16:])
	ctx.MapType = extraData[18]
	var channel []byte
	var order ChannelOrder
	if ctx.MapType == 0 {
		ctx.StreamCount = 1
		ctx.StereoStreamCount = ctx.ChannelCount - 1
		channel = []byte{0, 1}
		order = defalutOrder
	} else if ctx.MapType == 1 || ctx.MapType == 2 || ctx.MapType == 255 {
		ctx.StreamCount = int(extraData[19])
		ctx.StereoStreamCount = int(extraData[20])
		if ctx.MapType == 1 {
			channel = extraData[21 : 21+ctx.ChannelCount]
			order = vorbisOrder
		}
	} else {
		return errors.New("unsupport map type 255")
	}

	for i := 0; i < ctx.ChannelCount; i++ {
		cm := ChannelMap{}
		index := channel[order(ctx.ChannelCount, i)]
		if index == 255 {
			cm.Silence = true
			continue
		} else if index > byte(ctx.StereoStreamCount)+byte(ctx.StreamCount) {
			return errors.New("index must < (streamcount + stereo streamcount)")
		}

		for j := 0; j < i; j++ {
			if channel[order(ctx.ChannelCount, i)] == index {
				cm.Copy = true
				cm.CopyFrom = j
				break
			}
		}

		if int(index) < 2*ctx.StereoStreamCount {
			cm.StreamIdx = int(index) / 2
			if index&1 == 0 {
				cm.ChannelIdx = LEFT_CHANNEL
			} else {
				cm.ChannelIdx = RIGHT_CHANNEL
			}
		} else {
			cm.StreamIdx = int(index) - ctx.StereoStreamCount
			cm.ChannelIdx = 0
		}
		ctx.ChannelMaps = append(ctx.ChannelMaps, cm)
	}

	return nil
}

func (ctx *OpusContext) WriteOpusExtraData() []byte {
	extraData := make([]byte, 19)
	copy(extraData, string("OpusHead"))
	extraData[8] = 0x01
	extraData[9] = byte(ctx.ChannelCount)
	binary.LittleEndian.PutUint16(extraData[10:], uint16(ctx.Preskip))
	binary.LittleEndian.PutUint32(extraData[12:], uint32(ctx.SampleRate))
	return extraData
}

func WriteDefaultOpusExtraData() []byte {
	return []byte{
		'O', 'p', 'u', 's', 'H', 'e', 'a', 'd',
		1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
		0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
	}
}