Esempio n. 1
0
func TestParseBlocks(t *testing.T) {
	for i, g := range golden {
		stream, err := flac.ParseFile(g.name)
		if err != nil {
			t.Fatal(err)
		}
		defer stream.Close()
		blocks := stream.Blocks

		if len(blocks) != len(g.blocks) {
			t.Errorf("i=%d: invalid number of metadata blocks; expected %d, got %d", i, len(g.blocks), len(blocks))
			continue
		}

		got := stream.Info
		want := g.info
		if !reflect.DeepEqual(got, want) {
			t.Errorf("i=%d: metadata StreamInfo block bodies differ; expected %#v, got %#v", i, want, got)
		}

		for j, got := range blocks {
			want := g.blocks[j]
			if !reflect.DeepEqual(got.Header, want.Header) {
				t.Errorf("i=%d, j=%d: metadata block headers differ; expected %#v, got %#v", i, j, want.Header, got.Header)
			}
			if !reflect.DeepEqual(got.Body, want.Body) {
				t.Errorf("i=%d, j=%d: metadata block bodies differ; expected %#v, got %#v", i, j, want.Body, got.Body)
			}
		}
	}
}
Esempio n. 2
0
func list(path string) error {
	var blockNums []int
	if flagBlockNum != "" {
		// Parse "--block-number" command line flag.
		rawBlockNums := strings.Split(flagBlockNum, ",")
		for _, rawBlockNum := range rawBlockNums {
			blockNum, err := strconv.Atoi(rawBlockNum)
			if err != nil {
				return err
			}
			blockNums = append(blockNums, blockNum)
		}
	}

	// Open FLAC stream.
	stream, err := flac.ParseFile(path)
	if err != nil {
		return err
	}

	if blockNums != nil {
		// Only list blocks specified in the "--block-number" command line flag.
		for _, blockNum := range blockNums {
			if blockNum == 0 {
				listStreamInfo(stream.Info)
			} else {
				// strea.Blocks doesn't contain StreamInfo, therefore the blockNum
				// is one less.
				blockNum--
			}
			if blockNum < len(stream.Blocks) {
				listBlock(stream.Blocks[blockNum], blockNum)
			}
		}
	} else {
		// List all blocks.
		var isLast bool
		if len(stream.Blocks) == 0 {
			isLast = true
		}
		listStreamInfoHeader(isLast)
		listStreamInfo(stream.Info)
		for blockNum, block := range stream.Blocks {
			// strea.Blocks doesn't contain StreamInfo, therefore the blockNum
			// is one less.
			blockNum--
			listBlock(block, blockNum)
		}
	}

	return nil
}
Esempio n. 3
0
func TestEncode(t *testing.T) {
	paths := []string{
		"meta/testdata/input-SCPAP.flac",
		"meta/testdata/input-SCVA.flac",
		"meta/testdata/input-SCVPAP.flac",
		"meta/testdata/input-VA.flac",
		"meta/testdata/silence.flac",
		"testdata/19875.flac",
		"testdata/44127.flac",
		"testdata/59996.flac",
		"testdata/80574.flac",
		"testdata/172960.flac",
		"testdata/189983.flac",
		"testdata/191885.flac",
		"testdata/212768.flac",
		"testdata/220014.flac",
		"testdata/243749.flac",
		"testdata/256529.flac",
		"testdata/257344.flac",
		"testdata/love.flac",
	}
	for _, path := range paths {
		// Decode source file.
		stream, err := flac.ParseFile(path)
		if err != nil {
			t.Errorf("%q: unable to parse FLAC file; %v", path, err)
			continue
		}
		defer stream.Close()

		// Encode FLAC stream.
		out := new(bytes.Buffer)
		if err := flac.Encode(out, stream); err != nil {
			t.Errorf("%q: unable to encode FLAC stream; %v", path, err)
			continue
		}

		// Compare source and destination FLAC streams.
		want, err := ioutil.ReadFile(path)
		if err != nil {
			t.Errorf("%q: unable to read file; %v", path, err)
			continue
		}
		got := out.Bytes()
		if !bytes.Equal(got, want) {
			t.Errorf("%q: content mismatch; expected % X, got % X", path, want, got)
			continue
		}
	}
}
Esempio n. 4
0
func ExampleParseFile() {
	// Parse metadata of love.flac
	stream, err := flac.ParseFile("testdata/love.flac")
	if err != nil {
		log.Fatal(err)
	}
	defer stream.Close()

	fmt.Printf("unencoded audio md5sum: %032x\n", stream.Info.MD5sum[:])
	for i, block := range stream.Blocks {
		fmt.Printf("block %d: %v\n", i, block.Type)
	}
	// Output:
	// unencoded audio md5sum: bdf6f7d31f77cb696a02b2192d192a89
	// block 0: seek table
	// block 1: vorbis comment
	// block 2: padding
}
Esempio n. 5
0
func TestEncodeComment(t *testing.T) {
	// Decode FLAC file.
	src, err := flac.ParseFile("testdata/love.flac")
	if err != nil {
		t.Fatalf("unable to parse input FLAC file; %v", err)
	}
	defer src.Close()

	// Add custom vorbis comment.
	const want = "FLAC encoding test case"
	for _, block := range src.Blocks {
		if comment, ok := block.Body.(*meta.VorbisComment); ok {
			comment.Vendor = want
		}
	}

	// Encode FLAC file.
	out := new(bytes.Buffer)
	if err := flac.Encode(out, src); err != nil {
		t.Fatalf("unable to encode FLAC file; %v", err)
	}

	stream, err := flac.Parse(out)
	if err != nil {
		t.Fatalf("unable to parse output FLAC file; %v", err)
	}
	defer stream.Close()

	// Add custom vorbis comment.
	for _, block := range stream.Blocks {
		if comment, ok := block.Body.(*meta.VorbisComment); ok {
			got := comment.Vendor
			if got != want {
				t.Errorf("Vorbis comment mismatch; expected %q, got %q", want, got)
				continue
			}
		}
	}
}
Esempio n. 6
0
func TestParsePicture(t *testing.T) {
	stream, err := flac.ParseFile("testdata/silence.flac")
	if err != nil {
		t.Fatal(err)
	}
	defer stream.Close()

	want, err := ioutil.ReadFile("testdata/silence.jpg")
	if err != nil {
		t.Fatal(err)
	}

	for _, block := range stream.Blocks {
		if block.Type == meta.TypePicture {
			pic := block.Body.(*meta.Picture)
			got := pic.Data
			if !bytes.Equal(got, want) {
				t.Errorf("picture data differ; expected %v, got %v", want, got)
			}
			break
		}
	}
}
Esempio n. 7
0
// TODO: better error verification than string-based comparisons.
func TestMissingValue(t *testing.T) {
	_, err := flac.ParseFile("testdata/missing-value.flac")
	if err.Error() != `meta.Block.parseVorbisComment: unable to locate '=' in vector "title 2"` {
		t.Fatal(err)
	}
}