Task 044: .AT3 File Format

The .AT3 file format, associated with Sony's Adaptive Transform Acoustic Coding 3 (ATRAC3) compression algorithm, is primarily an audio file format used for storing compressed audio data. It is commonly found in Sony devices like the PlayStation Portable (PSP), Sony CD and MP3 players, and Sony Ericsson mobile phones, often for music or game audio. Below, I address each part of your request based on the available information and the lack of a detailed public specification for the ATRAC3 format, which is proprietary.

1. Properties of the .AT3 File Format Intrinsic to Its File System

The .AT3 file format is based on the RIFF (Resource Interchange File Format) container, which holds ATRAC3-compressed audio data. Since ATRAC3 is a proprietary format developed by Sony, detailed specifications are not publicly available, and some aspects are considered trade secrets. However, based on available information, the intrinsic properties of the .AT3 file format include:

• File Extension: .at3
• MIME Type: audio/x-oma
• Container Format: RIFF (Resource Interchange File Format), a generic file container format for multimedia data.
• Audio Codec: ATRAC3 (Adaptive Transform Acoustic Coding 3) or ATRAC3plus, a lossy audio compression algorithm.
• Compression: Uses Sony's proprietary ATRAC3 compression to reduce file size while maintaining acceptable audio quality.
• Bitrate: Supports various bitrates (e.g., 66, 105, 132 kbps for ATRAC3; higher for ATRAC3plus), depending on the compression settings.
• Sample Rate: Typically 44.1 kHz, standard for CD-quality audio, but can vary based on the source.
• Channels: Supports mono or stereo audio channels.
• File Structure:
• RIFF Header: Identifies the file as a RIFF container with a fmt chunk specifying ATRAC3 encoding.
• Data Chunk: Contains the compressed audio data.
• Optional Metadata: May include metadata like track title, artist, or DRM (Digital Rights Management) information.
• DRM Support: Some .AT3 files include Digital Rights Management to control playback, especially when used with Sony's SonicStage software.
• File Size: Smaller than uncompressed formats like WAV due to ATRAC3 compression, optimized for portable devices.
• Usage Context: Primarily used for game audio (e.g., PSP game soundtracks), music on Sony devices, or MiniDiscs.
• Compatibility: Compatible with Sony devices and software (e.g., SonicStage, PSP), and some third-party software like VLC media player or MAGIX Sound Forge Pro that support ATRAC3 decoding.

Note: The exact internal structure (e.g., specific chunk layouts, header fields, or proprietary encoding details) is not fully documented publicly, as Sony has not released a comprehensive specification. The properties listed are derived from general knowledge of the format and its usage.

Challenges with Implementation

Sony's ATRAC3 is a proprietary codec, and no public libraries or detailed documentation exist for decoding or encoding .AT3 files directly in Python, Java, JavaScript, or C. Tools like VLC media player or FFmpeg can handle .AT3 files because they include proprietary codec support, but their source code for ATRAC3 is not openly accessible for replication. Writing a class to decode, read, write, and print .AT3 properties is thus challenging without reverse-engineering the format or using existing libraries like FFmpeg (via bindings) or SonicStage (discontinued).

For the programming tasks below, I provide implementations that:

• Open and read .AT3 files to extract basic RIFF-based properties (e.g., header information, chunk sizes).
• Attempt to decode audio data using assumptions about the RIFF structure.
• Write .AT3 files by copying existing data (since encoding new ATRAC3 audio requires proprietary tools).
• Print the identified properties to the console.

These implementations rely on parsing the RIFF container and extracting metadata where possible, but they cannot fully decode or encode the ATRAC3 audio without proprietary codecs. For decoding, I suggest using FFmpeg bindings where applicable, as FFmpeg supports ATRAC3.

2. Python Class for .AT3 File Handling

import struct
import os

class AT3File:
    def __init__(self, filepath):
        self.filepath = filepath
        self.properties = {
            "extension": ".at3",
            "mime_type": "audio/x-oma",
            "container": "RIFF",
            "codec": "ATRAC3",
            "channels": None,
            "sample_rate": None,
            "bitrate": None,
            "file_size": None,
            "has_drm": None
        }
        self.data_chunk = None

    def read(self):
        try:
            with open(self.filepath, "rb") as f:
                # Read RIFF header
                riff_header = f.read(12)
                if len(riff_header) < 12 or riff_header[:4] != b"RIFF":
                    raise ValueError("Not a valid RIFF file")
                
                file_size = struct.unpack("<I", riff_header[4:8])[0] + 8
                self.properties["file_size"] = file_size
                if riff_header[8:12] != b"WAVE":
                    self.properties["container"] = "Unknown (expected WAVE)"
                
                # Read chunks
                while f.tell() < file_size:
                    chunk_id = f.read(4)
                    chunk_size = struct.unpack("<I", f.read(4))[0]
                    chunk_data = f.read(chunk_size)
                    
                    if chunk_id == b"fmt ":
                        # Parse format chunk (simplified, ATRAC3-specific fields are proprietary)
                        if len(chunk_data) >= 16:
                            self.properties["channels"] = struct.unpack("<H", chunk_data[2:4])[0]
                            self.properties["sample_rate"] = struct.unpack("<I", chunk_data[4:8])[0]
                            self.properties["bitrate"] = struct.unpack("<I", chunk_data[8:12])[0] * 8 // 1000  # Approx kbps
                    elif chunk_id == b"data":
                        self.data_chunk = chunk_data
                    # Check for DRM (heuristic, not definitive)
                    if b"DRM" in chunk_data:
                        self.properties["has_drm"] = True
                    else:
                        self.properties["has_drm"] = False if self.properties["has_drm"] is None else self.properties["has_drm"]
                
                print("Read .AT3 file properties:")
                self.print_properties()

        except Exception as e:
            print(f"Error reading .AT3 file: {e}")

    def write(self, output_path):
        try:
            with open(output_path, "wb") as f:
                # Write RIFF header
                f.write(b"RIFF")
                f.write(struct.pack("<I", self.properties["file_size"] - 8))
                f.write(b"WAVE")
                # Write fmt chunk (simplified)
                f.write(b"fmt ")
                f.write(struct.pack("<I", 16))
                f.write(struct.pack("<H", 1))  # Format tag (ATRAC3, placeholder)
                f.write(struct.pack("<H", self.properties["channels"] or 2))
                f.write(struct.pack("<I", self.properties["sample_rate"] or 44100))
                f.write(struct.pack("<I", (self.properties["bitrate"] or 132) * 1000 // 8))
                f.write(struct.pack("<H", 0))  # Block align
                f.write(struct.pack("<H", 0))  # Bits per sample
                # Write data chunk
                if self.data_chunk:
                    f.write(b"data")
                    f.write(struct.pack("<I", len(self.data_chunk)))
                    f.write(self.data_chunk)
            print(f"Written .AT3 file to {output_path}")
        except Exception as e:
            print(f"Error writing .AT3 file: {e}")

    def print_properties(self):
        for key, value in self.properties.items():
            print(f"{key}: {value}")

# Example usage
if __name__ == "__main__":
    at3 = AT3File("example.at3")
    at3.read()
    at3.write("output.at3")

Notes:

• This class reads the RIFF structure and extracts basic properties like channels, sample rate, and bitrate from the fmt chunk, but ATRAC3-specific fields are proprietary and may not be fully parsed.
• Writing is limited to copying existing data, as encoding new ATRAC3 audio requires Sony's proprietary tools.
• For full decoding, consider using pydub with FFmpeg installed (pydub.AudioSegment.from_file("example.at3", format="at3")).

3. Java Class for .AT3 File Handling

import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;

public class AT3File {
    private String filepath;
    private String extension = ".at3";
    private String mimeType = "audio/x-oma";
    private String container = "RIFF";
    private String codec = "ATRAC3";
    private Integer channels;
    private Integer sampleRate;
    private Integer bitrate;
    private Long fileSize;
    private Boolean hasDrm;
    private byte[] dataChunk;

    public AT3File(String filepath) {
        this.filepath = filepath;
    }

    public void read() {
        try (FileInputStream fis = new FileInputStream(filepath)) {
            // Read RIFF header
            byte[] riffHeader = new byte[12];
            if (fis.read(riffHeader) != 12 || !new String(riffHeader, 0, 4).equals("RIFF")) {
                throw new IOException("Not a valid RIFF file");
            }

            fileSize = ByteBuffer.wrap(riffHeader, 4, 4).order(ByteOrder.LITTLE_ENDIAN).getInt() + 8L;
            container = new String(riffHeader, 8, 4).equals("WAVE") ? "RIFF" : "Unknown (expected WAVE)";

            // Read chunks
            while (fis.available() > 0) {
                byte[] chunkId = new byte[4];
                fis.read(chunkId);
                byte[] chunkSizeBytes = new byte[4];
                fis.read(chunkSizeBytes);
                int chunkSize = ByteBuffer.wrap(chunkSizeBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
                byte[] chunkData = new byte[chunkSize];
                fis.read(chunkData);

                if (new String(chunkId).equals("fmt ")) {
                    if (chunkData.length >= 16) {
                        channels = ByteBuffer.wrap(chunkData, 2, 2).order(ByteOrder.LITTLE_ENDIAN).getShort();
                        sampleRate = ByteBuffer.wrap(chunkData, 4, 4).order(ByteOrder.LITTLE_ENDIAN).getInt();
                        bitrate = ByteBuffer.wrap(chunkData, 8, 4).order(ByteOrder.LITTLE_ENDIAN).getInt() * 8 / 1000;
                    }
                } else if (new String(chunkId).equals("data")) {
                    dataChunk = chunkData;
                }
                // Check for DRM (heuristic)
                if (new String(chunkData).contains("DRM")) {
                    hasDrm = true;
                } else {
                    hasDrm = hasDrm == null ? false : hasDrm;
                }
            }

            System.out.println("Read .AT3 file properties:");
            printProperties();

        } catch (IOException e) {
            System.err.println("Error reading .AT3 file: " + e.getMessage());
        }
    }

    public void write(String outputPath) {
        try (FileOutputStream fos = new FileOutputStream(outputPath)) {
            // Write RIFF header
            fos.write("RIFF".getBytes());
            fos.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(fileSize.intValue() - 8).array());
            fos.write("WAVE".getBytes());
            // Write fmt chunk (simplified)
            fos.write("fmt ".getBytes());
            fos.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(16).array());
            fos.write(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort((short) 1).array()); // Format tag
            fos.write(ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN).putShort((short) (channels != null ? channels : 2)).array());
            fos.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(sampleRate != null ? sampleRate : 44100).array());
            fos.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt((bitrate != null ? bitrate : 132) * 1000 / 8).array());
            fos.write(new byte[]{0, 0, 0, 0}); // Block align, bits per sample
            // Write data chunk
            if (dataChunk != null) {
                fos.write("data".getBytes());
                fos.write(ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).putInt(dataChunk.length).array());
                fos.write(dataChunk);
            }
            System.out.println("Written .AT3 file to " + outputPath);
        } catch (IOException e) {
            System.err.println("Error writing .AT3 file: " + e.getMessage());
        }
    }

    public void printProperties() {
        System.out.println("extension: " + extension);
        System.out.println("mime_type: " + mimeType);
        System.out.println("container: " + container);
        System.out.println("codec: " + codec);
        System.out.println("channels: " + channels);
        System.out.println("sample_rate: " + sampleRate);
        System.out.println("bitrate: " + bitrate);
        System.out.println("file_size: " + fileSize);
        System.out.println("has_drm: " + hasDrm);
    }

    public static void main(String[] args) {
        AT3File at3 = new AT3File("example.at3");
        at3.read();
        at3.write("output.at3");
    }
}

Notes:

• Similar to the Python implementation, this class parses the RIFF structure but cannot fully decode ATRAC3 without proprietary codecs.
• Writing is limited to replicating the existing file structure.
• For full decoding, consider using Java bindings for FFmpeg (e.g., java-ffmpeg).

4. JavaScript Class for .AT3 File Handling

const fs = require('fs');

class AT3File {
    constructor(filepath) {
        this.filepath = filepath;
        this.properties = {
            extension: '.at3',
            mime_type: 'audio/x-oma',
            container: 'RIFF',
            codec: 'ATRAC3',
            channels: null,
            sample_rate: null,
            bitrate: null,
            file_size: null,
            has_drm: null
        };
        this.dataChunk = null;
    }

    read() {
        try {
            const buffer = fs.readFileSync(this.filepath);
            // Read RIFF header
            if (buffer.length < 12 || buffer.toString('utf8', 0, 4) !== 'RIFF') {
                throw new Error('Not a valid RIFF file');
            }

            this.properties.file_size = buffer.readUInt32LE(4) + 8;
            this.properties.container = buffer.toString('utf8', 8, 12) === 'WAVE' ? 'RIFF' : 'Unknown (expected WAVE)';

            // Read chunks
            let offset = 12;
            while (offset < this.properties.file_size) {
                const chunkId = buffer.toString('utf8', offset, offset + 4);
                const chunkSize = buffer.readUInt32LE(offset + 4);
                const chunkData = buffer.slice(offset + 8, offset + 8 + chunkSize);

                if (chunkId === 'fmt ') {
                    if (chunkData.length >= 16) {
                        this.properties.channels = chunkData.readUInt16LE(2);
                        this.properties.sample_rate = chunkData.readUInt32LE(4);
                        this.properties.bitrate = (chunkData.readUInt32LE(8) * 8) / 1000;
                    }
                } else if (chunkId === 'data') {
                    this.dataChunk = chunkData;
                }
                // Check for DRM (heuristic)
                if (chunkData.toString('utf8').includes('DRM')) {
                    this.properties.has_drm = true;
                } else {
                    this.properties.has_drm = this.properties.has_drm === null ? false : this.properties.has_drm;
                }
                offset += 8 + chunkSize;
            }

            console.log('Read .AT3 file properties:');
            this.printProperties();

        } catch (e) {
            console.error(`Error reading .AT3 file: ${e.message}`);
        }
    }

    write(outputPath) {
        try {
            const buffer = Buffer.alloc(this.properties.file_size || 44);
            // Write RIFF header
            buffer.write('RIFF', 0);
            buffer.writeUInt32LE((this.properties.file_size || 36) - 8, 4);
            buffer.write('WAVE', 8);
            // Write fmt chunk (simplified)
            buffer.write('fmt ', 12);
            buffer.writeUInt32LE(16, 16);
            buffer.writeUInt16LE(1, 20); // Format tag
            buffer.writeUInt16LE(this.properties.channels || 2, 22);
            buffer.writeUInt32LE(this.properties.sample_rate || 44100, 24);
            buffer.writeUInt32LE((this.properties.bitrate || 132) * 1000 / 8, 28);
            buffer.writeUInt16LE(0, 32); // Block align
            buffer.writeUInt16LE(0, 34); // Bits per sample
            // Write data chunk
            if (this.dataChunk) {
                buffer.write('data', 36);
                buffer.writeUInt32LE(this.dataChunk.length, 40);
                this.dataChunk.copy(buffer, 44);
            }
            fs.writeFileSync(outputPath, buffer);
            console.log(`Written .AT3 file to ${outputPath}`);
        } catch (e) {
            console.error(`Error writing .AT3 file: ${e.message}`);
        }
    }

    printProperties() {
        for (const [key, value] of Object.entries(this.properties)) {
            console.log(`${key}: ${value}`);
        }
    }
}

// Example usage
const at3 = new AT3File('example.at3');
at3.read();
at3.write('output.at3');

Notes:

• This uses Node.js fs module for file operations, as JavaScript in browsers lacks direct file system access.
• Decoding ATRAC3 requires external libraries like ffmpeg.js or Web Audio API with codec support, which is not included here.
• Writing is limited to copying existing data.

5. C Class for .AT3 File Handling

Since C does not have a class-based structure like Python, Java, or JavaScript, I provide a C implementation using a struct and functions to mimic class behavior.

#include <stdio.h>
#include <stdlib.h>
#include <string.h>

typedef struct {
    char* filepath;
    char* extension;
    char* mime_type;
    char* container;
    char* codec;
    unsigned short channels;
    unsigned int sample_rate;
    unsigned int bitrate;
    unsigned long file_size;
    int has_drm;
    unsigned char* data_chunk;
    size_t data_chunk_size;
} AT3File;

AT3File* AT3File_create(const char* filepath) {
    AT3File* at3 = (AT3File*)malloc(sizeof(AT3File));
    at3->filepath = strdup(filepath);
    at3->extension = ".at3";
    at3->mime_type = "audio/x-oma";
    at3->container = "RIFF";
    at3->codec = "ATRAC3";
    at3->channels = 0;
    at3->sample_rate = 0;
    at3->bitrate = 0;
    at3->file_size = 0;
    at3->has_drm = -1; // Unknown
    at3->data_chunk = NULL;
    at3->data_chunk_size = 0;
    return at3;
}

void AT3File_destroy(AT3File* at3) {
    free(at3->filepath);
    free(at3->data_chunk);
    free(at3);
}

void AT3File_read(AT3File* at3) {
    FILE* file = fopen(at3->filepath, "rb");
    if (!file) {
        printf("Error opening .AT3 file\n");
        return;
    }

    // Read RIFF header
    unsigned char riff_header[12];
    if (fread(riff_header, 1, 12, file) != 12 || strncmp((char*)riff_header, "RIFF", 4) != 0) {
        printf("Not a valid RIFF file\n");
        fclose(file);
        return;
    }

    at3->file_size = *(unsigned int*)(riff_header + 4) + 8;
    at3->container = strncmp((char*)(riff_header + 8), "WAVE", 4) == 0 ? "RIFF" : "Unknown (expected WAVE)";

    // Read chunks
    while (ftell(file) < at3->file_size) {
        unsigned char chunk_id[4];
        unsigned int chunk_size;
        if (fread(chunk_id, 1, 4, file) != 4 || fread(&chunk_size, 4, 1, file) != 1) {
            break;
        }
        unsigned char* chunk_data = (unsigned char*)malloc(chunk_size);
        fread(chunk_data, 1, chunk_size, file);

        if (strncmp((char*)chunk_id, "fmt ", 4) == 0 && chunk_size >= 16) {
            at3->channels = *(unsigned short*)(chunk_data + 2);
            at3->sample_rate = *(unsigned int*)(chunk_data + 4);
            at3->bitrate = (*(unsigned int*)(chunk_data + 8) * 8) / 1000;
        } else if (strncmp((char*)chunk_id, "data", 4) == 0) {
            at3->data_chunk = chunk_data;
            at3->data_chunk_size = chunk_size;
            continue; // Don't free data chunk
        }
        // Check for DRM (heuristic)
        for (unsigned int i = 0; i < chunk_size - 2; i++) {
            if (strncmp((char*)(chunk_data + i), "DRM", 3) == 0) {
                at3->has_drm = 1;
                break;
            }
        }
        if (at3->has_drm == -1) at3->has_drm = 0;
        free(chunk_data);
    }

    printf("Read .AT3 file properties:\n");
    AT3File_print_properties(at3);
    fclose(file);
}

void AT3File_write(AT3File* at3, const char* output_path) {
    FILE* file = fopen(output_path, "wb");
    if (!file) {
        printf("Error opening output file\n");
        return;
    }

    // Write RIFF header
    fwrite("RIFF", 1, 4, file);
    unsigned int file_size = at3->file_size ? at3->file_size - 8 : 36;
    fwrite(&file_size, 4, 1, file);
    fwrite("WAVE", 1, 4, file);
    // Write fmt chunk (simplified)
    fwrite("fmt ", 1, 4, file);
    unsigned int fmt_size = 16;
    fwrite(&fmt_size, 4, 1, file);
    unsigned short format_tag = 1; // Placeholder
    fwrite(&format_tag, 2, 1, file);
    unsigned short channels = at3->channels ? at3->channels : 2;
    fwrite(&channels, 2, 1, file);
    unsigned int sample_rate = at3->sample_rate ? at3->sample_rate : 44100;
    fwrite(&sample_rate, 4, 1, file);
    unsigned int bitrate = (at3->bitrate ? at3->bitrate : 132) * 1000 / 8;
    fwrite(&bitrate, 4, 1, file);
    unsigned short block_align = 0, bits_per_sample = 0;
    fwrite(&block_align, 2, 1, file);
    fwrite(&bits_per_sample, 2, 1, file);
    // Write data chunk
    if (at3->data_chunk) {
        fwrite("data", 1, 4, file);
        fwrite(&at3->data_chunk_size, 4, 1, file);
        fwrite(at3->data_chunk, 1, at3->data_chunk_size, file);
    }

    printf("Written .AT3 file to %s\n", output_path);
    fclose(file);
}

void AT3File_print_properties(AT3File* at3) {
    printf("extension: %s\n", at3->extension);
    printf("mime_type: %s\n", at3->mime_type);
    printf("container: %s\n", at3->container);
    printf("codec: %s\n", at3->codec);
    printf("channels: %u\n", at3->channels);
    printf("sample_rate: %u\n", at3->sample_rate);
    printf("bitrate: %u\n", at3->bitrate);
    printf("file_size: %lu\n", at3->file_size);
    printf("has_drm: %d\n", at3->has_drm);
}

int main() {
    AT3File* at3 = AT3File_create("example.at3");
    AT3File_read(at3);
    AT3File_write(at3, "output.at3");
    AT3File_destroy(at3);
    return 0;
}

Notes:

• This implementation parses the RIFF structure and extracts basic properties.
• Writing is limited to copying existing data, as ATRAC3 encoding is proprietary.
• For decoding, consider linking against FFmpeg libraries (e.g., libavcodec).

Limitations and Recommendations

• Proprietary Codec: ATRAC3 decoding and encoding require proprietary codecs, which are not publicly available. The above implementations parse the RIFF container but cannot fully decode or encode ATRAC3 audio without external libraries like FFmpeg.
• FFmpeg Integration: For practical use, integrate FFmpeg (via pydub in Python, java-ffmpeg in Java, ffmpeg.js in JavaScript, or libavcodec in C) to handle ATRAC3 decoding and conversion to formats like MP3 or WAV.
• DRM Handling: DRM-protected .AT3 files may not be playable without Sony's SonicStage, which is discontinued. The heuristic DRM check in the code is not definitive.
• Testing: Test with actual .AT3 files, as the format's specifics vary by device (e.g., PSP vs. MiniDisc).
• Alternative Tools: For real-world applications, use existing tools like VLC media player, FFmpeg, or MAGIX Sound Forge Pro to handle .AT3 files, as they include ATRAC3 codec support.

If you need assistance integrating FFmpeg or testing these implementations with specific .AT3 files, please provide more details!

1. Properties:

• Channels: integer
• Sample Rate: integer (Hz)
• Avg Bytes Per Sec: integer
• Block Align: integer (bytes)
• Bits Per Sample: integer
• cb Size: integer (14)
• Extra Version: integer
• Extra Lag: integer
• Extra Samples Per Frame: integer
• Extra Frame Factor: integer
• Extra Frame Bytes: integer
• Num Samples: integer
• Extra Fact: integer
• Compressed Data: bytes

1. Python class:

import struct

class AT3File:
    def __init__(self, filename):
        with open(filename, 'rb') as f:
            self.data = f.read()
        self.properties = {}
        self.parse()

    def parse(self):
        pos = 12  # Skip RIFF header
        # fmt chunk
        fmt_size = struct.unpack('<I', self.data[pos+4:pos+8])[0]
        pos += 8
        self.properties['format_tag'] = struct.unpack('<H', self.data[pos:pos+2])[0]
        pos += 2
        self.properties['channels'] = struct.unpack('<H', self.data[pos:pos+2])[0]
        pos += 2
        self.properties['sample_rate'] = struct.unpack('<I', self.data[pos:pos+4])[0]
        pos += 4
        self.properties['avg_bytes_per_sec'] = struct.unpack('<I', self.data[pos:pos+4])[0]
        pos += 4
        self.properties['block_align'] = struct.unpack('<H', self.data[pos:pos+2])[0]
        pos += 2
        self.properties['bits_per_sample'] = struct.unpack('<H', self.data[pos:pos+2])[0]
        pos += 2
        self.properties['cb_size'] = struct.unpack('<H', self.data[pos:pos+2])[0]
        pos += 2
        extra = self.data[pos:pos+14]
        self.properties['extra_version'] = struct.unpack('>I', extra[0:4])[0]
        self.properties['extra_lag'] = struct.unpack('>H', extra[4:6])[0]
        self.properties['extra_samples_per_frame'] = struct.unpack('>H', extra[6:8])[0]
        self.properties['extra_frame_factor'] = struct.unpack('>H', extra[8:10])[0]
        high = struct.unpack('>H', extra[10:12])[0]
        low = struct.unpack('>H', extra[12:14])[0]
        self.properties['extra_frame_bytes'] = (high << 16) | low
        pos += 14
        # fact chunk
        pos += 8  # fact ID and size
        self.properties['num_samples'] = struct.unpack('<I', self.data[pos:pos+4])[0]
        pos += 4
        self.properties['extra_fact'] = struct.unpack('<I', self.data[pos:pos+4])[0]
        pos += 4
        # data chunk
        data_size = struct.unpack('<I', self.data[pos+4:pos+8])[0]
        pos += 8
        self.properties['compressed_data'] = self.data[pos:pos+data_size]

    def read(self, prop):
        return self.properties[prop]

    def write(self, prop, value):
        self.properties[prop] = value

    def save(self, filename):
        extra = struct.pack('>IHHHH', self.properties['extra_version'], self.properties['extra_lag'], self.properties['extra_samples_per_frame'], self.properties['extra_frame_factor'], self.properties['extra_frame_bytes'] >> 16, self.properties['extra_frame_bytes'] & 0xFFFF)
        fmt_data = struct.pack('<HHIIHHH', 0x0270, self.properties['channels'], self.properties['sample_rate'], self.properties['avg_bytes_per_sec'], self.properties['block_align'], self.properties['bits_per_sample'], self.properties['cb_size']) + extra
        fmt_chunk = b'fmt ' + struct.pack('<I', len(fmt_data)) + fmt_data
        fact_data = struct.pack('<II', self.properties['num_samples'], self.properties['extra_fact'])
        fact_chunk = b'fact' + struct.pack('<I', len(fact_data)) + fact_data
        data_chunk = b'data' + struct.pack('<I', len(self.properties['compressed_data'])) + self.properties['compressed_data']
        wave = fmt_chunk + fact_chunk + data_chunk
        riff = b'RIFF' + struct.pack('<I', len(wave) + 4) + b'WAVE' + wave
        with open(filename, 'wb') as f:
            f.write(riff)

1. Java class:

import java.io.*;
import java.nio.*;
public class AT3File {
    private ByteBuffer bb;
    private final ByteBuffer extraBb = ByteBuffer.allocate(14).order(ByteOrder.BIG_ENDIAN);
    private final int[] properties = new int[11];
    private byte[] compressedData;
    public AT3File(String filename) throws IOException {
        byte[] data = Files.readAllBytes(Paths.get(filename));
        bb = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        parse();
    }
    private void parse() {
        bb.position(12);
        bb.position(bb.position() + 8);
        properties[0] = bb.getShort(); // format_tag
        properties[1] = bb.getShort(); // channels
        properties[2] = bb.getInt(); // sample_rate
        properties[3] = bb.getInt(); // avg_bytes_per_sec
        properties[4] = bb.getShort(); // block_align
        properties[5] = bb.getShort(); // bits_per_sample
        properties[6] = bb.getShort(); // cb_size
        byte[] extra = new byte[14];
        bb.get(extra);
        extraBb.put(extra).flip();
        properties[7] = extraBb.getInt(); // extra_version
        properties[8] = extraBb.getShort(); // extra_lag
        properties[9] = extraBb.getShort(); // extra_samples_per_frame
        properties[10] = extraBb.getShort(); // extra_frame_factor
        int high = extraBb.getShort(); 
        int low = extraBb.getShort(); 
        properties[11] = (high << 16) | (low & 0xFFFF); // extra_frame_bytes
        bb.position(bb.position() + 8);
        properties[12] = bb.getInt(); // num_samples
        properties[13] = bb.getInt(); // extra_fact
        bb.position(bb.position() + 8);
        int dataSize = bb.getInt();
        compressedData = new byte[dataSize];
        bb.get(compressedData);
    }
    public Object read(String prop) { /* map prop to properties or compressedData */ return null; }
    public void write(String prop, Object value) { /* set */ }
    public void save(String filename) throws IOException { /* rebuild and write similar to python */ }
}

1. Javascript class:

class AT3File {
    constructor(filename) {
        this.properties = {};
        this.load(filename);
    }
    async load(filename) {
        const response = await fetch(filename);
        const arrayBuffer = await response.arrayBuffer();
        this.dv = new DataView(arrayBuffer);
        this.parse();
    }
    parse() {
        let pos = 12;
        pos += 8;
        this.properties.formatTag = this.dv.getUint16(pos, true);
        pos += 2;
        this.properties.channels = this.dv.getUint16(pos, true);
        pos += 2;
        this.properties.sampleRate = this.dv.getUint32(pos, true);
        pos += 4;
        this.properties.avgBytesPerSec = this.dv.getUint32(pos, true);
        pos += 4;
        this.properties.blockAlign = this.dv.getUint16(pos, true);
        pos += 2;
        this.properties.bitsPerSample = this.dv.getUint16(pos, true);
        pos += 2;
        this.properties.cbSize = this.dv.getUint16(pos, true);
        pos += 2;
        // Extra BE
        let extraPos = pos;
        this.properties.extraVersion = this.dv.getUint32(extraPos, false);
        extraPos += 4;
        this.properties.extraLag = this.dv.getUint16(extraPos, false);
        extraPos += 2;
        this.properties.extraSamplesPerFrame = this.dv.getUint16(extraPos, false);
        extraPos += 2;
        this.properties.extraFrameFactor = this.dv.getUint16(extraPos, false);
        extraPos += 2;
        let high = this.dv.getUint16(extraPos, false);
        extraPos += 2;
        let low = this.dv.getUint16(extraPos, false);
        this.properties.extraFrameBytes = (high << 16) | low;
        pos += 14;
        pos += 8;
        this.properties.numSamples = this.dv.getUint32(pos, true);
        pos += 4;
        this.properties.extraFact = this.dv.getUint32(pos, true);
        pos += 4;
        pos += 8;
        let dataSize = this.dv.getUint32(pos - 4, true);
        this.properties.compressedData = new Uint8Array(arrayBuffer.slice(pos, pos + dataSize));
    }
    read(prop) { return this.properties[prop]; }
    write(prop, value) { this.properties[prop] = value; }
    save(filename) { /* rebuild arraybuffer and save */ }
}

1. C class (C++):

#include <fstream>
#include <vector>
#include <cstdint>
class AT3File {
private:
    std::vector<uint8_t> data;
    std::unordered_map<std::string, uint32_t> props;
    std::vector<uint8_t> compressedData;
public:
    AT3File(const std::string& filename) {
        std::ifstream f(filename, std::ios::binary);
        data.assign((std::istreambuf_iterator<char>(f)), std::istreambuf_iterator<char>());
        parse();
    }
    void parse() {
        size_t pos = 12;
        pos += 8;
        props["channels"] = *reinterpret_cast<const uint16_t*>(&data[pos]);
        pos += 2;
        // similar parsing for other properties
        // for extra, manual byte swap for BE
        // ...
    }
    uint32_t read(const std::string& prop) { return props[prop]; }
    void write(const std::string& prop, uint32_t value) { props[prop] = value; }
    void save(const std::string& filename) { /* rebuild and write */ }
};