libwebp: update to 0.4.1

third_party/libwebp/dec/frame.c

 // Copyright 2010 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.
 // -----------------------------------------------------------------------------
 //
 // Frame-reconstruction function. Memory allocation.
@@ skipping 159 matching lines @@
           const int idx = (dqm->uv_quant_ < 0) ? 0 : dqm->uv_quant_;
           dqm->dither_ = (f * kQuantToDitherAmp[idx]) >> 3;
         }
         all_amp |= dqm->dither_;
       }
       if (all_amp != 0) {
         VP8InitRandom(&dec->dithering_rg_, 1.0f);
         dec->dither_ = 1;
       }
     }
+#if WEBP_DECODER_ABI_VERSION > 0x0203
+    // potentially allow alpha dithering
+    dec->alpha_dithering_ = options->alpha_dithering_strength;
+    if (dec->alpha_dithering_ > 100) {
+      dec->alpha_dithering_ = 100;
+    } else if (dec->alpha_dithering_ < 0) {
+      dec->alpha_dithering_ = 0;
+    }
+#endif
   }
 }
 
 // minimal amp that will provide a non-zero dithering effect
 #define MIN_DITHER_AMP 4
 #define DITHER_DESCALE 4
 #define DITHER_DESCALE_ROUNDER (1 << (DITHER_DESCALE - 1))
 #define DITHER_AMP_BITS 8
 #define DITHER_AMP_CENTER (1 << DITHER_AMP_BITS)
 
@@ skipping 150 matching lines @@
       (dec->mb_y_ >= dec->tl_mb_y_) && (dec->mb_y_ <= dec->br_mb_y_);
   if (dec->mt_method_ == 0) {
     // ctx->id_ and ctx->f_info_ are already set
     ctx->mb_y_ = dec->mb_y_;
     ctx->filter_row_ = filter_row;
     ReconstructRow(dec, ctx);
     ok = FinishRow(dec, io);
   } else {
     WebPWorker* const worker = &dec->worker_;
     // Finish previous job *before* updating context
-    ok &= WebPWorkerSync(worker);
+    ok &= WebPGetWorkerInterface()->Sync(worker);
     assert(worker->status_ == OK);
     if (ok) {   // spawn a new deblocking/output job
       ctx->io_ = *io;
       ctx->id_ = dec->cache_id_;
       ctx->mb_y_ = dec->mb_y_;
       ctx->filter_row_ = filter_row;
       if (dec->mt_method_ == 2) {  // swap macroblock data
         VP8MBData* const tmp = ctx->mb_data_;
         ctx->mb_data_ = dec->mb_data_;
         dec->mb_data_ = tmp;
       } else {
         // perform reconstruction directly in main thread
         ReconstructRow(dec, ctx);
       }
       if (filter_row) {            // swap filter info
         VP8FInfo* const tmp = ctx->f_info_;
         ctx->f_info_ = dec->f_info_;
         dec->f_info_ = tmp;
       }
-      WebPWorkerLaunch(worker);    // (reconstruct)+filter in parallel
+      // (reconstruct)+filter in parallel
+      WebPGetWorkerInterface()->Launch(worker);
       if (++dec->cache_id_ == dec->num_caches_) {
         dec->cache_id_ = 0;
       }
     }
   }
   return ok;
 }
 
 //------------------------------------------------------------------------------
 // Finish setting up the decoding parameter once user's setup() is called.
@@ skipping 49 matching lines @@
       dec->br_mb_y_ = dec->mb_h_;
     }
   }
   PrecomputeFilterStrengths(dec);
   return VP8_STATUS_OK;
 }
 
 int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
   int ok = 1;
   if (dec->mt_method_ > 0) {
-    ok = WebPWorkerSync(&dec->worker_);
+    ok = WebPGetWorkerInterface()->Sync(&dec->worker_);
   }
 
   if (io->teardown != NULL) {
     io->teardown(io);
   }
   return ok;
 }
 
 //------------------------------------------------------------------------------
 // For multi-threaded decoding we need to use 3 rows of 16 pixels as delay line.
@@ skipping 20 matching lines @@
 // io->put:         [ 0..15][16..31][ 0..15][...
 
 #define MT_CACHE_LINES 3
 #define ST_CACHE_LINES 1   // 1 cache row only for single-threaded case
 
 // Initialize multi/single-thread worker
 static int InitThreadContext(VP8Decoder* const dec) {
   dec->cache_id_ = 0;
   if (dec->mt_method_ > 0) {
     WebPWorker* const worker = &dec->worker_;
-    if (!WebPWorkerReset(worker)) {
+    if (!WebPGetWorkerInterface()->Reset(worker)) {
       return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                          "thread initialization failed.");
     }
     worker->data1 = dec;
     worker->data2 = (void*)&dec->thread_ctx_.io_;
     worker->hook = (WebPWorkerHook)FinishRow;
     dec->num_caches_ =
       (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
   } else {
     dec->num_caches_ = ST_CACHE_LINES;
   }
   return 1;
 }
 
 int VP8GetThreadMethod(const WebPDecoderOptions* const options,
                        const WebPHeaderStructure* const headers,
                        int width, int height) {
   if (options == NULL || options->use_threads == 0) {
     return 0;
   }
   (void)headers;
   (void)width;
   (void)height;
-  assert(!headers->is_lossless);
+  assert(headers == NULL || !headers->is_lossless);
 #if defined(WEBP_USE_THREAD)
   if (width < MIN_WIDTH_FOR_THREADS) return 0;
   // TODO(skal): tune the heuristic further
 #if 0
   if (height < 2 * width) return 2;
 #endif
   return 2;
 #else   // !WEBP_USE_THREAD
   return 0;
 #endif
@@ skipping 26 matching lines @@
   const uint64_t alpha_size = (dec->alpha_data_ != NULL) ?
       (uint64_t)dec->pic_hdr_.width_ * dec->pic_hdr_.height_ : 0ULL;
   const uint64_t needed = (uint64_t)intra_pred_mode_size
                         + top_size + mb_info_size + f_info_size
                         + yuv_size + mb_data_size
                         + cache_size + alpha_size + ALIGN_MASK;
   uint8_t* mem;
 
   if (needed != (size_t)needed) return 0;  // check for overflow
   if (needed > dec->mem_size_) {
-    free(dec->mem_);
+    WebPSafeFree(dec->mem_);
     dec->mem_size_ = 0;
     dec->mem_ = WebPSafeMalloc(needed, sizeof(uint8_t));
     if (dec->mem_ == NULL) {
       return VP8SetError(dec, VP8_STATUS_OUT_OF_MEMORY,
                          "no memory during frame initialization.");
     }
     // down-cast is ok, thanks to WebPSafeAlloc() above.
     dec->mem_size_ = (size_t)needed;
   }
 
@@ skipping 246 matching lines @@
       for (j = 0; j < 8; ++j) {
         memcpy(u_out + j * dec->cache_uv_stride_, u_dst + j * BPS, 8);
         memcpy(v_out + j * dec->cache_uv_stride_, v_dst + j * BPS, 8);
       }
     }
   }
 }
 
 //------------------------------------------------------------------------------