| /frameworks/base/media/mca/filterpacks/native/imageproc/ | 
| invert.c | 36   const char* input_ptr = inputs[0];  local 38   if (!input_ptr || !output_ptr)
 44     *(output_ptr++) = 255 - *(input_ptr++);
 
 | 
| to_rgba.c | 36   const char* input_ptr = inputs[0];  local 38   if (!input_ptr || !output_ptr)
 44     *(output_ptr++) = *(input_ptr);
 45     *(output_ptr++) = *(input_ptr);
 46     *(output_ptr++) = *(input_ptr++);
 67   const char* input_ptr = inputs[0];  local
 69   if (!input_ptr || !output_ptr)
 75     *(output_ptr++) = *(input_ptr++);
 76     *(output_ptr++) = *(input_ptr++);
 77     *(output_ptr++) = *(input_ptr++)
 99  const char* input_ptr = inputs[0];  local
 131  const char* input_ptr = inputs[0];  local
 [all...]
 | 
| contrast.c | 63   const char* input_ptr = inputs[0];  local 65   if (!input_ptr || !output_ptr) {
 77     float px = *(input_ptr++) / 255.0;
 
 | 
| brightness.c | 68   const int* input_ptr = (int*)inputs[0];  local 70   const int* end_ptr = input_ptr + (output_size / 4);
 71   if (!input_ptr || !output_ptr) {
 83   while (input_ptr < end_ptr) {
 84     pixel.value = *(input_ptr++);
 
 | 
| /external/adhd/cras/src/dsp/ | 
| dsp_util.c | 400 	float *input_ptr[channels];  local 411 		input_ptr[i] = input[i];
 415 			float f = *(input_ptr[j]++) * 32768.0f;
 
 | 
| /external/curl/src/ | 
| tool_convert.c | 52   char *input_ptr, *output_ptr;  local 64   input_ptr = output_ptr = buffer;
 66   res = iconv(outbound_cd, &input_ptr,  &in_bytes,
 82   char *input_ptr, *output_ptr;  local
 94   input_ptr = output_ptr = buffer;
 96   res = iconv(inbound_cd, &input_ptr,  &in_bytes,
 
 | 
| /external/curl/lib/ | 
| non-ascii.c | 101     char *input_ptr, *output_ptr;  local 120     input_ptr = output_ptr = buffer;
 122     rc = iconv(*cd, &input_ptr, &in_bytes,
 164     char *input_ptr, *output_ptr;  local
 183     input_ptr = output_ptr = buffer;
 185     rc = iconv(*cd, &input_ptr, &in_bytes,
 227     char *input_ptr;  local
 247     input_ptr = output_ptr = buffer;
 249     rc = iconv(*cd, &input_ptr, &in_bytes,
 259     if(output_ptr < input_ptr) {
 [all...]
 | 
| /external/libmojo/mojo/public/cpp/bindings/lib/ | 
| control_message_proxy.cc | 74                     interface_control::RunInputPtr input_ptr, 79   params_ptr->input = std::move(input_ptr);
 94     interface_control::RunOrClosePipeInputPtr input_ptr) {
 98   params_ptr->input = std::move(input_ptr);
 115     interface_control::RunOrClosePipeInputPtr input_ptr) {
 116   Message message(ConstructRunOrClosePipeMessage(std::move(input_ptr)));
 146   auto input_ptr = interface_control::RunInput::New();  local
 147   input_ptr->set_query_version(interface_control::QueryVersion::New());
 148   SendRunMessage(receiver_, std::move(input_ptr),
 155   auto input_ptr = interface_control::RunOrClosePipeInput::New()  local
 [all...]
 | 
| /external/tensorflow/tensorflow/core/kernels/ | 
| population_count_op.cc | 100     const T* input_ptr = input.data();  local 102     auto shard = [input_ptr, output_ptr](int64 start, int64 limit) {
 104         output_ptr[i] = PopCnt<T>(input_ptr[i]);
 
 | 
| concat_lib_gpu_impl.cu.cc | 46     const T* input_ptr = input_ptrs[split];  local 51           input_ptr[gidy * split_size + col_offset];
 105     const T* input_ptr = input_ptrs[curr_segment];  local
 110           input_ptr[gidy * segment_width + local_col];
 
 | 
| depthtospace_op_gpu.cu.cc | 35                          const dtype* __restrict__ input_ptr, 58     *(output_ptr + out_idx) = ldg(input_ptr + inp_idx);
 66                          const dtype* __restrict__ input_ptr,
 97     *(output_ptr + output_idx) = ldg(input_ptr + input_idx);
 127     auto input_ptr = input + n * input_depth_by_input_area + oC_iY_iX;  local
 136             input_ptr + (bY * block_size + bX) * output_depth_by_input_area);
 
 | 
| depthwise_conv_op.cc | 399     auto input_ptr = input.template flat<T>().data();  variable 402     LaunchDepthwiseConvOp<Device, T>()(context, args, input_ptr, filter_ptr,
 
 | 
| resize_area_op.cc | 214     const T* const input_ptr = input_data.data();  local 239               input_ptr + (b * st.in_height * st.in_width * st.channels +
 
 | 
| spacetodepth_op_gpu.cu.cc | 33 __global__ void S2D_NHWC(const int32 nthreads, const dtype* input_ptr, 57     *(output_ptr + out_idx) = ldg(input_ptr + inp_idx);
 65                          const dtype* __restrict__ input_ptr,
 95     *(output_ptr + output_idx) = ldg(input_ptr + input_idx);
 126     auto input_ptr = input + (n_iC_oY * input_width + oX) * block_size;  local
 135             ldg(input_ptr + bY * input_width + bX);
 
 | 
| svd_op_gpu.cu.cc | 96               int64 p, int64 batch_size, Scalar* input_ptr, 109       d.memcpy(input_copy.flat<Scalar>().data(), input_ptr,
 114       Scalar* input = input_ptr + batch * m * n;
 231     Scalar* input_ptr;  local
 236     input_ptr = input_reshaped.data();
 247     RunSVD(context, done, m, n, p, batch_size, input_ptr, outputS_ptr,
 303     Scalar* input_ptr;  local
 308     input_ptr = input_reshaped.data();
 321     RunSVD(context, done, n, m, p, batch_size, input_ptr, outputS_ptr,
 
 | 
| /frameworks/ml/nn/common/operations/ | 
| LSHProjection.cpp | 89   char* input_ptr = (char*)(input->buffer);  local 98     memcpy(key.get() + seed_size, input_ptr, input_item_bytes);
 102     input_ptr += input_item_bytes;
 
 | 
| /external/adhd/cras/src/dsp/tests/ | 
| dsp_util_test.c | 56 	float *input_ptr[channels];  local 60 		input_ptr[i] = input[i];
 64 			float f = *(input_ptr[j]++) * 32768.0f;
 
 | 
| /external/tensorflow/tensorflow/contrib/lite/kernels/ | 
| lsh_projection.cc | 119   char* input_ptr = input->data.raw;  local 128     memcpy(key.get() + seed_size, input_ptr, input_item_bytes);
 132     input_ptr += input_item_bytes;
 
 | 
| /external/tensorflow/tensorflow/contrib/lite/testing/ | 
| tflite_driver.cc | 48   T* input_ptr = reinterpret_cast<T*>(data->raw);  local 50     *input_ptr = v;
 51     ++input_ptr;
 
 | 
| /external/tensorflow/tensorflow/contrib/lite/toco/graph_transformations/ | 
| resolve_constant_transpose.cc | 88         const DataType<Type>* input_ptr = input_ptr_2 + i1 * input_stride_1;  local 93           *output_ptr = *input_ptr;
 94           input_ptr += input_stride_0;
 
 | 
| /external/tensorflow/tensorflow/core/kernels/neon/ | 
| neon_depthwise_conv_op.cc | 122     const float* input_ptr = input.template flat<float>().data();  variable 136         input_ptr, input_neon_dims, filter_ptr, filter_neon_dims, bias_ptr,
 
 | 
| depthwiseconv_float.h | 39                   const float* input_ptr, int input_ptr_increment, 52         input[i] = vld1q_f32(input_ptr + 4 * i);
 54       input_ptr += 16;
 76         input[i] = vld1q_f32(input_ptr + 4 * i);
 78       input_ptr += 8;
 100                   const float* input_ptr, int input_ptr_increment,
 110         input[i] = vld1q_f32(input_ptr + 4 * i);
 112       input_ptr += 16;
 133         input[i] = vld1q_f32(input_ptr + 4 * i);
 135       input_ptr += 8
 484  const float* input_ptr = input_data + in_x_origin * input_depth;  local
 522  const float* input_ptr = input_data + in_x_origin * input_depth;  local
 [all...]
 | 
| /external/vboot_reference/firmware/lib/cryptolib/ | 
| sha256.c | 316   const uint8_t* input_ptr;  local 324   input_ptr = data;
 332     SHA256_update(&ctx, input_ptr, block_size);
 334     input_ptr += block_size;
 
 | 
| sha512.c | 340   const uint8_t* input_ptr;  local 347   input_ptr = data;
 355        SHA512_update(&ctx, input_ptr, block_size);
 357     input_ptr += block_size;
 
 | 
| /external/v8/src/compiler/ | 
| node.cc | 32     DCHECK_EQ(old_input_ptr, old_use_ptr->input_ptr()); 33     DCHECK_EQ(new_input_ptr, new_use_ptr->input_ptr());
 54   Node** input_ptr;  local
 83     input_ptr = outline->inputs_;
 100     input_ptr = node->inputs_.inline_;
 108     input_ptr[current] = to;
 225   Node** input_ptr = GetInputPtr(start);  local
 228     DCHECK_EQ(input_ptr, use_ptr->input_ptr());
 229     Node* input = *input_ptr;
 [all...]
 |