av/stream/mts/psi/psi.go

package psi

import (
	"hash/crc32"
	"math/bits"
)

const (
	ESSDDefLen = 5
	DescDefLen = 2
	PMTDefLen  = 4
	PATLen     = 4
	TSSDefLen  = 5
	PSIDefLen  = 3
)

// Program specific information
type PSI struct {
	pf  byte   // Point field
	pfb []byte // Pointer filler bytes
	tid byte   // Table ID
	ssi bool   // Section syntax indicator (1 for PAT, PMT, CAT)
	pb  bool   // Private bit (0 for PAT, PMT, CAT)
	sl  uint16 // Section length
	tss *TSS   // Table syntax section (length defined by SL) if length 0 then nil
	crc uint32 // crc32 of entire table excluding pointer field, pointer filler bytes and the trailing CRC32
}

// Table syntax section
type TSS struct {
	tide uint16 // Table ID extension
	v    byte   // Version number
	cni  bool   // Current/next indicator
	sn   byte   // Section number
	lsn  byte   // Last section number
	sd   SD     // Specific data PAT/PMT
}

// Specific Data, (could be PAT or PMT)
type SD interface {
	Bytes() []byte
}

// Program association table, implements SD
type PAT struct {
	pn    uint16 // Program Number
	pmpid uint16 // Program map PID
}

// Program mapping table, implements SD
type PMT struct {
	pcrpid uint16 // Program clock reference pid
	pil    uint16 // Program info length
	pd     []Desc // Program descriptors
	essd   []ESSD // Elementary stream specific data
}

// Elementary stream specific data
type ESSD struct {
	st   byte   // Stream type
	epid uint16 // Elementary pid
	esil uint16 // Elementary stream
	esd  []Desc // Elementary stream desriptors
}

// Descriptor
type Desc struct {
	dt byte   // Descriptor tag
	dl byte   // Descriptor length
	dd []byte // Descriptor data
}

// TODO: Implement this
func ReadPSI(data []byte) *PSI {
	return nil
}

func (p *PSI) Bytes() []byte {
	l := 1 + len(p.pfb)
	out := make([]byte, l+PSIDefLen)
	out[0] = p.pf
	for i, b := range p.pfb {
		out[1+i] = b
	}
	out[l] = p.tid
	out[l+1] = 0x80 | 0x40 | 0x30 | (0x03 & byte(p.sl>>8))
	out[l+2] = byte(p.sl)
	out = append(out, p.tss.Bytes()...)
	crc32 := crc32_Update(0xffffffff, crc32_MakeTable(bits.Reverse32(crc32.IEEE)), out[l:])
	out = append(out, make([]byte, 0, 4)...)
	out = append(out, byte(crc32>>24))
	out = append(out, byte(crc32>>16))
	out = append(out, byte(crc32>>8))
	out = append(out, byte(crc32))
	return out
}

func (t *TSS) Bytes() []byte {
	out := make([]byte, TSSDefLen)
	out[0] = byte(t.tide >> 8)
	out[1] = byte(t.tide)
	out[2] = 0xc0 | (0x3e & (t.v << 1)) | (0x01 & boolToByte(t.cni))
	out[3] = t.sn
	out[4] = t.lsn
	out = append(out, t.sd.Bytes()...)
	return out
}

func (p *PAT) Bytes() []byte {
	out := make([]byte, PATLen)
	out[0] = byte(p.pn >> 8)
	out[1] = byte(p.pn)
	out[2] = 0xe0 | (0x1f & byte(p.pmpid>>8))
	out[3] = byte(p.pmpid)
	return out
}

func (p *PMT) Bytes() []byte {
	out := make([]byte, PMTDefLen)
	out[0] = 0xe0 | (0x1f & byte(p.pcrpid>>8))
	out[1] = byte(p.pcrpid)
	out[2] = 0xf0 | (0x03 & byte(p.pil>>8))
	out[3] = byte(p.pil)
	for _, d := range p.pd {
		out = append(out, d.Bytes()...)
	}
	for _, e := range p.essd {
		out = append(out, e.Bytes()...)
	}
	return out
}

func (d *Desc) Bytes() []byte {
	out := make([]byte, DescDefLen)
	out[0] = d.dt
	out[1] = d.dl
	out = append(out, d.dd...)
	return out
}

func (e *ESSD) Bytes() []byte {
	out := make([]byte, ESSDDefLen)
	out[0] = e.st
	out[1] = 0xe0 | (0x1f & byte(e.epid>>8))
	out[2] = byte(e.epid)
	out[3] = 0xf0 | (0x03 & byte(e.esil>>8))
	out[4] = byte(e.esil)
	for _, d := range e.esd {
		out = append(out, d.Bytes()...)
	}
	return out
}

func boolToByte(b bool) byte {
	if b {
		return 0x01
	}
	return 0x00
}

func crc32_MakeTable(poly uint32) *crc32.Table {
	var t crc32.Table
	for i := range t {
		crc := uint32(i) << 24
		for j := 0; j < 8; j++ {
			if crc&0x80000000 != 0 {
				crc = (crc << 1) ^ poly
			} else {
				crc <<= 1
			}
		}
		t[i] = crc
	}
	return &t
}

func crc32_Update(crc uint32, tab *crc32.Table, p []byte) uint32 {
	for _, v := range p {
		crc = tab[byte(crc>>24)^v] ^ (crc << 8)
	}
	return crc
}