| /frameworks/base/media/mca/filterpacks/native/imageproc/ |
| invert.c | 23 int input_count,
28 if (input_count != 1)
|
| to_rgba.c | 23 int input_count,
28 if (input_count != 1)
54 int input_count,
59 if (input_count != 1)
86 int input_count,
91 if (input_count != 1)
118 int input_count,
123 if (input_count != 1)
|
| brightness.c | 51 int input_count,
56 if (input_count != 1) {
57 LOGE("Brightness: Incorrect input count! Expected 1 but got %d!", input_count);
|
| contrast.c | 46 int input_count,
51 if (input_count != 1) {
52 LOGE("Contrast: Incorrect input count! Expected 1 but got %d!", input_count);
|
| /external/v8/test/unittests/compiler/ |
| value-numbering-reducer-unittest.cc | 80 TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
81 const TestOperator op1(static_cast<Operator::Opcode>(input_count),
82 Operator::kIdempotent, input_count, 1); local
83 Node* n1 = graph()->NewNode(&op1, static_cast<int>(input_count), inputs);
87 const TestOperator op2(static_cast<Operator::Opcode>(input_count),
88 Operator::kIdempotent, input_count, 1); local
89 Node* n2 = graph()->NewNode(&op2, static_cast<int>(input_count), inputs);
105 TRACED_FORRANGE(size_t, input_count, 0, arraysize(inputs)) {
106 const TestOperator op1(1, Operator::kIdempotent, input_count, 1);
107 Node* n = graph()->NewNode(&op1, static_cast<int>(input_count), inputs)
[all...] |
| dead-code-elimination-unittest.cc | 154 TRACED_FORRANGE(int, input_count, 1, kMaxInputs - 1) {
155 for (int i = 0; i < input_count; ++i) {
159 graph()->NewNode(common()->End(input_count), input_count, inputs));
172 TRACED_FORRANGE(int, input_count, 1, kMaxInputs - 1) {
173 for (int i = 0; i < input_count; ++i) {
177 graph()->NewNode(common()->Merge(input_count), input_count, inputs));
242 TRACED_FORRANGE(int, input_count, 1, kMaxInputs - 1) {
244 for (int i = 1; i < input_count; ++i)
[all...] |
| common-operator-unittest.cc | 174 TRACED_FOREACH(size_t, input_count, kInputCounts) {
175 const Operator* const op = common()->End(input_count);
180 EXPECT_EQ(input_count, static_cast<uint32_t>(op->ControlInputCount()));
181 EXPECT_EQ(input_count, static_cast<uint32_t>(
191 TRACED_FOREACH(int, input_count, kArguments) {
192 const Operator* const op = common()->Return(input_count);
195 EXPECT_EQ(input_count, op->ValueInputCount());
198 EXPECT_EQ(2 + input_count, OperatorProperties::GetTotalInputCount(op));
|
| instruction-sequence-unittest.cc | 168 size_t input_count = 0; local
169 for (; input_count < arraysize(inputs); ++input_count) {
170 if (inputs[input_count].value_ == kNoValue) break;
172 CHECK(input_count > 0);
173 auto phi = new (zone()) PhiInstruction(zone(), NewReg().value_, input_count);
174 for (size_t i = 0; i < input_count; ++i) {
183 size_t input_count) {
184 auto phi = new (zone()) PhiInstruction(zone(), NewReg().value_, input_count);
|
| /external/v8/src/compiler/ |
| dead-code-elimination.cc | 41 int const input_count = node->InputCount(); local
42 DCHECK_LE(1, input_count);
44 for (int i = 0; i < input_count; ++i) {
54 } else if (live_input_count < input_count) {
59 DCHECK_EQ(input_count, live_input_count);
66 int const input_count = node->InputCount(); local
67 DCHECK_LE(1, input_count);
75 for (int i = 0; i < input_count; ++i) {
84 DCHECK_EQ(input_count + 1, use->InputCount());
107 DCHECK_LE(live_input_count, input_count);
[all...] |
| graph.cc | 46 Node* Graph::NewNode(const Operator* op, int input_count, Node** inputs,
48 Node* node = NewNodeUnchecked(op, input_count, inputs, incomplete);
54 Node* Graph::NewNodeUnchecked(const Operator* op, int input_count,
57 Node::New(zone(), NextNodeId(), op, input_count, inputs, incomplete);
|
| node.cc | 52 Node* Node::New(Zone* zone, NodeId id, const Operator* op, int input_count,
61 for (int i = 0; i < input_count; i++) {
69 if (input_count > kMaxInlineCapacity) {
72 has_extensible_inputs ? input_count + kMaxInlineCapacity : input_count;
81 outline->count_ = input_count;
88 int capacity = input_count;
91 capacity = std::min(input_count + 3, max);
99 node = new (node_buffer) Node(id, op, input_count, capacity);
106 for (int current = 0; current < input_count; ++current)
120 int const input_count = node->InputCount(); local
153 int input_count = InputCount(); local
[all...] |
| control-flow-optimizer.cc | 159 int const input_count = merge->op()->ControlInputCount(); local
160 DCHECK_LE(1, input_count);
161 Node** const inputs = zone()->NewArray<Node*>(2 * input_count);
163 Node** const merge_false_inputs = &inputs[input_count];
164 for (int index = 0; index < input_count; ++index) {
172 Node* const merge_true = graph()->NewNode(common()->Merge(input_count),
173 input_count, merge_true_inputs);
174 Node* const merge_false = graph()->NewNode(common()->Merge(input_count),
175 input_count, merge_false_inputs);
177 for (int index = 0; index < input_count; ++index)
[all...] |
| common-operator.cc | 293 #define CACHED_END(input_count) \
294 EndOperator<input_count> kEnd##input_count##Operator;
306 #define CACHED_RETURN(input_count) \
307 ReturnOperator<input_count> kReturn##input_count##Operator;
332 #define CACHED_EFFECT_PHI(input_count) \
333 EffectPhiOperator<input_count> kEffectPhi##input_count##Operator;
345 #define CACHED_LOOP(input_count) \
[all...] |
| raw-machine-assembler.cc | 127 int input_count = param_count + 1; local
128 Node** buffer = zone()->NewArray<Node*>(input_count);
134 return AddNode(common()->Call(desc), input_count, buffer);
144 int input_count = param_count + 2; local
145 Node** buffer = zone()->NewArray<Node*>(input_count);
152 return AddNode(common()->Call(desc), input_count, buffer);
208 int input_count = param_count + 1; local
209 Node** buffer = zone()->NewArray<Node*>(input_count);
215 Node* tail_call = MakeNode(common()->TailCall(desc), input_count, buffer);
358 Node* RawMachineAssembler::AddNode(const Operator* op, int input_count,
[all...] |
| instruction-selector.cc | 144 size_t input_count = arraysize(inputs); local
145 return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
158 size_t input_count = arraysize(inputs); local
159 return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
170 size_t input_count = arraysize(inputs); local
171 return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
182 size_t input_count = arraysize(inputs); local
183 return Emit(opcode, output_count, &output, input_count, inputs, temp_count,
195 size_t input_count = arraysize(inputs); local
196 return Emit(opcode, output_count, &output, input_count, inputs, temp_count
480 size_t input_count() const { return descriptor->InputCount(); } function in struct:v8::internal::compiler::CallBuffer
602 size_t input_count = static_cast<size_t>(buffer->input_count()); member in namespace:v8::internal::compiler
1100 size_t input_count = 2 + sw.value_range; local
1119 size_t input_count = 2 + sw.case_count * 2; local
1333 const int input_count = node->op()->ValueInputCount(); local
[all...] |
| common-operator-reducer.cc | 165 int const input_count = node->InputCount() - 1; local
166 DCHECK_LE(1, input_count);
167 Node* const merge = node->InputAt(input_count);
169 DCHECK_EQ(input_count, merge->InputCount());
172 for (int i = 1; i < input_count; ++i) {
189 int const input_count = node->InputCount() - 1; local
190 DCHECK_LE(1, input_count);
191 Node* const merge = node->InputAt(input_count);
193 DCHECK_EQ(input_count, merge->InputCount());
194 if (input_count == 2)
[all...] |
| verifier.cc | 118 int input_count = value_count + context_count + frame_state_count + local
120 CHECK_EQ(input_count, node->InputCount());
178 CHECK_EQ(0, input_count);
274 CHECK_EQ(control_count, input_count);
292 CHECK_EQ(2, input_count);
307 CHECK_EQ(2, input_count);
316 CHECK_EQ(1, input_count);
330 CHECK_EQ(0, input_count);
336 CHECK_EQ(0, input_count);
345 CHECK_EQ(0, input_count);
[all...] |
| simplified-operator.cc | 198 #define PURE(Name, properties, input_count) \
202 input_count, 0, 0, 1, 0, 0) {} \
208 #define NO_THROW(Name, properties, input_count) \
212 input_count, 1, 1, 1, 1, 0) {} \
248 #define GET_FROM_CACHE(Name, properties, input_count) \
|
| state-values-utils.cc | 112 int input_count = static_cast<int>(count); local
113 node = graph()->NewNode(common()->StateValues(input_count), input_count,
|
| /external/v8/src/compiler/ia32/ |
| instruction-selector-ia32.cc | 51 size_t* input_count) {
63 inputs[(*input_count)++] = UseRegister(base);
66 inputs[(*input_count)++] = UseRegister(index);
68 inputs[(*input_count)++] = TempImmediate(displacement);
81 inputs[(*input_count)++] = TempImmediate(displacement);
88 inputs[(*input_count)++] = UseRegister(index);
90 inputs[(*input_count)++] = TempImmediate(displacement);
100 inputs[(*input_count)++] = TempImmediate(displacement);
109 size_t* input_count) {
114 m.displacement(), inputs, input_count);
203 size_t input_count = 0; local
225 size_t input_count = 0; local
295 size_t input_count = 0; local
412 size_t input_count = 0; local
452 DCHECK_GE(arraysize(inputs), input_count); local
537 size_t input_count = 0; local
542 DCHECK_GE(arraysize(inputs), input_count); local
608 size_t input_count = 0; local
613 DCHECK_GE(arraysize(inputs), input_count); local
[all...] |
| /external/v8/src/compiler/x87/ |
| instruction-selector-x87.cc | 55 size_t* input_count) {
67 inputs[(*input_count)++] = UseRegister(base);
70 inputs[(*input_count)++] = UseRegister(index);
72 inputs[(*input_count)++] = TempImmediate(displacement);
85 inputs[(*input_count)++] = TempImmediate(displacement);
92 inputs[(*input_count)++] = UseRegister(index);
94 inputs[(*input_count)++] = TempImmediate(displacement);
104 inputs[(*input_count)++] = TempImmediate(displacement);
113 size_t* input_count) {
118 m.displacement(), inputs, input_count);
164 size_t input_count = 0; local
186 size_t input_count = 0; local
256 size_t input_count = 0; local
373 size_t input_count = 0; local
413 DCHECK_GE(arraysize(inputs), input_count); local
498 size_t input_count = 0; local
503 DCHECK_GE(arraysize(inputs), input_count); local
566 size_t input_count = 0; local
571 DCHECK_GE(arraysize(inputs), input_count); local
[all...] |
| /external/v8/src/compiler/x64/ |
| instruction-selector-x64.cc | 42 size_t* input_count) {
45 inputs[(*input_count)++] = UseRegister(base);
48 inputs[(*input_count)++] = UseRegister(index);
50 inputs[(*input_count)++] = UseImmediate(displacement);
63 inputs[(*input_count)++] = UseImmediate(displacement);
70 inputs[(*input_count)++] = UseRegister(index);
72 inputs[(*input_count)++] = UseImmediate(displacement);
82 inputs[(*input_count)++] = UseRegister(index);
91 size_t* input_count) {
96 m.displacement(), inputs, input_count);
144 size_t input_count = 0; local
166 size_t input_count = 0; local
227 size_t input_count = 0; local
355 size_t input_count = 0; local
395 DCHECK_GE(arraysize(inputs), input_count); local
513 size_t input_count = 0; local
518 DCHECK_GE(arraysize(inputs), input_count); local
[all...] |
| /frameworks/base/media/mca/filterfw/jni/ |
| jni_native_program.cpp | 142 const int input_count = env->GetArrayLength(inputs); local
143 std::vector<const char*> input_buffers(input_count, NULL);
144 std::vector<int> input_sizes(input_count, 0);
145 for (int i = 0 ; i < input_count; ++i) {
|
| /external/v8/src/compiler/arm/ |
| instruction-selector-arm.cc | 192 size_t input_count = 0; local
206 inputs[input_count++] = input;
207 inputs[input_count++] = input;
209 &input_count, &inputs[1])) {
211 input_count++;
213 m.left().node(), &input_count,
217 input_count++;
220 inputs[input_count++] = g.UseRegister(m.left().node());
221 inputs[input_count++] = g.UseRegister(m.right().node());
225 inputs[input_count++] = g.Label(cont->true_block())
236 DCHECK_GE(arraysize(inputs), input_count); local
359 size_t input_count = 0; local
634 size_t input_count = 2; local
652 DCHECK_GE(arraysize(inputs), input_count); local
1265 size_t input_count = 0; local
1293 DCHECK_GE(arraysize(inputs), input_count); local
[all...] |
| /external/v8/src/compiler/arm64/ |
| instruction-selector-arm64.cc | 223 size_t input_count = 0; local
241 inputs[input_count++] = g.UseRegister(left_node);
242 inputs[input_count++] = g.UseImmediate(right_node);
245 inputs[input_count++] = g.UseRegister(right_node);
246 inputs[input_count++] = g.UseImmediate(left_node);
250 input_count += 2;
255 input_count += 2;
259 inputs[input_count++] = g.UseRegisterOrImmediateZero(left_node);
260 inputs[input_count++] = g.UseRegister(m_shift.left().node());
261 inputs[input_count++] = g.UseImmediate(m_shift.right().node())
289 DCHECK_GE(arraysize(inputs), input_count); local
402 size_t input_count = 0; local
[all...] |
