Struct Tag

pub struct Tag {
    pub ftyp: String,
    pub info: AudioInfo,
    pub userdata: Userdata,
}

A tag containing MPEG-4 audio metadata.

Fields

ftyp: String

The filetype (ftyp) atom.

info: AudioInfo

userdata: Userdata

Implementations

impl Tag

Audio information

pub fn audio_info(&self) -> &AudioInfo

Returns a reference of the audio information.

pub fn duration(&self) -> Duration

Returns the duration in seconds.

pub fn channel_config(&self) -> Option<ChannelConfig>

Returns the channel configuration.

pub fn sample_rate(&self) -> Option<SampleRate>

Returns the channel configuration.

pub fn avg_bitrate(&self) -> Option<u32>

Returns the average bitrate.

pub fn max_bitrate(&self) -> Option<u32>

Returns the maximum bitrate.

impl Tag

Filetype

pub fn filetype(&self) -> &str

returns the filetype (ftyp).

impl Tag

pub fn read_with( reader: &mut (impl Read + Seek), cfg: &ReadConfig, ) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the reader.

pub fn read_from(reader: &mut (impl Read + Seek)) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the reader.

pub fn read_with_path(path: impl AsRef<Path>, cfg: &ReadConfig) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the file at the indicated path.

pub fn read_from_path(path: impl AsRef<Path>) -> Result<Self>

Attempts to read a MPEG-4 audio tag from the file at the indicated path.

Methods from Deref<Target = Userdata>

pub fn album(&self) -> Option<&str>

Returns the album (©alb).

pub fn take_album(&mut self) -> Option<String>

Removes and returns the album (©alb).

pub fn set_album(&mut self, album: impl Into<String>)

Sets the album (©alb).

pub fn remove_album(&mut self)

Removes the album (©alb).

pub fn copyright(&self) -> Option<&str>

Returns the copyright (cprt).

pub fn take_copyright(&mut self) -> Option<String>

Removes and returns the copyright (cprt).

pub fn set_copyright(&mut self, copyright: impl Into<String>)

Sets the copyright (cprt).

pub fn remove_copyright(&mut self)

Removes the copyright (cprt).

pub fn encoder(&self) -> Option<&str>

Returns the encoder (©too).

pub fn take_encoder(&mut self) -> Option<String>

Removes and returns the encoder (©too).

pub fn set_encoder(&mut self, encoder: impl Into<String>)

Sets the encoder (©too).

pub fn remove_encoder(&mut self)

Removes the encoder (©too).

pub fn lyrics(&self) -> Option<&str>

Returns the lyrics (©lyr).

pub fn take_lyrics(&mut self) -> Option<String>

Removes and returns the lyrics (©lyr).

pub fn set_lyrics(&mut self, lyrics: impl Into<String>)

Sets the lyrics (©lyr).

pub fn remove_lyrics(&mut self)

Removes the lyrics (©lyr).

pub fn movement(&self) -> Option<&str>

Returns the movement (©mvn).

pub fn take_movement(&mut self) -> Option<String>

Removes and returns the movement (©mvn).

pub fn set_movement(&mut self, movement: impl Into<String>)

Sets the movement (©mvn).

pub fn remove_movement(&mut self)

Removes the movement (©mvn).

pub fn title(&self) -> Option<&str>

Returns the title (©nam).

pub fn take_title(&mut self) -> Option<String>

Removes and returns the title (©nam).

pub fn set_title(&mut self, title: impl Into<String>)

Sets the title (©nam).

pub fn remove_title(&mut self)

Removes the title (©nam).

pub fn tv_episode_name(&self) -> Option<&str>

Returns the tv episode name (tven).

pub fn take_tv_episode_name(&mut self) -> Option<String>

Removes and returns the tv episode name (tven).

pub fn set_tv_episode_name(&mut self, tv_episode_name: impl Into<String>)

Sets the tv episode name (tven).

pub fn remove_tv_episode_name(&mut self)

Removes the tv episode name (tven).

pub fn tv_network_name(&self) -> Option<&str>

Returns the tv network name (tvnn).

pub fn take_tv_network_name(&mut self) -> Option<String>

Removes and returns the tv network name (tvnn).

pub fn set_tv_network_name(&mut self, tv_network_name: impl Into<String>)

Sets the tv network name (tvnn).

pub fn remove_tv_network_name(&mut self)

Removes the tv network name (tvnn).

pub fn tv_show_name(&self) -> Option<&str>

Returns the tv show name (tvsh).

pub fn take_tv_show_name(&mut self) -> Option<String>

Removes and returns the tv show name (tvsh).

pub fn set_tv_show_name(&mut self, tv_show_name: impl Into<String>)

Sets the tv show name (tvsh).

pub fn remove_tv_show_name(&mut self)

Removes the tv show name (tvsh).

pub fn work(&self) -> Option<&str>

Returns the work (©wrk).

pub fn take_work(&mut self) -> Option<String>

Removes and returns the work (©wrk).

pub fn set_work(&mut self, work: impl Into<String>)

Sets the work (©wrk).

pub fn remove_work(&mut self)

Removes the work (©wrk).

pub fn year(&self) -> Option<&str>

Returns the year (©day).

pub fn take_year(&mut self) -> Option<String>

Removes and returns the year (©day).

pub fn set_year(&mut self, year: impl Into<String>)

Sets the year (©day).

pub fn remove_year(&mut self)

Removes the year (©day).

pub fn isrc(&self) -> Option<&str>

Returns the isrc (----:com.apple.iTunes:ISRC).

pub fn take_isrc(&mut self) -> Option<String>

Removes and returns the isrc (----:com.apple.iTunes:ISRC).

pub fn set_isrc(&mut self, isrc: impl Into<String>)

Sets the isrc (----:com.apple.iTunes:ISRC).

pub fn remove_isrc(&mut self)

Removes the isrc (----:com.apple.iTunes:ISRC).

pub fn album_sort_order(&self) -> Option<&str>

Returns the album sort order (soal).

pub fn take_album_sort_order(&mut self) -> Option<String>

Removes and returns the album sort order (soal).

pub fn set_album_sort_order(&mut self, album_sort_order: impl Into<String>)

Sets the album sort order (soal).

pub fn remove_album_sort_order(&mut self)

Removes the album sort order (soal).

pub fn title_sort_order(&self) -> Option<&str>

Returns the title sort order (sonm).

pub fn take_title_sort_order(&mut self) -> Option<String>

Removes and returns the title sort order (sonm).

pub fn set_title_sort_order(&mut self, title_sort_order: impl Into<String>)

Sets the title sort order (sonm).

pub fn remove_title_sort_order(&mut self)

Removes the title sort order (sonm).

pub fn tv_show_name_sort_order(&self) -> Option<&str>

Returns the tv show name sort order (sosn).

pub fn take_tv_show_name_sort_order(&mut self) -> Option<String>

Removes and returns the tv show name sort order (sosn).

pub fn set_tv_show_name_sort_order( &mut self, tv_show_name_sort_order: impl Into<String>, )

Sets the tv show name sort order (sosn).

pub fn remove_tv_show_name_sort_order(&mut self)

Removes the tv show name sort order (sosn).

pub fn album_artists(&self) -> impl Iterator<Item = &str>

Returns all album artists (aART).

pub fn album_artist(&self) -> Option<&str>

Returns the first album artist (aART).

pub fn take_album_artists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all album artists (aART).

pub fn take_album_artist(&mut self) -> Option<String>

Removes all and returns the first album artist (aART).

pub fn set_album_artists( &mut self, album_artists: impl IntoIterator<Item = String>, )

Sets all album artists (aART). This will remove all other album artists.

pub fn set_album_artist(&mut self, album_artist: impl Into<String>)

Sets the album artist (aART). This will remove all other album artists.

pub fn add_album_artists( &mut self, album_artists: impl IntoIterator<Item = String>, )

Adds all album artists (aART).

pub fn add_album_artist(&mut self, album_artist: impl Into<String>)

Adds an album artist (aART).

pub fn remove_album_artists(&mut self)

Removes all album artists (aART).

pub fn artists(&self) -> impl Iterator<Item = &str>

Returns all artists (©ART).

pub fn artist(&self) -> Option<&str>

Returns the first artist (©ART).

pub fn take_artists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all artists (©ART).

pub fn take_artist(&mut self) -> Option<String>

Removes all and returns the first artist (©ART).

pub fn set_artists(&mut self, artists: impl IntoIterator<Item = String>)

Sets all artists (©ART). This will remove all other artists.

pub fn set_artist(&mut self, artist: impl Into<String>)

Sets the artist (©ART). This will remove all other artists.

pub fn add_artists(&mut self, artists: impl IntoIterator<Item = String>)

Adds all artists (©ART).

pub fn add_artist(&mut self, artist: impl Into<String>)

Adds an artist (©ART).

pub fn remove_artists(&mut self)

Removes all artists (©ART).

pub fn categories(&self) -> impl Iterator<Item = &str>

Returns all categories (catg).

pub fn category(&self) -> Option<&str>

Returns the first category (catg).

pub fn take_categories(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all categories (catg).

pub fn take_category(&mut self) -> Option<String>

Removes all and returns the first category (catg).

pub fn set_categories(&mut self, categories: impl IntoIterator<Item = String>)

Sets all categories (catg). This will remove all other categories.

pub fn set_category(&mut self, category: impl Into<String>)

Sets the category (catg). This will remove all other categories.

pub fn add_categories(&mut self, categories: impl IntoIterator<Item = String>)

Adds all categories (catg).

pub fn add_category(&mut self, category: impl Into<String>)

Adds an category (catg).

pub fn remove_categories(&mut self)

Removes all categories (catg).

pub fn comments(&self) -> impl Iterator<Item = &str>

Returns all comments (©cmt).

pub fn comment(&self) -> Option<&str>

Returns the first comment (©cmt).

pub fn take_comments(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all comments (©cmt).

pub fn take_comment(&mut self) -> Option<String>

Removes all and returns the first comment (©cmt).

pub fn set_comments(&mut self, comments: impl IntoIterator<Item = String>)

Sets all comments (©cmt). This will remove all other comments.

pub fn set_comment(&mut self, comment: impl Into<String>)

Sets the comment (©cmt). This will remove all other comments.

pub fn add_comments(&mut self, comments: impl IntoIterator<Item = String>)

Adds all comments (©cmt).

pub fn add_comment(&mut self, comment: impl Into<String>)

Adds an comment (©cmt).

pub fn remove_comments(&mut self)

Removes all comments (©cmt).

pub fn composers(&self) -> impl Iterator<Item = &str>

Returns all composers (©wrt).

pub fn composer(&self) -> Option<&str>

Returns the first composer (©wrt).

pub fn take_composers(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all composers (©wrt).

pub fn take_composer(&mut self) -> Option<String>

Removes all and returns the first composer (©wrt).

pub fn set_composers(&mut self, composers: impl IntoIterator<Item = String>)

Sets all composers (©wrt). This will remove all other composers.

pub fn set_composer(&mut self, composer: impl Into<String>)

Sets the composer (©wrt). This will remove all other composers.

pub fn add_composers(&mut self, composers: impl IntoIterator<Item = String>)

Adds all composers (©wrt).

pub fn add_composer(&mut self, composer: impl Into<String>)

Adds an composer (©wrt).

pub fn remove_composers(&mut self)

Removes all composers (©wrt).

pub fn custom_genres(&self) -> impl Iterator<Item = &str>

Returns all custom genres (©gen).

pub fn custom_genre(&self) -> Option<&str>

Returns the first custom genre (©gen).

pub fn take_custom_genres(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all custom genres (©gen).

pub fn take_custom_genre(&mut self) -> Option<String>

Removes all and returns the first custom genre (©gen).

pub fn set_custom_genres( &mut self, custom_genres: impl IntoIterator<Item = String>, )

Sets all custom genres (©gen). This will remove all other custom genres.

pub fn set_custom_genre(&mut self, custom_genre: impl Into<String>)

Sets the custom genre (©gen). This will remove all other custom genres.

pub fn add_custom_genres( &mut self, custom_genres: impl IntoIterator<Item = String>, )

Adds all custom genres (©gen).

pub fn add_custom_genre(&mut self, custom_genre: impl Into<String>)

Adds an custom genre (©gen).

pub fn remove_custom_genres(&mut self)

Removes all custom genres (©gen).

pub fn descriptions(&self) -> impl Iterator<Item = &str>

Returns all descriptions (desc).

pub fn description(&self) -> Option<&str>

Returns the first description (desc).

pub fn take_descriptions(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all descriptions (desc).

pub fn take_description(&mut self) -> Option<String>

Removes all and returns the first description (desc).

pub fn set_descriptions( &mut self, descriptions: impl IntoIterator<Item = String>, )

Sets all descriptions (desc). This will remove all other descriptions.

pub fn set_description(&mut self, description: impl Into<String>)

Sets the description (desc). This will remove all other descriptions.

pub fn add_descriptions( &mut self, descriptions: impl IntoIterator<Item = String>, )

Adds all descriptions (desc).

pub fn add_description(&mut self, description: impl Into<String>)

Adds an description (desc).

pub fn remove_descriptions(&mut self)

Removes all descriptions (desc).

pub fn groupings(&self) -> impl Iterator<Item = &str>

Returns all groupings (©grp).

pub fn grouping(&self) -> Option<&str>

Returns the first grouping (©grp).

pub fn take_groupings(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all groupings (©grp).

pub fn take_grouping(&mut self) -> Option<String>

Removes all and returns the first grouping (©grp).

pub fn set_groupings(&mut self, groupings: impl IntoIterator<Item = String>)

Sets all groupings (©grp). This will remove all other groupings.

pub fn set_grouping(&mut self, grouping: impl Into<String>)

Sets the grouping (©grp). This will remove all other groupings.

pub fn add_groupings(&mut self, groupings: impl IntoIterator<Item = String>)

Adds all groupings (©grp).

pub fn add_grouping(&mut self, grouping: impl Into<String>)

Adds an grouping (©grp).

pub fn remove_groupings(&mut self)

Removes all groupings (©grp).

pub fn keywords(&self) -> impl Iterator<Item = &str>

Returns all keywords (keyw).

pub fn keyword(&self) -> Option<&str>

Returns the first keyword (keyw).

pub fn take_keywords(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all keywords (keyw).

pub fn take_keyword(&mut self) -> Option<String>

Removes all and returns the first keyword (keyw).

pub fn set_keywords(&mut self, keywords: impl IntoIterator<Item = String>)

Sets all keywords (keyw). This will remove all other keywords.

pub fn set_keyword(&mut self, keyword: impl Into<String>)

Sets the keyword (keyw). This will remove all other keywords.

pub fn add_keywords(&mut self, keywords: impl IntoIterator<Item = String>)

Adds all keywords (keyw).

pub fn add_keyword(&mut self, keyword: impl Into<String>)

Adds an keyword (keyw).

pub fn remove_keywords(&mut self)

Removes all keywords (keyw).

pub fn lyricists(&self) -> impl Iterator<Item = &str>

Returns all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn lyricist(&self) -> Option<&str>

Returns the first lyricist (----:com.apple.iTunes:LYRICIST).

pub fn take_lyricists(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn take_lyricist(&mut self) -> Option<String>

Removes all and returns the first lyricist (----:com.apple.iTunes:LYRICIST).

pub fn set_lyricists(&mut self, lyricists: impl IntoIterator<Item = String>)

Sets all lyricists (----:com.apple.iTunes:LYRICIST). This will remove all other lyricists.

pub fn set_lyricist(&mut self, lyricist: impl Into<String>)

Sets the lyricist (----:com.apple.iTunes:LYRICIST). This will remove all other lyricists.

pub fn add_lyricists(&mut self, lyricists: impl IntoIterator<Item = String>)

Adds all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn add_lyricist(&mut self, lyricist: impl Into<String>)

Adds an lyricist (----:com.apple.iTunes:LYRICIST).

pub fn remove_lyricists(&mut self)

Removes all lyricists (----:com.apple.iTunes:LYRICIST).

pub fn album_artist_sort_orders(&self) -> impl Iterator<Item = &str>

Returns all album artist sort orders (soaa).

pub fn album_artist_sort_order(&self) -> Option<&str>

Returns the first album artist sort order (soaa).

pub fn take_album_artist_sort_orders( &mut self, ) -> impl Iterator<Item = String> + '_

Removes and returns all album artist sort orders (soaa).

pub fn take_album_artist_sort_order(&mut self) -> Option<String>

Removes all and returns the first album artist sort order (soaa).

pub fn set_album_artist_sort_orders( &mut self, album_artist_sort_orders: impl IntoIterator<Item = String>, )

Sets all album artist sort orders (soaa). This will remove all other album artist sort orders.

pub fn set_album_artist_sort_order( &mut self, album_artist_sort_order: impl Into<String>, )

Sets the album artist sort order (soaa). This will remove all other album artist sort orders.

pub fn add_album_artist_sort_orders( &mut self, album_artist_sort_orders: impl IntoIterator<Item = String>, )

Adds all album artist sort orders (soaa).

pub fn add_album_artist_sort_order( &mut self, album_artist_sort_order: impl Into<String>, )

Adds an album artist sort order (soaa).

pub fn remove_album_artist_sort_orders(&mut self)

Removes all album artist sort orders (soaa).

pub fn artist_sort_orders(&self) -> impl Iterator<Item = &str>

Returns all artist sort orders (soar).

pub fn artist_sort_order(&self) -> Option<&str>

Returns the first artist sort order (soar).

pub fn take_artist_sort_orders(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all artist sort orders (soar).

pub fn take_artist_sort_order(&mut self) -> Option<String>

Removes all and returns the first artist sort order (soar).

pub fn set_artist_sort_orders( &mut self, artist_sort_orders: impl IntoIterator<Item = String>, )

Sets all artist sort orders (soar). This will remove all other artist sort orders.

pub fn set_artist_sort_order(&mut self, artist_sort_order: impl Into<String>)

Sets the artist sort order (soar). This will remove all other artist sort orders.

pub fn add_artist_sort_orders( &mut self, artist_sort_orders: impl IntoIterator<Item = String>, )

Adds all artist sort orders (soar).

pub fn add_artist_sort_order(&mut self, artist_sort_order: impl Into<String>)

Adds an artist sort order (soar).

pub fn remove_artist_sort_orders(&mut self)

Removes all artist sort orders (soar).

pub fn composer_sort_orders(&self) -> impl Iterator<Item = &str>

Returns all composer sort orders (soco).

pub fn composer_sort_order(&self) -> Option<&str>

Returns the first composer sort order (soco).

pub fn take_composer_sort_orders(&mut self) -> impl Iterator<Item = String> + '_

Removes and returns all composer sort orders (soco).

pub fn take_composer_sort_order(&mut self) -> Option<String>

Removes all and returns the first composer sort order (soco).

pub fn set_composer_sort_orders( &mut self, composer_sort_orders: impl IntoIterator<Item = String>, )

Sets all composer sort orders (soco). This will remove all other composer sort orders.

pub fn set_composer_sort_order( &mut self, composer_sort_order: impl Into<String>, )

Sets the composer sort order (soco). This will remove all other composer sort orders.

pub fn add_composer_sort_orders( &mut self, composer_sort_orders: impl IntoIterator<Item = String>, )

Adds all composer sort orders (soco).

pub fn add_composer_sort_order( &mut self, composer_sort_order: impl Into<String>, )

Adds an composer sort order (soco).

pub fn remove_composer_sort_orders(&mut self)

Removes all composer sort orders (soco).

pub fn compilation(&self) -> bool

Returns the compilation flag (cpil).

pub fn set_compilation(&mut self)

Sets the compilation flag to true (cpil).

pub fn remove_compilation(&mut self)

Removes the compilation flag (cpil).

pub fn gapless_playback(&self) -> bool

Returns the gapless playback flag (pgap).

pub fn set_gapless_playback(&mut self)

Sets the gapless playback flag to true (pgap).

pub fn remove_gapless_playback(&mut self)

Removes the gapless playback flag (pgap).

pub fn show_movement(&self) -> bool

Returns the show movement flag (shwm).

pub fn set_show_movement(&mut self)

Sets the show movement flag to true (shwm).

pub fn remove_show_movement(&mut self)

Removes the show movement flag (shwm).

pub fn bpm(&self) -> Option<u16>

Returns the bpm (tmpo)

pub fn set_bpm(&mut self, bpm: u16)

Sets the bpm (tmpo)

pub fn remove_bpm(&mut self)

Removes the bpm (tmpo).

pub fn movement_count(&self) -> Option<u16>

Returns the movement count (©mvc)

pub fn set_movement_count(&mut self, movement_count: u16)

Sets the movement count (©mvc)

pub fn remove_movement_count(&mut self)

Removes the movement count (©mvc).

pub fn movement_index(&self) -> Option<u16>

Returns the movement index (©mvi)

pub fn set_movement_index(&mut self, movement_index: u16)

Sets the movement index (©mvi)

pub fn remove_movement_index(&mut self)

Removes the movement index (©mvi).

pub fn tv_episode(&self) -> Option<u32>

Returns the tv episode (tves)

pub fn set_tv_episode(&mut self, tv_episode: u32)

Sets the tv episode (tves)

pub fn remove_tv_episode(&mut self)

Removes the tv episode (tves).

pub fn tv_season(&self) -> Option<u32>

Returns the tv season (tvsn)

pub fn set_tv_season(&mut self, tv_season: u32)

Sets the tv season (tvsn)

pub fn remove_tv_season(&mut self)

Removes the tv season (tvsn).

pub fn standard_genres(&self) -> impl Iterator<Item = u16> + '_

Returns all standard genres (gnre).

pub fn standard_genre(&self) -> Option<u16>

Returns the first standard genre (gnre).

pub fn set_standard_genre(&mut self, genre_code: u16)

Sets the standard genre (gnre). This will remove all other standard genres.

pub fn set_standard_genres( &mut self, genre_codes: impl IntoIterator<Item = u16>, )

Sets all standard genres (gnre). This will remove all other standard genres.

pub fn add_standard_genre(&mut self, genre_code: u16)

Adds a standard genre (gnre).

pub fn add_standard_genres( &mut self, genre_codes: impl IntoIterator<Item = u16>, )

Adds all standard genres (gnre).

pub fn remove_standard_genres(&mut self)

Removes all standard genres (gnre).

pub fn genres(&self) -> impl Iterator<Item = &str> + '_

Returns all genres, first the standard genres (gnre) then custom ones (©gen).

pub fn genre(&self) -> Option<&str>

Returns the first genre (gnre or ©gen).

pub fn take_genres(&mut self) -> impl Iterator<Item = String> + '_

Removes all custom genres (©gen) and returns all genres, first standard genres (gnre) then custom ones (©gen).

pub fn take_genre(&mut self) -> Option<String>

Removes all custom genres (©gen) and returns the first genre (gnre or ©gen).

pub fn set_genre(&mut self, genre: impl Into<String>)

Sets the custom genre (©gen). This will remove all other standard or custom genres.

pub fn set_genres(&mut self, genres: impl IntoIterator<Item = String>)

Sets the custom genre (©gen). This will remove all other standard or custom genres.

pub fn add_genre(&mut self, genre: impl Into<String>)

Adds a custom genre (©gen).

pub fn remove_genres(&mut self)

Removes the genre (gnre or ©gen).

pub fn track(&self) -> (Option<u16>, Option<u16>)

Returns the track number and the total number of tracks (trkn).

pub fn track_number(&self) -> Option<u16>

Returns the track number (trkn).

pub fn total_tracks(&self) -> Option<u16>

Returns the total number of tracks (trkn).

pub fn set_track(&mut self, track_number: u16, total_tracks: u16)

Sets the track number and the total number of tracks (trkn).

pub fn set_track_number(&mut self, track_number: u16)

Sets the track number (trkn).

pub fn set_total_tracks(&mut self, total_tracks: u16)

Sets the total number of tracks (trkn).

pub fn remove_track(&mut self)

Removes the track number and the total number of tracks (trkn).

pub fn remove_track_number(&mut self)

Removes the track number, preserving the total number of tracks if present (trkn).

pub fn remove_total_tracks(&mut self)

Removes the total number of tracks, preserving the track number if present (trkn).

pub fn disc(&self) -> (Option<u16>, Option<u16>)

Returns the disc number and total number of discs (disk).

pub fn disc_number(&self) -> Option<u16>

Returns the disc number (disk).

pub fn total_discs(&self) -> Option<u16>

Returns the total number of discs (disk).

pub fn set_disc(&mut self, disc_number: u16, total_discs: u16)

Sets the disc number and the total number of discs (disk).

pub fn set_disc_number(&mut self, disc_number: u16)

Sets the disc number (disk).

pub fn set_total_discs(&mut self, total_discs: u16)

Sets the total number of discs (disk).

pub fn remove_disc(&mut self)

Removes the disc number and the total number of discs (disk).

pub fn remove_disc_number(&mut self)

Removes the disc number, preserving the total number of discs if present (disk).

pub fn remove_total_discs(&mut self)

Removes the total number of discs, preserving the disc number if present (disk).

pub fn write_with(&self, file: &File, cfg: &WriteConfig) -> Result<()>

Attempts to write the MPEG-4 audio tag to the writer.

pub fn write_to(&self, file: &File) -> Result<()>

Attempts to write the MPEG-4 audio tag to the writer. This will overwrite any metadata previously present on the file.

pub fn write_with_path( &self, path: impl AsRef<Path>, cfg: &WriteConfig, ) -> Result<()>

Attempts to write the MPEG-4 audio tag to the path.

pub fn write_to_path(&self, path: impl AsRef<Path>) -> Result<()>

Attempts to write the MPEG-4 audio tag to the path. This will overwrite any metadata previously present on the file.

pub fn artworks(&self) -> impl Iterator<Item = ImgRef<'_>>

Returns all artwork images (covr).

pub fn artwork(&self) -> Option<ImgRef<'_>>

Returns the first artwork image (covr).

pub fn take_artworks(&mut self) -> impl Iterator<Item = ImgBuf> + '_

Removes and returns all artwork images (covr).

pub fn take_artwork(&mut self) -> Option<ImgBuf>

Removes all and returns the first artwork image (covr).

pub fn set_artwork(&mut self, image: Img<impl Into<Vec<u8>>>)

Sets the artwork image data (covr). This will remove all other artworks.

pub fn set_artworks(&mut self, images: impl IntoIterator<Item = ImgBuf>)

Sets all artwork image data (covr). This will remove all other artworks.

pub fn add_artwork(&mut self, image: Img<impl Into<Vec<u8>>>)

Adds artwork image data (covr).

pub fn add_artworks(&mut self, images: impl IntoIterator<Item = ImgBuf>)

Adds artwork image data (covr).

pub fn remove_artworks(&mut self)

Removes all artworks (covr).

pub fn media_type(&self) -> Option<MediaType>

Returns the media type (stik).

pub fn set_media_type(&mut self, media_type: MediaType)

Sets the media type (stik).

pub fn remove_media_type(&mut self)

Removes the media type (stik).

pub fn advisory_rating(&self) -> Option<AdvisoryRating>

Returns the advisory rating (rtng).

pub fn set_advisory_rating(&mut self, rating: AdvisoryRating)

Sets the advisory rating (rtng).

pub fn remove_advisory_rating(&mut self)

Removes the advisory rating (rtng).

pub fn chapters(&self) -> &[Chapter]

Returns either the chapter list or the chapter track. The chapter list is preferred.

pub fn chapters_mut(&mut self) -> &mut Vec<Chapter>

Returns either the chapter list or the chapter track. The chapter list is preferred.

pub fn take_chapters(&mut self) -> Vec<Chapter>

Removes and returns either the chapter list or the chapter track. The chapter list is preferred.

pub fn chapter_list(&self) -> &[Chapter]

Returns the chapter list.

pub fn chapter_list_mut(&mut self) -> &mut Vec<Chapter>

Returns the chapter list.

pub fn take_chapter_list(&mut self) -> Vec<Chapter>

Removes and returns the chapter list.

pub fn chapter_track(&self) -> &[Chapter]

Returns the chapter track.

pub fn chapter_track_mut(&mut self) -> &mut Vec<Chapter>

Returns the chapter track.

pub fn take_chapter_track(&mut self) -> Vec<Chapter>

Removes and returns the chapter track.

pub fn bytes_of<'a>( &'a self, ident: &impl Ident, ) -> impl Iterator<Item = &'a [u8]>

Returns references to all byte data corresponding to the identifier.
See Data::bytes.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::BeSigned(b"data".to_vec()));
assert_eq!(tag.bytes_of(&test).next().unwrap(), b"data");

pub fn bytes_mut_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = &mut Vec<u8>>

Returns mutable references to all byte data corresponding to the identifier.
See Data::bytes_mut.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Reserved(b"data".to_vec()));
tag.bytes_mut_of(&test).next().unwrap().push('1' as u8);
assert_eq!(tag.bytes_of(&test).next().unwrap(), b"data1");

pub fn take_bytes_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = Vec<u8>>

Removes the atom corresponding to the identifier and returns all of it’s byte data.
See Data::into_bytes.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Reserved(b"data".to_vec()));
assert_eq!(tag.take_bytes_of(&test).next().unwrap(), b"data");
assert_eq!(tag.bytes_of(&test).next(), None);

pub fn strings_of<'a>( &'a self, ident: &impl Ident, ) -> impl Iterator<Item = &'a str>

Returns references to all strings corresponding to the identifier.
See Data::string.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.strings_of(&test).next().unwrap(), "data");

pub fn strings_mut_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = &mut String>

Returns all mutable string references corresponding to the identifier.
See Data::string_mut.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("string".into()));
tag.strings_mut_of(&test).next().unwrap().push('1');
assert_eq!(tag.strings_of(&test).next().unwrap(), "string1");

pub fn take_strings_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = String>

Removes the atom corresponding to the identifier and returns all of it’s strings.
See Data::into_string.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("string".into()));
assert_eq!(tag.take_strings_of(&test).next().unwrap(), "string");
assert_eq!(tag.strings_of(&test).next(), None);

pub fn images_of<'a>( &'a self, ident: &impl Ident, ) -> impl Iterator<Item = ImgRef<'a>>

Returns references to all images corresponding to the identifier.
See Data::image.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Jpeg(b"image".to_vec()));
let img = tag.images_of(&test).next().unwrap();
assert_eq!(img.data, b"image");

pub fn images_mut_of<'a>( &'a mut self, ident: &impl Ident, ) -> impl Iterator<Item = ImgMut<'a>>

Returns mutable references to all images corresponding to the identifier.
See Data::image_mut.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Jpeg(b"image".to_vec()));
let img = tag.images_mut_of(&test).next().unwrap();
img.data.push('1' as u8);

let img = tag.images_of(&test).next().unwrap();
assert_eq!(img.data, b"image1");

pub fn take_images_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = ImgBuf>

Removes the atom corresponding to the identifier and returns all of it’s images.
See Data::into_image.

Example

use mp4ameta::{Userdata, Data, Fourcc, Img};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Png(b"image".to_vec()));
assert_eq!(tag.take_images_of(&test).next().unwrap(), Img::png(b"image".to_vec()));
assert_eq!(tag.images_of(&test).next(), None);

pub fn data_of<'a>( &'a self, ident: &impl Ident, ) -> impl Iterator<Item = &'a Data>

Returns references to all data corresponding to the identifier.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.data_of(&test).next().unwrap().string(), Some("data"));

pub fn data_mut_of( &mut self, ident: &impl Ident, ) -> impl Iterator<Item = &mut Data>

Returns mutable references to all data corresponding to the identifier.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
let data = tag.data_mut_of(&test).next().unwrap();
data.string_mut().unwrap().push('1');
assert_eq!(tag.strings_of(&test).next().unwrap(), "data1");

pub fn take_data_of(&mut self, ident: &impl Ident) -> impl Iterator<Item = Data>

Removes the atom corresponding to the identifier and returns all of it’s data.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.take_data_of(&test).next().unwrap(), Data::Utf8("data".into()));
assert_eq!(tag.data_of(&test).next(), None);

pub fn bytes(&self) -> impl Iterator<Item = (&DataIdent, &[u8])>

Returns an iterator over references to all byte data.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data1".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::BeSigned(b"data2".to_vec()));

let test = DataIdent::Fourcc(test);
let mut bytes = tag.bytes();
assert_eq!(bytes.next().unwrap(), (&test, &b"data1"[..]));
assert_eq!(bytes.next().unwrap(), (&test, &b"data2"[..]));
assert_eq!(bytes.next(), None);

pub fn bytes_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut Vec<u8>)>

Returns an iterator over mutable references to all byte data.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.bytes_mut().next().unwrap();
data.push('1' as u8);

let test = DataIdent::Fourcc(test);
let mut bytes = tag.bytes();
assert_eq!(bytes.next().unwrap(), (&test, &b"data1"[..]));
assert_eq!(bytes.next(), None);

pub fn strings(&self) -> impl Iterator<Item = (&DataIdent, &str)>

Returns an iterator over references to all strings.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string1".into()));
tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf16("string2".into()));

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next().unwrap(), (&test, "string2"));
assert_eq!(strings.next(), None);

pub fn strings_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut String)>

Returns an iterator over mutable references to all strings.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.strings_mut().next().unwrap();
data.push('1');

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next(), None);

pub fn images(&self) -> impl Iterator<Item = (&DataIdent, ImgRef<'_>)>

Returns an iterator over references to all images.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc, Img};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Png(b"image1".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Jpeg(b"image2".to_vec()));

let test = DataIdent::Fourcc(test);
let mut images = tag.images();
assert_eq!(images.next().unwrap(), (&test, Img::png(&b"image1"[..])));
assert_eq!(images.next().unwrap(), (&test, Img::jpeg(&b"image2"[..])));
assert_eq!(images.next(), None);

pub fn images_mut(&mut self) -> impl Iterator<Item = (&DataIdent, ImgMut<'_>)>

Returns an iterator over mutable references to all images.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc, Img};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Bmp(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));

let (ident, image) = tag.images_mut().next().unwrap();
image.data.push('1' as u8);

let test = DataIdent::Fourcc(test);
let mut images = tag.images();
assert_eq!(images.next().unwrap(), (&test, Img::bmp(&b"data1"[..])));
assert_eq!(images.next(), None);

pub fn data(&self) -> impl Iterator<Item = (&DataIdent, &Data)>

Returns an iterator over references to all data.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Reserved(b"data".to_vec()));
tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Png(b"image".to_vec()));

let test = DataIdent::Fourcc(test);
let mut data = tag.data();
assert_eq!(data.next().unwrap(), (&test, &Data::Reserved(b"data".to_vec())));
assert_eq!(data.next().unwrap(), (&test, &Data::Utf8("string".into())));
assert_eq!(data.next().unwrap(), (&test, &Data::Png(b"image".to_vec())));
assert_eq!(data.next(), None);

pub fn data_mut(&mut self) -> impl Iterator<Item = (&DataIdent, &mut Data)>

Returns an iterator over mutable references to all data.

Example

use mp4ameta::{Userdata, Data, DataIdent, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));

let (ident, data) = tag.data_mut().next().unwrap();
data.string_mut().unwrap().push('1');

let test = DataIdent::Fourcc(test);
let mut strings = tag.strings();
assert_eq!(strings.next().unwrap(), (&test, "string1"));
assert_eq!(strings.next(), None);

pub fn remove_bytes_of(&mut self, ident: &impl Ident)

Removes all byte data corresponding to the identifier. Other data will remain unaffected.
See Data::is_bytes

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::BeSigned("data".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::BeSigned(b"data".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_bytes_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), None);

pub fn remove_strings_of(&mut self, ident: &impl Ident)

Removes all strings corresponding to the identifier. Other data will remain unaffected.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Bmp("image".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_strings_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);

pub fn remove_images_of(&mut self, ident: &impl Ident)

Removes all images corresponding to the identifier. Other data will remain unaffected.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string".into()));
tag.add_data(test, Data::Bmp("image".into()));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), Some(&Data::Bmp(b"image".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.remove_images_of(&test);


let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("string".into())));
assert_eq!(data.next(), None);

pub fn remove_data_of(&mut self, ident: &impl Ident)

Removes all data corresponding to the identifier.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert!(tag.data_of(&test).next().is_some());
tag.remove_data_of(&test);
assert!(tag.data_of(&test).next().is_none());

pub fn retain_bytes_of( &mut self, ident: &impl Ident, predicate: impl Fn(&[u8]) -> bool, )

Retains only the bytes, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::BeSigned(vec![4; 12]));
tag.add_data(test, Data::Reserved(vec![6; 16]));

let mut bytes = tag.bytes_of(&test);
assert_eq!(bytes.next(), Some(&[4; 12][..]));
assert_eq!(bytes.next(), Some(&[6; 16][..]));
assert_eq!(bytes.next(), None);
drop(bytes);

tag.retain_bytes_of(&test, |b| b[2..4] == [4, 4]);

let mut bytes = tag.bytes_of(&test);
assert_eq!(bytes.next(), Some(&[4; 12][..]));
assert_eq!(bytes.next(), None);

pub fn retain_strings_of( &mut self, ident: &impl Ident, predicate: impl Fn(&str) -> bool, )

Retains only the strings, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Userdata, Data, Fourcc, Img, ImgFmt};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("string1".into()));
tag.add_data(test, Data::Utf8("string2".into()));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("string1"));
assert_eq!(strings.next(), Some("string2"));
assert_eq!(strings.next(), None);
drop(strings);

tag.retain_strings_of(&test, |s| s.ends_with("1"));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("string1"));
assert_eq!(strings.next(), None);

pub fn retain_images_of( &mut self, ident: &impl Ident, predicate: impl Fn(ImgRef<'_>) -> bool, )

Retains only the images, of the atom corresponding to the identifier, that match the predicate.

Example

use mp4ameta::{Userdata, Data, Fourcc, Img, ImgFmt};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Png(vec![5; 4]));
tag.add_data(test, Data::Jpeg(vec![6; 16]));

let mut images = tag.images_of(&test);
assert_eq!(images.next(), Some(Img::new(ImgFmt::Png, &[5; 4][..])));
assert_eq!(images.next(), Some(Img::new(ImgFmt::Jpeg, &[6; 16][..])));
assert_eq!(images.next(), None);
drop(images);

tag.retain_images_of(&test, |d| d.fmt == ImgFmt::Jpeg);

let mut images = tag.images_of(&test);
assert_eq!(images.next(), Some(Img::new(ImgFmt::Jpeg, &[6; 16][..])));
assert_eq!(images.next(), None);

pub fn retain_data_of( &mut self, ident: &impl Ident, predicate: impl Fn(&Data) -> bool, )

Retains only the data, of the atom corresponding to the identifier, that matches the predicate.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("short".into()));
tag.add_data(test, Data::Reserved(vec![6; 16]));

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("short".into())));
assert_eq!(data.next(), Some(&Data::Reserved(vec![6; 16])));
assert_eq!(data.next(), None);
drop(data);

tag.retain_data_of(&test, |d| d.data_len() < 10);

let mut data = tag.data_of(&test);
assert_eq!(data.next(), Some(&Data::Utf8("short".into())));
assert_eq!(data.next(), None);

pub fn retain_bytes(&mut self, predicate: impl Fn(&DataIdent, &[u8]) -> bool)

Retains only the byte data matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Reserved(b"data1".to_vec()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::BeSigned(b"data3".to_vec()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Reserved(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::BeSigned(b"data3".to_vec())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_bytes(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Reserved(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), None);

pub fn retain_strings(&mut self, predicate: impl Fn(&DataIdent, &str) -> bool)

Retains only the strings matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Utf8("data1".into()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::Utf8("data3".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_strings(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), None);

pub fn retain_images( &mut self, predicate: impl Fn(&DataIdent, ImgRef<'_>) -> bool, )

Retains only the images matching the predicate. Other data will remain unaffected.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Jpeg(b"data1".to_vec()));
tag.add_data(tst2, Data::Png(b"data2".to_vec()));
tag.add_data(tst2, Data::Utf8("data3".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Jpeg(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Png(b"data2".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_images(|i, d| &tst1 == i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Jpeg(b"data1".to_vec())));
assert_eq!(data.next(), Some(&Data::Utf8("data3".into())));
assert_eq!(data.next(), None);

pub fn retain_data(&mut self, predicate: impl Fn(&DataIdent, &Data) -> bool)

Retains only the data matching the predicate.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let tst1 = Fourcc(*b"tst1");
let tst2 = Fourcc(*b"tst2");

tag.add_data(tst1, Data::Utf8("data1".into()));
tag.add_data(tst2, Data::Utf8("data2".into()));

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data1".into())));
assert_eq!(data.next(), Some(&Data::Utf8("data2".into())));
assert_eq!(data.next(), None);
drop(data);

tag.retain_data(|i, d| &tst1 != i);

let mut data = tag.data().map(|(i, d)| d);
assert_eq!(data.next(), Some(&Data::Utf8("data2".into())));
assert_eq!(data.next(), None);

pub fn clear(&mut self)

Removes user data. This includes the metadata item list as well as the chapter list and track.

Example

use std::time::Duration;
use mp4ameta::{Userdata, Chapter, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
tag.chapter_list_mut().push(Chapter::new(Duration::ZERO, "first"));
assert!(!tag.is_empty());
tag.clear();
assert!(tag.is_empty());

pub fn clear_meta_items(&mut self)

Clear the metadata item list.

Example

use std::time::Duration;
use mp4ameta::{Userdata, Chapter, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
tag.chapter_list_mut().push(Chapter::new(Duration::ZERO, "first"));
assert!(!tag.is_empty());
assert!(!tag.meta_items_is_empty());
tag.clear_meta_items();
assert!(!tag.is_empty());
assert!(tag.meta_items_is_empty());

pub fn set_data(&mut self, ident: impl Ident + Into<DataIdent>, data: Data)

If an atom corresponding to the identifier exists, it’s data will be replaced by the new data, otherwise a new metadata item atom containing the data will be created.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
assert_eq!(tag.strings_of(&test).next().unwrap(), "data");

pub fn set_all_data( &mut self, ident: impl Ident + Into<DataIdent>, data: impl IntoIterator<Item = Data>, )

If an atom corresponding to the identifier exists, it’s data will be replaced by the new data, otherwise a new metadata item atom containing the data will be created.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

let data = vec![
    Data::Utf8("data1".into()),
    Data::Utf8("data2".into()),
];
tag.set_all_data(test, data);

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None);

pub fn add_data(&mut self, ident: impl Ident + Into<DataIdent>, data: Data)

If an atom corresponding to the identifier exists, the new data will be added to it, otherwise a new atom containing the data will be created.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.add_data(test, Data::Utf8("data1".into()));
tag.add_data(test, Data::Utf8("data2".into()));

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None)

pub fn add_all_data( &mut self, ident: impl Ident + Into<DataIdent>, data: impl IntoIterator<Item = Data>, )

If an atom corresponding to the identifier exists, the new data will be added to it, otherwise a new metadata item atom containing the data will be created.

Example

use mp4ameta::{Userdata, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

let data = vec![
    Data::Utf8("data1".into()),
    Data::Utf8("data2".into()),
];
tag.add_all_data(test, data);

let mut strings = tag.strings_of(&test);
assert_eq!(strings.next(), Some("data1"));
assert_eq!(strings.next(), Some("data2"));
assert_eq!(strings.next(), None)

pub fn is_empty(&self) -> bool

Returns true if there is any user data.
This includes the metadata item list as well as the chapter list and track.

Example

use std::time::Duration;
use mp4ameta::{Userdata, Chapter, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
tag.chapter_list_mut().push(Chapter::new(Duration::ZERO, "first"));
assert!(!tag.is_empty());
tag.clear();
assert!(tag.is_empty());

pub fn meta_items_is_empty(&self) -> bool

Returns true if metadata item list contains any data.

Example

use std::time::Duration;
use mp4ameta::{Userdata, Chapter, Data, Fourcc};

let mut tag = Userdata::default();
let test = Fourcc(*b"test");

tag.set_data(test, Data::Utf8("data".into()));
tag.chapter_list_mut().push(Chapter::new(Duration::ZERO, "first"));
assert!(!tag.is_empty());
assert!(!tag.meta_items_is_empty());
tag.clear_meta_items();
assert!(!tag.is_empty());
assert!(tag.meta_items_is_empty());

Trait Implementations

impl Clone for Tag

fn clone(&self) -> Tag

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Tag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Tag

fn default() -> Tag

Returns the “default value” for a type.

impl Deref for Tag

type Target = Userdata

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl DerefMut for Tag

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl Display for Tag

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Tag

fn eq(&self, other: &Tag) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Tag

impl StructuralPartialEq for Tag