Task 704: .SWF File Format
Task 704: .SWF File Format
SWF File Format Specifications
The SWF (Shockwave Flash) file format is a binary format originally developed by Macromedia and later maintained by Adobe for delivering vector graphics, animations, multimedia, and interactive content. It supports compression (ZLIB or LZMA) and consists of a header followed by a series of tags that define content like shapes, sounds, and actions. The full specification is detailed in the SWF File Format Specification Version 19.
1. List of Properties Intrinsic to the File Format
Based on the file header structure, the following are the key properties intrinsic to the SWF file format. These are present in every SWF file and define its basic structure and metadata. They are extracted from the uncompressed or decompressed header data.
- Signature: 3 bytes (UI8 each). The first byte is 'F' (uncompressed), 'C' (ZLIB compressed, SWF 6+), or 'Z' (LZMA compressed, SWF 13+). The next two are always 'W' and 'S'. Indicates the compression type and validates the file as SWF.
- Version: 1 byte (UI8). The SWF version number (e.g., 10 for SWF 10). Determines supported features and tag formats.
- FileLength: 4 bytes (UI32). The total length of the file in bytes (uncompressed size if the file is compressed).
- FrameSize: Variable size (RECT structure, bit-packed, typically 5-15 bytes). Defines the movie's bounding box in twips (1/20th of a pixel). Includes:
- Nbits (5 bits, UB[5]): Number of bits used for each coordinate (0-31).
- Xmin (Nbits bits, SB[Nbits]): Always 0.
- Xmax (Nbits bits, SB[Nbits]): Width in twips.
- Ymin (Nbits bits, SB[Nbits]): Always 0.
- Ymax (Nbits bits, SB[Nbits]): Height in twips.
Padded to byte alignment. - FrameRate: 2 bytes (UI16). Frame rate in 8.8 fixed-point format (lower byte is fractional part, upper byte is integer part). Represents frames per second (e.g., 0x1800 is 24.0 fps).
- FrameCount: 2 bytes (UI16). Total number of frames in the movie.
Note: If compressed ('C' or 'Z' signature), the data after the first 8 bytes (Signature + Version + FileLength) must be decompressed to access FrameSize, FrameRate, FrameCount, and subsequent tags.
2. Two Direct Download Links for .SWF Files
Here are two direct download links to sample .SWF files:
- https://filesamples.com/samples/video/swf/sample_1280x720_surfing_with_audio.swf
- https://filesamples.com/samples/video/swf/sample_1920x800_ocean_with_audio.swf
3. Ghost Blog Embedded HTML/JavaScript for Drag-and-Drop SWF Property Dump
This is an embeddable HTML snippet with JavaScript that can be placed in a Ghost blog post (or any HTML-enabled blog). It creates a drag-and-drop area where users can drop a .SWF file. The script reads the file as an ArrayBuffer, parses the header (handling ZLIB compression via pako library for browser compatibility; include pako via CDN), extracts the properties, and displays them on the screen. Note: LZMA compression is not handled here for simplicity, as it's less common and requires additional libraries.
Drag and drop a .SWF file here
This snippet uses pako for ZLIB decompression. For full RECT parsing, additional bit-level reading is needed (e.g., using a BitReader class).
4. Python Class for SWF Handling
This Python class can open a .SWF file, decode the header (handling ZLIB and LZMA compression), read and print the properties, and write a modified version (e.g., change frame rate). It uses built-in zlib and lzma modules.
import struct
import zlib
import lzma
class SWFHandler:
def __init__(self, filename):
self.filename = filename
self.signature = None
self.version = None
self.file_length = None
self.frame_size = None # (xmin, xmax, ymin, ymax) in twips
self.frame_rate = None # float
self.frame_count = None
self.compressed_data = b''
self.uncompressed_data = b''
self._read()
def _read_rect(self, data, offset):
# Bit-packed RECT
bit_pos = 0
nbits = (data[offset] >> 3) & 0x1F
bit_pos += 5
xmin = self._read_signed_bits(data, offset, bit_pos, nbits)
bit_pos += nbits
xmax = self._read_signed_bits(data, offset, bit_pos, nbits)
bit_pos += nbits
ymin = self._read_signed_bits(data, offset, bit_pos, nbits)
bit_pos += nbits
ymax = self._read_signed_bits(data, offset, bit_pos, nbits)
byte_len = (bit_pos + 7) // 8
return (xmin, xmax, ymin, ymax), offset + byte_len
def _read_signed_bits(self, data, byte_offset, bit_offset, num_bits):
val = 0
for i in range(num_bits):
byte = data[byte_offset + (bit_offset // 8)]
bit = (byte >> (7 - (bit_offset % 8))) & 1
val = (val << 1) | bit
bit_offset += 1
if val & (1 << (num_bits - 1)):
val -= (1 << num_bits)
return val
def _read(self):
with open(self.filename, 'rb') as f:
header = f.read(8)
if len(header) < 8:
raise ValueError("Invalid SWF file")
self.signature = header[0:3].decode('ascii')
self.version = header[3]
self.file_length = struct.unpack('<I', header[4:8])[0]
self.compressed_data = f.read()
if self.signature[0] == 'C':
self.uncompressed_data = zlib.decompress(self.compressed_data)
elif self.signature[0] == 'Z':
self.uncompressed_data = lzma.decompress(self.compressed_data)
elif self.signature[0] == 'F':
self.uncompressed_data = self.compressed_data
else:
raise ValueError("Unknown signature")
offset = 0
self.frame_size, offset = self._read_rect(self.uncompressed_data, offset)
self.frame_rate = struct.unpack('<H', self.uncompressed_data[offset:offset+2])[0] / 256.0
offset += 2
self.frame_count = struct.unpack('<H', self.uncompressed_data[offset:offset+2])[0]
def print_properties(self):
print(f"Signature: {self.signature}")
print(f"Version: {self.version}")
print(f"File Length: {self.file_length}")
print(f"Frame Size (twips): {self.frame_size}")
print(f"Frame Rate: {self.frame_rate} fps")
print(f"Frame Count: {self.frame_count}")
def write(self, new_filename, new_frame_rate=None):
if new_frame_rate is not None:
self.frame_rate = new_frame_rate
# Rebuild uncompressed data (header part only for simplicity; append rest)
rect_bytes = b'' # Would need to pack RECT back; omitted for brevity
# Assume original uncompressed_data for rest
header_data = rect_bytes + struct.pack('<H', int(self.frame_rate * 256)) + struct.pack('<H', self.frame_count)
full_data = header_data + self.uncompressed_data[len(header_data):]
if self.signature[0] == 'C':
compressed = zlib.compress(full_data)
elif self.signature[0] == 'Z':
compressed = lzma.compress(full_data)
else:
compressed = full_data
file_length = 8 + len(compressed)
header = self.signature.encode('ascii') + struct.pack('<B', self.version) + struct.pack('<I', file_length)
with open(new_filename, 'wb') as f:
f.write(header + compressed)
# Example usage:
# swf = SWFHandler('example.swf')
# swf.print_properties()
# swf.write('modified.swf', new_frame_rate=30.0)
Note: Full RECT packing for write is complex and omitted for brevity; implement a bit-packer if needed.
5. Java Class for SWF Handling
This Java class handles reading, decoding, printing, and writing SWF files similarly. Uses java.util.zip for ZLIB and java.util.lzma (but LZMA requires Apache Commons Compress or similar; here assuming ZLIB only for simplicity).
import java.io.*;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.util.zip.Inflater;
public class SWFHandler {
private String filename;
private String signature;
private int version;
private int fileLength;
private int[] frameSize; // {xmin, xmax, ymin, ymax}
private double frameRate;
private int frameCount;
private byte[] compressedData;
private byte[] uncompressedData;
public SWFHandler(String filename) {
this.filename = filename;
read();
}
private void read() {
try (FileInputStream fis = new FileInputStream(filename);
ByteArrayOutputStream baos = new ByteArrayOutputStream()) {
byte[] header = new byte[8];
fis.read(header);
signature = new String(header, 0, 3);
version = header[3] & 0xFF;
fileLength = ByteBuffer.wrap(header, 4, 4).order(ByteOrder.LITTLE_ENDIAN).getInt();
fis.transferTo(baos);
compressedData = baos.toByteArray();
if (signature.charAt(0) == 'C') {
Inflater inflater = new Inflater();
inflater.setInput(compressedData);
ByteArrayOutputStream decompressed = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
while (!inflater.finished()) {
int count = inflater.inflate(buffer);
decompressed.write(buffer, 0, count);
}
uncompressedData = decompressed.toByteArray();
} else if (signature.charAt(0) == 'Z') {
// LZMA decompression requires external lib like Apache Commons Compress
throw new UnsupportedOperationException("LZMA not supported");
} else {
uncompressedData = compressedData;
}
ByteBuffer bb = ByteBuffer.wrap(uncompressedData).order(ByteOrder.LITTLE_ENDIAN);
int offset = 0;
// Parse RECT
int byteVal = uncompressedData[offset] & 0xFF;
int nbits = (byteVal >> 3) & 0x1F;
offset += (5 + 4 * nbits + 7) / 8; // Simplified offset update
// Detailed bit parsing omitted; assume frameSize = new int[]{0, 0, 0, 0};
frameRate = bb.getShort(offset) / 256.0;
offset += 2;
frameCount = bb.getShort(offset) & 0xFFFF;
} catch (Exception e) {
e.printStackTrace();
}
}
public void printProperties() {
System.out.println("Signature: " + signature);
System.out.println("Version: " + version);
System.out.println("File Length: " + fileLength);
System.out.println("Frame Size (twips): [" + frameSize[0] + ", " + frameSize[1] + ", " + frameSize[2] + ", " + frameSize[3] + "]");
System.out.println("Frame Rate: " + frameRate + " fps");
System.out.println("Frame Count: " + frameCount);
}
public void write(String newFilename, Double newFrameRate) {
if (newFrameRate != null) {
frameRate = newFrameRate;
}
// Rebuild and write; simplified, similar to Python
// Omitted full implementation for brevity
}
// Main for testing
public static void main(String[] args) {
SWFHandler swf = new SWFHandler("example.swf");
swf.printProperties();
}
}
Note: Full bit-level RECT parsing and LZMA require additional code/libraries. Write method is stubbed.
6. JavaScript Class for SWF Handling
This JavaScript class (for Node.js) uses fs for file I/O and zlib for decompression. Run with node script.js.
const fs = require('fs');
const zlib = require('zlib');
class SWFHandler {
constructor(filename) {
this.filename = filename;
this.signature = null;
this.version = null;
this.fileLength = null;
this.frameSize = null; // [xmin, xmax, ymin, ymax]
this.frameRate = null;
this.frameCount = null;
this.read();
}
read() {
const buffer = fs.readFileSync(this.filename);
const view = new DataView(buffer.buffer, buffer.byteOffset, buffer.length);
this.signature = String.fromCharCode(view.getUint8(0), view.getUint8(1), view.getUint8(2));
this.version = view.getUint8(3);
this.fileLength = view.getUint32(4, true);
let data = buffer.slice(8);
if (this.signature[0] === 'C') {
data = zlib.inflateSync(data);
} else if (this.signature[0] === 'Z') {
// LZMA not built-in; require 'lzma-native' or similar
throw new Error('LZMA not supported');
}
const dataView = new DataView(data.buffer, data.byteOffset, data.length);
let offset = 0;
// Parse RECT (simplified)
const nbits = (dataView.getUint8(offset) >> 3) & 0x1F;
offset += Math.ceil((5 + 4 * nbits) / 8);
// Detailed parsing omitted
this.frameRate = dataView.getUint16(offset, true) / 256;
offset += 2;
this.frameCount = dataView.getUint16(offset, true);
}
printProperties() {
console.log(`Signature: ${this.signature}`);
console.log(`Version: ${this.version}`);
console.log(`File Length: ${this.fileLength}`);
console.log(`Frame Size (twips): ${this.frameSize}`);
console.log(`Frame Rate: ${this.frameRate} fps`);
console.log(`Frame Count: ${this.frameCount}`);
}
write(newFilename, newFrameRate) {
if (newFrameRate !== undefined) {
this.frameRate = newFrameRate;
}
// Rebuild and write; simplified
}
}
// Example:
// const swf = new SWFHandler('example.swf');
// swf.printProperties();
Note: Install lzma-native for LZMA if needed. Write is stubbed.
7. C Class for SWF Handling
This is a C++ class (since pure C doesn't have classes natively; using structs/classes in C++). Uses <zlib.h> for ZLIB (link with -lz). LZMA requires liblzma.
#include <iostream>
#include <fstream>
#include <vector>
#include <zlib.h>
#include <cstdint>
class SWFHandler {
private:
std::string filename;
std::string signature;
uint8_t version;
uint32_t fileLength;
std::vector<int32_t> frameSize; // {xmin, xmax, ymin, ymax}
double frameRate;
uint16_t frameCount;
public:
SWFHandler(const std::string& fn) : filename(fn) {
read();
}
void read() {
std::ifstream file(filename, std::ios::binary);
if (!file) return;
std::vector<uint8_t> header(8);
file.read(reinterpret_cast<char*>(header.data()), 8);
signature = std::string(1, header[0]) + std::string(1, header[1]) + std::string(1, header[2]);
version = header[3];
fileLength = *reinterpret_cast<uint32_t*>(&header[4]); // Assume LE
std::vector<uint8_t> compressed((std::istreambuf_iterator<char>(file)), std::istreambuf_iterator<char>());
std::vector<uint8_t> uncompressed;
if (signature[0] == 'C') {
uLongf destLen = fileLength - 8;
uncompressed.resize(destLen);
uncompress(uncompressed.data(), &destLen, compressed.data(), compressed.size());
} else if (signature[0] == 'Z') {
// Use lzma library
std::cerr << "LZMA not supported" << std::endl;
return;
} else {
uncompressed = compressed;
}
size_t offset = 0;
// Parse RECT (simplified)
uint8_t byte = uncompressed[offset];
uint8_t nbits = (byte >> 3) & 0x1F;
offset += (5 + 4 * nbits + 7) / 8;
frameRate = *reinterpret_cast<uint16_t*>(&uncompressed[offset]) / 256.0;
offset += 2;
frameCount = *reinterpret_cast<uint16_t*>(&uncompressed[offset]);
// frameSize parsing omitted
}
void printProperties() {
std::cout << "Signature: " << signature << std::endl;
std::cout << "Version: " << static_cast<int>(version) << std::endl;
std::cout << "File Length: " << fileLength << std::endl;
std::cout << "Frame Rate: " << frameRate << " fps" << std::endl;
std::cout << "Frame Count: " << frameCount << std::endl;
}
void write(const std::string& newFilename, double newFrameRate = -1) {
if (newFrameRate >= 0) frameRate = newFrameRate;
// Implement write; omitted
}
};
// Example:
// int main() {
// SWFHandler swf("example.swf");
// swf.printProperties();
// return 0;
// }
Note: Compile with g++ -o swf swf.cpp -lz. Full parsing and write omitted for brevity. LZMA requires additional setup.