1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178

/// Module with interface to different tag readers
use id3::Tag as id3tag;
use metaflac::{block::Block, Tag as flactag};
use mp3_metadata;
use mp4ameta::Tag as mp4tag;
use std::{fs::File, io::BufReader, time::Duration};

#[allow(dead_code)]
#[derive(Clone)]
pub struct CommonAudioInfo {
    pub title: String,
    pub artist: String,
    pub duration: Duration,
    pub album: Option<String>,
    pub track: Option<u16>,
    pub album_artist: Option<String>,
    pub genre: Option<String>,
    pub disc: Option<u16>,
    pub total_discs: Option<u16>,
    pub total_tracks: Option<u16>,
    pub year: Option<i32>,
}

/// Trait to ensure same calls
pub trait TagReader<'a> {
    fn read_tag_from(&self, file: &mut BufReader<File>) -> Result<CommonAudioInfo, String>;
    fn known_suffixes(&self) -> Vec<&'a str>;
}

pub struct MP4TagReader;
impl<'a> TagReader<'a> for MP4TagReader {
    fn read_tag_from(&self, file_buffer: &mut BufReader<File>) -> Result<CommonAudioInfo, String> {
        match mp4tag::read_from(file_buffer.get_mut()) {
            Ok(tag) => {
                // year needs extra treatment
                let year = tag
                    .year()
                    .map_or(None, |good_string| good_string.parse::<i32>().ok());

                let info = CommonAudioInfo {
                    title: tag.title().unwrap_or("").to_string(),
                    artist: tag.artist().unwrap_or("").to_string(),
                    duration: Duration::from_secs(tag.duration().unwrap_or(0.0) as u64),
                    album: tag.album().map(|op| op.to_string()),
                    track: tag.track_number(),
                    album_artist: tag.album_artist().map(|op| op.to_string()),
                    genre: tag.genre().map(|op| op.to_string()),
                    disc: None,        // no supported
                    total_discs: None, // no supported
                    total_tracks: tag.total_tracks(),
                    year,
                };
                Ok(info)
            }
            Err(e) => Err(format!("{:?}", e)),
        }
    }

    fn known_suffixes(&self) -> Vec<&'a str> {
        vec!["mp4"]
    }
}

pub struct ID3TagReader;
impl<'a> TagReader<'a> for ID3TagReader {
    fn read_tag_from(&self, file_buffer: &mut BufReader<File>) -> Result<CommonAudioInfo, String> {
        match id3tag::read_from(file_buffer.get_mut()) {
            Ok(tag) => {
                // write into common audio info that can be analyzed
                let info = CommonAudioInfo {
                    title: tag.title().unwrap_or("").to_string(),
                    artist: tag.artist().unwrap_or("").to_string(),
                    duration: Duration::from_secs(tag.duration().unwrap_or(0) as u64),
                    album: tag.album().map(|s| s.to_string()),
                    track: tag.track().and_then(|v| Some(v as u16)),
                    album_artist: tag.album_artist().map(|st| st.to_string()),
                    genre: tag.genre().map(|s| s.to_string()),
                    disc: tag.disc().and_then(|v| Some(v as u16)),
                    total_discs: tag.total_discs().and_then(|v| Some(v as u16)),
                    total_tracks: tag.total_tracks().and_then(|v| Some(v as u16)),
                    year: tag.year(),
                };
                Ok(info)
            }
            Err(e) => Err(format!("{:?}", e)),
        }
    }

    fn known_suffixes(&self) -> Vec<&'a str> {
        vec!["mpeg"]
    }
}

pub struct FlacTagReader;
impl<'a> TagReader<'a> for FlacTagReader {
    fn read_tag_from(&self, file_buffer: &mut BufReader<File>) -> Result<CommonAudioInfo, String> {
        match flactag::read_from(file_buffer) {
            Ok(tag_block) => {
                // try the first block
                let mut res_info = Err("vorbis comment block not found".to_string());
                for good_tag_block in tag_block.blocks() {
                    match good_tag_block {
                        Block::VorbisComment(tag) => {
                            // helper
                            let take_first_or_empty = |o: Option<&Vec<String>>| -> String {
                                (*o.map(|v_s| v_s.first().unwrap_or(&"".to_string()).clone())
                                    .unwrap_or("".to_string()))
                                .to_string()
                            };
                            let take_first_or_option = |o: Option<&Vec<String>>| -> Option<String> {
                                o.map(|v_s| Some(v_s.first().unwrap_or(&"".to_string()).clone()))
                                    .unwrap_or(None)
                            };

                            res_info = Ok(CommonAudioInfo {
                                title: take_first_or_empty(tag.title()),
                                artist: take_first_or_empty(tag.artist()),
                                // todo: duration somewhere else
                                duration: Duration::from_secs(0),
                                album: take_first_or_option(tag.album()),
                                track: tag.track().and_then(|v| Some(v as u16)),
                                album_artist: take_first_or_option(tag.album_artist()),
                                genre: take_first_or_option(tag.genre()),
                                disc: Some(0), // tag.disc(),
                                // todo: discs, total discs, year somewhere else??
                                total_discs: Some(0), // tag.total_discs(),
                                total_tracks: tag.total_tracks().and_then(|v| Some(v as u16)),
                                year: Some(0), //tag.year(),
                            });
                        }
                        _ => (),
                    }
                }
                res_info
            }
            Err(e) => Err(format!("{:?}", e)),
        }
    }

    fn known_suffixes(&self) -> Vec<&'a str> {
        vec!["flac", "x-vorbis+ogg"]
    }
}

pub struct MP3TagReader;
impl<'a> TagReader<'a> for MP3TagReader {
    fn read_tag_from(&self, file_buffer: &mut BufReader<File>) -> Result<CommonAudioInfo, String> {
        match mp3_metadata::read_from_slice(file_buffer.buffer()) {
            Ok(metadata) => {
                match metadata.tag {
                    Some(tag) => {
                        // write into common audio info that can be analyzed
                        let info = CommonAudioInfo {
                            title: tag.title,
                            artist: tag.artist,
                            duration: Duration::from_secs(0),
                            album: Some(tag.album),
                            track: None,
                            album_artist: None,
                            genre: Some(format!("{:?}", tag.genre)),
                            disc: None,
                            total_discs: None,
                            total_tracks: None,
                            year: Some(tag.year as i32),
                        };
                        Ok(info)
                    }
                    None => Err("no audio tag found".to_string()),
                }
            }
            Err(e) => Err(format!("{:?}", e)),
        }
    }

    fn known_suffixes(&self) -> Vec<&'a str> {
        vec!["mpeg", "mp3"]
    }
}