mirror of https://bitbucket.org/ausocean/av.git
244 lines
6.2 KiB
Go
244 lines
6.2 KiB
Go
|
/*
|
||
|
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"
|
||
|
"fmt"
|
||
|
"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
|
||
|
}
|
||
|
}
|
||
|
|
||
|
// codedBlockPatternBinString returns the binarization for the syntax element
|
||
|
// coded_block_pattern as defined by section 9.3.2.6 in specifications.
|
||
|
func codedBlockPatternBinString(luma, chroma, arrayType int) ([]int, error) {
|
||
|
p, err := fixedLenBinString(luma, 15)
|
||
|
if err != nil {
|
||
|
return nil, fmt.Errorf("fixed length binarization failed with error: %w", err)
|
||
|
}
|
||
|
|
||
|
if arrayType == 0 || arrayType == 3 {
|
||
|
return p, nil
|
||
|
}
|
||
|
|
||
|
s, err := truncUnaryBinString(chroma, 2)
|
||
|
if err != nil {
|
||
|
return nil, fmt.Errorf("truncated unary binarization failed with error: %w", err)
|
||
|
}
|
||
|
|
||
|
return append(p, s...), nil
|
||
|
}
|