author | Chris Double <chris.double@double.co.nz> |
Mon, 19 Apr 2010 13:17:06 +1200 | |
changeset 41188 | ae968e2a47926065da0ea32d302119fc91fc4eae |
parent 41187 | 8432af71c6852ba54027cea9dd29904bac5c0a72 |
child 41189 | 8eb90e55307978e1e18de60180bcd487eabe4ce3 |
push id | unknown |
push user | unknown |
push date | unknown |
reviewers | roc |
bugs | 551277 |
milestone | 1.9.3a5pre |
first release with | nightly linux32
nightly linux64
nightly mac
nightly win32
nightly win64
|
last release without | nightly linux32
nightly linux64
nightly mac
nightly win32
|
--- a/content/media/ogg/nsOggPlayStateMachine.cpp +++ b/content/media/ogg/nsOggPlayStateMachine.cpp @@ -964,165 +964,95 @@ nsresult nsOggPlayStateMachine::Run() } break; } } return NS_OK; } -static void ToARGBHook(const PlanarYCbCrImage::Data& aData, PRUint8* aOutput) -{ - OggPlayYUVChannels yuv; - NS_ASSERTION(aData.mYStride == aData.mYSize.width, - "Stride not supported"); - NS_ASSERTION(aData.mCbCrStride == aData.mCbCrSize.width, - "Stride not supported"); - yuv.ptry = aData.mYChannel; - yuv.ptru = aData.mCbChannel; - yuv.ptrv = aData.mCrChannel; - yuv.uv_width = aData.mCbCrSize.width; - yuv.uv_height = aData.mCbCrSize.height; - yuv.y_width = aData.mYSize.width; - yuv.y_height = aData.mYSize.height; - - OggPlayRGBChannels rgb; - rgb.ptro = aOutput; - rgb.rgb_width = aData.mYSize.width; - rgb.rgb_height = aData.mYSize.height; - - oggplay_yuv2bgra(&yuv, &rgb); -} - void nsOggPlayStateMachine::RenderVideoFrame(VideoData* aData) { NS_ASSERTION(IsThread(mDecoder->mStateMachineThread), "Should be on state machine thread."); if (aData->mDuplicate) { return; } - unsigned xSubsample = (aData->mBuffer[1].width != 0) ? - (aData->mBuffer[0].width / aData->mBuffer[1].width) : 0; - - unsigned ySubsample = (aData->mBuffer[1].height != 0) ? - (aData->mBuffer[0].height / aData->mBuffer[1].height) : 0; - - if (xSubsample == 0 || ySubsample == 0) { - // We can't perform yCbCr to RGB, so we can't render the frame... - return; - } NS_ASSERTION(mInfo.mPicture.width != 0 && mInfo.mPicture.height != 0, "We can only render non-zero-sized video"); - - unsigned cbCrStride = mInfo.mPicture.width / xSubsample; - unsigned cbCrHeight = mInfo.mPicture.height / ySubsample; + NS_ASSERTION(aData->mBuffer[0].stride >= 0 && aData->mBuffer[0].height >= 0 && + aData->mBuffer[1].stride >= 0 && aData->mBuffer[1].height >= 0 && + aData->mBuffer[2].stride >= 0 && aData->mBuffer[2].height >= 0, + "YCbCr stride and height must be non-negative"); // Ensure the picture size specified in the headers can be extracted out of // the frame we've been supplied without indexing out of bounds. PRUint32 picXLimit; PRUint32 picYLimit; if (!AddOverflow(mInfo.mPicture.x, mInfo.mPicture.width, picXLimit) || picXLimit > PRUint32(PR_ABS(aData->mBuffer[0].stride)) || !AddOverflow(mInfo.mPicture.y, mInfo.mPicture.height, picYLimit) || picYLimit > PRUint32(PR_ABS(aData->mBuffer[0].height))) { // The specified picture dimensions can't be contained inside the video // frame, we'll stomp memory if we try to copy it. Fail. return; } - unsigned cbCrSize = PR_ABS(aData->mBuffer[0].stride * aData->mBuffer[0].height) + - PR_ABS(aData->mBuffer[1].stride * aData->mBuffer[1].height) * 2; + unsigned ySize = aData->mBuffer[0].stride * aData->mBuffer[0].height; + unsigned cbSize = aData->mBuffer[1].stride * aData->mBuffer[1].height; + unsigned crSize = aData->mBuffer[2].stride * aData->mBuffer[2].height; + unsigned cbCrSize = ySize + cbSize + crSize; + if (cbCrSize != mCbCrSize) { mCbCrSize = cbCrSize; mCbCrBuffer = static_cast<unsigned char*>(moz_xmalloc(cbCrSize)); if (!mCbCrBuffer) { // Malloc failed... NS_WARNING("Malloc failure allocating YCbCr->RGB buffer"); return; } } unsigned char* data = mCbCrBuffer.get(); unsigned char* y = data; - unsigned char* cb = y + (mInfo.mPicture.width * PR_ABS(aData->mBuffer[0].height)); - unsigned char* cr = cb + (cbCrStride * PR_ABS(aData->mBuffer[1].height)); - - unsigned char* p = y; - unsigned char* q = aData->mBuffer[0].data + mInfo.mPicture.x + - aData->mBuffer[0].stride * mInfo.mPicture.y; - for(PRInt32 i=0; i < mInfo.mPicture.height; ++i) { - NS_ASSERTION(q + mInfo.mPicture.width < - aData->mBuffer[0].data + aData->mBuffer[0].stride * aData->mBuffer[0].height, - "Y read must be in bounds"); - NS_ASSERTION(p + mInfo.mPicture.width < data + mCbCrSize, - "Memory copy 1 will stomp"); - memcpy(p, q, mInfo.mPicture.width); - p += mInfo.mPicture.width; - q += aData->mBuffer[0].stride; - } - - unsigned xo = xSubsample ? (mInfo.mPicture.x / xSubsample) : 0; - unsigned yo = ySubsample ? aData->mBuffer[1].stride * (mInfo.mPicture.y / ySubsample) : 0; - - unsigned cbCrOffset = xo+yo; - p = cb; - q = aData->mBuffer[1].data + cbCrOffset; - unsigned char* p2 = cr; - unsigned char* q2 = aData->mBuffer[2].data + cbCrOffset; -#ifdef DEBUG - unsigned char* buffer1Limit = - aData->mBuffer[1].data + aData->mBuffer[1].stride * aData->mBuffer[1].height; - unsigned char* buffer2Limit = - aData->mBuffer[2].data + aData->mBuffer[2].stride * aData->mBuffer[2].height; -#endif - for(unsigned i=0; i < cbCrHeight; ++i) { - NS_ASSERTION(q + cbCrStride <= buffer1Limit, - "Cb source read must be within bounds"); - NS_ASSERTION(q2 + cbCrStride <= buffer2Limit, - "Cr source read must be within bounds"); - NS_ASSERTION(p + cbCrStride < data + mCbCrSize, - "Cb write destination must be within bounds"); - NS_ASSERTION(p2 + cbCrStride < data + mCbCrSize, - "Cr write destination must be within bounds"); - memcpy(p, q, cbCrStride); - memcpy(p2, q2, cbCrStride); - p += cbCrStride; - p2 += cbCrStride; - q += aData->mBuffer[1].stride; - q2 += aData->mBuffer[2].stride; - } - + unsigned char* cb = y + ySize; + unsigned char* cr = cb + cbSize; + + memcpy(y, aData->mBuffer[0].data, ySize); + memcpy(cb, aData->mBuffer[1].data, cbSize); + memcpy(cr, aData->mBuffer[2].data, crSize); + ImageContainer* container = mDecoder->GetImageContainer(); // Currently our Ogg decoder only knows how to output to PLANAR_YCBCR // format. Image::Format format = Image::PLANAR_YCBCR; nsRefPtr<Image> image; if (container) { image = container->CreateImage(&format, 1); } if (image) { NS_ASSERTION(image->GetFormat() == Image::PLANAR_YCBCR, "Wrong format?"); PlanarYCbCrImage* videoImage = static_cast<PlanarYCbCrImage*>(image.get()); - // XXX this is only temporary until we get YCbCr code in the layer - // system. - videoImage->SetRGBConverter(ToARGBHook); PlanarYCbCrImage::Data data; data.mYChannel = y; - data.mYSize = gfxIntSize(mInfo.mPicture.width, mInfo.mPicture.height); - data.mYStride = mInfo.mPicture.width; + data.mYSize = gfxIntSize(mInfo.mFrame.width, mInfo.mFrame.height); + data.mYStride = aData->mBuffer[0].stride; data.mCbChannel = cb; data.mCrChannel = cr; - data.mCbCrSize = gfxIntSize(cbCrStride, cbCrHeight); - data.mCbCrStride = cbCrStride; + data.mCbCrSize = gfxIntSize(aData->mBuffer[1].width, aData->mBuffer[1].height); + data.mCbCrStride = aData->mBuffer[1].stride; + data.mPicX = mInfo.mPicture.x; + data.mPicY = mInfo.mPicture.y; + data.mPicSize = gfxIntSize(mInfo.mPicture.width, mInfo.mPicture.height); videoImage->SetData(data); - mDecoder->SetVideoData(data.mYSize, mInfo.mAspectRatio, image); + mDecoder->SetVideoData(data.mPicSize, mInfo.mAspectRatio, image); } } PRInt64 nsOggPlayStateMachine::GetAudioClock() { NS_ASSERTION(IsThread(mDecoder->mStateMachineThread), "Should be on state machine thread."); if (!mAudioStream || !HasAudio())
--- a/gfx/Makefile.in +++ b/gfx/Makefile.in @@ -43,17 +43,17 @@ VPATH = @srcdir@ include $(DEPTH)/config/autoconf.mk MODULE = gfx ifdef MOZ_TREE_CAIRO DIRS = cairo endif -DIRS += thebes public idl src qcms layers +DIRS += thebes public idl src qcms ycbcr layers ifdef MOZ_IPC DIRS += ipc endif ifdef ENABLE_TESTS ifndef MOZ_ENABLE_LIBXUL TOOL_DIRS += tests
--- a/gfx/layers/ImageLayers.h +++ b/gfx/layers/ImageLayers.h @@ -201,40 +201,51 @@ protected: gfxPattern::GraphicsFilter mFilter; }; /****** Image subtypes for the different formats ******/ /** * We assume that the image data is in the REC 470M color space (see * Theora specification, section 4.3.1). - * XXX Eventually we should some color space parameter(s) here. + * + * The YCbCr format can be: + * + * 4:4:4 - CbCr width/height are the same as Y. + * 4:2:2 - CbCr width is half that of Y. Height is the same. + * 4:2:0 - CbCr width and height is half that of Y. + * + * The color format is detected based on the height/width ratios + * defined above. + * + * The Image that is rendered is the picture region defined by + * mPicX, mPicY and mPicSize. The size of the rendered image is + * mPicSize, not mYSize or mCbCrSize. + * + * Note: The color-conversion code does not currently support 4:4:4 + * and an error is raised in this case. See bug 551378. */ class THEBES_API PlanarYCbCrImage : public Image { public: struct Data { // Luminance buffer PRUint8* mYChannel; PRInt32 mYStride; gfxIntSize mYSize; // Chroma buffers PRUint8* mCbChannel; PRUint8* mCrChannel; PRInt32 mCbCrStride; gfxIntSize mCbCrSize; + // Picture region + PRUint32 mPicX; + PRUint32 mPicY; + gfxIntSize mPicSize; }; - typedef void (* ToARGBHook)(const Data& aData, PRUint8* aOutput); - /** - * XXX this is just a hack until we can get YCbCr conversion code into - * gfx - * This must be called before SetData(). - */ - virtual void SetRGBConverter(ToARGBHook aHook) {} - /** * This makes a copy of the data buffers. * XXX Eventually we will change this to not make a copy of the data, * but we can't do that until we have tighter control of nsOggDecoder's * buffer management (i.e. not going through liboggplay). Right now * it doesn't matter because the BasicLayer implementation does YCbCr * conversion here anyway. */
--- a/gfx/layers/Makefile.in +++ b/gfx/layers/Makefile.in @@ -68,16 +68,17 @@ CPPSRCS = \ ThebesLayerOGL.cpp \ ContainerLayerOGL.cpp \ ImageLayerOGL.cpp \ $(NULL) EXTRA_DSO_LIBS = \ gkgfx \ thebes \ + ycbcr \ $(NULL) EXTRA_DSO_LDOPTS += \ $(LIBS_DIR) \ $(EXTRA_DSO_LIBS) \ $(MOZ_CAIRO_LIBS) \ $(XPCOM_LIBS) \ $(NSPR_LIBS) \
--- a/gfx/layers/basic/BasicImages.cpp +++ b/gfx/layers/basic/BasicImages.cpp @@ -42,16 +42,18 @@ #include "gfxImageSurface.h" #ifdef XP_MACOSX #include "gfxQuartzImageSurface.h" #endif #include "cairo.h" +#include "yuv_convert.h" + using mozilla::Monitor; namespace mozilla { namespace layers { /** * All our images can yield up a cairo surface and their size. */ @@ -98,49 +100,74 @@ protected: /** * We handle YCbCr by converting to RGB when the image is initialized * (which should be done off the main thread). The RGB results are stored * in a memory buffer and converted to a cairo surface lazily. */ class BasicPlanarYCbCrImage : public PlanarYCbCrImage, public BasicImageImplData { public: BasicPlanarYCbCrImage() : - PlanarYCbCrImage(static_cast<BasicImageImplData*>(this)), - mToARGB(nsnull) + PlanarYCbCrImage(static_cast<BasicImageImplData*>(this)) {} - virtual void SetRGBConverter(ToARGBHook aHook) { mToARGB = aHook; } virtual void SetData(const Data& aData); virtual already_AddRefed<gfxASurface> GetAsSurface(); protected: - ToARGBHook mToARGB; nsAutoArrayPtr<PRUint8> mBuffer; nsCountedRef<nsMainThreadSurfaceRef> mSurface; }; void BasicPlanarYCbCrImage::SetData(const Data& aData) { // Do some sanity checks to prevent integer overflow if (aData.mYSize.width > 16384 || aData.mYSize.height > 16384) { NS_ERROR("Illegal width or height"); return; } - size_t size = aData.mYSize.width*aData.mYSize.height*4; + size_t size = aData.mPicSize.width*aData.mPicSize.height*4; mBuffer = new PRUint8[size]; if (!mBuffer) { // out of memory return; } + gfx::YUVType type = gfx::YV12; + if (aData.mYSize.width == aData.mCbCrSize.width && + aData.mYSize.height == aData.mCbCrSize.height) { + NS_ERROR("YCbCr 4:4:4 format not supported"); + } + else if (aData.mYSize.width / 2 == aData.mCbCrSize.width && + aData.mYSize.height == aData.mCbCrSize.height) { + type = gfx::YV16; + } + else if (aData.mYSize.width / 2 == aData.mCbCrSize.width && + aData.mYSize.height / 2 == aData.mCbCrSize.height ) { + type = gfx::YV12; + } + else { + NS_ERROR("YCbCr format not supported"); + } + // Convert from YCbCr to RGB now - mToARGB(aData, mBuffer); - mSize = aData.mYSize; + gfx::ConvertYCbCrToRGB32(aData.mYChannel, + aData.mCbChannel, + aData.mCrChannel, + mBuffer, + aData.mPicX, + aData.mPicY, + aData.mPicSize.width, + aData.mPicSize.height, + aData.mYStride, + aData.mCbCrStride, + aData.mPicSize.width*4, + type); + mSize = aData.mPicSize; } static cairo_user_data_key_t imageSurfaceDataKey; static void DestroyBuffer(void* aBuffer) { delete[] static_cast<PRUint8*>(aBuffer);
--- a/gfx/layers/opengl/ImageLayerOGL.cpp +++ b/gfx/layers/opengl/ImageLayerOGL.cpp @@ -198,25 +198,63 @@ PlanarYCbCrImageOGL::~PlanarYCbCrImageOG delete [] mData.mCbChannel; delete [] mData.mCrChannel; } } void PlanarYCbCrImageOGL::SetData(const PlanarYCbCrImage::Data &aData) { + int width_shift = 0; + int height_shift = 0; + if (aData.mYSize.width == aData.mCbCrSize.width && + aData.mYSize.height == aData.mCbCrSize.height) { + // YV24 format + width_shift = 0; + height_shift = 0; + } else if (aData.mYSize.width / 2 == aData.mCbCrSize.width && + aData.mYSize.height == aData.mCbCrSize.height) { + // YV16 format + width_shift = 1; + height_shift = 0; + } else if (aData.mYSize.width / 2 == aData.mCbCrSize.width && + aData.mYSize.height / 2 == aData.mCbCrSize.height ) { + // YV12 format + width_shift = 1; + height_shift = 1; + } else { + NS_ERROR("YCbCr format not supported"); + } + mData = aData; - mData.mCbChannel = new PRUint8[aData.mCbCrStride * aData.mCbCrSize.height]; - mData.mCrChannel = new PRUint8[aData.mCbCrStride * aData.mCbCrSize.height]; - mData.mYChannel = new PRUint8[aData.mYStride * aData.mYSize.height]; - memcpy(mData.mCbChannel, aData.mCbChannel, aData.mCbCrStride * aData.mCbCrSize.height); - memcpy(mData.mCrChannel, aData.mCrChannel, aData.mCbCrStride * aData.mCbCrSize.height); - memcpy(mData.mYChannel, aData.mYChannel, aData.mYStride * aData.mYSize.height); + mData.mCbCrStride = mData.mCbCrSize.width = aData.mPicSize.width >> width_shift; + mData.mCbCrSize.height = aData.mPicSize.height >> height_shift; + mData.mYSize = aData.mPicSize; + mData.mYStride = mData.mYSize.width; + mData.mCbChannel = new PRUint8[mData.mCbCrStride * mData.mCbCrSize.height]; + mData.mCrChannel = new PRUint8[mData.mCbCrStride * mData.mCbCrSize.height]; + mData.mYChannel = new PRUint8[mData.mYStride * mData.mYSize.height]; + int cbcr_x = aData.mPicX >> width_shift; + int cbcr_y = aData.mPicY >> height_shift; - mSize = aData.mYSize; + for (int i = 0; i < mData.mCbCrSize.height; i++) { + memcpy(mData.mCbChannel + i * mData.mCbCrStride, + aData.mCbChannel + ((cbcr_y + i) * aData.mCbCrStride) + cbcr_x, + mData.mCbCrStride); + memcpy(mData.mCrChannel + i * mData.mCbCrStride, + aData.mCrChannel + ((cbcr_y + i) * aData.mCbCrStride) + cbcr_x, + mData.mCbCrStride); + } + for (int i = 0; i < mData.mYSize.height; i++) { + memcpy(mData.mYChannel + i * mData.mYStride, + aData.mYChannel + ((aData.mPicY + i) * aData.mYStride) + aData.mPicX, + mData.mYStride); + } + + mSize = aData.mPicSize; mHasData = PR_TRUE; } void PlanarYCbCrImageOGL::AllocateTextures() { mManager->MakeCurrent();
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/LICENSE @@ -0,0 +1,27 @@ +// Copyright (c) 2010 The Chromium Authors. All rights reserved. +// +// Redistribution and use in source and binary forms, with or without +// modification, are permitted provided that the following conditions are +// met: +// +// * Redistributions of source code must retain the above copyright +// notice, this list of conditions and the following disclaimer. +// * Redistributions in binary form must reproduce the above +// copyright notice, this list of conditions and the following disclaimer +// in the documentation and/or other materials provided with the +// distribution. +// * Neither the name of Google Inc. nor the names of its +// contributors may be used to endorse or promote products derived from +// this software without specific prior written permission. +// +// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/Makefile.in @@ -0,0 +1,49 @@ +DEPTH = ../.. +topsrcdir = @top_srcdir@ +srcdir = @srcdir@ +VPATH = @srcdir@ + +include $(DEPTH)/config/autoconf.mk + +MODULE = ycbcr +LIBRARY_NAME = ycbcr +LIBXUL_LIBRARY = 1 +EXPORT_LIBRARY = 1 + +DEFINES += -D_IMPL_NS_GFX + +EXPORTS = chromium_types.h \ + yuv_convert.h \ + yuv_row.h \ + $(NULL) + +CPPSRCS = yuv_convert.cpp \ + yuv_row_c.cpp \ + $(NULL) + +ifeq ($(MOZ_WIDGET_TOOLKIT),windows) +CPPSRCS += yuv_row_win.cpp \ + $(NULL) +else +ifeq ($(MOZ_WIDGET_TOOLKIT),gtk2) +CPPSRCS += yuv_row_linux.cpp \ + $(NULL) +else +ifeq ($(MOZ_WIDGET_TOOLKIT),cocoa) +CPPSRCS += yuv_row_mac.cpp \ + $(NULL) +else +CPPSRCS += yuv_row_other.cpp \ + $(NULL) +endif +endif +endif + +EXTRA_DSO_LDOPTS += \ + $(LIBS_DIR) \ + $(EXTRA_DSO_LIBS) \ + $(XPCOM_LIBS) \ + $(NSPR_LIBS) \ + $(NULL) + +include $(topsrcdir)/config/rules.mk
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/README @@ -0,0 +1,19 @@ +This color conversion code is from the Chromium open source project available here: + +http://code.google.com/chromium/ + +The code comes from svn revision 40876. + +The code was copied from a Chromium svn checkout using the 'update.sh' script which then applies patches for our build and to add dynamic CPU detection. + +convert.patch: Change Chromium code to build using Mozilla build system. + Add runtime CPU detection for MMX + Move default C implementation to work on all platforms. + +picture_region.patch: Change Chromium code to allow a picture region. + The YUV conversion will convert within this + picture region only. + +remove_scale.patch: Removes Chromium scaling code. +export.patch: Fix export for building on comm-central +win64_mac64.patch: Fallback to C implementation on Windows and Mac OS X 64 bit
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/bustage.patch @@ -0,0 +1,26 @@ +diff --git a/gfx/ycbcr/yuv_row_linux.cpp b/gfx/ycbcr/yuv_row_linux.cpp +index ce5ee89..455dd7b 100644 +--- a/gfx/ycbcr/yuv_row_linux.cpp ++++ b/gfx/ycbcr/yuv_row_linux.cpp +@@ -18,7 +18,7 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { +- FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); ++ FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, 1); + } + + #else +diff --git a/gfx/ycbcr/yuv_row_mac.cpp b/gfx/ycbcr/yuv_row_mac.cpp +index 3515ada..351466c 100644 +--- a/gfx/ycbcr/yuv_row_mac.cpp ++++ b/gfx/ycbcr/yuv_row_mac.cpp +@@ -15,7 +15,7 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { +- FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); ++ FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, 1); + } + + #else
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/chromium_types.h @@ -0,0 +1,71 @@ +/* -*- Mode: C++; tab-width: 20; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * ***** 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 Mozilla Corporation code. + * + * The Initial Developer of the Original Code is Mozilla Foundation. + * Portions created by the Initial Developer are Copyright (C) 2009 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Chris Double <chris.double@double.co.nz> + * + * 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 GFX_CHROMIUMTYPES_H +#define GFX_CHROMIUMTYPES_H + +#include "prtypes.h" + +typedef PRUint8 uint8; +typedef PRInt8 int8; +typedef PRInt16 int16; + +// From Chromium build_config.h: +// Processor architecture detection. For more info on what's defined, see: +// http://msdn.microsoft.com/en-us/library/b0084kay.aspx +// http://www.agner.org/optimize/calling_conventions.pdf +// or with gcc, run: "echo | gcc -E -dM -" +#if defined(_M_X64) || defined(__x86_64__) +#define ARCH_CPU_X86_FAMILY 1 +#define ARCH_CPU_X86_64 1 +#define ARCH_CPU_64_BITS 1 +#elif defined(_M_IX86) || defined(__i386__) +#define ARCH_CPU_X86_FAMILY 1 +#define ARCH_CPU_X86 1 +#define ARCH_CPU_32_BITS 1 +#elif defined(__ARMEL__) +#define ARCH_CPU_ARM_FAMILY 1 +#define ARCH_CPU_ARMEL 1 +#define ARCH_CPU_32_BITS 1 +#elif defined(__ppc__) +#define ARCH_CPU_PPC_FAMILY 1 +#define ARCH_CPU_PPC 1 +#define ARCH_CPU_32_BITS 1 +#else +#error Please add support for your architecture in chromium_types.h +#endif + +#endif // GFX_CHROMIUMTYPES_H
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/convert.patch @@ -0,0 +1,1239 @@ +diff --git b/gfx/ycbcr/yuv_convert.cpp a/gfx/ycbcr/yuv_convert.cpp +index c73dfe4..c291d5c 100644 +--- b/gfx/ycbcr/yuv_convert.cpp ++++ a/gfx/ycbcr/yuv_convert.cpp +@@ -10,67 +10,80 @@ + // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf + // + // YV12 is a full plane of Y and a half height, half width chroma planes + // YV16 is a full plane of Y and a full height, half width chroma planes + // + // ARGB pixel format is output, which on little endian is stored as BGRA. + // The alpha is set to 255, allowing the application to use RGBA or RGB32. + +-#include "media/base/yuv_convert.h" ++#include "yuv_convert.h" + + // Header for low level row functions. +-#include "media/base/yuv_row.h" ++#include "yuv_row.h" ++#include "mozilla/SSE.h" + +-namespace media { ++namespace mozilla { ++ ++namespace gfx { + + // Convert a frame of YUV to 32 bit ARGB. +-void ConvertYUVToRGB32(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int height, +- int y_pitch, +- int uv_pitch, +- int rgb_pitch, +- YUVType yuv_type) { ++void ConvertYCbCrToRGB32(const uint8* y_buf, ++ const uint8* u_buf, ++ const uint8* v_buf, ++ uint8* rgb_buf, ++ int width, ++ int height, ++ int y_pitch, ++ int uv_pitch, ++ int rgb_pitch, ++ YUVType yuv_type) { + unsigned int y_shift = yuv_type; ++ bool has_mmx = supports_mmx(); + for (int y = 0; y < height; ++y) { + uint8* rgb_row = rgb_buf + y * rgb_pitch; + const uint8* y_ptr = y_buf + y * y_pitch; + const uint8* u_ptr = u_buf + (y >> y_shift) * uv_pitch; + const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch; + +- FastConvertYUVToRGB32Row(y_ptr, +- u_ptr, +- v_ptr, +- rgb_row, +- width); ++ if (has_mmx) ++ FastConvertYUVToRGB32Row(y_ptr, ++ u_ptr, ++ v_ptr, ++ rgb_row, ++ width); ++ else ++ FastConvertYUVToRGB32Row_C(y_ptr, ++ u_ptr, ++ v_ptr, ++ rgb_row, ++ width); + } + + // MMX used for FastConvertYUVToRGB32Row requires emms instruction. +- EMMS(); ++ if (has_mmx) ++ EMMS(); + } + + // Scale a frame of YUV to 32 bit ARGB. +-void ScaleYUVToRGB32(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int height, +- int scaled_width, +- int scaled_height, +- int y_pitch, +- int uv_pitch, +- int rgb_pitch, +- YUVType yuv_type, +- Rotate view_rotate) { ++void ScaleYCbCrToRGB32(const uint8* y_buf, ++ const uint8* u_buf, ++ const uint8* v_buf, ++ uint8* rgb_buf, ++ int width, ++ int height, ++ int scaled_width, ++ int scaled_height, ++ int y_pitch, ++ int uv_pitch, ++ int rgb_pitch, ++ YUVType yuv_type, ++ Rotate view_rotate) { + unsigned int y_shift = yuv_type; ++ bool has_mmx = supports_mmx(); + // Diagram showing origin and direction of source sampling. + // ->0 4<- + // 7 3 + // + // 6 5 + // ->1 2<- + // Rotations that start at right side of image. + if ((view_rotate == ROTATE_180) || +@@ -126,42 +139,57 @@ void ScaleYUVToRGB32(const uint8* y_buf, + + for (int y = 0; y < scaled_height; ++y) { + uint8* dest_pixel = rgb_buf + y * rgb_pitch; + int scaled_y = (y * height / scaled_height); + const uint8* y_ptr = y_buf + scaled_y * y_pitch; + const uint8* u_ptr = u_buf + (scaled_y >> y_shift) * uv_pitch; + const uint8* v_ptr = v_buf + (scaled_y >> y_shift) * uv_pitch; + +-#if USE_MMX && defined(_MSC_VER) ++#if defined(_MSC_VER) + if (scaled_width == (width * 2)) { + DoubleYUVToRGB32Row(y_ptr, u_ptr, v_ptr, + dest_pixel, scaled_width); + } else if ((scaled_dx & 15) == 0) { // Scaling by integer scale factor. + if (scaled_dx_uv == scaled_dx) { // Not rotated. + if (scaled_dx == 16) { // Not scaled +- FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); ++ if (has_mmx) ++ FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width); ++ else ++ FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width); + } else { // Simple scale down. ie half + ConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, + dest_pixel, scaled_width, scaled_dx >> 4); + } + } else { + RotateConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, + dest_pixel, scaled_width, + scaled_dx >> 4, scaled_dx_uv >> 4); + } + #else + if (scaled_dx == 16) { // Not scaled +- FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); ++ if (has_mmx) ++ FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width); ++ else ++ FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width); + #endif + } else { +- ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width, scaled_dx); +- } ++ if (has_mmx) ++ ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width, scaled_dx); ++ else ++ ScaleYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, ++ dest_pixel, scaled_width, scaled_dx); ++ ++ } + } + + // MMX used for FastConvertYUVToRGB32Row requires emms instruction. +- EMMS(); ++ if (has_mmx) ++ EMMS(); + } + +-} // namespace media ++} // namespace gfx ++} // namespace mozilla +diff --git b/gfx/ycbcr/yuv_convert.h a/gfx/ycbcr/yuv_convert.h +index a757070..9d148a6 100644 +--- b/gfx/ycbcr/yuv_convert.h ++++ a/gfx/ycbcr/yuv_convert.h +@@ -1,63 +1,66 @@ + // Copyright (c) 2009 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + + #ifndef MEDIA_BASE_YUV_CONVERT_H_ + #define MEDIA_BASE_YUV_CONVERT_H_ + +-#include "base/basictypes.h" ++#include "chromium_types.h" + +-namespace media { ++namespace mozilla { ++ ++namespace gfx { + + // Type of YUV surface. + // The value of these enums matter as they are used to shift vertical indices. + enum YUVType { + YV16 = 0, // YV16 is half width and full height chroma channels. +- YV12 = 1, // YV12 is half width and half height chroma channels. ++ YV12 = 1 // YV12 is half width and half height chroma channels. + }; + + // Mirror means flip the image horizontally, as in looking in a mirror. + // Rotate happens after mirroring. + enum Rotate { + ROTATE_0, // Rotation off. + ROTATE_90, // Rotate clockwise. + ROTATE_180, // Rotate upside down. + ROTATE_270, // Rotate counter clockwise. + MIRROR_ROTATE_0, // Mirror horizontally. + MIRROR_ROTATE_90, // Mirror then Rotate clockwise. + MIRROR_ROTATE_180, // Mirror vertically. +- MIRROR_ROTATE_270, // Transpose. ++ MIRROR_ROTATE_270 // Transpose. + }; + + // Convert a frame of YUV to 32 bit ARGB. + // Pass in YV16/YV12 depending on source format +-void ConvertYUVToRGB32(const uint8* yplane, ++void ConvertYCbCrToRGB32(const uint8* yplane, ++ const uint8* uplane, ++ const uint8* vplane, ++ uint8* rgbframe, ++ int frame_width, ++ int frame_height, ++ int ystride, ++ int uvstride, ++ int rgbstride, ++ YUVType yuv_type); ++ ++// Scale a frame of YUV to 32 bit ARGB. ++// Supports rotation and mirroring. ++void ScaleYCbCrToRGB32(const uint8* yplane, + const uint8* uplane, + const uint8* vplane, + uint8* rgbframe, + int frame_width, + int frame_height, ++ int scaled_width, ++ int scaled_height, + int ystride, + int uvstride, + int rgbstride, +- YUVType yuv_type); ++ YUVType yuv_type, ++ Rotate view_rotate); + +-// Scale a frame of YUV to 32 bit ARGB. +-// Supports rotation and mirroring. +-void ScaleYUVToRGB32(const uint8* yplane, +- const uint8* uplane, +- const uint8* vplane, +- uint8* rgbframe, +- int frame_width, +- int frame_height, +- int scaled_width, +- int scaled_height, +- int ystride, +- int uvstride, +- int rgbstride, +- YUVType yuv_type, +- Rotate view_rotate); +- +-} // namespace media ++} // namespace gfx ++} // namespace mozilla + + #endif // MEDIA_BASE_YUV_CONVERT_H_ +diff --git b/gfx/ycbcr/yuv_row.h a/gfx/ycbcr/yuv_row.h +index ac5c6fd..98efca6 100644 +--- b/gfx/ycbcr/yuv_row.h ++++ a/gfx/ycbcr/yuv_row.h +@@ -5,27 +5,34 @@ + // yuv_row internal functions to handle YUV conversion and scaling to RGB. + // These functions are used from both yuv_convert.cc and yuv_scale.cc. + + // TODO(fbarchard): Write function that can handle rotation and scaling. + + #ifndef MEDIA_BASE_YUV_ROW_H_ + #define MEDIA_BASE_YUV_ROW_H_ + +-#include "base/basictypes.h" ++#include "chromium_types.h" + + extern "C" { + // Can only do 1x. + // This is the second fastest of the scalers. + void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width); + ++void FastConvertYUVToRGB32Row_C(const uint8* y_buf, ++ const uint8* u_buf, ++ const uint8* v_buf, ++ uint8* rgb_buf, ++ int width); ++ ++ + // Can do 1x, half size or any scale down by an integer amount. + // Step can be negative (mirroring, rotate 180). + // This is the third fastest of the scalers. + void ConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width, +@@ -55,29 +62,28 @@ void DoubleYUVToRGB32Row(const uint8* y_buf, + // Chroma is under sampled every 2 pixels for performance. + // This is the slowest of the scalers. + void ScaleYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width, + int scaled_dx); +-} // extern "C" + +-#if !defined(USE_MMX) +-// Windows, Mac and Linux use MMX +-#if defined(ARCH_CPU_X86) || (defined(ARCH_CPU_X86_64) && defined(OS_LINUX)) +-#define USE_MMX 1 +-#else +-#define USE_MMX 0 +-#endif +-#endif ++void ScaleYUVToRGB32Row_C(const uint8* y_buf, ++ const uint8* u_buf, ++ const uint8* v_buf, ++ uint8* rgb_buf, ++ int width, ++ int scaled_dx); ++ ++} // extern "C" + + // x64 uses MMX2 (SSE) so emms is not required. +-#if USE_MMX && !defined(ARCH_CPU_X86_64) ++#if !defined(ARCH_CPU_X86_64) + #if defined(_MSC_VER) + #define EMMS() __asm emms + #else + #define EMMS() asm("emms") + #endif + #else + #define EMMS() + #endif +diff --git b/gfx/ycbcr/yuv_row_c.cpp a/gfx/ycbcr/yuv_row_c.cpp +index 4a20777..a81416c 100644 +--- b/gfx/ycbcr/yuv_row_c.cpp ++++ a/gfx/ycbcr/yuv_row_c.cpp +@@ -1,522 +1,20 @@ + // Copyright (c) 2009 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include "media/base/yuv_row.h" ++#include "yuv_row.h" + +-#ifdef _DEBUG +-#include "base/logging.h" +-#else + #define DCHECK(a) +-#endif + + // TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac. + // TODO(fbarchard): Do 64 bit version. + + extern "C" { +-#if USE_MMX +- +-#define RGBY(i) { \ +- static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ +- static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ +- static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ +- 0 \ +-} +- +-#define RGBU(i) { \ +- static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \ +- static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \ +- 0, \ +- static_cast<int16>(256 * 64 - 1) \ +-} +- +-#define RGBV(i) { \ +- 0, \ +- static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \ +- static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \ +- 0 \ +-} +- +-#define MMX_ALIGNED(var) var __attribute__((aligned(16))) +- +- +-MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = { +- RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03), +- RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07), +- RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B), +- RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F), +- RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13), +- RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17), +- RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B), +- RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F), +- RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23), +- RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27), +- RGBY(0x28), RGBY(0x29), RGBY(0x2A), RGBY(0x2B), +- RGBY(0x2C), RGBY(0x2D), RGBY(0x2E), RGBY(0x2F), +- RGBY(0x30), RGBY(0x31), RGBY(0x32), RGBY(0x33), +- RGBY(0x34), RGBY(0x35), RGBY(0x36), RGBY(0x37), +- RGBY(0x38), RGBY(0x39), RGBY(0x3A), RGBY(0x3B), +- RGBY(0x3C), RGBY(0x3D), RGBY(0x3E), RGBY(0x3F), +- RGBY(0x40), RGBY(0x41), RGBY(0x42), RGBY(0x43), +- RGBY(0x44), RGBY(0x45), RGBY(0x46), RGBY(0x47), +- RGBY(0x48), RGBY(0x49), RGBY(0x4A), RGBY(0x4B), +- RGBY(0x4C), RGBY(0x4D), RGBY(0x4E), RGBY(0x4F), +- RGBY(0x50), RGBY(0x51), RGBY(0x52), RGBY(0x53), +- RGBY(0x54), RGBY(0x55), RGBY(0x56), RGBY(0x57), +- RGBY(0x58), RGBY(0x59), RGBY(0x5A), RGBY(0x5B), +- RGBY(0x5C), RGBY(0x5D), RGBY(0x5E), RGBY(0x5F), +- RGBY(0x60), RGBY(0x61), RGBY(0x62), RGBY(0x63), +- RGBY(0x64), RGBY(0x65), RGBY(0x66), RGBY(0x67), +- RGBY(0x68), RGBY(0x69), RGBY(0x6A), RGBY(0x6B), +- RGBY(0x6C), RGBY(0x6D), RGBY(0x6E), RGBY(0x6F), +- RGBY(0x70), RGBY(0x71), RGBY(0x72), RGBY(0x73), +- RGBY(0x74), RGBY(0x75), RGBY(0x76), RGBY(0x77), +- RGBY(0x78), RGBY(0x79), RGBY(0x7A), RGBY(0x7B), +- RGBY(0x7C), RGBY(0x7D), RGBY(0x7E), RGBY(0x7F), +- RGBY(0x80), RGBY(0x81), RGBY(0x82), RGBY(0x83), +- RGBY(0x84), RGBY(0x85), RGBY(0x86), RGBY(0x87), +- RGBY(0x88), RGBY(0x89), RGBY(0x8A), RGBY(0x8B), +- RGBY(0x8C), RGBY(0x8D), RGBY(0x8E), RGBY(0x8F), +- RGBY(0x90), RGBY(0x91), RGBY(0x92), RGBY(0x93), +- RGBY(0x94), RGBY(0x95), RGBY(0x96), RGBY(0x97), +- RGBY(0x98), RGBY(0x99), RGBY(0x9A), RGBY(0x9B), +- RGBY(0x9C), RGBY(0x9D), RGBY(0x9E), RGBY(0x9F), +- RGBY(0xA0), RGBY(0xA1), RGBY(0xA2), RGBY(0xA3), +- RGBY(0xA4), RGBY(0xA5), RGBY(0xA6), RGBY(0xA7), +- RGBY(0xA8), RGBY(0xA9), RGBY(0xAA), RGBY(0xAB), +- RGBY(0xAC), RGBY(0xAD), RGBY(0xAE), RGBY(0xAF), +- RGBY(0xB0), RGBY(0xB1), RGBY(0xB2), RGBY(0xB3), +- RGBY(0xB4), RGBY(0xB5), RGBY(0xB6), RGBY(0xB7), +- RGBY(0xB8), RGBY(0xB9), RGBY(0xBA), RGBY(0xBB), +- RGBY(0xBC), RGBY(0xBD), RGBY(0xBE), RGBY(0xBF), +- RGBY(0xC0), RGBY(0xC1), RGBY(0xC2), RGBY(0xC3), +- RGBY(0xC4), RGBY(0xC5), RGBY(0xC6), RGBY(0xC7), +- RGBY(0xC8), RGBY(0xC9), RGBY(0xCA), RGBY(0xCB), +- RGBY(0xCC), RGBY(0xCD), RGBY(0xCE), RGBY(0xCF), +- RGBY(0xD0), RGBY(0xD1), RGBY(0xD2), RGBY(0xD3), +- RGBY(0xD4), RGBY(0xD5), RGBY(0xD6), RGBY(0xD7), +- RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB), +- RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF), +- RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3), +- RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7), +- RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB), +- RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF), +- RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3), +- RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7), +- RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB), +- RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF), +- +- // Chroma U table. +- RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03), +- RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07), +- RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B), +- RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F), +- RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13), +- RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17), +- RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B), +- RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F), +- RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23), +- RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27), +- RGBU(0x28), RGBU(0x29), RGBU(0x2A), RGBU(0x2B), +- RGBU(0x2C), RGBU(0x2D), RGBU(0x2E), RGBU(0x2F), +- RGBU(0x30), RGBU(0x31), RGBU(0x32), RGBU(0x33), +- RGBU(0x34), RGBU(0x35), RGBU(0x36), RGBU(0x37), +- RGBU(0x38), RGBU(0x39), RGBU(0x3A), RGBU(0x3B), +- RGBU(0x3C), RGBU(0x3D), RGBU(0x3E), RGBU(0x3F), +- RGBU(0x40), RGBU(0x41), RGBU(0x42), RGBU(0x43), +- RGBU(0x44), RGBU(0x45), RGBU(0x46), RGBU(0x47), +- RGBU(0x48), RGBU(0x49), RGBU(0x4A), RGBU(0x4B), +- RGBU(0x4C), RGBU(0x4D), RGBU(0x4E), RGBU(0x4F), +- RGBU(0x50), RGBU(0x51), RGBU(0x52), RGBU(0x53), +- RGBU(0x54), RGBU(0x55), RGBU(0x56), RGBU(0x57), +- RGBU(0x58), RGBU(0x59), RGBU(0x5A), RGBU(0x5B), +- RGBU(0x5C), RGBU(0x5D), RGBU(0x5E), RGBU(0x5F), +- RGBU(0x60), RGBU(0x61), RGBU(0x62), RGBU(0x63), +- RGBU(0x64), RGBU(0x65), RGBU(0x66), RGBU(0x67), +- RGBU(0x68), RGBU(0x69), RGBU(0x6A), RGBU(0x6B), +- RGBU(0x6C), RGBU(0x6D), RGBU(0x6E), RGBU(0x6F), +- RGBU(0x70), RGBU(0x71), RGBU(0x72), RGBU(0x73), +- RGBU(0x74), RGBU(0x75), RGBU(0x76), RGBU(0x77), +- RGBU(0x78), RGBU(0x79), RGBU(0x7A), RGBU(0x7B), +- RGBU(0x7C), RGBU(0x7D), RGBU(0x7E), RGBU(0x7F), +- RGBU(0x80), RGBU(0x81), RGBU(0x82), RGBU(0x83), +- RGBU(0x84), RGBU(0x85), RGBU(0x86), RGBU(0x87), +- RGBU(0x88), RGBU(0x89), RGBU(0x8A), RGBU(0x8B), +- RGBU(0x8C), RGBU(0x8D), RGBU(0x8E), RGBU(0x8F), +- RGBU(0x90), RGBU(0x91), RGBU(0x92), RGBU(0x93), +- RGBU(0x94), RGBU(0x95), RGBU(0x96), RGBU(0x97), +- RGBU(0x98), RGBU(0x99), RGBU(0x9A), RGBU(0x9B), +- RGBU(0x9C), RGBU(0x9D), RGBU(0x9E), RGBU(0x9F), +- RGBU(0xA0), RGBU(0xA1), RGBU(0xA2), RGBU(0xA3), +- RGBU(0xA4), RGBU(0xA5), RGBU(0xA6), RGBU(0xA7), +- RGBU(0xA8), RGBU(0xA9), RGBU(0xAA), RGBU(0xAB), +- RGBU(0xAC), RGBU(0xAD), RGBU(0xAE), RGBU(0xAF), +- RGBU(0xB0), RGBU(0xB1), RGBU(0xB2), RGBU(0xB3), +- RGBU(0xB4), RGBU(0xB5), RGBU(0xB6), RGBU(0xB7), +- RGBU(0xB8), RGBU(0xB9), RGBU(0xBA), RGBU(0xBB), +- RGBU(0xBC), RGBU(0xBD), RGBU(0xBE), RGBU(0xBF), +- RGBU(0xC0), RGBU(0xC1), RGBU(0xC2), RGBU(0xC3), +- RGBU(0xC4), RGBU(0xC5), RGBU(0xC6), RGBU(0xC7), +- RGBU(0xC8), RGBU(0xC9), RGBU(0xCA), RGBU(0xCB), +- RGBU(0xCC), RGBU(0xCD), RGBU(0xCE), RGBU(0xCF), +- RGBU(0xD0), RGBU(0xD1), RGBU(0xD2), RGBU(0xD3), +- RGBU(0xD4), RGBU(0xD5), RGBU(0xD6), RGBU(0xD7), +- RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB), +- RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF), +- RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3), +- RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7), +- RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB), +- RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF), +- RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3), +- RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7), +- RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB), +- RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF), +- +- // Chroma V table. +- RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03), +- RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07), +- RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B), +- RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F), +- RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13), +- RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17), +- RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B), +- RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F), +- RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23), +- RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27), +- RGBV(0x28), RGBV(0x29), RGBV(0x2A), RGBV(0x2B), +- RGBV(0x2C), RGBV(0x2D), RGBV(0x2E), RGBV(0x2F), +- RGBV(0x30), RGBV(0x31), RGBV(0x32), RGBV(0x33), +- RGBV(0x34), RGBV(0x35), RGBV(0x36), RGBV(0x37), +- RGBV(0x38), RGBV(0x39), RGBV(0x3A), RGBV(0x3B), +- RGBV(0x3C), RGBV(0x3D), RGBV(0x3E), RGBV(0x3F), +- RGBV(0x40), RGBV(0x41), RGBV(0x42), RGBV(0x43), +- RGBV(0x44), RGBV(0x45), RGBV(0x46), RGBV(0x47), +- RGBV(0x48), RGBV(0x49), RGBV(0x4A), RGBV(0x4B), +- RGBV(0x4C), RGBV(0x4D), RGBV(0x4E), RGBV(0x4F), +- RGBV(0x50), RGBV(0x51), RGBV(0x52), RGBV(0x53), +- RGBV(0x54), RGBV(0x55), RGBV(0x56), RGBV(0x57), +- RGBV(0x58), RGBV(0x59), RGBV(0x5A), RGBV(0x5B), +- RGBV(0x5C), RGBV(0x5D), RGBV(0x5E), RGBV(0x5F), +- RGBV(0x60), RGBV(0x61), RGBV(0x62), RGBV(0x63), +- RGBV(0x64), RGBV(0x65), RGBV(0x66), RGBV(0x67), +- RGBV(0x68), RGBV(0x69), RGBV(0x6A), RGBV(0x6B), +- RGBV(0x6C), RGBV(0x6D), RGBV(0x6E), RGBV(0x6F), +- RGBV(0x70), RGBV(0x71), RGBV(0x72), RGBV(0x73), +- RGBV(0x74), RGBV(0x75), RGBV(0x76), RGBV(0x77), +- RGBV(0x78), RGBV(0x79), RGBV(0x7A), RGBV(0x7B), +- RGBV(0x7C), RGBV(0x7D), RGBV(0x7E), RGBV(0x7F), +- RGBV(0x80), RGBV(0x81), RGBV(0x82), RGBV(0x83), +- RGBV(0x84), RGBV(0x85), RGBV(0x86), RGBV(0x87), +- RGBV(0x88), RGBV(0x89), RGBV(0x8A), RGBV(0x8B), +- RGBV(0x8C), RGBV(0x8D), RGBV(0x8E), RGBV(0x8F), +- RGBV(0x90), RGBV(0x91), RGBV(0x92), RGBV(0x93), +- RGBV(0x94), RGBV(0x95), RGBV(0x96), RGBV(0x97), +- RGBV(0x98), RGBV(0x99), RGBV(0x9A), RGBV(0x9B), +- RGBV(0x9C), RGBV(0x9D), RGBV(0x9E), RGBV(0x9F), +- RGBV(0xA0), RGBV(0xA1), RGBV(0xA2), RGBV(0xA3), +- RGBV(0xA4), RGBV(0xA5), RGBV(0xA6), RGBV(0xA7), +- RGBV(0xA8), RGBV(0xA9), RGBV(0xAA), RGBV(0xAB), +- RGBV(0xAC), RGBV(0xAD), RGBV(0xAE), RGBV(0xAF), +- RGBV(0xB0), RGBV(0xB1), RGBV(0xB2), RGBV(0xB3), +- RGBV(0xB4), RGBV(0xB5), RGBV(0xB6), RGBV(0xB7), +- RGBV(0xB8), RGBV(0xB9), RGBV(0xBA), RGBV(0xBB), +- RGBV(0xBC), RGBV(0xBD), RGBV(0xBE), RGBV(0xBF), +- RGBV(0xC0), RGBV(0xC1), RGBV(0xC2), RGBV(0xC3), +- RGBV(0xC4), RGBV(0xC5), RGBV(0xC6), RGBV(0xC7), +- RGBV(0xC8), RGBV(0xC9), RGBV(0xCA), RGBV(0xCB), +- RGBV(0xCC), RGBV(0xCD), RGBV(0xCE), RGBV(0xCF), +- RGBV(0xD0), RGBV(0xD1), RGBV(0xD2), RGBV(0xD3), +- RGBV(0xD4), RGBV(0xD5), RGBV(0xD6), RGBV(0xD7), +- RGBV(0xD8), RGBV(0xD9), RGBV(0xDA), RGBV(0xDB), +- RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF), +- RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3), +- RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7), +- RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB), +- RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF), +- RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3), +- RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7), +- RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB), +- RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF), +-}; +- +-#undef RGBY +-#undef RGBU +-#undef RGBV +-#undef MMX_ALIGNED +- +-#if defined(ARCH_CPU_X86_64) +- +-// AMD64 ABI uses register paremters. +-void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi +- const uint8* u_buf, // rsi +- const uint8* v_buf, // rdx +- uint8* rgb_buf, // rcx +- int width) { // r8 +- asm( +- "jmp convertend\n" +-"convertloop:" +- "movzb (%1),%%r10\n" +- "add $0x1,%1\n" +- "movzb (%2),%%r11\n" +- "add $0x1,%2\n" +- "movq 2048(%5,%%r10,8),%%xmm0\n" +- "movzb (%0),%%r10\n" +- "movq 4096(%5,%%r11,8),%%xmm1\n" +- "movzb 0x1(%0),%%r11\n" +- "paddsw %%xmm1,%%xmm0\n" +- "movq (%5,%%r10,8),%%xmm2\n" +- "add $0x2,%0\n" +- "movq (%5,%%r11,8),%%xmm3\n" +- "paddsw %%xmm0,%%xmm2\n" +- "paddsw %%xmm0,%%xmm3\n" +- "shufps $0x44,%%xmm3,%%xmm2\n" +- "psraw $0x6,%%xmm2\n" +- "packuswb %%xmm2,%%xmm2\n" +- "movq %%xmm2,0x0(%3)\n" +- "add $0x8,%3\n" +-"convertend:" +- "sub $0x2,%4\n" +- "jns convertloop\n" +- +-"convertnext:" +- "add $0x1,%4\n" +- "js convertdone\n" +- +- "movzb (%1),%%r10\n" +- "movq 2048(%5,%%r10,8),%%xmm0\n" +- "movzb (%2),%%r10\n" +- "movq 4096(%5,%%r10,8),%%xmm1\n" +- "paddsw %%xmm1,%%xmm0\n" +- "movzb (%0),%%r10\n" +- "movq (%5,%%r10,8),%%xmm1\n" +- "paddsw %%xmm0,%%xmm1\n" +- "psraw $0x6,%%xmm1\n" +- "packuswb %%xmm1,%%xmm1\n" +- "movd %%xmm1,0x0(%3)\n" +-"convertdone:" +- : +- : "r"(y_buf), // %0 +- "r"(u_buf), // %1 +- "r"(v_buf), // %2 +- "r"(rgb_buf), // %3 +- "r"(width), // %4 +- "r" (kCoefficientsRgbY) // %5 +- : "memory", "r10", "r11", "xmm0", "xmm1", "xmm2", "xmm3" +-); +-} +- +-void ScaleYUVToRGB32Row(const uint8* y_buf, // rdi +- const uint8* u_buf, // rsi +- const uint8* v_buf, // rdx +- uint8* rgb_buf, // rcx +- int width, // r8 +- int scaled_dx) { // r9 +- asm( +- "xor %%r11,%%r11\n" +- "sub $0x2,%4\n" +- "js scalenext\n" +- +-"scaleloop:" +- "mov %%r11,%%r10\n" +- "sar $0x5,%%r10\n" +- "movzb (%1,%%r10,1),%%rax\n" +- "movq 2048(%5,%%rax,8),%%xmm0\n" +- "movzb (%2,%%r10,1),%%rax\n" +- "movq 4096(%5,%%rax,8),%%xmm1\n" +- "lea (%%r11,%6),%%r10\n" +- "sar $0x4,%%r11\n" +- "movzb (%0,%%r11,1),%%rax\n" +- "paddsw %%xmm1,%%xmm0\n" +- "movq (%5,%%rax,8),%%xmm1\n" +- "lea (%%r10,%6),%%r11\n" +- "sar $0x4,%%r10\n" +- "movzb (%0,%%r10,1),%%rax\n" +- "movq (%5,%%rax,8),%%xmm2\n" +- "paddsw %%xmm0,%%xmm1\n" +- "paddsw %%xmm0,%%xmm2\n" +- "shufps $0x44,%%xmm2,%%xmm1\n" +- "psraw $0x6,%%xmm1\n" +- "packuswb %%xmm1,%%xmm1\n" +- "movq %%xmm1,0x0(%3)\n" +- "add $0x8,%3\n" +- "sub $0x2,%4\n" +- "jns scaleloop\n" +- +-"scalenext:" +- "add $0x1,%4\n" +- "js scaledone\n" +- +- "mov %%r11,%%r10\n" +- "sar $0x5,%%r10\n" +- "movzb (%1,%%r10,1),%%rax\n" +- "movq 2048(%5,%%rax,8),%%xmm0\n" +- "movzb (%2,%%r10,1),%%rax\n" +- "movq 4096(%5,%%rax,8),%%xmm1\n" +- "paddsw %%xmm1,%%xmm0\n" +- "sar $0x4,%%r11\n" +- "movzb (%0,%%r11,1),%%rax\n" +- "movq (%5,%%rax,8),%%xmm1\n" +- "paddsw %%xmm0,%%xmm1\n" +- "psraw $0x6,%%xmm1\n" +- "packuswb %%xmm1,%%xmm1\n" +- "movd %%xmm1,0x0(%3)\n" +- +-"scaledone:" +- : +- : "r"(y_buf), // %0 +- "r"(u_buf), // %1 +- "r"(v_buf), // %2 +- "r"(rgb_buf), // %3 +- "r"(width), // %4 +- "r" (kCoefficientsRgbY), // %5 +- "r"(static_cast<long>(scaled_dx)) // %6 +- : "memory", "r10", "r11", "rax", "xmm0", "xmm1", "xmm2" +-); +-} +- +-#else +- +-void FastConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width); +- +- asm( +- ".global FastConvertYUVToRGB32Row\n" +-"FastConvertYUVToRGB32Row:\n" +- "pusha\n" +- "mov 0x24(%esp),%edx\n" +- "mov 0x28(%esp),%edi\n" +- "mov 0x2c(%esp),%esi\n" +- "mov 0x30(%esp),%ebp\n" +- "mov 0x34(%esp),%ecx\n" +- "jmp convertend\n" +- +-"convertloop:" +- "movzbl (%edi),%eax\n" +- "add $0x1,%edi\n" +- "movzbl (%esi),%ebx\n" +- "add $0x1,%esi\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "movzbl (%edx),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%ebx,8),%mm0\n" +- "movzbl 0x1(%edx),%ebx\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "add $0x2,%edx\n" +- "movq kCoefficientsRgbY(,%ebx,8),%mm2\n" +- "paddsw %mm0,%mm1\n" +- "paddsw %mm0,%mm2\n" +- "psraw $0x6,%mm1\n" +- "psraw $0x6,%mm2\n" +- "packuswb %mm2,%mm1\n" +- "movntq %mm1,0x0(%ebp)\n" +- "add $0x8,%ebp\n" +-"convertend:" +- "sub $0x2,%ecx\n" +- "jns convertloop\n" +- +- "and $0x1,%ecx\n" +- "je convertdone\n" +- +- "movzbl (%edi),%eax\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "movzbl (%esi),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" +- "movzbl (%edx),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "paddsw %mm0,%mm1\n" +- "psraw $0x6,%mm1\n" +- "packuswb %mm1,%mm1\n" +- "movd %mm1,0x0(%ebp)\n" +-"convertdone:" +- "popa\n" +- "ret\n" +-); +- +- +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx); +- +- asm( +- ".global ScaleYUVToRGB32Row\n" +-"ScaleYUVToRGB32Row:\n" +- "pusha\n" +- "mov 0x24(%esp),%edx\n" +- "mov 0x28(%esp),%edi\n" +- "mov 0x2c(%esp),%esi\n" +- "mov 0x30(%esp),%ebp\n" +- "mov 0x34(%esp),%ecx\n" +- "xor %ebx,%ebx\n" +- "jmp scaleend\n" +- +-"scaleloop:" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm2\n" +- "paddsw %mm0,%mm1\n" +- "paddsw %mm0,%mm2\n" +- "psraw $0x6,%mm1\n" +- "psraw $0x6,%mm2\n" +- "packuswb %mm2,%mm1\n" +- "movntq %mm1,0x0(%ebp)\n" +- "add $0x8,%ebp\n" +-"scaleend:" +- "sub $0x2,%ecx\n" +- "jns scaleloop\n" +- +- "and $0x1,%ecx\n" +- "je scaledone\n" +- +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "paddsw %mm0,%mm1\n" +- "psraw $0x6,%mm1\n" +- "packuswb %mm1,%mm1\n" +- "movd %mm1,0x0(%ebp)\n" +- +-"scaledone:" +- "popa\n" +- "ret\n" +-); +- +-#endif +- +-#else // USE_MMX + + // Reference version of YUV converter. + static const int kClipTableSize = 256; + static const int kClipOverflow = 288; // Cb max is 535. + + static uint8 kRgbClipTable[kClipOverflow + + kClipTableSize + + kClipOverflow] = { +@@ -651,17 +149,17 @@ static inline void YuvPixel(uint8 y, + + int32 C298a = ((static_cast<int32>(y) - 16) * 298 + 128); + *reinterpret_cast<uint32*>(rgb_buf) = (clip(C298a + cb)) | + (clip(C298a + cg) << 8) | + (clip(C298a + cr) << 16) | + (0xff000000); + } + +-void FastConvertYUVToRGB32Row(const uint8* y_buf, ++void FastConvertYUVToRGB32Row_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width; x += 2) { + uint8 u = u_buf[x >> 1]; + uint8 v = v_buf[x >> 1]; + uint8 y0 = y_buf[x]; +@@ -673,27 +171,26 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + rgb_buf += 8; // Advance 2 pixels. + } + } + + // 28.4 fixed point is used. A shift by 4 isolates the integer. + // A shift by 5 is used to further subsample the chrominence channels. + // & 15 isolates the fixed point fraction. >> 2 to get the upper 2 bits, + // for 1/4 pixel accurate interpolation. +-void ScaleYUVToRGB32Row(const uint8* y_buf, ++void ScaleYUVToRGB32Row_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width, + int scaled_dx) { + int scaled_x = 0; + for (int x = 0; x < width; ++x) { + uint8 u = u_buf[scaled_x >> 5]; + uint8 v = v_buf[scaled_x >> 5]; + uint8 y0 = y_buf[scaled_x >> 4]; + YuvPixel(y0, u, v, rgb_buf); + rgb_buf += 4; + scaled_x += scaled_dx; + } + } +-#endif // USE_MMX + } // extern "C" + +diff --git b/gfx/ycbcr/yuv_row_linux.cpp a/gfx/ycbcr/yuv_row_linux.cpp +index 4a20777..eeb78f6 100644 +--- b/gfx/ycbcr/yuv_row_linux.cpp ++++ a/gfx/ycbcr/yuv_row_linux.cpp +@@ -1,25 +1,20 @@ + // Copyright (c) 2009 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include "media/base/yuv_row.h" ++#include "yuv_row.h" + +-#ifdef _DEBUG +-#include "base/logging.h" +-#else + #define DCHECK(a) +-#endif + + // TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac. + // TODO(fbarchard): Do 64 bit version. + + extern "C" { +-#if USE_MMX + + #define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + 0 \ + } + +@@ -234,21 +229,16 @@ MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = { + RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB), + RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF), + RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3), + RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7), + RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB), + RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF), + }; + +-#undef RGBY +-#undef RGBU +-#undef RGBV +-#undef MMX_ALIGNED +- + #if defined(ARCH_CPU_X86_64) + + // AMD64 ABI uses register paremters. + void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi + const uint8* u_buf, // rsi + const uint8* v_buf, // rdx + uint8* rgb_buf, // rcx + int width) { // r8 +@@ -376,17 +366,16 @@ void ScaleYUVToRGB32Row(const uint8* y_buf, // rdi + + #else + + void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width); +- + asm( + ".global FastConvertYUVToRGB32Row\n" + "FastConvertYUVToRGB32Row:\n" + "pusha\n" + "mov 0x24(%esp),%edx\n" + "mov 0x28(%esp),%edi\n" + "mov 0x2c(%esp),%esi\n" + "mov 0x30(%esp),%ebp\n" +@@ -505,195 +494,10 @@ void ScaleYUVToRGB32Row(const uint8* y_buf, + "movd %mm1,0x0(%ebp)\n" + + "scaledone:" + "popa\n" + "ret\n" + ); + + #endif +- +-#else // USE_MMX +- +-// Reference version of YUV converter. +-static const int kClipTableSize = 256; +-static const int kClipOverflow = 288; // Cb max is 535. +- +-static uint8 kRgbClipTable[kClipOverflow + +- kClipTableSize + +- kClipOverflow] = { +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 288 underflow values +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // clipped to 0. +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, +- 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // Unclipped values. +- 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, +- 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, +- 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, +- 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, +- 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, +- 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, +- 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, +- 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, +- 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, +- 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, +- 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, +- 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, +- 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, +- 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, +- 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, +- 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, +- 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, +- 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, +- 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, +- 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, +- 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, +- 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, +- 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, +- 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, +- 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, +- 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, +- 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, +- 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, +- 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, +- 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, +- 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 288 overflow values +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // clipped to 255. +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +- 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +-}; +- +-// Clip an rgb channel value to 0..255 range. +-// Source is signed fixed point 8.8. +-// Table allows for values to underflow or overflow by 128. +-// Therefore source range is -128 to 384. +-// Output clips to unsigned 0 to 255. +-static inline uint32 clip(int32 value) { +- DCHECK(((value >> 8) + kClipOverflow) >= 0); +- DCHECK(((value >> 8) + kClipOverflow) < +- (kClipOverflow + kClipTableSize + kClipOverflow)); +- return static_cast<uint32>(kRgbClipTable[((value) >> 8) + kClipOverflow]); +-} +- +-static inline void YuvPixel(uint8 y, +- uint8 u, +- uint8 v, +- uint8* rgb_buf) { +- int32 d = static_cast<int32>(u) - 128; +- int32 e = static_cast<int32>(v) - 128; +- +- int32 cb = (516 * d + 128); +- int32 cg = (- 100 * d - 208 * e + 128); +- int32 cr = (409 * e + 128); +- +- int32 C298a = ((static_cast<int32>(y) - 16) * 298 + 128); +- *reinterpret_cast<uint32*>(rgb_buf) = (clip(C298a + cb)) | +- (clip(C298a + cg) << 8) | +- (clip(C298a + cr) << 16) | +- (0xff000000); +-} +- +-void FastConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width) { +- for (int x = 0; x < width; x += 2) { +- uint8 u = u_buf[x >> 1]; +- uint8 v = v_buf[x >> 1]; +- uint8 y0 = y_buf[x]; +- YuvPixel(y0, u, v, rgb_buf); +- if ((x + 1) < width) { +- uint8 y1 = y_buf[x + 1]; +- YuvPixel(y1, u, v, rgb_buf + 4); +- } +- rgb_buf += 8; // Advance 2 pixels. +- } +-} +- +-// 28.4 fixed point is used. A shift by 4 isolates the integer. +-// A shift by 5 is used to further subsample the chrominence channels. +-// & 15 isolates the fixed point fraction. >> 2 to get the upper 2 bits, +-// for 1/4 pixel accurate interpolation. +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx) { +- int scaled_x = 0; +- for (int x = 0; x < width; ++x) { +- uint8 u = u_buf[scaled_x >> 5]; +- uint8 v = v_buf[scaled_x >> 5]; +- uint8 y0 = y_buf[scaled_x >> 4]; +- YuvPixel(y0, u, v, rgb_buf); +- rgb_buf += 4; +- scaled_x += scaled_dx; +- } +-} +-#endif // USE_MMX + } // extern "C" + +diff --git b/gfx/ycbcr/yuv_row_mac.cpp a/gfx/ycbcr/yuv_row_mac.cpp +index 39c252d..aa40aac 100644 +--- b/gfx/ycbcr/yuv_row_mac.cpp ++++ a/gfx/ycbcr/yuv_row_mac.cpp +@@ -1,13 +1,13 @@ + // Copyright (c) 2009 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include "media/base/yuv_row.h" ++#include "yuv_row.h" + + // TODO(fbarchard): Do 64 bit version. + + extern "C" { + + #define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ +diff --git b/gfx/ycbcr/yuv_row_win.cpp a/gfx/ycbcr/yuv_row_win.cpp +index 1e11d94..a77a16f 100644 +--- b/gfx/ycbcr/yuv_row_win.cpp ++++ a/gfx/ycbcr/yuv_row_win.cpp +@@ -1,13 +1,13 @@ + // Copyright (c) 2009 The Chromium Authors. All rights reserved. + // Use of this source code is governed by a BSD-style license that can be + // found in the LICENSE file. + +-#include "media/base/yuv_row.h" ++#include "yuv_row.h" + + extern "C" { + #define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + 0 \ + }
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/export.patch @@ -0,0 +1,43 @@ +diff --git a/gfx/ycbcr/yuv_convert.h b/gfx/ycbcr/yuv_convert.h +index 6735b77..e624168 100644 +--- a/gfx/ycbcr/yuv_convert.h ++++ b/gfx/ycbcr/yuv_convert.h +@@ -6,6 +6,7 @@ + #define MEDIA_BASE_YUV_CONVERT_H_ + + #include "chromium_types.h" ++#include "gfxCore.h" + + namespace mozilla { + +@@ -20,18 +21,18 @@ enum YUVType { + + // Convert a frame of YUV to 32 bit ARGB. + // Pass in YV16/YV12 depending on source format +-void ConvertYCbCrToRGB32(const uint8* yplane, +- const uint8* uplane, +- const uint8* vplane, +- uint8* rgbframe, +- int pic_x, +- int pic_y, +- int pic_width, +- int pic_height, +- int ystride, +- int uvstride, +- int rgbstride, +- YUVType yuv_type); ++NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* yplane, ++ const uint8* uplane, ++ const uint8* vplane, ++ uint8* rgbframe, ++ int pic_x, ++ int pic_y, ++ int pic_width, ++ int pic_height, ++ int ystride, ++ int uvstride, ++ int rgbstride, ++ YUVType yuv_type); + + } // namespace gfx + } // namespace mozilla
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/picture_region.patch @@ -0,0 +1,99 @@ +diff --git a/gfx/ycbcr/yuv_convert.cpp b/gfx/ycbcr/yuv_convert.cpp +index c291d5c..ff7267e 100644 +--- a/gfx/ycbcr/yuv_convert.cpp ++++ b/gfx/ycbcr/yuv_convert.cpp +@@ -25,42 +25,58 @@ namespace mozilla { + + namespace gfx { + + // Convert a frame of YUV to 32 bit ARGB. + void ConvertYCbCrToRGB32(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, +- int width, +- int height, ++ int pic_x, ++ int pic_y, ++ int pic_width, ++ int pic_height, + int y_pitch, + int uv_pitch, + int rgb_pitch, + YUVType yuv_type) { + unsigned int y_shift = yuv_type; + bool has_mmx = supports_mmx(); +- for (int y = 0; y < height; ++y) { +- uint8* rgb_row = rgb_buf + y * rgb_pitch; +- const uint8* y_ptr = y_buf + y * y_pitch; +- const uint8* u_ptr = u_buf + (y >> y_shift) * uv_pitch; +- const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch; ++ bool odd_pic_x = pic_x % 2 != 0; ++ int x_width = odd_pic_x ? pic_width - 1 : pic_width; ++ ++ for (int y = pic_y; y < pic_height + pic_y; ++y) { ++ uint8* rgb_row = rgb_buf + (y - pic_y) * rgb_pitch; ++ const uint8* y_ptr = y_buf + y * y_pitch + pic_x; ++ const uint8* u_ptr = u_buf + (y >> y_shift) * uv_pitch + (pic_x >> 1); ++ const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch + (pic_x >> 1); ++ ++ if (odd_pic_x) { ++ // Handle the single odd pixel manually and use the ++ // fast routines for the remaining. ++ FastConvertYUVToRGB32Row_C(y_ptr++, ++ u_ptr++, ++ v_ptr++, ++ rgb_row, ++ 1); ++ rgb_row += 4; ++ } + + if (has_mmx) + FastConvertYUVToRGB32Row(y_ptr, + u_ptr, + v_ptr, + rgb_row, +- width); ++ x_width); + else + FastConvertYUVToRGB32Row_C(y_ptr, + u_ptr, + v_ptr, + rgb_row, +- width); ++ x_width); + } + + // MMX used for FastConvertYUVToRGB32Row requires emms instruction. + if (has_mmx) + EMMS(); + } + + // Scale a frame of YUV to 32 bit ARGB. +diff --git a/gfx/ycbcr/yuv_convert.h b/gfx/ycbcr/yuv_convert.h +index 9d148a6..77ca8e6 100644 +--- a/gfx/ycbcr/yuv_convert.h ++++ b/gfx/ycbcr/yuv_convert.h +@@ -32,18 +32,20 @@ enum Rotate { + }; + + // Convert a frame of YUV to 32 bit ARGB. + // Pass in YV16/YV12 depending on source format + void ConvertYCbCrToRGB32(const uint8* yplane, + const uint8* uplane, + const uint8* vplane, + uint8* rgbframe, +- int frame_width, +- int frame_height, ++ int pic_x, ++ int pic_y, ++ int pic_width, ++ int pic_height, + int ystride, + int uvstride, + int rgbstride, + YUVType yuv_type); + + // Scale a frame of YUV to 32 bit ARGB. + // Supports rotation and mirroring. + void ScaleYCbCrToRGB32(const uint8* yplane,
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/remove_scale.patch @@ -0,0 +1,839 @@ +diff --git a/gfx/ycbcr/yuv_convert.cpp b/gfx/ycbcr/yuv_convert.cpp +index eec578d..de91f79 100644 +--- a/gfx/ycbcr/yuv_convert.cpp ++++ b/gfx/ycbcr/yuv_convert.cpp +@@ -81,133 +81,5 @@ void ConvertYCbCrToRGB32(const uint8* y_buf, + EMMS(); + } + +-// Scale a frame of YUV to 32 bit ARGB. +-void ScaleYCbCrToRGB32(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int height, +- int scaled_width, +- int scaled_height, +- int y_pitch, +- int uv_pitch, +- int rgb_pitch, +- YUVType yuv_type, +- Rotate view_rotate) { +- unsigned int y_shift = yuv_type; +- bool has_mmx = supports_mmx(); +- // Diagram showing origin and direction of source sampling. +- // ->0 4<- +- // 7 3 +- // +- // 6 5 +- // ->1 2<- +- // Rotations that start at right side of image. +- if ((view_rotate == ROTATE_180) || +- (view_rotate == ROTATE_270) || +- (view_rotate == MIRROR_ROTATE_0) || +- (view_rotate == MIRROR_ROTATE_90)) { +- y_buf += width - 1; +- u_buf += width / 2 - 1; +- v_buf += width / 2 - 1; +- width = -width; +- } +- // Rotations that start at bottom of image. +- if ((view_rotate == ROTATE_90) || +- (view_rotate == ROTATE_180) || +- (view_rotate == MIRROR_ROTATE_90) || +- (view_rotate == MIRROR_ROTATE_180)) { +- y_buf += (height - 1) * y_pitch; +- u_buf += ((height >> y_shift) - 1) * uv_pitch; +- v_buf += ((height >> y_shift) - 1) * uv_pitch; +- height = -height; +- } +- +- // Handle zero sized destination. +- if (scaled_width == 0 || scaled_height == 0) +- return; +- int scaled_dx = width * 16 / scaled_width; +- int scaled_dy = height * 16 / scaled_height; +- +- int scaled_dx_uv = scaled_dx; +- +- if ((view_rotate == ROTATE_90) || +- (view_rotate == ROTATE_270)) { +- int tmp = scaled_height; +- scaled_height = scaled_width; +- scaled_width = tmp; +- tmp = height; +- height = width; +- width = tmp; +- int original_dx = scaled_dx; +- int original_dy = scaled_dy; +- scaled_dx = ((original_dy >> 4) * y_pitch) << 4; +- scaled_dx_uv = ((original_dy >> 4) * uv_pitch) << 4; +- scaled_dy = original_dx; +- if (view_rotate == ROTATE_90) { +- y_pitch = -1; +- uv_pitch = -1; +- height = -height; +- } else { +- y_pitch = 1; +- uv_pitch = 1; +- } +- } +- +- for (int y = 0; y < scaled_height; ++y) { +- uint8* dest_pixel = rgb_buf + y * rgb_pitch; +- int scaled_y = (y * height / scaled_height); +- const uint8* y_ptr = y_buf + scaled_y * y_pitch; +- const uint8* u_ptr = u_buf + (scaled_y >> y_shift) * uv_pitch; +- const uint8* v_ptr = v_buf + (scaled_y >> y_shift) * uv_pitch; +- +-#if defined(_MSC_VER) +- if (scaled_width == (width * 2)) { +- DoubleYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); +- } else if ((scaled_dx & 15) == 0) { // Scaling by integer scale factor. +- if (scaled_dx_uv == scaled_dx) { // Not rotated. +- if (scaled_dx == 16) { // Not scaled +- if (has_mmx) +- FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); +- else +- FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); +- } else { // Simple scale down. ie half +- ConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width, scaled_dx >> 4); +- } +- } else { +- RotateConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width, +- scaled_dx >> 4, scaled_dx_uv >> 4); +- } +-#else +- if (scaled_dx == 16) { // Not scaled +- if (has_mmx) +- FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); +- else +- FastConvertYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width); +-#endif +- } else { +- if (has_mmx) +- ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width, scaled_dx); +- else +- ScaleYUVToRGB32Row_C(y_ptr, u_ptr, v_ptr, +- dest_pixel, scaled_width, scaled_dx); +- +- } +- } +- +- // MMX used for FastConvertYUVToRGB32Row requires emms instruction. +- if (has_mmx) +- EMMS(); +-} +- + } // namespace gfx + } // namespace mozilla +diff --git a/gfx/ycbcr/yuv_convert.h b/gfx/ycbcr/yuv_convert.h +index 7962af7..c9bf7e0 100644 +--- a/gfx/ycbcr/yuv_convert.h ++++ b/gfx/ycbcr/yuv_convert.h +@@ -18,19 +18,6 @@ enum YUVType { + YV12 = 1 // YV12 is half width and half height chroma channels. + }; + +-// Mirror means flip the image horizontally, as in looking in a mirror. +-// Rotate happens after mirroring. +-enum Rotate { +- ROTATE_0, // Rotation off. +- ROTATE_90, // Rotate clockwise. +- ROTATE_180, // Rotate upside down. +- ROTATE_270, // Rotate counter clockwise. +- MIRROR_ROTATE_0, // Mirror horizontally. +- MIRROR_ROTATE_90, // Mirror then Rotate clockwise. +- MIRROR_ROTATE_180, // Mirror vertically. +- MIRROR_ROTATE_270 // Transpose. +-}; +- + // Convert a frame of YUV to 32 bit ARGB. + // Pass in YV16/YV12 depending on source format + void ConvertYCbCrToRGB32(const uint8* yplane, +@@ -48,22 +35,6 @@ void ConvertYCbCrToRGB32(const uint8* yplane, + int rgbstride, + YUVType yuv_type); + +-// Scale a frame of YUV to 32 bit ARGB. +-// Supports rotation and mirroring. +-void ScaleYCbCrToRGB32(const uint8* yplane, +- const uint8* uplane, +- const uint8* vplane, +- uint8* rgbframe, +- int frame_width, +- int frame_height, +- int scaled_width, +- int scaled_height, +- int ystride, +- int uvstride, +- int rgbstride, +- YUVType yuv_type, +- Rotate view_rotate); +- + } // namespace gfx + } // namespace mozilla + +diff --git a/gfx/ycbcr/yuv_row.h b/gfx/ycbcr/yuv_row.h +index c43f713..2a82972 100644 +--- a/gfx/ycbcr/yuv_row.h ++++ b/gfx/ycbcr/yuv_row.h +@@ -28,53 +28,6 @@ void FastConvertYUVToRGB32Row_C(const uint8* y_buf, + int width); + + +-// Can do 1x, half size or any scale down by an integer amount. +-// Step can be negative (mirroring, rotate 180). +-// This is the third fastest of the scalers. +-void ConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int step); +- +-// Rotate is like Convert, but applies different step to Y versus U and V. +-// This allows rotation by 90 or 270, by stepping by stride. +-// This is the forth fastest of the scalers. +-void RotateConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int ystep, +- int uvstep); +- +-// Doubler does 4 pixels at a time. Each pixel is replicated. +-// This is the fastest of the scalers. +-void DoubleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width); +- +-// Handles arbitrary scaling up or down. +-// Mirroring is supported, but not 90 or 270 degree rotation. +-// Chroma is under sampled every 2 pixels for performance. +-// This is the slowest of the scalers. +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx); +- +-void ScaleYUVToRGB32Row_C(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx); +- + } // extern "C" + + // x64 uses MMX2 (SSE) so emms is not required. +diff --git a/gfx/ycbcr/yuv_row_c.cpp b/gfx/ycbcr/yuv_row_c.cpp +index a81416c..d3bdab4 100644 +--- a/gfx/ycbcr/yuv_row_c.cpp ++++ b/gfx/ycbcr/yuv_row_c.cpp +@@ -172,25 +172,5 @@ void FastConvertYUVToRGB32Row_C(const uint8* y_buf, + } + } + +-// 28.4 fixed point is used. A shift by 4 isolates the integer. +-// A shift by 5 is used to further subsample the chrominence channels. +-// & 15 isolates the fixed point fraction. >> 2 to get the upper 2 bits, +-// for 1/4 pixel accurate interpolation. +-void ScaleYUVToRGB32Row_C(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx) { +- int scaled_x = 0; +- for (int x = 0; x < width; ++x) { +- uint8 u = u_buf[scaled_x >> 5]; +- uint8 v = v_buf[scaled_x >> 5]; +- uint8 y0 = y_buf[scaled_x >> 4]; +- YuvPixel(y0, u, v, rgb_buf); +- rgb_buf += 4; +- scaled_x += scaled_dx; +- } +-} + } // extern "C" + +diff --git a/gfx/ycbcr/yuv_row_linux.cpp b/gfx/ycbcr/yuv_row_linux.cpp +index 5fb2bc4..ce5ee89 100644 +--- a/gfx/ycbcr/yuv_row_linux.cpp ++++ b/gfx/ycbcr/yuv_row_linux.cpp +@@ -21,14 +21,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); + } + +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx) { +- ScaleYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, scaled_dx); +-} + #else + + #define RGBY(i) { \ +@@ -315,75 +307,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi + ); + } + +-void ScaleYUVToRGB32Row(const uint8* y_buf, // rdi +- const uint8* u_buf, // rsi +- const uint8* v_buf, // rdx +- uint8* rgb_buf, // rcx +- int width, // r8 +- int scaled_dx) { // r9 +- asm( +- "xor %%r11,%%r11\n" +- "sub $0x2,%4\n" +- "js scalenext\n" +- +-"scaleloop:" +- "mov %%r11,%%r10\n" +- "sar $0x5,%%r10\n" +- "movzb (%1,%%r10,1),%%rax\n" +- "movq 2048(%5,%%rax,8),%%xmm0\n" +- "movzb (%2,%%r10,1),%%rax\n" +- "movq 4096(%5,%%rax,8),%%xmm1\n" +- "lea (%%r11,%6),%%r10\n" +- "sar $0x4,%%r11\n" +- "movzb (%0,%%r11,1),%%rax\n" +- "paddsw %%xmm1,%%xmm0\n" +- "movq (%5,%%rax,8),%%xmm1\n" +- "lea (%%r10,%6),%%r11\n" +- "sar $0x4,%%r10\n" +- "movzb (%0,%%r10,1),%%rax\n" +- "movq (%5,%%rax,8),%%xmm2\n" +- "paddsw %%xmm0,%%xmm1\n" +- "paddsw %%xmm0,%%xmm2\n" +- "shufps $0x44,%%xmm2,%%xmm1\n" +- "psraw $0x6,%%xmm1\n" +- "packuswb %%xmm1,%%xmm1\n" +- "movq %%xmm1,0x0(%3)\n" +- "add $0x8,%3\n" +- "sub $0x2,%4\n" +- "jns scaleloop\n" +- +-"scalenext:" +- "add $0x1,%4\n" +- "js scaledone\n" +- +- "mov %%r11,%%r10\n" +- "sar $0x5,%%r10\n" +- "movzb (%1,%%r10,1),%%rax\n" +- "movq 2048(%5,%%rax,8),%%xmm0\n" +- "movzb (%2,%%r10,1),%%rax\n" +- "movq 4096(%5,%%rax,8),%%xmm1\n" +- "paddsw %%xmm1,%%xmm0\n" +- "sar $0x4,%%r11\n" +- "movzb (%0,%%r11,1),%%rax\n" +- "movq (%5,%%rax,8),%%xmm1\n" +- "paddsw %%xmm0,%%xmm1\n" +- "psraw $0x6,%%xmm1\n" +- "packuswb %%xmm1,%%xmm1\n" +- "movd %%xmm1,0x0(%3)\n" +- +-"scaledone:" +- : +- : "r"(y_buf), // %0 +- "r"(u_buf), // %1 +- "r"(v_buf), // %2 +- "r"(rgb_buf), // %3 +- "r"(width), // %4 +- "r" (kCoefficientsRgbY), // %5 +- "r"(static_cast<long>(scaled_dx)) // %6 +- : "memory", "r10", "r11", "rax", "xmm0", "xmm1", "xmm2" +-); +-} +- + #else + + void FastConvertYUVToRGB32Row(const uint8* y_buf, +@@ -443,81 +366,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + "ret\n" + ); + +- +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx); +- +- asm( +- ".global ScaleYUVToRGB32Row\n" +-"ScaleYUVToRGB32Row:\n" +- "pusha\n" +- "mov 0x24(%esp),%edx\n" +- "mov 0x28(%esp),%edi\n" +- "mov 0x2c(%esp),%esi\n" +- "mov 0x30(%esp),%ebp\n" +- "mov 0x34(%esp),%ecx\n" +- "xor %ebx,%ebx\n" +- "jmp scaleend\n" +- +-"scaleloop:" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm2\n" +- "paddsw %mm0,%mm1\n" +- "paddsw %mm0,%mm2\n" +- "psraw $0x6,%mm1\n" +- "psraw $0x6,%mm2\n" +- "packuswb %mm2,%mm1\n" +- "movntq %mm1,0x0(%ebp)\n" +- "add $0x8,%ebp\n" +-"scaleend:" +- "sub $0x2,%ecx\n" +- "jns scaleloop\n" +- +- "and $0x1,%ecx\n" +- "je scaledone\n" +- +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq kCoefficientsRgbY(,%eax,8),%mm1\n" +- "paddsw %mm0,%mm1\n" +- "psraw $0x6,%mm1\n" +- "packuswb %mm1,%mm1\n" +- "movd %mm1,0x0(%ebp)\n" +- +-"scaledone:" +- "popa\n" +- "ret\n" +-); +- + #endif + #endif // ARCH_CPU_ARM_FAMILY + } // extern "C" +diff --git a/gfx/ycbcr/yuv_row_mac.cpp b/gfx/ycbcr/yuv_row_mac.cpp +index a7e8243..3515ada 100644 +--- a/gfx/ycbcr/yuv_row_mac.cpp ++++ b/gfx/ycbcr/yuv_row_mac.cpp +@@ -18,14 +18,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); + } + +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx) { +- ScaleYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, scaled_dx); +-} + #else + + #define RGBY(i) { \ +@@ -323,91 +315,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + &kCoefficientsRgbY[0][0]); + } + +-extern void MacScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx, +- int16 *kCoefficientsRgbY); +- +- __asm__( +-"_MacScaleYUVToRGB32Row:\n" +- "pusha\n" +- "mov 0x24(%esp),%edx\n" +- "mov 0x28(%esp),%edi\n" +- "mov 0x2c(%esp),%esi\n" +- "mov 0x30(%esp),%ebp\n" +- "mov 0x3c(%esp),%ecx\n" +- "xor %ebx,%ebx\n" +- "jmp Lscaleend\n" +- +-"Lscaleloop:" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq 2048(%ecx,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw 4096(%ecx,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq 0(%ecx,%eax,8),%mm1\n" +- "mov %ebx,%eax\n" +- "add 0x38(%esp),%ebx\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq 0(%ecx,%eax,8),%mm2\n" +- "paddsw %mm0,%mm1\n" +- "paddsw %mm0,%mm2\n" +- "psraw $0x6,%mm1\n" +- "psraw $0x6,%mm2\n" +- "packuswb %mm2,%mm1\n" +- "movntq %mm1,0x0(%ebp)\n" +- "add $0x8,%ebp\n" +-"Lscaleend:" +- "sub $0x2,0x34(%esp)\n" +- "jns Lscaleloop\n" +- +- "and $0x1,0x34(%esp)\n" +- "je Lscaledone\n" +- +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%edi,%eax,1),%eax\n" +- "movq 2048(%ecx,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x5,%eax\n" +- "movzbl (%esi,%eax,1),%eax\n" +- "paddsw 4096(%ecx,%eax,8),%mm0\n" +- "mov %ebx,%eax\n" +- "sar $0x4,%eax\n" +- "movzbl (%edx,%eax,1),%eax\n" +- "movq 0(%ecx,%eax,8),%mm1\n" +- "paddsw %mm0,%mm1\n" +- "psraw $0x6,%mm1\n" +- "packuswb %mm1,%mm1\n" +- "movd %mm1,0x0(%ebp)\n" +- +-"Lscaledone:" +- "popa\n" +- "ret\n" +-); +- +- +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int scaled_dx) { +- +- MacScaleYUVToRGB32Row(y_buf, u_buf, v_buf, rgb_buf, width, scaled_dx, +- &kCoefficientsRgbY[0][0]); +-} + #endif // ARCH_CPU_PPC + } // extern "C" + +diff --git a/gfx/ycbcr/yuv_row_win.cpp b/gfx/ycbcr/yuv_row_win.cpp +index a77a16f..f994931 100644 +--- a/gfx/ycbcr/yuv_row_win.cpp ++++ b/gfx/ycbcr/yuv_row_win.cpp +@@ -297,273 +297,5 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + } + } + +-__declspec(naked) +-void ConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int step) { +- __asm { +- pushad +- mov edx, [esp + 32 + 4] // Y +- mov edi, [esp + 32 + 8] // U +- mov esi, [esp + 32 + 12] // V +- mov ebp, [esp + 32 + 16] // rgb +- mov ecx, [esp + 32 + 20] // width +- mov ebx, [esp + 32 + 24] // step +- jmp wend +- +- wloop : +- movzx eax, byte ptr [edi] +- add edi, ebx +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [esi] +- add esi, ebx +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- movzx eax, byte ptr [edx] +- add edx, ebx +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- movzx eax, byte ptr [edx] +- add edx, ebx +- movq mm2, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- paddsw mm2, mm0 +- psraw mm1, 6 +- psraw mm2, 6 +- packuswb mm1, mm2 +- movntq [ebp], mm1 +- add ebp, 8 +- wend : +- sub ecx, 2 +- jns wloop +- +- and ecx, 1 // odd number of pixels? +- jz wdone +- +- movzx eax, byte ptr [edi] +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [esi] +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- movzx eax, byte ptr [edx] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- psraw mm1, 6 +- packuswb mm1, mm1 +- movd [ebp], mm1 +- wdone : +- +- popad +- ret +- } +-} +- +-__declspec(naked) +-void RotateConvertYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int ystep, +- int uvstep) { +- __asm { +- pushad +- mov edx, [esp + 32 + 4] // Y +- mov edi, [esp + 32 + 8] // U +- mov esi, [esp + 32 + 12] // V +- mov ebp, [esp + 32 + 16] // rgb +- mov ecx, [esp + 32 + 20] // width +- jmp wend +- +- wloop : +- movzx eax, byte ptr [edi] +- mov ebx, [esp + 32 + 28] // uvstep +- add edi, ebx +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [esi] +- add esi, ebx +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- movzx eax, byte ptr [edx] +- mov ebx, [esp + 32 + 24] // ystep +- add edx, ebx +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- movzx eax, byte ptr [edx] +- add edx, ebx +- movq mm2, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- paddsw mm2, mm0 +- psraw mm1, 6 +- psraw mm2, 6 +- packuswb mm1, mm2 +- movntq [ebp], mm1 +- add ebp, 8 +- wend : +- sub ecx, 2 +- jns wloop +- +- and ecx, 1 // odd number of pixels? +- jz wdone +- +- movzx eax, byte ptr [edi] +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [esi] +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- movzx eax, byte ptr [edx] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- psraw mm1, 6 +- packuswb mm1, mm1 +- movd [ebp], mm1 +- wdone : +- +- popad +- ret +- } +-} +- +-__declspec(naked) +-void DoubleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width) { +- __asm { +- pushad +- mov edx, [esp + 32 + 4] // Y +- mov edi, [esp + 32 + 8] // U +- mov esi, [esp + 32 + 12] // V +- mov ebp, [esp + 32 + 16] // rgb +- mov ecx, [esp + 32 + 20] // width +- jmp wend +- +- wloop : +- movzx eax, byte ptr [edi] +- add edi, 1 +- movzx ebx, byte ptr [esi] +- add esi, 1 +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [edx] +- paddsw mm0, [kCoefficientsRgbV + 8 * ebx] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- psraw mm1, 6 +- packuswb mm1, mm1 +- punpckldq mm1, mm1 +- movntq [ebp], mm1 +- +- movzx ebx, byte ptr [edx + 1] +- add edx, 2 +- paddsw mm0, [kCoefficientsRgbY + 8 * ebx] +- psraw mm0, 6 +- packuswb mm0, mm0 +- punpckldq mm0, mm0 +- movntq [ebp+8], mm0 +- add ebp, 16 +- wend : +- sub ecx, 4 +- jns wloop +- +- add ecx, 4 +- jz wdone +- +- movzx eax, byte ptr [edi] +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- movzx eax, byte ptr [esi] +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- movzx eax, byte ptr [edx] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- psraw mm1, 6 +- packuswb mm1, mm1 +- jmp wend1 +- +- wloop1 : +- movd [ebp], mm1 +- add ebp, 4 +- wend1 : +- sub ecx, 1 +- jns wloop1 +- wdone : +- popad +- ret +- } +-} +- +-// This version does general purpose scaling by any amount, up or down. +-// The only thing it can not do it rotation by 90 or 270. +-// For performance the chroma is under sampled, reducing cost of a 3x +-// 1080p scale from 8.4 ms to 5.4 ms. +-__declspec(naked) +-void ScaleYUVToRGB32Row(const uint8* y_buf, +- const uint8* u_buf, +- const uint8* v_buf, +- uint8* rgb_buf, +- int width, +- int dx) { +- __asm { +- pushad +- mov edx, [esp + 32 + 4] // Y +- mov edi, [esp + 32 + 8] // U +- mov esi, [esp + 32 + 12] // V +- mov ebp, [esp + 32 + 16] // rgb +- mov ecx, [esp + 32 + 20] // width +- xor ebx, ebx // x +- jmp scaleend +- +- scaleloop : +- mov eax, ebx +- sar eax, 5 +- movzx eax, byte ptr [edi + eax] +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- mov eax, ebx +- sar eax, 5 +- movzx eax, byte ptr [esi + eax] +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- mov eax, ebx +- add ebx, [esp + 32 + 24] // x += dx +- sar eax, 4 +- movzx eax, byte ptr [edx + eax] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- mov eax, ebx +- add ebx, [esp + 32 + 24] // x += dx +- sar eax, 4 +- movzx eax, byte ptr [edx + eax] +- movq mm2, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- paddsw mm2, mm0 +- psraw mm1, 6 +- psraw mm2, 6 +- packuswb mm1, mm2 +- movntq [ebp], mm1 +- add ebp, 8 +- scaleend : +- sub ecx, 2 +- jns scaleloop +- +- and ecx, 1 // odd number of pixels? +- jz scaledone +- +- mov eax, ebx +- sar eax, 5 +- movzx eax, byte ptr [edi + eax] +- movq mm0, [kCoefficientsRgbU + 8 * eax] +- mov eax, ebx +- sar eax, 5 +- movzx eax, byte ptr [esi + eax] +- paddsw mm0, [kCoefficientsRgbV + 8 * eax] +- mov eax, ebx +- sar eax, 4 +- movzx eax, byte ptr [edx + eax] +- movq mm1, [kCoefficientsRgbY + 8 * eax] +- paddsw mm1, mm0 +- psraw mm1, 6 +- packuswb mm1, mm1 +- movd [ebp], mm1 +- +- scaledone : +- popad +- ret +- } +-} + } // extern "C" +
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/update.sh @@ -0,0 +1,13 @@ +# update.sh <chromium-src-directory> +cp $1/media/base/yuv_convert.h . +cp $1/media/base/yuv_convert.cc yuv_convert.cpp +cp $1/media/base/yuv_row.h . +cp $1/media/base/yuv_row_linux.cc yuv_row_linux.cpp +cp $1/media/base/yuv_row_mac.cc yuv_row_mac.cpp +cp $1/media/base/yuv_row_win.cc yuv_row_win.cpp +cp $1/media/base/yuv_row_linux.cc yuv_row_c.cpp +patch -p3 <convert.patch +patch -p3 <picture_region.patch +patch -p3 <remove_scale.patch +patch -p3 <export.patch +patch -p3 <win64_mac64.patch
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/win64_mac64.patch @@ -0,0 +1,57 @@ +diff --git a/gfx/ycbcr/yuv_row_mac.cpp b/gfx/ycbcr/yuv_row_mac.cpp +index 351466c..2a679cc 100644 +--- a/gfx/ycbcr/yuv_row_mac.cpp ++++ b/gfx/ycbcr/yuv_row_mac.cpp +@@ -8,7 +8,10 @@ + + extern "C" { + +-#if defined(ARCH_CPU_PPC) ++// PPC and 64 Bit builds use the C fallback. Optimized code ++// needs to be fixed for 64 bit builds. PPC has no optimized code ++// option at all. ++#if defined(ARCH_CPU_PPC) || defined(ARCH_CPU_64_BITS) + // PPC implementation uses C fallback + void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, +@@ -315,6 +318,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + &kCoefficientsRgbY[0][0]); + } + +-#endif // ARCH_CPU_PPC ++#endif // ARCH_CPU_PPC || ARCH_CPU_64_BITS + } // extern "C" + +diff --git a/gfx/ycbcr/yuv_row_win.cpp b/gfx/ycbcr/yuv_row_win.cpp +index f994931..708ef14 100644 +--- a/gfx/ycbcr/yuv_row_win.cpp ++++ b/gfx/ycbcr/yuv_row_win.cpp +@@ -5,6 +5,21 @@ + #include "yuv_row.h" + + extern "C" { ++// 64 Bit builds use the C fallback. Optimized code ++// needs to be fixed for 64 bit builds. ++#if defined(ARCH_CPU_64_BITS) ++// PPC implementation uses C fallback ++void FastConvertYUVToRGB32Row(const uint8* y_buf, ++ const uint8* u_buf, ++ const uint8* v_buf, ++ uint8* rgb_buf, ++ int width) { ++ FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); ++} ++ ++#else ++ ++ + #define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ +@@ -297,5 +312,6 @@ void FastConvertYUVToRGB32Row(const uint8* y_buf, + } + } + ++#endif // ARCH_CPU_64_BITS + } // extern "C" +
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_convert.cpp @@ -0,0 +1,83 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// This webpage shows layout of YV12 and other YUV formats +// http://www.fourcc.org/yuv.php +// The actual conversion is best described here +// http://en.wikipedia.org/wiki/YUV +// An article on optimizing YUV conversion using tables instead of multiplies +// http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf +// +// YV12 is a full plane of Y and a half height, half width chroma planes +// YV16 is a full plane of Y and a full height, half width chroma planes +// +// ARGB pixel format is output, which on little endian is stored as BGRA. +// The alpha is set to 255, allowing the application to use RGBA or RGB32. + +#include "yuv_convert.h" + +// Header for low level row functions. +#include "yuv_row.h" +#include "mozilla/SSE.h" + +namespace mozilla { + +namespace gfx { + +// Convert a frame of YUV to 32 bit ARGB. +void ConvertYCbCrToRGB32(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int pic_x, + int pic_y, + int pic_width, + int pic_height, + int y_pitch, + int uv_pitch, + int rgb_pitch, + YUVType yuv_type) { + unsigned int y_shift = yuv_type; + bool has_mmx = supports_mmx(); + bool odd_pic_x = pic_x % 2 != 0; + int x_width = odd_pic_x ? pic_width - 1 : pic_width; + + for (int y = pic_y; y < pic_height + pic_y; ++y) { + uint8* rgb_row = rgb_buf + (y - pic_y) * rgb_pitch; + const uint8* y_ptr = y_buf + y * y_pitch + pic_x; + const uint8* u_ptr = u_buf + (y >> y_shift) * uv_pitch + (pic_x >> 1); + const uint8* v_ptr = v_buf + (y >> y_shift) * uv_pitch + (pic_x >> 1); + + if (odd_pic_x) { + // Handle the single odd pixel manually and use the + // fast routines for the remaining. + FastConvertYUVToRGB32Row_C(y_ptr++, + u_ptr++, + v_ptr++, + rgb_row, + 1); + rgb_row += 4; + } + + if (has_mmx) + FastConvertYUVToRGB32Row(y_ptr, + u_ptr, + v_ptr, + rgb_row, + x_width); + else + FastConvertYUVToRGB32Row_C(y_ptr, + u_ptr, + v_ptr, + rgb_row, + x_width); + } + + // MMX used for FastConvertYUVToRGB32Row requires emms instruction. + if (has_mmx) + EMMS(); +} + +} // namespace gfx +} // namespace mozilla
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_convert.h @@ -0,0 +1,40 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef MEDIA_BASE_YUV_CONVERT_H_ +#define MEDIA_BASE_YUV_CONVERT_H_ + +#include "chromium_types.h" +#include "gfxCore.h" + +namespace mozilla { + +namespace gfx { + +// Type of YUV surface. +// The value of these enums matter as they are used to shift vertical indices. +enum YUVType { + YV16 = 0, // YV16 is half width and full height chroma channels. + YV12 = 1 // YV12 is half width and half height chroma channels. +}; + +// Convert a frame of YUV to 32 bit ARGB. +// Pass in YV16/YV12 depending on source format +NS_GFX_(void) ConvertYCbCrToRGB32(const uint8* yplane, + const uint8* uplane, + const uint8* vplane, + uint8* rgbframe, + int pic_x, + int pic_y, + int pic_width, + int pic_height, + int ystride, + int uvstride, + int rgbstride, + YUVType yuv_type); + +} // namespace gfx +} // namespace mozilla + +#endif // MEDIA_BASE_YUV_CONVERT_H_
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row.h @@ -0,0 +1,44 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// yuv_row internal functions to handle YUV conversion and scaling to RGB. +// These functions are used from both yuv_convert.cc and yuv_scale.cc. + +// TODO(fbarchard): Write function that can handle rotation and scaling. + +#ifndef MEDIA_BASE_YUV_ROW_H_ +#define MEDIA_BASE_YUV_ROW_H_ + +#include "chromium_types.h" + +extern "C" { +// Can only do 1x. +// This is the second fastest of the scalers. +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width); + +void FastConvertYUVToRGB32Row_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width); + + +} // extern "C" + +// x64 uses MMX2 (SSE) so emms is not required. +#if !defined(ARCH_CPU_X86_64) && !defined(ARCH_CPU_PPC) +#if defined(_MSC_VER) +#define EMMS() __asm emms +#else +#define EMMS() asm("emms") +#endif +#else +#define EMMS() +#endif + +#endif // MEDIA_BASE_YUV_ROW_H_
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row_c.cpp @@ -0,0 +1,176 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "yuv_row.h" + +#define DCHECK(a) + +// TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac. +// TODO(fbarchard): Do 64 bit version. + +extern "C" { + +// Reference version of YUV converter. +static const int kClipTableSize = 256; +static const int kClipOverflow = 288; // Cb max is 535. + +static uint8 kRgbClipTable[kClipOverflow + + kClipTableSize + + kClipOverflow] = { + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // 288 underflow values + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, // clipped to 0. + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, // Unclipped values. + 0x08, 0x09, 0x0A, 0x0B, 0x0C, 0x0D, 0x0E, 0x0F, + 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, + 0x18, 0x19, 0x1A, 0x1B, 0x1C, 0x1D, 0x1E, 0x1F, + 0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, + 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, + 0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, + 0x38, 0x39, 0x3A, 0x3B, 0x3C, 0x3D, 0x3E, 0x3F, + 0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, + 0x48, 0x49, 0x4A, 0x4B, 0x4C, 0x4D, 0x4E, 0x4F, + 0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, + 0x58, 0x59, 0x5A, 0x5B, 0x5C, 0x5D, 0x5E, 0x5F, + 0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, + 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F, + 0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, + 0x78, 0x79, 0x7A, 0x7B, 0x7C, 0x7D, 0x7E, 0x7F, + 0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, + 0x88, 0x89, 0x8A, 0x8B, 0x8C, 0x8D, 0x8E, 0x8F, + 0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, + 0x98, 0x99, 0x9A, 0x9B, 0x9C, 0x9D, 0x9E, 0x9F, + 0xA0, 0xA1, 0xA2, 0xA3, 0xA4, 0xA5, 0xA6, 0xA7, + 0xA8, 0xA9, 0xAA, 0xAB, 0xAC, 0xAD, 0xAE, 0xAF, + 0xB0, 0xB1, 0xB2, 0xB3, 0xB4, 0xB5, 0xB6, 0xB7, + 0xB8, 0xB9, 0xBA, 0xBB, 0xBC, 0xBD, 0xBE, 0xBF, + 0xC0, 0xC1, 0xC2, 0xC3, 0xC4, 0xC5, 0xC6, 0xC7, + 0xC8, 0xC9, 0xCA, 0xCB, 0xCC, 0xCD, 0xCE, 0xCF, + 0xD0, 0xD1, 0xD2, 0xD3, 0xD4, 0xD5, 0xD6, 0xD7, + 0xD8, 0xD9, 0xDA, 0xDB, 0xDC, 0xDD, 0xDE, 0xDF, + 0xE0, 0xE1, 0xE2, 0xE3, 0xE4, 0xE5, 0xE6, 0xE7, + 0xE8, 0xE9, 0xEA, 0xEB, 0xEC, 0xED, 0xEE, 0xEF, + 0xF0, 0xF1, 0xF2, 0xF3, 0xF4, 0xF5, 0xF6, 0xF7, + 0xF8, 0xF9, 0xFA, 0xFB, 0xFC, 0xFD, 0xFE, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // 288 overflow values + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, // clipped to 255. + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, + 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, +}; + +// Clip an rgb channel value to 0..255 range. +// Source is signed fixed point 8.8. +// Table allows for values to underflow or overflow by 128. +// Therefore source range is -128 to 384. +// Output clips to unsigned 0 to 255. +static inline uint32 clip(int32 value) { + DCHECK(((value >> 8) + kClipOverflow) >= 0); + DCHECK(((value >> 8) + kClipOverflow) < + (kClipOverflow + kClipTableSize + kClipOverflow)); + return static_cast<uint32>(kRgbClipTable[((value) >> 8) + kClipOverflow]); +} + +static inline void YuvPixel(uint8 y, + uint8 u, + uint8 v, + uint8* rgb_buf) { + int32 d = static_cast<int32>(u) - 128; + int32 e = static_cast<int32>(v) - 128; + + int32 cb = (516 * d + 128); + int32 cg = (- 100 * d - 208 * e + 128); + int32 cr = (409 * e + 128); + + int32 C298a = ((static_cast<int32>(y) - 16) * 298 + 128); + *reinterpret_cast<uint32*>(rgb_buf) = (clip(C298a + cb)) | + (clip(C298a + cg) << 8) | + (clip(C298a + cr) << 16) | + (0xff000000); +} + +void FastConvertYUVToRGB32Row_C(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + for (int x = 0; x < width; x += 2) { + uint8 u = u_buf[x >> 1]; + uint8 v = v_buf[x >> 1]; + uint8 y0 = y_buf[x]; + YuvPixel(y0, u, v, rgb_buf); + if ((x + 1) < width) { + uint8 y1 = y_buf[x + 1]; + YuvPixel(y1, u, v, rgb_buf + 4); + } + rgb_buf += 8; // Advance 2 pixels. + } +} + +} // extern "C" +
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row_linux.cpp @@ -0,0 +1,372 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "yuv_row.h" + +#define DCHECK(a) + +// TODO(fbarchard): Move this to yuv_row_posix.cc to share with Mac. +// TODO(fbarchard): Do 64 bit version. + +extern "C" { + +#if defined(ARCH_CPU_ARM_FAMILY) +// ARM implementation uses C fallback +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); +} + +#else + +#define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + 0 \ +} + +#define RGBU(i) { \ + static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \ + 0, \ + static_cast<int16>(256 * 64 - 1) \ +} + +#define RGBV(i) { \ + 0, \ + static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \ + 0 \ +} + +#define MMX_ALIGNED(var) var __attribute__((aligned(16))) + + +MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = { + RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03), + RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07), + RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B), + RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F), + RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13), + RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17), + RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B), + RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F), + RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23), + RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27), + RGBY(0x28), RGBY(0x29), RGBY(0x2A), RGBY(0x2B), + RGBY(0x2C), RGBY(0x2D), RGBY(0x2E), RGBY(0x2F), + RGBY(0x30), RGBY(0x31), RGBY(0x32), RGBY(0x33), + RGBY(0x34), RGBY(0x35), RGBY(0x36), RGBY(0x37), + RGBY(0x38), RGBY(0x39), RGBY(0x3A), RGBY(0x3B), + RGBY(0x3C), RGBY(0x3D), RGBY(0x3E), RGBY(0x3F), + RGBY(0x40), RGBY(0x41), RGBY(0x42), RGBY(0x43), + RGBY(0x44), RGBY(0x45), RGBY(0x46), RGBY(0x47), + RGBY(0x48), RGBY(0x49), RGBY(0x4A), RGBY(0x4B), + RGBY(0x4C), RGBY(0x4D), RGBY(0x4E), RGBY(0x4F), + RGBY(0x50), RGBY(0x51), RGBY(0x52), RGBY(0x53), + RGBY(0x54), RGBY(0x55), RGBY(0x56), RGBY(0x57), + RGBY(0x58), RGBY(0x59), RGBY(0x5A), RGBY(0x5B), + RGBY(0x5C), RGBY(0x5D), RGBY(0x5E), RGBY(0x5F), + RGBY(0x60), RGBY(0x61), RGBY(0x62), RGBY(0x63), + RGBY(0x64), RGBY(0x65), RGBY(0x66), RGBY(0x67), + RGBY(0x68), RGBY(0x69), RGBY(0x6A), RGBY(0x6B), + RGBY(0x6C), RGBY(0x6D), RGBY(0x6E), RGBY(0x6F), + RGBY(0x70), RGBY(0x71), RGBY(0x72), RGBY(0x73), + RGBY(0x74), RGBY(0x75), RGBY(0x76), RGBY(0x77), + RGBY(0x78), RGBY(0x79), RGBY(0x7A), RGBY(0x7B), + RGBY(0x7C), RGBY(0x7D), RGBY(0x7E), RGBY(0x7F), + RGBY(0x80), RGBY(0x81), RGBY(0x82), RGBY(0x83), + RGBY(0x84), RGBY(0x85), RGBY(0x86), RGBY(0x87), + RGBY(0x88), RGBY(0x89), RGBY(0x8A), RGBY(0x8B), + RGBY(0x8C), RGBY(0x8D), RGBY(0x8E), RGBY(0x8F), + RGBY(0x90), RGBY(0x91), RGBY(0x92), RGBY(0x93), + RGBY(0x94), RGBY(0x95), RGBY(0x96), RGBY(0x97), + RGBY(0x98), RGBY(0x99), RGBY(0x9A), RGBY(0x9B), + RGBY(0x9C), RGBY(0x9D), RGBY(0x9E), RGBY(0x9F), + RGBY(0xA0), RGBY(0xA1), RGBY(0xA2), RGBY(0xA3), + RGBY(0xA4), RGBY(0xA5), RGBY(0xA6), RGBY(0xA7), + RGBY(0xA8), RGBY(0xA9), RGBY(0xAA), RGBY(0xAB), + RGBY(0xAC), RGBY(0xAD), RGBY(0xAE), RGBY(0xAF), + RGBY(0xB0), RGBY(0xB1), RGBY(0xB2), RGBY(0xB3), + RGBY(0xB4), RGBY(0xB5), RGBY(0xB6), RGBY(0xB7), + RGBY(0xB8), RGBY(0xB9), RGBY(0xBA), RGBY(0xBB), + RGBY(0xBC), RGBY(0xBD), RGBY(0xBE), RGBY(0xBF), + RGBY(0xC0), RGBY(0xC1), RGBY(0xC2), RGBY(0xC3), + RGBY(0xC4), RGBY(0xC5), RGBY(0xC6), RGBY(0xC7), + RGBY(0xC8), RGBY(0xC9), RGBY(0xCA), RGBY(0xCB), + RGBY(0xCC), RGBY(0xCD), RGBY(0xCE), RGBY(0xCF), + RGBY(0xD0), RGBY(0xD1), RGBY(0xD2), RGBY(0xD3), + RGBY(0xD4), RGBY(0xD5), RGBY(0xD6), RGBY(0xD7), + RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB), + RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF), + RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3), + RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7), + RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB), + RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF), + RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3), + RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7), + RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB), + RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF), + + // Chroma U table. + RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03), + RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07), + RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B), + RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F), + RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13), + RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17), + RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B), + RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F), + RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23), + RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27), + RGBU(0x28), RGBU(0x29), RGBU(0x2A), RGBU(0x2B), + RGBU(0x2C), RGBU(0x2D), RGBU(0x2E), RGBU(0x2F), + RGBU(0x30), RGBU(0x31), RGBU(0x32), RGBU(0x33), + RGBU(0x34), RGBU(0x35), RGBU(0x36), RGBU(0x37), + RGBU(0x38), RGBU(0x39), RGBU(0x3A), RGBU(0x3B), + RGBU(0x3C), RGBU(0x3D), RGBU(0x3E), RGBU(0x3F), + RGBU(0x40), RGBU(0x41), RGBU(0x42), RGBU(0x43), + RGBU(0x44), RGBU(0x45), RGBU(0x46), RGBU(0x47), + RGBU(0x48), RGBU(0x49), RGBU(0x4A), RGBU(0x4B), + RGBU(0x4C), RGBU(0x4D), RGBU(0x4E), RGBU(0x4F), + RGBU(0x50), RGBU(0x51), RGBU(0x52), RGBU(0x53), + RGBU(0x54), RGBU(0x55), RGBU(0x56), RGBU(0x57), + RGBU(0x58), RGBU(0x59), RGBU(0x5A), RGBU(0x5B), + RGBU(0x5C), RGBU(0x5D), RGBU(0x5E), RGBU(0x5F), + RGBU(0x60), RGBU(0x61), RGBU(0x62), RGBU(0x63), + RGBU(0x64), RGBU(0x65), RGBU(0x66), RGBU(0x67), + RGBU(0x68), RGBU(0x69), RGBU(0x6A), RGBU(0x6B), + RGBU(0x6C), RGBU(0x6D), RGBU(0x6E), RGBU(0x6F), + RGBU(0x70), RGBU(0x71), RGBU(0x72), RGBU(0x73), + RGBU(0x74), RGBU(0x75), RGBU(0x76), RGBU(0x77), + RGBU(0x78), RGBU(0x79), RGBU(0x7A), RGBU(0x7B), + RGBU(0x7C), RGBU(0x7D), RGBU(0x7E), RGBU(0x7F), + RGBU(0x80), RGBU(0x81), RGBU(0x82), RGBU(0x83), + RGBU(0x84), RGBU(0x85), RGBU(0x86), RGBU(0x87), + RGBU(0x88), RGBU(0x89), RGBU(0x8A), RGBU(0x8B), + RGBU(0x8C), RGBU(0x8D), RGBU(0x8E), RGBU(0x8F), + RGBU(0x90), RGBU(0x91), RGBU(0x92), RGBU(0x93), + RGBU(0x94), RGBU(0x95), RGBU(0x96), RGBU(0x97), + RGBU(0x98), RGBU(0x99), RGBU(0x9A), RGBU(0x9B), + RGBU(0x9C), RGBU(0x9D), RGBU(0x9E), RGBU(0x9F), + RGBU(0xA0), RGBU(0xA1), RGBU(0xA2), RGBU(0xA3), + RGBU(0xA4), RGBU(0xA5), RGBU(0xA6), RGBU(0xA7), + RGBU(0xA8), RGBU(0xA9), RGBU(0xAA), RGBU(0xAB), + RGBU(0xAC), RGBU(0xAD), RGBU(0xAE), RGBU(0xAF), + RGBU(0xB0), RGBU(0xB1), RGBU(0xB2), RGBU(0xB3), + RGBU(0xB4), RGBU(0xB5), RGBU(0xB6), RGBU(0xB7), + RGBU(0xB8), RGBU(0xB9), RGBU(0xBA), RGBU(0xBB), + RGBU(0xBC), RGBU(0xBD), RGBU(0xBE), RGBU(0xBF), + RGBU(0xC0), RGBU(0xC1), RGBU(0xC2), RGBU(0xC3), + RGBU(0xC4), RGBU(0xC5), RGBU(0xC6), RGBU(0xC7), + RGBU(0xC8), RGBU(0xC9), RGBU(0xCA), RGBU(0xCB), + RGBU(0xCC), RGBU(0xCD), RGBU(0xCE), RGBU(0xCF), + RGBU(0xD0), RGBU(0xD1), RGBU(0xD2), RGBU(0xD3), + RGBU(0xD4), RGBU(0xD5), RGBU(0xD6), RGBU(0xD7), + RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB), + RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF), + RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3), + RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7), + RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB), + RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF), + RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3), + RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7), + RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB), + RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF), + + // Chroma V table. + RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03), + RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07), + RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B), + RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F), + RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13), + RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17), + RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B), + RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F), + RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23), + RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27), + RGBV(0x28), RGBV(0x29), RGBV(0x2A), RGBV(0x2B), + RGBV(0x2C), RGBV(0x2D), RGBV(0x2E), RGBV(0x2F), + RGBV(0x30), RGBV(0x31), RGBV(0x32), RGBV(0x33), + RGBV(0x34), RGBV(0x35), RGBV(0x36), RGBV(0x37), + RGBV(0x38), RGBV(0x39), RGBV(0x3A), RGBV(0x3B), + RGBV(0x3C), RGBV(0x3D), RGBV(0x3E), RGBV(0x3F), + RGBV(0x40), RGBV(0x41), RGBV(0x42), RGBV(0x43), + RGBV(0x44), RGBV(0x45), RGBV(0x46), RGBV(0x47), + RGBV(0x48), RGBV(0x49), RGBV(0x4A), RGBV(0x4B), + RGBV(0x4C), RGBV(0x4D), RGBV(0x4E), RGBV(0x4F), + RGBV(0x50), RGBV(0x51), RGBV(0x52), RGBV(0x53), + RGBV(0x54), RGBV(0x55), RGBV(0x56), RGBV(0x57), + RGBV(0x58), RGBV(0x59), RGBV(0x5A), RGBV(0x5B), + RGBV(0x5C), RGBV(0x5D), RGBV(0x5E), RGBV(0x5F), + RGBV(0x60), RGBV(0x61), RGBV(0x62), RGBV(0x63), + RGBV(0x64), RGBV(0x65), RGBV(0x66), RGBV(0x67), + RGBV(0x68), RGBV(0x69), RGBV(0x6A), RGBV(0x6B), + RGBV(0x6C), RGBV(0x6D), RGBV(0x6E), RGBV(0x6F), + RGBV(0x70), RGBV(0x71), RGBV(0x72), RGBV(0x73), + RGBV(0x74), RGBV(0x75), RGBV(0x76), RGBV(0x77), + RGBV(0x78), RGBV(0x79), RGBV(0x7A), RGBV(0x7B), + RGBV(0x7C), RGBV(0x7D), RGBV(0x7E), RGBV(0x7F), + RGBV(0x80), RGBV(0x81), RGBV(0x82), RGBV(0x83), + RGBV(0x84), RGBV(0x85), RGBV(0x86), RGBV(0x87), + RGBV(0x88), RGBV(0x89), RGBV(0x8A), RGBV(0x8B), + RGBV(0x8C), RGBV(0x8D), RGBV(0x8E), RGBV(0x8F), + RGBV(0x90), RGBV(0x91), RGBV(0x92), RGBV(0x93), + RGBV(0x94), RGBV(0x95), RGBV(0x96), RGBV(0x97), + RGBV(0x98), RGBV(0x99), RGBV(0x9A), RGBV(0x9B), + RGBV(0x9C), RGBV(0x9D), RGBV(0x9E), RGBV(0x9F), + RGBV(0xA0), RGBV(0xA1), RGBV(0xA2), RGBV(0xA3), + RGBV(0xA4), RGBV(0xA5), RGBV(0xA6), RGBV(0xA7), + RGBV(0xA8), RGBV(0xA9), RGBV(0xAA), RGBV(0xAB), + RGBV(0xAC), RGBV(0xAD), RGBV(0xAE), RGBV(0xAF), + RGBV(0xB0), RGBV(0xB1), RGBV(0xB2), RGBV(0xB3), + RGBV(0xB4), RGBV(0xB5), RGBV(0xB6), RGBV(0xB7), + RGBV(0xB8), RGBV(0xB9), RGBV(0xBA), RGBV(0xBB), + RGBV(0xBC), RGBV(0xBD), RGBV(0xBE), RGBV(0xBF), + RGBV(0xC0), RGBV(0xC1), RGBV(0xC2), RGBV(0xC3), + RGBV(0xC4), RGBV(0xC5), RGBV(0xC6), RGBV(0xC7), + RGBV(0xC8), RGBV(0xC9), RGBV(0xCA), RGBV(0xCB), + RGBV(0xCC), RGBV(0xCD), RGBV(0xCE), RGBV(0xCF), + RGBV(0xD0), RGBV(0xD1), RGBV(0xD2), RGBV(0xD3), + RGBV(0xD4), RGBV(0xD5), RGBV(0xD6), RGBV(0xD7), + RGBV(0xD8), RGBV(0xD9), RGBV(0xDA), RGBV(0xDB), + RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF), + RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3), + RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7), + RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB), + RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF), + RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3), + RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7), + RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB), + RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF), +}; + +#if defined(ARCH_CPU_X86_64) + +// AMD64 ABI uses register paremters. +void FastConvertYUVToRGB32Row(const uint8* y_buf, // rdi + const uint8* u_buf, // rsi + const uint8* v_buf, // rdx + uint8* rgb_buf, // rcx + int width) { // r8 + asm( + "jmp convertend\n" +"convertloop:" + "movzb (%1),%%r10\n" + "add $0x1,%1\n" + "movzb (%2),%%r11\n" + "add $0x1,%2\n" + "movq 2048(%5,%%r10,8),%%xmm0\n" + "movzb (%0),%%r10\n" + "movq 4096(%5,%%r11,8),%%xmm1\n" + "movzb 0x1(%0),%%r11\n" + "paddsw %%xmm1,%%xmm0\n" + "movq (%5,%%r10,8),%%xmm2\n" + "add $0x2,%0\n" + "movq (%5,%%r11,8),%%xmm3\n" + "paddsw %%xmm0,%%xmm2\n" + "paddsw %%xmm0,%%xmm3\n" + "shufps $0x44,%%xmm3,%%xmm2\n" + "psraw $0x6,%%xmm2\n" + "packuswb %%xmm2,%%xmm2\n" + "movq %%xmm2,0x0(%3)\n" + "add $0x8,%3\n" +"convertend:" + "sub $0x2,%4\n" + "jns convertloop\n" + +"convertnext:" + "add $0x1,%4\n" + "js convertdone\n" + + "movzb (%1),%%r10\n" + "movq 2048(%5,%%r10,8),%%xmm0\n" + "movzb (%2),%%r10\n" + "movq 4096(%5,%%r10,8),%%xmm1\n" + "paddsw %%xmm1,%%xmm0\n" + "movzb (%0),%%r10\n" + "movq (%5,%%r10,8),%%xmm1\n" + "paddsw %%xmm0,%%xmm1\n" + "psraw $0x6,%%xmm1\n" + "packuswb %%xmm1,%%xmm1\n" + "movd %%xmm1,0x0(%3)\n" +"convertdone:" + : + : "r"(y_buf), // %0 + "r"(u_buf), // %1 + "r"(v_buf), // %2 + "r"(rgb_buf), // %3 + "r"(width), // %4 + "r" (kCoefficientsRgbY) // %5 + : "memory", "r10", "r11", "xmm0", "xmm1", "xmm2", "xmm3" +); +} + +#else + +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width); + asm( + ".global FastConvertYUVToRGB32Row\n" +"FastConvertYUVToRGB32Row:\n" + "pusha\n" + "mov 0x24(%esp),%edx\n" + "mov 0x28(%esp),%edi\n" + "mov 0x2c(%esp),%esi\n" + "mov 0x30(%esp),%ebp\n" + "mov 0x34(%esp),%ecx\n" + "jmp convertend\n" + +"convertloop:" + "movzbl (%edi),%eax\n" + "add $0x1,%edi\n" + "movzbl (%esi),%ebx\n" + "add $0x1,%esi\n" + "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" + "movzbl (%edx),%eax\n" + "paddsw kCoefficientsRgbY+4096(,%ebx,8),%mm0\n" + "movzbl 0x1(%edx),%ebx\n" + "movq kCoefficientsRgbY(,%eax,8),%mm1\n" + "add $0x2,%edx\n" + "movq kCoefficientsRgbY(,%ebx,8),%mm2\n" + "paddsw %mm0,%mm1\n" + "paddsw %mm0,%mm2\n" + "psraw $0x6,%mm1\n" + "psraw $0x6,%mm2\n" + "packuswb %mm2,%mm1\n" + "movntq %mm1,0x0(%ebp)\n" + "add $0x8,%ebp\n" +"convertend:" + "sub $0x2,%ecx\n" + "jns convertloop\n" + + "and $0x1,%ecx\n" + "je convertdone\n" + + "movzbl (%edi),%eax\n" + "movq kCoefficientsRgbY+2048(,%eax,8),%mm0\n" + "movzbl (%esi),%eax\n" + "paddsw kCoefficientsRgbY+4096(,%eax,8),%mm0\n" + "movzbl (%edx),%eax\n" + "movq kCoefficientsRgbY(,%eax,8),%mm1\n" + "paddsw %mm0,%mm1\n" + "psraw $0x6,%mm1\n" + "packuswb %mm1,%mm1\n" + "movd %mm1,0x0(%ebp)\n" +"convertdone:" + "popa\n" + "ret\n" +); + +#endif +#endif // ARCH_CPU_ARM_FAMILY +} // extern "C" +
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row_mac.cpp @@ -0,0 +1,323 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "yuv_row.h" + +// TODO(fbarchard): Do 64 bit version. + +extern "C" { + +// PPC and 64 Bit builds use the C fallback. Optimized code +// needs to be fixed for 64 bit builds. PPC has no optimized code +// option at all. +#if defined(ARCH_CPU_PPC) || defined(ARCH_CPU_64_BITS) +// PPC implementation uses C fallback +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); +} + +#else + +#define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + 0 \ +} + +#define RGBU(i) { \ + static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \ + 0, \ + static_cast<int16>(256 * 64 - 1) \ +} + +#define RGBV(i) { \ + 0, \ + static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \ + 0 \ +} + +#define MMX_ALIGNED(var) \ + var __attribute__ ((section ("__TEXT,__text"))) __attribute__ ((aligned(16))) + +MMX_ALIGNED(int16 kCoefficientsRgbY[768][4]) = { + RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03), + RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07), + RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B), + RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F), + RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13), + RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17), + RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B), + RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F), + RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23), + RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27), + RGBY(0x28), RGBY(0x29), RGBY(0x2A), RGBY(0x2B), + RGBY(0x2C), RGBY(0x2D), RGBY(0x2E), RGBY(0x2F), + RGBY(0x30), RGBY(0x31), RGBY(0x32), RGBY(0x33), + RGBY(0x34), RGBY(0x35), RGBY(0x36), RGBY(0x37), + RGBY(0x38), RGBY(0x39), RGBY(0x3A), RGBY(0x3B), + RGBY(0x3C), RGBY(0x3D), RGBY(0x3E), RGBY(0x3F), + RGBY(0x40), RGBY(0x41), RGBY(0x42), RGBY(0x43), + RGBY(0x44), RGBY(0x45), RGBY(0x46), RGBY(0x47), + RGBY(0x48), RGBY(0x49), RGBY(0x4A), RGBY(0x4B), + RGBY(0x4C), RGBY(0x4D), RGBY(0x4E), RGBY(0x4F), + RGBY(0x50), RGBY(0x51), RGBY(0x52), RGBY(0x53), + RGBY(0x54), RGBY(0x55), RGBY(0x56), RGBY(0x57), + RGBY(0x58), RGBY(0x59), RGBY(0x5A), RGBY(0x5B), + RGBY(0x5C), RGBY(0x5D), RGBY(0x5E), RGBY(0x5F), + RGBY(0x60), RGBY(0x61), RGBY(0x62), RGBY(0x63), + RGBY(0x64), RGBY(0x65), RGBY(0x66), RGBY(0x67), + RGBY(0x68), RGBY(0x69), RGBY(0x6A), RGBY(0x6B), + RGBY(0x6C), RGBY(0x6D), RGBY(0x6E), RGBY(0x6F), + RGBY(0x70), RGBY(0x71), RGBY(0x72), RGBY(0x73), + RGBY(0x74), RGBY(0x75), RGBY(0x76), RGBY(0x77), + RGBY(0x78), RGBY(0x79), RGBY(0x7A), RGBY(0x7B), + RGBY(0x7C), RGBY(0x7D), RGBY(0x7E), RGBY(0x7F), + RGBY(0x80), RGBY(0x81), RGBY(0x82), RGBY(0x83), + RGBY(0x84), RGBY(0x85), RGBY(0x86), RGBY(0x87), + RGBY(0x88), RGBY(0x89), RGBY(0x8A), RGBY(0x8B), + RGBY(0x8C), RGBY(0x8D), RGBY(0x8E), RGBY(0x8F), + RGBY(0x90), RGBY(0x91), RGBY(0x92), RGBY(0x93), + RGBY(0x94), RGBY(0x95), RGBY(0x96), RGBY(0x97), + RGBY(0x98), RGBY(0x99), RGBY(0x9A), RGBY(0x9B), + RGBY(0x9C), RGBY(0x9D), RGBY(0x9E), RGBY(0x9F), + RGBY(0xA0), RGBY(0xA1), RGBY(0xA2), RGBY(0xA3), + RGBY(0xA4), RGBY(0xA5), RGBY(0xA6), RGBY(0xA7), + RGBY(0xA8), RGBY(0xA9), RGBY(0xAA), RGBY(0xAB), + RGBY(0xAC), RGBY(0xAD), RGBY(0xAE), RGBY(0xAF), + RGBY(0xB0), RGBY(0xB1), RGBY(0xB2), RGBY(0xB3), + RGBY(0xB4), RGBY(0xB5), RGBY(0xB6), RGBY(0xB7), + RGBY(0xB8), RGBY(0xB9), RGBY(0xBA), RGBY(0xBB), + RGBY(0xBC), RGBY(0xBD), RGBY(0xBE), RGBY(0xBF), + RGBY(0xC0), RGBY(0xC1), RGBY(0xC2), RGBY(0xC3), + RGBY(0xC4), RGBY(0xC5), RGBY(0xC6), RGBY(0xC7), + RGBY(0xC8), RGBY(0xC9), RGBY(0xCA), RGBY(0xCB), + RGBY(0xCC), RGBY(0xCD), RGBY(0xCE), RGBY(0xCF), + RGBY(0xD0), RGBY(0xD1), RGBY(0xD2), RGBY(0xD3), + RGBY(0xD4), RGBY(0xD5), RGBY(0xD6), RGBY(0xD7), + RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB), + RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF), + RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3), + RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7), + RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB), + RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF), + RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3), + RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7), + RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB), + RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF), + + // Chroma U table. + RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03), + RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07), + RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B), + RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F), + RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13), + RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17), + RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B), + RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F), + RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23), + RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27), + RGBU(0x28), RGBU(0x29), RGBU(0x2A), RGBU(0x2B), + RGBU(0x2C), RGBU(0x2D), RGBU(0x2E), RGBU(0x2F), + RGBU(0x30), RGBU(0x31), RGBU(0x32), RGBU(0x33), + RGBU(0x34), RGBU(0x35), RGBU(0x36), RGBU(0x37), + RGBU(0x38), RGBU(0x39), RGBU(0x3A), RGBU(0x3B), + RGBU(0x3C), RGBU(0x3D), RGBU(0x3E), RGBU(0x3F), + RGBU(0x40), RGBU(0x41), RGBU(0x42), RGBU(0x43), + RGBU(0x44), RGBU(0x45), RGBU(0x46), RGBU(0x47), + RGBU(0x48), RGBU(0x49), RGBU(0x4A), RGBU(0x4B), + RGBU(0x4C), RGBU(0x4D), RGBU(0x4E), RGBU(0x4F), + RGBU(0x50), RGBU(0x51), RGBU(0x52), RGBU(0x53), + RGBU(0x54), RGBU(0x55), RGBU(0x56), RGBU(0x57), + RGBU(0x58), RGBU(0x59), RGBU(0x5A), RGBU(0x5B), + RGBU(0x5C), RGBU(0x5D), RGBU(0x5E), RGBU(0x5F), + RGBU(0x60), RGBU(0x61), RGBU(0x62), RGBU(0x63), + RGBU(0x64), RGBU(0x65), RGBU(0x66), RGBU(0x67), + RGBU(0x68), RGBU(0x69), RGBU(0x6A), RGBU(0x6B), + RGBU(0x6C), RGBU(0x6D), RGBU(0x6E), RGBU(0x6F), + RGBU(0x70), RGBU(0x71), RGBU(0x72), RGBU(0x73), + RGBU(0x74), RGBU(0x75), RGBU(0x76), RGBU(0x77), + RGBU(0x78), RGBU(0x79), RGBU(0x7A), RGBU(0x7B), + RGBU(0x7C), RGBU(0x7D), RGBU(0x7E), RGBU(0x7F), + RGBU(0x80), RGBU(0x81), RGBU(0x82), RGBU(0x83), + RGBU(0x84), RGBU(0x85), RGBU(0x86), RGBU(0x87), + RGBU(0x88), RGBU(0x89), RGBU(0x8A), RGBU(0x8B), + RGBU(0x8C), RGBU(0x8D), RGBU(0x8E), RGBU(0x8F), + RGBU(0x90), RGBU(0x91), RGBU(0x92), RGBU(0x93), + RGBU(0x94), RGBU(0x95), RGBU(0x96), RGBU(0x97), + RGBU(0x98), RGBU(0x99), RGBU(0x9A), RGBU(0x9B), + RGBU(0x9C), RGBU(0x9D), RGBU(0x9E), RGBU(0x9F), + RGBU(0xA0), RGBU(0xA1), RGBU(0xA2), RGBU(0xA3), + RGBU(0xA4), RGBU(0xA5), RGBU(0xA6), RGBU(0xA7), + RGBU(0xA8), RGBU(0xA9), RGBU(0xAA), RGBU(0xAB), + RGBU(0xAC), RGBU(0xAD), RGBU(0xAE), RGBU(0xAF), + RGBU(0xB0), RGBU(0xB1), RGBU(0xB2), RGBU(0xB3), + RGBU(0xB4), RGBU(0xB5), RGBU(0xB6), RGBU(0xB7), + RGBU(0xB8), RGBU(0xB9), RGBU(0xBA), RGBU(0xBB), + RGBU(0xBC), RGBU(0xBD), RGBU(0xBE), RGBU(0xBF), + RGBU(0xC0), RGBU(0xC1), RGBU(0xC2), RGBU(0xC3), + RGBU(0xC4), RGBU(0xC5), RGBU(0xC6), RGBU(0xC7), + RGBU(0xC8), RGBU(0xC9), RGBU(0xCA), RGBU(0xCB), + RGBU(0xCC), RGBU(0xCD), RGBU(0xCE), RGBU(0xCF), + RGBU(0xD0), RGBU(0xD1), RGBU(0xD2), RGBU(0xD3), + RGBU(0xD4), RGBU(0xD5), RGBU(0xD6), RGBU(0xD7), + RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB), + RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF), + RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3), + RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7), + RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB), + RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF), + RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3), + RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7), + RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB), + RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF), + + // Chroma V table. + RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03), + RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07), + RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B), + RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F), + RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13), + RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17), + RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B), + RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F), + RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23), + RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27), + RGBV(0x28), RGBV(0x29), RGBV(0x2A), RGBV(0x2B), + RGBV(0x2C), RGBV(0x2D), RGBV(0x2E), RGBV(0x2F), + RGBV(0x30), RGBV(0x31), RGBV(0x32), RGBV(0x33), + RGBV(0x34), RGBV(0x35), RGBV(0x36), RGBV(0x37), + RGBV(0x38), RGBV(0x39), RGBV(0x3A), RGBV(0x3B), + RGBV(0x3C), RGBV(0x3D), RGBV(0x3E), RGBV(0x3F), + RGBV(0x40), RGBV(0x41), RGBV(0x42), RGBV(0x43), + RGBV(0x44), RGBV(0x45), RGBV(0x46), RGBV(0x47), + RGBV(0x48), RGBV(0x49), RGBV(0x4A), RGBV(0x4B), + RGBV(0x4C), RGBV(0x4D), RGBV(0x4E), RGBV(0x4F), + RGBV(0x50), RGBV(0x51), RGBV(0x52), RGBV(0x53), + RGBV(0x54), RGBV(0x55), RGBV(0x56), RGBV(0x57), + RGBV(0x58), RGBV(0x59), RGBV(0x5A), RGBV(0x5B), + RGBV(0x5C), RGBV(0x5D), RGBV(0x5E), RGBV(0x5F), + RGBV(0x60), RGBV(0x61), RGBV(0x62), RGBV(0x63), + RGBV(0x64), RGBV(0x65), RGBV(0x66), RGBV(0x67), + RGBV(0x68), RGBV(0x69), RGBV(0x6A), RGBV(0x6B), + RGBV(0x6C), RGBV(0x6D), RGBV(0x6E), RGBV(0x6F), + RGBV(0x70), RGBV(0x71), RGBV(0x72), RGBV(0x73), + RGBV(0x74), RGBV(0x75), RGBV(0x76), RGBV(0x77), + RGBV(0x78), RGBV(0x79), RGBV(0x7A), RGBV(0x7B), + RGBV(0x7C), RGBV(0x7D), RGBV(0x7E), RGBV(0x7F), + RGBV(0x80), RGBV(0x81), RGBV(0x82), RGBV(0x83), + RGBV(0x84), RGBV(0x85), RGBV(0x86), RGBV(0x87), + RGBV(0x88), RGBV(0x89), RGBV(0x8A), RGBV(0x8B), + RGBV(0x8C), RGBV(0x8D), RGBV(0x8E), RGBV(0x8F), + RGBV(0x90), RGBV(0x91), RGBV(0x92), RGBV(0x93), + RGBV(0x94), RGBV(0x95), RGBV(0x96), RGBV(0x97), + RGBV(0x98), RGBV(0x99), RGBV(0x9A), RGBV(0x9B), + RGBV(0x9C), RGBV(0x9D), RGBV(0x9E), RGBV(0x9F), + RGBV(0xA0), RGBV(0xA1), RGBV(0xA2), RGBV(0xA3), + RGBV(0xA4), RGBV(0xA5), RGBV(0xA6), RGBV(0xA7), + RGBV(0xA8), RGBV(0xA9), RGBV(0xAA), RGBV(0xAB), + RGBV(0xAC), RGBV(0xAD), RGBV(0xAE), RGBV(0xAF), + RGBV(0xB0), RGBV(0xB1), RGBV(0xB2), RGBV(0xB3), + RGBV(0xB4), RGBV(0xB5), RGBV(0xB6), RGBV(0xB7), + RGBV(0xB8), RGBV(0xB9), RGBV(0xBA), RGBV(0xBB), + RGBV(0xBC), RGBV(0xBD), RGBV(0xBE), RGBV(0xBF), + RGBV(0xC0), RGBV(0xC1), RGBV(0xC2), RGBV(0xC3), + RGBV(0xC4), RGBV(0xC5), RGBV(0xC6), RGBV(0xC7), + RGBV(0xC8), RGBV(0xC9), RGBV(0xCA), RGBV(0xCB), + RGBV(0xCC), RGBV(0xCD), RGBV(0xCE), RGBV(0xCF), + RGBV(0xD0), RGBV(0xD1), RGBV(0xD2), RGBV(0xD3), + RGBV(0xD4), RGBV(0xD5), RGBV(0xD6), RGBV(0xD7), + RGBV(0xD8), RGBV(0xD9), RGBV(0xDA), RGBV(0xDB), + RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF), + RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3), + RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7), + RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB), + RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF), + RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3), + RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7), + RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB), + RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF), +}; + +#undef RGBY +#undef RGBU +#undef RGBV +#undef MMX_ALIGNED + +extern void MacConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width, + int16 *kCoefficientsRgbY); + __asm__( +"_MacConvertYUVToRGB32Row:\n" + "pusha\n" + "mov 0x24(%esp),%edx\n" + "mov 0x28(%esp),%edi\n" + "mov 0x2c(%esp),%esi\n" + "mov 0x30(%esp),%ebp\n" + "mov 0x38(%esp),%ecx\n" + + "jmp Lconvertend\n" + +"Lconvertloop:" + "movzbl (%edi),%eax\n" + "add $0x1,%edi\n" + "movzbl (%esi),%ebx\n" + "add $0x1,%esi\n" + "movq 2048(%ecx,%eax,8),%mm0\n" + "movzbl (%edx),%eax\n" + "paddsw 4096(%ecx,%ebx,8),%mm0\n" + "movzbl 0x1(%edx),%ebx\n" + "movq 0(%ecx,%eax,8),%mm1\n" + "add $0x2,%edx\n" + "movq 0(%ecx,%ebx,8),%mm2\n" + "paddsw %mm0,%mm1\n" + "paddsw %mm0,%mm2\n" + "psraw $0x6,%mm1\n" + "psraw $0x6,%mm2\n" + "packuswb %mm2,%mm1\n" + "movntq %mm1,0x0(%ebp)\n" + "add $0x8,%ebp\n" +"Lconvertend:" + "sub $0x2,0x34(%esp)\n" + "jns Lconvertloop\n" + + "and $0x1,0x34(%esp)\n" + "je Lconvertdone\n" + + "movzbl (%edi),%eax\n" + "movq 2048(%ecx,%eax,8),%mm0\n" + "movzbl (%esi),%eax\n" + "paddsw 4096(%ecx,%eax,8),%mm0\n" + "movzbl (%edx),%eax\n" + "movq 0(%ecx,%eax,8),%mm1\n" + "paddsw %mm0,%mm1\n" + "psraw $0x6,%mm1\n" + "packuswb %mm1,%mm1\n" + "movd %mm1,0x0(%ebp)\n" +"Lconvertdone:\n" + "popa\n" + "ret\n" +); + +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + MacConvertYUVToRGB32Row(y_buf, u_buf, v_buf, rgb_buf, width, + &kCoefficientsRgbY[0][0]); +} + +#endif // ARCH_CPU_PPC || ARCH_CPU_64_BITS +} // extern "C" +
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row_other.cpp @@ -0,0 +1,15 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "yuv_row.h" + +extern "C" { +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width, 1); +} +}
new file mode 100644 --- /dev/null +++ b/gfx/ycbcr/yuv_row_win.cpp @@ -0,0 +1,317 @@ +// Copyright (c) 2009 The Chromium Authors. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "yuv_row.h" + +extern "C" { +// 64 Bit builds use the C fallback. Optimized code +// needs to be fixed for 64 bit builds. +#if defined(ARCH_CPU_64_BITS) +// PPC implementation uses C fallback +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + FastConvertYUVToRGB32Row_C(y_buf, u_buf, v_buf, rgb_buf, width); +} + +#else + + +#define RGBY(i) { \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + static_cast<int16>(1.164 * 64 * (i - 16) + 0.5), \ + 0 \ +} + +#define RGBU(i) { \ + static_cast<int16>(2.018 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(-0.391 * 64 * (i - 128) + 0.5), \ + 0, \ + static_cast<int16>(256 * 64 - 1) \ +} + +#define RGBV(i) { \ + 0, \ + static_cast<int16>(-0.813 * 64 * (i - 128) + 0.5), \ + static_cast<int16>(1.596 * 64 * (i - 128) + 0.5), \ + 0 \ +} + +#define MMX_ALIGNED(var) __declspec(align(16)) var + +MMX_ALIGNED(int16 kCoefficientsRgbY[256][4]) = { + RGBY(0x00), RGBY(0x01), RGBY(0x02), RGBY(0x03), + RGBY(0x04), RGBY(0x05), RGBY(0x06), RGBY(0x07), + RGBY(0x08), RGBY(0x09), RGBY(0x0A), RGBY(0x0B), + RGBY(0x0C), RGBY(0x0D), RGBY(0x0E), RGBY(0x0F), + RGBY(0x10), RGBY(0x11), RGBY(0x12), RGBY(0x13), + RGBY(0x14), RGBY(0x15), RGBY(0x16), RGBY(0x17), + RGBY(0x18), RGBY(0x19), RGBY(0x1A), RGBY(0x1B), + RGBY(0x1C), RGBY(0x1D), RGBY(0x1E), RGBY(0x1F), + RGBY(0x20), RGBY(0x21), RGBY(0x22), RGBY(0x23), + RGBY(0x24), RGBY(0x25), RGBY(0x26), RGBY(0x27), + RGBY(0x28), RGBY(0x29), RGBY(0x2A), RGBY(0x2B), + RGBY(0x2C), RGBY(0x2D), RGBY(0x2E), RGBY(0x2F), + RGBY(0x30), RGBY(0x31), RGBY(0x32), RGBY(0x33), + RGBY(0x34), RGBY(0x35), RGBY(0x36), RGBY(0x37), + RGBY(0x38), RGBY(0x39), RGBY(0x3A), RGBY(0x3B), + RGBY(0x3C), RGBY(0x3D), RGBY(0x3E), RGBY(0x3F), + RGBY(0x40), RGBY(0x41), RGBY(0x42), RGBY(0x43), + RGBY(0x44), RGBY(0x45), RGBY(0x46), RGBY(0x47), + RGBY(0x48), RGBY(0x49), RGBY(0x4A), RGBY(0x4B), + RGBY(0x4C), RGBY(0x4D), RGBY(0x4E), RGBY(0x4F), + RGBY(0x50), RGBY(0x51), RGBY(0x52), RGBY(0x53), + RGBY(0x54), RGBY(0x55), RGBY(0x56), RGBY(0x57), + RGBY(0x58), RGBY(0x59), RGBY(0x5A), RGBY(0x5B), + RGBY(0x5C), RGBY(0x5D), RGBY(0x5E), RGBY(0x5F), + RGBY(0x60), RGBY(0x61), RGBY(0x62), RGBY(0x63), + RGBY(0x64), RGBY(0x65), RGBY(0x66), RGBY(0x67), + RGBY(0x68), RGBY(0x69), RGBY(0x6A), RGBY(0x6B), + RGBY(0x6C), RGBY(0x6D), RGBY(0x6E), RGBY(0x6F), + RGBY(0x70), RGBY(0x71), RGBY(0x72), RGBY(0x73), + RGBY(0x74), RGBY(0x75), RGBY(0x76), RGBY(0x77), + RGBY(0x78), RGBY(0x79), RGBY(0x7A), RGBY(0x7B), + RGBY(0x7C), RGBY(0x7D), RGBY(0x7E), RGBY(0x7F), + RGBY(0x80), RGBY(0x81), RGBY(0x82), RGBY(0x83), + RGBY(0x84), RGBY(0x85), RGBY(0x86), RGBY(0x87), + RGBY(0x88), RGBY(0x89), RGBY(0x8A), RGBY(0x8B), + RGBY(0x8C), RGBY(0x8D), RGBY(0x8E), RGBY(0x8F), + RGBY(0x90), RGBY(0x91), RGBY(0x92), RGBY(0x93), + RGBY(0x94), RGBY(0x95), RGBY(0x96), RGBY(0x97), + RGBY(0x98), RGBY(0x99), RGBY(0x9A), RGBY(0x9B), + RGBY(0x9C), RGBY(0x9D), RGBY(0x9E), RGBY(0x9F), + RGBY(0xA0), RGBY(0xA1), RGBY(0xA2), RGBY(0xA3), + RGBY(0xA4), RGBY(0xA5), RGBY(0xA6), RGBY(0xA7), + RGBY(0xA8), RGBY(0xA9), RGBY(0xAA), RGBY(0xAB), + RGBY(0xAC), RGBY(0xAD), RGBY(0xAE), RGBY(0xAF), + RGBY(0xB0), RGBY(0xB1), RGBY(0xB2), RGBY(0xB3), + RGBY(0xB4), RGBY(0xB5), RGBY(0xB6), RGBY(0xB7), + RGBY(0xB8), RGBY(0xB9), RGBY(0xBA), RGBY(0xBB), + RGBY(0xBC), RGBY(0xBD), RGBY(0xBE), RGBY(0xBF), + RGBY(0xC0), RGBY(0xC1), RGBY(0xC2), RGBY(0xC3), + RGBY(0xC4), RGBY(0xC5), RGBY(0xC6), RGBY(0xC7), + RGBY(0xC8), RGBY(0xC9), RGBY(0xCA), RGBY(0xCB), + RGBY(0xCC), RGBY(0xCD), RGBY(0xCE), RGBY(0xCF), + RGBY(0xD0), RGBY(0xD1), RGBY(0xD2), RGBY(0xD3), + RGBY(0xD4), RGBY(0xD5), RGBY(0xD6), RGBY(0xD7), + RGBY(0xD8), RGBY(0xD9), RGBY(0xDA), RGBY(0xDB), + RGBY(0xDC), RGBY(0xDD), RGBY(0xDE), RGBY(0xDF), + RGBY(0xE0), RGBY(0xE1), RGBY(0xE2), RGBY(0xE3), + RGBY(0xE4), RGBY(0xE5), RGBY(0xE6), RGBY(0xE7), + RGBY(0xE8), RGBY(0xE9), RGBY(0xEA), RGBY(0xEB), + RGBY(0xEC), RGBY(0xED), RGBY(0xEE), RGBY(0xEF), + RGBY(0xF0), RGBY(0xF1), RGBY(0xF2), RGBY(0xF3), + RGBY(0xF4), RGBY(0xF5), RGBY(0xF6), RGBY(0xF7), + RGBY(0xF8), RGBY(0xF9), RGBY(0xFA), RGBY(0xFB), + RGBY(0xFC), RGBY(0xFD), RGBY(0xFE), RGBY(0xFF), +}; + +MMX_ALIGNED(int16 kCoefficientsRgbU[256][4]) = { + RGBU(0x00), RGBU(0x01), RGBU(0x02), RGBU(0x03), + RGBU(0x04), RGBU(0x05), RGBU(0x06), RGBU(0x07), + RGBU(0x08), RGBU(0x09), RGBU(0x0A), RGBU(0x0B), + RGBU(0x0C), RGBU(0x0D), RGBU(0x0E), RGBU(0x0F), + RGBU(0x10), RGBU(0x11), RGBU(0x12), RGBU(0x13), + RGBU(0x14), RGBU(0x15), RGBU(0x16), RGBU(0x17), + RGBU(0x18), RGBU(0x19), RGBU(0x1A), RGBU(0x1B), + RGBU(0x1C), RGBU(0x1D), RGBU(0x1E), RGBU(0x1F), + RGBU(0x20), RGBU(0x21), RGBU(0x22), RGBU(0x23), + RGBU(0x24), RGBU(0x25), RGBU(0x26), RGBU(0x27), + RGBU(0x28), RGBU(0x29), RGBU(0x2A), RGBU(0x2B), + RGBU(0x2C), RGBU(0x2D), RGBU(0x2E), RGBU(0x2F), + RGBU(0x30), RGBU(0x31), RGBU(0x32), RGBU(0x33), + RGBU(0x34), RGBU(0x35), RGBU(0x36), RGBU(0x37), + RGBU(0x38), RGBU(0x39), RGBU(0x3A), RGBU(0x3B), + RGBU(0x3C), RGBU(0x3D), RGBU(0x3E), RGBU(0x3F), + RGBU(0x40), RGBU(0x41), RGBU(0x42), RGBU(0x43), + RGBU(0x44), RGBU(0x45), RGBU(0x46), RGBU(0x47), + RGBU(0x48), RGBU(0x49), RGBU(0x4A), RGBU(0x4B), + RGBU(0x4C), RGBU(0x4D), RGBU(0x4E), RGBU(0x4F), + RGBU(0x50), RGBU(0x51), RGBU(0x52), RGBU(0x53), + RGBU(0x54), RGBU(0x55), RGBU(0x56), RGBU(0x57), + RGBU(0x58), RGBU(0x59), RGBU(0x5A), RGBU(0x5B), + RGBU(0x5C), RGBU(0x5D), RGBU(0x5E), RGBU(0x5F), + RGBU(0x60), RGBU(0x61), RGBU(0x62), RGBU(0x63), + RGBU(0x64), RGBU(0x65), RGBU(0x66), RGBU(0x67), + RGBU(0x68), RGBU(0x69), RGBU(0x6A), RGBU(0x6B), + RGBU(0x6C), RGBU(0x6D), RGBU(0x6E), RGBU(0x6F), + RGBU(0x70), RGBU(0x71), RGBU(0x72), RGBU(0x73), + RGBU(0x74), RGBU(0x75), RGBU(0x76), RGBU(0x77), + RGBU(0x78), RGBU(0x79), RGBU(0x7A), RGBU(0x7B), + RGBU(0x7C), RGBU(0x7D), RGBU(0x7E), RGBU(0x7F), + RGBU(0x80), RGBU(0x81), RGBU(0x82), RGBU(0x83), + RGBU(0x84), RGBU(0x85), RGBU(0x86), RGBU(0x87), + RGBU(0x88), RGBU(0x89), RGBU(0x8A), RGBU(0x8B), + RGBU(0x8C), RGBU(0x8D), RGBU(0x8E), RGBU(0x8F), + RGBU(0x90), RGBU(0x91), RGBU(0x92), RGBU(0x93), + RGBU(0x94), RGBU(0x95), RGBU(0x96), RGBU(0x97), + RGBU(0x98), RGBU(0x99), RGBU(0x9A), RGBU(0x9B), + RGBU(0x9C), RGBU(0x9D), RGBU(0x9E), RGBU(0x9F), + RGBU(0xA0), RGBU(0xA1), RGBU(0xA2), RGBU(0xA3), + RGBU(0xA4), RGBU(0xA5), RGBU(0xA6), RGBU(0xA7), + RGBU(0xA8), RGBU(0xA9), RGBU(0xAA), RGBU(0xAB), + RGBU(0xAC), RGBU(0xAD), RGBU(0xAE), RGBU(0xAF), + RGBU(0xB0), RGBU(0xB1), RGBU(0xB2), RGBU(0xB3), + RGBU(0xB4), RGBU(0xB5), RGBU(0xB6), RGBU(0xB7), + RGBU(0xB8), RGBU(0xB9), RGBU(0xBA), RGBU(0xBB), + RGBU(0xBC), RGBU(0xBD), RGBU(0xBE), RGBU(0xBF), + RGBU(0xC0), RGBU(0xC1), RGBU(0xC2), RGBU(0xC3), + RGBU(0xC4), RGBU(0xC5), RGBU(0xC6), RGBU(0xC7), + RGBU(0xC8), RGBU(0xC9), RGBU(0xCA), RGBU(0xCB), + RGBU(0xCC), RGBU(0xCD), RGBU(0xCE), RGBU(0xCF), + RGBU(0xD0), RGBU(0xD1), RGBU(0xD2), RGBU(0xD3), + RGBU(0xD4), RGBU(0xD5), RGBU(0xD6), RGBU(0xD7), + RGBU(0xD8), RGBU(0xD9), RGBU(0xDA), RGBU(0xDB), + RGBU(0xDC), RGBU(0xDD), RGBU(0xDE), RGBU(0xDF), + RGBU(0xE0), RGBU(0xE1), RGBU(0xE2), RGBU(0xE3), + RGBU(0xE4), RGBU(0xE5), RGBU(0xE6), RGBU(0xE7), + RGBU(0xE8), RGBU(0xE9), RGBU(0xEA), RGBU(0xEB), + RGBU(0xEC), RGBU(0xED), RGBU(0xEE), RGBU(0xEF), + RGBU(0xF0), RGBU(0xF1), RGBU(0xF2), RGBU(0xF3), + RGBU(0xF4), RGBU(0xF5), RGBU(0xF6), RGBU(0xF7), + RGBU(0xF8), RGBU(0xF9), RGBU(0xFA), RGBU(0xFB), + RGBU(0xFC), RGBU(0xFD), RGBU(0xFE), RGBU(0xFF), +}; + +MMX_ALIGNED(int16 kCoefficientsRgbV[256][4]) = { + RGBV(0x00), RGBV(0x01), RGBV(0x02), RGBV(0x03), + RGBV(0x04), RGBV(0x05), RGBV(0x06), RGBV(0x07), + RGBV(0x08), RGBV(0x09), RGBV(0x0A), RGBV(0x0B), + RGBV(0x0C), RGBV(0x0D), RGBV(0x0E), RGBV(0x0F), + RGBV(0x10), RGBV(0x11), RGBV(0x12), RGBV(0x13), + RGBV(0x14), RGBV(0x15), RGBV(0x16), RGBV(0x17), + RGBV(0x18), RGBV(0x19), RGBV(0x1A), RGBV(0x1B), + RGBV(0x1C), RGBV(0x1D), RGBV(0x1E), RGBV(0x1F), + RGBV(0x20), RGBV(0x21), RGBV(0x22), RGBV(0x23), + RGBV(0x24), RGBV(0x25), RGBV(0x26), RGBV(0x27), + RGBV(0x28), RGBV(0x29), RGBV(0x2A), RGBV(0x2B), + RGBV(0x2C), RGBV(0x2D), RGBV(0x2E), RGBV(0x2F), + RGBV(0x30), RGBV(0x31), RGBV(0x32), RGBV(0x33), + RGBV(0x34), RGBV(0x35), RGBV(0x36), RGBV(0x37), + RGBV(0x38), RGBV(0x39), RGBV(0x3A), RGBV(0x3B), + RGBV(0x3C), RGBV(0x3D), RGBV(0x3E), RGBV(0x3F), + RGBV(0x40), RGBV(0x41), RGBV(0x42), RGBV(0x43), + RGBV(0x44), RGBV(0x45), RGBV(0x46), RGBV(0x47), + RGBV(0x48), RGBV(0x49), RGBV(0x4A), RGBV(0x4B), + RGBV(0x4C), RGBV(0x4D), RGBV(0x4E), RGBV(0x4F), + RGBV(0x50), RGBV(0x51), RGBV(0x52), RGBV(0x53), + RGBV(0x54), RGBV(0x55), RGBV(0x56), RGBV(0x57), + RGBV(0x58), RGBV(0x59), RGBV(0x5A), RGBV(0x5B), + RGBV(0x5C), RGBV(0x5D), RGBV(0x5E), RGBV(0x5F), + RGBV(0x60), RGBV(0x61), RGBV(0x62), RGBV(0x63), + RGBV(0x64), RGBV(0x65), RGBV(0x66), RGBV(0x67), + RGBV(0x68), RGBV(0x69), RGBV(0x6A), RGBV(0x6B), + RGBV(0x6C), RGBV(0x6D), RGBV(0x6E), RGBV(0x6F), + RGBV(0x70), RGBV(0x71), RGBV(0x72), RGBV(0x73), + RGBV(0x74), RGBV(0x75), RGBV(0x76), RGBV(0x77), + RGBV(0x78), RGBV(0x79), RGBV(0x7A), RGBV(0x7B), + RGBV(0x7C), RGBV(0x7D), RGBV(0x7E), RGBV(0x7F), + RGBV(0x80), RGBV(0x81), RGBV(0x82), RGBV(0x83), + RGBV(0x84), RGBV(0x85), RGBV(0x86), RGBV(0x87), + RGBV(0x88), RGBV(0x89), RGBV(0x8A), RGBV(0x8B), + RGBV(0x8C), RGBV(0x8D), RGBV(0x8E), RGBV(0x8F), + RGBV(0x90), RGBV(0x91), RGBV(0x92), RGBV(0x93), + RGBV(0x94), RGBV(0x95), RGBV(0x96), RGBV(0x97), + RGBV(0x98), RGBV(0x99), RGBV(0x9A), RGBV(0x9B), + RGBV(0x9C), RGBV(0x9D), RGBV(0x9E), RGBV(0x9F), + RGBV(0xA0), RGBV(0xA1), RGBV(0xA2), RGBV(0xA3), + RGBV(0xA4), RGBV(0xA5), RGBV(0xA6), RGBV(0xA7), + RGBV(0xA8), RGBV(0xA9), RGBV(0xAA), RGBV(0xAB), + RGBV(0xAC), RGBV(0xAD), RGBV(0xAE), RGBV(0xAF), + RGBV(0xB0), RGBV(0xB1), RGBV(0xB2), RGBV(0xB3), + RGBV(0xB4), RGBV(0xB5), RGBV(0xB6), RGBV(0xB7), + RGBV(0xB8), RGBV(0xB9), RGBV(0xBA), RGBV(0xBB), + RGBV(0xBC), RGBV(0xBD), RGBV(0xBE), RGBV(0xBF), + RGBV(0xC0), RGBV(0xC1), RGBV(0xC2), RGBV(0xC3), + RGBV(0xC4), RGBV(0xC5), RGBV(0xC6), RGBV(0xC7), + RGBV(0xC8), RGBV(0xC9), RGBV(0xCA), RGBV(0xCB), + RGBV(0xCC), RGBV(0xCD), RGBV(0xCE), RGBV(0xCF), + RGBV(0xD0), RGBV(0xD1), RGBV(0xD2), RGBV(0xD3), + RGBV(0xD4), RGBV(0xD5), RGBV(0xD6), RGBV(0xD7), + RGBV(0xD8), RGBV(0xD9), RGBV(0xDA), RGBV(0xDB), + RGBV(0xDC), RGBV(0xDD), RGBV(0xDE), RGBV(0xDF), + RGBV(0xE0), RGBV(0xE1), RGBV(0xE2), RGBV(0xE3), + RGBV(0xE4), RGBV(0xE5), RGBV(0xE6), RGBV(0xE7), + RGBV(0xE8), RGBV(0xE9), RGBV(0xEA), RGBV(0xEB), + RGBV(0xEC), RGBV(0xED), RGBV(0xEE), RGBV(0xEF), + RGBV(0xF0), RGBV(0xF1), RGBV(0xF2), RGBV(0xF3), + RGBV(0xF4), RGBV(0xF5), RGBV(0xF6), RGBV(0xF7), + RGBV(0xF8), RGBV(0xF9), RGBV(0xFA), RGBV(0xFB), + RGBV(0xFC), RGBV(0xFD), RGBV(0xFE), RGBV(0xFF), +}; + +#undef RGBHY +#undef RGBY +#undef RGBU +#undef RGBV +#undef MMX_ALIGNED + +// Warning C4799: function has no EMMS instruction. +// EMMS() is slow and should be called by the calling function once per image. +#pragma warning(disable: 4799) + +__declspec(naked) +void FastConvertYUVToRGB32Row(const uint8* y_buf, + const uint8* u_buf, + const uint8* v_buf, + uint8* rgb_buf, + int width) { + __asm { + pushad + mov edx, [esp + 32 + 4] // Y + mov edi, [esp + 32 + 8] // U + mov esi, [esp + 32 + 12] // V + mov ebp, [esp + 32 + 16] // rgb + mov ecx, [esp + 32 + 20] // width + jmp convertend + + convertloop : + movzx eax, byte ptr [edi] + add edi, 1 + movzx ebx, byte ptr [esi] + add esi, 1 + movq mm0, [kCoefficientsRgbU + 8 * eax] + movzx eax, byte ptr [edx] + paddsw mm0, [kCoefficientsRgbV + 8 * ebx] + movzx ebx, byte ptr [edx + 1] + movq mm1, [kCoefficientsRgbY + 8 * eax] + add edx, 2 + movq mm2, [kCoefficientsRgbY + 8 * ebx] + paddsw mm1, mm0 + paddsw mm2, mm0 + psraw mm1, 6 + psraw mm2, 6 + packuswb mm1, mm2 + movntq [ebp], mm1 + add ebp, 8 + convertend : + sub ecx, 2 + jns convertloop + + and ecx, 1 // odd number of pixels? + jz convertdone + + movzx eax, byte ptr [edi] + movq mm0, [kCoefficientsRgbU + 8 * eax] + movzx eax, byte ptr [esi] + paddsw mm0, [kCoefficientsRgbV + 8 * eax] + movzx eax, byte ptr [edx] + movq mm1, [kCoefficientsRgbY + 8 * eax] + paddsw mm1, mm0 + psraw mm1, 6 + packuswb mm1, mm1 + movd [ebp], mm1 + convertdone : + + popad + ret + } +} + +#endif // ARCH_CPU_64_BITS +} // extern "C" +
--- a/layout/build/Makefile.in +++ b/layout/build/Makefile.in @@ -56,17 +56,17 @@ EXPORT_LIBRARY = 1 IS_COMPONENT = 1 MODULE_NAME = nsLayoutModule GRE_MODULE = 1 LIBXUL_LIBRARY = 1 ifndef MOZ_ENABLE_LIBXUL EXTRA_DSO_LIBS = gkgfx gfxutils endif -EXTRA_DSO_LIBS += thebes layers +EXTRA_DSO_LIBS += thebes layers ycbcr CPPSRCS = \ nsLayoutModule.cpp \ nsContentDLF.cpp \ nsLayoutStatics.cpp \ $(NULL)
--- a/toolkit/content/license.html +++ b/toolkit/content/license.html @@ -2159,17 +2159,18 @@ WITH THE USE OR PERFORMANCE OF THIS SOFT </pre> <hr> <h1><a name="chromium"></a>Chromium License</h1> <p class="correctme">This license applies to some files in the directory - <span class="path">ipc/chromium/</span>. + <span class="path">ipc/chromium/</span> and + <span class="path">gfx/ycbcr</span>. </p> <pre> Copyright (c) 2006-2008 The Chromium Authors. All rights reserved. Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
--- a/toolkit/library/libxul-config.mk +++ b/toolkit/library/libxul-config.mk @@ -302,17 +302,17 @@ DEFINES += -DMOZ_ENABLE_POSTSCRIPT STATIC_LIBS += gfxpsshar endif ifneq (,$(filter icon,$(MOZ_IMG_DECODERS))) DEFINES += -DICON_DECODER COMPONENT_LIBS += imgicon endif -STATIC_LIBS += thebes layers +STATIC_LIBS += thebes layers ycbcr COMPONENT_LIBS += gkgfxthebes ifeq (windows,$(MOZ_WIDGET_TOOLKIT)) COMPONENT_LIBS += gkwidget endif ifeq (beos,$(MOZ_WIDGET_TOOLKIT)) COMPONENT_LIBS += widget_beos endif
--- a/toolkit/toolkit-makefiles.sh +++ b/toolkit/toolkit-makefiles.sh @@ -116,16 +116,17 @@ MAKEFILES_xmlparser=" parser/expat/lib/Makefile parser/xml/Makefile parser/xml/public/Makefile parser/xml/src/Makefile " MAKEFILES_gfx=" gfx/Makefile + gfx/ycbcr/Makefile gfx/idl/Makefile gfx/layers/Makefile gfx/public/Makefile gfx/src/Makefile gfx/src/psshared/Makefile gfx/src/thebes/Makefile gfx/tests/Makefile gfx/thebes/Makefile