head

Image

code

root

para

L<Examples| file:../examples/index.podlite>


L<Download |file:../download/index.podlite>


React

=begin React :component<HeaderCol> :id<menu> 
=para L<Documentation|/doc/introduction>
=para L<Modules| /mods>
=para L<Examples| file:../examples/index.podlite>
=para L<Download |file:../download/index.podlite>
=para L<About|file:../about/index.podlite>
=para 🔍 K<⌘K>/K<ctrl-K>
=end React


HEADER

FOOTER

README

Audio::Hydrogen - work with Hydrogen songs and drumkits


This provides the facilities for creating and manipulating drumkit and
song data of the L<Hydrogen|http://www.hydrogen-music.org/> drum software.


I originally wrote this with no other purpose than as a test for
L<XML::Class|https://github.com/jonathanstowe/XML-Class> so it may well
be missing some features that you would like to see, but please see the
examples for things that you can do with it.


This top level class doesn't provide much on its own as most of the
detail is in the other classes.


This returns a list of all the drumkits found in the places that
Hydrogen would store them, it is a list of C<DrumkitInfo> classes
which simply have two attributes, C<name> (which is the name of
the Drumkit,) and C<path> which is an L<IO::Path> for tne full
path of the drumkit directory, these is a single method C<drumkit>
which returns the L<Audio::Hydrogen::Drumkit> object.


If you have drumkits in a non-standard location you can add that
path to the C<data-paths> attribute before search for the drumkits.



use Audio::Hydrogen::Drumkit;
use Audio::Hydrogen::Song;

class Audio::Hydrogen:ver<0.0.5>:auth<github:jonathanstowe>:api<1.0> {

    class DrumkitInfo {
        has Str $.name;
        has IO::Path $.path;

        method drumkit( --> Audio::Hydrogen::Drumkit ) {
            my $xml = $!path.add('drumkit.xml').slurp;
            my $dk = Audio::Hydrogen::Drumkit.from-xml($xml);
            $dk.make-absolute($!path);
            $dk;
        }
    }

    has @.data-paths = $*HOME.add('.hydrogen/data').Str, '/usr/share/hydrogen/data';

    has DrumkitInfo @.drumkits;

    method drumkits() {
        if @!drumkits.elems == 0 {
            my %seen;
            for @!data-paths.map({ $_.IO }) -> $data-path {
                if $data-path.d && $data-path.add('drumkits').d {
                    for $data-path.add('drumkits').dir -> $d-path {
                        if $d-path.d && $d-path.add('drumkit.xml').f {
                            my $base-name = $d-path.basename;
                            if not %seen{$base-name}:exists {
                                my $drumkit = DrumkitInfo.new(path => $d-path, name => $base-name);
                                @!drumkits.append: $drumkit;
                                %seen{$base-name} = True;
                            }
                        }
                    }
                }
            }
        }
        @!drumkits;
    }
}
# vim: expandtab shiftwidth=4 ft=raku


Hydrogen


use v6;
use NativeCall;
use NativeHelpers::Array;



Audio::Fingerprint::Chromaprint  - Get audio fingerprint using the chromaprint / AcoustID library


=begin code

use Audio::Fingerprint::Chromaprint;
use Audio::Sndfile;

my $fp = Audio::Fingerprint::Chromaprint.new;

my $wav = Audio::Sndfile.new(filename => 'some.wav', :r);

$fp.start($wav.samplerate, $wav.channels);

# Read the whole file at once
my ( $data, $frames ) = $wav.read-short($wav.frames, :raw);

# You can feed multiple times
$fp.feed($data, $frames);

# call finish to indicate done feeding
$fp.finish;

say $fp.fingerprint;

=end code


This provides a mechanism for obtaining a fingerprint of some audio data
using the L<Chromaprint library|https://acoustid.org/chromaprint>, you
can use this to identify recorded audio or determine whether two audio
files are the same for instance.


You need several seconds worth of data in order to be able to get a
usable fingerprint, and for comparison of two files you will need to
ensure that you have the same number of samples, ideally you should
fingerprint the entire audio file, but this may be slow if you have
a large file.


The library only can handle integer PCM audio data, if you need to
deal with encoded data such as MP3 or Ogg/Vorbis you will need to
use another library to decode it to raw samples.


Depending on how the Chromaprint library was built, it may or may not
be safe to have multiple instances created at the same time, so it
is probably safest to take care you only have a single instance in
your application.


method new(Int :$silence-threshold, Algorithm :$algorithm = Test2) returns Audio::Fingerprint::Chromaprint


This is the contructor for the class. If the chromaprint library 
was built with the faster C<fftw> library rather than ffmpeq
then the initialisation of the library is not thread-safe, so
it may be best to avoid having more than one instance at a time
in your application.


If the named parameter C<silence-threshold> is supplied then it should be
in the range of 0 - 32768 and will be used to modify the way in which the
analysis is done. It's probably best not to use this if the fingerprints
are to be shared with other systems, and if it is used it should be the
same for every calculation if the fingerprint is to be compared.


C<algorithm> is a value of the C<enum>
C<Audio::Fingerprint::Chromaprint::Algorithm>, the default is C<Test2>
(the values are C<Test1> to C<Test4>,) they aren't very well documented
so I would suggest sticking to the default. Obviously for
comparison purposes the algorithm used to generate the fingerprints
should be the same.


This returns a Str representing the version of the library being used.


method start(Int $samplerate, Int $channels) returns Bool


This prepares the chromaprint library to begin receiving the
samples for an audio file. This must be called before C<feed>.
The C<$samplerate> and C<$channels> should be an accurate
reflection of the data that is going to be fed.


multi method feed(CArray $data, Int $frames) returns Bool
multi method feed(@frames) returns Bool 


This adds the audio data that is to be analysed, the data
should be interleaved 16 bit signed integers. You will need
several seconds worth of data (which can be fed in pieces,)
to be able to get a usable fingerprint, so, depending on 
the samplerate of the audio data, you may need to feed at
minimum somewhere in the region of 100,000 frames.


The CArray candidate is more efficient as no conversion
needs to be done to the data before passing to the
underlying library function - C<$frames> should be the
number of items in C<$data> divided by the number of
channels, if you are getting the data with Audio::Sndfile
for example then these values will be those returned
by C<read-short> with the C<:raw> adverb.


If you provide C<@frames> as an array, it should contain
a number of indivual samples that is divisible by the
number of channels in the data, this value will be used
to calculate C<$frames>.


If C<start> hasn't been called (or if C<finish> has
already been called without a subsequent C<start> then
an exception will be thrown.


This indicates to the library that the user has done feeding
data and that the remaining buffered data can be used to
calculate the fingerprint, if there is insufficient data
to calculate the fingerprint then the C<libchromaprint> may
rudely print a warning to C<STDERR>.


After C<finish> has been called then C<start> must be called
to allow the feeding of further data as the state of the
engine will be reset.


This returns the calculated fingerprint as a string, if there
was unsufficient data provided then the fingerprint may only
comprise 4 or 5 characters, rather than 23 or so that it 
should be.



class Audio::Fingerprint::Chromaprint {

    constant LIB = [ 'chromaprint', v1 ];

    enum Algorithm ( Test1 => 0, Test2 => 1, Test3 => 2, Test4 => 3);


    sub chromaprint_get_version( --> Str ) is native(LIB) { * }

    method version( --> Str ) {
        chromaprint_get_version();
    }

    class Context is repr('CPointer') {

        sub chromaprint_new(int32 $algorithm --> Context ) is native(LIB)  { * }

        method new(Context:U: Algorithm :$algorithm = Test2 --> Context ) {
            chromaprint_new($algorithm.Int);
        }

        sub chromaprint_free(Context $ctx) is native(LIB) { * }

        method free(Context:D:) {
            chromaprint_free(self);
        }


        sub chromaprint_set_option(Context  $ctx, Str $name, int32 $value --> int32 ) is native(LIB) { * }

        method silence-threshold(Context:D: Int $threshold --> Bool ) {
            my $rc = chromaprint_set_option(self, 'silence_threshold', $threshold);
            Bool($rc);
        }

        sub chromaprint_start(Context $ctx, int32  $sample_rate, int32 $num_channels --> int32 ) is native(LIB) { * }

        method start(Context:D: Int $sample-rate, Int $channels --> Bool ) {
            my $rc = chromaprint_start(self, $sample-rate, $channels);
            Bool($rc);
        }

        sub chromaprint_feed(Context $ctx, CArray[int16] $data, int32 $size --> int32 ) is native(LIB) { * }

        method feed(Context:D: CArray $data, Int $frames --> Bool ) {
            my $rc = chromaprint_feed(self, $data, $frames);
            Bool($rc);
        }

        sub chromaprint_finish(Context $ctx --> int32 ) is native(LIB) { * }

        method finish(Context:D: --> Bool ) {
            my $rc = chromaprint_finish(self);
            Bool($rc);
        }

        sub chromaprint_get_fingerprint(Context $ctx, Pointer[Str]  $fingerprint is rw --> int32 ) is native(LIB) { * }

        method fingerprint(Context:D: --> Str ) {
            my $p = Pointer[Str].new;
            my $rc = chromaprint_get_fingerprint(self, $p);
            my $ret = $p.deref.encode.decode;
            self!dealloc($p);
            $ret;
        }

        sub chromaprint_dealloc_p(Pointer $ptr ) is symbol('chromaprint_dealloc') is native(LIB) { * }

        method !dealloc(Pointer $ptr) {
            chromaprint_dealloc_p($ptr);
        }
    }

    has Context $!context handles <fingerprint free>;

    has Bool $!started = False;

    submethod BUILD(Int :$silence-threshold, Algorithm :$algorithm = Test2) {
        $!context = Context.new(:$algorithm);

        if $silence-threshold.defined {
            $!context.silence-threshold($silence-threshold);
        }
    }

    has Int $!samplerate;
    has Int $!channels;

    method start($!samplerate, $!channels --> Bool ) {
        $!started = $!context.start($!samplerate, $!channels);
    }

    class X::NotStarted is Exception {
        has Str $.message = "start() must be called before feed";
    }

    proto method feed(|c) { * }

    multi method feed(CArray $data, Int $frames --> Bool ) {
        if not $!started {
            X::NotStarted.new.throw;
        }
        $!context.feed($data, $frames);
    }

    multi method feed(@frames --> Bool ) {
        if not $!started {
            X::NotStarted.new.throw;
        }
        my $carray = copy-to-carray(@frames, int16);
        my $frames = (@frames.elems / $!channels).Int;
        $!context.feed($carray, $frames);
    }

    method finish( --> Bool ) {
        if not $!started {
            X::NotStarted.new.throw;
        }
        my $rc = $!context.finish;
        if $rc {
            $!started = False;
        }
        $rc;
    }
}

# vim: expandtab shiftwidth=4 ft=raku


Chromaprint

The Raku Knowledge Base


=begin React :component<HeaderCol> :id<footer>  
=begin nested :!nested
=item1 B<Language>
    =item2 L<Get started|file:../getting-started/getting-started.podlite>
    =item2 L<Why Raku?|/doc/language/faq#Why-should-I-learn-Raku-What's-so-great-about-it>
    =item2 L<Try Raku|https://glot.io/new/raku>
    =item2 L<Raku cheat sheet|https://github.com/Raku/mu/blob/master/docs/Perl6/Cheatsheet/cheatsheet.txt>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<Raku on Exercism|https://exercism.org/tracks/raku>
    =item2 L<Wikipedia|https://en.wikipedia.org/wiki/Raku_(programming_language)>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=begin nested :!nested

=item1 B<L<Documentation|/doc>>
    =item2 L<Getting started, Migration guides from other languages, & Tutorials | file:../doc/introduction.podlite>
    =item2 L<Language References|file:../doc/reference.podlite>
    =item2 L<Type Reference| file:../doc/types.podlite>
    =item2 L<Miscellaneous| file:../doc/miscellaneous.podlite>
    =item2 L<FAQs (Frequently Asked Questions)|/doc/language/faq>
    =item2 L<Community|/doc/language/community>
    =item2 L<The list of all documents|file:../doc/index.podlite>

=item1 B<Resources>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>

=end nested
=begin nested :!nested

=item1 B<Resoures>
    =item2 L<Download | file:../download/index.podlite>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=item1 B<Learning>
    =item2 L<The Raku Guide|https://raku.guide/>
    =item2 L<Wikibook |https://en.wikibooks.org/wiki/Raku_Programming>
    =item2 L<Books |https://perl6book.com/>
    =item2 L<Rosetta Code | https://www.raku.org/community/rosettacode>
    =item2 L<Learn Raku in Y minutes|https://learnxinyminutes.com/docs/raku/>
    =item2 L<Golfing |https://github.com/AlexDaniel/raku-golf-cheatsheet>
=end nested
=begin nested :!nested

=item1 B<Explore>
    =item2 L<Raku Blog Aggregator|https://planet.raku.org/>
    =item2 L<Rakudo Weekly|https://rakudoweekly.blog/>
    =item2 L<The Weekly Challenge |https://perlweeklychallenge.org/>
    =item2 L<Raku Advent Calendar|https://raku-advent.blog/>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>
    =item2 L<empty|#>

=end nested
=end React


=begin React :component<CookieConsent> :id<CookieConsent> :buttonCaption("Got it!")
=para
This website uses cookies for analytics.
=end React


README

Audio::Fingerprint::Chromaprint

image i_github_com_jonathanstowe_audio_fingerprint_chromaprint_workflows_ci_badge_svg not found

Synopsis

Description

Installation

Support

Copyright & Licence

Audio::Fingerprint::Chromaprint v0.0.4

Authors

License

Dependencies

Test Dependencies

Provides

Documentation