| /system/update_engine/payload_generator/ |
| block_mapping_unittest.cc | 60 size_t block_size_{1024};
61 BlockMapping bm_{block_size_}; // BlockMapping under test.
65 brillo::Blob blob(block_size_);
75 test_utils::WriteFileString(old_part_path_, string(block_size_, 'a'));
89 brillo::Blob block(block_size_, 'a');
107 string old_contents(10 * block_size_, '\0');
109 old_contents[i] = 4 + i / block_size_;
114 string new_contents(6 * block_size_, '\0');
116 new_contents[i] = i / block_size_;
124 block_size_,
[all...] |
| fake_filesystem.cc | 24 block_size_(block_size),
29 return block_size_;
|
| raw_filesystem.cc | 31 result->block_size_ = block_size;
37 return block_size_;
|
| delta_diff_utils_unittest.cc | 111 block_size_, block_size_ * kDefaultBlockCount);
113 block_size_, block_size_ * kDefaultBlockCount);
137 old_part_.size / block_size_,
138 new_part_.size / block_size_,
156 size_t block_size_{kBlockSize};
165 brillo::Blob data_blob(block_size_);
480 InitializePartitionWithUniqueBlocks(old_part_, block_size_, 5);
481 InitializePartitionWithUniqueBlocks(new_part_, block_size_, 42)
[all...] |
| block_mapping.cc | 48 brillo::Blob blob(block_size_);
50 if (!utils::PReadAll(fd, blob.data(), block_size_, byte_offset, &bytes_read))
52 if (static_cast<size_t>(bytes_read) != block_size_)
65 fd, initial_byte_offset + block * block_size_);
74 if (block_data.size() != block_size_)
|
| raw_filesystem.h | 53 uint64_t block_size_; member in class:chromeos_update_engine::RawFilesystem
|
| fake_filesystem.h | 57 uint64_t block_size_; member in class:chromeos_update_engine::FakeFilesystem
|
| /system/update_engine/payload_consumer/ |
| extent_writer.h | 72 block_size_ = block_size;
82 size_t block_size_{0};
92 // of bytes written is a multiple of block_size_. If not, it writes zeros
105 block_size_ = block_size;
111 bytes_written_mod_block_size_ %= block_size_;
118 const size_t write_size = block_size_ - bytes_written_mod_block_size_;
128 size_t block_size_{0};
|
| extent_writer.cc | 40 extents_[next_extent_index_].num_blocks() * block_size_ -
50 extents_[next_extent_index_].start_block() * block_size_ +
62 extents_[next_extent_index_].num_blocks() * block_size_);
|
| delta_performer.cc | [all...] |
| /hardware/intel/common/omx-components/videocodec/libvpx_internal/libvpx/test/ |
| intrapred_test.cc | 44 block_size_ = block_size;
55 for (int x = -1 ; x <= block_size_; x++)
57 for (int y = 0; y < block_size_; y++)
67 for (int i = -1; i < block_size_; ++i)
74 memset(&data_ptr_[p][-1 - stride_], 127, block_size_ + 2);
83 switch (block_size_) {
102 for (int x = 0; x < block_size_; x++)
105 for (int y = 0; y < block_size_; y++)
112 for (int y = 1; y < block_size_; ++y)
114 block_size_));
215 int block_size_; member in class:__anon31387::IntraPredBase
[all...] |
| variance_test.cc | 92 block_size_ = width_ * height_;
93 src_ = new uint8_t[block_size_];
94 ref_ = new uint8_t[block_size_];
115 int block_size_; member in class:__anon31400::VarianceTest
122 memset(src_, i, block_size_);
124 memset(ref_, j, block_size_);
136 for (int j = 0; j < block_size_; j++) {
152 memset(src_, 255, block_size_);
153 const int half = block_size_ / 2;
159 const unsigned int expected = block_size_ * 255 * 255 / 4
233 int block_size_; member in class:__anon31400::SubpelVarianceTest
[all...] |
| /external/webrtc/webrtc/common_audio/ |
| blocker.cc | 109 block_size_(block_size),
112 initial_delay_(block_size_ - gcd(chunk_size, shift_amount)),
116 input_block_(block_size_, num_input_channels_),
117 output_block_(block_size_, num_output_channels_),
118 window_(new float[block_size_]),
122 RTC_CHECK_LE(shift_amount_, block_size_);
124 memcpy(window_.get(), window, block_size_ * sizeof(*window_.get()));
182 block_size_);
183 input_buffer_.MoveReadPositionBackward(block_size_ - shift_amount_);
186 block_size_,
[all...] |
| blocker.h | 41 // (read: |block_size_|) or received-audio-size (read: |chunk_size_|).
82 const size_t block_size_; member in class:webrtc::Blocker
115 // |shift_amount_| = |block_size_| / 2 for a Hann window.
|
| /bionic/linker/ |
| linker_block_allocator.cpp | 41 : block_size_(
55 reinterpret_cast<char*>(free_block_list_) + block_size_);
63 memset(block_info, 0, block_size_);
81 if (offset % block_size_ != 0) {
85 memset(block, 0, block_size_);
120 first_block->num_free_blocks = (PAGE_SIZE - sizeof(LinkerBlockAllocatorPage*))/block_size_;
|
| linker_allocator.cpp | 73 : type_(0), block_size_(0), free_pages_cnt_(0), free_blocks_list_(nullptr) {}
83 reinterpret_cast<uint8_t*>(block_record) + block_size_);
101 memset(block_record, 0, block_size_);
136 if (offset % block_size_ != 0) {
137 __libc_fatal("invalid pointer: %p (block_size=%zd)", ptr, block_size_);
140 memset(ptr, 0, block_size_);
161 block_size_ = block_size;
173 __libc_fatal("page record for %p was not found (block_size=%zd)", ptr, block_size_);
208 size_t free_blocks_cnt = (PAGE_SIZE - sizeof(page_info))/block_size_;
|
| linker_allocator.h | 108 size_t get_block_size() const { return block_size_; }
116 size_t block_size_; member in class:LinkerSmallObjectAllocator
|
| linker_block_allocator.h | 45 size_t block_size_; member in class:LinkerBlockAllocator
|
| /external/webrtc/webrtc/modules/audio_coding/neteq/ |
| time_stretch_unittest.cc | 65 block_size_(30 * sample_rate_hz_ / 1000), // 30 ms
66 audio_(new int16_t[block_size_]),
72 RTC_CHECK(input_file_->Read(block_size_, audio_.get()));
84 UpdateReturnStats(accelerate.Process(Next30Ms(), block_size_, fast_mode,
105 const size_t block_size_; member in class:webrtc::TimeStretchTest
|
| /external/libvpx/libvpx/test/ |
| vp9_intrapred_test.cc | 41 for (int y = 0; y < block_size_; y++) {
42 for (int x = 0; x < block_size_; x++) {
62 for (int x = -1; x <= block_size_*2; x++) {
69 for (int y = 0; y < block_size_; y++) {
82 int block_size_; member in class:__anon17921::VP9IntraPredBase
103 block_size_ = GET_PARAM(2);
105 stride_ = block_size_ * 3;
|
| variance_test.cc | 233 block_size_ = width_ * height_;
235 src_ = reinterpret_cast<uint8_t *>(vpx_memalign(16, block_size_ * 2));
236 ref_ = new uint8_t[block_size_ * 2];
240 vpx_memalign(16, block_size_ * 2 * sizeof(uint16_t))));
241 ref_ = CONVERT_TO_BYTEPTR(new uint16_t[block_size_ * 2]);
275 int block_size_; member in class:__anon17900::VarianceTest
283 memset(src_, i, block_size_);
287 block_size_);
292 memset(ref_, j, block_size_);
296 block_size_);
379 block_size_); local
428 int block_size_; member in class:__anon17900::MseTest
613 int block_size_, mask_; member in class:__anon17900::SubpelVarianceTest
[all...] |
| /external/ceres-solver/internal/ceres/ |
| schur_jacobi_preconditioner.cc | 58 block_size_.resize(num_blocks);
60 block_size_[i] = bs.cols[i + options_.elimination_groups[0]].size;
63 m_.reset(new BlockRandomAccessDiagonalMatrix(block_size_));
114 for (int i = 0; i < block_size_.size(); ++i) {
115 const int block_size = block_size_[i];
|
| /external/webrtc/webrtc/common_audio/resampler/ |
| sinc_resampler.cc | 27 // block_size_ == r4_ - r2_
35 // and block_size_ are reinitialized via step (3) in the algorithm below.
58 // r0_ and choose block_size_ as the distance in frames between r4_ and r2_:
62 // block_size_ = r4_ - r2_ = request_frames_ - kKernelSize / 2
78 // r3_, r4_, and block_size_ then need to be reinitialized, so goto (3).
178 assert(block_size_ > kKernelSize);
198 block_size_ = r4_ - r2_;
290 ceil((block_size_ - virtual_source_idx_) / current_io_ratio));
292 assert(virtual_source_idx_ < block_size_);
330 virtual_source_idx_ -= block_size_;
[all...] |
| /external/v8/src/wasm/ |
| asm-wasm-builder.cc | 49 block_size_(0),
110 DCHECK(block_size_ >= 0);
126 prev_block_size_ = builder_->block_size_;
127 builder_->block_size_ = initial_block_size;
131 builder_->block_size_);
132 builder_->block_size_ = prev_block_size_;
226 block_size_++;
233 block_size_++;
244 block_size_ += stmts->length();
263 block_size_ += stmts->length()
1022 int block_size_; member in class:v8::internal::wasm::AsmWasmBuilderImpl
[all...] |
| /external/regex-re2/util/ |
| arena.cc | 17 : block_size_(block_size),
25 first_blocks_[0].mem = reinterpret_cast<char*>(malloc(block_size_));
26 first_blocks_[0].size = block_size_;
109 if (block_size_ == 0 || size > block_size_/4) {
129 AllocatedBlock *block = AllocNewBlock(block_size_);
|
