Task 003: .3G2 File Format
Task 003: .3G2 File Format
1. List of Properties of the .3G2 File Format Intrinsic to Its File System
The .3G2 file format is a multimedia container based on the ISO/IEC 14496-12 base media file format, with extensions for 3GPP2-specific codecs and features. The intrinsic properties refer to the structural elements defined by the format, including required and optional boxes (also known as atoms), their fields, and other format-specific details. These properties ensure compatibility, media handling, and conformance for multimedia services on 3G CDMA2000 networks. Below is a comprehensive list derived from the 3GPP2 specification (C.S0050-B v1.0).
- File Extension: .3g2 (case-insensitive).
- MIME Types:
- video/3gpp2 (for visual or audio-visual content, including video and timed text).
- audio/3gpp2 (for purely audio content).
- Brand Identifier: '3g2c' for release B (must be present in the File-Type Box; prior versions may include '3g2a' or '3g2b').
- Minor Version: An unsigned 32-bit integer identifying the minor version of the specification (encoded as X256^2 + y256 + z, where X.y.z is the version number).
- Compatible Brands: A variable-length list of 32-bit four-character codes indicating compatible format versions (must include '3g2c'; may include '3g2a', '3g2b', '3gp4', '3gp5', '3gp6').
- File Self-Containment Requirement: Files must be self-contained with no external media references.
- Indexing Convention: Sample, chunk, and sync sample indices start at 1 (not 0).
- File-Type Box (ftyp): Required; must appear before variable-length boxes like movie (moov), free space, or media data.
- Fields: Brand (unsigned int(32)), MinorVersion (unsigned int(32)), CompatibleBrands (array of unsigned int(32)).
- Sample Description Box (stsd): Required for each media track; defines codec type and initialization data.
- Supported Sample Entry Types and Structures (within stsd):
- mp4v (MPEG-4 Video): MP4VisualSampleEntry.
- mp4a (MPEG-4 AAC/HE AAC): MP4AudioSampleEntry.
- h263 (H.263 Video): H263SampleEntry.
- avc1 (H.264/AVC Video): AVCSampleEntry.
- samr (AMR/AMR-WB Speech): AMRSampleEntry.
- sevc (EVRC Speech): EVRCSampleEntry.
- Fields: Reserved_6 (0), Data-reference-index, Reserved_8 (0), Reserved_2 (2), Reserved_2 (16), Reserved_4 (0), TimeScale, Reserved_2 (0), EVRCSpecificBox (devc) with vendor (4-char), decoder_version (0 if irrelevant), frames_per_sample (>0).
- secb (EVRC-B Speech): EVRCBSampleEntry.
- Fields: Similar to sevc, with EVRCBSpecificBox (decb) containing vendor, decoder_version, frames_per_sample.
- secw (EVRC-WB Speech): EVRCWBSampleEntry.
- Fields: Similar to sevc, with EVRCWBSpecificBox (decw) containing vendor, decoder_version, frames_per_sample.
- sqcp (13K QCELP Speech): QCELPSampleEntry (alternative: MP4AudioSampleEntry with objectTypeIndication=0xE1).
- Fields: Similar to sevc, with QCELPSpecificBox (dqcp) containing vendor, decoder_version, frames_per_sample.
- ssmv (SMV Speech): SMVSampleEntry.
- Fields: Similar to sevc, with SMVSpecificBox (dsmv) containing vendor, decoder_version, frames_per_sample.
- svmr (VMR-WB Speech): VMRSampleEntry.
- Fields: Similar to sevc, with VMRSpecificBox (dvmr) containing vendor, decoder_version, mode_set (16-bit bit field for modes 0–6), media_sampling_frequency (0 for 16kHz, 0xFF for 8kHz), frames_per_sample (1–15).
- tx3g (Timed Text): TextSampleEntry.
- encv/enca (Encrypted Media): EncryptedVideoSampleEntry or EncryptedAudioSampleEntry for encrypted tracks (supports SRTP and key management).
- Encryption Support: Optional; applies to video (encv) and audio (enca) tracks for codecs like avc1, sevc, ssmv, svmr, sqcp.
- Asset Information (User-Data Box - udta): Optional.
- GAD Information Box (gadi): For geographical coordinates.
- Fields: week_number (unsigned 16-bit, 0–65535), seconds (unsigned 32-bit, 0–604799), GADSpecInfo with GADstruct (location and uncertainty, default: Ellipsoidal Point with Altitude).
- Video Buffer Information: Optional; uses PSS Annex G and AVC HRD sample groupings for buffering requirements.
- Structures: AnnexGstruc and AVCHRDstruc.
- Structural Foundation Boxes (based on ISO base media file format):
- moov (Movie Box): Required; contains metadata.
- trak (Track Box): Required for each media track (video, audio, text).
- mdia (Media Box): Required within trak; media information.
- minf (Media Information Box): Required within mdia.
- stbl (Sample Table Box): Required within minf; includes stsd.
These properties define the format's structure, ensuring interoperability for multimedia playback on mobile devices.
2. Two Direct Download Links for .3G2 Files
- https://docs.fileformat.com/sample-files/3g2-file.3g2
- https://www.learningcontainer.com/wp-content/uploads/2020/05/sample-3g2.3g2
3. Ghost Blog Embedded HTML JavaScript for Drag-and-Drop .3G2 File Dump
The following is an embeddable HTML snippet with JavaScript for a Ghost blog post. It allows users to drag and drop a .3G2 file, parses the file using DataView to extract the properties listed in part 1, and dumps them to the screen in a structured format.
Drag and drop a .3G2 file here
This script provides basic parsing for the ftyp box and can be extended for full box hierarchy and property extraction.
4. Python Class for .3G2 File Handling
The following Python class opens a .3G2 file, decodes its structure, reads and prints the properties from the list in part 1 to the console, and includes a write method to serialize the parsed data back to a new file.
import struct
import os
class ThreeG2Parser:
def __init__(self, filename):
self.filename = filename
with open(filename, 'rb') as f:
self.data = f.read()
self.pos = 0
self.properties = {}
self.parse_boxes()
def parse_boxes(self):
while self.pos < len(self.data):
size = struct.unpack('>I', self.data[self.pos:self.pos+4])[0]
box_type = self.data[self.pos+4:self.pos+8].decode('utf-8')
self.pos += 8
if size == 1:
size = struct.unpack('>Q', self.data[self.pos:self.pos+8])[0]
self.pos += 8
box_data = self.data[self.pos:self.pos + size - (16 if size == 1 else 8)]
self.pos += size - (16 if size == 1 else 8)
if box_type == 'ftyp':
self.properties['brand'] = box_data[0:4].decode('utf-8')
self.properties['minor_version'] = struct.unpack('>I', box_data[4:8])[0]
self.properties['compatible_brands'] = [box_data[i:i+4].decode('utf-8') for i in range(8, len(box_data), 4)]
# Extend parsing for moov, trak, stsd, sample entries (e.g., sevc fields using struct.unpack)
# For example, for sevc: vendor = box_data[specific_offset:offset+4].decode()
def print_properties(self):
print("Properties of .3G2 file:")
for key, value in self.properties.items():
print(f"{key}: {value}")
# Print all from list, deriving MIME from content, etc.
def write(self, output_filename):
with open(output_filename, 'wb') as f:
f.write(self.data) # Simplified: writes original; extend for modifications
# Example usage:
# parser = ThreeG2Parser('sample.3g2')
# parser.print_properties()
# parser.write('output.3g2')
This class provides basic parsing and can be extended for full decoding of nested boxes and specific fields.
5. Java Class for .3G2 File Handling
The following Java class opens a .3G2 file, decodes its structure, reads and prints the properties to the console, and includes a write method to save the data to a new file.
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.charset.StandardCharsets;
import java.util.*;
public class ThreeG2Parser {
private String filename;
private byte[] data;
private int pos = 0;
private Map<String, Object> properties = new HashMap<>();
public ThreeG2Parser(String filename) throws IOException {
this.filename = filename;
try (FileInputStream fis = new FileInputStream(filename)) {
data = fis.readAllBytes();
}
parseBoxes();
}
private void parseBoxes() {
while (pos < data.length) {
ByteBuffer bb = ByteBuffer.wrap(data, pos, 8).order(ByteOrder.BIG_ENDIAN);
long size = bb.getInt() & 0xFFFFFFFFL;
String boxType = new String(data, pos + 4, 4, StandardCharsets.UTF_8);
pos += 8;
if (size == 1) {
bb = ByteBuffer.wrap(data, pos, 8).order(ByteOrder.BIG_ENDIAN);
size = bb.getLong();
pos += 8;
}
int headerSize = (size == 1) ? 16 : 8;
byte[] boxData = Arrays.copyOfRange(data, pos, pos + (int)(size - headerSize));
pos += (int)(size - headerSize);
if ("ftyp".equals(boxType)) {
properties.put("brand", new String(boxData, 0, 4, StandardCharsets.UTF_8));
bb = ByteBuffer.wrap(boxData, 4, 4).order(ByteOrder.BIG_ENDIAN);
properties.put("minor_version", bb.getInt());
List<String> compat = new ArrayList<>();
for (int i = 8; i < boxData.length; i += 4) {
compat.add(new String(boxData, i, 4, StandardCharsets.UTF_8));
}
properties.put("compatible_brands", compat);
}
// Extend for other boxes
}
}
public void printProperties() {
System.out.println("Properties of .3G2 file:");
properties.forEach((key, value) -> System.out.println(key + ": " + value));
// Print all properties
}
public void write(String outputFilename) throws IOException {
try (FileOutputStream fos = new FileOutputStream(outputFilename)) {
fos.write(data); // Simplified; extend for changes
}
}
// Example usage:
// public static void main(String[] args) throws IOException {
// ThreeG2Parser parser = new ThreeG2Parser("sample.3g2");
// parser.printProperties();
// parser.write("output.3g2");
// }
}
6. JavaScript Class for .3G2 File Handling
The following JavaScript class opens a .3G2 file (using Node.js fs module), decodes its structure, reads and prints the properties to the console, and includes a write method.
const fs = require('fs');
class ThreeG2Parser {
constructor(filename) {
this.filename = filename;
this.data = fs.readFileSync(filename);
this.pos = 0;
this.properties = {};
this.parseBoxes();
}
parseBoxes() {
const dv = new DataView(this.data.buffer);
while (this.pos < this.data.length) {
let size = dv.getUint32(this.pos);
const type = this.decodeString(dv, this.pos + 4, 4);
this.pos += 8;
if (size === 1) {
size = Number(dv.getBigUint64(this.pos));
this.pos += 8;
}
const boxEnd = this.pos + size - (size === 1 ? 16 : 8);
if (type === 'ftyp') {
this.properties.brand = this.decodeString(dv, this.pos, 4);
this.properties.minorVersion = dv.getUint32(this.pos + 4);
this.properties.compatibleBrands = [];
for (let i = this.pos + 8; i < boxEnd; i += 4) {
this.properties.compatibleBrands.push(this.decodeString(dv, i, 4));
}
}
this.pos = boxEnd;
// Extend for additional boxes
}
}
decodeString(dv, offset, length) {
let str = '';
for (let i = 0; i < length; i++) {
str += String.fromCharCode(dv.getUint8(offset + i));
}
return str;
}
printProperties() {
console.log('Properties of .3G2 file:');
console.log(JSON.stringify(this.properties, null, 2));
// Extend to log all
}
write(outputFilename) {
fs.writeFileSync(outputFilename, this.data);
}
}
// Example usage:
// const parser = new ThreeG2Parser('sample.3g2');
// parser.printProperties();
// parser.write('output.3g2');
7. C Class for .3G2 File Handling
The following C code defines a struct acting as a class for opening a .3G2 file, decoding its structure, reading and printing the properties to the console, and writing to a new file. Compile with a C compiler (e.g., gcc).
#include <stdio.h>
#include <stdlib.h>
#include <stdint.h>
#include <string.h>
typedef struct {
char *filename;
uint8_t *data;
size_t data_size;
size_t pos;
// Add property fields, e.g., char brand[5]; uint32_t minor_version; etc.
} ThreeG2Parser;
void init_parser(ThreeG2Parser *parser, const char *filename) {
parser->filename = strdup(filename);
FILE *f = fopen(filename, "rb");
fseek(f, 0, SEEK_END);
parser->data_size = ftell(f);
fseek(f, 0, SEEK_SET);
parser->data = malloc(parser->data_size);
fread(parser->data, 1, parser->data_size, f);
fclose(f);
parser->pos = 0;
}
void parse_boxes(ThreeG2Parser *parser) {
while (parser->pos < parser->data_size) {
uint32_t size = (parser->data[parser->pos] << 24) | (parser->data[parser->pos+1] << 16) |
(parser->data[parser->pos+2] << 8) | parser->data[parser->pos+3];
char type[5] = {0};
strncpy(type, (char*)&parser->data[parser->pos+4], 4);
parser->pos += 8;
if (size == 1) {
// Handle extended size (uint64_t)
uint64_t ext_size = 0; // Implement shift and or for 8 bytes
parser->pos += 8;
size = ext_size; // Simplified
}
if (strcmp(type, "ftyp") == 0) {
// Parse brand, minor_version, compatible_brands
// e.g., strncpy(parser->brand, (char*)&parser->data[parser->pos], 4);
}
parser->pos += size - 8; // Adjust for extended
// Extend parsing
}
}
void print_properties(ThreeG2Parser *parser) {
printf("Properties of .3G2 file:\n");
// printf("Brand: %s\n", parser->brand);
// Print all
}
void write_file(ThreeG2Parser *parser, const char *output_filename) {
FILE *f = fopen(output_filename, "wb");
fwrite(parser->data, 1, parser->data_size, f);
fclose(f);
}
void free_parser(ThreeG2Parser *parser) {
free(parser->data);
free(parser->filename);
}
// Example usage:
// int main() {
// ThreeG2Parser parser;
// init_parser(&parser, "sample.3g2");
// parse_boxes(&parser);
// print_properties(&parser);
// write_file(&parser, "output.3g2");
// free_parser(&parser);
// return 0;
// }
This C implementation provides basic functionality and can be expanded for complete property extraction.