media: Drop "media::" in media/gpu

media/gpu/vt_video_encode_accelerator_mac.cc

 // Copyright 2016 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/vt_video_encode_accelerator_mac.h"
 
 #include <memory>
 
 #include "base/mac/mac_util.h"
 #include "base/threading/thread_task_runner_handle.h"
@@ skipping 76 matching lines @@
 
 VTVideoEncodeAccelerator::~VTVideoEncodeAccelerator() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   Destroy();
   DCHECK(!encoder_thread_.IsRunning());
   DCHECK(!encoder_task_weak_factory_.HasWeakPtrs());
 }
 
-media::VideoEncodeAccelerator::SupportedProfiles
+VideoEncodeAccelerator::SupportedProfiles
 VTVideoEncodeAccelerator::GetSupportedProfiles() {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   SupportedProfiles profiles;
   // Check if HW encoder is supported initially.
   videotoolbox_glue_ = VideoToolboxGlue::Get();
   if (!videotoolbox_glue_) {
     DLOG(ERROR) << "Failed creating VideoToolbox glue.";
     return profiles;
   }
   if (!base::mac::IsOSMavericksOrLater()) {
     DLOG(ERROR) << "VideoToolbox hardware encoder is supported on Mac OS 10.9 "
                    "and later.";
     return profiles;
   }
   const bool rv = CreateCompressionSession(
-      media::video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0),
+      video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0),
       gfx::Size(kDefaultResolutionWidth, kDefaultResolutionHeight), true);
   DestroyCompressionSession();
   if (!rv) {
     VLOG(1)
         << "Hardware encode acceleration is not available on this platform.";
     return profiles;
   }
 
   SupportedProfile profile;
-  profile.profile = media::H264PROFILE_BASELINE;
+  profile.profile = H264PROFILE_BASELINE;
   profile.max_framerate_numerator = kMaxFrameRateNumerator;
   profile.max_framerate_denominator = kMaxFrameRateDenominator;
   profile.max_resolution = gfx::Size(kMaxResolutionWidth, kMaxResolutionHeight);
   profiles.push_back(profile);
   return profiles;
 }
 
-bool VTVideoEncodeAccelerator::Initialize(
-    media::VideoPixelFormat format,
-    const gfx::Size& input_visible_size,
-    media::VideoCodecProfile output_profile,
-    uint32_t initial_bitrate,
-    Client* client) {
+bool VTVideoEncodeAccelerator::Initialize(VideoPixelFormat format,
+                                          const gfx::Size& input_visible_size,
+                                          VideoCodecProfile output_profile,
+                                          uint32_t initial_bitrate,
+                                          Client* client) {
   DVLOG(3) << __FUNCTION__
-           << ": input_format=" << media::VideoPixelFormatToString(format)
+           << ": input_format=" << VideoPixelFormatToString(format)
            << ", input_visible_size=" << input_visible_size.ToString()
            << ", output_profile=" << output_profile
            << ", initial_bitrate=" << initial_bitrate;
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(client);
 
-  if (media::PIXEL_FORMAT_I420 != format) {
+  if (PIXEL_FORMAT_I420 != format) {
     DLOG(ERROR) << "Input format not supported= "
-                << media::VideoPixelFormatToString(format);
+                << VideoPixelFormatToString(format);
     return false;
   }
-  if (media::H264PROFILE_BASELINE != output_profile) {
+  if (H264PROFILE_BASELINE != output_profile) {
     DLOG(ERROR) << "Output profile not supported= " << output_profile;
     return false;
   }
 
   videotoolbox_glue_ = VideoToolboxGlue::Get();
   if (!videotoolbox_glue_) {
     DLOG(ERROR) << "Failed creating VideoToolbox glue.";
     return false;
   }
   if (!base::mac::IsOSMavericksOrLater()) {
@@ skipping 20 matching lines @@
     return false;
   }
 
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::RequireBitstreamBuffers, client_, kNumInputBuffers,
                  input_visible_size_, bitstream_buffer_size_));
   return true;
 }
 
-void VTVideoEncodeAccelerator::Encode(
-    const scoped_refptr<media::VideoFrame>& frame,
-    bool force_keyframe) {
+void VTVideoEncodeAccelerator::Encode(const scoped_refptr<VideoFrame>& frame,
+                                      bool force_keyframe) {
   DVLOG(3) << __FUNCTION__;
   DCHECK(thread_checker_.CalledOnValidThread());
 
   encoder_thread_task_runner_->PostTask(
       FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::EncodeTask,
                             base::Unretained(this), frame, force_keyframe));
 }
 
 void VTVideoEncodeAccelerator::UseOutputBitstreamBuffer(
-    const media::BitstreamBuffer& buffer) {
+    const BitstreamBuffer& buffer) {
   DVLOG(3) << __FUNCTION__ << ": buffer size=" << buffer.size();
   DCHECK(thread_checker_.CalledOnValidThread());
 
   if (buffer.size() < bitstream_buffer_size_) {
     DLOG(ERROR) << "Output BitstreamBuffer isn't big enough: " << buffer.size()
                 << " vs. " << bitstream_buffer_size_;
     client_->NotifyError(kInvalidArgumentError);
     return;
   }
 
@@ skipping 38 matching lines @@
     encoder_thread_task_runner_->PostTask(
         FROM_HERE, base::Bind(&VTVideoEncodeAccelerator::DestroyTask,
                               base::Unretained(this)));
     encoder_thread_.Stop();
   } else {
     DestroyTask();
   }
 }
 
 void VTVideoEncodeAccelerator::EncodeTask(
-    const scoped_refptr<media::VideoFrame>& frame,
+    const scoped_refptr<VideoFrame>& frame,
     bool force_keyframe) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   DCHECK(compression_session_);
   DCHECK(frame);
 
   // TODO(emircan): See if we can eliminate a copy here by using
   // CVPixelBufferPool for the allocation of incoming VideoFrames.
   base::ScopedCFTypeRef<CVPixelBufferRef> pixel_buffer =
-      media::WrapVideoFrameInCVPixelBuffer(*frame);
+      WrapVideoFrameInCVPixelBuffer(*frame);
   base::ScopedCFTypeRef<CFDictionaryRef> frame_props =
-      media::video_toolbox::DictionaryWithKeyValue(
+      video_toolbox::DictionaryWithKeyValue(
           videotoolbox_glue_->kVTEncodeFrameOptionKey_ForceKeyFrame(),
           force_keyframe ? kCFBooleanTrue : kCFBooleanFalse);
 
   base::TimeTicks ref_time;
-  if (!frame->metadata()->GetTimeTicks(
-          media::VideoFrameMetadata::REFERENCE_TIME, &ref_time)) {
+  if (!frame->metadata()->GetTimeTicks(VideoFrameMetadata::REFERENCE_TIME,
+                                       &ref_time)) {
     ref_time = base::TimeTicks::Now();
   }
   auto timestamp_cm = CoreMediaGlue::CMTimeMake(
       frame->timestamp().InMicroseconds(), USEC_PER_SEC);
   // Wrap information we'll need after the frame is encoded in a heap object.
   // We'll get the pointer back from the VideoToolbox completion callback.
   std::unique_ptr<InProgressFrameEncode> request(
       new InProgressFrameEncode(frame->timestamp(), ref_time));
 
   // Update the bitrate if needed.
@@ skipping 33 matching lines @@
     uint32_t bitrate,
     uint32_t framerate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (!compression_session_) {
     NotifyError(kPlatformFailureError);
     return;
   }
 
   if (framerate != static_cast<uint32_t>(frame_rate_)) {
-    media::video_toolbox::SessionPropertySetter session_property_setter(
+    video_toolbox::SessionPropertySetter session_property_setter(
         compression_session_, videotoolbox_glue_);
     session_property_setter.Set(
         videotoolbox_glue_->kVTCompressionPropertyKey_ExpectedFrameRate(),
         frame_rate_);
   }
 
   if (bitrate != static_cast<uint32_t>(target_bitrate_) && bitrate > 0) {
     target_bitrate_ = bitrate;
     bitrate_adjuster_.SetTargetBitrateBps(target_bitrate_);
     SetAdjustedBitrate(bitrate_adjuster_.GetAdjustedBitrateBps());
   }
 }
 
 void VTVideoEncodeAccelerator::SetAdjustedBitrate(int32_t bitrate) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
 
   if (bitrate == encoder_set_bitrate_)
     return;
 
   encoder_set_bitrate_ = bitrate;
-  media::video_toolbox::SessionPropertySetter session_property_setter(
+  video_toolbox::SessionPropertySetter session_property_setter(
       compression_session_, videotoolbox_glue_);
   bool rv = session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_AverageBitRate(),
       encoder_set_bitrate_);
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_DataRateLimits(),
-      media::video_toolbox::ArrayWithIntegerAndFloat(
+      video_toolbox::ArrayWithIntegerAndFloat(
           encoder_set_bitrate_ / kBitsPerByte, 1.0f));
   DLOG_IF(ERROR, !rv)
       << "Couldn't change bitrate parameters of encode session.";
 }
 
 void VTVideoEncodeAccelerator::DestroyTask() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   // Cancel all encoder thread callbacks.
   encoder_task_weak_factory_.InvalidateWeakPtrs();
 
   // This call blocks until all pending frames are flushed out.
   DestroyCompressionSession();
 }
 
 void VTVideoEncodeAccelerator::NotifyError(
-    media::VideoEncodeAccelerator::Error error) {
+    VideoEncodeAccelerator::Error error) {
   DCHECK(encoder_thread_task_runner_->BelongsToCurrentThread());
   client_task_runner_->PostTask(
       FROM_HERE, base::Bind(&Client::NotifyError, client_, error));
 }
 
 // static
 void VTVideoEncodeAccelerator::CompressionCallback(void* encoder_opaque,
                                                    void* request_opaque,
                                                    OSStatus status,
                                                    VTEncodeInfoFlags info,
@@ skipping 62 matching lines @@
   }
 
   auto sample_attachments = static_cast<CFDictionaryRef>(CFArrayGetValueAtIndex(
       CoreMediaGlue::CMSampleBufferGetSampleAttachmentsArray(
           encode_output->sample_buffer.get(), true),
       0));
   const bool keyframe = !CFDictionaryContainsKey(
       sample_attachments, CoreMediaGlue::kCMSampleAttachmentKey_NotSync());
 
   size_t used_buffer_size = 0;
-  const bool copy_rv = media::video_toolbox::CopySampleBufferToAnnexBBuffer(
+  const bool copy_rv = video_toolbox::CopySampleBufferToAnnexBBuffer(
       encode_output->sample_buffer.get(), keyframe, buffer_ref->size,
       reinterpret_cast<char*>(buffer_ref->shm->memory()), &used_buffer_size);
   if (!copy_rv) {
     DLOG(ERROR) << "Cannot copy output from SampleBuffer to AnnexBBuffer.";
     used_buffer_size = 0;
   }
   bitrate_adjuster_.Update(used_buffer_size);
 
   client_task_runner_->PostTask(
       FROM_HERE,
       base::Bind(&Client::BitstreamBufferReady, client_, buffer_ref->id,
                  used_buffer_size, keyframe, encode_output->capture_timestamp));
 }
 
 bool VTVideoEncodeAccelerator::ResetCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
 
   DestroyCompressionSession();
 
   CFTypeRef attributes_keys[] = {kCVPixelBufferOpenGLCompatibilityKey,
                                  kCVPixelBufferIOSurfacePropertiesKey,
                                  kCVPixelBufferPixelFormatTypeKey};
   const int format[] = {
       CoreVideoGlue::kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange};
   CFTypeRef attributes_values[] = {
       kCFBooleanTrue,
-      media::video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0)
-          .release(),
-      media::video_toolbox::ArrayWithIntegers(format, arraysize(format))
-          .release()};
+      video_toolbox::DictionaryWithKeysAndValues(nullptr, nullptr, 0).release(),
+      video_toolbox::ArrayWithIntegers(format, arraysize(format)).release()};
   const base::ScopedCFTypeRef<CFDictionaryRef> attributes =
-      media::video_toolbox::DictionaryWithKeysAndValues(
+      video_toolbox::DictionaryWithKeysAndValues(
           attributes_keys, attributes_values, arraysize(attributes_keys));
   for (auto& v : attributes_values)
     CFRelease(v);
 
   bool session_rv =
       CreateCompressionSession(attributes, input_visible_size_, false);
   if (!session_rv) {
     DestroyCompressionSession();
     return false;
   }
@@ skipping 17 matching lines @@
         videotoolbox_glue_
             ->kVTVideoEncoderSpecification_RequireHardwareAcceleratedVideoEncoder());
     encoder_values.push_back(kCFBooleanTrue);
   } else {
     encoder_keys.push_back(
         videotoolbox_glue_
             ->kVTVideoEncoderSpecification_EnableHardwareAcceleratedVideoEncoder());
     encoder_values.push_back(kCFBooleanTrue);
   }
   base::ScopedCFTypeRef<CFDictionaryRef> encoder_spec =
-      media::video_toolbox::DictionaryWithKeysAndValues(
+      video_toolbox::DictionaryWithKeysAndValues(
           encoder_keys.data(), encoder_values.data(), encoder_keys.size());
 
   // Create the compression session.
   // Note that the encoder object is given to the compression session as the
   // callback context using a raw pointer. The C API does not allow us to use a
   // smart pointer, nor is this encoder ref counted. However, this is still
   // safe, because we 1) we own the compression session and 2) we tear it down
   // safely. When destructing the encoder, the compression session is flushed
   // and invalidated. Internally, VideoToolbox will join all of its threads
   // before returning to the client. Therefore, when control returns to us, we
@@ skipping 10 matching lines @@
   }
   DVLOG(3) << " VTCompressionSession created with HW encode: "
            << require_hw_encoding << ", input size=" << input_size.ToString();
   return true;
 }
 
 bool VTVideoEncodeAccelerator::ConfigureCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread());
   DCHECK(compression_session_);
 
-  media::video_toolbox::SessionPropertySetter session_property_setter(
+  video_toolbox::SessionPropertySetter session_property_setter(
       compression_session_, videotoolbox_glue_);
   bool rv = true;
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_ProfileLevel(),
       videotoolbox_glue_->kVTProfileLevel_H264_Baseline_AutoLevel());
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_RealTime(), true);
   rv &= session_property_setter.Set(
       videotoolbox_glue_->kVTCompressionPropertyKey_AllowFrameReordering(),
       false);
   DLOG_IF(ERROR, !rv) << " Setting session property failed.";
   return rv;
 }
 
 void VTVideoEncodeAccelerator::DestroyCompressionSession() {
   DCHECK(thread_checker_.CalledOnValidThread() ||
          (encoder_thread_.IsRunning() &&
           encoder_thread_task_runner_->BelongsToCurrentThread()));
 
   if (compression_session_) {
     videotoolbox_glue_->VTCompressionSessionInvalidate(compression_session_);
     compression_session_.reset();
   }
 }
 
 }  // namespace media