view release on metacpan or  search on metacpan

lib/Audio/M4P/QuickTime.pm  view on Meta::CPAN

                undef, undef );
        }
    }
    while ( ( $key, $type ) = each %iTMS_dict_meta_types ) {
        my $meta = $self->FindAtom($type) or next;
        my $data = substr( $meta->data, 16 );
        if ( $type eq 'trkn' ) {
            ( undef, $info{trackNumber}, $info{trackCount} ) = unpack "nnn",
              $data;
        }
        elsif ( $type eq 'disk' ) {
            ( undef, $info{diskNumber}, $info{discCount} ) = unpack "nnn",
              $data;
        }
        elsif ( $type eq 'cprt' ) {
            ( undef, $info{'copyright'} ) = split( /\s+/, $data, 2 );
        }
        else { $info{$key} = $data }
    }
    return \%info;
}


# Get cover art--returns a reference to an array of cover artwork
sub GetCoverArt {
    my ($self) = @_;
    my @covr = $self->FindAtom('covr') or return;
    my @artwork = ();
    foreach my $atm (@covr) {
        my @data_atms = $atm->Contained('data') or next;
        foreach my $dt ( @data_atms ) {
			push @artwork, substr( $dt->data, 8 );
		}
    }
    return \@artwork;
}


# remove all cover art, return number of covers removed
# does not remove an empty covr atom (one without cover data)
# but otherwise will remove covr atoms as well as cover data
sub DeleteAllCoverArt {
    my ($self) = @_;
    my $removed = 0;
    my @covr = $self->FindAtom('covr');
    foreach my $atm (@covr) {
		my @atoms = $atm->Contained('data') or next;
		my $siz  = $atm->size;
		my $pos  = $atm->start;
		$atm->selfDelete() or next;
		$self->FixStco( $siz, $pos );
		$removed += scalar @atoms;	
	}
	return $removed;	
}

# add a single album cover by EITHER adding one covr atom 
# OR adding one cover's data to an existing covr atom
# takes a argument which should be a compatible graphic format binary
# but does NO checks for compatibility with iTunes' cover art display
# type OUGHT TO BE 13 for jpeg, 14 for png graphics format,
# but method DOES NOT CHECK for type except will default to 13 
# if no type argument provided
sub AddCoverArt {
    my ($self, $art, $type) = @_;
    $type = 13 unless $type;
    my $covr = $self->FindAtom('covr');
    if( !$covr )
    {
		my $ilst = $self->FindAtom('ilst') || $self->MakeIlstAtom || return;
        $ilst->insertNew( 'covr', '' );
        $self->FixStco( -8, $ilst->start );
        return unless $covr = $self->FindAtom('covr');
    }
	$covr->insertNew( 'data', pack( 'NN', $type, 0 ) . $art );
	$self->FixStco( -16 - length $art, $covr->start );
	return 1;
}

#-----------------------------------------------------------

# MP3::Tag analogs, but more fields, and allow setting of tags

sub autoinfo {
    my ($self) = @_;
    my $tags = $self->GetMetaInfo;
    return (
        $tags->{TITLE},   $tags->{TRKN}, $tags->{ARTIST}, $tags->{ALBUM},
        $tags->{COMMENT}, $tags->{YEAR}, $tags->{GENRE}
    );
}

sub title {
    my ( $self, $new_tag ) = @_;
    $self->SetMetaInfo( 'TITLE', $new_tag, 1 ) if $new_tag;
    my $tags = $self->GetMetaInfo;
    return $tags->{TITLE} || '';
}

sub album {
    my ( $self, $new_tag ) = @_;
    $self->SetMetaInfo( 'ALBUM', $new_tag, 1 ) if $new_tag;
    my $tags = $self->GetMetaInfo;
    return $tags->{ALBUM} || '';
}

sub artist {
    my ( $self, $new_tag ) = @_;
    $self->SetMetaInfo( 'ARTIST', $new_tag, 1 ) if $new_tag;
    my $tags = $self->GetMetaInfo;
    return $tags->{ARTIST} || '';
}

sub comment {
    my ( $self, $new_tag ) = @_;
    $self->SetMetaInfo( 'COMMENT', $new_tag, 1 ) if $new_tag;
    my $tags = $self->GetMetaInfo;
    return $tags->{COMMENT} || '';
}

sub year {

lib/Audio/M4P/QuickTime.pm  view on Meta::CPAN

with tag information formats in MP3::Info and MP4::Info. Potential tags are 
LAYER (1), VERSION (4), SIZE, SECONDS, SS, MM, and BITRATE. 

=item B<SetMetaInfo>

 my $comment = "After paying for this music file, I have fair use rights to change it.";

 $qt->SetMetaInfo(COMMENT => $comment);
 $qt->SetMetaInfo(GENRE => "Bebop", 1, 'day');

Set a meta information field. The third argument, if given and true, indicates
that the program should replace all instances of meta data of this type with 
the new entry, rather than adding the tag to the existing meta data. The fourth 
argument, if given and true, indicated a tag value before which the new tag is
to be placed in the file. The fifth argument indicates the values are in text 
form, ie for meta type 'trkn', value is something like 'Track 5 of 11'.

=item B<iTMS_MetaInfo>

 my $hashref = $qt->iTMS_MetaInfo;
 
 $hashref->{comments} = "A new comment";
 $qt->iTMS_MetaInfo($hashref);
 
Get or set a meta information field via a hash reference to an Apple iTMS
type dict data structure. Possible fields are copyright, comments, 
songName, genre, playlistArtistName, genreID, composerName, playlistName,
year, trackNumber, trackCount, discNumber, discCount, and artworkURL. iTMS 
meta data entries may not be compatible with MP3::Info type meta data. An
optional second argument, if true, prevents the method from replacing old meta
information, as in $qt->iTMS_MetaInfo($hashref, 1);

Note that although this method of manipulating M4P data tags is closest to the 
way iTMS and iTunes do metadata, it may be less intuitive for most audio tag 
programmers than the MP3::Tag and Audio::TagLib compatible methods below.

=item B<GetCoverArt>

  my $artwork = $qt->GetCoverArt();
  foreach my $pic (@{$artwork}) { 
      # do stuff with art
  }
  
Returns a reference to an array of cover artwork. Note: the artwork routines
were suggested and largely contributed by pucklock. (Thanks!)


=item B<DeleteAllCoverArt>

  $qt->DeleteAllCoverArt;

Delete all cover art from the file. This removes all data from the covr atom, 
if any.  Returns the number of cover data atoms deleted.


=item B<AddCoverArt>


  $qt->AddCoverArt( $jpeg_art, 13 );  # $jpeg_art is an iTunes compatible jpeg 
  $qt->AddCoverArt( $jpeg_art );      # the same as above, defaults to type 13
  $qt->AddCoverArt( $png_art, 14 );   # PNG graphics are data type 14

Add cover artwork to the file. Creates a new covr atom if needed. Returns 1 if 
successful, otherwise null.

The method adds a single album cover by either adding one covr atom or 
by adding one cover's data to an existing covr atom. Takes a argument which 
should be a compatible graphic format binary, but does NO checks for 
compatibility with iTunes' cover art display. The type should be 13 
for jpeg, 14 for png graphics format, but defaults to 13.


=back

=head2 MP3::Tag and Audio::TagLib Compatible Functions

=over 4

=item B<autoinfo>

  my($title, $tracknum, $artist, $album, $comment, $year, $genre) =
    $qt->autoinfo;

Returns an array of tag metadata, similar to the same method in MP3::Tag.

=item B<album>

  my $album = $qt->album;
  $new_album = "My New Album Name";
  $qt->album($new_album);

Get and set title tag data.
Similar to the same method in MP3::TagLib.

Note this and other tag functions below will usually return the empty 
string "" when there is tag data lacking, unless an integer result is expected, 
in which case 0 is returned. This is for compatibility with MP3::Tag and 
Audio::TagLib's implementation of these methods.

=item B<artist>

  my $artist = $qt->artist;
  $new_artist = "My New Artist";
  $qt->artist($new_artist);

Get and set artist tag data.
Similar to the same method in MP3::TagLib.

=item B<comment>

  my $comment = $qt->comment;
  $new_comment = "My Comment Goes Here";
  $qt->comment($new_comment);

Get and set comment tag data.
Similar to the same method in MP3::Tag.

=item B<genre>

  my $genre = $qt->genre;
  $new_genre = 18;
  $qt->genre($new_genre);

Get and set genre tag data BY NUMBER.

=item B<genre_as_text>

  my $text_genre = $qt->genre_as_text;
  $new_genre = "Rock";
  $qt->genre_as_text($new_genre);