rendered paste body#!/usr/bin/perl
###############################################################################
# #
# ARFlac.pl #
# #
# KitchenStaff (Kitchen.Staff.Supervisor@gmail.com) #
# #
# Many thanks to Mr. Spoon for his kind permission to use the AccurateRip #
# technology and database. Access to AccurateRip is regulated, see #
# http://www.accuraterip.com/3rdparty-access.htm for details. #
# #
# Original ARCue script by Christopher Key <cjk32@cam.ac.uk> #
# #
# This script allows the usage of AccurateRip's extensive track checksum #
# database to verify the accuracy of directories of flac files. To use, #
# simply run: #
# #
# ARFlac.pl Flacdir1 Flacdir2 etc... #
# #
# OMGoptimized by infi/08 #
# #
###############################################################################
use Inline C;
use strict;
use LWP;
use Carp;
use Proc::ParallelLoop;
my $numcores = 2;
my $lwpUserAgent = LWP::UserAgent->new;
foreach my $flacDir (@ARGV) {
# Get the list of flac files from the directory
print $flacDir . ":";
opendir CURDIR, $flacDir;
my @flaclist = readdir CURDIR;
closedir CURDIR;
my @filelist = grep {/flac$/i} @flaclist;
@filelist = sort @filelist;
# We need track offsets in 'frames'
# can get these from metaflac
my (@trackOffsets,@trackLengths);
my $tn=0;
my $tmpl=0;
foreach my $fl (@filelist) {
$tmpl = `metaflac --show-total-samples "$flacDir/$fl"`;
$trackLengths[$tn] = $tmpl/588;
$tn++;
}
my $trackCount = $tn;
my $curoff = 0;
$trackOffsets[0] = 0;
for ($tmpl = 1; $tmpl <= $trackCount; $tmpl++) {
$curoff += $trackLengths[$tmpl-1];
$trackOffsets[$tmpl] = $curoff;
}
# Calculate the three disc ids used by AR
my ($discId1, $discId2, $cddbDiscId) = (0, 0, 0);
{
use integer;
for (my $trackNo = 0; $trackNo <= $trackCount; $trackNo++) {
my $trackOffset = $trackOffsets[$trackNo];
$discId1 += $trackOffset;
$discId2 += ($trackOffset ? $trackOffset : 1) * ($trackNo + 1);
if ($trackNo < $trackCount) {
$cddbDiscId = $cddbDiscId + sumDigits(int($trackOffset/75) + 2);
}
}
$cddbDiscId = (($cddbDiscId % 255) << 24) + ((int($trackOffsets[$trackCount]/75) - int($trackOffsets[0]/75)) << 8) + $trackCount;
$discId1 &= 0xFFFFFFFF;
$discId2 &= 0xFFFFFFFF;
$cddbDiscId &= 0xFFFFFFFF;
}
print "\nChecking AccurateRip database\n\n";
# See if we can find the disc in the database
my $arUrl = sprintf("http://www.accuraterip.com/accuraterip/%.1x/%.1x/%.1x/dBAR-%.3d-%.8x-%.8x-%.8x.bin",
$discId1 & 0xF, $discId1>>4 & 0xF, $discId1>>8 & 0xF, $trackCount, $discId1, $discId2, $cddbDiscId);
my $arDiscNotInDb = 0;
my $arNetworkFailed = 0;
my $response = $lwpUserAgent->get($arUrl);
if (!$response->is_success) {
if ($response->status_line =~ m/^404/) {
$arDiscNotInDb = 1;
}else{
$arNetworkFailed = $response->status_line;
}
}
# Extract CRCs from response data
my $arCrcCount = 0;
my @arTrackConfidences = ();
my @arTrackCRCs = ();
if (!($arDiscNotInDb || $arNetworkFailed)) {
my $arCrcData = $response->content;
my $ptr = 0;
while ($ptr < length($arCrcData)) {
my ($chunkTrackCount, $chunkDiscId1, $chunkDiscId2, $chunkCddbDiscId);
# Force perl to interpret these values as signed integers
{
use integer;
$chunkTrackCount = unpack("c",substr($arCrcData,$ptr,1));
$chunkDiscId1 = unpack("V",substr($arCrcData,$ptr+1,4)) + 0;
$chunkDiscId2 = unpack("V",substr($arCrcData,$ptr+5,4)) + 0;
$chunkCddbDiscId = unpack("V",substr($arCrcData,$ptr+9,4)) + 0;
}
$ptr +=13;
if ( $chunkTrackCount != $trackCount
|| $chunkDiscId1 != $discId1
|| $chunkDiscId2 != $discId2
|| $chunkCddbDiscId != $cddbDiscId ) {
croak("Track count or Disc IDs don't match.");
}
# How if it flagged that a track is not in the database?
for (my $track = 0; $track < $trackCount; $track++) {
my ($trackConfidence, $trackCrc);
# Force perl to interpret these values as signed integers
{
use integer;
$trackConfidence = unpack("c",substr($arCrcData,$ptr,1));
$trackCrc = unpack("V",substr($arCrcData,$ptr+1,4)) + 0;
$ptr += 9;
}
if ($arCrcCount == 0){
$arTrackConfidences[$track] = [];
$arTrackCRCs[$track] = [];
}
$arTrackConfidences[$track]->[$arCrcCount] = $trackConfidence;
$arTrackCRCs[$track]->[$arCrcCount] = $trackCrc;
}
$arCrcCount++;
}
}
printf "Track\tRipping Status\t\t[Disc ID: %08x-%08x]\n", $discId1, $cddbDiscId;
# Calculate a CRC for each track
my $errLevel = 0;
# Calculate a CRC for each track
my @trackCRCs = ();
my $FH;
my ($accuratelyRipped, $notAccuratelyRipped, $notInDatabase) = (0, 0, 0);
#for (my $trackNo = 0; $trackNo < $trackCount; $trackNo++) {
{ my $trackNo = 0; pardo sub{ $trackNo < $trackCount }, sub { $trackNo++ }, sub {
# Open a pipe to flac decode
open($FH, "flac -d -c -f --force-raw-format --totally-silent --endian=little --sign=signed \"$flacDir/$filelist[$trackNo]\" |");
binmode $FH;
my ($frame, $CRC);
$CRC = 0;
for (my $frameNo = 0; $frameNo < $trackLengths[$trackNo]; $frameNo++) {
if (read($FH, $frame, 2352) != 2352) { croak ("read failed.") };
{
use integer;
$CRC += C_processFrame($frame, $frameNo, $trackLengths[$trackNo], $trackNo == 0, $trackNo == $trackCount - 1);
}
}
close($FH);
{
use integer;
$trackCRCs[$trackNo] = $CRC & 0xFFFFFFFF;
}
if ($arDiscNotInDb) {
printf " %d\tTrack not present in database. [%08x]\n",
$trackNo + 1, $trackCRCs[$trackNo];
$notInDatabase++;
} elsif ($arNetworkFailed) {
printf " %d\t [%08x]\n",
$trackNo + 1, $trackCRCs[$trackNo];
} else {
my $foundCrc = 0;
my $foundCrcMatch = 0;
for (my $arCrcNo=0; $arCrcNo < $arCrcCount; $arCrcNo++) {
if ($arTrackConfidences[$trackNo]->[$arCrcNo] != 0){
$foundCrc = 1;
if ($arTrackCRCs[$trackNo]->[$arCrcNo] == $trackCRCs[$trackNo]) {
printf " %d\tAccurately Ripped (confidence %d) [%08x]\n",
$trackNo + 1, $arTrackConfidences[$trackNo]->[$arCrcNo], $arTrackCRCs[$trackNo]->[$arCrcNo];
$accuratelyRipped++;
$foundCrcMatch = 1;
last;
}
}
}
if (!$foundCrc) {
printf " %d\tTrack not present in database. [%08x]\n",
$trackNo + 1, $trackCRCs[$trackNo];
$notInDatabase++;
}elsif (!$foundCrcMatch) {
printf " %d\t** Rip not accurate ** (confidence %d) [%08x] [%08x]\n",
$trackNo + 1, $arTrackConfidences[$trackNo]->[0], $arTrackCRCs[$trackNo]->[0], $trackCRCs[$trackNo];
$notAccuratelyRipped++;
}
}
#}
}, { "Max_Workers" => $numcores } ; }
if ($arDiscNotInDb) {
print "Disc not present in AccurateRip database.\n";
$errLevel = 2;
} elsif ($arNetworkFailed) {
print "Failed to get $arUrl : " . $arNetworkFailed . "\n";
$errLevel = 3;
# } elsif ($accuratelyRipped == $trackCount) {
# print "All Tracks Accurately Ripped.\n";
# } else {
# if ($notAccuratelyRipped >= 3) {
# print "Your CD disc is possibly a different pressing to the one(s) stored in AccurateRip.\n"
# }
#
# printf "Track(s) Accurately Ripped: %d\n", $accuratelyRipped;
# printf "**** Track(s) Not Ripped Accurately: %d ****\n", $notAccuratelyRipped;
# printf "Track(s) Not in Database: %d\n", $notInDatabase;
#
# $errLevel = 1;
}
print "\n\n\n";
}
sub processFrame {
use integer;
my ($frame, $frameNo, $trackLength, $firstTrack, $lastTrack) = @_;
if ($firstTrack && $frameNo<4) {
return 0;
} elsif ($lastTrack && $trackLength - $frameNo < 6) {
return 0;
} elsif ($firstTrack && $frameNo == 4) {
my $sample = unpack("V", substr($frame,2348,4));
return ($sample * 588 * 5);
} else {
my $CRC = 0;
my $frameOffset = $frameNo * 588;
foreach (unpack("V588", $frame)) {
$CRC += $_ * (++$frameOffset);
}
return $CRC;
}
}
sub sumDigits {
my $n = shift;
my $r = 0;
while ($n > 0) {
$r = $r + ($n % 10);
$n = int($n / 10);
}
return $r;
}
__END__
__C__
int C_processFrame(char *frame, int frameno, int tracklen, int first, int last)
{
unsigned int i, frameoffset, crc = 0, sample = 0;
if( first && frameno < 4 )
{
return 0;
}
else if( last && ( tracklen - frameno < 6 ) )
{
return 0;
}
else if( first && frameno == 4 )
{
sample = *(unsigned int *)(frame + 2348);
return sample * 588 * 5;
}
else
{
frameoffset = frameno * 588;
for(i=0; i<588; i++) {
sample = *(unsigned int *)( frame + (i * 4) );
crc += sample * (++frameoffset);
}
return crc;
}
}