Add support for color formats negotiation.

content/common/gpu/media/android_video_encode_accelerator.cc

 // Copyright 2013 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 "content/common/gpu/media/android_video_encode_accelerator.h"
 
+#include <algorithm>
+#include <vector>
+
 #include "base/bind.h"
 #include "base/command_line.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
 #include "content/common/gpu/gpu_channel.h"
 #include "content/public/common/content_switches.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "media/base/android/media_codec_bridge.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
 #include "media/video/picture.h"
 #include "third_party/libyuv/include/libyuv/convert_from.h"
 #include "ui/gl/android/scoped_java_surface.h"
 #include "ui/gl/gl_bindings.h"
 
 using media::MediaCodecBridge;
 using media::VideoCodecBridge;
 using media::VideoFrame;
 
 namespace content {
 
-enum {
+enum PixelFormat {
   // Subset of MediaCodecInfo.CodecCapabilities.
+  COLOR_FORMAT_YUV420_PLANAR = 19,
   COLOR_FORMAT_YUV420_SEMIPLANAR = 21,
 };
 
 // Helper macros for dealing with failure.  If |result| evaluates false, emit
 // |log| to DLOG(ERROR), register |error| with the client, and return.
 #define RETURN_ON_FAILURE(result, log, error)                  \
   do {                                                         \
     if (!(result)) {                                           \
       DLOG(ERROR) << log;                                      \
       if (client_ptr_factory_->GetWeakPtr()) {                 \
@@ skipping 19 matching lines @@
   // pictures have been fed to saturate any internal buffering).  This is
   // speculative and it's unclear that this would be a win (nor that there's a
   // reasonably device-agnostic way to fill in the "believes" above).
   return base::TimeDelta::FromMilliseconds(10);
 }
 
 static inline const base::TimeDelta NoWaitTimeOut() {
   return base::TimeDelta::FromMicroseconds(0);
 }
 
+static PixelFormat GetSupportedColorFormatForMime(const std::string& mime) {
+  std::vector<int> formats = MediaCodecBridge::GetEncoderColorFormats(mime);
+  if (std::find(formats.begin(), formats.end(), COLOR_FORMAT_YUV420_PLANAR) !=
+      formats.end())

[xhwang, 2014/10/13 17:37:35]

nit: Seems like GetEncoderColorFormats() should return a "set" instead of a
"vector". You can do it easily in GetEncoderColorFormats() by 

return std::set(formats.begin(), formats.end());

Then the find() here would be super simple.

[changbin, 2014/10/15 02:17:10]

Done.

+    return COLOR_FORMAT_YUV420_PLANAR;
+  return COLOR_FORMAT_YUV420_SEMIPLANAR;

[xhwang, 2014/10/13 17:37:35]

Is COLOR_FORMAT_YUV420_SEMIPLANAR always supported? If so, is it part of
|formats| here? If so, check it?

[changbin, 2014/10/15 02:17:10]

Thanks for pointing this out:) I think COLOR_FORMAT_YUV420_SEMIPLANAR isn't
always supported, i.e, omx.MTK.

The new logic of this function would be: if the MediaCodecInfo.CodecCapabilities
contains COLOR_FORMAT_YUV420_SEMIPLANAR or COLOR_FORMAT_YUV420_PLANAR
, then they are the chosen color format. Otherwise we consider it unknown color
format and won't go through the VEA path. 

An uncertainty of this change is whether it can return
COLOR_FORMAT_YUV420_SEMIPLANAR for previous supported device, i guess Google
Nexus? See it gets MediaCodecInfo first per mime type, whereas the
MediaCodecInfo could be null for vp8 mime.

+}
+
 AndroidVideoEncodeAccelerator::AndroidVideoEncodeAccelerator()
     : num_buffers_at_codec_(0),
       num_output_buffers_(-1),
       output_buffers_capacity_(0),
       last_set_bitrate_(0) {}
 
 AndroidVideoEncodeAccelerator::~AndroidVideoEncodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
@@ skipping 55 matching lines @@
 
   last_set_bitrate_ = initial_bitrate;
 
   // Only consider using MediaCodec if it's likely backed by hardware.
   if (media::VideoCodecBridge::IsKnownUnaccelerated(
           media::kCodecVP8, media::MEDIA_CODEC_ENCODER)) {
     DLOG(ERROR) << "No HW support";
     return false;
   }
 
-  // TODO(fischman): when there is more HW out there with different color-space
-  // support, this should turn into a negotiation with the codec for supported
-  // formats.  For now we use the only format supported by the only available
-  // HW.
-  media_codec_.reset(
-      media::VideoCodecBridge::CreateEncoder(media::kCodecVP8,
-                                             input_visible_size,
-                                             initial_bitrate,
-                                             INITIAL_FRAMERATE,
-                                             IFRAME_INTERVAL,
-                                             COLOR_FORMAT_YUV420_SEMIPLANAR));
+  media_codec_.reset(media::VideoCodecBridge::CreateEncoder(
+      media::kCodecVP8,
+      input_visible_size,
+      initial_bitrate,
+      INITIAL_FRAMERATE,
+      IFRAME_INTERVAL,
+      GetSupportedColorFormatForMime("video/x-vnd.on2.vp8")));
 
   if (!media_codec_) {
     DLOG(ERROR) << "Failed to create/start the codec: "
                 << input_visible_size.ToString();
     return false;
   }
 
   num_output_buffers_ = media_codec_->GetOutputBuffersCount();
   output_buffers_capacity_ = media_codec_->GetOutputBuffersCapacity();
   base::MessageLoop::current()->PostTask(
@@ skipping 237 matching lines @@
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
                  client_ptr_factory_->GetWeakPtr(),
                  bitstream_buffer.id(),
                  size,
                  key_frame));
 }
 
 }  // namespace content