cmd/dif-split: first import

Author: sbinet

cmd/dif-split/main.go

@@ -0,0 +1,124 @@
+// Copyright 2021 The go-lpc Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Command dif-split splits a DIF/EDA binary file into n DIF files,
+// one per DIF-ID.
+package main // import "github.com/go-lpc/mim/cmd/dif-split"
+
+import (
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"log"
+	"os"
+	"path/filepath"
+	"strings"
+
+	"github.com/go-lpc/mim/internal/eformat"
+)
+
+var (
+	msg = log.New(os.Stdout, "dif-split: ", 0)
+)
+
+func main() {
+	xmain(os.Args[1:])
+}
+
+func xmain(args []string) {
+	var (
+		fset = flag.NewFlagSet("dif", flag.ExitOnError)
+
+		oname = fset.String("o", "out.raw", "path to output DIF file")
+		eda   = fset.Bool("eda", false, "enable EDA hack")
+	)
+
+	fset.Usage = func() {
+		fmt.Printf(`Usage: dif-split [OPTIONS] file.raw
+
+ex:
+ $> dif-split -o out.raw ./input.eda.raw
+
+options:
+`)
+		fset.PrintDefaults()
+	}
+
+	err := fset.Parse(args)
+	if err != nil {
+		log.Fatalf("could not parse input arguments: %+v", err)
+	}
+
+	if fset.NArg() != 1 {
+		fset.Usage()
+		msg.Fatalf("missing input DIF raw file")
+	}
+
+	if *oname == "" {
+		fset.Usage()
+		msg.Fatalf("invalid output DIF raw file")
+	}
+
+	for _, arg := range fset.Args() {
+		err := process(*oname, *eda, arg)
+		if err != nil {
+			msg.Fatalf("could not split DIF file %q: %+v", arg, err)
+		}
+	}
+}
+
+func process(oname string, isEDA bool, fname string) error {
+	f, err := os.Open(fname)
+	if err != nil {
+		return fmt.Errorf("could not open EDA file: %w", err)
+	}
+	defer f.Close()
+
+	out := make(map[uint8]*eformat.Encoder)
+
+	dec := eformat.NewDecoder(0, f)
+	dec.IsEDA = isEDA
+
+loop:
+	for {
+		var d eformat.DIF
+		err := dec.Decode(&d)
+		if err != nil {
+			if errors.Is(err, io.EOF) {
+				break loop
+			}
+			return fmt.Errorf("could not decode DIF: %w", err)
+		}
+
+		enc, ok := out[d.Header.ID]
+		if !ok {
+			oid := outFileFrom(oname, d.Header.ID)
+			msg.Printf("creating output file %q...", oid)
+			o, err := os.Create(oid)
+			if err != nil {
+				return fmt.Errorf("could not create output file: %w", err)
+			}
+			defer o.Close()
+
+			enc = eformat.NewEncoder(o)
+			out[d.Header.ID] = enc
+		}
+
+		err = enc.Encode(&d)
+		if err != nil {
+			return fmt.Errorf("could not encode DIF: %w", err)
+		}
+	}
+
+	return nil
+}
+
+func outFileFrom(fname string, id uint8) string {
+	var (
+		ext   = filepath.Ext(fname)
+		oname = strings.Replace(fname, ext, fmt.Sprintf("-%03d%s", id, ext), 1)
+	)
+	return oname
+}

cmd/dif-split/main_test.go

@@ -0,0 +1,123 @@
+// Copyright 2021 The go-lpc Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+import (
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+
+	"github.com/go-lpc/mim/internal/eformat"
+)
+
+func TestSplit(t *testing.T) {
+	tmpdir, err := ioutil.TempDir("", "dif-split-")
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer os.RemoveAll(tmpdir)
+
+	oname := filepath.Join(tmpdir, "out.raw")
+
+	f, err := os.Create(filepath.Join(tmpdir, "dif.raw"))
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer f.Close()
+
+	dif1 := eformat.DIF{
+		Header: eformat.GlobalHeader{
+			ID:        0x1,
+			DTC:       10,
+			ATC:       11,
+			GTC:       12,
+			AbsBCID:   0x0000112233445566,
+			TimeDIFTC: 0x00112233,
+		},
+		Frames: []eformat.Frame{
+			{
+				Header: 11,
+				BCID:   0x001a1b1c,
+				Data:   [16]uint8{0xa, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+			},
+			{
+				Header: 12,
+				BCID:   0x002a2b2c,
+				Data: [16]uint8{
+					0xb, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+					210, 211, 212, 213, 214, 215,
+				},
+			},
+		},
+	}
+
+	dif2 := eformat.DIF{
+		Header: eformat.GlobalHeader{
+			ID:        0x2,
+			DTC:       20,
+			ATC:       21,
+			GTC:       22,
+			AbsBCID:   0x0000112233445566,
+			TimeDIFTC: 0x00112233,
+		},
+		Frames: []eformat.Frame{
+			{
+				Header: 21,
+				BCID:   0x001a1b1c,
+				Data:   [16]uint8{0xa, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
+			},
+			{
+				Header: 22,
+				BCID:   0x002a2b2c,
+				Data: [16]uint8{
+					0xb, 21, 22, 23, 24, 25, 26, 27, 28, 29,
+					210, 211, 212, 213, 214, 215,
+				},
+			},
+		},
+	}
+
+	for _, dif := range []eformat.DIF{dif1, dif2} {
+		err = eformat.NewEncoder(f).Encode(&dif)
+		if err != nil {
+			t.Fatal(err)
+		}
+	}
+
+	err = f.Close()
+	if err != nil {
+		t.Fatalf("could not close input file: %+v", err)
+	}
+
+	xmain([]string{"-eda", "-o", oname, f.Name()})
+
+	for _, tc := range []struct {
+		fname string
+		want  eformat.DIF
+	}{
+		{filepath.Join(tmpdir, "out-001.raw"), dif1},
+		{filepath.Join(tmpdir, "out-002.raw"), dif2},
+	} {
+		f, err := os.Open(tc.fname)
+		if err != nil {
+			t.Fatalf("could not open split file: %+v", err)
+		}
+		defer f.Close()
+
+		var dif eformat.DIF
+		dec := eformat.NewDecoder(0, f)
+		err = dec.Decode(&dif)
+		if err != nil {
+			t.Fatalf("could not decode DIF from %q: %+v", tc.fname, err)
+		}
+
+		if got, want := dif, tc.want; !reflect.DeepEqual(got, want) {
+			t.Fatalf("invalid split")
+		}
+	}
+
+}