diff --git a/common_video/OWNERS b/common_video/OWNERS
new file mode 100644
index 0000000..30eee35
--- /dev/null
+++ b/common_video/OWNERS
@@ -0,0 +1,4 @@
+holmer@google.com
+mikhal@google.com
+marpan@google.com
+hlundin@google.com
diff --git a/common_video/jpeg/main/interface/jpeg.h b/common_video/jpeg/main/interface/jpeg.h
new file mode 100644
index 0000000..6f092b8
--- /dev/null
+++ b/common_video/jpeg/main/interface/jpeg.h
@@ -0,0 +1,96 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * JPEG wrapper
+ */
+
+#ifndef WEBRTC_COMMON_VIDEO_JPEG
+#define WEBRTC_COMMON_VIDEO_JPEG
+
+#include "typedefs.h"
+
+// jpeg forward declaration
+struct jpeg_compress_struct;
+struct jpeg_decompress_struct;
+
+namespace webrtc
+{
+
+class JpegEncoder
+{
+public:
+    JpegEncoder();
+    ~JpegEncoder();
+
+// SetFileName
+// Input:
+//  - fileName - Pointer to input vector (should be less than 256) to which the
+//               compressed  file will be written to
+//    Output:
+//    - 0             : OK
+//    - (-1)          : Error
+    WebRtc_Word32 SetFileName(const WebRtc_Word8* fileName);
+
+// Encode an I420 image. The encoded image is saved to a file
+//
+// Input:
+//          - inputImage        : Image to be encoded
+//
+//    Output:
+//    - 0             : OK
+//    - (-1)          : Error
+    WebRtc_Word32 Encode(const WebRtc_UWord8* imageBuffer,
+                         const WebRtc_UWord32 imageBufferSize,
+                         const WebRtc_UWord32 width,
+                         const WebRtc_UWord32 height);
+
+private:
+    WebRtc_Word32 Encode(const WebRtc_UWord8* imageBuffer,
+                         const WebRtc_UWord32 imageBufferSize);
+
+    jpeg_compress_struct*   _cinfo;
+    WebRtc_Word8            _fileName[256];
+    WebRtc_UWord32          _width;
+    WebRtc_UWord32          _height;
+};
+
+class JpegDecoder
+{
+ public:
+    JpegDecoder();
+    ~JpegDecoder();
+
+//Decodes a JPEG-stream
+//Supports 1 image component. 3 interleaved image components, YCbCr sub-sampling 4:4:4, 4:2:2, 4:2:0.
+//
+//Input:
+//    - encodedBuffer     : Pointer to the encoded stream to be decoded.
+//    - encodedBufferSize : Size of the data to be decoded
+//    - decodedBuffer     : Reference to the destination of the decoded I420-image.
+//    - width             : Reference returning width of decoded image.
+//    - height            : Reference returning height of decoded image.
+//
+//    Output:
+//    - 0             : OK
+//    - (-1)          : Error
+//Note: decodedBuffer should be freed by user
+    WebRtc_Word32 Decode(const WebRtc_UWord8* encodedBuffer,
+                         const WebRtc_UWord32 encodedBufferSize,
+                         WebRtc_UWord8*& decodedBuffer,
+                         WebRtc_UWord32& width,
+                         WebRtc_UWord32& height);
+ private:
+    jpeg_decompress_struct*    _cinfo;
+};
+
+
+}
+#endif /* WEBRTC_COMMON_VIDEO_JPEG  */
diff --git a/common_video/jpeg/main/source/data_manager.cc b/common_video/jpeg/main/source/data_manager.cc
new file mode 100644
index 0000000..2e2a870
--- /dev/null
+++ b/common_video/jpeg/main/source/data_manager.cc
@@ -0,0 +1,100 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * data_manager.cc
+ */
+
+#include "data_manager.h"
+
+#ifdef WEBRTC_ANDROID
+extern "C" {
+#endif
+#include "jpeglib.h"
+#ifdef WEBRTC_ANDROID
+}
+#endif
+#include "jmorecfg.h"
+
+
+namespace webrtc
+{
+
+typedef struct
+{
+    jpeg_source_mgr  mgr;
+    JOCTET* next_input_byte;
+    size_t bytes_in_buffer;      /* # of byte spaces remaining in buffer */
+} DataSrcMgr;
+
+void
+jpegSetSrcBuffer(j_decompress_ptr cinfo, JOCTET* srcBuffer, size_t bufferSize)
+{
+    DataSrcMgr* src;
+    if (cinfo->src == NULL)
+    {  /* first time for this JPEG object? */
+        cinfo->src = (struct jpeg_source_mgr *)
+                   (*cinfo->mem->alloc_small) ((j_common_ptr) cinfo,
+                       JPOOL_PERMANENT, sizeof(DataSrcMgr));
+    }
+
+    // Setting required functionality
+    src = (DataSrcMgr*) cinfo->src;
+    src->mgr.init_source = initSrc;;
+    src->mgr.fill_input_buffer = fillInputBuffer;
+    src->mgr.skip_input_data = skipInputData;
+    src->mgr.resync_to_restart = jpeg_resync_to_restart; // use default
+    src->mgr.term_source = termSource;
+    // setting buffer/src
+    src->bytes_in_buffer = bufferSize;
+    src->next_input_byte = srcBuffer;
+
+}
+
+
+void
+initSrc(j_decompress_ptr cinfo)
+{
+    DataSrcMgr  *src = (DataSrcMgr*)cinfo->src;
+    src->mgr.next_input_byte = src->next_input_byte;
+    src->mgr.bytes_in_buffer = src->bytes_in_buffer;
+}
+
+boolean
+fillInputBuffer(j_decompress_ptr cinfo)
+{
+    return false;
+}
+
+
+void
+skipInputData(j_decompress_ptr cinfo, long num_bytes)
+{
+    DataSrcMgr* src = (DataSrcMgr*)cinfo->src;
+    if (num_bytes > 0)
+    {
+          if ((unsigned long)num_bytes > src->mgr.bytes_in_buffer)
+              src->mgr.bytes_in_buffer = 0;
+          else
+          {
+              src->mgr.next_input_byte += num_bytes;
+              src->mgr.bytes_in_buffer -= num_bytes;
+          }
+    }
+}
+
+
+void
+termSource (j_decompress_ptr cinfo)
+{
+  //
+}
+
+} // end of namespace webrtc
diff --git a/common_video/jpeg/main/source/data_manager.h b/common_video/jpeg/main/source/data_manager.h
new file mode 100644
index 0000000..56fdb2d
--- /dev/null
+++ b/common_video/jpeg/main/source/data_manager.h
@@ -0,0 +1,68 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * Jpeg source data manager
+ */
+
+#ifndef WEBRTC_COMMON_VIDEO_JPEG_DATA_MANAGER
+#define WEBRTC_COMMON_VIDEO_JPEG_DATA_MANAGER
+
+#include <stdio.h>
+
+// jpeg forward declaration
+struct jpeg_source_mgr;
+typedef unsigned char JOCTET;
+typedef int boolean;
+typedef struct jpeg_decompress_struct* j_decompress_ptr;
+typedef struct jpeg_compress_struct* j_compress_ptr;
+
+namespace webrtc
+{
+
+// Source manager:
+
+
+// a general function that will set these values
+void
+jpegSetSrcBuffer(j_decompress_ptr cinfo, JOCTET* srcBuffer, size_t bufferSize);
+
+
+// Initialize source.  This is called by jpeg_read_header() before any
+//  data is actually read.
+
+void
+initSrc(j_decompress_ptr cinfo);
+
+
+// Fill input buffer
+// This is called whenever bytes_in_buffer has reached zero and more
+//  data is wanted.
+
+boolean
+fillInputBuffer(j_decompress_ptr cinfo);
+
+// Skip input data
+// Skip num_bytes worth of data.
+
+void
+skipInputData(j_decompress_ptr cinfo, long num_bytes);
+
+
+
+
+// Terminate source
+void
+termSource (j_decompress_ptr cinfo);
+
+} // end of namespace webrtc
+
+
+#endif /* WEBRTC_COMMON_VIDEO_JPEG_DATA_MANAGER */
diff --git a/common_video/jpeg/main/source/jpeg.cc b/common_video/jpeg/main/source/jpeg.cc
new file mode 100644
index 0000000..9fffedd
--- /dev/null
+++ b/common_video/jpeg/main/source/jpeg.cc
@@ -0,0 +1,345 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * jpeg.cc
+ */
+
+
+#include <stdio.h>
+#include <string.h>
+
+#include "vplib.h"
+#include "jpeg.h"
+#include "data_manager.h"
+#if defined(WIN32)
+ #include <basetsd.h>
+#endif
+#ifdef WEBRTC_ANDROID
+extern "C" {
+#endif
+#include "jpeglib.h"
+#ifdef WEBRTC_ANDROID
+}
+#endif
+#include <setjmp.h>
+
+
+namespace webrtc
+{
+
+// Error handler
+struct myErrorMgr {
+
+    struct jpeg_error_mgr pub;
+    jmp_buf setjmp_buffer;
+};
+typedef struct myErrorMgr * myErrorPtr;
+
+METHODDEF(void)
+MyErrorExit (j_common_ptr cinfo)
+{
+    myErrorPtr myerr = (myErrorPtr) cinfo->err;
+
+    // Return control to the setjmp point
+    longjmp(myerr->setjmp_buffer, 1);
+}
+
+JpegEncoder::JpegEncoder():
+_width(0),
+_height(0)
+{
+    _cinfo = new jpeg_compress_struct;
+    strcpy(_fileName, "Snapshot.jpg");
+}
+
+JpegEncoder::~JpegEncoder()
+{
+    delete _cinfo;
+    _cinfo = NULL;
+}
+
+
+WebRtc_Word32
+JpegEncoder::SetFileName(const WebRtc_Word8* fileName)
+{
+    if (!fileName)
+    {
+        return -1;
+    }
+
+    if (fileName)
+    {
+        strncpy(_fileName, fileName, 256);
+    }
+    return 0;
+}
+
+
+WebRtc_Word32
+JpegEncoder::Encode(const WebRtc_UWord8* imageBuffer,
+                    const WebRtc_UWord32 imageBufferSize,
+                    const WebRtc_UWord32 width,
+                    const WebRtc_UWord32 height)
+{
+    if ((imageBuffer == NULL) || (imageBufferSize == 0))
+    {
+        return -1;
+    }
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    FILE* outFile = NULL;
+
+    _width = width;
+    _height = height;
+
+    // Set error handler
+    myErrorMgr      jerr;
+    _cinfo->err = jpeg_std_error(&jerr.pub);
+    jerr.pub.error_exit = MyErrorExit;
+    // Establish the setjmp return context
+    if (setjmp(jerr.setjmp_buffer))
+    {
+        // If we get here, the JPEG code has signaled an error.
+        jpeg_destroy_compress(_cinfo);
+        if (outFile != NULL)
+        {
+            fclose(outFile);
+        }
+        return -1;
+    }
+
+    if ((outFile = fopen(_fileName, "wb")) == NULL)
+    {
+        fprintf(stderr, "can't open %s\n", _fileName);
+        return -2;
+    }
+    // Create a compression object
+    jpeg_create_compress(_cinfo);
+
+    // Setting destination file
+    jpeg_stdio_dest(_cinfo, outFile);
+
+    WebRtc_Word32 ret = 0;
+
+    // Height of image buffer should be  a multiple of 16
+    if (_height % 16 == 0)
+    {
+        ret = Encode(imageBuffer, imageBufferSize);
+    }
+    else
+    {
+         WebRtc_UWord32 height16 = ((_height + 15) - 16) & - 16;
+         height16 = (height16 < _height) ? height16 + 16 : height16;
+
+         // Copy image to an adequate size buffer
+         WebRtc_UWord32 requiredSize = height16 * _width * 3 >> 1;
+         WebRtc_UWord8* origImagePtr = new WebRtc_UWord8[requiredSize];
+         if (origImagePtr == NULL)
+         {
+             return -1;
+         }
+         memset(origImagePtr, 0, requiredSize);
+         memcpy(origImagePtr, imageBuffer, imageBufferSize);
+
+         ret = Encode(origImagePtr, requiredSize);
+
+         // delete allocated buffer
+         delete [] origImagePtr;
+         origImagePtr = NULL;
+    }
+
+
+    fclose(outFile);
+
+    return ret;
+}
+
+WebRtc_Word32
+JpegEncoder::Encode(const WebRtc_UWord8* imageBuffer,
+                    const WebRtc_UWord32 imageBufferSize)
+{
+    // Set parameters for compression
+    _cinfo->in_color_space = JCS_YCbCr;
+    jpeg_set_defaults(_cinfo);
+
+    _cinfo->image_width = _width;
+    _cinfo->image_height = _height;
+    _cinfo->input_components = 3;
+
+    _cinfo->comp_info[0].h_samp_factor = 2;   // Y
+    _cinfo->comp_info[0].v_samp_factor = 2;
+    _cinfo->comp_info[1].h_samp_factor = 1;   // U
+    _cinfo->comp_info[1].v_samp_factor = 1;
+    _cinfo->comp_info[2].h_samp_factor = 1;   // V
+    _cinfo->comp_info[2].v_samp_factor = 1;
+    _cinfo->raw_data_in = TRUE;
+
+    jpeg_start_compress(_cinfo, TRUE);
+
+    JSAMPROW y[16],u[8],v[8];
+    JSAMPARRAY data[3];
+
+    data[0] = y;
+    data[1] = u;
+    data[2] = v;
+
+    WebRtc_UWord32 i, j;
+
+    for (j = 0; j < _height; j += 16)
+    {
+        for (i = 0; i < 16; i++)
+        {
+            y[i] = (JSAMPLE*) imageBuffer + _width * (i + j);
+
+            if (i % 2 == 0)
+            {
+                u[i / 2] = (JSAMPLE*) imageBuffer + _width * _height +
+                            _width / 2 * ((i + j) / 2);
+                v[i / 2] = (JSAMPLE*) imageBuffer + _width * _height +
+                            _width * _height / 4 + _width / 2 * ((i + j) / 2);
+            }
+        }
+            jpeg_write_raw_data(_cinfo, data, 16);
+    }
+
+    jpeg_finish_compress(_cinfo);
+    jpeg_destroy_compress(_cinfo);
+
+    return 0;
+}
+
+
+JpegDecoder::JpegDecoder()
+{
+    _cinfo = new jpeg_decompress_struct;
+}
+
+JpegDecoder::~JpegDecoder()
+{
+    delete _cinfo;
+    _cinfo = NULL;
+}
+
+WebRtc_Word32
+JpegDecoder::Decode(const WebRtc_UWord8* encodedBuffer,
+                    const WebRtc_UWord32 encodedBufferSize,
+                    WebRtc_UWord8*& decodedBuffer,
+                    WebRtc_UWord32& width,
+                    WebRtc_UWord32& height)
+{
+    // Set  error handler
+    myErrorMgr    jerr;
+    _cinfo->err = jpeg_std_error(&jerr.pub);
+    jerr.pub.error_exit = MyErrorExit;
+
+    // Establish the setjmp return context
+    if (setjmp(jerr.setjmp_buffer))
+    {
+        if (_cinfo->is_decompressor)
+        {
+            jpeg_destroy_decompress(_cinfo);
+        }
+        return -1;
+    }
+
+    _cinfo->out_color_space = JCS_YCbCr;
+
+    // Create decompression object
+    jpeg_create_decompress(_cinfo);
+
+    // Specify data source
+    jpegSetSrcBuffer(_cinfo, (JOCTET*) encodedBuffer, encodedBufferSize);
+
+    // Read header data
+    jpeg_read_header(_cinfo, TRUE);
+
+    _cinfo->raw_data_out = TRUE;
+    jpeg_start_decompress(_cinfo);
+
+    // Check header
+    if (_cinfo->num_components == 4)
+    {
+        return -2; // not supported
+    }
+    if (_cinfo->progressive_mode == 1)
+    {
+        return -2; // not supported
+    }
+
+    height = _cinfo->image_height;
+    width = _cinfo->image_width;
+
+    // Making sure width and height are even
+    if (height % 2)
+        height++;
+    if (width % 2)
+         width++;
+
+    WebRtc_UWord32 height16 = ((height + 15) - 16) & - 16;
+    height16 = (height16 < height) ? height16 + 16 : height16;
+
+    // allocate buffer to output
+    if (decodedBuffer != NULL)
+    {
+        delete [] decodedBuffer;
+        decodedBuffer = NULL;
+    }
+    decodedBuffer = new WebRtc_UWord8[width * height16 * 3 >> 1];
+    if (decodedBuffer == NULL)
+    {
+        return -1;
+    }
+
+    JSAMPROW y[16],u[8],v[8];
+    JSAMPARRAY data[3];
+    data[0] = y;
+    data[1] = u;
+    data[2] = v;
+
+    WebRtc_UWord32 hInd, i;
+    WebRtc_UWord32 numScanLines = 16;
+    WebRtc_UWord32 numLinesProcessed = 0;
+    while(_cinfo->output_scanline < _cinfo->output_height)
+    {
+        hInd = _cinfo->output_scanline;
+        for (i = 0; i < numScanLines; i++)
+        {
+            y[i] = decodedBuffer + width * (i + hInd);
+
+            if (i % 2 == 0)
+            {
+                 u[i / 2] = decodedBuffer + width * height +
+                            width / 2 * ((i + hInd) / 2);
+                 v[i / 2] = decodedBuffer + width * height +
+                            width * height / 4 + width / 2 * ((i + hInd) / 2);
+            }
+        }
+        // Processes exactly one iMCU row per call
+        numLinesProcessed = jpeg_read_raw_data(_cinfo, data, numScanLines);
+        // Error in read
+        if (numLinesProcessed == 0)
+        {
+            delete [] decodedBuffer;
+            jpeg_abort((j_common_ptr)_cinfo);
+            return -1;
+        }
+    }
+
+    jpeg_finish_decompress(_cinfo);
+    jpeg_destroy_decompress(_cinfo);
+    return 0;
+}
+
+
+}
diff --git a/common_video/jpeg/main/source/jpeg.gyp b/common_video/jpeg/main/source/jpeg.gyp
new file mode 100644
index 0000000..ad5419e
--- /dev/null
+++ b/common_video/jpeg/main/source/jpeg.gyp
@@ -0,0 +1,98 @@
+# Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+{
+  'includes': [
+    '../../../../common_settings.gypi', # Common settings
+  ],
+  'targets': [
+    {
+      'target_name': 'webrtc_jpeg',
+      'type': '<(library)',
+      'dependencies': [
+        '../../../vplib/main/source/vplib.gyp:webrtc_vplib',
+      ],
+      'include_dirs': [
+        '../interface',
+        '../../../../../../',
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '../interface',
+        ],
+      },
+      'conditions': [
+        ['build_with_chromium==1', {
+          'dependencies': [
+            '../../../../../libjpeg_turbo/libjpeg.gyp:libjpeg',
+          ],
+		  'include_dirs': [
+            '../../../../../libjpeg_turbo',
+          ],
+		  'direct_dependent_settings': {
+			'include_dirs': [
+			  '../../../../../libjpeg_turbo', 
+			],
+		  },
+        },{
+          'dependencies': [
+            '../../../../../third_party/libjpeg_turbo/libjpeg.gyp:libjpeg',
+          ],
+          'include_dirs': [
+            '../../../../third_party/libjpeg_turbo',
+          ],
+          'direct_dependent_settings': {
+			'include_dirs': [
+			  '../../../../third_party/libjpeg_turbo', 
+			],
+		  },
+        }],
+      ],
+      'sources': [
+        # interfaces
+        '../interface/jpeg.h',
+       
+        # headers
+        'data_manager.h',
+
+        # sources
+        'jpeg.cc',
+        'data_manager.cc',
+      ],
+    },
+    {
+      'target_name': 'jpeg_test',
+      'type': 'executable',
+      'dependencies': [
+         'webrtc_jpeg',
+      ],
+      'include_dirs': [
+         '../interface',
+         '../../../vplib/main/interface',
+         '../source',
+      ],
+      'sources': [
+
+        # headers
+        '../test/test_buffer.h',
+        
+        
+        # sources
+        '../test/test_buffer.cc',
+        '../test/test_jpeg.cc',
+
+      ], # source
+    },
+  ],
+}
+
+# Local Variables:
+# tab-width:2
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/common_video/jpeg/main/test/test_buffer.cc b/common_video/jpeg/main/test/test_buffer.cc
new file mode 100644
index 0000000..98468f2
--- /dev/null
+++ b/common_video/jpeg/main/test/test_buffer.cc
@@ -0,0 +1,161 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// system includes
+#include <assert.h>
+#include <string.h>     // memcpy
+
+#include "test_buffer.h"
+#include "vplib.h"
+
+TestBuffer::TestBuffer():
+_buffer(0),
+_bufferSize(0),
+_bufferLength(0),
+_width(0),
+_height(0)
+{
+    //
+}
+
+TestBuffer::~TestBuffer()
+{
+    _bufferLength = 0;
+    _bufferSize = 0;
+    if(_buffer)
+    {
+        delete [] _buffer;
+        _buffer = 0;
+    }
+}
+
+TestBuffer::TestBuffer(const TestBuffer& rhs)
+:
+_bufferLength(rhs._bufferLength),
+_bufferSize(rhs._bufferSize),
+_height(rhs._height),
+_width(rhs._width),
+_buffer(0)
+{
+    // make sure that our buffer is big enough
+    _buffer = new WebRtc_UWord8[_bufferSize];
+    // only copy required length 
+    memcpy(_buffer, rhs._buffer, _bufferLength);
+}
+
+WebRtc_UWord32
+TestBuffer::GetWidth() const
+{
+    return _width;
+}
+
+WebRtc_UWord32
+TestBuffer::GetHeight() const
+{
+    return _height;
+}
+
+void            
+TestBuffer::SetWidth(WebRtc_UWord32 width)
+{
+    _width = width;
+}
+
+void            
+TestBuffer::SetHeight(WebRtc_UWord32 height)
+{
+    _height = height;
+}
+
+void
+TestBuffer::Free()
+{
+    _bufferLength = 0;
+    _bufferSize = 0;
+    _height = 0;
+    _width = 0;
+    if(_buffer)
+    {
+        delete [] _buffer;
+        _buffer = 0;
+    }
+}
+
+void
+TestBuffer::VerifyAndAllocate(WebRtc_UWord32 minimumSize)
+{
+    if(minimumSize > _bufferSize)
+    {
+        // make sure that our buffer is big enough
+        WebRtc_UWord8 * newBufferBuffer = new WebRtc_UWord8[minimumSize];
+        if(_buffer)
+        {
+            // copy the old data
+            memcpy(newBufferBuffer, _buffer, _bufferSize);
+            delete [] _buffer;
+        }
+        _buffer = newBufferBuffer;
+        _bufferSize = minimumSize;
+    }
+}
+
+void
+TestBuffer::UpdateLength(WebRtc_UWord32 newLength)
+{
+    assert(newLength <= _bufferSize);
+    _bufferLength = newLength;
+}
+
+void
+TestBuffer::CopyBuffer(WebRtc_UWord32 length, const WebRtc_UWord8* buffer)
+{
+    assert(length <= _bufferSize);
+     memcpy(_buffer, buffer, length);
+    _bufferLength = length;
+}
+
+void
+TestBuffer::CopyBuffer(TestBuffer& fromVideoBuffer)
+{
+    assert(fromVideoBuffer.GetLength() <= _bufferSize);
+    assert(fromVideoBuffer.GetSize() <= _bufferSize);
+    _bufferLength = fromVideoBuffer.GetLength();
+    _height = fromVideoBuffer.GetHeight();
+    _width = fromVideoBuffer.GetWidth();
+    memcpy(_buffer, fromVideoBuffer.GetBuffer(), fromVideoBuffer.GetLength());
+}
+
+void
+TestBuffer::Set(WebRtc_UWord8* tempBuffer,WebRtc_UWord32 tempSize, WebRtc_UWord32 tempLength)
+{
+    _buffer = tempBuffer;
+    _bufferSize = tempSize;
+    _bufferLength = tempLength;
+
+}
+
+WebRtc_UWord8*
+TestBuffer::GetBuffer() const
+{
+  return _buffer;
+}
+
+WebRtc_UWord32
+TestBuffer::GetSize() const
+{
+    return _bufferSize;
+}
+
+WebRtc_UWord32
+TestBuffer::GetLength() const
+{
+    return _bufferLength;
+}
+
diff --git a/common_video/jpeg/main/test/test_buffer.h b/common_video/jpeg/main/test/test_buffer.h
new file mode 100644
index 0000000..757fae3
--- /dev/null
+++ b/common_video/jpeg/main/test/test_buffer.h
@@ -0,0 +1,77 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+
+#ifndef WEBRTC_COMMON_VIDEO_JPEG_TEST_BUFFER_H
+#define WEBRTC_COMMON_VIDEO_JPEG_TEST_BUFFER_H
+
+#include "typedefs.h"
+
+class TestBuffer
+{
+public:
+    TestBuffer();
+
+    virtual ~TestBuffer();
+
+    TestBuffer(const TestBuffer& rhs);
+
+    /**
+     * Verifies that current allocated buffer size is larger than or equal to the input size.
+    * If the current buffer size is smaller, a new allocation is made and the old buffer data is copied to the new buffer.
+    */
+    void VerifyAndAllocate(WebRtc_UWord32 minimumSize);
+
+    void UpdateLength(WebRtc_UWord32 newLength);
+
+
+
+    void CopyBuffer(WebRtc_UWord32 length, const WebRtc_UWord8* fromBuffer);
+
+    void CopyBuffer(TestBuffer& fromBuffer);
+
+    void Free();    // Deletes frame buffer and resets members to zero
+
+    /**
+     *   Gets pointer to frame buffer
+     */
+    WebRtc_UWord8*    GetBuffer() const;
+
+    /**
+     *   Gets allocated buffer size
+     */
+    WebRtc_UWord32    GetSize() const;
+
+    /**
+     *   Gets length of frame
+     */
+    WebRtc_UWord32    GetLength() const;
+
+
+    WebRtc_UWord32    GetWidth() const;
+    WebRtc_UWord32    GetHeight() const;
+
+    void            SetWidth(WebRtc_UWord32 width);
+    void            SetHeight(WebRtc_UWord32 height);
+
+private:
+  //  TestBuffer& operator=(const TestBuffer& inBuffer);
+
+private:
+    void Set(WebRtc_UWord8* buffer,WebRtc_UWord32 size,WebRtc_UWord32 length);
+
+    WebRtc_UWord8*      _buffer;          // Pointer to frame buffer
+    WebRtc_UWord32      _bufferSize;      // Allocated buffer size
+    WebRtc_UWord32      _bufferLength;    // Length (in bytes) of frame
+    WebRtc_UWord32      _width;
+    WebRtc_UWord32      _height;
+};
+
+#endif
diff --git a/common_video/jpeg/main/test/test_jpeg.cc b/common_video/jpeg/main/test/test_jpeg.cc
new file mode 100644
index 0000000..a947dbd
--- /dev/null
+++ b/common_video/jpeg/main/test/test_jpeg.cc
@@ -0,0 +1,141 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * test_jpeg.cc
+ */
+
+#include <cassert>
+#include <iostream>
+#include <cmath>
+#include <string>
+#include <stdio.h>
+
+
+#include "test_buffer.h"
+#include "jpeg.h"
+
+using namespace webrtc;
+
+#define PRINT_LINE std::cout << "-------------------------------" << std::endl;
+
+int
+main(int argc, char **argv)
+{
+    if (argc < 1)
+    {
+        return -1;
+    }
+    std::string fileName = argv[1];
+    const char* fileNameDec = "TestJpegDec.yuv";
+    const char* fileNameEnc = "TestJpegEnc.jpg";
+
+    std::string str;
+    std::cout << "---------------------" << std::endl;
+    std::cout << "----- Test JPEG -----" << std::endl;
+    std::cout << "---------------------" << std::endl;
+    std::cout << "  "  << std::endl;
+
+
+    JpegDecoder* JpgDecPtr = new JpegDecoder( );
+
+    // Open input file
+    FILE* openFile = fopen(fileName.c_str(), "rb");
+    assert(openFile != NULL);
+
+    // Get file length
+    fseek(openFile, 0, SEEK_END);
+    int length = ftell(openFile);
+    fseek(openFile, 0, SEEK_SET);
+
+    // Read input file to buffer
+    TestBuffer encodedBuffer;
+    encodedBuffer.VerifyAndAllocate(length);
+    encodedBuffer.UpdateLength(length);
+    fread(encodedBuffer.GetBuffer(), 1, length, openFile);
+    fclose(openFile);
+
+    // ------------------
+    // Decode
+    // ------------------
+
+    TestBuffer imageBuffer;
+    WebRtc_UWord32 width = 0;
+    WebRtc_UWord32 height = 0;
+    WebRtc_UWord8* tmp = NULL;
+    int error = JpgDecPtr->Decode(encodedBuffer.GetBuffer(),
+                                  encodedBuffer.GetSize(), tmp, width, height);
+
+    std::cout << error << " = Decode(" << fileName.c_str() << ", (" << width <<
+        "x" << height << "))" << std::endl;
+    PRINT_LINE;
+
+    if (error == 0)
+    {
+        int imageBufferSize = width*height*3/2;
+        //update buffer info
+        imageBuffer.VerifyAndAllocate( imageBufferSize);
+        imageBuffer.CopyBuffer(imageBufferSize, tmp);
+        delete [] tmp;
+        // Save decoded image to file
+        FILE* saveFile = fopen(fileNameDec, "wb");
+        fwrite(imageBuffer.GetBuffer(), 1, imageBuffer.GetLength(), saveFile);
+        fclose(saveFile);
+
+        // ------------------
+        // Encode
+        // ------------------
+
+        JpegEncoder* JpegEncoderPtr = new JpegEncoder();
+
+        // Test invalid inputs
+
+        // Test buffer
+        TestBuffer empty;
+
+        int error = JpegEncoderPtr->SetFileName(0);
+        assert(error == -1);
+        error = JpegEncoderPtr->Encode(empty.GetBuffer(), empty.GetSize(),
+                                       164, 164);
+        assert(error == -1);
+        error = JpegEncoderPtr->Encode(empty.GetBuffer(), empty.GetSize(),
+                                       0, height);
+        assert(error == -1);
+        error = JpegEncoderPtr->Encode(empty.GetBuffer(), empty.GetSize(),
+                                       width, 0);
+        assert(error == -1);
+
+        error = JpegEncoderPtr->SetFileName(fileNameEnc);
+        assert(error == 0);
+
+        // Actual Encode
+        error = JpegEncoderPtr->Encode(imageBuffer.GetBuffer(),
+                                       imageBuffer.GetSize(), width, height);
+        assert(error == 0);
+
+        std::cout << error << " = Encode(" << fileNameDec << ")" << std::endl;
+
+        PRINT_LINE;
+
+        delete JpegEncoderPtr;
+    }
+
+    imageBuffer.Free();
+    encodedBuffer.Free();
+    delete JpgDecPtr;
+
+    std::cout << "Verify that the encoded and decoded images look correct."
+        << std::endl;
+    std::cout << "Press enter to quit test...";
+    std::getline(std::cin, str);
+
+    return 0;
+}
+
diff --git a/common_video/vplib/main/interface/interpolator.h b/common_video/vplib/main/interface/interpolator.h
new file mode 100644
index 0000000..70ec4fa
--- /dev/null
+++ b/common_video/vplib/main/interface/interpolator.h
@@ -0,0 +1,76 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * interpolator.h
+ * Interface to the WebRTC's interpolation functionality
+ */
+
+#ifndef WEBRTC_COMMON_VIDEO_INTERFACE_INTERPOLATOR_H
+#define WEBRTC_COMMON_VIDEO_INTERFACE_INTERPOLATOR_H
+
+#include "typedefs.h"
+#include "vplib.h"
+
+namespace webrtc
+{
+
+// supported interpolation types
+enum interpolatorType
+{
+    kBilinear
+};
+
+
+class interpolator
+{
+public:
+    interpolator();
+    ~interpolator();
+
+    // Set interpolation properties:
+    //
+    // Return value     : 0 if OK,
+    //                  : -1 - parameter error
+    //                  : -2 - general error
+    WebRtc_Word32 Set(WebRtc_UWord32 srcWidth, WebRtc_UWord32 srcHeight,
+                      WebRtc_UWord32 dstWidth, WebRtc_UWord32 dstHeight,
+                      VideoType srcVideoType, VideoType dstVideoType,
+                      interpolatorType type);
+
+    // Interpolate frame
+    //
+    // Return value     : Height of interpolated frame if OK,
+    //                  : -1 - parameter error
+    //                  : -2 - general error
+    WebRtc_Word32 Interpolate(const WebRtc_UWord8* srcFrame,
+                              WebRtc_UWord8*& dstFrame);
+
+private:
+
+    // Extract computation method given actual type
+    WebRtc_Word32 Method(interpolatorType type);
+
+    // Determine if the VideoTypes are currently supported
+    WebRtc_Word32 SupportedVideoType(VideoType srcVideoType,
+                                     VideoType dstVideoType);
+
+    interpolatorType        _method;
+    WebRtc_UWord32          _srcWidth;
+    WebRtc_UWord32          _srcHeight;
+    WebRtc_UWord32          _dstWidth;
+    WebRtc_UWord32          _dstHeight;
+};
+
+
+}  // namespace webrtc
+
+
+#endif  // WEBRTC_COMMON_VIDEO_INTERFACE_INTERPOLATOR_H
diff --git a/common_video/vplib/main/interface/vplib.h b/common_video/vplib/main/interface/vplib.h
new file mode 100644
index 0000000..79f96be
--- /dev/null
+++ b/common_video/vplib/main/interface/vplib.h
@@ -0,0 +1,356 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+
+#ifndef WEBRTC_COMMON_VIDEO_INTERFACE_VPLIB_H
+#define WEBRTC_COMMON_VIDEO_INTERFACE_VPLIB_H
+
+
+#include "typedefs.h"
+
+namespace webrtc
+{
+
+// Supported video types
+enum VideoType
+{
+    kUnknown,
+    kI420,
+    kIYUV,
+    kRGB24,
+    kARGB,
+    kARGB4444,
+    kRGB565,
+    kARGB1555,
+    kYUY2,
+    kYV12,
+    kUYVY,
+    kMJPG,
+    kNV21,
+    kNV12,
+    kARGBMac,
+    kRGBAMac,
+
+    kNumberOfVideoTypes
+};
+
+
+// Supported rotation
+enum VideoRotationMode
+{
+    kRotateNone = 0,
+    kRotateClockwise = 90,
+    kRotateAntiClockwise = -90,
+    kRotate180 = 180,
+};
+
+
+    // Calculate the required buffer size
+    // Input
+    //    - type - The type of the designated video frame
+    //    - width - frame width in pixels
+    //    - height - frame height in pixels
+    // Output
+    //    - The required size in bytes to accommodate the specified video frame
+    //
+    WebRtc_UWord32 CalcBufferSize(VideoType type, WebRtc_UWord32 width, WebRtc_UWord32 height);
+
+
+    // Calculate the required buffer size when converting from one type to another
+    // Input
+    //   - incomingVideoType - The type of the existing video frame
+    //   - convertedVideoType - width of the designated video frame
+    //   - length - length in bytes of the data
+    // Output
+    //   - The required size in bytes to accommodate the specified converted video frame
+    //
+    WebRtc_UWord32 CalcBufferSize(VideoType incomingVideoType, VideoType convertedVideoType,
+                                  WebRtc_UWord32 length);
+
+    //
+    // Convert To/From I420
+    //
+    // The following 2 functions convert an image to/from a I420 type to/from a specified
+    // format.
+    //
+    // Input:
+    //    - incomingVideoType  : Type of input video
+    //    - incomingBuffer     : Pointer to an input image.
+    //    - width              : Image width in pixels.
+    //    - height             : Image height in pixels.
+    //    - outgoingBuffer     : Pointer to converted image.
+    //    - interlaced         : Flag indicating if interlaced I420 output
+    //    - rotate             : Rotation mode of output image
+    // Return value            : Size of converted image if OK, otherwise, the following error
+    //                           codes:
+    //                           -1 : Parameter error
+    //                           -2 : Unsupported command (parameter request)
+    //
+    // Note: the following functions includes the most common usage cases; for a more general
+    // usage, refer to explicit function
+    WebRtc_Word32 ConvertToI420(VideoType incomingVideoType,
+                                const WebRtc_UWord8* incomingBuffer,
+                                WebRtc_UWord32 width,
+                                WebRtc_UWord32 height,
+                                WebRtc_UWord8* outgoingBuffer,
+                                bool interlaced = false ,
+                                VideoRotationMode rotate  = kRotateNone
+                                );
+
+    WebRtc_Word32 ConvertFromI420(VideoType outgoingVideoType,
+                                  const WebRtc_UWord8* incomingBuffer,
+                                  WebRtc_UWord32 width,
+                                  WebRtc_UWord32 height,
+                                  WebRtc_UWord8* outgoingBuffer,
+                                  bool interlaced = false ,
+                                  VideoRotationMode rotate = kRotateNone
+                                  );
+
+    // Designated Convert Functions
+    // The following list describes the designated conversion function which are called by the
+    // 2 prior general conversion function.
+    // Input and output descriptions match the above descriptions, and are therefore omitted.
+    WebRtc_Word32 ConvertI420ToRGB24(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                     WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertI420ToARGB(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertI420ToARGB4444(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                        WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                        WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertI420ToRGB565(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                      WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertI420ToRGB565Android(const WebRtc_UWord8* inFrame,
+                                             WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                                             WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertI420ToARGB1555(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                        WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                        WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertI420ToARGBMac(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                       WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                       WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertI420ToRGBAMac(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                       WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                       WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertI420ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_UWord32 strideOut = 0);
+    WebRtc_Word32 ConvertI420ToUYVY(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_UWord32 strideOut = 0);
+    WebRtc_Word32 ConvertI420ToYUY2(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_UWord32 strideOut = 0);
+    WebRtc_Word32 ConvertI420ToYV12(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertYUY2ToI420interlaced(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                                              WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                                              WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight);
+    WebRtc_Word32 ConvertYV12ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 width,
+                                    WebRtc_UWord32 height, WebRtc_UWord8* outFrame);
+    WebRtc_Word32 ConvertRGB24ToARGB(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                     WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                     WebRtc_UWord32 strideOut);
+    WebRtc_Word32 ConvertRGB24ToI420(WebRtc_Word32 width, WebRtc_Word32 height,
+                                     const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame);
+    WebRtc_Word32 ConvertRGB565ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 width,
+                                      WebRtc_UWord32 height, WebRtc_UWord8* outFrame);
+    WebRtc_Word32 ConvertARGBMacToI420(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame);
+    WebRtc_Word32 ConvertUYVYToI420(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame);
+
+    // pad cut and convert
+    WebRtc_Word32 ConvertYUY2ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                                    WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight);
+    WebRtc_Word32 ConvertUYVYToI420interlaced(const WebRtc_UWord8* inFrame,
+                                              WebRtc_UWord32 inWidth, WebRtc_UWord32 inHeight,
+                                              WebRtc_UWord8* outFrame, WebRtc_UWord32 outWidth,
+                                              WebRtc_UWord32 outHeight);
+    WebRtc_Word32 ConvertRGB24ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                                     WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                                     WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight);
+    WebRtc_Word32 ConvertI420ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                                    WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight);
+
+    //NV12 Conversion/Rotation
+    WebRtc_Word32 ConvertNV12ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV12ToI420AndRotate180(const WebRtc_UWord8* inFrame,
+                                                WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                                                WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV12ToI420AndRotateAntiClockwise(const WebRtc_UWord8* inFrame,
+                                                          WebRtc_UWord8* outFrame,
+                                                          WebRtc_UWord32 width,
+                                                          WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV12ToI420AndRotateClockwise(const WebRtc_UWord8* inFrame,
+                                                      WebRtc_UWord8* outFrame,
+                                                      WebRtc_UWord32 width,
+                                                      WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV12ToRGB565(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                      WebRtc_UWord32 width, WebRtc_UWord32 height);
+
+    //NV21 Conversion/Rotation
+    WebRtc_Word32 ConvertNV21ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV21ToI420AndRotate180(const WebRtc_UWord8* inFrame,
+                                                WebRtc_UWord8* outFrame,
+                                                WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV21ToI420AndRotateAntiClockwise(const WebRtc_UWord8* inFrame,
+                                                          WebRtc_UWord8* outFrame,
+                                                          WebRtc_UWord32 width,
+                                                          WebRtc_UWord32 height);
+    WebRtc_Word32 ConvertNV21ToI420AndRotateClockwise(const WebRtc_UWord8* inFrame,
+                                                      WebRtc_UWord8* outFrame,
+                                                      WebRtc_UWord32 width,
+                                                      WebRtc_UWord32 height);
+
+    //IPhone
+    WebRtc_Word32 ConvertI420ToRGBAIPhone(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                          WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                          WebRtc_UWord32 strideOut);
+
+    // I420 Cut and Pad - make a center cut
+    WebRtc_Word32 CutI420Frame(WebRtc_UWord8* frame, WebRtc_UWord32 fromWidth,
+                               WebRtc_UWord32 fromHeight, WebRtc_UWord32 toWidth,
+                               WebRtc_UWord32 toHeight);
+
+    // Pad an I420 frame
+    // Input:
+    //    - inBuffer       : Pointer to the input image component to be padded.
+    //    - outBuffer      : Pointer to the output padded image component.
+    //    - fromWidth      : Width in pixels of the inBuffer component.
+    //    - fromHeight     : Height in pixels of the inBuffer component.
+    //    - toWidth        : Width in pixels of the outBuffer component.
+    //    - toHeight       : Height in pixels of the outBuffer component.
+    // Return Value:
+    //      - Length of the output component.
+    WebRtc_Word32 PadI420Frame(const WebRtc_UWord8* inBuffer, WebRtc_UWord8* outBuffer,
+                               WebRtc_UWord32 fromWidth, WebRtc_UWord32 fromHeight,
+                               WebRtc_UWord32 toWidth, WebRtc_UWord32 toHeight);
+    WebRtc_Word32 PadI420BottomRows(WebRtc_UWord8* buffer, WebRtc_UWord32 size,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                    WebRtc_Word32 nrRows, WebRtc_UWord32& newLength);
+
+    // I420 Scale
+    // Scale an I420 frame:Half frame, quarter frame
+    // Input:
+    //    - inFrame     : Pointer to the image component to be scaled
+    //    - width          : Width in pixels of the output frame.
+    //    - height         : Height in pixels of the out frame.
+    // Return Value:
+    //      - Length of the output component.
+    WebRtc_Word32 ScaleI420FrameQuarter(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                        WebRtc_UWord8* inFrame);
+    WebRtc_Word32 ScaleI420DownHalfFrame(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                         WebRtc_UWord8* inFrame);
+    WebRtc_Word32 ScaleI420UpHalfFrame(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                       WebRtc_UWord8* inFrame);
+
+    // Scales up an I420-frame to twice its width and height. Interpolates by using mean value
+    // of neighboring pixels.
+    // The following two function allow up-scaling by either twice or 3/2 of the original
+    // the width and height
+    // Input:
+    //    - width          : Width of input frame in pixels.
+    //    - height         : Height of input frame in pixels.
+    //    - buffer         : Reference to a buffer containing the frame.
+    //    - size           :Size of allocated buffer
+    //    - scaledWidth    : Reference to the width of scaled frame in pixels.
+    //    - scaledHeight   : Reference to the height of scaled frame in pixels.
+    // Return value:
+    //    - (length)       : Length of scaled frame.
+    //    - (-1)           : Error.
+    WebRtc_Word32 ScaleI420Up2(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                               WebRtc_UWord8*& buffer, WebRtc_UWord32 size,
+                               WebRtc_UWord32 &scaledWidth, WebRtc_UWord32 &scaledHeight);
+    WebRtc_Word32 ScaleI420Up3_2(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                 WebRtc_UWord8*& buffer, WebRtc_UWord32 size,
+                                 WebRtc_UWord32 &scaledWidth, WebRtc_UWord32 &scaledHeight);
+
+    // Scales down an I420-frame to one third its width and height.
+    // Input:
+    //    - width          : Width of frame in pixels.
+    //    - height         : Height of frame in pixels.
+    //    - videoBuffer    : Reference to a buffer containing the frame.
+    //    - scaledWidth    : Width of scaled frame in pixels.
+    //    - scaledHeight   : Height of scaled frame in pixels.
+    // Return value:
+    //    - (length)       : Length of scaled frame.
+    //    - (-1)           : Error.
+    WebRtc_Word32 ScaleI420Down1_3(WebRtc_UWord32 width, WebRtc_UWord32 height,
+                                   WebRtc_UWord8*& buffer, WebRtc_UWord32 size,
+                                   WebRtc_UWord32 &scaledWidth, WebRtc_UWord32 &scaledHeight);
+
+    // Convert From I420/YV12 to I420 and Rotate clockwise
+    // Input:
+    //    - srcBuffer    : Reference to a buffer containing the source frame.
+    //    - srcWidth     : Width of source frame in pixels.
+    //    - srcHeight    : Height of source frame in pixels.
+    //    - dstBuffer    : Reference to a buffer containing the destination frame.
+    //    - dstWidth     : Width of destination frame in pixels.
+    //    - dstHeight    : Height of destination frame in pixels.
+    //    - colorSpaceIn : Input color space
+    // Return value:
+    //    - (length)       : Length of scaled frame.
+    //    - (-1)           : Error.
+    WebRtc_Word32 ConvertToI420AndRotateClockwise(const WebRtc_UWord8* srcBuffer,
+                                                  WebRtc_UWord32 srcWidth,
+                                                  WebRtc_UWord32 srcHeight,
+                                                  WebRtc_UWord8* dstBuffer,
+                                                  WebRtc_UWord32 dstWidth,
+                                                  WebRtc_UWord32 dstHeight,
+                                                  VideoType colorSpaceIn);
+
+    // Convert From I420/YV12 to I420 and Rotate anti clockwise
+    // Inputs/outputs as the above function
+    WebRtc_Word32 ConvertToI420AndRotateAntiClockwise(const WebRtc_UWord8* srcBuffer,
+                                                      WebRtc_UWord32 srcWidth,
+                                                      WebRtc_UWord32 srcHeight,
+                                                      WebRtc_UWord8* dstBuffer,
+                                                      WebRtc_UWord32 dstWidth,
+                                                      WebRtc_UWord32 dstHeight,
+                                                      VideoType colorSpaceIn);
+
+    // Mirror functions
+    // The following 2 functions perform mirroring on a given image (LeftRight/UpDown)
+    // Input:
+    //    - width       : Image width in pixels.
+    //    - height      : Image height in pixels.
+    //    - inFrame     : Reference to input image.
+    //    - outFrame    : Reference to converted image.
+    // Return value: 0 if OK, < 0 otherwise.
+    WebRtc_Word32 MirrorI420LeftRight(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                      WebRtc_UWord32 width, WebRtc_UWord32 height);
+    WebRtc_Word32 MirrorI420UpDown(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                   WebRtc_UWord32 width, WebRtc_UWord32 height);
+
+    // Mirror functions - Don't work in place (srcBuffer == dstBuffer),
+    // and are therefore faster. Also combine mirroring with conversion to speed things up.
+    // Input:
+    //    - srcBuffer       : Pointer to source image.
+    //    - dstBuffer       : Pointer to destination image.
+    //    - srcWidth        : Width of input buffer.
+    //    - srcHeight       : Height of input buffer.
+    //    - colorSpaceIn    : Color space to convert from, I420 if no conversion should be done
+    //    - dstBuffer       : Pointer to converted/rotated image.
+    // Return value:      0 if OK, < 0 otherwise.
+    WebRtc_Word32 ConvertToI420AndMirrorUpDown(const WebRtc_UWord8* srcBuffer,
+                                               WebRtc_UWord8* dstBuffer,
+                                               WebRtc_UWord32 srcWidth,
+                                               WebRtc_UWord32 srcHeight,
+                                               VideoType colorSpaceIn = kI420);
+
+}
+
+#endif
diff --git a/common_video/vplib/main/source/conversion_tables.h b/common_video/vplib/main/source/conversion_tables.h
new file mode 100644
index 0000000..4f3b1ec
--- /dev/null
+++ b/common_video/vplib/main/source/conversion_tables.h
@@ -0,0 +1,182 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/**************************************************************
+*  conversion_tables.h
+*
+*    Pre-compiled definitions of the conversion equations: YUV -> RGB.
+*    
+***************************************************************/
+
+#ifndef WEBRTC_COMMON_VIDEO_VPLIB_CONVERSION_TABLES
+#define WEBRTC_COMMON_VIDEO_VPLIB_CONVERSION_TABLES
+
+#include "typedefs.h"
+namespace webrtc
+{
+/*********************************************************************************************
+* YUV TO RGB approximation
+*
+*         R = clip( (298 * (Y - 16)                   + 409 * (V - 128) + 128 ) >> 8 )
+*         G = clip( (298 * (Y - 16) - 100 * (U - 128) - 208 * (V - 128) + 128 ) >> 8 )  
+*         B = clip( (298 * (Y - 16) + 516 * (U - 128)                   + 128 ) >> 8 )      
+**********************************************************************************************/
+
+    #define Yc(i)  static_cast<WebRtc_Word32> ( 298  * ( i - 16 ))     // Y contribution
+    #define Ucg(i) static_cast<WebRtc_Word32> ( -100 * ( i - 128 ))    // U contribution to G
+    #define Ucb(i) static_cast<WebRtc_Word32> ( 516  * ( i - 128 ))    // U contribution to B
+    #define Vcr(i) static_cast<WebRtc_Word32> ( 409  * ( i - 128 ))    // V contribution to R
+    #define Vcg(i) static_cast<WebRtc_Word32> ( -208 * ( i - 128 ))    // V contribution to G
+
+    static const WebRtc_Word32 mapYc[256] = {
+        Yc(0),Yc(1),Yc(2),Yc(3),Yc(4),Yc(5),Yc(6),Yc(7),Yc(8),Yc(9),
+        Yc(10),Yc(11),Yc(12),Yc(13),Yc(14),Yc(15),Yc(16),Yc(17),Yc(18),Yc(19),
+        Yc(20),Yc(21),Yc(22),Yc(23),Yc(24),Yc(25),Yc(26),Yc(27),Yc(28),Yc(29),
+        Yc(30),Yc(31),Yc(32),Yc(33),Yc(34),Yc(35),Yc(36),Yc(37),Yc(38),Yc(39),
+        Yc(40),Yc(41),Yc(42),Yc(43),Yc(44),Yc(45),Yc(46),Yc(47),Yc(48),Yc(49),
+        Yc(50),Yc(51),Yc(52),Yc(53),Yc(54),Yc(55),Yc(56),Yc(57),Yc(58),Yc(59),
+        Yc(60),Yc(61),Yc(62),Yc(63),Yc(64),Yc(65),Yc(66),Yc(67),Yc(68),Yc(69),
+        Yc(70),Yc(71),Yc(72),Yc(73),Yc(74),Yc(75),Yc(76),Yc(77),Yc(78),Yc(79),
+        Yc(80),Yc(81),Yc(82),Yc(83),Yc(84),Yc(85),Yc(86),Yc(87),Yc(88),Yc(89),
+        Yc(90),Yc(91),Yc(92),Yc(93),Yc(94),Yc(95),Yc(96),Yc(97),Yc(98),Yc(99),
+        Yc(100),Yc(101),Yc(102),Yc(103),Yc(104),Yc(105),Yc(106),Yc(107),Yc(108),Yc(109),
+        Yc(110),Yc(111),Yc(112),Yc(113),Yc(114),Yc(115),Yc(116),Yc(117),Yc(118),Yc(119),
+        Yc(120),Yc(121),Yc(122),Yc(123),Yc(124),Yc(125),Yc(126),Yc(127),Yc(128),Yc(129),
+        Yc(130),Yc(131),Yc(132),Yc(133),Yc(134),Yc(135),Yc(136),Yc(137),Yc(138),Yc(139),
+        Yc(140),Yc(141),Yc(142),Yc(143),Yc(144),Yc(145),Yc(146),Yc(147),Yc(148),Yc(149),
+        Yc(150),Yc(151),Yc(152),Yc(153),Yc(154),Yc(155),Yc(156),Yc(157),Yc(158),Yc(159),
+        Yc(160),Yc(161),Yc(162),Yc(163),Yc(164),Yc(165),Yc(166),Yc(167),Yc(168),Yc(169),
+        Yc(170),Yc(171),Yc(172),Yc(173),Yc(174),Yc(175),Yc(176),Yc(177),Yc(178),Yc(179),
+        Yc(180),Yc(181),Yc(182),Yc(183),Yc(184),Yc(185),Yc(186),Yc(187),Yc(188),Yc(189),
+        Yc(190),Yc(191),Yc(192),Yc(193),Yc(194),Yc(195),Yc(196),Yc(197),Yc(198),Yc(199),
+        Yc(200),Yc(201),Yc(202),Yc(203),Yc(204),Yc(205),Yc(206),Yc(207),Yc(208),Yc(209),
+        Yc(210),Yc(211),Yc(212),Yc(213),Yc(214),Yc(215),Yc(216),Yc(217),Yc(218),Yc(219),
+        Yc(220),Yc(221),Yc(222),Yc(223),Yc(224),Yc(225),Yc(226),Yc(227),Yc(228),Yc(229),
+        Yc(230),Yc(231),Yc(232),Yc(233),Yc(234),Yc(235),Yc(236),Yc(237),Yc(238),Yc(239),
+        Yc(240),Yc(241),Yc(242),Yc(243),Yc(244),Yc(245),Yc(246),Yc(247),Yc(248),Yc(249),
+        Yc(250),Yc(251),Yc(252),Yc(253),Yc(254),Yc(255)};
+
+   static const WebRtc_Word32 mapUcg[256] = {
+        Ucg(0),Ucg(1),Ucg(2),Ucg(3),Ucg(4),Ucg(5),Ucg(6),Ucg(7),Ucg(8),Ucg(9),
+        Ucg(10),Ucg(11),Ucg(12),Ucg(13),Ucg(14),Ucg(15),Ucg(16),Ucg(17),Ucg(18),Ucg(19),
+        Ucg(20),Ucg(21),Ucg(22),Ucg(23),Ucg(24),Ucg(25),Ucg(26),Ucg(27),Ucg(28),Ucg(29),
+        Ucg(30),Ucg(31),Ucg(32),Ucg(33),Ucg(34),Ucg(35),Ucg(36),Ucg(37),Ucg(38),Ucg(39),
+        Ucg(40),Ucg(41),Ucg(42),Ucg(43),Ucg(44),Ucg(45),Ucg(46),Ucg(47),Ucg(48),Ucg(49),
+        Ucg(50),Ucg(51),Ucg(52),Ucg(53),Ucg(54),Ucg(55),Ucg(56),Ucg(57),Ucg(58),Ucg(59),
+        Ucg(60),Ucg(61),Ucg(62),Ucg(63),Ucg(64),Ucg(65),Ucg(66),Ucg(67),Ucg(68),Ucg(69),
+        Ucg(70),Ucg(71),Ucg(72),Ucg(73),Ucg(74),Ucg(75),Ucg(76),Ucg(77),Ucg(78),Ucg(79),
+        Ucg(80),Ucg(81),Ucg(82),Ucg(83),Ucg(84),Ucg(85),Ucg(86),Ucg(87),Ucg(88),Ucg(89),
+        Ucg(90),Ucg(91),Ucg(92),Ucg(93),Ucg(94),Ucg(95),Ucg(96),Ucg(97),Ucg(98),Ucg(99),
+        Ucg(100),Ucg(101),Ucg(102),Ucg(103),Ucg(104),Ucg(105),Ucg(106),Ucg(107),Ucg(108),Ucg(109),
+        Ucg(110),Ucg(111),Ucg(112),Ucg(113),Ucg(114),Ucg(115),Ucg(116),Ucg(117),Ucg(118),Ucg(119),
+        Ucg(120),Ucg(121),Ucg(122),Ucg(123),Ucg(124),Ucg(125),Ucg(126),Ucg(127),Ucg(128),Ucg(129),
+        Ucg(130),Ucg(131),Ucg(132),Ucg(133),Ucg(134),Ucg(135),Ucg(136),Ucg(137),Ucg(138),Ucg(139),
+        Ucg(140),Ucg(141),Ucg(142),Ucg(143),Ucg(144),Ucg(145),Ucg(146),Ucg(147),Ucg(148),Ucg(149),
+        Ucg(150),Ucg(151),Ucg(152),Ucg(153),Ucg(154),Ucg(155),Ucg(156),Ucg(157),Ucg(158),Ucg(159),
+        Ucg(160),Ucg(161),Ucg(162),Ucg(163),Ucg(164),Ucg(165),Ucg(166),Ucg(167),Ucg(168),Ucg(169),
+        Ucg(170),Ucg(171),Ucg(172),Ucg(173),Ucg(174),Ucg(175),Ucg(176),Ucg(177),Ucg(178),Ucg(179),
+        Ucg(180),Ucg(181),Ucg(182),Ucg(183),Ucg(184),Ucg(185),Ucg(186),Ucg(187),Ucg(188),Ucg(189),
+        Ucg(190),Ucg(191),Ucg(192),Ucg(193),Ucg(194),Ucg(195),Ucg(196),Ucg(197),Ucg(198),Ucg(199),
+        Ucg(200),Ucg(201),Ucg(202),Ucg(203),Ucg(204),Ucg(205),Ucg(206),Ucg(207),Ucg(208),Ucg(209),
+        Ucg(210),Ucg(211),Ucg(212),Ucg(213),Ucg(214),Ucg(215),Ucg(216),Ucg(217),Ucg(218),Ucg(219),
+        Ucg(220),Ucg(221),Ucg(222),Ucg(223),Ucg(224),Ucg(225),Ucg(226),Ucg(227),Ucg(228),Ucg(229),
+        Ucg(230),Ucg(231),Ucg(232),Ucg(233),Ucg(234),Ucg(235),Ucg(236),Ucg(237),Ucg(238),Ucg(239),
+        Ucg(240),Ucg(241),Ucg(242),Ucg(243),Ucg(244),Ucg(245),Ucg(246),Ucg(247),Ucg(248),Ucg(249),
+        Ucg(250),Ucg(251),Ucg(252),Ucg(253),Ucg(254),Ucg(255)};
+        
+
+   static const WebRtc_Word32 mapUcb[256] = {
+        Ucb(0),Ucb(1),Ucb(2),Ucb(3),Ucb(4),Ucb(5),Ucb(6),Ucb(7),Ucb(8),Ucb(9),
+        Ucb(10),Ucb(11),Ucb(12),Ucb(13),Ucb(14),Ucb(15),Ucb(16),Ucb(17),Ucb(18),Ucb(19),
+        Ucb(20),Ucb(21),Ucb(22),Ucb(23),Ucb(24),Ucb(25),Ucb(26),Ucb(27),Ucb(28),Ucb(29),
+        Ucb(30),Ucb(31),Ucb(32),Ucb(33),Ucb(34),Ucb(35),Ucb(36),Ucb(37),Ucb(38),Ucb(39),
+        Ucb(40),Ucb(41),Ucb(42),Ucb(43),Ucb(44),Ucb(45),Ucb(46),Ucb(47),Ucb(48),Ucb(49),
+        Ucb(50),Ucb(51),Ucb(52),Ucb(53),Ucb(54),Ucb(55),Ucb(56),Ucb(57),Ucb(58),Ucb(59),
+        Ucb(60),Ucb(61),Ucb(62),Ucb(63),Ucb(64),Ucb(65),Ucb(66),Ucb(67),Ucb(68),Ucb(69),
+        Ucb(70),Ucb(71),Ucb(72),Ucb(73),Ucb(74),Ucb(75),Ucb(76),Ucb(77),Ucb(78),Ucb(79),
+        Ucb(80),Ucb(81),Ucb(82),Ucb(83),Ucb(84),Ucb(85),Ucb(86),Ucb(87),Ucb(88),Ucb(89),
+        Ucb(90),Ucb(91),Ucb(92),Ucb(93),Ucb(94),Ucb(95),Ucb(96),Ucb(97),Ucb(98),Ucb(99),
+        Ucb(100),Ucb(101),Ucb(102),Ucb(103),Ucb(104),Ucb(105),Ucb(106),Ucb(107),Ucb(108),Ucb(109),
+        Ucb(110),Ucb(111),Ucb(112),Ucb(113),Ucb(114),Ucb(115),Ucb(116),Ucb(117),Ucb(118),Ucb(119),
+        Ucb(120),Ucb(121),Ucb(122),Ucb(123),Ucb(124),Ucb(125),Ucb(126),Ucb(127),Ucb(128),Ucb(129),
+        Ucb(130),Ucb(131),Ucb(132),Ucb(133),Ucb(134),Ucb(135),Ucb(136),Ucb(137),Ucb(138),Ucb(139),
+        Ucb(140),Ucb(141),Ucb(142),Ucb(143),Ucb(144),Ucb(145),Ucb(146),Ucb(147),Ucb(148),Ucb(149),
+        Ucb(150),Ucb(151),Ucb(152),Ucb(153),Ucb(154),Ucb(155),Ucb(156),Ucb(157),Ucb(158),Ucb(159),
+        Ucb(160),Ucb(161),Ucb(162),Ucb(163),Ucb(164),Ucb(165),Ucb(166),Ucb(167),Ucb(168),Ucb(169),
+        Ucb(170),Ucb(171),Ucb(172),Ucb(173),Ucb(174),Ucb(175),Ucb(176),Ucb(177),Ucb(178),Ucb(179),
+        Ucb(180),Ucb(181),Ucb(182),Ucb(183),Ucb(184),Ucb(185),Ucb(186),Ucb(187),Ucb(188),Ucb(189),
+        Ucb(190),Ucb(191),Ucb(192),Ucb(193),Ucb(194),Ucb(195),Ucb(196),Ucb(197),Ucb(198),Ucb(199),
+        Ucb(200),Ucb(201),Ucb(202),Ucb(203),Ucb(204),Ucb(205),Ucb(206),Ucb(207),Ucb(208),Ucb(209),
+        Ucb(210),Ucb(211),Ucb(212),Ucb(213),Ucb(214),Ucb(215),Ucb(216),Ucb(217),Ucb(218),Ucb(219),
+        Ucb(220),Ucb(221),Ucb(222),Ucb(223),Ucb(224),Ucb(225),Ucb(226),Ucb(227),Ucb(228),Ucb(229),
+        Ucb(230),Ucb(231),Ucb(232),Ucb(233),Ucb(234),Ucb(235),Ucb(236),Ucb(237),Ucb(238),Ucb(239),
+        Ucb(240),Ucb(241),Ucb(242),Ucb(243),Ucb(244),Ucb(245),Ucb(246),Ucb(247),Ucb(248),Ucb(249),
+        Ucb(250),Ucb(251),Ucb(252),Ucb(253),Ucb(254),Ucb(255)};
+
+    static const WebRtc_Word32 mapVcr[256] = {
+        Vcr(0),Vcr(1),Vcr(2),Vcr(3),Vcr(4),Vcr(5),Vcr(6),Vcr(7),Vcr(8),Vcr(9),
+        Vcr(10),Vcr(11),Vcr(12),Vcr(13),Vcr(14),Vcr(15),Vcr(16),Vcr(17),Vcr(18),Vcr(19),
+        Vcr(20),Vcr(21),Vcr(22),Vcr(23),Vcr(24),Vcr(25),Vcr(26),Vcr(27),Vcr(28),Vcr(29),
+        Vcr(30),Vcr(31),Vcr(32),Vcr(33),Vcr(34),Vcr(35),Vcr(36),Vcr(37),Vcr(38),Vcr(39),
+        Vcr(40),Vcr(41),Vcr(42),Vcr(43),Vcr(44),Vcr(45),Vcr(46),Vcr(47),Vcr(48),Vcr(49),
+        Vcr(50),Vcr(51),Vcr(52),Vcr(53),Vcr(54),Vcr(55),Vcr(56),Vcr(57),Vcr(58),Vcr(59),
+        Vcr(60),Vcr(61),Vcr(62),Vcr(63),Vcr(64),Vcr(65),Vcr(66),Vcr(67),Vcr(68),Vcr(69),
+        Vcr(70),Vcr(71),Vcr(72),Vcr(73),Vcr(74),Vcr(75),Vcr(76),Vcr(77),Vcr(78),Vcr(79),
+        Vcr(80),Vcr(81),Vcr(82),Vcr(83),Vcr(84),Vcr(85),Vcr(86),Vcr(87),Vcr(88),Vcr(89),
+        Vcr(90),Vcr(91),Vcr(92),Vcr(93),Vcr(94),Vcr(95),Vcr(96),Vcr(97),Vcr(98),Vcr(99),
+        Vcr(100),Vcr(101),Vcr(102),Vcr(103),Vcr(104),Vcr(105),Vcr(106),Vcr(107),Vcr(108),Vcr(109),
+        Vcr(110),Vcr(111),Vcr(112),Vcr(113),Vcr(114),Vcr(115),Vcr(116),Vcr(117),Vcr(118),Vcr(119),
+        Vcr(120),Vcr(121),Vcr(122),Vcr(123),Vcr(124),Vcr(125),Vcr(126),Vcr(127),Vcr(128),Vcr(129),
+        Vcr(130),Vcr(131),Vcr(132),Vcr(133),Vcr(134),Vcr(135),Vcr(136),Vcr(137),Vcr(138),Vcr(139),
+        Vcr(140),Vcr(141),Vcr(142),Vcr(143),Vcr(144),Vcr(145),Vcr(146),Vcr(147),Vcr(148),Vcr(149),
+        Vcr(150),Vcr(151),Vcr(152),Vcr(153),Vcr(154),Vcr(155),Vcr(156),Vcr(157),Vcr(158),Vcr(159),
+        Vcr(160),Vcr(161),Vcr(162),Vcr(163),Vcr(164),Vcr(165),Vcr(166),Vcr(167),Vcr(168),Vcr(169),
+        Vcr(170),Vcr(171),Vcr(172),Vcr(173),Vcr(174),Vcr(175),Vcr(176),Vcr(177),Vcr(178),Vcr(179),
+        Vcr(180),Vcr(181),Vcr(182),Vcr(183),Vcr(184),Vcr(185),Vcr(186),Vcr(187),Vcr(188),Vcr(189),
+        Vcr(190),Vcr(191),Vcr(192),Vcr(193),Vcr(194),Vcr(195),Vcr(196),Vcr(197),Vcr(198),Vcr(199),
+        Vcr(200),Vcr(201),Vcr(202),Vcr(203),Vcr(204),Vcr(205),Vcr(206),Vcr(207),Vcr(208),Vcr(209),
+        Vcr(210),Vcr(211),Vcr(212),Vcr(213),Vcr(214),Vcr(215),Vcr(216),Vcr(217),Vcr(218),Vcr(219),
+        Vcr(220),Vcr(221),Vcr(222),Vcr(223),Vcr(224),Vcr(225),Vcr(226),Vcr(227),Vcr(228),Vcr(229),
+        Vcr(230),Vcr(231),Vcr(232),Vcr(233),Vcr(234),Vcr(235),Vcr(236),Vcr(237),Vcr(238),Vcr(239),
+        Vcr(240),Vcr(241),Vcr(242),Vcr(243),Vcr(244),Vcr(245),Vcr(246),Vcr(247),Vcr(248),Vcr(249),
+        Vcr(250),Vcr(251),Vcr(252),Vcr(253),Vcr(254),Vcr(255)};
+
+
+         static const WebRtc_Word32 mapVcg[256] = {
+        Vcg(0),Vcg(1),Vcg(2),Vcg(3),Vcg(4),Vcg(5),Vcg(6),Vcg(7),Vcg(8),Vcg(9),
+        Vcg(10),Vcg(11),Vcg(12),Vcg(13),Vcg(14),Vcg(15),Vcg(16),Vcg(17),Vcg(18),Vcg(19),
+        Vcg(20),Vcg(21),Vcg(22),Vcg(23),Vcg(24),Vcg(25),Vcg(26),Vcg(27),Vcg(28),Vcg(29),
+        Vcg(30),Vcg(31),Vcg(32),Vcg(33),Vcg(34),Vcg(35),Vcg(36),Vcg(37),Vcg(38),Vcg(39),
+        Vcg(40),Vcg(41),Vcg(42),Vcg(43),Vcg(44),Vcg(45),Vcg(46),Vcg(47),Vcg(48),Vcg(49),
+        Vcg(50),Vcg(51),Vcg(52),Vcg(53),Vcg(54),Vcg(55),Vcg(56),Vcg(57),Vcg(58),Vcg(59),
+        Vcg(60),Vcg(61),Vcg(62),Vcg(63),Vcg(64),Vcg(65),Vcg(66),Vcg(67),Vcg(68),Vcg(69),
+        Vcg(70),Vcg(71),Vcg(72),Vcg(73),Vcg(74),Vcg(75),Vcg(76),Vcg(77),Vcg(78),Vcg(79),
+        Vcg(80),Vcg(81),Vcg(82),Vcg(83),Vcg(84),Vcg(85),Vcg(86),Vcg(87),Vcg(88),Vcg(89),
+        Vcg(90),Vcg(91),Vcg(92),Vcg(93),Vcg(94),Vcg(95),Vcg(96),Vcg(97),Vcg(98),Vcg(99),
+        Vcg(100),Vcg(101),Vcg(102),Vcg(103),Vcg(104),Vcg(105),Vcg(106),Vcg(107),Vcg(108),Vcg(109),
+        Vcg(110),Vcg(111),Vcg(112),Vcg(113),Vcg(114),Vcg(115),Vcg(116),Vcg(117),Vcg(118),Vcg(119),
+        Vcg(120),Vcg(121),Vcg(122),Vcg(123),Vcg(124),Vcg(125),Vcg(126),Vcg(127),Vcg(128),Vcg(129),
+        Vcg(130),Vcg(131),Vcg(132),Vcg(133),Vcg(134),Vcg(135),Vcg(136),Vcg(137),Vcg(138),Vcg(139),
+        Vcg(140),Vcg(141),Vcg(142),Vcg(143),Vcg(144),Vcg(145),Vcg(146),Vcg(147),Vcg(148),Vcg(149),
+        Vcg(150),Vcg(151),Vcg(152),Vcg(153),Vcg(154),Vcg(155),Vcg(156),Vcg(157),Vcg(158),Vcg(159),
+        Vcg(160),Vcg(161),Vcg(162),Vcg(163),Vcg(164),Vcg(165),Vcg(166),Vcg(167),Vcg(168),Vcg(169),
+        Vcg(170),Vcg(171),Vcg(172),Vcg(173),Vcg(174),Vcg(175),Vcg(176),Vcg(177),Vcg(178),Vcg(179),
+        Vcg(180),Vcg(181),Vcg(182),Vcg(183),Vcg(184),Vcg(185),Vcg(186),Vcg(187),Vcg(188),Vcg(189),
+        Vcg(190),Vcg(191),Vcg(192),Vcg(193),Vcg(194),Vcg(195),Vcg(196),Vcg(197),Vcg(198),Vcg(199),
+        Vcg(200),Vcg(201),Vcg(202),Vcg(203),Vcg(204),Vcg(205),Vcg(206),Vcg(207),Vcg(208),Vcg(209),
+        Vcg(210),Vcg(211),Vcg(212),Vcg(213),Vcg(214),Vcg(215),Vcg(216),Vcg(217),Vcg(218),Vcg(219),
+        Vcg(220),Vcg(221),Vcg(222),Vcg(223),Vcg(224),Vcg(225),Vcg(226),Vcg(227),Vcg(228),Vcg(229),
+        Vcg(230),Vcg(231),Vcg(232),Vcg(233),Vcg(234),Vcg(235),Vcg(236),Vcg(237),Vcg(238),Vcg(239),
+        Vcg(240),Vcg(241),Vcg(242),Vcg(243),Vcg(244),Vcg(245),Vcg(246),Vcg(247),Vcg(248),Vcg(249),
+        Vcg(250),Vcg(251),Vcg(252),Vcg(253),Vcg(254),Vcg(255)};
+
+}
+#endif
+
diff --git a/common_video/vplib/main/source/interpolator.cc b/common_video/vplib/main/source/interpolator.cc
new file mode 100644
index 0000000..8e49eb1
--- /dev/null
+++ b/common_video/vplib/main/source/interpolator.cc
@@ -0,0 +1,100 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdlib.h>
+
+#include "interpolator.h"
+#include "scale_bilinear_yuv.h"
+
+namespace webrtc
+{
+
+interpolator::interpolator():
+_method(kBilinear),
+_srcWidth(0),
+_srcHeight(0),
+_dstWidth(0),
+_dstHeight(0)
+{
+}
+
+interpolator:: ~interpolator()
+{
+    //
+}
+
+WebRtc_Word32
+interpolator::Set(WebRtc_UWord32 srcWidth, WebRtc_UWord32 srcHeight,
+                  WebRtc_UWord32 dstWidth, WebRtc_UWord32 dstHeight,
+                  VideoType srcVideoType, VideoType dstVideoType,
+                  interpolatorType type)
+{
+    if (srcWidth < 1 || srcHeight < 1 || dstWidth < 1 || dstHeight < 1 )
+        return -1;
+
+    if (Method(type) < 0)
+        return -1;
+
+    if (!SupportedVideoType(srcVideoType, dstVideoType))
+        return -1;
+
+    _srcWidth = srcWidth;
+    _srcHeight = srcHeight;
+    _dstWidth = dstWidth;
+    _dstHeight = dstHeight;
+    return 0;
+}
+
+
+WebRtc_Word32
+interpolator::Interpolate(const WebRtc_UWord8* srcFrame,
+                          WebRtc_UWord8*& dstFrame)
+{
+    if (srcFrame == NULL)
+        return -1;
+
+    switch (_method)
+    {
+        case kBilinear :
+            return ScaleBilinear (srcFrame, dstFrame,
+                                  _srcWidth, _srcHeight,
+                                  _dstWidth, _dstHeight);
+        default :
+            return -1;
+    }
+}
+
+
+
+WebRtc_Word32
+interpolator::Method(interpolatorType type)
+{
+    _method = type;
+
+    return 0;
+}
+
+
+WebRtc_Word32
+interpolator::SupportedVideoType(VideoType srcVideoType,
+                                 VideoType dstVideoType)
+{
+    if (srcVideoType != dstVideoType)
+        return -1;
+
+    if ((srcVideoType != kI420) ||
+        (srcVideoType != kIYUV) ||
+        (srcVideoType != kYV12))
+        return -1;
+
+    return 0;
+}
+
+}  // namespace webrtc
diff --git a/common_video/vplib/main/source/scale_bilinear_yuv.cc b/common_video/vplib/main/source/scale_bilinear_yuv.cc
new file mode 100644
index 0000000..b92fb73
--- /dev/null
+++ b/common_video/vplib/main/source/scale_bilinear_yuv.cc
@@ -0,0 +1,343 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "scale_bilinear_yuv.h"
+#include <string.h>
+
+namespace webrtc
+{
+// 16.16 fixed point arithmetic
+const WebRtc_UWord32 kFractionBits = 16;
+const WebRtc_UWord32 kFractionMax = 1 << kFractionBits;
+const WebRtc_UWord32 kFractionMask = ((1 << kFractionBits) - 1);
+
+#if USE_MMX
+#if defined(_MSC_VER)
+#include <intrin.h>
+#else
+#include <mmintrin.h>
+#endif
+#endif
+
+#if USE_SSE2
+#include <emmintrin.h>
+#endif
+
+#if USE_SSE2
+// FilterHorizontal combines two rows of the image using linear interpolation.
+// SSE2 version does 16 pixels at a time
+
+static void FilterHorizontal(WebRtc_UWord8* ybuf,
+                             const WebRtc_UWord8* y0_ptr,
+                             const WebRtc_UWord8* y1_ptr,
+                             WebRtc_UWord32 source_width,
+                             WebRtc_UWord32 source_y_fraction)
+{
+    __m128i zero = _mm_setzero_si128();
+    __m128i y1_fraction = _mm_set1_epi16(source_y_fraction);
+    __m128i y0_fraction = _mm_set1_epi16(256 - source_y_fraction);
+
+    const __m128i* y0_ptr128 = reinterpret_cast<const __m128i*>(y0_ptr);
+    const __m128i* y1_ptr128 = reinterpret_cast<const __m128i*>(y1_ptr);
+    __m128i* dest128 = reinterpret_cast<__m128i*>(ybuf);
+    __m128i* end128 = reinterpret_cast<__m128i*>(ybuf + source_width);
+
+    do
+    {
+        __m128i y0 = _mm_loadu_si128(y0_ptr128);
+        __m128i y1 = _mm_loadu_si128(y1_ptr128);
+        __m128i y2 = _mm_unpackhi_epi8(y0, zero);
+        __m128i y3 = _mm_unpackhi_epi8(y1, zero);
+        y0 = _mm_unpacklo_epi8(y0, zero);
+        y1 = _mm_unpacklo_epi8(y1, zero);
+        y0 = _mm_mullo_epi16(y0, y0_fraction);
+        y1 = _mm_mullo_epi16(y1, y1_fraction);
+        y2 = _mm_mullo_epi16(y2, y0_fraction);
+        y3 = _mm_mullo_epi16(y3, y1_fraction);
+        y0 = _mm_add_epi16(y0, y1);
+        y2 = _mm_add_epi16(y2, y3);
+        y0 = _mm_srli_epi16(y0, 8);
+        y2 = _mm_srli_epi16(y2, 8);
+        y0 = _mm_packus_epi16(y0, y2);
+        *dest128++ = y0;
+        ++y0_ptr128;
+        ++y1_ptr128;
+    }
+    while (dest128 < end128);
+}
+#elif USE_MMX
+// MMX version does 8 pixels at a time
+static void FilterHorizontal(WebRtc_UWord8* ybuf,
+                             const WebRtc_UWord8* y0_ptr,
+                             const WebRtc_UWord8* y1_ptr,
+                             WebRtc_UWord32 source_width,
+                             WebRtc_UWord32 source_y_fraction)
+{
+    __m64 zero = _mm_setzero_si64();
+    __m64 y1_fraction = _mm_set1_pi16(source_y_fraction);
+    __m64 y0_fraction = _mm_set1_pi16(256 - source_y_fraction);
+
+    const __m64* y0_ptr64 = reinterpret_cast<const __m64*>(y0_ptr);
+    const __m64* y1_ptr64 = reinterpret_cast<const __m64*>(y1_ptr);
+    __m64* dest64 = reinterpret_cast<__m64*>(ybuf);
+    __m64* end64 = reinterpret_cast<__m64*>(ybuf + source_width);
+
+    do
+    {
+        __m64 y0 = *y0_ptr64++;
+        __m64 y1 = *y1_ptr64++;
+        __m64 y2 = _mm_unpackhi_pi8(y0, zero);
+        __m64 y3 = _mm_unpackhi_pi8(y1, zero);
+        y0 = _mm_unpacklo_pi8(y0, zero);
+        y1 = _mm_unpacklo_pi8(y1, zero);
+        y0 = _mm_mullo_pi16(y0, y0_fraction);
+        y1 = _mm_mullo_pi16(y1, y1_fraction);
+        y2 = _mm_mullo_pi16(y2, y0_fraction);
+        y3 = _mm_mullo_pi16(y3, y1_fraction);
+        y0 = _mm_add_pi16(y0, y1);
+        y2 = _mm_add_pi16(y2, y3);
+        y0 = _mm_srli_pi16(y0, 8);
+        y2 = _mm_srli_pi16(y2, 8);
+        y0 = _mm_packs_pu16(y0, y2);
+        *dest64++ = y0;
+    }
+    while (dest64 < end64);
+}
+#else  // no MMX or SSE2
+// C version does 8 at a time to mimic MMX code
+static void FilterHorizontal(WebRtc_UWord8* ybuf,
+                             const WebRtc_UWord8* y0_ptr,
+                             const WebRtc_UWord8* y1_ptr,
+                             WebRtc_UWord32 source_width,
+                             WebRtc_UWord32 source_y_fraction)
+{
+    WebRtc_UWord32 y1_fraction = source_y_fraction;
+    WebRtc_UWord32 y0_fraction = 256 - y1_fraction;
+    WebRtc_UWord8* end = ybuf + source_width;
+    do
+    {
+        ybuf[0] = (y0_ptr[0] * y0_fraction + y1_ptr[0] * y1_fraction) >> 8;
+        ybuf[1] = (y0_ptr[1] * y0_fraction + y1_ptr[1] * y1_fraction) >> 8;
+        ybuf[2] = (y0_ptr[2] * y0_fraction + y1_ptr[2] * y1_fraction) >> 8;
+        ybuf[3] = (y0_ptr[3] * y0_fraction + y1_ptr[3] * y1_fraction) >> 8;
+        ybuf[4] = (y0_ptr[4] * y0_fraction + y1_ptr[4] * y1_fraction) >> 8;
+        ybuf[5] = (y0_ptr[5] * y0_fraction + y1_ptr[5] * y1_fraction) >> 8;
+        ybuf[6] = (y0_ptr[6] * y0_fraction + y1_ptr[6] * y1_fraction) >> 8;
+        ybuf[7] = (y0_ptr[7] * y0_fraction + y1_ptr[7] * y1_fraction) >> 8;
+        y0_ptr += 8;
+        y1_ptr += 8;
+        ybuf += 8;
+    }
+    while (ybuf < end);
+}
+#endif
+
+static void FilterVertical(WebRtc_UWord8* ybuf,
+                           const WebRtc_UWord8* y0_ptr,
+                           WebRtc_UWord32 width,
+                           WebRtc_UWord32 source_dx)
+{
+    WebRtc_UWord32 x = 0;
+
+    for (WebRtc_UWord32 i = 0; i < width; i ++)
+    {
+        WebRtc_UWord32 y0 = y0_ptr[x >> 16];
+        WebRtc_UWord32 y1 = y0_ptr[(x >> 16) + 1];
+
+        WebRtc_UWord32 y_frac = (x & 65535);
+        ybuf[i] = (y_frac * y1 + (y_frac ^ 65535) * y0) >> 16;
+
+        x += source_dx;
+    }
+}
+
+
+WebRtc_Word32
+ScaleBilinear(const WebRtc_UWord8* srcFrame,
+              WebRtc_UWord8*& dstFrame,
+              WebRtc_UWord32 srcWidth,
+              WebRtc_UWord32 srcHeight,
+              WebRtc_UWord32 dstWidth,
+              WebRtc_UWord32 dstHeight)
+{
+    // Setting source
+    const WebRtc_UWord8* src = srcFrame;
+    WebRtc_UWord8* srcTmp = NULL;
+
+    const WebRtc_UWord32 srcStride = (srcWidth  + 15) & ~15;
+    const WebRtc_UWord32 srcUvStride = (((srcStride + 1 >> 1) + 15) & ~15);
+
+    const WebRtc_UWord32 srcStrideArray[3] = {srcStride,
+            srcUvStride,
+            srcUvStride
+                                             };
+    const WebRtc_UWord32 srcWidthArray[3] = {srcWidth,
+                                            (srcWidth + 1) >> 1,
+                                            (srcWidth + 1) >> 1
+                                            };
+
+    // if srcFrame isn't aligned to nice boundaries then copy it over
+    // int another buffer
+    if ((srcStride > srcWidth) || (srcUvStride > ((srcWidth + 1) >> 1)))
+    {
+        // allocate buffer that can accommodate the stride
+        srcTmp = new WebRtc_UWord8[srcStride*srcHeight*3 >> 1];
+        WebRtc_UWord8* tmpPlaneArray[3];
+        tmpPlaneArray[0] = srcTmp;
+        tmpPlaneArray[1] = tmpPlaneArray[0] + srcStride * srcHeight;
+        tmpPlaneArray[2] = tmpPlaneArray[1] + (srcStride >> 1)*(srcHeight >> 1);
+
+        WebRtc_UWord8* tmpPtr = srcTmp;
+        const WebRtc_UWord8* srcPtr = srcFrame;
+
+        for (WebRtc_UWord32 p = 0; p < 3; p++)
+        {
+            WebRtc_UWord8* dstPtr = tmpPlaneArray[p];
+            const WebRtc_UWord32 h = (p == 0) ? srcHeight : srcHeight >> 1;
+
+            for (WebRtc_UWord32 i = 0; i < h; i++)
+            {
+                memcpy(dstPtr, srcPtr, srcWidthArray[p]);
+                dstPtr += srcStrideArray[p];
+                srcPtr += srcWidthArray[p];
+            }
+        }
+        src = srcTmp;
+    }
+
+    const WebRtc_UWord8* srcPlaneArray[3];
+    srcPlaneArray[0] = src;
+    srcPlaneArray[1] = srcPlaneArray[0] + srcStride*srcHeight;
+    srcPlaneArray[2] = srcPlaneArray[1] + (srcStride >> 1)*(srcHeight >> 1);
+
+    // Setting destination
+    const WebRtc_UWord32 dstStride = (dstWidth + 31) & ~31;
+    const WebRtc_UWord32 dstUvStride = (((dstStride + 1 >> 1) + 31) & ~31);
+
+    if (dstFrame)
+    {
+        delete [] dstFrame;
+        dstFrame = NULL;
+    }
+
+    WebRtc_UWord32 dstRequiredSize = dstStride*dstHeight +
+                                     2*(dstUvStride*((dstHeight + 1) >> 1));
+    dstFrame = new WebRtc_UWord8[dstRequiredSize];
+    if (dstFrame == NULL)
+        return -1;
+
+    WebRtc_UWord8* dstPlaneArray[3] = {dstFrame,
+                                       dstPlaneArray[0] + dstStride*dstHeight,
+                                       dstPlaneArray[1] +
+                                       (dstUvStride*((dstHeight + 1) >> 1))
+                                      };
+
+    const WebRtc_UWord32 dstStrideArray[3] = {dstStride,
+            dstUvStride,
+            dstUvStride
+                                             };
+    const WebRtc_UWord32 dstWidthArray[3] = {dstWidth,
+                                            dstWidth>>1,
+                                            dstWidth>>1
+                                            };
+
+    for (WebRtc_UWord32 p = 0; p < 3; p++)
+    {
+        const WebRtc_UWord32 sh = (p == 0) ? srcHeight : srcHeight >> 1;
+        const WebRtc_UWord32 dh = (p == 0) ? dstHeight : dstHeight >> 1;
+        WebRtc_UWord8* filteredBuf = dstPlaneArray[p];
+        WebRtc_UWord8* horizontalFilteredBuf;
+        WebRtc_UWord8* intermediaryBuf = new WebRtc_UWord8[srcStrideArray[p]];
+
+        const WebRtc_UWord32 hscale_fixed = (sh << kFractionBits) / dh;
+        const WebRtc_UWord32 source_dx = srcWidthArray[p]*kFractionMax /
+                                         dstWidthArray[p];
+
+
+        for (WebRtc_UWord32 h = 0; h < dh; ++h)
+        {
+            horizontalFilteredBuf = filteredBuf;
+
+            if (source_dx != kFractionMax)
+                horizontalFilteredBuf = intermediaryBuf;
+
+            // horizontal filter
+            WebRtc_UWord32 source_h_subpixel = (h * hscale_fixed);
+            if (hscale_fixed >= (kFractionMax * 2))
+                // For 1/2 or less, center filter.
+                source_h_subpixel += kFractionMax / 2;
+
+            WebRtc_UWord32 source_h = source_h_subpixel >> kFractionBits;
+
+            const WebRtc_UWord8* ptr_0 = srcPlaneArray[p] +
+                                         source_h*srcStrideArray[p];
+
+            const WebRtc_UWord8* ptr_1 = ptr_0 + srcStrideArray[p];
+
+            // vertical scaler uses 16.8 fixed point
+            WebRtc_UWord32 source_h_fraction =
+                (source_h_subpixel & kFractionMask) >> 8;
+
+            if (hscale_fixed != kFractionMax &&
+                    source_h_fraction && ((source_h + 1) < sh))
+            {
+                FilterHorizontal(horizontalFilteredBuf, ptr_0, ptr_1,
+                                 srcWidthArray[p], source_h_fraction);
+            }
+            else
+            {
+                memcpy(horizontalFilteredBuf, ptr_1, srcWidthArray[p]);
+            }
+            filteredBuf[srcWidthArray[p]] = filteredBuf[srcWidthArray[p]-1];
+
+            // vertical filter only if necessary
+            if (source_dx != kFractionMax)
+                FilterVertical(filteredBuf, horizontalFilteredBuf,
+                               dstWidthArray[p], source_dx);
+
+            filteredBuf += dstStrideArray[p];
+        }
+
+        if (intermediaryBuf != NULL)
+            delete [] intermediaryBuf;
+    }
+
+    if (srcTmp != NULL)
+        delete [] srcTmp;
+
+    // Filtered image was placed in an aligned buffer.  If the
+    // final output is not in an aligned buffer copy the image over.
+    if (dstStride > dstWidth)
+    {
+        WebRtc_UWord8* dstFinal =
+            new WebRtc_UWord8[(dstWidth*dstHeight*3) >> 1];
+        WebRtc_UWord8* dstPtr = dstFinal;
+
+        for (WebRtc_UWord32 p = 0; p < 3; p++)
+        {
+            WebRtc_UWord8* srcPtr = dstPlaneArray[p];
+            const WebRtc_UWord32 h = (p == 0) ? dstHeight : dstHeight >> 1;
+
+            for (WebRtc_UWord32 i = 0; i < h; i++)
+            {
+                memcpy(dstPtr, srcPtr, dstWidthArray[p]);
+                dstPtr += dstWidthArray[p];
+                srcPtr += dstStrideArray[p];
+            }
+        }
+
+        delete [] dstFrame;
+        dstFrame = dstFinal;
+    }
+
+    return dstHeight;
+}
+
+}  // namespace webrtc
diff --git a/common_video/vplib/main/source/scale_bilinear_yuv.h b/common_video/vplib/main/source/scale_bilinear_yuv.h
new file mode 100644
index 0000000..08e905e
--- /dev/null
+++ b/common_video/vplib/main/source/scale_bilinear_yuv.h
@@ -0,0 +1,31 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+/*
+ * scale_bilinear_yuv.h
+ * yuv bilinear scaler
+ */
+
+#ifndef WEBRTC_COMMON_VIDEO_INTERFACE_SCALE_BILINEAR_YUV_H
+#define WEBRTC_COMMON_VIDEO_INTERFACE_SCALE_BILINEAR_YUV_H
+
+#include "typedefs.h"
+#include "vplib.h"
+
+namespace webrtc
+{
+
+WebRtc_Word32 ScaleBilinear(const WebRtc_UWord8* src, WebRtc_UWord8*& dst,
+                            WebRtc_UWord32 sW, WebRtc_UWord32 sH,
+                            WebRtc_UWord32 dW, WebRtc_UWord32 dH);
+
+}  // namespace webrtc
+
+#endif  // WEBRTC_COMMON_VIDEO_INTERFACE_SCALE_BILINEAR_YUV_H
diff --git a/common_video/vplib/main/source/vplib.cc b/common_video/vplib/main/source/vplib.cc
new file mode 100644
index 0000000..804a159
--- /dev/null
+++ b/common_video/vplib/main/source/vplib.cc
@@ -0,0 +1,4438 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include "vplib.h"
+
+#include <string.h>     // memcpy(), memset()
+#include <assert.h>
+#include <stdlib.h>     // abs
+
+//#define SCALEOPT //Currently for windows only. June 2010
+
+#ifdef SCALEOPT
+#include <emmintrin.h>
+#endif
+
+// webrtc includes
+#include "conversion_tables.h"
+
+namespace webrtc
+{
+
+//Verify and allocate buffer
+static WebRtc_Word32 VerifyAndAllocate(WebRtc_UWord8*& buffer, WebRtc_UWord32 currentSize,
+                                       WebRtc_UWord32 newSize);
+// clip value to [0,255]
+inline WebRtc_UWord8 Clip(WebRtc_Word32 val);
+
+#ifdef SCALEOPT
+void *memcpy_16(void * dest, const void * src, size_t n);
+void *memcpy_8(void * dest, const void * src, size_t n);
+#endif
+
+
+WebRtc_UWord32
+CalcBufferSize(VideoType type, WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    WebRtc_UWord32 bitsPerPixel = 32;
+    switch(type)
+    {
+        case kI420:
+            bitsPerPixel = 12;
+            break;
+        case kNV12:
+            bitsPerPixel = 12;
+            break;
+        case kNV21:
+            bitsPerPixel = 12;
+            break;
+        case kIYUV:
+            bitsPerPixel = 12;
+            break;
+        case kYV12:
+            bitsPerPixel = 12;
+            break;
+        case kRGB24:
+            bitsPerPixel = 24;
+            break;
+        case kARGB:
+            bitsPerPixel = 32;
+            break;
+        case kARGB4444:
+            bitsPerPixel = 16;
+            break;
+        case kRGB565:
+            bitsPerPixel = 16;
+            break;
+        case kARGB1555:
+            bitsPerPixel = 16;
+            break;
+        case kYUY2:
+            bitsPerPixel = 16;
+            break;
+        case kUYVY:
+            bitsPerPixel = 16;
+            break;
+        default:
+            assert(false);
+            break;
+    }
+    return (width * height * bitsPerPixel) >> 3; // bytes
+}
+
+WebRtc_UWord32
+CalcBufferSize(VideoType incomingVideoType, VideoType convertedVideoType,
+               WebRtc_UWord32 length)
+{
+    WebRtc_UWord32 incomingBitsPerPixel = 32;
+    switch(incomingVideoType)
+    {
+        case kI420:
+            incomingBitsPerPixel = 12;
+            break;
+        case kNV12:
+            incomingBitsPerPixel = 12;
+            break;
+        case kNV21:
+            incomingBitsPerPixel = 12;
+            break;
+        case kIYUV:
+            incomingBitsPerPixel = 12;
+            break;
+        case kYV12:
+            incomingBitsPerPixel = 12;
+            break;
+        case kRGB24:
+            incomingBitsPerPixel = 24;
+            break;
+        case kARGB:
+            incomingBitsPerPixel = 32;
+            break;
+        case kARGB4444:
+            incomingBitsPerPixel = 16;
+            break;
+        case kRGB565:
+            incomingBitsPerPixel = 16;
+            break;
+        case kARGB1555:
+            incomingBitsPerPixel = 16;
+            break;
+        case kYUY2:
+            incomingBitsPerPixel = 16;
+            break;
+        case kUYVY:
+            incomingBitsPerPixel = 16;
+            break;
+        default:
+            assert(false);
+            break;
+    }
+
+    WebRtc_Word32 convertedBitsPerPixel = 32;
+    switch(convertedVideoType)
+    {
+        case kI420:
+            convertedBitsPerPixel = 12;
+            break;
+        case kIYUV:
+            convertedBitsPerPixel = 12;
+            break;
+        case kYV12:
+            convertedBitsPerPixel = 12;
+            break;
+        case kRGB24:
+            convertedBitsPerPixel = 24;
+            break;
+        case kARGB:
+            convertedBitsPerPixel = 32;
+            break;
+        case kARGB4444:
+            convertedBitsPerPixel = 16;
+            break;
+        case kRGB565:
+            convertedBitsPerPixel = 16;
+            break;
+        case kARGB1555:
+            convertedBitsPerPixel = 16;
+            break;
+        case kYUY2:
+            convertedBitsPerPixel = 16;
+            break;
+        case kUYVY:
+            convertedBitsPerPixel = 16;
+            break;
+        default:
+            assert(false);
+            break;
+    }
+    return (length * convertedBitsPerPixel) / incomingBitsPerPixel;
+}
+
+WebRtc_Word32
+ConvertI420ToRGB24(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                   WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // RGB orientation - bottom up
+    WebRtc_UWord8* out = outFrame + width * height * 3 - width * 3;
+    WebRtc_UWord8* out2 = out - width * 3;
+    WebRtc_UWord32 h, w;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1, *y2 ,*u, *v;
+    y1 = inFrame;
+    y2 = y1 + width;
+    u =  y1 + width * height;
+    v =  u + ((width * height) >> 2);
+    for (h = (height >> 1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {// vertical and horizontal sub-sampling
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] +                mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]]                + 128) >> 8);
+            out[2] = Clip(tmpR);
+            out[1] = Clip(tmpG);
+            out[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] +                mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]]                + 128) >> 8);
+            out2[2] = Clip(tmpR);
+            out2[1] = Clip(tmpG);
+            out2[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] +                mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]]                + 128) >> 8);
+            out[5] = Clip(tmpR);
+            out[4] = Clip(tmpG);
+            out[3] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] +                mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] +                128) >> 8);
+            out2[5] = Clip(tmpR);
+            out2[4] = Clip(tmpG);
+            out2[3] = Clip(tmpB);
+
+            out  += 6;
+            out2 += 6;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out -= width * 9;
+        out2 -= width * 9;
+    } // end height for
+
+    return width * height * 3;
+}
+
+WebRtc_Word32
+ConvertI420ToARGB(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+    }
+    WebRtc_Word32 diff = strideOut - width;
+    WebRtc_UWord8* out1 = outFrame;
+    WebRtc_UWord8* out2 = out1 + strideOut * 4;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + (( width * height ) >> 2 );
+    WebRtc_UWord32 h, w;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+
+    for (h = (height >> 1); h > 0; h--)
+    {
+        //do 2 rows at the time
+        for (w = 0; w < (width >> 1); w++)
+        {   // vertical and horizontal sub-sampling
+
+            tmpR = (WebRtc_UWord32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_UWord32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] +128) >> 8);
+            tmpB = (WebRtc_UWord32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+            out1[3] = 0xff;
+            out1[2] = Clip(tmpR);
+            out1[1] = Clip(tmpG);
+            out1[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_UWord32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_UWord32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_UWord32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[3] = 0xff;
+            out2[2] = Clip(tmpR);
+            out2[1] = Clip(tmpG);
+            out2[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_UWord32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_UWord32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_UWord32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out1[7] = 0xff;
+            out1[6] = Clip(tmpR);
+            out1[5] = Clip(tmpG);
+            out1[4] = Clip(tmpB);
+
+            tmpR = (WebRtc_UWord32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_UWord32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_UWord32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[7] = 0xff;
+            out2[6] = Clip(tmpR);
+            out2[5] = Clip(tmpG);
+            out2[4] = Clip(tmpB);
+
+            out1 += 8;
+            out2 += 8;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out1 += (strideOut + diff) * 4;
+        out2 += (strideOut + diff) * 4;
+
+    } // end height for
+    return strideOut * height * 4;
+}
+
+WebRtc_Word32
+ConvertI420ToRGBAMac(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                     WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (height < 1 || width < 1)
+    {
+        return -1;
+    }
+
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    } else if (strideOut  < width)
+    {
+        return -1;
+    }
+    WebRtc_Word32 diff = strideOut - width;
+
+    WebRtc_UWord8 * out = outFrame;
+    WebRtc_UWord8 * out2 = out + strideOut * 4;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    WebRtc_Word32 tmpG, tmpB, tmpR;
+    WebRtc_UWord32 h, w;
+    y1 = inFrame;
+    y2 = y1 + width;
+    v = y1 + width * height;
+    u = v + ((width * height) >> 2);
+
+    for (h = (height >> 1); h > 0; h--)
+    {
+        //do 2 rows at the time
+        for (w = 0; w < (width >> 1); w++)
+        {
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128  ) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128 ) >> 8);
+            out[1] = Clip(tmpR);
+            out[2] = Clip(tmpG);
+            out[3] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[1] = Clip(tmpR);
+            out2[2] = Clip(tmpG);
+            out2[3] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[5] = Clip(tmpR);
+            out[6] = Clip(tmpG);
+            out[7] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[5] = Clip(tmpR);
+            out2[6] = Clip(tmpG);
+            out2[7] = Clip(tmpB);
+
+            out[0] = 0xff;
+            out[4] = 0xff;
+            out += 8;
+            out2[0] = 0xff;
+            out2[4] = 0xff;
+            out2 += 8;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+
+        y1 += width;
+        y2 += width;
+        out += (width + diff * 2) * 4;
+        out2 += (width + diff * 2) * 4;
+    }
+    return strideOut * height * 4;
+}
+
+// Little Endian...
+WebRtc_Word32
+ConvertI420ToARGB4444(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                      WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    } else if (strideOut < width)
+    {
+        return -1;
+    }
+    // RGB orientation - bottom up
+    WebRtc_UWord8* out = outFrame + strideOut * (height - 1) * 2;
+    WebRtc_UWord8* out2 = out - 2 * strideOut;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + ((width * height) >> 2);
+    WebRtc_UWord32 h, w;
+
+    for (h = (height >> 1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {   // vertical and horizontal sub-sampling
+            // Convert to RGB888 and re-scale to 4 bits
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+            out[0] =(WebRtc_UWord8)((Clip(tmpG) & 0xf0) + (Clip(tmpB) >> 4));
+            out[1] = (WebRtc_UWord8)(0xf0 + (Clip(tmpR) >> 4));
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[0] = (WebRtc_UWord8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
+            out2[1] = (WebRtc_UWord8) (0xf0 + (Clip(tmpR) >> 4));
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[2] = (WebRtc_UWord8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
+            out[3] = (WebRtc_UWord8)(0xf0 + (Clip(tmpR) >> 4));
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[2] = (WebRtc_UWord8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
+            out2[3] = (WebRtc_UWord8)(0xf0 + (Clip(tmpR) >> 4));
+
+            out  += 4;
+            out2 += 4;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out -= (2 * strideOut + width) * 2;
+        out2 -= (2 * strideOut + width) * 2;
+     } // end height for
+
+    return strideOut * height * 2;
+}
+
+WebRtc_Word32
+ConvertI420ToRGB565(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                    WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord16* out = (WebRtc_UWord16*)(outFrame) + width * (height - 1);
+    WebRtc_UWord16* out2 = out - width ;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + (width * height >> 2);
+    WebRtc_UWord32 h, w;
+
+    for (h = (height >>1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {   // vertical and horizontal sub-sampling
+            // 1. Convert to RGB888
+            // 2. Shift to adequate location (in the 16 bit word) - RGB 565
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+            out[0]  = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[0] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                       + (Clip(tmpB ) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            y1 += 2;
+            y2 += 2;
+            out += 2;
+            out2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out -= 3 * width;
+        out2 -=  3 * width;
+    } // end height for
+
+    return width * height * 2;
+}
+
+
+//Same as ConvertI420ToRGB565 but doesn't flip vertically.
+WebRtc_Word32
+ConvertI420ToRGB565Android(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                           WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord16* out = (WebRtc_UWord16*)(outFrame);
+    WebRtc_UWord16* out2 = out +  (width) ;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    WebRtc_UWord32 h, w;
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + (width * height >> 2);
+
+    for (h = (height >>1); h > 0; h--)
+    {
+      // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {
+            // vertical and horizontal sub-sampling
+            // 1. Convert to RGB888
+            // 2. Shift to adequate location (in the 16 bit word) - RGB 565
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+            out[0]  = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[0] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                       + (Clip(tmpB ) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3)
+                                        + (Clip(tmpB) >> 3);
+
+            y1 += 2;
+            y2 += 2;
+            out += 2;
+            out2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out += width;
+        out2 +=  width;
+    } // end height for
+
+    return width * height * 2;
+}
+
+WebRtc_Word32
+ConvertI420ToARGB1555(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                      WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord16* out = (WebRtc_UWord16*)(outFrame) + width * (height - 1);
+    WebRtc_UWord16* out2 = out - width ;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    WebRtc_UWord32 h, w;
+
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + (width * height >> 2);
+
+    for (h = (height >> 1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {
+            // vertical and horizontal sub-sampling
+            // 1. Convert to RGB888
+            // 2. shift to adequate location (in the 16 bit word) - RGB 555
+            // 3. Add 1 for alpha value
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+            out[0]  = (WebRtc_UWord16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) + ((Clip(tmpG) & 0xf8) << 3)
+                                       + (Clip(tmpB) >> 3));
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[0]  = (WebRtc_UWord16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) + ((Clip(tmpG) & 0xf8) << 3)
+                                        + (Clip(tmpB) >> 3));
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[1]  = (WebRtc_UWord16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) + ((Clip(tmpG) & 0xf8) << 3)
+                                       + (Clip(tmpB) >> 3));
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[1]  = (WebRtc_UWord16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) + ((Clip(tmpG) & 0xf8) << 3)
+                                        + (Clip(tmpB) >> 3));
+
+            y1 += 2;
+            y2 += 2;
+            out += 2;
+            out2 += 2;
+            u++;
+            v++;
+        }
+        y1 += width;
+        y2 += width;
+        out -= 3 * width;
+        out2 -=  3 * width;
+    } // end height for
+    return strideOut * height * 2;
+}
+
+WebRtc_Word32
+ConvertI420ToYUY2(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if(strideOut == 0)
+    {
+      strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+     }
+
+    const WebRtc_UWord8* in1 = inFrame;
+    const WebRtc_UWord8* in2 = inFrame + width ;
+    const WebRtc_UWord8* inU = inFrame + width * height;
+    const WebRtc_UWord8* inV = inU + width * (height >> 2);
+
+    WebRtc_UWord8* out1 = outFrame;
+    WebRtc_UWord8* out2 = outFrame + 2*strideOut;
+
+    //YUY2 - Macro-pixel = 2 image pixels
+    //Y0U0Y1V0....Y2U2Y3V2...Y4U4Y5V4....
+
+#ifndef SCALEOPT
+    for (WebRtc_UWord32 i = 0; i < (height >> 1);i++)
+    {
+        for (WebRtc_UWord32 j = 0; j < (width >> 1);j++)
+        {
+            out1[0] = in1[0];
+            out1[1] = *inU;
+            out1[2] = in1[1];
+            out1[3] = *inV;
+
+            out2[0] = in2[0];
+            out2[1] = *inU;
+            out2[2] = in2[1];
+            out2[3] = *inV;
+            out1 += 4;
+            out2 += 4;
+            inU++;
+            inV++;
+            in1 += 2;
+            in2 += 2;
+        }
+        in1 += width;
+        in2 += width;
+        out1 += 2 * strideOut + 2 * (strideOut - width);
+        out2 += 2 * strideOut + 2 * (strideOut - width);
+    }
+#else
+    for (WebRtc_UWord32 i = 0; i < (height >> 1);i++)
+    {
+        WebRtc_Word32 width__ = (width >> 4);
+        _asm
+        {
+            ;pusha
+            mov       eax, DWORD PTR [in1]                       ;1939.33
+            mov       ecx, DWORD PTR [in2]                       ;1939.33
+            mov       ebx, DWORD PTR [inU]                       ;1939.33
+            mov       edx, DWORD PTR [inV]                       ;1939.33
+            loop0:
+            movq      xmm6, QWORD PTR [ebx]          ;inU
+            movq      xmm0, QWORD PTR [edx]          ;inV
+            punpcklbw xmm6, xmm0                     ;inU, inV mix
+            ;movdqa    xmm1, xmm6
+            ;movdqa    xmm2, xmm6
+            ;movdqa    xmm4, xmm6
+
+            movdqu    xmm3, XMMWORD PTR [eax]        ;in1
+            movdqa    xmm1, xmm3
+            punpcklbw xmm1, xmm6                     ;in1, inU, in1, inV
+            mov       esi, DWORD PTR [out1]
+            movdqu    XMMWORD PTR [esi], xmm1        ;write to out1
+
+            movdqu    xmm5, XMMWORD PTR [ecx]        ;in2
+            movdqa    xmm2, xmm5
+            punpcklbw xmm2, xmm6                     ;in2, inU, in2, inV
+            mov       edi, DWORD PTR [out2]
+            movdqu    XMMWORD PTR [edi], xmm2        ;write to out2
+
+            punpckhbw xmm3, xmm6                     ;in1, inU, in1, inV again
+            movdqu    XMMWORD PTR [esi+16], xmm3     ;write to out1 again
+            add       esi, 32
+            mov       DWORD PTR [out1], esi
+
+            punpckhbw xmm5, xmm6                     ;inU, in2, inV again
+            movdqu    XMMWORD PTR [edi+16], xmm5     ;write to out2 again
+            add       edi, 32
+            mov       DWORD PTR [out2], edi
+
+            add       ebx, 8
+            add       edx, 8
+            add       eax, 16
+            add       ecx, 16
+
+            mov       esi, DWORD PTR [width__]
+            sub       esi, 1
+            mov       DWORD PTR [width__], esi
+            jg        loop0
+
+            mov       DWORD PTR [in1], eax                       ;1939.33
+            mov       DWORD PTR [in2], ecx                       ;1939.33
+            mov       DWORD PTR [inU], ebx                       ;1939.33
+            mov       DWORD PTR [inV], edx                       ;1939.33
+
+            ;popa
+            emms
+        }
+        in1 += width;
+        in2 += width;
+        out1 += 2 * strideOut + 2 * (strideOut - width);
+        out2 += 2 * strideOut + 2 * (strideOut - width);
+    }
+#endif
+    return strideOut * height * 2;
+}
+
+WebRtc_Word32
+ConvertI420ToUYVY(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+         return -1;
+    }
+    if(strideOut == 0)
+    {
+        strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 i = 0;
+    const WebRtc_UWord8* in1 = inFrame;
+    const WebRtc_UWord8* in2 = inFrame + width ;
+    const WebRtc_UWord8* inU = inFrame + width * height;
+    const WebRtc_UWord8* inV = inFrame + width * height + width * (height >> 2);
+
+    WebRtc_UWord8* out1 = outFrame;
+    WebRtc_UWord8* out2 = outFrame + 2 * strideOut;
+
+    //Macro-pixel = 2 image pixels
+    //U0Y0V0Y1....U2Y2V2Y3...U4Y4V4Y5.....
+
+#ifndef SCALEOPT
+    for (; i < (height >> 1);i++)
+    {
+        for (WebRtc_UWord32 j = 0; j < (width >> 1) ;j++)
+        {
+            out1[0] = *inU;
+            out1[1] = in1[0];
+            out1[2] = *inV;
+            out1[3] = in1[1];
+
+            out2[0] = *inU;
+            out2[1] = in2[0];
+            out2[2] = *inV;
+            out2[3] = in2[1];
+            out1 += 4;
+            out2 += 4;
+            inU++;
+            inV++;
+            in1 += 2;
+            in2 += 2;
+        }
+        in1 += width;
+        in2 += width;
+        out1 += 2 * (strideOut + (strideOut - width));
+        out2 += 2 * (strideOut + (strideOut - width));
+    }
+#else
+    for (; i< (height >> 1);i++)
+    {
+        WebRtc_Word32 width__ = (width >> 4);
+        _asm
+        {
+            ;pusha
+            mov       eax, DWORD PTR [in1]                       ;1939.33
+            mov       ecx, DWORD PTR [in2]                       ;1939.33
+            mov       ebx, DWORD PTR [inU]                       ;1939.33
+            mov       edx, DWORD PTR [inV]                       ;1939.33
+loop0:
+            movq      xmm6, QWORD PTR [ebx]          ;inU
+            movq      xmm0, QWORD PTR [edx]          ;inV
+            punpcklbw xmm6, xmm0                     ;inU, inV mix
+            movdqa    xmm1, xmm6
+            movdqa    xmm2, xmm6
+            movdqa    xmm4, xmm6
+
+            movdqu    xmm3, XMMWORD PTR [eax]        ;in1
+            punpcklbw xmm1, xmm3                     ;inU, in1, inV
+            mov       esi, DWORD PTR [out1]
+            movdqu    XMMWORD PTR [esi], xmm1        ;write to out1
+
+            movdqu    xmm5, XMMWORD PTR [ecx]        ;in2
+            punpcklbw xmm2, xmm5                     ;inU, in2, inV
+            mov       edi, DWORD PTR [out2]
+            movdqu    XMMWORD PTR [edi], xmm2        ;write to out2
+
+            punpckhbw xmm4, xmm3                     ;inU, in1, inV again
+            movdqu    XMMWORD PTR [esi+16], xmm4     ;write to out1 again
+            add       esi, 32
+            mov       DWORD PTR [out1], esi
+
+            punpckhbw xmm6, xmm5                     ;inU, in2, inV again
+            movdqu    XMMWORD PTR [edi+16], xmm6     ;write to out2 again
+            add       edi, 32
+            mov       DWORD PTR [out2], edi
+
+            add       ebx, 8
+            add       edx, 8
+            add       eax, 16
+            add       ecx, 16
+
+            mov       esi, DWORD PTR [width__]
+            sub       esi, 1
+            mov       DWORD PTR [width__], esi
+            jg        loop0
+
+            mov       DWORD PTR [in1], eax                       ;1939.33
+            mov       DWORD PTR [in2], ecx                       ;1939.33
+            mov       DWORD PTR [inU], ebx                       ;1939.33
+            mov       DWORD PTR [inV], edx                       ;1939.33
+
+            ;popa
+            emms
+        }
+        in1 += width;
+        in2 += width;
+        out1 += 2 * (strideOut + (strideOut - width));
+        out2 += 2 * (strideOut + (strideOut - width));
+    }
+#endif
+    return strideOut * height * 2;
+}
+
+WebRtc_Word32
+ConvertI420ToYV12(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (height < 1 || width < 1 )
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+    }
+
+    // copy Y
+    for (WebRtc_UWord32 i = 0; i < height; i++)
+    {
+#ifndef SCALEOPT
+        memcpy(outFrame, inFrame, width);
+#else
+        memcpy_16(outFrame, inFrame, width);
+#endif
+        inFrame += width;
+        outFrame += strideOut;
+    }
+    // copy U
+    outFrame += (strideOut >> 1) * height >> 1;
+    for (WebRtc_UWord32 i = 0; i < height >>1; i++)
+    {
+#ifndef SCALEOPT
+        memcpy(outFrame, inFrame, width >> 1);
+#else
+        memcpy_8(outFrame, inFrame, width >> 1);
+#endif
+        inFrame += width >> 1;
+        outFrame += strideOut >> 1;
+    }
+    outFrame -= strideOut*height >> 1;
+    // copy V
+    for (WebRtc_UWord32 i = 0; i < height >> 1; i++)
+    {
+#ifndef SCALEOPT
+        memcpy(outFrame, inFrame, width >> 1);
+#else
+        memcpy_8(outFrame, inFrame, width >> 1);
+#endif
+        inFrame += width >> 1;
+        outFrame += strideOut >> 1;
+    }
+    return ((3 * strideOut * height) >> 1);
+}
+
+WebRtc_Word32
+ConvertYV12ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 width, WebRtc_UWord32 height,
+                  WebRtc_UWord8* outFrame)
+{
+    if (height < 1 || width <1)
+    {
+        return -1;
+    }
+    WebRtc_UWord8 *u, *v, *uo, *vo;
+    WebRtc_Word32 lumlen = 0;
+    WebRtc_Word32 crlen = 0;
+
+    lumlen = height * width;
+    crlen = (lumlen >> 2);
+    v = (WebRtc_UWord8 *)inFrame + lumlen;
+    uo = outFrame + lumlen;
+    u = v + crlen;
+    vo = uo + crlen;
+
+    memcpy(outFrame, inFrame, lumlen); // copy luminance
+    memcpy(vo, v, crlen);   // copy V to V out
+    memcpy(uo, u, crlen);   // copy U to U out
+
+    return (width * height * 3) >> 1;
+}
+
+WebRtc_Word32
+ConvertNV12ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // Bi-Planar: Y plane followed by an interlaced U and V plane
+    WebRtc_UWord8* out = outFrame;
+    // copying Y plane as is
+    memcpy(out, inFrame, width * height);
+    // de-interlacing U and V
+    const WebRtc_UWord8 *interlacedSrc;
+    WebRtc_UWord8 *u, *v;
+    u = outFrame + width * height;
+    v = u + (width * height >> 2);
+    interlacedSrc = inFrame + width * height;
+    for (WebRtc_UWord32 ind = 0; ind < (width * height >> 2); ind ++)
+    {
+        u[ind] = interlacedSrc[2 * ind];
+        v[ind] = interlacedSrc[2 * ind + 1];
+    }
+    return (width * height * 3 >> 1);
+}
+WebRtc_Word32
+ConvertNV12ToI420AndRotate180(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                              WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // Bi-Planar: Y plane followed by an interlaced U and V plane
+    WebRtc_UWord8* out = outFrame;
+
+    for(WebRtc_UWord32 index = 0; index < width * height; index++)
+    {
+        out[index] = inFrame[width * height - index - 1];
+    }
+    // de-interlacing U and V
+    const WebRtc_UWord8 *interlacedSrc;
+    WebRtc_UWord8 *u, *v;
+    u = outFrame + width * height;
+    v = u + (width * height >> 2);
+    interlacedSrc = inFrame + width * height;
+    // extracting and rotating 180
+    for (WebRtc_UWord32 index = 0; index < (width * height >> 2); index++)
+    {
+        u[(width * height >> 2) - index - 1] = interlacedSrc[2 * index];
+        v[(width * height >> 2) - index - 1] = interlacedSrc[2 * index + 1];
+    }
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertNV12ToI420AndRotateClockwise(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord8* targetBuffer = outFrame;
+    const WebRtc_UWord8* sourcePtr = inFrame;
+    const WebRtc_UWord8* interlacedSrc = inFrame + width * height;
+
+    WebRtc_UWord32 index = 0;
+
+    // Rotate Y
+    for(WebRtc_UWord32 newRow = 0; newRow < width; ++newRow)
+    {
+        for(WebRtc_Word32 newColumn = height-1; newColumn >= 0; --newColumn)
+        {
+            targetBuffer[index++] = sourcePtr[newColumn * width + newRow];
+        }
+    }
+
+    // extracting and rotating U and V
+    WebRtc_UWord8* u  = targetBuffer + width * height;
+    WebRtc_UWord8* v  = u + (width * height >> 2);
+    for (WebRtc_UWord32 colInd = 0; colInd < height >> 1; colInd ++)
+    {
+        for (WebRtc_UWord32 rowInd = 0; rowInd < width >> 1; rowInd ++)
+        {
+            u[rowInd * height / 2 + colInd] = interlacedSrc[(height / 2 - colInd - 1) * width
+                                                             + 2 * rowInd];
+            v[rowInd * height / 2 + colInd] = interlacedSrc[(height / 2 - colInd - 1) * width
+                                                             + 2 * rowInd + 1];
+        }
+    }
+
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertNV12ToI420AndRotateAntiClockwise(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                        WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord8* targetBuffer = outFrame;
+    const WebRtc_UWord8* sourcePtr = inFrame;
+    const WebRtc_UWord8* interlacedSrc = inFrame + width * height;
+
+    WebRtc_UWord32 index = 0;
+    // Rotate Y
+    for(WebRtc_Word32 newRow = width - 1; newRow >= 0; --newRow)
+    {
+        for(WebRtc_UWord32 newColumn = 0; newColumn < height; ++newColumn)
+        {
+            targetBuffer[index++] = sourcePtr[newColumn * width + newRow];
+        }
+    }
+
+    // extracting and rotating U and V
+    WebRtc_UWord8* u  = targetBuffer + width * height;
+    WebRtc_UWord8* v  = u + (width * height >> 2);
+    index = 0;
+    for(WebRtc_Word32 newRow = (width >> 1) - 1; newRow >= 0; --newRow)
+    {
+        for(WebRtc_UWord32 newColumn = 0; newColumn < (height >> 1); ++newColumn)
+        {
+            u[index] = interlacedSrc[2 * (newColumn * (width >> 1) + newRow)];
+            v[index] = interlacedSrc[2 * (newColumn * (width >> 1) + newRow) + 1];
+            index++;
+        }
+    }
+
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertNV12ToRGB565(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                    WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // Bi-Planar: Y plane followed by an interlaced U and V plane
+    const WebRtc_UWord8* interlacedSrc = inFrame + width * height;
+    WebRtc_UWord16* out = (WebRtc_UWord16*)(outFrame) + width * (height - 1);
+    WebRtc_UWord16* out2 = out - width;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2;
+    y1 = inFrame;
+    y2 = y1 + width;
+    WebRtc_UWord32 h, w;
+
+    for (h = (height >> 1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {   // vertical and horizontal sub-sampling
+            // 1. Convert to RGB888
+            // 2. Shift to adequate location (in the 16 bit word) - RGB 565
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[interlacedSrc[0]]
+                                    + mapVcg[interlacedSrc[1]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+            out[0]  = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3) + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[interlacedSrc[0]]
+                                    + mapVcg[interlacedSrc[1]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+            out2[0] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3) + (Clip(tmpB) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[interlacedSrc[0]]
+                                    + mapVcg[interlacedSrc[1]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+            out[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3) + (Clip(tmpB ) >> 3);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[interlacedSrc[0]]
+                                    + mapVcg[interlacedSrc[1]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+            out2[1] = (WebRtc_UWord16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG) & 0xfc) << 3) + (Clip(tmpB) >> 3);
+
+            y1 += 2;
+            y2 += 2;
+            out += 2;
+            out2 += 2;
+            interlacedSrc += 2;
+            }
+        y1 += width;
+        y2 += width;
+        out -= 3 * width;
+        out2 -= 3 * width;
+    } // end height for
+
+    return (width * height * 2);
+}
+
+//NV21 Android Functions
+WebRtc_Word32
+ConvertNV21ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // Bi-Planar: Y plane followed by an interlaced U and V plane
+    WebRtc_UWord8* out = outFrame;
+    // copying Y plane as is
+    memcpy(out, inFrame, width * height);
+    // de-interlacing U and V
+    const WebRtc_UWord8 *interlacedSrc;
+    WebRtc_UWord8 *u, *v;
+    u = outFrame + width * height;
+    v = u + (width * height >> 2);
+    interlacedSrc = inFrame + width * height;
+    for (WebRtc_UWord32 ind = 0; ind < (width * height >> 2); ind ++)
+    {
+        v[ind] = interlacedSrc[2 * ind];
+        u[ind] = interlacedSrc[2 * ind + 1];
+    }
+    return (width * height * 3 >> 1);
+}
+WebRtc_Word32
+ConvertNV21ToI420AndRotate180(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                              WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    // Bi-Planar: Y plane followed by an interlaced U and V plane
+    WebRtc_UWord8* out = outFrame;
+    for(WebRtc_UWord32 index = 0; index < width * height; index++)
+    {
+        out[index] = inFrame[width * height - index - 1];
+    }
+    // de-interlacing U and V
+    const WebRtc_UWord8 *interlacedSrc;
+    WebRtc_UWord8 *u, *v;
+    u = outFrame + width * height;
+    v = u + (width * height >> 2);
+    interlacedSrc = inFrame + width * height;
+    // extracting and rotating 180
+    for (WebRtc_UWord32 index = 0; index < (width * height >> 2); index++)
+    {
+        v[(width * height >> 2) - index - 1] = interlacedSrc[2 * index];
+        u[(width * height >> 2) - index - 1] = interlacedSrc[2 * index + 1];
+    }
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertNV21ToI420AndRotateClockwise(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                    WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    // Paint the destination buffer black
+    memset(outFrame,0,width * height);
+    memset(outFrame + width * height,127,(width * height) / 2);
+    const WebRtc_Word32 offset = (width - height) / 2;
+
+    //Y
+    WebRtc_UWord8* yn= outFrame;
+    const WebRtc_UWord8* ys= inFrame;
+    for (WebRtc_UWord32 m = 0; m < height; ++m)// New row
+    {
+        yn += offset;
+        for (WebRtc_UWord32 n = 0; n < height; ++n) // new column
+        {
+            (*yn++) = ys[(height - 1 - n) * width + offset + m];
+        }
+        yn += offset;
+    }
+
+    //U & V
+    WebRtc_UWord8* un= outFrame + height * width;
+    WebRtc_UWord8* vn= outFrame+height * width + height * width / 4;
+    const WebRtc_UWord8* uvs= inFrame + height * width;
+
+    for (WebRtc_UWord32 m = 0;m < height / 2; ++m)// New row
+    {
+        un += offset / 2;
+        vn += offset / 2;
+        for (WebRtc_UWord32 n = 0;n < height / 2; ++n) // new column
+        {
+            (*un++) = uvs[(height / 2 - 1 - n) * width + offset + 2 * m + 1];
+            (*vn++) = uvs[(height / 2 - 1 - n) * width + offset + 2 * m];
+        }
+        un += offset / 2;
+        vn += offset / 2;
+    }
+
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertNV21ToI420AndRotateAntiClockwise(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                                        WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    // Paint the destination buffer black
+    memset(outFrame,0,width * height);
+    memset(outFrame + width * height, 127, (width * height) / 2);
+
+    const WebRtc_Word32 offset = (width - height) / 2;
+
+    //Y
+    WebRtc_UWord8* yn = outFrame;
+    const WebRtc_UWord8* ys = inFrame;
+    for (WebRtc_UWord32 m = 0;m < height; ++m)// New row
+    {
+        yn += offset;
+        for (WebRtc_UWord32 n = 0;n < height; ++n) // new column
+        {
+            (*yn++) = ys[width * (n + 1) - 1 - offset - m];
+        }
+        yn += offset;
+    }
+
+    //U & V
+    WebRtc_UWord8* un= outFrame + height * width;
+    WebRtc_UWord8* vn= outFrame + height * width + height * width / 4;
+    const WebRtc_UWord8* uvs= inFrame + height * width;
+
+    for (WebRtc_UWord32 m = 0;m < height / 2; ++m)// New row
+    {
+        un += offset / 2;
+        vn += offset / 2;
+        for (WebRtc_UWord32 n = 0;n < height / 2; ++n) // new column
+        {
+            (*un++) = uvs[width * (n + 1) - 1 - offset - 2 * m];;
+            (*vn++) = uvs[width * (n + 1) - 1 - offset - 2 * m - 1];;
+        }
+        un += offset / 2;
+        vn += offset / 2;
+    }
+    return (width * height * 3 >> 1);
+}
+
+WebRtc_Word32
+ConvertI420ToRGBAIPhone(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                        WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    } else if (strideOut < width)
+    {
+        return -1;
+    }
+
+    // RGB orientation - bottom up
+    // same as ARGB but reverting RGB <-> BGR (same as previous version)
+    WebRtc_UWord8* out = outFrame + strideOut * height * 4 - strideOut * 4;
+    WebRtc_UWord8* out2 = out - strideOut * 4;
+    WebRtc_Word32 tmpR, tmpG, tmpB;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    WebRtc_UWord32 h, w;
+
+    y1 = inFrame;
+    y2 = y1 + width;
+    u = y1 + width * height;
+    v = u + ((width * height) >> 2);
+
+    for (h = (height >> 1); h > 0; h--)
+    {  // 2 rows at a time, 2 y's at a time
+        for (w = 0; w < (width >> 1); w++)
+        {   // vertical and horizontal sub-sampling
+            tmpR = (WebRtc_Word32)((298 * (y1[0] - 16) + 409 * (v[0] - 128) + 128) >> 8);
+            tmpG = (WebRtc_Word32)((298 * (y1[0] - 16) - 100 * (u[0] - 128)
+                                    - 208 * (v[0] - 128) + 128 ) >> 8);
+            tmpB = (WebRtc_Word32)((298 * (y1[0] - 16) + 516 * (u[0] - 128) + 128 ) >> 8);
+
+            out[3] = 0xff;
+            out[0] = Clip(tmpR);
+            out[1] = Clip(tmpG);
+            out[2] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((298 * (y2[0] - 16) + 409 * (v[0] - 128) + 128) >> 8);
+            tmpG = (WebRtc_Word32)((298 * (y2[0] - 16) - 100 * (u[0] - 128)
+                                    - 208 * (v[0] - 128) + 128) >> 8);
+            tmpB = (WebRtc_Word32)((298 * (y2[0] - 16) + 516 * (u[0] - 128) + 128) >> 8);
+
+            out2[3] = 0xff;
+            out2[0] = Clip(tmpR);
+            out2[1] = Clip(tmpG);
+            out2[2] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((298 * (y1[1] - 16) + 409 * (v[0] - 128) + 128 ) >> 8);
+            tmpG = (WebRtc_Word32)((298 * (y1[1] - 16) - 100 * (u[0] - 128)
+                                    - 208 * (v[0] - 128) + 128 ) >> 8);
+            tmpB = (WebRtc_Word32)((298 * (y1[1] - 16) + 516 * (u[0] - 128) + 128) >> 8);
+
+            out[7] = 0xff;
+            out[4] = Clip(tmpR);
+            out[5] = Clip(tmpG);
+            out[6] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((298 * (y2[1] - 16) + 409 * (v[0] - 128) + 128) >> 8);
+            tmpG = (WebRtc_Word32)((298 * (y2[1] - 16) - 100 * (u[0] - 128)
+                                    - 208 * (v[0] - 128) + 128) >> 8);
+            tmpB = (WebRtc_Word32)((298 * (y2[1] - 16) + 516 * (u[0] - 128) + 128 ) >> 8);
+
+            out2[7] = 0xff;
+            out2[4] = Clip(tmpR);
+            out2[5] = Clip(tmpG);
+            out2[6] = Clip(tmpB);
+
+            out  += 8;
+            out2 += 8;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+
+        y1 += width;
+        y2 += width;
+        out -= (2 * strideOut + width) * 4;
+        out2 -= (2 * strideOut + width) * 4;
+    } // end height for
+
+    return strideOut * height * 4;
+}
+
+WebRtc_Word32
+ConvertI420ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (strideOut == 0 || strideOut == width)
+    {
+        memcpy(outFrame, inFrame, 3 * width * (height >> 1));
+        strideOut = width;
+    } else if (strideOut < width)
+    {
+        return -1;
+    } else
+    {
+        WebRtc_UWord32 i = 0;
+        for (; i < height; i++)
+        {
+            memcpy(outFrame,inFrame ,width);
+            outFrame += strideOut;
+            inFrame += width;
+        }
+        for (i = 0; i < (height >> 1);i++)
+        {
+            memcpy(outFrame, inFrame,width >> 1);
+            outFrame += strideOut >> 1;
+            inFrame += width >> 1;
+        }
+        for (i = 0; i< (height >> 1); i++)
+        {
+            memcpy(outFrame, inFrame,width >> 1);
+            outFrame += strideOut >> 1;
+            inFrame += width >> 1;
+        }
+    }
+    return 3 * strideOut * (height >> 1);
+}
+
+WebRtc_Word32
+ConvertUYVYToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth, WebRtc_UWord32 inHeight,
+                  WebRtc_UWord8* outFrame, WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || inHeight < 1 || outHeight < 1 || outWidth < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 i = 0;
+    WebRtc_UWord32 j = 0;
+    WebRtc_Word32 cutDiff = 0; // in pixels
+    WebRtc_Word32 padDiffLow = 0; // in pixels
+    WebRtc_Word32 padDiffHigh = 0; // in pixels
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + outWidth * outHeight;
+    WebRtc_UWord8* outCb = outFrame + outWidth * outHeight + outWidth * (outHeight >> 2);
+
+    // cut height?
+    if (inHeight > outHeight)
+    {
+        // parse away half of the lines
+      inFrame += ((inHeight - outHeight) / 2) * inWidth * 2;
+    }
+    // cut width?
+    if (inWidth > outWidth)
+    {
+        cutDiff = (inWidth - outWidth); // in pixels
+        // start half of the width diff into the line
+        inFrame += cutDiff; // each pixel is 2 bytes hence diff is the correct value in bytes
+    }
+    // pad height?
+    if (inHeight < outHeight)
+    {
+        // pad top
+        WebRtc_Word32 diff = (outHeight - inHeight) >> 1;
+        memset(outI, 0, diff * outWidth);
+        outI += diff * outWidth;
+        WebRtc_Word32 colorLength = (diff >> 1) * (outWidth >> 1);
+        memset(outCr, 127, colorLength);
+        memset(outCb, 127, colorLength);
+        outCr += colorLength;
+        outCb += colorLength;
+
+        // pad bottom
+        memset(outI + outWidth * inHeight, 0, diff * outWidth);
+        memset(outCr + (outWidth * inHeight >> 2), 127, colorLength);
+        memset(outCb + (outWidth * inHeight >> 2), 127, colorLength);
+    }
+    // pad width?
+    if (inWidth < outWidth)
+    {
+        padDiffLow = (outWidth - inWidth) >> 1; // in pixels
+        padDiffHigh = (outWidth - inWidth) - padDiffLow; // in pixels
+    }
+    WebRtc_UWord32 height = 0;
+    if (inHeight > outHeight)
+        height = outHeight;
+    else
+        height = inHeight;
+
+    for (; i< (height >> 1); i++) // 2 rows per loop
+    {
+        // pad beginning of row?
+        if (padDiffLow)
+        {
+            // pad row
+            memset(outI,0,padDiffLow);
+            memset(outCr,127,padDiffLow >> 1);
+            memset(outCb,127,padDiffLow >> 1);
+            outI += padDiffLow;
+            outCr += padDiffLow >> 1;
+            outCb += padDiffLow >> 1;
+        }
+
+        for (j = 0; j < (inWidth >> 1); j++) // 2 pixels per loop
+        {
+            outI[0] = inFrame[1];
+            *outCr = inFrame[0];
+            outI[1] = inFrame[3];
+            *outCb = inFrame[2];
+            inFrame += 4;
+            outI += 2;
+            outCr++;
+            outCb++;
+        }
+        // pad end of row?
+        if (padDiffHigh)
+        {
+            memset(outI,0,padDiffHigh);
+            memset(outCr,127,padDiffHigh >> 1);
+            memset(outCb,127,padDiffHigh >> 1);
+            outI += padDiffHigh;
+            outCr += padDiffHigh >> 1;
+            outCb += padDiffHigh >> 1;
+        }
+        // next row
+        // pad beginning of row?
+        memset(outI,0,padDiffLow);
+        outI += padDiffLow;
+
+        for (j = 0; j < (inWidth >> 1);j++)
+        {
+            outI[0] = inFrame[1];
+            outI[1] = inFrame[3];
+            inFrame += 4;
+            outI += 2;
+        }
+        // pad end of row?
+        if (padDiffHigh)
+        {
+            memset(outI,0,padDiffHigh);
+            outI += padDiffHigh;
+        } else
+        {
+            // cut row
+            for (j = 0; j < (outWidth >> 1); j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[1];
+                *outCr = inFrame[0];
+                outI[1] = inFrame[3];
+                *outCb = inFrame[2];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            inFrame += cutDiff * 2;
+            // next row
+            for (j = 0; j < (outWidth >> 1);j++)
+            {
+                outI[0] = inFrame[1];
+                outI[1] = inFrame[3];
+                inFrame += 4;
+                outI += 2;
+            }
+            inFrame += cutDiff * 2;
+        }
+    }
+    return outWidth * (outHeight >> 1) * 3;
+}
+
+WebRtc_Word32
+ConvertUYVYToI420interlaced(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                            WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                            WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || inHeight < 1 || outHeight < 1 || outWidth < 1)
+    {
+        return -1;
+    }
+    WebRtc_Word32 i = 0;
+    WebRtc_UWord32 j = 0;
+    WebRtc_Word32 cutDiff = 0; // in pixels
+    WebRtc_Word32 padDiffLow = 0; // in pixels
+    WebRtc_Word32 padDiffHigh = 0; // in pixels
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + outWidth * outHeight;
+    WebRtc_UWord8* outCb = outFrame + outWidth * outHeight + outWidth * ( outHeight >> 2 );
+
+    // cut height?
+    if (inHeight > outHeight)
+    {
+        // parse away half of the lines
+        inFrame += (( inHeight - outHeight ) / 2) * inWidth * 2;
+    }
+    // cut width?
+    if (inWidth > outWidth)
+    {
+        cutDiff = (inWidth - outWidth); // in pixels
+        // start half of the width diff into the line
+        inFrame += cutDiff; // each pixel is 2 bytes hence diff is the correct value in bytes
+    }
+    // pad height?
+    if (inHeight < outHeight)
+    {
+        // pad top
+        WebRtc_Word32 diff = (outHeight - inHeight) >> 1;
+        memset(outI, 0, diff * outWidth);
+        outI += diff * outWidth;
+        WebRtc_Word32 colorLength =(diff >> 1) * (outWidth >> 1);
+        memset(outCr, 127, colorLength);
+        memset(outCb, 127, colorLength);
+        outCr += colorLength;
+        outCb += colorLength;
+
+        // pad bottom
+        memset(outI+outWidth * inHeight, 0, diff * outWidth);
+        memset(outCr+(outWidth * inHeight >> 2), 127, colorLength);
+        memset(outCb+(outWidth * inHeight >> 2), 127, colorLength);
+    }
+    // pad width?
+    if (inWidth < outWidth)
+    {
+        padDiffLow = (outWidth - inWidth) >> 1; // in pixels
+        padDiffHigh = (outWidth - inWidth) - padDiffLow; // in pixels
+    }
+    WebRtc_Word32 height = 0;
+    if (inHeight > outHeight)
+        height = outHeight;
+    else
+        height = inHeight;
+
+    for (; i < (height >> 1); i++) // 2 rows per loop
+    {
+        // pad beginning of row?
+        if (padDiffLow)
+        {
+            // pad row
+            memset(outI,0,padDiffLow);
+            memset(outCr,127,padDiffLow >> 1);
+            memset(outCb,127,padDiffLow >> 1);
+            outI += padDiffLow;
+            outCr += padDiffLow / 2;
+            outCb += padDiffLow / 2;
+
+            for (j = 0; j < (inWidth >> 1); j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[1];
+                *outCr = inFrame[0];
+                outI[1] = inFrame[3];
+                *outCb = inFrame[2];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                memset(outCr,127,padDiffHigh >> 1);
+                memset(outCb,127,padDiffHigh >> 1);
+                outI += padDiffHigh;
+                outCr += padDiffHigh >> 1;
+                outCb += padDiffHigh >> 1;
+            }
+            // next row
+            // pad beginning of row?
+            memset(outI,0,padDiffLow);
+            outI += padDiffLow;
+
+            for (j = 0; j < (inWidth >> 1); j++)
+            {
+                outI[0] = inFrame[1];
+                outI[1] = inFrame[3];
+                inFrame += 4;
+                outI += 2;
+            }
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                outI += padDiffHigh;
+            }
+        } else
+        {
+            // cut row
+            for (j = 0; j < (outWidth >> 1); j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[1];
+                *outCr = inFrame[0];
+                outI[1] = inFrame[3];
+                *outCb = inFrame[2];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            inFrame -= (outWidth * 2);
+            const WebRtc_UWord8 *inFrame2 = inFrame + (inWidth * 2) * 2;
+
+            if(i + 1 == (height >> 1))
+            {
+                // last row
+                for (j = 0; j < (outWidth >> 1); j++)
+                {
+                    // copy last row
+                    outI[0] = inFrame[1];
+                    outI[1] = inFrame[3];
+                    inFrame += 4;
+                    inFrame2 += 4;
+                    outI += 2;
+                }
+            } else
+            {
+                // next row
+                for (j = 0; j < (outWidth >> 1); j++)
+                {
+                    outI[0] = (inFrame[1] + inFrame2[1]) >> 1;
+                    outI[1] = (inFrame[3] + inFrame2[1]) >> 1;
+                    inFrame += 4;
+                    inFrame2 += 4;
+                    outI += 2;
+                }
+            }
+            inFrame += cutDiff * 2;
+            inFrame += inWidth * 2; // skip next row
+        }
+    }
+    return outWidth * (outHeight >> 1) * 3;
+}
+
+WebRtc_Word32
+ConvertUYVYToI420(WebRtc_UWord32 width,WebRtc_UWord32 height, const WebRtc_UWord8* inFrame,
+                  WebRtc_UWord8* outFrame)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 i = 0;
+    WebRtc_UWord32 j = 0;
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + width * height;
+    WebRtc_UWord8* outCb = outFrame + width * height + width * (height >> 2);
+    for (; i< (height >> 1);i++)
+    {
+        for (j = 0; j < (width >> 1); j++)
+        {
+            outI[0] = inFrame[1];
+            *outCr = inFrame[0];
+            outI[1] = inFrame[3];
+            *outCb = inFrame[2];
+            inFrame += 4;
+            outI += 2;
+            outCr++;
+            outCb++;
+        }
+        for (j = 0; j < (width >> 1); j++)
+        {
+            outI[0] = inFrame[1];
+            outI[1] = inFrame[3];
+            inFrame += 4;
+            outI += 2;
+        }
+    }
+    return width * (height >> 1) * 3;
+}
+
+WebRtc_Word32
+ConvertYUY2ToI420interlaced(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                            WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame,
+                            WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || inHeight < 1 || outHeight < 1 || outWidth < 1)
+    {
+        return -1;
+    }
+    // use every other row and interpolate the removed row
+    WebRtc_UWord32 i = 0;
+    WebRtc_UWord32 j = 0;
+    WebRtc_Word32 cutDiff = 0; // in pixels
+    WebRtc_Word32 padDiffLow = 0; // in pixels
+    WebRtc_Word32 padDiffHigh = 0; // in pixels
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* inPtr3 = (WebRtc_UWord8*)inFrame + inWidth * 2 * 2; // ptr to third row
+    WebRtc_UWord8* outCr = outFrame + outWidth * outHeight;
+    WebRtc_UWord8* outCb = outFrame +outWidth * outHeight + outWidth * (outHeight >> 2);
+
+    // cut height?
+    if(inHeight > outHeight)
+    {
+        // parse away half of the lines
+        inFrame += ((inHeight - outHeight) / 2) * inWidth * 2;
+        inPtr3 += ((inHeight - outHeight) / 2) * inWidth * 2;
+    }
+    // cut width?
+    if(inWidth > outWidth)
+    {
+        cutDiff = (inWidth - outWidth); // in pixels
+        // start half of the width diff into the line
+        inPtr3 += cutDiff;
+        inFrame += cutDiff; // each pixel is 2 bytes hence diff is the correct value in bytes
+    }
+    // pad height?
+    if(inHeight < outHeight)
+    {
+        // pad top
+        WebRtc_Word32 diff = (outHeight - inHeight) / 2;
+        memset(outI, 0, diff * outWidth);
+        outI += diff * outWidth;
+        WebRtc_Word32 colorLength =(diff / 2) * (outWidth / 2);
+        memset(outCr, 127, colorLength);
+        memset(outCb, 127, colorLength);
+        outCr+= colorLength;
+        outCb+= colorLength;
+
+        // pad bottom
+        memset(outI + outWidth * inHeight, 0, diff * outWidth);
+        memset(outCr + (outWidth * inHeight / 4), 127, colorLength);
+        memset(outCb + (outWidth * inHeight / 4), 127, colorLength);
+    }
+    // pad width?
+    if(inWidth < outWidth)
+    {
+        padDiffLow = (outWidth - inWidth) / 2; // in pixels
+        padDiffHigh = (outWidth - inWidth) - padDiffLow; // in pixels
+    }
+    WebRtc_UWord32 height = 0;
+    if(inHeight > outHeight)
+        height = outHeight;
+    else
+        height = inHeight;
+
+    for (; i< (height >> 1);i++) // 2 rows per loop
+    {
+        // pad beginning of row?
+        if(padDiffLow)
+        {
+            // pad row
+            memset(outI,0,padDiffLow);
+            memset(outCr,127,padDiffLow / 2);
+            memset(outCb,127,padDiffLow / 2);
+            outI += padDiffLow;
+            outCr += padDiffLow / 2;
+            outCb += padDiffLow / 2;
+
+            for (j = 0; j< (inWidth >> 1);j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[0];
+                *outCr = inFrame[1];
+                outI[1] = inFrame[2];
+                *outCb = inFrame[3];
+                inFrame +=4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                memset(outCr,127,padDiffHigh / 2);
+                memset(outCb,127,padDiffHigh / 2);
+                outI += padDiffHigh;
+                outCr += padDiffHigh / 2;
+                outCb += padDiffHigh / 2;
+            }
+            // next row
+            // pad beginning of row?
+            memset(outI,0,padDiffLow);
+            outI += padDiffLow;
+            inFrame -= inWidth * 2;
+            if (i == (height >> 1) - 1)
+            {
+                // last loop
+                // copy the last row
+                for (j = 0; j< (inWidth >> 1); j++)
+                {
+                    outI[0] = inFrame[0];
+                    outI[1] = inFrame[2];
+                    inFrame += 4;
+                    outI += 2;
+                }
+            } else
+            {
+                // turn back inFrame
+                for (j = 0; j < (inWidth >> 1); j++)
+                {
+                    outI[0] = (inFrame[0] + inPtr3[0]) >> 1;
+                    outI[1] = (inFrame[2] + inPtr3[2]) >> 1;
+                    inFrame += 4;
+                    inPtr3 += 4;
+                    outI += 2;
+                }
+                inFrame += inWidth * 2;
+                inPtr3 += inWidth * 2;
+            }
+
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                outI += padDiffHigh;
+            }
+        } else
+        {
+            // cut row
+            for (j = 0; j < (outWidth >> 1); j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[0];
+                *outCr = inFrame[1];
+                outI[1] = inFrame[2];
+                *outCb = inFrame[3];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            inFrame += cutDiff * 2;
+            inFrame -= inWidth * 2;
+
+            if (i == (height >> 1) -1)
+            {
+                // last loop
+                // copy the last row
+                for (j = 0; j < (outWidth >> 1);j++)
+                {
+                    outI[0] = inFrame[0];
+                    outI[1] = inFrame[2];
+                    inFrame +=4;
+                    outI += 2;
+                }
+            } else
+            {
+                // next row
+                for (j = 0; j< (outWidth >> 1);j++)
+                {
+                    outI[0] = (inFrame[0] + inPtr3[0]) >> 1;
+                    outI[1] = (inFrame[2] + inPtr3[2]) >> 1;
+                    inPtr3 += 4;
+                    inFrame += 4;
+                    outI += 2;
+                }
+                inFrame += cutDiff * 2;
+                inPtr3 += cutDiff * 2;
+            }
+            inFrame += inWidth * 2;
+            inPtr3 += inWidth * 2;
+        }
+    }
+    return outWidth * (outHeight >> 1) * 3;
+}
+
+WebRtc_Word32
+ConvertYUY2ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth, WebRtc_UWord32 inHeight,
+                  WebRtc_UWord8* outFrame, WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || inHeight < 1 || outHeight < 1 || outWidth < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 i = 0;
+    WebRtc_UWord32 j = 0;
+    WebRtc_Word32 cutDiff = 0; // in pixels
+    WebRtc_Word32 padDiffLow = 0; // in pixels
+    WebRtc_Word32 padDiffHigh = 0; // in pixels
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + outWidth * outHeight;
+    WebRtc_UWord8* outCb = outFrame + outWidth * outHeight + outWidth * (outHeight >> 2);
+
+    // cut height?
+    if (inHeight > outHeight)
+    {
+        // parse away half of the lines
+        inFrame += ((inHeight - outHeight) >> 1) * inWidth * 2;
+    }
+    // cut width?
+    if (inWidth > outWidth)
+    {
+        cutDiff = (inWidth - outWidth); // in pixels
+        // start half of the width diff into the line
+        inFrame += cutDiff; // each pixel is 2 bytes hence diff is the correct value in bytes
+    }
+    // pad height?
+    if (inHeight < outHeight)
+    {
+        // pad top
+        WebRtc_Word32 diff = (outHeight - inHeight) >> 1;
+        memset(outI, 0, diff * outWidth);
+        outI += diff * outWidth;
+        WebRtc_Word32 colorLength =(diff >> 1) * (outWidth >> 1);
+        memset(outCr, 127, colorLength);
+        memset(outCb, 127, colorLength);
+        outCr += colorLength;
+        outCb += colorLength;
+
+        // pad bottom
+        memset(outI + outWidth * inHeight, 0, diff * outWidth);
+        memset(outCr + (outWidth * inHeight >> 2), 127, colorLength);
+        memset(outCb + (outWidth * inHeight >> 2), 127, colorLength);
+    }
+    // pad width?
+    if (inWidth < outWidth)
+    {
+        padDiffLow = (outWidth - inWidth) >> 1; // in pixels
+        padDiffHigh = (outWidth - inWidth) - padDiffLow; // in pixels
+    }
+    WebRtc_UWord32 height = 0;
+    if (inHeight > outHeight)
+        height = outHeight;
+    else
+        height = inHeight;
+
+    for (; i< (height >> 1); i++) // 2 rows per loop
+    {
+        // pad beginning of row?
+        if (padDiffLow)
+        {
+            // pad row
+            memset(outI,0,padDiffLow);
+            memset(outCr,127,padDiffLow >> 1);
+            memset(outCb,127,padDiffLow >> 1);
+            outI += padDiffLow;
+            outCr += padDiffLow >> 1;
+            outCb += padDiffLow >> 1;
+
+            for (j = 0; j< (inWidth >> 1);j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[0];
+                *outCr = inFrame[1];
+                outI[1] = inFrame[2];
+                *outCb = inFrame[3];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                memset(outCr,127,padDiffHigh >> 1);
+                memset(outCb,127,padDiffHigh >> 1);
+                outI += padDiffHigh;
+                outCr += padDiffHigh >> 1;
+                outCb += padDiffHigh >> 1;
+            }
+            // next row
+            // pad beginning of row?
+            memset(outI,0,padDiffLow);
+            outI += padDiffLow;
+
+            for (j = 0; j< (inWidth >> 1); j++)
+            {
+                outI[0] = inFrame[0];
+                outI[1] = inFrame[2];
+                inFrame += 4;
+                outI += 2;
+            }
+            // pad end of row?
+            if (padDiffHigh)
+            {
+                memset(outI,0,padDiffHigh);
+                outI += padDiffHigh;
+            }
+        } else
+        {
+            // cut row
+            for (j = 0; j < (outWidth >> 1); j++) // 2 pixels per loop
+            {
+                outI[0] = inFrame[0];
+                *outCr = inFrame[1];
+                outI[1] = inFrame[2];
+                *outCb = inFrame[3];
+                inFrame += 4;
+                outI += 2;
+                outCr++;
+                outCb++;
+            }
+            inFrame += cutDiff * 2;
+            // next row
+            for (j = 0; j < (outWidth >> 1); j++)
+            {
+                outI[0] = inFrame[0];
+                outI[1] = inFrame[2];
+                inFrame += 4;
+                outI += 2;
+            }
+            inFrame += cutDiff * 2;
+        }
+    }
+    return outWidth * (outHeight >> 1) * 3;
+}
+
+WebRtc_Word32
+ConvertYUY2ToI420(WebRtc_UWord32 width, WebRtc_UWord32 height,const WebRtc_UWord8* inFrame,
+                  WebRtc_UWord8* outFrame)
+{
+#ifndef SCALEOPT
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 i =0;
+    WebRtc_UWord32 j =0;
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + width * height;
+    WebRtc_UWord8* outCb = outFrame +width * height + width * (height >> 2);
+
+    for (; i < (height >> 1); i++)
+    {
+        for (j = 0; j < (width >> 1); j++)
+        {
+            outI[0] = inFrame[0];
+            *outCr = inFrame[1];
+            outI[1] = inFrame[2];
+            *outCb = inFrame[3];
+            inFrame += 4;
+            outI += 2;
+            outCr++;
+            outCb++;
+        }
+        for (j = 0; j < (width >> 1); j++)
+        {
+            outI[0] = inFrame[0];
+            outI[1] = inFrame[2];
+            inFrame += 4;
+            outI += 2;
+        }
+    }
+#else
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_Word32 i =0;
+    WebRtc_Word32 j =0;
+    WebRtc_UWord8* outI = outFrame;
+    WebRtc_UWord8* outCr = outFrame + width * height;
+    WebRtc_UWord8* outCb = outFrame + width * height + width * (height >> 2);
+
+    WebRtc_Word32 height_half = height / 2;
+
+    _asm{
+    mov       esi, DWORD PTR [width]
+    mov       edx, DWORD PTR [height_half]
+
+    ; prepare masks:
+    pxor      xmm0, xmm0
+    pcmpeqd   xmm1, xmm1
+    punpcklbw xmm1, xmm0
+    pcmpeqd   xmm2, xmm2
+    punpcklbw xmm0, xmm2
+    test      edx, edx
+    jle       exit_
+
+    xor       ebx, ebx
+    mov       edi, DWORD PTR [outFrame]
+    sar       esi, 4
+    test      esi, esi
+    jle       exit_
+
+    loop0:
+    add       ebx, 1
+
+    mov       DWORD PTR [i], ebx
+    mov       ebx, DWORD PTR [inFrame]
+    mov       edx, DWORD PTR [outCr]
+    mov       eax, DWORD PTR [outCb]
+    xor       ecx, ecx
+
+    loop1:
+
+    movdqa    xmm5, xmm1
+
+    movdqa    xmm2, xmm1
+    movdqu    xmm4, XMMWORD PTR [ebx]
+    movdqu    xmm3, XMMWORD PTR [ebx+16]
+
+    add       ebx, 32
+    pand      xmm5, xmm4
+    pand      xmm4, xmm0
+    psrldq    xmm4, 1
+    pand      xmm2, xmm3
+    pand      xmm3, xmm0
+    psrldq    xmm3, 1
+
+    packuswb  xmm5, xmm2
+
+    movdqu    XMMWORD PTR [edi], xmm5
+    movdqa    xmm2, xmm1
+    packuswb  xmm4, xmm3
+    pand      xmm2, xmm4
+    pand      xmm4, xmm0
+    psrldq    xmm4, 1
+    packuswb  xmm2, xmm4
+
+    movq      QWORD PTR [edx], xmm2
+    psrldq    xmm2, 8
+    movq      QWORD PTR [eax], xmm2
+
+    add       edi, 16
+    add       edx, 8
+    add       eax, 8
+    add       ecx, 1
+    cmp       ecx, esi
+    jl        loop1
+
+    mov       DWORD PTR [outCb], eax
+    mov       DWORD PTR [outCr], edx
+    mov       edx, DWORD PTR [height_half]
+    mov       DWORD PTR [inFrame], ebx
+    mov       ebx, DWORD PTR [i]
+
+    test      esi, esi
+    jle       exit_
+
+    mov       eax, DWORD PTR [inFrame] //now becomes 00568FE8
+    xor       ecx, ecx
+
+    loop2:
+
+    movdqu    xmm3, XMMWORD PTR [eax]
+    movdqu    xmm2, XMMWORD PTR [eax+16]
+    add       eax, 32
+    pand      xmm3, xmm1
+    pand      xmm2, xmm1
+    packuswb  xmm3, xmm2
+    movdqu    XMMWORD PTR [edi], xmm3
+
+    add       edi, 16
+    add       ecx, 1
+    cmp       ecx, esi
+    jl        loop2
+
+    mov       DWORD PTR [inFrame], eax //now 005692A8
+    mov       eax, DWORD PTR [width]
+    cmp       ebx, edx
+    jl        loop0
+    exit_:
+    }
+#endif
+    return width * (height >> 1) * 3;
+}
+
+// make a center cut
+WebRtc_Word32
+CutI420Frame(WebRtc_UWord8* frame, WebRtc_UWord32 fromWidth, WebRtc_UWord32 fromHeight,
+             WebRtc_UWord32 toWidth, WebRtc_UWord32 toHeight)
+{
+    if (toWidth < 1 || fromWidth < 1 || toHeight < 1 || fromHeight < 1 )
+    {
+        return -1;
+    }
+    if (toWidth == fromWidth && toHeight == fromHeight)
+    {
+        // nothing to do
+      return 3 * toHeight * toWidth / 2;
+    }
+    if (toWidth > fromWidth || toHeight > fromHeight)
+    {
+        // error
+        return -1;
+    }
+    WebRtc_UWord32 i = 0;
+    WebRtc_Word32 m = 0;
+    WebRtc_UWord32 loop = 0;
+    WebRtc_UWord32 halfToWidth = toWidth / 2;
+    WebRtc_UWord32 halfToHeight = toHeight / 2;
+    WebRtc_UWord32 halfFromWidth = fromWidth / 2;
+    WebRtc_UWord32 halfFromHeight= fromHeight / 2;
+    WebRtc_UWord32 cutHeight = ( fromHeight - toHeight ) / 2; //12
+    WebRtc_UWord32 cutWidth = ( fromWidth - toWidth ) / 2; // 16
+
+    for (i = fromWidth * cutHeight + cutWidth; loop < toHeight ; loop++, i += fromWidth)
+    {
+        memcpy(&frame[m],&frame[i],toWidth);
+        m += toWidth;
+    }
+    i = fromWidth * fromHeight; // ilum
+    loop = 0;
+    for ( i += (halfFromWidth * cutHeight / 2 + cutWidth / 2);
+          loop < halfToHeight; loop++,i += halfFromWidth)
+    {
+        memcpy(&frame[m],&frame[i],halfToWidth);
+        m += halfToWidth;
+    }
+    loop = 0;
+    i = fromWidth * fromHeight + halfFromHeight * halfFromWidth; // ilum +Cr
+    for( i += (halfFromWidth * cutHeight / 2 + cutWidth / 2); loop < halfToHeight; loop++, i += halfFromWidth)
+    {
+        memcpy(&frame[m],&frame[i],halfToWidth);
+        m += halfToWidth;
+    }
+    return halfToWidth * toHeight * 3;// new size  64*96*3; // 128/2 == 64
+}
+
+WebRtc_Word32
+ConvertI420ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth,
+                  WebRtc_UWord32 inHeight, WebRtc_UWord8* outFrame, WebRtc_UWord32 outWidth,
+                  WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || outWidth < 1 || inHeight < 1 || outHeight < 1 )
+    {
+        return -1;
+    }
+    if (inWidth == outWidth && inHeight == outHeight)
+    {
+        memcpy(outFrame, inFrame, 3*outWidth*(outHeight>>1));
+    } else
+    {
+        if( inHeight < outHeight)
+        {
+            // pad height
+            WebRtc_Word32 padH = outHeight - inHeight;
+            WebRtc_UWord32 i =0;
+            WebRtc_Word32 padW = 0;
+            WebRtc_Word32 cutW = 0;
+            WebRtc_Word32 width = inWidth;
+            if (inWidth < outWidth)
+            {
+                // pad width
+                padW = outWidth - inWidth;
+            } else
+            {
+              // cut width
+              cutW = inWidth - outWidth;
+              width = outWidth;
+            }
+            if (padH)
+            {
+                memset(outFrame, 0, outWidth * (padH >> 1));
+                outFrame +=  outWidth * (padH >> 1);
+            }
+            for (i = 0; i < inHeight;i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 0, padW / 2);
+                    outFrame +=  padW / 2;
+                }
+                inFrame += cutW >> 1; // in case we have a cut
+                memcpy(outFrame,inFrame ,width);
+                inFrame += cutW >> 1;
+                outFrame += width;
+                inFrame += width;
+                if (padW)
+                {
+                    memset(outFrame, 0, padW / 2);
+                    outFrame +=  padW / 2;
+                }
+            }
+            if (padH)
+            {
+                memset(outFrame, 0, outWidth * (padH >> 1));
+                outFrame +=  outWidth * (padH >> 1);
+            }
+            if (padH)
+            {
+                memset(outFrame, 127, (outWidth >> 2) * (padH >> 1));
+                outFrame +=  (outWidth >> 2) * (padH >> 1);
+            }
+            for (i = 0; i < (inHeight >> 1); i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+                inFrame += cutW >> 2; // in case we have a cut
+                memcpy(outFrame, inFrame,width >> 1);
+                inFrame += cutW >> 2;
+                outFrame += width >> 1;
+                inFrame += width >> 1;
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+            }
+            if (padH)
+            {
+                memset(outFrame, 127, (outWidth >> 1) * (padH >> 1));
+                outFrame +=  (outWidth >> 1) * (padH >> 1);
+            }
+            for (i = 0; i < (inHeight >> 1); i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+                inFrame += cutW >> 2; // in case we have a cut
+                memcpy(outFrame, inFrame,width >> 1);
+                inFrame += cutW >> 2;
+                outFrame += width >> 1;
+                inFrame += width >> 1;
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame += padW >> 2;
+                }
+            }
+            if (padH)
+            {
+                memset(outFrame, 127, (outWidth >> 2) * (padH >> 1));
+                outFrame +=  (outWidth >> 2) * (padH >> 1);
+            }
+        } else
+        {
+            // cut height
+            WebRtc_UWord32 i =0;
+            WebRtc_Word32 padW = 0;
+            WebRtc_Word32 cutW = 0;
+            WebRtc_Word32 width = inWidth;
+
+            if (inWidth < outWidth)
+            {
+                // pad width
+                padW = outWidth - inWidth;
+            } else
+            {
+                // cut width
+                cutW = inWidth - outWidth;
+                width = outWidth;
+            }
+            WebRtc_Word32 diffH = inHeight - outHeight;
+            inFrame += inWidth * (diffH >> 1);  // skip top I
+
+            for (i = 0; i < outHeight; i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 0, padW / 2);
+                    outFrame +=  padW / 2;
+                }
+                inFrame += cutW >> 1; // in case we have a cut
+                memcpy(outFrame,inFrame ,width);
+                inFrame += cutW >> 1;
+                outFrame += width;
+                inFrame += width;
+                if (padW)
+                {
+                    memset(outFrame, 0, padW / 2);
+                    outFrame +=  padW / 2;
+                }
+            }
+            inFrame += inWidth * (diffH >> 1);  // skip end I
+            inFrame += (inWidth >> 2) * (diffH >> 1); // skip top of Cr
+            for (i = 0; i < (outHeight >> 1); i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+                inFrame += cutW >> 2; // in case we have a cut
+                memcpy(outFrame, inFrame,width >> 1);
+                inFrame += cutW >> 2;
+                outFrame += width >> 1;
+                inFrame += width >> 1;
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+            }
+            inFrame += (inWidth >> 2) * (diffH >> 1); // skip end of Cr
+            inFrame += (inWidth >> 2) * (diffH >> 1); // skip top of Cb
+            for (i = 0; i < (outHeight >> 1); i++)
+            {
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+                inFrame += cutW >> 2; // in case we have a cut
+                memcpy(outFrame, inFrame, width >> 1);
+                inFrame += cutW >> 2;
+                outFrame += width >> 1;
+                inFrame += width >> 1;
+                if (padW)
+                {
+                    memset(outFrame, 127, padW >> 2);
+                    outFrame +=  padW >> 2;
+                }
+            }
+        }
+    }
+    return 3 * outWidth * (outHeight >> 1);
+}
+
+WebRtc_Word32
+ConvertRGB24ToARGB(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                   WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    }
+    else if (strideOut < width)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord32 i, j, offset;
+
+    outFrame += strideOut * (height - 1) * 4;
+    for(i = 0; i < height; i++)
+    {
+        for(j = 0; j < width; j++)
+        {
+            offset = j*4;
+            outFrame[0 + offset] = inFrame[0];
+            outFrame[1 + offset] = inFrame[1];
+            outFrame[2 + offset] = inFrame[2];
+            outFrame[3 + offset] = 0xff;
+            inFrame += 3;
+        }
+        outFrame -= 4 * (strideOut - width);
+    }
+    return strideOut * height * 4;
+}
+
+WebRtc_Word32
+ConvertRGB24ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 inWidth, WebRtc_UWord32 inHeight,
+                   WebRtc_UWord8* outFrame, WebRtc_UWord32 outWidth, WebRtc_UWord32 outHeight)
+{
+    if (inWidth < 1 || outWidth < 1 || inHeight < 1 || outHeight < 1 )
+    {
+        return -1;
+    }
+    WebRtc_UWord32* yStartPtr = (WebRtc_UWord32*)(outFrame + (outWidth * outHeight));
+    WebRtc_UWord8* uStartPtr = outFrame + (outWidth * outHeight) + ((outWidth * outHeight) >> 2);
+    WebRtc_UWord8* vStartPtr = outFrame + (outWidth * outHeight) +((outWidth * outHeight) >> 1);
+
+    yStartPtr--;
+    uStartPtr--;
+    vStartPtr--;
+    const WebRtc_UWord8* inpPtr;
+    const WebRtc_UWord8* inFramePtr = inFrame;
+    WebRtc_Word32 offset = 0;
+    WebRtc_Word32 height = inHeight;
+    WebRtc_Word32 cutDiff = 0;
+    WebRtc_Word32 padDiffLow= 0;
+    WebRtc_Word32 padDiffHigh = 0;
+
+    if (inHeight > outHeight)
+    {
+        // cut height
+        inFramePtr += inWidth*3 * ((inHeight - outHeight) >> 1); // skip the first diff/2 rows
+        height = outHeight;
+    }
+    if (outHeight > inHeight)
+    {
+        // Pad height.
+        WebRtc_UWord8* outI = outFrame;
+        WebRtc_UWord8* outCr = outFrame + outWidth * outHeight;
+        WebRtc_UWord8* outCb = outCr + ((outWidth * outHeight) >> 2);
+
+        // -- I --
+        WebRtc_UWord32 padHeight = outHeight - inHeight;
+        WebRtc_UWord32 padHeightT = padHeight >> 1;
+        WebRtc_UWord32 padHeightB = padHeight - padHeightT;
+        WebRtc_UWord32 padLength = padHeightT * outWidth;
+        memset(outI, 0, padLength); // Pad the top.
+        outI += padLength;
+
+        outI += outWidth * inHeight; // Skip the image.
+        padLength = padHeightB * outWidth;
+        memset(outI, 0, padLength); // Pad the bottom.
+
+        // Shift the out poWebRtc_Word32er.
+        yStartPtr -= (padLength >> 2); // (>> 2) due to WebRtc_Word32 pointer.
+
+        // -- Cr and Cb --
+        padHeight >>= 1;
+        padHeightT >>= 1;
+        padHeightB = padHeight - padHeightT;
+
+        padLength = padHeightT * (outWidth >> 1);
+        memset(outCr, 127, padLength); // Pad the top.
+        memset(outCb, 127, padLength);
+        outCr += padLength;
+        outCb += padLength;
+
+        padLength = (outWidth * inHeight) >> 2;
+        outCr += padLength; // Skip the image.
+        outCb += padLength;
+        padLength = padHeightB * (outWidth >> 1);
+        memset(outCr, 127, padLength); // Pad the bottom.
+        memset(outCb, 127, padLength);
+
+        // Shift the out pointers.
+        uStartPtr -= padLength;
+        vStartPtr -= padLength;
+    }
+    // cut width?
+    if (inWidth > outWidth)
+    {
+        cutDiff = (inWidth - outWidth) >> 1; // in pixels
+    }
+    // pad width?
+    if (inWidth < outWidth)
+    {
+        padDiffLow = (outWidth - inWidth) >> 1; // in pixels
+        padDiffHigh = (outWidth - inWidth) - padDiffLow; // in pixels
+    }
+
+    for (WebRtc_Word32 y = 0; y < height; y++)
+    {
+        offset = y * inWidth * 3;
+        inpPtr = &inFramePtr[offset + (inWidth - 4) * 3]; // right to left
+        inpPtr -= 3*cutDiff;
+        WebRtc_Word32 i = (inWidth - (cutDiff * 2)) >> 2;
+        WebRtc_UWord32 tmp;
+        if (padDiffLow)
+        {
+            yStartPtr -= padDiffLow >> 2; //div by 4 since its a WebRtc_Word32 ptr
+            memset(yStartPtr + 1, 0, padDiffLow);
+        }
+        for (; i > 0; i--) // do 4 pixels wide in one loop
+        {
+#ifdef  WEBRTC_BIG_ENDIAN
+            tmp = (WebRtc_UWord8)((66 * inpPtr[2] + 129 * inpPtr[1] + 25 * inpPtr[0] + 128)
+                   >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[4] + 25 * inpPtr[3] + 128)
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 *  inpPtr[8] + 129 * inpPtr[7] + 25 * inpPtr[6] + 128)
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[11] + 129 * inpPtr[10] + 25 * inpPtr[9] + 128)
+                    >> 8) + 16;
+
+#else
+            tmp = (WebRtc_UWord8)((66 * inpPtr[11] + 129 * inpPtr[10] + 25 * inpPtr[9] + 128) >> 8)
+                   + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[8] + 129 * inpPtr[7] + 25 * inpPtr[6] + 128) >> 8)
+                    + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[4] + 25 * inpPtr[3] + 128) >> 8)
+                    + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[2] + 129 * inpPtr[1] + 25 * inpPtr[0] + 128) >> 8)
+                    + 16;
+#endif
+            *yStartPtr = tmp;
+            yStartPtr--;
+            inpPtr -= 12;
+        }
+        if (padDiffHigh)
+        {
+            yStartPtr -= padDiffHigh >> 2; //div by 4 since its a WebRtc_Word32 ptr
+            memset(yStartPtr + 1, 0, padDiffHigh);
+        }
+        y++; // doing an ugly add to my loop variable
+        offset = y * inWidth * 3;
+        inpPtr = &inFramePtr[offset + (inWidth - 4) * 3];
+        inpPtr -= 3 * cutDiff;
+        i = (inWidth - (cutDiff * 2)) >> 2;
+
+        if (padDiffLow)
+        {
+            yStartPtr -= padDiffLow >> 2; //div by 4 since its a WebRtc_Word32 ptr
+            uStartPtr -= padDiffLow >> 1;
+            vStartPtr -= padDiffLow >> 1;
+            memset(yStartPtr + 1, 0, padDiffLow);
+            memset(uStartPtr + 1, 127, padDiffLow >> 1);
+            memset(vStartPtr + 1, 127, padDiffLow >> 1);
+        }
+        for (; i > 0; i--)
+        {
+            *uStartPtr = (WebRtc_UWord8)((-38 * inpPtr[8] - 74 * inpPtr[7] + 112 * inpPtr[6] + 128)
+                          >> 8) + 128;
+            uStartPtr--;
+            *vStartPtr = (WebRtc_UWord8)((112 * inpPtr[8] - 94 * inpPtr[7] - 18 * inpPtr[6] + 128)
+                          >> 8) + 128;
+            vStartPtr--;
+            *uStartPtr = (WebRtc_UWord8)((-38 * inpPtr[2] - 74 * inpPtr[1] + 112 * inpPtr[0] + 128)
+                          >> 8) + 128;
+            uStartPtr--;
+            *vStartPtr = (WebRtc_UWord8)((112 * inpPtr[2] - 94 * inpPtr[1] - 18 * inpPtr[0] + 128)
+                          >> 8) + 128;
+            vStartPtr--;
+#ifdef WEBRTC_BIG_ENDIAN
+            tmp = (WebRtc_UWord8)((66 * inpPtr[2] + 129 * inpPtr[1] + 25 * inpPtr[0] + 128 )
+                   >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[4] + 25 * inpPtr[3] + 128)
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[8] + 129 * inpPtr[7] + 25 * inpPtr[6] + 128)
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[11] + 129 * inpPtr[10] + 25 * inpPtr[9] + 128)
+                    >> 8) + 16;
+#else
+            tmp = (WebRtc_UWord8)((66 * inpPtr[11] + 129 * inpPtr[10] + 25 * inpPtr[9]+ 128)
+                   >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[8] + 129 * inpPtr[7] + 25 * inpPtr[6] + 128)
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[4] + 25 * inpPtr[3] + 128 )
+                    >> 8) + 16;
+            tmp = tmp << 8;
+            tmp += (WebRtc_UWord8)((66 * inpPtr[2] + 129 * inpPtr[1] + 25 * inpPtr[0] + 128)
+                    >> 8) + 16;
+#endif
+            *yStartPtr = tmp;
+            yStartPtr--;
+            inpPtr -= 12;
+        }
+        if (padDiffHigh)
+        {
+            yStartPtr -= padDiffHigh >> 2; //div by 4 since its a WebRtc_Word32 ptr
+            uStartPtr -= padDiffHigh >> 1;
+            vStartPtr -= padDiffHigh >> 1;
+            memset(yStartPtr + 1, 0, padDiffHigh);
+            memset(uStartPtr + 1, 127, padDiffHigh >> 1);
+            memset(vStartPtr + 1, 127, padDiffHigh >> 1);
+        }
+    }
+    return (outWidth >> 1) * outHeight * 3;
+}
+
+
+WebRtc_Word32
+ConvertRGB24ToI420(WebRtc_UWord32 width, WebRtc_UWord32 height, const WebRtc_UWord8* inFrame,
+                   WebRtc_UWord8* outFrame)
+{
+    if (height < 1 || width < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord8* yStartPtr;
+    WebRtc_UWord8* yStartPtr2;
+    WebRtc_UWord8* uStartPtr;
+    WebRtc_UWord8* vStartPtr;
+    const WebRtc_UWord8* inpPtr;
+    const WebRtc_UWord8* inpPtr2;
+
+    // assuming RGB in a bottom up orientation.
+    yStartPtr = outFrame;
+    yStartPtr2 = yStartPtr + width;
+    uStartPtr = outFrame + (width * height);
+    vStartPtr = uStartPtr + (width * height >> 2);
+    inpPtr = inFrame + width * height * 3 - 3 * width;
+    inpPtr2 = inpPtr - 3 * width;
+
+    for (WebRtc_UWord32 h = 0; h < (height >> 1); h++ )
+    {
+        for (WebRtc_UWord32 w = 0; w < (width >> 1); w++)
+        {
+            //Y
+            yStartPtr[0] =  (WebRtc_UWord8)((66 * inpPtr[2] + 129 * inpPtr[1] + 25 * inpPtr[0]
+                                             + 128) >> 8) + 16;
+            yStartPtr2[0] = (WebRtc_UWord8)((66 * inpPtr2[2] + 129 * inpPtr2[1] + 25 * inpPtr2[0]
+                                             + 128) >> 8) + 16;
+            // moving to next column
+            yStartPtr[1] = (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[4] + 25 * inpPtr[3]
+                                            + 128) >> 8) + 16;
+            yStartPtr2[1] = (WebRtc_UWord8)((66 * inpPtr2[5] + 129 * inpPtr2[4] + 25 * inpPtr2[3]
+                                             + 128) >> 8 ) + 16;
+            //U
+            uStartPtr[0] = (WebRtc_UWord8)((-38 * inpPtr[2] - 74 * inpPtr[1] + 112 * inpPtr[0]
+                                            + 128) >> 8) + 128;
+            //V
+            vStartPtr[0] = (WebRtc_UWord8)((112 * inpPtr[2] -94 * inpPtr[1] -18 * inpPtr[0]
+                                            + 128) >> 8) + 128;
+
+            yStartPtr += 2;
+            yStartPtr2 += 2;
+            uStartPtr++;
+            vStartPtr++;
+            inpPtr += 6;
+            inpPtr2 += 6;
+        } // end for w
+        yStartPtr += width;
+        yStartPtr2 += width;
+        inpPtr -= 9 * width;
+        inpPtr2 -= 9 * width;
+    } // end for h
+    return (width >> 1) * height * 3;
+}
+
+WebRtc_Word32
+ConvertI420ToARGBMac(const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                     WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord32 strideOut)
+{
+    if (height < 1 || width < 1)
+    {
+        return -1;
+    }
+    if (strideOut == 0)
+    {
+        strideOut = width;
+    } else if (strideOut  < width)
+    {
+        return -1;
+    }
+    WebRtc_Word32 diff = strideOut - width;
+    WebRtc_UWord8* out = outFrame;
+    WebRtc_UWord8* out2 = out + strideOut * 4;
+    const WebRtc_UWord8 *y1,*y2, *u, *v;
+    WebRtc_UWord32 h, w;
+    y1 = inFrame;
+    y2 = y1 + width;
+    v = y1 + width * height;
+    u = v + ((width * height) >> 2);
+
+    for (h = (height >> 1); h > 0; h--)
+    {
+      WebRtc_Word32 tmpG, tmpB, tmpR;
+        //do 2 rows at the time
+        for (w = 0; w < (width >> 1); w++)
+        {
+            tmpR = (WebRtc_Word32)((mapYc[y1[0]] + mapVcr[v[0]] + 128  )>> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[0]] + mapUcb[u[0]] + 128 )>> 8);
+            out[2] = Clip(tmpR);
+            out[1] = Clip(tmpG);
+            out[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+            out2[2] = Clip(tmpR);
+            out2[1] = Clip(tmpG);
+            out2[0] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y1[1]] + mapVcr[v[0]] + 128)>> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+            out[6] = Clip(tmpR);
+            out[5] = Clip(tmpG);
+            out[4] = Clip(tmpB);
+
+            tmpR = (WebRtc_Word32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+            tmpG = (WebRtc_Word32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+            tmpB = (WebRtc_Word32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+            out2[6] = Clip(tmpR);
+            out2[5] = Clip(tmpG);
+            out2[4] = Clip(tmpB);
+
+
+            out[3] = 0xff;
+            out[7] = 0xff;
+            out += 8;
+            out2[3] = 0xff;
+            out2[7] = 0xff;
+            out2 += 8;
+            y1 += 2;
+            y2 += 2;
+            u++;
+            v++;
+        }
+
+        y1 += width;
+        y2 += width;
+        out += (width + diff * 2) * 4;
+        out2 += (width + diff * 2) * 4;
+    }
+    return strideOut * height * 4;
+}
+
+WebRtc_Word32
+ConvertRGB565ToI420(const WebRtc_UWord8* inFrame, WebRtc_UWord32 width, WebRtc_UWord32 height,
+                    WebRtc_UWord8* outFrame)
+{
+    if (width < 1 || height < 1 )
+    {
+        return -1;
+    }
+    WebRtc_UWord8 tmpR, tmpG, tmpB;
+    WebRtc_UWord8 tmpR2, tmpG2, tmpB2;
+
+    WebRtc_UWord8* yStartPtr = outFrame;
+    WebRtc_UWord8* yStartPtr2 = yStartPtr + width;
+    WebRtc_UWord8* uStartPtr = outFrame + (width * height);
+    WebRtc_UWord8* vStartPtr = uStartPtr + (width * height >> 2);
+    const WebRtc_UWord16* inpPtr = (const WebRtc_UWord16*)inFrame;
+    inpPtr += width * (height - 1);
+    const WebRtc_UWord16* inpPtr2 = inpPtr - width;
+
+    for (WebRtc_UWord32 h = 0; h < (height >> 1); h++ )
+    {
+        for (WebRtc_UWord32 w = 0; w < (width >> 1); w++)
+        {
+          // calculating 8 bit values
+            tmpB = (WebRtc_UWord8)((inpPtr[0] & 0x001F) << 3);
+            tmpG = (WebRtc_UWord8)((inpPtr[0] & 0x07E0) >> 3);
+            tmpR = (WebRtc_UWord8)((inpPtr[0] & 0xF800) >> 8);
+            tmpB2 = (WebRtc_UWord8)((inpPtr2[0] & 0x001F) << 3);
+            tmpG2 = (WebRtc_UWord8)((inpPtr2[0] & 0x07E0) >> 3);
+            tmpR2 = (WebRtc_UWord8)((inpPtr2[0] & 0xF800) >> 8);
+
+            //Y
+            yStartPtr[0] = (WebRtc_UWord8)((66 * tmpR + 129 * tmpG + 25 * tmpB + 128) >> 8)
+                                            + 16;
+            //U
+            uStartPtr[0] = (WebRtc_UWord8)((-38 * tmpR - 74 * tmpG + 112 * tmpB + 128) >> 8)
+                                            + 128;
+            //V
+            vStartPtr[0] = (WebRtc_UWord8)((112 * tmpR - 94 * tmpG - 18 * tmpB + 128) >> 8)
+                                            + 128;
+
+            yStartPtr2[0] = (WebRtc_UWord8)((66 * tmpR2 + 129 * tmpG2 + 25 * tmpB2 + 128) >> 8)
+                                             + 16;
+
+            // moving to next column
+            tmpB = (WebRtc_UWord8)((inpPtr[1] & 0x001F) << 3);
+            tmpG = (WebRtc_UWord8)((inpPtr[1] & 0x07E0) >> 3);
+            tmpR = (WebRtc_UWord8)((inpPtr[1] & 0xF800) >> 8);
+
+            tmpB2 = (WebRtc_UWord8)((inpPtr2[1] & 0x001F) << 3);
+            tmpG2 = (WebRtc_UWord8)((inpPtr2[1] & 0x07E0) >> 3);
+            tmpR2 = (WebRtc_UWord8)((inpPtr2[1] & 0xF800) >> 8);
+
+            yStartPtr[1] =  (WebRtc_UWord8)((66 * tmpR + 129 * tmpG + 25 * tmpB + 128) >> 8) + 16;
+            yStartPtr2[1] =  (WebRtc_UWord8)((66 * tmpR2 +129 * tmpG2 + 25 * tmpB2 + 128) >> 8) + 16;
+
+            yStartPtr += 2;
+            yStartPtr2 += 2;
+            uStartPtr++;
+            vStartPtr++;
+            inpPtr += 2;
+            inpPtr2 += 2;
+        }
+        yStartPtr += width;
+        yStartPtr2 += width;
+        inpPtr -= 3 * width;
+        inpPtr2 -= 3 * width;
+    }
+    return (width >> 1) * height * 3;
+}
+
+WebRtc_Word32
+ConvertARGBMacToI420(WebRtc_UWord32 width, WebRtc_UWord32 height, const WebRtc_UWord8* inFrame,
+                  WebRtc_UWord8* outFrame)
+{
+    if (height < 1 || width < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord8* yStartPtr;
+    WebRtc_UWord8* yStartPtr2;
+    WebRtc_UWord8* uStartPtr;
+    WebRtc_UWord8* vStartPtr;
+    const WebRtc_UWord8* inpPtr;
+    const WebRtc_UWord8* inpPtr2;
+
+    yStartPtr = outFrame;
+    yStartPtr2 = yStartPtr + width;
+    uStartPtr = outFrame + (width * height);
+    vStartPtr = uStartPtr + (width * height >> 2);
+    inpPtr = inFrame;
+    inpPtr2 = inpPtr + 4 * width;
+    WebRtc_UWord32 h, w;
+    for (h = 0; h < (height >> 1); h++)
+    {
+        for (w = 0; w < (width >> 1); w++)
+        {   //Y
+            yStartPtr[0]  = (WebRtc_UWord8)((66 * inpPtr[1] + 129 * inpPtr[2]
+                                             + 25 * inpPtr[3] + 128) >> 8) + 16;
+            yStartPtr2[0] = (WebRtc_UWord8)((66 * inpPtr2[1] + 129 * inpPtr2[2]
+                                             + 25 * inpPtr2[3] + 128) >> 8) + 16;
+            // moving to next column
+            yStartPtr[1] =  (WebRtc_UWord8)((66 * inpPtr[5] + 129 * inpPtr[6]
+                                             + 25 * inpPtr[7] + 128) >> 8) + 16;
+            yStartPtr2[1] = (WebRtc_UWord8)((66 * inpPtr2[5] + 129 * inpPtr2[6]
+                                             + 25 * inpPtr2[7] + 128) >> 8) + 16;
+            //U
+            uStartPtr[0] = (WebRtc_UWord8)((-38 * inpPtr[1] - 74 * inpPtr[2]
+                                            + 112 * inpPtr[3] + 128) >> 8) + 128;
+            //V
+            vStartPtr[0] = (WebRtc_UWord8)((112 * inpPtr[1] - 94 * inpPtr[2]
+                                            - 18 * inpPtr[3] + 128) >> 8) + 128;
+
+            yStartPtr += 2;
+            yStartPtr2 += 2;
+            uStartPtr++;
+            vStartPtr++;
+            inpPtr += 8;
+            inpPtr2 += 8;
+        }
+        yStartPtr += width;
+        yStartPtr2 += width;
+        inpPtr += 4 * width;
+        inpPtr2 += 4 * width;
+    }
+    return (width * height * 3 >> 1);
+}
+
+
+WebRtc_Word32
+PadI420BottomRows(WebRtc_UWord8* inputVideoBuffer, WebRtc_UWord32 size, WebRtc_UWord32 width,
+                  WebRtc_UWord32 height, WebRtc_Word32 nrRows, WebRtc_UWord32& newLength)
+{
+    // sanity
+    WebRtc_UWord32 length = 3 * (width >> 1) * (height + nrRows);
+    if (size < length)
+        return -1;
+
+    if (nrRows < 0)
+        return -1;
+
+    WebRtc_Word32 colorSize = (width * height) >> 2;
+    WebRtc_Word32 padSize = width * nrRows;
+    WebRtc_Word32 padSizeColor = (width * nrRows) >> 2;
+    WebRtc_Word32 outColorSize = (width *(height + nrRows)) >> 2;
+    WebRtc_Word32 j = width * (height + nrRows) + outColorSize;
+
+    WebRtc_Word32 i = width*height + colorSize; // start of Cr
+    memmove(&inputVideoBuffer[j], &inputVideoBuffer[i], colorSize);
+    memset((&inputVideoBuffer[j])+colorSize,127,padSizeColor);
+
+    i = width*height; // start of Cb
+    j = width*(height+nrRows);
+    memmove(&inputVideoBuffer[j], &inputVideoBuffer[i], colorSize);
+    memset((&inputVideoBuffer[j])+colorSize,127,padSizeColor);
+
+    memset(&inputVideoBuffer[i],0,padSize);
+
+    newLength = length;
+    return 0;
+}
+
+
+static WebRtc_UWord32
+PadI420Component(const WebRtc_UWord8* inBuf, WebRtc_UWord8* outBuf,
+                 const WebRtc_UWord32 fromWidth, const WebRtc_UWord32 fromHeight,
+                 const WebRtc_UWord32 padWidth,  const WebRtc_UWord32 padWidthL,
+                 const WebRtc_UWord32 padHeight, const WebRtc_UWord32 padHeightT,
+                 const WebRtc_UWord8 padValue)
+{
+    const WebRtc_Word32 toWidth = fromWidth + padWidth;
+    const WebRtc_Word32 padWidthR = padWidth - padWidthL;
+    const WebRtc_Word32 padHeightB = padHeight - padHeightT;
+
+    // Top border
+    memset(outBuf, padValue, toWidth * padHeightT);
+    WebRtc_UWord32 outIdx = toWidth * padHeightT;
+    WebRtc_UWord32 inIdx = 0;
+    for (WebRtc_UWord32 i = 0; i < fromHeight; i++)
+    {
+        // Left border
+        memset(&outBuf[outIdx], padValue, padWidthL);
+        outIdx += padWidthL;
+
+        // Copy image
+        memcpy(&outBuf[outIdx], &inBuf[inIdx], fromWidth);
+        outIdx += fromWidth;
+        inIdx += fromWidth;
+
+        // Right border
+        memset(&outBuf[outIdx], padValue, padWidthR);
+        outIdx += padWidthR;
+    }
+    // Bottom border
+    memset(&outBuf[outIdx], padValue, toWidth * padHeightB);
+    outIdx += toWidth * padHeightB;
+
+    return outIdx;
+}
+
+WebRtc_Word32
+PadI420Frame(const WebRtc_UWord8* inBuffer, WebRtc_UWord8* outBuffer, WebRtc_UWord32 fromWidth,
+             WebRtc_UWord32 fromHeight, WebRtc_UWord32 toWidth, WebRtc_UWord32 toHeight)
+{
+    if (toWidth < 1 || fromWidth < 1 || toHeight < 1 || fromHeight < 1)
+    {
+        return -1;
+    }
+    if (toWidth == fromWidth && toHeight == fromHeight)
+    {
+        // nothing to do
+        return (3 * toHeight * toWidth) >> 1;
+    }
+
+    if (inBuffer == NULL)
+    {
+        return -1;
+    }
+
+    if (outBuffer == NULL)
+    {
+        return -1;
+    }
+
+    if (fromWidth < 0 || fromHeight < 0)
+    {
+        return -1;
+    }
+
+    if (toWidth < 0 || toHeight < 0)
+    {
+        return -1;
+    }
+
+    if (toWidth < fromWidth || toHeight < fromHeight)
+    {
+        return -1;
+    }
+
+    WebRtc_UWord32 padWidth = toWidth - fromWidth;
+    WebRtc_UWord32 padHeight = toHeight - fromHeight;
+    WebRtc_UWord32 padWidthL = 0;
+    WebRtc_UWord32 padHeightT = 0;
+
+    // If one of the padded dimensions is a multiple of 16, we apply the padding in
+    // blocks of 16.
+    if (padHeight % 16 == 0)
+    {
+        WebRtc_UWord32 num16blocks = padHeight >> 4;
+        padHeightT = ((num16blocks >> 1) << 4); // NOTE: not the same as
+                                                //       num16blocks << 3
+    }
+    else
+    {
+        padHeightT = padHeight >> 1;
+    }
+
+    if (padWidth % 16 == 0)
+    {
+        WebRtc_UWord32 num16blocks = padWidth >> 4;
+        padWidthL = ((num16blocks >> 1) << 4);
+    }
+    else
+    {
+        padWidthL = padWidth >> 1;
+    }
+
+    // -- I --
+    WebRtc_UWord32 inIdx = 0;
+    WebRtc_UWord32 outIdx = 0;
+    outIdx = PadI420Component(&inBuffer[inIdx], &outBuffer[outIdx], fromWidth,
+                              fromHeight, padWidth, padWidthL, padHeight, padHeightT, 0);
+    // -- Cr --
+    inIdx = fromWidth * fromHeight;
+    fromWidth >>= 1;
+    fromHeight >>= 1;
+    padWidth >>= 1;
+    padWidthL >>= 1;
+    padHeight >>= 1;
+    padHeightT >>= 1;
+    outIdx += PadI420Component(&inBuffer[inIdx], &outBuffer[outIdx], fromWidth,
+                               fromHeight, padWidth, padWidthL, padHeight, padHeightT, 127);
+    // -- Cb --
+    inIdx += fromWidth * fromHeight;
+    outIdx += PadI420Component(&inBuffer[inIdx], &outBuffer[outIdx], fromWidth,
+                               fromHeight, padWidth, padWidthL, padHeight, padHeightT, 127);
+
+    return outIdx;
+}
+
+WebRtc_Word32
+PadI420Frame(WebRtc_UWord32 size, const WebRtc_UWord8* inBuffer, WebRtc_UWord8* outBuffer,
+             bool block16Bit)
+{
+    if (size < 1)
+    {
+        return -1;
+    }
+    WebRtc_Word32 i = 0;
+    WebRtc_Word32 m = 0;
+    WebRtc_Word32 loop = 0;
+    WebRtc_Word32 dropHeightBits = 0; // must be a factor of 4
+    WebRtc_Word32 halfToWidth;
+    WebRtc_Word32 halfToHeight;
+    WebRtc_Word32 halfFromWidth;
+    WebRtc_Word32 halfFromHeight;
+    WebRtc_Word32 padHeightT;
+    WebRtc_Word32 padHeightB;
+    WebRtc_Word32 padWidthL;
+    WebRtc_Word32 padWidthR;
+    WebRtc_Word32 toWidth;
+    WebRtc_Word32 toHeight;
+    WebRtc_Word32 fromWidth;
+    WebRtc_Word32 fromHeight;
+    if (block16Bit)
+    {
+        if (size == 115200) // to 152064
+        {
+            toWidth = 352;
+            toHeight = 288;
+            fromWidth = 320;
+            fromHeight =240;
+            padHeightT = 16;
+            padHeightB = 32;
+            padWidthL = 16;
+            padWidthR = 16;
+        } else if (size == 28800)
+        {
+            fromWidth = 160;
+            fromHeight =120;
+            dropHeightBits = 8; // drop 8 bits
+            toWidth = 176;
+            toHeight = 144;
+            padHeightT = 16;
+            padHeightB = 16;
+            padWidthL = 0;
+            padWidthR = 16;
+        } else
+        {
+            return -1;
+        }
+    } else
+    {
+        return -1;
+    }
+    halfFromWidth = fromWidth >> 1;
+    halfFromHeight = fromHeight >> 1;
+    halfToWidth = toWidth >> 1;
+    halfToHeight = toHeight >> 1;
+
+    //Ilum
+    memset(outBuffer,0,toWidth * padHeightT + padWidthL); // black
+    i =  toWidth * padHeightT + padWidthL;
+    m = (dropHeightBits >> 1) * fromWidth;
+    for (loop = 0; loop < (fromHeight - dropHeightBits); loop++)
+    {
+        memcpy(&outBuffer[i], &inBuffer[m],fromWidth);
+        i += fromWidth;
+        m += fromWidth;
+        memset(&outBuffer[i],0,padWidthL + padWidthR); // black
+        i += padWidthL + padWidthR;
+    }
+    memset(&outBuffer[i],0,toWidth * padHeightB - padWidthL); // black
+    m += (dropHeightBits >> 1) * fromWidth;
+    i = toWidth * toHeight; // ilum end
+
+    // Cr
+    memset(&outBuffer[i],127,halfToWidth * (padHeightT >> 1) + (padWidthL >> 1) ); // black
+    i += halfToWidth * (padHeightT >> 1) + (padWidthL >> 1);
+
+    m += (dropHeightBits >> 2) * halfFromWidth;
+    for(loop =0 ; loop < (halfFromHeight - (dropHeightBits >> 1)); loop++)
+    {
+        memcpy(&outBuffer[i],&inBuffer[m],halfFromWidth);
+        m += halfFromWidth;
+        i += halfFromWidth;
+        memset(&outBuffer[i],127,(padWidthL + padWidthR) >> 1); // black
+        i += (padWidthL + padWidthR) >> 1;
+    }
+    memset(&outBuffer[i],127,halfToWidth * (padHeightB >> 1) - (padWidthL >> 1) ); // black
+    m += (dropHeightBits>>2) * halfFromWidth;
+    i = toWidth * toHeight + halfToHeight * halfToWidth; // ilum +Cr
+
+    // Cb
+    memset(&outBuffer[i],127,halfToWidth * (padHeightT >> 1) + (padWidthL >> 2)); // black
+    i += halfToWidth * (padHeightT >> 1) + (padWidthL >> 1);
+
+    m += (dropHeightBits >> 2) * halfFromWidth;
+    for(loop = 0; loop < (halfFromHeight - (dropHeightBits >> 1)); loop++)
+    {
+        memcpy(&outBuffer[i],&inBuffer[m],halfFromWidth);
+        m += halfFromWidth;
+        i += halfFromWidth;
+        memset(&outBuffer[i],127,((padWidthL + padWidthR) >> 1)); // black
+        i+=((padWidthL + padWidthR) >> 1);
+    }
+    memset(&outBuffer[i],127,halfToWidth * (padHeightB >> 1) - (padWidthL >> 1) ); // black
+    return halfToWidth * toHeight * 3;
+}
+
+WebRtc_Word32
+ScaleI420UpHalfFrame(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8* inFrame)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord8* inPtr = inFrame + (width * height / 4 * 3) -1;
+    WebRtc_UWord8* outPtr = inFrame + (width * height / 2 * 3) -1;
+
+    for(WebRtc_Word32 i = (width * height / 4 * 3)-1; i > 0; i--)
+    {
+        *outPtr = *inPtr;
+        outPtr--;
+        inPtr--;
+        *outPtr = ((inPtr[0] + inPtr[1]) / 2);
+        outPtr--;
+    }
+    *outPtr = *inPtr;
+    outPtr--;
+    *outPtr = *inPtr;
+
+    return 3 * width * height / 2;
+}
+
+WebRtc_Word32
+ScaleI420DownHalfFrame(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8* inFrame)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord8* inPtr1 = inFrame;
+    WebRtc_UWord8* outPtr = inFrame;
+    WebRtc_UWord32 y = 0;
+    WebRtc_UWord32 x = 0;
+    // ilum
+    for(; y < (height); y++)
+    {
+        for(x = 0; x < (width >> 1); x++)
+        {
+            WebRtc_Word32 avg = inPtr1[0] + inPtr1[1];
+            avg = avg >>1;
+            *outPtr= (WebRtc_UWord8)(avg);
+            inPtr1 += 2;
+            outPtr++;
+        }
+    }
+    inPtr1 = inFrame + (width * height);
+
+    // color
+    for(y = 0; y < height; y++)
+    {
+        // 2 rows
+        for(x = 0; x < (width >> 2); x++)
+        {
+            WebRtc_Word32 avg = inPtr1[0] + inPtr1[1] ;
+            *outPtr = (WebRtc_UWord8)(avg >> 1);
+            inPtr1 += 2;
+            outPtr++;
+        }
+    }
+    return height * (width >> 1) * 3;
+}
+
+WebRtc_Word32
+ScaleI420FrameQuarter(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8* inFrame)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord8* inPtr1 = inFrame;
+    WebRtc_UWord8* inPtr2 = inFrame + width;
+    WebRtc_UWord8* outPtr = inFrame;
+
+    WebRtc_UWord32 y = 0;
+    WebRtc_UWord32 x = 0;
+    // ilum
+    for(; y < (height >> 1); y++)
+    {
+        // 2 rows
+        for(x = 0; x < (width >> 1); x++)
+        {
+            WebRtc_Word32 avg = inPtr1[0] + inPtr2[0] + inPtr1[1] + inPtr2[1];
+            *outPtr= (WebRtc_UWord8)(avg >> 2);
+            inPtr1 += 2;
+            inPtr2 += 2;
+            outPtr++;
+        }
+        inPtr1 +=width;
+        inPtr2 +=width;
+    }
+
+    inPtr1 = inFrame + (width * height);
+    inPtr2 = inPtr1 + (width>>1);
+
+    // color
+    for(y = 0; y < (height>>1); y++)
+    {
+        // 2 rows
+        for(x = 0; x < (width>>2); x++)
+        {
+            WebRtc_Word32 avg = inPtr1[0] + inPtr2[0] + inPtr1[1] + inPtr2[1];
+            *outPtr= (WebRtc_UWord8)(avg >> 2);
+
+            inPtr1 += 2;
+            inPtr2 += 2;
+            outPtr++;
+        }
+        inPtr1 += (width >> 1);
+        inPtr2 += (width >> 1);
+    }
+    return height * (width >> 1) * 3;
+}
+
+WebRtc_Word32
+ScaleI420Up2(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8*& buffer,
+             WebRtc_UWord32 size, WebRtc_UWord32 &scaledWidth, WebRtc_UWord32 &scaledHeight)
+{
+    if (width <= 1 || height <= 1 || (width % 2) != 0 || (height % 2) != 0)
+    {
+        return -1;
+    }
+
+    if (size < (WebRtc_UWord32)(width * height * 3 / 2))
+    {
+        return -1;
+    }
+
+    scaledWidth  = (width << 1);
+    scaledHeight = (height << 1);
+
+    // Verify allocated size
+    WebRtc_UWord32 scaledBufferSize = CalcBufferSize(kI420, scaledWidth, scaledHeight);
+    VerifyAndAllocate(buffer, size, scaledBufferSize);
+    WebRtc_UWord8* inPtr1 = buffer + (3 * width * (height >> 1)) - 1;
+    WebRtc_UWord8* inPtr2 = buffer + (3 * width * (height >> 1)) - (width >> 1) - 1;
+    WebRtc_UWord8* outPtr1 = buffer + (3 * scaledWidth * (scaledHeight >> 1)) - 1;
+    WebRtc_UWord8* outPtr2 = buffer + (3 * scaledWidth * (scaledHeight >> 1)) - (scaledWidth >> 1) - 1;
+
+    // Color
+    for (WebRtc_Word32 i = 1; i <= 2; i++)
+    {
+        for (WebRtc_UWord32 y = 0; y < (height >> 1) - 1; y++)
+        {
+            for (WebRtc_UWord32 x = 0; x < (width >> 1) - 1; x++)
+            {
+                  *outPtr1 = *inPtr1;
+                  *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+                  inPtr1--;
+                  inPtr2--;
+                  outPtr1--;
+                  outPtr2--;
+                  *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+                  *outPtr2 = ((inPtr1[0] + inPtr1[1] + inPtr2[0] + inPtr2[1]) >> 2);
+                  outPtr1--;
+                  outPtr2--;
+            }
+            *outPtr1 = *inPtr1;
+            *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+            outPtr1--;
+            outPtr2--;
+            *outPtr1 = *inPtr1;
+            *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+            outPtr1--;
+            outPtr2--;
+            inPtr1--;
+            inPtr2--;
+            outPtr1 -= width;
+            outPtr2 -= width;
+        }
+        // First row
+        for (WebRtc_UWord32 x = 0; x < (width >> 1) - 1; x++)
+        {
+            *outPtr1 = *inPtr1;
+            *outPtr2 = *outPtr1;
+            inPtr1--;
+            inPtr2--;
+            outPtr1--;
+            outPtr2--;
+            *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+            *outPtr2 = *outPtr1;
+            outPtr1--;
+            outPtr2--;
+        }
+        *outPtr1 = *inPtr1;
+        *outPtr2 = *inPtr1;
+        outPtr1--;
+        outPtr2--;
+        *outPtr1 = *inPtr1;
+        *outPtr2 = *inPtr1;
+        outPtr1--;
+        outPtr2--;
+        inPtr1--;
+        inPtr2--;
+        outPtr1 -= width;
+        outPtr2 -= width;
+    }
+
+    inPtr2 -= (width >> 1);
+    outPtr2 -= width;
+
+    // illum
+    for (WebRtc_UWord32 y = 0; y < height - 1; y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < width - 1; x++)
+        {
+            *outPtr1 = *inPtr1;
+            *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+            inPtr1--;
+            inPtr2--;
+            outPtr1--;
+            outPtr2--;
+            *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+            *outPtr2 = ((inPtr1[0] + inPtr1[1] + inPtr2[0] + inPtr2[1]) >> 2);
+            outPtr1--;
+            outPtr2--;
+        }
+        *outPtr1 = *inPtr1;
+        *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+        outPtr1--;
+        outPtr2--;
+        *outPtr1 = *inPtr1;
+        *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+        outPtr1--;
+        outPtr2--;
+        inPtr1--;
+        inPtr2--;
+
+        outPtr1 -= scaledWidth;
+        outPtr2 -= scaledWidth;
+    }
+    // First row
+    for (WebRtc_UWord32 x = 0; x < width - 1; x++)
+    {
+        *outPtr1 = *inPtr1;
+        *outPtr2 = *outPtr1;
+        inPtr1--;
+        outPtr1--;
+        outPtr2--;
+        *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+        *outPtr2 = *outPtr1;
+        outPtr1--;
+        outPtr2--;
+    }
+    *outPtr1 = *inPtr1;
+    *outPtr2 = *inPtr1;
+    outPtr1--;
+    outPtr2--;
+    *outPtr1 = *inPtr1;
+    *outPtr2 = *inPtr1;
+
+    return scaledHeight * (scaledWidth >> 1) * 3;
+}
+
+WebRtc_Word32
+ScaleI420Up3_2(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8*& buffer,
+               WebRtc_UWord32 size, WebRtc_UWord32 &scaledWidth, WebRtc_UWord32 &scaledHeight)
+{
+    if (width <= 1 || height <= 1)
+    {
+        return -1;
+    }
+
+    if ((width % 2) != 0 || (height % 2) != 0 || ((width >> 1) % 2) != 0 || ((height >> 1) % 2) != 0)
+    {
+        return -1;
+    }
+
+    if (size < (WebRtc_UWord32)(width * height * 3 / 2))
+    {
+        return -1;
+    }
+
+    scaledWidth = 3 * (width >> 1);
+    scaledHeight = 3 * (height >> 1);
+
+    // Verify new buffer size
+    WebRtc_UWord32 scaledBufferSize = webrtc::CalcBufferSize(kI420, scaledWidth, scaledHeight);
+    VerifyAndAllocate(buffer, size, scaledBufferSize);
+
+    WebRtc_UWord8* inPtr1 = buffer + (3 * width * (height >> 1)) - 1;
+    WebRtc_UWord8* inPtr2 = buffer + (3 * width*(height >> 1)) - (width >> 1) - 1;
+
+    WebRtc_UWord8* outPtr1 = buffer + (3 * scaledWidth * (scaledHeight >> 1)) - 1;
+    WebRtc_UWord8* outPtr2 = buffer + (3 * scaledWidth * (scaledHeight >> 1)) - (scaledWidth >> 1) - 1;
+
+    WebRtc_Word32 cy = 0;
+    WebRtc_Word32 cx = 0;
+    // Color
+    for (WebRtc_UWord32 y = 0; y < (height); y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < (width >> 1); x++)
+        {
+            *outPtr1 = *inPtr1;
+            outPtr1--;
+            cy = y % 2;
+            cx = x % 2;
+            if (cy == 0)
+            {
+                *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+            }
+            outPtr2--;
+            inPtr1--;
+            inPtr2--;
+
+            if (cx == 0 && cy == 0)
+            {
+                *outPtr2 = ((inPtr1[0] + inPtr1[1] + inPtr2[0] + inPtr2[1]) >> 2);
+            }
+            if (cx == 0)
+            {
+                *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+                outPtr1--;
+                outPtr2--;
+            }
+        }
+        if (cy == 0)
+        {
+            outPtr1 -= (scaledWidth >> 1);
+            outPtr2 -= (scaledWidth >> 1);
+        }
+    }
+    inPtr2 -= (width >> 1);
+    outPtr2 -= (scaledWidth >> 1);
+
+    // illum
+    for (WebRtc_UWord32 y = 0; y < height; y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < width; x++)
+        {
+            *outPtr1 = *inPtr1;
+            outPtr1--;
+            cy = y % 2;
+            cx = x % 2;
+            if (cy == 0)
+            {
+                *outPtr2 = ((inPtr1[0] + inPtr2[0]) >> 1);
+            }
+            outPtr2--;
+            inPtr1--;
+            inPtr2--;
+            if (cx == 0 && cy == 0)
+            {
+                *outPtr2 = ((inPtr1[0] + inPtr1[1] + inPtr2[0] + inPtr2[1]) >> 2);
+            }
+            if (cx == 0)
+            {
+                *outPtr1 = ((inPtr1[0] + inPtr1[1]) >> 1);
+                outPtr1--;
+                outPtr2--;
+            }
+        }
+        if (cy == 0)
+        {
+            outPtr1 -= scaledWidth;
+            outPtr2 -= scaledWidth;
+        }
+    }
+
+    return scaledHeight * (scaledWidth >> 1) * 3;
+}
+
+WebRtc_Word32
+ScaleI420Down1_3(WebRtc_UWord32 width, WebRtc_UWord32 height, WebRtc_UWord8*& buffer,
+                 WebRtc_UWord32 size, WebRtc_UWord32 &scaledWidth,
+                 WebRtc_UWord32 &scaledHeight)
+{
+    if (width <= 5 || height <= 5)
+    {
+        return -1;
+    }
+
+    if ((width % 2) != 0 || (height % 2) != 0 || (((height / 3) % 2) != 0))
+    {
+        return -1;
+    }
+
+    if (size < (WebRtc_UWord32)(width * height * 3 / 2))
+    {
+        return -1;
+    }
+
+    scaledWidth = width / 3;
+    scaledHeight = height / 3;
+    WebRtc_Word32 scaledBufferSize = CalcBufferSize(kI420, scaledWidth, scaledHeight);
+    VerifyAndAllocate(buffer, size, scaledBufferSize);
+
+    WebRtc_UWord8* inPtr1 = buffer;
+    WebRtc_UWord8* inPtr2 = buffer + width;
+    WebRtc_UWord8* outPtr = buffer;
+
+    WebRtc_Word32 remWidth = width - scaledWidth * 3;
+
+    bool addWidth = false;
+    if (scaledWidth % 2)
+    {
+        scaledWidth++;
+        addWidth = true;
+    }
+    WebRtc_Word32 remWidthCol = (width >> 1) - WebRtc_Word32((scaledWidth >> 1) * 3.0);
+
+    // illum
+    for (WebRtc_UWord32 y = 0; y < height / 3; y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < width / 3; x++)
+        {
+            *outPtr = ((inPtr1[0] + inPtr2[0] + inPtr1[1] + inPtr2[1]) >> 2);
+            inPtr1 += 3;
+            inPtr2 += 3;
+            outPtr++;
+        }
+        if (addWidth)
+        {
+            *outPtr = ((inPtr1[0] + inPtr2[0]) >> 1);
+            outPtr++;
+        }
+            inPtr1 += (width << 1) + remWidth;
+            inPtr2 += (width << 1) + remWidth;
+    }
+    inPtr1 = buffer + (width * height);
+    inPtr2 = inPtr1 + (width >> 1);
+
+    // Color
+    for (WebRtc_UWord32 y = 0; y < (scaledHeight >> 1); y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < (scaledWidth >> 1); x++)
+        {
+            *outPtr = ((inPtr1[0] + inPtr2[0] + inPtr1[1] + inPtr2[1]) >> 2);
+            inPtr1 += 3;
+            inPtr2 += 3;
+            outPtr++;
+        }
+        inPtr1 += width + (remWidthCol);
+        inPtr2 += width + (remWidthCol);
+    }
+    inPtr1 = buffer + (width * height) + (width * height >> 2);
+    inPtr2 = inPtr1 + (width >> 1);
+
+    for (WebRtc_UWord32 y = 0; y < (scaledHeight >> 1); y++)
+    {
+        for (WebRtc_UWord32 x = 0; x < (scaledWidth >> 1); x++)
+        {
+            *outPtr = ((inPtr1[0] + inPtr2[0] + inPtr1[1] + inPtr2[1]) >> 2);
+            inPtr1 += 3;
+            inPtr2 += 3;
+            outPtr++;
+        }
+        inPtr1 += width + (remWidthCol);
+        inPtr2 += width + (remWidthCol);
+    }
+
+    return scaledHeight * (scaledWidth >> 1) * 3;
+}
+
+
+WebRtc_Word32
+ConvertToI420(VideoType incomingVideoType,
+              const WebRtc_UWord8* incomingBuffer,
+              WebRtc_UWord32 width,
+              WebRtc_UWord32 height,
+              WebRtc_UWord8* outgoingBuffer,
+              bool interlaced /* =false */,
+              VideoRotationMode rotate /* =  kRotateNone  */)
+
+{
+    if (width < 1  || height < 1 )
+    {
+        return -1;
+    }
+    WebRtc_Word32 outgoingLength = 0;
+    WebRtc_Word32 length = 0;
+    switch(incomingVideoType)
+    {
+        case kRGB24:
+            outgoingLength = ConvertRGB24ToI420(width, height, incomingBuffer, outgoingBuffer);
+            break;
+        case kRGB565:
+            outgoingLength = ConvertRGB565ToI420(incomingBuffer, width, height, outgoingBuffer);
+            break;
+#ifdef WEBRTC_MAC
+        case kARGB:
+            outgoingLength = ConvertARGBMacToI420(width, height, incomingBuffer, outgoingBuffer);
+            break;
+#endif
+        case kI420:
+            switch(rotate)
+            {
+              case kRotateNone:
+                  length = CalcBufferSize(kI420, width, height);
+                  outgoingLength = length;
+                  memcpy(outgoingBuffer, incomingBuffer, length);
+                  break;
+              case kRotateClockwise:
+                  outgoingLength = ConvertToI420AndRotateClockwise(incomingBuffer, width,
+                                                                   height, outgoingBuffer,
+                                                                   height, width, kI420);
+                  break;
+              case kRotateAntiClockwise:
+                  outgoingLength = ConvertToI420AndRotateAntiClockwise(incomingBuffer, width,
+                                                                       height, outgoingBuffer,
+                                                                       height, width, kI420);
+                  break;
+              case kRotate180:
+                  outgoingLength = ConvertToI420AndMirrorUpDown(incomingBuffer,outgoingBuffer,
+                                                                width, height, kI420);
+                  break;
+              default:
+                  assert(false);
+                  break;
+            }
+            break;
+        case kYUY2:
+            if (interlaced) {
+                outgoingLength = ConvertYUY2ToI420interlaced(incomingBuffer, width, height,
+                                                             outgoingBuffer, width, height);
+            } else {
+                outgoingLength = ConvertYUY2ToI420(incomingBuffer, width, height,
+                                                   outgoingBuffer, width, height);
+            }
+            break;
+        case kUYVY:
+            if (interlaced) {
+                outgoingLength = ConvertUYVYToI420interlaced(incomingBuffer, width, height,
+                                                             outgoingBuffer, width, height);
+            } else {
+                outgoingLength = ConvertUYVYToI420(width, height, incomingBuffer,
+                                                   outgoingBuffer);
+            }
+            break;
+        case kYV12:
+            switch(rotate)
+                {
+                    case kRotateNone:
+                        outgoingLength = ConvertYV12ToI420(incomingBuffer, width, height,
+                                                           outgoingBuffer);
+                        break;
+                    case kRotateClockwise:
+                        outgoingLength = ConvertToI420AndRotateClockwise(incomingBuffer, width,
+                                                                         height, outgoingBuffer,
+                                                                         height,width, kYV12);
+                        break;
+                    case kRotateAntiClockwise:
+                        outgoingLength = ConvertToI420AndRotateAntiClockwise(incomingBuffer,
+                                                                             width, height,
+                                                                             outgoingBuffer,
+                                                                             height, width,
+                                                                             kYV12);
+                        break;
+                    case kRotate180:
+                        outgoingLength = ConvertToI420AndMirrorUpDown(incomingBuffer,
+                                                                      outgoingBuffer,
+                                                                      width, height, kYV12);
+                        break;
+                    default:
+                        assert(false);
+                        break;
+                }
+            break;
+        case kNV12:
+            switch(rotate)
+            {
+                case kRotateNone:
+                    outgoingLength = ConvertNV12ToI420(incomingBuffer, outgoingBuffer, width,
+                                                       height);
+                    break;
+                case kRotateClockwise:
+                    outgoingLength = ConvertNV12ToI420AndRotateClockwise(incomingBuffer,
+                                                                         outgoingBuffer,
+                                                                         width, height);
+                    break;
+                case kRotateAntiClockwise:
+                    outgoingLength = ConvertNV12ToI420AndRotateAntiClockwise(incomingBuffer,
+                                                                             outgoingBuffer,
+                                                                             width, height);
+                    break;
+                case kRotate180:
+                    outgoingLength = ConvertNV12ToI420AndRotate180(incomingBuffer,
+                                                                   outgoingBuffer,
+                                                                   width, height);
+                    break;
+                default:
+                    assert(false);
+                    break;
+            }
+            break;
+        case kNV21:
+            switch(rotate)
+            {
+                case kRotateNone:
+                    outgoingLength = ConvertNV21ToI420(incomingBuffer, outgoingBuffer, width,
+                                                       height);
+                    break;
+                case kRotateClockwise:
+                    outgoingLength = ConvertNV21ToI420AndRotateClockwise(incomingBuffer,
+                                                                         outgoingBuffer,
+                                                                         width, height);
+                    break;
+                case kRotateAntiClockwise:
+                    outgoingLength = ConvertNV21ToI420AndRotateAntiClockwise(incomingBuffer,
+                                                                             outgoingBuffer,
+                                                                             width, height);
+                    break;
+                case kRotate180:
+                    outgoingLength = ConvertNV21ToI420AndRotate180(incomingBuffer,
+                                                                   outgoingBuffer,
+                                                                   width, height);
+                    break;
+                default:
+                    assert(false);
+                    break;
+            }
+            break;
+        default:
+            assert(false);
+            break;
+    }
+    return outgoingLength;
+}
+
+WebRtc_Word32 ConvertFromI420(VideoType outgoingVideoType,
+                               const WebRtc_UWord8* incomingBuffer,
+                               WebRtc_UWord32 width,
+                               WebRtc_UWord32 height,
+                               WebRtc_UWord8* outgoingBuffer,
+                               bool interlaced /* = false */,
+                               VideoRotationMode rotate /* = kRotateNone */)
+
+{
+    if (width < 1  || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_Word32 outgoingLength = 0;
+    WebRtc_Word32 length = 0;
+    switch(outgoingVideoType)
+    {
+      case kRGB24:
+          outgoingLength = ConvertI420ToRGB24(incomingBuffer, outgoingBuffer, width, height);
+          break;
+      case kARGB:
+         outgoingLength = ConvertI420ToARGB(incomingBuffer, outgoingBuffer, width, height, 0);
+         break;
+      case kARGB4444:
+          outgoingLength = ConvertI420ToARGB4444(incomingBuffer, outgoingBuffer, width, height, 0);
+          break;
+      case kARGB1555:
+          outgoingLength = ConvertI420ToARGB1555(incomingBuffer, outgoingBuffer, width, height,0);
+          break;
+      case kRGB565:
+          outgoingLength = ConvertI420ToRGB565(incomingBuffer, outgoingBuffer, width, height);
+          break;
+      case kI420:
+          length = CalcBufferSize(kI420, width, height);
+          outgoingLength = length;
+          memcpy(outgoingBuffer, incomingBuffer, length);
+          break;
+      case kUYVY:
+          outgoingLength = ConvertI420ToUYVY(incomingBuffer, outgoingBuffer, width, height);
+          break;
+      case kYUY2:
+          outgoingLength = ConvertI420ToYUY2(incomingBuffer, outgoingBuffer, width, height,0);
+          break;
+      case kYV12:
+        outgoingLength = ConvertI420ToYV12(incomingBuffer, outgoingBuffer, width, height,0);
+        break;
+#ifdef WEBRTC_MAC
+      case kRGBAMac:
+        outgoingLength = ConvertI420ToRGBAMac(incomingBuffer, outgoingBuffer, width, height,0);
+        break;
+      case kARGBMac:
+        outgoingLength = ConvertI420ToARGBMac(incomingBuffer, outgoingBuffer, width, height,0);
+        break;
+#endif
+      default:
+          assert(false);
+          break;
+    }
+    return outgoingLength;
+}
+
+WebRtc_Word32
+MirrorI420LeftRight( const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                     WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+
+    WebRtc_Word32 indO = 0;
+    WebRtc_Word32 indS  = 0;
+    WebRtc_UWord32 wind, hind;
+    WebRtc_UWord8 tmpVal;
+    // will swap two values per iteration
+    const WebRtc_UWord32 halfW = width >> 1;
+    // Y
+    for (wind = 0; wind < halfW; wind++ )
+    {
+        for (hind = 0; hind < height; hind++ )
+        {
+            indO = hind * width + wind;
+            indS = hind * width + (width - wind - 1); // swapping index
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        } // end for (height)
+    } // end for(width)
+    const WebRtc_UWord32 lengthW = width >> 2;
+    const WebRtc_UWord32 lengthH = height >> 1;
+    // V
+    WebRtc_Word32 zeroInd = width * height;
+    for (wind = 0; wind < lengthW; wind++ )
+    {
+        for (hind = 0; hind < lengthH; hind++ )
+        {
+            indO = zeroInd + hind * halfW + wind;
+            indS = zeroInd + hind * halfW + (halfW - wind - 1); // swapping index
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        } // end for (height)
+    } // end for(width)
+
+    //U
+    zeroInd += width * height >> 2;
+    for (wind = 0; wind < lengthW; wind++ )
+    {
+        for (hind = 0; hind < lengthH; hind++ )
+        {
+            indO = zeroInd + hind * halfW + wind;
+            indS = zeroInd + hind * halfW + (halfW - wind - 1); // swapping index
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        } // end for (height)
+    } // end for(width)
+
+    return 0;
+}
+
+WebRtc_Word32
+MirrorI420UpDown( const WebRtc_UWord8* inFrame, WebRtc_UWord8* outFrame,
+                  WebRtc_UWord32 width, WebRtc_UWord32 height)
+{
+    if (width < 1 || height < 1)
+    {
+        return -1;
+    }
+    WebRtc_UWord32 indO = 0;
+    WebRtc_UWord32 indS  = 0;
+    WebRtc_UWord32 wind, hind;
+    WebRtc_UWord8 tmpVal;
+    WebRtc_UWord32 halfH = height >> 1;
+    WebRtc_UWord32 halfW = width >> 1;
+    // Y
+    for (hind = 0; hind < halfH; hind++ )
+    {
+        for (wind = 0; wind < width; wind++ )
+        {
+            indO = hind * width + wind;
+            indS = (height - hind - 1) * width + wind;
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        }
+    }
+    // V
+    WebRtc_UWord32 lengthW = width >> 1;
+    WebRtc_UWord32 lengthH = height >> 2;
+    WebRtc_UWord32 zeroInd = width * height;
+    for (hind = 0; hind < lengthH; hind++ )
+    {
+        for (wind = 0; wind < lengthW; wind++ )
+        {
+            indO = zeroInd + hind * halfW + wind;
+            indS = zeroInd + (halfH - hind - 1) * halfW + wind;
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        }
+    }
+    // U
+    zeroInd += width * height >> 2;
+    for (hind = 0; hind < lengthH; hind++ )
+    {
+        for (wind = 0; wind < lengthW; wind++ )
+        {
+            indO = zeroInd + hind * halfW + wind;
+            indS = zeroInd + (halfH - hind - 1) * halfW + wind;
+            tmpVal = inFrame[indO];
+            outFrame[indO] = inFrame[indS];
+            outFrame[indS] = tmpVal;
+        }
+    }
+    return 0;
+}
+
+WebRtc_Word32
+ConvertToI420AndMirrorUpDown(const WebRtc_UWord8* srcBuffer, WebRtc_UWord8* dstBuffer,
+                             WebRtc_UWord32 srcWidth, WebRtc_UWord32 srcHeight,
+                             VideoType colorSpaceIn)
+{
+    if (colorSpaceIn != kI420 && colorSpaceIn != kYV12)
+    {
+        return -1;
+    }
+
+    const WebRtc_Word32 sourceHeight = srcHeight;
+    const WebRtc_Word32 halfHeight = srcHeight >> 1;
+    const WebRtc_Word32 sourceWidth = srcWidth;
+    const WebRtc_Word32 halfWidth = sourceWidth >> 1;
+    WebRtc_UWord8* targetBuffer = dstBuffer;
+    const WebRtc_UWord8* sourcePtr = srcBuffer;
+
+    //Mirror Y component
+    for (WebRtc_UWord32 newRow = 0; newRow < srcHeight; ++newRow)
+    {
+        memcpy(targetBuffer, &sourcePtr[((srcHeight - newRow) - 1) * sourceWidth], sourceWidth);
+        targetBuffer += sourceWidth;
+    }
+
+    //Mirror U component
+    sourcePtr += sourceHeight * sourceWidth;
+    if (colorSpaceIn == kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    }
+    for (WebRtc_Word32 newRow = 0; newRow < halfHeight; ++newRow)
+    {
+        memcpy(targetBuffer, &sourcePtr[((halfHeight - newRow) - 1) * halfWidth], halfWidth);
+        targetBuffer += halfWidth;
+    }
+
+    //Mirror V component
+    if (colorSpaceIn != kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    }
+    else
+    {
+        sourcePtr -= (sourceHeight * sourceWidth) >> 2;
+    }
+    for(WebRtc_Word32 newRow = 0; newRow < halfHeight; ++newRow)
+    {
+        memcpy(targetBuffer, &sourcePtr[((halfHeight - newRow) - 1) * halfWidth], halfWidth);
+        targetBuffer += halfWidth;
+    }
+    return 0;
+}
+
+
+WebRtc_Word32
+ConvertToI420AndRotateClockwise(const WebRtc_UWord8* srcBuffer, WebRtc_UWord32 srcWidth,
+                                WebRtc_UWord32 srcHeight, WebRtc_UWord8* dstBuffer,
+                                WebRtc_UWord32 dstWidth, WebRtc_UWord32 dstHeight,
+                                VideoType colorSpaceIn)
+{
+    if (colorSpaceIn != kI420 && colorSpaceIn != kYV12)
+    {
+         return -1;
+     }
+
+    const WebRtc_Word32 targetHeight = dstHeight;
+    const WebRtc_Word32 targetWidth = dstWidth;
+    const WebRtc_Word32 sourceHeight = srcHeight;
+    const WebRtc_Word32 sourceWidth = srcWidth;
+
+    WebRtc_UWord8* targetBuffer=dstBuffer;
+    const WebRtc_UWord8* sourcePtr=srcBuffer;
+
+    // Paint the destination buffer black
+    memset(dstBuffer,0,dstWidth * dstHeight);
+    memset(dstBuffer + dstWidth * dstHeight,127,(dstWidth * dstHeight) / 2);
+
+    const WebRtc_Word32 paddingWidth = (targetWidth - sourceHeight) / 2;
+    const WebRtc_Word32 halfPaddingWidth = paddingWidth / 2;
+    const WebRtc_Word32 paddingHeight = (targetHeight - sourceWidth) / 2;
+    const WebRtc_Word32 halfPaddingHeight = paddingHeight / 2;
+
+    //Rotate Y component
+    targetBuffer += paddingHeight * targetWidth;
+    for(WebRtc_Word32 newRow = 0; newRow < sourceWidth; ++newRow)
+    {
+        targetBuffer+=paddingWidth;
+        for(WebRtc_Word32 newColumn = sourceHeight - 1;newColumn >= 0;--newColumn)
+        {
+            (*targetBuffer++) = sourcePtr[newColumn * sourceWidth + newRow];
+        }
+        targetBuffer += paddingWidth;
+    }
+    targetBuffer += paddingHeight * targetWidth;
+
+    //Rotate U component and store as kI420
+    sourcePtr += sourceHeight * sourceWidth;
+    if (colorSpaceIn == kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    for(WebRtc_Word32 newRow = 0;newRow < sourceWidth / 2; ++newRow)
+    {
+        targetBuffer += halfPaddingWidth;
+        for(WebRtc_Word32 newColumn=sourceHeight / 2 - 1; newColumn >= 0; --newColumn)
+        {
+            (*targetBuffer++) = sourcePtr[(newColumn * sourceWidth >> 1) + newRow];
+        }
+        targetBuffer += halfPaddingWidth;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+
+    //Rotate V component
+    if (colorSpaceIn != kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    } else
+    {
+        sourcePtr -= (sourceHeight * sourceWidth) >> 2;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    for(WebRtc_Word32 newRow = 0; newRow < sourceWidth / 2; ++newRow)
+    {
+        targetBuffer+=halfPaddingWidth;
+        for(WebRtc_Word32 newColumn = sourceHeight / 2 - 1; newColumn >= 0; --newColumn)
+        {
+            (*targetBuffer++) = sourcePtr[(newColumn * sourceWidth >> 1) + newRow];
+        }
+        targetBuffer += halfPaddingWidth;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    return 0;
+}
+
+
+WebRtc_Word32
+ConvertToI420AndRotateAntiClockwise(const WebRtc_UWord8* srcBuffer, WebRtc_UWord32 srcWidth,
+                                    WebRtc_UWord32 srcHeight, WebRtc_UWord8* dstBuffer,
+                                    WebRtc_UWord32 dstWidth, WebRtc_UWord32 dstHeight,
+                                    VideoType colorSpaceIn)
+{
+    if (colorSpaceIn != kI420 && colorSpaceIn != kYV12)
+    {
+        return -1;
+    }
+    if (dstWidth < srcHeight || dstHeight < srcWidth)
+    {
+        return -1;
+    }
+    const WebRtc_Word32 targetHeight = dstHeight;
+    const WebRtc_Word32 targetWidth = dstWidth;
+    const WebRtc_Word32 sourceHeight = srcHeight;
+    const WebRtc_Word32 sourceWidth = srcWidth;
+
+    WebRtc_UWord8* targetBuffer = dstBuffer;
+
+    const WebRtc_UWord8* sourcePtr = srcBuffer;
+
+    // Paint the destination buffer black
+    memset(dstBuffer,0,dstWidth * dstHeight);
+    memset(dstBuffer + dstWidth * dstHeight,127,(dstWidth * dstHeight) / 2);
+
+    const WebRtc_Word32 paddingWidth = (targetWidth - sourceHeight) / 2;
+    const WebRtc_Word32 halfPaddingWidth = paddingWidth / 2;
+
+    const WebRtc_Word32 paddingHeight = (targetHeight - sourceWidth) / 2;
+    const WebRtc_Word32 halfPaddingHeight = paddingHeight / 2;
+
+    //Rotate Y component
+    targetBuffer += paddingHeight*targetWidth;
+    for(WebRtc_Word32 newRow = sourceWidth - 1; newRow >= 0; --newRow)
+    {
+        targetBuffer+=paddingWidth;
+         for(WebRtc_Word32 newColumn = 0; newColumn < sourceHeight; ++newColumn)
+         {
+             (*targetBuffer++) = sourcePtr[newColumn * sourceWidth + newRow];
+         }
+         targetBuffer += paddingWidth;
+    }
+    targetBuffer += paddingHeight * targetWidth;
+
+    //Rotate U component and store as kI420
+    sourcePtr += sourceHeight * sourceWidth;
+    if (colorSpaceIn == kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    for(WebRtc_Word32 newRow = sourceWidth / 2 - 1; newRow >= 0;--newRow)
+    {
+        targetBuffer += halfPaddingWidth;
+        for(WebRtc_Word32 newColumn = 0; newColumn < sourceHeight / 2; ++newColumn)
+        {
+            (*targetBuffer++) = sourcePtr[(newColumn*sourceWidth >> 1) + newRow];
+        }
+        targetBuffer += halfPaddingWidth;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+
+    //Rotate V component
+    if (colorSpaceIn != kYV12)
+    {
+        sourcePtr += (sourceHeight * sourceWidth) >> 2;
+    } else
+    {
+        sourcePtr -= (sourceHeight * sourceWidth) >> 2;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    for (WebRtc_Word32 newRow = sourceWidth / 2 - 1; newRow >= 0; --newRow)
+    {
+        targetBuffer += halfPaddingWidth;
+        for (WebRtc_Word32 newColumn = 0; newColumn < sourceHeight / 2; ++newColumn)
+        {
+            (*targetBuffer++) = sourcePtr[(newColumn*sourceWidth >> 1) + newRow];
+        }
+        targetBuffer += halfPaddingWidth;
+    }
+    targetBuffer += halfPaddingHeight * targetWidth / 2;
+    return 0;
+}
+
+
+inline
+WebRtc_UWord8 Clip(WebRtc_Word32 val)
+{
+    if (val < 0)
+    {
+        return (WebRtc_UWord8)0;
+    } else if (val > 255)
+    {
+        return (WebRtc_UWord8)255;
+    }
+    return (WebRtc_UWord8)val;
+}
+
+WebRtc_Word32
+VerifyAndAllocate(WebRtc_UWord8*& buffer, WebRtc_UWord32 currentSize, WebRtc_UWord32 newSize)
+{
+    if (newSize > currentSize)
+    {
+        // make sure that our buffer is big enough
+        WebRtc_UWord8* newBuffer = new WebRtc_UWord8[newSize];
+        if (buffer)
+        {
+            // copy old data
+            memcpy(newBuffer, buffer, currentSize);
+            delete [] buffer;
+        }
+        buffer = newBuffer;
+        return newSize;
+    }
+    return currentSize;
+}
+
+#ifdef SCALEOPT
+//memcpy_16 assumes that width is an integer multiple of 16!
+void *memcpy_16(void * dest, const void * src, size_t n)
+{
+    _asm
+    {
+        mov eax, dword ptr [src]
+        mov ebx, dword ptr [dest]
+        mov ecx, dword ptr [n]
+
+    loop0:
+
+        movdqu    xmm0, XMMWORD PTR [eax]
+        movdqu    XMMWORD PTR [ebx], xmm0
+        add       eax, 16
+        add       ebx, 16
+        sub       ecx, 16
+        jg        loop0
+    }
+}
+
+//memcpy_8 assumes that width is an integer multiple of 8!
+void *memcpy_8(void * dest, const void * src, size_t n)
+{
+    _asm
+    {
+        mov eax, dword ptr [src]
+        mov ebx, dword ptr [dest]
+        mov ecx, dword ptr [n]
+
+    loop0:
+
+        movq    mm0, QWORD PTR [eax]
+        movq    QWORD PTR [ebx], mm0
+        add       eax, 8
+        add       ebx, 8
+        sub       ecx, 8
+        jg        loop0
+
+    emms
+    }
+
+}
+
+#endif
+
+}
diff --git a/common_video/vplib/main/source/vplib.gyp b/common_video/vplib/main/source/vplib.gyp
new file mode 100644
index 0000000..e21a503
--- /dev/null
+++ b/common_video/vplib/main/source/vplib.gyp
@@ -0,0 +1,71 @@
+# Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+#
+# Use of this source code is governed by a BSD-style license
+# that can be found in the LICENSE file in the root of the source
+# tree. An additional intellectual property rights grant can be found
+# in the file PATENTS.  All contributing project authors may
+# be found in the AUTHORS file in the root of the source tree.
+
+{
+  'includes': [
+    '../../../../common_settings.gypi', # Common settings
+  ],
+  'targets': [
+    {
+      'target_name': 'webrtc_vplib',
+      'type': '<(library)',
+      'dependencies': [
+      ],
+      'include_dirs': [
+        '../interface',
+      ],
+      'direct_dependent_settings': {
+        'include_dirs': [
+          '../interface',
+        ],
+      },
+      'sources': [
+        # interfaces
+        '../interface/vplib.h',
+        '../interface/interpolator.h',
+
+        # headers
+        'conversion_tables.h',
+        'scale_bilinear_yuv.h',
+      
+        # sources
+        'vplib.cc',
+        'interpolator.cc',
+        'scale_bilinear_yuv.cc',
+      ],
+    },
+    {
+      'target_name': 'vplib_test',
+      'type': 'executable',
+      'dependencies': [
+        'webrtc_vplib',
+      ],
+      'include_dirs': [
+         '../interface',
+         '../source',
+      ],
+      'sources': [
+
+        # headers
+        '../test/test_util.h',
+        
+        # sources
+        '../test/tester_main.cc',
+        '../test/scale_test.cc',
+        '../test/convert_test.cc',
+        '../test/interpolation_test.cc',
+      ], # source
+    },  
+  ],
+}
+
+# Local Variables:
+# tab-width:2
+# indent-tabs-mode:nil
+# End:
+# vim: set expandtab tabstop=2 shiftwidth=2:
diff --git a/common_video/vplib/main/test/convert_test.cc b/common_video/vplib/main/test/convert_test.cc
new file mode 100644
index 0000000..dec535d
--- /dev/null
+++ b/common_video/vplib/main/test/convert_test.cc
@@ -0,0 +1,368 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+// Test application for color space conversion functions
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <iostream>
+#include <string>
+#include <cmath>
+#include <time.h>
+
+#include "test_util.h"
+#include "vplib.h"
+
+using namespace webrtc;
+
+
+// Optimization testing
+//#define SCALEOPT //For Windows currently, June 2010
+
+WebRtc_Word32
+ImagePSNRfromBuffer(WebRtc_UWord8 *refBufName, WebRtc_UWord8 *testBufName,
+                    WebRtc_Word32 width, WebRtc_Word32 height,
+                    VideoType vType, double *YPSNRptr);
+void TestRetVal(int testVal, int refVal );
+
+int  convert_test(CmdArgs& args)
+{
+    // reading YUV frame - testing on the first frame of the foreman sequence
+    
+    //SET UP
+    int j = 0;
+    int retVal;
+    std::string outname = args.outputFile;
+    if (outname == "")
+    {
+        outname = "conversionTest_out.yuv";
+    }
+    std::string inname;
+    inname = args.inputFile;
+    FILE* sourceFile;
+    FILE* outputFile;
+    FILE* logFile;
+    WebRtc_UWord32 width = args.width;
+    WebRtc_UWord32 height = args.height;
+    WebRtc_UWord32 lengthSourceFrame = width*height*3/2;
+    double psnr = 0;
+    if ((sourceFile = fopen(inname.c_str(), "rb")) == NULL)
+    {
+        printf("Cannot read file %s.\n", inname.c_str());
+        exit(1); 
+    }
+    if ((outputFile = fopen(outname.c_str(), "wb")) == NULL)
+    {
+        printf("Cannot write file %s.\n", outname.c_str());
+        exit(1);
+    }
+    if ((logFile = fopen("../log.txt", "a")) == NULL)
+    {
+        printf("Cannot write file ../log.txt.\n");
+        exit(1);
+    }
+
+    // reading first frame of Foreman sequence
+    WebRtc_UWord8* origBuffer = new WebRtc_UWord8[width * height*3/2];
+    fread(origBuffer, 1, lengthSourceFrame, sourceFile);
+
+    // START TEST
+    printf("\nTEST #%d I420 <-> RGB24\n", j);
+
+    WebRtc_UWord8* resRGBBuffer2  = new WebRtc_UWord8[width*height*3];
+    WebRtc_UWord8* resI420Buffer = new WebRtc_UWord8[width*height*3/2];
+    retVal = ConvertFromI420(kRGB24, origBuffer, width, height,resRGBBuffer2);
+    TestRetVal(retVal, width*height*3);
+    clock_t tticks = clock();
+    for (int tt = 0; tt < 1000; tt++)
+    {
+        retVal = ConvertToI420(kRGB24, resRGBBuffer2, width, height,
+                               resI420Buffer);
+    }
+    tticks = clock() - tticks;
+    printf("RGB24->I420 Time(1000): %d\n", tticks);
+
+    TestRetVal(retVal, width*height*3/2);
+    fwrite(resI420Buffer, lengthSourceFrame, 1, outputFile);
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height, kI420, &psnr);
+    printf("Conversion between type #%d and type #%d, PSNR = %f\n", kI420,
+           kRGB24, psnr);
+    j++;
+    delete [] resRGBBuffer2;
+
+
+    printf("\nTEST #%d I420 <-> UYVY\n", j);
+    WebRtc_UWord8* outUYVYBuffer = new WebRtc_UWord8[width*height*2];
+
+    clock_t ticks = clock();
+    for (int t = 0; t < 100; t++)
+    {
+        retVal = ConvertFromI420(kUYVY, origBuffer, width,
+                                 height, outUYVYBuffer);
+    }
+    ticks = clock() - ticks;
+#ifndef SCALEOPT
+    fprintf(logFile, "\nConvertI420ToUYVY, before opt: %d\n", ticks);
+#else
+    fprintf(logFile, "\nConvertI420ToUYVY, after opt: %d\n", ticks);
+#endif
+
+    TestRetVal(retVal, width*height*2);
+    retVal = ConvertToI420(kUYVY, outUYVYBuffer, width, height, resI420Buffer);
+    TestRetVal(retVal, width*height*3/2);
+
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height, kI420, &psnr);
+    printf("Conversion between type #%d and type #%d, PSNR = %f\n",
+           kI420, kUYVY, psnr);
+    j++;
+    delete [] outUYVYBuffer;
+
+
+    printf("\nTEST #%d I420 <-> I420 \n", j);
+
+    WebRtc_UWord8* outI420Buffer = new WebRtc_UWord8[width*height*2];
+    retVal = ConvertToI420(kI420, origBuffer, width, height, outI420Buffer);
+    TestRetVal(retVal, width*height*3/2);
+    retVal = ConvertToI420(kI420 ,outI420Buffer, width, height, resI420Buffer);
+    TestRetVal(retVal, width*height*3/2);
+    fwrite(resI420Buffer, lengthSourceFrame, 1, outputFile);
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height,
+                        kI420, &psnr);
+    printf("Conversion between type #%d and type #%d, PSNR = %f\n",
+           kI420, kUYVY, psnr);
+    j++;
+    delete [] outI420Buffer;
+
+    printf("\nTEST #%d I420 <-> YV12\n", j);
+    outI420Buffer = new WebRtc_UWord8[width*height*3/2]; // assuming DIFF = 0
+
+    ticks = clock();
+    for (int t = 0; t < 1000; t++)
+    {
+        retVal = ConvertFromI420(kYV12, origBuffer, width, height, outI420Buffer);
+    }
+    ticks = clock() - ticks;
+#ifndef SCALEOPT
+    fprintf(logFile, "\nConvertI420ToYV12, before opt: %d\n", ticks);
+#else
+    fprintf(logFile, "\nConvertI420ToYV12, after opt: %d\n", ticks);
+#endif
+    TestRetVal(retVal, width*height*3/2);
+    retVal = webrtc::ConvertYV12ToI420(outI420Buffer, width, height,
+                                       resI420Buffer);
+    TestRetVal(retVal, width*height*3/2);
+
+    fwrite(resI420Buffer, lengthSourceFrame, 1, outputFile);
+
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height, kI420, &psnr);
+    printf("Conversion between type #%d and type #%d, PSNR = %f\n", kI420,
+           kYV12, psnr);
+    j++;
+    delete [] outI420Buffer;
+    delete [] resI420Buffer;
+
+
+    printf("\nTEST #%d I420<-> RGB565\n", j);
+    WebRtc_UWord8* res2ByteBuffer = new WebRtc_UWord8[width*height*2];
+    resI420Buffer = new WebRtc_UWord8[width * height * 3 / 2];
+    retVal = ConvertFromI420(kRGB565, origBuffer, width, height, res2ByteBuffer);
+    TestRetVal(retVal, width*height*2);
+    retVal = ConvertRGB565ToI420(res2ByteBuffer, width, height, resI420Buffer);
+    TestRetVal(retVal, width*height*3/2);
+    fwrite(resI420Buffer, lengthSourceFrame, 1, outputFile);
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height, kI420, &psnr);
+    printf("Note: Frame was compressed!\n");
+    printf("Conversion between type #%d and type #%d, PSNR = %f\n", kI420,
+           kRGB565, psnr);
+ 
+    delete [] res2ByteBuffer;
+    j++;
+
+    printf("\nTEST #%d I420 <-> YUY2\n", j);
+    WebRtc_UWord8* outYUY2Buffer = new WebRtc_UWord8[width*height*2];
+
+    ticks = clock();
+    for (int t = 0; t < 1000; t++)
+    {
+        retVal = ConvertI420ToYUY2(origBuffer, outYUY2Buffer, width, height,0);
+    }
+    ticks = clock() - ticks;
+#ifndef SCALEOPT
+    fprintf(logFile, "\nConvertI420ToYUY2, before opt: %d\n", ticks);
+#else
+    fprintf(logFile, "\nConvertI420ToYUY2, after opt: %d\n", ticks);
+#endif
+    TestRetVal(retVal, width*height*2);
+    ticks = clock();
+    for (int t = 0; t < 1000; t++)
+    {
+        retVal = ConvertToI420(kYUY2, outYUY2Buffer, width, height,
+                               resI420Buffer);
+    }
+    ticks = clock() - ticks;
+#ifndef SCALEOPT
+    fprintf(logFile, "\nConvertYUY2ToI420, before opt: %d\n", ticks);
+#else
+    fprintf(logFile, "\nConvertYUY2ToI420, after opt: %d\n", ticks);
+#endif
+    TestRetVal(retVal, width*height*3/2);
+    fwrite(resI420Buffer, lengthSourceFrame, 1, outputFile);
+    ImagePSNRfromBuffer(origBuffer, resI420Buffer, width, height, kI420, &psnr);
+    printf("Conversion between type #%d and type #%d,PSNR = %f\n", kI420,
+           kYUY2, psnr);
+  
+    delete [] outYUY2Buffer;
+    j++;
+ 
+    printf("\nTEST #%d I420 <-> UYVY\n", j);
+
+    outUYVYBuffer = new WebRtc_UWord8[width*height*2]; // assuming DIFF = 0
+    WebRtc_UWord8* resYUVBuffer = new WebRtc_UWord8[width*height*2];
+    retVal = ConvertFromI420(kUYVY, origBuffer, width, height, outUYVYBuffer);
+    TestRetVal(retVal, width*height*2);
+    retVal = ConvertToI420(kUYVY, outUYVYBuffer, width, height, resYUVBuffer);
+    TestRetVal(retVal, width*height*3/2);
+    fwrite(resYUVBuffer, lengthSourceFrame, 1, outputFile);
+    ImagePSNRfromBuffer(origBuffer, resYUVBuffer, width, height, kI420, &psnr);
+    printf("Conversion between type #%d and type #%d,PSNR = %f\n", kI420,
+           kUYVY, psnr);
+
+    delete [] outUYVYBuffer;
+    delete [] resYUVBuffer;
+
+    j++;
+
+     /*******************************************************************
+     * THE FOLLOWING FUNCTIONS HAVE NO INVERSE, BUT ARE PART OF THE TEST
+     * IN ORDER TO VERIFY THAT THEY DO NOT CRASH
+     *******************************************************************/
+     printf("\n\n Running functions with no inverse...\n");
+
+     //printf("TEST #%d I420 -> ARGB4444 \n", j);
+     res2ByteBuffer  = new WebRtc_UWord8[width*height*2];
+     ConvertI420ToARGB4444(origBuffer, res2ByteBuffer, width, height, 0);
+     delete [] res2ByteBuffer;
+
+     // YUY2 conversions
+     //printf("TEST #%d I420 -> YUY2 \n", j);
+     WebRtc_UWord8* sourceYUY2 = new WebRtc_UWord8[width*height*2];
+     ConvertI420ToYUY2(origBuffer, sourceYUY2, width, height, 0);
+
+     delete [] sourceYUY2;
+
+     //UYVY conversions
+     WebRtc_UWord8* sourceUYVY = new WebRtc_UWord8[width*height*2];
+     ConvertI420ToUYVY(origBuffer, sourceUYVY, width, height, 0);
+
+     //printf("TEST I420-> ARGB444\n");
+     res2ByteBuffer  = new WebRtc_UWord8[(width+10)*height*2];
+     retVal = webrtc::ConvertI420ToARGB4444(origBuffer, res2ByteBuffer,
+                                            width, height, width + 10);
+     TestRetVal(retVal, (width+10)*height*2);
+     delete [] res2ByteBuffer;
+
+      //printf("TEST I420-> ARGB1555\n");
+     res2ByteBuffer  = new WebRtc_UWord8[(width+10)*height*2];
+     retVal = ConvertI420ToARGB1555(origBuffer, res2ByteBuffer, width,
+                                    height, width + 10);
+     TestRetVal(retVal, (width+10)*height*2);
+     delete [] res2ByteBuffer;
+
+     //printf("TEST NV12 - > I420\n");
+     // using original I420 sequence - > just to verify it doesn't crash
+     ConvertNV12ToI420(origBuffer,resI420Buffer, width, height);
+     //printf("TEST NV12 - > I420 and Rotate 180\n");
+     ConvertNV12ToI420AndRotate180(origBuffer, resI420Buffer, width, height);
+     //printf("TEST NV12 - > I420 and Rotate anti Clockwise\n");
+     ConvertNV12ToI420AndRotateAntiClockwise(origBuffer, resI420Buffer,
+                                             width, height);
+     //printf("TEST NV12 - > I420 and Rotate Clockwise\n");
+     ConvertNV12ToI420AndRotateClockwise(origBuffer, resI420Buffer,
+                                         width, height);
+     //printf("TEST NV12 -> RGB565 \n");
+     res2ByteBuffer  = new WebRtc_UWord8[(width+10)*height*2];
+     ConvertNV12ToRGB565(origBuffer, res2ByteBuffer, width, height);
+     delete [] res2ByteBuffer;
+
+     //printf("TEST I420 - > RGBAIPhone");
+     WebRtc_UWord8* resBuffer = new WebRtc_UWord8[(width + 10) * height * 4];
+     ConvertI420ToRGBAIPhone(origBuffer, resBuffer, width, height, width + 10);
+     delete [] resBuffer;
+
+     //printf("TEST #%d I420 <-> ARGB_Mac", j);
+     WebRtc_UWord8* outARGBBuffer = new WebRtc_UWord8[width * height * 4];
+     retVal = ConvertI420ToARGBMac(origBuffer,outARGBBuffer, width, height, 0);
+     TestRetVal(retVal, width * height * 4);
+     delete [] outARGBBuffer;
+
+
+
+
+    //closing
+    fclose(sourceFile);
+    fclose(outputFile);
+    fclose(logFile);
+    delete [] origBuffer;
+    delete [] resI420Buffer;
+    std::cout << "\n**  View output file **\n";
+    std::cout << "Press enter to  quit test...";
+    std::string str;
+    std::getline(std::cin, str);
+    
+    return 0;
+}
+
+WebRtc_Word32
+ImagePSNRfromBuffer(WebRtc_UWord8 *refBufName, WebRtc_UWord8 *testBufName,
+                    WebRtc_Word32 width, WebRtc_Word32 height,
+                    VideoType vType, double *YPSNRptr)
+{
+    // currently assumes I420
+    if (vType != kI420)
+    {
+        return -1;
+    }
+    double mse = 0.0;
+    double mseLogSum = 0.0;
+   
+    WebRtc_UWord8 *ref = refBufName;
+    WebRtc_UWord8 * test = testBufName;
+    // comparing only 1 frame
+    mse = 0.0;
+
+    // calculate Y sum-square-difference
+    for( int k = 0; k < width * height; k++ )
+    {
+          mse += (test[k] - ref[k]) * (test[k] - ref[k]);
+    }
+
+    // divide by number of pixels
+    mse /= (double) (width * height);
+
+    if (mse == 0)
+    {
+        *YPSNRptr = 48;
+        return 0;
+    }
+    // accumulate for total average
+    mseLogSum += std::log10( mse );
+   
+    *YPSNRptr = 20.0 * std::log10(255.0) - 10.0 * mseLogSum;
+
+     return 0;
+}
+
+void TestRetVal(int testVal, int refVal )
+{
+    if (testVal != refVal)
+    {
+        printf("return value = %d, desired value = %d\n", testVal, refVal);
+    }
+}
diff --git a/common_video/vplib/main/test/convert_test/convert_test.h b/common_video/vplib/main/test/convert_test/convert_test.h
new file mode 100644
index 0000000..992b497
--- /dev/null
+++ b/common_video/vplib/main/test/convert_test/convert_test.h
@@ -0,0 +1,22 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#ifndef WEBRTC_COMMON_VIDEO_VPLIB_TEST_CONVERT_TEST_H
+#define WEBRTC_COMMON_VIDEO_VPLIB_TEST_CONVERT_TEST_H
+
+#include "vplib.h"
+
+
+void ToFile(WebRtc_UWord8 *buf, WebRtc_Word32 length, WebRtc_Word32 num);
+WebRtc_Word32
+PSNRfromFiles(const WebRtc_Word8 *refFileName, const WebRtc_Word8 *testFileName, WebRtc_Word32 width, 
+              WebRtc_Word32 height, WebRtc_Word32 numberOfFrames, double *YPSNRptr);
+
+#endif
diff --git a/common_video/vplib/main/test/interpolation_test.cc b/common_video/vplib/main/test/interpolation_test.cc
new file mode 100644
index 0000000..9ae1ce5
--- /dev/null
+++ b/common_video/vplib/main/test/interpolation_test.cc
@@ -0,0 +1,128 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <string.h>
+#include <stdio.h>
+#include <time.h>
+
+#include "interpolator.h"
+#include "vplib.h"
+#include "test_util.h"
+
+using namespace webrtc;
+
+int interpolationTest(CmdArgs& args)
+{
+    // Read input file, interpolate first frame according to requested method
+    // for now only YUV input and output
+
+    FILE* sourceFile;
+    FILE* outputFile;
+
+    std::string outname = args.outputFile;
+    if (outname == "")
+    {
+        outname = "InterTest_out.yuv";
+    }
+    if (args.width < 1 || args.height < 1 ||
+        args.dstWidth < 1 || args.dstHeight < 1)
+    {
+        printf("Error in input dimensions\n" );
+        return -1;
+    }
+
+    WebRtc_Word32 ret;
+
+    // create interpolator
+    webrtc::interpolator* inter = new webrtc::interpolator();
+    ret = inter->Set(args.width, args.height,
+                     args.dstWidth, args.dstHeight,
+                     kI420, kI420,
+                     (webrtc::interpolatorType) args.intMethod);
+    if (ret != 0)
+    {
+        printf("Set ret = %d\n", ret);
+        delete inter;
+        return ret;
+    }
+
+    // read frame into buffer / create destination buffer
+    if ((outputFile = fopen(outname.c_str(), "wb")) == NULL)
+    {
+        printf("Cannot write file %s.\n", outname.c_str());
+
+        exit(1);
+    }
+
+    std::string inname = args.inputFile;
+    if ((sourceFile = fopen(inname.c_str(), "rb")) == NULL)
+    {
+        printf("Cannot read file %s.\n", inname.c_str());
+        exit(1);
+    }
+
+    WebRtc_UWord32 inRequiredSize = args.width * args.height * 3 >> 1;
+    WebRtc_UWord32 outRequiredSize = args.dstWidth * args.dstHeight * 3 >> 1;
+    WebRtc_UWord8* inputBuffer = new WebRtc_UWord8[inRequiredSize];
+    WebRtc_UWord8* outputBuffer = NULL;
+
+    //
+    clock_t startClock, TotalClock;
+    TotalClock = 0;
+    //
+    // running through entire sequence
+    int frameCnt = 0;
+    while (feof(sourceFile)== 0)
+    {
+        if (inRequiredSize != fread(inputBuffer, 1, inRequiredSize, sourceFile))
+            break;
+
+        startClock = clock();
+        ret = inter->Interpolate(inputBuffer, outputBuffer);
+        TotalClock += clock() - startClock;
+
+        if (ret == args.dstHeight)
+        {
+            fwrite(outputBuffer, 1, outRequiredSize, outputFile);
+            ret = 0;  // signaling OK to main tester
+        }
+        else
+        {
+            printf("frame #%d: Interpolation Error, ret = %d\n", frameCnt, ret);
+        }
+
+        if (outputBuffer)
+        {
+            delete [] outputBuffer;
+            outputBuffer = NULL;
+        }
+        frameCnt++;
+        printf(".");
+    }
+
+    printf("\nProcessed %d frames\n", frameCnt);
+    if (frameCnt)
+        printf("\nAvg. Time per frame[mS]: %.2lf\n",
+              (1000.0 * static_cast<double>(TotalClock + 0.0)
+               /CLOCKS_PER_SEC)/frameCnt);
+
+    if (outputBuffer)
+        delete [] outputBuffer;
+
+    fclose(sourceFile);
+    fclose(outputFile);
+
+
+    // wrap up
+    delete inter;
+    delete [] inputBuffer;
+
+    return ret;
+}
diff --git a/common_video/vplib/main/test/scale_test.cc b/common_video/vplib/main/test/scale_test.cc
new file mode 100644
index 0000000..611060d
--- /dev/null
+++ b/common_video/vplib/main/test/scale_test.cc
@@ -0,0 +1,695 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+
+#include <cassert>
+#include <iostream>
+#include <string>
+
+#include "vplib.h"
+
+#include <cstring>
+
+using namespace webrtc;
+
+#define TEST_STR "Test Scale."
+#define TEST_PASSED() std::cerr << TEST_STR << " : [OK]" << std::endl
+#define PRINT_LINE std::cout << "------------------------------------------" << std::endl;
+
+void PrintFrame(WebRtc_UWord8* ptrFrame, WebRtc_Word32 width, WebRtc_Word32 height)
+{
+    WebRtc_Word32 k = 0;
+    for (WebRtc_Word32 i = 0; i < height; i++)
+    {
+        for (WebRtc_Word32 j = 0; j < width; j++)
+        {
+            std::cout << (WebRtc_Word32)ptrFrame[k++] << " ";
+        }
+        std::cout << " " << std::endl;
+    }
+    std::cout << " " << std::endl;
+}
+
+
+void PrintFrame(WebRtc_UWord8* ptrInFrame, WebRtc_Word32 width, WebRtc_Word32 height, const WebRtc_Word8* str)
+{
+    std::cout << str << " (" << width << "x" << height << ") = " << std::endl;
+
+    WebRtc_UWord8* ptrFrameY  = ptrInFrame;
+    WebRtc_UWord8* ptrFrameCb = ptrFrameY  + width*height;
+    WebRtc_UWord8* ptrFrameCr = ptrFrameCb + width*height/4;
+   
+    PrintFrame(ptrFrameY,  width,   height);
+    PrintFrame(ptrFrameCb, width/2, height/2);
+    PrintFrame(ptrFrameCr, width/2, height/2);  
+}
+
+void CreateImage(WebRtc_Word32 width, WebRtc_Word32 height, WebRtc_UWord8* ptrFrame, WebRtc_Word32 offset, WebRtc_Word32 heightFactor, WebRtc_Word32 widthFactor = 0)
+{
+    for (WebRtc_Word32 i = 0; i < height; i++)
+    {
+        for (WebRtc_Word32 j = 0; j < width; j++)
+        {
+            *ptrFrame = (WebRtc_UWord8)((i + offset)*heightFactor + j*widthFactor);
+            ptrFrame++;
+        }
+    }
+}
+
+void ValidateImage2(WebRtc_Word32 width, WebRtc_Word32 height, WebRtc_UWord8* ptrFrame, WebRtc_Word32 offset, WebRtc_Word32 factor)
+{
+    WebRtc_Word32 k = 0;
+    WebRtc_Word32 res = offset*factor;
+    for (WebRtc_Word32 i = 0; i < height; i++)
+    {
+        for (WebRtc_Word32 j = 0; j < width; j++)
+        {
+            assert(ptrFrame[k++] == res);
+        }
+        if (i > 0)
+        {
+            res += factor/2;
+        }
+    }
+}
+
+void ValidateImage3_2(WebRtc_Word32 width, WebRtc_Word32 height, WebRtc_UWord8* ptrFrame, WebRtc_Word32 offset, WebRtc_Word32 factor)
+{
+    WebRtc_Word32 k = 0;
+    bool inc = true;
+    WebRtc_Word32 res = offset*factor;
+    for (WebRtc_Word32 i = 1; i <= height; i++)
+    {
+        for (WebRtc_Word32 j = 0; j < width; j++)
+        {
+            assert(ptrFrame[k++] == res);
+        }
+        res += factor/2;
+        if ((i % 3) == 0)
+        {
+            res += factor/2;  
+        }
+    }
+}
+
+void ValidateImage1_3(WebRtc_Word32 width, WebRtc_Word32 height, WebRtc_UWord8* ptrFrame, WebRtc_Word32 offset, WebRtc_Word32 factor)
+{
+    WebRtc_Word32 k = 0;
+    WebRtc_Word32 res = offset*factor;
+    res += factor/2;
+    for (WebRtc_Word32 i = 0; i < height; i++)
+    {
+        for (WebRtc_Word32 j = 0; j < width; j++)
+        {
+            assert(ptrFrame[k++] == res);
+        }
+        res += factor*3;  
+    }
+}
+
+static void VerifyInBounds(const WebRtc_UWord8* ptrImage, const WebRtc_Word32 imageLength, 
+                           const WebRtc_Word32 startOffset, const WebRtc_Word32 endOffset)
+{
+    // Verify that function does not write outside buffer
+    const WebRtc_UWord8* ptrFrameStart = ptrImage - startOffset;
+    const WebRtc_UWord8* ptrFrameEnd   = ptrImage + imageLength;
+
+    // Verify that function does not write outside buffer
+    for (WebRtc_Word32 i = 0; i < startOffset; i++)
+    {
+        assert(ptrFrameStart[i] == 255);
+    }
+
+    for (WebRtc_Word32 i = 0; i < endOffset; i++)
+    {
+        assert(ptrFrameEnd[i] == 255);
+    }
+}
+
+WebRtc_Word32 
+VerifyAndAllocateTest(WebRtc_UWord8*& buffer, WebRtc_Word32 currentSize, WebRtc_Word32 newSize)
+{
+    if(newSize > currentSize)
+    {
+        // make sure that our buffer is big enough
+        WebRtc_UWord8* newBuffer = new WebRtc_UWord8[newSize];
+        if(buffer)
+        {
+            // copy the old data
+            memcpy(newBuffer, buffer, currentSize);
+            delete [] buffer;
+        }
+        buffer = newBuffer;
+        return newSize;
+    }
+
+    return currentSize;
+}
+
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+//--------------------------------------------------------------------------------
+
+int
+scale_test()
+{
+
+  std::string str;
+    std::cout << "--------------------------------" << std::endl;
+    std::cout << "-------- Test Scaling ----------" << std::endl;
+    std::cout << "--------------------------------" << std::endl;
+    std::cout << "  "  << std::endl;
+  
+    // -------------------------------
+    // Test ScaleI420Up2() -----------
+    // -------------------------------
+    PRINT_LINE;
+    std::cout << "Test ScaleI420Up2()" << std::endl;
+    PRINT_LINE;
+
+    WebRtc_UWord32 width = 12;
+    WebRtc_UWord32 height = 10;
+    WebRtc_Word32 factorY = 2;
+    WebRtc_Word32 factorCb = 10;
+    WebRtc_Word32 factorCr = 20;
+    WebRtc_Word32 offset = 5;
+    WebRtc_Word32 startBufferOffset = 10;
+    WebRtc_UWord32 length = CalcBufferSize(kI420, width, height);
+
+    // Test bad inputs
+    WebRtc_UWord32 scW = 0;
+    WebRtc_UWord32 scH = 0;
+   
+    WebRtc_UWord8* testFrame = new WebRtc_UWord8[length + offset];
+    WebRtc_Word32 retVal = ScaleI420Up2(0, height,testFrame,length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(width, 0, testFrame,length,  scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(49, height, testFrame, length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(width, 3, testFrame,length, scW, scH);   // odd height
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(width + 2, height, testFrame,length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(width, height + 2, testFrame,length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Up2(width, height, testFrame,length, scW, scH);     // width, height == allocated buffer size, OK
+    assert(retVal == scW * scH * 3 / 2);
+    delete [] testFrame;
+
+    testFrame = new WebRtc_UWord8[  length * 4 + startBufferOffset * 2];
+    memset(testFrame, 255, length * 4 + startBufferOffset * 2);
+
+    // Create input frame
+    WebRtc_UWord8* ptrFrameY = testFrame;
+    WebRtc_UWord8* ptrFrameCb = ptrFrameY + width*height;
+    WebRtc_UWord8* ptrFrameCr = ptrFrameCb + width*height/4;
+    CreateImage(width,   height,   ptrFrameY,  offset, factorY);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, offset, factorCb); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, offset, factorCr); // Cr
+    PrintFrame(testFrame, width, height, "InputFrame");
+
+    // Scale frame to twice its size
+    WebRtc_UWord32 scaledWidth = 0;
+    WebRtc_UWord32 scaledHeight = 0;
+    retVal = ScaleI420Up2(width, height, testFrame, length * 4 + startBufferOffset * 2, scaledWidth, scaledHeight);
+   
+    PrintFrame(testFrame, scaledWidth, scaledHeight, "Output Frame");
+
+    // Validate results
+    assert(retVal == scaledWidth * scaledHeight * 3 / 2);
+    ptrFrameY = testFrame;
+    ptrFrameCb  = ptrFrameY  + scaledWidth*scaledHeight;
+    ptrFrameCr  = ptrFrameCb + scaledWidth*scaledHeight/4;
+
+    ValidateImage2(scaledWidth,   scaledHeight,   ptrFrameY,  offset, factorY);
+    ValidateImage2(scaledWidth/2, scaledHeight/2, ptrFrameCb, offset, factorCb);
+    ValidateImage2(scaledWidth/2, scaledHeight/2, ptrFrameCr, offset, factorCr);
+
+    delete [] testFrame;
+
+    // --------------------------------
+    // Test ScaleI420Up3_2() ----------
+    // --------------------------------
+    PRINT_LINE;
+    std::cout << "Test ScaleI420Up3_2()" << std::endl;
+    PRINT_LINE;
+
+    width = 12;
+    height = 8;
+    factorY = 2;
+    factorCb = 10;
+    factorCr = 20;
+    offset = 5;
+    startBufferOffset = 10;
+    length = CalcBufferSize(kI420, width, height);
+
+    // Test bad inputs
+    testFrame = new WebRtc_UWord8[length];
+
+    retVal = ScaleI420Up3_2(0, height, testFrame,length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width, 0, testFrame,length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(49, height, testFrame,length, scW, scH); // odd width
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width, 3, testFrame,length, scW, scH);   // odd height
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width, 10, testFrame,length, scW, scH);   // odd height (color)
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(14, height, testFrame,length, scW, scH);   // odd width (color)
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width + 2, height, testFrame,length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width, height + 2, testFrame,length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Up3_2(width, height, testFrame,length, scW, scH);     // width, height == allocated buffer size, OK
+    assert(retVal == scW * scH * 3 / 2);
+
+    delete [] testFrame;
+       
+    testFrame = new WebRtc_UWord8[length + startBufferOffset];
+    memset(testFrame, 255, length + startBufferOffset);
+    
+    // Create input frame
+    ptrFrameY = testFrame;
+    ptrFrameCb = ptrFrameY + width*height;
+    ptrFrameCr = ptrFrameCb + width*height/4;
+    CreateImage(width,   height,   ptrFrameY,  offset, factorY);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, offset, factorCb); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, offset, factorCr); // Cr
+    PrintFrame(testFrame, width, height, "Input Frame");
+
+
+    // Scale frame to 1.5 times its size
+    scaledWidth = 0;
+    scaledHeight = 0;
+    retVal = ScaleI420Up3_2(width, height, testFrame, length + startBufferOffset, scaledWidth, scaledHeight);
+    
+    PrintFrame(testFrame, scaledWidth, scaledHeight, "Output Frame");
+
+    // Validate results
+    assert(retVal == scaledWidth * scaledHeight * 3 / 2);
+
+    // Verify that function does not write outside buffer
+    ptrFrameY  = testFrame;//imageBuffer.GetBuffer();
+    ptrFrameCb = ptrFrameY  + scaledWidth*scaledHeight;
+    ptrFrameCr = ptrFrameCb + scaledWidth*scaledHeight/4;
+
+    ValidateImage3_2(scaledWidth,   scaledHeight,   ptrFrameY,  offset, factorY);
+    ValidateImage3_2(scaledWidth/2, scaledHeight/2, ptrFrameCb, offset, factorCb);
+    ValidateImage3_2(scaledWidth/2, scaledHeight/2, ptrFrameCr, offset, factorCr);
+
+    delete [] testFrame;
+
+    // --------------------------------
+    // Test ScaleI420Down1_3() ----------
+    // --------------------------------
+    PRINT_LINE;
+    std::cout << "Test ScaleI420Up1_3()" << std::endl;
+    PRINT_LINE;
+
+    width = 10;
+    height = 8;
+    factorY = 2;
+    factorCb = 10;
+    factorCr = 20;
+    offset = 5;
+    startBufferOffset = 10;
+    length = webrtc::CalcBufferSize(kI420, width, height);
+
+    // Test bad inputs
+    testFrame = new WebRtc_UWord8[length];
+    retVal = ScaleI420Down1_3(0, height, testFrame, length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(width, 0, testFrame, length, scW, scH);
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(49, height, testFrame, length, scW, scH); // odd width
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(width, 3, testFrame, length, scW, scH);   // odd height
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(width + 2, height, testFrame, length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(width, height + 2, testFrame, length, scW, scH); // width, height > allocated buffer size
+    assert(retVal == -1);
+    retVal = ScaleI420Down1_3(width, height, testFrame, length, scW, scH);     // width, height == allocated buffer size, ok
+    assert(retVal == scW * scH * 3 / 2);
+    
+    delete [] testFrame;
+        
+    testFrame = new WebRtc_UWord8[length + startBufferOffset * 2];
+    memset(testFrame, 255, length + startBufferOffset * 2);
+    // Create input frame
+    ptrFrameY = testFrame;
+    ptrFrameCb = ptrFrameY + width*height;
+    ptrFrameCr = ptrFrameCb + width*height/4;
+    CreateImage(width,   height,   ptrFrameY,  offset, factorY);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, offset, factorCb); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, offset, factorCr); // Cr
+    PrintFrame(testFrame, width, height, "Input Frame");
+
+    // Scale frame to one third its size
+    scaledWidth = 0;
+    scaledHeight = 0;
+    retVal = ScaleI420Down1_3(width, height, testFrame, length + startBufferOffset * 2 , scaledWidth, scaledHeight);
+    
+    PrintFrame(testFrame, scaledWidth, scaledHeight, "Output Frame");
+
+    // Validate results
+    assert(retVal == scaledWidth * scaledHeight * 3 / 2);
+
+    // Verify that function does not write outside buffer
+    ptrFrameY  = testFrame;//imageBuffer.GetBuffer();
+    ptrFrameCb = ptrFrameY  + scaledWidth*scaledHeight;
+    ptrFrameCr = ptrFrameCb + scaledWidth*scaledHeight/4;
+
+    ValidateImage1_3(scaledWidth,   scaledHeight,   ptrFrameY,  offset, factorY);
+    ValidateImage1_3(scaledWidth/2, scaledHeight/2, ptrFrameCb, offset, factorCb);
+    ValidateImage1_3(scaledWidth/2, scaledHeight/2, ptrFrameCr, offset, factorCr);
+
+    delete [] testFrame;
+
+    // -------------------
+    // Test PadI420Frame()
+    // -------------------
+    PRINT_LINE;
+    std::cout << "Test PadI420Frame()" << std::endl;
+    PRINT_LINE;
+
+    width = 16;
+    height = 8;
+    factorY = 1;
+    factorCb = 1;
+    factorCr = 1;
+    offset = 5;
+    startBufferOffset = 10;
+    length = CalcBufferSize(kI420, width, height);
+
+    testFrame = new WebRtc_UWord8[length];
+    memset(testFrame, 255, length);
+
+    // Create input frame
+    ptrFrameY = testFrame;//imageBuffer.GetBuffer();
+    ptrFrameCb = ptrFrameY + width*height;
+    ptrFrameCr = ptrFrameCb + width*height/4;
+    CreateImage(width,   height,   ptrFrameY,  1, factorY);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, 100, factorCb); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, 200, factorCr); // Cr
+    PrintFrame(testFrame, width, height, "Input Frame");
+
+    WebRtc_UWord8* testFrame2 = new WebRtc_UWord8[352*288];
+
+    // Test bad input
+    assert(PadI420Frame(NULL, testFrame2, 16, 16, 32, 32) == -1);
+    assert(PadI420Frame(testFrame, NULL, 16, 16, 32, 32) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 0, 16, 32, 32) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 0, 32, 32) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 16, 0, 32) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 16, 32, 0) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 16, 8, 32) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 16, 32, 8) == -1);
+    assert(PadI420Frame(testFrame, testFrame2, 16, 16, 16, 16) == 3 * 16 * 16 / 2);
+
+    enum { NumOfPaddedSizes = 4 };
+    WebRtc_Word32 paddedWidth[NumOfPaddedSizes] = { 32, 22, 16, 20 };
+    WebRtc_Word32 paddedHeight[NumOfPaddedSizes] = { 16, 14, 12, 8 };
+    
+    for (WebRtc_Word32 i = 0; i < NumOfPaddedSizes; i++)
+    {
+        scaledWidth = paddedWidth[i];
+        scaledHeight = paddedHeight[i];
+        
+        WebRtc_Word32 toLength = webrtc::CalcBufferSize(kI420, scaledWidth, scaledHeight);
+
+         if (testFrame2)
+         {
+             delete [] testFrame2;
+         }
+         testFrame2 = new WebRtc_UWord8[toLength + startBufferOffset * 2];
+         memset(testFrame2, 255, toLength + startBufferOffset * 2);
+
+
+        retVal = webrtc::PadI420Frame(testFrame, testFrame2, width, height, scaledWidth, scaledHeight);
+        PrintFrame(testFrame2, scaledWidth, scaledHeight, "Output Frame");
+        
+        // Validate results
+        assert(retVal == toLength);
+
+    }
+    std::cout << "Do the padded frames look correct?" << std::endl
+        << "(Padded dimensions which are multiples of 16 will have the" << std::endl
+        << "padding applied in blocks of 16)" << std::endl
+        << "Press enter to continue...";
+    std::getline(std::cin, str);
+
+    // -----------------
+    // Test video sizes
+    // -----------------
+    const WebRtc_Word32 nr = 16;
+    // currently not keeping video sizes as a type - testing scaling functions only
+    WebRtc_UWord16 widths[nr] =  {128, 160, 176, 320, 352, 640, 720, 704, 800, 960, 1024, 1440, 400, 800, 1280, 1920};
+    WebRtc_UWord16 heights[nr] = { 96, 120, 144, 240, 288, 480, 480, 576, 600, 720,  768, 1080, 240, 480,  720, 1080};
+
+    for (WebRtc_Word32 j = 0; j < 3; j++)
+    {
+        for (WebRtc_Word32 i = 0; i < nr; i++)
+        {
+            width = widths[i];
+            height = heights[i];
+            factorY = 2;
+            factorCb = 2;
+            factorCr = 2;
+            offset = 2;
+            startBufferOffset = 10;
+            length = webrtc::CalcBufferSize(kI420, width, height);
+
+            float f = 1;
+            if (j == 0)
+            {
+                f = 2;
+            }
+            else if (j == 1)
+            {
+                f = 1.5;
+            }
+            else if (j == 2)
+            {
+                f = 1;
+            }
+
+            if (testFrame)
+            {
+                delete testFrame;
+                testFrame = 0;
+            }
+            WebRtc_Word32 frameSize = (WebRtc_Word32) ((length * f * f) + startBufferOffset * 2);
+            testFrame = new WebRtc_UWord8[frameSize];
+            memset(testFrame, 255, frameSize);
+          
+            // Create input frame
+            ptrFrameY = testFrame;
+            ptrFrameCb = ptrFrameY + width*height;
+            ptrFrameCr = ptrFrameCb + width*height/4;
+            CreateImage(width,   height,   ptrFrameY,  offset, factorY);  // Y
+            CreateImage(width/2, height/2, ptrFrameCb, offset, factorCb); // Cb
+            CreateImage(width/2, height/2, ptrFrameCr, offset, factorCr); // Cr
+          
+            scaledWidth = 0;
+            scaledHeight = 0;
+            if (j == 0)
+            {
+                retVal = ScaleI420Up2(width, height, testFrame,frameSize, scaledWidth, scaledHeight);
+                length = scaledWidth*scaledHeight*3/2;
+            }
+            else if (j == 1)
+            {
+                retVal = ScaleI420Up3_2(width, height, testFrame,frameSize, scaledWidth, scaledHeight);
+                length = scaledWidth*scaledHeight*3/2;
+            }
+            else if (j == 2)
+            {
+                retVal = ScaleI420Down1_3(width, height, testFrame,frameSize, scaledWidth, scaledHeight);
+                length = width*height*3/2;
+            }
+
+            // Validate results
+            assert(retVal == scaledWidth * scaledHeight * 3 / 2);
+        }
+    }
+
+    // ---------------------
+    // Test mirror functions
+    // ---------------------
+    std::cout << "Test Mirror function" << std::endl;
+    
+    // 4:2:0 images can't have odd width or height
+    width = 16;
+    height = 8;
+    factorY = 1;
+    factorCb = 1;
+    factorCr = 1;
+    offset = 5;
+    startBufferOffset = 10;
+    length = webrtc::CalcBufferSize(kI420, width, height);
+
+    delete [] testFrame;
+    testFrame = new WebRtc_UWord8[length];
+    memset(testFrame, 255, length);
+
+    // Create input frame
+    WebRtc_UWord8* inFrame = testFrame;
+    ptrFrameCb = inFrame + width * height;
+    ptrFrameCr = ptrFrameCb + (width * height) / 4;
+    CreateImage(width,   height,   inFrame,  10, factorY, 1);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, 100, factorCb, 1); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, 200, factorCr, 1); // Cr
+    PrintFrame(testFrame, width, height, "Input Frame");
+
+    if (testFrame2)
+    {
+        delete [] testFrame2;
+        testFrame2 = 0;
+    }
+    testFrame2 = new WebRtc_UWord8[length + startBufferOffset * 2];
+    memset(testFrame2, 255, length + startBufferOffset * 2);
+    WebRtc_UWord8* outFrame = testFrame2;
+    
+    // LeftRight
+    std::cout << "Test Mirror function: LeftRight" << std::endl;
+    retVal = MirrorI420LeftRight(inFrame, outFrame, width, height);
+    PrintFrame(testFrame2, width, height, "Output Frame");
+    retVal = MirrorI420LeftRight(outFrame, outFrame, width, height);
+
+    assert(memcmp(inFrame, outFrame, length) == 0);
+    //VerifyInBounds(outFrame, length, startBufferOffset, startBufferOffset);
+    
+    //UpDown
+    std::cout << "Test Mirror function: UpDown" << std::endl;
+    retVal = MirrorI420UpDown(inFrame, outFrame, width, height);
+    PrintFrame(testFrame2, width, height, "Output Frame");
+    retVal = MirrorI420UpDown(outFrame, outFrame, width, height);
+
+    assert(memcmp(inFrame, outFrame, length) == 0);
+    //VerifyInBounds(outFrame, length, startBufferOffset, startBufferOffset);
+
+    std::cout << "Do the mirrored frames look correct?" << std::endl
+        << "Press enter to continue...";
+    std::getline(std::cin, str);
+  // end Mirror Function check
+
+    delete [] testFrame;
+    testFrame = new WebRtc_UWord8[length];
+    memset(testFrame,255,length);
+    inFrame = testFrame;
+
+    CreateImage(width,   height,   inFrame,  10, factorY, 1);  // Y
+    CreateImage(width/2, height/2, ptrFrameCb, 100, factorCb, 1); // Cb
+    CreateImage(width/2, height/2, ptrFrameCr, 200, factorCr, 1); // Cr
+
+    PrintFrame(inFrame, width, height, "Input frame");
+
+    delete [] testFrame2;
+    testFrame2 = new WebRtc_UWord8[length];
+    memset(testFrame2, 255, length);
+    int yv12Size = CalcBufferSize(kI420, kYV12, length);
+    WebRtc_UWord8* yv12TestFrame = new WebRtc_UWord8[yv12Size];
+    memset(yv12TestFrame, 255, yv12Size);
+    outFrame = testFrame2;    
+    retVal = ConvertI420ToYV12(inFrame, yv12TestFrame, width, height, 0);
+    assert(retVal >= 0);
+
+    // Test convert and mirror functions
+    ConvertToI420AndMirrorUpDown(yv12TestFrame, outFrame, width, height, kYV12);
+    std::cout << "Test: ConvertAndMirrorUpDown" << std::endl;
+    PrintFrame(outFrame, width, height, "Output Frame");
+    MirrorI420UpDown(outFrame, outFrame, width, height);
+    assert(memcmp(inFrame, outFrame, length) == 0);
+    std::cout << "Does the converted (U and V flipped) mirrored frame look correct?" << std::endl
+        << "Press enter to continue...";
+    std::getline(std::cin, str);
+    delete [] testFrame2;
+
+    PrintFrame(inFrame, width, height, "Input frame");
+
+    // Test convert and rotate functions
+    testFrame2 = new WebRtc_UWord8[length];
+    memset(testFrame2, 255, length);
+    outFrame = testFrame2;
+    WebRtc_UWord8* tempFrame = new WebRtc_UWord8[length];
+
+    ConvertToI420(kYV12, yv12TestFrame, width, height, outFrame, false, kRotateAntiClockwise);
+    std::cout << "Test: ConvertAndRotateAntiClockwise" << std::endl;
+    PrintFrame(outFrame, height, width, "Output Frame");
+    ConvertToI420(kI420, outFrame, height, width, tempFrame, false, kRotateAntiClockwise);
+    ConvertToI420(kI420, tempFrame, width, height, outFrame, false, kRotateAntiClockwise);
+    ConvertToI420(kI420, outFrame, height, width, tempFrame, false, kRotateAntiClockwise);
+    assert(memcmp(inFrame, tempFrame, length) == 0);
+
+    delete [] testFrame2;
+
+    testFrame2 = new WebRtc_UWord8[length];
+    outFrame = testFrame2;
+    memset(outFrame, 255, length);
+    memset(tempFrame, 255, length);
+    ConvertToI420(kYV12, yv12TestFrame, width, height, outFrame, false, kRotateClockwise);
+    std::cout << "Test: ConvertAndRotateClockwise" << std::endl;
+    PrintFrame(outFrame, height, width, "Output Frame");
+    ConvertToI420(kI420, outFrame, height, width, tempFrame, false, kRotateClockwise);
+    ConvertToI420(kI420, tempFrame, width, height, outFrame, false, kRotateClockwise);
+    ConvertToI420(kI420, outFrame, height, width, tempFrame, false, kRotateClockwise);
+    assert(memcmp(inFrame, tempFrame, length) == 0);
+
+    delete [] testFrame2;
+
+    std::cout << "Do the converted (U and V flipped) and rotated frames look correct?" << std::endl
+        << "Press enter to continue...";
+    std::getline(std::cin, str);
+
+
+    PrintFrame(inFrame, width, height, "Input frame");
+
+    // Test rotation with padding
+   
+    height += 4;
+    length = width * height * 3 / 2;
+    testFrame2 = new WebRtc_UWord8[length];
+    memset(testFrame2, 255, length);
+    outFrame = testFrame2;
+    webrtc::ConvertToI420(kYV12, yv12TestFrame, width, height - 4, outFrame, false, webrtc::kRotateClockwise);
+    std::cout << "Test: ConvertAndRotateClockwise (width padding)" << std::endl;
+    PrintFrame(outFrame, height, width, "Output Frame");
+
+    width += 4;
+    height -= 4;
+    memset(testFrame2, 255, length);
+    outFrame = testFrame2;
+    ConvertToI420(kYV12, yv12TestFrame, width - 4, height, outFrame, false, webrtc::kRotateAntiClockwise);
+    std::cout << "Test: ConvertAndRotateClockwise (height padding)" << std::endl;
+    PrintFrame(outFrame, height, width, "Output Frame");
+
+    std::cout << "Do the rotated and padded images look correct?" << std::endl
+        << "Press enter to continue...";
+    std::getline(std::cin, str);
+
+    delete [] tempFrame;
+    tempFrame = NULL;
+    delete [] testFrame;
+    testFrame = NULL;
+    delete [] testFrame2;
+    testFrame2 = NULL;
+    delete [] yv12TestFrame;
+    yv12TestFrame = NULL;
+
+    TEST_PASSED();
+    std::cout << "Press enter to quit test...";
+    std::getline(std::cin, str);
+
+    return 0;
+}
diff --git a/common_video/vplib/main/test/test_util.h b/common_video/vplib/main/test/test_util.h
new file mode 100644
index 0000000..7fd34da
--- /dev/null
+++ b/common_video/vplib/main/test/test_util.h
@@ -0,0 +1,38 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+#ifndef COMMON_VIDEO_VPLIB_TEST_UTIL_H
+#define COMMON_VIDEO_VPLIB_TEST_UTIL_H
+
+#include <string.h>
+#include <fstream>
+#include <cstdlib>
+
+
+class CmdArgs
+{
+public:
+    CmdArgs() : width(-1), height(-1), dstWidth(-1), dstHeight(-1),
+                intMethod(-1), inputFile(""), outputFile(""), testNum(-1)
+    {}
+    int width;
+    int height;
+    int dstWidth;
+    int dstHeight;
+    int intMethod;
+    std::string inputFile;
+    std::string outputFile;
+    int testNum;
+};
+
+int interpolationTest(CmdArgs& args);
+int convert_test(CmdArgs& args);
+int scale_test();
+
+#endif  // COMMON_VIDEO_VPLIB_TEST_UTIL_H
diff --git a/common_video/vplib/main/test/tester_main.cc b/common_video/vplib/main/test/tester_main.cc
new file mode 100644
index 0000000..090a56c
--- /dev/null
+++ b/common_video/vplib/main/test/tester_main.cc
@@ -0,0 +1,133 @@
+/*
+ *  Copyright (c) 2011 The WebRTC project authors. All Rights Reserved.
+ *
+ *  Use of this source code is governed by a BSD-style license
+ *  that can be found in the LICENSE file in the root of the source
+ *  tree. An additional intellectual property rights grant can be found
+ *  in the file PATENTS.  All contributing project authors may
+ *  be found in the AUTHORS file in the root of the source tree.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#include "vplib.h"
+#include "test_util.h"
+
+using namespace webrtc;
+
+int ParseArguments(int argc, char **argv, CmdArgs& args)
+{
+    int i = 1;
+    while (i < argc)
+    {
+        if (argv[i][0] != '-')
+        {
+            return -1;
+        }
+        switch (argv[i][1])
+        {
+        case 'w':
+        {
+            int w = atoi(argv[i+1]);
+            if (w < 1)
+                return -1;
+            args.width = w;
+            break;
+        }
+        case 'h':
+        {
+            int h = atoi(argv[i+1]);
+            if (h < 1)
+                return -1;
+            args.height = h;
+            break;
+        }
+        case 'x':
+        {
+            int x = atoi(argv[i+1]);
+            if (x < 1)
+                return -1;
+            args.dstWidth = x;
+            break;
+        }
+        case 'y':
+        {
+            int y = atoi(argv[i+1]);
+            if (y < 1)
+                return -1;
+            args.dstHeight = y;
+            break;
+        }
+        case 'm': // interpolation method
+        {
+            int m = atoi(argv[i+1]);
+            if (m < 0)
+                return -1;
+            args.intMethod = m;
+            break;
+        }
+        case 'i':
+        {
+            args.inputFile = argv[i+1];
+            break;
+        }
+        case 'o':
+            args.outputFile = argv[i+1];
+            break;
+        case 'n':
+        {
+            int n = atoi(argv[i+1]);
+            if (n < 1)
+                return -1;
+            args.testNum = n;
+            break;
+        }
+        default:
+            return -1;
+        }
+        i += 2;
+    }
+    return 0;
+}
+
+int main(int argc, char **argv)
+{
+    CmdArgs args;
+
+    if (ParseArguments(argc, argv, args) != 0)
+    {
+        printf("Unable to parse input arguments\n");
+        printf("args: -n <test #> -w <width> -h <height>  "
+               "-x <destination width> -y <destination height> -f <fps> "
+               "-b <bps> -m <method> -i <input file> -o <output file>\n");
+        return -1;
+    }
+    int ret = -1;
+    switch (args.testNum)
+    {
+        printf("\n");
+        case 1:
+            printf("VPLIB Interpolation Test\n");
+            ret = interpolationTest(args);
+            break;
+        case 2:
+            printf("VPLIB Scale Test\n");
+            ret = scale_test();
+            break;
+        case 3:
+            printf("VPLIB Convert Test\n");
+            ret = convert_test(args);
+            break;
+        default:
+            ret = -1;
+            break;
+    }
+    if (ret != 0)
+    {
+        printf("Test failed!\n");
+        return -1;
+    }
+    return 0;
+}