File Coverage

blib/lib/MP3/Cut/Gapless.pm

Criterion	Covered	Total	%
statement	60	65	92.3
branch	17	24	70.8
condition	4	7	57.1
subroutine	7	7	100.0
pod	3	3	100.0
total	91	106	85.8

package MP3::Cut::Gapless;

use strict;

our $VERSION = '0.03';

require XSLoader;
XSLoader::load('MP3::Cut::Gapless', $VERSION);

sub new {
    my ( $class, %args ) = @_;

    if ( !$args{file} && !$args{cue} ) {
        die "Either file or cue argument must be specified";
    }

    my $self = bless \%args, $class;

    if ( $self->{cue} ) {
        $self->_parse_cue;
    }

    if ( !-f $self->{file} ) {
        die "Invalid file: $self->{file}";
    }

    if ( $self->{cache_dir} ) {
        require Digest::MD5;
        require File::Spec;

        if ( !-d $self->{cache_dir} ) {
            require File::Path;
            File::Path::mkpath( $self->{cache_dir} );
        }

        # Cache key is filename + size + mtime so if the file changes
        # we will not read a stale cache file.
        my ($size, $mtime) = (stat $self->{file})[7, 9];
        $self->{cache_file} = File::Spec->catfile(
            $self->{cache_dir},
            Digest::MD5::md5_hex( $self->{file} . $size . $mtime ) . '.mllt'
        );
    }

    # Pre-scan the file for the range we will be cutting
    $self->_init;

    return $self;
}

sub tracks {
    my $self = shift;

    return @{ $self->{_tracks} || [] };
}

sub write {
    my ( $self, $track, $filename ) = @_;

    if ( !$filename ) {
        # Default filename is "position - performer - title.mp3"
        $filename = join(' - ', $track->{position}, $track->{performer}, $track->{title}) . '.mp3';
    }

    if ( -e $filename ) {
        warn "$filename already exists, will not overwrite\n";
        return;
    }

    # Reset XS counter for read()
    $self->__reset_read();

    delete $self->{start_ms};
    delete $self->{end_ms};

    $self->{start_ms} = $track->{start_ms};
    $self->{end_ms}   = $track->{end_ms} if $track->{end_ms};

    print "Writing $filename...\n";

    open my $fh, '>', $filename;
    while ( $self->read( my $buf, 65536 ) ) {
        syswrite $fh, $buf;
    }
    close $fh;
}

# read() is implemented in XS

sub _init {
    my $self = shift;

    open $self->{_fh}, '<', $self->{file} || die "Unable to open $self->{file} for reading";

    binmode $self->{_fh};

    # XS init
    $self->{_mp3c} = $self->__init(@_);
}

sub _parse_cue {
    my $self = shift;

    require Audio::Cuefile::Parser;
    require MP3::Cut::Gapless::Track;
    require File::Spec;

    my $cue = Audio::Cuefile::Parser->new( $self->{cue} );

    if ( !$self->{file} ) {
        $self->{file} = $cue->file || die "No FILE entry found in cue sheet";

        # Handle relative path
        my ($vol, $dirs, $file) = File::Spec->splitpath( $self->{file} );
        if ( $dirs !~ m{^[/\\]} ) {
            my ($cvol, $cdirs, undef) = File::Spec->splitpath( File::Spec->rel2abs( $self->{cue} ) );
            $self->{file} = File::Spec->rel2abs( $self->{file}, File::Spec->catdir($cvol, $cdirs) );
        }
    }

    $self->{_tracks} = [];
    for my $track ( $cue->tracks ) {
        push @{ $self->{_tracks} }, MP3::Cut::Gapless::Track->new($track);
    }

    # Set end_ms values, last track will fill to the end
    for ( my $i = 0; $i < scalar @{ $self->{_tracks} } - 1; $i++ ) {
        $self->{_tracks}->[$i]->{end_ms} = $self->{_tracks}->[$i + 1]->{start_ms};
    }
}

sub DESTROY {
    my $self = shift;

    close $self->{_fh};

    $self->__cleanup( $self->{_mp3c} ) if exists $self->{_mp3c};
}

1;
__END__