Incorrect chroma on the right border fixed.

media/base/yuv_convert.cc

 // Copyright (c) 2010 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 // This webpage shows layout of YV12 and other YUV formats
 // http://www.fourcc.org/yuv.php
 // The actual conversion is best described here
 // http://en.wikipedia.org/wiki/YUV
 // An article on optimizing YUV conversion using tables instead of multiplies
 // http://lestourtereaux.free.fr/papers/data/yuvrgb.pdf
@@ skipping 116 matching lines @@
       ybuf += 4;
     } while (ybuf < end);
   }
 }
 
 #endif  // USE_SSE
 #else  // no MMX or SSE
 // C version blends 4 pixels at a time.
 static void FilterRows(uint8* ybuf, const uint8* y0_ptr, const uint8* y1_ptr,
                        int width, int scaled_y_fraction) {
-  int y0_fraction = 65536 - scaled_y_fraction;
+  int y0_fraction = kFractionMax - scaled_y_fraction;
   int y1_fraction = scaled_y_fraction;
   uint8* end = ybuf + width;
   if (ybuf < end) {
     do {
       ybuf[0] = (y0_ptr[0] * (y0_fraction) + y1_ptr[0] * (y1_fraction)) >> 16;
       ybuf[1] = (y0_ptr[1] * (y0_fraction) + y1_ptr[1] * (y1_fraction)) >> 16;
       ybuf[2] = (y0_ptr[2] * (y0_fraction) + y1_ptr[2] * (y1_fraction)) >> 16;
       ybuf[3] = (y0_ptr[3] * (y0_fraction) + y1_ptr[3] * (y1_fraction)) >> 16;
       y0_ptr += 4;
       y1_ptr += 4;
@@ skipping 84 matching lines @@
   }
 
   // Need padding because FilterRows() may write up to 15 extra pixels
   // after the end for SSE2 version.
   uint8 ybuf[kFilterBufferSize + 16];
   uint8 ubuf[kFilterBufferSize / 2 + 16];
   uint8 vbuf[kFilterBufferSize / 2 + 16];
   int yscale_fixed = (height << kFractionBits) / scaled_height;
   for (int y = 0; y < scaled_height; ++y) {
     uint8* dest_pixel = rgb_buf + y * rgb_pitch;
-    int scaled_y = (y * yscale_fixed);
+    int source_y_subpixel = (y * yscale_fixed);
+    int source_y = source_y_subpixel >> kFractionBits;

[fbarchard, 2010/04/14 06:21:42]

source... ya thats a better name

 
-    const uint8* y0_ptr = y_buf + (scaled_y >> kFractionBits) * y_pitch;
+    const uint8* y0_ptr = y_buf + source_y * y_pitch;
     const uint8* y1_ptr = y0_ptr + y_pitch;
 
-    const uint8* u0_ptr = u_buf +
-        ((scaled_y >> kFractionBits) >> y_shift) * uv_pitch;
+    const uint8* u0_ptr = u_buf + (source_y >> y_shift) * uv_pitch;
     const uint8* u1_ptr = u0_ptr + uv_pitch;
-    const uint8* v0_ptr = v_buf +
-        ((scaled_y >> kFractionBits) >> y_shift) * uv_pitch;
+    const uint8* v0_ptr = v_buf + (source_y >> y_shift) * uv_pitch;
     const uint8* v1_ptr = v0_ptr + uv_pitch;
 
-    int scaled_y_fraction = scaled_y & (kFractionMax - 1);
-    int scaled_uv_fraction = (scaled_y >> y_shift) & (kFractionMax - 1);
+    int scaled_y_fraction = source_y_subpixel & (kFractionMax - 1);
+    int scaled_uv_fraction = (source_y_subpixel >> y_shift) & (kFractionMax - 1);
 
     const uint8* y_ptr = y0_ptr;
     const uint8* u_ptr = u0_ptr;
     const uint8* v_ptr = v0_ptr;
     // Apply vertical filtering if necessary.
     // TODO(fbarchard): Remove memcpy when not necessary.
     if (filter == media::FILTER_BILINEAR) {
       if (yscale_fixed != kFractionMax &&
-          scaled_y_fraction && ((y + 1) < scaled_height)) {
+          scaled_y_fraction && ((source_y + 1) < height)) {
         FilterRows(ybuf, y0_ptr, y1_ptr, width, scaled_y_fraction);
       } else {
         memcpy(ybuf, y0_ptr, width);
       }
       y_ptr = ybuf;
       ybuf[width] = ybuf[width-1];
       int uv_width = (width + 1) / 2;
       if (yscale_fixed != kFractionMax &&
           scaled_uv_fraction &&
-          (((y >> y_shift) + 1) < (scaled_height >> y_shift))) {
+          (((source_y >> y_shift) + 1) < (height >> y_shift))) {

[fbarchard, 2010/04/14 06:21:42]

is this the error you referred to?

         FilterRows(ubuf, u0_ptr, u1_ptr, uv_width, scaled_uv_fraction);
         FilterRows(vbuf, v0_ptr, v1_ptr, uv_width, scaled_uv_fraction);
       } else {
         memcpy(ubuf, u0_ptr, uv_width);
         memcpy(vbuf, v0_ptr, uv_width);
       }
       u_ptr = ubuf;
       v_ptr = vbuf;
-      ubuf[(width + 1) / 2] = ybuf[(width + 1) / 2 -1];
-      vbuf[(width + 1) / 2] = vbuf[(width + 1) / 2 -1];
+      ubuf[uv_width] = ubuf[uv_width - 1];

[fbarchard, 2010/04/14 06:21:42]

good catch!  

+      vbuf[uv_width] = vbuf[uv_width - 1];
     }
     if (scaled_dx == kFractionMax) {  // Not scaled
       FastConvertYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
                                dest_pixel, scaled_width);
     } else {
       if (filter == FILTER_BILINEAR)
         LinearScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
                                  dest_pixel, scaled_width, scaled_dx);
       else
         ScaleYUVToRGB32Row(y_ptr, u_ptr, v_ptr,
                            dest_pixel, scaled_width, scaled_dx);
     }
   }
 
   // MMX used for FastConvertYUVToRGB32Row requires emms instruction.
   EMMS();
 }
 
 }  // namespace media