Task 419: .MPEG File Format
Task 419: .MPEG File Format
File Format Specifications for .MPEG
The .MPEG file format refers to files conforming to the MPEG-1 standard, specifically the systems layer defined in ISO/IEC 11172-1, which specifies how to multiplex video and audio elementary streams into a program stream for storage or transmission. This standard supports compression of video (typically at SIF resolution: 352x240 or 352x288 pixels) and audio at bit rates up to about 1.5 Mbit/s, ensuring synchronization via timestamps and clock references. MPEG-1 streams are packetized, with structures like packs and packets to handle interleaving and timing. The format is "catenative," allowing concatenation of sequences, and is commonly used for video files with the .mpeg or .mpg extension.
- List of Properties Intrinsic to the .MPEG File Format
Based on the MPEG-1 systems layer specification, the following are the key properties (fields and structural elements) intrinsic to the format. These include headers, timestamps, rates, and identifiers parsed from the binary stream. They define the multiplex structure, synchronization, and resource requirements. Properties are grouped by header type for clarity.
Pack Header Properties:
- Pack start code: 32-bit identifier (value: 0x000001BA) marking the start of a pack.
- System Clock Reference (SCR) base: 33-bit timestamp (90 kHz resolution) for synchronizing the decoder's clock.
- SCR extension: 9-bit extension (27 MHz resolution) for finer timing precision.
- Marker bits (for SCR): 3 bits (set to 1) to ensure parsing unambiguity.
- Program mux rate: 22-bit value indicating the total bit rate in 50-byte units, plus 1 marker bit.
- Packing stuffing length: 3-bit value specifying 0-7 stuffing bytes for alignment.
System Header Properties (optional but typically present in the first pack):
- System header start code: 32-bit identifier (value: 0x000001BB).
- Header length: 16-bit value indicating the length of the system header excluding the start code.
- Rate bound: 22-bit maximum bit rate bound for the stream, plus 1 marker bit.
- Audio bound: 6-bit maximum number of audio streams (0-32).
- Fixed flag: 1-bit flag indicating fixed (1) or variable (0) bit rate.
- CSPS flag: 1-bit flag for constrained system parameter stream (1 if compliant with standard constraints).
- System audio lock flag: 1-bit flag indicating if audio is locked to the system clock.
- System video lock flag: 1-bit flag indicating if video is locked to the system clock.
- Marker bit (post-flags): 1 bit (set to 1).
- Video bound: 5-bit maximum number of video streams (0-16, typically 1).
- Packet rate restriction flag: 1-bit flag restricting packet rate.
- Reserved bits: 7 bits (set to 1).
- Stream-specific bindings: Variable; for each stream, includes stream ID (8 bits), P-STD buffer bound scale (1 bit), and P-STD buffer size bound (13 bits).
Packet Header Properties (PES - Packetized Elementary Stream):
- Packet start code prefix: 24-bit prefix (0x000001).
- Stream ID: 8-bit identifier (e.g., 0xE0-0xEF for video, 0xC0-0xDF for audio, 0xBD for private data).
- PES packet length: 16-bit length of the packet data (0 indicates unbounded for video).
- PES scrambling control: 2 bits indicating scrambling mode (00 = not scrambled).
- PES priority: 1 bit for priority indication.
- Data alignment indicator: 1 bit indicating if payload starts with a video/audio start code.
- Copyright: 1 bit for copyright status.
- Original or copy: 1 bit indicating original (1) or copy (0).
- PTS DTS indicator: 2 bits (00 = none, 10 = PTS only, 11 = PTS and DTS, 01 forbidden).
- ESCR flag: 1 bit for Elementary Stream Clock Reference presence.
- ES rate flag: 1 bit for Elementary Stream rate presence.
- DSM trick mode flag: 1 bit for trick mode (fast forward, etc.).
- Additional copy info flag: 1 bit for additional copyright info.
- PES CRC flag: 1 bit for CRC presence.
- PES extension flag: 1 bit for extension fields.
- PES header data length: 8-bit length of optional fields.
- Presentation Time Stamp (PTS): 33-bit timestamp (plus markers) for when to present the access unit.
- Decoding Time Stamp (DTS): 33-bit timestamp (plus markers, optional) for when to decode the access unit.
- Stuffing bytes: Variable bytes (0xFF) for alignment.
These properties ensure synchronization, buffer management, and stream identification. General format properties include support for variable bit rates, a 90 kHz time base, and interleaving of up to 1 video and 32 audio streams.
Two Direct Download Links for .MPEG Files
- https://filesamples.com/samples/video/mpeg/sample_1280x720_surfing_with_audio.mpeg (Sample surfing video with audio, ~12 MB).
- https://filesamples.com/samples/video/mpeg/sample_960x400_ocean_with_audio.mpeg (Sample ocean video with audio, ~3 MB).
Ghost Blog Embedded HTML JavaScript for Drag-and-Drop .MPEG Property Dump
Below is an HTML snippet with embedded JavaScript that can be inserted into a Ghost blog post (using the HTML card in the editor). It creates a drag-and-drop area where users can drop a .MPEG file. The script reads the file as an ArrayBuffer, parses the MPEG-1 system stream to extract the properties listed in (1), and dumps them to the screen in a pre-formatted text area.
Drag and drop .MPEG file here
Note: This script performs basic parsing of major headers. Full parsing of all fields (e.g., detailed PTS/DTS bit shifting) can be extended in the parseMPEG function for completeness. It assumes MPEG-1 compliance and may not handle errors or non-standard files.
- Python Class for .MPEG Handling
import struct
import os
class MPEGHandler:
def __init__(self, filepath):
self.filepath = filepath
self.properties = {}
def read_decode(self):
with open(self.filepath, 'rb') as f:
data = f.read()
offset = 0
while offset < len(data) - 4:
start_code = struct.unpack_from('>I', data, offset)[0]
if start_code == 0x000001BA: # Pack header
scr1, scr2, scr3, mux1, stuffing = struct.unpack_from('>BBBH B', data, offset + 4)
scr_base = ((scr1 & 0x0E) << 30 | (scr1 & 0x01) << 29 | (scr2 >> 3) << 15 | (scr2 & 0x07) << 12 | (scr3 >> 4) << 0)
scr_ext = (scr3 & 0x03) << 7 | (mux1 >> 1)
mux_rate = ((mux1 & 0x01) << 21 | (struct.unpack_from('>H', data, offset + 9)[0] >> 1)) * 50
stuffing_len = stuffing & 0x07
self.properties['pack'] = {'SCR Base': scr_base, 'SCR Ext': scr_ext, 'Mux Rate': mux_rate, 'Stuffing Len': stuffing_len}
offset += 12 + stuffing_len
elif start_code == 0x000001BB: # System header
header_len = struct.unpack_from('>H', data, offset + 4)[0]
rate_bound = struct.unpack_from('>I', data, offset + 6)[0] >> 9 & 0x7FFFFF
flags = struct.unpack_from('>B', data, offset + 8)[0]
audio_bound = flags >> 2 & 0x3F
fixed_flag = (flags >> 1) & 0x01
csps_flag = flags & 0x01
self.properties['system'] = {'Header Len': header_len, 'Rate Bound': rate_bound, 'Audio Bound': audio_bound, 'Fixed Flag': fixed_flag, 'CSPS Flag': csps_flag}
# Parse more as needed
offset += 6 + header_len
elif (start_code & 0xFFFFFF00) == 0x00000100: # PES packet
stream_id = start_code & 0xFF
packet_len = struct.unpack_from('>H', data, offset + 4)[0]
self.properties.setdefault('packets', []).append({'Stream ID': stream_id, 'Packet Len': packet_len})
# PTS/DTS parsing if flags indicate
offset += 6 # Minimal, adjust for full
if data[offset] == 0x2: # Example for PTS only
pts = struct.unpack_from('>Q', b'\x00' + data[offset:offset+5])[0] >> 7 # Simplified
self.properties['packets'][-1]['PTS'] = pts
offset += 5
else:
offset += 1
def print_properties(self):
print('MPEG Properties:')
for key, value in self.properties.items():
print(f'{key}: {value}')
def write(self, output_path):
# Simple write: copy original file (extend for modification)
with open(self.filepath, 'rb') as f_in, open(output_path, 'wb') as f_out:
f_out.write(f_in.read())
print(f'Wrote to {output_path}')
# Example usage:
# handler = MPEGHandler('sample.mpeg')
# handler.read_decode()
# handler.print_properties()
# handler.write('output.mpeg')
This class reads and decodes the file, stores properties, prints them, and writes a copy (can be extended to modify properties).
- Java Class for .MPEG Handling
import java.io.*;
import java.nio.*;
import java.util.*;
public class MPEGHandler {
private String filepath;
private Map<String, Object> properties = new HashMap<>();
public MPEGHandler(String filepath) {
this.filepath = filepath;
}
public void readDecode() throws IOException {
File file = new File(filepath);
byte[] data = new byte[(int) file.length()];
try (FileInputStream fis = new FileInputStream(file)) {
fis.read(data);
}
ByteBuffer buffer = ByteBuffer.wrap(data).order(ByteOrder.BIG_ENDIAN);
int offset = 0;
while (offset < data.length - 4) {
int startCode = buffer.getInt(offset);
if (startCode == 0x000001BA) { // Pack header
long scr = ((long) buffer.get(offset + 4) << 32) | ((long) buffer.getInt(offset + 5) & 0xFFFFFFFFL);
// Bit shifting for SCR base/ext (simplified)
int muxRate = (buffer.getInt(offset + 9) >>> 1) * 50; // Approximate
int stuffingLen = buffer.get(offset + 11) & 0x07;
Map<String, Integer> packProps = new HashMap<>();
packProps.put("Mux Rate", muxRate);
packProps.put("Stuffing Len", stuffingLen);
properties.put("pack", packProps);
offset += 12 + stuffingLen;
} else if (startCode == 0x000001BB) { // System header
short headerLen = buffer.getShort(offset + 4);
int rateBound = buffer.getInt(offset + 6) >>> 9 & 0x7FFFFF;
byte flags = buffer.get(offset + 8);
int audioBound = (flags >>> 2) & 0x3F;
Map<String, Integer> sysProps = new HashMap<>();
sysProps.put("Header Len", (int) headerLen);
sysProps.put("Rate Bound", rateBound);
sysProps.put("Audio Bound", audioBound);
properties.put("system", sysProps);
offset += 6 + headerLen;
} else if ((startCode & 0xFFFFFF00) == 0x00000100) { // PES packet
int streamId = startCode & 0xFF;
short packetLen = buffer.getShort(offset + 4);
List<Map<String, Integer>> packets = (List) properties.getOrDefault("packets", new ArrayList<>());
Map<String, Integer> packetProps = new HashMap<>();
packetProps.put("Stream ID", streamId);
packetProps.put("Packet Len", (int) packetLen);
packets.add(packetProps);
properties.put("packets", packets);
offset += 6; // Extend for PTS/DTS
} else {
offset++;
}
}
}
public void printProperties() {
System.out.println("MPEG Properties:");
properties.forEach((key, value) -> System.out.println(key + ": " + value));
}
public void write(String outputPath) throws IOException {
// Simple copy write
Files.copy(new File(filepath).toPath(), new File(outputPath).toPath());
System.out.println("Wrote to " + outputPath);
}
// Example usage:
// public static void main(String[] args) throws IOException {
// MPEGHandler handler = new MPEGHandler("sample.mpeg");
// handler.readDecode();
// handler.printProperties();
// handler.write("output.mpeg");
// }
}
This class reads/decodes the file, stores properties, prints them, and writes a copy.
- JavaScript Class for .MPEG Handling
class MPEGHandler {
constructor(filepath) {
this.filepath = filepath;
this.properties = {};
}
async readDecode() {
// For Node.js, require fs
const fs = require('fs');
const data = fs.readFileSync(this.filepath);
const view = new DataView(data.buffer);
let offset = 0;
while (offset < data.length - 4) {
const startCode = view.getUint32(offset);
if (startCode === 0x000001BA) { // Pack header
const scrHigh = view.getUint8(offset + 4) & 0xF0 >>> 4;
// Similar parsing as in HTML script...
// Add to this.properties.pack = {...}
offset += 12 + (view.getUint8(offset + 11) & 0x07);
} else if (startCode === 0x000001BB) {
// Parse system header
offset += 6 + view.getUint16(offset + 4);
} else if ((startCode & 0xFFFFFF00) === 0x00000100) {
// Parse packet
offset += 6; // Extend
} else {
offset++;
}
}
}
printProperties() {
console.log('MPEG Properties:', this.properties);
}
write(outputPath) {
const fs = require('fs');
fs.copyFileSync(this.filepath, outputPath);
console.log(`Wrote to ${outputPath}`);
}
}
// Example usage (Node.js):
// const handler = new MPEGHandler('sample.mpeg');
// await handler.readDecode();
// handler.printProperties();
// handler.write('output.mpeg');
This class is for Node.js (uses fs). It reads/decodes, prints properties, and writes a copy. Parsing logic mirrors the HTML script; extend for full fields.
- C "Class" for .MPEG Handling
C doesn't have classes, so here's a struct with functions for equivalent functionality.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdint.h>
typedef struct {
char* filepath;
// Use a map-like array or struct for properties (simplified as char buffer for print)
char properties[4096]; // Buffer for printed properties
} MPEGHandler;
void init_mpeg_handler(MPEGHandler* handler, const char* filepath) {
handler->filepath = strdup(filepath);
memset(handler->properties, 0, sizeof(handler->properties));
}
void read_decode(MPEGHandler* handler) {
FILE* f = fopen(handler->filepath, "rb");
if (!f) return;
fseek(f, 0, SEEK_END);
long len = ftell(f);
fseek(f, 0, SEEK_SET);
uint8_t* data = malloc(len);
fread(data, 1, len, f);
fclose(f);
int offset = 0;
char buf[1024] = {0};
while (offset < len - 4) {
uint32_t start_code = (data[offset] << 24) | (data[offset+1] << 16) | (data[offset+2] << 8) | data[offset+3];
if (start_code == 0x000001BA) { // Pack header
// Parse SCR, mux rate, etc.
uint32_t mux_rate = (((data[offset+9] & 0x01) << 21) | ((data[offset+10] << 8 | data[offset+11]) >> 1)) * 50;
int stuffing_len = data[offset+11] & 0x07;
sprintf(buf, "Pack: Mux Rate %u, Stuffing %d\n", mux_rate, stuffing_len);
strcat(handler->properties, buf);
offset += 12 + stuffing_len;
} else if (start_code == 0x000001BB) { // System header
uint16_t header_len = (data[offset+4] << 8) | data[offset+5];
// Parse more
sprintf(buf, "System: Header Len %hu\n", header_len);
strcat(handler->properties, buf);
offset += 6 + header_len;
} else if ((start_code & 0xFFFFFF00) == 0x00000100) {
uint8_t stream_id = start_code & 0xFF;
uint16_t packet_len = (data[offset+4] << 8) | data[offset+5];
sprintf(buf, "Packet: Stream ID 0x%02X, Len %hu\n", stream_id, packet_len);
strcat(handler->properties, buf);
offset += 6; // Extend
} else {
offset++;
}
}
free(data);
}
void print_properties(MPEGHandler* handler) {
printf("MPEG Properties:\n%s", handler->properties);
}
void write_file(MPEGHandler* handler, const char* output_path) {
FILE* f_in = fopen(handler->filepath, "rb");
FILE* f_out = fopen(output_path, "wb");
if (f_in && f_out) {
char buf[4096];
size_t read;
while ((read = fread(buf, 1, sizeof(buf), f_in)) > 0) {
fwrite(buf, 1, read, f_out);
}
fclose(f_in);
fclose(f_out);
printf("Wrote to %s\n", output_path);
}
}
void free_mpeg_handler(MPEGHandler* handler) {
free(handler->filepath);
}
// Example usage:
// int main() {
// MPEGHandler handler;
// init_mpeg_handler(&handler, "sample.mpeg");
// read_decode(&handler);
// print_properties(&handler);
// write_file(&handler, "output.mpeg");
// free_mpeg_handler(&handler);
// return 0;
// }
This implements reading/decoding, printing properties, and writing a copy using basic file I/O and bit manipulation. Extend parsing for all fields.