av/codec/h264/h264dec/cabacenc.go

223 lines
5.6 KiB
Go
Raw Normal View History

/*
TODO: this file should really be in a 'h264enc' package.
DESCRIPTION
cabacenc.go provides functionality for CABAC encoding.
AUTHORS
Saxon A. Nelson-Milton <saxon@ausocean.org>
LICENSE
Copyright (C) 2019 the Australian Ocean Lab (AusOcean).
It is free software: you can redistribute it and/or modify them
under the terms of the GNU General Public License as published by the
Free Software Foundation, either version 3 of the License, or (at your
option) any later version.
It is distributed in the hope that it will be useful, but WITHOUT
ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
You should have received a copy of the GNU General Public License
in gpl.txt. If not, see http://www.gnu.org/licenses.
*/
package h264dec
import (
"errors"
"math"
)
// Error used by unaryBinString.
var errNegativeSyntaxVal = errors.New("cannot get unary binary string of negative value")
// unaryBinString returns the unary binary string of a syntax element having
// value v, as specified by setion 9.3.2.1 in the specifications.
func unaryBinString(v int) ([]int, error) {
if v < 0 {
return nil, errNegativeSyntaxVal
}
r := make([]int, v+1)
for i := 0; i <= v; i++ {
if i < v {
r[i] = 1
}
}
return r, nil
}
// Error used by truncUnaryBinString.
var errInvalidSyntaxVal = errors.New("syntax value cannot be greater than cMax")
// truncUnaryBinString returns the truncated unary binary string of a syntax
// element v given a cMax as specified in section 9.3.2.2 of the specifications.
func truncUnaryBinString(v, cMax int) ([]int, error) {
if v < 0 {
return nil, errNegativeSyntaxVal
}
if v > cMax {
return nil, errInvalidSyntaxVal
}
if v == cMax {
b, _ := unaryBinString(v)
return b[:len(b)-1], nil
}
return unaryBinString(v)
}
// Error used by unaryExpGolombBinString.
var errInvalidUCoff = errors.New("uCoff cannot be less than or equal to zero")
// unaryExpGolombBinString returns the concatendated unary/k-th order
// Exp-Golomb (UEGk) binary string of a syntax element using the process defined
// in section 9.3.2.3 of the specifications.
func unaryExpGolombBinString(v, uCoff, k int, signedValFlag bool) ([]int, error) {
if uCoff <= 0 {
return nil, errInvalidUCoff
}
prefix, err := truncUnaryBinString(mini(uCoff, absi(v)), uCoff)
if err != nil {
return nil, err
}
return append(prefix, suffix(v, uCoff, k, signedValFlag)...), nil
}
// suffix returns the suffix part of a unary k-th Exp-Golomb binar string
// using the the algorithm as described by pseudo code 9-6 in section 9.3.2.3.
// TODO: could probably reduce allocations.
func suffix(v, uCoff, k int, signedValFlag bool) []int {
var s []int
if absi(v) >= uCoff {
sufS := absi(v) - uCoff
var stop bool
for {
if sufS >= (1 << uint(k)) {
s = append(s, 1)
sufS = sufS - (1 << uint(k))
k++
} else {
s = append(s, 0)
for k = k - 1; k >= 0; k-- {
s = append(s, (sufS>>uint(k))&1)
}
stop = true
}
if stop {
break
}
}
}
if signedValFlag && v != 0 {
if v > 0 {
s = append(s, 0)
} else {
s = append(s, 1)
}
}
return s
}
// Error used by fixedLenBinString.
var errNegativeValue = errors.New("cannot get fixed length binary string of negative value")
// fixedLenBinString returns the fixed-length (FL) binary string of the syntax
// element v, given cMax to determine bin length, as specified by section 9.3.2.4
// of the specifications.
func fixedLenBinString(v, cMax int) ([]int, error) {
if v < 0 {
return nil, errNegativeValue
}
l := int(math.Ceil(math.Log2(float64(cMax + 1))))
r := make([]int, l)
for i := l - 1; i >= 0; i-- {
r[i] = v % 2
v = v / 2
}
return r, nil
}
// Errors used by mbTypeBinString.
var (
errBadMbType = errors.New("macroblock type outside of valid range")
errBadMbSliceType = errors.New("bad slice type for macroblock")
)
// mbTypeBinString returns the macroblock type binary string for the given
// macroblock type value and slice type using the process defined in section
// 9.3.2.5 of the specifications.
func mbTypeBinString(v, slice int) ([]int, error) {
switch slice {
case sliceTypeI:
if v < minIMbType || v > maxIMbType {
return nil, errBadMbType
}
return binOfIMBTypes[v], nil
case sliceTypeSI:
if v < minSIMbType || v > maxSIMbType {
return nil, errBadMbType
}
if v == sliceTypeSI {
return []int{0}, nil
}
return append([]int{1}, binOfIMBTypes[v-1]...), nil
case sliceTypeP, sliceTypeSP:
if v < minPOrSPMbType || v > maxPOrSPMbType || v == P8x8ref0 {
return nil, errBadMbType
}
if v < 5 {
return binOfPOrSPMBTypes[v], nil
}
return append([]int{1}, binOfIMBTypes[v-5]...), nil
case sliceTypeB:
if v < minBMbType || v > maxBMbType {
return nil, errBadMbType
}
if v < 23 {
return binOfBMBTypes[v], nil
}
return append([]int{1, 1, 1, 1, 0, 1}, binOfIMBTypes[v-23]...), nil
default:
return nil, errBadMbSliceType
}
}
// Error used by subMbTypeBinString.
var errBadSubMbSliceType = errors.New("bad slice type for sub-macroblock")
// subMbTypeBinString returns the binary string of a sub-macroblock type
// given the slice in which it is in using the process defined in section
// 9.3.2.5 of the specifications.
func subMbTypeBinString(v, slice int) ([]int, error) {
switch slice {
case sliceTypeP, sliceTypeSP:
if v < minPOrSPSubMbType || v > maxPOrSPSubMbType {
return nil, errBadMbType
}
return binOfPOrSPSubMBTypes[v], nil
case sliceTypeB:
if v < minBSubMbType || v > maxBSubMbType {
return nil, errBadMbType
}
return binOfBSubMBTypes[v], nil
default:
return nil, errBadSubMbSliceType
}
}