libwebp-0.6.0-rc1

third_party/libwebp/enc/picture.c

Index: third_party/libwebp/enc/picture.c
diff --git a/third_party/libwebp/enc/picture.c b/third_party/libwebp/enc/picture.c
deleted file mode 100644
index 28c56cd6e54d18cbfa9933b25f3bf7ad0e74942f..0000000000000000000000000000000000000000
--- a/third_party/libwebp/enc/picture.c
+++ /dev/null
@@ -1,293 +0,0 @@
-// Copyright 2011 Google Inc. All Rights Reserved.
-//
-// Use of this source code is governed by a BSD-style license
-// that can be found in the COPYING file in the root of the source
-// tree. An additional intellectual property rights grant can be found
-// in the file PATENTS. All contributing project authors may
-// be found in the AUTHORS file in the root of the source tree.
-// -----------------------------------------------------------------------------
-//
-// WebPPicture class basis
-//
-// Author: Skal (pascal.massimino@gmail.com)
-
-#include <assert.h>
-#include <stdlib.h>
-
-#include "./vp8enci.h"
-#include "../dsp/dsp.h"
-#include "../utils/utils.h"
-
-//------------------------------------------------------------------------------
-// WebPPicture
-//------------------------------------------------------------------------------
-
-static int DummyWriter(const uint8_t* data, size_t data_size,
-                       const WebPPicture* const picture) {
-  // The following are to prevent 'unused variable' error message.
-  (void)data;
-  (void)data_size;
-  (void)picture;
-  return 1;
-}
-
-int WebPPictureInitInternal(WebPPicture* picture, int version) {
-  if (WEBP_ABI_IS_INCOMPATIBLE(version, WEBP_ENCODER_ABI_VERSION)) {
-    return 0;   // caller/system version mismatch!
-  }
-  if (picture != NULL) {
-    memset(picture, 0, sizeof(*picture));
-    picture->writer = DummyWriter;
-    WebPEncodingSetError(picture, VP8_ENC_OK);
-  }
-  return 1;
-}
-
-//------------------------------------------------------------------------------
-
-static void WebPPictureResetBufferARGB(WebPPicture* const picture) {
-  picture->memory_argb_ = NULL;
-  picture->argb = NULL;
-  picture->argb_stride = 0;
-}
-
-static void WebPPictureResetBufferYUVA(WebPPicture* const picture) {
-  picture->memory_ = NULL;
-  picture->y = picture->u = picture->v = picture->a = NULL;
-  picture->y_stride = picture->uv_stride = 0;
-  picture->a_stride = 0;
-}
-
-void WebPPictureResetBuffers(WebPPicture* const picture) {
-  WebPPictureResetBufferARGB(picture);
-  WebPPictureResetBufferYUVA(picture);
-}
-
-int WebPPictureAllocARGB(WebPPicture* const picture, int width, int height) {
-  void* memory;
-  const uint64_t argb_size = (uint64_t)width * height;
-
-  assert(picture != NULL);
-
-  WebPSafeFree(picture->memory_argb_);
-  WebPPictureResetBufferARGB(picture);
-
-  if (width <= 0 || height <= 0) {
-    return WebPEncodingSetError(picture, VP8_ENC_ERROR_BAD_DIMENSION);
-  }
-  // allocate a new buffer.
-  memory = WebPSafeMalloc(argb_size, sizeof(*picture->argb));
-  if (memory == NULL) {
-    return WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
-  }
-  // TODO(skal): align plane to cache line?
-  picture->memory_argb_ = memory;
-  picture->argb = (uint32_t*)memory;
-  picture->argb_stride = width;
-  return 1;
-}
-
-int WebPPictureAllocYUVA(WebPPicture* const picture, int width, int height) {
-  const WebPEncCSP uv_csp =
-      (WebPEncCSP)((int)picture->colorspace & WEBP_CSP_UV_MASK);
-  const int has_alpha = (int)picture->colorspace & WEBP_CSP_ALPHA_BIT;
-  const int y_stride = width;
-  const int uv_width = (width + 1) >> 1;
-  const int uv_height = (height + 1) >> 1;
-  const int uv_stride = uv_width;
-  int a_width, a_stride;
-  uint64_t y_size, uv_size, a_size, total_size;
-  uint8_t* mem;
-
-  assert(picture != NULL);
-
-  WebPSafeFree(picture->memory_);
-  WebPPictureResetBufferYUVA(picture);
-
-  if (uv_csp != WEBP_YUV420) {
-    return WebPEncodingSetError(picture, VP8_ENC_ERROR_INVALID_CONFIGURATION);
-  }
-
-  // alpha
-  a_width = has_alpha ? width : 0;
-  a_stride = a_width;
-  y_size = (uint64_t)y_stride * height;
-  uv_size = (uint64_t)uv_stride * uv_height;
-  a_size =  (uint64_t)a_stride * height;
-
-  total_size = y_size + a_size + 2 * uv_size;
-
-  // Security and validation checks
-  if (width <= 0 || height <= 0 ||         // luma/alpha param error
-      uv_width < 0 || uv_height < 0) {     // u/v param error
-    return WebPEncodingSetError(picture, VP8_ENC_ERROR_BAD_DIMENSION);
-  }
-  // allocate a new buffer.
-  mem = (uint8_t*)WebPSafeMalloc(total_size, sizeof(*mem));
-  if (mem == NULL) {
-    return WebPEncodingSetError(picture, VP8_ENC_ERROR_OUT_OF_MEMORY);
-  }
-
-  // From now on, we're in the clear, we can no longer fail...
-  picture->memory_ = (void*)mem;
-  picture->y_stride  = y_stride;
-  picture->uv_stride = uv_stride;
-  picture->a_stride  = a_stride;
-
-  // TODO(skal): we could align the y/u/v planes and adjust stride.
-  picture->y = mem;
-  mem += y_size;
-
-  picture->u = mem;
-  mem += uv_size;
-  picture->v = mem;
-  mem += uv_size;
-
-  if (a_size > 0) {
-    picture->a = mem;
-    mem += a_size;
-  }
-  (void)mem;  // makes the static analyzer happy
-  return 1;
-}
-
-int WebPPictureAlloc(WebPPicture* picture) {
-  if (picture != NULL) {
-    const int width = picture->width;
-    const int height = picture->height;
-
-    WebPPictureFree(picture);   // erase previous buffer
-
-    if (!picture->use_argb) {
-      return WebPPictureAllocYUVA(picture, width, height);
-    } else {
-      return WebPPictureAllocARGB(picture, width, height);
-    }
-  }
-  return 1;
-}
-
-void WebPPictureFree(WebPPicture* picture) {
-  if (picture != NULL) {
-    WebPSafeFree(picture->memory_);
-    WebPSafeFree(picture->memory_argb_);
-    WebPPictureResetBuffers(picture);
-  }
-}
-
-//------------------------------------------------------------------------------
-// WebPMemoryWriter: Write-to-memory
-
-void WebPMemoryWriterInit(WebPMemoryWriter* writer) {
-  writer->mem = NULL;
-  writer->size = 0;
-  writer->max_size = 0;
-}
-
-int WebPMemoryWrite(const uint8_t* data, size_t data_size,
-                    const WebPPicture* picture) {
-  WebPMemoryWriter* const w = (WebPMemoryWriter*)picture->custom_ptr;
-  uint64_t next_size;
-  if (w == NULL) {
-    return 1;
-  }
-  next_size = (uint64_t)w->size + data_size;
-  if (next_size > w->max_size) {
-    uint8_t* new_mem;
-    uint64_t next_max_size = 2ULL * w->max_size;
-    if (next_max_size < next_size) next_max_size = next_size;
-    if (next_max_size < 8192ULL) next_max_size = 8192ULL;
-    new_mem = (uint8_t*)WebPSafeMalloc(next_max_size, 1);
-    if (new_mem == NULL) {
-      return 0;
-    }
-    if (w->size > 0) {
-      memcpy(new_mem, w->mem, w->size);
-    }
-    WebPSafeFree(w->mem);
-    w->mem = new_mem;
-    // down-cast is ok, thanks to WebPSafeMalloc
-    w->max_size = (size_t)next_max_size;
-  }
-  if (data_size > 0) {
-    memcpy(w->mem + w->size, data, data_size);
-    w->size += data_size;
-  }
-  return 1;
-}
-
-void WebPMemoryWriterClear(WebPMemoryWriter* writer) {
-  if (writer != NULL) {
-    WebPSafeFree(writer->mem);
-    writer->mem = NULL;
-    writer->size = 0;
-    writer->max_size = 0;
-  }
-}
-
-//------------------------------------------------------------------------------
-// Simplest high-level calls:
-
-typedef int (*Importer)(WebPPicture* const, const uint8_t* const, int);
-
-static size_t Encode(const uint8_t* rgba, int width, int height, int stride,
-                     Importer import, float quality_factor, int lossless,
-                     uint8_t** output) {
-  WebPPicture pic;
-  WebPConfig config;
-  WebPMemoryWriter wrt;
-  int ok;
-
-  if (output == NULL) return 0;
-
-  if (!WebPConfigPreset(&config, WEBP_PRESET_DEFAULT, quality_factor) ||
-      !WebPPictureInit(&pic)) {
-    return 0;  // shouldn't happen, except if system installation is broken
-  }
-
-  config.lossless = !!lossless;
-  pic.use_argb = !!lossless;
-  pic.width = width;
-  pic.height = height;
-  pic.writer = WebPMemoryWrite;
-  pic.custom_ptr = &wrt;
-  WebPMemoryWriterInit(&wrt);
-
-  ok = import(&pic, rgba, stride) && WebPEncode(&config, &pic);
-  WebPPictureFree(&pic);
-  if (!ok) {
-    WebPMemoryWriterClear(&wrt);
-    *output = NULL;
-    return 0;
-  }
-  *output = wrt.mem;
-  return wrt.size;
-}
-
-#define ENCODE_FUNC(NAME, IMPORTER)                                     \
-size_t NAME(const uint8_t* in, int w, int h, int bps, float q,          \
-            uint8_t** out) {                                            \
-  return Encode(in, w, h, bps, IMPORTER, q, 0, out);                    \
-}
-
-ENCODE_FUNC(WebPEncodeRGB, WebPPictureImportRGB)
-ENCODE_FUNC(WebPEncodeBGR, WebPPictureImportBGR)
-ENCODE_FUNC(WebPEncodeRGBA, WebPPictureImportRGBA)
-ENCODE_FUNC(WebPEncodeBGRA, WebPPictureImportBGRA)
-
-#undef ENCODE_FUNC
-
-#define LOSSLESS_DEFAULT_QUALITY 70.
-#define LOSSLESS_ENCODE_FUNC(NAME, IMPORTER)                                 \
-size_t NAME(const uint8_t* in, int w, int h, int bps, uint8_t** out) {       \
-  return Encode(in, w, h, bps, IMPORTER, LOSSLESS_DEFAULT_QUALITY, 1, out);  \
-}
-
-LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessRGB, WebPPictureImportRGB)
-LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessBGR, WebPPictureImportBGR)
-LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessRGBA, WebPPictureImportRGBA)
-LOSSLESS_ENCODE_FUNC(WebPEncodeLosslessBGRA, WebPPictureImportBGRA)
-
-#undef LOSSLESS_ENCODE_FUNC
-
-//------------------------------------------------------------------------------