Added chromaprint client and duration metadata

Author: djthorpe

metadata.go

@@ -15,7 +15,8 @@ type metadata struct {
 }
 
 const (
-	MetaArtwork = "artwork"
+	MetaArtwork  = "artwork"  // Metadata key for artwork, sets the value as []byte
+	MetaDuration = "duration" // Metadata key for duration, sets the value as float64 (seconds)
 )
 
 ////////////////////////////////////////////////////////////////////////////////

pkg/chromaprint/client.go

@@ -1,225 +1,86 @@
 package chromaprint
 
 import (
-	"encoding/json"
-	"errors"
 	"fmt"
-	"io/ioutil"
-	"mime"
-	"net/http"
 	"net/url"
-	"os"
-	"path/filepath"
 	"time"
 
+	// Packages
+	"github.com/mutablelogic/go-client"
+
 	// Namespace imports
 	. "github.com/djthorpe/go-errors"
 )
 
-////////////////////////////////////////////////////////////////////////////////
+///////////////////////////////////////////////////////////////////////////////
 // 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
-}
-
 type Client struct {
-	Config
-	*http.Client
-	*url.URL
-	last time.Time
+	*client.Client
+	key string
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // GLOBALS
 
 const (
 	// Register a clientId: https://acoustid.org/login
-	defaultClientId = "-YectPtndAM"
-
-	// Timeout requests after 15 seconds
-	defaultTimeout = 15 * time.Second
+	defaultApiKey = "-YectPtndAM"
 
 	// The API endpoint
-	baseUrl = "https://api.acoustid.org/v2"
+	endPoint = "https://api.acoustid.org/v2"
 
 	// defaultQps rate limits number of requests per second
 	defaultQps = 3
 )
 
-var (
-	ErrQueryRateExceeded = errors.New("query rate exceeded")
-)
+///////////////////////////////////////////////////////////////////////////////
+// LIFECYCLE
 
-var (
-	DefaultConfig = Config{
-		Key:     defaultClientId,
-		Timeout: defaultTimeout,
-		Rate:    defaultQps,
-		Base:    baseUrl,
+// Create a new client
+func NewClient(ApiKey string, opts ...client.ClientOpt) (*Client, error) {
+	// Check for missing API key
+	if ApiKey == "" {
+		ApiKey = defaultApiKey
 	}
-)
-
-////////////////////////////////////////////////////////////////////////////////
-// NEW
-
-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
-	}
-}
-
-func NewClientWithConfig(cfg Config) (*Client, error) {
-	client := new(Client)
-	client.Config = cfg
 
-	// Set parameters
-	if client.Config.Timeout == 0 {
-		client.Config.Timeout = DefaultConfig.Timeout
-	}
-	if client.Key == "" {
-		client.Key = os.ExpandEnv(DefaultConfig.Key)
-	}
-	if client.Base == "" {
-		client.Base = DefaultConfig.Base
-	}
-	if client.Rate == 0 {
-		client.Rate = DefaultConfig.Rate
-	}
-
-	// Create HTTP client
-	client.Client = &http.Client{
-		Timeout: client.Config.Timeout,
-	}
-	url, err := url.Parse(client.Base)
+	// Create client
+	opts = append(opts, client.OptEndpoint(endPoint))
+	client, err := client.New(opts...)
 	if err != nil {
 		return nil, err
-	} else {
-		client.URL = url
 	}
-	// Fudge key into URL
-	v := url.Query()
-	v.Set("client", client.Key)
-	url.RawQuery = v.Encode()
 
-	// Return success
-	return client, nil
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// STRINGIFY
-
-func (client *Client) String() string {
-	str := "<chromaprint"
-	if u := client.URL; u != nil {
-		str += fmt.Sprintf(" url=%q", u.String())
-	}
-	if rate := client.Rate; rate > 0 {
-		str += fmt.Sprintf(" rate=%dops/s", rate)
-	}
-	if timeout := client.Client.Timeout; timeout > 0 {
-		str += fmt.Sprintf(" timeout=%v", timeout)
-	}
-	return str + ">"
+	// Return the client
+	return &Client{
+		Client: client,
+		key:    ApiKey,
+	}, nil
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // LOOKUP
 
-func (client *Client) Lookup(fingerprint string, duration time.Duration, flags Meta) ([]*ResponseMatch, error) {
+// Lookup a fingerprint with a duration and the metadata that needs to be
+// returned
+func (c *Client) Lookup(fingerprint string, duration time.Duration, flags Meta) ([]*ResponseMatch, error) {
 	// Check incoming parameters
 	if fingerprint == "" || duration == 0 || flags == META_NONE {
 		return nil, ErrBadParameter.With("Lookup")
 	}
 
-	// Check Qps
-	if client.last.IsZero() {
-		if time.Since(client.last) < (time.Second / defaultQps) {
-			return nil, ErrQueryRateExceeded
-		}
-	}
-
 	// Set URL parameters
 	params := url.Values{}
+	params.Set("client", c.key)
 	params.Set("fingerprint", fingerprint)
 	params.Set("duration", fmt.Sprint(duration.Truncate(time.Second).Seconds()))
 	params.Set("meta", flags.String())
-	url := client.requestUrl("lookup", params)
-	if url == nil {
-		return nil, ErrBadParameter.With("Lookup")
-	}
 
-	//fmt.Println(url.String())
-
-	// Perform request
-	now := time.Now()
-	req, err := http.NewRequest(http.MethodGet, url.String(), nil)
-	if err != nil {
+	// Request -> Response
+	var response Response
+	if err := c.Do(nil, &response, client.OptPath("lookup"), client.OptQuery(params)); err != nil {
 		return nil, err
+	} else {
+		return response.Results, nil
 	}
-	response, err := client.Client.Do(req)
-	if err != nil {
-		return nil, err
-	}
-	defer response.Body.Close()
-
-	// Read response body
-	body, err := ioutil.ReadAll(response.Body)
-	if err != nil {
-		return nil, err
-	}
-
-	// Decode response body
-	var r Response
-	if mimeType, _, err := mime.ParseMediaType(response.Header.Get("Content-type")); err != nil {
-		return nil, ErrUnexpectedResponse.With(err)
-	} else if mimeType != "application/json" {
-		return nil, ErrUnexpectedResponse.With(mimeType)
-	} else if err := json.Unmarshal(body, &r); err != nil {
-		return nil, ErrUnexpectedResponse.With(err)
-	}
-
-	// Check for errors
-	if r.Status != "ok" {
-		return nil, ErrBadParameter.Withf("%v (code %v)", r.Error.Message, r.Error.Code)
-	} else if response.StatusCode != http.StatusOK {
-		return nil, ErrBadParameter.Withf("%v (code %v)", response.Status, response.StatusCode)
-	}
-
-	// Set response time for calculating qps
-	client.last = now
-
-	// Return success
-	return r.Results, nil
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// PRIVATE METHODS
-
-func (client *Client) requestUrl(path string, v url.Values) *url.URL {
-	url, err := url.Parse(client.URL.String())
-	if err != nil {
-		return nil
-	}
-	// Copy params
-	params := client.URL.Query()
-	for k := range v {
-		params[k] = v[k]
-	}
-	url.RawQuery = params.Encode()
-
-	// Set path
-	url.Path = filepath.Join(url.Path, path)
-
-	// Return URL
-	return url
 }

pkg/chromaprint/client_test.go

@@ -5,6 +5,9 @@ import (
 	"testing"
 	"time"
 
+	"github.com/stretchr/testify/assert"
+
+	// Namespace imports
 	. "github.com/mutablelogic/go-media/pkg/chromaprint"
 )
 
@@ -24,48 +27,50 @@ const (
 ////////////////////////////////////////////////////////////////////////////////
 // TESTS
 
-func Test_Client_001(t *testing.T) {
-	client := NewClient("${CHROMAPRINT_KEY}")
+func GetKey(t *testing.T) string {
+	key := os.Getenv("CHROMAPRINT_KEY")
+	if key == "" {
+		t.Skip("No API key set, set using environment variable CHROMAPRINT_KEY")
+	}
+	return key
+}
+
+func Test_client_001(t *testing.T) {
+	assert := assert.New(t)
+	client, err := NewClient(GetKey(t))
+	if !assert.NoError(err) {
+		t.SkipNow()
+	}
 	if client == nil {
 		t.Fatal("Failed to create client")
 	} else {
 		t.Log(client)
 	}
 }
 
-func Test_Client_002(t *testing.T) {
-	key := os.Getenv("CHROMAPRINT_KEY")
-	if key == "" {
-		t.Skip("No API key set, set using environment variable CHROMAPRINT_KEY")
-	}
-	client, err := NewClientWithConfig(Config{Key: key})
-	if err != nil {
-		t.Fatal(err)
-	}
-	if matches, err := client.Lookup("AQAAT0mUaEkSRZEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 5*time.Second, META_TRACK); err != nil {
-		t.Error(err)
-	} else if len(matches) != 0 {
-		t.Error("Unexpected matches")
+func Test_client_002(t *testing.T) {
+	assert := assert.New(t)
+	client, err := NewClient(GetKey(t))
+	if !assert.NoError(err) {
+		t.SkipNow()
 	}
+	matches, err := client.Lookup("AQAAT0mUaEkSRZEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA", 5*time.Second, META_TRACK)
+	assert.NoError(err)
+	t.Log(matches)
 }
 
-func Test_Client_003(t *testing.T) {
-	key := os.Getenv("CHROMAPRINT_KEY")
-	if key == "" {
-		t.Skip("No API key set, set using environment variable CHROMAPRINT_KEY")
-	}
-	client, err := NewClientWithConfig(Config{Key: key})
-	if err != nil {
-		t.Fatal(err)
+func Test_client_003(t *testing.T) {
+	assert := assert.New(t)
+	client, err := NewClient(GetKey(t))
+	if !assert.NoError(err) {
+		t.SkipNow()
 	}
 
-	if matches, err := client.Lookup(SAMPLE_001_FINGERPRINT, SAMPLE_001_DURATION, META_ALL); err != nil {
-		t.Error(err)
-	} else if len(matches) == 0 {
-		t.Error("No matches")
-	} else {
-		t.Log(matches)
+	matches, err := client.Lookup(SAMPLE_001_FINGERPRINT, SAMPLE_001_DURATION, META_ALL)
+	if !assert.NoError(err) {
+		t.SkipNow()
 	}
+	t.Log(matches)
 }
 
 /*
@@ -87,7 +92,6 @@ func Test_Client_004(t *testing.T) {
 		t.Log(matches)
 	}
 }
-*/
 
 func Test_Client_005(t *testing.T) {
 	key := os.Getenv("CHROMAPRINT_KEY")
@@ -107,3 +111,5 @@ func Test_Client_005(t *testing.T) {
 		t.Log(matches)
 	}
 }
+
+*/

reader.go

@@ -208,6 +208,14 @@ func (r *reader) Metadata(keys ...string) []Metadata {
 		}
 	}
 
+	// Add duration
+	if len(keys) == 0 || slices.Contains(keys, MetaDuration) {
+		duration := r.input.Duration()
+		if duration > 0 {
+			result = append(result, newMetadata(MetaDuration, float64(duration)/float64(ff.AV_TIME_BASE)))
+		}
+	}
+
 	// Obtain any artwork from the streams
 	if slices.Contains(keys, MetaArtwork) {
 		for _, stream := range r.input.Streams() {

sys/ffmpeg61/avformat.go

@@ -256,6 +256,10 @@ func (ctx *AVFormatContext) Flags() AVFormat {
 	return AVFormat(ctx.flags)
 }
 
+func (ctx *AVFormatContext) Duration() int64 {
+	return int64(ctx.duration)
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // AVFormatFlag