diff --git a/libyuv.gyp b/libyuv.gyp
index d5abab73c..ea3575eee 100644
--- a/libyuv.gyp
+++ b/libyuv.gyp
@@ -12,28 +12,29 @@
       'target_name': 'libyuv',
       'type': 'static_library',
       'include_dirs': [
-        'common',
         'include',
+        '.',
       ],
       'direct_dependent_settings': {
         'include_dirs': [
-          'common',
           'include',
+          '.',
         ],
       },
       'sources': [
         # includes
-        'include/convert.h',
-        'include/general.h',
-        'include/scale.h',
-        'include/planar_functions.h',
+        'include/libyuv/basic_types.h',
+        'include/libyuv/convert.h',
+        'include/libyuv/general.h',
+        'include/libyuv/scale.h',
+        'include/libyuv/planar_functions.h',
+        
 
         # headers
-        'common/basic_types.h',
-        'common/common.h',
-        'common/constructor_magic.h',
+         'source/conversion_tables.h',
         'source/cpu_id.h',
-        'source/rotate.h'
+        'source/rotate.h',
+        'source/rotate_priv.h',
         'source/row.h',
         'source/video_common.h',
 
diff --git a/source/convert.cc b/source/convert.cc
index e555c5440..3d6dc99fe 100644
--- a/source/convert.cc
+++ b/source/convert.cc
@@ -30,22 +30,21 @@ static inline uint8 Clip(int32 val) {
   return (uint8) val;
 }
 
-int
-I420ToRGB24(const uint8* src_yplane, int src_ystride,
-            const uint8* src_uplane, int src_ustride,
-            const uint8* src_vplane, int src_vstride,
-            uint8* dst_frame, int dst_stride,
-            int src_width, int src_height)
+int I420ToRGB24(const uint8* src_yplane, int src_ystride,
+                const uint8* src_uplane, int src_ustride,
+                const uint8* src_vplane, int src_vstride,
+                uint8* dst_frame, int dst_stride,
+                int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
       dst_frame == NULL)
     return -1;
 
   // RGB orientation - bottom up
-  uint8* out = dst_frame + dst_stride * src_height * 3 - dst_stride * 3;
-  uint8* out2 = out - dst_stride * 3;
+  uint8* out = dst_frame + dst_stride * src_height - dst_stride;
+  uint8* out2 = out - dst_stride;
   int h, w;
-  int tmpR, tmpG, tmpB;
+  int tmp_r, tmp_g, tmp_b;
   const uint8 *y1, *y2 ,*u, *v;
   y1 = src_yplane;
   y2 = y1 + src_ystride;
@@ -55,33 +54,33 @@ I420ToRGB24(const uint8* src_yplane, int src_ystride,
     // 2 rows at a time, 2 y's at a time
     for (w = 0; w < ((src_width + 1) >> 1); w++){
       // Vertical and horizontal sub-sampling
-      tmpR = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
-      out[0] = Clip(tmpB);
-      out[1] = Clip(tmpG);
-      out[2] = Clip(tmpR);
+      tmp_r = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+      out[0] = Clip(tmp_b);
+      out[1] = Clip(tmp_g);
+      out[2] = Clip(tmp_r);
 
-      tmpR = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
-      out[3] = Clip(tmpB);
-      out[4] = Clip(tmpG);
-      out[5] = Clip(tmpR);
+      tmp_r = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+      out[3] = Clip(tmp_b);
+      out[4] = Clip(tmp_g);
+      out[5] = Clip(tmp_r);
 
-      tmpR = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
-      out2[0] = Clip(tmpB);
-      out2[1] = Clip(tmpG);
-      out2[2] = Clip(tmpR);
+      tmp_r = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+      out2[0] = Clip(tmp_b);
+      out2[1] = Clip(tmp_g);
+      out2[2] = Clip(tmp_r);
 
-      tmpR = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
-      out2[3] = Clip(tmpB);
-      out2[4] = Clip(tmpG);
-      out2[5] = Clip(tmpR);
+      tmp_r = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+      out2[3] = Clip(tmp_b);
+      out2[4] = Clip(tmp_g);
+      out2[5] = Clip(tmp_r);
 
       out += 6;
       out2 += 6;
@@ -94,28 +93,27 @@ I420ToRGB24(const uint8* src_yplane, int src_ystride,
     y2 += src_ystride + src_ystride - src_width;
     u += src_ustride - ((src_width + 1) >> 1);
     v += src_vstride - ((src_width + 1) >> 1);
-    out -= dst_stride * 9;
-    out2 -= dst_stride * 9;
+    out -= dst_stride * 3;
+    out2 -= dst_stride * 3;
   } // end height for
   return 0;
 }
 
 // Little Endian...
-int
-I420ToARGB4444(const uint8* src_yplane, int src_ystride,
-               const uint8* src_uplane, int src_ustride,
-               const uint8* src_vplane, int src_vstride,
-               uint8* dst_frame, int dst_stride,
-               int src_width, int src_height)
+int I420ToARGB4444(const uint8* src_yplane, int src_ystride,
+                   const uint8* src_uplane, int src_ustride,
+                   const uint8* src_vplane, int src_vstride,
+                   uint8* dst_frame, int dst_stride,
+                   int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
-      dst_frame == NULL){
+      dst_frame == NULL)
     return -1;
-  }
+
   // RGB orientation - bottom up
-  uint8* out = dst_frame + dst_stride * (src_height - 1) * 2;
-  uint8* out2 = out - (2 * dst_stride);
-  int tmpR, tmpG, tmpB;
+  uint8* out = dst_frame + dst_stride * (src_height - 1);
+  uint8* out2 = out - dst_stride;
+  int tmp_r, tmp_g, tmp_b;
   const uint8 *y1,*y2, *u, *v;
   y1 = src_yplane;
   y2 = y1 + src_ystride;
@@ -128,29 +126,29 @@ I420ToARGB4444(const uint8* src_yplane, int src_ystride,
     for (w = 0; w < ((src_width + 1) >> 1); w++){
         // Vertical and horizontal sub-sampling
         // Convert to RGB888 and re-scale to 4 bits
-        tmpR = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
-        tmpG = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-        tmpB = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
-        out[0] =(uint8)((Clip(tmpG) & 0xf0) + (Clip(tmpB) >> 4));
-        out[1] = (uint8)(0xf0 + (Clip(tmpR) >> 4));
+        tmp_r = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+        tmp_g = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+        tmp_b = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+        out[0] =(uint8)((Clip(tmp_g) & 0xf0) + (Clip(tmp_b) >> 4));
+        out[1] = (uint8)(0xf0 + (Clip(tmp_r) >> 4));
 
-        tmpR = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
-        tmpG = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-        tmpB = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
-        out[2] = (uint8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
-        out[3] = (uint8)(0xf0 + (Clip(tmpR) >> 4));
+        tmp_r = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+        tmp_g = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+        tmp_b = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+        out[2] = (uint8)((Clip(tmp_g) & 0xf0 ) + (Clip(tmp_b) >> 4));
+        out[3] = (uint8)(0xf0 + (Clip(tmp_r) >> 4));
 
-        tmpR = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
-        tmpG = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-        tmpB = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
-        out2[0] = (uint8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
-        out2[1] = (uint8) (0xf0 + (Clip(tmpR) >> 4));
+        tmp_r = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+        tmp_g = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+        tmp_b = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+        out2[0] = (uint8)((Clip(tmp_g) & 0xf0 ) + (Clip(tmp_b) >> 4));
+        out2[1] = (uint8) (0xf0 + (Clip(tmp_r) >> 4));
 
-        tmpR = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
-        tmpG = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-        tmpB = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
-        out2[2] = (uint8)((Clip(tmpG) & 0xf0 ) + (Clip(tmpB) >> 4));
-        out2[3] = (uint8)(0xf0 + (Clip(tmpR) >> 4));
+        tmp_r = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+        tmp_g = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+        tmp_b = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+        out2[2] = (uint8)((Clip(tmp_g) & 0xf0 ) + (Clip(tmp_b) >> 4));
+        out2[3] = (uint8)(0xf0 + (Clip(tmp_r) >> 4));
 
         out += 4;
         out2 += 4;
@@ -163,24 +161,22 @@ I420ToARGB4444(const uint8* src_yplane, int src_ystride,
     y2 += 2 * src_ystride - src_width;
     u += src_ustride - ((src_width + 1) >> 1);
     v += src_vstride - ((src_width + 1) >> 1);
-    out -= (2 * dst_stride + src_width) * 2;
-    out2 -= (2 * dst_stride + src_width) * 2;
+    out -= (dst_stride + src_width) * 2;
+    out2 -= (dst_stride + src_width) * 2;
   } // end height for
   return 0;
 }
 
 
-int
-I420ToRGB565(const uint8* src_yplane, int src_ystride,
-             const uint8* src_uplane, int src_ustride,
-             const uint8* src_vplane, int src_vstride,
-             uint8* dst_frame, int dst_stride,
-             int src_width, int src_height)
+int I420ToRGB565(const uint8* src_yplane, int src_ystride,
+                 const uint8* src_uplane, int src_ustride,
+                 const uint8* src_vplane, int src_vstride,
+                 uint8* dst_frame, int dst_stride,
+                 int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
-      dst_frame == NULL){
+      dst_frame == NULL)
     return -1;
-  }
 
   // Negative height means invert the image.
   if (src_height < 0) {
@@ -195,7 +191,7 @@ I420ToRGB565(const uint8* src_yplane, int src_ystride,
   uint16* out = (uint16*)(dst_frame) + dst_stride * (src_height - 1);
   uint16* out2 = out - dst_stride;
 
-  int tmpR, tmpG, tmpB;
+  int tmp_r, tmp_g, tmp_b;
   const uint8 *y1,*y2, *u, *v;
   y1 = src_yplane;
   y2 = y1 + src_ystride;
@@ -210,29 +206,29 @@ I420ToRGB565(const uint8* src_yplane, int src_ystride,
       // 1. Convert to RGB888
       // 2. Shift to adequate location (in the 16 bit word) - RGB 565
 
-      tmpR = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
-      out[0]  = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_r = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+      out[0]  = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
-      tmpR = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
-      out[1] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                         & 0xfc) << 3) + (Clip(tmpB ) >> 3);
+      tmp_r = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+      out[1] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                         & 0xfc) << 3) + (Clip(tmp_b ) >> 3);
 
-      tmpR = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
-      out2[0] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_r = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+      out2[0] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
-      tmpR = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
-      out2[1] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_r = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+      out2[1] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
       y1 += 2;
       y2 += 2;
@@ -247,17 +243,16 @@ I420ToRGB565(const uint8* src_yplane, int src_ystride,
     v += src_vstride - ((src_width + 1) >> 1);
     out -= 2 * dst_stride + src_width;
     out2 -=  2 * dst_stride + src_width;
-  } // end height for
+  }
   return 0;
 }
 
 
-int
-I420ToARGB1555(const uint8* src_yplane, int src_ystride,
-               const uint8* src_uplane, int src_ustride,
-               const uint8* src_vplane, int src_vstride,
-               uint8* dst_frame, int dst_stride,
-               int src_width, int src_height)
+int I420ToARGB1555(const uint8* src_yplane, int src_ystride,
+                   const uint8* src_uplane, int src_ustride,
+                   const uint8* src_vplane, int src_vstride,
+                   uint8* dst_frame, int dst_stride,
+                   int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
       dst_frame == NULL){
@@ -265,7 +260,7 @@ I420ToARGB1555(const uint8* src_yplane, int src_ystride,
   }
   uint16* out = (uint16*)(dst_frame) + dst_stride * (src_height - 1);
   uint16* out2 = out - dst_stride ;
-  int32 tmpR, tmpG, tmpB;
+  int32 tmp_r, tmp_g, tmp_b;
   const uint8 *y1,*y2, *u, *v;
   int h, w;
 
@@ -281,29 +276,29 @@ I420ToARGB1555(const uint8* src_yplane, int src_ystride,
       // 1. Convert to RGB888
       // 2. Shift to adequate location (in the 16 bit word) - RGB 555
       // 3. Add 1 for alpha value
-      tmpR = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
-      out[0]  = (uint16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) +
-                ((Clip(tmpG) & 0xf8) << 3) + (Clip(tmpB) >> 3));
+      tmp_r = (int32)((mapYc[y1[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[0]] + mapUcb[u[0]] + 128) >> 8);
+      out[0]  = (uint16)(0x8000 + ((Clip(tmp_r) & 0xf8) << 10) +
+                ((Clip(tmp_g) & 0xf8) << 3) + (Clip(tmp_b) >> 3));
 
-      tmpR = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]]  + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
-      out[1]  = (uint16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) +
-                ((Clip(tmpG) & 0xf8) << 3)  + (Clip(tmpB) >> 3));
+      tmp_r = (int32)((mapYc[y1[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[1]] + mapUcg[u[0]] + mapVcg[v[0]]  + 128) >> 8);
+      tmp_b = (int32)((mapYc[y1[1]] + mapUcb[u[0]] + 128) >> 8);
+      out[1]  = (uint16)(0x8000 + ((Clip(tmp_r) & 0xf8) << 10) +
+                ((Clip(tmp_g) & 0xf8) << 3)  + (Clip(tmp_b) >> 3));
 
-      tmpR = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
-      out2[0]  = (uint16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) +
-                 ((Clip(tmpG) & 0xf8) << 3) + (Clip(tmpB) >> 3));
+      tmp_r = (int32)((mapYc[y2[0]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[0]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[0]] + mapUcb[u[0]] + 128) >> 8);
+      out2[0]  = (uint16)(0x8000 + ((Clip(tmp_r) & 0xf8) << 10) +
+                 ((Clip(tmp_g) & 0xf8) << 3) + (Clip(tmp_b) >> 3));
 
-      tmpR = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
-      out2[1]  = (uint16)(0x8000 + ((Clip(tmpR) & 0xf8) << 10) +
-                 ((Clip(tmpG) & 0xf8) << 3)  + (Clip(tmpB) >> 3));
+      tmp_r = (int32)((mapYc[y2[1]] + mapVcr[v[0]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[1]] + mapUcg[u[0]] + mapVcg[v[0]] + 128) >> 8);
+      tmp_b = (int32)((mapYc[y2[1]] + mapUcb[u[0]] + 128) >> 8);
+      out2[1]  = (uint16)(0x8000 + ((Clip(tmp_r) & 0xf8) << 10) +
+                 ((Clip(tmp_g) & 0xf8) << 3)  + (Clip(tmp_b) >> 3));
 
       y1 += 2;
       y2 += 2;
@@ -318,17 +313,16 @@ I420ToARGB1555(const uint8* src_yplane, int src_ystride,
     v += src_vstride - ((src_width + 1) >> 1);
     out -= 2 * dst_stride + src_width;
     out2 -=  2 * dst_stride + src_width;
-  } // end height for
+  }
   return 0;
 }
 
 
-int
-I420ToYUY2(const uint8* src_yplane, int src_ystride,
-           const uint8* src_uplane, int src_ustride,
-           const uint8* src_vplane, int src_vstride,
-           uint8* dst_frame, int dst_stride,
-           int src_width, int src_height)
+int I420ToYUY2(const uint8* src_yplane, int src_ystride,
+               const uint8* src_uplane, int src_ustride,
+               const uint8* src_vplane, int src_vstride,
+               uint8* dst_frame, int dst_stride,
+               int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
       dst_frame == NULL){
@@ -341,7 +335,7 @@ I420ToYUY2(const uint8* src_yplane, int src_ystride,
   const uint8* src_v = src_vplane;
 
   uint8* out1 = dst_frame;
-  uint8* out2 = dst_frame + 2 * dst_stride;
+  uint8* out2 = dst_frame + dst_stride;
 
   // YUY2 - Macro-pixel = 2 image pixels
   // Y0U0Y1V0....Y2U2Y3V2...Y4U4Y5V4....
@@ -368,8 +362,8 @@ I420ToYUY2(const uint8* src_yplane, int src_ystride,
     in2 += 2 * src_ystride - src_width;
     src_u += src_ustride - ((src_width + 1) >> 1);
     src_v += src_vstride - ((src_width + 1) >> 1);
-    out1 += 2 * dst_stride + 2 * (dst_stride - src_width);
-    out2 += 2 * dst_stride + 2 * (dst_stride - src_width);
+    out1 += dst_stride + dst_stride - 2 * src_width;
+    out2 += dst_stride + dst_stride - 2 * src_width;
   }
 #else
   for (WebRtc_UWord32 i = 0; i < ((height + 1) >> 1);i++)
@@ -432,24 +426,23 @@ I420ToYUY2(const uint8* src_yplane, int src_ystride,
     }
     in1 += 2 * src_ystride - src_width;
     in2 += 2 * src_ystride - src_width;
-    out1 += 2 * strideOut + 2 * (strideOut - width);
-    out2 += 2 * strideOut + 2 * (strideOut - width);
+    out1 += dst_stride + dst_stride - 2 * width;
+    out2 += dst_stride + dst_stride - 2 * width;
   }
 #endif
   return 0;
 }
 
-int
-I420ToUYVY(const uint8* src_yplane, int src_ystride,
-           const uint8* src_uplane, int src_ustride,
-           const uint8* src_vplane, int src_vstride,
-           uint8* dst_frame, int dst_stride,
-           int src_width, int src_height)
+int I420ToUYVY(const uint8* src_yplane, int src_ystride,
+               const uint8* src_uplane, int src_ustride,
+               const uint8* src_vplane, int src_vstride,
+               uint8* dst_frame, int dst_stride,
+               int src_width, int src_height)
 {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
-      dst_frame == NULL){
+      dst_frame == NULL)
     return -1;
-  }
+
   int i = 0;
   const uint8* y1 = src_yplane;
   const uint8* y2 = y1 + src_ystride;
@@ -457,7 +450,7 @@ I420ToUYVY(const uint8* src_yplane, int src_ystride,
   const uint8* v = src_vplane;
 
   uint8* out1 = dst_frame;
-  uint8* out2 = dst_frame + 2 * dst_stride;
+  uint8* out2 = dst_frame + dst_stride;
 
   // Macro-pixel = 2 image pixels
   // U0Y0V0Y1....U2Y2V2Y3...U4Y4V4Y5.....
@@ -485,8 +478,8 @@ I420ToUYVY(const uint8* src_yplane, int src_ystride,
     y2 += 2 * src_ystride - src_width;
     u += src_ustride - ((src_width + 1) >> 1);
     v += src_vstride - ((src_width + 1) >> 1);
-    out1 += 2 * (dst_stride + (dst_stride - src_width));
-    out2 += 2 * (dst_stride + (dst_stride - src_width));
+    out1 += 2 * (dst_stride - src_width);
+    out2 += 2 * (dst_stride - src_width);
   }
 #else
   for (; i < (height >> 1);i++)
@@ -547,29 +540,27 @@ loop0:
     }
     in1 += width;
     in2 += width;
-    out1 += 2 * (strideOut + (strideOut - width));
-    out2 += 2 * (strideOut + (strideOut - width));
+    out1 += 2 * (dst_stride - width);
+    out2 += 2 * (dst_stride - width);
   }
 #endif
   return 0;
 }
 
 
-int
-NV12ToRGB565(const uint8* src_yplane, int src_ystride,
-             const  uint8* src_uvplane, int src_uvstride,
-             uint8* dst_frame, int dst_stride,
-             int src_width, int src_height)
+int NV12ToRGB565(const uint8* src_yplane, int src_ystride,
+                 const  uint8* src_uvplane, int src_uvstride,
+                 uint8* dst_frame, int dst_stride,
+                 int src_width, int src_height)
 {
-  if (src_yplane == NULL || src_uvplane == NULL || dst_frame == NULL){
+  if (src_yplane == NULL || src_uvplane == NULL || dst_frame == NULL)
      return -1;
-  }
 
   // Bi-Planar: Y plane followed by an interlaced U and V plane
   const uint8* interlacedSrc = src_uvplane;
   uint16* out = (uint16*)(src_yplane) + dst_stride * (src_height - 1);
   uint16* out2 = out - dst_stride;
-  int32 tmpR, tmpG, tmpB;
+  int32 tmp_r, tmp_g, tmp_b;
   const uint8 *y1,*y2;
   y1 = src_yplane;
   y2 = y1 + src_ystride;
@@ -582,34 +573,34 @@ NV12ToRGB565(const uint8* src_yplane, int src_ystride,
       // 1. Convert to RGB888
       // 2. Shift to adequate location (in the 16 bit word) - RGB 565
 
-      tmpR = (int32)((mapYc[y1[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[0]] + mapUcg[interlacedSrc[0]]
+      tmp_r = (int32)((mapYc[y1[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[0]] + mapUcg[interlacedSrc[0]]
                       + mapVcg[interlacedSrc[1]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
-      out[0]  = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_b = (int32)((mapYc[y1[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+      out[0]  = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
-      tmpR = (int32)((mapYc[y1[1]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y1[1]] + mapUcg[interlacedSrc[0]]
+      tmp_r = (int32)((mapYc[y1[1]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y1[1]] + mapUcg[interlacedSrc[0]]
                       + mapVcg[interlacedSrc[1]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y1[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
-      out[1] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                         & 0xfc) << 3) + (Clip(tmpB ) >> 3);
+      tmp_b = (int32)((mapYc[y1[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+      out[1] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                         & 0xfc) << 3) + (Clip(tmp_b ) >> 3);
 
-      tmpR = (int32)((mapYc[y2[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[0]] + mapUcg[interlacedSrc[0]]
+      tmp_r = (int32)((mapYc[y2[0]] + mapVcr[interlacedSrc[1]] + 128) >> 8);
+      tmp_g = (int32)((mapYc[y2[0]] + mapUcg[interlacedSrc[0]]
                       + mapVcg[interlacedSrc[1]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
-      out2[0] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_b = (int32)((mapYc[y2[0]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+      out2[0] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
-      tmpR = (int32)((mapYc[y2[1]] + mapVcr[interlacedSrc[1]]
+      tmp_r = (int32)((mapYc[y2[1]] + mapVcr[interlacedSrc[1]]
                       + 128) >> 8);
-      tmpG = (int32)((mapYc[y2[1]] + mapUcg[interlacedSrc[0]]
+      tmp_g = (int32)((mapYc[y2[1]] + mapUcg[interlacedSrc[0]]
                       + mapVcg[interlacedSrc[1]] + 128) >> 8);
-      tmpB = (int32)((mapYc[y2[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
-      out2[1] = (uint16)((Clip(tmpR) & 0xf8) << 8) + ((Clip(tmpG)
-                          & 0xfc) << 3) + (Clip(tmpB) >> 3);
+      tmp_b = (int32)((mapYc[y2[1]] + mapUcb[interlacedSrc[0]] + 128) >> 8);
+      out2[1] = (uint16)((Clip(tmp_r) & 0xf8) << 8) + ((Clip(tmp_g)
+                          & 0xfc) << 3) + (Clip(tmp_b) >> 3);
 
       y1 += 2;
       y2 += 2;
@@ -622,28 +613,24 @@ NV12ToRGB565(const uint8* src_yplane, int src_ystride,
     interlacedSrc += src_uvstride - ((src_width + 1) >> 1);
     out -= 3 * dst_stride + dst_stride - src_width;
     out2 -= 3 * dst_stride + dst_stride - src_width;
-  } // end height for
+  }
   return 0;
 }
 
-int
-RGB24ToARGB(const uint8* src_frame, int src_stride,
-            uint8* dst_frame, int dst_stride,
-            int src_width, int src_height)
+int RGB24ToARGB(const uint8* src_frame, int src_stride,
+                uint8* dst_frame, int dst_stride,
+                int src_width, int src_height)
 {
-  if (src_frame == NULL || dst_frame == NULL){
+  if (src_frame == NULL || dst_frame == NULL)
     return -1;
-  }
 
   int i, j, offset;
   uint8* outFrame = dst_frame;
   const uint8* inFrame = src_frame;
 
   outFrame += dst_stride * (src_height - 1) * 4;
-  for (i = 0; i < src_height; i++)
-  {
-    for (j = 0; j < src_width; j++)
-    {
+  for (i = 0; i < src_height; i++){
+    for (j = 0; j < src_width; j++){
       offset = j * 4;
       outFrame[0 + offset] = inFrame[0];
       outFrame[1 + offset] = inFrame[1];
@@ -749,9 +736,9 @@ static int RGBToI420(const uint8* src_frame, int src_stride,
                                           uint8* dst_vplane,
                                           int src_width)) {
   if (src_frame == NULL || dst_yplane == NULL ||
-      dst_vplane == NULL || dst_vplane == NULL) {
+      dst_vplane == NULL || dst_vplane == NULL)
     return -1;
-  }
+
   if (src_height < 0) {
     src_height = -src_height;
     src_frame = src_frame + src_stride * (src_height -1);
@@ -776,12 +763,11 @@ static int RGBToI420(const uint8* src_frame, int src_stride,
   return 0;
 }
 
-int
-ARGBToI420(const uint8* src_frame, int src_stride,
-           uint8* dst_yplane, int dst_ystride,
-           uint8* dst_uplane, int dst_ustride,
-           uint8* dst_vplane, int dst_vstride,
-           int src_width, int src_height) {
+int ARGBToI420(const uint8* src_frame, int src_stride,
+               uint8* dst_yplane, int dst_ystride,
+               uint8* dst_uplane, int dst_ustride,
+               uint8* dst_vplane, int dst_vstride,
+               int src_width, int src_height) {
   return RGBToI420(src_frame, src_stride,
                    dst_yplane, dst_ystride,
                    dst_uplane, dst_ustride,
@@ -789,12 +775,11 @@ ARGBToI420(const uint8* src_frame, int src_stride,
                    src_width, src_height, ARGBToI420Row_C);
 }
 
-int
-BGRAToI420(const uint8* src_frame, int src_stride,
-           uint8* dst_yplane, int dst_ystride,
-           uint8* dst_uplane, int dst_ustride,
-           uint8* dst_vplane, int dst_vstride,
-           int src_width, int src_height) {
+int BGRAToI420(const uint8* src_frame, int src_stride,
+               uint8* dst_yplane, int dst_ystride,
+               uint8* dst_uplane, int dst_ustride,
+               uint8* dst_vplane, int dst_vstride,
+               int src_width, int src_height) {
   return RGBToI420(src_frame, src_stride,
                    dst_yplane, dst_ystride,
                    dst_uplane, dst_ustride,
@@ -802,12 +787,11 @@ BGRAToI420(const uint8* src_frame, int src_stride,
                    src_width, src_height, BGRAToI420Row_C);
 }
 
-int
-ABGRToI420(const uint8* src_frame, int src_stride,
-           uint8* dst_yplane, int dst_ystride,
-           uint8* dst_uplane, int dst_ustride,
-           uint8* dst_vplane, int dst_vstride,
-           int src_width, int src_height) {
+int ABGRToI420(const uint8* src_frame, int src_stride,
+               uint8* dst_yplane, int dst_ystride,
+               uint8* dst_uplane, int dst_ustride,
+               uint8* dst_vplane, int dst_vstride,
+               int src_width, int src_height) {
   return RGBToI420(src_frame, src_stride,
                    dst_yplane, dst_ystride,
                    dst_uplane, dst_ustride,
@@ -815,12 +799,11 @@ ABGRToI420(const uint8* src_frame, int src_stride,
                    src_width, src_height, ABGRToI420Row_C);
 }
 
-int
-RGB24ToI420(const uint8* src_frame, int src_stride,
-            uint8* dst_yplane, int dst_ystride,
-            uint8* dst_uplane, int dst_ustride,
-            uint8* dst_vplane, int dst_vstride,
-            int src_width, int src_height) {
+int RGB24ToI420(const uint8* src_frame, int src_stride,
+                uint8* dst_yplane, int dst_ystride,
+                uint8* dst_uplane, int dst_ustride,
+                uint8* dst_vplane, int dst_vstride,
+                int src_width, int src_height) {
   return RGBToI420(src_frame, src_stride,
                    dst_yplane, dst_ystride,
                    dst_uplane, dst_ustride,
@@ -828,12 +811,11 @@ RGB24ToI420(const uint8* src_frame, int src_stride,
                    src_width, src_height, RGB24ToI420Row_C);
 }
 
-int
-RAWToI420(const uint8* src_frame, int src_stride,
-          uint8* dst_yplane, int dst_ystride,
-          uint8* dst_uplane, int dst_ustride,
-          uint8* dst_vplane, int dst_vstride,
-          int src_width, int src_height) {
+int RAWToI420(const uint8* src_frame, int src_stride,
+              uint8* dst_yplane, int dst_ystride,
+              uint8* dst_uplane, int dst_ustride,
+              uint8* dst_vplane, int dst_vstride,
+              int src_width, int src_height) {
   return RGBToI420(src_frame, src_stride,
                    dst_yplane, dst_ystride,
                    dst_uplane, dst_ustride,
diff --git a/source/general.cc b/source/general.cc
index 9d39f9bfb..162a0259a 100644
--- a/source/general.cc
+++ b/source/general.cc
@@ -16,70 +16,73 @@
 
 namespace libyuv {
 
-int
-I420Mirror(const uint8* src_yplane, int src_ystride,
-           const uint8* src_uplane, int src_ustride,
-           const uint8* src_vplane, int src_vstride,
-           uint8* dst_yplane, int dst_ystride,
-           uint8* dst_uplane, int dst_ustride,
-           uint8* dst_vplane, int dst_vstride,
-           int width, int height) {
+int I420Mirror(const uint8* src_yplane, int src_ystride,
+               const uint8* src_uplane, int src_ustride,
+               const uint8* src_vplane, int src_vstride,
+               uint8* dst_yplane, int dst_ystride,
+               uint8* dst_uplane, int dst_ustride,
+               uint8* dst_vplane, int dst_vstride,
+               int width, int height) {
   if (src_yplane == NULL || src_uplane == NULL || src_vplane == NULL ||
-      dst_yplane == NULL || dst_uplane == NULL || dst_vplane == NULL) {
+      dst_yplane == NULL || dst_uplane == NULL || dst_vplane == NULL)
+    return -1;
+
+  // Only accepts positive dimensions
+  if (height < 0 || width < 0 ||  dst_ystride < 0 || dst_ustride < 0 ||
+      dst_vstride < 0)
     return -1;
-  }
 
   int indO = 0;
   int indS  = 0;
   int wind, hind;
-  uint8 tmpVal, tmpValU, tmpValV;
+  uint8 tmp_val;
   // Will swap two values per iteration
-  const int halfWidth = (width + 1) >> 1;
+  const int half_width = (width + 1) >> 1;
 
   // Y
-  for (wind = 0; wind < halfWidth; wind++) {
-   for (hind = 0; hind < height; hind++) {
+  for (wind = 0; wind < half_width; ++wind) {
+   for (hind = 0; hind < height; ++hind) {
      indO = hind * src_ystride + wind;
      indS = hind * dst_ystride + (width - wind - 1);
-     tmpVal = src_yplane[indO];
+     tmp_val = src_yplane[indO];
      dst_yplane[indO] = src_yplane[indS];
-     dst_yplane[indS] = tmpVal;
+     dst_yplane[indS] = tmp_val;
     }
   }
 
-  const int halfHeight = (height + 1) >> 1;
-  const int halfSrcuvStride = (height + 1) >> 1;
-  const int halfuvWidth = (width + 1) >> 2;
+  const int half_height = (height + 1) >> 1;
+  const int half_uv_width = (width + 1) >> 1;
 
-  for (wind = 0; wind < halfuvWidth; wind++) {
-   for (hind = 0; hind < halfHeight; hind++) {
-     indO = hind * halfSrcuvStride + wind;
-     indS = hind * halfSrcuvStride + (halfuvWidth - wind - 1);
+  for (wind = 0; wind < half_uv_width; ++wind) {
+   for (hind = 0; hind < half_height; ++hind) {
      // U
-     tmpValU = src_uplane[indO];
+     indO = hind * dst_ustride + wind;
+     indS = hind * dst_ustride + (half_uv_width - wind - 1);
+     tmp_val = src_uplane[indO];
      dst_uplane[indO] = src_uplane[indS];
-     dst_uplane[indS] = tmpValU;
+     dst_uplane[indS] = tmp_val;
      // V
-     tmpValV = src_vplane[indO];
+     indO = hind * dst_vstride + wind;
+     indS = hind * dst_vstride + (half_uv_width - wind - 1);
+     tmp_val = src_vplane[indO];
      dst_vplane[indO] = src_vplane[indS];
-     dst_vplane[indS] = tmpValV;
+     dst_vplane[indS] = tmp_val;
    }
   }
   return 0;
 }
 
 // Make a center cut
-int
-I420Crop(uint8* frame,
-         int src_width, int src_height,
-         int dst_width, int dst_height)
+int I420Crop(uint8* frame,
+             int src_width, int src_height,
+             int dst_width, int dst_height)
 {
   if (frame == NULL)
     return -1;
 
   if (src_width == dst_width && src_height == dst_height) {
       // Nothing to do
-    return 3 * dst_height * dst_width / 2;
+    return 0;
   }
   if (dst_width > src_width || dst_height > src_height) {
       // error
@@ -118,10 +121,9 @@ I420Crop(uint8* frame,
 }
 
 
-int
-I420CropPad(const uint8* src_frame, int src_width,
-            int src_height, uint8* dst_frame,
-            int dst_width, int dst_height)
+int I420CropPad(const uint8* src_frame, int src_width,
+                int src_height, uint8* dst_frame,
+                int dst_width, int dst_height)
 {
   if (src_width < 1 || dst_width < 1 || src_height < 1 || dst_height < 1) {
     return -1;