Fix type truncation warnings in YUV-related code.

media/base/yuv_convert.cc

 // Copyright (c) 2012 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 22 matching lines @@
 #else
 #include <mmintrin.h>
 #endif
 #endif
 
 // Assembly functions are declared without namespace.
 extern "C" { void EmptyRegisterState_MMX(); }  // extern "C"
 
 namespace media {
 
-typedef void (*FilterYUVRowsProc)(uint8*, const uint8*, const uint8*, int, int);
+typedef void (*FilterYUVRowsProc)(uint8*,
+                                  const uint8*,
+                                  const uint8*,
+                                  int,
+                                  uint8);
 
 typedef void (*ConvertRGBToYUVProc)(const uint8*,
                                     uint8*,
                                     uint8*,
                                     uint8*,
                                     int,
                                     int,
                                     int,
                                     int,
                                     int);
@@ skipping 270 matching lines @@
     const uint8* v_ptr = NULL;
     // Apply vertical filtering if necessary.
     // TODO(fbarchard): Remove memcpy when not necessary.
     if (filter & media::FILTER_BILINEAR_V) {
       int source_y = source_y_subpixel >> kFractionBits;
       y_ptr = y_buf + source_y * y_pitch;
       u_ptr = u_buf + (source_y >> y_shift) * uv_pitch;
       v_ptr = v_buf + (source_y >> y_shift) * uv_pitch;
 
       // Vertical scaler uses 16.8 fixed point.
-      int source_y_fraction = (source_y_subpixel & kFractionMask) >> 8;
+      uint8 source_y_fraction = (source_y_subpixel & kFractionMask) >> 8;
       if (source_y_fraction != 0) {
         g_filter_yuv_rows_proc_(
             ybuf, y_ptr, y_ptr + y_pitch, source_width, source_y_fraction);
       } else {
         memcpy(ybuf, y_ptr, source_width);
       }
       y_ptr = ybuf;
       ybuf[source_width] = ybuf[source_width - 1];
 
       int uv_source_width = (source_width + 1) / 2;
-      int source_uv_fraction;
+      uint8 source_uv_fraction;
 
       // For formats with half-height UV planes, each even-numbered pixel row
       // should not interpolate, since the next row to interpolate from should
       // be a duplicate of the current row.
       if (y_shift && (source_y & 0x1) == 0)
         source_uv_fraction = 0;
       else
         source_uv_fraction = source_y_fraction;
 
       if (source_uv_fraction != 0) {
@@ skipping 107 matching lines @@
   int source_y_width = source_y_right - source_y_left;
   int source_uv_width = source_uv_right - source_uv_left;
 
   // Determine number of pixels in each output row.
   int dest_rect_width = dest_rect_right - dest_rect_left;
 
   // Intermediate buffer for vertical interpolation.
   // 4096 bytes allows 3 buffers to fit in 12k, which fits in a 16K L1 cache,
   // and is bigger than most users will generally need.
   // The buffer is 16-byte aligned and padded with 16 extra bytes; some of the
-  // FilterYUVRowProcs have alignment requirements, and the SSE version can
+  // FilterYUVRowsProcs have alignment requirements, and the SSE version can
   // write up to 16 bytes past the end of the buffer.
   const int kFilterBufferSize = 4096;
   const bool kAvoidUsingOptimizedFilter = source_width > kFilterBufferSize;
   uint8 yuv_temp[16 + kFilterBufferSize * 3 + 16];
   // memset() yuv_temp to 0 to avoid bogus warnings when running on Valgrind.
   if (RunningOnValgrind())
     memset(yuv_temp, 0, sizeof(yuv_temp));
   uint8* y_temp = reinterpret_cast<uint8*>(
       reinterpret_cast<uintptr_t>(yuv_temp + 15) & ~15);
   uint8* u_temp = y_temp + kFilterBufferSize;
@@ skipping 28 matching lines @@
     if (source_uv_row + 1 >= (source_height + 1) / 2) {
       u1_ptr = u0_ptr;
       v1_ptr = v0_ptr;
     } else {
       u1_ptr = u0_ptr + uv_pitch;
       v1_ptr = v0_ptr + uv_pitch;
     }
 
     if (!kAvoidUsingOptimizedFilter) {
       // Vertical scaler uses 16.8 fixed point.
-      int fraction = (source_top & kFractionMask) >> 8;
+      uint8 fraction = (source_top & kFractionMask) >> 8;
       g_filter_yuv_rows_proc_(
           y_temp + source_y_left, y0_ptr, y1_ptr, source_y_width, fraction);
       g_filter_yuv_rows_proc_(
           u_temp + source_uv_left, u0_ptr, u1_ptr, source_uv_width, fraction);
       g_filter_yuv_rows_proc_(
           v_temp + source_uv_left, v0_ptr, v1_ptr, source_uv_width, fraction);
 
       // Perform horizontal interpolation and color space conversion.
       // TODO(hclam): Use the MMX version after more testing.
       LinearScaleYUVToRGB32RowWithRange_C(y_temp,
@@ skipping 149 matching lines @@
                                width,
                                height,
                                ystride,
                                uvstride,
                                astride,
                                rgbstride,
                                yuv_type);
 }
 
 }  // namespace media