Line data    Source code

       1             : /*
       2             :  *  Copyright (c) 2014 The WebRTC project authors. All Rights Reserved.
       3             :  *
       4             :  *  Use of this source code is governed by a BSD-style license
       5             :  *  that can be found in the LICENSE file in the root of the source
       6             :  *  tree. An additional intellectual property rights grant can be found
       7             :  *  in the file PATENTS.  All contributing project authors may
       8             :  *  be found in the AUTHORS file in the root of the source tree.
       9             :  */
      10             : 
      11             : #ifndef WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_ARRAY_
      12             : #define WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_ARRAY_
      13             : 
      14             : #include "webrtc/base/checks.h"
      15             : #include "webrtc/system_wrappers/include/aligned_malloc.h"
      16             : 
      17             : namespace webrtc {
      18             : 
      19             : // Wrapper class for aligned arrays. Every row (and the first dimension) are
      20             : // aligned to the given byte alignment.
      21             : template<typename T> class AlignedArray {
      22             :  public:
      23           0 :   AlignedArray(size_t rows, size_t cols, size_t alignment)
      24             :       : rows_(rows),
      25           0 :         cols_(cols) {
      26           0 :     RTC_CHECK_GT(alignment, 0);
      27           0 :     head_row_ = static_cast<T**>(AlignedMalloc(rows_ * sizeof(*head_row_),
      28             :                                                alignment));
      29           0 :     for (size_t i = 0; i < rows_; ++i) {
      30           0 :       head_row_[i] = static_cast<T*>(AlignedMalloc(cols_ * sizeof(**head_row_),
      31             :                                                    alignment));
      32             :     }
      33           0 :   }
      34             : 
      35           0 :   ~AlignedArray() {
      36           0 :     for (size_t i = 0; i < rows_; ++i) {
      37           0 :       AlignedFree(head_row_[i]);
      38             :     }
      39           0 :     AlignedFree(head_row_);
      40           0 :   }
      41             : 
      42           0 :   T* const* Array() {
      43           0 :     return head_row_;
      44             :   }
      45             : 
      46             :   const T* const* Array() const {
      47             :     return head_row_;
      48             :   }
      49             : 
      50           0 :   T* Row(size_t row) {
      51           0 :     RTC_CHECK_LE(row, rows_);
      52           0 :     return head_row_[row];
      53             :   }
      54             : 
      55             :   const T* Row(size_t row) const {
      56             :     RTC_CHECK_LE(row, rows_);
      57             :     return head_row_[row];
      58             :   }
      59             : 
      60             :   T& At(size_t row, size_t col) {
      61             :     RTC_CHECK_LE(col, cols_);
      62             :     return Row(row)[col];
      63             :   }
      64             : 
      65             :   const T& At(size_t row, size_t col) const {
      66             :     RTC_CHECK_LE(col, cols_);
      67             :     return Row(row)[col];
      68             :   }
      69             : 
      70             :   size_t rows() const {
      71             :     return rows_;
      72             :   }
      73             : 
      74             :   size_t cols() const {
      75             :     return cols_;
      76             :   }
      77             : 
      78             :  private:
      79             :   size_t rows_;
      80             :   size_t cols_;
      81             :   T** head_row_;
      82             : };
      83             : 
      84             : }  // namespace webrtc
      85             : 
      86             : #endif  // WEBRTC_SYSTEM_WRAPPERS_INCLUDE_ALIGNED_ARRAY_