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

media/gpu/video_decode_accelerator_unittest.cc

 // Copyright (c) 2012 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.
 //
 // The bulk of this file is support code; sorry about that.  Here's an overview
 // to hopefully help readers of this code:
 // - RenderingHelper is charged with interacting with X11/{EGL/GLES2,GLX/GL} or
 //   Win/EGL.
 // - ClientState is an enum for the state of the decode client used by the test.
 // - ClientStateNotification is a barrier abstraction that allows the test code
@@ skipping 67 matching lines @@
 #error The VideoAccelerator tests are not supported on this platform.
 #endif  // OS_WIN
 
 #if defined(USE_OZONE)
 #include "ui/ozone/public/native_pixmap.h"
 #include "ui/ozone/public/ozone_gpu_test_helper.h"
 #include "ui/ozone/public/ozone_platform.h"
 #include "ui/ozone/public/surface_factory_ozone.h"
 #endif  // defined(USE_OZONE)
 
-using media::VideoDecodeAccelerator;
+namespace media {
 
-namespace media {
 namespace {
 
 // Values optionally filled in from flags; see main() below.
 // The syntax of multiple test videos is:
 //  test-video1;test-video2;test-video3
 // where only the first video is required and other optional videos would be
 // decoded by concurrent decoders.
 // The syntax of each test-video is:
 //  filename:width:height:numframes:numfragments:minFPSwithRender:minFPSnoRender
 // where only the first field is required.  Value details:
 // - |filename| must be an h264 Annex B (NAL) stream or an IVF VP8/9 stream.
 // - |width| and |height| are in pixels.
 // - |numframes| is the number of picture frames in the file.
 // - |numfragments| NALU (h264) or frame (VP8/9) count in the stream.
 // - |minFPSwithRender| and |minFPSnoRender| are minimum frames/second speeds
 //   expected to be achieved with and without rendering to the screen, resp.
 //   (the latter tests just decode speed).
-// - |profile| is the media::VideoCodecProfile set during Initialization.
+// - |profile| is the VideoCodecProfile set during Initialization.
 // An empty value for a numeric field means "ignore".
 const base::FilePath::CharType* g_test_video_data =
     // FILE_PATH_LITERAL("test-25fps.vp8:320:240:250:250:50:175:11");
     FILE_PATH_LITERAL("test-25fps.h264:320:240:250:258:50:175:1");
 
 // The file path of the test output log. This is used to communicate the test
 // results to CrOS autotests. We can enable the log and specify the filename by
 // the "--output_log" switch.
 const base::FilePath::CharType* g_output_log = NULL;
 
@@ skipping 40 matching lines @@
 
 struct TestVideoFile {
   explicit TestVideoFile(base::FilePath::StringType file_name)
       : file_name(file_name),
         width(-1),
         height(-1),
         num_frames(-1),
         num_fragments(-1),
         min_fps_render(-1),
         min_fps_no_render(-1),
-        profile(media::VIDEO_CODEC_PROFILE_UNKNOWN),
+        profile(VIDEO_CODEC_PROFILE_UNKNOWN),
         reset_after_frame_num(END_OF_STREAM_RESET) {}
 
   base::FilePath::StringType file_name;
   int width;
   int height;
   int num_frames;
   int num_fragments;
   int min_fps_render;
   int min_fps_no_render;
-  media::VideoCodecProfile profile;
+  VideoCodecProfile profile;
   int reset_after_frame_num;
   std::string data_str;
 };
 
 const gfx::Size kThumbnailsPageSize(1600, 1200);
 const gfx::Size kThumbnailSize(160, 120);
 const int kMD5StringLength = 32;
 
 // Read in golden MD5s for the thumbnailed rendering of this video
 void ReadGoldenThumbnailMD5s(const TestVideoFile* video_file,
@@ skipping 91 matching lines @@
 // either a buffer allocated by the VDA, or by a preallocated pixmap.
 class TextureRef : public base::RefCounted<TextureRef> {
  public:
   static scoped_refptr<TextureRef> Create(
       uint32_t texture_id,
       const base::Closure& no_longer_needed_cb);
 
   static scoped_refptr<TextureRef> CreatePreallocated(
       uint32_t texture_id,
       const base::Closure& no_longer_needed_cb,
-      media::VideoPixelFormat pixel_format,
+      VideoPixelFormat pixel_format,
       const gfx::Size& size);
 
   gfx::GpuMemoryBufferHandle ExportGpuMemoryBufferHandle() const;
 
   int32_t texture_id() const { return texture_id_; }
 
  private:
   friend class base::RefCounted<TextureRef>;
 
   TextureRef(uint32_t texture_id, const base::Closure& no_longer_needed_cb)
@@ skipping 14 matching lines @@
 
 // static
 scoped_refptr<TextureRef> TextureRef::Create(
     uint32_t texture_id,
     const base::Closure& no_longer_needed_cb) {
   return make_scoped_refptr(new TextureRef(texture_id, no_longer_needed_cb));
 }
 
 #if defined(USE_OZONE)
 gfx::BufferFormat VideoPixelFormatToGfxBufferFormat(
-    media::VideoPixelFormat pixel_format) {
+    VideoPixelFormat pixel_format) {
   switch (pixel_format) {
-    case media::VideoPixelFormat::PIXEL_FORMAT_ARGB:
+    case VideoPixelFormat::PIXEL_FORMAT_ARGB:
       return gfx::BufferFormat::BGRA_8888;
-    case media::VideoPixelFormat::PIXEL_FORMAT_XRGB:
+    case VideoPixelFormat::PIXEL_FORMAT_XRGB:
       return gfx::BufferFormat::BGRX_8888;
-    case media::VideoPixelFormat::PIXEL_FORMAT_NV12:
+    case VideoPixelFormat::PIXEL_FORMAT_NV12:
       return gfx::BufferFormat::YUV_420_BIPLANAR;
     default:
       LOG_ASSERT(false) << "Unknown VideoPixelFormat";
       return gfx::BufferFormat::BGRX_8888;
   }
 }
 #endif
 
 // static
 scoped_refptr<TextureRef> TextureRef::CreatePreallocated(
     uint32_t texture_id,
     const base::Closure& no_longer_needed_cb,
-    media::VideoPixelFormat pixel_format,
+    VideoPixelFormat pixel_format,
     const gfx::Size& size) {
   scoped_refptr<TextureRef> texture_ref;
 #if defined(USE_OZONE)
   texture_ref = TextureRef::Create(texture_id, no_longer_needed_cb);
   LOG_ASSERT(texture_ref);
 
   ui::OzonePlatform* platform = ui::OzonePlatform::GetInstance();
   ui::SurfaceFactoryOzone* factory = platform->GetSurfaceFactoryOzone();
   gfx::BufferFormat buffer_format =
       VideoPixelFormatToGfxBufferFormat(pixel_format);
@@ skipping 48 matching lines @@
   GLRenderingVDAClient(size_t window_id,
                        RenderingHelper* rendering_helper,
                        ClientStateNotification<ClientState>* note,
                        const std::string& encoded_data,
                        int num_in_flight_decodes,
                        int num_play_throughs,
                        int reset_after_frame_num,
                        int delete_decoder_state,
                        int frame_width,
                        int frame_height,
-                       media::VideoCodecProfile profile,
+                       VideoCodecProfile profile,
                        int fake_decoder,
                        bool suppress_rendering,
                        int delay_reuse_after_frame_num,
                        int decode_calls_per_second,
                        bool render_as_thumbnails);
   ~GLRenderingVDAClient() override;
   void CreateAndStartDecoder();
 
   // VideoDecodeAccelerator::Client implementation.
   // The heart of the Client.
   void ProvidePictureBuffers(uint32_t requested_num_of_buffers,
                              VideoPixelFormat format,
                              uint32_t textures_per_buffer,
                              const gfx::Size& dimensions,
                              uint32_t texture_target) override;
   void DismissPictureBuffer(int32_t picture_buffer_id) override;
-  void PictureReady(const media::Picture& picture) override;
+  void PictureReady(const Picture& picture) override;
   // Simple state changes.
   void NotifyEndOfBitstreamBuffer(int32_t bitstream_buffer_id) override;
   void NotifyFlushDone() override;
   void NotifyResetDone() override;
   void NotifyError(VideoDecodeAccelerator::Error error) override;
 
   void OutputFrameDeliveryTimes(base::File* output);
 
   // Simple getters for inspecting the state of the Client.
   int num_done_bitstream_buffers() { return num_done_bitstream_buffers_; }
@@ skipping 46 matching lines @@
   std::unique_ptr<GpuVideoDecodeAcceleratorFactoryImpl> vda_factory_;
   int remaining_play_throughs_;
   int reset_after_frame_num_;
   int delete_decoder_state_;
   ClientState state_;
   int num_skipped_fragments_;
   int num_queued_fragments_;
   int num_decoded_frames_;
   int num_done_bitstream_buffers_;
   base::TimeTicks initialize_done_ticks_;
-  media::VideoCodecProfile profile_;
+  VideoCodecProfile profile_;
   int fake_decoder_;
   GLenum texture_target_;
   VideoPixelFormat pixel_format_;
   bool suppress_rendering_;
   std::vector<base::TimeTicks> frame_delivery_times_;
   int delay_reuse_after_frame_num_;
   // A map from bitstream buffer id to the decode start time of the buffer.
   std::map<int, base::TimeTicks> decode_start_time_;
   // The decode time of all decoded frames.
   std::vector<base::TimeDelta> decode_time_;
@@ skipping 36 matching lines @@
     size_t window_id,
     RenderingHelper* rendering_helper,
     ClientStateNotification<ClientState>* note,
     const std::string& encoded_data,
     int num_in_flight_decodes,
     int num_play_throughs,
     int reset_after_frame_num,
     int delete_decoder_state,
     int frame_width,
     int frame_height,
-    media::VideoCodecProfile profile,
+    VideoCodecProfile profile,
     int fake_decoder,
     bool suppress_rendering,
     int delay_reuse_after_frame_num,
     int decode_calls_per_second,
     bool render_as_thumbnails)
     : window_id_(window_id),
       rendering_helper_(rendering_helper),
       frame_size_(frame_width, frame_height),
       encoded_data_(encoded_data),
       num_in_flight_decodes_(num_in_flight_decodes),
@@ skipping 18 matching lines @@
       render_as_thumbnails_(render_as_thumbnails),
       next_picture_buffer_id_(1),
       weak_this_factory_(this) {
   LOG_ASSERT(num_in_flight_decodes > 0);
   LOG_ASSERT(num_play_throughs > 0);
   // |num_in_flight_decodes_| is unsupported if |decode_calls_per_second_| > 0.
   if (decode_calls_per_second_ > 0)
     LOG_ASSERT(1 == num_in_flight_decodes_);
 
   // Default to H264 baseline if no profile provided.
-  profile_ = (profile != media::VIDEO_CODEC_PROFILE_UNKNOWN
-                  ? profile
-                  : media::H264PROFILE_BASELINE);
+  profile_ =
+      (profile != VIDEO_CODEC_PROFILE_UNKNOWN ? profile : H264PROFILE_BASELINE);
 
   weak_this_ = weak_this_factory_.GetWeakPtr();
 }
 
 GLRenderingVDAClient::~GLRenderingVDAClient() {
   DeleteDecoder();  // Clean up in case of expected error.
   LOG_ASSERT(decoder_deleted());
   SetState(CS_DESTROYED);
 }
 
 void GLRenderingVDAClient::CreateAndStartDecoder() {
   LOG_ASSERT(decoder_deleted());
   LOG_ASSERT(!decoder_.get());
 
   if (fake_decoder_) {
     decoder_.reset(new FakeVideoDecodeAccelerator(
         frame_size_, base::Bind(&DoNothingReturnTrue)));
     LOG_ASSERT(decoder_->Initialize(profile_, this));
   } else {
     if (!vda_factory_) {
       vda_factory_ = GpuVideoDecodeAcceleratorFactoryImpl::Create(
           base::Bind(&RenderingHelper::GetGLContext,
                      base::Unretained(rendering_helper_)),
           base::Bind(&DoNothingReturnTrue), base::Bind(&DummyBindImage));
       LOG_ASSERT(vda_factory_);
     }
 
     VideoDecodeAccelerator::Config config(profile_);
     if (g_test_import) {
-      config.output_mode =
-          media::VideoDecodeAccelerator::Config::OutputMode::IMPORT;
+      config.output_mode = VideoDecodeAccelerator::Config::OutputMode::IMPORT;
     }
     gpu::GpuPreferences gpu_preferences;
     decoder_ = vda_factory_->CreateVDA(this, config, gpu_preferences);
   }
 
   LOG_ASSERT(decoder_) << "Failed creating a VDA";
 
   decoder_->TryToSetupDecodeOnSeparateThread(
       weak_this_, base::ThreadTaskRunnerHandle::Get());
 
   weak_vda_ptr_factory_.reset(
       new base::WeakPtrFactory<VideoDecodeAccelerator>(decoder_.get()));
   weak_vda_ = weak_vda_ptr_factory_->GetWeakPtr();
 
   SetState(CS_DECODER_SET);
   FinishInitialization();
 }
 
 void GLRenderingVDAClient::ProvidePictureBuffers(
     uint32_t requested_num_of_buffers,
     VideoPixelFormat pixel_format,
     uint32_t textures_per_buffer,
     const gfx::Size& dimensions,
     uint32_t texture_target) {
   if (decoder_deleted())
     return;
   LOG_ASSERT(textures_per_buffer == 1u);
-  std::vector<media::PictureBuffer> buffers;
+  std::vector<PictureBuffer> buffers;
 
   requested_num_of_buffers += kExtraPictureBuffers;
-  if (pixel_format == media::PIXEL_FORMAT_UNKNOWN)
-    pixel_format = media::PIXEL_FORMAT_ARGB;
+  if (pixel_format == PIXEL_FORMAT_UNKNOWN)
+    pixel_format = PIXEL_FORMAT_ARGB;
 
   LOG_ASSERT((pixel_format_ == PIXEL_FORMAT_UNKNOWN) ||
              (pixel_format_ == pixel_format));
   pixel_format_ = pixel_format;
 
   texture_target_ = texture_target;
   for (uint32_t i = 0; i < requested_num_of_buffers; ++i) {
     uint32_t texture_id;
     base::WaitableEvent done(base::WaitableEvent::ResetPolicy::AUTOMATIC,
                              base::WaitableEvent::InitialState::NOT_SIGNALED);
@@ skipping 13 matching lines @@
       texture_ref = TextureRef::Create(texture_id, delete_texture_cb);
     }
 
     LOG_ASSERT(texture_ref);
 
     int32_t picture_buffer_id = next_picture_buffer_id_++;
     LOG_ASSERT(
         active_textures_.insert(std::make_pair(picture_buffer_id, texture_ref))
             .second);
 
-    media::PictureBuffer::TextureIds ids;
+    PictureBuffer::TextureIds ids;
     ids.push_back(texture_id);
-    buffers.push_back(media::PictureBuffer(picture_buffer_id, dimensions, ids));
+    buffers.push_back(PictureBuffer(picture_buffer_id, dimensions, ids));
   }
   decoder_->AssignPictureBuffers(buffers);
 
   if (g_test_import) {
     for (const auto& buffer : buffers) {
       TextureRefMap::iterator texture_it = active_textures_.find(buffer.id());
       ASSERT_NE(active_textures_.end(), texture_it);
 
       const gfx::GpuMemoryBufferHandle& handle =
           texture_it->second->ExportGpuMemoryBufferHandle();
       LOG_ASSERT(!handle.is_null()) << "Failed producing GMB handle";
       decoder_->ImportBufferForPicture(buffer.id(), handle);
     }
   }
 }
 
 void GLRenderingVDAClient::DismissPictureBuffer(int32_t picture_buffer_id) {
   LOG_ASSERT(1U == active_textures_.erase(picture_buffer_id));
 }
 
-void GLRenderingVDAClient::PictureReady(const media::Picture& picture) {
+void GLRenderingVDAClient::PictureReady(const Picture& picture) {
   // We shouldn't be getting pictures delivered after Reset has completed.
   LOG_ASSERT(state_ < CS_RESET);
 
   if (decoder_deleted())
     return;
 
   base::TimeTicks now = base::TimeTicks::Now();
 
   frame_delivery_times_.push_back(now);
 
@@ skipping 176 matching lines @@
   STLClearObject(&encoded_data_);
   active_textures_.clear();
 
   // Cascade through the rest of the states to simplify test code below.
   for (int i = state_ + 1; i < CS_MAX; ++i)
     SetState(static_cast<ClientState>(i));
 }
 
 std::string GLRenderingVDAClient::GetBytesForFirstFragment(size_t start_pos,
                                                            size_t* end_pos) {
-  if (profile_ < media::H264PROFILE_MAX) {
+  if (profile_ < H264PROFILE_MAX) {
     *end_pos = start_pos;
     while (*end_pos + 4 < encoded_data_.size()) {
       if ((encoded_data_[*end_pos + 4] & 0x1f) == 0x7)  // SPS start frame
         return GetBytesForNextFragment(*end_pos, end_pos);
       GetBytesForNextNALU(*end_pos, end_pos);
       num_skipped_fragments_++;
     }
     *end_pos = start_pos;
     return std::string();
   }
-  DCHECK_LE(profile_, media::VP9PROFILE_MAX);
+  DCHECK_LE(profile_, VP9PROFILE_MAX);
   return GetBytesForNextFragment(start_pos, end_pos);
 }
 
 std::string GLRenderingVDAClient::GetBytesForNextFragment(size_t start_pos,
                                                           size_t* end_pos) {
-  if (profile_ < media::H264PROFILE_MAX) {
+  if (profile_ < H264PROFILE_MAX) {
     *end_pos = start_pos;
     GetBytesForNextNALU(*end_pos, end_pos);
     if (start_pos != *end_pos) {
       num_queued_fragments_++;
     }
     return encoded_data_.substr(start_pos, *end_pos - start_pos);
   }
-  DCHECK_LE(profile_, media::VP9PROFILE_MAX);
+  DCHECK_LE(profile_, VP9PROFILE_MAX);
   return GetBytesForNextFrame(start_pos, end_pos);
 }
 
 void GLRenderingVDAClient::GetBytesForNextNALU(size_t start_pos,
                                                size_t* end_pos) {
   *end_pos = start_pos;
   if (*end_pos + 4 > encoded_data_.size())
     return;
   LOG_ASSERT(LookingAtNAL(encoded_data_, start_pos));
   *end_pos += 4;
@@ skipping 15 matching lines @@
   uint32_t frame_size = *reinterpret_cast<uint32_t*>(&encoded_data_[*end_pos]);
   *end_pos += 12;  // Skip frame header.
   bytes.append(encoded_data_.substr(*end_pos, frame_size));
   *end_pos += frame_size;
   num_queued_fragments_++;
   return bytes;
 }
 
 static bool FragmentHasConfigInfo(const uint8_t* data,
                                   size_t size,
-                                  media::VideoCodecProfile profile) {
-  if (profile >= media::H264PROFILE_MIN && profile <= media::H264PROFILE_MAX) {
-    media::H264Parser parser;
+                                  VideoCodecProfile profile) {
+  if (profile >= H264PROFILE_MIN && profile <= H264PROFILE_MAX) {
+    H264Parser parser;
     parser.SetStream(data, size);
-    media::H264NALU nalu;
-    media::H264Parser::Result result = parser.AdvanceToNextNALU(&nalu);
-    if (result != media::H264Parser::kOk) {
+    H264NALU nalu;
+    H264Parser::Result result = parser.AdvanceToNextNALU(&nalu);
+    if (result != H264Parser::kOk) {
       // Let the VDA figure out there's something wrong with the stream.
       return false;
     }
 
-    return nalu.nal_unit_type == media::H264NALU::kSPS;
-  } else if (profile >= media::VP8PROFILE_MIN &&
-             profile <= media::VP9PROFILE_MAX) {
+    return nalu.nal_unit_type == H264NALU::kSPS;
+  } else if (profile >= VP8PROFILE_MIN && profile <= VP9PROFILE_MAX) {
     return (size > 0 && !(data[0] & 0x01));
   }
   // Shouldn't happen at this point.
   LOG(FATAL) << "Invalid profile: " << profile;
   return false;
 }
 
 void GLRenderingVDAClient::DecodeNextFragment() {
   if (decoder_deleted())
     return;
@@ skipping 23 matching lines @@
 
   // Populate the shared memory buffer w/ the fragment, duplicate its handle,
   // and hand it off to the decoder.
   base::SharedMemory shm;
   LOG_ASSERT(shm.CreateAndMapAnonymous(next_fragment_size));
   memcpy(shm.memory(), next_fragment_bytes.data(), next_fragment_size);
   base::SharedMemoryHandle dup_handle;
   bool result =
       shm.ShareToProcess(base::GetCurrentProcessHandle(), &dup_handle);
   LOG_ASSERT(result);
-  media::BitstreamBuffer bitstream_buffer(next_bitstream_buffer_id_, dup_handle,
-                                          next_fragment_size);
+  BitstreamBuffer bitstream_buffer(next_bitstream_buffer_id_, dup_handle,
+                                   next_fragment_size);
   decode_start_time_[next_bitstream_buffer_id_] = base::TimeTicks::Now();
   // Mask against 30 bits, to avoid (undefined) wraparound on signed integer.
   next_bitstream_buffer_id_ = (next_bitstream_buffer_id_ + 1) & 0x3FFFFFFF;
   decoder_->Decode(bitstream_buffer);
   ++outstanding_decodes_;
   if (!remaining_play_throughs_ &&
       -delete_decoder_state_ == next_bitstream_buffer_id_) {
     DeleteDecoder();
   }
 
@@ skipping 110 matching lines @@
       LOG_ASSERT(base::StringToInt(fields[3], &video_file->num_frames));
     if (!fields[4].empty())
       LOG_ASSERT(base::StringToInt(fields[4], &video_file->num_fragments));
     if (!fields[5].empty())
       LOG_ASSERT(base::StringToInt(fields[5], &video_file->min_fps_render));
     if (!fields[6].empty())
       LOG_ASSERT(base::StringToInt(fields[6], &video_file->min_fps_no_render));
     int profile = -1;
     if (!fields[7].empty())
       LOG_ASSERT(base::StringToInt(fields[7], &profile));
-    video_file->profile = static_cast<media::VideoCodecProfile>(profile);
+    video_file->profile = static_cast<VideoCodecProfile>(profile);
 
     // Read in the video data.
     base::FilePath filepath(video_file->file_name);
     LOG_ASSERT(base::ReadFileToString(filepath, &video_file->data_str))
         << "test_video_file: " << filepath.MaybeAsASCII();
 
     test_video_files->push_back(video_file);
   }
 }
 
@@ skipping 609 matching lines @@
   media::VaapiWrapper::PreSandboxInitialization();
 #endif
 
   media::g_env =
       reinterpret_cast<media::VideoDecodeAcceleratorTestEnvironment*>(
           testing::AddGlobalTestEnvironment(
               new media::VideoDecodeAcceleratorTestEnvironment()));
 
   return RUN_ALL_TESTS();
 }