Task 417: .MPC File Format
Task 417: .MPC File Format
Musepack (.mpc) File Format Specifications
The .mpc file format is used for Musepack audio compression, a lossy audio codec optimized for high-quality stereo audio at bitrates around 160–180 kbit/s. It is based on MPEG-1 Layer-2 algorithms with improvements. The current specification is for Stream Version 8 (SV8), which is the preferred version and supersedes older versions like SV7. The format is container-based, starting with a magic number, followed by packets in Key/Size/Payload structure. All multi-byte fields are big-endian. The format supports streaming and tagging (e.g., APEv2 tags after the stream end packet).
1. List of All Properties Intrinsic to the File Format
The properties are the fields within the various packets of the .mpc file. These include header information, replaygain data, encoder details, seek table, and other structural elements. The file begins with the magic number 'MPCK' (0x4D50434B). Packets are identified by 2-character ASCII keys (A-Z). Sizes are variable-length integers (varint) in big-endian format. Below is a comprehensive list of properties from the SV8 specification, including sizes, types, and descriptions:
- Magic Number: 32 bits, string 'MPCK' (0x4D50434B) - Identifies the start of an SV8 Musepack file.
- Packet Key: 16 bits, ASCII string (e.g., 'SH' for Stream Header) - Defines the packet type.
- Packet Size: Variable bits (7-bit chunks with continuation bit) - Length of the packet in bytes, including key and size fields (minimum 3 bytes).
- Stream Header Packet (SH - Mandatory):
- CRC: 32 bits, unsigned integer - CRC-32 of the header block (excluding this field); 0 means invalid.
- Stream Version: 8 bits, unsigned integer - Always 8 for SV8.
- Sample Count: Variable bytes (varint), unsigned integer - Total number of samples in the stream; 0 if unknown.
- Beginning Silence: Variable bytes (varint), unsigned integer - Number of samples to skip at the beginning.
- Sample Frequency: 3 bits, unsigned integer - Sample rate index (0: 44100 Hz, 1: 48000 Hz, 2: 37800 Hz, 3: 32000 Hz).
- Max Used Bands: 5 bits, unsigned integer - Maximum number of bands (1-32).
- Channel Count: 4 bits, unsigned integer - Number of channels (1-16).
- MS Used: 1 bit, boolean - True if Mid/Side stereo is enabled.
- Audio Block Frames: 3 bits, unsigned integer - Frames per audio packet (0-7, where 4^value gives 1-16384 frames).
- Replaygain Packet (RG - Mandatory):
- ReplayGain Version: 8 bits, unsigned integer - Always 1.
- Title Gain: 16 bits, signed integer (Q8.8 fixed-point) - Title loudness in dB; 0 if not computed.
- Title Peak: 16 bits, unsigned integer (Q8.8 fixed-point) - Title peak level in dB.
- Album Gain: 16 bits, signed integer (Q8.8 fixed-point) - Album loudness in dB; 0 if not computed.
- Album Peak: 16 bits, unsigned integer (Q8.8 fixed-point) - Album peak level in dB.
- Encoder Info Packet (EI - Optional):
- Profile: 7 bits, unsigned integer (4.3 fixed-point) - Encoder quality profile (0-15.875).
- PNS Tool: 1 bit, boolean - True if Perceptual Noise Substitution is enabled.
- Major Version: 8 bits, unsigned integer - Encoder major version.
- Minor Version: 8 bits, unsigned integer - Encoder minor version (even for stable, odd for unstable).
- Build: 8 bits, unsigned integer - Encoder build number.
- Seek Table Offset Packet (SO - Optional):
- Offset: Variable bytes (varint), unsigned integer - Offset to the seek table packet from the magic number.
- Seek Table Packet (ST - Optional):
- Seek Count: Variable bytes (varint), unsigned integer - Number of seek elements.
- Seek Distance: 4 bits, unsigned integer - Distance between referenced blocks (2^value).
- Seek Data: Variable - Golomb-coded seek offsets (complex differential encoding).
- Chapter-Tag Packet (CT - Optional):
- Sample Offset: Variable bytes (varint), unsigned integer - Chapter position in samples.
- Chapter Gain: 16 bits, signed integer (Q8.8) - Chapter loudness in dB.
- Chapter Peak: 16 bits, unsigned integer (Q8.8) - Chapter peak in dB.
- APEv2 Tag: Variable bytes - Embedded APEv2 tag data (without preamble).
- Audio Packet (AP - Mandatory):
- Audio Frames: Variable - Compressed audio data (number of frames as defined in SH; bitstream details in frame format).
- Stream End Packet (SE - Mandatory):
- (No additional fields; fixed 3-byte packet marking end of stream).
These properties define the structure, audio metadata, and navigation of the file. Audio bitstream properties (e.g., frame formats, Huffman codes) are part of the codec but not listed here as they are not "file system intrinsic" (i.e., not part of the container structure).
2. Two Direct Download Links for .mpc Files
- https://samples.ffmpeg.org/A-codecs/musepack/sv8/CPE.mpc (SV8 Musepack audio sample)
- https://samples.ffmpeg.org/A-codecs/musepack/sv8/Choral.mpc (SV8 Musepack audio sample)
3. Ghost Blog Embedded HTML JavaScript for Drag and Drop .mpc File Dump
This is a self-contained HTML page with JavaScript that allows dragging and dropping a .mpc file. It parses the file (assuming SV8) and dumps all properties to the screen.
Drag and drop .mpc file here
Note: The parsing is basic and assumes valid SV8 files. Variable size calculation is implemented, but seek data and APEv2 are not fully parsed. Write functionality is not included in this JS as it's for dump only.
4. Python Class for .mpc File
This Python class can open, decode (parse), read properties, print them to console, and write a new file with the same data (for simple r/w).
import struct
import sys
class MPCFile:
def __init__(self, filename):
self.filename = filename
self.properties = {}
self.packets = []
self.parse()
def read_varint(self, data, offset):
value = 0
while True:
byte = data[offset]
offset += 1
value = (value << 7) | (byte & 0x7F)
if (byte & 0x80) == 0:
break
return value, offset
def parse(self):
with open(self.filename, 'rb') as f:
data = f.read()
offset = 0
magic = data[offset:offset+4].decode('ascii', errors='ignore')
offset += 4
if magic != 'MPCK':
raise ValueError('Invalid MPC file')
self.properties['Magic Number'] = 'MPCK'
while offset < len(data):
key = data[offset:offset+2].decode('ascii')
offset += 2
size, offset = self.read_varint(data, offset)
packet_start = offset
packet_data = data[offset:offset + size - 2 - (offset - packet_start + offset - packet_start)] wait, size includes key and size
packet_end = offset + size - 2 - (offset - (offset - 2)) # Calculate length of size field
size_length = 1
temp = size
while temp >= 128:
temp //= 128
size_length += 1
packet_end = offset + size - 2 - size_length
packet_props = {'Key': key, 'Size': size}
if key == 'SH':
crc, = struct.unpack('>I', data[offset:offset+4])
offset += 4
version = data[offset]
offset += 1
sample_count, offset = self.read_varint(data, offset)
begin_silence, offset = self.read_varint(data, offset)
freq_bits = data[offset]
freq = (freq_bits >> 5) & 0x07
max_bands = freq_bits & 0x1F
offset += 1
chan_bits = data[offset]
channels = (chan_bits >> 4) & 0x0F
ms_used = (chan_bits >> 3) & 0x01
block_frames = chan_bits & 0x07
offset += 1
packet_props.update({'CRC': crc, 'Stream Version': version, 'Sample Count': sample_count, 'Beginning Silence': begin_silence, 'Sample Frequency': freq, 'Sample Rate (Hz)': [44100,48000,37800,32000][freq], 'Max Used Bands': max_bands, 'Channel Count': channels, 'MS Used': ms_used, 'Audio Block Frames': block_frames})
elif key == 'RG':
rg_version = data[offset]
offset += 1
title_gain, = struct.unpack('>h', data[offset:offset+2])
offset += 2
title_peak, = struct.unpack('>H', data[offset:offset+2])
offset += 2
album_gain, = struct.unpack('>h', data[offset:offset+2])
offset += 2
album_peak, = struct.unpack('>H', data[offset:offset+2])
offset += 2
packet_props.update({'ReplayGain Version': rg_version, 'Title Gain (dB)': title_gain / 256, 'Title Peak (dB)': title_peak / 256, 'Album Gain (dB)': album_gain / 256, 'Album Peak (dB)': album_peak / 256})
elif key == 'EI':
profile_bits = data[offset]
offset += 1
profile = (profile_bits >> 1) + (profile_bits & 0x01) * 0.875 # Simplified
pns = profile_bits & 0x01
major = data[offset]
offset += 1
minor = data[offset]
offset += 1
build = data[offset]
offset += 1
packet_props.update({'Profile': profile, 'PNS Tool': pns, 'Major': major, 'Minor': minor, 'Build': build})
# Similar for other keys, skipping detailed for brevity
self.properties[key] = packet_props
self.packets.append((key, data[packet_start - 2 - size_length:packet_end]))
offset = packet_end
def print_properties(self):
for key, props in self.properties.items():
print(f"Packet {key}:")
for k, v in props.items():
print(f" {k}: {v}")
def write(self, new_filename):
with open(new_filename, 'wb') as f:
f.write(b'MPCK')
for key, packet_data in self.packets:
f.write(packet_data)
# Example usage
if __name__ == '__main__':
if len(sys.argv) > 1:
mpc = MPCFile(sys.argv[1])
mpc.print_properties()
mpc.write('output.mpc')
Note: The parse method is simplified; full packet data is stored for write. Add parsing for other packets as needed.
5. Java Class for .mpc File
This Java class uses ByteBuffer for parsing.
import java.io.*;
import java.nio.*;
import java.util.*;
public class MPCFile {
private String filename;
private Map<String, Map<String, Object>> properties = new HashMap<>();
private List<byte[]> packets = new ArrayList<>();
public MPCFile(String filename) {
this.filename = filename;
parse();
}
private int[] readVarint(ByteBuffer bb) {
int value = 0;
while (true) {
byte byteVal = bb.get();
value = (value << 7) | (byteVal & 0x7F);
if ((byteVal & 0x80) == 0) break;
}
return new int[]{value, bb.position()};
}
private void parse() {
try (FileInputStream fis = new FileInputStream(filename)) {
byte[] data = new byte[(int) new File(filename).length()];
fis.read(data);
ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN);
String magic = new String(new byte[]{bb.get(), bb.get(), bb.get(), bb.get()});
if (!"MPCK".equals(magic)) throw new IOException("Invalid MPC file");
properties.put("Magic Number", Collections.singletonMap("Value", "MPCK"));
while (bb.hasRemaining()) {
String key = new String(new byte[]{bb.get(), bb.get()});
int[] sizeRes = readVarint(bb);
int size = sizeRes[0];
int pos = bb.position();
Map<String, Object> packetProps = new HashMap<>();
packetProps.put("Key", key);
packetProps.put("Size", size);
if (key.equals("SH")) {
int crc = bb.getInt();
byte version = bb.get();
sizeRes = readVarint(bb);
int sampleCount = sizeRes[0];
bb.position(sizeRes[1]);
sizeRes = readVarint(bb);
int beginSilence = sizeRes[0];
bb.position(sizeRes[1]);
byte freqBits = bb.get();
int freq = (freqBits >> 5) & 0x07;
int maxBands = freqBits & 0x1F;
byte chanBits = bb.get();
int channels = (chanBits >> 4) & 0x0F;
int msUsed = (chanBits >> 3) & 0x01;
int blockFrames = chanBits & 0x07;
packetProps.put("CRC", crc);
packetProps.put("Stream Version", (int) version);
packetProps.put("Sample Count", sampleCount);
packetProps.put("Beginning Silence", beginSilence);
packetProps.put("Sample Frequency", freq);
packetProps.put("Max Used Bands", maxBands);
packetProps.put("Channel Count", channels);
packetProps.put("MS Used", msUsed);
packetProps.put("Audio Block Frames", blockFrames);
} // Add similar blocks for RG, EI, etc.
properties.put(key, packetProps);
int endPos = pos + size - 2 - (sizeRes[1] - (pos - 2)); // Adjust for size length
byte[] packetData = new byte[endPos - (pos - 2 - (sizeRes[1] - pos + pos))]; // Simplified
System.arraycopy(data, pos - 2 - (sizeRes[1] - pos), packetData, 0, packetData.length);
packets.add(packetData);
bb.position(endPos);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public void printProperties() {
for (Map.Entry<String, Map<String, Object>> entry : properties.entrySet()) {
System.out.println("Packet " + entry.getKey() + ":");
for (Map.Entry<String, Object> prop : entry.getValue().entrySet()) {
System.out.println(" " + prop.getKey() + ": " + prop.getValue());
}
}
}
public void write(String newFilename) {
try (FileOutputStream fos = new FileOutputStream(newFilename)) {
fos.write("MPCK".getBytes());
for (byte[] packet : packets) {
fos.write(packet);
}
} catch (IOException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
if (args.length > 0) {
MPCFile mpc = new MPCFile(args[0]);
mpc.printProperties();
mpc.write("output.mpc");
}
}
}
Note: Simplified; expand for full packet parsing.
6. JavaScript Class for .mpc File
This JS class can be used in Node.js (with fs) to open, parse, print to console, and write.
const fs = require('fs');
class MPCFile {
constructor(filename) {
this.filename = filename;
this.properties = {};
this.packets = [];
this.parse();
}
readVarint(data, offset) {
let value = 0;
while (true) {
const byte = data[offset++];
value = (value << 7) | (byte & 0x7F);
if ((byte & 0x80) === 0) break;
}
return { value, offset };
}
parse() {
const data = fs.readSync(this.filename);
let offset = 0;
const magic = data.toString('ascii', offset, offset+4);
offset += 4;
if (magic !== 'MPCK') throw new Error('Invalid MPC file');
this.properties['Magic Number'] = 'MPCK';
while (offset < data.length) {
const key = data.toString('ascii', offset, offset+2);
offset += 2;
const sizeRes = this.readVarint(data, offset);
offset = sizeRes.offset;
const size = sizeRes.value;
const packetStart = offset;
const packetProps = { Key: key, Size: size };
if (key === 'SH') {
const view = new DataView(data.buffer, data.byteOffset + offset);
const crc = view.getUint32(0, false);
offset += 4;
const version = data[offset++];
const sampleCountRes = this.readVarint(data, offset);
offset = sampleCountRes.offset;
const beginSilenceRes = this.readVarint(data, offset);
offset = beginSilenceRes.offset;
const freqBits = data[offset++];
const freq = (freqBits >> 5) & 0x07;
const maxBands = freqBits & 0x1F;
const chanBits = data[offset++];
const channels = (chanBits >> 4) & 0x0F;
const msUsed = (chanBits >> 3) & 0x01;
const blockFrames = chanBits & 0x07;
packetProps.CRC = crc;
packetProps['Stream Version'] = version;
packetProps['Sample Count'] = sampleCountRes.value;
packetProps['Beginning Silence'] = beginSilenceRes.value;
packetProps['Sample Frequency'] = freq;
packetProps['Max Used Bands'] = maxBands;
packetProps['Channel Count'] = channels;
packetProps['MS Used'] = msUsed;
packetProps['Audio Block Frames'] = blockFrames;
} // Add for other keys
this.properties[key] = packetProps;
const sizeLength = Math.ceil(Math.log2(size + 1) / 7);
const packetEnd = packetStart + size - 2 - sizeLength;
this.packets.push(data.slice(packetStart - 2 - sizeLength, packetEnd));
offset = packetEnd;
}
}
printProperties() {
for (const [key, props] in Object.entries(this.properties)) {
console.log(`Packet ${key}:`);
for (const [k, v] in Object.entries(props)) {
console.log(` ${k}: ${v}`);
}
}
}
write(newFilename) {
let buffer = Buffer.from('MPCK');
this.packets.forEach(packet => buffer = Buffer.concat([buffer, packet]));
fs.writeFileSync(newFilename, buffer);
}
}
// Example
if (process.argv.length > 2) {
const mpc = new MPCFile(process.argv[2]);
mpc.printProperties();
mpc.write('output.mpc');
}
Note: Requires Node.js. Simplified parsing.
7. C Class for .mpc File
This C++ class uses fstream for r/w.
#include <iostream>
#include <fstream>
#include <vector>
#include <map>
#include <string>
#include <cmath>
using namespace std;
class MPCFile {
private:
string filename;
map<string, map<string, string>> properties;
vector<vector<char>> packets;
pair<long, int> readVarint(ifstream& file) {
long value = 0;
int byte;
while (true) {
file.read((char*)&byte, 1);
value = (value << 7) | (byte & 0x7F);
if ((byte & 0x80) == 0) break;
}
return {value, file.tellg()};
}
public:
MPCFile(const string& fn) : filename(fn) {
parse();
}
void parse() {
ifstream file(filename, ios::binary);
char magic[4];
file.read(magic, 4);
if (string(magic, 4) != "MPCK") {
cerr << "Invalid MPC file" << endl;
return;
}
properties["Magic Number"]["Value"] = "MPCK";
while (!file.eof()) {
char keyBuf[2];
file.read(keyBuf, 2);
string key(keyBuf, 2);
auto sizeRes = readVarint(file);
long size = sizeRes.first;
streampos pos = file.tellg();
map<string, string> packetProps;
packetProps["Key"] = key;
packetProps["Size"] = to_string(size);
if (key == "SH") {
unsigned int crc;
file.read((char*)&crc, 4);
char version;
file.read(&version, 1);
auto sampleCountRes = readVarint(file);
file.seekg(sampleCountRes.second);
auto beginSilenceRes = readVarint(file);
file.seekg(beginSilenceRes.second);
char freqBits;
file.read(&freqBits, 1);
int freq = (freqBits >> 5) & 0x07;
int maxBands = freqBits & 0x1F;
char chanBits;
file.read(&chanBits, 1);
int channels = (chanBits >> 4) & 0x0F;
int msUsed = (chanBits >> 3) & 0x01;
int blockFrames = chanBits & 0x07;
packetProps["CRC"] = to_string(crc);
packetProps["Stream Version"] = to_string((int)version);
packetProps["Sample Count"] = to_string(sampleCountRes.first);
packetProps["Beginning Silence"] = to_string(beginSilenceRes.first);
packetProps["Sample Frequency"] = to_string(freq);
packetProps["Max Used Bands"] = to_string(maxBands);
packetProps["Channel Count"] = to_string(channels);
packetProps["MS Used"] = to_string(msUsed);
packetProps["Audio Block Frames"] = to_string(blockFrames);
} // Add for other
properties[key] = packetProps;
int sizeLength = ceil(log2(size + 1) / 7.0);
streampos packetStart = pos - 2 - sizeLength;
file.seekg(pos);
vector<char> packetData(size);
file.read(packetData.data(), size);
packets.push_back(packetData);
file.seekg(pos + size - 2 - sizeLength + pos - pos); // Adjust
long endPos = pos + size - 2 - sizeLength;
file.seekg(endPos);
}
file.close();
}
void printProperties() {
for (const auto& p : properties) {
cout << "Packet " << p.first << ":" << endl;
for (const auto& prop : p.second) {
cout << " " << prop.first << ": " << prop.second << endl;
}
}
}
void write(const string& newFilename) {
ofstream out(newFilename, ios::binary);
out.write("MPCK", 4);
for (const auto& packet : packets) {
out.write(packet.data(), packet.size());
}
out.close();
}
};
int main(int argc, char** argv) {
if (argc > 1) {
MPCFile mpc(argv[1]);
mpc.printProperties();
mpc.write("output.mpc");
}
return 0;
}
Note: Simplified; compile with g++. Full varint position handling may need adjustment for accuracy.