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

media/gpu/h264_decoder.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.
 
 #include <algorithm>
 #include <limits>
 
 #include "base/bind.h"
 #include "base/bind_helpers.h"
 #include "base/callback_helpers.h"
@@ skipping 45 matching lines @@
   dpb_.Clear();
   parser_.Reset();
   accelerator_->Reset();
   last_output_poc_ = std::numeric_limits<int>::min();
 
   // If we are in kDecoding, we can resume without processing an SPS.
   if (state_ == kDecoding)
     state_ = kAfterReset;
 }
 
-void H264Decoder::PrepareRefPicLists(const media::H264SliceHeader* slice_hdr) {
+void H264Decoder::PrepareRefPicLists(const H264SliceHeader* slice_hdr) {
   ConstructReferencePicListsP(slice_hdr);
   ConstructReferencePicListsB(slice_hdr);
 }
 
-bool H264Decoder::ModifyReferencePicLists(
-    const media::H264SliceHeader* slice_hdr,
-    H264Picture::Vector* ref_pic_list0,
-    H264Picture::Vector* ref_pic_list1) {
+bool H264Decoder::ModifyReferencePicLists(const H264SliceHeader* slice_hdr,
+                                          H264Picture::Vector* ref_pic_list0,
+                                          H264Picture::Vector* ref_pic_list1) {
   ref_pic_list0->clear();
   ref_pic_list1->clear();
 
   // Fill reference picture lists for B and S/SP slices.
   if (slice_hdr->IsPSlice() || slice_hdr->IsSPSlice()) {
     *ref_pic_list0 = ref_pic_list_p0_;
     return ModifyReferencePicList(slice_hdr, 0, ref_pic_list0);
   } else if (slice_hdr->IsBSlice()) {
     *ref_pic_list0 = ref_pic_list_b0_;
     *ref_pic_list1 = ref_pic_list_b1_;
@@ skipping 17 matching lines @@
   pic->nal_ref_idc = 1;
   pic->frame_num = pic->pic_num = frame_num;
   pic->adaptive_ref_pic_marking_mode_flag = false;
   pic->ref = true;
   pic->long_term_reference_flag = false;
   pic->field = H264Picture::FIELD_NONE;
 
   return CalculatePicOrderCounts(pic);
 }
 
-bool H264Decoder::InitCurrPicture(const media::H264SliceHeader* slice_hdr) {
+bool H264Decoder::InitCurrPicture(const H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
   curr_pic_->idr = slice_hdr->idr_pic_flag;
   if (curr_pic_->idr)
     curr_pic_->idr_pic_id = slice_hdr->idr_pic_id;
 
   if (slice_hdr->field_pic_flag) {
     curr_pic_->field = slice_hdr->bottom_field_flag ? H264Picture::FIELD_BOTTOM
                                                     : H264Picture::FIELD_TOP;
   } else {
     curr_pic_->field = H264Picture::FIELD_NONE;
   }
 
   if (curr_pic_->field != H264Picture::FIELD_NONE) {
     DVLOG(1) << "Interlaced video not supported.";
     return false;
   }
 
   curr_pic_->nal_ref_idc = slice_hdr->nal_ref_idc;
   curr_pic_->ref = slice_hdr->nal_ref_idc != 0;
   // This assumes non-interlaced stream.
   curr_pic_->frame_num = curr_pic_->pic_num = slice_hdr->frame_num;
 
   DCHECK_NE(curr_sps_id_, -1);
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   curr_pic_->pic_order_cnt_type = sps->pic_order_cnt_type;
   switch (curr_pic_->pic_order_cnt_type) {
     case 0:
       curr_pic_->pic_order_cnt_lsb = slice_hdr->pic_order_cnt_lsb;
       curr_pic_->delta_pic_order_cnt_bottom =
           slice_hdr->delta_pic_order_cnt_bottom;
       break;
@@ skipping 26 matching lines @@
                       sizeof(slice_hdr->ref_pic_marking),
                   "Array sizes of ref pic marking do not match.");
     memcpy(curr_pic_->ref_pic_marking, slice_hdr->ref_pic_marking,
            sizeof(curr_pic_->ref_pic_marking));
   }
 
   return true;
 }
 
 bool H264Decoder::CalculatePicOrderCounts(scoped_refptr<H264Picture> pic) {
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   switch (pic->pic_order_cnt_type) {
     case 0: {
       // See spec 8.2.1.1.
       int prev_pic_order_cnt_msb, prev_pic_order_cnt_lsb;
 
       if (pic->idr) {
         prev_pic_order_cnt_msb = prev_pic_order_cnt_lsb = 0;
@@ skipping 186 matching lines @@
 };
 
 struct LongTermPicNumAscCompare {
   bool operator()(const scoped_refptr<H264Picture>& a,
                   const scoped_refptr<H264Picture>& b) const {
     return a->long_term_pic_num < b->long_term_pic_num;
   }
 };
 
 void H264Decoder::ConstructReferencePicListsP(
-    const media::H264SliceHeader* slice_hdr) {
+    const H264SliceHeader* slice_hdr) {
   // RefPicList0 (8.2.4.2.1) [[1] [2]], where:
   // [1] shortterm ref pics sorted by descending pic_num,
   // [2] longterm ref pics by ascending long_term_pic_num.
   ref_pic_list_p0_.clear();
 
   // First get the short ref pics...
   dpb_.GetShortTermRefPicsAppending(&ref_pic_list_p0_);
   size_t num_short_refs = ref_pic_list_p0_.size();
 
   // and sort them to get [1].
@@ skipping 14 matching lines @@
 };
 
 struct POCDescCompare {
   bool operator()(const scoped_refptr<H264Picture>& a,
                   const scoped_refptr<H264Picture>& b) const {
     return a->pic_order_cnt > b->pic_order_cnt;
   }
 };
 
 void H264Decoder::ConstructReferencePicListsB(
-    const media::H264SliceHeader* slice_hdr) {
+    const H264SliceHeader* slice_hdr) {
   // RefPicList0 (8.2.4.2.3) [[1] [2] [3]], where:
   // [1] shortterm ref pics with POC < curr_pic's POC sorted by descending POC,
   // [2] shortterm ref pics with POC > curr_pic's POC by ascending POC,
   // [3] longterm ref pics by ascending long_term_pic_num.
   ref_pic_list_b0_.clear();
   ref_pic_list_b1_.clear();
   dpb_.GetShortTermRefPicsAppending(&ref_pic_list_b0_);
   size_t num_short_refs = ref_pic_list_b0_.size();
 
   // First sort ascending, this will put [1] in right place and finish [2].
@@ skipping 77 matching lines @@
          (to + 2 == static_cast<int>(v->size())));
 
   v->resize(to + 2);
 
   for (int i = to + 1; i > from; --i)
     (*v)[i] = (*v)[i - 1];
 
   (*v)[from] = pic;
 }
 
-bool H264Decoder::ModifyReferencePicList(
-    const media::H264SliceHeader* slice_hdr,
-    int list,
-    H264Picture::Vector* ref_pic_listx) {
+bool H264Decoder::ModifyReferencePicList(const H264SliceHeader* slice_hdr,
+                                         int list,
+                                         H264Picture::Vector* ref_pic_listx) {
   bool ref_pic_list_modification_flag_lX;
   int num_ref_idx_lX_active_minus1;
-  const media::H264ModificationOfPicNum* list_mod;
+  const H264ModificationOfPicNum* list_mod;
 
   // This can process either ref_pic_list0 or ref_pic_list1, depending on
   // the list argument. Set up pointers to proper list to be processed here.
   if (list == 0) {
     ref_pic_list_modification_flag_lX =
         slice_hdr->ref_pic_list_modification_flag_l0;
     num_ref_idx_lX_active_minus1 = slice_hdr->num_ref_idx_l0_active_minus1;
     list_mod = slice_hdr->ref_list_l0_modifications;
   } else {
     ref_pic_list_modification_flag_lX =
@@ skipping 14 matching lines @@
     return true;
 
   // Spec 8.2.4.3:
   // Reorder pictures on the list in a way specified in the stream.
   int pic_num_lx_pred = curr_pic_->pic_num;
   int ref_idx_lx = 0;
   int pic_num_lx_no_wrap;
   int pic_num_lx;
   bool done = false;
   scoped_refptr<H264Picture> pic;
-  for (int i = 0; i < media::H264SliceHeader::kRefListModSize && !done; ++i) {
+  for (int i = 0; i < H264SliceHeader::kRefListModSize && !done; ++i) {
     switch (list_mod->modification_of_pic_nums_idc) {
       case 0:
       case 1:
         // Modify short reference picture position.
         if (list_mod->modification_of_pic_nums_idc == 0) {
           // Subtract given value from predicted PicNum.
           pic_num_lx_no_wrap =
               pic_num_lx_pred -
               (static_cast<int>(list_mod->abs_diff_pic_num_minus1) + 1);
           // Wrap around max_pic_num_ if it becomes < 0 as result
@@ skipping 13 matching lines @@
 
         // For use in next iteration.
         pic_num_lx_pred = pic_num_lx_no_wrap;
 
         if (pic_num_lx_no_wrap > curr_pic_->pic_num)
           pic_num_lx = pic_num_lx_no_wrap - max_pic_num_;
         else
           pic_num_lx = pic_num_lx_no_wrap;
 
         DCHECK_LT(num_ref_idx_lX_active_minus1 + 1,
-                  media::H264SliceHeader::kRefListModSize);
+                  H264SliceHeader::kRefListModSize);
         pic = dpb_.GetShortRefPicByPicNum(pic_num_lx);
         if (!pic) {
           DVLOG(1) << "Malformed stream, no pic num " << pic_num_lx;
           return false;
         }
         ShiftRightAndInsert(ref_pic_listx, ref_idx_lx,
                             num_ref_idx_lX_active_minus1, pic);
         ref_idx_lx++;
 
         for (int src = ref_idx_lx, dst = ref_idx_lx;
              src <= num_ref_idx_lX_active_minus1 + 1; ++src) {
           if (PicNumF((*ref_pic_listx)[src]) != pic_num_lx)
             (*ref_pic_listx)[dst++] = (*ref_pic_listx)[src];
         }
         break;
 
       case 2:
         // Modify long term reference picture position.
         DCHECK_LT(num_ref_idx_lX_active_minus1 + 1,
-                  media::H264SliceHeader::kRefListModSize);
+                  H264SliceHeader::kRefListModSize);
         pic = dpb_.GetLongRefPicByLongTermPicNum(list_mod->long_term_pic_num);
         if (!pic) {
           DVLOG(1) << "Malformed stream, no pic num "
                    << list_mod->long_term_pic_num;
           return false;
         }
         ShiftRightAndInsert(ref_pic_listx, ref_idx_lx,
                             num_ref_idx_lX_active_minus1, pic);
         ref_idx_lx++;
 
@@ skipping 71 matching lines @@
   DVLOG(2) << "Decoder flush";
 
   if (!OutputAllRemainingPics())
     return false;
 
   ClearDPB();
   DVLOG(2) << "Decoder flush finished";
   return true;
 }
 
-bool H264Decoder::StartNewFrame(const media::H264SliceHeader* slice_hdr) {
+bool H264Decoder::StartNewFrame(const H264SliceHeader* slice_hdr) {
   // TODO posciak: add handling of max_num_ref_frames per spec.
   CHECK(curr_pic_.get());
   DCHECK(slice_hdr);
 
   curr_pps_id_ = slice_hdr->pic_parameter_set_id;
-  const media::H264PPS* pps = parser_.GetPPS(curr_pps_id_);
+  const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   if (!pps)
     return false;
 
   curr_sps_id_ = pps->seq_parameter_set_id;
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   max_frame_num_ = 1 << (sps->log2_max_frame_num_minus4 + 4);
   int frame_num = slice_hdr->frame_num;
   if (slice_hdr->idr_pic_flag)
     prev_ref_frame_num_ = 0;
 
   // 7.4.3
   if (frame_num != prev_ref_frame_num_ &&
@@ skipping 13 matching lines @@
                                          curr_pic_.get()))
     return false;
 
   return true;
 }
 
 bool H264Decoder::HandleMemoryManagementOps(scoped_refptr<H264Picture> pic) {
   // 8.2.5.4
   for (size_t i = 0; i < arraysize(pic->ref_pic_marking); ++i) {
     // Code below does not support interlaced stream (per-field pictures).
-    media::H264DecRefPicMarking* ref_pic_marking = &pic->ref_pic_marking[i];
+    H264DecRefPicMarking* ref_pic_marking = &pic->ref_pic_marking[i];
     scoped_refptr<H264Picture> to_mark;
     int pic_num_x;
 
     switch (ref_pic_marking->memory_mgmnt_control_operation) {
       case 0:
         // Normal end of operations' specification.
         return true;
 
       case 1:
         // Mark a short term reference picture as unused so it can be removed
@@ skipping 118 matching lines @@
   // Otherwise, fall back to default sliding window process.
   if (pic->adaptive_ref_pic_marking_mode_flag) {
     DCHECK(!pic->nonexisting);
     return HandleMemoryManagementOps(pic);
   } else {
     return SlidingWindowPictureMarking();
   }
 }
 
 bool H264Decoder::SlidingWindowPictureMarking() {
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   // 8.2.5.3. Ensure the DPB doesn't overflow by discarding the oldest picture.
   int num_ref_pics = dpb_.CountRefPics();
   DCHECK_LE(num_ref_pics, std::max<int>(sps->max_num_ref_frames, 1));
   if (num_ref_pics == std::max<int>(sps->max_num_ref_frames, 1)) {
     // Max number of reference pics reached, need to remove one of the short
     // term ones. Find smallest frame_num_wrap short reference picture and mark
     // it as unused.
@@ skipping 124 matching lines @@
       return 110400;
     case 51:  //  fallthrough
     case 52:
       return 184320;
     default:
       DVLOG(1) << "Invalid codec level (" << level << ")";
       return 0;
   }
 }
 
-bool H264Decoder::UpdateMaxNumReorderFrames(const media::H264SPS* sps) {
+bool H264Decoder::UpdateMaxNumReorderFrames(const H264SPS* sps) {
   if (sps->vui_parameters_present_flag && sps->bitstream_restriction_flag) {
     max_num_reorder_frames_ =
         base::checked_cast<size_t>(sps->max_num_reorder_frames);
     if (max_num_reorder_frames_ > dpb_.max_num_pics()) {
       DVLOG(1)
           << "max_num_reorder_frames present, but larger than MaxDpbFrames ("
           << max_num_reorder_frames_ << " > " << dpb_.max_num_pics() << ")";
       max_num_reorder_frames_ = 0;
       return false;
     }
@@ skipping 19 matching lines @@
   } else {
     max_num_reorder_frames_ = dpb_.max_num_pics();
   }
 
   return true;
 }
 
 bool H264Decoder::ProcessSPS(int sps_id, bool* need_new_buffers) {
   DVLOG(4) << "Processing SPS id:" << sps_id;
 
-  const media::H264SPS* sps = parser_.GetSPS(sps_id);
+  const H264SPS* sps = parser_.GetSPS(sps_id);
   if (!sps)
     return false;
 
   *need_new_buffers = false;
 
   if (sps->frame_mbs_only_flag == 0) {
     DVLOG(1) << "frame_mbs_only_flag != 1 not supported";
     return false;
   }
 
@@ skipping 56 matching lines @@
 
     scoped_refptr<H264Picture> pic = curr_pic_;
     curr_pic_ = nullptr;
     return FinishPicture(pic);
   }
 
   return true;
 }
 
 bool H264Decoder::HandleFrameNumGap(int frame_num) {
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   if (!sps->gaps_in_frame_num_value_allowed_flag) {
     DVLOG(1) << "Invalid frame_num: " << frame_num;
     return false;
   }
 
   DVLOG(2) << "Handling frame_num gap: " << prev_ref_frame_num_ << "->"
            << frame_num;
@@ skipping 11 matching lines @@
       return false;
 
     unused_short_term_frame_num++;
     unused_short_term_frame_num %= max_frame_num_;
   }
 
   return true;
 }
 
 bool H264Decoder::IsNewPrimaryCodedPicture(
-    const media::H264SliceHeader* slice_hdr) const {
+    const H264SliceHeader* slice_hdr) const {
   if (!curr_pic_)
     return true;
 
   // 7.4.1.2.4, assumes non-interlaced.
   if (slice_hdr->frame_num != curr_pic_->frame_num ||
       slice_hdr->pic_parameter_set_id != curr_pps_id_ ||
       slice_hdr->nal_ref_idc != curr_pic_->nal_ref_idc ||
       slice_hdr->idr_pic_flag != curr_pic_->idr ||
       (slice_hdr->idr_pic_flag &&
        (slice_hdr->idr_pic_id != curr_pic_->idr_pic_id ||
         // If we have two consecutive IDR slices, and the second one has
         // first_mb_in_slice == 0, treat it as a new picture.
         // Per spec, idr_pic_id should not be equal in this case (and we should
         // have hit the condition above instead, see spec 7.4.3 on idr_pic_id),
         // but some encoders neglect changing idr_pic_id for two consecutive
         // IDRs. Work around this by checking if the next slice contains the
         // zeroth macroblock, i.e. data that belongs to the next picture.
         slice_hdr->first_mb_in_slice == 0)))
     return true;
 
-  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
   if (!sps)
     return false;
 
   if (sps->pic_order_cnt_type == curr_pic_->pic_order_cnt_type) {
     if (curr_pic_->pic_order_cnt_type == 0) {
       if (slice_hdr->pic_order_cnt_lsb != curr_pic_->pic_order_cnt_lsb ||
           slice_hdr->delta_pic_order_cnt_bottom !=
               curr_pic_->delta_pic_order_cnt_bottom)
         return true;
     } else if (curr_pic_->pic_order_cnt_type == 1) {
       if (slice_hdr->delta_pic_order_cnt0 != curr_pic_->delta_pic_order_cnt0 ||
           slice_hdr->delta_pic_order_cnt1 != curr_pic_->delta_pic_order_cnt1)
         return true;
     }
   }
 
   return false;
 }
 
 bool H264Decoder::PreprocessCurrentSlice() {
-  const media::H264SliceHeader* slice_hdr = curr_slice_hdr_.get();
+  const H264SliceHeader* slice_hdr = curr_slice_hdr_.get();
   DCHECK(slice_hdr);
 
   if (IsNewPrimaryCodedPicture(slice_hdr)) {
     // New picture, so first finish the previous one before processing it.
     if (!FinishPrevFrameIfPresent())
       return false;
 
     DCHECK(!curr_pic_);
 
     if (slice_hdr->first_mb_in_slice != 0) {
@@ skipping 14 matching lines @@
       last_output_poc_ = std::numeric_limits<int>::min();
     }
   }
 
   return true;
 }
 
 bool H264Decoder::ProcessCurrentSlice() {
   DCHECK(curr_pic_);
 
-  const media::H264SliceHeader* slice_hdr = curr_slice_hdr_.get();
+  const H264SliceHeader* slice_hdr = curr_slice_hdr_.get();
   DCHECK(slice_hdr);
 
   if (slice_hdr->field_pic_flag == 0)
     max_pic_num_ = max_frame_num_;
   else
     max_pic_num_ = 2 * max_frame_num_;
 
   H264Picture::Vector ref_pic_list0, ref_pic_list1;
   if (!ModifyReferencePicLists(slice_hdr, &ref_pic_list0, &ref_pic_list1))
     return false;
 
-  const media::H264PPS* pps = parser_.GetPPS(curr_pps_id_);
+  const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   if (!pps)
     return false;
 
   if (!accelerator_->SubmitSlice(pps, slice_hdr, ref_pic_list0, ref_pic_list1,
                                  curr_pic_.get(), slice_hdr->nalu_data,
                                  slice_hdr->nalu_size))
     return false;
 
   return true;
 }
@@ skipping 13 matching lines @@
   parser_.SetStream(ptr, size);
 }
 
 H264Decoder::DecodeResult H264Decoder::Decode() {
   if (state_ == kError) {
     DVLOG(1) << "Decoder in error state";
     return kDecodeError;
   }
 
   while (1) {
-    media::H264Parser::Result par_res;
+    H264Parser::Result par_res;
 
     if (!curr_nalu_) {
-      curr_nalu_.reset(new media::H264NALU());
+      curr_nalu_.reset(new H264NALU());
       par_res = parser_.AdvanceToNextNALU(curr_nalu_.get());
-      if (par_res == media::H264Parser::kEOStream)
+      if (par_res == H264Parser::kEOStream)
         return kRanOutOfStreamData;
-      else if (par_res != media::H264Parser::kOk)
+      else if (par_res != H264Parser::kOk)
         SET_ERROR_AND_RETURN();
 
       DVLOG(4) << "New NALU: " << static_cast<int>(curr_nalu_->nal_unit_type);
     }
 
     switch (curr_nalu_->nal_unit_type) {
-      case media::H264NALU::kNonIDRSlice:
+      case H264NALU::kNonIDRSlice:
         // We can't resume from a non-IDR slice.
         if (state_ != kDecoding)
           break;
-        // else fallthrough
-      case media::H264NALU::kIDRSlice: {
+
+      // else fallthrough
+      case H264NALU::kIDRSlice: {
         // TODO(posciak): the IDR may require an SPS that we don't have
         // available. For now we'd fail if that happens, but ideally we'd like
         // to keep going until the next SPS in the stream.
         if (state_ == kNeedStreamMetadata) {
           // We need an SPS, skip this IDR and keep looking.
           break;
         }
 
         // If after reset, we should be able to recover from an IDR.
         state_ = kDecoding;
 
         if (!curr_slice_hdr_) {
-          curr_slice_hdr_.reset(new media::H264SliceHeader());
+          curr_slice_hdr_.reset(new H264SliceHeader());
           par_res =
               parser_.ParseSliceHeader(*curr_nalu_, curr_slice_hdr_.get());
-          if (par_res != media::H264Parser::kOk)
+          if (par_res != H264Parser::kOk)
             SET_ERROR_AND_RETURN();
 
           if (!PreprocessCurrentSlice())
             SET_ERROR_AND_RETURN();
         }
 
         if (!curr_pic_) {
           // New picture/finished previous one, try to start a new one
           // or tell the client we need more surfaces.
           curr_pic_ = accelerator_->CreateH264Picture();
           if (!curr_pic_)
             return kRanOutOfSurfaces;
 
           if (!StartNewFrame(curr_slice_hdr_.get()))
             SET_ERROR_AND_RETURN();
         }
 
         if (!ProcessCurrentSlice())
           SET_ERROR_AND_RETURN();
 
         curr_slice_hdr_.reset();
         break;
       }
 
-      case media::H264NALU::kSPS: {
+      case H264NALU::kSPS: {
         int sps_id;
 
         if (!FinishPrevFrameIfPresent())
           SET_ERROR_AND_RETURN();
 
         par_res = parser_.ParseSPS(&sps_id);
-        if (par_res != media::H264Parser::kOk)
+        if (par_res != H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         bool need_new_buffers = false;
         if (!ProcessSPS(sps_id, &need_new_buffers))
           SET_ERROR_AND_RETURN();
 
         if (state_ == kNeedStreamMetadata)
           state_ = kAfterReset;
 
         if (need_new_buffers) {
           if (!Flush())
             return kDecodeError;
 
           curr_pic_ = nullptr;
           curr_nalu_ = nullptr;
           ref_pic_list_p0_.clear();
           ref_pic_list_b0_.clear();
           ref_pic_list_b1_.clear();
 
           return kAllocateNewSurfaces;
         }
         break;
       }
 
-      case media::H264NALU::kPPS: {
+      case H264NALU::kPPS: {
         int pps_id;
 
         if (!FinishPrevFrameIfPresent())
           SET_ERROR_AND_RETURN();
 
         par_res = parser_.ParsePPS(&pps_id);
-        if (par_res != media::H264Parser::kOk)
+        if (par_res != H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         break;
       }
 
-      case media::H264NALU::kAUD:
-      case media::H264NALU::kEOSeq:
-      case media::H264NALU::kEOStream:
+      case H264NALU::kAUD:
+      case H264NALU::kEOSeq:
+      case H264NALU::kEOStream:
         if (state_ != kDecoding)
           break;
 
         if (!FinishPrevFrameIfPresent())
           SET_ERROR_AND_RETURN();
 
         break;
 
       default:
         DVLOG(4) << "Skipping NALU type: " << curr_nalu_->nal_unit_type;
         break;
     }
 
     DVLOG(4) << "NALU done";
     curr_nalu_.reset();
   }
 }
 
 gfx::Size H264Decoder::GetPicSize() const {
   return pic_size_;
 }
 
 size_t H264Decoder::GetRequiredNumOfPictures() const {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
 }  // namespace media