import os
import struct


def pack_lzw_bits(codes, code_size):
    """Pack a list of integer codes into bytes, LSB-first (GIF LZW style)."""
    bits = []
    for code in codes:
        for i in range(code_size):
            bits.append((code >> i) & 1)
    out = bytearray()
    for i in range(0, len(bits), 8):
        byte = 0
        for j in range(8):
            if i + j < len(bits):
                byte |= bits[i + j] << j
        out.append(byte)
    return bytes(out)


def main():
    # --- Header ---
    header = b'GIF87a'

    # --- Logical Screen Descriptor ---
    # Packed byte 0x81: GCT flag=1, color resolution=0 (1 bit),
    #                   sort=0, GCT size=1 => 2^(1+1) = 4 entries
    screen_desc = struct.pack('<HHBBB', 1, 1, 0x81, 0, 0)

    # --- Global Color Table (4 entries, all black) ---
    gct = b'\x00\x00\x00' * 4

    # --- Image Descriptor ---
    image_desc = b'\x2c' + struct.pack('<HHHHB', 0, 0, 1, 1, 0)

    # --- Image Data (LZW) ---
    lzw_min_code_size = 8
    clear_code = 1 << lzw_min_code_size       # 256
    eoi_code = clear_code + 1                 # 257
    code_size = lzw_min_code_size + 1         # 9 bits initially

    # One black pixel (index 0): emit clear, 0, EOI
    lzw_bytes = pack_lzw_bits([clear_code, 0, eoi_code], code_size)

    # Sub-block: min code size, then data sub-block(s), then terminator
    image_data = (
        bytes([lzw_min_code_size])
        + bytes([len(lzw_bytes)]) + lzw_bytes
        + b'\x00'
    )

    # --- Trailer ---
    trailer = b'\x3b'

    data = header + screen_desc + gct + image_desc + image_data + trailer

    out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'black.gif')
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f'created {out_path}')


if __name__ == '__main__':
    main()

import os
import struct


# --- JPEG quantization tables (zig-zag order) ---

DQT_LUMINANCE = [
      8,   6,   6,   7,   6,   5,   8,   7,
      7,   7,   9,   9,   8,  10,  12,  20,
     13,  12,  11,  11,  12,  25,  18,  19,
     15,  20,  29,  26,  31,  30,  29,  26,
     28,  28,  32,  36,  46,  39,  32,  34,
     44,  35,  28,  28,  40,  55,  41,  44,
     48,  49,  52,  52,  52,  31,  39,  57,
     61,  56,  50,  60,  46,  51,  52,  50,
]

DQT_CHROMINANCE = [
      9,   9,   9,  12,  11,  12,  24,  13,
     13,  24,  50,  33,  28,  33,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
     50,  50,  50,  50,  50,  50,  50,  50,
]

# --- Standard JPEG Huffman tables ---
# Each table = (class_and_id, 16 count bytes, symbol bytes)

DC_LUMINANCE = (
    0x00,  # class 0 (DC), table id 0
    [0, 1, 5, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
)

DC_CHROMINANCE = (
    0x01,  # class 0 (DC), table id 1
    [0, 3, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0],
    [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11],
)

AC_LUMINANCE = (
    0x10,  # class 1 (AC), table id 0
    [0, 2, 1, 3, 3, 2, 4, 3, 5, 5, 4, 4, 0, 0, 1, 0x7d],
    [
        0x01, 0x02, 0x03, 0x00, 0x04, 0x11, 0x05, 0x12,
        0x21, 0x31, 0x41, 0x06, 0x13, 0x51, 0x61, 0x07,
        0x22, 0x71, 0x14, 0x32, 0x81, 0x91, 0xa1, 0x08,
        0x23, 0x42, 0xb1, 0xc1, 0x15, 0x52, 0xd1, 0xf0,
        0x24, 0x33, 0x62, 0x72, 0x82, 0x09, 0x0a, 0x16,
        0x17, 0x18, 0x19, 0x1a, 0x25, 0x26, 0x27, 0x28,
        0x29, 0x2a, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
        0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
        0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
        0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
        0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
        0x7a, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
        0x8a, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98,
        0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5, 0xa6, 0xa7,
        0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4, 0xb5, 0xb6,
        0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3, 0xc4, 0xc5,
        0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2, 0xd3, 0xd4,
        0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda, 0xe1, 0xe2,
        0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9, 0xea,
        0xf1, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
        0xf9, 0xfa,
    ],
)

AC_CHROMINANCE = (
    0x11,  # class 1 (AC), table id 1
    [0, 2, 1, 2, 4, 4, 3, 4, 7, 5, 4, 4, 0, 1, 2, 0x77],
    [
        0x00, 0x01, 0x02, 0x03, 0x11, 0x04, 0x05, 0x21,
        0x31, 0x06, 0x12, 0x41, 0x51, 0x07, 0x61, 0x71,
        0x13, 0x22, 0x32, 0x81, 0x08, 0x14, 0x42, 0x91,
        0xa1, 0xb1, 0xc1, 0x09, 0x23, 0x33, 0x52, 0xf0,
        0x15, 0x62, 0x72, 0xd1, 0x0a, 0x16, 0x24, 0x34,
        0xe1, 0x25, 0xf1, 0x17, 0x18, 0x19, 0x1a, 0x26,
        0x27, 0x28, 0x29, 0x2a, 0x35, 0x36, 0x37, 0x38,
        0x39, 0x3a, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48,
        0x49, 0x4a, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58,
        0x59, 0x5a, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68,
        0x69, 0x6a, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78,
        0x79, 0x7a, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87,
        0x88, 0x89, 0x8a, 0x92, 0x93, 0x94, 0x95, 0x96,
        0x97, 0x98, 0x99, 0x9a, 0xa2, 0xa3, 0xa4, 0xa5,
        0xa6, 0xa7, 0xa8, 0xa9, 0xaa, 0xb2, 0xb3, 0xb4,
        0xb5, 0xb6, 0xb7, 0xb8, 0xb9, 0xba, 0xc2, 0xc3,
        0xc4, 0xc5, 0xc6, 0xc7, 0xc8, 0xc9, 0xca, 0xd2,
        0xd3, 0xd4, 0xd5, 0xd6, 0xd7, 0xd8, 0xd9, 0xda,
        0xe2, 0xe3, 0xe4, 0xe5, 0xe6, 0xe7, 0xe8, 0xe9,
        0xea, 0xf2, 0xf3, 0xf4, 0xf5, 0xf6, 0xf7, 0xf8,
        0xf9, 0xfa,
    ],
)

# Entropy-coded scan data for a 1x1 black pixel.
# Encodes 6 blocks (4Y + 1Cb + 1Cr, 4:2:0 sampling) with all-zero DCT
# coefficients using the standard Huffman tables above.
SCAN_DATA = b'\xf9\xfe\x8a\x28\xa0\x0f'


def segment(marker, payload):
    """Build a JPEG marker segment: FF xx + 2-byte length + payload."""
    return marker + struct.pack('>H', len(payload) + 2) + payload


def dqt_segment(table_id, values):
    """Build a DQT marker segment (FF DB)."""
    payload = bytes([table_id]) + bytes(values)
    return segment(b'\xff\xdb', payload)


def dht_segment(class_and_id, counts, symbols):
    """Build a DHT marker segment (FF C4)."""
    payload = bytes([class_and_id]) + bytes(counts) + bytes(symbols)
    return segment(b'\xff\xc4', payload)


def main():
    parts = []

    # SOI
    parts.append(b'\xff\xd8')

    # APP0 - JFIF
    parts.append(segment(
        b'\xff\xe0',
        b'JFIF\x00'        # identifier + zero
        b'\x01\x01'        # version 1.1
        b'\x00'            # units (no units)
        b'\x00\x01'        # X density
        b'\x00\x01'        # Y density
        b'\x00\x00',       # no thumbnail
    ))

    # DQT - luminance (table 0) and chrominance (table 1)
    parts.append(dqt_segment(0x00, DQT_LUMINANCE))
    parts.append(dqt_segment(0x01, DQT_CHROMINANCE))

    # SOF0 - baseline DCT, 1x1, 3 components, 4:2:0 sampling
    sof0_payload = struct.pack(
        '>BHHB',
        8,    # precision (8 bits)
        1,    # height
        1,    # width
        3,    # number of components
    )
    # Component: id, sampling factors (H|V), quant table id
    sof0_payload += bytes([1, 0x22, 0])   # Y:  2x2 sampling, QT 0
    sof0_payload += bytes([2, 0x11, 1])   # Cb: 1x1 sampling, QT 1
    sof0_payload += bytes([3, 0x11, 1])   # Cr: 1x1 sampling, QT 1
    parts.append(segment(b'\xff\xc0', sof0_payload))

    # DHT - four Huffman tables
    parts.append(dht_segment(*DC_LUMINANCE))
    parts.append(dht_segment(*AC_LUMINANCE))
    parts.append(dht_segment(*DC_CHROMINANCE))
    parts.append(dht_segment(*AC_CHROMINANCE))

    # SOS - start of scan
    sos_payload = struct.pack('>B', 3)           # 3 components
    sos_payload += bytes([1, 0x00])              # Y:  DC table 0, AC table 0
    sos_payload += bytes([2, 0x11])              # Cb: DC table 1, AC table 1
    sos_payload += bytes([3, 0x11])              # Cr: DC table 1, AC table 1
    sos_payload += bytes([0, 0x3f, 0x00])        # Ss=0, Se=63, Ah=0/Al=0
    parts.append(segment(b'\xff\xda', sos_payload))

    # Entropy-coded scan data
    parts.append(SCAN_DATA)

    # EOI
    parts.append(b'\xff\xd9')

    data = b''.join(parts)

    out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'black.jpg')
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f'created {out_path}')


if __name__ == '__main__':
    main()

import os
import struct
import zlib


def make_chunk(chunk_type, data):
    """Assemble a PNG chunk: length + type + data + CRC-32."""
    length = struct.pack('>I', len(data))
    crc = struct.pack('>I', zlib.crc32(chunk_type + data) & 0xFFFFFFFF)
    return length + chunk_type + data + crc


def main():
    # PNG signature
    signature = b'\x89PNG\r\n\x1a\n'

    # IHDR: width=1, height=1, bit depth=8, color type=2 (truecolor RGB),
    #        compression=0, filter=0, interlace=0
    ihdr_data = struct.pack('>IIBBBBB', 1, 1, 8, 2, 0, 0, 0)
    ihdr = make_chunk(b'IHDR', ihdr_data)

    # IDAT: deflate-compressed scanline.
    # One scanline = filter byte (0x00 = None) + 3 bytes (R=0, G=0, B=0)
    raw_scanline = b'\x00\x00\x00\x00'
    compressed = zlib.compress(raw_scanline, 6)
    idat = make_chunk(b'IDAT', compressed)

    # IEND
    iend = make_chunk(b'IEND', b'')

    data = signature + ihdr + idat + iend

    out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'black.png')
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f'created {out_path}')


if __name__ == '__main__':
    main()

import os
import struct


def main():
    # BITMAPFILEHEADER (14 bytes)
    file_header = struct.pack(  # type: ignore[call-overload]
        '<2sIHHI',
        b'BM',    # signature
        58,       # total file size (14 + 40 + 4)
        0,        # reserved1
        0,        # reserved2
        54,       # bfOffBits: offset from file start to pixel data
    )

    # BITMAPINFOHEADER (40 bytes)
    info_header = struct.pack(  # type: ignore[call-overload]
        '<IiiHHIIiiII',
        40,    # biSize
        1,     # biWidth
        1,     # biHeight (positive => bottom-up)
        1,     # biPlanes
        24,    # biBitCount (24-bit RGB, no palette)
        0,     # biCompression (BI_RGB)
        4,     # biSizeImage (1 pixel * 3 bytes, padded to 4-byte row)
        3780,  # biXPelsPerMeter (~96 DPI)
        3780,  # biYPelsPerMeter (~96 DPI)
        0,     # biClrUsed
        0,     # biClrImportant
    )

    # Pixel data: one BGR black pixel + one padding byte (row must be 4-aligned)
    pixel_data = b'\x00\x00\x00\x00'

    data = file_header + info_header + pixel_data

    out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'black.bmp')
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f'created {out_path}')


if __name__ == '__main__':
    main()

import os
import struct


def main():
    width = 1
    height = 1

    # --- VP8 (lossy) bitstream for a 1x1 black keyframe ---
    #
    # Uncompressed 10-byte keyframe header:
    #   frame_tag (3 bytes) + start code (3 bytes) + dimensions (4 bytes)
    #
    # frame_tag (24-bit LE) packs:
    #   frame_type      (1 bit)  = 0  (keyframe)
    #   version         (3 bits) = 0
    #   show_frame      (1 bit)  = 1
    #   first_part_size (19 bits)= 9  (size of the first data partition)
    frame_type = 0
    version = 0
    show_frame = 1
    first_part_size = 9

    frame_tag = (frame_type
                 | (version << 1)
                 | (show_frame << 4)
                 | (first_part_size << 5))
    frame_tag_bytes = struct.pack('<I', frame_tag)[:3]   # 3 bytes, little-endian

    start_code = b'\x9d\x01\x2a'                         # fixed VP8 keyframe magic
    dimensions = struct.pack('<HH', width, height)        # scale = 0

    uncompressed_header = frame_tag_bytes + start_code + dimensions

    # Boolean-coded VP8 frame header + residual for a 1x1 black keyframe.
    # The first partition (9 bytes) carries the frame header; the remaining
    # 5 bytes are the (empty) coefficient partition.  These bytes are the
    # entropy-coded output of the VP8 boolean encoder and cannot be derived
    # from simple arithmetic, so they are embedded directly.
    vp8_bitstream = bytes([
        0x01, 0x40, 0x26, 0x25, 0xa4, 0x00, 0x03, 0x70, 0x00,  # first partition (9)
        0xfe, 0xfd, 0x36, 0x68, 0x00,                          # second partition (5)
    ])

    vp8_data = uncompressed_header + vp8_bitstream

    # --- RIFF container ---
    chunk_id = b'VP8 '                                    # lossy VP8 chunk
    chunk_size = struct.pack('<I', len(vp8_data))

    webp_body = b'WEBP' + chunk_id + chunk_size + vp8_data

    riff = b'RIFF' + struct.pack('<I', len(webp_body)) + webp_body

    data = riff

    out_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'black.webp')
    with open(out_path, 'wb') as f:
        f.write(data)
    print(f'created {out_path}')


if __name__ == '__main__':
    main()