media: Clean up MediaCodecBridge and remove subclasses

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 "media/gpu/android_video_encode_accelerator.h"
 
 #include <memory>
 #include <set>
 #include <tuple>
 
@@ skipping 103 matching lines @@
     if (supported_codec.codec == kCodecVP8 &&
         !MediaCodecUtil::IsVp8EncoderAvailable()) {
       continue;
     }
 
     if (supported_codec.codec == kCodecH264 &&
         !MediaCodecUtil::IsH264EncoderAvailable()) {
       continue;
     }
 
-    if (VideoCodecBridge::IsKnownUnaccelerated(supported_codec.codec,
-                                               MEDIA_CODEC_ENCODER)) {
+    if (MediaCodecUtil::IsKnownUnaccelerated(supported_codec.codec,
+                                             MediaCodecDirection::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_framerate_numerator = kMaxFramerateNumerator;
     profile.max_framerate_denominator = kMaxFramerateDenominator;
@@ skipping 44 matching lines @@
     frame_input_count = 30;
     i_frame_interval = IFRAME_INTERVAL_H264;
   } else {
     return false;
   }
 
   frame_size_ = input_visible_size;
   last_set_bitrate_ = initial_bitrate;
 
   // Only consider using MediaCodec if it's likely backed by hardware.
-  if (VideoCodecBridge::IsKnownUnaccelerated(codec, MEDIA_CODEC_ENCODER)) {
+  if (MediaCodecUtil::IsKnownUnaccelerated(codec,
+                                           MediaCodecDirection::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(VideoCodecBridge::CreateEncoder(
+  media_codec_ = MediaCodecBridgeImpl::CreateVideoEncoder(
       codec, input_visible_size, initial_bitrate, INITIAL_FRAMERATE,
-      i_frame_interval, pixel_format));
+      i_frame_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;
@@ skipping 90 matching lines @@
 }
 
 void AndroidVideoEncodeAccelerator::QueueInput() {
   if (error_occurred_ || pending_frames_.empty())
     return;
 
   int input_buf_index = 0;
   MediaCodecStatus status =
       media_codec_->DequeueInputBuffer(NoWaitTimeOut(), &input_buf_index);
   if (status != MEDIA_CODEC_OK) {
-    DCHECK(status == MEDIA_CODEC_DEQUEUE_INPUT_AGAIN_LATER ||
+    DCHECK(status == MEDIA_CODEC_TRY_AGAIN_LATER ||
            status == MEDIA_CODEC_ERROR);
     RETURN_ON_FAILURE(status != MEDIA_CODEC_ERROR, "MediaCodec error",
                       kPlatformFailureError);
     return;
   }
 
   const PendingFrames::value_type& input = pending_frames_.front();
   bool is_key_frame = std::get<1>(input);
   if (is_key_frame) {
     // Ideally MediaCodec would honor BUFFER_FLAG_SYNC_FRAME so we could
@@ skipping 53 matching lines @@
 
   int32_t buf_index = 0;
   size_t offset = 0;
   size_t size = 0;
   bool key_frame = false;
 
   MediaCodecStatus status =
       media_codec_->DequeueOutputBuffer(NoWaitTimeOut(), &buf_index, &offset,
                                         &size, nullptr, nullptr, &key_frame);
   switch (status) {
-    case MEDIA_CODEC_DEQUEUE_OUTPUT_AGAIN_LATER:
+    case MEDIA_CODEC_TRY_AGAIN_LATER:
       return;
 
     case MEDIA_CODEC_ERROR:
       RETURN_ON_FAILURE(false, "Codec error", kPlatformFailureError);
       // Unreachable because of previous statement, but included for clarity.
       return;
 
     case MEDIA_CODEC_OUTPUT_FORMAT_CHANGED:
       return;
 
@@ skipping 26 matching lines @@
   --num_buffers_at_codec_;
 
   base::ThreadTaskRunnerHandle::Get()->PostTask(
       FROM_HERE,
       base::Bind(&VideoEncodeAccelerator::Client::BitstreamBufferReady,
                  client_ptr_factory_->GetWeakPtr(), bitstream_buffer.id(), size,
                  key_frame, base::Time::Now() - base::Time()));
 }
 
 }  // namespace media