pad yuv additional 15 bytes to allow 16 pixels at a time to be processed with...

media/base/video_frame.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.
 
 #include "media/base/video_frame.h"
 
 namespace media {
 
 // static
 void VideoFrame::CreateFrame(VideoFrame::Format format,
@@ skipping 112 matching lines @@
   size_t bytes_per_row = RoundUp(width_ * bytes_per_pixel, 8);
   planes_ = VideoFrame::kNumRGBPlanes;
   strides_[VideoFrame::kRGBPlane] = bytes_per_row;
   data_[VideoFrame::kRGBPlane] = new uint8[bytes_per_row * height_];
   DCHECK(data_[VideoFrame::kRGBPlane]);
   DCHECK(!(reinterpret_cast<intptr_t>(data_[VideoFrame::kRGBPlane]) & 7));
   COMPILE_ASSERT(0 == VideoFrame::kRGBPlane, RGB_data_must_be_index_0);
   return (NULL != data_[VideoFrame::kRGBPlane]);
 }
 
+static const int kFramePadBytes = 15;  // allows faster SIMD YUV convert
+
 bool VideoFrame::AllocateYUV() {
   DCHECK(format_ == VideoFrame::YV12 ||
          format_ == VideoFrame::YV16);
   // Align Y rows at 32-bit (4 byte) boundaries.  The stride for both YV12 and
   // YV16 is 1/2 of the stride of Y.  For YV12, every row of bytes for U and V
   // applies to two rows of Y (one byte of UV for 4 bytes of Y), so in the
   // case of YV12 the strides are identical for the same width surface, but the
   // number of bytes allocated for YV12 is 1/2 the amount for U & V as YV16.
   // We also round the height of the surface allocated to be an even number
   // to avoid any potential of faulting by code that attempts to access the Y
   // values of the final row, but assumes that the last row of U & V applies to
   // a full two rows of Y.
   size_t alloc_height = RoundUp(height_, 2);
   size_t y_bytes_per_row = RoundUp(width_, 4);
   size_t uv_stride = RoundUp(y_bytes_per_row / 2, 4);
   size_t y_bytes = alloc_height * y_bytes_per_row;
   size_t uv_bytes = alloc_height * uv_stride;
   if (format_ == VideoFrame::YV12) {
     uv_bytes /= 2;
   }
-  uint8* data = new uint8[y_bytes + (uv_bytes * 2)];
+  uint8* data = new uint8[y_bytes + (uv_bytes * 2) + kFramePadBytes];
   if (data) {
     planes_ = VideoFrame::kNumYUVPlanes;
     COMPILE_ASSERT(0 == VideoFrame::kYPlane, y_plane_data_must_be_index_0);
     data_[VideoFrame::kYPlane] = data;
     data_[VideoFrame::kUPlane] = data + y_bytes;
     data_[VideoFrame::kVPlane] = data + y_bytes + uv_bytes;
     strides_[VideoFrame::kYPlane] = y_bytes_per_row;
     strides_[VideoFrame::kUPlane] = uv_stride;
     strides_[VideoFrame::kVPlane] = uv_stride;
     return true;
@@ skipping 21 matching lines @@
   // on the heap, and other |data| pointers point inside the same, single block
   // so just delete index 0.
   delete[] data_[0];
 }
 
 bool VideoFrame::IsEndOfStream() const {
   return format_ == VideoFrame::EMPTY;
 }
 
 }  // namespace media