23 #include "table/strings.h" 
   35   return ((red * 19595) + (green * 38470) + (blue * 7471)) / 65536;
 
   49   byte gray_palette[256];
 
   50   png_bytep *row_pointers = NULL;
 
   51   bool has_palette = png_get_color_type(png_ptr, info_ptr) == PNG_COLOR_TYPE_PALETTE;
 
   52   uint channels = png_get_channels(png_ptr, info_ptr);
 
   61     png_get_PLTE(png_ptr, info_ptr, &palette, &palette_size);
 
   62     for (i = 0; i < palette_size && (palette_size != 16 || all_gray); i++) {
 
   63       all_gray &= palette[i].red == palette[i].green && palette[i].red == palette[i].blue;
 
   64       gray_palette[i] = 
RGBToGrayscale(palette[i].red, palette[i].green, palette[i].blue);
 
   73     if (palette_size == 16 && !all_gray) {
 
   74       for (i = 0; i < palette_size; i++) {
 
   75         gray_palette[i] = 256 * i / palette_size;
 
   80   row_pointers = png_get_rows(png_ptr, info_ptr);
 
   83   for (x = 0; x < png_get_image_width(png_ptr, info_ptr); x++) {
 
   84     for (y = 0; y < png_get_image_height(png_ptr, info_ptr); y++) {
 
   85       byte *pixel = &map[y * png_get_image_width(png_ptr, info_ptr) + x];
 
   86       uint x_offset = x * channels;
 
   89         *pixel = gray_palette[row_pointers[y][x_offset]];
 
   90       } 
else if (channels == 3) {
 
   92             row_pointers[y][x_offset + 1], row_pointers[y][x_offset + 2]);
 
   94         *pixel = row_pointers[y][x_offset];
 
  108   png_structp png_ptr = NULL;
 
  109   png_infop info_ptr  = NULL;
 
  117   png_ptr = png_create_read_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
 
  118   if (png_ptr == NULL) {
 
  124   info_ptr = png_create_info_struct(png_ptr);
 
  125   if (info_ptr == NULL || setjmp(png_jmpbuf(png_ptr))) {
 
  128     png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
  132   png_init_io(png_ptr, fp);
 
  136   png_set_packing(png_ptr);
 
  137   png_read_png(png_ptr, info_ptr, PNG_TRANSFORM_PACKING | PNG_TRANSFORM_STRIP_ALPHA | PNG_TRANSFORM_STRIP_16, NULL);
 
  141   if ((png_get_channels(png_ptr, info_ptr) != 1) && (png_get_channels(png_ptr, info_ptr) != 3) && (png_get_bit_depth(png_ptr, info_ptr) != 8)) {
 
  144     png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
  148   uint 
width = png_get_image_width(png_ptr, info_ptr);
 
  149   uint 
height = png_get_image_height(png_ptr, info_ptr);
 
  152   if ((uint64)width * height >= (
size_t)-1) {
 
  155     png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
  160     *map = MallocT<byte>(width * 
height);
 
  168   png_destroy_read_struct(&png_ptr, &info_ptr, NULL);
 
  181   byte gray_palette[256];
 
  183   if (data->palette != NULL) {
 
  185     bool all_gray = 
true;
 
  189         all_gray &= data->palette[i].r == data->palette[i].g && data->palette[i].r == data->palette[i].b;
 
  190         gray_palette[i] = 
RGBToGrayscale(data->palette[i].r, data->palette[i].g, data->palette[i].b);
 
  210       gray_palette[1] = 16;
 
  215   for (y = 0; y < info->
height; y++) {
 
  216     byte *pixel = &map[y * info->
width];
 
  217     byte *bitmap = &data->bitmap[y * info->
width * (info->
bpp == 24 ? 3 : 1)];
 
  219     for (x = 0; x < info->
width; x++) {
 
  220       if (info->
bpp != 24) {
 
  221         *pixel++ = gray_palette[*bitmap++];
 
  243   memset(&data, 0, 
sizeof(data));
 
  251   BmpInitializeBuffer(&buffer, f);
 
  253   if (!BmpReadHeader(&buffer, &info, &data)) {
 
  256     BmpDestroyData(&data);
 
  261   if ((uint64)info.
width * info.
height >= (
size_t)-1 / (info.
bpp == 24 ? 3 : 1)) {
 
  264     BmpDestroyData(&data);
 
  269     if (!BmpReadBitmap(&buffer, &info, &data)) {
 
  272       BmpDestroyData(&data);
 
  280   BmpDestroyData(&data);
 
  299   const uint num_div = 16384;
 
  303   uint row_pad = 0, col_pad = 0;
 
  305   uint img_row, img_col;
 
  310     default: NOT_REACHED();
 
  321   if ((img_width * num_div) / img_height > ((width * num_div) / height)) {
 
  323     img_scale = (width * num_div) / img_width;
 
  324     row_pad = (1 + height - ((img_height * img_scale) / num_div)) / 2;
 
  327     img_scale = (height * num_div) / img_height;
 
  328     col_pad = (1 + width - ((img_width * img_scale) / num_div)) / 2;
 
  337   for (row = 0; row < 
height; row++) {
 
  338     for (col = 0; col < 
width; col++) {
 
  340         default: NOT_REACHED();
 
  353         img_row = (((row - row_pad) * num_div) / img_scale);
 
  355           default: NOT_REACHED();
 
  357             img_col = (((width - 1 - col - col_pad) * num_div) / img_scale);
 
  360             img_col = (((col - col_pad) * num_div) / img_scale);
 
  364         assert(img_row < img_height);
 
  365         assert(img_col < img_width);
 
  367         uint heightmap_height = map[img_row * img_width + img_col];
 
  369         if (heightmap_height > 0) {
 
  401   for (row = 0; (uint)row < height; row++) {
 
  402     for (col = 0; (uint)col < width; col++) {
 
  423   for (row = height - 1; row >= 0; row--) {
 
  424     for (col = width - 1; col >= 0; col--) {
 
  426       if ((uint)col != width - 1) {
 
  431       if ((uint)row != height - 1) {
 
  515   for (uint row = edge_distance; row < 
MapSizeY() - edge_distance; row++) {
 
  516     for (uint col = edge_distance; col < 
MapSizeX() - edge_distance; col++) {