16222310284

Committed 11 Jul 2025 02:20PM UTC coverage: 62.333% (+0.2%) from 62.179%

Build # 16222310284

Build Type

push

github

Committed by

mewmew

Commit Message

go fmt

Run Details

2 of 2 new or added lines in 1 file covered. (100.0%)

8 existing lines in 1 file now uncovered.

1774 of 2846 relevant lines covered (62.33%)

3774476.96 hits per line

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

45.9

/encode.go

package flac

import (
        "crypto/md5"
        "hash"
        "io"

        "github.com/icza/bitio"
        "github.com/mewkiz/flac/meta"
        "github.com/mewkiz/pkg/errutil"
)

// An Encoder represents a FLAC encoder.
type Encoder struct {
        // FLAC stream of encoder.
        *Stream
        // Underlying io.Writer or io.WriteCloser to the output stream.
        w io.Writer
        // Minimum and maximum block size (in samples) of frames written by encoder.
        blockSizeMin, blockSizeMax uint16
        // Minimum and maximum frame size (in bytes) of frames written by encoder.
        frameSizeMin, frameSizeMax uint32
        // MD5 running hash of unencoded audio samples.
        md5sum hash.Hash
        // Total number of samples (per channel) written by encoder.
        nsamples uint64
        // Current frame number if block size is fixed, and the first sample number
        // of the current frame otherwise.
        curNum uint64
        // AnalysisEnabled indicates whether analysis is enabled for the encoder.
        AnalysisEnabled bool
}

// NewEncoder returns a new FLAC encoder for the given metadata StreamInfo block
// and optional metadata blocks.
//
// By default prediction analysis is enabled. For more information, see
// Encoder.EnablePredictionAnalysis.
func NewEncoder(w io.Writer, info *meta.StreamInfo, blocks ...*meta.Block) (*Encoder, error) {
        // Store FLAC signature.
        enc := &Encoder{
                Stream: &Stream{
                        Info:   info,
                        Blocks: blocks,
                },
                w:               w,
                md5sum:          md5.New(),
                AnalysisEnabled: true, // enable prediction analysis by default.
        }

        bw := bitio.NewWriter(w)
        if _, err := bw.Write(flacSignature); err != nil {
                return nil, errutil.Err(err)
        }
        // Encode metadata blocks.
        // TODO: consider using bufio.NewWriter.
        if err := encodeStreamInfo(bw, info, len(blocks) == 0); err != nil {
                return nil, errutil.Err(err)
        }
        for i, block := range blocks {
                if err := encodeBlock(bw, block, i == len(blocks)-1); err != nil {
                        return nil, errutil.Err(err)
                }
        }
        // Flush pending writes of metadata blocks.
        if _, err := bw.Align(); err != nil {
                return nil, errutil.Err(err)
        }
        // Return encoder to be used for encoding audio samples.
        return enc, nil
}

// Close closes the underlying io.Writer of the encoder and flushes any pending
// writes. If the io.Writer implements io.Seeker, the encoder will update the
// StreamInfo metadata block with the MD5 checksum of the unencoded audio
// samples, the number of samples, and the minimum and maximum frame size and
// block size.
func (enc *Encoder) Close() error {
        // TODO: check if bit writer should be flushed before seeking on enc.w.
        // Update StreamInfo metadata block.
        if ws, ok := enc.w.(io.WriteSeeker); ok {
                if _, err := ws.Seek(int64(len(flacSignature)), io.SeekStart); err != nil {
                        return errutil.Err(err)
                }
                // Update minimum and maximum block size (in samples) of FLAC stream.
                enc.Info.BlockSizeMin = enc.blockSizeMin
                enc.Info.BlockSizeMax = enc.blockSizeMax
                // Update minimum and maximum frame size (in bytes) of FLAC stream.
                enc.Info.FrameSizeMin = enc.frameSizeMin
                enc.Info.FrameSizeMax = enc.frameSizeMax
                // Update total number of samples (per channel) of FLAC stream.
                enc.Info.NSamples = enc.nsamples
                // Update MD5 checksum of the unencoded audio samples.
                sum := enc.md5sum.Sum(nil)
                for i := range sum {
                        enc.Info.MD5sum[i] = sum[i]
                }
                bw := bitio.NewWriter(ws)
                // Write updated StreamInfo metadata block to output stream.
                if err := encodeStreamInfo(bw, enc.Info, len(enc.Blocks) == 0); err != nil {
                        return errutil.Err(err)
                }
                if _, err := bw.Align(); err != nil {
                        return errutil.Err(err)
                }
        }
        if closer, ok := enc.w.(io.Closer); ok {
                return closer.Close()
        }
        return nil
}

// EnablePredictionAnalysis specifies whether to enable analysis for the
// encoder. When analysis is enabled, subframes that are currently marked as
// PredVerbatim will be analyzed to use the best prediction method
// (constant, fixed or verbatim) based on size.
func (enc *Encoder) EnablePredictionAnalysis(enable bool) {
        enc.AnalysisEnabled = enable
}

1	package flac
2
3	import (
4	"crypto/md5"
5	"hash"
6	"io"
7
8	"github.com/icza/bitio"
9	"github.com/mewkiz/flac/meta"
10	"github.com/mewkiz/pkg/errutil"
11	)
12
13	// An Encoder represents a FLAC encoder.
14	type Encoder struct {
15	// FLAC stream of encoder.
16	*Stream
17	// Underlying io.Writer or io.WriteCloser to the output stream.
18	w io.Writer
19	// Minimum and maximum block size (in samples) of frames written by encoder.
20	blockSizeMin, blockSizeMax uint16
21	// Minimum and maximum frame size (in bytes) of frames written by encoder.
22	frameSizeMin, frameSizeMax uint32
23	// MD5 running hash of unencoded audio samples.
24	md5sum hash.Hash
25	// Total number of samples (per channel) written by encoder.
26	nsamples uint64
27	// Current frame number if block size is fixed, and the first sample number
28	// of the current frame otherwise.
29	curNum uint64
30	// AnalysisEnabled indicates whether analysis is enabled for the encoder.
31	AnalysisEnabled bool
32	}
33
34	// NewEncoder returns a new FLAC encoder for the given metadata StreamInfo block
35	// and optional metadata blocks.
36	//
37	// By default prediction analysis is enabled. For more information, see
38	// Encoder.EnablePredictionAnalysis.
39	func NewEncoder(w io.Writer, info meta.StreamInfo, blocks ...meta.Block) (*Encoder, error) {	82✔
40	// Store FLAC signature.	82✔
41	enc := &Encoder{	82✔
42	Stream: &Stream{	82✔
43	Info: info,	82✔
44	Blocks: blocks,	82✔
45	},	82✔
46	w: w,	82✔
47	md5sum: md5.New(),	82✔
48	AnalysisEnabled: true, // enable prediction analysis by default.	82✔
49	}	82✔
50		82✔
51	bw := bitio.NewWriter(w)	82✔
52	if _, err := bw.Write(flacSignature); err != nil {	82✔
UNCOV 53	return nil, errutil.Err(err)	×
54	}	×
55	// Encode metadata blocks.
56	// TODO: consider using bufio.NewWriter.
57	if err := encodeStreamInfo(bw, info, len(blocks) == 0); err != nil {	82✔
58	return nil, errutil.Err(err)	×
59	}	×
60	for i, block := range blocks {	274✔
61	if err := encodeBlock(bw, block, i == len(blocks)-1); err != nil {	192✔
UNCOV 62	return nil, errutil.Err(err)	×
63	}	×
64	}
65	// Flush pending writes of metadata blocks.
66	if _, err := bw.Align(); err != nil {	82✔
UNCOV 67	return nil, errutil.Err(err)	×
UNCOV 68	}	×
69	// Return encoder to be used for encoding audio samples.
70	return enc, nil	82✔
71	}
72
73	// Close closes the underlying io.Writer of the encoder and flushes any pending
74	// writes. If the io.Writer implements io.Seeker, the encoder will update the
75	// StreamInfo metadata block with the MD5 checksum of the unencoded audio
76	// samples, the number of samples, and the minimum and maximum frame size and
77	// block size.
78	func (enc *Encoder) Close() error {	82✔
79	// TODO: check if bit writer should be flushed before seeking on enc.w.	82✔
80	// Update StreamInfo metadata block.	82✔
81	if ws, ok := enc.w.(io.WriteSeeker); ok {	82✔
82	if _, err := ws.Seek(int64(len(flacSignature)), io.SeekStart); err != nil {	×
83	return errutil.Err(err)	×
84	}	×
85	// Update minimum and maximum block size (in samples) of FLAC stream.
86	enc.Info.BlockSizeMin = enc.blockSizeMin	×
87	enc.Info.BlockSizeMax = enc.blockSizeMax	×
88	// Update minimum and maximum frame size (in bytes) of FLAC stream.	×
89	enc.Info.FrameSizeMin = enc.frameSizeMin	×
90	enc.Info.FrameSizeMax = enc.frameSizeMax	×
91	// Update total number of samples (per channel) of FLAC stream.	×
92	enc.Info.NSamples = enc.nsamples	×
93	// Update MD5 checksum of the unencoded audio samples.	×
94	sum := enc.md5sum.Sum(nil)	×
95	for i := range sum {	×
96	enc.Info.MD5sum[i] = sum[i]	×
97	}	×
98	bw := bitio.NewWriter(ws)	×
99	// Write updated StreamInfo metadata block to output stream.	×
100	if err := encodeStreamInfo(bw, enc.Info, len(enc.Blocks) == 0); err != nil {	×
101	return errutil.Err(err)	×
UNCOV 102	}	×
UNCOV 103	if _, err := bw.Align(); err != nil {	×
104	return errutil.Err(err)	×
105	}	×
106	}
107	if closer, ok := enc.w.(io.Closer); ok {	82✔
UNCOV 108	return closer.Close()	×
UNCOV 109	}	×
110	return nil	82✔
111	}
112
113	// EnablePredictionAnalysis specifies whether to enable analysis for the
114	// encoder. When analysis is enabled, subframes that are currently marked as
115	// PredVerbatim will be analyzed to use the best prediction method
116	// (constant, fixed or verbatim) based on size.
117	func (enc *Encoder) EnablePredictionAnalysis(enable bool) {	81✔
118	enc.AnalysisEnabled = enable	81✔
119	}	81✔

mewkiz / flac / 16222310284

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