src/dec/idec.c

// 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/
// -----------------------------------------------------------------------------
//
// Incremental decoding
//
// Author: somnath (at) google.com (Somnath Banerjee)

#include <assert.h>
#include <string.h>
#include <stdlib.h>

#include "webpi.h"
#include "vp8i.h"

#if defined(__cplusplus) || defined(c_plusplus)
extern "C" {
#endif

#define RIFF_HEADER_SIZE 20
#define VP8_HEADER_SIZE 10
#define WEBP_HEADER_SIZE (RIFF_HEADER_SIZE + VP8_HEADER_SIZE)
#define CHUNK_SIZE 4096
#define MAX_MB_SIZE 4096

//------------------------------------------------------------------------------
// Data structures for memory and states

// Decoding states. State normally flows like HEADER->PARTS0->DATA->DONE.
// If there is any error the decoder goes into state ERROR.
typedef enum { STATE_HEADER = 0, STATE_PARTS0 = 1,
               STATE_DATA = 2, STATE_DONE = 3,
               STATE_ERROR = 4
} DecState;

// Operating state for the MemBuffer
typedef enum { MEM_MODE_NONE = 0,
               MEM_MODE_APPEND, MEM_MODE_MAP
} MemBufferMode;

// storage for partition #0 and partial data (in a rolling fashion)
typedef struct {
  MemBufferMode mode_;  // Operation mode
  uint32_t start_;      // start location of the data to be decoded
  uint32_t end_;        // end location
  size_t buf_size_;     // size of the allocated buffer
  uint8_t* buf_;        // We don't own this buffer in case WebPIUpdate()

  size_t part0_size_;         // size of partition #0
  const uint8_t* part0_buf_;  // buffer to store partition #0
} MemBuffer;

struct WebPIDecoder {
  DecState state_;         // current decoding state
  WebPDecParams params_;   // Params to store output info
  VP8Decoder* dec_;
  VP8Io io_;

  MemBuffer mem_;          // input memory buffer.
  WebPDecBuffer output_;   // output buffer (when no external one is supplied)
};

// MB context to restore in case VP8DecodeMB() fails
typedef struct {
  VP8MB left_;
  VP8MB info_;
  uint8_t intra_t_[4];
  uint8_t intra_l_[4];
  VP8BitReader br_;
  VP8BitReader token_br_;
} MBContext;

//------------------------------------------------------------------------------
// MemBuffer: incoming data handling

#define REMAP(PTR, OLD_BASE, NEW_BASE) (PTR) = (NEW_BASE) + ((PTR) - OLD_BASE)

static inline size_t MemDataSize(const MemBuffer* mem) {
  return (mem->end_ - mem->start_);
}

// Appends data to the end of MemBuffer->buf_. It expands the allocated memory
// size if required and also updates VP8BitReader's if new memory is allocated.
static int AppendToMemBuffer(WebPIDecoder* const idec,
                             const uint8_t* const data, size_t data_size) {
  MemBuffer* const mem = &idec->mem_;
  VP8Decoder* const dec = idec->dec_;
  const int last_part = dec->num_parts_ - 1;
  assert(mem->mode_ == MEM_MODE_APPEND);

  if (mem->end_ + data_size > mem->buf_size_) {  // Need some free memory
    int p;
    uint8_t* new_buf = NULL;
    const int num_chunks = (MemDataSize(mem) + data_size + CHUNK_SIZE - 1)
        / CHUNK_SIZE;
    const size_t new_size = num_chunks * CHUNK_SIZE;
    const uint8_t* const base = mem->buf_ + mem->start_;

    new_buf = (uint8_t*)malloc(new_size);
    if (!new_buf) return 0;
    memcpy(new_buf, base, MemDataSize(mem));

    // adjust VP8BitReader pointers
    for (p = 0; p <= last_part; ++p) {
      if (dec->parts_[p].buf_) {
        REMAP(dec->parts_[p].buf_, base, new_buf);
        REMAP(dec->parts_[p].buf_end_, base, new_buf);
      }
    }

    // adjust memory pointers
    free(mem->buf_);
    mem->buf_ = new_buf;
    mem->buf_size_ = new_size;

    mem->end_ = MemDataSize(mem);
    mem->start_ = 0;
  }

  memcpy(mem->buf_ + mem->end_, data, data_size);
  mem->end_ += data_size;
  assert(mem->end_ <= mem->buf_size_);
  dec->parts_[last_part].buf_end_ = mem->buf_ + mem->end_;

  // note: setting up idec->io_ is only really needed at the beginning
  // of the decoding, till partition #0 is complete.
  idec->io_.data = mem->buf_ + mem->start_;
  idec->io_.data_size = MemDataSize(mem);
  return 1;
}

static int RemapMemBuffer(WebPIDecoder* const idec,
                          const uint8_t* const data, size_t data_size) {
  int p;
  MemBuffer* const mem = &idec->mem_;
  VP8Decoder* const dec = idec->dec_;
  const int last_part = dec->num_parts_ - 1;
  const uint8_t* base = mem->buf_;

  assert(mem->mode_ == MEM_MODE_MAP);
  if (data_size < mem->buf_size_) {
    return 0;  // we cannot remap to a shorter buffer!
  }

  for (p = 0; p <= last_part; ++p) {
    if (dec->parts_[p].buf_) {
      REMAP(dec->parts_[p].buf_, base, data);
      REMAP(dec->parts_[p].buf_end_, base, data);
    }
  }
  dec->parts_[last_part].buf_end_ = data + data_size;

  // Remap partition #0 data pointer to new offset.
  if (dec->br_.buf_) {
    REMAP(dec->br_.buf_, base, data);
    REMAP(dec->br_.buf_end_, base, data);
  }

  mem->buf_ = (uint8_t*)data;
  mem->end_ = mem->buf_size_ = data_size;

  idec->io_.data = data;
  idec->io_.data_size = data_size;
  return 1;
}

static void InitMemBuffer(MemBuffer* const mem) {
  mem->mode_       = MEM_MODE_NONE;
  mem->buf_        = 0;
  mem->buf_size_   = 0;
  mem->part0_buf_  = 0;
  mem->part0_size_ = 0;
}

static void ClearMemBuffer(MemBuffer* const mem) {
  assert(mem);
  if (mem->mode_ == MEM_MODE_APPEND) {
    free(mem->buf_);
    free((void*)mem->part0_buf_);
  }
}

static int CheckMemBufferMode(MemBuffer* const mem, MemBufferMode expected) {
  if (mem->mode_ == MEM_MODE_NONE) {
    mem->mode_ = expected;    // switch to the expected mode
  } else if (mem->mode_ != expected) {
    return 0;         // we mixed the modes => error
  }
  assert(mem->mode_ == expected);   // mode is ok
  return 1;
}

#undef REMAP

//------------------------------------------------------------------------------
// Macroblock-decoding contexts

static void SaveContext(const VP8Decoder* dec, const VP8BitReader* token_br,
                        MBContext* const context) {
  const VP8BitReader* const br = &dec->br_;
  const VP8MB* const left = dec->mb_info_ - 1;
  const VP8MB* const info = dec->mb_info_ + dec->mb_x_;

  context->left_ = *left;
  context->info_ = *info;
  context->br_ = *br;
  context->token_br_ = *token_br;
  memcpy(context->intra_t_, dec->intra_t_ + 4 * dec->mb_x_, 4);
  memcpy(context->intra_l_, dec->intra_l_, 4);
}

static void RestoreContext(const MBContext* context, VP8Decoder* const dec,
                           VP8BitReader* const token_br) {
  VP8BitReader* const br = &dec->br_;
  VP8MB* const left = dec->mb_info_ - 1;
  VP8MB* const info = dec->mb_info_ + dec->mb_x_;

  *left = context->left_;
  *info = context->info_;
  *br = context->br_;
  *token_br = context->token_br_;
  memcpy(dec->intra_t_ + 4 * dec->mb_x_, context->intra_t_, 4);
  memcpy(dec->intra_l_, context->intra_l_, 4);
}

//------------------------------------------------------------------------------

static VP8StatusCode IDecError(WebPIDecoder* idec, VP8StatusCode error) {
  if (idec->state_ == STATE_DATA) {
    VP8Io* const io = &idec->io_;
    if (io->teardown) {
      io->teardown(io);
    }
  }
  idec->state_ = STATE_ERROR;
  return error;
}

// Header
static VP8StatusCode DecodeHeader(WebPIDecoder* const idec) {
  uint32_t riff_header_size, bits;
  const uint8_t* data = idec->mem_.buf_ + idec->mem_.start_;
  uint32_t curr_size = MemDataSize(&idec->mem_);
  uint32_t chunk_size;

  if (curr_size < WEBP_HEADER_SIZE) {
    return VP8_STATUS_SUSPENDED;
  }

  // Validate and Skip over RIFF header
  chunk_size = WebPCheckRIFFHeader(&data, &curr_size);
  if (chunk_size == 0 ||
      curr_size < VP8_HEADER_SIZE ||
      !VP8GetInfo(data, curr_size, chunk_size, NULL, NULL, NULL)) {
    return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR);
  }

  riff_header_size = idec->mem_.end_ - curr_size;
  bits = data[0] | (data[1] << 8) | (data[2] << 16);

  idec->mem_.part0_size_ = (bits >> 5) + VP8_HEADER_SIZE;
  idec->mem_.start_ += riff_header_size;
  assert(idec->mem_.start_ <= idec->mem_.end_);

  idec->io_.data_size -= riff_header_size;
  idec->io_.data = data;
  idec->state_ = STATE_PARTS0;
  return VP8_STATUS_OK;
}

// Partition #0
static int CopyParts0Data(WebPIDecoder* idec) {
  VP8BitReader* const br = &idec->dec_->br_;
  const size_t psize = br->buf_end_ - br->buf_;
  MemBuffer* const mem = &idec->mem_;
  assert(!mem->part0_buf_);
  assert(psize > 0);
  assert(psize <= mem->part0_size_);
  if (mem->mode_ == MEM_MODE_APPEND) {
    // We copy and grab ownership of the partition #0 data.
    uint8_t* const part0_buf = (uint8_t*)malloc(psize);
    if (!part0_buf) {
      return 0;
    }
    memcpy(part0_buf, br->buf_, psize);
    mem->part0_buf_ = part0_buf;
    mem->start_ += psize;
    br->buf_ = part0_buf;
    br->buf_end_ = part0_buf + psize;
  } else {
    // Else: just keep pointers to the partition #0's data in dec_->br_.
  }
  return 1;
}

static VP8StatusCode DecodePartition0(WebPIDecoder* const idec) {
  VP8Decoder* const dec = idec->dec_;
  VP8Io* const io = &idec->io_;
  const WebPDecParams* const params = &idec->params_;
  WebPDecBuffer* const output = params->output;

  // Wait till we have enough data for the whole partition #0
  if (MemDataSize(&idec->mem_) < idec->mem_.part0_size_) {
    return VP8_STATUS_SUSPENDED;
  }

  if (!VP8GetHeaders(dec, io)) {
    const VP8StatusCode status = dec->status_;
    if (status == VP8_STATUS_SUSPENDED ||
        status == VP8_STATUS_NOT_ENOUGH_DATA) {
      // treating NOT_ENOUGH_DATA as SUSPENDED state
      return VP8_STATUS_SUSPENDED;
    }
    return IDecError(idec, status);
  }

  // Allocate/Verify output buffer now
  dec->status_ = WebPAllocateDecBuffer(io->width, io->height, params->options,
                                       output);
  if (dec->status_ != VP8_STATUS_OK) {
    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.
  if (VP8FinishFrameSetup(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;
  return VP8_STATUS_OK;
}

// Remaining partitions
static VP8StatusCode DecodeRemaining(WebPIDecoder* const idec) {
  VP8BitReader*  br;
  VP8Decoder* const dec = idec->dec_;
  VP8Io* const io = &idec->io_;

  assert(dec->ready_);

  br = &dec->br_;
  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;
      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);

      if (!VP8DecodeMB(dec, token_br)) {
        RestoreContext(&context, dec, token_br);
        // We shouldn't fail when MAX_MB data was available
        if (dec->num_parts_ == 1 && MemDataSize(&idec->mem_) > MAX_MB_SIZE) {
          return IDecError(idec, VP8_STATUS_BITSTREAM_ERROR);
        }
        return VP8_STATUS_SUSPENDED;
      }
      VP8ReconstructBlock(dec);
      // Store data and save block's filtering params
      VP8StoreBlock(dec);

      // Release buffer only if there is only one partition
      if (dec->num_parts_ == 1) {
        idec->mem_.start_ = token_br->buf_ - idec->mem_.buf_;
        assert(idec->mem_.start_ <= idec->mem_.end_);
      }
    }
    if (dec->filter_type_ > 0) {
      VP8FilterRow(dec);
    }
    if (!VP8FinishRow(dec, io)) {
      return IDecError(idec, VP8_STATUS_USER_ABORT);
    }
    dec->mb_x_ = 0;
  }

  if (io->teardown) {
    io->teardown(io);
  }
  dec->ready_ = 0;
  idec->state_ = STATE_DONE;

  return VP8_STATUS_OK;
}

  // Main decoding loop
static VP8StatusCode IDecode(WebPIDecoder* idec) {
  VP8StatusCode status = VP8_STATUS_SUSPENDED;
  assert(idec->dec_);

  if (idec->state_ == STATE_HEADER) {
    status = DecodeHeader(idec);
  }
  if (idec->state_ == STATE_PARTS0) {
    status = DecodePartition0(idec);
  }
  if (idec->state_ == STATE_DATA) {
    status = DecodeRemaining(idec);
  }
  return status;
}

//------------------------------------------------------------------------------
// Public functions

WebPIDecoder* WebPINewDecoder(WebPDecBuffer* const output_buffer) {
  WebPIDecoder* idec = (WebPIDecoder*)calloc(1, sizeof(WebPIDecoder));
  if (idec == NULL) {
    return NULL;
  }

  idec->dec_ = VP8New();
  if (idec->dec_ == NULL) {
    free(idec);
    return NULL;
  }

  idec->state_ = STATE_HEADER;

  InitMemBuffer(&idec->mem_);
  WebPInitDecBuffer(&idec->output_);
  VP8InitIo(&idec->io_);

  WebPResetDecParams(&idec->params_);
  idec->params_.output = output_buffer ? output_buffer : &idec->output_;
  WebPInitCustomIo(&idec->params_, &idec->io_);  // Plug the I/O functions.

  return idec;
}

WebPIDecoder* WebPIDecode(const uint8_t* data, uint32_t data_size,
                          WebPDecoderConfig* const config) {
  WebPIDecoder* idec;

  // Parse the bitstream's features, if requested:
  if (data != NULL && data_size > 0 && config != NULL) {
    if (WebPGetFeatures(data, data_size, &config->input) != VP8_STATUS_OK) {
      return NULL;
    }
  }
  // Create an instance of the incremental decoder
  idec = WebPINewDecoder(config ? &config->output : NULL);
  if (!idec) {
    return NULL;
  }
  // Finish initialization
  if (config != NULL) {
    idec->params_.options = &config->options;
  }
  return idec;
}

void WebPIDelete(WebPIDecoder* const idec) {
  if (!idec) return;
  VP8Delete(idec->dec_);
  ClearMemBuffer(&idec->mem_);
  WebPFreeDecBuffer(&idec->output_);
  free(idec);
}

//------------------------------------------------------------------------------
// Wrapper toward WebPINewDecoder

WebPIDecoder* WebPINew(WEBP_CSP_MODE mode) {
  WebPIDecoder* const idec = WebPINewDecoder(NULL);
  if (!idec) return NULL;
  idec->output_.colorspace = mode;
  return idec;
}

WebPIDecoder* WebPINewRGB(WEBP_CSP_MODE mode, uint8_t* output_buffer,
                          int output_buffer_size, int output_stride) {
  WebPIDecoder* idec;
  if (mode >= MODE_YUV) return NULL;
  idec = WebPINewDecoder(NULL);
  if (!idec) return NULL;
  idec->output_.colorspace = mode;
  idec->output_.is_external_memory = 1;
  idec->output_.u.RGBA.rgba = output_buffer;
  idec->output_.u.RGBA.stride = output_stride;
  idec->output_.u.RGBA.size = output_buffer_size;
  return idec;
}

WebPIDecoder* WebPINewYUV(uint8_t* luma, int luma_size, int luma_stride,
                          uint8_t* u, int u_size, int u_stride,
                          uint8_t* v, int v_size, int v_stride) {
  WebPIDecoder* const idec = WebPINewDecoder(NULL);
  if (!idec) return NULL;
  idec->output_.colorspace = MODE_YUV;
  idec->output_.is_external_memory = 1;
  idec->output_.u.YUVA.y = luma;
  idec->output_.u.YUVA.y_stride = luma_stride;
  idec->output_.u.YUVA.y_size = luma_size;
  idec->output_.u.YUVA.u = u;
  idec->output_.u.YUVA.u_stride = u_stride;
  idec->output_.u.YUVA.u_size = u_size;
  idec->output_.u.YUVA.v = v;
  idec->output_.u.YUVA.v_stride = v_stride;
  idec->output_.u.YUVA.v_size = v_size;
  return idec;
}

//------------------------------------------------------------------------------

static VP8StatusCode IDecCheckStatus(const WebPIDecoder* const idec) {
  assert(idec);
  if (idec->dec_ == NULL) {
    return VP8_STATUS_USER_ABORT;
  }
  if (idec->state_ == STATE_ERROR) {
    return VP8_STATUS_BITSTREAM_ERROR;
  }
  if (idec->state_ == STATE_DONE) {
    return VP8_STATUS_OK;
  }
  return VP8_STATUS_SUSPENDED;
}

VP8StatusCode WebPIAppend(WebPIDecoder* const idec, const uint8_t* data,
                          uint32_t data_size) {
  VP8StatusCode status;
  if (idec == NULL || data == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  status = IDecCheckStatus(idec);
  if (status != VP8_STATUS_SUSPENDED) {
    return status;
  }
  // Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
  if (!CheckMemBufferMode(&idec->mem_, MEM_MODE_APPEND)) {
    return VP8_STATUS_INVALID_PARAM;
  }
  // Append data to memory buffer
  if (!AppendToMemBuffer(idec, data, data_size)) {
    return VP8_STATUS_OUT_OF_MEMORY;
  }
  return IDecode(idec);
}

VP8StatusCode WebPIUpdate(WebPIDecoder* const idec, const uint8_t* data,
                          uint32_t data_size) {
  VP8StatusCode status;
  if (idec == NULL || data == NULL) {
    return VP8_STATUS_INVALID_PARAM;
  }
  status = IDecCheckStatus(idec);
  if (status != VP8_STATUS_SUSPENDED) {
    return status;
  }
  // Check mixed calls between RemapMemBuffer and AppendToMemBuffer.
  if (!CheckMemBufferMode(&idec->mem_, MEM_MODE_MAP)) {
    return VP8_STATUS_INVALID_PARAM;
  }
  // Make the memory buffer point to the new buffer
  if (!RemapMemBuffer(idec, data, data_size)) {
    return VP8_STATUS_INVALID_PARAM;
  }
  return IDecode(idec);
}

//------------------------------------------------------------------------------

static const WebPDecBuffer* GetOutputBuffer(const WebPIDecoder* const idec) {
  if (!idec || !idec->dec_ || idec->state_ <= STATE_PARTS0) {
    return NULL;
  }
  return idec->params_.output;
}

const WebPDecBuffer* WebPIDecodedArea(const WebPIDecoder* const idec,
                                      int* const left, int* const top,
                                      int* const width, int* const height) {
  const WebPDecBuffer* const src = GetOutputBuffer(idec);
  if (left) *left = 0;
  if (top) *top = 0;
  // TODO(skal): later include handling of rotations.
  if (src) {
    if (width) *width = src->width;
    if (height) *height = idec->params_.last_y;
  } else {
    if (width) *width = 0;
    if (height) *height = 0;
  }
  return src;
}

uint8_t* WebPIDecGetRGB(const WebPIDecoder* const idec, int* last_y,
                        int* width, int* height, int* stride) {
  const WebPDecBuffer* const src = GetOutputBuffer(idec);
  if (!src) return NULL;
  if (src->colorspace >= MODE_YUV) {
    return NULL;
  }

  if (last_y) *last_y = idec->params_.last_y;
  if (width) *width = src->width;
  if (height) *height = src->height;
  if (stride) *stride = src->u.RGBA.stride;

  return src->u.RGBA.rgba;
}

uint8_t* WebPIDecGetYUV(const WebPIDecoder* const idec, int* last_y,
                        uint8_t** u, uint8_t** v,
                        int* width, int* height, int *stride, int* uv_stride) {
  const WebPDecBuffer* const src = GetOutputBuffer(idec);
  if (!src) return NULL;
  if (src->colorspace < MODE_YUV) {
    return NULL;
  }

  if (last_y) *last_y = idec->params_.last_y;
  if (u) *u = src->u.YUVA.u;
  if (v) *v = src->u.YUVA.v;
  if (width) *width = src->width;
  if (height) *height = src->height;
  if (stride) *stride = src->u.YUVA.y_stride;
  if (uv_stride) *uv_stride = src->u.YUVA.u_stride;

  return src->u.YUVA.y;
}

int WebPISetIOHooks(WebPIDecoder* const idec,
                    VP8IoPutHook put,
                    VP8IoSetupHook setup,
                    VP8IoTeardownHook teardown,
                    void* user_data) {
  if (!idec || !idec->dec_ || idec->state_ > STATE_HEADER) {
    return 0;
  }

  idec->io_.put = put;
  idec->io_.setup = setup;
  idec->io_.teardown = teardown;
  idec->io_.opaque = user_data;

  return 1;
}

#if defined(__cplusplus) || defined(c_plusplus)
}    // extern "C"
#endif