#!/usr/bin/env python
# Copyright 2024 Google LLC
#
# Licensed under the Apache License, Version 2.0 (the "License");
# you may not use this file except in compliance with the License.
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import StringIO
import argparse
import os
import struct
import sys
import png
import itertools
import generate_c_byte_array
from pebble_image_routines import (rgba32_triplet_to_argb8, num_colors_to_bitdepth,
get_reduction_func)
SCALE_TO_GCOLOR8 = 64
WHITE_COLOR_MAP = {
'white': 1,
'black': 0,
'transparent': 0,
}
BLACK_COLOR_MAP = {
'white': 0,
'black': 1,
'transparent': 0,
}
# translates bitdepth to supported PBI format
#0 is special case of legacy 1Bit format
bitdepth_dict = {0: 0, #GBitmapFormat1Bit
8: 1, #GBitmapFormat8Bit
1: 2, #GBitmapFormat1BitPalette
2: 3, #GBitmapFormat2BitPalette
4: 4} #GBitmapFormat4BitPalette
FORMAT_BW = "bw"
FORMAT_COLOR = "color"
FORMAT_COLOR_RAW = "color_raw" # forces output to be ARGB8 (no palette)
FORMAT_CHOICES = [FORMAT_BW, FORMAT_COLOR, FORMAT_COLOR_RAW]
DEFAULT_FORMAT = FORMAT_BW
TRUNCATE = "truncate"
NEAREST = "nearest"
COLOR_REDUCTION_CHOICES = [TRUNCATE, NEAREST]
DEFAULT_COLOR_REDUCTION = NEAREST
# Bitmap struct only contains a color palette for GBitmapFormat(1/2/4)BitPalette
# Bitmap struct (NB: All fields are little-endian)
# (uint16_t) row_size_bytes
# (uint16_t) info_flags
# bit 0 : is heap allocated (must be zero for bitmap files)
# bits 1-5 : bitmap_format
# bits 6-11 : reserved, must be 0
# bits 12-15 : file version
# (int16_t) bounds.origin.x
# (int16_t) bounds.origin.y
# (int16_t) bounds.size.w
# (int16_t) bounds.size.h
# (uint8_t)[] image data (row_size_bytes-aligned, 0-padded rows of bits)
# [optional] (uint8_t)[] argb8 palette data (0-padded to 2 ** bitdepth)
class PebbleBitmap(object):
def __init__(self, path, color_map=WHITE_COLOR_MAP, bitmap_format=DEFAULT_FORMAT,
color_reduction_method=DEFAULT_COLOR_REDUCTION, crop=True, bitdepth=None,
palette_name='pebble64'):
self.palette_name = palette_name
self.version = 1
self.path = path
self.name, _ = os.path.splitext(os.path.basename(path))
self.color_map = color_map
self.palette = None # only used in color mode for <=16 colors
self.bitdepth = bitdepth # number of bits per pixel, 0 for legacy b&w
if bitmap_format == FORMAT_BW:
self.bitdepth = 0
self.bitmap_format = bitmap_format
self.color_reduction_method = color_reduction_method
width, height, pixels, metadata = png.Reader(filename=path).asRGBA8()
# convert planar boxed row flat pixel to 2d array of (R, G, B, A)
self._im_pixels = []
for row in pixels:
row_list = []
for (r, g, b, a) in grouper(row, 4):
row_list.append((r, g, b, a))
self._im_pixels.append(row_list)
self._im_size = (width, height)
self._set_bbox(crop)
def _set_bbox(self, crop=True):
left, top = (0, 0)
right, bottom = self._im_size
if crop:
alphas = [[p[3] for p in row] for row in self._im_pixels]
alphas_transposed = zip(*alphas)
for row in alphas:
if any(row):
break
top += 1
for row in reversed(alphas):
if any(row):
break
bottom -= 1
for row in alphas_transposed:
if any(row):
break
left += 1
for row in reversed(alphas_transposed):
if any(row):
break
right -= 1
self.x = left
self.y = top
self.w = right - left
self.h = bottom - top
def row_size_bytes(self):
"""
Return the length of the bitmap's row in bytes.
On b/w, row lengths are rounded up to the nearest word, padding up to
3 empty bytes per row.
On color, row lengths are rounded up to the nearest byte
"""
if self.bitmap_format == FORMAT_COLOR_RAW:
return self.w
elif self.bitmap_format == FORMAT_COLOR:
# adds (8 / bitdepth) - 1 to round up (ceil) to the next nearest byte
return (self.w + ((8 / self.bitdepth) - 1)) / (8 / self.bitdepth)
else:
row_size_padded_words = (self.w + 31) / 32
return row_size_padded_words * 4
def info_flags(self):
"""Returns the type and version of bitmap."""
format_value = bitdepth_dict[self.bitdepth]
return self.version << 12 | format_value << 1
def pbi_header(self):
return struct.pack('<HHhhhh',
self.row_size_bytes(),
self.info_flags(),
self.x,
self.y,
self.w,
self.h)
def image_bits_bw(self):
"""
Return a raw b/w bitmap capable of being rendered using Pebble's bitblt graphics routines.
The returned bitmap will always be y * row_size_bytes large.
"""
def get_monochrome_value_for_pixel(pixel):
if pixel[3] < 127:
return self.color_map['transparent']
if ((pixel[0] + pixel[1] + pixel[2]) / 3) < 127:
return self.color_map['black']
return self.color_map['white']
def pack_pixels_to_bitblt_word(pixels, x_offset, x_max):
word = 0
for column in xrange(0, 32):
x = x_offset + column
if (x < x_max):
pixel = pixels[x]
word |= get_monochrome_value_for_pixel(pixel) << (column)
return struct.pack('<I', word)
src_pixels = self._im_pixels
out_pixels = []
row_size_words = self.row_size_bytes() / 4
for row in xrange(self.y, self.y + self.h):
x_max = self._im_size[0]
for column_word in xrange(0, row_size_words):
x_offset = self.x + column_word * 32
out_pixels.append(pack_pixels_to_bitblt_word(src_pixels[row],
x_offset,
x_max))
return ''.join(out_pixels)
def image_bits_color(self):
"""
Return a raw color bitmap capable of being rendered using Pebble's bitblt graphics routines.
"""
if self.bitmap_format == FORMAT_COLOR_RAW:
self.bitdepth = 8 # forced to 8-bit depth for color_raw, no palette
else:
self.generate_palette()
assert self.bitdepth is not None
out_pixels = []
for row in xrange(self.y, self.y + self.h):
packed_count = 0
packed_value = 0
for column in xrange(self.x, self.x + self.w):
pixel = self._im_pixels[row][column]
r, g, b, a = [pixel[i] for i in range(4)]
# convert RGBA 32-bit image colors to pebble color table
fn = get_reduction_func(self.palette_name, self.color_reduction_method)
r, g, b, a = fn(r, g, b, a)
if a == 0:
# clear values in transparent pixels
r, g, b = (0, 0, 0)
# convert colors to ARGB8 format
argb8 = rgba32_triplet_to_argb8(r, g, b, a)
if (self.bitdepth == 8):
out_pixels.append(struct.pack("B", argb8))
else:
# all palettized color bitdepths (1, 2, 4)
# look up the color index in the palette
color_index = self.palette.index(argb8)
# shift and store the color index in a packed value
packed_count = packed_count + 1 # pre-increment for calculation below
packed_value = packed_value | (color_index << \
(self.bitdepth * (8 / self.bitdepth - (packed_count))))
if (packed_count == 8 / self.bitdepth):
out_pixels.append(struct.pack("B", packed_value))
packed_count = 0
packed_value = 0
# write out the last non-byte-aligned set for the row (ie. byte-align rows)
if (packed_count):
out_pixels.append(struct.pack("B", packed_value))
return ''.join(out_pixels)
def image_bits(self):
if self.bitmap_format == FORMAT_COLOR or self.bitmap_format == FORMAT_COLOR_RAW:
return self.image_bits_color()
else:
return self.image_bits_bw()
def header(self):
f = StringIO.StringIO()
f.write("// GBitmap + pixel data generated by bitmapgen.py:\n\n")
bytes = self.image_bits()
bytes_var_name = "s_{var_name}_pixels".format(var_name=self.name)
generate_c_byte_array.write(f, bytes, bytes_var_name)
f.write("static const GBitmap s_{0}_bitmap = {{\n".format(self.name))
f.write(" .addr = (void*) &{0},\n".format(bytes_var_name))
f.write(" .row_size_bytes = {0},\n".format(self.row_size_bytes()))
f.write(" .info_flags = 0x%02x,\n" % self.info_flags())
f.write(" .bounds = {\n")
f.write(" .origin = {{ .x = {0}, .y = {1} }},\n".format(self.x, self.y))
f.write(" .size = {{ .w = {0}, .h = {1} }},\n".format(self.w, self.h))
f.write(" },\n")
f.write("};\n\n")
return f.getvalue()
def convert_to_h(self, header_file=None):
to_file = header_file if header_file else (os.path.splitext(self.path)[0] + '.h')
with open(to_file, 'w') as f:
f.write(self.header())
return to_file
def convert_to_pbi(self):
pbi_bits = []
image_data = self.image_bits() # compute before generating header
pbi_bits.extend(self.pbi_header())
pbi_bits.extend(image_data)
if self.palette and self.bitdepth < 8:
# write out palette, padded to the bitdepth
for i in xrange(0, 2**self.bitdepth):
value = 0
if i < len(self.palette):
value = self.palette[i]
pbi_bits.extend(struct.pack('B', value))
return b"".join(pbi_bits)
def convert_to_pbi_file(self, pbi_file=None):
to_file = pbi_file if pbi_file else (os.path.splitext(self.path)[0] + '.pbi')
with open(to_file, 'wb') as f:
f.write(self.convert_to_pbi())
return to_file
def generate_palette(self):
self.palette = []
for row in xrange(self.y, self.y + self.h):
for column in xrange(self.x, self.x + self.w):
pixel = self._im_pixels[row][column]
r, g, b, a = [pixel[i] for i in range(4)]
# convert RGBA 32-bit image colors to pebble color table
fn = get_reduction_func(self.palette_name, self.color_reduction_method)
r, g, b, a = fn(r, g, b, a)
if a == 0:
# clear values in transparent pixels
r, g, b = (0, 0, 0)
# store color value as ARGB8 entry in the palette
self.palette.append(rgba32_triplet_to_argb8(r, g, b, a))
# remove duplicate colors
self.palette = list(set(self.palette))
# get the bitdepth for the number of colors
min_bitdepth = num_colors_to_bitdepth(len(self.palette))
if self.bitdepth is None:
self.bitdepth = min_bitdepth
if self.bitdepth < min_bitdepth:
raise Exception("Required bitdepth {} is lower than required depth {}."
.format(self.bitdepth, min_bitdepth))
self.palette.extend([0] * (self.bitdepth - len(self.palette)))
def cmd_pbi(args):
pb = PebbleBitmap(args.input_png, bitmap_format=args.format,
color_reduction_method=args.color_reduction_method, crop=not args.disable_crop)
pb.convert_to_pbi_file(args.output_pbi)
def cmd_header(args):
pb = PebbleBitmap(args.input_png, bitmap_format=args.format,
color_reduction_method=args.color_reduction_method, crop=not args.disable_crop)
print pb.header()
def cmd_white_trans_pbi(args):
pb = PebbleBitmap(args.input_png, WHITE_COLOR_MAP, crop=not args.disable_crop)
pb.convert_to_pbi_file(args.output_pbi)
def cmd_black_trans_pbi(args):
pb = PebbleBitmap(args.input_png, BLACK_COLOR_MAP, crop=not args.disable_crop)
pb.convert_to_pbi_file(args.output_pbi)
def process_all_bitmaps():
directory = "bitmaps"
paths = []
for _, _, filenames in os.walk(directory):
for filename in filenames:
if os.path.splitext(filename)[1] == '.png':
paths.append(os.path.join(directory, filename))
header_paths = []
for path in paths:
b = PebbleBitmap(path)
b.convert_to_pbi_file()
to_file = b.convert_to_h()
header_paths.append(os.path.basename(to_file))
f = open(os.path.join(directory, 'bitmaps.h'), 'w')
print>> f, '#pragma once'
for h in header_paths:
print>> f, "#include \"{0}\"".format(h)
f.close()
def grouper(iterable, n, fillvalue=None):
from itertools import izip_longest
args = [iter(iterable)] * n
return izip_longest(fillvalue=fillvalue, *args)
def process_cmd_line_args():
parser = argparse.ArgumentParser(description="Generate pebble-usable files from png images")
parser_parent = argparse.ArgumentParser(add_help=False)
parser_parent.add_argument('--disable_crop', required=False, action='store_true',
help='Disable transparent region cropping for PBI output')
parser_parent.add_argument('--color_reduction_method', metavar='method', required=False,
nargs=1, default=NEAREST, choices=COLOR_REDUCTION_CHOICES,
help="Method used to convert colors to Pebble's color palette, "
"options are [{}, {}]".format(NEAREST, TRUNCATE))
subparsers = parser.add_subparsers(help="commands", dest='which')
bitmap_format = {"dest": "format", "metavar": "BITMAP_FORMAT",
"choices": FORMAT_CHOICES, "nargs": "?",
"default": DEFAULT_FORMAT, "help": "resulting GBitmap format"}
input_png = {"dest": "input_png", "metavar": "INPUT_PNG", "help": "The png image to process"}
output_pbi = {"dest": "output_pbi", "metavar": "OUTPUT_PBI", "help": "The pbi output file"}
pbi_parser = subparsers.add_parser('pbi', parents=[parser_parent],
help="make a .pbi (pebble binary image) file")
for arg in [bitmap_format, input_png, output_pbi]:
pbi_parser.add_argument(**arg)
pbi_parser.set_defaults(func=cmd_pbi)
h_parser = subparsers.add_parser('header', parents=[parser_parent], help="make a .h file")
for arg in [bitmap_format, input_png]:
h_parser.add_argument(**arg)
h_parser.set_defaults(func=cmd_header)
white_pbi_parser = subparsers.add_parser('white_trans_pbi', parents=[parser_parent],
help="make a .pbi (pebble binary image) file for a white transparency layer")
for arg in [input_png, output_pbi]:
white_pbi_parser.add_argument(**arg)
white_pbi_parser.set_defaults(func=cmd_white_trans_pbi)
black_pbi_parser = subparsers.add_parser('black_trans_pbi', parents=[parser_parent],
help="make a .pbi (pebble binary image) file for a black transparency layer")
for arg in [input_png, output_pbi]:
black_pbi_parser.add_argument(**arg)
black_pbi_parser.set_defaults(func=cmd_black_trans_pbi)
args = parser.parse_args()
args.func(args)
def main():
if (len(sys.argv) < 2):
# process everything in the bitmaps folder
process_all_bitmaps()
else:
# process an individual file
process_cmd_line_args()
if __name__ == "__main__":
main()