Bugzilla

#ifdef MOZ_WEBM

contract @mozilla.org/uriloader/content-handler;1?type=image/webp {5d0ce354-df01-421a-83fb-7ead0990c24e} application={ec8030f7-c20a-464f-9b0e-13a3a9e97384}

#endif

#ifdef MOZ_WEBM

  { "Gecko-Content-Viewers", "image/webp", "@mozilla.org/content/document-loader-factory;1" },

#endif

          nsWebPDecoder.cpp \

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * ***** BEGIN LICENSE BLOCK *****

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is WebP Decoder.

 *

 * The Initial Developer of the Original Code is Google Inc.

 * Portions created by the Initial Developer are Copyright (C) 2010

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *   Aaron Kaluszka <ask@swva.net>

 *

 * Alternatively, the contents of this file may be used under the terms of

 * either the GNU General Public License Version 2 or later (the "GPL"), or

 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 * ***** END LICENSE BLOCK ***** */

#include "nsWebPDecoder.h"

#include "nsIInputStream.h"

#include "RasterImage.h"

#include "imgIContainerObserver.h"

#include "prlog.h"

namespace mozilla {

namespace imagelib {

#ifdef PR_LOGGING

PRLogModuleInfo *gWebPLog = PR_NewLogModule("WebPDecoder");

#endif

nsWebPDecoder::nsWebPDecoder() :

  mWidth(-1),

  mHeight(-1),

  mPos(0),

  mData(nsnull),

  mIter(nsnull)

{

  if (!sInitDone) {

    // Initialize look-up tables for YUV to RGB conversion

    for (PRInt32 i = 0; i < 256; ++i)

    {

      sVToR[i] = ( 89858 * (i - 128) + RGB_HALF) >> RGB_FRAC;

      sUToG[i] =  -22014 * (i - 128) + RGB_HALF;

      sVToG[i] =  -45773 * (i - 128);

      sUToB[i] = (113618 * (i - 128) + RGB_HALF) >> RGB_FRAC;

    }

    for (PRInt32 i = RGB_RANGE_MIN; i < RGB_RANGE_MAX; ++i) {

      const PRInt32 j = ((i - 16) * 76283 + RGB_HALF) >> RGB_FRAC;

      sClip[i - RGB_RANGE_MIN] = (j < 0) ? 0 : (j > 255) ? 255 : j;

    }

    sInitDone = PR_TRUE;

  }

}

nsWebPDecoder::~nsWebPDecoder()

{

  if (mData)

    free(mData);

}

void nsWebPDecoder::InitInternal()

{

  // Initialize libvpx

  if (vpx_codec_dec_init(&mDec, &vpx_codec_vp8_dx_algo, NULL, 0) != VPX_CODEC_OK) {

    PostDecoderError(NS_ERROR_FAILURE);

    return;

  }

  mPPCfg.post_proc_flag = VP8_NOFILTERING;

  vpx_codec_control(&mDec, VP8_SET_POSTPROC, &mPPCfg);

}

void

nsWebPDecoder::WriteInternal(const char *aBuffer, PRUint32 aCount)

{

  NS_ABORT_IF_FALSE(!HasError(), "Shouldn't call WriteInternal after error!");

  // aCount = 0 means EOF, mWidth set means image has been processed

  if (!aCount || mWidth != -1)

    return;

  // RIFF layout is:

  // Offset  Data

  // 0...3   "RIFF" 4-byte tag

  // 4...7   Size of image data (including metadata) starting at offset 8

  // 8...11  "WEBP" Form-type signature

  // 12..15  "VP8 " 4-byte tag describing the raw video format used

  // 16..19  Size of the raw WebP image data, starting at offset 20

  // 20....  The WebP bytes

  // There can be extra chunks after the "VP8 " chunk (ICMT, ICOP, ...)

  // All 32-bits sizes are in little-endian order.

  // Note: chunk data must be padded to multiple of 2 in size

  if (mPos < RIFF_HEADER_LENGTH) {

    PRUint32 toCopy = RIFF_HEADER_LENGTH - mPos;

    if (toCopy > aCount)

      toCopy = aCount;

    memcpy(mHeaderData + mPos, aBuffer, toCopy);

    mPos += toCopy;

    aCount -= toCopy;

    aBuffer += toCopy;

  }

  if (mPos == RIFF_HEADER_LENGTH) {

    if (memcmp(mHeaderData,      "RIFF", 4)) {

      PostDataError(); // wrong image file signature

      return;

	}

    if (memcmp(mHeaderData +  8, "WEBP", 4)) {

      PostDataError(); // wrong image file signature

      return;

	}

    if (memcmp(mHeaderData + 12, "VP8 ", 4)) {

      PostDataError(); // invalid compression format

      return;

	}

    mDataLength = LITTLE_TO_NATIVE32(*(PRUint32*)(mHeaderData + 16));

    if ((mDataLength > LITTLE_TO_NATIVE32(*(PRUint32*)(mHeaderData + 4)) + 8) || (mDataLength & 1)) {

      PostDataError(); // inconsistent size information

      return;

	}

	mData = (PRUint8*)moz_malloc(mDataLength);

	if (!mData) {

      PostDecoderError(NS_ERROR_OUT_OF_MEMORY);

      return;

    }

  }

  // XXX Currently no progressive decoding support, so grab all image data

  if (aCount && mPos >= RIFF_HEADER_LENGTH && mPos < RIFF_HEADER_LENGTH + mDataLength) {

    PRUint32 toCopy = RIFF_HEADER_LENGTH + mDataLength - mPos;

    if (toCopy > aCount)

      toCopy = aCount;

    memcpy(mData + mPos - RIFF_HEADER_LENGTH, aBuffer, toCopy);

    mPos += toCopy;

    aCount -= toCopy;

    aBuffer += toCopy;

  }

  if (mPos == RIFF_HEADER_LENGTH + mDataLength - 1) {

    // Avoid full decode for size query

    if (IsSizeDecode()) {

	  vpx_codec_stream_info_t streamInfo;

      if (vpx_codec_peek_stream_info(&vpx_codec_vp8_dx_algo, mData, mDataLength, &streamInfo) != VPX_CODEC_OK) {

        PostDataError();

        return;

      }

      mWidth = streamInfo.w;

      mHeight = streamInfo.h;

      PR_LOG(gWebPLog, PR_LOG_DEBUG, ("WebP image is %lix%lix.\n", mWidth, mHeight));

      // Post our size to the superclass

      PostSize(mWidth, mHeight);

      return;

    }

    // Decode data with libvpx

	if (vpx_codec_decode(&mDec, mData, mDataLength, NULL, 0) != VPX_CODEC_OK) {

      PostDataError();

      return;

    }

    // Get image frame from libvpx

    vpx_image_t* const imageFrame = vpx_codec_get_frame(&mDec, &mIter);

    if (!imageFrame) {

      PostDataError();

      return;

    }

    mWidth = imageFrame->d_w;

    mHeight = imageFrame->d_h;

    PR_LOG(gWebPLog, PR_LOG_DEBUG, ("WebP image is %lix%lix.\n", mWidth, mHeight));

    // Post our size to the superclass

    PostSize(mWidth, mHeight);

    PRUint32 imageLength;

    PRUint32* imageData;

    nsresult rv = mImage->AppendFrame(0, 0, mWidth, mHeight, gfxASurface::ImageFormatARGB32, 

                                      (PRUint8**)&imageData, &imageLength);

    if (NS_FAILED(rv) || !imageData) {

      PostDecoderError(NS_ERROR_FAILURE);

      return;

    }

    // Tell the superclass we're starting a frame

    PostFrameStart();

    // Get YUV data from decoder

    PRUint8* YSrc = imageFrame->planes[0];

    PRUint8* USrc = imageFrame->planes[1];

    PRUint8* VSrc = imageFrame->planes[2];

    PRUint32* Dst = imageData;

    PRUint32 YStride = imageFrame->stride[0];

    PRUint32 UStride = imageFrame->stride[1];

    PRUint32 VStride = imageFrame->stride[2];

    // Generate ARGB image from YUV data (with height upsampling of chroma data)

    for (PRInt32 y = 0; y < (mHeight >> 1); ++y)

    {

      YUV420toARGBLine(Dst, YSrc, USrc, VSrc);

	  YSrc += YStride;

      YUV420toARGBLine(Dst, YSrc, USrc, VSrc);

	  YSrc += YStride;

	  USrc += UStride;

	  VSrc += VStride;

    }

    if(mHeight & 1) // Bottom row (if image has odd height)

      YUV420toARGBLine(Dst, YSrc, USrc, VSrc);

    // Invalidate

    nsIntRect r(0, 0, mWidth, mHeight);

    PostInvalidation(r);

  }

}

void

nsWebPDecoder::FinishInternal()

{

  // We shouldn't be called in error cases

  NS_ABORT_IF_FALSE(!HasError(), "Can't call FinishInternal on error!");

  vpx_codec_destroy(&mDec);

  // We should never make multiple frames

  NS_ABORT_IF_FALSE(GetFrameCount() <= 1, "Multiple WebP frames?");

  // Send notifications if appropriate

  if (!IsSizeDecode() && (GetFrameCount() == 1)) {

      PostFrameStop();

      PostDecodeDone();

  }

}

// Converts YUV to RGB and writes into a 32 bit pixel in endian-neutral fashion

inline void

nsWebPDecoder::SetPixel(PRUint32*& aDst, PRUint8 aY, PRUint8 aU, PRUint8 aV, PRUint8 aAlpha = 0xFF)

{

  *aDst++ = GFX_PACKED_PIXEL(aAlpha, 

    sClip[aY + sVToR[aV] - RGB_RANGE_MIN], 

    sClip[aY + ((sVToG[aV] + sUToG[aU]) >> RGB_FRAC) - RGB_RANGE_MIN], 

    sClip[aY + sUToB[aU] - RGB_RANGE_MIN]);

}

// Generate ARGB row from an YUV row (with width upsampling of chroma data)

void 

nsWebPDecoder::YUV420toARGBLine(PRUint32*& aDst, PRUint8* aYSrc, PRUint8* aUSrc, PRUint8* aVSrc)

{

  for (PRInt32 x = 0; x < (mWidth >> 1); ++x) {

    SetPixel(aDst, *aYSrc++, *aUSrc,   *aVSrc  );

    SetPixel(aDst, *aYSrc++, *aUSrc++, *aVSrc++);

  }

  if (mWidth & 1) // Right-most pixel (if image has odd width)

    SetPixel(aDst, *aYSrc++, *aUSrc++, *aVSrc++);

}

PRBool nsWebPDecoder::sInitDone = PR_FALSE;

PRInt16 nsWebPDecoder::sVToR[256];

PRInt16 nsWebPDecoder::sUToB[256];

PRInt32 nsWebPDecoder::sVToG[256];

PRInt32 nsWebPDecoder::sUToG[256];

PRUint8 nsWebPDecoder::sClip[RGB_RANGE_MAX - RGB_RANGE_MIN];

} // namespace imagelib

} // namespace mozilla

/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*-

 * ***** BEGIN LICENSE BLOCK *****

 * Version: MPL 1.1/GPL 2.0/LGPL 2.1

 *

 * The contents of this file are subject to the Mozilla Public License Version

 * 1.1 (the "License"); you may not use this file except in compliance with

 * the License. You may obtain a copy of the License at

 * http://www.mozilla.org/MPL/

 *

 * Software distributed under the License is distributed on an "AS IS" basis,

 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License

 * for the specific language governing rights and limitations under the

 * License.

 *

 * The Original Code is WebP Decoder.

 *

 * The Initial Developer of the Original Code is Google Inc.

 * Portions created by the Initial Developer are Copyright (C) 2010

 * the Initial Developer. All Rights Reserved.

 *

 * Contributor(s):

 *   Aaron Kaluszka <ask@swva.net>

 *

 * Alternatively, the contents of this file may be used under the terms of

 * either the GNU General Public License Version 2 or later (the "GPL"), or

 * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),

 * in which case the provisions of the GPL or the LGPL are applicable instead

 * of those above. If you wish to allow use of your version of this file only

 * under the terms of either the GPL or the LGPL, and not to allow others to

 * use your version of this file under the terms of the MPL, indicate your

 * decision by deleting the provisions above and replace them with the notice

 * and other provisions required by the GPL or the LGPL. If you do not delete

 * the provisions above, a recipient may use your version of this file under

 * the terms of any one of the MPL, the GPL or the LGPL.

 *

 * ***** END LICENSE BLOCK ***** */

#ifndef nsWebMDecoder_h__

#define nsWebMDecoder_h__

#include "Decoder.h"

#include "nsAutoPtr.h"

#include "imgIDecoderObserver.h"

#include "vpx/vpx_decoder.h"

#include "vpx/vp8dx.h"

namespace mozilla {

namespace imagelib {

class nsWebPDecoder : public Decoder

{

public:

  nsWebPDecoder();

  virtual ~nsWebPDecoder();

  virtual void InitInternal();

  virtual void WriteInternal(const char* aBuffer, PRUint32 aCount);

  virtual void FinishInternal();

  enum {

    RIFF_HEADER_LENGTH = 20,

    RGB_FRAC = 16,

    RGB_HALF = (1 << RGB_FRAC) / 2,

    RGB_RANGE_MIN = -227,

    RGB_RANGE_MAX = 256 + 226

  };

  // Static look-up tables for YUV to RGB conversion

  static PRInt16 sVToR[256];

  static PRInt16 sUToB[256];

  static PRInt32 sVToG[256];

  static PRInt32 sUToG[256];

  static PRUint8 sClip[RGB_RANGE_MAX - RGB_RANGE_MIN];

  static PRBool sInitDone; // Are static members initialized?

private:

  /** Converts YUV to RGB and writes into a 32 bit pixel in endian neutral fashion

   * The exact naming is Y'CbCr, following the ITU-R BT.601 standard.

   * More information at: http://en.wikipedia.org/wiki/YCbCr

   * @param aDst pointer to pixel to be set, will be incremented to point to the next pixel

   * @param aY Y value

   * @param aU U value

   * @param aV V value

   */

  inline void SetPixel(PRUint32*& aDst, PRUint8 aY, PRUint8 aU, PRUint8 aV, PRUint8 aAlpha);

  /** Generate ARGB row from an YUV row (with width upsampling of chroma data)

   * @param aDst pointer to row of pixels to be set, will be incremented to point to the next row

   * @param aYSrc pointer to row of Y pixels

   * @param aUsrc pointer to row of V pixels

   * @param aVSrc pointer to row of U pixels

   */

  void YUV420toARGBLine(PRUint32*& aDst, PRUint8* aYSrc, PRUint8* aUSrc, PRUint8* aVSrc);

#if defined WORDS_BIGENDIAN || defined IS_BIG_ENDIAN

#define LITTLE_TO_NATIVE32(x) (((((PRUint32) x)        & 0xFF) << 24) | \

                              (((((PRUint32) x) >>  8) & 0xFF) << 16) | \

                              (((((PRUint32) x) >> 16) & 0xFF) <<  8) | \

                                (((PRUint32) x) >> 24))

#else

#define LITTLE_TO_NATIVE32(x) x

#endif

  PRUint32 mWidth;

  PRUint32 mHeight;

  PRUint32 mPos;  // Current processing position in incoming data

  PRUint8  mHeaderData[RIFF_HEADER_LENGTH];  // Image header data

  PRUint8 *mData;  // Pointer to WebP-encoded data

  PRUint32 mDataLength;  // Length of WebP-encoded data

  vpx_codec_ctx_t mDec;  // libvpx decoder

  vp8_postproc_cfg_t mPPCfg; // libvpx configuration

  vpx_codec_iter_t mIter;  // libvpx iterator

};

} // namespace imagelib

} // namespace mozilla

#endif // nsWebPDecoder_h__

#ifdef MOZ_WEBM

  // WebP

  else if (!strcmp(aMimeType, "image/webp"))

    rv = eDecoderType_webp;

#endif

#ifdef MOZ_WEBM

    eDecoderType_webp    = 6,

    eDecoderType_unknown = 7

#else

#endif

#ifdef MOZ_WEBM

#include "nsWebPDecoder.h"

#endif

#ifdef MOZ_WEBM

    case eDecoderType_webp:

      mDecoder = new nsWebPDecoder();

      break;

#endif

#define IMAGE_WEBP                          "image/webp"

#ifdef MOZ_WEBM

  { IMAGE_WEBP, "webp" },

#endif

  { IMAGE_WEBP, "webp", "WebP Image" },