Merge pull request #11 from mutablelogic/5.1

Updated chromaprint

Author: djthorpe

Makefile

@@ -1,12 +1,13 @@
 # Paths to packages
 GO=$(shell which go)
+DOCKER=$(shell which docker)
 
 # Paths to locations, etc
 BUILD_DIR := "build"
 CMD_DIR := $(filter-out cmd/README.md, $(wildcard cmd/*))
 
 # Build flags
-BUILD_MODULE = "github.com/mutablelogic/go-media"
+BUILD_MODULE := $(shell go list -m)
 BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/config.GitSource=${BUILD_MODULE}
 BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/config.GitTag=$(shell git describe --tags)
 BUILD_LD_FLAGS += -X $(BUILD_MODULE)/pkg/config.GitBranch=$(shell git name-rev HEAD --name-only --always)
@@ -28,6 +29,15 @@ $(PLUGIN_DIR): FORCE
 
 FORCE:
 
+docker:
+	@echo Build docker image
+	@${DOCKER} build \
+	    --tag go-media:$(shell git describe --tags) \
+		--build-arg PLATFORM=$(shell ${GO} env GOOS) \
+		--build-arg ARCH=$(shell ${GO} env GOARCH) \
+		--build-arg VERSION=kinetic \
+		-f etc/docker/Dockerfile .
+
 test: clean dependencies
 	@echo Test sys/
 	@${GO} test ./sys/...

chromaprint.go

@@ -0,0 +1,22 @@
+package media
+
+import (
+	"io"
+)
+
+////////////////////////////////////////////////////////////////////////////////
+// TYPES
+
+// Chromaprint is a wrapper around the chromaprint library. Create a new
+// Chromaprint object by calling chromaprint.New(sample_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)
+}

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
+}

cmd/transcode/main.go

@@ -119,9 +119,6 @@ func main() {
 		os.Exit(-2)
 	}
 
-	// Print the map
-	media_map.PrintMap(os.Stdout)
-
 	// For the output, we can output to a device, a URL, or a file
 	var out Media
 	if reDeviceName.MatchString(flags.Out()) {
@@ -138,6 +135,25 @@ func main() {
 		os.Exit(-2)
 	}
 
+	// For each input stream, add an output
+	for _, stream := range media_map.Streams(flags.MediaFlags()) {
+		// TODO
+		// If audio, then resample data
+		switch {
+		case stream.Flags().Is(MEDIA_FLAG_AUDIO):
+			if err := media_map.Resample(AudioFormat{
+				Rate:   11025,
+				Format: SAMPLE_FORMAT_U8,
+			}, stream); err != nil {
+				fmt.Fprintln(os.Stderr, "Cannot resample audio stream:", err)
+				os.Exit(-2)
+			}
+		}
+	}
+
+	// Print the map
+	media_map.PrintMap(os.Stdout)
+
 	// Create a cancellable context
 	ctx := contextForSignal(os.Interrupt)
 

etc/docker/Dockerfile

@@ -1,12 +1,26 @@
 # recommended way to build is using:
 # docker build \
-#   --build-arg PLATFORM=linux --build-arg ARCH=amd64 --build-arg VERSION=bullseye \
+#   --build-arg PLATFORM=linux --build-arg ARCH=amd64 --build-arg VERSION=focal \
 #   -f etc/docker/Dockerfile .
 #
+# ${VERSION} should be "focal"
 ARG PLATFORM
 ARG ARCH
 ARG VERSION
-FROM --platform=${PLATFORM}/${ARCH} golang:1.19-${VERSION} AS builder
+FROM --platform=${PLATFORM}/${ARCH} ubuntu:${VERSION} AS builder
+
+# update the base packages
+ENV DEBIAN_FRONTEND="noninteractive" TZ="Europe/Berlin"
+RUN apt-get update -y && apt-get upgrade -y
+
+# install packages
+RUN apt-get install -y apt-utils golang make pkg-config ca-certificates lsb-release software-properties-common
+
+# install other build dependencies
+# note we need to install ffmpeg 4 from a different repo for bionic
+RUN apt-get install -y  \
+  libavcodec-dev libavdevice-dev libavfilter-dev \
+  libavformat-dev libswresample-dev libavutil-dev libchromaprint-dev
 
 # Run makefile to build command-line tools
 WORKDIR /usr/src/app

etc/test/audio_22050_1ch_5m35.s16le

@@ -105,22 +105,24 @@ type Map interface {
 	// Return input media
 	Input() Media
 
-	// Return streams which are mapped for decoding
-	Streams() []Stream
+	// Return a single stream which is mapped for decoding, filtering by
+	// stream type. Returns nil if there is no selection of that type
+	Streams(MediaFlag) []Stream
 
 	// Print a summary of the mapping
 	PrintMap(w io.Writer)
+
+	// Resample an audio stream
+	Resample(AudioFormat, Stream) error
+
+	// Encode to output media using default codec from a specific stream
+	//Encode(Media, Stream) error
 }
 
 // Media is a source or destination of media
 type Media interface {
 	io.Closer
 
-	// Return best streams for specific types (video, audio, subtitle, data or attachment)
-	// or returns empty slice if no streams of that type are in the media file. Only returns
-	// one stream of each type.
-	//StreamsByType(MediaFlag) []Stream
-
 	// URL for the media
 	URL() string
 
@@ -130,6 +132,9 @@ type Media interface {
 	// Return media flags for the media
 	Flags() MediaFlag
 
+	// Return the format of the media
+	Format() MediaFormat
+
 	// Return metadata for the media
 	Metadata() Metadata