From 884b5f2e6fd3a708780a43f0ae7662afaf0e926d Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Tue, 1 Sep 2015 13:04:11 +0200
Subject: [PATCH 01/11] add submodule libwebp for #273

---
 .gitmodules                              |  3 ++
 CMakeLists.txt                           | 15 ++++++++
 third_party/CMakeLists.txt               |  4 +++
 third_party/libwebp                      |  1 +
 third_party/libwebp-cmake/CMakeLists.txt | 45 ++++++++++++++++++++++++
 5 files changed, 68 insertions(+)
 create mode 160000 third_party/libwebp
 create mode 100644 third_party/libwebp-cmake/CMakeLists.txt

diff --git a/.gitmodules b/.gitmodules
index 6d8632a203..83da9fb817 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -10,3 +10,6 @@
 [submodule "third_party/duktape"]
 	path = third_party/duktape
 	url = https://github.com/aseprite/duktape.git
+[submodule "third_party/libwebp"]
+	path = third_party/libwebp
+	url = https://chromium.googlesource.com/webm/libwebp
diff --git a/CMakeLists.txt b/CMakeLists.txt
index eff1bc0c7e..a38160896f 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -40,6 +40,7 @@ option(USE_SHARED_JPEGLIB "Use your installed copy of jpeglib" off)
 option(USE_SHARED_ZLIB    "Use your installed copy of zlib" off)
 option(USE_SHARED_LIBPNG  "Use your installed copy of libpng" off)
 option(USE_SHARED_LIBLOADPNG "Use your installed copy of libloadpng" off)
+option(USE_SHARED_LIBWEBP "Use your installed copy of libwebp" off)
 option(USE_SHARED_TINYXML "Use your installed copy of tinyxml" off)
 option(USE_SHARED_PIXMAN  "Use your installed copy of pixman" off)
 option(USE_SHARED_ALLEGRO4 "Use shared Allegro 4 library (without resize support)" off)
@@ -106,6 +107,7 @@ set(LIBFREETYPE_DIR     ${CMAKE_SOURCE_DIR}/third_party/freetype)
 set(LIBJPEG_DIR         ${CMAKE_SOURCE_DIR}/third_party/jpeg)
 set(LIBPNG_DIR          ${CMAKE_SOURCE_DIR}/third_party/libpng)
 set(LOADPNG_DIR         ${CMAKE_SOURCE_DIR}/third_party/loadpng)
+set(LIBWEBP_DIR         ${CMAKE_SOURCE_DIR}/third_party/libwebp)
 set(MONGOOSE_DIR        ${CMAKE_SOURCE_DIR}/third_party/mongoose)
 set(PIXMAN_DIR          ${CMAKE_SOURCE_DIR}/third_party/pixman)
 set(SIMPLEINI_DIR       ${CMAKE_SOURCE_DIR}/third_party/simpleini)
@@ -170,6 +172,19 @@ endif()
 include_directories(${PNG_INCLUDE_DIR})
 add_definitions(-DPNG_NO_MMX_CODE) # Do not use MMX optimizations in PNG code
 
+# libwebp
+if(USE_SHARED_LIBWEBP)
+  find_package(PkgConfig)
+  pkg_check_modules(WEBP libwebp)
+  if(NOT WEBP_FOUND)
+    message(FATAL_ERROR "libwebp not found")
+  endif()
+else()
+  set(WEBP_LIBRARIES webp)
+  set(WEBP_INCLUDE_DIR ${LIBWEBP_DIR}/src)
+endif()
+include_directories(${WEBP_INCLUDE_DIR})
+
 # tinyxml
 if(USE_SHARED_TINYXML)
   find_library(TINYXML_LIBRARY NAMES tinyxml)
diff --git a/third_party/CMakeLists.txt b/third_party/CMakeLists.txt
index 59cd5aa7a4..9bcedd1107 100644
--- a/third_party/CMakeLists.txt
+++ b/third_party/CMakeLists.txt
@@ -20,6 +20,10 @@ if(NOT USE_SHARED_LIBPNG)
   add_subdirectory(libpng)
 endif()
 
+if(NOT USE_SHARED_LIBWEBP)
+  add_subdirectory(libwebp-cmake)
+endif()
+
 if(NOT USE_SHARED_GIFLIB)
   add_subdirectory(giflib)
 endif()
diff --git a/third_party/libwebp b/third_party/libwebp
new file mode 160000
index 0000000000..03fb75221c
--- /dev/null
+++ b/third_party/libwebp
@@ -0,0 +1 @@
+Subproject commit 03fb75221c36ff773379eb5f018d7206f1ef30c9
diff --git a/third_party/libwebp-cmake/CMakeLists.txt b/third_party/libwebp-cmake/CMakeLists.txt
new file mode 100644
index 0000000000..fad88693c2
--- /dev/null
+++ b/third_party/libwebp-cmake/CMakeLists.txt
@@ -0,0 +1,45 @@
+project (webp C)
+cmake_minimum_required(VERSION 2.6)
+
+add_definitions(-DNDEBUG -DWEBP_USE_THREAD)
+
+set(LIBWEBP_SOURCE_DIR "${CMAKE_CURRENT_SOURCE_DIR}/../libwebp")
+
+file(GLOB WEBP_DEC_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/dec/*c
+)
+
+file(GLOB WEBP_DEMUX_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/demux/*c
+)
+
+file(GLOB WEBP_DSP_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/dsp/*c
+)
+
+file(GLOB WEBP_ENC_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/enc/*c
+)
+
+file(GLOB WEBP_UTILS_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/utils/*c
+)
+
+file(GLOB WEBP_MUX_SRCS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/mux/*c
+)
+
+file(GLOB WEBP_HEADERS
+	RELATIVE ${CMAKE_CURRENT_SOURCE_DIR}
+	${LIBWEBP_SOURCE_DIR}/src/webp/*.h
+)
+
+SET(CMAKE_DEBUG_POSTFIX "d")
+set(WEBP_SOURCE ${WEBP_DEC_SRCS} ${WEBP_DEMUX_SRCS} ${WEBP_DSP_SRCS} ${WEBP_ENC_SRCS} ${WEBP_UTILS_SRCS} ${WEBP_MUX_SRC})
+add_library(${PROJECT_NAME} STATIC ${WEBP_SOURCE} ${WEBP_HEADERS})

From 497fc3ed3ae60e39d3f1f85a448f38daf80549ad Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Tue, 1 Sep 2015 13:05:24 +0200
Subject: [PATCH 02/11] implement simple non animation webp for #273

This includes lossless and lossy webp file format. For this reason a
save option dialog was added giving rudimentary options for saving to
the user.
---
 data/widgets/webp_options.xml         |  48 ++++
 src/app/CMakeLists.txt                |   2 +
 src/app/file/file_formats_manager.cpp |   2 +
 src/app/file/webp_format.cpp          | 361 ++++++++++++++++++++++++++
 4 files changed, 413 insertions(+)
 create mode 100644 data/widgets/webp_options.xml
 create mode 100644 src/app/file/webp_format.cpp

diff --git a/data/widgets/webp_options.xml b/data/widgets/webp_options.xml
new file mode 100644
index 0000000000..2f9a9f6985
--- /dev/null
+++ b/data/widgets/webp_options.xml
@@ -0,0 +1,48 @@
+<!-- ASEPRITE -->
+<!-- Copyright (C) 2014, 2015 by David Capello -->
+<gui>
+<window text="WebP Options" id="webp_options">
+  <vbox>
+    <label text="Save as:" />
+    <radio group="1" text="Lossless WebP" id="lossless" tooltip="Save in simple WebP lossless format." />
+    <hbox>
+      <label width="55" text="Compression:" />
+      <slider min="0" max="9" id="compression" cell_align="horizontal" width="128" />
+    </hbox>
+    <hbox>
+      <label width="55" text="Image Hint:" />
+      <combobox width="128" id="image_hint">
+        <listitem text="Default" value="0" />
+        <listitem text="Picture" value="1" />
+        <listitem text="Photo" value="2" />
+        <listitem text="Graph" value="3" />
+        <listitem text="Last" value="4" />
+      </combobox>
+    </hbox>
+    <separator horizontal="true" />
+    <radio group="1" text="Lossy WebP" id="lossy" tooltip="Save in simple WebP lossy format." />
+    <hbox>
+      <label width="55" text="Quality:" />
+      <slider min="0" max="100" id="quality" cell_align="horizontal" width="128" />
+    </hbox>
+    <hbox>
+      <label width="55" text="Image Preset:" />
+      <combobox width="128" id="image_preset">
+        <listitem text="Default" value="0" />
+        <listitem text="Picture" value="1" />
+        <listitem text="Photo" value="2" />
+        <listitem text="Drawing" value="3" />
+        <listitem text="Icon" value="4" />
+        <listitem text="Text" value="5" />
+      </combobox>
+    </hbox>
+    <hbox>
+      <boxfiller />
+      <hbox homogeneous="true">
+        <button text="&amp;OK" closewindow="true" id="ok" magnet="true" minwidth="60" />
+        <button text="&amp;Cancel" closewindow="true" />
+      </hbox>
+    </hbox>
+  </vbox>
+</window>
+</gui>
diff --git a/src/app/CMakeLists.txt b/src/app/CMakeLists.txt
index e070386ab0..0125cdd468 100644
--- a/src/app/CMakeLists.txt
+++ b/src/app/CMakeLists.txt
@@ -274,6 +274,7 @@ add_library(app-lib
   file/png_format.cpp
   file/split_filename.cpp
   file/tga_format.cpp
+  file/webp_format.cpp
   file_selector.cpp
   file_system.cpp
   filename_formatter.cpp
@@ -412,6 +413,7 @@ target_link_libraries(app-lib
   ${JPEG_LIBRARIES}
   ${GIF_LIBRARIES}
   ${PNG_LIBRARIES}
+  ${WEBP_LIBRARIES}
   ${ZLIB_LIBRARIES})
 
 if(ENABLE_UPDATER)
diff --git a/src/app/file/file_formats_manager.cpp b/src/app/file/file_formats_manager.cpp
index 1a8f8027ce..74b78e8950 100644
--- a/src/app/file/file_formats_manager.cpp
+++ b/src/app/file/file_formats_manager.cpp
@@ -29,6 +29,7 @@ extern FileFormat* CreateJpegFormat();
 extern FileFormat* CreatePcxFormat();
 extern FileFormat* CreatePngFormat();
 extern FileFormat* CreateTgaFormat();
+extern FileFormat* CreateWebPFormat();
 
 static FileFormatsManager* singleton = NULL;
 
@@ -67,6 +68,7 @@ void FileFormatsManager::registerAllFormats()
   registerFormat(CreatePcxFormat());
   registerFormat(CreatePngFormat());
   registerFormat(CreateTgaFormat());
+  registerFormat(CreateWebPFormat());
 }
 
 void FileFormatsManager::registerFormat(FileFormat* fileFormat)
diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
new file mode 100644
index 0000000000..489a4ceeaf
--- /dev/null
+++ b/src/app/file/webp_format.cpp
@@ -0,0 +1,361 @@
+// Aseprite
+// Copyright (C) 2001-2015  David Capello
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation.
+
+#ifdef HAVE_CONFIG_H
+#include "config.h"
+#endif
+
+#include "app/app.h"
+#include "app/console.h"
+#include "app/context.h"
+#include "app/document.h"
+#include "app/file/file.h"
+#include "app/file/file_format.h"
+#include "app/file/format_options.h"
+#include "app/find_widget.h"
+#include "app/ini_file.h"
+#include "app/load_widget.h"
+#include "base/file_handle.h"
+#include "doc/doc.h"
+#include "ui/ui.h"
+
+#include <cstdio>
+#include <cstdlib>
+#include <algorithm>
+#include <map>
+
+
+//include webp librarys
+#include <webp/decode.h>
+#include <webp/encode.h>
+
+namespace app {
+
+using namespace base;
+
+class WebPFormat : public FileFormat {
+  // Data for WEBP files
+  class WebPOptions : public FormatOptions {
+  public:
+    WebPOptions(): lossless(0), quality(75), method(6), image_hint(WEBP_HINT_DEFAULT), image_preset(WEBP_PRESET_DEFAULT) {};
+    int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+    float quality;          // between 0 (smallest file) and 100 (biggest)
+    int method;             // quality/speed trade-off (0=fast, 9=slower-better)
+    WebPImageHint image_hint;  // Hint for image type (lossless only for now).
+    WebPPreset image_preset;  // Image Preset for lossy webp.
+  };
+
+  const char* onGetName() const { return "webp"; }
+  const char* onGetExtensions() const { return "webp"; }
+  int onGetFlags() const {
+    return
+      FILE_SUPPORT_LOAD |
+      FILE_SUPPORT_SAVE |
+      FILE_SUPPORT_RGB |
+      FILE_SUPPORT_RGBA |
+      FILE_SUPPORT_SEQUENCES |
+      FILE_SUPPORT_GET_FORMAT_OPTIONS;
+  }
+
+  bool onLoad(FileOp* fop) override;
+#ifdef ENABLE_SAVE
+  bool onSave(FileOp* fop) override;
+#endif
+
+base::SharedPtr<FormatOptions> onGetFormatOptions(FileOp* fop) override;
+};
+
+FileFormat* CreateWebPFormat()
+{
+  return new WebPFormat;
+}
+
+const std::pair<VP8StatusCode, std::string> dec_error_map_data[] = {
+    std::make_pair(VP8_STATUS_OK, ""),
+    std::make_pair(VP8_STATUS_OUT_OF_MEMORY, "out of memory"),
+    std::make_pair(VP8_STATUS_INVALID_PARAM, "invalid parameters"),
+    std::make_pair(VP8_STATUS_BITSTREAM_ERROR, "bitstream error"),
+    std::make_pair(VP8_STATUS_UNSUPPORTED_FEATURE, "unsupported feature"),
+    std::make_pair(VP8_STATUS_SUSPENDED, "suspended"),
+    std::make_pair(VP8_STATUS_USER_ABORT, "user aborted"),
+    std::make_pair(VP8_STATUS_NOT_ENOUGH_DATA, "not enough data")
+};
+
+const std::map<VP8StatusCode, std::string> WebPDecodingErrorMap(dec_error_map_data, dec_error_map_data + sizeof dec_error_map_data / sizeof dec_error_map_data[0]);
+
+bool WebPFormat::onLoad(FileOp* fop)
+{
+  FileHandle handle(open_file_with_exception(fop->filename, "rb"));
+  FILE* fp = handle.get();
+
+  long len;
+	uint8_t* buf = NULL;
+
+  if (fseek(fp, 0, SEEK_END) != 0) {
+    fop_error(fop, "Error while getting WebP file size for %s\n", fop->filename.c_str());
+    return false;
+  }
+
+  len = ftell(fp);
+  rewind(fp);
+
+  if (len < 4) {
+    fop_error(fop, "%s is corrupt or not a WebP file\n", fop->filename.c_str());
+    return false;
+  }
+
+  buf = (uint8_t*) malloc(len);
+  if (!buf) {
+    fop_error(fop, "Error while allocating memory for %s\n", fop->filename.c_str());
+    return false;
+  }
+
+  if (!fread(buf, len, 1, fp)) {
+    fop_error(fop, "Error while writing to %s to memory\n", fop->filename.c_str());
+    free(buf);
+    return false;
+  }
+
+  WebPDecoderConfig config;
+  if (!WebPInitDecoderConfig(&config)) {
+    fop_error(fop, "LibWebP version mismatch %s\n", fop->filename.c_str());
+    free(buf);
+    return false;
+  }
+
+  if (WebPGetFeatures(buf, len, &config.input) != VP8_STATUS_OK) {
+    fop_error(fop, "Bad bitstream in %s\n", fop->filename.c_str());
+    free(buf);
+    return false;
+  }
+
+  fop->seq.has_alpha = config.input.has_alpha;
+  //TODO write imagefeatures
+
+  auto image = fop_sequence_image(fop, IMAGE_RGB, config.input.width, config.input.height);
+
+  config.output.colorspace = MODE_RGBA;
+  config.output.u.RGBA.rgba = (uint8_t*)image->getPixelAddress(0, 0);
+  config.output.u.RGBA.stride = config.input.width * sizeof(uint32_t);
+  config.output.u.RGBA.size = config.input.width * config.input.height * sizeof(uint32_t);
+  config.output.is_external_memory = 1;
+
+  WebPIDecoder* idec = WebPIDecode(NULL, 0, &config);
+  if (idec == NULL) {
+    fop_error(fop, "Error creating WebP decoder for %s\n", fop->filename.c_str());
+    free(buf);
+    return false;
+  }
+
+  auto bytes_remaining = len;
+  auto bytes_read = std::max(4l, len/100l);
+  auto data = buf;
+
+  while (bytes_remaining > 0) {
+    VP8StatusCode status = WebPIAppend(idec, data, bytes_read);
+    if (status == VP8_STATUS_OK || status == VP8_STATUS_SUSPENDED) {
+      bytes_remaining -= bytes_read;
+      data += bytes_read;
+      if (bytes_remaining < bytes_read) bytes_read = bytes_remaining;
+      fop_progress(fop, 1.0f - ((float)std::max(bytes_remaining, 0l)/(float)len));
+    } else {
+      fop_error(fop, "Error during decoding %s : %s\n", fop->filename.c_str(), WebPDecodingErrorMap.find(status)->second.c_str());
+      WebPIDelete(idec);
+      WebPFreeDecBuffer(&config.output);
+      free(buf);
+      return false;
+    }
+    if (fop_is_stop(fop))
+      break;
+  }
+  WebPIDelete(idec);
+  WebPFreeDecBuffer(&config.output);
+  return true;
+}
+
+#ifdef ENABLE_SAVE
+struct writerData {
+  FILE* fp;
+  FileOp* fop;
+};
+
+const std::pair<WebPEncodingError, std::string> enc_error_map_data[] = {
+    std::make_pair(VP8_ENC_OK, ""),
+    std::make_pair(VP8_ENC_ERROR_OUT_OF_MEMORY, "memory error allocating objects"),
+    std::make_pair(VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY, "memory error while flushing bits"),
+    std::make_pair(VP8_ENC_ERROR_NULL_PARAMETER, "a pointer parameter is NULL"),
+    std::make_pair(VP8_ENC_ERROR_INVALID_CONFIGURATION, "configuration is invalid"),
+    std::make_pair(VP8_ENC_ERROR_BAD_DIMENSION, "picture has invalid width/height"),
+    std::make_pair(VP8_ENC_ERROR_PARTITION0_OVERFLOW, "partition is bigger than 512k"),
+    std::make_pair(VP8_ENC_ERROR_PARTITION_OVERFLOW, "partition is bigger than 16M"),
+    std::make_pair(VP8_ENC_ERROR_BAD_WRITE, "error while flushing bytes"),
+    std::make_pair(VP8_ENC_ERROR_FILE_TOO_BIG, "file is bigger than 4G"),
+    std::make_pair(VP8_ENC_ERROR_OUT_OF_MEMORY, "memory error allocating objects"),
+    std::make_pair(VP8_ENC_ERROR_USER_ABORT, "abort request by user"),
+    std::make_pair(VP8_ENC_ERROR_LAST, "list terminator. always last.")
+};
+
+const std::map<WebPEncodingError, std::string> WebPEncodingErrorMap(enc_error_map_data, enc_error_map_data + sizeof enc_error_map_data / sizeof enc_error_map_data[0]);
+
+static int ProgressReport(int percent, const WebPPicture* const pic)
+{
+  fop_progress(((writerData*)pic->custom_ptr)->fop, (double)percent/(double)100);
+  if (fop_is_stop(((writerData*)pic->custom_ptr)->fop)) return false;
+  return true;
+}
+
+static int FileWriter(const uint8_t* data, size_t data_size, const WebPPicture* const pic)
+{
+  return data_size ? (fwrite(data, data_size, 1, ((writerData*)pic->custom_ptr)->fp) == 1) : 1;
+}
+
+
+//Helper functions instead of std::stoi because of missing c++11 on mac os x
+template<typename T>
+static inline std::string ToString(const T& v)
+{
+    std::ostringstream ss;
+    ss << v;
+    return ss.str();
+}
+
+template<typename T>
+static inline T FromString(const std::string& str)
+{
+    std::istringstream ss(str);
+    T ret;
+    ss >> ret;
+    return ret;
+}
+
+bool WebPFormat::onSave(FileOp* fop)
+{
+  FileHandle handle(open_file_with_exception(fop->filename, "wb"));
+  FILE* fp = handle.get();
+
+  struct writerData wd = {fp, fop};
+
+  auto image = fop->seq.image.get();
+  if (image->width() > WEBP_MAX_DIMENSION || image->height() > WEBP_MAX_DIMENSION) {
+   fop_error(
+     fop, "Error: WebP can only have a maximum width and height of %i but your %s has a size of %i x %i\n",
+     WEBP_MAX_DIMENSION, fop->filename.c_str(), image->width(), image->height()
+   );
+   return false;
+  }
+
+  base::SharedPtr<WebPOptions> webp_options = fop->seq.format_options;
+
+  WebPConfig config;
+
+  if (webp_options->lossless) {
+    if (!(WebPConfigInit(&config) && WebPConfigLosslessPreset(&config, webp_options->method))) {
+     fop_error(fop, "Error for WebP Config Version for file %s\n", fop->filename.c_str());
+     return false;
+    }
+    config.image_hint = webp_options->image_hint;
+  } else {
+    if (!WebPConfigPreset(&config, webp_options->image_preset, webp_options->quality)) {
+     fop_error(fop, "Error for WebP Config Version for file %s\n", fop->filename.c_str());
+     return false;
+    }
+  }
+
+  if (!WebPValidateConfig(&config)) {
+   fop_error(fop, "Error in WebP Encoder Config for file %s\n", fop->filename.c_str());
+   return false;
+  }
+
+  WebPPicture pic;
+  if (!WebPPictureInit(&pic)) {
+    fop_error(fop, "Error for WebP Picture Version mismatch for file %s\n", fop->filename.c_str());
+    return false;
+  }
+
+  pic.width = image->width();
+  pic.height = image->height();
+  if (webp_options->lossless) {
+    pic.use_argb = true;
+  }
+
+  if (!WebPPictureAlloc(&pic)) {
+    fop_error(fop, "Error for  WebP Picture memory allocations for file %s\n", fop->filename.c_str());
+    return false;
+  }
+
+  if (!WebPPictureImportRGBA(&pic, (uint8_t*)image->getPixelAddress(0, 0), image->width() * sizeof(uint32_t))) {
+    fop_error(fop, "Error for LibWebP Import RGBA Buffer into Picture for %s\n", fop->filename.c_str());
+    WebPPictureFree(&pic);
+    return false;
+  }
+
+  pic.writer = FileWriter;
+  pic.custom_ptr = &wd;
+  pic.progress_hook = ProgressReport;
+
+  if (!WebPEncode(&config, &pic)) {
+    fop_error(fop, "Error for LibWebP while Encoding %s: %s\n", fop->filename.c_str(), WebPEncodingErrorMap.find(pic.error_code)->second.c_str());
+    WebPPictureFree(&pic);
+    return false;
+  }
+
+  WebPPictureFree(&pic);
+  return true;
+}
+#endif
+
+// Shows the WebP configuration dialog.
+base::SharedPtr<FormatOptions> WebPFormat::onGetFormatOptions(FileOp* fop)
+{
+  base::SharedPtr<WebPOptions> webp_options;
+  if (fop->document->getFormatOptions())
+    webp_options = base::SharedPtr<WebPOptions>(fop->document->getFormatOptions());
+
+  if (!webp_options)
+    webp_options.reset(new WebPOptions);
+
+  // Non-interactive mode
+  if (!fop->context || !fop->context->isUIAvailable())
+    return webp_options;
+
+  try {
+
+    // Load the window to ask to the user the JPEG options he wants.
+    UniquePtr<ui::Window> window(app::load_widget<ui::Window>("webp_options.xml", "webp_options"));
+    ui::RadioButton* button_lossless = app::find_widget<ui::RadioButton>(window, "lossless");
+    ui::Slider* slider_compression = app::find_widget<ui::Slider>(window, "compression");
+    ui::Slider* slider_quality = app::find_widget<ui::Slider>(window, "quality");
+    ui::Widget* ok = app::find_widget<ui::Widget>(window, "ok");
+    ui::ComboBox* list_hint = app::find_widget<ui::ComboBox>(window, "image_hint");
+    ui::ComboBox* list_preset = app::find_widget<ui::ComboBox>(window, "image_preset");
+
+    button_lossless->setSelected(true);
+    slider_compression->setValue(6);
+    slider_quality->setValue(75);
+
+    window->openWindowInForeground();
+
+    if (window->getKiller() == ok) {
+      webp_options->quality = slider_quality->getValue();
+      webp_options->method = slider_compression->getValue();
+      webp_options->lossless = button_lossless->isSelected();
+      webp_options->image_hint = static_cast<WebPImageHint>(FromString<int>(list_hint->getValue()));
+      webp_options->image_preset = static_cast<WebPPreset>(FromString<int>(list_preset->getValue()));
+    }
+    else {
+      webp_options.reset(NULL);
+    }
+
+    return webp_options;
+  }
+  catch (std::exception& e) {
+    Console::showException(e);
+    return base::SharedPtr<WebPOptions>(0);
+  }
+}
+
+} // namespace app

From 83159aba8a4b984320e4568bc06b5d1e2346e887 Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Tue, 1 Sep 2015 13:31:33 +0200
Subject: [PATCH 03/11] add libwebp info to credits

---
 README.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/README.md b/README.md
index 7380949482..81076bd4f6 100644
--- a/README.md
+++ b/README.md
@@ -77,6 +77,7 @@ of the following projects created by third-parties:
 * [giflib](http://sourceforge.net/projects/giflib/) - [giflib license](https://github.com/aseprite/aseprite/tree/master/docs/licenses/giflib-LICENSE.txt)
 * [libjpeg](http://www.ijg.org/) - [libjpeg license](https://github.com/aseprite/aseprite/tree/master/docs/licenses/libjpeg-LICENSE.txt)
 * [libpng](http://www.libpng.org/pub/png/) - [libpng license](https://github.com/aseprite/aseprite/tree/master/docs/licenses/libpng-LICENSE.txt)
+* [libwebp](https://developers.google.com/speed/webp/) - [libwebp license](https://chromium.googlesource.com/webm/libwebp/+/master/COPYING)
 * [loadpng](http://tjaden.strangesoft.net/loadpng/) - [zlib license](https://github.com/aseprite/aseprite/tree/master/docs/licenses/ZLIB.txt)
 * [mongoose](https://github.com/valenok/mongoose) - [MIT license](https://github.com/valenok/mongoose/blob/master/LICENSE)
 * [pixman](http://www.pixman.org/) - [MIT license](http://cgit.freedesktop.org/pixman/plain/COPYING)

From 5ae9b9a6ef5662fd310924ea175113172770b54a Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Tue, 1 Sep 2015 23:11:50 +0200
Subject: [PATCH 04/11] correct copyright line

---
 data/widgets/webp_options.xml | 2 +-
 src/app/file/webp_format.cpp  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/data/widgets/webp_options.xml b/data/widgets/webp_options.xml
index 2f9a9f6985..29f88859ab 100644
--- a/data/widgets/webp_options.xml
+++ b/data/widgets/webp_options.xml
@@ -1,5 +1,5 @@
 <!-- ASEPRITE -->
-<!-- Copyright (C) 2014, 2015 by David Capello -->
+<!-- Copyright (C) 2015 by Gabriel Rauter -->
 <gui>
 <window text="WebP Options" id="webp_options">
   <vbox>
diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index 489a4ceeaf..8a38d05624 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -1,5 +1,5 @@
 // Aseprite
-// Copyright (C) 2001-2015  David Capello
+// Copyright (C) 2015 Gabriel Rauter
 //
 // This program is free software; you can redistribute it and/or modify
 // it under the terms of the GNU General Public License version 2 as
@@ -93,7 +93,7 @@ bool WebPFormat::onLoad(FileOp* fop)
   FILE* fp = handle.get();
 
   long len;
-	uint8_t* buf = NULL;
+  uint8_t* buf = NULL;
 
   if (fseek(fp, 0, SEEK_END) != 0) {
     fop_error(fop, "Error while getting WebP file size for %s\n", fop->filename.c_str());

From 467fcbc0cec4a7ad09ac459d8d7eac5ea1bbb21a Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Tue, 1 Sep 2015 23:39:35 +0200
Subject: [PATCH 05/11] fix compatibility with last stable libWebP release =
 0.4.3

---
 src/app/file/webp_format.cpp | 19 +++++++++++++++++++
 1 file changed, 19 insertions(+)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index 8a38d05624..a5fa8ea9f4 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -201,6 +201,25 @@ const std::pair<WebPEncodingError, std::string> enc_error_map_data[] = {
 
 const std::map<WebPEncodingError, std::string> WebPEncodingErrorMap(enc_error_map_data, enc_error_map_data + sizeof enc_error_map_data / sizeof enc_error_map_data[0]);
 
+#if WEBP_ENCODER_ABI_VERSION < 0x0203
+#define MAX_LEVEL 9
+// Mapping between -z level and -m / -q parameter settings.
+static const struct {
+  uint8_t method_;
+  uint8_t quality_;
+} kLosslessPresets[MAX_LEVEL + 1] = {
+  { 0,  0 }, { 1, 20 }, { 2, 25 }, { 3, 30 }, { 3, 50 },
+  { 4, 50 }, { 4, 75 }, { 4, 90 }, { 5, 90 }, { 6, 100 }
+};
+int WebPConfigLosslessPreset(WebPConfig* config, int level) {
+  if (config == NULL || level < 0 || level > MAX_LEVEL) return 0;
+  config->lossless = 1;
+  config->method = kLosslessPresets[level].method_;
+  config->quality = kLosslessPresets[level].quality_;
+  return 1;
+}
+#endif
+
 static int ProgressReport(int percent, const WebPPicture* const pic)
 {
   fop_progress(((writerData*)pic->custom_ptr)->fop, (double)percent/(double)100);

From 085ffcdcb297ecfc54521ca9cb0246d7cc07cbcf Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 00:57:29 +0200
Subject: [PATCH 06/11] use auto-generated widget for webp options dialog and
 save options

---
 src/app/file/webp_format.cpp | 66 +++++++++++++++++++++---------------
 1 file changed, 38 insertions(+), 28 deletions(-)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index a5fa8ea9f4..6d876cbe5b 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -16,12 +16,11 @@
 #include "app/file/file.h"
 #include "app/file/file_format.h"
 #include "app/file/format_options.h"
-#include "app/find_widget.h"
 #include "app/ini_file.h"
-#include "app/load_widget.h"
 #include "base/file_handle.h"
 #include "doc/doc.h"
-#include "ui/ui.h"
+
+#include "generated_webp_options.h"
 
 #include <cstdio>
 #include <cstdlib>
@@ -38,10 +37,10 @@ namespace app {
 using namespace base;
 
 class WebPFormat : public FileFormat {
-  // Data for WEBP files
+  // Data for WEBP files TODO make this better OOP like GIF_OPTIONS
   class WebPOptions : public FormatOptions {
   public:
-    WebPOptions(): lossless(0), quality(75), method(6), image_hint(WEBP_HINT_DEFAULT), image_preset(WEBP_PRESET_DEFAULT) {};
+    WebPOptions(): lossless(1), quality(75), method(6), image_hint(WEBP_HINT_DEFAULT), image_preset(WEBP_PRESET_DEFAULT) {};
     int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
     float quality;          // between 0 (smallest file) and 100 (biggest)
     int method;             // quality/speed trade-off (0=fast, 9=slower-better)
@@ -134,7 +133,6 @@ bool WebPFormat::onLoad(FileOp* fop)
   }
 
   fop->seq.has_alpha = config.input.has_alpha;
-  //TODO write imagefeatures
 
   auto image = fop_sequence_image(fop, IMAGE_RGB, config.input.width, config.input.height);
 
@@ -172,6 +170,11 @@ bool WebPFormat::onLoad(FileOp* fop)
     if (fop_is_stop(fop))
       break;
   }
+
+  base::SharedPtr<WebPOptions> webPOptions = base::SharedPtr<WebPOptions>(new WebPOptions());
+  fop->seq.format_options = webPOptions;
+  webPOptions->lossless = std::min(config.input.format - 1, 1);
+
   WebPIDelete(idec);
   WebPFreeDecBuffer(&config.output);
   return true;
@@ -342,28 +345,35 @@ base::SharedPtr<FormatOptions> WebPFormat::onGetFormatOptions(FileOp* fop)
     return webp_options;
 
   try {
-
-    // Load the window to ask to the user the JPEG options he wants.
-    UniquePtr<ui::Window> window(app::load_widget<ui::Window>("webp_options.xml", "webp_options"));
-    ui::RadioButton* button_lossless = app::find_widget<ui::RadioButton>(window, "lossless");
-    ui::Slider* slider_compression = app::find_widget<ui::Slider>(window, "compression");
-    ui::Slider* slider_quality = app::find_widget<ui::Slider>(window, "quality");
-    ui::Widget* ok = app::find_widget<ui::Widget>(window, "ok");
-    ui::ComboBox* list_hint = app::find_widget<ui::ComboBox>(window, "image_hint");
-    ui::ComboBox* list_preset = app::find_widget<ui::ComboBox>(window, "image_preset");
-
-    button_lossless->setSelected(true);
-    slider_compression->setValue(6);
-    slider_quality->setValue(75);
-
-    window->openWindowInForeground();
-
-    if (window->getKiller() == ok) {
-      webp_options->quality = slider_quality->getValue();
-      webp_options->method = slider_compression->getValue();
-      webp_options->lossless = button_lossless->isSelected();
-      webp_options->image_hint = static_cast<WebPImageHint>(FromString<int>(list_hint->getValue()));
-      webp_options->image_preset = static_cast<WebPPreset>(FromString<int>(list_preset->getValue()));
+    // Configuration parameters
+    webp_options->quality = get_config_int("WEBP", "Quality", webp_options->quality);
+    webp_options->method = get_config_int("WEBP", "Compression", webp_options->method);
+    webp_options->image_hint = static_cast<WebPImageHint>(get_config_int("WEBP", "ImageHint", webp_options->image_hint));
+    webp_options->image_preset = static_cast<WebPPreset>(get_config_int("WEBP", "ImagePreset", webp_options->image_preset));
+
+    // Load the window to ask to the user the WebP options he wants.
+
+    app::gen::WebpOptions win;
+    win.lossless()->setSelected(webp_options->lossless);
+    win.lossy()->setSelected(!webp_options->lossless);
+    win.quality()->setValue(webp_options->quality);
+    win.compression()->setValue(webp_options->method);
+    win.imageHint()->setSelectedItemIndex(webp_options->image_hint);
+    win.imagePreset()->setSelectedItemIndex(webp_options->image_preset);
+
+    win.openWindowInForeground();
+
+    if (win.getKiller() == win.ok()) {
+      webp_options->quality = win.quality()->getValue();
+      webp_options->method = win.compression()->getValue();
+      webp_options->lossless = win.lossless()->isSelected();
+      webp_options->image_hint = static_cast<WebPImageHint>(FromString<int>(win.imageHint()->getValue()));
+      webp_options->image_preset = static_cast<WebPPreset>(FromString<int>(win.imagePreset()->getValue()));
+
+      set_config_int("WEBP", "Quality", webp_options->quality);
+      set_config_int("WEBP", "Compression", webp_options->method);
+      set_config_int("WEBP", "ImageHint", webp_options->image_hint);
+      set_config_int("WEBP", "ImagePreset", webp_options->image_preset);
     }
     else {
       webp_options.reset(NULL);

From c9d9af7c6f9d903d48416f2e9b38048ff0de007c Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 03:51:35 +0200
Subject: [PATCH 07/11] use std::vector as buffer for input file

---
 src/app/file/webp_format.cpp | 22 +++++-----------------
 1 file changed, 5 insertions(+), 17 deletions(-)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index 6d876cbe5b..190608ff36 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -91,15 +91,12 @@ bool WebPFormat::onLoad(FileOp* fop)
   FileHandle handle(open_file_with_exception(fop->filename, "rb"));
   FILE* fp = handle.get();
 
-  long len;
-  uint8_t* buf = NULL;
-
   if (fseek(fp, 0, SEEK_END) != 0) {
     fop_error(fop, "Error while getting WebP file size for %s\n", fop->filename.c_str());
     return false;
   }
 
-  len = ftell(fp);
+  long len = ftell(fp);
   rewind(fp);
 
   if (len < 4) {
@@ -107,28 +104,22 @@ bool WebPFormat::onLoad(FileOp* fop)
     return false;
   }
 
-  buf = (uint8_t*) malloc(len);
-  if (!buf) {
-    fop_error(fop, "Error while allocating memory for %s\n", fop->filename.c_str());
-    return false;
-  }
+  std::vector<uint8_t> buf(len);
+  auto* data = &buf.front();
 
-  if (!fread(buf, len, 1, fp)) {
+  if (!fread(data, sizeof(uint8_t), len, fp)) {
     fop_error(fop, "Error while writing to %s to memory\n", fop->filename.c_str());
-    free(buf);
     return false;
   }
 
   WebPDecoderConfig config;
   if (!WebPInitDecoderConfig(&config)) {
     fop_error(fop, "LibWebP version mismatch %s\n", fop->filename.c_str());
-    free(buf);
     return false;
   }
 
-  if (WebPGetFeatures(buf, len, &config.input) != VP8_STATUS_OK) {
+  if (WebPGetFeatures(data, len, &config.input) != VP8_STATUS_OK) {
     fop_error(fop, "Bad bitstream in %s\n", fop->filename.c_str());
-    free(buf);
     return false;
   }
 
@@ -145,13 +136,11 @@ bool WebPFormat::onLoad(FileOp* fop)
   WebPIDecoder* idec = WebPIDecode(NULL, 0, &config);
   if (idec == NULL) {
     fop_error(fop, "Error creating WebP decoder for %s\n", fop->filename.c_str());
-    free(buf);
     return false;
   }
 
   auto bytes_remaining = len;
   auto bytes_read = std::max(4l, len/100l);
-  auto data = buf;
 
   while (bytes_remaining > 0) {
     VP8StatusCode status = WebPIAppend(idec, data, bytes_read);
@@ -164,7 +153,6 @@ bool WebPFormat::onLoad(FileOp* fop)
       fop_error(fop, "Error during decoding %s : %s\n", fop->filename.c_str(), WebPDecodingErrorMap.find(status)->second.c_str());
       WebPIDelete(idec);
       WebPFreeDecBuffer(&config.output);
-      free(buf);
       return false;
     }
     if (fop_is_stop(fop))

From 76f0f82b9538765d44754ba75daf358dc89728bd Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 03:55:26 +0200
Subject: [PATCH 08/11] use base::convert_to for string to in conversion
 instead of own funtions

---
 src/app/file/webp_format.cpp | 24 +++---------------------
 1 file changed, 3 insertions(+), 21 deletions(-)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index 190608ff36..cf851f3a04 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -18,6 +18,7 @@
 #include "app/file/format_options.h"
 #include "app/ini_file.h"
 #include "base/file_handle.h"
+#include "base/convert_to.h"
 #include "doc/doc.h"
 
 #include "generated_webp_options.h"
@@ -223,25 +224,6 @@ static int FileWriter(const uint8_t* data, size_t data_size, const WebPPicture*
   return data_size ? (fwrite(data, data_size, 1, ((writerData*)pic->custom_ptr)->fp) == 1) : 1;
 }
 
-
-//Helper functions instead of std::stoi because of missing c++11 on mac os x
-template<typename T>
-static inline std::string ToString(const T& v)
-{
-    std::ostringstream ss;
-    ss << v;
-    return ss.str();
-}
-
-template<typename T>
-static inline T FromString(const std::string& str)
-{
-    std::istringstream ss(str);
-    T ret;
-    ss >> ret;
-    return ret;
-}
-
 bool WebPFormat::onSave(FileOp* fop)
 {
   FileHandle handle(open_file_with_exception(fop->filename, "wb"));
@@ -355,8 +337,8 @@ base::SharedPtr<FormatOptions> WebPFormat::onGetFormatOptions(FileOp* fop)
       webp_options->quality = win.quality()->getValue();
       webp_options->method = win.compression()->getValue();
       webp_options->lossless = win.lossless()->isSelected();
-      webp_options->image_hint = static_cast<WebPImageHint>(FromString<int>(win.imageHint()->getValue()));
-      webp_options->image_preset = static_cast<WebPPreset>(FromString<int>(win.imagePreset()->getValue()));
+      webp_options->image_hint = static_cast<WebPImageHint>(base::convert_to<int>(win.imageHint()->getValue()));
+      webp_options->image_preset = static_cast<WebPPreset>(base::convert_to<int>(win.imagePreset()->getValue()));
 
       set_config_int("WEBP", "Quality", webp_options->quality);
       set_config_int("WEBP", "Compression", webp_options->method);

From 5f3dfd125c1d5b8a7f0c9f5e0461ed432f8f2d40 Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 04:10:53 +0200
Subject: [PATCH 09/11] use functions for int status code error message
 conversion instead of maps

---
 src/app/file/webp_format.cpp | 63 ++++++++++++++++++------------------
 1 file changed, 32 insertions(+), 31 deletions(-)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index cf851f3a04..f1c2f4893a 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -74,18 +74,19 @@ FileFormat* CreateWebPFormat()
   return new WebPFormat;
 }
 
-const std::pair<VP8StatusCode, std::string> dec_error_map_data[] = {
-    std::make_pair(VP8_STATUS_OK, ""),
-    std::make_pair(VP8_STATUS_OUT_OF_MEMORY, "out of memory"),
-    std::make_pair(VP8_STATUS_INVALID_PARAM, "invalid parameters"),
-    std::make_pair(VP8_STATUS_BITSTREAM_ERROR, "bitstream error"),
-    std::make_pair(VP8_STATUS_UNSUPPORTED_FEATURE, "unsupported feature"),
-    std::make_pair(VP8_STATUS_SUSPENDED, "suspended"),
-    std::make_pair(VP8_STATUS_USER_ABORT, "user aborted"),
-    std::make_pair(VP8_STATUS_NOT_ENOUGH_DATA, "not enough data")
-};
-
-const std::map<VP8StatusCode, std::string> WebPDecodingErrorMap(dec_error_map_data, dec_error_map_data + sizeof dec_error_map_data / sizeof dec_error_map_data[0]);
+const char* getDecoderErrorMessage(VP8StatusCode statusCode) {
+  switch (statusCode) {
+  case VP8_STATUS_OK: return ""; break;
+  case VP8_STATUS_OUT_OF_MEMORY: return "out of memory"; break;
+  case VP8_STATUS_INVALID_PARAM: return "invalid parameters"; break;
+  case VP8_STATUS_BITSTREAM_ERROR: return "bitstream error"; break;
+  case VP8_STATUS_UNSUPPORTED_FEATURE: return "unsupported feature"; break;
+  case VP8_STATUS_SUSPENDED: return "suspended"; break;
+  case VP8_STATUS_USER_ABORT: return "user aborted"; break;
+  case VP8_STATUS_NOT_ENOUGH_DATA: return "not enough data"; break;
+  default: return "unknown error"; break;
+  }
+}
 
 bool WebPFormat::onLoad(FileOp* fop)
 {
@@ -151,7 +152,7 @@ bool WebPFormat::onLoad(FileOp* fop)
       if (bytes_remaining < bytes_read) bytes_read = bytes_remaining;
       fop_progress(fop, 1.0f - ((float)std::max(bytes_remaining, 0l)/(float)len));
     } else {
-      fop_error(fop, "Error during decoding %s : %s\n", fop->filename.c_str(), WebPDecodingErrorMap.find(status)->second.c_str());
+      fop_error(fop, "Error during decoding %s : %s\n", fop->filename.c_str(), getDecoderErrorMessage(status));
       WebPIDelete(idec);
       WebPFreeDecBuffer(&config.output);
       return false;
@@ -175,23 +176,23 @@ struct writerData {
   FileOp* fop;
 };
 
-const std::pair<WebPEncodingError, std::string> enc_error_map_data[] = {
-    std::make_pair(VP8_ENC_OK, ""),
-    std::make_pair(VP8_ENC_ERROR_OUT_OF_MEMORY, "memory error allocating objects"),
-    std::make_pair(VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY, "memory error while flushing bits"),
-    std::make_pair(VP8_ENC_ERROR_NULL_PARAMETER, "a pointer parameter is NULL"),
-    std::make_pair(VP8_ENC_ERROR_INVALID_CONFIGURATION, "configuration is invalid"),
-    std::make_pair(VP8_ENC_ERROR_BAD_DIMENSION, "picture has invalid width/height"),
-    std::make_pair(VP8_ENC_ERROR_PARTITION0_OVERFLOW, "partition is bigger than 512k"),
-    std::make_pair(VP8_ENC_ERROR_PARTITION_OVERFLOW, "partition is bigger than 16M"),
-    std::make_pair(VP8_ENC_ERROR_BAD_WRITE, "error while flushing bytes"),
-    std::make_pair(VP8_ENC_ERROR_FILE_TOO_BIG, "file is bigger than 4G"),
-    std::make_pair(VP8_ENC_ERROR_OUT_OF_MEMORY, "memory error allocating objects"),
-    std::make_pair(VP8_ENC_ERROR_USER_ABORT, "abort request by user"),
-    std::make_pair(VP8_ENC_ERROR_LAST, "list terminator. always last.")
-};
-
-const std::map<WebPEncodingError, std::string> WebPEncodingErrorMap(enc_error_map_data, enc_error_map_data + sizeof enc_error_map_data / sizeof enc_error_map_data[0]);
+const char* getEncoderErrorMessage(WebPEncodingError errorCode) {
+  switch (errorCode) {
+  case VP8_ENC_OK: return ""; break;
+  case VP8_ENC_ERROR_OUT_OF_MEMORY: return "memory error allocating objects"; break;
+  case VP8_ENC_ERROR_BITSTREAM_OUT_OF_MEMORY: return "memory error while flushing bits"; break;
+  case VP8_ENC_ERROR_NULL_PARAMETER: return "a pointer parameter is NULL"; break;
+  case VP8_ENC_ERROR_INVALID_CONFIGURATION: return "configuration is invalid"; break;
+  case VP8_ENC_ERROR_BAD_DIMENSION: return "picture has invalid width/height"; break;
+  case VP8_ENC_ERROR_PARTITION0_OVERFLOW: return "partition is bigger than 512k"; break;
+  case VP8_ENC_ERROR_PARTITION_OVERFLOW: return "partition is bigger than 16M"; break;
+  case VP8_ENC_ERROR_BAD_WRITE: return "error while flushing bytes"; break;
+  case VP8_ENC_ERROR_FILE_TOO_BIG: return "file is bigger than 4G"; break;
+  case VP8_ENC_ERROR_USER_ABORT: return "abort request by user"; break;
+  case VP8_ENC_ERROR_LAST: return "abort request by user"; break;
+  default: return ""; break;
+  }
+}
 
 #if WEBP_ENCODER_ABI_VERSION < 0x0203
 #define MAX_LEVEL 9
@@ -290,7 +291,7 @@ bool WebPFormat::onSave(FileOp* fop)
   pic.progress_hook = ProgressReport;
 
   if (!WebPEncode(&config, &pic)) {
-    fop_error(fop, "Error for LibWebP while Encoding %s: %s\n", fop->filename.c_str(), WebPEncodingErrorMap.find(pic.error_code)->second.c_str());
+    fop_error(fop, "Error for LibWebP while Encoding %s: %s\n", fop->filename.c_str(), getEncoderErrorMessage(pic.error_code));
     WebPPictureFree(&pic);
     return false;
   }

From 7a3aa6d0c4c893281514c3c6c9e793e9adf27aae Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 13:34:40 +0200
Subject: [PATCH 10/11] replace auto keyword with corresponding types

---
 src/app/file/webp_format.cpp | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index f1c2f4893a..b93f34480c 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -107,7 +107,7 @@ bool WebPFormat::onLoad(FileOp* fop)
   }
 
   std::vector<uint8_t> buf(len);
-  auto* data = &buf.front();
+  uint8_t* data = &buf.front();
 
   if (!fread(data, sizeof(uint8_t), len, fp)) {
     fop_error(fop, "Error while writing to %s to memory\n", fop->filename.c_str());
@@ -127,7 +127,7 @@ bool WebPFormat::onLoad(FileOp* fop)
 
   fop->seq.has_alpha = config.input.has_alpha;
 
-  auto image = fop_sequence_image(fop, IMAGE_RGB, config.input.width, config.input.height);
+  Image* image = fop_sequence_image(fop, IMAGE_RGB, config.input.width, config.input.height);
 
   config.output.colorspace = MODE_RGBA;
   config.output.u.RGBA.rgba = (uint8_t*)image->getPixelAddress(0, 0);
@@ -141,8 +141,8 @@ bool WebPFormat::onLoad(FileOp* fop)
     return false;
   }
 
-  auto bytes_remaining = len;
-  auto bytes_read = std::max(4l, len/100l);
+  long bytes_remaining = len;
+  long bytes_read = std::max(4l, len/100l);
 
   while (bytes_remaining > 0) {
     VP8StatusCode status = WebPIAppend(idec, data, bytes_read);
@@ -232,7 +232,7 @@ bool WebPFormat::onSave(FileOp* fop)
 
   struct writerData wd = {fp, fop};
 
-  auto image = fop->seq.image.get();
+  Image* image = fop->seq.image.get();
   if (image->width() > WEBP_MAX_DIMENSION || image->height() > WEBP_MAX_DIMENSION) {
    fop_error(
      fop, "Error: WebP can only have a maximum width and height of %i but your %s has a size of %i x %i\n",

From c2a58dd46fc2d300ce82df16f3052339cce5f058 Mon Sep 17 00:00:00 2001
From: Gabriel Rauter <rauter.gabriel@gmail.com>
Date: Wed, 2 Sep 2015 14:50:01 +0200
Subject: [PATCH 11/11] fix type conversion warn. & remove problem preset

fix type conversions by putting WebPOptions Class in a seperate file like
GifOptions and use Getter and Setter for better handling. In cases
needed explicit casting was used to supress those warings.

Additionaly the LAST WebPHint Option was removed as it does not work for
this situation.
---
 data/widgets/webp_options.xml |  1 -
 src/app/file/webp_format.cpp  | 65 +++++++++++++++--------------------
 src/app/file/webp_options.h   | 48 ++++++++++++++++++++++++++
 3 files changed, 76 insertions(+), 38 deletions(-)
 create mode 100644 src/app/file/webp_options.h

diff --git a/data/widgets/webp_options.xml b/data/widgets/webp_options.xml
index 29f88859ab..50fe266782 100644
--- a/data/widgets/webp_options.xml
+++ b/data/widgets/webp_options.xml
@@ -16,7 +16,6 @@
         <listitem text="Picture" value="1" />
         <listitem text="Photo" value="2" />
         <listitem text="Graph" value="3" />
-        <listitem text="Last" value="4" />
       </combobox>
     </hbox>
     <separator horizontal="true" />
diff --git a/src/app/file/webp_format.cpp b/src/app/file/webp_format.cpp
index b93f34480c..00bcf762a7 100644
--- a/src/app/file/webp_format.cpp
+++ b/src/app/file/webp_format.cpp
@@ -16,6 +16,7 @@
 #include "app/file/file.h"
 #include "app/file/file_format.h"
 #include "app/file/format_options.h"
+#include "app/file/webp_options.h"
 #include "app/ini_file.h"
 #include "base/file_handle.h"
 #include "base/convert_to.h"
@@ -38,16 +39,6 @@ namespace app {
 using namespace base;
 
 class WebPFormat : public FileFormat {
-  // Data for WEBP files TODO make this better OOP like GIF_OPTIONS
-  class WebPOptions : public FormatOptions {
-  public:
-    WebPOptions(): lossless(1), quality(75), method(6), image_hint(WEBP_HINT_DEFAULT), image_preset(WEBP_PRESET_DEFAULT) {};
-    int lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
-    float quality;          // between 0 (smallest file) and 100 (biggest)
-    int method;             // quality/speed trade-off (0=fast, 9=slower-better)
-    WebPImageHint image_hint;  // Hint for image type (lossless only for now).
-    WebPPreset image_preset;  // Image Preset for lossy webp.
-  };
 
   const char* onGetName() const { return "webp"; }
   const char* onGetExtensions() const { return "webp"; }
@@ -125,7 +116,7 @@ bool WebPFormat::onLoad(FileOp* fop)
     return false;
   }
 
-  fop->seq.has_alpha = config.input.has_alpha;
+  fop->seq.has_alpha = (config.input.has_alpha != 0);
 
   Image* image = fop_sequence_image(fop, IMAGE_RGB, config.input.width, config.input.height);
 
@@ -163,7 +154,7 @@ bool WebPFormat::onLoad(FileOp* fop)
 
   base::SharedPtr<WebPOptions> webPOptions = base::SharedPtr<WebPOptions>(new WebPOptions());
   fop->seq.format_options = webPOptions;
-  webPOptions->lossless = std::min(config.input.format - 1, 1);
+  webPOptions->setLossless(std::min(config.input.format - 1, 1));
 
   WebPIDelete(idec);
   WebPFreeDecBuffer(&config.output);
@@ -245,14 +236,14 @@ bool WebPFormat::onSave(FileOp* fop)
 
   WebPConfig config;
 
-  if (webp_options->lossless) {
-    if (!(WebPConfigInit(&config) && WebPConfigLosslessPreset(&config, webp_options->method))) {
+  if (webp_options->lossless()) {
+    if (!(WebPConfigInit(&config) && WebPConfigLosslessPreset(&config, webp_options->getMethod()))) {
      fop_error(fop, "Error for WebP Config Version for file %s\n", fop->filename.c_str());
      return false;
     }
-    config.image_hint = webp_options->image_hint;
+    config.image_hint = webp_options->getImageHint();
   } else {
-    if (!WebPConfigPreset(&config, webp_options->image_preset, webp_options->quality)) {
+    if (!WebPConfigPreset(&config, webp_options->getImagePreset(), static_cast<float>(webp_options->getQuality()))) {
      fop_error(fop, "Error for WebP Config Version for file %s\n", fop->filename.c_str());
      return false;
     }
@@ -271,7 +262,7 @@ bool WebPFormat::onSave(FileOp* fop)
 
   pic.width = image->width();
   pic.height = image->height();
-  if (webp_options->lossless) {
+  if (webp_options->lossless()) {
     pic.use_argb = true;
   }
 
@@ -317,34 +308,34 @@ base::SharedPtr<FormatOptions> WebPFormat::onGetFormatOptions(FileOp* fop)
 
   try {
     // Configuration parameters
-    webp_options->quality = get_config_int("WEBP", "Quality", webp_options->quality);
-    webp_options->method = get_config_int("WEBP", "Compression", webp_options->method);
-    webp_options->image_hint = static_cast<WebPImageHint>(get_config_int("WEBP", "ImageHint", webp_options->image_hint));
-    webp_options->image_preset = static_cast<WebPPreset>(get_config_int("WEBP", "ImagePreset", webp_options->image_preset));
+    webp_options->setQuality(get_config_int("WEBP", "Quality", webp_options->getQuality()));
+    webp_options->setMethod(get_config_int("WEBP", "Compression", webp_options->getMethod()));
+    webp_options->setImageHint(get_config_int("WEBP", "ImageHint", webp_options->getImageHint()));
+    webp_options->setImagePreset(get_config_int("WEBP", "ImagePreset", webp_options->getImagePreset()));
 
     // Load the window to ask to the user the WebP options he wants.
 
     app::gen::WebpOptions win;
-    win.lossless()->setSelected(webp_options->lossless);
-    win.lossy()->setSelected(!webp_options->lossless);
-    win.quality()->setValue(webp_options->quality);
-    win.compression()->setValue(webp_options->method);
-    win.imageHint()->setSelectedItemIndex(webp_options->image_hint);
-    win.imagePreset()->setSelectedItemIndex(webp_options->image_preset);
+    win.lossless()->setSelected(webp_options->lossless());
+    win.lossy()->setSelected(!webp_options->lossless());
+    win.quality()->setValue(static_cast<int>(webp_options->getQuality()));
+    win.compression()->setValue(webp_options->getMethod());
+    win.imageHint()->setSelectedItemIndex(webp_options->getImageHint());
+    win.imagePreset()->setSelectedItemIndex(webp_options->getImagePreset());
 
     win.openWindowInForeground();
 
     if (win.getKiller() == win.ok()) {
-      webp_options->quality = win.quality()->getValue();
-      webp_options->method = win.compression()->getValue();
-      webp_options->lossless = win.lossless()->isSelected();
-      webp_options->image_hint = static_cast<WebPImageHint>(base::convert_to<int>(win.imageHint()->getValue()));
-      webp_options->image_preset = static_cast<WebPPreset>(base::convert_to<int>(win.imagePreset()->getValue()));
-
-      set_config_int("WEBP", "Quality", webp_options->quality);
-      set_config_int("WEBP", "Compression", webp_options->method);
-      set_config_int("WEBP", "ImageHint", webp_options->image_hint);
-      set_config_int("WEBP", "ImagePreset", webp_options->image_preset);
+      webp_options->setQuality(win.quality()->getValue());
+      webp_options->setMethod(win.compression()->getValue());
+      webp_options->setLossless(win.lossless()->isSelected());
+      webp_options->setImageHint(base::convert_to<int>(win.imageHint()->getValue()));
+      webp_options->setImagePreset(base::convert_to<int>(win.imagePreset()->getValue()));
+
+      set_config_int("WEBP", "Quality", webp_options->getQuality());
+      set_config_int("WEBP", "Compression", webp_options->getMethod());
+      set_config_int("WEBP", "ImageHint", webp_options->getImageHint());
+      set_config_int("WEBP", "ImagePreset", webp_options->getImagePreset());
     }
     else {
       webp_options.reset(NULL);
diff --git a/src/app/file/webp_options.h b/src/app/file/webp_options.h
new file mode 100644
index 0000000000..404258b268
--- /dev/null
+++ b/src/app/file/webp_options.h
@@ -0,0 +1,48 @@
+// Aseprite
+// Copyright (C) 2015  Gabriel Rauter
+//
+// This program is free software; you can redistribute it and/or modify
+// it under the terms of the GNU General Public License version 2 as
+// published by the Free Software Foundation.
+
+#ifndef APP_FILE_WEBP_OPTIONS_H_INCLUDED
+#define APP_FILE_WEBP_OPTIONS_H_INCLUDED
+#pragma once
+
+#include "app/file/format_options.h"
+
+#include <webp/decode.h>
+#include <webp/encode.h>
+
+namespace app {
+  // Data for WebP files
+  class WebPOptions : public FormatOptions {
+  public:
+    WebPOptions(): m_lossless(1), m_quality(75), m_method(6), m_image_hint(WEBP_HINT_DEFAULT), m_image_preset(WEBP_PRESET_DEFAULT) {};
+
+    bool lossless() { return m_lossless; }
+    int getQuality() { return m_quality; }
+    int getMethod() { return m_method; }
+    WebPImageHint getImageHint() { return m_image_hint; }
+    WebPPreset getImagePreset() { return m_image_preset; }
+
+    void setLossless(int lossless) { m_lossless = (lossless != 0); }
+    void setLossless(bool lossless) { m_lossless = lossless; }
+    void setQuality(int quality) { m_quality = quality; }
+    void setMethod(int method) { m_method = method; }
+    void setImageHint(int imageHint) { m_image_hint = static_cast<WebPImageHint>(imageHint); }
+    void setImageHint(WebPImageHint imageHint) { m_image_hint = imageHint; }
+    void setImagePreset(int imagePreset) { m_image_preset = static_cast<WebPPreset>(imagePreset); };
+    void setImagePreset(WebPPreset imagePreset) { m_image_preset = imagePreset ; }
+
+  private:
+    bool m_lossless;           // Lossless encoding (0=lossy(default), 1=lossless).
+    int m_quality;          // between 0 (smallest file) and 100 (biggest)
+    int m_method;             // quality/speed trade-off (0=fast, 9=slower-better)
+    WebPImageHint m_image_hint;  // Hint for image type (lossless only for now).
+    WebPPreset m_image_preset;  // Image Preset for lossy webp.
+  };
+
+} // namespace app
+
+#endif