Refactor MediaCodecBridge to add support for NDK APIs

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/android/media_codec_util.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 {
 
 // Limit default max video codec size for Android to avoid
 // HW codec initialization failure for resolution higher than 720p.
 // Default values are from Libjingle "jsepsessiondescription.cc".
 const int kMaxEncodeFrameWidth = 1280;
 const int kMaxEncodeFrameHeight = 720;
@@ skipping 40 matching lines @@
 
 static inline const base::TimeDelta NoWaitTimeOut() {
   return base::TimeDelta::FromMicroseconds(0);
 }
 
 static bool GetSupportedColorFormatForMime(const std::string& mime,
                                            PixelFormat* pixel_format) {
   if (mime.empty())
     return false;
 
-  std::set<int> formats = MediaCodecBridge::GetEncoderColorFormats(mime);
+  std::set<int> formats = media::MediaCodecUtil::GetEncoderColorFormats(mime);
   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;
 }
 
@@ skipping 53 matching lines @@
     Client* client) {
   DVLOG(3) << __PRETTY_FUNCTION__ << " format: " << format
            << ", input_visible_size: " << input_visible_size.ToString()
            << ", output_profile: " << output_profile
            << ", initial_bitrate: " << initial_bitrate;
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
 
-  if (!(media::MediaCodecBridge::SupportsSetParameters() &&
-        format == media::PIXEL_FORMAT_I420)) {
+  if (!(media::MediaCodecUtil::SupportsSetParameters() &&
+      format == media::PIXEL_FORMAT_I420)) {
     DLOG(ERROR) << "Unexpected combo: " << format << ", " << output_profile;
     return false;
   }
 
   std::string mime_type;
   media::VideoCodec codec;
   if (output_profile == media::VP8PROFILE_ANY) {
     codec = media::kCodecVP8;
     mime_type = "video/x-vnd.on2.vp8";
   } else if (output_profile == media::H264PROFILE_BASELINE ||
@@ skipping 275 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