Allocate one extra line to allow for H264 chroma MC overreads.

media/base/video_frame.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.
 
 #include "media/base/video_frame.h"
 
 #include "base/logging.h"
 #include "base/string_piece.h"
 #include "media/base/limits.h"
 #include "media/base/video_util.h"
@@ skipping 117 matching lines @@
   // 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 y_stride = RoundUp(row_bytes(VideoFrame::kYPlane),
                             kFrameSizeAlignment);
   size_t uv_stride = RoundUp(row_bytes(VideoFrame::kUPlane),
                              kFrameSizeAlignment);
-  size_t y_height = RoundUp(height_, kFrameSizeAlignment);
+  // the *2 here is because some formats (e.g. h264) allow interlaced coding,
+  // and then the size needs to be a multiple of two macroblocks (vertically).
+  size_t y_height = RoundUp(height_, kFrameSizeAlignment * 2);

[DaleCurtis, 2012/07/11 20:11:05]

The code you reference below adds 2 to the height after alignment.  Is this what
you intended?

   size_t uv_height = format_ == VideoFrame::YV12 ? y_height / 2 : y_height;
   size_t y_bytes = y_height * y_stride;
   size_t uv_bytes = uv_height * uv_stride;
 
 #if !defined(OS_ANDROID)
   // TODO(dalecurtis): use DataAligned or so, so this #ifdef hackery
   // doesn't need to be repeated in every single user of aligned data.
+  // The extra line of UV being allocates is because h264 chroma MC
+  // overreads by one line in some cases, see libavcodec/utils.c:244 or
+  // libavcodec/x86/h264_chromamc.asm:637).
   uint8* data = reinterpret_cast<uint8*>(
-      av_malloc(y_bytes + (uv_bytes * 2) + kFramePadBytes));
+      av_malloc(y_bytes + (uv_bytes * 2 + uv_stride) + kFramePadBytes));
 #else
   uint8* data = new uint8_t[y_bytes + (uv_bytes * 2)];
 #endif
   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_stride;
   strides_[VideoFrame::kUPlane] = uv_stride;
   strides_[VideoFrame::kVPlane] = uv_stride;
@@ skipping 129 matching lines @@
       break;
     for(int row = 0; row < rows(plane); row++) {
       base::MD5Update(context, base::StringPiece(
           reinterpret_cast<char*>(data(plane) + stride(plane) * row),
           row_bytes(plane)));
     }
   }
 }
 
 }  // namespace media