Unbewohnte
/
rip
1
0
Fork 0
Code Issues Pull Requests Projects Releases 1 Wiki Activity
Browse Source

MP3 RIPPING !

master v0.3
Kasianov Nikolai Alekseevich 2 years ago
parent
80388f1b47
commit
bc54844d9b
3 changed files with 174 additions and 524 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Unified View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 646
      src/audio/mp3.rs
  2. 1
      src/img/png.rs
  3. 51
      src/main.rs

646
src/audio/mp3.rs
Unescape View File

@ -22,409 +22,144 @@ use crate::util::content_type::ContentType;
const ID3V2_IDENTIFIER: [u8; 3] = [0x49, 0x44, 0x33]; const ID3V2_IDENTIFIER: [u8; 3] = [0x49, 0x44, 0x33];
const ID3V2_HEADER_LENGTH: usize = 10; const ID3V2_HEADER_LENGTH: usize = 10;
const MP3_HEADER_LENGTH: usize = 4; const MP3_HEADER_LENGTH: usize = 4;
const MP3_HEADER_SYNC_WORD_MASK: u32 = 0xFFE00000; // 11111111111000000000000000000000
const MP3_HEADER_VERSION_MASK: u32 = 0x00180000; // 00000000000110000000000000000000
const MP3_HEADER_LAYER_MASK: u32 = 0x00060000; // 00000000000001100000000000000000
const MP3_HEADER_BITRATE_MASK: u32 = 0x0000F000; // 00000000000000001111000000000000
const MP3_HEADER_SAMPLING_RATE_MASK: u32 = 0x00000C00; // 00000000000000000000110000000000
const MP3_HEADER_PADDING_MASK: u32 = 0x00000200; // 00000000000000000000001000000000
// const MP3_HEADER_SYNC_WORD_MASK: u32 = 0xFFF00000; // 11111111111100000000000000000000 // bitrate table for mpeg Version+Layer
// const MP3_HEADER_VERSION_MASK: u32 = 0xC0000; // 00000000000011000000000000000000 const MP3_BITRATE_TABLE: [[[u32; 15]; 3]; 2] = [
// const MP3_HEADER_LAYER_MASK: u32 = 0x30000; // 00000000000000110000000000000000 // mpegv1
// const MP3_HEADER_BITRATE_MASK: u32 = 0x7800; // 00000000000000000111100000000000 [
// const MP3_HEADER_SAMPLING_RATE_MASK: u32 = 0x600; // 00000000000000000000011000000000 // layer I
// const MP3_HEADER_PADDING_MASK: u32 = 0x100; // 00000000000000000000000100000000 [
0, 32000, 64000, 96000, 128000, 160000,
#[derive(Debug)] 192000, 224000, 256000, 288000, 320000,
enum AudioVersion { 352000, 384000, 416000, 448000,
MpegV1, ],
MpegV2, // layer II
MpegV25, [
} 0, 32000, 48000, 56000, 64000, 80000,
96000, 112000, 128000, 160000, 192000,
#[derive(Debug)] 224000, 256000, 320000, 384000,
enum LayerIndex { ],
LayerI, // layer III
LayerII, [
LayerIII, 0, 32000, 40000, 48000, 56000, 64000,
80000, 96000, 112000, 128000, 160000,
192000, 224000, 256000, 320000,
],
],
//mpegv2
[
// layer I
[
0, 32_000, 48_000, 56_000, 64_000, 80_000,
96_000, 112_000, 128_000, 144_000, 160_000,
176_000, 192_000, 224_000, 256_000,
],
// layer III
[
0, 8_000, 16_000, 24_000, 32_000, 40_000, 48_000,
56_000, 64_000, 80_000, 96_000, 112_000, 128_000,
144_000, 160_000,
],
// layer III
[
0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
],
],
];
enum Layer {
I,
II,
III,
} }
fn get_bitrate(header: u32, audio_version: &AudioVersion, layer: &LayerIndex) -> Option<u16> { #[derive(Debug, PartialEq, Eq)]
match header & MP3_HEADER_BITRATE_MASK { enum MpegVersion {
// 0001 V1,
0x1000 => { V2,
match audio_version { V2_5,
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI | LayerIndex::LayerII | LayerIndex::LayerIII => return Some(32),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(32),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(8),
}
}
}
}
// 0010
0x2000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(64),
LayerIndex::LayerII => return Some(48),
LayerIndex::LayerIII => return Some(40),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(48),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(16),
}
}
}
}
// 0011
0x3000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(96),
LayerIndex::LayerII => return Some(56),
LayerIndex::LayerIII => return Some(48),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(56),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(24),
}
}
}
}
// 0100
0x4000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(128),
LayerIndex::LayerII => return Some(64),
LayerIndex::LayerIII => return Some(56),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(64),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(32),
}
}
}
}
// 0101
0x5000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(160),
LayerIndex::LayerII => return Some(80),
LayerIndex::LayerIII => return Some(64),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(80),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(40),
}
}
}
}
// 0110
0x6000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(192),
LayerIndex::LayerII => return Some(96),
LayerIndex::LayerIII => return Some(80),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(96),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(48),
}
}
}
}
// 0111
0x7000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(224),
LayerIndex::LayerII => return Some(112),
LayerIndex::LayerIII => return Some(96),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(112),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(56),
}
}
}
}
// 1000
0x8000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(256),
LayerIndex::LayerII => return Some(128),
LayerIndex::LayerIII => return Some(112),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(128),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(64),
}
}
}
}
// 1001
0x9000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(288),
LayerIndex::LayerII => return Some(160),
LayerIndex::LayerIII => return Some(128),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(144),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(80),
}
}
}
}
// 1010
0xA000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(320),
LayerIndex::LayerII => return Some(192),
LayerIndex::LayerIII => return Some(160),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(160),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(96),
}
}
}
}
// 1011
0xB000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(352),
LayerIndex::LayerII => return Some(224),
LayerIndex::LayerIII => return Some(192),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(176),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(112),
}
}
}
}
// 1100
0xC000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(384),
LayerIndex::LayerII => return Some(256),
LayerIndex::LayerIII => return Some(224),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(192),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(128),
}
}
}
}
// 1101
0xD000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(416),
LayerIndex::LayerII => return Some(320),
LayerIndex::LayerIII => return Some(256),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(224),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(144),
}
}
}
}
// 1110
0xE000 => {
match audio_version {
AudioVersion::MpegV1 => {
match layer {
LayerIndex::LayerI => return Some(448),
LayerIndex::LayerII => return Some(384),
LayerIndex::LayerIII => return Some(320),
}
}
AudioVersion::MpegV2 | AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return Some(256),
LayerIndex::LayerII | LayerIndex::LayerIII => return Some(160),
}
}
}
}
_ => {
// invalid bitrate index
return None;
}
}
} }
fn get_samples_per_frame(audio_version: &AudioVersion, layer: &LayerIndex) -> u16 { struct MP3Header {
match audio_version { bitrate: u32,
AudioVersion::MpegV1 => { layer: Layer,
match layer { version: MpegVersion,
LayerIndex::LayerI => return 384, sampling_rate: u32,
LayerIndex::LayerII => return 1152, padding: bool,
LayerIndex::LayerIII => return 1152,
}
}
AudioVersion::MpegV2 => {
match layer {
LayerIndex::LayerI => return 384,
LayerIndex::LayerII => return 1152,
LayerIndex::LayerIII => return 576,
}
}
AudioVersion::MpegV25 => {
match layer {
LayerIndex::LayerI => return 384,
LayerIndex::LayerII => return 1152,
LayerIndex::LayerIII => return 576,
}
}
}
} }
fn get_sampling_rate(header: u32, audio_version: &AudioVersion) -> Option<u16> { impl MP3Header {
match header & MP3_HEADER_SAMPLING_RATE_MASK { fn from_bytes(header_bytes: &[u8; MP3_HEADER_LENGTH]) -> Result<MP3Header, &'static str> {
// 00 let header: u32 = u32::from_be_bytes(*header_bytes);
0x0 => { // check sync
match audio_version { if header & 0xFFE00000 != 0xFFE00000 {
AudioVersion::MpegV1 => return Some(44100), return Err("does not contain sync");
AudioVersion::MpegV2 => return Some(22050), }
AudioVersion::MpegV25 => return Some(11025),
} // get version
} let version: MpegVersion;
match (header & 0x180000) >> 19 {
// 01 0b00 => version = MpegVersion::V2_5,
0x400 => { 0b10 => version = MpegVersion::V2,
match audio_version { 0b11 => version = MpegVersion::V1,
AudioVersion::MpegV1 => return Some(48000), _ => return Err("invalid mpeg version"),
AudioVersion::MpegV2 => return Some(24000), }
AudioVersion::MpegV25 => return Some(12000),
} // get layer
} let layer: Layer;
match (header & 0x60000) >> 17 {
// 10 0b01 => layer = Layer::III,
0x800 => { 0b10 => layer = Layer::II,
match audio_version { 0b11 => layer = Layer::I,
AudioVersion::MpegV1 => return Some(32000), _ => return Err("invalid mpeg layer"),
AudioVersion::MpegV2 => return Some(16000), }
AudioVersion::MpegV25 => return Some(8000),
} // calculate bitrate
} let bitrate: u32;
match ((header & 0xF000) >> 12, &version, &layer) {
// invalid value (n, MpegVersion::V1, Layer::I) => bitrate = MP3_BITRATE_TABLE[0][0][n as usize],
_ => return None (n, MpegVersion::V1, Layer::II) => bitrate = MP3_BITRATE_TABLE[0][1][n as usize],
(n, MpegVersion::V1, Layer::III) => bitrate = MP3_BITRATE_TABLE[0][2][n as usize],
(n, MpegVersion::V2|MpegVersion::V2_5, Layer::I) => bitrate = MP3_BITRATE_TABLE[1][0][n as usize],
(n, MpegVersion::V2|MpegVersion::V2_5, Layer::III) => bitrate = MP3_BITRATE_TABLE[1][1][n as usize],
_ => return Err("invalid or too tricky frame header to calculate bitrate"),
}
// sample rate
let sampling_rate: u32;
match ((header & 0xC00) >> 10, &version) {
(0b00, MpegVersion::V1) => sampling_rate = 44100,
(0b01, MpegVersion::V1) => sampling_rate = 48000,
(0b10, MpegVersion::V1) => sampling_rate = 32000,
(0b00, MpegVersion::V2) => sampling_rate = 22050,
(0b01, MpegVersion::V2) => sampling_rate = 24000,
(0b10, MpegVersion::V2) => sampling_rate = 16000,
(0b00, MpegVersion::V2_5) => sampling_rate = 11025,
(0b01, MpegVersion::V2_5) => sampling_rate = 12000,
(0b10, MpegVersion::V2_5) => sampling_rate = 8000,
_ => return Err("invalid sampling rate calculation"),
}
let padding: bool = header & 0x200 != 0;
return Ok(MP3Header{
bitrate: bitrate,
layer: layer,
version: version,
sampling_rate: sampling_rate,
padding: padding,
});
} }
}
fn get_audio_version(header: u32) -> Option<AudioVersion> { fn frame_size(&self) -> usize {
match header & MP3_HEADER_VERSION_MASK { return {
// 00 (if self.version == MpegVersion::V1 {144} else {72} *
0x0 => return Some(AudioVersion::MpegV25), self.bitrate /
// 10 self.sampling_rate) as usize + if self.padding {1} else {0}
0x100000 => return Some(AudioVersion::MpegV2), };
// 11
0x180000 => return Some(AudioVersion::MpegV1),
// invalid version id
_ => return None,
} }
} }
fn get_layer(header: u32) -> Option<LayerIndex> {
match header & MP3_HEADER_LAYER_MASK {
// 01
0x20000 => return Some(LayerIndex::LayerIII),
// 10
0x40000 => return Some(LayerIndex::LayerII),
// 11
0x60000 => return Some(LayerIndex::LayerI),
// invalid layer index
_ => return None,
}
}
pub fn rip_mp3(data: &[u8], start_index: usize) -> Option<Position> { pub fn rip_mp3(data: &[u8], start_index: usize) -> Option<Position> {
if data.len() < ID3V2_HEADER_LENGTH + MP3_HEADER_LENGTH + 1 || if data.len() < ID3V2_HEADER_LENGTH + MP3_HEADER_LENGTH + 1 ||
@ -438,13 +173,10 @@ pub fn rip_mp3(data: &[u8], start_index: usize) -> Option<Position> {
content_type: ContentType::MP3, content_type: ContentType::MP3,
}; };
let mut cursor_index: usize;
for i in start_index..data.len() { for i in start_index..data.len() {
if i < ID3V2_HEADER_LENGTH && position.start == usize::MAX { if i < ID3V2_HEADER_LENGTH && position.start == usize::MAX {
if data[i..i + ID3V2_IDENTIFIER.len()] == ID3V2_IDENTIFIER { if data[i..i + ID3V2_IDENTIFIER.len()] == ID3V2_IDENTIFIER {
// found ID3v2 tag (the beginning of the MP3 file) // found ID3v2 tag (the beginning of the MP3 file)
println!("id3 at {}", i);
// get tag length // get tag length
let mut tag_length_bytes: [u8; 4] = [0; 4]; let mut tag_length_bytes: [u8; 4] = [0; 4];
for j in 0..4 { for j in 0..4 {
@ -458,7 +190,6 @@ pub fn rip_mp3(data: &[u8], start_index: usize) -> Option<Position> {
} }
let id3v2_end_index: usize = i + ID3V2_HEADER_LENGTH + tag_length as usize; let id3v2_end_index: usize = i + ID3V2_HEADER_LENGTH + tag_length as usize;
println!("id3v2 end index is {}; the data size is {}", id3v2_end_index, data.len());
if id3v2_end_index + MP3_HEADER_LENGTH > data.len() - 1 { if id3v2_end_index + MP3_HEADER_LENGTH > data.len() - 1 {
println!("not enough data length"); println!("not enough data length");
// strange: there's a valid ID3 tag but not enough data to store any music // strange: there's a valid ID3 tag but not enough data to store any music
@ -466,114 +197,33 @@ pub fn rip_mp3(data: &[u8], start_index: usize) -> Option<Position> {
} }
position.start = i; position.start = i;
cursor_index = id3v2_end_index; position.end = id3v2_end_index;
loop { break;
if cursor_index >= data.len() - 1 { }
break; }
} }
// whole header
let mut mp3_header_bytes: [u8 ; MP3_HEADER_LENGTH] = [0; MP3_HEADER_LENGTH];
for j in 0..MP3_HEADER_LENGTH {
mp3_header_bytes[j] = data[cursor_index + j];
}
let mp3_header: u32 = u32::from_be_bytes(mp3_header_bytes);
// check for sync word
if !mp3_header & MP3_HEADER_SYNC_WORD_MASK == MP3_HEADER_SYNC_WORD_MASK {
println!("SYNCWORD NO");
break;
}
// that's really an MP3 !
println!("mpeg header at {}", cursor_index);
cursor_index += MP3_HEADER_LENGTH;
println!("{:#032b}", mp3_header);
// retrieve audio version
let audio_version: AudioVersion;
match get_audio_version(mp3_header) {
Some(version) => audio_version = version,
None => {println!("VERSION NO {:032x}", mp3_header & MP3_HEADER_VERSION_MASK); break},
}
println!("audio version is {:?}", audio_version);
// get layer
let layer: LayerIndex;
match get_layer(mp3_header) {
Some(l) => layer = l,
None => {println!("LAYER NO"); break},
}
println!("layer is {:?}", layer);
// decode that HUGE bitrate table
let bitrate: u16;
match get_bitrate(mp3_header, &audio_version, &layer) {
Some(rate) => bitrate = rate,
None => {println!("BITRATE NO"); break},
}
println!("bitrate is {}", bitrate);
// samples per frame
// let samples_per_frame: u16 = get_samples_per_frame(&audio_version, &layer);
// sampling rate
let sampling_rate: u16;
match get_sampling_rate(mp3_header, &audio_version) {
Some(rate) => sampling_rate = rate,
None => {println!("SAMPLING RATE NO"); break},
}
println!("sampling rate is {}", sampling_rate);
// padding
let padding: u8;
if mp3_header == MP3_HEADER_PADDING_MASK {
padding = 1;
} else {
padding = 0;
}
println!("padding is {}", padding);
let slot_size: u32;
match layer {
LayerIndex::LayerI => slot_size = 4,
_ => slot_size = 1,
}
let multiplier: u32;
match layer {
LayerIndex::LayerI => multiplier = 12,
_ => multiplier = 144000,
}
let slot_count: u32 = ((multiplier as u32 * (bitrate as u32 * 1000)) / sampling_rate as u32) + padding as u32;
// finally calculate frame size // return None immediately if id3 tag was not found
let frame_size: u32 = slot_count * slot_size; if position.start == usize::MAX {
println!("frame size is {}", frame_size); return None;
}
// set cursor to the next frame // try to extract mp3 frames
cursor_index += frame_size as usize; let mut mp3_header_bytes: [u8; MP3_HEADER_LENGTH] = [0; MP3_HEADER_LENGTH];
// extend end position while position.end < data.len() - MP3_HEADER_LENGTH {
position.end = cursor_index; for j in 0..MP3_HEADER_LENGTH {
println!("frame end at {}", cursor_index); mp3_header_bytes[j] = data[position.end + j];
}
}
} }
if position.start != usize::MAX && position.end != usize::MAX { match MP3Header::from_bytes(&mp3_header_bytes) {
break; Ok(header) => {
position.end += header.frame_size();
}
Err(_) => {
break;
}
} }
} }
if position.start == usize::MAX || position.end == usize::MAX || position.end <= position.start { if position.start == usize::MAX || position.end == usize::MAX || position.end <= position.start {
return None; return None;

1
src/img/png.rs
Unescape View File

@ -48,7 +48,6 @@ pub fn rip_png(data: &[u8], start_index: usize) -> Option<Position> {
if i <= data.len() - PNG_END_IDENTIFIER.len() && position.end == usize::MAX { if i <= data.len() - PNG_END_IDENTIFIER.len() && position.end == usize::MAX {
if data[i..i + PNG_END_IDENTIFIER.len()] == PNG_END_IDENTIFIER { if data[i..i + PNG_END_IDENTIFIER.len()] == PNG_END_IDENTIFIER {
position.end = i + PNG_END_IDENTIFIER.len(); position.end = i + PNG_END_IDENTIFIER.len();
println!("end {}", position.end);
} }
} }

51
src/main.rs
Unescape View File

@ -66,18 +66,14 @@ fn main() {
[RIPTYPE]\n\ [RIPTYPE]\n\
ALL -> rip everything that seems like an embedded content\n\ ALL -> rip everything that seems like an embedded content\n\
IMG -> try to look for images only\n\ IMG -> try to look for images only\n\
AUDIO -> rip audio content\n AUDIO -> rip audio content"
"
); );
return; return;
} }
else if &args[arg_index] == "-v" || &args[arg_index] == "--version" { else if &args[arg_index] == "-v" || &args[arg_index] == "--version" {
println!( println!(
"rip v0.2\ "rip v0.3\n\n\
\n (c) 2022 Kasyanov Nikolay Alexeyevich (Unbewohnte)"
\n\
(c) 2022 Kasyanov Nikolay Alexeyevich (Unbewohnte)\
"
); );
return; return;
} }
@ -252,7 +248,6 @@ fn main() {
match rip_mp3(&file_contents, cursor_index) { match rip_mp3(&file_contents, cursor_index) {
Some(pos) => { Some(pos) => {
cursor_index = pos.end; cursor_index = pos.end;
println!("b {:?}", pos);
positions.push(pos); positions.push(pos);
} }
None => { None => {
@ -296,19 +291,19 @@ fn main() {
} }
// find MP3 positions // find MP3 positions
// cursor_index = 0; cursor_index = 0;
// while (cursor_index as u64) < file_metadata.len() { while (cursor_index as u64) < file_metadata.len() {
// match rip_mp3(&file_contents, cursor_index) { match rip_mp3(&file_contents, cursor_index) {
// Some(pos) => { Some(pos) => {
// cursor_index = pos.end; cursor_index = pos.end;
// positions.push(pos); positions.push(pos);
// } }
// None => { None => {
// // no MP3s were found // no MP3s were found
// break; break;
// } }
// } }
// } }
} }
} }
@ -337,15 +332,18 @@ fn main() {
let mut output_file_path_string: String = save_directory.join(&source_file_name).to_string_lossy().to_string(); let mut output_file_path_string: String = save_directory.join(&source_file_name).to_string_lossy().to_string();
match positions[position_index].content_type { match positions[position_index].content_type {
ContentType::PNG => { ContentType::PNG => {
output_file_path_string = output_file_path_string + &format!("_{}.png", position_index); output_file_path_string =
output_file_path_string + &format!("_{}.png", position_index);
} }
ContentType::JPEG => { ContentType::JPEG => {
output_file_path_string = output_file_path_string + &format!("_{}.jpeg", position_index); output_file_path_string =
output_file_path_string + &format!("_{}.jpeg", position_index);
} }
ContentType::MP3 => { ContentType::MP3 => {
output_file_path_string = output_file_path_string + &format!("_{}.mp3", position_index); output_file_path_string =
output_file_path_string + &format!("_{}.mp3", position_index);
} }
} }
@ -368,7 +366,10 @@ fn main() {
} }
} }
println!("[INFO] Outputted {}", output_file_path_string); println!("[INFO] Outputted {} ({} bytes)",
output_file_path_string,
positions[position_index].end - positions[position_index].start
);
} }
} }
} }

Write Preview
Loading…
Cancel
Save