media/.../{android_,gpu_}video_encode_accelerator{,_host} cleanup

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 122 matching lines @@
   }
   return profiles;
 }
 
 bool AndroidVideoEncodeAccelerator::Initialize(
     VideoPixelFormat format,
     const gfx::Size& input_visible_size,
     VideoCodecProfile output_profile,
     uint32_t initial_bitrate,
     Client* client) {
-  DVLOG(3) << __PRETTY_FUNCTION__ << " format: " << format
+  DVLOG(3) << __func__ << " format: " << VideoPixelFormatToString(format)
            << ", input_visible_size: " << input_visible_size.ToString()
-           << ", output_profile: " << output_profile
+           << ", output_profile: " << GetProfileName(output_profile)
            << ", initial_bitrate: " << initial_bitrate;
   DCHECK(!media_codec_);
   DCHECK(thread_checker_.CalledOnValidThread());
 
   client_ptr_factory_.reset(new base::WeakPtrFactory<Client>(client));
 
   if (!(MediaCodecUtil::SupportsSetParameters() &&
         format == PIXEL_FORMAT_I420)) {
     DLOG(ERROR) << "Unexpected combo: " << format << ", " << output_profile;
     return false;
@@ skipping 156 matching lines @@
   bool is_key_frame = std::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.
     // Instead, we request a key frame "soon".
     media_codec_->RequestKeyFrameSoon();
   }
   scoped_refptr<VideoFrame> frame = std::get<0>(input);
 
   uint8_t* buffer = NULL;

[watk, 2016/08/18 18:12:15]

s/NULL/nullptr

[mcasas, 2016/08/18 19:24:40]

Done.

   size_t capacity = 0;
   status = media_codec_->GetInputBuffer(input_buf_index, &buffer, &capacity);
   RETURN_ON_FAILURE(status == MEDIA_CODEC_OK, "GetInputBuffer failed.",
                     kPlatformFailureError);
 
   size_t queued_size =
       VideoFrame::AllocationSize(PIXEL_FORMAT_I420, frame->coded_size());
   RETURN_ON_FAILURE(capacity >= queued_size,
                     "Failed to get input buffer: " << input_buf_index,
                     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());
   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,

[watk, 2016/08/18 18:12:15]

s/NULL/nullptr

[mcasas, 2016/08/18 19:24:40]

Done.

                                           fake_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() {
   if (!client_ptr_factory_->GetWeakPtr() ||
       available_bitstream_buffers_.empty() || num_buffers_at_codec_ == 0) {
     return;
   }
 
   int32_t buf_index = 0;
   size_t offset = 0;
   size_t size = 0;
   bool key_frame = false;
   do {
     MediaCodecStatus status = media_codec_->DequeueOutputBuffer(
         NoWaitTimeOut(), &buf_index, &offset, &size, NULL, NULL, &key_frame);

[watk, 2016/08/18 18:12:15]

s/NULL/nullptr

[mcasas, 2016/08/18 19:24:40]

Done.

     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:
@@ skipping 31 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