File Coverage

blib/lib/Music/Tag/MusicBrainz.pm

Criterion	Covered	Total	%
statement	10	12	83.3
branch			n/a
condition			n/a
subroutine	4	4	100.0
pod			n/a
total	14	16	87.5

package Music::Tag::MusicBrainz;
use strict; use warnings; use utf8;
our $VERSION = '0.4101';

# Copyright © 2006,2010 Edward Allen III. Some rights reserved.
#
# You may distribute under the terms of either the GNU General Public
# License or the Artistic License, as specified in the README file.

use WebService::MusicBrainz::Artist;
use WebService::MusicBrainz::Release;
use WebService::MusicBrainz::Track;
use Cache::FileCache;
use utf8;
use base qw(Music::Tag::Generic);

sub default_options {
    {   prefered_country         => "US",
        min_artist_score         => 1,
        min_album_score          => 17,
        min_track_score          => 3,
        ignore_mbid              => 0,
        trust_time               => 0,
        trust_track              => 0,
        trust_title              => 0,
        skip_seen                => 0,
        ignore_multidisc_warning => 1,
        mb_host                  => "www.musicbrainz.org",
    };
}

sub required_values {
    return qw( artist);
}

sub set_values {
    return
        qw( album releasedate totaltracks title tracknum title track releasedate);
}

sub get_tag {
    my $self = shift;
    if (   ( $self->options->{skip_seen} )
        && ( length( $self->info->get_data('mb_trackid') ) == 36 ) ) {
        $self->status( "Skipping previously looked up track with mb_trackid "
                . $self->info->get_data('mb_trackid') );
    }
    else {
        $self->artist_info() && $self->album_info() && $self->track_info();
    }
    return $self;
}

sub artist_info {
    my $self = shift;
    $self->status( "Looking up artist from " . $self->options->{mb_host} );
    unless ( exists $self->{mb_a} ) {
        $self->{mb_a} = WebService::MusicBrainz::Artist->new(
            HOST  => $self->options->{mb_host},
            CACHE => $self->mb_cache
        );
    }
    my $params   = {};
    my $maxscore = 0;
    my $artist   = undef;
    if (   ( $self->info->has_data('mb_artistid') )
        && ( not $self->options->{ignore_mbid} ) ) {
        $params->{MBID} = $self->info->get_data('mb_artistid');
        $artist = $self->{mb_a}->search($params);
        unless ( ref($artist) eq "WebService::MusicBrainz::Response::Artist" )
        {
            $artist = $artist->artist();
        }
        $maxscore = 8;
    }
    elsif ( ( $self->info->has_data('artist') ) ) {
        $params->{NAME} = $self->info->get_data('artist');
        my $response = $self->{mb_a}->search($params);
        return unless $response;
        return unless $response->artist_list();
        foreach ( @{ $response->artist_list->artists() } ) {
            my $s = 0;
            if (   ( $self->info->has_data('artist') )
                && ( $_->{name} )
                && ( $self->info->get_data('artist') eq $_->{name} ) ) {
                $s += 16;
            }
            elsif (( $self->info->has_data('artist') )
                && ( $_->{sortname} )
                && ( $self->info->get_data('artist') eq $_->{sortname} ) ) {
                $s += 8;
            }
            elsif (( $self->info->has_data('mb_artistid') )
                && ( $_->{id} )
                && ( $self->info->get_data('mb_artistid') eq $_->{id} ) ) {
                $s += 4;
            }
            elsif (
                   ( $self->info->has_data('artist') )
                && ( $_->{name} )
                && ($self->simple_compare(
                        $self->info->get_data('artist'),
                        $_->{name}, .90
                    )
                )
                ) {
                $s += 2;
            }
            if ( $s > $maxscore ) {
                $artist   = $_;
                $maxscore = $s;
            }
        }
        if ( $maxscore > $self->options->{min_artist_score} ) {
            $self->status( "Artist ", $artist->name, " won election with ",
                $maxscore, "pts" );
        }
        elsif ($maxscore) {
            $self->status( "Artist ", $artist->name, " won election with ",
                $maxscore, "pts, but that is not good enough" );
            return;
        }
        else {
            $self->status("No Artist found");
            return;
        }
    }
    return unless ( defined $artist );
    my %amap = (
        name            => 'artist',
        id              => 'mb_artistid',
        sort_name       => 'sortname',
        type            => 'artist_type',
        life_span_begin => 'artist_start',
        life_span_end   => 'artist_end',

    );

    while ( my ( $k, $v ) = each %amap ) {
        if ( $artist->$k ) {
            unless (( $self->info->has_data($v) )
                and ( ( $self->info->get_data($v) ) eq ( $artist->$k ) ) ) {
                $self->info->set_data( $v => $artist->$k );
                $self->tagchange("ARTIST");
            }
        }
    }
    return $self->info;
}

sub album_info {
    my $self = shift;
    $self->status( "Looking up album from " . $self->options->{mb_host} );
    unless ( exists $self->{mb_r} ) {
        $self->{mb_r} = WebService::MusicBrainz::Release->new(
            HOST  => $self->options->{mb_host},
            CACHE => $self->mb_cache
        );
    }
    my $params = { LIMIT => 200 };
    my $release = undef;
    if (   ( $self->info->has_data('mb_albumid') )
        && ( not $self->info->options->{ignore_mbid} )
        && ( length( $self->info->get_data('mb_albumid') ) > 30 )

        ) {
        $params->{MBID} = $self->info->get_data('mb_albumid');
        my $response = $self->{mb_r}->search($params);
        $release = $response->release();

        #print Dumper($release);
    }
    else {
        if (   ( $self->info->has_data('mb_artistid') )
            && ( $self->info->get_data('mb_artistid') ) ) {
            $params->{artistid} = $self->info->get_data('mb_artistid');
        }
        elsif ( ( $self->info->has_data('artist') )
            && ( $self->info->get_data('artist') ) ) {
                $params->{artist} = $self->info->get_data('artist');
        }
        else {
                $self->status("Artist required for album lookup...");
                return ();
        }

        my $response = $self->{mb_r}->search($params);
        return unless $response;

        #     albumid          256 pts
        #     title             64 pts
        #	    asin              32 pts
        #     simple_title      32 pts
        #	    discid            32 pts
        #	    track_count       16 pts
        #     release_date       8 pts
        #     track name match   4 pts
        #     strack name match  2 pts
        #     track time match   1 pts

        my $releases = $response->release_list();
        return unless $releases;

        my $maxscore = 0;
        foreach ( @{ $releases->releases } ) {
                my $s     = 0;
                my $title = $_->{title};
                my $disc  = 1;
                if ( $title =~ /^(.+) \(disc (\d)(\: ([^)]*))?\)/i ) {
                    $title = $1;
                    $disc  = $2;
                }
                if (    ( $self->info->has_data('mb_albumid') )
                    and ( $self->info->get_data('mb_albumid') eq $_->id )
                    and ( not $self->options->{ignore_mbid} ) ) {
                    $s += 256;
                }
                if ( $title eq $self->info->album ) {
                    $s += 64;
                }
                if (   ( $_->{asin} )
                    && ( $self->info->asin )
                    && ( length( $_->{asin} ) > 8 )
                    && ( $_->{asin} eq $self->info->get_data('asin') ) ) {
                    $s += 32;
                }
                if ($self->simple_compare(
                        $title, $self->info->get_data('album'), .80
                    )
                    ) {
                    $s += 32;
                }
                if (( $self->info->has_data('totaltracks') )
                    and ( ( $self->info->get_data('totaltracks') )
                        == ( $_->track_list->{count} ) )
                    ) {
                    $s += 16;
                }
                if (    ( $self->info->has_data('disc') )
                    and ( defined $disc )
                    and ( ( $self->info->get_data('disc') ) == ($disc) ) ) {
                    $s += 8;
                }
                if ( $s > $maxscore ) {
                    $release  = $_;
                    $maxscore = $s;
                }
        }
        if ( $maxscore > $self->options->{min_album_score} ) {
                $self->status( "Awarding highest score of "
                        . $maxscore . " to "
                        . $release->title );
        }
        elsif ($release) {
                $self->status( "Highest score of "
                        . $maxscore . " to "
                        . $release->title
                        . " is too low" );
                return;
        }
        else {
                $self->status("No good match found for album, sorry\n");
                return;
        }
    }
    if ( $release->type ) {
            unless (
                ( $self->info->has_data('album_type') )
                and ( ( $self->info->get_data('album_type') ) eq
                    ( $release->{type} ) )
                ) {
                $self->info->set_data( 'album_type', $release->{type} );
                $self->tagchange("ALBUM_TYPE");
            }
    }
    if ( $release->id ) {
            unless (
                ( $self->info->has_data('mb_albumid') )
                and ( ( $self->info->get_data('mb_albumid') ) eq
                    ( $release->{id} ) )
                ) {
                $self->info->set_data( 'mb_albumid', $release->id() );
                $self->tagchange("MB_ALBUMID");
            }
    }
    if ( $release->title ) {

# Parse out additional disc information.  I still don't know how to deal with multi-volume sets
# in MusicBrainz.  Style says to use (disc X) or (disc X: Disc Title) or even (box X, disc X).
# for now, I will support in album_title /\(disc (\d):?[^)]*\)/.
            unless ( ( $self->info->has_data('album') )
                && ( $self->info->get_data('album') eq $release->title ) ) {
                if ($release->title() =~ /^(.+) \(disc (\d)(\: ([^)]*))?\)/i )
                {
                    my ( $alb, $disc, $disctitle ) = ( $1, $2, $4 );
                    unless ( $self->info->get_data('album') eq $alb ) {
                        $self->info->set_data( 'album', $1 );
                        $self->tagchange("ALBUM");
                    }
                    unless ( $self->info->get_data('disc') eq $disc ) {
                        $self->info->set_data( 'disc', $2 );
                        $self->tagchange("DISC");
                    }
                    if ($3) {
                        $self->status("Debug disctitle: $disctitle");
                        unless (
                            $self->info->get_data('disctitle') eq $disctitle )
                        {
                            $self->info->set_data( 'disctitle', $disctitle );
                            $self->tagchange("DISCTITLE");
                        }
                    }
                }
                else {
                    $self->info->set_data( 'album', $release->title() );
                    $self->tagchange("ALBUM");
                }
            }
    }
    if ( $release->track_list ) {
            unless (
                ( $self->info->has_data('totaltracks') )
                and ( ( $self->info->get_data('totaltracks') )
                    == ( $release->track_list->{count} ) )
                ) {
                $self->info->get_data( 'totaltracks',
                    $release->track_list->{count} );
                $self->tagchange("TOTALTRACKS");
            }
    }

    if ( exists $release->{asin} ) {
            unless (( $self->info->has_data('asin') )
                and ( $self->info->get_data('asin') eq $release->{asin} ) ) {
                $self->info->set_data( 'asin', $release->{asin} );
                $self->tagchange("ASIN");
            }
    }
    return $self->info;
}

sub track_info {
        my $self = shift;
        if ((   (      $self->info->has_data('totaldiscs')
                    && $self->info->get_data('totaldiscs') > 1
                )
                or (   $self->info->has_data('disc')
                    && $self->info->get_data('disc') > 1 )
            )
            && ( not $self->options->{ignore_multidisc_warning} )
            ) {
            $self->status(
                "Warning! Multi-Disc item. MusicBrainz is not reliable for this. Will not change track name or number."
            );
        }
        $self->status( "Looking up track from " . $self->options->{mb_host} );
        unless ( exists $self->{mb_r} ) {
            $self->{mb_r} = WebService::MusicBrainz::Release->new(
                HOST  => $self->options->{mb_host},
                CACHE => $self->mb_cache
            );
        }
        return unless ( $self->info->has_data('mb_albumid') );
        my $params = {
            MBID => $self->info->get_data('mb_albumid'),
            INC  => "tracks discs release-events",
        };
        my $response = $self->{mb_r}->search($params);
        unless ( $response->release->track_list ) {
            return;
        }
        my $tracks   = $response->release->track_list->tracks();
        my $release  = $response->release;
        my $tracknum = 0;
        my $maxscore = 0;
        my $track    = undef;
        my $trackn   = 0;

        #   track ID (unless ignore_ids)  128 pts
        #   tracknum match                  4 pts
        #    trust track set               64 pts
        #   title match                     8 pts
        #    trust title set               64 pts
        #   close title match               4 pts
        #    trust title set               16 pts
        #   time match                      2 pts
        #    trust time set                64 pts
        #   close time match                1 pts
        #    trust time set                16 pts

        foreach my $t ( @{$tracks} ) {
            my $s = 0;
            if (   ( $self->info->has_data('mb_trackid') )
                && ( $self->info->get_data('mb_trackid') eq $t->{id} )
                && ( not $self->info->{ignore_mbid} ) ) {
                $s += 128;
            }
            if (   ( $self->info->has_data('track') )
                && ( $self->info->get_data('track') - 1 == $tracknum ) ) {
                if ( $self->options->{trust_track} ) {
                    $s += 64;
                }
                else {
                    $s += 4;
                }
            }
            if (   ( $self->info->has_data('title') )
                && ( $self->info->get_data('title') eq $t->{title} ) ) {
                if ( $self->options->{trust_title} ) {
                    $s += 64;
                }
                else {
                    $s += 8;
                }
            }
            elsif (
                ( $self->info->has_data('title') )
                && ($self->simple_compare(
                        $self->info->get_data('title'),
                        $t->{title}, .80
                    )
                )
                ) {
                if ( $self->options->{trust_title} ) {
                    $s += 16;
                }
                else {
                    $s += 4;
                }
            }
            if (   ( $self->info->has_data('duration') )
                && ( exists $t->{duration} )
                && ( defined $t->{duration} ) ) {
                my $diff =
                    abs( $self->info->get_data('duration') - $t->{duration} );
                if ( $diff < 3000 ) {
                    if ( $self->options->{trust_time} ) {
                        $s += 16;
                    }
                    else {
                        $s += 1;
                    }
                }
                elsif ( $diff < 100 ) {
                    $s += 2;
                    if ( $self->options->{trust_time} ) {
                        $s += 64;
                    }
                    else {
                        $s += 1;
                    }
                }
            }
            if ( $s > $maxscore ) {
                $maxscore = $s;
                $track    = $t;
                $trackn   = $tracknum + 1;
            }
            $tracknum++;
        }
        if (   ($maxscore)
            && ( $maxscore > $self->options->{min_track_score} ) ) {
            $self->status( "Awarding highest score of "
                    . $maxscore . " to "
                    . $track->title );
        }
        elsif ($maxscore) {
            $self->status( "Highest score was "
                    . $maxscore . " for "
                    . $track->title
                    . ", but that is not good enough, skipping track info." );
            return;
        }
        else {
            $self->status("No match for track, skipping track info.");
            return;
        }
        unless (
            (   (      $self->info->has_data('totaldiscs')
                    && $self->info->get_data('totaldiscs') > 1
                )
                or (   $self->info->has_data('disc')
                    && $self->info->get_data('disc') > 1 )
            )
            && ( not $self->options->{ignore_multidisc_warning} )
            ) {
            if ( $track->title ) {
                unless (
                    ( $self->info->has_data('title') )
                    and ( ( $self->info->get_data('title') ) eq
                        ( $track->title ) )
                    ) {
                    $self->info->set_data( 'title', $track->title );
                    $self->tagchange("TITLE");
                }
            }
            unless (( $self->info->has_data('track') )
                and ( $self->info->get_data('track') == $trackn ) ) {
                $self->info->set_data( 'track', $trackn );
                $self->tagchange("TRACK");
            }
            if ( $track->id ) {
                unless (
                    ( $self->info->has_data('mb_trackid') )
                    and ( ( $self->info->get_data('mb_trackid') ) eq
                        ( $track->id ) )
                    ) {
                    $self->info->set_data( 'mb_trackid', $track->id );
                    $self->tagchange("MB_TRACKID");
                }
            }
        }
        my $releases = [];
        if ( $release->release_event_list ) {
            $releases = $release->release_event_list->events;
        }
        my $countrycode = undef;
        my $releasedate = undef;
        if ( scalar @{$releases} ) {
            $maxscore = 0;
            foreach ( @{$releases} ) {
                my $score = 0;
                if (   ( $_->date )
                    && ( $self->info->has_data('releasedate') )
                    && ( $_->date eq $self->info->get_data('releasedate') ) )
                {
                    $score += 4;
                }
                elsif ( $_->country eq $self->options->{prefered_country} ) {
                    $score += 2;
                }
                elsif ( not defined $countrycode ) {
                    $score += 1;
                }
                if ( $score > $maxscore ) {
                    $countrycode = $_->country();
                    $releasedate = $_->date();
                    $maxscore    = $score;
                }
            }
        }
        if (($countrycode)
            && (not( ( $self->info->has_data('countrycode') )
                    && ($self->info->get_data('countrycode') eq $countrycode )
                )
            )
            ) {
            $self->info->set_data( 'countrycode', $countrycode );
            $self->tagchange("countrycode");
        }
        if (($releasedate)
            && (not( ( $self->info->has_data('releasedate') )
                    && ($self->info->get_data('releasedate') eq $releasedate )
                )
            )
            ) {
            $self->info->set_data( 'releasedate', $releasedate );
            $self->tagchange("releasedate");
        }
}

sub mb_cache {
        my $self = shift;
        my $new  = shift;
        if ($new) {
            $self->{mb_cache} = $new;
        }
        unless ( ( exists $self->{mb_cache} ) && ( $self->{mb_cache} ) ) {
            if ( $self->options->{mb_cache} ) {
                $self->{mb_cache} = $self->options->{mb_cache};
            }
            else {
                $self->{mb_cache} = Cache::FileCache->new(
                    {   namespace          => "mb_cache",
                        default_expires_in => 60000,
                    }
                );
            }
        }
        return $self->{mb_cache};
}

1;
__END__