dff-meta 0.1.0

DFF (DSDIFF File) metadata support for Rust
Documentation 
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

//! DFF File Model

use std::io;
use std::collections::HashMap;

use id3::Tag;

use crate::DffFile;

pub type Uchar = u8;
pub type Ushort = u16;
pub type Ulong = u32;
pub type DoubleUlong = u64;
pub type ID = u32;

pub const CHUNK_HEADER_SIZE: DoubleUlong = 12;
pub const DSD_LABEL: ID = u32::from_be_bytes(*b"DSD ");
pub const FVER_LABEL: ID = u32::from_be_bytes(*b"FVER");
pub const PROP_LABEL: ID = u32::from_be_bytes(*b"PROP");
pub const SND_LABEL: ID = u32::from_be_bytes(*b"SND ");
pub const FS_LABEL: ID = u32::from_be_bytes(*b"FS  ");
pub const CHNL_LABEL: ID = u32::from_be_bytes(*b"CHNL");
pub const COMP_LABEL: ID = u32::from_be_bytes(*b"CMPR");
pub const ABS_TIME_LABEL: ID = u32::from_be_bytes(*b"ABSS");
pub const LS_CONF_LABEL: ID = u32::from_be_bytes(*b"LSCO");
pub const ID3_LABEL: ID = u32::from_be_bytes(*b"ID3 ");

#[derive(Debug)]
pub enum Error {
    DsdChunkHeader,
    DsdChunkSize,
    Id3Error(id3::Error, DffFile),
    IoError(io::Error),
    FormChunkHeader,
    FormTypeMismatch,
    FverChunkHeader,
    FverChunkSize,
    FverUnsupportedVersion,
    PropChunkHeader,
    PropChunkType,
    FsChunkHeader,
    FsChunkSize,
    ChnlChunkHeader,
    ChnlChunkSize,
    ChnlNumber,
    CmprChunkHeader,
    CmprChunkSize,
    AbssChunkHeader,
    AbssChunkSize,
    LscoChunkHeader,
    LscoChunkSize,
    CmprTypeMismatch,
    PrematureTagFound(String),
    Eof,
}

#[derive(Debug, Clone)]
pub enum LocalChunk {
    FormatVersion(FormatVersionChunk),
    Property(PropertyChunk),
    SampleRate(SampleRateChunk),
    Channels(ChannelsChunk),
    CompressionType(#[allow(dead_code)]CompressionTypeChunk),
    AbsoluteStartTime(#[allow(dead_code)]AbsoluteStartTimeChunk),
    LoudspeakerConfig(#[allow(dead_code)]LoudspeakerConfigChunk),
    Dsd(#[allow(dead_code)] DsdChunk),
    Id3(Id3Chunk), // NEW
}

#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct ChunkHeader {
    pub ck_id: ID,
    pub ck_data_size: DoubleUlong,
}

#[derive(Debug, Clone)]
pub struct Chunk {
    pub header: ChunkHeader,
    pub local_chunks: HashMap<ID, LocalChunk>,
}

#[derive(Debug, Clone)]
pub struct FormDsdChunk {
    pub chunk: Chunk,
    pub form_type: ID,
}

#[derive(Debug, Clone)]
pub struct FormatVersionChunk {
    pub chunk: Chunk,
    pub format_version: Ulong,
}

#[derive(Debug, Clone)]
pub struct PropertyChunk {
    pub chunk: Chunk,
    pub property_type: ID,
}

#[derive(Debug, Clone)]
pub struct SampleRateChunk {
    pub chunk: Chunk,
    pub sample_rate: Ulong,
}

#[derive(Debug, Clone)]
pub struct ChannelsChunk {
    pub chunk: Chunk,
    pub num_channels: Ushort,
    pub ch_id: Vec<ID>, // length = channel_count
}

#[derive(Debug, Clone)]
pub struct CompressionTypeChunk {
    pub chunk: Chunk,
    pub compression_type: ID,
    pub compression_name: String,
}

#[derive(Debug, Clone)]
pub struct AbsoluteStartTimeChunk {
    pub chunk: Chunk,
    #[allow(dead_code)]
    pub hours: Ushort,
    #[allow(dead_code)]
    pub minutes: Uchar,
    #[allow(dead_code)]
    pub seconds: Uchar,
    #[allow(dead_code)]
    pub samples: Ulong,
}

#[derive(Debug, Clone)]
pub struct LoudspeakerConfigChunk {
    pub chunk: Chunk,
    #[allow(dead_code)]
    pub ls_config: Ushort,
}

#[derive(Debug, Clone)]
pub struct DsdChunk {
    pub chunk: Chunk,
}

#[derive(Debug, Clone)]
pub struct Id3Chunk {
    #[allow(dead_code)]
    pub chunk: Chunk,
    pub tag: Option<Tag>,
}