6645815568

Committed 25 Oct 2023 08:30PM UTC coverage: 47.0% (+1.7%) from 45.284%

Build # 6645815568

Build Type

push

github

Committed by

web-flow

Commit Message

Replace Travis CI with Github Actions (#64)

* Add basic Github Actions workflow file

* Give the build job a name which includes the go version

* Checkout submodules in the Github workflow

* Flip around gofmt and go test in the Github workflow so the most important errors are shown first

* Replace Github workflow Go version 1.21 with stable

* Replace the Travis CI badge with a Github Actions badge in the README

* Remove Travis CI file

* Add goveralls to the Github workflow

* Only install goveralls when building with Go stable in the Github workflow

* Try to fix goveralls in Github workflow

* Try to fix goveralls in Github workflow

* Update Coveralls badge

* Only run coverage on the master branch in the Github workflow

* Use the Go version in the go.mod file instead of using a matrix

* Revert "Use the Go version in the go.mod file instead of using a matrix"

This reverts commit 12bbfc461.

Run Details

1026 of 2183 relevant lines covered (47.0%)

3496647.41 hits per line

Source File
Press 'n' to go to next uncovered line, 'b' for previous

75.0

/frame/subframe.go

package frame

import (
        "errors"
        "fmt"
        "github.com/mewkiz/flac/internal/bits"
)

// A Subframe contains the encoded audio samples from one channel of an audio
// block (a part of the audio stream).
//
// ref: https://www.xiph.org/flac/format.html#subframe
type Subframe struct {
        // Subframe header.
        SubHeader
        // Unencoded audio samples. Samples is initially nil, and gets populated by a
        // call to Frame.Parse.
        //
        // Samples is used by decodeFixed and decodeFIR to temporarily store
        // residuals. Before returning they call decodeLPC which decodes the audio
        // samples.
        Samples []int32
        // Number of audio samples in the subframe.
        NSamples int
}

// parseSubframe reads and parses the header, and the audio samples of a
// subframe.
func (frame *Frame) parseSubframe(br *bits.Reader, bps uint) (subframe *Subframe, err error) {
        // Parse subframe header.
        subframe = new(Subframe)
        if err = subframe.parseHeader(br); err != nil {
                return subframe, err
        }
        // Adjust bps of subframe for wasted bits-per-sample.
        bps -= subframe.Wasted

        // Decode subframe audio samples.
        subframe.NSamples = int(frame.BlockSize)
        subframe.Samples = make([]int32, 0, subframe.NSamples)
        switch subframe.Pred {
        case PredConstant:
                err = subframe.decodeConstant(br, bps)
        case PredVerbatim:
                err = subframe.decodeVerbatim(br, bps)
        case PredFixed:
                err = subframe.decodeFixed(br, bps)
        case PredFIR:
                err = subframe.decodeFIR(br, bps)
        }

        // Left shift to accout for wasted bits-per-sample.
        for i, sample := range subframe.Samples {
                subframe.Samples[i] = sample << subframe.Wasted
        }
        return subframe, err
}

// A SubHeader specifies the prediction method and order of a subframe.
//
// ref: https://www.xiph.org/flac/format.html#subframe_header
type SubHeader struct {
        // Specifies the prediction method used to encode the audio sample of the
        // subframe.
        Pred Pred
        // Prediction order used by fixed and FIR linear prediction decoding.
        Order int
        // Wasted bits-per-sample.
        Wasted uint
}

// parseHeader reads and parses the header of a subframe.
func (subframe *Subframe) parseHeader(br *bits.Reader) error {
        // 1 bit: zero-padding.
        x, err := br.Read(1)
        if err != nil {
                return unexpected(err)
        }
        if x != 0 {
                return errors.New("frame.Subframe.parseHeader: non-zero padding")
        }

        // 6 bits: Pred.
        x, err = br.Read(6)
        if err != nil {
                return unexpected(err)
        }
        // The 6 bits are used to specify the prediction method and order as follows:
        //    000000: Constant prediction method.
        //    000001: Verbatim prediction method.
        //    00001x: reserved.
        //    0001xx: reserved.
        //    001xxx:
        //       if (xxx <= 4)
        //          Fixed prediction method; xxx=order
        //       else
        //          reserved.
        //    01xxxx: reserved.
        //    1xxxxx: FIR prediction method; xxxxx=order-1
        switch {
        case x < 1:
                // 000000: Constant prediction method.
                subframe.Pred = PredConstant
        case x < 2:
                // 000001: Verbatim prediction method.
                subframe.Pred = PredVerbatim
        case x < 8:
                // 00001x: reserved.
                // 0001xx: reserved.
                return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)
        case x < 16:
                // 001xxx:
                //    if (xxx <= 4)
                //       Fixed prediction method; xxx=order
                //    else
                //       reserved.
                order := int(x & 0x07)
                if order > 4 {
                        return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)
                }
                subframe.Pred = PredFixed
                subframe.Order = order
        case x < 32:
                // 01xxxx: reserved.
                return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)
        default:
                // 1xxxxx: FIR prediction method; xxxxx=order-1
                subframe.Pred = PredFIR
                subframe.Order = int(x&0x1F) + 1
        }

        // 1 bit: hasWastedBits.
        x, err = br.Read(1)
        if err != nil {
                return unexpected(err)
        }
        if x != 0 {
                // k wasted bits-per-sample in source subblock, k-1 follows, unary coded;
                // e.g. k=3 => 001 follows, k=7 => 0000001 follows.
                x, err = br.ReadUnary()
                if err != nil {
                        return unexpected(err)
                }
                subframe.Wasted = uint(x) + 1
        }

        return nil
}

// Pred specifies the prediction method used to encode the audio samples of a
// subframe.
type Pred uint8

// Prediction methods.
const (
        // PredConstant specifies that the subframe contains a constant sound. The
        // audio samples are encoded using run-length encoding. Since every audio
        // sample has the same constant value, a single unencoded audio sample is
        // stored in practice. It is replicated a number of times, as specified by
        // BlockSize in the frame header.
        PredConstant Pred = iota
        // PredVerbatim specifies that the subframe contains unencoded audio samples.
        // Random sound is often stored verbatim, since no prediction method can
        // compress it sufficiently.
        PredVerbatim
        // PredFixed specifies that the subframe contains linear prediction coded
        // audio samples. The coefficients of the prediction polynomial are selected
        // from a fixed set, and can represent 0th through fourth-order polynomials.
        // The prediction order (0 through 4) is stored within the subframe along
        // with the same number of unencoded warm-up samples, which are used to kick
        // start the prediction polynomial. The remainder of the subframe stores
        // encoded residuals (signal errors) which specify the difference between the
        // predicted and the original audio samples.
        PredFixed
        // PredFIR specifies that the subframe contains linear prediction coded audio
        // samples. The coefficients of the prediction polynomial are stored in the
        // subframe, and can represent 0th through 32nd-order polynomials. The
        // prediction order (0 through 32) is stored within the subframe along with
        // the same number of unencoded warm-up samples, which are used to kick start
        // the prediction polynomial. The remainder of the subframe stores encoded
        // residuals (signal errors) which specify the difference between the
        // predicted and the original audio samples.
        PredFIR
)

// signExtend interprets x as a signed n-bit integer value and sign extends it
// to 32 bits.
func signExtend(x uint64, n uint) int32 {
        // x is signed if its most significant bit is set.
        if x&(1<<(n-1)) != 0 {
                // Sign extend x.
                return int32(x | ^uint64(0)<<n)
        }
        return int32(x)
}

// decodeConstant reads an unencoded audio sample of the subframe. Each sample
// of the subframe has this constant value. The constant encoding can be thought
// of as run-length encoding.
//
// ref: https://www.xiph.org/flac/format.html#subframe_constant
func (subframe *Subframe) decodeConstant(br *bits.Reader, bps uint) error {
        // (bits-per-sample) bits: Unencoded constant value of the subblock.
        x, err := br.Read(bps)
        if err != nil {
                return unexpected(err)
        }

        // Each sample of the subframe has the same constant value.
        sample := signExtend(x, bps)
        for i := 0; i < subframe.NSamples; i++ {
                subframe.Samples = append(subframe.Samples, sample)
        }

        return nil
}

// decodeVerbatim reads the unencoded audio samples of the subframe.
//
// ref: https://www.xiph.org/flac/format.html#subframe_verbatim
func (subframe *Subframe) decodeVerbatim(br *bits.Reader, bps uint) error {
        // Parse the unencoded audio samples of the subframe.
        for i := 0; i < subframe.NSamples; i++ {
                // (bits-per-sample) bits: Unencoded constant value of the subblock.
                x, err := br.Read(bps)
                if err != nil {
                        return unexpected(err)
                }
                sample := signExtend(x, bps)
                subframe.Samples = append(subframe.Samples, sample)
        }
        return nil
}

// fixedCoeffs maps from prediction order to the LPC coefficients used in fixed
// encoding.
//
//        x_0[n] = 0
//        x_1[n] = x[n-1]
//        x_2[n] = 2*x[n-1] - x[n-2]
//        x_3[n] = 3*x[n-1] - 3*x[n-2] + x[n-3]
//        x_4[n] = 4*x[n-1] - 6*x[n-2] + 4*x[n-3] - x[n-4]
var fixedCoeffs = [...][]int32{
        // ref: Section 2.2 of http://www.hpl.hp.com/techreports/1999/HPL-1999-144.pdf
        1: {1},
        2: {2, -1},
        3: {3, -3, 1},
        // ref: Data Compression: The Complete Reference (7.10.1)
        4: {4, -6, 4, -1},
}

// decodeFixed decodes the linear prediction coded samples of the subframe,
// using a fixed set of predefined polynomial coefficients.
//
// ref: https://www.xiph.org/flac/format.html#subframe_fixed
func (subframe *Subframe) decodeFixed(br *bits.Reader, bps uint) error {
        // Parse unencoded warm-up samples.
        for i := 0; i < subframe.Order; i++ {
                // (bits-per-sample) bits: Unencoded warm-up sample.
                x, err := br.Read(bps)
                if err != nil {
                        return unexpected(err)
                }
                sample := signExtend(x, bps)
                subframe.Samples = append(subframe.Samples, sample)
        }

        // Decode subframe residuals.
        err := subframe.decodeResidual(br)
        if err != nil {
                return err
        }

        // Predict the audio samples of the subframe using a polynomial with
        // predefined coefficients of a given order. Correct signal errors using the
        // decoded residuals.
        return subframe.decodeLPC(fixedCoeffs[subframe.Order], 0)
}

// decodeFIR decodes the linear prediction coded samples of the subframe, using
// polynomial coefficients stored in the stream.
//
// ref: https://www.xiph.org/flac/format.html#subframe_lpc
func (subframe *Subframe) decodeFIR(br *bits.Reader, bps uint) error {
        // Parse unencoded warm-up samples.
        for i := 0; i < subframe.Order; i++ {
                // (bits-per-sample) bits: Unencoded warm-up sample.
                x, err := br.Read(bps)
                if err != nil {
                        return unexpected(err)
                }
                sample := signExtend(x, bps)
                subframe.Samples = append(subframe.Samples, sample)
        }

        // 4 bits: (coefficients' precision in bits) - 1.
        x, err := br.Read(4)
        if err != nil {
                return unexpected(err)
        }
        if x == 0xF {
                return errors.New("frame.Subframe.decodeFIR: invalid coefficient precision bit pattern (1111)")
        }
        prec := uint(x) + 1

        // 5 bits: predictor coefficient shift needed in bits.
        x, err = br.Read(5)
        if err != nil {
                return unexpected(err)
        }
        shift := signExtend(x, 5)

        // Parse coefficients.
        coeffs := make([]int32, subframe.Order)
        for i := range coeffs {
                // (prec) bits: Predictor coefficient.
                x, err = br.Read(prec)
                if err != nil {
                        return unexpected(err)
                }
                coeffs[i] = signExtend(x, prec)
        }

        // Decode subframe residuals.
        if err = subframe.decodeResidual(br); err != nil {
                return err
        }

        // Predict the audio samples of the subframe using a polynomial with
        // predefined coefficients of a given order. Correct signal errors using the
        // decoded residuals.
        return subframe.decodeLPC(coeffs, shift)
}

// decodeResidual decodes the encoded residuals (prediction method error
// signals) of the subframe.
//
// ref: https://www.xiph.org/flac/format.html#residual
func (subframe *Subframe) decodeResidual(br *bits.Reader) error {
        // 2 bits: Residual coding method.
        x, err := br.Read(2)
        if err != nil {
                return unexpected(err)
        }
        // The 2 bits are used to specify the residual coding method as follows:
        //    00: Rice coding with a 4-bit Rice parameter.
        //    01: Rice coding with a 5-bit Rice parameter.
        //    10: reserved.
        //    11: reserved.
        switch x {
        case 0x0:
                return subframe.decodeRicePart(br, 4)
        case 0x1:
                return subframe.decodeRicePart(br, 5)
        default:
                return fmt.Errorf("frame.Subframe.decodeResidual: reserved residual coding method bit pattern (%02b)", x)
        }
}

// decodeRicePart decodes a Rice partition of encoded residuals from the
// subframe, using a Rice parameter of the specified size in bits.
//
// ref: https://www.xiph.org/flac/format.html#partitioned_rice
// ref: https://www.xiph.org/flac/format.html#partitioned_rice2
func (subframe *Subframe) decodeRicePart(br *bits.Reader, paramSize uint) error {
        // 4 bits: Partition order.
        x, err := br.Read(4)
        if err != nil {
                return unexpected(err)
        }
        partOrder := x

        // Parse Rice partitions; in total 2^partOrder partitions.
        //
        // ref: https://www.xiph.org/flac/format.html#rice_partition
        // ref: https://www.xiph.org/flac/format.html#rice2_partition
        nparts := 1 << partOrder
        for i := 0; i < nparts; i++ {
                // (4 or 5) bits: Rice parameter.
                x, err = br.Read(paramSize)
                if err != nil {
                        return unexpected(err)
                }
                param := uint(x)

                // Determine the number of Rice encoded samples in the partition.
                var nsamples int
                if partOrder == 0 {
                        nsamples = subframe.NSamples - subframe.Order
                } else if i != 0 {
                        nsamples = subframe.NSamples / nparts
                } else {
                        nsamples = subframe.NSamples/nparts - subframe.Order
                }

                if paramSize == 4 && param == 0xF || paramSize == 5 && param == 0x1F {
                        // 1111 or 11111: Escape code, meaning the partition is in unencoded
                        // binary form using n bits per sample; n follows as a 5-bit number.
                        x, err := br.Read(5)
                        if err != nil {
                                return unexpected(err)
                        }
                        n := uint(x)
                        for j := 0; j < nsamples; j++ {
                                sample, err := br.Read(n)
                                if err != nil {
                                        return unexpected(err)
                                }
                                // ref: https://datatracker.ietf.org/doc/draft-ietf-cellar-flac/
                                //
                                // From section 9.2.7.1.  Escaped partition:
                                //
                                // The residual samples themselves are stored signed two's
                                // complement.  For example, when a partition is escaped and each
                                // residual sample is stored with 3 bits, the number -1 is
                                // represented as 0b111.
                                subframe.Samples = append(subframe.Samples, int32(bits.IntN(sample, n)))
                        }
                        continue
                }

                // Decode the Rice encoded residuals of the partition.
                for j := 0; j < nsamples; j++ {
                        if err = subframe.decodeRiceResidual(br, param); err != nil {
                                return err
                        }
                }
        }

        return nil
}

// decodeRiceResidual decodes a Rice encoded residual (error signal).
func (subframe *Subframe) decodeRiceResidual(br *bits.Reader, k uint) error {
        // Read unary encoded most significant bits.
        high, err := br.ReadUnary()
        if err != nil {
                return unexpected(err)
        }

        // Read binary encoded least significant bits.
        low, err := br.Read(k)
        if err != nil {
                return unexpected(err)
        }
        folded := uint32(high<<k | low)

        // ZigZag decode.
        residual := bits.ZigZag(folded)
        subframe.Samples = append(subframe.Samples, residual)

        return nil
}

// decodeLPC decodes linear prediction coded audio samples, using the
// coefficients of a given polynomial, a couple of unencoded warm-up samples,
// and the signal errors of the prediction as specified by the residuals.
func (subframe *Subframe) decodeLPC(coeffs []int32, shift int32) error {
        if len(coeffs) != subframe.Order {
                return fmt.Errorf("frame.Subframe.decodeLPC: prediction order (%d) differs from number of coefficients (%d)", subframe.Order, len(coeffs))
        }
        if shift < 0 {
                return fmt.Errorf("frame.Subframe.decodeLPC: invalid negative shift")
        }
        if subframe.NSamples != len(subframe.Samples) {
                return fmt.Errorf("frame.Subframe.decodeLPC: subframe sample count mismatch; expected %d, got %d", subframe.NSamples, len(subframe.Samples))
        }
        for i := subframe.Order; i < subframe.NSamples; i++ {
                var sample int64
                for j, c := range coeffs {
                        sample += int64(c) * int64(subframe.Samples[i-j-1])
                }
                subframe.Samples[i] += int32(sample >> uint(shift))
        }
        return nil
}

1	package frame
2
3	import (
4	"errors"
5	"fmt"
6	"github.com/mewkiz/flac/internal/bits"
7	)
8
9	// A Subframe contains the encoded audio samples from one channel of an audio
10	// block (a part of the audio stream).
11	//
12	// ref: https://www.xiph.org/flac/format.html#subframe
13	type Subframe struct {
14	// Subframe header.
15	SubHeader
16	// Unencoded audio samples. Samples is initially nil, and gets populated by a
17	// call to Frame.Parse.
18	//
19	// Samples is used by decodeFixed and decodeFIR to temporarily store
20	// residuals. Before returning they call decodeLPC which decodes the audio
21	// samples.
22	Samples []int32
23	// Number of audio samples in the subframe.
24	NSamples int
25	}
26
27	// parseSubframe reads and parses the header, and the audio samples of a
28	// subframe.
29	func (frame Frame) parseSubframe(br bits.Reader, bps uint) (subframe *Subframe, err error) {	78,172✔
30	// Parse subframe header.	78,172✔
31	subframe = new(Subframe)	78,172✔
32	if err = subframe.parseHeader(br); err != nil {	78,172✔
33	return subframe, err	×
34	}	×
35	// Adjust bps of subframe for wasted bits-per-sample.
36	bps -= subframe.Wasted	78,172✔
37		78,172✔
38	// Decode subframe audio samples.	78,172✔
39	subframe.NSamples = int(frame.BlockSize)	78,172✔
40	subframe.Samples = make([]int32, 0, subframe.NSamples)	78,172✔
41	switch subframe.Pred {	78,172✔
42	case PredConstant:	2,560✔
43	err = subframe.decodeConstant(br, bps)	2,560✔
44	case PredVerbatim:	110✔
45	err = subframe.decodeVerbatim(br, bps)	110✔
46	case PredFixed:	39,742✔
47	err = subframe.decodeFixed(br, bps)	39,742✔
48	case PredFIR:	35,760✔
49	err = subframe.decodeFIR(br, bps)	35,760✔
50	}
51
52	// Left shift to accout for wasted bits-per-sample.
53	for i, sample := range subframe.Samples {	105,201,771✔
54	subframe.Samples[i] = sample << subframe.Wasted	105,123,599✔
55	}	105,123,599✔
56	return subframe, err	78,172✔
57	}
58
59	// A SubHeader specifies the prediction method and order of a subframe.
60	//
61	// ref: https://www.xiph.org/flac/format.html#subframe_header
62	type SubHeader struct {
63	// Specifies the prediction method used to encode the audio sample of the
64	// subframe.
65	Pred Pred
66	// Prediction order used by fixed and FIR linear prediction decoding.
67	Order int
68	// Wasted bits-per-sample.
69	Wasted uint
70	}
71
72	// parseHeader reads and parses the header of a subframe.
73	func (subframe Subframe) parseHeader(br bits.Reader) error {	78,172✔
74	// 1 bit: zero-padding.	78,172✔
75	x, err := br.Read(1)	78,172✔
76	if err != nil {	78,172✔
77	return unexpected(err)	×
78	}	×
79	if x != 0 {	78,172✔
80	return errors.New("frame.Subframe.parseHeader: non-zero padding")	×
81	}	×
82
83	// 6 bits: Pred.
84	x, err = br.Read(6)	78,172✔
85	if err != nil {	78,172✔
86	return unexpected(err)	×
87	}	×
88	// The 6 bits are used to specify the prediction method and order as follows:
89	// 000000: Constant prediction method.
90	// 000001: Verbatim prediction method.
91	// 00001x: reserved.
92	// 0001xx: reserved.
93	// 001xxx:
94	// if (xxx <= 4)
95	// Fixed prediction method; xxx=order
96	// else
97	// reserved.
98	// 01xxxx: reserved.
99	// 1xxxxx: FIR prediction method; xxxxx=order-1
100	switch {	78,172✔
101	case x < 1:	2,560✔
102	// 000000: Constant prediction method.	2,560✔
103	subframe.Pred = PredConstant	2,560✔
104	case x < 2:	110✔
105	// 000001: Verbatim prediction method.	110✔
106	subframe.Pred = PredVerbatim	110✔
107	case x < 8:	×
108	// 00001x: reserved.	×
109	// 0001xx: reserved.	×
110	return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)	×
111	case x < 16:	39,742✔
112	// 001xxx:	39,742✔
113	// if (xxx <= 4)	39,742✔
114	// Fixed prediction method; xxx=order	39,742✔
115	// else	39,742✔
116	// reserved.	39,742✔
117	order := int(x & 0x07)	39,742✔
118	if order > 4 {	39,742✔
119	return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)	×
120	}	×
121	subframe.Pred = PredFixed	39,742✔
122	subframe.Order = order	39,742✔
123	case x < 32:	×
124	// 01xxxx: reserved.	×
125	return fmt.Errorf("frame.Subframe.parseHeader: reserved prediction method bit pattern (%06b)", x)	×
126	default:	35,760✔
127	// 1xxxxx: FIR prediction method; xxxxx=order-1	35,760✔
128	subframe.Pred = PredFIR	35,760✔
129	subframe.Order = int(x&0x1F) + 1	35,760✔
130	}
131
132	// 1 bit: hasWastedBits.
133	x, err = br.Read(1)	78,172✔
134	if err != nil {	78,172✔
135	return unexpected(err)	×
136	}	×
137	if x != 0 {	78,952✔
138	// k wasted bits-per-sample in source subblock, k-1 follows, unary coded;	780✔
139	// e.g. k=3 => 001 follows, k=7 => 0000001 follows.	780✔
140	x, err = br.ReadUnary()	780✔
141	if err != nil {	780✔
142	return unexpected(err)	×
143	}	×
144	subframe.Wasted = uint(x) + 1	780✔
145	}
146
147	return nil	78,172✔
148	}
149
150	// Pred specifies the prediction method used to encode the audio samples of a
151	// subframe.
152	type Pred uint8
153
154	// Prediction methods.
155	const (
156	// PredConstant specifies that the subframe contains a constant sound. The
157	// audio samples are encoded using run-length encoding. Since every audio
158	// sample has the same constant value, a single unencoded audio sample is
159	// stored in practice. It is replicated a number of times, as specified by
160	// BlockSize in the frame header.
161	PredConstant Pred = iota
162	// PredVerbatim specifies that the subframe contains unencoded audio samples.
163	// Random sound is often stored verbatim, since no prediction method can
164	// compress it sufficiently.
165	PredVerbatim
166	// PredFixed specifies that the subframe contains linear prediction coded
167	// audio samples. The coefficients of the prediction polynomial are selected
168	// from a fixed set, and can represent 0th through fourth-order polynomials.
169	// The prediction order (0 through 4) is stored within the subframe along
170	// with the same number of unencoded warm-up samples, which are used to kick
171	// start the prediction polynomial. The remainder of the subframe stores
172	// encoded residuals (signal errors) which specify the difference between the
173	// predicted and the original audio samples.
174	PredFixed
175	// PredFIR specifies that the subframe contains linear prediction coded audio
176	// samples. The coefficients of the prediction polynomial are stored in the
177	// subframe, and can represent 0th through 32nd-order polynomials. The
178	// prediction order (0 through 32) is stored within the subframe along with
179	// the same number of unencoded warm-up samples, which are used to kick start
180	// the prediction polynomial. The remainder of the subframe stores encoded
181	// residuals (signal errors) which specify the difference between the
182	// predicted and the original audio samples.
183	PredFIR
184	)
185
186	// signExtend interprets x as a signed n-bit integer value and sign extends it
187	// to 32 bits.
188	func signExtend(x uint64, n uint) int32 {	1,081,936✔
189	// x is signed if its most significant bit is set.	1,081,936✔
190	if x&(1<<(n-1)) != 0 {	1,581,577✔
191	// Sign extend x.	499,641✔
192	return int32(x \| ^uint64(0)<<n)	499,641✔
193	}	499,641✔
194	return int32(x)	582,295✔
195	}
196
197	// decodeConstant reads an unencoded audio sample of the subframe. Each sample
198	// of the subframe has this constant value. The constant encoding can be thought
199	// of as run-length encoding.
200	//
201	// ref: https://www.xiph.org/flac/format.html#subframe_constant
202	func (subframe Subframe) decodeConstant(br bits.Reader, bps uint) error {	2,560✔
203	// (bits-per-sample) bits: Unencoded constant value of the subblock.	2,560✔
204	x, err := br.Read(bps)	2,560✔
205	if err != nil {	2,560✔
206	return unexpected(err)	×
207	}	×
208
209	// Each sample of the subframe has the same constant value.
210	sample := signExtend(x, bps)	2,560✔
211	for i := 0; i < subframe.NSamples; i++ {	10,367,616✔
212	subframe.Samples = append(subframe.Samples, sample)	10,365,056✔
213	}	10,365,056✔
214
215	return nil	2,560✔
216	}
217
218	// decodeVerbatim reads the unencoded audio samples of the subframe.
219	//
220	// ref: https://www.xiph.org/flac/format.html#subframe_verbatim
221	func (subframe Subframe) decodeVerbatim(br bits.Reader, bps uint) error {	110✔
222	// Parse the unencoded audio samples of the subframe.	110✔
223	for i := 0; i < subframe.NSamples; i++ {	440,620✔
224	// (bits-per-sample) bits: Unencoded constant value of the subblock.	440,510✔
225	x, err := br.Read(bps)	440,510✔
226	if err != nil {	440,510✔
227	return unexpected(err)	×
228	}	×
229	sample := signExtend(x, bps)	440,510✔
230	subframe.Samples = append(subframe.Samples, sample)	440,510✔
231	}
232	return nil	110✔
233	}
234
235	// fixedCoeffs maps from prediction order to the LPC coefficients used in fixed
236	// encoding.
237	//
238	// x_0[n] = 0
239	// x_1[n] = x[n-1]
240	// x_2[n] = 2*x[n-1] - x[n-2]
241	// x_3[n] = 3x[n-1] - 3x[n-2] + x[n-3]
242	// x_4[n] = 4x[n-1] - 6x[n-2] + 4*x[n-3] - x[n-4]
243	var fixedCoeffs = [...][]int32{
244	// ref: Section 2.2 of http://www.hpl.hp.com/techreports/1999/HPL-1999-144.pdf
245	1: {1},
246	2: {2, -1},
247	3: {3, -3, 1},
248	// ref: Data Compression: The Complete Reference (7.10.1)
249	4: {4, -6, 4, -1},
250	}
251
252	// decodeFixed decodes the linear prediction coded samples of the subframe,
253	// using a fixed set of predefined polynomial coefficients.
254	//
255	// ref: https://www.xiph.org/flac/format.html#subframe_fixed
256	func (subframe Subframe) decodeFixed(br bits.Reader, bps uint) error {	39,742✔
257	// Parse unencoded warm-up samples.	39,742✔
258	for i := 0; i < subframe.Order; i++ {	135,680✔
259	// (bits-per-sample) bits: Unencoded warm-up sample.	95,938✔
260	x, err := br.Read(bps)	95,938✔
261	if err != nil {	95,938✔
262	return unexpected(err)	×
263	}	×
264	sample := signExtend(x, bps)	95,938✔
265	subframe.Samples = append(subframe.Samples, sample)	95,938✔
266	}
267
268	// Decode subframe residuals.
269	err := subframe.decodeResidual(br)	39,742✔
270	if err != nil {	39,742✔
271	return err	×
272	}	×
273
274	// Predict the audio samples of the subframe using a polynomial with
275	// predefined coefficients of a given order. Correct signal errors using the
276	// decoded residuals.
277	return subframe.decodeLPC(fixedCoeffs[subframe.Order], 0)	39,742✔
278	}
279
280	// decodeFIR decodes the linear prediction coded samples of the subframe, using
281	// polynomial coefficients stored in the stream.
282	//
283	// ref: https://www.xiph.org/flac/format.html#subframe_lpc
284	func (subframe Subframe) decodeFIR(br bits.Reader, bps uint) error {	35,760✔
285	// Parse unencoded warm-up samples.	35,760✔
286	for i := 0; i < subframe.Order; i++ {	289,344✔
287	// (bits-per-sample) bits: Unencoded warm-up sample.	253,584✔
288	x, err := br.Read(bps)	253,584✔
289	if err != nil {	253,584✔
290	return unexpected(err)	×
291	}	×
292	sample := signExtend(x, bps)	253,584✔
293	subframe.Samples = append(subframe.Samples, sample)	253,584✔
294	}
295
296	// 4 bits: (coefficients' precision in bits) - 1.
297	x, err := br.Read(4)	35,760✔
298	if err != nil {	35,760✔
299	return unexpected(err)	×
300	}	×
301	if x == 0xF {	35,760✔
302	return errors.New("frame.Subframe.decodeFIR: invalid coefficient precision bit pattern (1111)")	×
303	}	×
304	prec := uint(x) + 1	35,760✔
305		35,760✔
306	// 5 bits: predictor coefficient shift needed in bits.	35,760✔
307	x, err = br.Read(5)	35,760✔
308	if err != nil {	35,760✔
309	return unexpected(err)	×
310	}	×
311	shift := signExtend(x, 5)	35,760✔
312		35,760✔
313	// Parse coefficients.	35,760✔
314	coeffs := make([]int32, subframe.Order)	35,760✔
315	for i := range coeffs {	289,344✔
316	// (prec) bits: Predictor coefficient.	253,584✔
317	x, err = br.Read(prec)	253,584✔
318	if err != nil {	253,584✔
319	return unexpected(err)	×
320	}	×
321	coeffs[i] = signExtend(x, prec)	253,584✔
322	}
323
324	// Decode subframe residuals.
325	if err = subframe.decodeResidual(br); err != nil {	35,760✔
326	return err	×
327	}	×
328
329	// Predict the audio samples of the subframe using a polynomial with
330	// predefined coefficients of a given order. Correct signal errors using the
331	// decoded residuals.
332	return subframe.decodeLPC(coeffs, shift)	35,760✔
333	}
334
335	// decodeResidual decodes the encoded residuals (prediction method error
336	// signals) of the subframe.
337	//
338	// ref: https://www.xiph.org/flac/format.html#residual
339	func (subframe Subframe) decodeResidual(br bits.Reader) error {	75,502✔
340	// 2 bits: Residual coding method.	75,502✔
341	x, err := br.Read(2)	75,502✔
342	if err != nil {	75,502✔
343	return unexpected(err)	×
344	}	×
345	// The 2 bits are used to specify the residual coding method as follows:
346	// 00: Rice coding with a 4-bit Rice parameter.
347	// 01: Rice coding with a 5-bit Rice parameter.
348	// 10: reserved.
349	// 11: reserved.
350	switch x {	75,502✔
351	case 0x0:	71,624✔
352	return subframe.decodeRicePart(br, 4)	71,624✔
353	case 0x1:	3,878✔
354	return subframe.decodeRicePart(br, 5)	3,878✔
355	default:	×
356	return fmt.Errorf("frame.Subframe.decodeResidual: reserved residual coding method bit pattern (%02b)", x)	×
357	}
358	}
359
360	// decodeRicePart decodes a Rice partition of encoded residuals from the
361	// subframe, using a Rice parameter of the specified size in bits.
362	//
363	// ref: https://www.xiph.org/flac/format.html#partitioned_rice
364	// ref: https://www.xiph.org/flac/format.html#partitioned_rice2
365	func (subframe Subframe) decodeRicePart(br bits.Reader, paramSize uint) error {	75,502✔
366	// 4 bits: Partition order.	75,502✔
367	x, err := br.Read(4)	75,502✔
368	if err != nil {	75,502✔
369	return unexpected(err)	×
370	}	×
371	partOrder := x	75,502✔
372		75,502✔
373	// Parse Rice partitions; in total 2^partOrder partitions.	75,502✔
374	//	75,502✔
375	// ref: https://www.xiph.org/flac/format.html#rice_partition	75,502✔
376	// ref: https://www.xiph.org/flac/format.html#rice2_partition	75,502✔
377	nparts := 1 << partOrder	75,502✔
378	for i := 0; i < nparts; i++ {	401,453✔
379	// (4 or 5) bits: Rice parameter.	325,951✔
380	x, err = br.Read(paramSize)	325,951✔
381	if err != nil {	325,951✔
382	return unexpected(err)	×
383	}	×
384	param := uint(x)	325,951✔
385		325,951✔
386	// Determine the number of Rice encoded samples in the partition.	325,951✔
387	var nsamples int	325,951✔
388	if partOrder == 0 {	389,838✔
389	nsamples = subframe.NSamples - subframe.Order	63,887✔
390	} else if i != 0 {	576,400✔
391	nsamples = subframe.NSamples / nparts	250,449✔
392	} else {	262,064✔
393	nsamples = subframe.NSamples/nparts - subframe.Order	11,615✔
394	}	11,615✔
395
396	if paramSize == 4 && param == 0xF \|\| paramSize == 5 && param == 0x1F {	328,656✔
397	// 1111 or 11111: Escape code, meaning the partition is in unencoded	2,705✔
398	// binary form using n bits per sample; n follows as a 5-bit number.	2,705✔
399	x, err := br.Read(5)	2,705✔
400	if err != nil {	2,705✔
401	return unexpected(err)	×
402	}	×
403	n := uint(x)	2,705✔
404	for j := 0; j < nsamples; j++ {	56,693✔
405	sample, err := br.Read(n)	53,988✔
406	if err != nil {	53,988✔
407	return unexpected(err)	×
408	}	×
409	// ref: https://datatracker.ietf.org/doc/draft-ietf-cellar-flac/
410	//
411	// From section 9.2.7.1. Escaped partition:
412	//
413	// The residual samples themselves are stored signed two's
414	// complement. For example, when a partition is escaped and each
415	// residual sample is stored with 3 bits, the number -1 is
416	// represented as 0b111.
417	subframe.Samples = append(subframe.Samples, int32(bits.IntN(sample, n)))	53,988✔
418	}
419	continue	2,705✔
420	}
421
422	// Decode the Rice encoded residuals of the partition.
423	for j := 0; j < nsamples; j++ {	94,237,769✔
424	if err = subframe.decodeRiceResidual(br, param); err != nil {	93,914,523✔
425	return err	×
426	}	×
427	}
428	}
429
430	return nil	75,502✔
431	}
432
433	// decodeRiceResidual decodes a Rice encoded residual (error signal).
434	func (subframe Subframe) decodeRiceResidual(br bits.Reader, k uint) error {	93,914,523✔
435	// Read unary encoded most significant bits.	93,914,523✔
436	high, err := br.ReadUnary()	93,914,523✔
437	if err != nil {	93,914,523✔
438	return unexpected(err)	×
439	}	×
440
441	// Read binary encoded least significant bits.
442	low, err := br.Read(k)	93,914,523✔
443	if err != nil {	93,914,523✔
444	return unexpected(err)	×
445	}	×
446	folded := uint32(high<<k \| low)	93,914,523✔
447		93,914,523✔
448	// ZigZag decode.	93,914,523✔
449	residual := bits.ZigZag(folded)	93,914,523✔
450	subframe.Samples = append(subframe.Samples, residual)	93,914,523✔
451		93,914,523✔
452	return nil	93,914,523✔
453	}
454
455	// decodeLPC decodes linear prediction coded audio samples, using the
456	// coefficients of a given polynomial, a couple of unencoded warm-up samples,
457	// and the signal errors of the prediction as specified by the residuals.
458	func (subframe *Subframe) decodeLPC(coeffs []int32, shift int32) error {	75,502✔
459	if len(coeffs) != subframe.Order {	75,502✔
460	return fmt.Errorf("frame.Subframe.decodeLPC: prediction order (%d) differs from number of coefficients (%d)", subframe.Order, len(coeffs))	×
461	}	×
462	if shift < 0 {	75,502✔
463	return fmt.Errorf("frame.Subframe.decodeLPC: invalid negative shift")	×
464	}	×
465	if subframe.NSamples != len(subframe.Samples) {	75,502✔
466	return fmt.Errorf("frame.Subframe.decodeLPC: subframe sample count mismatch; expected %d, got %d", subframe.NSamples, len(subframe.Samples))	×
467	}	×
468	for i := subframe.Order; i < subframe.NSamples; i++ {	94,044,013✔
469	var sample int64	93,968,511✔
470	for j, c := range coeffs {	1,512,646,263✔
471	sample += int64(c) * int64(subframe.Samples[i-j-1])	1,418,677,752✔
472	}	1,418,677,752✔
473	subframe.Samples[i] += int32(sample >> uint(shift))	93,968,511✔
474	}
475	return nil	75,502✔
476	}

mewkiz / flac / 6645815568

Source File Press 'n' to go to next uncovered line, 'b' for previous

Source File
Press 'n' to go to next uncovered line, 'b' for previous