This CL adds client.toDataURL which gets the contents...

core/cross/bitmap_png.cc

 /*
  * Copyright 2009, Google Inc.
  * All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions are
  * met:
  *
  *     * Redistributions of source code must retain the above copyright
  * notice, this list of conditions and the following disclaimer.
@@ skipping 19 matching lines @@
  */
 
 
 // This file contains the image codec operations for PNG files.
 
 // precompiled header must appear before anything else.
 #include "core/cross/precompile.h"
 
 #include <fstream>
 #include "core/cross/bitmap.h"
+#include "core/cross/error.h"
 #include "core/cross/types.h"
 #include "utils/cross/file_path_utils.h"
 #include "base/file_path.h"
 #include "base/file_util.h"
 #include "import/cross/memory_buffer.h"
 #include "import/cross/memory_stream.h"
 #include "png.h"
+#include "utils/cross/dataurl.h"
 
 using file_util::OpenFile;
 using file_util::CloseFile;
 
 namespace o3d {
 
+namespace {
+
 // Helper function for LoadFromPNGFile that converts a stream into the
 // necessary abstract byte reading function.
-static void stream_read_data(png_structp png_ptr,
-                             png_bytep data,
-                             png_size_t length) {
+void StreamReadData(png_structp png_ptr, png_bytep data, png_size_t length) {
   MemoryReadStream *stream =
     static_cast<MemoryReadStream*>(png_get_io_ptr(png_ptr));
   stream->Read(data, length);
 }
 
+// Helper function for ToDataURL that converts a stream into the necessary
+// abstract byte writing function.
+void StreamWriteData(png_structp png_ptr, png_bytep data, png_size_t length) {
+  std::vector<uint8>* stream =
+     static_cast<std::vector<uint8>*>(png_get_io_ptr(png_ptr));
+  stream->insert(stream->end(),
+                 static_cast<uint8*>(data),
+                 static_cast<uint8*>(data) + length);
+}
+
+// Because libpng requires a flush function according to the docs.
+void StreamFlush(png_structp png_ptr) {
+}
+
+}  // anonymous namespace
 
 // Loads the raw RGB data from a compressed PNG file.
 bool Bitmap::LoadFromPNGStream(MemoryReadStream *stream,
                                const String &filename,
                                bool generate_mipmaps) {
   // Read the magic header.
   char magic[4];
   size_t bytes_read = stream->Read(magic, sizeof(magic));
   if (bytes_read != sizeof(magic)) {
     DLOG(ERROR) << "PNG file magic header not loaded \"" << filename << "\"";
@@ skipping 37 matching lines @@
   if (setjmp(png_jmpbuf(png_ptr))) {
     // If we reach here, a fatal error occurred so free memory and exit.
     DLOG(ERROR) << "Fatal error reading PNG file \"" << filename << "\"";
     if (row_pointers)
       png_free(png_ptr, row_pointers);
     png_destroy_read_struct(&png_ptr, &info_ptr, png_infopp_NULL);
     return false;
   }
 
   // Set up our STL stream input control
-  png_set_read_fn(png_ptr, stream, &stream_read_data);
+  png_set_read_fn(png_ptr, stream, &StreamReadData);
 
   // We have already read some of the signature, advance the pointer.
   png_set_sig_bytes(png_ptr, sizeof(magic));
 
   // Read the PNG header information.
   png_uint_32 png_width = 0;
   png_uint_32 png_height = 0;
   int png_color_type = 0;
   int png_interlace_type = 0;
   int png_bits_per_channel = 0;
@@ skipping 125 matching lines @@
 
   // Success.
   image_data_.swap(image_data);
   format_ = format;
   width_ = png_width;
   height_ = png_height;
   num_mipmaps_ = num_mipmaps;
   return true;
 }
 
-// Saves the BGRA data from a compressed PNG file.
-bool Bitmap::SaveToPNGFile(const char* filename) {
+// TODO(gman): Use the one in chrome or skia or some other place this function
+//    is implemented.

[apatrick, 2009/08/07 18:25:45]

isn't this also in core/cross/base64.cc

[gman, 2009/08/07 21:34:31]

doh, forgot to delete this.

Done

+namespace {
+
+const int kEncodePad = 64;
+
+const char kEncode[] =
+    "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
+    "abcdefghijklmnopqrstuvwxyz"
+    "0123456789+/=";
+
+size_t GetBase64EncodeLength(size_t length) {
+  return (length + 2) / 3 * 4;
+}
+
+size_t Base64Encode(const void* srcPtr, size_t length, void* dstPtr) {

[apatrick, 2009/08/07 18:25:45]

src_ptr, dst_ptr

[gman, 2009/08/07 21:34:31]

Done.

+    const uint8* src = (const uint8*) srcPtr;
+    uint8* dst = (uint8*) dstPtr;
+    if (dst) {
+        size_t remainder = length % 3;
+        const uint8* end = &src[length - remainder];
+        while (src < end) {
+            unsigned a = *src++;
+            unsigned b = *src++;
+            unsigned c = *src++;
+            unsigned d = c & 0x3F;
+            c = (c >> 6 | b << 2) & 0x3F;
+            b = (b >> 4 | a << 4) & 0x3F;
+            a = a >> 2;
+            *dst++ = kEncode[a];
+            *dst++ = kEncode[b];
+            *dst++ = kEncode[c];
+            *dst++ = kEncode[d];
+        }
+        if (remainder > 0) {
+            unsigned k1 = 0;
+            unsigned k2 = kEncodePad;
+            unsigned a = (uint8) *src++;
+            if (remainder == 2)
+            {
+                int b = *src++;
+                k1 = b >> 4;
+                k2 = (b << 2) & 0x3F;
+            }
+            *dst++ = kEncode[a >> 2];
+            *dst++ = kEncode[(k1 | a << 4) & 0x3F];
+            *dst++ = kEncode[k2];
+            *dst++ = kEncode[kEncodePad];
+        }
+    }
+    return GetBase64EncodeLength(length);
+}
+
+}  // anonymous namespace
+
+String Bitmap::ToDataURL() {
   if (format_ != Texture::ARGB8) {
-    DLOG(ERROR) << "Can only save ARGB8 images.";
-    return false;
+    O3D_ERROR(service_locator()) << "Can only get data URL from ARGB8 images.";
+    return String("data:,");

[apatrick, 2009/08/07 18:25:45]

Could these refer to a constant for empty data urls?

[gman, 2009/08/07 21:34:31]

strange. for some reason this didn't get uploaded

done

   }
   if (num_mipmaps_ != 1 || is_cubemap_) {
-    DLOG(ERROR) << "Only 2D images with only the base level can be saved.";
-    return false;
-  }
-  FILE *fp = fopen(filename, "wb");
-  if (!fp) {
-    DLOG(ERROR) << "Could not open file " << filename << " for writing.";
-    return false;
+    O3D_ERROR(service_locator()) <<
+        "Can only get data URL from images with no mips.";
+    return String("data:,");
   }
 
   png_structp png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL,
                                                 NULL, NULL);
   if (!png_ptr) {
     DLOG(ERROR) << "Could not create PNG structure.";
-    fclose(fp);
-    return false;
+    return String("data:,");
   }
 
   png_infop info_ptr = png_create_info_struct(png_ptr);
   if (!info_ptr) {
     DLOG(ERROR) << "Could not create PNG info structure.";
     png_destroy_write_struct(&png_ptr,  png_infopp_NULL);
-    fclose(fp);
-    return false;
+    return String("data:,");
   }
 
   scoped_array<png_bytep> row_pointers(new png_bytep[height_]);
   for (int i = 0; i < height_; ++i) {
     row_pointers[height_-1-i] = image_data_.get() + i * width_ * 4;
   }
 
   if (setjmp(png_jmpbuf(png_ptr))) {

[apatrick, 2009/08/07 18:25:45]

setjmp messes up invocation of constructors and destructors for local variables.
I bet if there's a failure, the stream vector won't be destroyed correctly. Have
you checked? Or maybe there's another way to detect errors?

[piman, 2009/08/07 19:04:32]

setjmp/longjmp are unfortunately the standard way of handling errors in libpng.

In my experience for having looked at and fixed the other pieces of code in this
file, any object that you declare before the setjmp get properly destroyed at
the return below in the error path. So if you move the declaration of 'stream'
above the setjmp it should get properly destroyed.

I don't know how that property survives aggressive optimizations, but when I
tested on both gcc and msvc under
-O2/whatever-is-the-optimized-settings-on-msvc, it was working fine.

[gman, 2009/08/07 21:34:31]

I put it in another function and hope that's enough.

     // If we get here, we had a problem reading the file.
-    DLOG(ERROR) << "Error while writing file " << filename << ".";
+    DLOG(ERROR) << "Error while getting dataURL.";
     png_destroy_write_struct(&png_ptr, &info_ptr);
-    fclose(fp);
-    return false;
+    return String("data:,");
   }
 
-  png_init_io(png_ptr, fp);
+  // Set up our STL stream output.
+  std::vector<uint8> stream;
+  png_set_write_fn(png_ptr, &stream, &StreamWriteData, &StreamFlush);
 
   png_set_IHDR(png_ptr, info_ptr, width_, height_, 8,
                PNG_COLOR_TYPE_RGB_ALPHA, PNG_INTERLACE_NONE,
                PNG_COMPRESSION_TYPE_DEFAULT, PNG_FILTER_TYPE_DEFAULT);
   png_set_bgr(png_ptr);
   png_set_rows(png_ptr, info_ptr, row_pointers.get());
   png_write_png(png_ptr, info_ptr, PNG_TRANSFORM_IDENTITY, png_voidp_NULL);
 
   png_destroy_write_struct(&png_ptr, &info_ptr);
-  fclose(fp);
-  return true;
+
+  return dataurl::ToDataURL("image/png", &stream[0], stream.size());
 }
 
 }  // namespace o3d