multi-thread decoding: ~25-30% faster

To be enabled with the flag WEBP_USE_THREAD.
For now it's only available on unix (pthread), when using Makefile.unix
Will be switched on more generally later.

In-loop filtering and output (=rescaling/yuv->rgb conversion)
is done in parallel to bitstream decoding, lagging 1 row behind.

Example:
examples/dwebp bryce.webp -v
Time to decode picture: 0.680s

examples/dwebp bryce.webp -v -mt
Time to decode picture: 0.515s

Change-Id: Ic30a897423137a3bdace9c4e30465ef758fe53f2

Android.mk

@@ -15,6 +15,7 @@ LOCAL_SRC_FILES := \
 	src/dec/io.c \
 	src/dec/buffer.c \
 	src/dec/yuv.c \
+	src/dec/thread.c \
 	src/enc/alpha.c \
 	src/enc/analysis.c \
 	src/enc/bit_writer.c \
@@ -30,7 +31,7 @@ LOCAL_SRC_FILES := \
 	src/enc/tree.c \
 	src/enc/webpenc.c
 
-LOCAL_CFLAGS := -Wall -DANDROID -DHAVE_MALLOC_H -DHAVE_PTHREAD \
+LOCAL_CFLAGS := -Wall -DANDROID -DHAVE_MALLOC_H -DHAVE_PTHREAD -DWEBP_USE_THREAD \
                 -finline-functions -frename-registers -ffast-math \
                 -s -fomit-frame-pointer -Isrc/webp
 

Makefile.vc

@@ -146,6 +146,7 @@ X_OBJS= \
 	$(DIROBJ)\dec\idec.obj \
 	$(DIROBJ)\dec\alpha.obj \
 	$(DIROBJ)\dec\layer.obj \
+	$(DIROBJ)\dec\thread.obj \
 	$(DIROBJ)\enc\analysis.obj \
 	$(DIROBJ)\enc\bit_writer.obj \
 	$(DIROBJ)\enc\config.obj \

README

@@ -217,6 +217,7 @@ Use following options to convert into alternate image formats:
   -version  .... print version number and exit.
   -nofancy ..... don't use the fancy YUV420 upscaler.
   -nofilter .... disable in-loop filtering.
+  -mt .......... use multi-threading
   -crop <x> <y> <w> <h> ... crop output with the given rectangle
   -scale <w> <h> .......... scale the output (*after* any cropping)
   -h     ....... this help message.

examples/dwebp.c

@@ -318,6 +318,7 @@ static void Help(void) {
          "  -version  .... print version number and exit.\n"
          "  -nofancy ..... don't use the fancy YUV420 upscaler.\n"
          "  -nofilter .... disable in-loop filtering.\n"
+         "  -mt .......... use multi-threading\n"
          "  -crop <x> <y> <w> <h> ... crop output with the given rectangle\n"
          "  -scale <w> <h> .......... scale the output (*after* any cropping)\n"
 #ifdef WEBP_EXPERIMENTAL_FEATURES
@@ -372,6 +373,8 @@ int main(int argc, const char *argv[]) {
       return 0;
     } else if (!strcmp(argv[c], "-pgm")) {
       format = PGM;
+    } else if (!strcmp(argv[c], "-mt")) {
+      config.options.use_threads = 1;
     } else if (!strcmp(argv[c], "-crop") && c < argc - 4) {
       config.options.use_cropping = 1;
       config.options.crop_left   = strtol(argv[++c], NULL, 0);

makefile.unix

@@ -36,12 +36,16 @@ endif
 # Extra flags to enable experimental features and code
 # EXTRA_FLAGS += -DWEBP_EXPERIMENTAL_FEATURES
 
+# Extra flags to enable multi-threading
+EXTRA_FLAGS += -DWEBP_USE_THREAD
+EXTRA_LIBS += -lpthread
+
 # Extra flags to emulate C89 strictness with the full ANSI
 EXTRA_FLAGS += -Wextra -Wold-style-definition
 EXTRA_FLAGS += -Wmissing-prototypes
 EXTRA_FLAGS += -Wmissing-declarations
 EXTRA_FLAGS += -Wdeclaration-after-statement
-# EXTRA_FLAGS += -Wvla
+EXTRA_FLAGS += -Wvla
 
 #### Nothing should normally be changed below this line ####
 
@@ -58,7 +62,7 @@ OBJS = src/enc/webpenc.o src/enc/bit_writer.o src/enc/syntax.o \
        src/dec/bits.o src/dec/dsp.o src/dec/dsp_sse2.o src/dec/frame.o \
        src/dec/webp.o src/dec/quant.o src/dec/tree.o src/dec/vp8.o \
        src/dec/yuv.o src/dec/idec.o src/dec/alpha.o src/dec/layer.o \
-       src/dec/io.o src/dec/io_sse2.o src/dec/buffer.o
+       src/dec/io.o src/dec/io_sse2.o src/dec/buffer.o src/dec/thread.o
 HDRS = src/webp/encode.h src/enc/vp8enci.h src/enc/bit_writer.h \
        src/enc/cost.h src/dec/bits.h  src/dec/vp8i.h src/dec/yuv.h
 OUTPUT = examples/cwebp examples/dwebp src/libwebp.a

man/dwebp.1

@@ -41,6 +41,9 @@ Don't use the in-loop filtering process even if it is required by
 the bitstream. This may produce visible blocks on the non-compliant output,
 but will make the decoding faster.
 .TP
+.B \-mt
+Use multi-threading for decoding, if possible.
+.TP
 .B \-crop x_position y_position width height
 Crop the decoded picture to a rectangle with top-left corner at coordinates
 (\fBx_position\fP, \fBy_position\fP) and size \fBwidth\fP x \fBheight\fP.

src/dec/Makefile.am

@@ -2,13 +2,13 @@ AM_CPPFLAGS = -I$(top_srcdir)/src
 
 libwebpdecode_la_SOURCES = bits.h vp8i.h yuv.h bits.c dsp.c dsp_sse2.c frame.c \
                           quant.c tree.c vp8.c webp.c yuv.c idec.c alpha.c \
-                          layer.c io.c io_sse2.c buffer.c
+                          layer.c io.c io_sse2.c buffer.c thread.c
 libwebpdecode_la_LDFLAGS = -version-info 0:0:0
 libwebpdecode_la_CPPFLAGS = $(USE_EXPERIMENTAL_CODE)
 libwebpdecodeinclude_HEADERS = ../webp/decode.h ../webp/decode_vp8.h ../webp/types.h
 libwebpdecodeincludedir = $(includedir)/webp
 
-noinst_HEADERS = bits.h vp8i.h webpi.h yuv.h
+noinst_HEADERS = bits.h vp8i.h webpi.h yuv.h thread.h
 
 noinst_LTLIBRARIES = libwebpdecode.la
 # uncomment the following line (and comment the above) if you want

src/dec/frame.c

@@ -18,6 +18,53 @@ extern "C" {
 
 #define ALIGN_MASK (32 - 1)
 
+//------------------------------------------------------------------------------
+// For multi-threaded decoding we need to use 3 rows of 16 pixels as delay line.
+//
+// Reason is: the deblocking filter cannot deblock the bottom horizontal edges
+// immediately, and needs to wait for first few rows of the next macroblock to
+// be decoded. Hence, deblocking is lagging behind by 4 or 8 pixels (depending
+// on strength).
+// With two threads, the vertical positions of the rows being decoded are:
+// Decode:  [ 0..15][16..31][32..47][48..63][64..79][...
+// Deblock:         [ 0..11][12..27][28..43][44..59][...
+// If we use two threads and two caches of 16 pixels, the sequence would be:
+// Decode:  [ 0..15][16..31][ 0..15!!][16..31][ 0..15][...
+// Deblock:         [ 0..11][12..27!!][-4..11][12..27][...
+// The problem occurs during row [12..15!!] that both the decoding and
+// deblocking threads are writing simultaneously.
+// With 3 cache lines, one get a safe write pattern:
+// Decode:  [ 0..15][16..31][32..47][ 0..15][16..31][32..47][0..
+// Deblock:         [ 0..11][12..27][28..43][-4..11][12..27][28...
+// Note that multi-threaded output _without_ deblocking can make use of two
+// cache lines of 16 pixels only, since there's no lagging behind. The decoding
+// and output process have non-concurrent writing:
+// Decode:  [ 0..15][16..31][ 0..15][16..31][...
+// 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->use_threads_) {
+    WebPWorker* const worker = &dec->worker_;
+    if (!WebPWorkerReset(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)VP8FinishRow;
+    dec->num_caches_ =
+      (dec->filter_type_ > 0) ? MT_CACHE_LINES : MT_CACHE_LINES - 1;
+  } else {
+    dec->num_caches_ = ST_CACHE_LINES;
+  }
+  return 1;
+}
+
 //------------------------------------------------------------------------------
 // Memory setup
 
@@ -28,19 +75,25 @@ extern "C" {
 //                 U/V, so it's 8 samples total (because of the 2x upsampling).
 static const uint8_t kFilterExtraRows[3] = { 0, 2, 8 };
 
-int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
+static int AllocateMemory(VP8Decoder* const dec) {
+  const int num_caches = dec->num_caches_;
   const int mb_w = dec->mb_w_;
   const int intra_pred_mode_size = 4 * mb_w * sizeof(uint8_t);
   const int top_size = (16 + 8 + 8) * mb_w;
-  const int info_size = (mb_w + 1) * sizeof(VP8MB);
+  const int mb_info_size = (mb_w + 1) * sizeof(VP8MB);
+  const int f_info_size =
+    (dec->filter_type_ > 0) ?
+        mb_w * (dec->use_threads_ ? 2 : 1) * sizeof(VP8FInfo)
+      : 0;
   const int yuv_size = YUV_SIZE * sizeof(*dec->yuv_b_);
   const int coeffs_size = 384 * sizeof(*dec->coeffs_);
-  const int cache_height = (16 + kFilterExtraRows[dec->filter_type_]) * 3 / 2;
+  const int cache_height = (16 * num_caches
+                         + kFilterExtraRows[dec->filter_type_]) * 3 / 2;
   const int cache_size = top_size * cache_height;
   const int alpha_size =
     dec->alpha_data_ ? (dec->pic_hdr_.width_ * dec->pic_hdr_.height_) : 0;
   const int needed = intra_pred_mode_size
-                   + top_size + info_size
+                   + top_size + mb_info_size + f_info_size
                    + yuv_size + coeffs_size
                    + cache_size + alpha_size + ALIGN_MASK;
   uint8_t* mem;
@@ -68,7 +121,18 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
   mem += 8 * mb_w;
 
   dec->mb_info_ = ((VP8MB*)mem) + 1;
-  mem += info_size;
+  mem += mb_info_size;
+
+  dec->f_info_ = f_info_size ? (VP8FInfo*)mem : NULL;
+  mem += f_info_size;
+  dec->thread_ctx_.id_ = 0;
+  dec->thread_ctx_.f_info_ = dec->f_info_;
+  if (dec->use_threads_) {
+    // secondary cache line. The deblocking process need to make use of the
+    // filtering strength from previous macroblock row, while the new ones
+    // are being decoded in parallel. We'll just swap the pointers.
+    dec->thread_ctx_.f_info_ += mb_w;
+  }
 
   mem = (uint8_t*)((uintptr_t)(mem + ALIGN_MASK) & ~ALIGN_MASK);
   assert((yuv_size & ALIGN_MASK) == 0);
@@ -85,8 +149,11 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
     const int extra_y = extra_rows * dec->cache_y_stride_;
     const int extra_uv = (extra_rows / 2) * dec->cache_uv_stride_;
     dec->cache_y_ = ((uint8_t*)mem) + extra_y;
-    dec->cache_u_ = dec->cache_y_ + 16 * dec->cache_y_stride_ + extra_uv;
+    dec->cache_u_ = dec->cache_y_
-    dec->cache_v_ = dec->cache_u_ + 8 * dec->cache_uv_stride_ + extra_uv;
+                  + 16 * num_caches * dec->cache_y_stride_ + extra_uv;
+    dec->cache_v_ = dec->cache_u_
+                  + 8 * num_caches * dec->cache_uv_stride_ + extra_uv;
+    dec->cache_id_ = 0;
   }
   mem += cache_size;
 
@@ -95,11 +162,15 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
   mem += alpha_size;
 
   // note: left-info is initialized once for all.
-  memset(dec->mb_info_ - 1, 0, (mb_w + 1) * sizeof(*dec->mb_info_));
+  memset(dec->mb_info_ - 1, 0, mb_info_size);
 
   // initialize top
   memset(dec->intra_t_, B_DC_PRED, intra_pred_mode_size);
 
+  return 1;
+}
+
+static void InitIo(VP8Decoder* const dec, VP8Io* io) {
   // prepare 'io'
   io->mb_y = 0;
   io->y = dec->cache_y_;
@@ -109,11 +180,14 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
   io->uv_stride = dec->cache_uv_stride_;
   io->fancy_upsampling = 0;    // default
   io->a = NULL;
+}
 
-  // Init critical function pointers and look-up tables.
+int VP8InitFrame(VP8Decoder* const dec, VP8Io* io) {
-  VP8DspInitTables();
+  if (!InitThreadContext(dec)) return 0;  // call first. Sets dec->num_caches_.
+  if (!AllocateMemory(dec)) return 0;
+  InitIo(dec, io);
+  VP8DspInitTables(); // Init critical function pointers and look-up tables.
   VP8DspInit();
-
   return 1;
 }
 
@@ -129,11 +203,12 @@ static inline int hev_thresh_from_level(int level, int keyframe) {
 }
 
 static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
-  VP8MB* const mb = dec->mb_info_ + mb_x;
+  const VP8ThreadContext* const ctx = &dec->thread_ctx_;
-  uint8_t* const y_dst = dec->cache_y_ + mb_x * 16;
   const int y_bps = dec->cache_y_stride_;
-  const int level = mb->f_level_;
+  VP8FInfo* const f_info = ctx->f_info_ + mb_x;
-  const int ilevel = mb->f_ilevel_;
+  uint8_t* const y_dst = dec->cache_y_ + ctx->id_ * 16 * y_bps + mb_x * 16;
+  const int level = f_info->f_level_;
+  const int ilevel = f_info->f_ilevel_;
   const int limit = 2 * level + ilevel;
   if (level == 0) {
     return;
@@ -142,26 +217,26 @@ static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
     if (mb_x > 0) {
       VP8SimpleHFilter16(y_dst, y_bps, limit + 4);
     }
-    if (mb->f_inner_) {
+    if (f_info->f_inner_) {
       VP8SimpleHFilter16i(y_dst, y_bps, limit);
     }
     if (mb_y > 0) {
       VP8SimpleVFilter16(y_dst, y_bps, limit + 4);
     }
-    if (mb->f_inner_) {
+    if (f_info->f_inner_) {
       VP8SimpleVFilter16i(y_dst, y_bps, limit);
     }
   } else {    // complex
-    uint8_t* const u_dst = dec->cache_u_ + mb_x * 8;
-    uint8_t* const v_dst = dec->cache_v_ + mb_x * 8;
     const int uv_bps = dec->cache_uv_stride_;
+    uint8_t* const u_dst = dec->cache_u_ + ctx->id_ * 8 * uv_bps + mb_x * 8;
+    uint8_t* const v_dst = dec->cache_v_ + ctx->id_ * 8 * uv_bps + mb_x * 8;
     const int hev_thresh =
         hev_thresh_from_level(level, dec->frm_hdr_.key_frame_);
     if (mb_x > 0) {
       VP8HFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
       VP8HFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
     }
-    if (mb->f_inner_) {
+    if (f_info->f_inner_) {
       VP8HFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
       VP8HFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
     }
@@ -169,21 +244,20 @@ static void DoFilter(const VP8Decoder* const dec, int mb_x, int mb_y) {
       VP8VFilter16(y_dst, y_bps, limit + 4, ilevel, hev_thresh);
       VP8VFilter8(u_dst, v_dst, uv_bps, limit + 4, ilevel, hev_thresh);
     }
-    if (mb->f_inner_) {
+    if (f_info->f_inner_) {
       VP8VFilter16i(y_dst, y_bps, limit, ilevel, hev_thresh);
       VP8VFilter8i(u_dst, v_dst, uv_bps, limit, ilevel, hev_thresh);
     }
   }
 }
 
-void VP8FilterRow(const VP8Decoder* const dec) {
+// Filter the decoded macroblock row (if needed)
+static void FilterRow(const VP8Decoder* const dec) {
   int mb_x;
-  assert(dec->filter_type_ > 0);
+  const int mb_y = dec->thread_ctx_.mb_y_;
-  if (dec->mb_y_ < dec->tl_mb_y_ || dec->mb_y_ > dec->br_mb_y_) {
+  assert(dec->thread_ctx_.filter_row_);
-    return;
-  }
   for (mb_x = dec->tl_mb_x_; mb_x < dec->br_mb_x_; ++mb_x) {
-    DoFilter(dec, mb_x, dec->mb_y_);
+    DoFilter(dec, mb_x, mb_y);
   }
 }
 
@@ -191,7 +265,8 @@ void VP8FilterRow(const VP8Decoder* const dec) {
 
 void VP8StoreBlock(VP8Decoder* const dec) {
   if (dec->filter_type_ > 0) {
-    VP8MB* const info = dec->mb_info_ + dec->mb_x_;
+    VP8FInfo* const info = dec->f_info_ + dec->mb_x_;
+    const int skip = dec->mb_info_[dec->mb_x_].skip_;
     int level = dec->filter_levels_[dec->segment_];
     if (dec->filter_hdr_.use_lf_delta_) {
       // TODO(skal): only CURRENT is handled for now.
@@ -215,14 +290,16 @@ void VP8StoreBlock(VP8Decoder* const dec) {
     }
 
     info->f_ilevel_ = (level < 1) ? 1 : level;
-    info->f_inner_ = (!info->skip_ || dec->is_i4x4_);
+    info->f_inner_ = (!skip || dec->is_i4x4_);
   }
   {
     // Transfer samples to row cache
     int y;
-    uint8_t* const ydst = dec->cache_y_ + dec->mb_x_ * 16;
+    const int y_offset = dec->cache_id_ * 16 * dec->cache_y_stride_;
-    uint8_t* const udst = dec->cache_u_ + dec->mb_x_ * 8;
+    const int uv_offset = dec->cache_id_ * 8 * dec->cache_uv_stride_;
-    uint8_t* const vdst = dec->cache_v_ + dec->mb_x_ * 8;
+    uint8_t* const ydst = dec->cache_y_ + dec->mb_x_ * 16 + y_offset;
+    uint8_t* const udst = dec->cache_u_ + dec->mb_x_ * 8 + uv_offset;
+    uint8_t* const vdst = dec->cache_v_ + dec->mb_x_ * 8 + uv_offset;
     for (y = 0; y < 16; ++y) {
       memcpy(ydst + y * dec->cache_y_stride_,
              dec->yuv_b_ + Y_OFF + y * BPS, 16);
@@ -249,17 +326,27 @@ void VP8StoreBlock(VP8Decoder* const dec) {
 
 #define MACROBLOCK_VPOS(mb_y)  ((mb_y) * 16)    // vertical position of a MB
 
+// Finalize and transmit a complete row. Return false in case of user-abort.
 int VP8FinishRow(VP8Decoder* const dec, VP8Io* io) {
+  int ok = 1;
+  const VP8ThreadContext* const ctx = &dec->thread_ctx_;
   const int extra_y_rows = kFilterExtraRows[dec->filter_type_];
   const int ysize = extra_y_rows * dec->cache_y_stride_;
   const int uvsize = (extra_y_rows / 2) * dec->cache_uv_stride_;
-  uint8_t* const ydst = dec->cache_y_ - ysize;
+  const int y_offset = ctx->id_ * 16 * dec->cache_y_stride_;
-  uint8_t* const udst = dec->cache_u_ - uvsize;
+  const int uv_offset = ctx->id_ * 8 * dec->cache_uv_stride_;
-  uint8_t* const vdst = dec->cache_v_ - uvsize;
+  uint8_t* const ydst = dec->cache_y_ - ysize + y_offset;
-  const int first_row = (dec->mb_y_ == 0);
+  uint8_t* const udst = dec->cache_u_ - uvsize + uv_offset;
-  const int last_row = (dec->mb_y_ >= dec->br_mb_y_ - 1);
+  uint8_t* const vdst = dec->cache_v_ - uvsize + uv_offset;
-  int y_start = MACROBLOCK_VPOS(dec->mb_y_);
+  const int first_row = (ctx->mb_y_ == 0);
-  int y_end = MACROBLOCK_VPOS(dec->mb_y_ + 1);
+  const int last_row = (ctx->mb_y_ >= dec->br_mb_y_ - 1);
+  int y_start = MACROBLOCK_VPOS(ctx->mb_y_);
+  int y_end = MACROBLOCK_VPOS(ctx->mb_y_ + 1);
+
+  if (ctx->filter_row_) {
+    FilterRow(dec);
+  }
+
   if (io->put) {
     if (!first_row) {
       y_start -= extra_y_rows;
@@ -267,9 +354,9 @@ int VP8FinishRow(VP8Decoder* const dec, VP8Io* io) {
       io->u = udst;
       io->v = vdst;
     } else {
-      io->y = dec->cache_y_;
+      io->y = dec->cache_y_ + y_offset;
-      io->u = dec->cache_u_;
+      io->u = dec->cache_u_ + uv_offset;
-      io->v = dec->cache_v_;
+      io->v = dec->cache_v_ + uv_offset;
     }
 
     if (!last_row) {
@@ -309,27 +396,63 @@ int VP8FinishRow(VP8Decoder* const dec, VP8Io* io) {
       io->mb_y = y_start - io->crop_top;
       io->mb_w = io->crop_right - io->crop_left;
       io->mb_h = y_end - y_start;
-      if (!io->put(io)) {
+      ok = io->put(io);
-        return 0;
-      }
     }
   }
-  // rotate top samples
+  // rotate top samples if needed
-  if (!last_row) {
+  if (ctx->id_ + 1 == dec->num_caches_) {
-    memcpy(ydst, ydst + 16 * dec->cache_y_stride_, ysize);
+    if (!last_row) {
-    memcpy(udst, udst + 8 * dec->cache_uv_stride_, uvsize);
+      memcpy(dec->cache_y_ - ysize, ydst + 16 * dec->cache_y_stride_, ysize);
-    memcpy(vdst, vdst + 8 * dec->cache_uv_stride_, uvsize);
+      memcpy(dec->cache_u_ - uvsize, udst + 8 * dec->cache_uv_stride_, uvsize);
+      memcpy(dec->cache_v_ - uvsize, vdst + 8 * dec->cache_uv_stride_, uvsize);
+    }
   }
-  return 1;
+
+  return ok;
 }
 
 #undef MACROBLOCK_VPOS
 
+//------------------------------------------------------------------------------
+
+int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io) {
+  int ok = 1;
+  VP8ThreadContext* const ctx = &dec->thread_ctx_;
+  if (!dec->use_threads_) {
+    // ctx->id_ and ctx->f_info_ are already set
+    ctx->mb_y_ = dec->mb_y_;
+    ctx->filter_row_ = dec->filter_row_;
+    ok = VP8FinishRow(dec, io);
+  } else {
+    WebPWorker* const worker = &dec->worker_;
+    // Finish previous job *before* updating context
+    ok &= WebPWorkerSync(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_ = dec->filter_row_;
+      if (ctx->filter_row_) {    // just swap filter info
+        VP8FInfo* const tmp = ctx->f_info_;
+        ctx->f_info_ = dec->f_info_;
+        dec->f_info_ = tmp;
+      }
+      WebPWorkerLaunch(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.
 
-VP8StatusCode VP8FinishFrameSetup(VP8Decoder* const dec, VP8Io* const io) {
+VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io) {
   // Call setup() first. This may trigger additional decoding features on 'io'.
+  // Note: Afterward, we must call teardown() not matter what.
   if (io->setup && !io->setup(io)) {
     VP8SetError(dec, VP8_STATUS_USER_ABORT, "Frame setup failed");
     return dec->status_;
@@ -376,6 +499,18 @@ VP8StatusCode VP8FinishFrameSetup(VP8Decoder* const dec, VP8Io* const io) {
   return VP8_STATUS_OK;
 }
 
+int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io) {
+  int ok = 1;
+  if (dec->use_threads_) {
+    ok = WebPWorkerSync(&dec->worker_);
+  }
+
+  if (io->teardown) {
+    io->teardown(io);
+  }
+  return ok;
+}
+
 //------------------------------------------------------------------------------
 // Main reconstruction function.
 

src/dec/idec.c

@@ -324,28 +324,28 @@ static VP8StatusCode DecodePartition0(WebPIDecoder* const idec) {
     return IDecError(idec, dec->status_);
   }
 
-  // Allocate memory and prepare everything.
-  if (!VP8InitFrame(dec, io)) {
-    return IDecError(idec, dec->status_);
-  }
-
   if (!CopyParts0Data(idec)) {
     return IDecError(idec, VP8_STATUS_OUT_OF_MEMORY);
   }
 
-  // Finish setting up the decoding parameters.
+  // Finish setting up the decoding parameters. Will call io->setup().
-  if (VP8FinishFrameSetup(dec, io) != VP8_STATUS_OK) {
+  if (VP8EnterCritical(dec, io) != VP8_STATUS_OK) {
     return IDecError(idec, dec->status_);
   }
+
   // Note: past this point, teardown() must always be called
   // in case of error.
   idec->state_ = STATE_DATA;
+  // Allocate memory and prepare everything.
+  if (!VP8InitFrame(dec, io)) {
+    return IDecError(idec, dec->status_);
+  }
   return VP8_STATUS_OK;
 }
 
 // Remaining partitions
 static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
-  VP8BitReader*  br;
+  VP8BitReader* br;
   VP8Decoder* const dec = idec->dec_;
   VP8Io* const io = &idec->io_;
 
@@ -355,12 +355,8 @@ static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
   for (; dec->mb_y_ < dec->mb_h_; ++dec->mb_y_) {
     VP8BitReader* token_br = &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)];
     if (dec->mb_x_ == 0) {
-      VP8MB* const left = dec->mb_info_ - 1;
+      VP8InitScanline(dec);
-      left->nz_ = 0;
-      left->dc_nz_ = 0;
-      memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
     }
-
     for (; dec->mb_x_ < dec->mb_w_;  dec->mb_x_++) {
       MBContext context;
       SaveContext(dec, token_br, &context);
@@ -383,17 +379,14 @@ static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
         assert(idec->mem_.start_ <= idec->mem_.end_);
       }
     }
-    if (dec->filter_type_ > 0) {
+    if (!VP8ProcessRow(dec, io)) {
-      VP8FilterRow(dec);
-    }
-    if (!VP8FinishRow(dec, io)) {
       return IDecError(idec, VP8_STATUS_USER_ABORT);
     }
     dec->mb_x_ = 0;
   }
-
+  // Synchronize the thread and check for errors.
-  if (io->teardown) {
+  if (!VP8ExitCritical(dec, io)) {
-    io->teardown(io);
+    return IDecError(idec, VP8_STATUS_USER_ABORT);
   }
   dec->ready_ = 0;
   idec->state_ = STATE_DONE;
@@ -443,6 +436,13 @@ WebPIDecoder* WebPINewDecoder(WebPDecBuffer* const output_buffer) {
   idec->params_.output = output_buffer ? output_buffer : &idec->output_;
   WebPInitCustomIo(&idec->params_, &idec->io_);  // Plug the I/O functions.
 
+#ifdef WEBP_USE_THREAD
+  idec->dec_->use_threads_ = idec->params_.options &&
+                             (idec->params_.options->use_threads > 0);
+#else
+  idec->dec_->use_threads_ = 0;
+#endif
+
   return idec;
 }
 

src/dec/thread.c

@@ -0,0 +1,128 @@
+// Copyright 2011 Google Inc.
+//
+// This code is licensed under the same terms as WebM:
+//  Software License Agreement:  http://www.webmproject.org/license/software/
+//  Additional IP Rights Grant:  http://www.webmproject.org/license/additional/
+// -----------------------------------------------------------------------------
+//
+// Multi-threaded worker
+//
+// Author: skal@google.com (Pascal Massimino)
+
+#include "./vp8i.h"
+#include "./thread.h"
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#ifdef WEBP_USE_THREAD
+
+static void *WebPWorkerThreadLoop(void *ptr) {    // thread loop
+  WebPWorker* const worker = (WebPWorker*)ptr;
+  int done = 0;
+  while (!done) {
+    pthread_mutex_lock(&worker->mutex_);
+    while (worker->status_ == OK) {   // wait in idling mode
+      pthread_cond_wait(&worker->condition_, &worker->mutex_);
+    }
+    if (worker->status_ == WORK) {
+      if (worker->hook) {
+        worker->had_error |= !worker->hook(worker->data1, worker->data2);
+      }
+      worker->status_ = OK;
+    } else if (worker->status_ == NOT_OK) {   // finish the worker
+      done = 1;
+    }
+    // signal to the main thread that we're done (for Sync())
+    pthread_cond_signal(&worker->condition_);
+    pthread_mutex_unlock(&worker->mutex_);
+  }
+  return NULL;    // Thread is finished
+}
+
+// main thread state control
+static void WebPWorkerChangeState(WebPWorker* const worker,
+                                  WebPWorkerStatus new_status) {
+  pthread_mutex_lock(&worker->mutex_);
+  assert(worker->status_ >= OK);
+  // wait for the worker to finish
+  while (worker->status_ != OK) {
+    pthread_cond_wait(&worker->condition_, &worker->mutex_);
+  }
+  // assign new status and release the working thread if needed
+  if (new_status != OK) {
+    worker->status_ = new_status;
+    pthread_cond_signal(&worker->condition_);
+  }
+  pthread_mutex_unlock(&worker->mutex_);
+}
+
+#endif
+
+//-----------------------------------------------------------------------------
+
+void WebPWorkerInit(WebPWorker* const worker) {
+  memset(worker, 0, sizeof(*worker));
+  worker->status_ = NOT_OK;
+}
+
+int WebPWorkerSync(WebPWorker* const worker) {
+#ifdef WEBP_USE_THREAD
+  WebPWorkerChangeState(worker, OK);
+#endif
+  assert(worker->status_ == OK);
+  return !worker->had_error;
+}
+
+int WebPWorkerReset(WebPWorker* const worker) {
+  int ok = 1;
+  worker->had_error = 0;
+  if (worker->status_ < OK) {
+#ifdef WEBP_USE_THREAD
+    if (pthread_mutex_init(&worker->mutex_, 0) ||
+        pthread_cond_init(&worker->condition_, 0)) {
+      return 0;
+    }
+    pthread_mutex_lock(&worker->mutex_);
+    ok = !pthread_create(&worker->thread_, 0, WebPWorkerThreadLoop, worker);
+    if (ok) worker->status_ = OK;
+    pthread_mutex_unlock(&worker->mutex_);
+#else
+    worker->status_ = OK;
+#endif
+  } else if (worker->status_ > OK) {
+    ok = WebPWorkerSync(worker);
+  }
+  assert(!ok || (worker->status_ == OK));
+  return ok;
+}
+
+void WebPWorkerLaunch(WebPWorker* const worker) {
+#ifdef WEBP_USE_THREAD
+  WebPWorkerChangeState(worker, WORK);
+#else
+  if (worker->hook)
+    worker->had_error |= !worker->hook(worker->data1, worker->data2);
+#endif
+}
+
+void WebPWorkerEnd(WebPWorker* const worker) {
+  if (worker->status_ >= OK) {
+#ifdef WEBP_USE_THREAD
+    WebPWorkerChangeState(worker, NOT_OK);
+    pthread_join(worker->thread_, NULL);
+    pthread_mutex_destroy(&worker->mutex_);
+    pthread_cond_destroy(&worker->condition_);
+#else
+    worker->status_ = NOT_OK;
+#endif
+  }
+  assert(worker->status_ == NOT_OK);
+}
+
+//------------------------------------------------------------------------------
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    // extern "C"
+#endif

src/dec/thread.h

@@ -0,0 +1,79 @@
+// Copyright 2011 Google Inc.
+//
+// This code is licensed under the same terms as WebM:
+//  Software License Agreement:  http://www.webmproject.org/license/software/
+//  Additional IP Rights Grant:  http://www.webmproject.org/license/additional/
+// -----------------------------------------------------------------------------
+//
+// Multi-threaded worker
+//
+// Author: skal@google.com (Pascal Massimino)
+
+#ifndef WEBP_DEC_THREAD_H
+#define WEBP_DEC_THREAD_H
+
+#if defined(__cplusplus) || defined(c_plusplus)
+extern "C" {
+#endif
+
+#if WEBP_USE_THREAD
+
+#if defined(_WIN32)
+
+#undef WEBP_USE_THREAD
+
+#else
+
+#include <pthread.h>
+
+#endif    // _WIN32
+#endif    // WEBP_USE_THREAD
+
+// State of the worker thread object
+typedef enum {
+  NOT_OK = 0,   // object is unusable
+  OK,           // ready to work
+  WORK          // busy finishing the current task
+} WebPWorkerStatus;
+
+// Function to be called by the worker thread. Takes two opaque pointers as
+// arguments (data1 and data2), and should return false in case of error.
+typedef int (*WebPWorkerHook)(void*, void*);
+
+// Synchronize object used to launch job in the worker thread
+typedef struct {
+#if WEBP_USE_THREAD
+  pthread_mutex_t mutex_;
+  pthread_cond_t  condition_;
+  pthread_t       thread_;
+#endif
+  WebPWorkerStatus status_;
+  WebPWorkerHook hook;    // hook to call
+  void* data1;            // first argument passed to 'hook'
+  void* data2;            // second argument passed to 'hook'
+  int had_error;          // return value of the last call to 'hook'
+} WebPWorker;
+
+// Must be called first, before any other method.
+void WebPWorkerInit(WebPWorker* const worker);
+// Must be called initialize the object and spawn the thread. Re-entrant.
+// Will potentially launch the thread. Returns false in case of error.
+int WebPWorkerReset(WebPWorker* const worker);
+// Make sure the previous work is finished. Returns true if worker->had_error
+// was not set and not error condition was triggered by the working thread.
+int WebPWorkerSync(WebPWorker* const worker);
+// Trigger the thread to call hook() with data1 and data2 argument. These
+// hook/data1/data2 can be changed at any time before calling this function,
+// but not be changed afterward until the next call to WebPWorkerSync().
+void WebPWorkerLaunch(WebPWorker* const worker);
+// Kill the thread and terminate the object. To use the object again, one
+// must call WebPWorkerReset() again.
+void WebPWorkerEnd(WebPWorker* const worker);
+
+//------------------------------------------------------------------------------
+
+#if defined(__cplusplus) || defined(c_plusplus)
+}    // extern "C"
+#endif
+
+#endif  // WEBP_DEC_THREAD_H

src/dec/vp8.c

@@ -43,6 +43,7 @@ VP8Decoder* VP8New(void) {
   VP8Decoder* dec = (VP8Decoder*)calloc(1, sizeof(VP8Decoder));
   if (dec) {
     SetOk(dec);
+    WebPWorkerInit(&dec->worker_);
     dec->ready_ = 0;
   }
   return dec;
@@ -682,15 +683,21 @@ int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br) {
   return (!token_br->eof_);
 }
 
+void VP8InitScanline(VP8Decoder* const dec) {
+  VP8MB* const left = dec->mb_info_ - 1;
+  left->nz_ = 0;
+  left->dc_nz_ = 0;
+  memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
+  dec->filter_row_ =
+    (dec->filter_type_ > 0) &&
+    (dec->mb_y_ >= dec->tl_mb_y_) && (dec->mb_y_ <= dec->br_mb_y_);
+}
+
 static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
   for (dec->mb_y_ = 0; dec->mb_y_ < dec->br_mb_y_; ++dec->mb_y_) {
-    VP8MB* const left = dec->mb_info_ - 1;
     VP8BitReader* const token_br =
         &dec->parts_[dec->mb_y_ & (dec->num_parts_ - 1)];
-    left->nz_ = 0;
+    VP8InitScanline(dec);
-    left->dc_nz_ = 0;
-    memset(dec->intra_l_, B_DC_PRED, sizeof(dec->intra_l_));
-
     for (dec->mb_x_ = 0; dec->mb_x_ < dec->mb_w_;  dec->mb_x_++) {
       if (!VP8DecodeMB(dec, token_br)) {
         return VP8SetError(dec, VP8_STATUS_NOT_ENOUGH_DATA,
@@ -701,13 +708,13 @@ static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
       // Store data and save block's filtering params
       VP8StoreBlock(dec);
     }
-    if (dec->filter_type_ > 0) {
+    if (!VP8ProcessRow(dec, io)) {
-      VP8FilterRow(dec);
-    }
-    if (!VP8FinishRow(dec, io)) {
       return VP8SetError(dec, VP8_STATUS_USER_ABORT, "Output aborted.");
     }
   }
+  if (dec->use_threads_ && !WebPWorkerSync(&dec->worker_)) {
+    return 0;
+  }
 
   // Finish
 #ifndef ONLY_KEYFRAME_CODE
@@ -729,6 +736,7 @@ static int ParseFrame(VP8Decoder* const dec, VP8Io* io) {
 
 // Main entry point
 int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
+  int ok = 0;
   if (dec == NULL) {
     return 0;
   }
@@ -744,30 +752,24 @@ int VP8Decode(VP8Decoder* const dec, VP8Io* const io) {
   }
   assert(dec->ready_);
 
-  // Will allocate memory and prepare everything.
+  // Finish setting up the decoding parameter. Will call io->setup().
-  if (!VP8InitFrame(dec, io)) {
+  ok = (VP8EnterCritical(dec, io) == VP8_STATUS_OK);
-    VP8Clear(dec);
+  if (ok) {   // good to go.
-    return 0;
+    // Will allocate memory and prepare everything.
+    if (ok) ok = VP8InitFrame(dec, io);
+
+    // Main decoding loop
+    if (ok) ok = ParseFrame(dec, io);
+
+    // Exit.
+    ok &= VP8ExitCritical(dec, io);
   }
 
-  // Finish setting up the decoding parameter
+  if (!ok) {
-  if (VP8FinishFrameSetup(dec, io) != VP8_STATUS_OK) {
     VP8Clear(dec);
     return 0;
   }
 
-  // Main decoding loop
-  {
-    const int ret = ParseFrame(dec, io);
-    if (io->teardown) {
-      io->teardown(io);
-    }
-    if (!ret) {
-      VP8Clear(dec);
-      return 0;
-    }
-  }
-
   dec->ready_ = 0;
   return 1;
 }
@@ -776,6 +778,9 @@ void VP8Clear(VP8Decoder* const dec) {
   if (dec == NULL) {
     return;
   }
+  if (dec->use_threads_) {
+    WebPWorkerEnd(&dec->worker_);
+  }
   if (dec->mem_) {
     free(dec->mem_);
   }

src/dec/vp8i.h

@@ -13,7 +13,8 @@
 #define WEBP_DEC_VP8I_H_
 
 #include <string.h>     // for memcpy()
-#include "bits.h"
+#include "./bits.h"
+#include "./thread.h"
 
 #if defined(__cplusplus) || defined(c_plusplus)
 extern "C" {
@@ -147,16 +148,16 @@ typedef struct {
 //-----------------------------------------------------------------------------
 // Informations about the macroblocks.
 
-typedef struct {
+typedef struct {  // filter specs
-  // block type
+  unsigned int f_level_:6;      // filter strength: 0..63
-  uint8_t skip_:1;
+  unsigned int f_ilevel_:6;     // inner limit: 1..63
-  // filter specs
+  unsigned int f_inner_:1;      // do inner filtering?
-  uint8_t f_level_:6;      // filter strength: 0..63
+} VP8FInfo;
-  uint8_t f_ilevel_:6;     // inner limit: 1..63
+
-  uint8_t f_inner_:1;      // do inner filtering?
+typedef struct {  // used for syntax-parsing
-  // cbp
+  unsigned int nz_;          // non-zero AC/DC coeffs
-  uint8_t nz_;        // non-zero AC/DC coeffs
+  unsigned int dc_nz_:1;     // non-zero DC coeffs
-  uint8_t dc_nz_;     // non-zero DC coeffs
+  unsigned int skip_:1;      // block type
 } VP8MB;
 
 // Dequantization matrices
@@ -164,6 +165,15 @@ typedef struct {
   uint16_t y1_mat_[2], y2_mat_[2], uv_mat_[2];    // [DC / AC]
 } VP8QuantMatrix;
 
+// Persistent information needed by the parallel processing
+typedef struct {
+  int id_;            // cache row to process (in [0..2])
+  int mb_y_;          // macroblock position of the row
+  int filter_row_;    // true if row-filtering is needed
+  VP8FInfo* f_info_;  // filter strengths
+  VP8Io io_;          // copy of the VP8Io to pass to put()
+} VP8ThreadContext;
+
 //-----------------------------------------------------------------------------
 // VP8Decoder: the main opaque structure handed over to user
 
@@ -181,6 +191,13 @@ struct VP8Decoder {
   VP8FilterHeader  filter_hdr_;
   VP8SegmentHeader segment_hdr_;
 
+  // Worker
+  WebPWorker worker_;
+  int use_threads_;    // use multi-thread
+  int cache_id_;       // current cache row
+  int num_caches_;     // number of cached rows of 16 pixels (1, 2 or 3)
+  VP8ThreadContext thread_ctx_;  // Thread context
+
   // dimension, in macroblock units.
   int mb_w_, mb_h_;
 
@@ -219,7 +236,8 @@ struct VP8Decoder {
   uint8_t* y_t_;         // top luma samples: 16 * mb_w_
   uint8_t* u_t_, *v_t_;  // top u/v samples: 8 * mb_w_ each
 
-  VP8MB* mb_info_;       // contextual macroblock infos (mb_w_ + 1)
+  VP8MB* mb_info_;       // contextual macroblock info (mb_w_ + 1)
+  VP8FInfo* f_info_;     // filter strength info
   uint8_t* yuv_b_;       // main block for Y/U/V (size = YUV_SIZE)
   int16_t* coeffs_;      // 384 coeffs = (16+8+8) * 4*4
 
@@ -249,6 +267,7 @@ struct VP8Decoder {
 
   // Filtering side-info
   int filter_type_;                         // 0=off, 1=simple, 2=complex
+  int filter_row_;                          // per-row flag
   uint8_t filter_levels_[NUM_MB_SEGMENTS];  // precalculated per-segment
 
   // extensions
@@ -288,13 +307,23 @@ int VP8InitFrame(VP8Decoder* const dec, VP8Io* io);
 // Predict a block and add residual
 void VP8ReconstructBlock(VP8Decoder* const dec);
 // Call io->setup() and finish setting up scan parameters.
-VP8StatusCode VP8FinishFrameSetup(VP8Decoder* const dec, VP8Io* const io);
+// After this call returns, one must always call VP8ExitCritical() with the
+// same parameters. Both functions should be used in pair. Returns VP8_STATUS_OK
+// if ok, otherwise sets and returns the error status on *dec.
+VP8StatusCode VP8EnterCritical(VP8Decoder* const dec, VP8Io* const io);
+// Must always be called in pair with VP8EnterCritical().
+// Returns false in case of error.
+int VP8ExitCritical(VP8Decoder* const dec, VP8Io* const io);
 // Filter the decoded macroblock row (if needed)
-void VP8FilterRow(const VP8Decoder* const dec);
+int VP8FinishRow(VP8Decoder* const dec, VP8Io* io);   // multi threaded call
+// Process the last decoded row (filtering + output)
+int VP8ProcessRow(VP8Decoder* const dec, VP8Io* const io);
 // Store a block, along with filtering params
 void VP8StoreBlock(VP8Decoder* const dec);
 // Finalize and transmit a complete row. Return false in case of user-abort.
 int VP8FinishRow(VP8Decoder* const dec, VP8Io* const io);
+// To be called at the start of a new scanline, to initialize predictors.
+void VP8InitScanline(VP8Decoder* const dec);
 // Decode one macroblock. Returns false if there is not enough data.
 int VP8DecodeMB(VP8Decoder* const dec, VP8BitReader* const token_br);
 

src/dec/webp.c

@@ -92,6 +92,12 @@ static VP8StatusCode DecodeInto(const uint8_t* data, uint32_t data_size,
   io.data_size = data_size;
   WebPInitCustomIo(params, &io);  // Plug the I/O functions.
 
+#ifdef WEBP_USE_THREAD
+  dec->use_threads_ = params->options && (params->options->use_threads > 0);
+#else
+  dec->use_threads_ = 0;
+#endif
+
   // Decode bitstream header, update io->width/io->height.
   if (!VP8GetHeaders(dec, &io)) {
     status = VP8_STATUS_BITSTREAM_ERROR;

src/webp/decode.h

@@ -351,6 +351,7 @@ typedef struct {
   int scaled_width, scaled_height;    // final resolution
   int force_rotation;                 // forced rotation (to be applied _last_)
   int no_enhancement;                 // if true, discard enhancement layer
+  int use_threads;                    // if true, use multi-threaded decoding
 } WebPDecoderOptions;
 
 // Main object storing the configuration for advanced decoding.

src/webp/decode_vp8.h

@@ -67,10 +67,13 @@ struct VP8Io {
   VP8IoPutHook put;
 
   // called just before starting to decode the blocks.
-  // Should returns 0 in case of error.
+  // Must return false in case of setup error, true otherwise. If false is
+  // returned, teardown() will NOT be called. But if the setup succeeded
+  // and true is returned, then teardown() will always be called afterward.
   VP8IoSetupHook setup;
 
-  // called just after block decoding is finished (or when an error occurred).
+  // Called just after block decoding is finished (or when an error occurred
+  // during put()). Is NOT called if setup() failed.
   VP8IoTeardownHook teardown;
 
   // this is a recommendation for the user-side yuv->rgb converter. This flag