Task 030: .AMV File Format

The AMV (Actions Media Video) file format is a proprietary video format designed for low-cost Chinese portable media players, such as MP3 and MP4 players with video playback capabilities. It is a modified version of the AVI format, optimized for low-resolution and low-frame-rate playback on devices with limited processing power. Below, I’ll address the tasks as requested, based on available information about the AMV file format, primarily sourced from reverse-engineering efforts due to the proprietary nature of the format.

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

The AMV file format is a container format derived from AVI, with specific modifications to support low-end hardware. The intrinsic properties of the AMV file format, based on available documentation, are as follows:

• File Extension: .amv or .mtv
• Container Format: Modified AVI container, with header strings "AVI" and "avih" replaced by "AMV" and "amvh".
• Video Codec: Variant of Motion JPEG with fixed quantization tables (derived from JPEG standard).
• Audio Codec: Variant of IMA ADPCM (Adaptive Differential Pulse Code Modulation).
• Audio Frame Structure: Each audio frame starts with 8 bytes:
• Origin (16 bits)
• Index (16 bits)
• Number of encoded 16-bit samples (32 bits)
• Audio Sample Rate: Typically 22050 Hz (22.05 kHz).
• Resolution: Low resolution, ranging from 96x96 to 320x240 pixels (common resolutions include 128x96, 160x120, or 208x176).
• Frame Rate: Low frame rate, typically 10, 12, or 16 frames per second (fps).
• Compression Ratio: Low, approximately 4 pixels per byte (compared to over 10 pixels/byte for MPEG-2), due to the use of fixed quantization tables.
• Header Characteristics: Contains "garbage" values in the AVI header, as many parameters are hardcoded for simplicity.
• Versions: Two known versions:
• Older version for Actions semiconductor chips.
• Newer version for ALi’s M5661 chip (sometimes called ALIAVI).
• Purpose: Optimized for low-cost, low-power portable media players with minimal processing capabilities.
• File Size: Small due to low resolution and frame rate (e.g., a 30-minute video at 128x96 pixels and 12 fps compresses to approximately 80 MB).

These properties are intrinsic to the AMV format’s design and are critical for its functionality on target devices. Note that detailed official specifications are not publicly available, and much of this information comes from reverse-engineering efforts, such as those by Dobrica Pavlinušić and contributors to FFmpeg.

Challenges and Limitations

Due to the proprietary nature of the AMV format and the lack of comprehensive public documentation, implementing full read/write functionality in multiple programming languages is challenging. The available information allows for partial decoding of the format, particularly for reading headers and extracting basic properties. However, writing AMV files requires access to specific encoding tools or libraries (e.g., FFmpeg with AMV support) that handle the proprietary Motion JPEG and IMA ADPCM variants. For the purposes of this task, the classes below will focus on reading and printing AMV file properties and provide a basic framework for writing, assuming access to a compatible encoder. Full encoding/decoding of video and audio streams is not feasible without proprietary tools or extensive reverse-engineering beyond the scope of this response.

2. Python Class for AMV File Handling

Below is a Python class that opens an AMV file, reads its header to extract properties, and provides a placeholder for writing AMV files (noting that full encoding requires external tools like FFmpeg).

import struct
import os

class AMVFile:
    def __init__(self, filepath):
        self.filepath = filepath
        self.properties = {
            "extension": ".amv",
            "container": "Modified AVI",
            "video_codec": "Motion JPEG (fixed quantization)",
            "audio_codec": "IMA ADPCM",
            "audio_sample_rate": 22050,
            "resolution": None,  # To be read from file
            "frame_rate": None,  # To be read from file
            "version": "Unknown",
            "file_size": os.path.getsize(filepath) if os.path.exists(filepath) else 0
        }

    def read_properties(self):
        """Read AMV file header and extract properties."""
        try:
            with open(self.filepath, 'rb') as f:
                # Read RIFF header
                riff = f.read(4)
                if riff != b'RIFF':
                    raise ValueError("Not a valid AMV file: Missing RIFF header")
                
                # Skip file size (4 bytes)
                f.seek(4, 1)
                
                # Check AMV identifier
                amv_id = f.read(4)
                if amv_id != b'AMV ':
                    raise ValueError("Not a valid AMV file: Missing AMV identifier")
                
                # Read header chunk
                header = f.read(4)
                if header != b'amvh':
                    raise ValueError("Not a valid AMV file: Missing amvh header")
                
                # Read header size
                header_size = struct.unpack('<I', f.read(4))[0]
                
                # Read width and height
                width = struct.unpack('<I', f.read(4))[0]
                height = struct.unpack('<I', f.read(4))[0]
                self.properties["resolution"] = f"{width}x{height}"
                
                # Read frame rate (assuming stored as a 4-byte integer, frames per second)
                frame_rate = struct.unpack('<I', f.read(4))[0]
                self.properties["frame_rate"] = frame_rate
                
                # Attempt to determine version (heuristic based on resolution)
                if width <= 208 and height <= 176:
                    self.properties["version"] = "Actions Chip"
                else:
                    self.properties["version"] = "ALIAVI (M5661 Chip)"
                
                return True
        except Exception as e:
            print(f"Error reading AMV file: {e}")
            return False

    def write_properties(self, output_filepath):
        """Placeholder for writing AMV file (requires external encoder)."""
        print(f"Writing AMV file to {output_filepath} is not fully supported.")
        print("Use FFmpeg with AMV support for encoding. Example command:")
        print(f"ffmpeg -i input.mp4 -c:v mjpeg -q:v 3 -c:a adpcm_ima -ar 22050 -s 128x96 -r 12 {output_filepath}")
        return False

    def print_properties(self):
        """Print all AMV file properties to console."""
        print("AMV File Properties:")
        for key, value in self.properties.items():
            print(f"{key}: {value}")

# Example usage
if __name__ == "__main__":
    amv = AMVFile("sample.amv")
    if amv.read_properties():
        amv.print_properties()
    # amv.write_properties("output.amv")  # Placeholder for writing

Notes:

• The class reads the AMV file header to extract resolution, frame rate, and heuristically determines the version based on resolution.
• Writing AMV files is not implemented, as it requires proprietary encoding tools or FFmpeg with AMV support. A placeholder suggests using FFmpeg.
• Error handling ensures the file is a valid AMV file by checking for "RIFF", "AMV ", and "amvh" signatures.
• The audio sample rate is hardcoded as 22050 Hz based on documentation, as it’s not always stored in the header.

3. Java Class for AMV File Handling

Below is a Java class with similar functionality to the Python class.

import java.io.RandomAccessFile;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.HashMap;
import java.util.Map;

public class AMVFile {
    private String filepath;
    private Map<String, Object> properties;

    public AMVFile(String filepath) {
        this.filepath = filepath;
        this.properties = new HashMap<>();
        this.properties.put("extension", ".amv");
        this.properties.put("container", "Modified AVI");
        this.properties.put("video_codec", "Motion JPEG (fixed quantization)");
        this.properties.put("audio_codec", "IMA ADPCM");
        this.properties.put("audio_sample_rate", 22050);
        this.properties.put("resolution", null);
        this.properties.put("frame_rate", null);
        this.properties.put("version", "Unknown");
        this.properties.put("file_size", new java.io.File(filepath).length());
    }

    public boolean readProperties() {
        try (RandomAccessFile file = new RandomAccessFile(filepath, "r")) {
            // Read RIFF header
            byte[] riff = new byte[4];
            file.read(riff);
            if (!new String(riff).equals("RIFF")) {
                System.err.println("Not a valid AMV file: Missing RIFF header");
                return false;
            }

            // Skip file size
            file.skipBytes(4);

            // Check AMV identifier
            byte[] amvId = new byte[4];
            file.read(amvId);
            if (!new String(amvId).equals("AMV ")) {
                System.err.println("Not a valid AMV file: Missing AMV identifier");
                return false;
            }

            // Read header chunk
            byte[] header = new byte[4];
            file.read(header);
            if (!new String(header).equals("amvh")) {
                System.err.println("Not a valid AMV file: Missing amvh header");
                return false;
            }

            // Read header size
            byte[] headerSizeBytes = new byte[4];
            file.read(headerSizeBytes);
            int headerSize = ByteBuffer.wrap(headerSizeBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();

            // Read width and height
            byte[] widthBytes = new byte[4];
            file.read(widthBytes);
            int width = ByteBuffer.wrap(widthBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
            byte[] heightBytes = new byte[4];
            file.read(heightBytes);
            int height = ByteBuffer.wrap(heightBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
            properties.put("resolution", width + "x" + height);

            // Read frame rate
            byte[] frameRateBytes = new byte[4];
            file.read(frameRateBytes);
            int frameRate = ByteBuffer.wrap(frameRateBytes).order(ByteOrder.LITTLE_ENDIAN).getInt();
            properties.put("frame_rate", frameRate);

            // Determine version
            if (width <= 208 && height <= 176) {
                properties.put("version", "Actions Chip");
            } else {
                properties.put("version", "ALIAVI (M5661 Chip)");
            }

            return true;
        } catch (Exception e) {
            System.err.println("Error reading AMV file: " + e.getMessage());
            return false;
        }
    }

    public boolean writeProperties(String outputFilepath) {
        System.out.println("Writing AMV file to " + outputFilepath + " is not fully supported.");
        System.out.println("Use FFmpeg with AMV support for encoding. Example command:");
        System.out.println("ffmpeg -i input.mp4 -c:v mjpeg -q:v 3 -c:a adpcm_ima -ar 22050 -s 128x96 -r 12 " + outputFilepath);
        return false;
    }

    public void printProperties() {
        System.out.println("AMV File Properties:");
        for (Map.Entry<String, Object> entry : properties.entrySet()) {
            System.out.println(entry.getKey() + ": " + entry.getValue());
        }
    }

    public static void main(String[] args) {
        AMVFile amv = new AMVFile("sample.amv");
        if (amv.readProperties()) {
            amv.printProperties();
        }
        // amv.writeProperties("output.amv"); // Placeholder for writing
    }
}

Notes:

• Uses RandomAccessFile for binary file reading.
• Similar structure to the Python class, with header validation and property extraction.
• Writing is a placeholder, as Java lacks native AMV encoding support.
• Byte order is explicitly set to little-endian, matching AVI/AMV conventions.

4. JavaScript Class for AMV File Handling

Below is a JavaScript class designed for Node.js, using the fs module to read AMV files.

const fs = require('fs');

class AMVFile {
    constructor(filepath) {
        this.filepath = filepath;
        this.properties = {
            extension: '.amv',
            container: 'Modified AVI',
            video_codec: 'Motion JPEG (fixed quantization)',
            audio_codec: 'IMA ADPCM',
            audio_sample_rate: 22050,
            resolution: null,
            frame_rate: null,
            version: 'Unknown',
            file_size: fs.existsSync(filepath) ? fs.statSync(filepath).size : 0
        };
    }

    readProperties() {
        try {
            const buffer = fs.readFileSync(this.filepath);
            let offset = 0;

            // Check RIFF header
            if (buffer.toString('ascii', 0, 4) !== 'RIFF') {
                throw new Error('Not a valid AMV file: Missing RIFF header');
            }
            offset += 4;

            // Skip file size
            offset += 4;

            // Check AMV identifier
            if (buffer.toString('ascii', offset, offset + 4) !== 'AMV ') {
                throw new Error('Not a valid AMV file: Missing AMV identifier');
            }
            offset += 4;

            // Check header chunk
            if (buffer.toString('ascii', offset, offset + 4) !== 'amvh') {
                throw new Error('Not a valid AMV file: Missing amvh header');
            }
            offset += 4;

            // Read header size
            const headerSize = buffer.readUInt32LE(offset);
            offset += 4;

            // Read width and height
            const width = buffer.readUInt32LE(offset);
            offset += 4;
            const height = buffer.readUInt32LE(offset);
            offset += 4;
            this.properties.resolution = `${width}x${height}`;

            // Read frame rate
            const frameRate = buffer.readUInt32LE(offset);
            this.properties.frame_rate = frameRate;

            // Determine version
            this.properties.version = (width <= 208 && height <= 176) ? 'Actions Chip' : 'ALIAVI (M5661 Chip)';

            return true;
        } catch (error) {
            console.error(`Error reading AMV file: ${error.message}`);
            return false;
        }
    }

    writeProperties(outputFilepath) {
        console.log(`Writing AMV file to ${outputFilepath} is not fully supported.`);
        console.log('Use FFmpeg with AMV support for encoding. Example command:');
        console.log(`ffmpeg -i input.mp4 -c:v mjpeg -q:v 3 -c:a adpcm_ima -ar 22050 -s 128x96 -r 12 ${outputFilepath}`);
        return false;
    }

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

// Example usage
const amv = new AMVFile('sample.amv');
if (amv.readProperties()) {
    amv.printProperties();
}
// amv.writeProperties('output.amv'); // Placeholder for writing

Notes:

• Designed for Node.js, using synchronous file reading for simplicity.
• Reads binary data and extracts properties similarly to Python and Java classes.
• Writing is a placeholder, as JavaScript lacks native AMV encoding support.

5. C Class for AMV File Handling

In C, there is no direct concept of a "class," so we use a struct and functions to achieve similar functionality.

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

typedef struct {
    const char* filepath;
    char extension[5];
    char container[20];
    char video_codec[30];
    char audio_codec[15];
    int32_t audio_sample_rate;
    char* resolution;
    int32_t frame_rate;
    char version[20];
    int64_t file_size;
} AMVFile;

void initAMVFile(AMVFile* amv, const char* filepath) {
    amv->filepath = filepath;
    strcpy(amv->extension, ".amv");
    strcpy(amv->container, "Modified AVI");
    strcpy(amv->video_codec, "Motion JPEG (fixed quantization)");
    strcpy(amv->audio_codec, "IMA ADPCM");
    amv->audio_sample_rate = 22050;
    amv->resolution = NULL;
    amv->frame_rate = 0;
    strcpy(amv->version, "Unknown");

    FILE* file = fopen(filepath, "rb");
    if (file) {
        fseek(file, 0, SEEK_END);
        amv->file_size = ftell(file);
        fclose(file);
    } else {
        amv->file_size = 0;
    }
}

void freeAMVFile(AMVFile* amv) {
    if (amv->resolution) {
        free(amv->resolution);
        amv->resolution = NULL;
    }
}

int readProperties(AMVFile* amv) {
    FILE* file = fopen(amv->filepath, "rb");
    if (!file) {
        printf("Error: Cannot open file %s\n", amv->filepath);
        return 0;
    }

    char buffer[5];
    // Check RIFF header
    if (fread(buffer, 1, 4, file) != 4 || strncmp(buffer, "RIFF", 4) != 0) {
        printf("Not a valid AMV file: Missing RIFF header\n");
        fclose(file);
        return 0;
    }

    // Skip file size
    fseek(file, 4, SEEK_CUR);

    // Check AMV identifier
    if (fread(buffer, 1, 4, file) != 4 || strncmp(buffer, "AMV ", 4) != 0) {
        printf("Not a valid AMV file: Missing AMV identifier\n");
        fclose(file);
        return 0;
    }

    // Check header chunk
    if (fread(buffer, 1, 4, file) != 4 || strncmp(buffer, "amvh", 4) != 0) {
        printf("Not a valid AMV file: Missing amvh header\n");
        fclose(file);
        return 0;
    }

    // Read header size
    uint32_t header_size;
    fread(&header_size, sizeof(uint32_t), 1, file);

    // Read width and height
    uint32_t width, height;
    fread(&width, sizeof(uint32_t), 1, file);
    fread(&height, sizeof(uint32_t), 1, file);
    amv->resolution = (char*)malloc(20);
    snprintf(amv->resolution, 20, "%ux%u", width, height);

    // Read frame rate
    fread(&amv->frame_rate, sizeof(uint32_t), 1, file);

    // Determine version
    if (width <= 208 && height <= 176) {
        strcpy(amv->version, "Actions Chip");
    } else {
        strcpy(amv->version, "ALIAVI (M5661 Chip)");
    }

    fclose(file);
    return 1;
}

int writeProperties(AMVFile* amv, const char* outputFilepath) {
    printf("Writing AMV file to %s is not fully supported.\n", outputFilepath);
    printf("Use FFmpeg with AMV support for encoding. Example command:\n");
    printf("ffmpeg -i input.mp4 -c:v mjpeg -q:v 3 -c:a adpcm_ima -ar 22050 -s 128x96 -r 12 %s\n", outputFilepath);
    return 0;
}

void printProperties(AMVFile* amv) {
    printf("AMV File Properties:\n");
    printf("extension: %s\n", amv->extension);
    printf("container: %s\n", amv->container);
    printf("video_codec: %s\n", amv->video_codec);
    printf("audio_codec: %s\n", amv->audio_codec);
    printf("audio_sample_rate: %d\n", amv->audio_sample_rate);
    printf("resolution: %s\n", amv->resolution ? amv->resolution : "Unknown");
    printf("frame_rate: %d\n", amv->frame_rate);
    printf("version: %s\n", amv->version);
    printf("file_size: %lld\n", amv->file_size);
}

int main() {
    AMVFile amv;
    initAMVFile(&amv, "sample.amv");
    if (readProperties(&amv)) {
        printProperties(&amv);
    }
    // writeProperties(&amv, "output.amv"); // Placeholder for writing
    freeAMVFile(&amv);
    return 0;
}

Notes:

• Uses standard C file I/O to read binary data.
• Dynamically allocates memory for the resolution string to avoid fixed-size buffers.
• Includes memory management with freeAMVFile to prevent leaks.
• Writing is a placeholder, as C lacks native AMV encoding support.

General Notes and Limitations

• Reading Limitations: The classes assume a simplified AMV header structure based on available documentation. Actual AMV files may vary slightly (e.g., different header layouts for Actions vs. ALIAVI versions), and some properties (like frame rate) may not always be stored in the expected location. Testing with real AMV files is recommended.
• Writing Limitations: Writing AMV files requires proprietary encoding tools or FFmpeg with AMV support, as the specific Motion JPEG and IMA ADPCM variants are not easily implemented from scratch. The classes provide a placeholder with an FFmpeg command for reference.
• Testing: The code assumes the existence of a sample.amv file. Replace with an actual AMV file for testing. Sample AMV files can be found at resources like http://www.mympxplayer.org/sample-videos-dc7.html or http://samples.mplayerhq.hu/amv/.
• Dependencies: The Python, Java, and JavaScript classes have minimal dependencies (standard libraries or Node.js fs). The C implementation is self-contained. For actual encoding/decoding, FFmpeg or similar tools are required.
• Sources: The implementation is based on information from Wikipedia, MultimediaWiki, and other sources that document the AMV format’s structure.

If you have access to specific AMV files or need further assistance with testing or extending the functionality (e.g., integrating FFmpeg programmatically), please let me know!

AMV File Format Specifications

The .AMV file format is a proprietary video container format designed for low-cost portable media players, primarily Chinese S1 MP3/MP4 players. It is a modified variant of the AVI format, optimized for low-resolution video and low-processor power devices. The container is based on the RIFF (Resource Interchange File Format) structure, with specific modifications:

• The file type FourCC is "AMV " instead of "AVI ".
• The main header chunk is "amvh" instead of "avih".
• Many fields in the headers are hardcoded, ignored, or set to "garbage" values because parameters like frame rate and audio sample rate are often fixed in hardware (e.g., frame rate 10-16 fps, audio 22050 Hz mono).
• Video codec: A variant of Motion JPEG (M-JPEG) with fixed quantization tables from the JPEG standard (no variable tables). The codec FourCC is "AMV ".
• Audio codec: A variant of IMA ADPCM (format tag 0x11), where each audio frame starts with 8 bytes: origin (16 bits), index (16 bits), and number of encoded 16-bit samples (32 bits). Audio is always mono at 22050 Hz.
• Streams: Always 2 streams (video as stream 0, audio as stream 1).
• Resolution: Typically low (96x96 to 208x176 pixels), but not enforced in the header.
• Frame rate: Typically 10, 12, or 16 fps, derived from microseconds per frame in the header.
• Data chunks: Video frames are tagged as "00dc" (compressed video), audio as "01wb".
• Index: Ends with an "idx1" chunk for frame indexing.
• No support for variable bitrates or advanced features; designed for simple playback.

The format has two variants: an older one for Actions semiconductor chips and a newer one for ALi M5661 chips (sometimes called ALIAVI), but the structure is similar.

1. List of All Properties Intrinsic to the File Format

The following are the key properties (fields) intrinsic to .AMV files, based on the RIFF structure and headers. These are the fields that define the file's metadata and are always present in a valid .AMV file. They are grouped by chunk for clarity. All fields are little-endian.

RIFF Header (12 bytes):

• Signature: "RIFF" (4 bytes, fixed)
• File size minus 8 bytes (u32)
• File type: "AMV " (4 bytes, fixed)

hdrl LIST (variable size):

• Signature: "LIST" (4 bytes, fixed)
• List size (u32)
• List type: "hdrl" (4 bytes, fixed)

amvh Chunk (Main Header, 68 bytes total: 8-byte chunk header + 56 bytes data):

• Chunk ID: "amvh" (4 bytes, fixed)
• Chunk size: 56 (u32, fixed)
• Microseconds per frame (u32; e.g., 62500 for 16 fps; often the only reliable FPS source)
• Max bytes per second (u32; often 0 or garbage)
• Padding granularity (u32; often 1)
• Flags (u32; typically 0x10 for AVIF_HASINDEX)
• Total frames (u32)
• Initial frames (u32; always 0)
• Number of streams (u32; always 2)
• Suggested buffer size (u32; often 0 or garbage)
• Width (u32; video width in pixels)
• Height (u32; video height in pixels)
• Reserved [4] (u32 x4; often 0 or garbage)

strl LIST for Video (Stream 0, variable size):

• Signature: "LIST" (4 bytes, fixed)
• List size (u32)
• List type: "strl" (4 bytes, fixed)

strh Chunk for Video (64 bytes total: 8-byte chunk header + 56 bytes data):

• Chunk ID: "strh" (4 bytes, fixed)
• Chunk size: 56 (u32, fixed)
• Stream type: "vids" (4 bytes, fixed)
• Handler (FourCC): "AMV " (4 bytes, fixed for AMV video codec)
• Flags (u32; often 0)
• Priority (u16; often 0)
• Language (u16; often 0)
• Initial frames (u32; 0)
• Scale (u32; 1)
• Rate (u32; 1, but actual rate derived from main header)
• Start (u32; 0)
• Length (u32; total video frames, matches main total frames)
• Suggested buffer size (u32; often 0)
• Quality (u32; often -1)
• Sample size (u32; 0 for variable size frames)
• Frame rectangle left (u16; 0)
• Frame rectangle top (u16; 0)
• Frame rectangle right (u16; width)
• Frame rectangle bottom (u16; height)

strf Chunk for Video (44 bytes total: 8-byte chunk header + 36 bytes data; BITMAPINFOHEADER without full 40 bytes in some implementations, but typically 40):

• Chunk ID: "strf" (4 bytes, fixed)
• Chunk size: 40 (u32; standard for BITMAPINFOHEADER)
• Structure size (u32; 40)
• Width (u32)
• Height (u32)
• Planes (u16; 1)
• Bit count (u16; 24 for YUV-based compression)
• Compression (FourCC): "AMV " (4 bytes, fixed)
• Image size (u32; width * height * 3 or 0)
• X pixels per meter (u32; 0)
• Y pixels per meter (u32; 0)
• Colors used (u32; 0)
• Colors important (u32; 0)

strl LIST for Audio (Stream 1, variable size):

• Signature: "LIST" (4 bytes, fixed)
• List size (u32)
• List type: "strl" (4 bytes, fixed)

strh Chunk for Audio (56 bytes total: 8-byte chunk header + 48 bytes data):

• Chunk ID: "strh" (4 bytes, fixed)
• Chunk size: 48 (u32)
• Stream type: "auds" (4 bytes, fixed)
• Handler (FourCC): 0x00000000 (4 bytes, fixed)
• Flags (u32; often 0)
• Priority (u16; often 0)
• Language (u16; often 0)
• Initial frames (u32; 0)
• Scale (u32; 1)
• Rate (u32; sample rate, fixed 22050)
• Start (u32; 0)
• Length (u32; total audio samples)
• Suggested buffer size (u32; often 0)
• Quality (u32; often -1)
• Sample size (u32; 2 for 16-bit)
• Frame rectangle (u32; 0, unused for audio)

strf Chunk for Audio (28 bytes total: 8-byte chunk header + 20 bytes data; WAVEFORMATEX + extra):

• Chunk ID: "strf" (4 bytes, fixed)
• Chunk size: 20 (u32)
• Format tag (u16; 0x11 for IMA ADPCM variant)
• Channels (u16; 1, mono fixed)
• Samples per second (u32; 22050 fixed)
• Average bytes per second (u32; calculated)
• Block align (u16; typically 32 or calculated)
• Bits per sample (u16; 4 for ADPCM)
• Extra size (u16; 2)
• Samples per block (u16; typically 505 for AMV ADPCM)

movi LIST (variable size, contains data frames):

• Signature: "LIST" (4 bytes, fixed)
• List size (u32)
• List type: "movi" (4 bytes, fixed)
• Data chunks: "00dc" + size + video frame data, "01wb" + size + audio frame data (audio frames have 8-byte prefix)

idx1 Chunk (variable size, at end):

• Chunk ID: "idx1" (4 bytes, fixed)
• Chunk size (u32)
• Index entries (16 bytes each): FourCC ("00dc" or "01wb"), flags (u32), offset (u32), size (u32)

These properties are "intrinsic" as they define the file's structure and are required for parsing/writing. Data frames themselves are not properties but payload.

2. Python Class for .AMV Files

import struct
import os

class AMVFile:
    def __init__(self, filepath=None):
        self.properties = {}
        self.data_chunks = []  # List of (tag, data) for movi chunks
        self.idx1 = []  # List of index entries: (fourcc, flags, offset, size)
        if filepath:
            self.load(filepath)

    def load(self, filepath):
        with open(filepath, 'rb') as f:
            data = f.read()
        pos = 0
        # RIFF Header
        sig, file_size, file_type = struct.unpack('<4sI4s', data[pos:pos+12])
        pos += 12
        self.properties['riff_signature'] = sig.decode()
        self.properties['file_size'] = file_size
        self.properties['file_type'] = file_type.decode()
        # hdrl LIST
        list_sig, list_size, list_type = struct.unpack('<4sI4s', data[pos:pos+12])
        pos += 12
        self.properties['hdrl_list_sig'] = list_sig.decode()
        self.properties['hdrl_list_size'] = list_size
        self.properties['hdrl_list_type'] = list_type.decode()
        # amvh Chunk
        chunk_id, chunk_size = struct.unpack('<4sI', data[pos:pos+8])
        pos += 8
        self.properties['amvh_id'] = chunk_id.decode()
        self.properties['amvh_size'] = chunk_size
        (self.properties['microsec_per_frame'], self.properties['max_bytes_per_sec'], self.properties['padding_granularity'], self.properties['flags'], self.properties['total_frames'], self.properties['initial_frames'], self.properties['streams'], self.properties['suggested_buffer_size'], self.properties['width'], self.properties['height'], r1, r2, r3, r4) = struct.unpack('<14I', data[pos:pos+56])
        self.properties['reserved'] = [r1, r2, r3, r4]
        pos += 56
        # Video strl LIST
        list_sig, list_size, list_type = struct.unpack('<4sI4s', data[pos:pos+12])
        pos += 12
        self.properties['video_strl_sig'] = list_sig.decode()
        self.properties['video_strl_size'] = list_size
        self.properties['video_strl_type'] = list_type.decode()
        # Video strh
        chunk_id, chunk_size = struct.unpack('<4sI', data[pos:pos+8])
        pos += 8
        self.properties['video_strh_id'] = chunk_id.decode()
        self.properties['video_strh_size'] = chunk_size
        (v_type, v_handler, v_flags, v_priority, v_language, v_initial_frames, v_scale, v_rate, v_start, v_length, v_suggested_buffer, v_quality, v_sample_size, v_left, v_top, v_right, v_bottom) = struct.unpack('<4s4sIHHIIIIIIIHHHH', data[pos:pos+56])
        self.properties['video_type'] = v_type.decode()
        self.properties['video_handler'] = v_handler.decode()
        self.properties['video_flags'] = v_flags
        self.properties['video_priority'] = v_priority
        self.properties['video_language'] = v_language
        self.properties['video_initial_frames'] = v_initial_frames
        self.properties['video_scale'] = v_scale
        self.properties['video_rate'] = v_rate
        self.properties['video_start'] = v_start
        self.properties['video_length'] = v_length
        self.properties['video_suggested_buffer'] = v_suggested_buffer
        self.properties['video_quality'] = v_quality
        self.properties['video_sample_size'] = v_sample_size
        self.properties['video_rect'] = [v_left, v_top, v_right, v_bottom]
        pos += 56
        # Video strf
        chunk_id, chunk_size = struct.unpack('<4sI', data[pos:pos+8])
        pos += 8
        self.properties['video_strf_id'] = chunk_id.decode()
        self.properties['video_strf_size'] = chunk_size
        (strf_size, w, h, planes, bit_count, compression, image_size, x_ppm, y_ppm, clr_used, clr_important) = struct.unpack('<IiiHH4sIiiII', data[pos:pos+40])
        self.properties['video_strf_structure_size'] = strf_size
        self.properties['video_width'] = w
        self.properties['video_height'] = h
        self.properties['video_planes'] = planes
        self.properties['video_bit_count'] = bit_count
        self.properties['video_compression'] = compression.decode()
        self.properties['video_image_size'] = image_size
        self.properties['video_x_ppm'] = x_ppm
        self.properties['video_y_ppm'] = y_ppm
        self.properties['video_clr_used'] = clr_used
        self.properties['video_clr_important'] = clr_important
        pos += 40
        # Audio strl, strh, strf similar unpacking...
        # (Omitted for brevity, similar to video but using audio fields)
        # movi LIST and data chunks
        # (Parse 'movi' list, read chunks until idx1)
        # idx1 chunk
        # (Parse index entries)

    def write(self, filepath):
        with open(filepath, 'wb') as f:
            # Pack and write all properties in reverse of load
            # (Omitted for brevity, use struct.pack to mirror the unpack)
            pass  # Implement packing logic for all properties and data

    def get_property(self, key):
        return self.properties.get(key)

    def set_property(self, key, value):
        if key in self.properties:
            self.properties[key] = value

(Note: Full unpacking for audio and data/index chunks omitted for brevity; implement similar struct.unpack for audio strl/strh/strf, then loop for movi chunks, and idx1 entries. Write method would pack in order and update sizes.)

3. Java Class for .AMV Files

import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.HashMap;
import java.util.Map;

public class AMVFile {
    private Map<String, Object> properties = new HashMap<>();
    private byte[] data; // Full file data for parsing

    public AMVFile(String filepath) throws Exception {
        if (filepath != null) {
            load(filepath);
        }
    }

    public void load(String filepath) throws Exception {
        File file = new File(filepath);
        data = new byte[(int) file.length()];
        try (FileInputStream fis = new FileInputStream(file)) {
            fis.read(data);
        }
        ByteBuffer bb = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN);
        int pos = 0;
        // RIFF Header
        byte[] sig = new byte[4];
        bb.position(pos);
        bb.get(sig);
        properties.put("riff_signature", new String(sig));
        properties.put("file_size", bb.getInt());
        bb.get(sig);
        properties.put("file_type", new String(sig));
        pos += 12;
        // hdrl LIST
        bb.position(pos);
        bb.get(sig);
        properties.put("hdrl_list_sig", new String(sig));
        properties.put("hdrl_list_size", bb.getInt());
        bb.get(sig);
        properties.put("hdrl_list_type", new String(sig));
        pos += 12;
        // amvh Chunk
        bb.position(pos);
        bb.get(sig);
        properties.put("amvh_id", new String(sig));
        properties.put("amvh_size", bb.getInt());
        pos += 8;
        properties.put("microsec_per_frame", bb.getInt());
        properties.put("max_bytes_per_sec", bb.getInt());
        properties.put("padding_granularity", bb.getInt());
        properties.put("flags", bb.getInt());
        properties.put("total_frames", bb.getInt());
        properties.put("initial_frames", bb.getInt());
        properties.put("streams", bb.getInt());
        properties.put("suggested_buffer_size", bb.getInt());
        properties.put("width", bb.getInt());
        properties.put("height", bb.getInt());
        int[] reserved = new int[4];
        for (int i = 0; i < 4; i++) reserved[i] = bb.getInt();
        properties.put("reserved", reserved);
        pos += 56;
        // Similar parsing for video/audio strl, strh, strf, movi, idx1...
        // (Omitted for brevity, use bb.get* methods)

    }

    public void write(String filepath) throws Exception {
        ByteBuffer bb = ByteBuffer.allocate(data.length).order(ByteOrder.LITTLE_ENDIAN);
        // Pack all properties in order
        // (Omitted for brevity, mirror load with bb.put*)
        try (FileOutputStream fos = new FileOutputStream(filepath)) {
            fos.write(bb.array());
        }
    }

    public Object getProperty(String key) {
        return properties.get(key);
    }

    public void setProperty(String key, Object value) {
        properties.put(key, value);
    }
}

(Note: Full parsing for all chunks omitted; implement additional bb.get for each field.)

4. JavaScript Class for .AMV Files

const fs = require('fs');

class AMVFile {
    constructor(filepath = null) {
        this.properties = {};
        this.dataChunks = [];
        this.idx1 = [];
        if (filepath) {
            this.load(filepath);
        }
    }

    load(filepath) {
        const data = fs.readFileSync(filepath);
        let pos = 0;
        // RIFF Header
        this.properties.riff_signature = data.toString('utf8', pos, pos+4);
        pos += 4;
        this.properties.file_size = data.readUInt32LE(pos);
        pos += 4;
        this.properties.file_type = data.toString('utf8', pos, pos+4);
        pos += 4;
        // hdrl LIST
        this.properties.hdrl_list_sig = data.toString('utf8', pos, pos+4);
        pos += 4;
        this.properties.hdrl_list_size = data.readUInt32LE(pos);
        pos += 4;
        this.properties.hdrl_list_type = data.toString('utf8', pos, pos+4);
        pos += 4;
        // amvh Chunk
        this.properties.amvh_id = data.toString('utf8', pos, pos+4);
        pos += 4;
        this.properties.amvh_size = data.readUInt32LE(pos);
        pos += 4;
        this.properties.microsec_per_frame = data.readUInt32LE(pos);
        pos += 4;
        this.properties.max_bytes_per_sec = data.readUInt32LE(pos);
        pos += 4;
        // Continue for all fields...
        // (Omitted for brevity, use data.read*LE for each)

    }

    write(filepath) {
        const buffer = Buffer.alloc( /* calculate size */ );
        let pos = 0;
        buffer.write(this.properties.riff_signature, pos, 4, 'utf8');
        pos += 4;
        buffer.writeUInt32LE(this.properties.file_size, pos);
        pos += 4;
        // Continue packing...
        // (Omitted for brevity)
        fs.writeFileSync(filepath, buffer);
    }

    getProperty(key) {
        return this.properties[key];
    }

    setProperty(key, value) {
        this.properties[key] = value;
    }
}

(Note: Requires Node.js. Full read/write for all fields omitted; use Buffer methods.)

5. C++ Class for .AMV Files

#include <fstream>
#include <iostream>
#include <vector>
#include <map>
#include <cstring>

struct AMVProperties {
    std::string riff_signature;
    uint32_t file_size;
    std::string file_type;
    // Add all other properties as members...
    uint32_t width;
    uint32_t height;
    // etc.
};

class AMVFile {
private:
    AMVProperties properties;
    std::vector<char> rawData;

public:
    AMVFile(const std::string& filepath = "") {
        if (!filepath.empty()) {
            load(filepath);
        }
    }

    void load(const std::string& filepath) {
        std::ifstream file(filepath, std::ios::binary | std::ios::ate);
        std::streamsize size = file.tellg();
        file.seekg(0, std::ios::beg);
        rawData.resize(size);
        file.read(rawData.data(), size);
        const char* data = rawData.data();
        int pos = 0;
        char sig[5] = {0};
        memcpy(sig, data + pos, 4);
        properties.riff_signature = sig;
        pos += 4;
        memcpy(&properties.file_size, data + pos, 4);
        pos += 4;
        memcpy(sig, data + pos, 4);
        properties.file_type = sig;
        pos += 4;
        // Continue memcpy for all fields...
        // (Omitted for brevity, use memcpy for each u32/u16/string)

    }

    void write(const std::string& filepath) {
        std::ofstream file(filepath, std::ios::binary);
        char buffer[1024]; // Temp buffer
        int pos = 0;
        memcpy(buffer + pos, properties.riff_signature.c_str(), 4);
        pos += 4;
        memcpy(buffer + pos, &properties.file_size, 4);
        pos += 4;
        // Continue for all, write in chunks if needed
        file.write(buffer, pos);
    }

    std::string getProperty(const std::string& key) {
        // Implement getter based on struct members
        if (key == "width") return std::to_string(properties.width);
        // etc.
        return "";
    }

    void setProperty(const std::string& key, const std::string& value) {
        // Implement setter
        if (key == "width") properties.width = std::stoul(value);
        // etc.
    }
};

(Note: Full struct with all properties and memcpy for each omitted. Use little-endian assumption. For read/write, handle endian if needed.)