Migrate content/common/gpu/media code to media/gpu

media/gpu/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 "media/gpu/android_video_encode_accelerator.h"
 
 #include <set>
 
 #include "base/bind.h"
 #include "base/logging.h"
 #include "base/message_loop/message_loop.h"
 #include "base/metrics/histogram.h"
-#include "content/common/gpu/media/shared_memory_region.h"
 #include "gpu/command_buffer/service/gles2_cmd_decoder.h"
 #include "gpu/ipc/service/gpu_channel.h"
 #include "media/base/android/media_codec_util.h"
 #include "media/base/bitstream_buffer.h"
 #include "media/base/limits.h"
+#include "media/gpu/shared_memory_region.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::VideoCodecBridge;
 using media::VideoFrame;
 
-namespace content {
+namespace media {
 
 // 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;
 const int kMaxFramerateNumerator = 30;
 const int kMaxFramerateDenominator = 1;
 
 enum PixelFormat {
@@ skipping 48 matching lines @@
     *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;
 }
 
 AndroidVideoEncodeAccelerator::AndroidVideoEncodeAccelerator()
-    : num_buffers_at_codec_(0),
-      last_set_bitrate_(0) {}
+    : num_buffers_at_codec_(0), last_set_bitrate_(0) {}
 
 AndroidVideoEncodeAccelerator::~AndroidVideoEncodeAccelerator() {
   DCHECK(thread_checker_.CalledOnValidThread());
 }
 
 media::VideoEncodeAccelerator::SupportedProfiles
 AndroidVideoEncodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
 
   const struct {
-      const media::VideoCodec codec;
-      const media::VideoCodecProfile profile;
-  } kSupportedCodecs[] = {
-      { media::kCodecVP8, media::VP8PROFILE_ANY },
-      { media::kCodecH264, media::H264PROFILE_BASELINE },
-      { media::kCodecH264, media::H264PROFILE_MAIN }
-  };
+    const media::VideoCodec codec;
+    const media::VideoCodecProfile profile;
+  } kSupportedCodecs[] = {{media::kCodecVP8, media::VP8PROFILE_ANY},
+                          {media::kCodecH264, media::H264PROFILE_BASELINE},
+                          {media::kCodecH264, media::H264PROFILE_MAIN}};
 
   for (const auto& supported_codec : kSupportedCodecs) {
     if (supported_codec.codec == media::kCodecVP8 &&
         !media::MediaCodecUtil::IsVp8EncoderAvailable()) {
       continue;
     }
 
     if (VideoCodecBridge::IsKnownUnaccelerated(supported_codec.codec,
                                                media::MEDIA_CODEC_ENCODER)) {
       continue;
     }
 
     SupportedProfile profile;
     profile.profile = supported_codec.profile;
     // It would be nice if MediaCodec exposes the maximum capabilities of
     // the encoder. Hard-code some reasonable defaults as workaround.
-    profile.max_resolution.SetSize(kMaxEncodeFrameWidth,
-                                   kMaxEncodeFrameHeight);
+    profile.max_resolution.SetSize(kMaxEncodeFrameWidth, kMaxEncodeFrameHeight);
     profile.max_framerate_numerator = kMaxFramerateNumerator;
     profile.max_framerate_denominator = kMaxFramerateDenominator;
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 bool AndroidVideoEncodeAccelerator::Initialize(
     media::VideoPixelFormat format,
     const gfx::Size& input_visible_size,
@@ skipping 42 matching lines @@
           codec, media::MEDIA_CODEC_ENCODER)) {
     DLOG(ERROR) << "No HW support";
     return false;
   }
 
   PixelFormat pixel_format = COLOR_FORMAT_YUV420_SEMIPLANAR;
   if (!GetSupportedColorFormatForMime(mime_type, &pixel_format)) {
     DLOG(ERROR) << "No color format support.";
     return false;
   }
-  media_codec_.reset(media::VideoCodecBridge::CreateEncoder(codec,
-                                                            input_visible_size,
-                                                            initial_bitrate,
-                                                            INITIAL_FRAMERATE,
-                                                            IFRAME_INTERVAL,
-                                                            pixel_format));
+  media_codec_.reset(media::VideoCodecBridge::CreateEncoder(
+      codec, 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;
   }
 
   // Conservative upper bound for output buffer size: decoded size + 2KB.
   const size_t output_buffer_capacity =
       VideoFrame::AllocationSize(format, input_visible_size) + 2048;
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::RequireBitstreamBuffers,
-                 client_ptr_factory_->GetWeakPtr(),
-                 frame_input_count,
-                 input_visible_size,
-                 output_buffer_capacity));
+                 client_ptr_factory_->GetWeakPtr(), frame_input_count,
+                 input_visible_size, output_buffer_capacity));
   return true;
 }
 
 void AndroidVideoEncodeAccelerator::MaybeStartIOTimer() {
   if (!io_timer_.IsRunning() &&
       (num_buffers_at_codec_ > 0 || !pending_frames_.empty())) {
-    io_timer_.Start(FROM_HERE,
-                    EncodePollDelay(),
-                    this,
+    io_timer_.Start(FROM_HERE, EncodePollDelay(), this,
                     &AndroidVideoEncodeAccelerator::DoIOTask);
   }
 }
 
 void AndroidVideoEncodeAccelerator::MaybeStopIOTimer() {
   if (io_timer_.IsRunning() &&
       (num_buffers_at_codec_ == 0 && pending_frames_.empty())) {
     io_timer_.Stop();
   }
 }
@@ skipping 70 matching lines @@
 void AndroidVideoEncodeAccelerator::QueueInput() {
   if (!client_ptr_factory_->GetWeakPtr() || pending_frames_.empty())
     return;
 
   int input_buf_index = 0;
   media::MediaCodecStatus status =
       media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
   if (status != media::MEDIA_CODEC_OK) {
     DCHECK(status == media::MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER ||
            status == media::MEDIA_CODEC_ERROR);
-    RETURN_ON_FAILURE(status != media::MEDIA_CODEC_ERROR,
-                      "MediaCodec error",
+    RETURN_ON_FAILURE(status != media::MEDIA_CODEC_ERROR, "MediaCodec error",
                       kPlatformFailureError);
     return;
   }
 
   const PendingFrames::value_type& input = pending_frames_.front();
   bool is_key_frame = base::get<1>(input);
   if (is_key_frame) {
     // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
     // indicate this in the QueueInputBuffer() call below and guarantee _this_
     // frame be encoded as a key frame, but sadly that flag is ignored.
@@ skipping 15 matching lines @@
                     kPlatformFailureError);
 
   uint8_t* dst_y = buffer;
   int dst_stride_y = frame->stride(VideoFrame::kYPlane);
   uint8_t* dst_uv =
       buffer +
       frame->stride(VideoFrame::kYPlane) * frame->rows(VideoFrame::kYPlane);
   int dst_stride_uv = frame->stride(VideoFrame::kUPlane) * 2;
   // Why NV12?  Because COLOR_FORMAT_YUV420_SEMIPLANAR.  See comment at other
   // mention of that constant.
-  bool converted = !libyuv::I420ToNV12(frame->data(VideoFrame::kYPlane),
-                                       frame->stride(VideoFrame::kYPlane),
-                                       frame->data(VideoFrame::kUPlane),
-                                       frame->stride(VideoFrame::kUPlane),
-                                       frame->data(VideoFrame::kVPlane),
-                                       frame->stride(VideoFrame::kVPlane),
-                                       dst_y,
-                                       dst_stride_y,
-                                       dst_uv,
-                                       dst_stride_uv,
-                                       frame->coded_size().width(),
-                                       frame->coded_size().height());
+  bool converted = !libyuv::I420ToNV12(
+      frame->data(VideoFrame::kYPlane), frame->stride(VideoFrame::kYPlane),
+      frame->data(VideoFrame::kUPlane), frame->stride(VideoFrame::kUPlane),
+      frame->data(VideoFrame::kVPlane), frame->stride(VideoFrame::kVPlane),
+      dst_y, dst_stride_y, dst_uv, dst_stride_uv, frame->coded_size().width(),
+      frame->coded_size().height());
   RETURN_ON_FAILURE(converted, "Failed to I420ToNV12!", kPlatformFailureError);
 
   fake_input_timestamp_ += base::TimeDelta::FromMicroseconds(1);
-  status = media_codec_->QueueInputBuffer(
-      input_buf_index, NULL, queued_size, fake_input_timestamp_);
-  UMA_HISTOGRAM_TIMES("Media.AVEA.InputQueueTime",
+  status = media_codec_->QueueInputBuffer(input_buf_index, NULL, queued_size,
+                                          fake_input_timestamp_);
+  UMA_HISTOGRAM_TIMES("Media.AVDA.InputQueueTime",
                       base::Time::Now() - base::get<2>(input));
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status,
                     kPlatformFailureError);
   ++num_buffers_at_codec_;
   pending_frames_.pop();
 }
 
 void AndroidVideoEncodeAccelerator::DequeueOutput() {
   if (!client_ptr_factory_->GetWeakPtr() ||
@@ skipping 44 matching lines @@
                     "Encoded buffer too large: " << size << ">" << shm->size(),
                     kPlatformFailureError);
 
   media::MediaCodecStatus status = media_codec_->CopyFromOutputBuffer(
       buf_index, offset, shm->memory(), size);
   RETURN_ON_FAILURE(status == media::MEDIA_CODEC_OK,
                     "CopyFromOutputBuffer failed", kPlatformFailureError);
   media_codec_->ReleaseOutputBuffer(buf_index, false);
   --num_buffers_at_codec_;
 
-  UMA_HISTOGRAM_COUNTS_10000("Media.AVEA.EncodedBufferSizeKB", size / 1024);
   base::MessageLoop::current()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
-                 client_ptr_factory_->GetWeakPtr(),
-                 bitstream_buffer.id(),
-                 size,
+                 client_ptr_factory_->GetWeakPtr(), bitstream_buffer.id(), size,
                  key_frame));
 }
 
-}  // namespace content
+}  // namespace media