Always round up coded size to avoid VideoFrame restrictions.

media/filters/ffmpeg_video_decoder.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/filters/ffmpeg_video_decoder.h"
 
 #include <algorithm>
 #include <string>
 
 #include "base/bind.h"
@@ skipping 48 matching lines @@
                               int flags) {
   FFmpegVideoDecoder* decoder = static_cast<FFmpegVideoDecoder*>(s->opaque);
   return decoder->GetVideoBuffer(s, frame, flags);
 }
 
 static void ReleaseVideoBufferImpl(void* opaque, uint8* data) {
   scoped_refptr<VideoFrame> video_frame;
   video_frame.swap(reinterpret_cast<VideoFrame**>(&opaque));
 }
 
+static size_t RoundUp(size_t value, size_t alignment) {
+  // Check that |alignment| is a power of 2.
+  DCHECK((alignment + (alignment - 1)) == (alignment | (alignment - 1)));
+  return ((value + (alignment - 1)) & ~(alignment - 1));
+}
+
 FFmpegVideoDecoder::FFmpegVideoDecoder(
     const scoped_refptr<base::SingleThreadTaskRunner>& task_runner)
     : task_runner_(task_runner), state_(kUninitialized) {}
 
 int FFmpegVideoDecoder::GetVideoBuffer(struct AVCodecContext* codec_context,
                                        AVFrame* frame,
                                        int flags) {
   // Don't use |codec_context_| here! With threaded decoding,
   // it will contain unsynchronized width/height/pix_fmt values,
   // whereas |codec_context| contains the current threads's
@@ skipping 18 matching lines @@
   } else {
     natural_size = config_.natural_size();
   }
 
   // FFmpeg has specific requirements on the allocation size of the frame.  The
   // following logic replicates FFmpeg's allocation strategy to ensure buffers
   // are not overread / overwritten.  See ff_init_buffer_info() for details.
   //
   // When lowres is non-zero, dimensions should be divided by 2^(lowres), but
   // since we don't use this, just DCHECK that it's zero.
+  //
+  // Always round up to a multiple of two to match VideoFrame restrictions on
+  // frame alignment.
   DCHECK_EQ(codec_context->lowres, 0);
-  gfx::Size coded_size(std::max(size.width(), codec_context->coded_width),
-                       std::max(size.height(), codec_context->coded_height));
+  gfx::Size coded_size(
+      RoundUp(std::max(size.width(), codec_context->coded_width), 2),
+      RoundUp(std::max(size.height(), codec_context->coded_height), 2));
 
   if (!VideoFrame::IsValidConfig(

[scherkus (not reviewing), 2014/06/06 21:25:50]

was this check failing with that test clip?

[DaleCurtis, 2014/06/06 21:33:06]

Yes.

           format, coded_size, gfx::Rect(size), natural_size))
     return AVERROR(EINVAL);
 
   scoped_refptr<VideoFrame> video_frame = frame_pool_.CreateFrame(
       format, coded_size, gfx::Rect(size), natural_size, kNoTimestamp());
 
   for (int i = 0; i < 3; i++) {
     frame->data[i] = video_frame->data(i);
     frame->linesize[i] = video_frame->stride(i);
   }
@@ skipping 242 matching lines @@
   if (!codec || avcodec_open2(codec_context_.get(), codec, NULL) < 0) {
     ReleaseFFmpegResources();
     return false;
   }
 
   av_frame_.reset(av_frame_alloc());
   return true;
 }
 
 }  // namespace media