Move H264Parser and H264BitReader to media/filters.

content/common/gpu/media/vaapi_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/stl_util.h"
@@ skipping 201 matching lines @@
     return;
   }
 
   DVLOG(4) << "POC " << poc << " no longer using VA surface "
            << it->second->va_surface()->id();
 
   decode_surfaces_in_use_.erase(it);
 }
 
 bool VaapiH264Decoder::SendPPS() {
-  const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
+  const media::H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   DCHECK(pps);
 
-  const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
+  const media::H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
   DCHECK(sps);
 
   DCHECK(curr_pic_.get());
 
   VAPictureParameterBufferH264 pic_param;
   memset(&pic_param, 0, sizeof(VAPictureParameterBufferH264));
 
 #define FROM_SPS_TO_PP(a) pic_param.a = sps->a;
 #define FROM_SPS_TO_PP2(a, b) pic_param.b = sps->a;
   FROM_SPS_TO_PP2(pic_width_in_mbs_minus1, picture_width_in_mbs_minus1);
@@ skipping 63 matching lines @@
                          arraysize(pic_param.ReferenceFrames));
 
   pic_param.num_ref_frames = sps->max_num_ref_frames;
 
   return vaapi_wrapper_->SubmitBuffer(VAPictureParameterBufferType,
                                       sizeof(VAPictureParameterBufferH264),
                                       &pic_param);
 }
 
 bool VaapiH264Decoder::SendIQMatrix() {
-  const H264PPS* pps = parser_.GetPPS(curr_pps_id_);
+  const media::H264PPS* pps = parser_.GetPPS(curr_pps_id_);
   DCHECK(pps);
 
   VAIQMatrixBufferH264 iq_matrix_buf;
   memset(&iq_matrix_buf, 0, sizeof(VAIQMatrixBufferH264));
 
   if (pps->pic_scaling_matrix_present_flag) {
     for (int i = 0; i < 6; ++i) {
       for (int j = 0; j < 16; ++j)
         iq_matrix_buf.ScalingList4x4[i][j] = pps->scaling_list4x4[i][j];
     }
 
     for (int i = 0; i < 2; ++i) {
       for (int j = 0; j < 64; ++j)
         iq_matrix_buf.ScalingList8x8[i][j] = pps->scaling_list8x8[i][j];
     }
   } else {
-    const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
+    const media::H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
     DCHECK(sps);
     for (int i = 0; i < 6; ++i) {
       for (int j = 0; j < 16; ++j)
         iq_matrix_buf.ScalingList4x4[i][j] = sps->scaling_list4x4[i][j];
     }
 
     for (int i = 0; i < 2; ++i) {
       for (int j = 0; j < 64; ++j)
         iq_matrix_buf.ScalingList8x8[i][j] = sps->scaling_list8x8[i][j];
     }
   }
 
   return vaapi_wrapper_->SubmitBuffer(VAIQMatrixBufferType,
                                       sizeof(VAIQMatrixBufferH264),
                                       &iq_matrix_buf);
 }
 
-bool VaapiH264Decoder::SendVASliceParam(H264SliceHeader* slice_hdr) {
-  const H264PPS* pps = parser_.GetPPS(slice_hdr->pic_parameter_set_id);
+bool VaapiH264Decoder::SendVASliceParam(media::H264SliceHeader* slice_hdr) {
+  const media::H264PPS* pps = parser_.GetPPS(slice_hdr->pic_parameter_set_id);
   DCHECK(pps);
 
-  const H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
+  const media::H264SPS* sps = parser_.GetSPS(pps->seq_parameter_set_id);
   DCHECK(sps);
 
   VASliceParameterBufferH264 slice_param;
   memset(&slice_param, 0, sizeof(VASliceParameterBufferH264));
 
   slice_param.slice_data_size = slice_hdr->nalu_size;
   slice_param.slice_data_offset = 0;
   slice_param.slice_data_flag = VA_SLICE_DATA_FLAG_ALL;
   slice_param.slice_data_bit_offset = slice_hdr->header_bit_size;
 
@@ skipping 74 matching lines @@
                                       &slice_param);
 }
 
 bool VaapiH264Decoder::SendSliceData(const uint8* ptr, size_t size) {
   // Can't help it, blame libva...
   void* non_const_ptr = const_cast<uint8*>(ptr);
   return vaapi_wrapper_->SubmitBuffer(VASliceDataBufferType, size,
                                       non_const_ptr);
 }
 
-bool VaapiH264Decoder::PrepareRefPicLists(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::PrepareRefPicLists(media::H264SliceHeader* slice_hdr) {
   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()) {
     ConstructReferencePicListsP(slice_hdr);
     return ModifyReferencePicList(slice_hdr, 0);
   }
 
   if (slice_hdr->IsBSlice()) {
     ConstructReferencePicListsB(slice_hdr);
     return ModifyReferencePicList(slice_hdr, 0) &&
         ModifyReferencePicList(slice_hdr, 1);
   }
 
   return true;
 }
 
-bool VaapiH264Decoder::QueueSlice(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::QueueSlice(media::H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
   if (!PrepareRefPicLists(slice_hdr))
     return false;
 
   if (!SendVASliceParam(slice_hdr))
     return false;
 
   if (!SendSliceData(slice_hdr->nalu_data, slice_hdr->nalu_size))
     return false;
@@ skipping 15 matching lines @@
 
   if (!vaapi_wrapper_->DecodeAndDestroyPendingBuffers(
       dec_surface->va_surface()->id())) {
     DVLOG(1) << "Failed decoding picture";
     return false;
   }
 
   return true;
 }
 
-
-bool VaapiH264Decoder::InitCurrPicture(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::InitCurrPicture(media::H264SliceHeader* slice_hdr) {
   DCHECK(curr_pic_.get());
 
   memset(curr_pic_.get(), 0, sizeof(H264Picture));
 
   curr_pic_->idr = slice_hdr->idr_pic_flag;
 
   if (slice_hdr->field_pic_flag) {
     curr_pic_->field = slice_hdr->bottom_field_flag ? H264Picture::FIELD_BOTTOM
                                                     : H264Picture::FIELD_TOP;
   } else {
@@ skipping 24 matching lines @@
     COMPILE_ASSERT(sizeof(curr_pic_->ref_pic_marking) ==
                    sizeof(slice_hdr->ref_pic_marking),
                    ref_pic_marking_array_sizes_do_not_match);
     memcpy(curr_pic_->ref_pic_marking, slice_hdr->ref_pic_marking,
            sizeof(curr_pic_->ref_pic_marking));
   }
 
   return true;
 }
 
-bool VaapiH264Decoder::CalculatePicOrderCounts(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::CalculatePicOrderCounts(
+    media::H264SliceHeader* slice_hdr) {
   DCHECK_NE(curr_sps_id_, -1);
-  const H264SPS* sps = parser_.GetSPS(curr_sps_id_);
+  const media::H264SPS* sps = parser_.GetSPS(curr_sps_id_);
 
   int pic_order_cnt_lsb = slice_hdr->pic_order_cnt_lsb;
   curr_pic_->pic_order_cnt_lsb = pic_order_cnt_lsb;
 
   switch (sps->pic_order_cnt_type) {
     case 0:
       // See spec 8.2.1.1.
       int prev_pic_order_cnt_msb, prev_pic_order_cnt_lsb;
       if (slice_hdr->idr_pic_flag) {
         prev_pic_order_cnt_msb = prev_pic_order_cnt_lsb = 0;
@@ skipping 186 matching lines @@
     return a->pic_num > b->pic_num;
   }
 };
 
 struct LongTermPicNumAscCompare {
   bool operator()(const H264Picture* a, const H264Picture* b) const {
     return a->long_term_pic_num < b->long_term_pic_num;
   }
 };
 
-void VaapiH264Decoder::ConstructReferencePicListsP(H264SliceHeader* slice_hdr) {
+void VaapiH264Decoder::ConstructReferencePicListsP(
+    media::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.
   DCHECK(ref_pic_list0_.empty() && ref_pic_list1_.empty());
   // First get the short ref pics...
   dpb_.GetShortTermRefPicsAppending(ref_pic_list0_);
   size_t num_short_refs = ref_pic_list0_.size();
 
   // and sort them to get [1].
   std::sort(ref_pic_list0_.begin(), ref_pic_list0_.end(), PicNumDescCompare());
@@ skipping 12 matching lines @@
     return a->pic_order_cnt < b->pic_order_cnt;
   }
 };
 
 struct POCDescCompare {
   bool operator()(const H264Picture* a, const H264Picture* b) const {
     return a->pic_order_cnt > b->pic_order_cnt;
   }
 };
 
-void VaapiH264Decoder::ConstructReferencePicListsB(H264SliceHeader* slice_hdr) {
+void VaapiH264Decoder::ConstructReferencePicListsB(
+    media::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.
   DCHECK(ref_pic_list0_.empty() && ref_pic_list1_.empty());
   dpb_.GetShortTermRefPicsAppending(ref_pic_list0_);
   size_t num_short_refs = ref_pic_list0_.size();
 
   // First sort ascending, this will put [1] in right place and finish [2].
   std::sort(ref_pic_list0_.begin(), ref_pic_list0_.end(), POCAscCompare());
@@ skipping 82 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 VaapiH264Decoder::ModifyReferencePicList(H264SliceHeader *slice_hdr,
+bool VaapiH264Decoder::ModifyReferencePicList(media::H264SliceHeader* slice_hdr,
                                               int list) {
   int num_ref_idx_lX_active_minus1;
   H264Picture::PtrVector* ref_pic_listx;
-  H264ModificationOfPicNum* list_mod;
+  media::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) {
     if (!slice_hdr->ref_pic_list_modification_flag_l0)
       return true;
 
     list_mod = slice_hdr->ref_list_l0_modifications;
     num_ref_idx_lX_active_minus1 = ref_pic_list0_.size() - 1;
 
@@ skipping 11 matching lines @@
   DCHECK_GE(num_ref_idx_lX_active_minus1, 0);
 
   // 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;
   H264Picture* pic;
-  for (int i = 0; i < H264SliceHeader::kRefListModSize && !done; ++i) {
+  for (int i = 0; i < media::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
           // of subtraction.
@@ skipping 11 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,
-                  H264SliceHeader::kRefListModSize);
+                  media::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,
-                  H264SliceHeader::kRefListModSize);
+                  media::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 79 matching lines @@
 
   if (!OutputAllRemainingPics())
     return false;
 
   ClearDPB();
 
   DCHECK(decode_surfaces_in_use_.empty());
   return true;
 }
 
-bool VaapiH264Decoder::StartNewFrame(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::StartNewFrame(media::H264SliceHeader* slice_hdr) {
   // TODO posciak: add handling of max_num_ref_frames per spec.
 
   // If the new frame is an IDR, output what's left to output and clear DPB
   if (slice_hdr->idr_pic_flag) {
     // (unless we are explicitly instructed not to do so).
     if (!slice_hdr->no_output_of_prior_pics_flag) {
       // Output DPB contents.
       if (!Flush())
         return false;
     }
@@ skipping 25 matching lines @@
   if (!QueueSlice(slice_hdr))
     return false;
 
   return true;
 }
 
 bool VaapiH264Decoder::HandleMemoryManagementOps() {
   // 8.2.5.4
   for (unsigned int i = 0; i < arraysize(curr_pic_->ref_pic_marking); ++i) {
     // Code below does not support interlaced stream (per-field pictures).
-    H264DecRefPicMarking* ref_pic_marking = &curr_pic_->ref_pic_marking[i];
+    media::H264DecRefPicMarking* ref_pic_marking =
+        &curr_pic_->ref_pic_marking[i];
     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 256 matching lines @@
     case 50: return 110400;
     case 51: //  fallthrough
     case 52: return 184320;
     default:
       DVLOG(1) << "Invalid codec level (" << level << ")";
       return 0;
   }
 }
 
 bool VaapiH264Decoder::ProcessSPS(int sps_id, bool* need_new_buffers) {
-  const H264SPS* sps = parser_.GetSPS(sps_id);
+  const media::H264SPS* sps = parser_.GetSPS(sps_id);
   DCHECK(sps);
   DVLOG(4) << "Processing SPS";
 
   *need_new_buffers = false;
 
   if (sps->frame_mbs_only_flag == 0) {
     DVLOG(1) << "frame_mbs_only_flag != 1 not supported";
     report_error_to_uma_cb_.Run(FRAME_MBS_ONLY_FLAG_NOT_ONE);
     return false;
   }
@@ skipping 43 matching lines @@
     return false;
   }
 
   dpb_.set_max_num_pics(max_dpb_size);
 
   *need_new_buffers = true;
   return true;
 }
 
 bool VaapiH264Decoder::ProcessPPS(int pps_id) {
-  const H264PPS* pps = parser_.GetPPS(pps_id);
+  const media::H264PPS* pps = parser_.GetPPS(pps_id);
   DCHECK(pps);
 
   curr_pps_id_ = pps->pic_parameter_set_id;
 
   return true;
 }
 
 bool VaapiH264Decoder::FinishPrevFrameIfPresent() {
   // If we already have a frame waiting to be decoded, decode it and finish.
   if (curr_pic_ != NULL) {
     if (!DecodePicture())
       return false;
     return FinishPicture();
   }
 
   return true;
 }
 
-bool VaapiH264Decoder::ProcessSlice(H264SliceHeader* slice_hdr) {
+bool VaapiH264Decoder::ProcessSlice(media::H264SliceHeader* slice_hdr) {
   prev_frame_num_ = frame_num_;
   frame_num_ = slice_hdr->frame_num;
 
   if (prev_frame_num_ > 0 && prev_frame_num_ < frame_num_ - 1) {
     DVLOG(1) << "Gap in frame_num!";
     report_error_to_uma_cb_.Run(GAPS_IN_FRAME_NUM);
     return false;
   }
 
   if (slice_hdr->field_pic_flag == 0)
@@ skipping 29 matching lines @@
   DCHECK(size);
 
   // Got new input stream data from the client.
   DVLOG(4) << "New input stream id: " << input_id << " at: " << (void*) ptr
            << " size:  " << size;
   parser_.SetStream(ptr, size);
   curr_input_id_ = input_id;
 }
 
 VaapiH264Decoder::DecResult VaapiH264Decoder::Decode() {
-  H264Parser::Result par_res;
-  H264NALU nalu;
+  media::H264Parser::Result par_res;
+  media::H264NALU nalu;
   DCHECK_NE(state_, kError);
 
   while (1) {
     // If we've already decoded some of the stream (after reset, i.e. we are
     // not in kNeedStreamMetadata state), we may be able to go back into
     // decoding state not only starting at/resuming from an SPS, but also from
     // other resume points, such as IDRs. In the latter case we need an output
     // surface, because we will end up decoding that IDR in the process.
     // Otherwise we just look for an SPS and don't produce any output frames.
     if (state_ != kNeedStreamMetadata && available_va_surfaces_.empty()) {
       DVLOG(4) << "No output surfaces available";
       return kRanOutOfSurfaces;
     }
 
     par_res = parser_.AdvanceToNextNALU(&nalu);
-    if (par_res == H264Parser::kEOStream)
+    if (par_res == media::H264Parser::kEOStream)
       return kRanOutOfStreamData;
-    else if (par_res != H264Parser::kOk)
+    else if (par_res != media::H264Parser::kOk)
       SET_ERROR_AND_RETURN();
 
     DVLOG(4) << "NALU found: " << static_cast<int>(nalu.nal_unit_type);
 
     switch (nalu.nal_unit_type) {
-      case H264NALU::kNonIDRSlice:
+      case media::H264NALU::kNonIDRSlice:
         // We can't resume from a non-IDR slice.
         if (state_ != kDecoding)
           break;
         // else fallthrough
-      case H264NALU::kIDRSlice: {
+      case media::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.
-        H264SliceHeader slice_hdr;
+        media::H264SliceHeader slice_hdr;
 
         par_res = parser_.ParseSliceHeader(nalu, &slice_hdr);
-        if (par_res != H264Parser::kOk)
+        if (par_res != media::H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         if (!ProcessSlice(&slice_hdr))
           SET_ERROR_AND_RETURN();
 
         state_ = kDecoding;
         break;
       }
 
-      case H264NALU::kSPS: {
+      case media::H264NALU::kSPS: {
         int sps_id;
 
         if (!FinishPrevFrameIfPresent())
           SET_ERROR_AND_RETURN();
 
         par_res = parser_.ParseSPS(&sps_id);
-        if (par_res != H264Parser::kOk)
+        if (par_res != media::H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         bool need_new_buffers = false;
         if (!ProcessSPS(sps_id, &need_new_buffers))
           SET_ERROR_AND_RETURN();
 
         state_ = kDecoding;
 
         if (need_new_buffers) {
           if (!Flush())
             return kDecodeError;
 
           available_va_surfaces_.clear();
           return kAllocateNewSurfaces;
         }
         break;
       }
 
-      case H264NALU::kPPS: {
+      case media::H264NALU::kPPS: {
         if (state_ != kDecoding)
           break;
 
         int pps_id;
 
         if (!FinishPrevFrameIfPresent())
           SET_ERROR_AND_RETURN();
 
         par_res = parser_.ParsePPS(&pps_id);
-        if (par_res != H264Parser::kOk)
+        if (par_res != media::H264Parser::kOk)
           SET_ERROR_AND_RETURN();
 
         if (!ProcessPPS(pps_id))
           SET_ERROR_AND_RETURN();
         break;
       }
 
       default:
         DVLOG(4) << "Skipping NALU type: " << nalu.nal_unit_type;;
         break;
     }
   }
 }
 
 size_t VaapiH264Decoder::GetRequiredNumOfPictures() {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
 }  // namespace content