173 lines
3.1 KiB
Go
173 lines
3.1 KiB
Go
package main
|
|
|
|
import (
|
|
"bufio"
|
|
"encoding/binary"
|
|
"errors"
|
|
"fmt"
|
|
"io"
|
|
"log"
|
|
"os"
|
|
)
|
|
|
|
const fname = "/home/rob/share/home-office/example.mp3"
|
|
|
|
type (
|
|
AudioVersionId int
|
|
LayerIndex int
|
|
|
|
header uint32
|
|
)
|
|
|
|
const (
|
|
AudioVersionMPEG25 AudioVersionId = iota
|
|
AudioVersionReserved
|
|
AudioVersionMPEG2
|
|
AudioVersionMPEG1
|
|
)
|
|
|
|
const (
|
|
LayerIndexReserved LayerIndex = iota
|
|
LayerIndexIII
|
|
LayerIndexII
|
|
LayerIndexI
|
|
)
|
|
|
|
var (
|
|
bitRates = [5][16]uint32{
|
|
{0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448, 0},
|
|
{0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384, 0},
|
|
{0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 0},
|
|
{0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256, 0},
|
|
{0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160, 0},
|
|
}
|
|
|
|
sampleRates = [4][4]uint32{
|
|
{11025, 12000, 8000, 0},
|
|
{0, 0, 0, 0},
|
|
{22050, 24000, 16000, 0},
|
|
{44100, 48000, 32000, 0},
|
|
}
|
|
|
|
samplesPerFrame = [4][4]uint32{
|
|
{0, 384, 1152, 576},
|
|
{0, 0, 0, 0},
|
|
{384, 1152, 576},
|
|
{384, 1152, 1152},
|
|
}
|
|
)
|
|
|
|
// TODO tests
|
|
func (h header) HasSyncWord() bool {
|
|
return (h>>21)&0x7ff == 0x7ff
|
|
}
|
|
|
|
func (h header) AudioVersionId() AudioVersionId {
|
|
return AudioVersionId((h >> 19) & 0x3)
|
|
}
|
|
|
|
func (h header) LayerIndex() LayerIndex {
|
|
return LayerIndex(((h >> 8) & 0x6) >> 1)
|
|
}
|
|
|
|
func (h header) IsProtected() bool {
|
|
return (h>>8)&1 == 1
|
|
}
|
|
|
|
func (h header) SampleRate() uint32 {
|
|
i := h.AudioVersionId()
|
|
j := (h >> 18) & 0xb11
|
|
return sampleRates[i][j]
|
|
}
|
|
|
|
func (h header) IsValid() bool {
|
|
if !h.HasSyncWord() {
|
|
return false
|
|
}
|
|
if h.AudioVersionId() == AudioVersionReserved {
|
|
return false
|
|
}
|
|
if h.LayerIndex() == LayerIndexReserved {
|
|
return false
|
|
}
|
|
if h.BitRate() == 0 {
|
|
return false
|
|
}
|
|
|
|
return true
|
|
}
|
|
|
|
func (h header) BitRate() uint32 {
|
|
var j int
|
|
switch h.AudioVersionId() {
|
|
case AudioVersionMPEG1:
|
|
switch h.LayerIndex() {
|
|
case LayerIndexIII:
|
|
j = 2
|
|
case LayerIndexII:
|
|
j = 1
|
|
case LayerIndexI:
|
|
j = 0
|
|
default:
|
|
return 0
|
|
}
|
|
case AudioVersionReserved:
|
|
return 0
|
|
case AudioVersionMPEG2, AudioVersionMPEG25:
|
|
switch h.LayerIndex() {
|
|
case LayerIndexIII, LayerIndexII:
|
|
j = 4
|
|
case LayerIndexI:
|
|
j = 3
|
|
default:
|
|
return 0
|
|
|
|
}
|
|
}
|
|
k := ((h >> 20) & 0xf)
|
|
return bitRates[j][k]
|
|
}
|
|
|
|
func main() {
|
|
f, err := os.Open(fname)
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
|
|
bufreader := bufio.NewReader(f)
|
|
buf := make([]byte, 4)
|
|
|
|
var i int
|
|
for {
|
|
_, err := io.ReadFull(bufreader, buf)
|
|
if err != nil {
|
|
if err == io.EOF {
|
|
break
|
|
}
|
|
log.Fatal(err)
|
|
}
|
|
|
|
header, err := newHeaderFromBytes(buf)
|
|
if header.IsValid() {
|
|
fmt.Printf("%+v\n", buf)
|
|
fmt.Printf("Got header: %032b, audio version: %d, layer index: %d, bitrate: %d\n", header, header.AudioVersionId(), header.LayerIndex(), header.BitRate())
|
|
} else {
|
|
bufreader.Discard(3)
|
|
}
|
|
i++
|
|
}
|
|
}
|
|
|
|
func newHeaderFromBytes(buf []byte) (header, error) {
|
|
if len(buf) < 4 {
|
|
return 0, errors.New("insufficient bytes")
|
|
}
|
|
// assume little-endian for now
|
|
return newHeader(binary.LittleEndian.Uint32(buf))
|
|
}
|
|
|
|
// TODO use unsafe here? https://codereview.stackexchange.com/a/60161
|
|
func newHeader(n uint32) (header, error) {
|
|
return header(n), nil
|
|
}
|