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

media/gpu/vt_video_decode_accelerator_mac.cc

 // Copyright 2014 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_decode_accelerator_mac.h"
 
 #include <CoreVideo/CoreVideo.h>
 #include <OpenGL/CGLIOSurface.h>
 #include <OpenGL/gl.h>
 #include <stddef.h>
@@ skipping 25 matching lines @@
 
 #define NOTIFY_STATUS(name, status, session_failure) \
   do {                                               \
     OSSTATUS_DLOG(ERROR, status) << name;            \
     NotifyError(PLATFORM_FAILURE, session_failure);  \
   } while (0)
 
 namespace media {
 
 // Only H.264 with 4:2:0 chroma sampling is supported.
-static const media::VideoCodecProfile kSupportedProfiles[] = {
-    media::H264PROFILE_BASELINE, media::H264PROFILE_MAIN,
-    media::H264PROFILE_EXTENDED, media::H264PROFILE_HIGH,
+static const VideoCodecProfile kSupportedProfiles[] = {
+    H264PROFILE_BASELINE, H264PROFILE_MAIN, H264PROFILE_EXTENDED,
+    H264PROFILE_HIGH,
     // TODO(hubbe): Try to re-enable this again somehow. Currently it seems
     // that some codecs fail to check the profile during initialization and
     // then fail on the first frame decode, which currently results in a
     // pipeline failure.
-    // media::H264PROFILE_HIGH10PROFILE,
-    media::H264PROFILE_SCALABLEBASELINE, media::H264PROFILE_SCALABLEHIGH,
-    media::H264PROFILE_STEREOHIGH, media::H264PROFILE_MULTIVIEWHIGH,
+    // H264PROFILE_HIGH10PROFILE,
+    H264PROFILE_SCALABLEBASELINE, H264PROFILE_SCALABLEHIGH,
+    H264PROFILE_STEREOHIGH, H264PROFILE_MULTIVIEWHIGH,
 };
 
 // Size to use for NALU length headers in AVC format (can be 1, 2, or 4).
 static const int kNALUHeaderLength = 4;
 
 // We request 5 picture buffers from the client, each of which has a texture ID
 // that we can bind decoded frames to. We need enough to satisfy preroll, and
 // enough to avoid unnecessary stalling, but no more than that. The resource
 // requirements are low, as we don't need the textures to be backed by storage.
-static const int kNumPictureBuffers = media::limits::kMaxVideoFrames + 1;
+static const int kNumPictureBuffers = limits::kMaxVideoFrames + 1;
 
 // Maximum number of frames to queue for reordering before we stop asking for
 // more. (NotifyEndOfBitstreamBuffer() is called when frames are moved into the
 // reorder queue.)
 static const int kMaxReorderQueueSize = 16;
 
 // Build an |image_config| dictionary for VideoToolbox initialization.
 static base::ScopedCFTypeRef<CFMutableDictionaryRef> BuildImageConfig(
     CMVideoDimensions coded_dimensions) {
   base::ScopedCFTypeRef<CFMutableDictionaryRef> image_config;
@@ skipping 378 matching lines @@
           // kVTDecompressionPropertyKey_UsingHardwareAcceleratedVideoDecoder
           CFSTR("UsingHardwareAcceleratedVideoDecoder"), kCFAllocatorDefault,
           cf_using_hardware.InitializeInto()) == 0) {
     using_hardware = CFBooleanGetValue(cf_using_hardware);
   }
   UMA_HISTOGRAM_BOOLEAN("Media.VTVDA.HardwareAccelerated", using_hardware);
 
   return true;
 }
 
-void VTVideoDecodeAccelerator::DecodeTask(
-    const media::BitstreamBuffer& bitstream,
-    Frame* frame) {
+void VTVideoDecodeAccelerator::DecodeTask(const BitstreamBuffer& bitstream,
+                                          Frame* frame) {
   DCHECK(decoder_thread_.task_runner()->BelongsToCurrentThread());
 
   // Map the bitstream buffer.
   SharedMemoryRegion memory(bitstream, true);
   if (!memory.Map()) {
     DLOG(ERROR) << "Failed to map bitstream buffer";
     NotifyError(PLATFORM_FAILURE, SFT_PLATFORM_ERROR);
     return;
   }
   const uint8_t* buf = static_cast<uint8_t*>(memory.memory());
 
   // NALUs are stored with Annex B format in the bitstream buffer (start codes),
   // but VideoToolbox expects AVC format (length headers), so we must rewrite
   // the data.
   //
   // Locate relevant NALUs and compute the size of the rewritten data. Also
   // record any parameter sets for VideoToolbox initialization.
   std::vector<uint8_t> sps;
   std::vector<uint8_t> spsext;
   std::vector<uint8_t> pps;
   bool has_slice = false;
   size_t data_size = 0;
-  std::vector<media::H264NALU> nalus;
+  std::vector<H264NALU> nalus;
   parser_.SetStream(buf, memory.size());
-  media::H264NALU nalu;
+  H264NALU nalu;
   while (true) {
-    media::H264Parser::Result result = parser_.AdvanceToNextNALU(&nalu);
-    if (result == media::H264Parser::kEOStream)
+    H264Parser::Result result = parser_.AdvanceToNextNALU(&nalu);
+    if (result == H264Parser::kEOStream)
       break;
-    if (result == media::H264Parser::kUnsupportedStream) {
+    if (result == H264Parser::kUnsupportedStream) {
       DLOG(ERROR) << "Unsupported H.264 stream";
       NotifyError(PLATFORM_FAILURE, SFT_UNSUPPORTED_STREAM);
       return;
     }
-    if (result != media::H264Parser::kOk) {
+    if (result != H264Parser::kOk) {
       DLOG(ERROR) << "Failed to parse H.264 stream";
       NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
       return;
     }
     switch (nalu.nal_unit_type) {
-      case media::H264NALU::kSPS:
+      case H264NALU::kSPS:
         result = parser_.ParseSPS(&last_sps_id_);
-        if (result == media::H264Parser::kUnsupportedStream) {
+        if (result == H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported SPS";
           NotifyError(PLATFORM_FAILURE, SFT_UNSUPPORTED_STREAM);
           return;
         }
-        if (result != media::H264Parser::kOk) {
+        if (result != H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse SPS";
           NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
           return;
         }
         sps.assign(nalu.data, nalu.data + nalu.size);
         spsext.clear();
         break;
 
-      case media::H264NALU::kSPSExt:
+      case H264NALU::kSPSExt:
         // TODO(sandersd): Check that the previous NALU was an SPS.
         spsext.assign(nalu.data, nalu.data + nalu.size);
         break;
 
-      case media::H264NALU::kPPS:
+      case H264NALU::kPPS:
         result = parser_.ParsePPS(&last_pps_id_);
-        if (result == media::H264Parser::kUnsupportedStream) {
+        if (result == H264Parser::kUnsupportedStream) {
           DLOG(ERROR) << "Unsupported PPS";
           NotifyError(PLATFORM_FAILURE, SFT_UNSUPPORTED_STREAM);
           return;
         }
-        if (result != media::H264Parser::kOk) {
+        if (result != H264Parser::kOk) {
           DLOG(ERROR) << "Could not parse PPS";
           NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
           return;
         }
         pps.assign(nalu.data, nalu.data + nalu.size);
         break;
 
-      case media::H264NALU::kSliceDataA:
-      case media::H264NALU::kSliceDataB:
-      case media::H264NALU::kSliceDataC:
-      case media::H264NALU::kNonIDRSlice:
-      case media::H264NALU::kIDRSlice:
+      case H264NALU::kSliceDataA:
+      case H264NALU::kSliceDataB:
+      case H264NALU::kSliceDataC:
+      case H264NALU::kNonIDRSlice:
+      case H264NALU::kIDRSlice:
         // Compute the |pic_order_cnt| for the picture from the first slice.
         if (!has_slice) {
           // Verify that we are not trying to decode a slice without an IDR.
           if (waiting_for_idr_) {
-            if (nalu.nal_unit_type == media::H264NALU::kIDRSlice) {
+            if (nalu.nal_unit_type == H264NALU::kIDRSlice) {
               waiting_for_idr_ = false;
             } else {
               // We can't compute anything yet, bail on this frame.
               has_slice = true;
               break;
             }
           }
 
-          media::H264SliceHeader slice_hdr;
+          H264SliceHeader slice_hdr;
           result = parser_.ParseSliceHeader(nalu, &slice_hdr);
-          if (result == media::H264Parser::kUnsupportedStream) {
+          if (result == H264Parser::kUnsupportedStream) {
             DLOG(ERROR) << "Unsupported slice header";
             NotifyError(PLATFORM_FAILURE, SFT_UNSUPPORTED_STREAM);
             return;
           }
-          if (result != media::H264Parser::kOk) {
+          if (result != H264Parser::kOk) {
             DLOG(ERROR) << "Could not parse slice header";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           // TODO(sandersd): Maintain a cache of configurations and reconfigure
           // when a slice references a new config.
           DCHECK_EQ(slice_hdr.pic_parameter_set_id, last_pps_id_);
-          const media::H264PPS* pps =
-              parser_.GetPPS(slice_hdr.pic_parameter_set_id);
+          const H264PPS* pps = parser_.GetPPS(slice_hdr.pic_parameter_set_id);
           if (!pps) {
             DLOG(ERROR) << "Mising PPS referenced by slice";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           DCHECK_EQ(pps->seq_parameter_set_id, last_sps_id_);
-          const media::H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
+          const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
           if (!sps) {
             DLOG(ERROR) << "Mising SPS referenced by PPS";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
           if (!poc_.ComputePicOrderCnt(sps, slice_hdr, &frame->pic_order_cnt)) {
             DLOG(ERROR) << "Unable to compute POC";
             NotifyError(UNREADABLE_INPUT, SFT_INVALID_STREAM);
             return;
           }
 
-          if (nalu.nal_unit_type == media::H264NALU::kIDRSlice)
+          if (nalu.nal_unit_type == H264NALU::kIDRSlice)
             frame->is_idr = true;
 
           if (sps->vui_parameters_present_flag &&
               sps->bitstream_restriction_flag) {
             frame->reorder_window =
                 std::min(sps->max_num_reorder_frames, kMaxReorderQueueSize - 1);
           }
         }
         has_slice = true;
       default:
@@ skipping 92 matching lines @@
   status = CMBlockBufferAssureBlockMemory(data);
   if (status) {
     NOTIFY_STATUS("CMBlockBufferAssureBlockMemory()", status,
                   SFT_PLATFORM_ERROR);
     return;
   }
 
   // Copy NALU data into the CMBlockBuffer, inserting length headers.
   size_t offset = 0;
   for (size_t i = 0; i < nalus.size(); i++) {
-    media::H264NALU& nalu = nalus[i];
+    H264NALU& nalu = nalus[i];
     uint32_t header = base::HostToNet32(static_cast<uint32_t>(nalu.size));
     status =
         CMBlockBufferReplaceDataBytes(&header, data, offset, kNALUHeaderLength);
     if (status) {
       NOTIFY_STATUS("CMBlockBufferReplaceDataBytes()", status,
                     SFT_PLATFORM_ERROR);
       return;
     }
     offset += kNALUHeaderLength;
     status = CMBlockBufferReplaceDataBytes(nalu.data, data, offset, nalu.size);
@@ skipping 94 matching lines @@
       FROM_HERE,
       base::Bind(&VTVideoDecodeAccelerator::FlushDone, weak_this_, type));
 }
 
 void VTVideoDecodeAccelerator::FlushDone(TaskType type) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   task_queue_.push(Task(type));
   ProcessWorkQueues();
 }
 
-void VTVideoDecodeAccelerator::Decode(const media::BitstreamBuffer& bitstream) {
+void VTVideoDecodeAccelerator::Decode(const BitstreamBuffer& bitstream) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
   if (bitstream.id() < 0) {
     DLOG(ERROR) << "Invalid bitstream, id: " << bitstream.id();
     if (base::SharedMemory::IsHandleValid(bitstream.handle()))
       base::SharedMemory::CloseHandle(bitstream.handle());
     NotifyError(INVALID_ARGUMENT, SFT_INVALID_STREAM);
     return;
   }
   DCHECK_EQ(0u, assigned_bitstream_ids_.count(bitstream.id()));
   assigned_bitstream_ids_.insert(bitstream.id());
   Frame* frame = new Frame(bitstream.id());
   pending_frames_[frame->bitstream_id] = make_linked_ptr(frame);
   decoder_thread_.task_runner()->PostTask(
       FROM_HERE, base::Bind(&VTVideoDecodeAccelerator::DecodeTask,
                             base::Unretained(this), bitstream, frame));
 }
 
 void VTVideoDecodeAccelerator::AssignPictureBuffers(
-    const std::vector<media::PictureBuffer>& pictures) {
+    const std::vector<PictureBuffer>& pictures) {
   DCHECK(gpu_thread_checker_.CalledOnValidThread());
 
-  for (const media::PictureBuffer& picture : pictures) {
+  for (const PictureBuffer& picture : pictures) {
     DCHECK(!picture_info_map_.count(picture.id()));
     assigned_picture_ids_.insert(picture.id());
     available_picture_ids_.push_back(picture.id());
     DCHECK_LE(1u, picture.internal_texture_ids().size());
     DCHECK_LE(1u, picture.texture_ids().size());
     picture_info_map_.insert(std::make_pair(
         picture.id(),
         base::WrapUnique(new PictureInfo(picture.internal_texture_ids()[0],
                                          picture.texture_ids()[0]))));
   }
@@ skipping 196 matching lines @@
   // Assign the new image(s) to the the picture info.
   picture_info->gl_image = gl_image;
   picture_info->cv_image = frame.image;
   available_picture_ids_.pop_back();
 
   // TODO(sandersd): Currently, the size got from
   // CMVideoFormatDescriptionGetDimensions is visible size. We pass it to
   // GpuVideoDecoder so that GpuVideoDecoder can use correct visible size in
   // resolution changed. We should find the correct API to get the real
   // coded size and fix it.
-  client_->PictureReady(media::Picture(picture_id, frame.bitstream_id,
-                                       gfx::Rect(frame.coded_size), true));
+  client_->PictureReady(Picture(picture_id, frame.bitstream_id,
+                                gfx::Rect(frame.coded_size), true));
   return true;
 }
 
 void VTVideoDecodeAccelerator::NotifyError(
     Error vda_error_type,
     VTVDASessionFailureType session_failure_type) {
   DCHECK_LT(session_failure_type, SFT_MAX + 1);
   if (!gpu_thread_checker_.CalledOnValidThread()) {
     gpu_task_runner_->PostTask(
         FROM_HERE,
@@ skipping 49 matching lines @@
   QueueFlush(TASK_DESTROY);
 }
 
 bool VTVideoDecodeAccelerator::TryToSetupDecodeOnSeparateThread(
     const base::WeakPtr<Client>& decode_client,
     const scoped_refptr<base::SingleThreadTaskRunner>& decode_task_runner) {
   return false;
 }
 
 // static
-media::VideoDecodeAccelerator::SupportedProfiles
+VideoDecodeAccelerator::SupportedProfiles
 VTVideoDecodeAccelerator::GetSupportedProfiles() {
   SupportedProfiles profiles;
   for (const auto& supported_profile : kSupportedProfiles) {
     SupportedProfile profile;
     profile.profile = supported_profile;
     profile.min_resolution.SetSize(16, 16);
     profile.max_resolution.SetSize(4096, 2160);
     profiles.push_back(profile);
   }
   return profiles;
 }
 
 }  // namespace media