From 7d8e720092e86b73845ff5064893bd96d1b5372d Mon Sep 17 00:00:00 2001 From: Quentin Renard Date: Tue, 31 Dec 2019 16:11:12 +0100 Subject: [PATCH] Now using astikit instead of astitools --- astits/main.go | 23 +++++++------------ data.go | 6 ++--- data_eit.go | 6 ++--- data_eit_test.go | 11 ++++----- data_nit.go | 4 ++-- data_nit_test.go | 11 ++++----- data_pat.go | 4 ++-- data_pat_test.go | 11 ++++----- data_pes.go | 12 +++++----- data_pes_test.go | 51 ++++++++++++++++++++++++------------------ data_pmt.go | 4 ++-- data_pmt_test.go | 11 ++++----- data_psi.go | 18 +++++++-------- data_psi_test.go | 35 ++++++++++++++++------------- data_sdt.go | 8 +++---- data_sdt_test.go | 11 ++++----- data_test.go | 12 +++++----- data_tot.go | 4 ++-- data_tot_test.go | 11 ++++----- demuxer_test.go | 12 +++++----- descriptor.go | 52 +++++++++++++++++++++---------------------- descriptor_test.go | 11 ++++----- dvb.go | 8 +++---- dvb_test.go | 8 +++---- go.mod | 4 ++-- go.sum | 34 ++++------------------------ packet.go | 12 +++++----- packet_buffer.go | 5 ++--- packet_buffer_test.go | 11 ++++----- packet_test.go | 37 +++++++++++++++++------------- 30 files changed, 221 insertions(+), 226 deletions(-) diff --git a/astits/main.go b/astits/main.go index 8ae645e..8a4e12e 100644 --- a/astits/main.go +++ b/astits/main.go @@ -13,9 +13,8 @@ import ( "strings" "syscall" + "github.com/asticode/go-astikit" "github.com/asticode/go-astilog" - "github.com/asticode/go-astitools/flag" - "github.com/asticode/go-astitools/io" "github.com/asticode/go-astits" "github.com/pkg/errors" "github.com/pkg/profile" @@ -25,7 +24,7 @@ import ( var ( ctx, cancel = context.WithCancel(context.Background()) cpuProfiling = flag.Bool("cp", false, "if yes, cpu profiling is enabled") - dataTypes = astiflag.NewStringsMap() + dataTypes = astikit.NewFlagStrings() format = flag.String("f", "", "the format") inputPath = flag.String("i", "", "the input path") memoryProfiling = flag.Bool("mp", false, "if yes, memory profiling is enabled") @@ -38,7 +37,8 @@ func main() { flag.PrintDefaults() } flag.Var(dataTypes, "d", "the datatypes whitelist (all, pat, pmt, pes, eit, nit, sdt, tot)") - var s = astiflag.Subcommand() + cmd := astikit.FlagCmd() + astilog.SetHandyFlags() flag.Parse() astilog.FlagInit() @@ -68,8 +68,8 @@ func main() { // Create the demuxer var dmx = astits.New(ctx, r) - // Switch on subcommand - switch s { + // Switch on command + switch cmd { case "data": // Fetch data if err = data(dmx); err != nil { @@ -117,8 +117,8 @@ func handleSignals() { switch s { case syscall.SIGABRT, syscall.SIGINT, syscall.SIGQUIT, syscall.SIGTERM: cancel() + return } - return } }() } @@ -154,14 +154,7 @@ func buildReader(ctx context.Context) (r io.Reader, err error) { return } c.SetReadBuffer(4096) - - // Initialize linearizer - // It will read 4096 bytes at each iteration, and will store up to 2MB in its buffer - var l = astiio.NewLinearizer(ctx, c, 4096, 2048*1024) - - // Start linearizer - go l.Start() - r = l + r = c default: // Open file var f *os.File diff --git a/data.go b/data.go index f8859f9..23aaa51 100644 --- a/data.go +++ b/data.go @@ -1,8 +1,8 @@ package astits import ( + "github.com/asticode/go-astikit" "github.com/pkg/errors" - "github.com/asticode/go-astitools/byte" ) // PIDs @@ -52,8 +52,8 @@ func parseData(ps []*Packet, prs PacketsParser, pm programMap) (ds []*Data, err c += copy(payload[c:], p.Payload) } - // Create iterator - i := astibyte.NewIterator(payload) + // Create reader + i := astikit.NewBytesIterator(payload) // Parse PID pid := ps[0].Header.PID diff --git a/data_eit.go b/data_eit.go index 21fa892..48d9dcd 100644 --- a/data_eit.go +++ b/data_eit.go @@ -3,7 +3,7 @@ package astits import ( "time" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -29,7 +29,7 @@ type EITDataEvent struct { } // parseEITSection parses an EIT section -func parseEITSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtension uint16) (d *EITData, err error) { +func parseEITSection(i *astikit.BytesIterator, offsetSectionsEnd int, tableIDExtension uint16) (d *EITData, err error) { // Create data d = &EITData{ServiceID: tableIDExtension} @@ -108,7 +108,7 @@ func parseEITSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtensi e.HasFreeCSAMode = uint8(b&0x10) > 0 // We need to rewind since the current byte is used by the descriptor as well - i.FastForward(-1) + i.Skip(-1) // Descriptors if e.Descriptors, err = parseDescriptors(i); err != nil { diff --git a/data_eit_test.go b/data_eit_test.go index 0a76269..2b3f494 100644 --- a/data_eit_test.go +++ b/data_eit_test.go @@ -1,11 +1,11 @@ package astits import ( + "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" - "github.com/asticode/go-astitools/byte" ) var eit = &EITData{ @@ -25,7 +25,8 @@ var eit = &EITData{ } func eitBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(2)) // Transport stream ID w.Write(uint16(3)) // Original network ID w.Write(uint8(4)) // Segment last section number @@ -36,12 +37,12 @@ func eitBytes() []byte { w.Write("111") // Event #1 running status w.Write("1") // Event #1 free CA mode descriptorsBytes(w) // Event #1 descriptors - return w.Bytes() + return buf.Bytes() } func TestParseEITSection(t *testing.T) { var b = eitBytes() - d, err := parseEITSection(astibyte.NewIterator(b), len(b), uint16(1)) + d, err := parseEITSection(astikit.NewBytesIterator(b), len(b), uint16(1)) assert.Equal(t, d, eit) assert.NoError(t, err) } diff --git a/data_nit.go b/data_nit.go index ecff474..3d39d5f 100644 --- a/data_nit.go +++ b/data_nit.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -21,7 +21,7 @@ type NITDataTransportStream struct { } // parseNITSection parses a NIT section -func parseNITSection(i *astibyte.Iterator, tableIDExtension uint16) (d *NITData, err error) { +func parseNITSection(i *astikit.BytesIterator, tableIDExtension uint16) (d *NITData, err error) { // Create data d = &NITData{NetworkID: tableIDExtension} diff --git a/data_nit_test.go b/data_nit_test.go index d26cc4c..902f20d 100644 --- a/data_nit_test.go +++ b/data_nit_test.go @@ -1,10 +1,10 @@ package astits import ( + "bytes" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -19,7 +19,8 @@ var nit = &NITData{ } func nitBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("0000") // Reserved for future use descriptorsBytes(w) // Network descriptors w.Write("0000") // Reserved for future use @@ -28,12 +29,12 @@ func nitBytes() []byte { w.Write(uint16(3)) // Transport stream #1 original network id w.Write("0000") // Transport stream #1 reserved for future use descriptorsBytes(w) // Transport stream #1 descriptors - return w.Bytes() + return buf.Bytes() } func TestParseNITSection(t *testing.T) { var b = nitBytes() - d, err := parseNITSection(astibyte.NewIterator(b), uint16(1)) + d, err := parseNITSection(astikit.NewBytesIterator(b), uint16(1)) assert.Equal(t, d, nit) assert.NoError(t, err) } diff --git a/data_pat.go b/data_pat.go index eadacb5..a684a5b 100644 --- a/data_pat.go +++ b/data_pat.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -19,7 +19,7 @@ type PATProgram struct { } // parsePATSection parses a PAT section -func parsePATSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtension uint16) (d *PATData, err error) { +func parsePATSection(i *astikit.BytesIterator, offsetSectionsEnd int, tableIDExtension uint16) (d *PATData, err error) { // Create data d = &PATData{TransportStreamID: tableIDExtension} diff --git a/data_pat_test.go b/data_pat_test.go index c2e212c..21a5db4 100644 --- a/data_pat_test.go +++ b/data_pat_test.go @@ -1,11 +1,11 @@ package astits import ( + "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" - "github.com/asticode/go-astitools/byte" ) var pat = &PATData{ @@ -17,19 +17,20 @@ var pat = &PATData{ } func patBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(2)) // Program #1 number w.Write("111") // Program #1 reserved bits w.Write("0000000000011") // Program #1 map ID w.Write(uint16(4)) // Program #2 number w.Write("111") // Program #2 reserved bits w.Write("0000000000101") // Program #3 map ID - return w.Bytes() + return buf.Bytes() } func TestParsePATSection(t *testing.T) { var b = patBytes() - d, err := parsePATSection(astibyte.NewIterator(b), len(b), uint16(1)) + d, err := parsePATSection(astikit.NewBytesIterator(b), len(b), uint16(1)) assert.Equal(t, d, pat) assert.NoError(t, err) } diff --git a/data_pes.go b/data_pes.go index aa9236c..49f619f 100644 --- a/data_pes.go +++ b/data_pes.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -102,7 +102,7 @@ type DSMTrickMode struct { } // parsePESData parses a PES data -func parsePESData(i *astibyte.Iterator) (d *PESData, err error) { +func parsePESData(i *astikit.BytesIterator) (d *PESData, err error) { // Create data d = &PESData{} @@ -133,7 +133,7 @@ func hasPESOptionalHeader(streamID uint8) bool { } // parsePESData parses a PES header -func parsePESHeader(i *astibyte.Iterator) (h *PESHeader, dataStart, dataEnd int, err error) { +func parsePESHeader(i *astikit.BytesIterator) (h *PESHeader, dataStart, dataEnd int, err error) { // Create header h = &PESHeader{} @@ -177,7 +177,7 @@ func parsePESHeader(i *astibyte.Iterator) (h *PESHeader, dataStart, dataEnd int, } // parsePESOptionalHeader parses a PES optional header -func parsePESOptionalHeader(i *astibyte.Iterator) (h *PESOptionalHeader, dataStart int, err error) { +func parsePESOptionalHeader(i *astikit.BytesIterator) (h *PESOptionalHeader, dataStart int, err error) { // Create header h = &PESOptionalHeader{} @@ -390,7 +390,7 @@ func parseDSMTrickMode(i byte) (m *DSMTrickMode) { } // parsePTSOrDTS parses a PTS or a DTS -func parsePTSOrDTS(i *astibyte.Iterator) (cr *ClockReference, err error) { +func parsePTSOrDTS(i *astikit.BytesIterator) (cr *ClockReference, err error) { var bs []byte if bs, err = i.NextBytes(5); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") @@ -401,7 +401,7 @@ func parsePTSOrDTS(i *astibyte.Iterator) (cr *ClockReference, err error) { } // parseESCR parses an ESCR -func parseESCR(i *astibyte.Iterator) (cr *ClockReference, err error) { +func parseESCR(i *astikit.BytesIterator) (cr *ClockReference, err error) { var bs []byte if bs, err = i.NextBytes(6); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") diff --git a/data_pes_test.go b/data_pes_test.go index c5528c0..f241904 100644 --- a/data_pes_test.go +++ b/data_pes_test.go @@ -1,10 +1,10 @@ package astits import ( + "bytes" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -24,20 +24,22 @@ var dsmTrickModeSlow = &DSMTrickMode{ } func dsmTrickModeSlowBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("001") // Control w.Write("10101") // Repeat control - return w.Bytes() + return buf.Bytes() } func TestParseDSMTrickMode(t *testing.T) { // Fast - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("011") // Control w.Write("10") // Field ID w.Write("1") // Intra slice refresh w.Write("11") // Frequency truncation - assert.Equal(t, parseDSMTrickMode(w.Bytes()[0]), &DSMTrickMode{ + assert.Equal(t, parseDSMTrickMode(buf.Bytes()[0]), &DSMTrickMode{ FieldID: 2, FrequencyTruncation: 3, IntraSliceRefresh: 1, @@ -45,11 +47,11 @@ func TestParseDSMTrickMode(t *testing.T) { }) // Freeze - w.Reset() + buf.Reset() w.Write("010") // Control w.Write("10") // Field ID w.Write("000") // Reserved - assert.Equal(t, parseDSMTrickMode(w.Bytes()[0]), &DSMTrickMode{ + assert.Equal(t, parseDSMTrickMode(buf.Bytes()[0]), &DSMTrickMode{ FieldID: 2, TrickModeControl: TrickModeControlFreezeFrame, }) @@ -61,7 +63,8 @@ func TestParseDSMTrickMode(t *testing.T) { var ptsClockReference = &ClockReference{Base: 5726623061} func ptsBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("0010") // Flag w.Write("101") // 32...30 w.Write("0") // Dummy @@ -69,13 +72,14 @@ func ptsBytes() []byte { w.Write("0") // Dummy w.Write("101010101010101") // 14...0 w.Write("0") // Dummy - return w.Bytes() + return buf.Bytes() } var dtsClockReference = &ClockReference{Base: 5726623060} func dtsBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("0010") // Flag w.Write("101") // 32...30 w.Write("0") // Dummy @@ -83,17 +87,18 @@ func dtsBytes() []byte { w.Write("0") // Dummy w.Write("101010101010100") // 14...0 w.Write("0") // Dummy - return w.Bytes() + return buf.Bytes() } func TestParsePTSOrDTS(t *testing.T) { - v, err := parsePTSOrDTS(astibyte.NewIterator(ptsBytes())) + v, err := parsePTSOrDTS(astikit.NewBytesIterator(ptsBytes())) assert.Equal(t, v, ptsClockReference) assert.NoError(t, err) } func escrBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("00") // Dummy w.Write("011") // 32...30 w.Write("1") // Dummy @@ -103,11 +108,11 @@ func escrBytes() []byte { w.Write("1") // Dummy w.Write("000111010") // Ext w.Write("1") // Dummy - return w.Bytes() + return buf.Bytes() } func TestParseESCR(t *testing.T) { - v, err := parseESCR(astibyte.NewIterator(escrBytes())) + v, err := parseESCR(astikit.NewBytesIterator(escrBytes())) assert.Equal(t, v, clockReference) assert.NoError(t, err) } @@ -121,12 +126,13 @@ var pesWithoutHeader = &PESData{ } func pesWithoutHeaderBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("000000000000000000000001") // Prefix w.Write(uint8(StreamIDPaddingStream)) // Stream ID w.Write(uint16(4)) // Packet length w.Write([]byte("datastuff")) // Data - return w.Bytes() + return buf.Bytes() } var pesWithHeader = &PESData{ @@ -175,7 +181,8 @@ var pesWithHeader = &PESData{ } func pesWithHeaderBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("000000000000000000000001") // Prefix w.Write(uint8(1)) // Stream ID w.Write(uint16(69)) // Packet length @@ -214,17 +221,17 @@ func pesWithHeaderBytes() []byte { w.Write([]byte("extension2")) // Extension 2 data w.Write([]byte("stuff")) // Optional header stuffing bytes w.Write([]byte("datastuff")) // Data - return w.Bytes() + return buf.Bytes() } func TestParsePESData(t *testing.T) { // No optional header and specific packet length - d, err := parsePESData(astibyte.NewIterator(pesWithoutHeaderBytes())) + d, err := parsePESData(astikit.NewBytesIterator(pesWithoutHeaderBytes())) assert.NoError(t, err) assert.Equal(t, pesWithoutHeader, d) // Optional header and no specific header length - d, err = parsePESData(astibyte.NewIterator(pesWithHeaderBytes())) + d, err = parsePESData(astikit.NewBytesIterator(pesWithHeaderBytes())) assert.NoError(t, err) assert.Equal(t, pesWithHeader, d) } diff --git a/data_pmt.go b/data_pmt.go index fd94ad1..6f45e86 100644 --- a/data_pmt.go +++ b/data_pmt.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -30,7 +30,7 @@ type PMTElementaryStream struct { } // parsePMTSection parses a PMT section -func parsePMTSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtension uint16) (d *PMTData, err error) { +func parsePMTSection(i *astikit.BytesIterator, offsetSectionsEnd int, tableIDExtension uint16) (d *PMTData, err error) { // Create data d = &PMTData{ProgramNumber: tableIDExtension} diff --git a/data_pmt_test.go b/data_pmt_test.go index 6a85e37..15b8423 100644 --- a/data_pmt_test.go +++ b/data_pmt_test.go @@ -1,11 +1,11 @@ package astits import ( + "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" - "github.com/asticode/go-astitools/byte" ) var pmt = &PMTData{ @@ -20,7 +20,8 @@ var pmt = &PMTData{ } func pmtBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("111") // Reserved bits w.Write("1010101010101") // PCR PID w.Write("1111") // Reserved @@ -30,12 +31,12 @@ func pmtBytes() []byte { w.Write("0101010101010") // Stream #1 PID w.Write("1111") // Stream #1 reserved descriptorsBytes(w) // Stream #1 descriptors - return w.Bytes() + return buf.Bytes() } func TestParsePMTSection(t *testing.T) { var b = pmtBytes() - d, err := parsePMTSection(astibyte.NewIterator(b), len(b), uint16(1)) + d, err := parsePMTSection(astikit.NewBytesIterator(b), len(b), uint16(1)) assert.Equal(t, d, pmt) assert.NoError(t, err) } diff --git a/data_psi.go b/data_psi.go index c7beb8f..851a294 100644 --- a/data_psi.go +++ b/data_psi.go @@ -3,8 +3,8 @@ package astits import ( "fmt" + "github.com/asticode/go-astikit" "github.com/asticode/go-astilog" - astibyte "github.com/asticode/go-astitools/byte" "github.com/pkg/errors" ) @@ -75,7 +75,7 @@ type PSISectionSyntaxData struct { } // parsePSIData parses a PSI data -func parsePSIData(i *astibyte.Iterator) (d *PSIData, err error) { +func parsePSIData(i *astikit.BytesIterator) (d *PSIData, err error) { // Init data d = &PSIData{} @@ -90,7 +90,7 @@ func parsePSIData(i *astibyte.Iterator) (d *PSIData, err error) { d.PointerField = int(b) // Pointer filler bytes - i.FastForward(d.PointerField) + i.Skip(d.PointerField) // Parse sections var s *PSISection @@ -106,7 +106,7 @@ func parsePSIData(i *astibyte.Iterator) (d *PSIData, err error) { } // parsePSISection parses a PSI section -func parsePSISection(i *astibyte.Iterator) (s *PSISection, stop bool, err error) { +func parsePSISection(i *astikit.BytesIterator) (s *PSISection, stop bool, err error) { // Init section s = &PSISection{} @@ -171,7 +171,7 @@ func parsePSISection(i *astibyte.Iterator) (s *PSISection, stop bool, err error) } // parseCRC32 parses a CRC32 -func parseCRC32(i *astibyte.Iterator) (c uint32, err error) { +func parseCRC32(i *astikit.BytesIterator) (c uint32, err error) { var bs []byte if bs, err = i.NextBytes(4); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") @@ -204,7 +204,7 @@ func shouldStopPSIParsing(tableType string) bool { } // parsePSISectionHeader parses a PSI section header -func parsePSISectionHeader(i *astibyte.Iterator) (h *PSISectionHeader, offsetStart, offsetSectionsStart, offsetSectionsEnd, offsetEnd int, err error) { +func parsePSISectionHeader(i *astikit.BytesIterator) (h *PSISectionHeader, offsetStart, offsetSectionsStart, offsetSectionsEnd, offsetEnd int, err error) { // Init h = &PSISectionHeader{} offsetStart = i.Offset() @@ -300,7 +300,7 @@ func psiTableType(tableID int) string { } // parsePSISectionSyntax parses a PSI section syntax -func parsePSISectionSyntax(i *astibyte.Iterator, h *PSISectionHeader, offsetSectionsEnd int) (s *PSISectionSyntax, err error) { +func parsePSISectionSyntax(i *astikit.BytesIterator, h *PSISectionHeader, offsetSectionsEnd int) (s *PSISectionSyntax, err error) { // Init s = &PSISectionSyntax{} @@ -330,7 +330,7 @@ func hasPSISyntaxHeader(tableType string) bool { } // parsePSISectionSyntaxHeader parses a PSI section syntax header -func parsePSISectionSyntaxHeader(i *astibyte.Iterator) (h *PSISectionSyntaxHeader, err error) { +func parsePSISectionSyntaxHeader(i *astikit.BytesIterator) (h *PSISectionSyntaxHeader, err error) { // Init h = &PSISectionSyntaxHeader{} @@ -378,7 +378,7 @@ func parsePSISectionSyntaxHeader(i *astibyte.Iterator) (h *PSISectionSyntaxHeade } // parsePSISectionSyntaxData parses a PSI section data -func parsePSISectionSyntaxData(i *astibyte.Iterator, h *PSISectionHeader, sh *PSISectionSyntaxHeader, offsetSectionsEnd int) (d *PSISectionSyntaxData, err error) { +func parsePSISectionSyntaxData(i *astikit.BytesIterator, h *PSISectionHeader, sh *PSISectionSyntaxHeader, offsetSectionsEnd int) (d *PSISectionSyntaxData, err error) { // Init d = &PSISectionSyntaxData{} diff --git a/data_psi_test.go b/data_psi_test.go index f7b1993..e55b8b0 100644 --- a/data_psi_test.go +++ b/data_psi_test.go @@ -1,10 +1,10 @@ package astits import ( + "bytes" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -99,7 +99,8 @@ var psi = &PSIData{ } func psiBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(4)) // Pointer field w.Write([]byte("test")) // Pointer field bytes w.Write(uint8(78)) // EIT table ID @@ -151,12 +152,13 @@ func psiBytes() []byte { w.Write(uint32(0x6969b13)) // TOT CRC32 w.Write(uint8(254)) // Unknown table ID w.Write(uint8(0)) // PAT table ID - return w.Bytes() + return buf.Bytes() } func TestParsePSIData(t *testing.T) { // Invalid CRC32 - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(0)) // Pointer field w.Write(uint8(115)) // TOT table ID w.Write("1") // TOT syntax section indicator @@ -165,11 +167,11 @@ func TestParsePSIData(t *testing.T) { w.Write("000000001110") // TOT section length w.Write(totBytes()) // TOT data w.Write(uint32(32)) // TOT CRC32 - _, err := parsePSIData(astibyte.NewIterator(w.Bytes())) + _, err := parsePSIData(astikit.NewBytesIterator(buf.Bytes())) assert.EqualError(t, err, "astits: parsing PSI table failed: astits: Table CRC32 20 != computed CRC32 6969b13") // Valid - d, err := parsePSIData(astibyte.NewIterator(psiBytes())) + d, err := parsePSIData(astikit.NewBytesIterator(psiBytes())) assert.NoError(t, err) assert.Equal(t, d, psi) } @@ -183,22 +185,24 @@ var psiSectionHeader = &PSISectionHeader{ } func psiSectionHeaderBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(0)) // Table ID w.Write("1") // Syntax section indicator w.Write("1") // Private bit w.Write("11") // Reserved w.Write("101010101010") // Section length - return w.Bytes() + return buf.Bytes() } func TestParsePSISectionHeader(t *testing.T) { // Unknown table type - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(254)) // Table ID w.Write("1") // Syntax section indicator w.Write("0000000") // Finish the byte - d, _, _, _, _, err := parsePSISectionHeader(astibyte.NewIterator(w.Bytes())) + d, _, _, _, _, err := parsePSISectionHeader(astikit.NewBytesIterator(buf.Bytes())) assert.Equal(t, d, &PSISectionHeader{ TableID: 254, TableType: PSITableTypeUnknown, @@ -206,7 +210,7 @@ func TestParsePSISectionHeader(t *testing.T) { assert.NoError(t, err) // Valid table type - d, offsetStart, offsetSectionsStart, offsetSectionsEnd, offsetEnd, err := parsePSISectionHeader(astibyte.NewIterator(psiSectionHeaderBytes())) + d, offsetStart, offsetSectionsStart, offsetSectionsEnd, offsetEnd, err := parsePSISectionHeader(astikit.NewBytesIterator(psiSectionHeaderBytes())) assert.Equal(t, d, psiSectionHeader) assert.Equal(t, 0, offsetStart) assert.Equal(t, 3, offsetSectionsStart) @@ -245,18 +249,19 @@ var psiSectionSyntaxHeader = &PSISectionSyntaxHeader{ } func psiSectionSyntaxHeaderBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(1)) // Table ID extension w.Write("11") // Reserved bits w.Write("10101") // Version number w.Write("1") // Current/next indicator w.Write(uint8(2)) // Section number w.Write(uint8(3)) // Last section number - return w.Bytes() + return buf.Bytes() } func TestParsePSISectionSyntaxHeader(t *testing.T) { - h, err := parsePSISectionSyntaxHeader(astibyte.NewIterator(psiSectionSyntaxHeaderBytes())) + h, err := parsePSISectionSyntaxHeader(astikit.NewBytesIterator(psiSectionSyntaxHeaderBytes())) assert.Equal(t, psiSectionSyntaxHeader, h) assert.NoError(t, err) } diff --git a/data_sdt.go b/data_sdt.go index a4207a5..58bebf8 100644 --- a/data_sdt.go +++ b/data_sdt.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -34,7 +34,7 @@ type SDTDataService struct { } // parseSDTSection parses an SDT section -func parseSDTSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtension uint16) (d *SDTData, err error) { +func parseSDTSection(i *astikit.BytesIterator, offsetSectionsEnd int, tableIDExtension uint16) (d *SDTData, err error) { // Create data d = &SDTData{TransportStreamID: tableIDExtension} @@ -49,7 +49,7 @@ func parseSDTSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtensi d.OriginalNetworkID = uint16(bs[0])<<8 | uint16(bs[1]) // Reserved for future use - i.FastForward(1) + i.Skip(1) // Loop until end of section data is reached for i.Offset() < offsetSectionsEnd { @@ -91,7 +91,7 @@ func parseSDTSection(i *astibyte.Iterator, offsetSectionsEnd int, tableIDExtensi s.HasFreeCSAMode = uint8(b&0x10) > 0 // We need to rewind since the current byte is used by the descriptor as well - i.FastForward(-1) + i.Skip(-1) // Descriptors if s.Descriptors, err = parseDescriptors(i); err != nil { diff --git a/data_sdt_test.go b/data_sdt_test.go index e97ad55..cc59c9d 100644 --- a/data_sdt_test.go +++ b/data_sdt_test.go @@ -1,10 +1,10 @@ package astits import ( + "bytes" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -22,7 +22,8 @@ var sdt = &SDTData{ } func sdtBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(2)) // Original network ID w.Write(uint8(0)) // Reserved for future use w.Write(uint16(3)) // Service #1 id @@ -32,12 +33,12 @@ func sdtBytes() []byte { w.Write("101") // Service #1 running status w.Write("1") // Service #1 free CA mode descriptorsBytes(w) // Service #1 descriptors - return w.Bytes() + return buf.Bytes() } func TestParseSDTSection(t *testing.T) { var b = sdtBytes() - d, err := parseSDTSection(astibyte.NewIterator(b), len(b), uint16(1)) + d, err := parseSDTSection(astikit.NewBytesIterator(b), len(b), uint16(1)) assert.Equal(t, d, sdt) assert.NoError(t, err) } diff --git a/data_test.go b/data_test.go index de6244c..428671b 100644 --- a/data_test.go +++ b/data_test.go @@ -1,9 +1,10 @@ package astits import ( + "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -77,10 +78,11 @@ func TestIsPSIPayload(t *testing.T) { } func TestIsPESPayload(t *testing.T) { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("0000000000000001") - assert.False(t, isPESPayload(w.Bytes())) - w.Reset() + assert.False(t, isPESPayload(buf.Bytes())) + buf.Reset() w.Write("000000000000000000000001") - assert.True(t, isPESPayload(w.Bytes())) + assert.True(t, isPESPayload(buf.Bytes())) } diff --git a/data_tot.go b/data_tot.go index ffc4123..69aeaac 100644 --- a/data_tot.go +++ b/data_tot.go @@ -3,7 +3,7 @@ package astits import ( "time" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -15,7 +15,7 @@ type TOTData struct { } // parseTOTSection parses a TOT section -func parseTOTSection(i *astibyte.Iterator) (d *TOTData, err error) { +func parseTOTSection(i *astikit.BytesIterator) (d *TOTData, err error) { // Create data d = &TOTData{} diff --git a/data_tot_test.go b/data_tot_test.go index 99e642d..0f2756c 100644 --- a/data_tot_test.go +++ b/data_tot_test.go @@ -1,11 +1,11 @@ package astits import ( + "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" - "github.com/asticode/go-astitools/byte" ) var tot = &TOTData{ @@ -14,15 +14,16 @@ var tot = &TOTData{ } func totBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(dvbTimeBytes) // UTC time w.Write("0000") // Reserved descriptorsBytes(w) // Service #1 descriptors - return w.Bytes() + return buf.Bytes() } func TestParseTOTSection(t *testing.T) { - d, err := parseTOTSection(astibyte.NewIterator(totBytes())) + d, err := parseTOTSection(astikit.NewBytesIterator(totBytes())) assert.Equal(t, d, tot) assert.NoError(t, err) } diff --git a/demuxer_test.go b/demuxer_test.go index 28e8705..d5dfee5 100644 --- a/demuxer_test.go +++ b/demuxer_test.go @@ -6,7 +6,7 @@ import ( "fmt" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -27,12 +27,13 @@ func TestDemuxerNextPacket(t *testing.T) { assert.Error(t, err) // Valid - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) b1, p1 := packet(*packetHeader, *packetAdaptationField, []byte("1")) w.Write(b1) b2, p2 := packet(*packetHeader, *packetAdaptationField, []byte("2")) w.Write(b2) - dmx = New(context.Background(), bytes.NewReader(w.Bytes())) + dmx = New(context.Background(), bytes.NewReader(buf.Bytes())) // First packet p, err := dmx.NextPacket() @@ -52,13 +53,14 @@ func TestDemuxerNextPacket(t *testing.T) { func TestDemuxerNextData(t *testing.T) { // Init - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) b := psiBytes() b1, _ := packet(PacketHeader{ContinuityCounter: uint8(0), PayloadUnitStartIndicator: true, PID: PIDPAT}, PacketAdaptationField{}, b[:147]) w.Write(b1) b2, _ := packet(PacketHeader{ContinuityCounter: uint8(1), PID: PIDPAT}, PacketAdaptationField{}, b[147:]) w.Write(b2) - dmx := New(context.Background(), bytes.NewReader(w.Bytes())) + dmx := New(context.Background(), bytes.NewReader(buf.Bytes())) p, err := dmx.NextPacket() assert.NoError(t, err) _, err = dmx.Rewind() diff --git a/descriptor.go b/descriptor.go index eb21645..5cd939f 100644 --- a/descriptor.go +++ b/descriptor.go @@ -3,8 +3,8 @@ package astits import ( "time" + "github.com/asticode/go-astikit" "github.com/asticode/go-astilog" - "github.com/asticode/go-astitools/byte" "github.com/pkg/errors" ) @@ -132,7 +132,7 @@ type DescriptorAC3 struct { MainID uint8 } -func newDescriptorAC3(i *astibyte.Iterator, offsetEnd int) (d *DescriptorAC3, err error) { +func newDescriptorAC3(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorAC3, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -207,7 +207,7 @@ type DescriptorAVCVideo struct { ProfileIDC uint8 } -func newDescriptorAVCVideo(i *astibyte.Iterator) (d *DescriptorAVCVideo, err error) { +func newDescriptorAVCVideo(i *astikit.BytesIterator) (d *DescriptorAVCVideo, err error) { // Init d = &DescriptorAVCVideo{} @@ -267,7 +267,7 @@ type DescriptorComponent struct { Text []byte } -func newDescriptorComponent(i *astibyte.Iterator, offsetEnd int) (d *DescriptorComponent, err error) { +func newDescriptorComponent(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorComponent, err error) { // Init d = &DescriptorComponent{} @@ -332,7 +332,7 @@ type DescriptorContentItem struct { UserByte uint8 } -func newDescriptorContent(i *astibyte.Iterator, offsetEnd int) (d *DescriptorContent, err error) { +func newDescriptorContent(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorContent, err error) { // Init d = &DescriptorContent{} @@ -360,7 +360,7 @@ type DescriptorDataStreamAlignment struct { Type uint8 } -func newDescriptorDataStreamAlignment(i *astibyte.Iterator) (d *DescriptorDataStreamAlignment, err error) { +func newDescriptorDataStreamAlignment(i *astikit.BytesIterator) (d *DescriptorDataStreamAlignment, err error) { var b byte if b, err = i.NextByte(); err != nil { err = errors.Wrap(err, "astits: fetching next byte failed") @@ -391,7 +391,7 @@ type DescriptorEnhancedAC3 struct { SubStream3 uint8 } -func newDescriptorEnhancedAC3(i *astibyte.Iterator, offsetEnd int) (d *DescriptorEnhancedAC3, err error) { +func newDescriptorEnhancedAC3(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorEnhancedAC3, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -508,7 +508,7 @@ type DescriptorExtendedEventItem struct { Description []byte } -func newDescriptorExtendedEvent(i *astibyte.Iterator) (d *DescriptorExtendedEvent, err error) { +func newDescriptorExtendedEvent(i *astikit.BytesIterator) (d *DescriptorExtendedEvent, err error) { // Init d = &DescriptorExtendedEvent{} @@ -571,7 +571,7 @@ func newDescriptorExtendedEvent(i *astibyte.Iterator) (d *DescriptorExtendedEven return } -func newDescriptorExtendedEventItem(i *astibyte.Iterator) (d *DescriptorExtendedEventItem, err error) { +func newDescriptorExtendedEventItem(i *astikit.BytesIterator) (d *DescriptorExtendedEventItem, err error) { // Init d = &DescriptorExtendedEventItem{} @@ -615,7 +615,7 @@ type DescriptorExtension struct { Tag uint8 } -func newDescriptorExtension(i *astibyte.Iterator, offsetEnd int) (d *DescriptorExtension, err error) { +func newDescriptorExtension(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorExtension, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -650,7 +650,7 @@ type DescriptorExtensionSupplementaryAudio struct { PrivateData []byte } -func newDescriptorExtensionSupplementaryAudio(i *astibyte.Iterator, offsetEnd int) (d *DescriptorExtensionSupplementaryAudio, err error) { +func newDescriptorExtensionSupplementaryAudio(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorExtensionSupplementaryAudio, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -691,7 +691,7 @@ type DescriptorISO639LanguageAndAudioType struct { } // In some actual cases, the length is 3 and the language is described in only 2 bytes -func newDescriptorISO639LanguageAndAudioType(i *astibyte.Iterator, offsetEnd int) (d *DescriptorISO639LanguageAndAudioType, err error) { +func newDescriptorISO639LanguageAndAudioType(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorISO639LanguageAndAudioType, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(offsetEnd - i.Offset()); err != nil { @@ -724,7 +724,7 @@ type DescriptorLocalTimeOffsetItem struct { TimeOfChange time.Time } -func newDescriptorLocalTimeOffset(i *astibyte.Iterator, offsetEnd int) (d *DescriptorLocalTimeOffset, err error) { +func newDescriptorLocalTimeOffset(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorLocalTimeOffset, err error) { // Init d = &DescriptorLocalTimeOffset{} @@ -781,7 +781,7 @@ type DescriptorMaximumBitrate struct { Bitrate uint32 // In bytes/second } -func newDescriptorMaximumBitrate(i *astibyte.Iterator) (d *DescriptorMaximumBitrate, err error) { +func newDescriptorMaximumBitrate(i *astikit.BytesIterator) (d *DescriptorMaximumBitrate, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(3); err != nil { @@ -800,7 +800,7 @@ type DescriptorNetworkName struct { Name []byte } -func newDescriptorNetworkName(i *astibyte.Iterator, offsetEnd int) (d *DescriptorNetworkName, err error) { +func newDescriptorNetworkName(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorNetworkName, err error) { // Create descriptor d = &DescriptorNetworkName{} @@ -834,7 +834,7 @@ func (d DescriptorParentalRatingItem) MinimumAge() int { return int(d.Rating) + 3 } -func newDescriptorParentalRating(i *astibyte.Iterator, offsetEnd int) (d *DescriptorParentalRating, err error) { +func newDescriptorParentalRating(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorParentalRating, err error) { // Create descriptor d = &DescriptorParentalRating{} @@ -861,7 +861,7 @@ type DescriptorPrivateDataIndicator struct { Indicator uint32 } -func newDescriptorPrivateDataIndicator(i *astibyte.Iterator) (d *DescriptorPrivateDataIndicator, err error) { +func newDescriptorPrivateDataIndicator(i *astikit.BytesIterator) (d *DescriptorPrivateDataIndicator, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(4); err != nil { @@ -879,7 +879,7 @@ type DescriptorPrivateDataSpecifier struct { Specifier uint32 } -func newDescriptorPrivateDataSpecifier(i *astibyte.Iterator) (d *DescriptorPrivateDataSpecifier, err error) { +func newDescriptorPrivateDataSpecifier(i *astikit.BytesIterator) (d *DescriptorPrivateDataSpecifier, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(4); err != nil { @@ -899,7 +899,7 @@ type DescriptorRegistration struct { FormatIdentifier uint32 } -func newDescriptorRegistration(i *astibyte.Iterator, offsetEnd int) (d *DescriptorRegistration, err error) { +func newDescriptorRegistration(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorRegistration, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(4); err != nil { @@ -928,7 +928,7 @@ type DescriptorService struct { Type uint8 } -func newDescriptorService(i *astibyte.Iterator) (d *DescriptorService, err error) { +func newDescriptorService(i *astikit.BytesIterator) (d *DescriptorService, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -979,7 +979,7 @@ type DescriptorShortEvent struct { Text []byte } -func newDescriptorShortEvent(i *astibyte.Iterator) (d *DescriptorShortEvent, err error) { +func newDescriptorShortEvent(i *astikit.BytesIterator) (d *DescriptorShortEvent, err error) { // Create descriptor d = &DescriptorShortEvent{} @@ -1026,7 +1026,7 @@ func newDescriptorShortEvent(i *astibyte.Iterator) (d *DescriptorShortEvent, err // Chapter: 6.2.39 | Link: https://www.etsi.org/deliver/etsi_en/300400_300499/300468/01.15.01_60/en_300468v011501p.pdf type DescriptorStreamIdentifier struct{ ComponentTag uint8 } -func newDescriptorStreamIdentifier(i *astibyte.Iterator) (d *DescriptorStreamIdentifier, err error) { +func newDescriptorStreamIdentifier(i *astikit.BytesIterator) (d *DescriptorStreamIdentifier, err error) { var b byte if b, err = i.NextByte(); err != nil { err = errors.Wrap(err, "astits: fetching next byte failed") @@ -1051,7 +1051,7 @@ type DescriptorSubtitlingItem struct { Type uint8 } -func newDescriptorSubtitling(i *astibyte.Iterator, offsetEnd int) (d *DescriptorSubtitling, err error) { +func newDescriptorSubtitling(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorSubtitling, err error) { // Create descriptor d = &DescriptorSubtitling{} @@ -1116,7 +1116,7 @@ type DescriptorTeletextItem struct { Type uint8 } -func newDescriptorTeletext(i *astibyte.Iterator, offsetEnd int) (d *DescriptorTeletext, err error) { +func newDescriptorTeletext(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorTeletext, err error) { // Create descriptor d = &DescriptorTeletext{} @@ -1179,7 +1179,7 @@ type DescriptorVBIDataDescriptor struct { LineOffset uint8 } -func newDescriptorVBIData(i *astibyte.Iterator, offsetEnd int) (d *DescriptorVBIData, err error) { +func newDescriptorVBIData(i *astikit.BytesIterator, offsetEnd int) (d *DescriptorVBIData, err error) { // Create descriptor d = &DescriptorVBIData{} @@ -1237,7 +1237,7 @@ func newDescriptorVBIData(i *astibyte.Iterator, offsetEnd int) (d *DescriptorVBI } // parseDescriptors parses descriptors -func parseDescriptors(i *astibyte.Iterator) (o []*Descriptor, err error) { +func parseDescriptors(i *astikit.BytesIterator) (o []*Descriptor, err error) { // Get next 2 bytes var bs []byte if bs, err = i.NextBytes(2); err != nil { diff --git a/descriptor_test.go b/descriptor_test.go index 61324ec..d41551c 100644 --- a/descriptor_test.go +++ b/descriptor_test.go @@ -1,10 +1,10 @@ package astits import ( + "bytes" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -14,7 +14,7 @@ var descriptors = []*Descriptor{{ Tag: DescriptorTagStreamIdentifier, }} -func descriptorsBytes(w *astibinary.Writer) { +func descriptorsBytes(w *astikit.BitsWriter) { w.Write("000000000011") // Overall length w.Write(uint8(DescriptorTagStreamIdentifier)) // Tag w.Write(uint8(1)) // Length @@ -23,7 +23,8 @@ func descriptorsBytes(w *astibinary.Writer) { func TestParseDescriptor(t *testing.T) { // Init - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(242)) // Descriptors length // AC3 w.Write(uint8(DescriptorTagAC3)) // Tag @@ -215,7 +216,7 @@ func TestParseDescriptor(t *testing.T) { w.Write([]byte("test")) // Additional identification info // Assert - ds, err := parseDescriptors(astibyte.NewIterator(w.Bytes())) + ds, err := parseDescriptors(astikit.NewBytesIterator(buf.Bytes())) assert.NoError(t, err) assert.Equal(t, *ds[0].AC3, DescriptorAC3{ AdditionalInfo: []byte("info"), diff --git a/dvb.go b/dvb.go index 6f47b91..c831c4e 100644 --- a/dvb.go +++ b/dvb.go @@ -4,7 +4,7 @@ import ( "fmt" "time" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -14,7 +14,7 @@ import ( // field are set to "1". // I apologize for the computation which is really messy but details are given in the documentation // Page: 160 | Annex C | Link: https://www.dvb.org/resources/public/standards/a38_dvb-si_specification.pdf -func parseDVBTime(i *astibyte.Iterator) (t time.Time, err error) { +func parseDVBTime(i *astikit.BytesIterator) (t time.Time, err error) { // Get next 2 bytes var bs []byte if bs, err = i.NextBytes(2); err != nil { @@ -47,7 +47,7 @@ func parseDVBTime(i *astibyte.Iterator) (t time.Time, err error) { // parseDVBDurationMinutes parses a minutes duration // 16 bit field containing the duration of the event in hours, minutes. format: 4 digits, 4 - bit BCD = 18 bit -func parseDVBDurationMinutes(i *astibyte.Iterator) (d time.Duration, err error) { +func parseDVBDurationMinutes(i *astikit.BytesIterator) (d time.Duration, err error) { var bs []byte if bs, err = i.NextBytes(2); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") @@ -59,7 +59,7 @@ func parseDVBDurationMinutes(i *astibyte.Iterator) (d time.Duration, err error) // parseDVBDurationSeconds parses a seconds duration // 24 bit field containing the duration of the event in hours, minutes, seconds. format: 6 digits, 4 - bit BCD = 24 bit -func parseDVBDurationSeconds(i *astibyte.Iterator) (d time.Duration, err error) { +func parseDVBDurationSeconds(i *astikit.BytesIterator) (d time.Duration, err error) { var bs []byte if bs, err = i.NextBytes(3); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") diff --git a/dvb_test.go b/dvb_test.go index 013e3c5..8e71ef2 100644 --- a/dvb_test.go +++ b/dvb_test.go @@ -4,7 +4,7 @@ import ( "testing" "time" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) @@ -18,19 +18,19 @@ var ( ) func TestParseDVBTime(t *testing.T) { - d, err := parseDVBTime(astibyte.NewIterator(dvbTimeBytes)) + d, err := parseDVBTime(astikit.NewBytesIterator(dvbTimeBytes)) assert.Equal(t, dvbTime, d) assert.NoError(t, err) } func TestParseDVBDurationMinutes(t *testing.T) { - d, err := parseDVBDurationMinutes(astibyte.NewIterator(dvbDurationMinutesBytes)) + d, err := parseDVBDurationMinutes(astikit.NewBytesIterator(dvbDurationMinutesBytes)) assert.Equal(t, dvbDurationMinutes, d) assert.NoError(t, err) } func TestParseDVBDurationSeconds(t *testing.T) { - d, err := parseDVBDurationSeconds(astibyte.NewIterator(dvbDurationSecondsBytes)) + d, err := parseDVBDurationSeconds(astikit.NewBytesIterator(dvbDurationSecondsBytes)) assert.Equal(t, dvbDurationSeconds, d) assert.NoError(t, err) } diff --git a/go.mod b/go.mod index 33fc2e2..e03477f 100644 --- a/go.mod +++ b/go.mod @@ -3,8 +3,8 @@ module github.com/asticode/go-astits go 1.13 require ( - github.com/asticode/go-astilog v1.2.0 - github.com/asticode/go-astitools v1.2.1 + github.com/asticode/go-astikit v0.0.9 + github.com/asticode/go-astilog v1.4.0 github.com/pkg/errors v0.8.1 github.com/pkg/profile v1.4.0 github.com/stretchr/testify v1.4.0 diff --git a/go.sum b/go.sum index d3e58ee..5197b82 100644 --- a/go.sum +++ b/go.sum @@ -1,65 +1,39 @@ -github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU= -github.com/asticode/go-astiamqp v1.0.0/go.mod h1:PDHG8FjHJDtbDNNHixFCm80+7Ma1dKvwYl325Mj5DI4= -github.com/asticode/go-astiamqp v1.0.1/go.mod h1:Xe27K2GHnsEoIgAtHi+udd7xXV5YSQG4nE3ggZoyU/4= -github.com/asticode/go-astilog v1.0.0/go.mod h1:Vg6SGUYb3tVyFeGQe0Mqmh0RMygpwy+huFKcyL92EVc= -github.com/asticode/go-astilog v1.2.0 h1:p1jTI/4CgUgtkuAVP6DiRn6RTjX6CIqLdn9pu6tsz5w= -github.com/asticode/go-astilog v1.2.0/go.mod h1:0sGDwdYLRSFVbbvrXLbJC9niyGWL5JGTCEQWFJKHZr0= -github.com/asticode/go-astitools v1.0.0/go.mod h1:E7f1P0KkBNgafRCD0dHqn41jNHyYHjxrnK1jH2s4pmA= -github.com/asticode/go-astitools v1.2.0/go.mod h1:EfgrhUJK6nM17TckqASIqR2W71uNUAoIonm6mNhUtaQ= -github.com/asticode/go-astitools v1.2.1 h1:1KPzl1MquD7UlkPQULV3np+HlThfu1nDmKKJnmRT2Mw= -github.com/asticode/go-astitools v1.2.1/go.mod h1:7HUpcFY8dQwjwBFCEXAHCLF5gWCObPoE9GTlgQKmAPo= -github.com/asticode/go-astiws v1.0.1/go.mod h1:5F/0RkJTq1SZ0TsiheD3j/9lr9kla70c2q7w1aAG78Q= +github.com/asticode/go-astikit v0.0.9 h1:4r1jjQU3g+2RuoCJSrzoLogcKU+3AQcQGMPBQdnijq4= +github.com/asticode/go-astikit v0.0.9/go.mod h1:h4ly7idim1tNhaVkdVBeXQZEE3L0xblP7fCWbgwipF0= +github.com/asticode/go-astilog v1.4.0 h1:81eNYAC04VPg1b9UXdQe3NCT1EPo9CtGa2UUDnQyvik= +github.com/asticode/go-astilog v1.4.0/go.mod h1:0sGDwdYLRSFVbbvrXLbJC9niyGWL5JGTCEQWFJKHZr0= github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= -github.com/gorilla/websocket v1.4.1/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE= -github.com/imdario/mergo v0.3.6/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= -github.com/imdario/mergo v0.3.8/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA= -github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w= -github.com/julienschmidt/httprouter v1.3.0/go.mod h1:JR6WtHb+2LUe8TCKY3cZOxFyyO8IZAc4RVcycCCAKdM= github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk= github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ= -github.com/mattn/go-colorable v0.0.9/go.mod h1:9vuHe8Xs5qXnSaW/c/ABM9alt+Vo+STaOChaDxuIBZU= github.com/mattn/go-colorable v0.1.4 h1:snbPLB8fVfU9iwbbo30TPtbLRzwWu6aJS6Xh4eaaviA= github.com/mattn/go-colorable v0.1.4/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE= -github.com/mattn/go-isatty v0.0.4/go.mod h1:M+lRXTBqGeGNdLjl/ufCoiOlB5xdOkqRJdNxMWT7Zi4= github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE= github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s= -github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I= github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0= github.com/pkg/profile v1.4.0 h1:uCmaf4vVbWAOZz36k1hrQD7ijGRzLwaME8Am/7a4jZI= github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE= github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= -github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo= github.com/sirupsen/logrus v1.4.2 h1:SPIRibHv4MatM3XXNO2BJeFLZwZ2LvZgfQ5+UNI2im4= github.com/sirupsen/logrus v1.4.2/go.mod h1:tLMulIdttU9McNUspp0xgXVQah82FyeX6MwdIuYE2rE= -github.com/streadway/amqp v0.0.0-20181205114330-a314942b2fd9/go.mod h1:1WNBiOZtZQLpVAyu0iTduoJL9hEsMloAK5XWrtW0xdY= -github.com/streadway/amqp v0.0.0-20190827072141-edfb9018d271/go.mod h1:AZpEONHx3DKn8O/DFsRAY58/XVQiIPMTMB1SddzLXVw= github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs= github.com/stretchr/testify v1.4.0 h1:2E4SXV/wtOkTonXsotYi4li6zVWxYlZuYNCXe9XRJyk= github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81PSLYec5m4= -golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= -golang.org/x/crypto v0.0.0-20181203042331-505ab145d0a9/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4= golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w= golang.org/x/crypto v0.0.0-20191202143827-86a70503ff7e h1:egKlR8l7Nu9vHGWbcUV8lqR4987UfUbBd7GbhqGzNYU= golang.org/x/crypto v0.0.0-20191202143827-86a70503ff7e/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto= golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg= -golang.org/x/net v0.0.0-20191204025024-5ee1b9f4859a h1:+HHJiFUXVOIS9mr1ThqkQD1N8vpFCfCShqADBM12KTc= -golang.org/x/net v0.0.0-20191204025024-5ee1b9f4859a/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s= -golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= -golang.org/x/sys v0.0.0-20181217223516-dcdaa6325bcb/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY= golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/sys v0.0.0-20190422165155-953cdadca894 h1:Cz4ceDQGXuKRnVBDTS23GTn/pU5OE2C0WrNTOYK1Uuc= golang.org/x/sys v0.0.0-20190422165155-953cdadca894/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs= golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ= -golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk= -golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw= diff --git a/packet.go b/packet.go index 48d9834..ab72008 100644 --- a/packet.go +++ b/packet.go @@ -1,7 +1,7 @@ package astits import ( - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) @@ -66,7 +66,7 @@ type PacketAdaptationExtensionField struct { } // parsePacket parses a packet -func parsePacket(i *astibyte.Iterator) (p *Packet, err error) { +func parsePacket(i *astikit.BytesIterator) (p *Packet, err error) { // Get next byte var b byte if b, err = i.NextByte(); err != nil { @@ -119,7 +119,7 @@ func payloadOffset(offsetStart int, h *PacketHeader, a *PacketAdaptationField) ( } // parsePacketHeader parses the packet header -func parsePacketHeader(i *astibyte.Iterator) (h *PacketHeader, err error) { +func parsePacketHeader(i *astikit.BytesIterator) (h *PacketHeader, err error) { // Get next bytes var bs []byte if bs, err = i.NextBytes(3); err != nil { @@ -142,7 +142,7 @@ func parsePacketHeader(i *astibyte.Iterator) (h *PacketHeader, err error) { } // parsePacketAdaptationField parses the packet adaptation field -func parsePacketAdaptationField(i *astibyte.Iterator) (a *PacketAdaptationField, err error) { +func parsePacketAdaptationField(i *astikit.BytesIterator) (a *PacketAdaptationField, err error) { // Create adaptation field a = &PacketAdaptationField{} @@ -275,7 +275,7 @@ func parsePacketAdaptationField(i *astibyte.Iterator) (a *PacketAdaptationField, a.AdaptationExtensionField.SpliceType = uint8(b&0xf0) >> 4 // We need to rewind since the current byte is used by the DTS next access unit as well - i.FastForward(-1) + i.Skip(-1) // DTS Next access unit if a.AdaptationExtensionField.DTSNextAccessUnit, err = parsePTSOrDTS(i); err != nil { @@ -291,7 +291,7 @@ func parsePacketAdaptationField(i *astibyte.Iterator) (a *PacketAdaptationField, // parsePCR parses a Program Clock Reference // Program clock reference, stored as 33 bits base, 6 bits reserved, 9 bits extension. -func parsePCR(i *astibyte.Iterator) (cr *ClockReference, err error) { +func parsePCR(i *astikit.BytesIterator) (cr *ClockReference, err error) { var bs []byte if bs, err = i.NextBytes(6); err != nil { err = errors.Wrap(err, "astits: fetching next bytes failed") diff --git a/packet_buffer.go b/packet_buffer.go index 13832b8..cc2070c 100644 --- a/packet_buffer.go +++ b/packet_buffer.go @@ -4,13 +4,12 @@ import ( "fmt" "io" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/pkg/errors" ) // packetBuffer represents a packet buffer type packetBuffer struct { - b []*Packet packetSize int r io.Reader } @@ -104,7 +103,7 @@ func (pb *packetBuffer) next() (p *Packet, err error) { } // Parse packet - if p, err = parsePacket(astibyte.NewIterator(b)); err != nil { + if p, err = parsePacket(astikit.NewBytesIterator(b)); err != nil { err = errors.Wrap(err, "astits: building packet failed") return } diff --git a/packet_buffer_test.go b/packet_buffer_test.go index 3381e0d..b0c3d6e 100644 --- a/packet_buffer_test.go +++ b/packet_buffer_test.go @@ -4,20 +4,21 @@ import ( "bytes" "testing" - "github.com/asticode/go-astitools/binary" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) func TestAutoDetectPacketSize(t *testing.T) { // Packet should start with a sync byte - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(2)) w.Write(byte(syncByte)) - _, err := autoDetectPacketSize(bytes.NewReader(w.Bytes())) + _, err := autoDetectPacketSize(bytes.NewReader(buf.Bytes())) assert.EqualError(t, err, ErrPacketMustStartWithASyncByte.Error()) // Valid packet size - w.Reset() + buf.Reset() w.Write(byte(syncByte)) w.Write(make([]byte, 20)) w.Write(byte(syncByte)) @@ -25,7 +26,7 @@ func TestAutoDetectPacketSize(t *testing.T) { w.Write(byte(syncByte)) w.Write(make([]byte, 187)) w.Write([]byte("test")) - r := bytes.NewReader(w.Bytes()) + r := bytes.NewReader(buf.Bytes()) p, err := autoDetectPacketSize(r) assert.NoError(t, err) assert.Equal(t, 188, p) diff --git a/packet_test.go b/packet_test.go index a12be23..873582d 100644 --- a/packet_test.go +++ b/packet_test.go @@ -1,23 +1,24 @@ package astits import ( + "bytes" "fmt" "testing" - astibinary "github.com/asticode/go-astitools/binary" - astibyte "github.com/asticode/go-astitools/byte" + "github.com/asticode/go-astikit" "github.com/stretchr/testify/assert" ) func packet(h PacketHeader, a PacketAdaptationField, i []byte) ([]byte, *Packet) { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(syncByte)) // Sync byte w.Write([]byte("test")) // Sometimes packets are 192 bytes w.Write(packetHeaderBytes(h)) // Header w.Write(packetAdaptationFieldBytes(a)) // Adaptation field var payload = append(i, make([]byte, 147-len(i))...) // Payload w.Write(payload) - return w.Bytes(), &Packet{ + return buf.Bytes(), &Packet{ AdaptationField: packetAdaptationField, Header: packetHeader, Payload: payload, @@ -26,14 +27,15 @@ func packet(h PacketHeader, a PacketAdaptationField, i []byte) ([]byte, *Packet) func TestParsePacket(t *testing.T) { // Packet not starting with a sync - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint16(1)) // Invalid sync byte - _, err := parsePacket(astibyte.NewIterator(w.Bytes())) + _, err := parsePacket(astikit.NewBytesIterator(buf.Bytes())) assert.EqualError(t, err, ErrPacketMustStartWithASyncByte.Error()) // Valid b, ep := packet(*packetHeader, *packetAdaptationField, []byte("payload")) - p, err := parsePacket(astibyte.NewIterator(b)) + p, err := parsePacket(astikit.NewBytesIterator(b)) assert.NoError(t, err) assert.Equal(t, p, ep) } @@ -55,7 +57,8 @@ var packetHeader = &PacketHeader{ } func packetHeaderBytes(h PacketHeader) []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(h.TransportErrorIndicator) // Transport error indicator w.Write(h.PayloadUnitStartIndicator) // Payload unit start indicator w.Write("1") // Transport priority @@ -63,11 +66,11 @@ func packetHeaderBytes(h PacketHeader) []byte { w.Write("10") // Scrambling control w.Write("11") // Adaptation field control w.Write(fmt.Sprintf("%.4b", h.ContinuityCounter)) // Continuity counter - return w.Bytes() + return buf.Bytes() } func TestParsePacketHeader(t *testing.T) { - v, err := parsePacketHeader(astibyte.NewIterator(packetHeaderBytes(*packetHeader))) + v, err := parsePacketHeader(astikit.NewBytesIterator(packetHeaderBytes(*packetHeader))) assert.Equal(t, packetHeader, v) assert.NoError(t, err) } @@ -101,7 +104,8 @@ var packetAdaptationField = &PacketAdaptationField{ } func packetAdaptationFieldBytes(a PacketAdaptationField) []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write(uint8(36)) // Length w.Write(a.DiscontinuityIndicator) // Discontinuity indicator w.Write("1") // Random access indicator @@ -127,11 +131,11 @@ func packetAdaptationFieldBytes(a PacketAdaptationField) []byte { w.Write("1010101010101010101010") // Piecewise rate w.Write(dtsBytes()) // Splice type + DTS next access unit w.Write([]byte("stuff")) // Stuffing bytes - return w.Bytes() + return buf.Bytes() } func TestParsePacketAdaptationField(t *testing.T) { - v, err := parsePacketAdaptationField(astibyte.NewIterator(packetAdaptationFieldBytes(*packetAdaptationField))) + v, err := parsePacketAdaptationField(astikit.NewBytesIterator(packetAdaptationFieldBytes(*packetAdaptationField))) assert.Equal(t, packetAdaptationField, v) assert.NoError(t, err) } @@ -142,15 +146,16 @@ var pcr = &ClockReference{ } func pcrBytes() []byte { - w := astibinary.New() + buf := &bytes.Buffer{} + w := astikit.NewBitsWriter(astikit.BitsWriterOptions{Writer: buf}) w.Write("101010101010101010101010101010101") // Base w.Write("111111") // Reserved w.Write("101010101") // Extension - return w.Bytes() + return buf.Bytes() } func TestParsePCR(t *testing.T) { - v, err := parsePCR(astibyte.NewIterator(pcrBytes())) + v, err := parsePCR(astikit.NewBytesIterator(pcrBytes())) assert.Equal(t, pcr, v) assert.NoError(t, err) }