Android: enable/disable WebRTC HW H264 with a flag.

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 90 matching lines @@
 }
 
 VideoEncodeAccelerator::SupportedProfiles
 AndroidVideoEncodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
 
   const struct {
     const VideoCodec codec;
     const VideoCodecProfile profile;
   } kSupportedCodecs[] = {{kCodecVP8, VP8PROFILE_ANY},
-                          {kCodecH264, H264PROFILE_BASELINE},
-                          {kCodecH264, H264PROFILE_MAIN}};
+                          {kCodecH264, H264PROFILE_BASELINE}};
 
   for (const auto& supported_codec : kSupportedCodecs) {
     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)) {
       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);
@@ skipping 24 matching lines @@
     DLOG(ERROR) << "Unexpected combo: " << format << ", " << output_profile;
     return false;
   }
 
   std::string mime_type;
   VideoCodec codec;
   // The client should be prepared to feed at least this many frames into the
   // encoder before being returned any output frames, since the encoder may
   // need to hold onto some subset of inputs as reference pictures.
   uint32_t frame_input_count;
+  uint32_t i_frame_interval;
   if (output_profile == VP8PROFILE_ANY) {
     codec = kCodecVP8;
     mime_type = "video/x-vnd.on2.vp8";
     frame_input_count = 1;
+    i_frame_interval = IFRAME_INTERVAL_VPX;
   } else if (output_profile == H264PROFILE_BASELINE ||
              output_profile == H264PROFILE_MAIN) {
     codec = kCodecH264;
     mime_type = "video/avc";
     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)) {
     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(
       codec, input_visible_size, initial_bitrate, INITIAL_FRAMERATE,
-      IFRAME_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 136 matching lines @@
   // 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());
   RETURN_ON_FAILURE(converted, "Failed to I420ToNV12!", kPlatformFailureError);
 
-  fake_input_timestamp_ += base::TimeDelta::FromMicroseconds(1);
+  input_timestamp_ += base::TimeDelta::FromMicroseconds(
+      base::Time::kMicrosecondsPerSecond / INITIAL_FRAMERATE);
   status = media_codec_->QueueInputBuffer(input_buf_index, nullptr, queued_size,
-                                          fake_input_timestamp_);
+                                          input_timestamp_);
   UMA_HISTOGRAM_TIMES("Media.AVDA.InputQueueTime",
                       base::Time::Now() - std::get<2>(input));
   RETURN_ON_FAILURE(status == MEDIA_CODEC_OK,
                     "Failed to QueueInputBuffer: " << status,
                     kPlatformFailureError);
   ++num_buffers_at_codec_;
   pending_frames_.pop();
 }
 
 void AndroidVideoEncodeAccelerator::DequeueOutput() {
@@ skipping 13 matching lines @@
     switch (status) {
       case MEDIA_CODEC_DEQUEUE_OUTPUT_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:
-        break;
+        return;

[watk, 2016/10/01 01:06:54]

Did you mean to change these? You don't want to try dequeueing again if the
buffers changed?

Since all cases are returns now, you don't need the do {} while do you?

[braveyao, 2016/10/03 23:50:15]

Done removing do-while.

Yes I incline to return instead of break here. The reason is with 'return' the
bitrate will, with greater chance, ramp up more quickly and smoothly with the
BWE setting, at least in all my testings. 
I'm still working on it with other performance tuning for the following up cl.
We can make a final decision there.

 
       case MEDIA_CODEC_OUTPUT_BUFFERS_CHANGED:
-        break;
+        return;
 
       case MEDIA_CODEC_OK:
         DCHECK_GE(buf_index, 0);
         break;
 
       default:
         NOTREACHED();
         break;
     }
   } while (buf_index < 0);
@@ skipping 15 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