meta

type Application struct {
	// Registered application ID.
	ID string
	// Application data.
	Data []byte
}

type Block struct {
	// Metadata block header.
	Header *BlockHeader
	// Metadata block body: StreamInfo, Application, SeekTable, etc.
	Body interface{}
}

type BlockHeader struct {
	// IsLast is true if this block is the last metadata block before the audio
	// blocks, and false otherwise.
	IsLast bool
	// Block types:
	//    0: Streaminfo
	//    1: Padding
	//    2: Application
	//    3: Seektable
	//    4: Vorbis_comment
	//    5: Cuesheet
	//    6: Picture
	//    7-126: reserved
	//    127: invalid, to avoid confusion with a frame sync code
	BlockType BlockType
	// Length (in bytes) of metadata to follow (does not include the size of the
	// BlockHeader).
	Length int
}

type BlockType uint8

type CueSheet struct {
	// Media catalog number, in ASCII printable characters 0x20-0x7e. In general,
	// the media catalog number may be 0 to 128 bytes long; any unused characters
	// should be right-padded with NUL characters. For CD-DA, this is a thirteen
	// digit number, followed by 115 NUL bytes.
	MCN string
	// The number of lead-in samples. This field has meaning only for CD-DA
	// cuesheets; for other uses it should be 0. For CD-DA, the lead-in is the
	// TRACK 00 area where the table of contents is stored; more precisely, it is
	// the number of samples from the first sample of the media to the first
	// sample of the first index point of the first track. According to the Red
	// Book, the lead-in must be silence and CD grabbing software does not
	// usually store it; additionally, the lead-in must be at least two seconds
	// but may be longer. For these reasons the lead-in length is stored here so
	// that the absolute position of the first track can be computed. Note that
	// the lead-in stored here is the number of samples up to the first index
	// point of the first track, not necessarily to INDEX 01 of the first track;
	// even the first track may have INDEX 00 data.
	LeadInSampleCount uint64
	// true if the CUESHEET corresponds to a Compact Disc, else false.
	IsCompactDisc bool
	// The number of tracks. Must be at least 1 (because of the requisite
	// lead-out track). For CD-DA, this number must be no more than 100 (99
	// regular tracks and one lead-out track).
	TrackCount uint8
	// One or more tracks. A CUESHEET block is required to have a lead-out track;
	// it is always the last track in the CUESHEET. For CD-DA, the lead-out track
	// number must be 170 as specified by the Red Book, otherwise is must be 255.
	Tracks []CueSheetTrack
}

type CueSheetTrack struct {
	// Track offset in samples, relative to the beginning of the FLAC audio
	// stream. It is the offset to the first index point of the track. (Note how
	// this differs from CD-DA, where the track's offset in the TOC is that of
	// the track's INDEX 01 even if there is an INDEX 00.) For CD-DA, the offset
	// must be evenly divisible by 588 samples (588 samples = 44100 samples/sec *
	// 1/75th of a sec).
	Offset uint64
	// Track number. A track number of 0 is not allowed to avoid conflicting with
	// the CD-DA spec, which reserves this for the lead-in. For CD-DA the number
	// must be 1-99, or 170 for the lead-out; for non-CD-DA, the track number
	// must for 255 for the lead-out. It is not required but encouraged to start
	// with track 1 and increase sequentially. Track numbers must be unique
	// within a CUESHEET.
	TrackNum uint8
	// Track ISRC. This is a 12-digit alphanumeric code. A value of 12 ASCII NUL
	// characters may be used to denote absence of an ISRC.
	ISRC string
	// The track type: true for audio, false for non-audio.
	IsAudio bool
	// The pre-emphasis flag: false for no pre-emphasis, true for pre-emphasis.
	// This corresponds to the CD-DA Q-channel control bit 5.
	HasPreEmphasis bool
	// The number of track index points. There must be at least one index in
	// every track in a CUESHEET except for the lead-out track, which must have
	// zero. For CD-DA, this number may be no more than 100.
	TrackIndexCount uint8
	// For all tracks except the lead-out track, one or more track index points.
	TrackIndexes []CueSheetTrackIndex
}

type CueSheetTrackIndex struct {
	// Offset in samples, relative to the track offset, of the index point. For
	// CD-DA, the offset must be evenly divisible by 588 samples (588 samples =
	// 44100 samples/sec * 1/75th of a sec). Note that the offset is from the
	// beginning of the track, not the beginning of the audio data.
	Offset uint64
	// The index point number. For CD-DA, an index number of 0 corresponds to the
	// track pre-gap. The first index in a track must have a number of 0 or 1,
	// and subsequently, index numbers must increase by 1. Index numbers must be
	// unique within a track.
	IndexPointNum uint8
}

type Picture struct {
	// The picture type according to the ID3v2 APIC frame:
	//    0 - Other
	//    1 - 32x32 pixels 'file icon' (PNG only)
	//    2 - Other file icon
	//    3 - Cover (front)
	//    4 - Cover (back)
	//    5 - Leaflet page
	//    6 - Media (e.g. label side of CD)
	//    7 - Lead artist/lead performer/soloist
	//    8 - Artist/performer
	//    9 - Conductor
	//    10 - Band/Orchestra
	//    11 - Composer
	//    12 - Lyricist/text writer
	//    13 - Recording Location
	//    14 - During recording
	//    15 - During performance
	//    16 - Movie/video screen capture
	//    17 - A bright coloured fish
	//    18 - Illustration
	//    19 - Band/artist logotype
	//    20 - Publisher/Studio logotype
	//
	// Others are reserved and should not be used. There may only be one each of
	// picture type 1 and 2 in a file.
	Type uint32
	// The MIME type string, in printable ASCII characters 0x20-0x7e. The MIME
	// type may also be --> to signify that the data part is a URL of the picture
	// instead of the picture data itself.
	MIME string
	// The description of the picture, in UTF-8.
	Desc string
	// The width of the picture in pixels.
	Width uint32
	// The height of the picture in pixels.
	Height uint32
	// The color depth of the picture in bits-per-pixel.
	ColorDepth uint32
	// For indexed-color pictures (e.g. GIF), the number of colors used, or 0 for
	// non-indexed pictures.
	ColorCount uint32
	// The binary picture data.
	Data []byte
}

type SeekPoint struct {
	// Sample number of first sample in the target frame, or 0xFFFFFFFFFFFFFFFF
	// for a placeholder point.
	SampleNum uint64
	// Offset (in bytes) from the first byte of the first frame header to the
	// first byte of the target frame's header.
	Offset uint64
	// Number of samples in the target frame.
	SampleCount uint16
}

type SeekTable struct {
	// One or more seek points.
	Points []SeekPoint
}

type StreamInfo struct {
	// The minimum block size (in samples) used in the stream.
	MinBlockSize uint16
	// The maximum block size (in samples) used in the stream.
	// (MinBlockSize == MaxBlockSize) implies a fixed-blocksize stream.
	MaxBlockSize uint16
	// The minimum frame size (in bytes) used in the stream. May be 0 to imply
	// the value is not known.
	MinFrameSize uint32
	// The maximum frame size (in bytes) used in the stream. May be 0 to imply
	// the value is not known.
	MaxFrameSize uint32
	// Sample rate in Hz. Though 20 bits are available, the maximum sample rate
	// is limited by the structure of frame headers to 655350Hz. Also, a value of
	// 0 is invalid.
	SampleRate uint32
	// Number of channels. FLAC supports from 1 to 8 channels.
	ChannelCount uint8
	// Bits per sample. FLAC supports from 4 to 32 bits per sample. Currently the
	// reference encoder and decoders only support up to 24 bits per sample.
	BitsPerSample uint8
	// Total samples in stream. 'Samples' means inter-channel sample, i.e. one
	// second of 44.1Khz audio will have 44100 samples regardless of the number
	// of channels. A value of zero here means the number of total samples is
	// unknown.
	SampleCount uint64
	// MD5 signature of the unencoded audio data. This allows the decoder to
	// determine if an error exists in the audio data even when the error does
	// not result in an invalid bitstream.
	MD5sum [16]byte
}

type VorbisComment struct {
	Vendor  string
	Entries []VorbisEntry
}

type VorbisEntry struct {
	Name  string
	Value string
}