Updated

Author: djthorpe

cmd/fingerprint/main.go

@@ -0,0 +1,127 @@
+/*
+An example of fingerprinting audio and recognizing the any music tracks within the audio.
+*/
+package main
+
+import (
+	"encoding/binary"
+	"errors"
+	"flag"
+	"fmt"
+	"io"
+	"os"
+	"time"
+
+	// Packages
+	chromaprint "github.com/mutablelogic/go-media/pkg/chromaprint"
+	config "github.com/mutablelogic/go-media/pkg/config"
+)
+
+var (
+	flagVersion  = flag.Bool("version", false, "Print version information")
+	flagRate     = flag.Int("rate", 22050, "Sample rate")
+	flagChannels = flag.Int("channels", 1, "Number of channels")
+	flagKey      = flag.String("key", "${CHROMAPRINT_KEY}", "AcoustID API key")
+	flagLength   = flag.Duration("length", 2*time.Minute, "Restrict the duration of the processed input audio")
+	flagDuration = flag.Duration("duration", 0, "The actual duration of the audio file")
+)
+
+const (
+	bufsize = 1024 * 64 // Number of bytes to read at a time
+)
+
+func main() {
+	flag.Parse()
+
+	// Check for version
+	if *flagVersion {
+		config.PrintVersion(flag.CommandLine.Output())
+		chromaprint.PrintVersion(flag.CommandLine.Output())
+		os.Exit(0)
+	}
+
+	// Check arguments
+	if flag.NArg() != 1 {
+		flag.Usage()
+		os.Exit(-1)
+	}
+
+	// Open file
+	info, err := os.Stat(flag.Arg(0))
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-2)
+	}
+	if info.Size() == 0 {
+		fmt.Fprintln(os.Stderr, "file is empty")
+		os.Exit(-2)
+	}
+
+	// Open the file
+	r, err := os.Open(flag.Arg(0))
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-2)
+	}
+	defer r.Close()
+
+	// Create fingerprinter, write samples
+	size := int(info.Size() >> 1)
+	fingerprint := chromaprint.New(*flagRate, *flagChannels, *flagLength)
+	samples := make([]int16, bufsize)
+	for {
+		// Adjust buffer size
+		sz := MinInt(bufsize, size)
+		size -= sz
+		if sz == 0 {
+			break
+		}
+
+		// Read samples
+		if err := binary.Read(r, binary.LittleEndian, samples[:sz]); errors.Is(err, io.EOF) {
+			break
+		} else if err != nil {
+			fmt.Fprintln(os.Stderr, "Unexpected error:", err)
+			os.Exit(-2)
+		}
+
+		// Write samples
+		if _, err := fingerprint.Write(samples); err != nil {
+			fmt.Fprintln(os.Stderr, err)
+			os.Exit(-2)
+		}
+	}
+
+	// Get fingerprint
+	str, err := fingerprint.Finish()
+	if err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-2)
+	}
+
+	// Get duration
+	duration := fingerprint.Duration()
+	if *flagDuration != 0 {
+		duration = *flagDuration
+	}
+
+	// Create client, make matches
+	client := chromaprint.NewClient(*flagKey)
+	if matches, err := client.Lookup(str, duration, chromaprint.META_ALL); err != nil {
+		fmt.Fprintln(os.Stderr, err)
+		os.Exit(-2)
+	} else if len(matches) == 0 {
+		fmt.Fprintln(os.Stderr, "No matches found")
+	} else {
+		for _, match := range matches {
+			fmt.Println(match)
+		}
+	}
+}
+
+func MinInt(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
+}

etc/test/audio_22050_1ch_5m35.s16le

@@ -8,6 +8,7 @@ import (
 	"mime"
 	"net/http"
 	"net/url"
+	"os"
 	"path/filepath"
 	"time"
 
@@ -19,10 +20,10 @@ import (
 // TYPES
 
 type Config struct {
-	Key     string        `yaml:key`     // AcuostId Web Service Key
-	Timeout time.Duration `yaml:timeout` // AcoustId Client timeout
-	Rate    uint          `yaml:rate`    // Maximum requests per second
-	Base    string        `yaml:base`    // Base URL
+	Key     string        `yaml:"key"`     // AcuostId Web Service Key
+	Timeout time.Duration `yaml:"timeout"` // AcoustId Client timeout
+	Rate    uint          `yaml:"rate"`    // Maximum requests per second
+	Base    string        `yaml:"base"`    // Base URL
 }
 
 type Client struct {
@@ -50,7 +51,7 @@ const (
 )
 
 var (
-	ErrQueryRateExceeded = errors.New("Query Rate Exceeded")
+	ErrQueryRateExceeded = errors.New("query rate exceeded")
 )
 
 var (
@@ -65,8 +66,12 @@ var (
 ////////////////////////////////////////////////////////////////////////////////
 // NEW
 
-func NewClient() *Client {
-	if client, err := NewClientWithConfig(DefaultConfig); err != nil {
+func NewClient(key string) *Client {
+	config := DefaultConfig
+	if key != "" {
+		config.Key = os.ExpandEnv(key)
+	}
+	if client, err := NewClientWithConfig(config); err != nil {
 		return nil
 	} else {
 		return client
@@ -82,7 +87,7 @@ func NewClientWithConfig(cfg Config) (*Client, error) {
 		client.Config.Timeout = DefaultConfig.Timeout
 	}
 	if client.Key == "" {
-		client.Key = DefaultConfig.Key
+		client.Key = os.ExpandEnv(DefaultConfig.Key)
 	}
 	if client.Base == "" {
 		client.Base = DefaultConfig.Base
@@ -153,6 +158,8 @@ func (client *Client) Lookup(fingerprint string, duration time.Duration, flags M
 		return nil, ErrBadParameter.With("Lookup")
 	}
 
+	//fmt.Println(url.String())
+
 	// Perform request
 	now := time.Now()
 	req, err := http.NewRequest(http.MethodGet, url.String(), nil)

etc/test/s16le_22050_1ch_audio.raw

@@ -25,7 +25,7 @@ const (
 // TESTS
 
 func Test_Client_001(t *testing.T) {
-	client := NewClient()
+	client := NewClient("${CHROMAPRINT_KEY}")
 	if client == nil {
 		t.Fatal("Failed to create client")
 	} else {

etc/test/s16le_44100_1ch_audio.raw

@@ -2,6 +2,7 @@ package chromaprint
 
 import (
 	"io"
+	"time"
 	"unsafe"
 
 	// Packages
@@ -11,30 +12,34 @@ import (
 ////////////////////////////////////////////////////////////////////////////////
 // TYPES
 
-// Chromaprint is a wrapper around the chromaprint library. Create a new
-// Chromaprint object by calling New(rate,channels)
-type Chromaprint interface {
-	io.Closer
-
-	// Write sample data to the fingerprinter. Expects 16-bit signed integers
-	// and returns number of samples written
-	Write([]int16) (int64, error)
-
-	// Finish the fingerprinting, and compute the fingerprint, return as a
-	// string
-	Finish() (string, error)
-}
-
 type fingerprint struct {
-	n   int64
-	ctx *chromaprint.Context
+	rate, channels int
+	duration       time.Duration
+	n              int64
+	ctx            *chromaprint.Context
 }
 
+////////////////////////////////////////////////////////////////////////////////
+// CONSTANTS
+
+const (
+	defaultDuration = 2 * time.Minute
+)
+
 ////////////////////////////////////////////////////////////////////////////////
 // LIFECYCLE
 
-// Create a new fingerprint context
-func New(rate, channels int) *fingerprint {
+// Create a new fingerprint context, with the expected sample rate,
+// number of channels and the maximum duration of the data to put into
+// the fingerprint. Returns nil if the context could not be created.
+func New(rate, channels int, duration time.Duration) *fingerprint {
+	// Check arguments
+	if rate <= 0 || channels <= 0 || duration <= 0 {
+		return nil
+	} else if duration == 0 {
+		duration = defaultDuration
+	}
+
 	// Create a context
 	ctx := chromaprint.NewChromaprint(chromaprint.ALGORITHM_DEFAULT)
 	if ctx == nil {
@@ -46,7 +51,7 @@ func New(rate, channels int) *fingerprint {
 		return nil
 	}
 	// Return success
-	return &fingerprint{0, ctx}
+	return &fingerprint{rate, channels, duration, 0, ctx}
 }
 
 // Close the fingerprint to release resources
@@ -72,8 +77,10 @@ func (fingerprint *fingerprint) Write(data []int16) (int64, error) {
 	if fingerprint.ctx == nil {
 		return 0, io.ErrClosedPipe
 	}
-	if err := fingerprint.ctx.WritePtr(uintptr(unsafe.Pointer(&data[0])), len(data)); err != nil {
-		return 0, err
+	if fingerprint.Duration() < fingerprint.duration {
+		if err := fingerprint.ctx.WritePtr(uintptr(unsafe.Pointer(&data[0])), len(data)); err != nil {
+			return 0, err
+		}
 	}
 	fingerprint.n += int64(len(data))
 	return fingerprint.n, nil
@@ -89,3 +96,11 @@ func (fingerprint *fingerprint) Finish() (string, error) {
 	}
 	return fingerprint.ctx.GetFingerprint()
 }
+
+// Return the duration of the sampled data
+func (fingerprint *fingerprint) Duration() time.Duration {
+	if fingerprint.ctx == nil {
+		return 0
+	}
+	return time.Duration(fingerprint.n) * time.Second / time.Duration(fingerprint.rate*fingerprint.channels)
+}

etc/test/s16le_44100_2ch_audio.raw

@@ -5,14 +5,15 @@ import (
 	"io"
 	"os"
 	"testing"
+	"time"
 
 	"github.com/mutablelogic/go-media/pkg/chromaprint"
 	"github.com/stretchr/testify/assert"
 )
 
 const (
 	// Test data
-	testData1 = "../../etc/test/s16le_22050_1ch_audio.raw"
+	testData1 = "../../etc/test/audio_22050_1ch_5m35.s16le"
 )
 
 func Test_fingerprint_000(t *testing.T) {
@@ -21,14 +22,14 @@ func Test_fingerprint_000(t *testing.T) {
 
 func Test_fingerprint_001(t *testing.T) {
 	assert := assert.New(t)
-	fingerprint := chromaprint.New(22050, 1)
+	fingerprint := chromaprint.New(22050, 1, 5*time.Minute+35*time.Second)
 	assert.NotNil(fingerprint)
 	assert.NoError(fingerprint.Close())
 }
 
 func Test_fingerprint_002(t *testing.T) {
 	assert := assert.New(t)
-	fingerprint := chromaprint.New(22050, 1)
+	fingerprint := chromaprint.New(22050, 1, 5*time.Minute+35*time.Second)
 	assert.NotNil(fingerprint)
 
 	r, err := os.Open(testData1)