summaryrefslogtreecommitdiff
path: root/tools/mp3info.pm
diff options
context:
space:
mode:
authorHardeep Sidhu <dyp@pobox.com>2006-06-28 15:44:51 +0000
committerHardeep Sidhu <dyp@pobox.com>2006-06-28 15:44:51 +0000
commit4e88de837e0cd0217c50da305e59cce2342ee1ec (patch)
tree3795e79ed70691887f0d89dafcb6e979aa877bda /tools/mp3info.pm
parent71cf604d8d317b7c2b167aac37493795046431cd (diff)
downloadrockbox-4e88de837e0cd0217c50da305e59cce2342ee1ec.tar.gz
rockbox-4e88de837e0cd0217c50da305e59cce2342ee1ec.zip
Re-adding songdb.pl with support for tagcache. Works with mp3 and has partial support for ogg.
git-svn-id: svn://svn.rockbox.org/rockbox/trunk@10150 a1c6a512-1295-4272-9138-f99709370657
Diffstat (limited to 'tools/mp3info.pm')
-rwxr-xr-xtools/mp3info.pm2184
1 files changed, 2184 insertions, 0 deletions
diff --git a/tools/mp3info.pm b/tools/mp3info.pm
new file mode 100755
index 0000000000..d900777266
--- /dev/null
+++ b/tools/mp3info.pm
@@ -0,0 +1,2184 @@
1package mp3info;
2
3require 5.006;
4
5use overload;
6use strict;
7use Carp;
8
9use vars qw(
10 @ISA @EXPORT @EXPORT_OK %EXPORT_TAGS $VERSION $REVISION
11 @mp3_genres %mp3_genres @winamp_genres %winamp_genres $try_harder
12 @t_bitrate @t_sampling_freq @frequency_tbl %v1_tag_fields
13 @v1_tag_names %v2_tag_names %v2_to_v1_names $AUTOLOAD
14 @mp3_info_fields %rva2_channel_types
15);
16
17@ISA = 'Exporter';
18@EXPORT = qw(
19 set_mp3tag get_mp3tag get_mp3info remove_mp3tag
20 use_winamp_genres, use_mp3_utf8
21);
22@EXPORT_OK = qw(@mp3_genres %mp3_genres use_mp3_utf8);
23%EXPORT_TAGS = (
24 genres => [qw(@mp3_genres %mp3_genres)],
25 utf8 => [qw(use_mp3_utf8)],
26 all => [@EXPORT, @EXPORT_OK]
27);
28
29# $Id$
30($REVISION) = ' $Revision$ ' =~ /\$Revision:\s+([^\s]+)/;
31$VERSION = '1.20';
32
33=pod
34
35=head1 NAME
36
37MP3::Info - Manipulate / fetch info from MP3 audio files
38
39=head1 SYNOPSIS
40
41 #!perl -w
42 use MP3::Info;
43 my $file = 'Pearls_Before_Swine.mp3';
44 set_mp3tag($file, 'Pearls Before Swine', q"77's",
45 'Sticks and Stones', '1990',
46 q"(c) 1990 77's LTD.", 'rock & roll');
47
48 my $tag = get_mp3tag($file) or die "No TAG info";
49 $tag->{GENRE} = 'rock';
50 set_mp3tag($file, $tag);
51
52 my $info = get_mp3info($file);
53 printf "$file length is %d:%d\n", $info->{MM}, $info->{SS};
54
55=cut
56
57{
58 my $c = -1;
59 # set all lower-case and regular-cased versions of genres as keys
60 # with index as value of each key
61 %mp3_genres = map {($_, ++$c, lc, $c)} @mp3_genres;
62
63 # do it again for winamp genres
64 $c = -1;
65 %winamp_genres = map {($_, ++$c, lc, $c)} @winamp_genres;
66}
67
68=pod
69
70 my $mp3 = new MP3::Info $file;
71 $mp3->title('Perls Before Swine');
72 printf "$file length is %s, title is %s\n",
73 $mp3->time, $mp3->title;
74
75
76=head1 DESCRIPTION
77
78=over 4
79
80=item $mp3 = MP3::Info-E<gt>new(FILE)
81
82OOP interface to the rest of the module. The same keys
83available via get_mp3info and get_mp3tag are available
84via the returned object (using upper case or lower case;
85but note that all-caps "VERSION" will return the module
86version, not the MP3 version).
87
88Passing a value to one of the methods will set the value
89for that tag in the MP3 file, if applicable.
90
91=cut
92
93sub new {
94 my($pack, $file) = @_;
95
96 my $info = get_mp3info($file) or return undef;
97 my $tags = get_mp3tag($file) || { map { ($_ => undef) } @v1_tag_names };
98 my %self = (
99 FILE => $file,
100 TRY_HARDER => 0
101 );
102
103 @self{@mp3_info_fields, @v1_tag_names, 'file'} = (
104 @{$info}{@mp3_info_fields},
105 @{$tags}{@v1_tag_names},
106 $file
107 );
108
109 return bless \%self, $pack;
110}
111
112sub can {
113 my $self = shift;
114 return $self->SUPER::can(@_) unless ref $self;
115 my $name = uc shift;
116 return sub { $self->$name(@_) } if exists $self->{$name};
117 return undef;
118}
119
120sub AUTOLOAD {
121 my($self) = @_;
122 (my $name = uc $AUTOLOAD) =~ s/^.*://;
123
124 if (exists $self->{$name}) {
125 my $sub = exists $v1_tag_fields{$name}
126 ? sub {
127 if (defined $_[1]) {
128 $_[0]->{$name} = $_[1];
129 set_mp3tag($_[0]->{FILE}, $_[0]);
130 }
131 return $_[0]->{$name};
132 }
133 : sub {
134 return $_[0]->{$name}
135 };
136
137 no strict 'refs';
138 *{$AUTOLOAD} = $sub;
139 goto &$AUTOLOAD;
140
141 } else {
142 carp(sprintf "No method '$name' available in package %s.",
143 __PACKAGE__);
144 }
145}
146
147sub DESTROY {
148
149}
150
151
152=item use_mp3_utf8([STATUS])
153
154Tells MP3::Info to (or not) return TAG info in UTF-8.
155TRUE is 1, FALSE is 0. Default is TRUE, if available.
156
157Will only be able to turn it on if Encode is available. ID3v2
158tags will be converted to UTF-8 according to the encoding specified
159in each tag; ID3v1 tags will be assumed Latin-1 and converted
160to UTF-8.
161
162Function returns status (TRUE/FALSE). If no argument is supplied,
163or an unaccepted argument is supplied, function merely returns status.
164
165This function is not exported by default, but may be exported
166with the C<:utf8> or C<:all> export tag.
167
168=cut
169
170my $unicode_module = eval { require Encode; require Encode::Guess };
171my $UNICODE = use_mp3_utf8($unicode_module ? 1 : 0);
172
173sub use_mp3_utf8 {
174 my($val) = @_;
175 if ($val == 1) {
176 if ($unicode_module) {
177 $UNICODE = 1;
178 $Encode::Guess::NoUTFAutoGuess = 1;
179 }
180 } elsif ($val == 0) {
181 $UNICODE = 0;
182 }
183 return $UNICODE;
184}
185
186=pod
187
188=item use_winamp_genres()
189
190Puts WinAmp genres into C<@mp3_genres> and C<%mp3_genres>
191(adds 68 additional genres to the default list of 80).
192This is a separate function because these are non-standard
193genres, but they are included because they are widely used.
194
195You can import the data structures with one of:
196
197 use MP3::Info qw(:genres);
198 use MP3::Info qw(:DEFAULT :genres);
199 use MP3::Info qw(:all);
200
201=cut
202
203sub use_winamp_genres {
204 %mp3_genres = %winamp_genres;
205 @mp3_genres = @winamp_genres;
206 return 1;
207}
208
209=pod
210
211=item remove_mp3tag (FILE [, VERSION, BUFFER])
212
213Can remove ID3v1 or ID3v2 tags. VERSION should be C<1> for ID3v1
214(the default), C<2> for ID3v2, and C<ALL> for both.
215
216For ID3v1, removes last 128 bytes from file if those last 128 bytes begin
217with the text 'TAG'. File will be 128 bytes shorter.
218
219For ID3v2, removes ID3v2 tag. Because an ID3v2 tag is at the
220beginning of the file, we rewrite the file after removing the tag data.
221The buffer for rewriting the file is 4MB. BUFFER (in bytes) ca
222change the buffer size.
223
224Returns the number of bytes removed, or -1 if no tag removed,
225or undef if there is an error.
226
227=cut
228
229sub remove_mp3tag {
230 my($file, $version, $buf) = @_;
231 my($fh, $return);
232
233 $buf ||= 4096*1024; # the bigger the faster
234 $version ||= 1;
235
236 if (not (defined $file && $file ne '')) {
237 $@ = "No file specified";
238 return undef;
239 }
240
241 if (not -s $file) {
242 $@ = "File is empty";
243 return undef;
244 }
245
246 if (ref $file) { # filehandle passed
247 $fh = $file;
248 } else {
249 if (not open $fh, '+<', $file) {
250 $@ = "Can't open $file: $!";
251 return undef;
252 }
253 }
254
255 binmode $fh;
256
257 if ($version eq 1 || $version eq 'ALL') {
258 seek $fh, -128, 2;
259 my $tell = tell $fh;
260 if (<$fh> =~ /^TAG/) {
261 truncate $fh, $tell or carp "Can't truncate '$file': $!";
262 $return += 128;
263 }
264 }
265
266 if ($version eq 2 || $version eq 'ALL') {
267 my $v2h = _get_v2head($fh);
268 if ($v2h) {
269 local $\;
270 seek $fh, 0, 2;
271 my $eof = tell $fh;
272 my $off = $v2h->{tag_size};
273
274 while ($off < $eof) {
275 seek $fh, $off, 0;
276 read $fh, my($bytes), $buf;
277 seek $fh, $off - $v2h->{tag_size}, 0;
278 print $fh $bytes;
279 $off += $buf;
280 }
281
282 truncate $fh, $eof - $v2h->{tag_size}
283 or carp "Can't truncate '$file': $!";
284 $return += $v2h->{tag_size};
285 }
286 }
287
288 _close($file, $fh);
289
290 return $return || -1;
291}
292
293
294=pod
295
296=item set_mp3tag (FILE, TITLE, ARTIST, ALBUM, YEAR, COMMENT, GENRE [, TRACKNUM])
297
298=item set_mp3tag (FILE, $HASHREF)
299
300Adds/changes tag information in an MP3 audio file. Will clobber
301any existing information in file.
302
303Fields are TITLE, ARTIST, ALBUM, YEAR, COMMENT, GENRE. All fields have
304a 30-byte limit, except for YEAR, which has a four-byte limit, and GENRE,
305which is one byte in the file. The GENRE passed in the function is a
306case-insensitive text string representing a genre found in C<@mp3_genres>.
307
308Will accept either a list of values, or a hashref of the type
309returned by C<get_mp3tag>.
310
311If TRACKNUM is present (for ID3v1.1), then the COMMENT field can only be
31228 bytes.
313
314ID3v2 support may come eventually. Note that if you set a tag on a file
315with ID3v2, the set tag will be for ID3v1[.1] only, and if you call
316C<get_mp3tag> on the file, it will show you the (unchanged) ID3v2 tags,
317unless you specify ID3v1.
318
319=cut
320
321sub set_mp3tag {
322 my($file, $title, $artist, $album, $year, $comment, $genre, $tracknum) = @_;
323 my(%info, $oldfh, $ref, $fh);
324 local %v1_tag_fields = %v1_tag_fields;
325
326 # set each to '' if undef
327 for ($title, $artist, $album, $year, $comment, $tracknum, $genre,
328 (@info{@v1_tag_names}))
329 {$_ = defined() ? $_ : ''}
330
331 ($ref) = (overload::StrVal($title) =~ /^(?:.*\=)?([^=]*)\((?:[^\(]*)\)$/)
332 if ref $title;
333 # populate data to hashref if hashref is not passed
334 if (!$ref) {
335 (@info{@v1_tag_names}) =
336 ($title, $artist, $album, $year, $comment, $tracknum, $genre);
337
338 # put data from hashref into hashref if hashref is passed
339 } elsif ($ref eq 'HASH') {
340 %info = %$title;
341
342 # return otherwise
343 } else {
344 carp(<<'EOT');
345Usage: set_mp3tag (FILE, TITLE, ARTIST, ALBUM, YEAR, COMMENT, GENRE [, TRACKNUM])
346 set_mp3tag (FILE, $HASHREF)
347EOT
348 return undef;
349 }
350
351 if (not (defined $file && $file ne '')) {
352 $@ = "No file specified";
353 return undef;
354 }
355
356 if (not -s $file) {
357 $@ = "File is empty";
358 return undef;
359 }
360
361 # comment field length 28 if ID3v1.1
362 $v1_tag_fields{COMMENT} = 28 if $info{TRACKNUM};
363
364
365 # only if -w is on
366 if ($^W) {
367 # warn if fields too long
368 foreach my $field (keys %v1_tag_fields) {
369 $info{$field} = '' unless defined $info{$field};
370 if (length($info{$field}) > $v1_tag_fields{$field}) {
371 carp "Data too long for field $field: truncated to " .
372 "$v1_tag_fields{$field}";
373 }
374 }
375
376 if ($info{GENRE}) {
377 carp "Genre `$info{GENRE}' does not exist\n"
378 unless exists $mp3_genres{$info{GENRE}};
379 }
380 }
381
382 if ($info{TRACKNUM}) {
383 $info{TRACKNUM} =~ s/^(\d+)\/(\d+)$/$1/;
384 unless ($info{TRACKNUM} =~ /^\d+$/ &&
385 $info{TRACKNUM} > 0 && $info{TRACKNUM} < 256) {
386 carp "Tracknum `$info{TRACKNUM}' must be an integer " .
387 "from 1 and 255\n" if $^W;
388 $info{TRACKNUM} = '';
389 }
390 }
391
392 if (ref $file) { # filehandle passed
393 $fh = $file;
394 } else {
395 if (not open $fh, '+<', $file) {
396 $@ = "Can't open $file: $!";
397 return undef;
398 }
399 }
400
401 binmode $fh;
402 $oldfh = select $fh;
403 seek $fh, -128, 2;
404 # go to end of file if no tag, beginning of file if tag
405 seek $fh, (<$fh> =~ /^TAG/ ? -128 : 0), 2;
406
407 # get genre value
408 $info{GENRE} = $info{GENRE} && exists $mp3_genres{$info{GENRE}} ?
409 $mp3_genres{$info{GENRE}} : 255; # some default genre
410
411 local $\;
412 # print TAG to file
413 if ($info{TRACKNUM}) {
414 print pack 'a3a30a30a30a4a28xCC', 'TAG', @info{@v1_tag_names};
415 } else {
416 print pack 'a3a30a30a30a4a30C', 'TAG', @info{@v1_tag_names[0..4, 6]};
417 }
418
419 select $oldfh;
420
421 _close($file, $fh);
422
423 return 1;
424}
425
426=pod
427
428=item get_mp3tag (FILE [, VERSION, RAW_V2])
429
430Returns hash reference containing tag information in MP3 file. The keys
431returned are the same as those supplied for C<set_mp3tag>, except in the
432case of RAW_V2 being set.
433
434If VERSION is C<1>, the information is taken from the ID3v1 tag (if present).
435If VERSION is C<2>, the information is taken from the ID3v2 tag (if present).
436If VERSION is not supplied, or is false, the ID3v1 tag is read if present, and
437then, if present, the ID3v2 tag information will override any existing ID3v1
438tag info.
439
440If RAW_V2 is C<1>, the raw ID3v2 tag data is returned, without any manipulation
441of text encoding. The key name is the same as the frame ID (ID to name mappings
442are in the global %v2_tag_names).
443
444If RAW_V2 is C<2>, the ID3v2 tag data is returned, manipulating for Unicode if
445necessary, etc. It also takes multiple values for a given key (such as comments)
446and puts them in an arrayref.
447
448If the ID3v2 version is older than ID3v2.2.0 or newer than ID3v2.4.0, it will
449not be read.
450
451Strings returned will be in Latin-1, unless UTF-8 is specified (L<use_mp3_utf8>),
452(unless RAW_V2 is C<1>).
453
454Also returns a TAGVERSION key, containing the ID3 version used for the returned
455data (if TAGVERSION argument is C<0>, may contain two versions).
456
457=cut
458
459sub get_mp3tag {
460 my ($file, $ver, $raw_v2, $find_ape) = @_;
461 my ($tag, $v2h, $fh);
462
463 my $v1 = {};
464 my $v2 = {};
465 my $ape = {};
466 my %info = ();
467 my @array = ();
468
469 $raw_v2 ||= 0;
470 $ver = !$ver ? 0 : ($ver == 2 || $ver == 1) ? $ver : 0;
471
472 if (not (defined $file && $file ne '')) {
473 $@ = "No file specified";
474 return undef;
475 }
476
477 my $filesize = -s $file;
478
479 if (!$filesize) {
480 $@ = "File is empty";
481 return undef;
482 }
483
484 if (ref $file) { # filehandle passed
485 $fh = $file;
486 } else {
487 if (not open $fh, '<', $file) {
488 $@ = "Can't open $file: $!";
489 return undef;
490 }
491 }
492
493 binmode $fh;
494
495 # Try and find an APE Tag - this is where FooBar2k & others
496 # store ReplayGain information
497 if ($find_ape) {
498
499 $ape = _parse_ape_tag($fh, $filesize, \%info);
500 }
501
502 if ($ver < 2) {
503
504 $v1 = _get_v1tag($fh, \%info);
505
506 if ($ver == 1 && !$v1) {
507 _close($file, $fh);
508 $@ = "No ID3v1 tag found";
509 return undef;
510 }
511 }
512
513 if ($ver == 2 || $ver == 0) {
514 ($v2, $v2h) = _get_v2tag($fh);
515 }
516
517 if (!$v1 && !$v2 && !$ape) {
518 _close($file, $fh);
519 $@ = "No ID3 tag found";
520 return undef;
521 }
522
523 if (($ver == 0 || $ver == 2) && $v2) {
524
525 if ($raw_v2 == 1 && $ver == 2) {
526
527 %info = %$v2;
528
529 $info{'TAGVERSION'} = $v2h->{'version'};
530
531 } else {
532
533 _parse_v2tag($raw_v2, $v2, \%info);
534
535 if ($ver == 0 && $info{'TAGVERSION'}) {
536 $info{'TAGVERSION'} .= ' / ' . $v2h->{'version'};
537 } else {
538 $info{'TAGVERSION'} = $v2h->{'version'};
539 }
540 }
541 }
542
543 unless ($raw_v2 && $ver == 2) {
544 foreach my $key (keys %info) {
545 if (defined $info{$key}) {
546 $info{$key} =~ s/\000+.*//g;
547 $info{$key} =~ s/\s+$//;
548 }
549 }
550
551 for (@v1_tag_names) {
552 $info{$_} = '' unless defined $info{$_};
553 }
554 }
555
556 if (keys %info && exists $info{'GENRE'} && ! defined $info{'GENRE'}) {
557 $info{'GENRE'} = '';
558 }
559
560 _close($file, $fh);
561
562 return keys %info ? {%info} : undef;
563}
564
565sub _get_v1tag {
566 my ($fh, $info) = @_;
567
568 seek $fh, -128, 2;
569 read($fh, my $tag, 128);
570
571 if (!defined($tag) || $tag !~ /^TAG/) {
572
573 return 0;
574 }
575
576 if (substr($tag, -3, 2) =~ /\000[^\000]/) {
577
578 (undef, @{$info}{@v1_tag_names}) =
579 (unpack('a3a30a30a30a4a28', $tag),
580 ord(substr($tag, -2, 1)),
581 $mp3_genres[ord(substr $tag, -1)]);
582
583 $info->{'TAGVERSION'} = 'ID3v1.1';
584
585 } else {
586
587 (undef, @{$info}{@v1_tag_names[0..4, 6]}) =
588 (unpack('a3a30a30a30a4a30', $tag),
589 $mp3_genres[ord(substr $tag, -1)]);
590
591 $info->{'TAGVERSION'} = 'ID3v1';
592 }
593
594 if ($UNICODE) {
595
596 # Save off the old suspects list, since we add
597 # iso-8859-1 below, but don't want that there
598 # for possible ID3 v2.x parsing below.
599 my $oldSuspects = $Encode::Encoding{'Guess'}->{'Suspects'};
600
601 for my $key (keys %{$info}) {
602
603 next unless $info->{$key};
604
605 # Try and guess the encoding.
606 my $value = $info->{$key};
607 my $icode = Encode::Guess->guess($value);
608
609 unless (ref($icode)) {
610
611 # Often Latin1 bytes are
612 # stuffed into a 1.1 tag.
613 Encode::Guess->add_suspects('iso-8859-1');
614
615 while (length($value)) {
616
617 $icode = Encode::Guess->guess($value);
618
619 last if ref($icode);
620
621 # Remove garbage and retry
622 # (string is truncated in the
623 # middle of a multibyte char?)
624 $value =~ s/(.)$//;
625 }
626 }
627
628 $info->{$key} = Encode::decode(ref($icode) ? $icode->name : 'iso-8859-1', $info->{$key});
629 }
630
631 Encode::Guess->set_suspects(keys %{$oldSuspects});
632 }
633
634 return 1;
635}
636
637sub _parse_v2tag {
638 my ($raw_v2, $v2, $info) = @_;
639
640 # Make sure any existing TXXX flags are an array.
641 # As we might need to append comments to it below.
642 if ($v2->{'TXXX'} && ref($v2->{'TXXX'}) ne 'ARRAY') {
643
644 $v2->{'TXXX'} = [ $v2->{'TXXX'} ];
645 }
646
647 # J.River Media Center sticks RG tags in comments.
648 # Ugh. Make them look like TXXX tags, which is really what they are.
649 if (ref($v2->{'COMM'}) eq 'ARRAY' && grep { /Media Jukebox/ } @{$v2->{'COMM'}}) {
650
651 for my $comment (@{$v2->{'COMM'}}) {
652
653 if ($comment =~ /Media Jukebox/) {
654
655 # we only want one null to lead.
656 $comment =~ s/^\000+//g;
657
658 push @{$v2->{'TXXX'}}, "\000$comment";
659 }
660 }
661 }
662
663 my $hash = $raw_v2 == 2 ? { map { ($_, $_) } keys %v2_tag_names } : \%v2_to_v1_names;
664
665 for my $id (keys %$hash) {
666
667 next if !exists $v2->{$id};
668
669 if ($id =~ /^UFID?$/) {
670
671 my @ufid_list = split(/\0/, $v2->{$id});
672
673 $info->{$hash->{$id}} = $ufid_list[1] if ($#ufid_list > 0);
674
675 } elsif ($id =~ /^RVA[D2]?$/) {
676
677 # Expand these binary fields. See the ID3 spec for Relative Volume Adjustment.
678 if ($id eq 'RVA2') {
679
680 # ID is a text string
681 ($info->{$hash->{$id}}->{'ID'}, my $rvad) = split /\0/, $v2->{$id};
682
683 my $channel = $rva2_channel_types{ ord(substr($rvad, 0, 1, '')) };
684
685 $info->{$hash->{$id}}->{$channel}->{'REPLAYGAIN_TRACK_GAIN'} =
686 sprintf('%f', _grab_int_16(\$rvad) / 512);
687
688 my $peakBytes = ord(substr($rvad, 0, 1, ''));
689
690 if (int($peakBytes / 8)) {
691
692 $info->{$hash->{$id}}->{$channel}->{'REPLAYGAIN_TRACK_PEAK'} =
693 sprintf('%f', _grab_int_16(\$rvad) / 512);
694 }
695
696 } elsif ($id eq 'RVAD' || $id eq 'RVA') {
697
698 my $rvad = $v2->{$id};
699 my $flags = ord(substr($rvad, 0, 1, ''));
700 my $desc = ord(substr($rvad, 0, 1, ''));
701
702 # iTunes appears to be the only program that actually writes
703 # out a RVA/RVAD tag. Everyone else punts.
704 for my $type (qw(REPLAYGAIN_TRACK_GAIN REPLAYGAIN_TRACK_PEAK)) {
705
706 for my $channel (qw(RIGHT LEFT)) {
707
708 my $val = _grab_uint_16(\$rvad) / 256;
709
710 # iTunes uses a range of -255 to 255
711 # to be -100% (silent) to 100% (+6dB)
712 if ($val == -255) {
713 $val = -96.0;
714 } else {
715 $val = 20.0 * log(($val+255)/255)/log(10);
716 }
717
718 $info->{$hash->{$id}}->{$channel}->{$type} = $flags & 0x01 ? $val : -$val;
719 }
720 }
721 }
722
723 } elsif ($id =~ /^A?PIC$/) {
724
725 my $pic = $v2->{$id};
726
727 # if there is more than one picture, just grab the first one.
728 if (ref($pic) eq 'ARRAY') {
729 $pic = (@$pic)[0];
730 }
731
732 use bytes;
733
734 my $valid_pic = 0;
735 my $pic_len = 0;
736 my $pic_format = '';
737
738 # look for ID3 v2.2 picture
739 if ($pic && $id eq 'PIC') {
740
741 # look for ID3 v2.2 picture
742 my ($encoding, $format, $picture_type, $description) = unpack 'Ca3CZ*', $pic;
743 $pic_len = length($description) + 1 + 5;
744
745 # skip extra terminating null if unicode
746 if ($encoding) { $pic_len++; }
747
748 if ($pic_len < length($pic)) {
749 $valid_pic = 1;
750 $pic_format = $format;
751 }
752
753 } elsif ($pic && $id eq 'APIC') {
754
755 # look for ID3 v2.3 picture
756 my ($encoding, $format) = unpack 'C Z*', $pic;
757
758 $pic_len = length($format) + 2;
759
760 if ($pic_len < length($pic)) {
761
762 my ($picture_type, $description) = unpack "x$pic_len C Z*", $pic;
763
764 $pic_len += 1 + length($description) + 1;
765
766 # skip extra terminating null if unicode
767 if ($encoding) { $pic_len++; }
768
769 $valid_pic = 1;
770 $pic_format = $format;
771 }
772 }
773
774 # Proceed if we have a valid picture.
775 if ($valid_pic && $pic_format) {
776
777 my ($data) = unpack("x$pic_len A*", $pic);
778
779 if (length($data) && $pic_format) {
780
781 $info->{$hash->{$id}} = {
782 'DATA' => $data,
783 'FORMAT' => $pic_format,
784 }
785 }
786 }
787
788 } else {
789 my $data1 = $v2->{$id};
790
791 # this is tricky ... if this is an arrayref,
792 # we want to only return one, so we pick the
793 # first one. but if it is a comment, we pick
794 # the first one where the first charcter after
795 # the language is NULL and not an additional
796 # sub-comment, because that is most likely to be
797 # the user-supplied comment
798 if (ref $data1 && !$raw_v2) {
799 if ($id =~ /^COMM?$/) {
800 my($newdata) = grep /^(....\000)/, @{$data1};
801 $data1 = $newdata || $data1->[0];
802 } elsif ($id !~ /^(?:TXXX?|PRIV)$/) {
803 # We can get multiple User Defined Text frames in a mp3 file
804 $data1 = $data1->[0];
805 }
806 }
807
808 $data1 = [ $data1 ] if ! ref $data1;
809
810 for my $data (@$data1) {
811 # TODO : this should only be done for certain frames;
812 # using RAW still gives you access, but we should be smarter
813 # about how individual frame types are handled. it's not
814 # like the list is infinitely long.
815 $data =~ s/^(.)//; # strip first char (text encoding)
816 my $encoding = $1;
817 my $desc;
818
819 # Comments & Unsyncronized Lyrics have the same format.
820 if ($id =~ /^(COM[M ]?|USLT)$/) { # space for iTunes brokenness
821
822 $data =~ s/^(?:...)//; # strip language
823 }
824
825 if ($UNICODE) {
826
827 if ($encoding eq "\001" || $encoding eq "\002") { # UTF-16, UTF-16BE
828 # text fields can be null-separated lists;
829 # UTF-16 therefore needs special care
830 #
831 # foobar2000 encodes tags in UTF-16LE
832 # (which is apparently illegal)
833 # Encode dies on a bad BOM, so it is
834 # probably wise to wrap it in an eval
835 # anyway
836 $data = eval { Encode::decode('utf16', $data) } || Encode::decode('utf16le', $data);
837
838 } elsif ($encoding eq "\003") { # UTF-8
839
840 # make sure string is UTF8, and set flag appropriately
841 $data = Encode::decode('utf8', $data);
842
843 } elsif ($encoding eq "\000") {
844
845 # Only guess if it's not ascii.
846 if ($data && $data !~ /^[\x00-\x7F]+$/) {
847
848 # Try and guess the encoding, otherwise just use latin1
849 my $dec = Encode::Guess->guess($data);
850
851 if (ref $dec) {
852 $data = $dec->decode($data);
853 } else {
854 # Best try
855 $data = Encode::decode('iso-8859-1', $data);
856 }
857 }
858 }
859
860 } else {
861
862 # If the string starts with an
863 # UTF-16 little endian BOM, use a hack to
864 # convert to ASCII per best-effort
865 my $pat;
866 if ($data =~ s/^\xFF\xFE//) {
867 $pat = 'v';
868 } elsif ($data =~ s/^\xFE\xFF//) {
869 $pat = 'n';
870 }
871
872 if ($pat) {
873 $data = pack 'C*', map {
874 (chr =~ /[[:ascii:]]/ && chr =~ /[[:print:]]/)
875 ? $_
876 : ord('?')
877 } unpack "$pat*", $data;
878 }
879 }
880
881 # We do this after decoding so we could be certain we're dealing
882 # with 8-bit text.
883 if ($id =~ /^(COM[M ]?|USLT)$/) { # space for iTunes brokenness
884
885 $data =~ s/^(.*?)\000//; # strip up to first NULL(s),
886 # for sub-comments (TODO:
887 # handle all comment data)
888 $desc = $1;
889
890 } elsif ($id =~ /^TCON?$/) {
891
892 my ($index, $name);
893
894 # Turn multiple nulls into a single.
895 $data =~ s/\000+/\000/g;
896
897 # Handle the ID3v2.x spec -
898 #
899 # just an index number, possibly
900 # paren enclosed - referer to the v1 genres.
901 if ($data =~ /^ \(? (\d+) \)?\000?$/sx) {
902
903 $index = $1;
904
905 # Paren enclosed index with refinement.
906 # (4)Eurodisco
907 } elsif ($data =~ /^ \( (\d+) \)\000? ([^\(].+)$/x) {
908
909 ($index, $name) = ($1, $2);
910
911 # List of indexes: (37)(38)
912 } elsif ($data =~ /^ \( (\d+) \)\000?/x) {
913
914 my @genres = ();
915
916 while ($data =~ s/^ \( (\d+) \)\000?//x) {
917
918 push @genres, $mp3_genres[$1];
919 }
920
921 $data = \@genres;
922 }
923
924 # Text based genres will fall through.
925 if ($name && $name ne "\000") {
926 $data = $name;
927 } elsif (defined $index) {
928 $data = $mp3_genres[$index];
929 }
930 }
931
932 if ($raw_v2 == 2 && $desc) {
933 $data = { $desc => $data };
934 }
935
936 if ($raw_v2 == 2 && exists $info->{$hash->{$id}}) {
937
938 if (ref $info->{$hash->{$id}} eq 'ARRAY') {
939 push @{$info->{$hash->{$id}}}, $data;
940 } else {
941 $info->{$hash->{$id}} = [ $info->{$hash->{$id}}, $data ];
942 }
943
944 } else {
945
946 # User defined frame
947 if ($id eq 'TXXX') {
948
949 my ($key, $val) = split(/\0/, $data);
950 $info->{uc($key)} = $val;
951
952 } elsif ($id eq 'PRIV') {
953
954 my ($key, $val) = split(/\0/, $data);
955 $info->{uc($key)} = unpack('v', $val);
956
957 } else {
958
959 $info->{$hash->{$id}} = $data;
960 }
961 }
962 }
963 }
964 }
965}
966
967sub _get_v2tag {
968 my($fh) = @_;
969 my($off, $end, $myseek, $v2, $v2h, $hlen, $num, $wholetag);
970
971 $v2 = {};
972 $v2h = _get_v2head($fh) or return;
973
974 if ($v2h->{major_version} < 2) {
975 carp "This is $v2h->{version}; " .
976 "ID3v2 versions older than ID3v2.2.0 not supported\n"
977 if $^W;
978 return;
979 }
980
981 # use syncsafe bytes if using version 2.4
982 # my $bytesize = ($v2h->{major_version} > 3) ? 128 : 256;
983
984 # alas, that's what the spec says, but iTunes and others don't syncsafe
985 # the length, which breaks MP3 files with v2.4 tags longer than 128 bytes,
986 # like every image file.
987 my $bytesize = 256;
988
989 if ($v2h->{major_version} == 2) {
990 $hlen = 6;
991 $num = 3;
992 } else {
993 $hlen = 10;
994 $num = 4;
995 }
996
997 $off = $v2h->{ext_header_size} + 10;
998 $end = $v2h->{tag_size} + 10; # should we read in the footer too?
999
1000 seek $fh, $v2h->{offset}, 0;
1001 read $fh, $wholetag, $end;
1002
1003 $wholetag =~ s/\xFF\x00/\xFF/gs if $v2h->{unsync};
1004
1005 $myseek = sub {
1006 my $bytes = substr($wholetag, $off, $hlen);
1007 return unless $bytes =~ /^([A-Z0-9]{$num})/
1008 || ($num == 4 && $bytes =~ /^(COM )/); # stupid iTunes
1009 my($id, $size) = ($1, $hlen);
1010 my @bytes = reverse unpack "C$num", substr($bytes, $num, $num);
1011
1012 for my $i (0 .. ($num - 1)) {
1013 $size += $bytes[$i] * $bytesize ** $i;
1014 }
1015
1016 my $flags = {};
1017 if ($v2h->{major_version} > 3) {
1018 my @bits = split //, unpack 'B16', substr($bytes, 8, 2);
1019 $flags->{frame_unsync} = $bits[14];
1020 $flags->{data_len_indicator} = $bits[15];
1021 }
1022
1023 return($id, $size, $flags);
1024 };
1025
1026 while ($off < $end) {
1027 my($id, $size, $flags) = &$myseek or last;
1028
1029 my $bytes = substr($wholetag, $off+$hlen, $size-$hlen);
1030
1031 my $data_len;
1032 if ($flags->{data_len_indicator}) {
1033 $data_len = 0;
1034 my @data_len_bytes = reverse unpack 'C4', substr($bytes, 0, 4);
1035 $bytes = substr($bytes, 4);
1036 for my $i (0..3) {
1037 $data_len += $data_len_bytes[$i] * 128 ** $i;
1038 }
1039 }
1040
1041 # perform frame-level unsync if needed (skip if already done for whole tag)
1042 $bytes =~ s/\xFF\x00/\xFF/gs if $flags->{frame_unsync} && !$v2h->{unsync};
1043
1044 # if we know the data length, sanity check it now.
1045 if ($flags->{data_len_indicator} && defined $data_len) {
1046 carp "Size mismatch on $id\n" unless $data_len == length($bytes);
1047 }
1048
1049 if (exists $v2->{$id}) {
1050 if (ref $v2->{$id} eq 'ARRAY') {
1051 push @{$v2->{$id}}, $bytes;
1052 } else {
1053 $v2->{$id} = [$v2->{$id}, $bytes];
1054 }
1055 } else {
1056 $v2->{$id} = $bytes;
1057 }
1058 $off += $size;
1059 }
1060
1061 return($v2, $v2h);
1062}
1063
1064
1065=pod
1066
1067=item get_mp3info (FILE)
1068
1069Returns hash reference containing file information for MP3 file.
1070This data cannot be changed. Returned data:
1071
1072 VERSION MPEG audio version (1, 2, 2.5)
1073 LAYER MPEG layer description (1, 2, 3)
1074 STEREO boolean for audio is in stereo
1075
1076 VBR boolean for variable bitrate
1077 BITRATE bitrate in kbps (average for VBR files)
1078 FREQUENCY frequency in kHz
1079 SIZE bytes in audio stream
1080 OFFSET bytes offset that stream begins
1081
1082 SECS total seconds
1083 MM minutes
1084 SS leftover seconds
1085 MS leftover milliseconds
1086 TIME time in MM:SS
1087
1088 COPYRIGHT boolean for audio is copyrighted
1089 PADDING boolean for MP3 frames are padded
1090 MODE channel mode (0 = stereo, 1 = joint stereo,
1091 2 = dual channel, 3 = single channel)
1092 FRAMES approximate number of frames
1093 FRAME_LENGTH approximate length of a frame
1094 VBR_SCALE VBR scale from VBR header
1095
1096On error, returns nothing and sets C<$@>.
1097
1098=cut
1099
1100sub get_mp3info {
1101 my($file) = @_;
1102 my($off, $byte, $eof, $h, $tot, $fh);
1103
1104 if (not (defined $file && $file ne '')) {
1105 $@ = "No file specified";
1106 return undef;
1107 }
1108
1109 if (not -s $file) {
1110 $@ = "File is empty";
1111 return undef;
1112 }
1113
1114 if (ref $file) { # filehandle passed
1115 $fh = $file;
1116 } else {
1117 if (not open $fh, '<', $file) {
1118 $@ = "Can't open $file: $!";
1119 return undef;
1120 }
1121 }
1122
1123 $off = 0;
1124 $tot = 8192;
1125
1126 # Let the caller change how far we seek in looking for a header.
1127 if ($try_harder) {
1128 $tot *= $try_harder;
1129 }
1130
1131 binmode $fh;
1132 seek $fh, $off, 0;
1133 read $fh, $byte, 4;
1134
1135 if ($off == 0) {
1136 if (my $v2h = _get_v2head($fh)) {
1137 $tot += $off += $v2h->{tag_size};
1138 seek $fh, $off, 0;
1139 read $fh, $byte, 4;
1140 }
1141 }
1142
1143 $h = _get_head($byte);
1144 my $is_mp3 = _is_mp3($h);
1145
1146 # the head wasn't where we were expecting it.. dig deeper.
1147 unless ($is_mp3) {
1148
1149 # do only one read - it's _much_ faster
1150 $off++;
1151 seek $fh, $off, 0;
1152 read $fh, $byte, $tot;
1153
1154 my $i;
1155
1156 # now walk the bytes looking for the head
1157 for ($i = 0; $i < $tot; $i++) {
1158
1159 last if ($tot - $i) < 4;
1160
1161 my $head = substr($byte, $i, 4) || last;
1162
1163 next if (ord($head) != 0xff);
1164
1165 $h = _get_head($head);
1166 $is_mp3 = _is_mp3($h);
1167 last if $is_mp3;
1168 }
1169
1170 # adjust where we are for _get_vbr()
1171 $off += $i;
1172
1173 if ($off > $tot && !$try_harder) {
1174 _close($file, $fh);
1175 $@ = "Couldn't find MP3 header (perhaps set " .
1176 '$MP3::Info::try_harder and retry)';
1177 return undef;
1178 }
1179 }
1180
1181 my $vbr = _get_vbr($fh, $h, \$off);
1182
1183 seek $fh, 0, 2;
1184 $eof = tell $fh;
1185 seek $fh, -128, 2;
1186 $eof -= 128 if <$fh> =~ /^TAG/ ? 1 : 0;
1187
1188 _close($file, $fh);
1189
1190 $h->{size} = $eof - $off;
1191 $h->{offset} = $off;
1192
1193 return _get_info($h, $vbr);
1194}
1195
1196sub _get_info {
1197 my($h, $vbr) = @_;
1198 my $i;
1199
1200 # No bitrate or sample rate? Something's wrong.
1201 unless ($h->{bitrate} && $h->{fs}) {
1202 return {};
1203 }
1204
1205 $i->{VERSION} = $h->{IDR} == 2 ? 2 : $h->{IDR} == 3 ? 1 :
1206 $h->{IDR} == 0 ? 2.5 : 0;
1207 $i->{LAYER} = 4 - $h->{layer};
1208 $i->{VBR} = defined $vbr ? 1 : 0;
1209
1210 $i->{COPYRIGHT} = $h->{copyright} ? 1 : 0;
1211 $i->{PADDING} = $h->{padding_bit} ? 1 : 0;
1212 $i->{STEREO} = $h->{mode} == 3 ? 0 : 1;
1213 $i->{MODE} = $h->{mode};
1214
1215 $i->{SIZE} = $vbr && $vbr->{bytes} ? $vbr->{bytes} : $h->{size};
1216 $i->{OFFSET} = $h->{offset};
1217
1218 my $mfs = $h->{fs} / ($h->{ID} ? 144000 : 72000);
1219 $i->{FRAMES} = int($vbr && $vbr->{frames}
1220 ? $vbr->{frames}
1221 : $i->{SIZE} / ($h->{bitrate} / $mfs)
1222 );
1223
1224 if ($vbr) {
1225 $i->{VBR_SCALE} = $vbr->{scale} if $vbr->{scale};
1226 $h->{bitrate} = $i->{SIZE} / $i->{FRAMES} * $mfs;
1227 if (not $h->{bitrate}) {
1228 $@ = "Couldn't determine VBR bitrate";
1229 return undef;
1230 }
1231 }
1232
1233 $h->{'length'} = ($i->{SIZE} * 8) / $h->{bitrate} / 10;
1234 $i->{SECS} = $h->{'length'} / 100;
1235 $i->{MM} = int $i->{SECS} / 60;
1236 $i->{SS} = int $i->{SECS} % 60;
1237 $i->{MS} = (($i->{SECS} - ($i->{MM} * 60) - $i->{SS}) * 1000);
1238# $i->{LF} = ($i->{MS} / 1000) * ($i->{FRAMES} / $i->{SECS});
1239# int($i->{MS} / 100 * 75); # is this right?
1240 $i->{TIME} = sprintf "%.2d:%.2d", @{$i}{'MM', 'SS'};
1241
1242 $i->{BITRATE} = int $h->{bitrate};
1243 # should we just return if ! FRAMES?
1244 $i->{FRAME_LENGTH} = int($h->{size} / $i->{FRAMES}) if $i->{FRAMES};
1245 $i->{FREQUENCY} = $frequency_tbl[3 * $h->{IDR} + $h->{sampling_freq}];
1246
1247 return $i;
1248}
1249
1250sub _get_head {
1251 my($byte) = @_;
1252 my($bytes, $h);
1253
1254 $bytes = _unpack_head($byte);
1255 @$h{qw(IDR ID layer protection_bit
1256 bitrate_index sampling_freq padding_bit private_bit
1257 mode mode_extension copyright original
1258 emphasis version_index bytes)} = (
1259 ($bytes>>19)&3, ($bytes>>19)&1, ($bytes>>17)&3, ($bytes>>16)&1,
1260 ($bytes>>12)&15, ($bytes>>10)&3, ($bytes>>9)&1, ($bytes>>8)&1,
1261 ($bytes>>6)&3, ($bytes>>4)&3, ($bytes>>3)&1, ($bytes>>2)&1,
1262 $bytes&3, ($bytes>>19)&3, $bytes
1263 );
1264
1265 $h->{bitrate} = $t_bitrate[$h->{ID}][3 - $h->{layer}][$h->{bitrate_index}];
1266 $h->{fs} = $t_sampling_freq[$h->{IDR}][$h->{sampling_freq}];
1267
1268 return $h;
1269}
1270
1271sub _is_mp3 {
1272 my $h = $_[0] or return undef;
1273 return ! ( # all below must be false
1274 $h->{bitrate_index} == 0
1275 ||
1276 $h->{version_index} == 1
1277 ||
1278 ($h->{bytes} & 0xFFE00000) != 0xFFE00000
1279 ||
1280 !$h->{fs}
1281 ||
1282 !$h->{bitrate}
1283 ||
1284 $h->{bitrate_index} == 15
1285 ||
1286 !$h->{layer}
1287 ||
1288 $h->{sampling_freq} == 3
1289 ||
1290 $h->{emphasis} == 2
1291 ||
1292 !$h->{bitrate_index}
1293 ||
1294 ($h->{bytes} & 0xFFFF0000) == 0xFFFE0000
1295 ||
1296 ($h->{ID} == 1 && $h->{layer} == 3 && $h->{protection_bit} == 1)
1297 # mode extension should only be applicable when mode = 1
1298 # however, failing just becuase mode extension is used when unneeded is a bit strict
1299 # ||
1300 #($h->{mode_extension} != 0 && $h->{mode} != 1)
1301 );
1302}
1303
1304sub _vbr_seek {
1305 my $fh = shift;
1306 my $off = shift;
1307 my $bytes = shift;
1308 my $n = shift || 4;
1309
1310 seek $fh, $$off, 0;
1311 read $fh, $$bytes, $n;
1312
1313 $$off += $n;
1314}
1315
1316sub _get_vbr {
1317 my($fh, $h, $roff) = @_;
1318 my($off, $bytes, @bytes, %vbr);
1319
1320 $off = $$roff;
1321
1322 $off += 4;
1323
1324 if ($h->{ID}) { # MPEG1
1325 $off += $h->{mode} == 3 ? 17 : 32;
1326 } else { # MPEG2
1327 $off += $h->{mode} == 3 ? 9 : 17;
1328 }
1329
1330 _vbr_seek($fh, \$off, \$bytes);
1331 return unless $bytes eq 'Xing';
1332
1333 _vbr_seek($fh, \$off, \$bytes);
1334 $vbr{flags} = _unpack_head($bytes);
1335
1336 if ($vbr{flags} & 1) {
1337 _vbr_seek($fh, \$off, \$bytes);
1338 $vbr{frames} = _unpack_head($bytes);
1339 }
1340
1341 if ($vbr{flags} & 2) {
1342 _vbr_seek($fh, \$off, \$bytes);
1343 $vbr{bytes} = _unpack_head($bytes);
1344 }
1345
1346 if ($vbr{flags} & 4) {
1347 _vbr_seek($fh, \$off, \$bytes, 100);
1348# Not used right now ...
1349# $vbr{toc} = _unpack_head($bytes);
1350 }
1351
1352 if ($vbr{flags} & 8) { # (quality ind., 0=best 100=worst)
1353 _vbr_seek($fh, \$off, \$bytes);
1354 $vbr{scale} = _unpack_head($bytes);
1355 } else {
1356 $vbr{scale} = -1;
1357 }
1358
1359 $$roff = $off;
1360 return \%vbr;
1361}
1362
1363sub _get_v2head {
1364 my $fh = $_[0] or return;
1365 my($v2h, $bytes, @bytes);
1366 $v2h->{offset} = 0;
1367
1368 # check first three bytes for 'ID3'
1369 seek $fh, 0, 0;
1370 read $fh, $bytes, 3;
1371
1372 # TODO: add support for tags at the end of the file
1373 if ($bytes eq 'RIF' || $bytes eq 'FOR') {
1374 _find_id3_chunk($fh, $bytes) or return;
1375 $v2h->{offset} = tell $fh;
1376 read $fh, $bytes, 3;
1377 }
1378
1379 return unless $bytes eq 'ID3';
1380
1381 # get version
1382 read $fh, $bytes, 2;
1383 $v2h->{version} = sprintf "ID3v2.%d.%d",
1384 @$v2h{qw[major_version minor_version]} =
1385 unpack 'c2', $bytes;
1386
1387 # get flags
1388 read $fh, $bytes, 1;
1389 my @bits = split //, unpack 'b8', $bytes;
1390 if ($v2h->{major_version} == 2) {
1391 $v2h->{unsync} = $bits[7];
1392 $v2h->{compression} = $bits[8];
1393 $v2h->{ext_header} = 0;
1394 $v2h->{experimental} = 0;
1395 } else {
1396 $v2h->{unsync} = $bits[7];
1397 $v2h->{ext_header} = $bits[6];
1398 $v2h->{experimental} = $bits[5];
1399 $v2h->{footer} = $bits[4] if $v2h->{major_version} == 4;
1400 }
1401
1402 # get ID3v2 tag length from bytes 7-10
1403 $v2h->{tag_size} = 10; # include ID3v2 header size
1404 $v2h->{tag_size} += 10 if $v2h->{footer};
1405 read $fh, $bytes, 4;
1406 @bytes = reverse unpack 'C4', $bytes;
1407 foreach my $i (0 .. 3) {
1408 # whoaaaaaa nellllllyyyyyy!
1409 $v2h->{tag_size} += $bytes[$i] * 128 ** $i;
1410 }
1411
1412 # get extended header size
1413 $v2h->{ext_header_size} = 0;
1414 if ($v2h->{ext_header}) {
1415 read $fh, $bytes, 4;
1416 @bytes = reverse unpack 'C4', $bytes;
1417
1418 # use syncsafe bytes if using version 2.4
1419 my $bytesize = ($v2h->{major_version} > 3) ? 128 : 256;
1420 for my $i (0..3) {
1421 $v2h->{ext_header_size} += $bytes[$i] * $bytesize ** $i;
1422 }
1423 }
1424
1425 return $v2h;
1426}
1427
1428sub _find_id3_chunk {
1429 my($fh, $filetype) = @_;
1430 my($bytes, $size, $tag, $pat, $mat);
1431
1432 read $fh, $bytes, 1;
1433 if ($filetype eq 'RIF') { # WAV
1434 return 0 if $bytes ne 'F';
1435 $pat = 'a4V';
1436 $mat = 'id3 ';
1437 } elsif ($filetype eq 'FOR') { # AIFF
1438 return 0 if $bytes ne 'M';
1439 $pat = 'a4N';
1440 $mat = 'ID3 ';
1441 }
1442 seek $fh, 12, 0; # skip to the first chunk
1443
1444 while ((read $fh, $bytes, 8) == 8) {
1445 ($tag, $size) = unpack $pat, $bytes;
1446 return 1 if $tag eq $mat;
1447 seek $fh, $size, 1;
1448 }
1449
1450 return 0;
1451}
1452
1453sub _unpack_head {
1454 unpack('l', pack('L', unpack('N', $_[0])));
1455}
1456
1457sub _grab_int_16 {
1458 my $data = shift;
1459 my $value = unpack('s',substr($$data,0,2));
1460 $$data = substr($$data,2);
1461 return $value;
1462}
1463
1464sub _grab_uint_16 {
1465 my $data = shift;
1466 my $value = unpack('S',substr($$data,0,2));
1467 $$data = substr($$data,2);
1468 return $value;
1469}
1470
1471sub _grab_int_32 {
1472 my $data = shift;
1473 my $value = unpack('V',substr($$data,0,4));
1474 $$data = substr($$data,4);
1475 return $value;
1476}
1477
1478sub _parse_ape_tag {
1479 my ($fh, $filesize, $info) = @_;
1480
1481 my $ape_tag_id = 'APETAGEX';
1482
1483 seek $fh, -256, 2;
1484 read($fh, my $tag, 256);
1485 my $pre_tag = substr($tag, 0, 128, '');
1486
1487 # Try and bail early if there's no ape tag.
1488 if (substr($pre_tag, 96, 8) ne $ape_tag_id && substr($tag, 96, 8) ne $ape_tag_id) {
1489
1490 seek($fh, 0, 0);
1491 return 0;
1492 }
1493
1494 my $id3v1_tag_size = 128;
1495 my $ape_tag_header_size = 32;
1496 my $lyrics3_tag_size = 10;
1497 my $tag_offset_start = 0;
1498 my $tag_offset_end = 0;
1499
1500 seek($fh, (0 - $id3v1_tag_size - $ape_tag_header_size - $lyrics3_tag_size), 2);
1501
1502 read($fh, my $ape_footer_id3v1, $id3v1_tag_size + $ape_tag_header_size + $lyrics3_tag_size);
1503
1504 if (substr($ape_footer_id3v1, (length($ape_footer_id3v1) - $id3v1_tag_size - $ape_tag_header_size), 8) eq $ape_tag_id) {
1505
1506 $tag_offset_end = $filesize - $id3v1_tag_size;
1507
1508 } elsif (substr($ape_footer_id3v1, (length($ape_footer_id3v1) - $ape_tag_header_size), 8) eq $ape_tag_id) {
1509
1510 $tag_offset_end = $filesize;
1511 }
1512
1513 seek($fh, $tag_offset_end - $ape_tag_header_size, 0);
1514
1515 read($fh, my $ape_footer_data, 32);
1516
1517 my $ape_footer = _parse_ape_header_or_footer($ape_footer_data);
1518
1519 if (keys %{$ape_footer}) {
1520
1521 my $ape_tag_data = '';
1522
1523 if ($ape_footer->{'flags'}->{'header'}) {
1524
1525 seek($fh, ($tag_offset_end - $ape_footer->{'tag_size'} - $ape_tag_header_size), 0);
1526
1527 $tag_offset_start = tell($fh);
1528
1529 read($fh, $ape_tag_data, $ape_footer->{'tag_size'} + $ape_tag_header_size);
1530
1531 } else {
1532
1533 $tag_offset_start = $tag_offset_end - $ape_footer->{'tag_size'};
1534
1535 seek($fh, $tag_offset_start, 0);
1536
1537 read($fh, $ape_tag_data, $ape_footer->{'tag_size'});
1538 }
1539
1540 my $ape_header_data = substr($ape_tag_data, 0, $ape_tag_header_size, '');
1541 my $ape_header = _parse_ape_header_or_footer($ape_header_data);
1542
1543 for (my $c = 0; $c < $ape_header->{'tag_items'}; $c++) {
1544
1545 # Loop through the tag items
1546 my $tag_len = _grab_int_32(\$ape_tag_data);
1547 my $tag_flags = _grab_int_32(\$ape_tag_data);
1548
1549 $ape_tag_data =~ s/^(.*?)\0//;
1550
1551 my $tag_item_key = uc($1 || 'UNKNOWN');
1552
1553 $info->{$tag_item_key} = substr($ape_tag_data, 0, $tag_len, '');
1554 }
1555 }
1556
1557 seek($fh, 0, 0);
1558
1559 return 1;
1560}
1561
1562sub _parse_ape_header_or_footer {
1563 my $bytes = shift;
1564 my %data = ();
1565
1566 if (substr($bytes, 0, 8, '') eq 'APETAGEX') {
1567
1568 $data{'version'} = _grab_int_32(\$bytes);
1569 $data{'tag_size'} = _grab_int_32(\$bytes);
1570 $data{'tag_items'} = _grab_int_32(\$bytes);
1571 $data{'global_flags'} = _grab_int_32(\$bytes);
1572
1573 # trim the reseved bytes
1574 _grab_int_32(\$bytes);
1575 _grab_int_32(\$bytes);
1576
1577 $data{'flags'}->{'header'} = ($data{'global_flags'} & 0x80000000) ? 1 : 0;
1578 $data{'flags'}->{'footer'} = ($data{'global_flags'} & 0x40000000) ? 1 : 0;
1579 $data{'flags'}->{'is_header'} = ($data{'global_flags'} & 0x20000000) ? 1 : 0;
1580 }
1581
1582 return \%data;
1583}
1584
1585sub _close {
1586 my($file, $fh) = @_;
1587 unless (ref $file) { # filehandle not passed
1588 close $fh or carp "Problem closing '$file': $!";
1589 }
1590}
1591
1592BEGIN {
1593 @mp3_genres = (
1594 'Blues',
1595 'Classic Rock',
1596 'Country',
1597 'Dance',
1598 'Disco',
1599 'Funk',
1600 'Grunge',
1601 'Hip-Hop',
1602 'Jazz',
1603 'Metal',
1604 'New Age',
1605 'Oldies',
1606 'Other',
1607 'Pop',
1608 'R&B',
1609 'Rap',
1610 'Reggae',
1611 'Rock',
1612 'Techno',
1613 'Industrial',
1614 'Alternative',
1615 'Ska',
1616 'Death Metal',
1617 'Pranks',
1618 'Soundtrack',
1619 'Euro-Techno',
1620 'Ambient',
1621 'Trip-Hop',
1622 'Vocal',
1623 'Jazz+Funk',
1624 'Fusion',
1625 'Trance',
1626 'Classical',
1627 'Instrumental',
1628 'Acid',
1629 'House',
1630 'Game',
1631 'Sound Clip',
1632 'Gospel',
1633 'Noise',
1634 'AlternRock',
1635 'Bass',
1636 'Soul',
1637 'Punk',
1638 'Space',
1639 'Meditative',
1640 'Instrumental Pop',
1641 'Instrumental Rock',
1642 'Ethnic',
1643 'Gothic',
1644 'Darkwave',
1645 'Techno-Industrial',
1646 'Electronic',
1647 'Pop-Folk',
1648 'Eurodance',
1649 'Dream',
1650 'Southern Rock',
1651 'Comedy',
1652 'Cult',
1653 'Gangsta',
1654 'Top 40',
1655 'Christian Rap',
1656 'Pop/Funk',
1657 'Jungle',
1658 'Native American',
1659 'Cabaret',
1660 'New Wave',
1661 'Psychadelic',
1662 'Rave',
1663 'Showtunes',
1664 'Trailer',
1665 'Lo-Fi',
1666 'Tribal',
1667 'Acid Punk',
1668 'Acid Jazz',
1669 'Polka',
1670 'Retro',
1671 'Musical',
1672 'Rock & Roll',
1673 'Hard Rock',
1674 );
1675
1676 @winamp_genres = (
1677 @mp3_genres,
1678 'Folk',
1679 'Folk-Rock',
1680 'National Folk',
1681 'Swing',
1682 'Fast Fusion',
1683 'Bebop',
1684 'Latin',
1685 'Revival',
1686 'Celtic',
1687 'Bluegrass',
1688 'Avantgarde',
1689 'Gothic Rock',
1690 'Progressive Rock',
1691 'Psychedelic Rock',
1692 'Symphonic Rock',
1693 'Slow Rock',
1694 'Big Band',
1695 'Chorus',
1696 'Easy Listening',
1697 'Acoustic',
1698 'Humour',
1699 'Speech',
1700 'Chanson',
1701 'Opera',
1702 'Chamber Music',
1703 'Sonata',
1704 'Symphony',
1705 'Booty Bass',
1706 'Primus',
1707 'Porn Groove',
1708 'Satire',
1709 'Slow Jam',
1710 'Club',
1711 'Tango',
1712 'Samba',
1713 'Folklore',
1714 'Ballad',
1715 'Power Ballad',
1716 'Rhythmic Soul',
1717 'Freestyle',
1718 'Duet',
1719 'Punk Rock',
1720 'Drum Solo',
1721 'Acapella',
1722 'Euro-House',
1723 'Dance Hall',
1724 'Goa',
1725 'Drum & Bass',
1726 'Club-House',
1727 'Hardcore',
1728 'Terror',
1729 'Indie',
1730 'BritPop',
1731 'Negerpunk',
1732 'Polsk Punk',
1733 'Beat',
1734 'Christian Gangsta Rap',
1735 'Heavy Metal',
1736 'Black Metal',
1737 'Crossover',
1738 'Contemporary Christian',
1739 'Christian Rock',
1740 'Merengue',
1741 'Salsa',
1742 'Thrash Metal',
1743 'Anime',
1744 'JPop',
1745 'Synthpop',
1746 );
1747
1748 @t_bitrate = ([
1749 [0, 32, 48, 56, 64, 80, 96, 112, 128, 144, 160, 176, 192, 224, 256],
1750 [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160],
1751 [0, 8, 16, 24, 32, 40, 48, 56, 64, 80, 96, 112, 128, 144, 160]
1752 ],[
1753 [0, 32, 64, 96, 128, 160, 192, 224, 256, 288, 320, 352, 384, 416, 448],
1754 [0, 32, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320, 384],
1755 [0, 32, 40, 48, 56, 64, 80, 96, 112, 128, 160, 192, 224, 256, 320]
1756 ]);
1757
1758 @t_sampling_freq = (
1759 [11025, 12000, 8000],
1760 [undef, undef, undef], # reserved
1761 [22050, 24000, 16000],
1762 [44100, 48000, 32000]
1763 );
1764
1765 @frequency_tbl = map { $_ ? eval "${_}e-3" : 0 }
1766 map { @$_ } @t_sampling_freq;
1767
1768 @mp3_info_fields = qw(
1769 VERSION
1770 LAYER
1771 STEREO
1772 VBR
1773 BITRATE
1774 FREQUENCY
1775 SIZE
1776 OFFSET
1777 SECS
1778 MM
1779 SS
1780 MS
1781 TIME
1782 COPYRIGHT
1783 PADDING
1784 MODE
1785 FRAMES
1786 FRAME_LENGTH
1787 VBR_SCALE
1788 );
1789
1790 %rva2_channel_types = (
1791 0x00 => 'OTHER',
1792 0x01 => 'MASTER',
1793 0x02 => 'FRONT_RIGHT',
1794 0x03 => 'FRONT_LEFT',
1795 0x04 => 'BACK_RIGHT',
1796 0x05 => 'BACK_LEFT',
1797 0x06 => 'FRONT_CENTER',
1798 0x07 => 'BACK_CENTER',
1799 0x08 => 'SUBWOOFER',
1800 );
1801
1802 %v1_tag_fields =
1803 (TITLE => 30, ARTIST => 30, ALBUM => 30, COMMENT => 30, YEAR => 4);
1804
1805 @v1_tag_names = qw(TITLE ARTIST ALBUM YEAR COMMENT TRACKNUM GENRE);
1806
1807 %v2_to_v1_names = (
1808 # v2.2 tags
1809 'TT2' => 'TITLE',
1810 'TP1' => 'ARTIST',
1811 'TAL' => 'ALBUM',
1812 'TYE' => 'YEAR',
1813 'COM' => 'COMMENT',
1814 'TRK' => 'TRACKNUM',
1815 'TCO' => 'GENRE', # not clean mapping, but ...
1816 # v2.3 tags
1817 'TIT2' => 'TITLE',
1818 'TPE1' => 'ARTIST',
1819 'TALB' => 'ALBUM',
1820 'TYER' => 'YEAR',
1821 'COMM' => 'COMMENT',
1822 'TRCK' => 'TRACKNUM',
1823 'TCON' => 'GENRE',
1824 # v2.3 tags - needed for MusicBrainz
1825 'UFID' => 'Unique file identifier',
1826 'TXXX' => 'User defined text information frame',
1827 );
1828
1829 %v2_tag_names = (
1830 # v2.2 tags
1831 'BUF' => 'Recommended buffer size',
1832 'CNT' => 'Play counter',
1833 'COM' => 'Comments',
1834 'CRA' => 'Audio encryption',
1835 'CRM' => 'Encrypted meta frame',
1836 'ETC' => 'Event timing codes',
1837 'EQU' => 'Equalization',
1838 'GEO' => 'General encapsulated object',
1839 'IPL' => 'Involved people list',
1840 'LNK' => 'Linked information',
1841 'MCI' => 'Music CD Identifier',
1842 'MLL' => 'MPEG location lookup table',
1843 'PIC' => 'Attached picture',
1844 'POP' => 'Popularimeter',
1845 'REV' => 'Reverb',
1846 'RVA' => 'Relative volume adjustment',
1847 'SLT' => 'Synchronized lyric/text',
1848 'STC' => 'Synced tempo codes',
1849 'TAL' => 'Album/Movie/Show title',
1850 'TBP' => 'BPM (Beats Per Minute)',
1851 'TCM' => 'Composer',
1852 'TCO' => 'Content type',
1853 'TCR' => 'Copyright message',
1854 'TDA' => 'Date',
1855 'TDY' => 'Playlist delay',
1856 'TEN' => 'Encoded by',
1857 'TFT' => 'File type',
1858 'TIM' => 'Time',
1859 'TKE' => 'Initial key',
1860 'TLA' => 'Language(s)',
1861 'TLE' => 'Length',
1862 'TMT' => 'Media type',
1863 'TOA' => 'Original artist(s)/performer(s)',
1864 'TOF' => 'Original filename',
1865 'TOL' => 'Original Lyricist(s)/text writer(s)',
1866 'TOR' => 'Original release year',
1867 'TOT' => 'Original album/Movie/Show title',
1868 'TP1' => 'Lead artist(s)/Lead performer(s)/Soloist(s)/Performing group',
1869 'TP2' => 'Band/Orchestra/Accompaniment',
1870 'TP3' => 'Conductor/Performer refinement',
1871 'TP4' => 'Interpreted, remixed, or otherwise modified by',
1872 'TPA' => 'Part of a set',
1873 'TPB' => 'Publisher',
1874 'TRC' => 'ISRC (International Standard Recording Code)',
1875 'TRD' => 'Recording dates',
1876 'TRK' => 'Track number/Position in set',
1877 'TSI' => 'Size',
1878 'TSS' => 'Software/hardware and settings used for encoding',
1879 'TT1' => 'Content group description',
1880 'TT2' => 'Title/Songname/Content description',
1881 'TT3' => 'Subtitle/Description refinement',
1882 'TXT' => 'Lyricist/text writer',
1883 'TXX' => 'User defined text information frame',
1884 'TYE' => 'Year',
1885 'UFI' => 'Unique file identifier',
1886 'ULT' => 'Unsychronized lyric/text transcription',
1887 'WAF' => 'Official audio file webpage',
1888 'WAR' => 'Official artist/performer webpage',
1889 'WAS' => 'Official audio source webpage',
1890 'WCM' => 'Commercial information',
1891 'WCP' => 'Copyright/Legal information',
1892 'WPB' => 'Publishers official webpage',
1893 'WXX' => 'User defined URL link frame',
1894
1895 # v2.3 tags
1896 'AENC' => 'Audio encryption',
1897 'APIC' => 'Attached picture',
1898 'COMM' => 'Comments',
1899 'COMR' => 'Commercial frame',
1900 'ENCR' => 'Encryption method registration',
1901 'EQUA' => 'Equalization',
1902 'ETCO' => 'Event timing codes',
1903 'GEOB' => 'General encapsulated object',
1904 'GRID' => 'Group identification registration',
1905 'IPLS' => 'Involved people list',
1906 'LINK' => 'Linked information',
1907 'MCDI' => 'Music CD identifier',
1908 'MLLT' => 'MPEG location lookup table',
1909 'OWNE' => 'Ownership frame',
1910 'PCNT' => 'Play counter',
1911 'POPM' => 'Popularimeter',
1912 'POSS' => 'Position synchronisation frame',
1913 'PRIV' => 'Private frame',
1914 'RBUF' => 'Recommended buffer size',
1915 'RVAD' => 'Relative volume adjustment',
1916 'RVRB' => 'Reverb',
1917 'SYLT' => 'Synchronized lyric/text',
1918 'SYTC' => 'Synchronized tempo codes',
1919 'TALB' => 'Album/Movie/Show title',
1920 'TBPM' => 'BPM (beats per minute)',
1921 'TCOM' => 'Composer',
1922 'TCON' => 'Content type',
1923 'TCOP' => 'Copyright message',
1924 'TDAT' => 'Date',
1925 'TDLY' => 'Playlist delay',
1926 'TENC' => 'Encoded by',
1927 'TEXT' => 'Lyricist/Text writer',
1928 'TFLT' => 'File type',
1929 'TIME' => 'Time',
1930 'TIT1' => 'Content group description',
1931 'TIT2' => 'Title/songname/content description',
1932 'TIT3' => 'Subtitle/Description refinement',
1933 'TKEY' => 'Initial key',
1934 'TLAN' => 'Language(s)',
1935 'TLEN' => 'Length',
1936 'TMED' => 'Media type',
1937 'TOAL' => 'Original album/movie/show title',
1938 'TOFN' => 'Original filename',
1939 'TOLY' => 'Original lyricist(s)/text writer(s)',
1940 'TOPE' => 'Original artist(s)/performer(s)',
1941 'TORY' => 'Original release year',
1942 'TOWN' => 'File owner/licensee',
1943 'TPE1' => 'Lead performer(s)/Soloist(s)',
1944 'TPE2' => 'Band/orchestra/accompaniment',
1945 'TPE3' => 'Conductor/performer refinement',
1946 'TPE4' => 'Interpreted, remixed, or otherwise modified by',
1947 'TPOS' => 'Part of a set',
1948 'TPUB' => 'Publisher',
1949 'TRCK' => 'Track number/Position in set',
1950 'TRDA' => 'Recording dates',
1951 'TRSN' => 'Internet radio station name',
1952 'TRSO' => 'Internet radio station owner',
1953 'TSIZ' => 'Size',
1954 'TSRC' => 'ISRC (international standard recording code)',
1955 'TSSE' => 'Software/Hardware and settings used for encoding',
1956 'TXXX' => 'User defined text information frame',
1957 'TYER' => 'Year',
1958 'UFID' => 'Unique file identifier',
1959 'USER' => 'Terms of use',
1960 'USLT' => 'Unsychronized lyric/text transcription',
1961 'WCOM' => 'Commercial information',
1962 'WCOP' => 'Copyright/Legal information',
1963 'WOAF' => 'Official audio file webpage',
1964 'WOAR' => 'Official artist/performer webpage',
1965 'WOAS' => 'Official audio source webpage',
1966 'WORS' => 'Official internet radio station homepage',
1967 'WPAY' => 'Payment',
1968 'WPUB' => 'Publishers official webpage',
1969 'WXXX' => 'User defined URL link frame',
1970
1971 # v2.4 additional tags
1972 # note that we don't restrict tags from 2.3 or 2.4,
1973 'ASPI' => 'Audio seek point index',
1974 'EQU2' => 'Equalisation (2)',
1975 'RVA2' => 'Relative volume adjustment (2)',
1976 'SEEK' => 'Seek frame',
1977 'SIGN' => 'Signature frame',
1978 'TDEN' => 'Encoding time',
1979 'TDOR' => 'Original release time',
1980 'TDRC' => 'Recording time',
1981 'TDRL' => 'Release time',
1982 'TDTG' => 'Tagging time',
1983 'TIPL' => 'Involved people list',
1984 'TMCL' => 'Musician credits list',
1985 'TMOO' => 'Mood',
1986 'TPRO' => 'Produced notice',
1987 'TSOA' => 'Album sort order',
1988 'TSOP' => 'Performer sort order',
1989 'TSOT' => 'Title sort order',
1990 'TSST' => 'Set subtitle',
1991
1992 # grrrrrrr
1993 'COM ' => 'Broken iTunes comments',
1994 );
1995}
1996
19971;
1998
1999__END__
2000
2001=pod
2002
2003=back
2004
2005=head1 TROUBLESHOOTING
2006
2007If you find a bug, please send me a patch (see the project page in L<"SEE ALSO">).
2008If you cannot figure out why it does not work for you, please put the MP3 file in
2009a place where I can get it (preferably via FTP, or HTTP, or .Mac iDisk) and send me
2010mail regarding where I can get the file, with a detailed description of the problem.
2011
2012If I download the file, after debugging the problem I will not keep the MP3 file
2013if it is not legal for me to have it. Just let me know if it is legal for me to
2014keep it or not.
2015
2016
2017=head1 TODO
2018
2019=over 4
2020
2021=item ID3v2 Support
2022
2023Still need to do more for reading tags, such as using Compress::Zlib to decompress
2024compressed tags. But until I see this in use more, I won't bother. If something
2025does not work properly with reading, follow the instructions above for
2026troubleshooting.
2027
2028ID3v2 I<writing> is coming soon.
2029
2030=item Get data from scalar
2031
2032Instead of passing a file spec or filehandle, pass the
2033data itself. Would take some work, converting the seeks, etc.
2034
2035=item Padding bit ?
2036
2037Do something with padding bit.
2038
2039=item Test suite
2040
2041Test suite could use a bit of an overhaul and update. Patches very welcome.
2042
2043=over 4
2044
2045=item *
2046
2047Revamp getset.t. Test all the various get_mp3tag args.
2048
2049=item *
2050
2051Test Unicode.
2052
2053=item *
2054
2055Test OOP API.
2056
2057=item *
2058
2059Test error handling, check more for missing files, bad MP3s, etc.
2060
2061=back
2062
2063=item Other VBR
2064
2065Right now, only Xing VBR is supported.
2066
2067=back
2068
2069
2070=head1 THANKS
2071
2072Edward Allen,
2073Vittorio Bertola,
2074Michael Blakeley,
2075Per Bolmstedt,
2076Tony Bowden,
2077Tom Brown,
2078Sergio Camarena,
2079Chris Dawson,
2080Anthony DiSante,
2081Luke Drumm,
2082Kyle Farrell,
2083Jeffrey Friedl,
2084brian d foy,
2085Ben Gertzfield,
2086Brian Goodwin,
2087Todd Hanneken,
2088Todd Harris,
2089Woodrow Hill,
2090Kee Hinckley,
2091Roman Hodek,
2092Ilya Konstantinov,
2093Peter Kovacs,
2094Johann Lindvall,
2095Alex Marandon,
2096Peter Marschall,
2097michael,
2098Trond Michelsen,
2099Dave O'Neill,
2100Christoph Oberauer,
2101Jake Palmer,
2102Andrew Phillips,
2103David Reuteler,
2104John Ruttenberg,
2105Matthew Sachs,
2106scfc_de,
2107Hermann Schwaerzler,
2108Chris Sidi,
2109Roland Steinbach,
2110Brian S. Stephan,
2111Stuart,
2112Dan Sully,
2113Jeffery Sumler,
2114Predrag Supurovic,
2115Bogdan Surdu,
2116Pierre-Yves Thoulon,
2117tim,
2118Pass F. B. Travis,
2119Tobias Wagener,
2120Ronan Waide,
2121Andy Waite,
2122Ken Williams,
2123Ben Winslow,
2124Meng Weng Wong.
2125
2126
2127=head1 CURRENT AUTHOR
2128
2129Dan Sully E<lt>dan | at | slimdevices.comE<gt> & Slim Devices, Inc.
2130
2131=head1 AUTHOR EMERITUS
2132
2133Chris Nandor E<lt>pudge@pobox.comE<gt>, http://pudge.net/
2134
2135=head1 COPYRIGHT AND LICENSE
2136
2137Copyright (c) 2006 Dan Sully & Slim Devices, Inc. All rights reserved.
2138
2139Copyright (c) 1998-2005 Chris Nandor. All rights reserved.
2140
2141This program is free software; you can redistribute it and/or modify it under
2142the same terms as Perl itself.
2143
2144=head1 SEE ALSO
2145
2146=over 4
2147
2148=item Slim Devices
2149
2150 http://www.slimdevices.com/
2151
2152=item mp3tools
2153
2154 http://www.zevils.com/linux/mp3tools/
2155
2156=item mpgtools
2157
2158 http://www.dv.co.yu/mpgscript/mpgtools.htm
2159 http://www.dv.co.yu/mpgscript/mpeghdr.htm
2160
2161=item mp3tool
2162
2163 http://www.dtek.chalmers.se/~d2linjo/mp3/mp3tool.html
2164
2165=item ID3v2
2166
2167 http://www.id3.org/
2168
2169=item Xing Variable Bitrate
2170
2171 http://www.xingtech.com/support/partner_developer/mp3/vbr_sdk/
2172
2173=item MP3Ext
2174
2175 http://rupert.informatik.uni-stuttgart.de/~mutschml/MP3ext/
2176
2177=item Xmms
2178
2179 http://www.xmms.org/
2180
2181
2182=back
2183
2184=cut
generated by cgit v1.2.3 (git 2.39.1) at 2024-09-25 13:24:50 +0000