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 <set>
+
 #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 bool GetSupportedColorFormatForMime(const std::string& mime,
+                                           PixelFormat* pixel_format) {
+  std::set<int> formats = MediaCodecBridge::GetEncoderColorFormats(mime);
+  if (formats.find(COLOR_FORMAT_YUV420_SEMIPLANAR) == formats.end() &&
+      formats.find(COLOR_FORMAT_YUV420_PLANAR) == formats.end())
+    return false;
+
+  *pixel_format = formats.find(COLOR_FORMAT_YUV420_SEMIPLANAR) != formats.end()
+                      ? COLOR_FORMAT_YUV420_SEMIPLANAR
+                      : COLOR_FORMAT_YUV420_PLANAR;

[Pawel Osciak, 2014/10/20 08:10:24]

Perhaps:

if (formats.count(COLOR_FORMAT_YUV420_SEMIPLANAR) > 0
  *pixel_format = COLOR_FORMAT_YUV420_SEMIPLANAR;
else if (formats.count(COLOR_FORMAT_YUV420_PLANAR) > 0)
  *pixel_format = COLOR_FORMAT_YUV420_PLANAR;
else
  return false;

return true;

[changbin, 2014/10/20 14:45:47]

Done.

+  return true;
+}
+
 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));
+  PixelFormat pixel_format = COLOR_FORMAT_YUV420_SEMIPLANAR;
+  if (!GetSupportedColorFormatForMime("video/x-vnd.on2.vp8", &pixel_format)) {
+    DLOG(ERROR) << "No color format support.";
+    return false;
+  }
+  media_codec_.reset(media::VideoCodecBridge::CreateEncoder(media::kCodecVP8,
+                                                            input_visible_size,
+                                                            initial_bitrate,
+                                                            INITIAL_FRAMERATE,
+                                                            IFRAME_INTERVAL,
+                                                            pixel_format));
 
   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