Test X11 header pollution

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"
 #include "base/macros.h"
 #include "base/numerics/safe_conversions.h"
 #include "base/stl_util.h"
-#include "content/common/gpu/media/h264_decoder.h"
+#include "media/gpu/h264_decoder.h"
 
-namespace content {
+namespace media {
 
-H264Decoder::H264Accelerator::H264Accelerator() {
-}
+H264Decoder::H264Accelerator::H264Accelerator() {}
 
-H264Decoder::H264Accelerator::~H264Accelerator() {
-}
+H264Decoder::H264Accelerator::~H264Accelerator() {}
 
 H264Decoder::H264Decoder(H264Accelerator* accelerator)
     : max_frame_num_(0),
       max_pic_num_(0),
       max_long_term_frame_idx_(0),
       max_num_reorder_frames_(0),
       accelerator_(accelerator) {
   DCHECK(accelerator_);
   Reset();
   state_ = kNeedStreamMetadata;
 }
 
-H264Decoder::~H264Decoder() {
-}
+H264Decoder::~H264Decoder() {}
 
 void H264Decoder::Reset() {
   curr_pic_ = nullptr;
   curr_nalu_ = nullptr;
   curr_slice_hdr_ = nullptr;
   curr_sps_id_ = -1;
   curr_pps_id_ = -1;
 
   prev_frame_num_ = -1;
   prev_ref_frame_num_ = -1;
@@ skipping 120 matching lines @@
 
   curr_pic_->long_term_reference_flag = slice_hdr->long_term_reference_flag;
   curr_pic_->adaptive_ref_pic_marking_mode_flag =
       slice_hdr->adaptive_ref_pic_marking_mode_flag;
 
   // If the slice header indicates we will have to perform reference marking
   // process after this picture is decoded, store required data for that
   // purpose.
   if (slice_hdr->adaptive_ref_pic_marking_mode_flag) {
     static_assert(sizeof(curr_pic_->ref_pic_marking) ==
-                  sizeof(slice_hdr->ref_pic_marking),
+                      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_);
@@ skipping 76 matching lines @@
         --abs_frame_num;
 
       int expected_pic_order_cnt = 0;
       if (abs_frame_num > 0) {
         if (sps->num_ref_frames_in_pic_order_cnt_cycle == 0) {
           DVLOG(1) << "Invalid num_ref_frames_in_pic_order_cnt_cycle "
                    << "in stream";
           return false;
         }
 
-        int pic_order_cnt_cycle_cnt = (abs_frame_num - 1) /
-            sps->num_ref_frames_in_pic_order_cnt_cycle;
-        int frame_num_in_pic_order_cnt_cycle = (abs_frame_num - 1) %
-            sps->num_ref_frames_in_pic_order_cnt_cycle;
+        int pic_order_cnt_cycle_cnt =
+            (abs_frame_num - 1) / sps->num_ref_frames_in_pic_order_cnt_cycle;
+        int frame_num_in_pic_order_cnt_cycle =
+            (abs_frame_num - 1) % sps->num_ref_frames_in_pic_order_cnt_cycle;
 
         expected_pic_order_cnt = pic_order_cnt_cycle_cnt *
-            sps->expected_delta_per_pic_order_cnt_cycle;
+                                 sps->expected_delta_per_pic_order_cnt_cycle;
         // frame_num_in_pic_order_cnt_cycle is verified < 255 in parser
         for (int i = 0; i <= frame_num_in_pic_order_cnt_cycle; ++i)
           expected_pic_order_cnt += sps->offset_for_ref_frame[i];
       }
 
       if (!pic->nal_ref_idc)
         expected_pic_order_cnt += sps->offset_for_non_ref_pic;
 
       if (pic->field == H264Picture::FIELD_NONE) {
         pic->top_field_order_cnt =
@@ skipping 239 matching lines @@
     H264Picture::Vector* ref_pic_listx) {
   bool ref_pic_list_modification_flag_lX;
   int num_ref_idx_lX_active_minus1;
   const 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) {
     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;
+    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 =
         slice_hdr->ref_pic_list_modification_flag_l1;
-    num_ref_idx_lX_active_minus1 =
-        slice_hdr->num_ref_idx_l1_active_minus1;
+    num_ref_idx_lX_active_minus1 = slice_hdr->num_ref_idx_l1_active_minus1;
     list_mod = slice_hdr->ref_list_l1_modifications;
   }
 
   // Resize the list to the size requested in the slice header.
   // Note that per 8.2.4.2 it's possible for num_ref_idx_lX_active_minus1 to
   // indicate there should be more ref pics on list than we constructed.
   // Those superfluous ones should be treated as non-reference and will be
   // initialized to nullptr, which must be handled by clients.
   DCHECK_GE(num_ref_idx_lX_active_minus1, 0);
   ref_pic_listx->resize(num_ref_idx_lX_active_minus1 + 1);
 
   if (!ref_pic_list_modification_flag_lX)
     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) {
     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 -
+          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.
           if (pic_num_lx_no_wrap < 0)
             pic_num_lx_no_wrap += max_pic_num_;
         } else {
           // Add given value to predicted PicNum.
-          pic_num_lx_no_wrap = pic_num_lx_pred +
+          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 >= max_pic_num_ as result
           // of the addition.
           if (pic_num_lx_no_wrap >= max_pic_num_)
             pic_num_lx_no_wrap -= max_pic_num_;
         }
 
         // For use in next iteration.
         pic_num_lx_pred = pic_num_lx_no_wrap;
 
@@ skipping 43 matching lines @@
         break;
 
       case 3:
         // End of modification list.
         done = true;
         break;
 
       default:
         // May be recoverable.
         DVLOG(1) << "Invalid modification_of_pic_nums_idc="
-                 << list_mod->modification_of_pic_nums_idc
-                 << " in position " << i;
+                 << list_mod->modification_of_pic_nums_idc << " in position "
+                 << i;
         break;
     }
 
     ++list_mod;
   }
 
   // Per NOTE 2 in 8.2.4.3.2, the ref_pic_listx size in the above loop is
   // temporarily made one element longer than the required final list.
   // Resize the list back to its required size.
   ref_pic_listx->resize(num_ref_idx_lX_active_minus1 + 1);
 
   return true;
 }
 
 void H264Decoder::OutputPic(scoped_refptr<H264Picture> pic) {
   DCHECK(!pic->outputted);
   pic->outputted = true;
 
   if (pic->nonexisting) {
     DVLOG(4) << "Skipping output, non-existing frame_num: " << pic->frame_num;
     return;
   }
 
   DVLOG_IF(1, pic->pic_order_cnt < last_output_poc_)
-      << "Outputting out of order, likely a broken stream: "
-      << last_output_poc_ << " -> " << pic->pic_order_cnt;
+      << "Outputting out of order, likely a broken stream: " << last_output_poc_
+      << " -> " << pic->pic_order_cnt;
   last_output_poc_ = pic->pic_order_cnt;
 
   DVLOG(4) << "Posting output task for POC: " << pic->pic_order_cnt;
   accelerator_->OutputPicture(pic);
 }
 
 void H264Decoder::ClearDPB() {
   // Clear DPB contents, marking the pictures as unused first.
   dpb_.Clear();
   last_output_poc_ = std::numeric_limits<int>::min();
@@ skipping 313 matching lines @@
 
     dpb_.StorePic(pic);
   }
 
   return true;
 }
 
 static int LevelToMaxDpbMbs(int level) {
   // See table A-1 in spec.
   switch (level) {
-    case 10: return 396;
-    case 11: return 900;
-    case 12: //  fallthrough
-    case 13: //  fallthrough
-    case 20: return 2376;
-    case 21: return 4752;
-    case 22: //  fallthrough
-    case 30: return 8100;
-    case 31: return 18000;
-    case 32: return 20480;
-    case 40: //  fallthrough
-    case 41: return 32768;
-    case 42: return 34816;
-    case 50: return 110400;
-    case 51: //  fallthrough
-    case 52: return 184320;
+    case 10:
+      return 396;
+    case 11:
+      return 900;
+    case 12:  //  fallthrough
+    case 13:  //  fallthrough
+    case 20:
+      return 2376;
+    case 21:
+      return 4752;
+    case 22:  //  fallthrough
+    case 30:
+      return 8100;
+    case 31:
+      return 18000;
+    case 32:
+      return 20480;
+    case 40:  //  fallthrough
+    case 41:
+      return 32768;
+    case 42:
+      return 34816;
+    case 50:
+      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) {
   if (sps->vui_parameters_present_flag && sps->bitstream_restriction_flag) {
     max_num_reorder_frames_ =
         base::checked_cast<size_t>(sps->max_num_reorder_frames);
@@ skipping 268 matching lines @@
         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:
         // We can't resume from a non-IDR slice.
         if (state_ != kDecoding)
           break;
-        // else fallthrough
+      // else fallthrough
       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.
@@ skipping 95 matching lines @@
 }
 
 gfx::Size H264Decoder::GetPicSize() const {
   return pic_size_;
 }
 
 size_t H264Decoder::GetRequiredNumOfPictures() const {
   return dpb_.max_num_pics() + kPicsInPipeline;
 }
 
-}  // namespace content
+}  // namespace media