WIP: Dedup tiles

Author: joeyparrish

encoder/encode_sega_video.py

@@ -34,7 +34,7 @@
 # that people want to expand on this goofy project and worry about
 # compatibility, we define a constant for the file format that is written into
 # the output file.
-FILE_FORMAT = 3
+FILE_FORMAT = 4
 
 # Number of tiles (w, h) for fullscreen and thumbnail sizes.
 FULLSCREEN_TILES = (32, 28)
@@ -493,7 +493,7 @@ def dump_debug_file(frame_dir, audio_dir, args):
   run(args.debug, check=True, args=ffmpeg_args)
 
 
-def png_to_sega_frame(in_path, out_file, expected_tiles):
+def png_to_sega_frame(in_path, out_file, expected_tiles, dedup, pal=0):
   img = Image.open(in_path)
   pixels = img.getdata()
   width, height = img.size
@@ -513,6 +513,7 @@ def png_to_sega_frame(in_path, out_file, expected_tiles):
 
   # Each tile is 8x8 pixels, 4 bit palette index per pixel.
   binary_tiles = b''
+  tile_map = []
 
   # The image dimensions should each be a multiple of 8 already.
   assert width % 8 == 0 and height % 8 == 0
@@ -522,6 +523,8 @@ def png_to_sega_frame(in_path, out_file, expected_tiles):
   # We should have a fullscreen image.
   assert (tiles_width, tiles_height) == expected_tiles
 
+  binary_tile_to_index = {}
+
   for tile_y in range(tiles_height):
     for tile_x in range(tiles_width):
       tile = []
@@ -539,15 +542,33 @@ def png_to_sega_frame(in_path, out_file, expected_tiles):
 
           tile.append(palette_index)
 
-      binary_tiles += pack_tile(tile)
+      binary_tile = pack_tile(tile)
+      index = binary_tile_to_index.get(binary_tile, None)
+      if dedup == False:
+        index = None
+
+      if index is None:
+        index = len(binary_tile_to_index)
+        binary_tile_to_index[binary_tile] = index
+        binary_tiles += binary_tile
+
+      tile_map.append(index | (pal << 13))
 
-  # SegaVideoFrameHeader contains the palette only
+  # Output the palette
   out_file.write(pack_palette(palette))
+
+  if dedup == True:
+    # Pack the tile map
+    out_file.write(pack_tile_map(tile_map))
+    # The number of tiles to follow
+    out_file.write(len(binary_tile_to_index).to_bytes(4, 'big'))
+
   # Actual tile data follows
   out_file.write(binary_tiles)
 
-  # A palette is always 32 bytes
-  return 32 + len(binary_tiles)
+  # A palette is always 32 bytes, the tile map is 1792 bytes, the number of
+  # tiles is encoded in 4 bytes.
+  return 32 + 1792 + 4 + len(binary_tiles)
 
 
 def sega_color_map(value):
@@ -587,6 +608,13 @@ def pack_tile(palette_indexes):
   return packed
 
 
+def pack_tile_map(tile_indexes):
+  packed = b''
+  for idx in tile_indexes:
+    packed += idx.to_bytes(2, 'big')
+  return packed
+
+
 def pack_palette(palette):
   packed = b''
   assert(len(palette) <= 16)
@@ -654,7 +682,8 @@ def write_chunk(f, state):
   chunk_frame_data_len = 0
   for i in range(chunk_frame_count):
     input_path = state.frame_paths[state.frame_path_index]
-    bytes_written = png_to_sega_frame(input_path, f, FULLSCREEN_TILES)
+    bytes_written = png_to_sega_frame(input_path, f, FULLSCREEN_TILES,
+        dedup=True, pal=(1 if (i % 2) else 0))
     chunk_frame_data_len += bytes_written
     state.frame_count -= 1
     state.frame_path_index += 1
@@ -854,7 +883,7 @@ def generate_thumbnail(args, fullcolor_dir, thumb_dir):
 
   # Then convert to Sega format.
   with open(sega_frame_out, 'wb') as f:
-    png_to_sega_frame(thumb_out, f, THUMBNAIL_TILES)
+    png_to_sega_frame(thumb_out, f, THUMBNAIL_TILES, dedup=False)
 
   print('Thumbnail generated from frame #{}.'.format(thumb_index + 1))
 

encoder/generate_trivial_tilemap.py

@@ -17,6 +17,11 @@ def write_trivial_tilemap(path, pal_num, width, height):
     for i in range(width * height):
       # Stripped down version of TILE_ATTR_FULL() macro without priority or
       # flipping.  Assuming no deduplication of tiles.
+      # #define TILE_ATTR_HFLIP_SFT         11
+      # #define TILE_ATTR_VFLIP_SFT         12
+      # #define TILE_ATTR_PALETTE_SFT       13
+      # #define TILE_ATTR_PRIORITY_SFT      15
+      # #define TILE_ATTR_FULL(pal, prio, flipV, flipH, index)   (((flipH) << TILE_ATTR_HFLIP_SFT) + ((flipV) << TILE_ATTR_VFLIP_SFT) + ((pal) << TILE_ATTR_PALETTE_SFT) + ((prio) << TILE_ATTR_PRIORITY_SFT) + (index))
       map_value = (pal_num << 13) | i
       f.write(map_value.to_bytes(2, 'big'))
 

software/player/inc/segavideo_format.h

@@ -20,7 +20,7 @@
 #endif
 
 #define SEGAVIDEO_HEADER_MAGIC  "what nintendon't"
-#define SEGAVIDEO_HEADER_FORMAT 0x0003
+#define SEGAVIDEO_HEADER_FORMAT 0x0004
 
 // This header appears at the start of the file in both embedded and streaming
 // mode.  Each one is exactly 8kB, so they can form the basis of a catalog
@@ -97,6 +97,12 @@ typedef struct SegaVideoFrame {
   // always considered fully transparent by the VDP, and all other entries are
   // considered fully opaque.  The alpha bits are always ignored.
   uint16_t palette[16];
+  // Custom tile map.  Each entry is a tile number in the low 10 bits, and a
+  // palette number in bits 13-14 (left blank by the encoder, set by the player
+  // as it flips frames).
+  uint16_t tileMap[32 * 28];
+  // Unique tiles below.  May not use all 32x28 tiles.
+  uint32_t numTiles;
   // Each tile is a packed array of 64 (8x8) 4-bit palette indexes (16 words).
   // Uses trivial_tilemap_0 or trivial_tilemap_1.
   uint32_t tiles[8 * 32 * 28];  // 32 bytes per tile (8*uint32_t), 32x28 tiles

software/player/src/segavideo_player.c

@@ -59,7 +59,7 @@ static uint32_t nextFrameNum;
 // Hard-coded for now.  Fullscreen video only.
 #define MAP_W 32
 #define MAP_H 28
-#define NUM_TILES (32 * 28)  // 896
+#define MAX_NUM_TILES (32 * 28)  // 896
 #define FRAME_TILE_INDEX 0  // Overwrites 16 system tiles, but we need space
 
 // NOTE: We use the XGM2 driver.  With the PCM-specific drivers, I found audio
@@ -371,13 +371,12 @@ static bool nextVideoFrame() {
 
   // We alternate tile and palette indexes every frame.
   bool second = currentFrameNum & 1;
-  const uint16_t* tileMap = (const uint16_t*)(
-      second ? trivial_tilemap_1 : trivial_tilemap_0);
+  const uint16_t* tileMap = frame->tileMap;
   uint16_t palNum =
       (tileMap[0] & TILE_ATTR_PALETTE_MASK) >> TILE_ATTR_PALETTE_SFT;
   // NOTE: We are hijacking system tiles for more space!
   // User tiles start at index 256, and the max index is 1425.
-  uint16_t tileIndex = FRAME_TILE_INDEX + (second ? NUM_TILES : 0);
+  uint16_t tileIndex = FRAME_TILE_INDEX + (second ? MAX_NUM_TILES : 0);
 
   // The order of loading things here matters, but it took some experimentation
   // to get it right.  Tiles, colors, then map gives us clean frames that look
@@ -389,7 +388,7 @@ static bool nextVideoFrame() {
 #pragma GCC diagnostic push
 #pragma GCC diagnostic ignored "-Waddress-of-packed-member"
   // Unpacked, raw pointer method used by VDP_loadTileSet
-  VDP_loadTileData(frame->tiles, tileIndex, NUM_TILES, CPU);
+  VDP_loadTileData(frame->tiles, tileIndex, frame->numTiles, CPU);
 
   // Unpacked, raw pointer method used by PAL_setPaletteColors
   PAL_setColors(palNum << 4, frame->palette, /* count= */ 16, CPU);