1 /*
2 * Copyright (C) 2012 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_NDEBUG 1
18 #define LOG_TAG "camera_metadata_tests"
19 #include "cutils/log.h"
20
21 #include <errno.h>
22
23 #include <vector>
24 #include <algorithm>
25 #include "gtest/gtest.h"
26 #include "system/camera_metadata.h"
27 #include "camera_metadata_hidden.h"
28
29 #include "camera_metadata_tests_fake_vendor.h"
30
31 #define EXPECT_NULL(x) EXPECT_EQ((void*)0, x)
32 #define EXPECT_NOT_NULL(x) EXPECT_NE((void*)0, x)
33 #define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
34
35 #define OK 0
36 #define ERROR 1
37 #define NOT_FOUND (-ENOENT)
38
39 #define _Alignas(T) \
40 ({struct _AlignasStruct { char c; T field; }; \
41 offsetof(struct _AlignasStruct, field); })
42
43 #define FINISH_USING_CAMERA_METADATA(m) \
44 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL)); \
45 free_camera_metadata(m); \
46
TEST(camera_metadata,allocate_normal)47 TEST(camera_metadata, allocate_normal) {
48 camera_metadata_t *m = NULL;
49 const size_t entry_capacity = 5;
50 const size_t data_capacity = 32;
51
52 m = allocate_camera_metadata(entry_capacity, data_capacity);
53
54 EXPECT_NOT_NULL(m);
55 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
56 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
57 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
58 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
59
60 FINISH_USING_CAMERA_METADATA(m);
61 }
62
TEST(camera_metadata,allocate_nodata)63 TEST(camera_metadata, allocate_nodata) {
64 camera_metadata_t *m = NULL;
65
66 m = allocate_camera_metadata(1, 0);
67
68 EXPECT_NOT_NULL(m);
69 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
70 EXPECT_EQ((size_t)1, get_camera_metadata_entry_capacity(m));
71 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
72 EXPECT_EQ((size_t)0, get_camera_metadata_data_capacity(m));
73
74 FINISH_USING_CAMERA_METADATA(m);
75 }
76
TEST(camera_metadata,clone_nodata)77 TEST(camera_metadata, clone_nodata) {
78 camera_metadata_t *src = NULL;
79 camera_metadata_t *copy = NULL;
80
81 src = allocate_camera_metadata(10, 0);
82
83 ASSERT_NE((void*)NULL, (void*)src);
84 copy = clone_camera_metadata(src);
85 ASSERT_NE((void*)NULL, (void*)copy);
86 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(copy));
87 EXPECT_EQ((size_t)0, get_camera_metadata_entry_capacity(copy));
88 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(copy));
89 EXPECT_EQ((size_t)0, get_camera_metadata_data_capacity(copy));
90
91 FINISH_USING_CAMERA_METADATA(src);
92 FINISH_USING_CAMERA_METADATA(copy);
93 }
94
TEST(camera_metadata,allocate_nothing)95 TEST(camera_metadata, allocate_nothing) {
96 camera_metadata_t *m = NULL;
97
98 m = allocate_camera_metadata(0, 0);
99
100 ASSERT_NE((void*)NULL, (void*)m);
101 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
102 EXPECT_EQ((size_t)0, get_camera_metadata_entry_capacity(m));
103 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
104 EXPECT_EQ((size_t)0, get_camera_metadata_data_capacity(m));
105 }
106
TEST(camera_metadata,place_normal)107 TEST(camera_metadata, place_normal) {
108 camera_metadata_t *m = NULL;
109 void *buf = NULL;
110
111 const size_t entry_capacity = 5;
112 const size_t data_capacity = 32;
113
114 size_t buf_size = calculate_camera_metadata_size(entry_capacity,
115 data_capacity);
116
117 EXPECT_TRUE(buf_size > 0);
118
119 buf = malloc(buf_size);
120
121 EXPECT_NOT_NULL(buf);
122
123 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
124
125 EXPECT_EQ(buf, (uint8_t*)m);
126 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
127 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
128 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
129 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
130
131 EXPECT_EQ(OK, validate_camera_metadata_structure(m, &buf_size));
132
133 free(buf);
134 }
135
TEST(camera_metadata,place_nospace)136 TEST(camera_metadata, place_nospace) {
137 camera_metadata_t *m = NULL;
138 void *buf = NULL;
139
140 const size_t entry_capacity = 5;
141 const size_t data_capacity = 32;
142
143 size_t buf_size = calculate_camera_metadata_size(entry_capacity,
144 data_capacity);
145
146 EXPECT_GT(buf_size, (size_t)0);
147
148 buf_size--;
149
150 buf = malloc(buf_size);
151
152 EXPECT_NOT_NULL(buf);
153
154 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
155
156 EXPECT_NULL(m);
157
158 free(buf);
159 }
160
TEST(camera_metadata,place_extraspace)161 TEST(camera_metadata, place_extraspace) {
162 camera_metadata_t *m = NULL;
163 uint8_t *buf = NULL;
164
165 const size_t entry_capacity = 5;
166 const size_t data_capacity = 32;
167 const size_t extra_space = 10;
168
169 size_t buf_size = calculate_camera_metadata_size(entry_capacity,
170 data_capacity);
171
172 EXPECT_GT(buf_size, (size_t)0);
173
174 buf_size += extra_space;
175
176 buf = (uint8_t*)malloc(buf_size);
177
178 EXPECT_NOT_NULL(buf);
179
180 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
181
182 EXPECT_EQ((uint8_t*)m, buf);
183 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
184 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
185 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
186 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
187 EXPECT_EQ(buf + buf_size - extra_space, (uint8_t*)m + get_camera_metadata_size(m));
188
189 EXPECT_EQ(OK, validate_camera_metadata_structure(m, &buf_size));
190
191 free(buf);
192 }
193
TEST(camera_metadata,get_size)194 TEST(camera_metadata, get_size) {
195 camera_metadata_t *m = NULL;
196 const size_t entry_capacity = 5;
197 const size_t data_capacity = 32;
198
199 m = allocate_camera_metadata(entry_capacity, data_capacity);
200
201 EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity),
202 get_camera_metadata_size(m) );
203
204 EXPECT_EQ(calculate_camera_metadata_size(0,0),
205 get_camera_metadata_compact_size(m) );
206
207 FINISH_USING_CAMERA_METADATA(m);
208 }
209
TEST(camera_metadata,add_get_normal)210 TEST(camera_metadata, add_get_normal) {
211 camera_metadata_t *m = NULL;
212 const size_t entry_capacity = 5;
213 const size_t data_capacity = 128;
214
215 m = allocate_camera_metadata(entry_capacity, data_capacity);
216
217 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
218
219 int result;
220 size_t data_used = 0;
221 size_t entries_used = 0;
222
223 // INT64
224
225 int64_t exposure_time = 1000000000;
226 result = add_camera_metadata_entry(m,
227 ANDROID_SENSOR_EXPOSURE_TIME,
228 &exposure_time, 1);
229 EXPECT_EQ(OK, result);
230 data_used += calculate_camera_metadata_entry_data_size(
231 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1);
232 entries_used++;
233
234 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
235
236 // INT32
237
238 int32_t sensitivity = 800;
239 result = add_camera_metadata_entry(m,
240 ANDROID_SENSOR_SENSITIVITY,
241 &sensitivity, 1);
242 EXPECT_EQ(OK, result);
243 data_used += calculate_camera_metadata_entry_data_size(
244 get_camera_metadata_tag_type(ANDROID_SENSOR_SENSITIVITY), 1);
245 entries_used++;
246
247 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
248
249 // FLOAT
250
251 float focusDistance = 0.5f;
252 result = add_camera_metadata_entry(m,
253 ANDROID_LENS_FOCUS_DISTANCE,
254 &focusDistance, 1);
255 EXPECT_EQ(OK, result);
256 data_used += calculate_camera_metadata_entry_data_size(
257 get_camera_metadata_tag_type(ANDROID_LENS_FOCUS_DISTANCE), 1);
258 entries_used++;
259
260 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
261
262 // Array of FLOAT
263
264 float colorCorrectionGains[] = {1.69f, 1.00f, 1.00f, 2.41f};
265 result = add_camera_metadata_entry(m,
266 ANDROID_COLOR_CORRECTION_GAINS,
267 colorCorrectionGains, ARRAY_SIZE(colorCorrectionGains));
268 EXPECT_EQ(OK, result);
269 data_used += calculate_camera_metadata_entry_data_size(
270 get_camera_metadata_tag_type(ANDROID_COLOR_CORRECTION_GAINS),
271 ARRAY_SIZE(colorCorrectionGains));
272 entries_used++;
273
274 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
275
276
277 // Array of RATIONAL
278
279 camera_metadata_rational_t colorTransform[] = {
280 {9, 10}, {0, 1}, {0, 1},
281 {1, 5}, {1, 2}, {0, 1},
282 {0, 1}, {1, 10}, {7, 10}
283 };
284 result = add_camera_metadata_entry(m,
285 ANDROID_COLOR_CORRECTION_TRANSFORM,
286 colorTransform, ARRAY_SIZE(colorTransform));
287 EXPECT_EQ(OK, result);
288 data_used += calculate_camera_metadata_entry_data_size(
289 get_camera_metadata_tag_type(ANDROID_COLOR_CORRECTION_TRANSFORM),
290 ARRAY_SIZE(colorTransform));
291 entries_used++;
292
293 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
294
295 // Check added entries
296
297 size_t index = 0;
298 camera_metadata_entry entry;
299
300 result = get_camera_metadata_entry(m,
301 index, &entry);
302 EXPECT_EQ(OK, result);
303 EXPECT_EQ(index, (int)entry.index);
304 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, entry.tag);
305 EXPECT_EQ(TYPE_INT64, entry.type);
306 EXPECT_EQ((size_t)1, entry.count);
307 EXPECT_EQ(exposure_time, *entry.data.i64);
308 index++;
309
310 result = get_camera_metadata_entry(m,
311 index, &entry);
312 EXPECT_EQ(OK, result);
313 EXPECT_EQ(index, entry.index);
314 EXPECT_EQ(ANDROID_SENSOR_SENSITIVITY, entry.tag);
315 EXPECT_EQ(TYPE_INT32, entry.type);
316 EXPECT_EQ((size_t)1, entry.count);
317 EXPECT_EQ(sensitivity, *entry.data.i32);
318 index++;
319
320 result = get_camera_metadata_entry(m,
321 index, &entry);
322 EXPECT_EQ(OK, result);
323 EXPECT_EQ(index, entry.index);
324 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
325 EXPECT_EQ(TYPE_FLOAT, entry.type);
326 EXPECT_EQ((size_t)1, entry.count);
327 EXPECT_EQ(focusDistance, *entry.data.f);
328 index++;
329
330 result = get_camera_metadata_entry(m,
331 index, &entry);
332 EXPECT_EQ(OK, result);
333 EXPECT_EQ(index, entry.index);
334 EXPECT_EQ(ANDROID_COLOR_CORRECTION_GAINS, entry.tag);
335 EXPECT_EQ(TYPE_FLOAT, entry.type);
336 EXPECT_EQ(ARRAY_SIZE(colorCorrectionGains), entry.count);
337 for (unsigned int i=0; i < entry.count; i++) {
338 EXPECT_EQ(colorCorrectionGains[i], entry.data.f[i]);
339 }
340 index++;
341
342 result = get_camera_metadata_entry(m,
343 index, &entry);
344 EXPECT_EQ(OK, result);
345 EXPECT_EQ(index, entry.index);
346 EXPECT_EQ(ANDROID_COLOR_CORRECTION_TRANSFORM, entry.tag);
347 EXPECT_EQ(TYPE_RATIONAL, entry.type);
348 EXPECT_EQ(ARRAY_SIZE(colorTransform), entry.count);
349 for (unsigned int i=0; i < entry.count; i++) {
350 EXPECT_EQ(colorTransform[i].numerator, entry.data.r[i].numerator);
351 EXPECT_EQ(colorTransform[i].denominator, entry.data.r[i].denominator);
352 }
353 index++;
354
355 EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity),
356 get_camera_metadata_size(m) );
357
358 EXPECT_EQ(calculate_camera_metadata_size(entries_used, data_used),
359 get_camera_metadata_compact_size(m) );
360
361 IF_ALOGV() {
362 dump_camera_metadata(m, 0, 2);
363 }
364
365 FINISH_USING_CAMERA_METADATA(m);
366 }
367
add_test_metadata(camera_metadata_t * m,int entry_count)368 void add_test_metadata(camera_metadata_t *m, int entry_count) {
369
370 EXPECT_NOT_NULL(m);
371
372 int result;
373 size_t data_used = 0;
374 size_t entries_used = 0;
375 int64_t exposure_time;
376 for (int i=0; i < entry_count; i++ ) {
377 exposure_time = 100 + i * 100;
378 result = add_camera_metadata_entry(m,
379 ANDROID_SENSOR_EXPOSURE_TIME,
380 &exposure_time, 1);
381 EXPECT_EQ(OK, result);
382 data_used += calculate_camera_metadata_entry_data_size(
383 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1);
384 entries_used++;
385 }
386 EXPECT_EQ(data_used, get_camera_metadata_data_count(m));
387 EXPECT_EQ(entries_used, get_camera_metadata_entry_count(m));
388 EXPECT_GE(get_camera_metadata_data_capacity(m),
389 get_camera_metadata_data_count(m));
390 }
391
TEST(camera_metadata,add_get_toomany)392 TEST(camera_metadata, add_get_toomany) {
393 camera_metadata_t *m = NULL;
394 const size_t entry_capacity = 5;
395 const size_t data_capacity = 50;
396 int result;
397
398 m = allocate_camera_metadata(entry_capacity, data_capacity);
399
400 add_test_metadata(m, entry_capacity);
401
402 int32_t sensitivity = 100;
403 result = add_camera_metadata_entry(m,
404 ANDROID_SENSOR_SENSITIVITY,
405 &sensitivity, 1);
406
407 EXPECT_EQ(ERROR, result);
408
409 camera_metadata_entry entry;
410 for (unsigned int i=0; i < entry_capacity; i++) {
411 int64_t exposure_time = 100 + i * 100;
412 result = get_camera_metadata_entry(m,
413 i, &entry);
414 EXPECT_EQ(OK, result);
415 EXPECT_EQ(i, entry.index);
416 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, entry.tag);
417 EXPECT_EQ(TYPE_INT64, entry.type);
418 EXPECT_EQ((size_t)1, entry.count);
419 EXPECT_EQ(exposure_time, *entry.data.i64);
420 }
421 entry.tag = 1234;
422 entry.type = 56;
423 entry.data.u8 = NULL;
424 entry.count = 7890;
425 result = get_camera_metadata_entry(m,
426 entry_capacity, &entry);
427 EXPECT_EQ(ERROR, result);
428 EXPECT_EQ((uint32_t)1234, entry.tag);
429 EXPECT_EQ((uint8_t)56, entry.type);
430 EXPECT_EQ(NULL, entry.data.u8);
431 EXPECT_EQ((size_t)7890, entry.count);
432
433 IF_ALOGV() {
434 dump_camera_metadata(m, 0, 2);
435 }
436
437 FINISH_USING_CAMERA_METADATA(m);
438 }
439
TEST(camera_metadata,add_too_much_data)440 TEST(camera_metadata, add_too_much_data) {
441 camera_metadata_t *m = NULL;
442 const size_t entry_capacity = 5;
443 int result;
444 size_t data_used = entry_capacity * calculate_camera_metadata_entry_data_size(
445 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1);
446 m = allocate_camera_metadata(entry_capacity + 1, data_used);
447
448
449 add_test_metadata(m, entry_capacity);
450
451 int64_t exposure_time = 12345;
452 result = add_camera_metadata_entry(m,
453 ANDROID_SENSOR_EXPOSURE_TIME,
454 &exposure_time, 1);
455 EXPECT_EQ(ERROR, result);
456
457 FINISH_USING_CAMERA_METADATA(m);
458 }
459
TEST(camera_metadata,copy_metadata)460 TEST(camera_metadata, copy_metadata) {
461 camera_metadata_t *m = NULL;
462 const size_t entry_capacity = 50;
463 const size_t data_capacity = 450;
464
465 int result;
466
467 m = allocate_camera_metadata(entry_capacity, data_capacity);
468
469 add_test_metadata(m, entry_capacity);
470
471 size_t buf_size = get_camera_metadata_compact_size(m);
472 EXPECT_LT((size_t)0, buf_size);
473
474 uint8_t *buf = (uint8_t*)malloc(buf_size);
475 EXPECT_NOT_NULL(buf);
476
477 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
478 EXPECT_NOT_NULL(m2);
479 EXPECT_EQ(buf, (uint8_t*)m2);
480 EXPECT_EQ(get_camera_metadata_entry_count(m),
481 get_camera_metadata_entry_count(m2));
482 EXPECT_EQ(get_camera_metadata_data_count(m),
483 get_camera_metadata_data_count(m2));
484 EXPECT_EQ(get_camera_metadata_entry_capacity(m2),
485 get_camera_metadata_entry_count(m2));
486 EXPECT_EQ(get_camera_metadata_data_capacity(m2),
487 get_camera_metadata_data_count(m2));
488
489 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
490 camera_metadata_entry e1, e2;
491 int result;
492 result = get_camera_metadata_entry(m, i, &e1);
493 EXPECT_EQ(OK, result);
494 result = get_camera_metadata_entry(m2, i, &e2);
495 EXPECT_EQ(OK, result);
496 EXPECT_EQ(e1.index, e2.index);
497 EXPECT_EQ(e1.tag, e2.tag);
498 EXPECT_EQ(e1.type, e2.type);
499 EXPECT_EQ(e1.count, e2.count);
500 for (unsigned int j=0;
501 j < e1.count * camera_metadata_type_size[e1.type];
502 j++) {
503 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
504 }
505 }
506
507 EXPECT_EQ(OK, validate_camera_metadata_structure(m2, &buf_size));
508 free(buf);
509
510 FINISH_USING_CAMERA_METADATA(m);
511 }
512
TEST(camera_metadata,copy_metadata_extraspace)513 TEST(camera_metadata, copy_metadata_extraspace) {
514 camera_metadata_t *m = NULL;
515 const size_t entry_capacity = 12;
516 const size_t data_capacity = 100;
517
518 const size_t extra_space = 10;
519
520 int result;
521
522 m = allocate_camera_metadata(entry_capacity, data_capacity);
523
524 add_test_metadata(m, entry_capacity);
525
526 size_t buf_size = get_camera_metadata_compact_size(m);
527 EXPECT_LT((size_t)0, buf_size);
528 buf_size += extra_space;
529
530 uint8_t *buf = (uint8_t*)malloc(buf_size);
531 EXPECT_NOT_NULL(buf);
532
533 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
534 EXPECT_NOT_NULL(m2);
535 EXPECT_EQ(buf, (uint8_t*)m2);
536 EXPECT_EQ(get_camera_metadata_entry_count(m),
537 get_camera_metadata_entry_count(m2));
538 EXPECT_EQ(get_camera_metadata_data_count(m),
539 get_camera_metadata_data_count(m2));
540 EXPECT_EQ(get_camera_metadata_entry_capacity(m2),
541 get_camera_metadata_entry_count(m2));
542 EXPECT_EQ(get_camera_metadata_data_capacity(m2),
543 get_camera_metadata_data_count(m2));
544 EXPECT_EQ(buf + buf_size - extra_space,
545 (uint8_t*)m2 + get_camera_metadata_size(m2) );
546
547 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
548 camera_metadata_entry e1, e2;
549
550 int result;
551 result = get_camera_metadata_entry(m, i, &e1);
552 EXPECT_EQ(OK, result);
553 EXPECT_EQ(i, e1.index);
554 result = get_camera_metadata_entry(m2, i, &e2);
555 EXPECT_EQ(OK, result);
556 EXPECT_EQ(e1.index, e2.index);
557 EXPECT_EQ(e1.tag, e2.tag);
558 EXPECT_EQ(e1.type, e2.type);
559 EXPECT_EQ(e1.count, e2.count);
560 for (unsigned int j=0;
561 j < e1.count * camera_metadata_type_size[e1.type];
562 j++) {
563 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
564 }
565 }
566
567 EXPECT_EQ(OK, validate_camera_metadata_structure(m2, &buf_size));
568 free(buf);
569
570 FINISH_USING_CAMERA_METADATA(m);
571 }
572
TEST(camera_metadata,copy_metadata_nospace)573 TEST(camera_metadata, copy_metadata_nospace) {
574 camera_metadata_t *m = NULL;
575 const size_t entry_capacity = 5;
576 const size_t data_capacity = 50;
577
578 int result;
579
580 m = allocate_camera_metadata(entry_capacity, data_capacity);
581
582 add_test_metadata(m, entry_capacity);
583
584 size_t buf_size = get_camera_metadata_compact_size(m);
585 EXPECT_LT((size_t)0, buf_size);
586
587 buf_size--;
588
589 uint8_t *buf = (uint8_t*)malloc(buf_size);
590 EXPECT_NOT_NULL(buf);
591
592 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
593 EXPECT_NULL(m2);
594
595 free(buf);
596
597 FINISH_USING_CAMERA_METADATA(m);
598 }
599
TEST(camera_metadata,append_metadata)600 TEST(camera_metadata, append_metadata) {
601 camera_metadata_t *m = NULL;
602 const size_t entry_capacity = 5;
603 const size_t data_capacity = 50;
604
605 int result;
606
607 m = allocate_camera_metadata(entry_capacity, data_capacity);
608
609 add_test_metadata(m, entry_capacity);
610
611 camera_metadata_t *m2 = NULL;
612
613 m2 = allocate_camera_metadata(entry_capacity*2, data_capacity*2);
614 EXPECT_NOT_NULL(m2);
615
616 result = append_camera_metadata(m2, m);
617
618 EXPECT_EQ(OK, result);
619
620 EXPECT_EQ(get_camera_metadata_entry_count(m),
621 get_camera_metadata_entry_count(m2));
622 EXPECT_EQ(get_camera_metadata_data_count(m),
623 get_camera_metadata_data_count(m2));
624 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2));
625 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2));
626
627 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
628 camera_metadata_entry e1, e2;
629 int result;
630 result = get_camera_metadata_entry(m, i, &e1);
631 EXPECT_EQ(OK, result);
632 EXPECT_EQ(i, e1.index);
633 result = get_camera_metadata_entry(m2, i, &e2);
634 EXPECT_EQ(OK, result);
635 EXPECT_EQ(e1.index, e2.index);
636 EXPECT_EQ(e1.tag, e2.tag);
637 EXPECT_EQ(e1.type, e2.type);
638 EXPECT_EQ(e1.count, e2.count);
639 for (unsigned int j=0;
640 j < e1.count * camera_metadata_type_size[e1.type];
641 j++) {
642 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
643 }
644 }
645
646 result = append_camera_metadata(m2, m);
647
648 EXPECT_EQ(OK, result);
649
650 EXPECT_EQ(get_camera_metadata_entry_count(m)*2,
651 get_camera_metadata_entry_count(m2));
652 EXPECT_EQ(get_camera_metadata_data_count(m)*2,
653 get_camera_metadata_data_count(m2));
654 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2));
655 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2));
656
657 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) {
658 camera_metadata_entry e1, e2;
659
660 int result;
661 result = get_camera_metadata_entry(m,
662 i % entry_capacity, &e1);
663 EXPECT_EQ(OK, result);
664 EXPECT_EQ(i % entry_capacity, e1.index);
665 result = get_camera_metadata_entry(m2,
666 i, &e2);
667 EXPECT_EQ(OK, result);
668 EXPECT_EQ(i, e2.index);
669 EXPECT_EQ(e1.tag, e2.tag);
670 EXPECT_EQ(e1.type, e2.type);
671 EXPECT_EQ(e1.count, e2.count);
672 for (unsigned int j=0;
673 j < e1.count * camera_metadata_type_size[e1.type];
674 j++) {
675 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
676 }
677 }
678
679 FINISH_USING_CAMERA_METADATA(m);
680 FINISH_USING_CAMERA_METADATA(m2);
681 }
682
TEST(camera_metadata,append_metadata_nospace)683 TEST(camera_metadata, append_metadata_nospace) {
684 camera_metadata_t *m = NULL;
685 const size_t entry_capacity = 5;
686 const size_t data_capacity = 50;
687
688 int result;
689
690 m = allocate_camera_metadata(entry_capacity, data_capacity);
691
692 add_test_metadata(m, entry_capacity);
693
694 camera_metadata_t *m2 = NULL;
695
696 m2 = allocate_camera_metadata(entry_capacity-1, data_capacity);
697 EXPECT_NOT_NULL(m2);
698
699 result = append_camera_metadata(m2, m);
700
701 EXPECT_EQ(ERROR, result);
702 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m2));
703 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m2));
704
705 FINISH_USING_CAMERA_METADATA(m);
706 FINISH_USING_CAMERA_METADATA(m2);
707 }
708
TEST(camera_metadata,append_metadata_onespace)709 TEST(camera_metadata, append_metadata_onespace) {
710 camera_metadata_t *m = NULL;
711 const size_t entry_capacity = 5;
712 const size_t data_capacity = 50;
713 const size_t entry_capacity2 = entry_capacity * 2 - 2;
714 const size_t data_capacity2 = data_capacity * 2;
715 int result;
716
717 m = allocate_camera_metadata(entry_capacity, data_capacity);
718
719 add_test_metadata(m, entry_capacity);
720
721 camera_metadata_t *m2 = NULL;
722
723 m2 = allocate_camera_metadata(entry_capacity2, data_capacity2);
724 EXPECT_NOT_NULL(m2);
725
726 result = append_camera_metadata(m2, m);
727
728 EXPECT_EQ(OK, result);
729
730 EXPECT_EQ(get_camera_metadata_entry_count(m),
731 get_camera_metadata_entry_count(m2));
732 EXPECT_EQ(get_camera_metadata_data_count(m),
733 get_camera_metadata_data_count(m2));
734 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2));
735 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2));
736
737 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
738 camera_metadata_entry e1, e2;
739
740 int result;
741 result = get_camera_metadata_entry(m, i, &e1);
742 EXPECT_EQ(OK, result);
743 EXPECT_EQ(i, e1.index);
744 result = get_camera_metadata_entry(m2, i, &e2);
745 EXPECT_EQ(OK, result);
746 EXPECT_EQ(e1.index, e2.index);
747 EXPECT_EQ(e1.tag, e2.tag);
748 EXPECT_EQ(e1.type, e2.type);
749 EXPECT_EQ(e1.count, e2.count);
750 for (unsigned int j=0;
751 j < e1.count * camera_metadata_type_size[e1.type];
752 j++) {
753 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
754 }
755 }
756
757 result = append_camera_metadata(m2, m);
758
759 EXPECT_EQ(ERROR, result);
760 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_count(m2));
761 EXPECT_EQ(get_camera_metadata_data_count(m),
762 get_camera_metadata_data_count(m2));
763 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2));
764 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2));
765
766 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) {
767 camera_metadata_entry e1, e2;
768
769 int result;
770 result = get_camera_metadata_entry(m,
771 i % entry_capacity, &e1);
772 EXPECT_EQ(OK, result);
773 EXPECT_EQ(i % entry_capacity, e1.index);
774 result = get_camera_metadata_entry(m2, i, &e2);
775 EXPECT_EQ(OK, result);
776 EXPECT_EQ(i, e2.index);
777 EXPECT_EQ(e1.tag, e2.tag);
778 EXPECT_EQ(e1.type, e2.type);
779 EXPECT_EQ(e1.count, e2.count);
780 for (unsigned int j=0;
781 j < e1.count * camera_metadata_type_size[e1.type];
782 j++) {
783 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]);
784 }
785 }
786
787 FINISH_USING_CAMERA_METADATA(m);
788 FINISH_USING_CAMERA_METADATA(m2);
789 }
790
TEST(camera_metadata,vendor_tags)791 TEST(camera_metadata, vendor_tags) {
792 camera_metadata_t *m = NULL;
793 const size_t entry_capacity = 5;
794 const size_t data_capacity = 50;
795 int result;
796
797 m = allocate_camera_metadata(entry_capacity, data_capacity);
798
799 uint8_t superMode = 5;
800 result = add_camera_metadata_entry(m,
801 FAKEVENDOR_SENSOR_SUPERMODE,
802 &superMode, 1);
803 EXPECT_EQ(ERROR, result);
804 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
805
806 result = add_camera_metadata_entry(m,
807 ANDROID_REQUEST_METADATA_MODE,
808 &superMode, 1);
809 EXPECT_EQ(OK, result);
810 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
811
812 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
813 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
814 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
815
816 set_camera_metadata_vendor_ops(&fakevendor_ops);
817
818 result = add_camera_metadata_entry(m,
819 FAKEVENDOR_SENSOR_SUPERMODE,
820 &superMode, 1);
821 EXPECT_EQ(OK, result);
822 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
823
824 result = add_camera_metadata_entry(m,
825 ANDROID_REQUEST_METADATA_MODE,
826 &superMode, 1);
827 EXPECT_EQ(OK, result);
828 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
829
830 result = add_camera_metadata_entry(m,
831 FAKEVENDOR_SCALER_END,
832 &superMode, 1);
833 EXPECT_EQ(ERROR, result);
834 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
835
836 EXPECT_STREQ("com.fakevendor.sensor",
837 get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
838 EXPECT_STREQ("superMode",
839 get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
840 EXPECT_EQ(TYPE_BYTE,
841 get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
842
843 EXPECT_STREQ("com.fakevendor.scaler",
844 get_camera_metadata_section_name(FAKEVENDOR_SCALER_END));
845 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SCALER_END));
846 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SCALER_END));
847
848 set_camera_metadata_vendor_ops(NULL);
849 // TODO: fix vendor ops. Then the below 3 validations should fail.
850 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
851
852 result = add_camera_metadata_entry(m,
853 FAKEVENDOR_SENSOR_SUPERMODE,
854 &superMode, 1);
855 EXPECT_EQ(ERROR, result);
856 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
857
858 result = add_camera_metadata_entry(m,
859 ANDROID_REQUEST_METADATA_MODE,
860 &superMode, 1);
861 EXPECT_EQ(OK, result);
862 EXPECT_EQ(OK, validate_camera_metadata_structure(m, NULL));
863
864 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
865 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
866 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
867
868 // Remove all vendor entries so validation passes
869 {
870 camera_metadata_ro_entry_t entry;
871 EXPECT_EQ(OK, find_camera_metadata_ro_entry(m,
872 FAKEVENDOR_SENSOR_SUPERMODE,
873 &entry));
874 EXPECT_EQ(OK, delete_camera_metadata_entry(m, entry.index));
875 }
876
877 FINISH_USING_CAMERA_METADATA(m);
878 }
879
TEST(camera_metadata,add_all_tags)880 TEST(camera_metadata, add_all_tags) {
881 int total_tag_count = 0;
882 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) {
883 total_tag_count += camera_metadata_section_bounds[i][1] -
884 camera_metadata_section_bounds[i][0];
885 }
886 int entry_data_count = 3;
887 int conservative_data_space = total_tag_count * entry_data_count * 8;
888 uint8_t data[entry_data_count * 8];
889 int32_t *data_int32 = (int32_t *)data;
890 float *data_float = (float *)data;
891 int64_t *data_int64 = (int64_t *)data;
892 double *data_double = (double *)data;
893 camera_metadata_rational_t *data_rational =
894 (camera_metadata_rational_t *)data;
895
896 camera_metadata_t *m = allocate_camera_metadata(total_tag_count,
897 conservative_data_space);
898
899 ASSERT_NE((void*)NULL, (void*)m);
900
901 int result;
902
903 int counter = 0;
904 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) {
905 for (uint32_t tag = camera_metadata_section_bounds[i][0];
906 tag < camera_metadata_section_bounds[i][1];
907 tag++, counter++) {
908 int type = get_camera_metadata_tag_type(tag);
909 ASSERT_NE(-1, type);
910
911 switch (type) {
912 case TYPE_BYTE:
913 data[0] = tag & 0xFF;
914 data[1] = (tag >> 8) & 0xFF;
915 data[2] = (tag >> 16) & 0xFF;
916 break;
917 case TYPE_INT32:
918 data_int32[0] = tag;
919 data_int32[1] = i;
920 data_int32[2] = counter;
921 break;
922 case TYPE_FLOAT:
923 data_float[0] = tag;
924 data_float[1] = i;
925 data_float[2] = counter / (float)total_tag_count;
926 break;
927 case TYPE_INT64:
928 data_int64[0] = (int64_t)tag | ( (int64_t)tag << 32);
929 data_int64[1] = i;
930 data_int64[2] = counter;
931 break;
932 case TYPE_DOUBLE:
933 data_double[0] = tag;
934 data_double[1] = i;
935 data_double[2] = counter / (double)total_tag_count;
936 break;
937 case TYPE_RATIONAL:
938 data_rational[0].numerator = tag;
939 data_rational[0].denominator = 1;
940 data_rational[1].numerator = i;
941 data_rational[1].denominator = 1;
942 data_rational[2].numerator = counter;
943 data_rational[2].denominator = total_tag_count;
944 break;
945 default:
946 FAIL() << "Unknown type field encountered:" << type;
947 break;
948 }
949 result = add_camera_metadata_entry(m,
950 tag,
951 data,
952 entry_data_count);
953 ASSERT_EQ(OK, result);
954
955 }
956 }
957
958 IF_ALOGV() {
959 dump_camera_metadata(m, 0, 2);
960 }
961
962 FINISH_USING_CAMERA_METADATA(m);
963 }
964
TEST(camera_metadata,sort_metadata)965 TEST(camera_metadata, sort_metadata) {
966 camera_metadata_t *m = NULL;
967 const size_t entry_capacity = 5;
968 const size_t data_capacity = 100;
969
970 int result;
971
972 m = allocate_camera_metadata(entry_capacity, data_capacity);
973
974 // Add several unique entries in non-sorted order
975
976 camera_metadata_rational_t colorTransform[] = {
977 {9, 10}, {0, 1}, {0, 1},
978 {1, 5}, {1, 2}, {0, 1},
979 {0, 1}, {1, 10}, {7, 10}
980 };
981 result = add_camera_metadata_entry(m,
982 ANDROID_COLOR_CORRECTION_TRANSFORM,
983 colorTransform, ARRAY_SIZE(colorTransform));
984 EXPECT_EQ(OK, result);
985
986 float focus_distance = 0.5f;
987 result = add_camera_metadata_entry(m,
988 ANDROID_LENS_FOCUS_DISTANCE,
989 &focus_distance, 1);
990 EXPECT_EQ(OK, result);
991
992 int64_t exposure_time = 1000000000;
993 result = add_camera_metadata_entry(m,
994 ANDROID_SENSOR_EXPOSURE_TIME,
995 &exposure_time, 1);
996 EXPECT_EQ(OK, result);
997
998 int32_t sensitivity = 800;
999 result = add_camera_metadata_entry(m,
1000 ANDROID_SENSOR_SENSITIVITY,
1001 &sensitivity, 1);
1002 EXPECT_EQ(OK, result);
1003
1004 // Test unsorted find
1005 camera_metadata_entry_t entry;
1006 result = find_camera_metadata_entry(m,
1007 ANDROID_LENS_FOCUS_DISTANCE,
1008 &entry);
1009 EXPECT_EQ(OK, result);
1010 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
1011 EXPECT_EQ((size_t)1, entry.index);
1012 EXPECT_EQ(TYPE_FLOAT, entry.type);
1013 EXPECT_EQ((size_t)1, entry.count);
1014 EXPECT_EQ(focus_distance, *entry.data.f);
1015
1016 result = find_camera_metadata_entry(m,
1017 ANDROID_NOISE_REDUCTION_STRENGTH,
1018 &entry);
1019 EXPECT_EQ(NOT_FOUND, result);
1020 EXPECT_EQ((size_t)1, entry.index);
1021 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
1022 EXPECT_EQ(TYPE_FLOAT, entry.type);
1023 EXPECT_EQ((size_t)1, entry.count);
1024 EXPECT_EQ(focus_distance, *entry.data.f);
1025
1026 // Sort
1027 IF_ALOGV() {
1028 std::cout << "Pre-sorted metadata" << std::endl;
1029 dump_camera_metadata(m, 0, 2);
1030 }
1031
1032 result = sort_camera_metadata(m);
1033 EXPECT_EQ(OK, result);
1034
1035 IF_ALOGV() {
1036 std::cout << "Sorted metadata" << std::endl;
1037 dump_camera_metadata(m, 0, 2);
1038 }
1039
1040 // Test sorted find
1041 size_t lensFocusIndex = -1;
1042 {
1043 std::vector<uint32_t> tags;
1044 tags.push_back(ANDROID_COLOR_CORRECTION_TRANSFORM);
1045 tags.push_back(ANDROID_LENS_FOCUS_DISTANCE);
1046 tags.push_back(ANDROID_SENSOR_EXPOSURE_TIME);
1047 tags.push_back(ANDROID_SENSOR_SENSITIVITY);
1048 std::sort(tags.begin(), tags.end());
1049
1050 lensFocusIndex =
1051 std::find(tags.begin(), tags.end(), ANDROID_LENS_FOCUS_DISTANCE)
1052 - tags.begin();
1053 }
1054
1055 result = find_camera_metadata_entry(m,
1056 ANDROID_LENS_FOCUS_DISTANCE,
1057 &entry);
1058 EXPECT_EQ(OK, result);
1059 EXPECT_EQ(lensFocusIndex, entry.index);
1060 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
1061 EXPECT_EQ(TYPE_FLOAT, entry.type);
1062 EXPECT_EQ((size_t)1, (size_t)entry.count);
1063 EXPECT_EQ(focus_distance, *entry.data.f);
1064
1065 result = find_camera_metadata_entry(m,
1066 ANDROID_NOISE_REDUCTION_STRENGTH,
1067 &entry);
1068 EXPECT_EQ(NOT_FOUND, result);
1069 EXPECT_EQ(lensFocusIndex, entry.index);
1070 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag);
1071 EXPECT_EQ(TYPE_FLOAT, entry.type);
1072 EXPECT_EQ((size_t)1, entry.count);
1073 EXPECT_EQ(focus_distance, *entry.data.f);
1074
1075
1076 FINISH_USING_CAMERA_METADATA(m);
1077 }
1078
TEST(camera_metadata,delete_metadata)1079 TEST(camera_metadata, delete_metadata) {
1080 camera_metadata_t *m = NULL;
1081 const size_t entry_capacity = 50;
1082 const size_t data_capacity = 450;
1083
1084 int result;
1085
1086 m = allocate_camera_metadata(entry_capacity, data_capacity);
1087
1088 size_t num_entries = 5;
1089 size_t data_per_entry =
1090 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
1091 size_t num_data = num_entries * data_per_entry;
1092
1093 // Delete an entry with data
1094
1095 add_test_metadata(m, num_entries);
1096 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1097 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1098
1099 result = delete_camera_metadata_entry(m, 1);
1100 EXPECT_EQ(OK, result);
1101 num_entries--;
1102 num_data -= data_per_entry;
1103
1104 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1105 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1106 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1107 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1108
1109 result = delete_camera_metadata_entry(m, 4);
1110 EXPECT_EQ(ERROR, result);
1111
1112 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1113 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1114 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1115 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1116
1117 for (size_t i = 0; i < num_entries; i++) {
1118 camera_metadata_entry e;
1119 result = get_camera_metadata_entry(m, i, &e);
1120 EXPECT_EQ(OK, result);
1121 EXPECT_EQ(i, e.index);
1122 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1123 EXPECT_EQ(TYPE_INT64, e.type);
1124 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
1125 EXPECT_EQ(exposureTime, *e.data.i64);
1126 }
1127
1128 // Delete an entry with no data, at end of array
1129
1130 int32_t frameCount = 12;
1131 result = add_camera_metadata_entry(m,
1132 ANDROID_REQUEST_FRAME_COUNT,
1133 &frameCount, 1);
1134 EXPECT_EQ(OK, result);
1135 num_entries++;
1136
1137 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1138 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1139 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1140 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1141
1142 camera_metadata_entry e;
1143 result = get_camera_metadata_entry(m, 4, &e);
1144 EXPECT_EQ(OK, result);
1145
1146 EXPECT_EQ((size_t)4, e.index);
1147 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1148 EXPECT_EQ(TYPE_INT32, e.type);
1149 EXPECT_EQ((size_t)1, e.count);
1150 EXPECT_EQ(frameCount, *e.data.i32);
1151
1152 result = delete_camera_metadata_entry(m, 4);
1153 EXPECT_EQ(OK, result);
1154
1155 num_entries--;
1156 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1157 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1158 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1159 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1160
1161 result = delete_camera_metadata_entry(m, 4);
1162 EXPECT_EQ(ERROR, result);
1163
1164 result = get_camera_metadata_entry(m, 4, &e);
1165 EXPECT_EQ(ERROR, result);
1166
1167 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1168 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1169 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1170 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1171
1172 // Delete with extra data on end of array
1173 result = delete_camera_metadata_entry(m, 3);
1174 EXPECT_EQ(OK, result);
1175 num_entries--;
1176 num_data -= data_per_entry;
1177
1178 for (size_t i = 0; i < num_entries; i++) {
1179 camera_metadata_entry e2;
1180 result = get_camera_metadata_entry(m, i, &e2);
1181 EXPECT_EQ(OK, result);
1182 EXPECT_EQ(i, e2.index);
1183 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1184 EXPECT_EQ(TYPE_INT64, e2.type);
1185 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
1186 EXPECT_EQ(exposureTime, *e2.data.i64);
1187 }
1188
1189 // Delete without extra data in front of array
1190
1191 frameCount = 1001;
1192 result = add_camera_metadata_entry(m,
1193 ANDROID_REQUEST_FRAME_COUNT,
1194 &frameCount, 1);
1195 EXPECT_EQ(OK, result);
1196 num_entries++;
1197
1198 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1199 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1200 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1201 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1202
1203 result = sort_camera_metadata(m);
1204 EXPECT_EQ(OK, result);
1205
1206 result = find_camera_metadata_entry(m,
1207 ANDROID_REQUEST_FRAME_COUNT, &e);
1208 EXPECT_EQ(OK, result);
1209 EXPECT_EQ((size_t)0, e.index);
1210 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1211 EXPECT_EQ(TYPE_INT32, e.type);
1212 EXPECT_EQ((size_t)1, e.count);
1213 EXPECT_EQ(frameCount, *e.data.i32);
1214
1215 result = delete_camera_metadata_entry(m, e.index);
1216 EXPECT_EQ(OK, result);
1217 num_entries--;
1218
1219 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1220 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1221 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1222 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1223
1224 for (size_t i = 0; i < num_entries; i++) {
1225 camera_metadata_entry e2;
1226 result = get_camera_metadata_entry(m, i, &e2);
1227 EXPECT_EQ(OK, result);
1228 EXPECT_EQ(i, e2.index);
1229 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1230 EXPECT_EQ(TYPE_INT64, e2.type);
1231 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i;
1232 EXPECT_EQ(exposureTime, *e2.data.i64);
1233 }
1234 }
1235
TEST(camera_metadata,update_metadata)1236 TEST(camera_metadata, update_metadata) {
1237 camera_metadata_t *m = NULL;
1238 const size_t entry_capacity = 50;
1239 const size_t data_capacity = 450;
1240
1241 int result;
1242
1243 m = allocate_camera_metadata(entry_capacity, data_capacity);
1244
1245 size_t num_entries = 5;
1246 size_t data_per_entry =
1247 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
1248 size_t num_data = num_entries * data_per_entry;
1249
1250 add_test_metadata(m, num_entries);
1251 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1252 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1253
1254 // Update with same-size data, doesn't fit in entry
1255
1256 int64_t newExposureTime = 1000;
1257 camera_metadata_entry_t e;
1258 result = update_camera_metadata_entry(m,
1259 0, &newExposureTime, 1, &e);
1260 EXPECT_EQ(OK, result);
1261
1262 EXPECT_EQ((size_t)0, e.index);
1263 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1264 EXPECT_EQ(TYPE_INT64, e.type);
1265 EXPECT_EQ((size_t)1, e.count);
1266 EXPECT_EQ(newExposureTime, *e.data.i64);
1267
1268 e.count = 0;
1269 result = get_camera_metadata_entry(m,
1270 0, &e);
1271
1272 EXPECT_EQ((size_t)0, e.index);
1273 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1274 EXPECT_EQ(TYPE_INT64, e.type);
1275 EXPECT_EQ((size_t)1, e.count);
1276 EXPECT_EQ(newExposureTime, *e.data.i64);
1277
1278 for (size_t i = 1; i < num_entries; i++) {
1279 camera_metadata_entry e2;
1280 result = get_camera_metadata_entry(m, i, &e2);
1281 EXPECT_EQ(OK, result);
1282 EXPECT_EQ(i, e2.index);
1283 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1284 EXPECT_EQ(TYPE_INT64, e2.type);
1285 int64_t exposureTime = 100 + 100 * i;
1286 EXPECT_EQ(exposureTime, *e2.data.i64);
1287 }
1288
1289 // Update with larger data
1290 int64_t newExposures[2] = { 5000, 6000 };
1291 result = update_camera_metadata_entry(m,
1292 0, newExposures, 2, &e);
1293 EXPECT_EQ(OK, result);
1294 num_data += data_per_entry;
1295
1296 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1297 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1298
1299 EXPECT_EQ((size_t)0, e.index);
1300 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1301 EXPECT_EQ(TYPE_INT64, e.type);
1302 EXPECT_EQ((size_t)2, e.count);
1303 EXPECT_EQ(newExposures[0], e.data.i64[0]);
1304 EXPECT_EQ(newExposures[1], e.data.i64[1]);
1305
1306 e.count = 0;
1307 result = get_camera_metadata_entry(m,
1308 0, &e);
1309
1310 EXPECT_EQ((size_t)0, e.index);
1311 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1312 EXPECT_EQ(TYPE_INT64, e.type);
1313 EXPECT_EQ((size_t)2, e.count);
1314 EXPECT_EQ(newExposures[0], e.data.i64[0]);
1315 EXPECT_EQ(newExposures[1], e.data.i64[1]);
1316
1317 for (size_t i = 1; i < num_entries; i++) {
1318 camera_metadata_entry e2;
1319 result = get_camera_metadata_entry(m, i, &e2);
1320 EXPECT_EQ(OK, result);
1321 EXPECT_EQ(i, e2.index);
1322 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1323 EXPECT_EQ(TYPE_INT64, e2.type);
1324 int64_t exposureTime = 100 + 100 * i;
1325 EXPECT_EQ(exposureTime, *e2.data.i64);
1326 }
1327
1328 // Update with smaller data
1329 newExposureTime = 100;
1330 result = update_camera_metadata_entry(m,
1331 0, &newExposureTime, 1, &e);
1332 EXPECT_EQ(OK, result);
1333
1334 num_data -= data_per_entry;
1335
1336 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1337 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1338
1339 EXPECT_EQ((size_t)0, e.index);
1340 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1341 EXPECT_EQ(TYPE_INT64, e.type);
1342 EXPECT_EQ((size_t)1, e.count);
1343 EXPECT_EQ(newExposureTime, *e.data.i64);
1344
1345 e.count = 0;
1346 result = get_camera_metadata_entry(m,
1347 0, &e);
1348
1349 EXPECT_EQ((size_t)0, e.index);
1350 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1351 EXPECT_EQ(TYPE_INT64, e.type);
1352 EXPECT_EQ((size_t)1, e.count);
1353 EXPECT_EQ(newExposureTime, *e.data.i64);
1354
1355 for (size_t i = 1; i < num_entries; i++) {
1356 camera_metadata_entry e2;
1357 result = get_camera_metadata_entry(m, i, &e2);
1358 EXPECT_EQ(OK, result);
1359 EXPECT_EQ(i, e2.index);
1360 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1361 EXPECT_EQ(TYPE_INT64, e2.type);
1362 int64_t exposureTime = 100 + 100 * i;
1363 EXPECT_EQ(exposureTime, *e2.data.i64);
1364 }
1365
1366 // Update with size fitting in entry
1367
1368 int32_t frameCount = 1001;
1369 result = add_camera_metadata_entry(m,
1370 ANDROID_REQUEST_FRAME_COUNT,
1371 &frameCount, 1);
1372 EXPECT_EQ(OK, result);
1373 num_entries++;
1374
1375 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1376 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
1377 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1378 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
1379
1380 result = sort_camera_metadata(m);
1381 EXPECT_EQ(OK, result);
1382
1383 result = find_camera_metadata_entry(m,
1384 ANDROID_REQUEST_FRAME_COUNT, &e);
1385 EXPECT_EQ(OK, result);
1386 EXPECT_EQ((size_t)0, e.index);
1387 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1388 EXPECT_EQ(TYPE_INT32, e.type);
1389 EXPECT_EQ((size_t)1, e.count);
1390 EXPECT_EQ(frameCount, *e.data.i32);
1391
1392 int32_t newFrameCount = 0x12349876;
1393 result = update_camera_metadata_entry(m,
1394 0, &newFrameCount, 1, &e);
1395
1396 EXPECT_EQ(OK, result);
1397 EXPECT_EQ((size_t)0, e.index);
1398 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1399 EXPECT_EQ(TYPE_INT32, e.type);
1400 EXPECT_EQ((size_t)1, e.count);
1401 EXPECT_EQ(newFrameCount, *e.data.i32);
1402
1403 result = find_camera_metadata_entry(m,
1404 ANDROID_REQUEST_FRAME_COUNT, &e);
1405
1406 EXPECT_EQ(OK, result);
1407 EXPECT_EQ((size_t)0, e.index);
1408 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1409 EXPECT_EQ(TYPE_INT32, e.type);
1410 EXPECT_EQ((size_t)1, e.count);
1411 EXPECT_EQ(newFrameCount, *e.data.i32);
1412
1413 for (size_t i = 1; i < num_entries; i++) {
1414 camera_metadata_entry e2;
1415 result = get_camera_metadata_entry(m, i, &e2);
1416 EXPECT_EQ(OK, result);
1417 EXPECT_EQ(i, e2.index);
1418 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1419 EXPECT_EQ(TYPE_INT64, e2.type);
1420 int64_t exposureTime = 100 * i;
1421 EXPECT_EQ(exposureTime, *e2.data.i64);
1422 }
1423
1424 // Update to bigger than entry
1425
1426 int32_t newFrameCounts[4] = { 0x0, 0x1, 0x10, 0x100 };
1427
1428 result = update_camera_metadata_entry(m,
1429 0, &newFrameCounts, 4, &e);
1430
1431 EXPECT_EQ(OK, result);
1432
1433 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT32,
1434 4);
1435
1436 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1437 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1438
1439 EXPECT_EQ((size_t)0, e.index);
1440 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1441 EXPECT_EQ(TYPE_INT32, e.type);
1442 EXPECT_EQ((size_t)4, e.count);
1443 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]);
1444 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]);
1445 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]);
1446 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]);
1447
1448 e.count = 0;
1449
1450 result = find_camera_metadata_entry(m,
1451 ANDROID_REQUEST_FRAME_COUNT, &e);
1452
1453 EXPECT_EQ(OK, result);
1454 EXPECT_EQ((size_t)0, e.index);
1455 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1456 EXPECT_EQ(TYPE_INT32, e.type);
1457 EXPECT_EQ((size_t)4, e.count);
1458 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]);
1459 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]);
1460 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]);
1461 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]);
1462
1463 for (size_t i = 1; i < num_entries; i++) {
1464 camera_metadata_entry e2;
1465 result = get_camera_metadata_entry(m, i, &e2);
1466 EXPECT_EQ(OK, result);
1467 EXPECT_EQ(i, e2.index);
1468 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1469 EXPECT_EQ(TYPE_INT64, e2.type);
1470 int64_t exposureTime = 100 * i;
1471 EXPECT_EQ(exposureTime, *e2.data.i64);
1472 }
1473
1474 // Update to smaller than entry
1475 result = update_camera_metadata_entry(m,
1476 0, &newFrameCount, 1, &e);
1477
1478 EXPECT_EQ(OK, result);
1479
1480 num_data -= camera_metadata_type_size[TYPE_INT32] * 4;
1481
1482 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1483 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1484
1485 EXPECT_EQ((size_t)0, e.index);
1486 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1487 EXPECT_EQ(TYPE_INT32, e.type);
1488 EXPECT_EQ((size_t)1, e.count);
1489 EXPECT_EQ(newFrameCount, *e.data.i32);
1490
1491 result = find_camera_metadata_entry(m,
1492 ANDROID_REQUEST_FRAME_COUNT, &e);
1493
1494 EXPECT_EQ(OK, result);
1495 EXPECT_EQ((size_t)0, e.index);
1496 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1497 EXPECT_EQ(TYPE_INT32, e.type);
1498 EXPECT_EQ((size_t)1, e.count);
1499 EXPECT_EQ(newFrameCount, *e.data.i32);
1500
1501 for (size_t i = 1; i < num_entries; i++) {
1502 camera_metadata_entry_t e2;
1503 result = get_camera_metadata_entry(m, i, &e2);
1504 EXPECT_EQ(OK, result);
1505 EXPECT_EQ(i, e2.index);
1506 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1507 EXPECT_EQ(TYPE_INT64, e2.type);
1508 int64_t exposureTime = 100 * i;
1509 EXPECT_EQ(exposureTime, *e2.data.i64);
1510 }
1511
1512 // Setup new buffer with no spare data space
1513
1514 result = update_camera_metadata_entry(m,
1515 1, newExposures, 2, &e);
1516 EXPECT_EQ(OK, result);
1517
1518 num_data += data_per_entry;
1519
1520 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m));
1521 EXPECT_EQ(num_data, get_camera_metadata_data_count(m));
1522
1523 EXPECT_EQ((size_t)1, e.index);
1524 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1525 EXPECT_EQ(TYPE_INT64, e.type);
1526 EXPECT_EQ((size_t)2, e.count);
1527 EXPECT_EQ(newExposures[0], e.data.i64[0]);
1528 EXPECT_EQ(newExposures[1], e.data.i64[1]);
1529
1530 camera_metadata_t *m2;
1531 m2 = allocate_camera_metadata(get_camera_metadata_entry_count(m),
1532 get_camera_metadata_data_count(m));
1533 EXPECT_NOT_NULL(m2);
1534
1535 result = append_camera_metadata(m2, m);
1536 EXPECT_EQ(OK, result);
1537
1538 result = find_camera_metadata_entry(m2,
1539 ANDROID_REQUEST_FRAME_COUNT, &e);
1540
1541 EXPECT_EQ(OK, result);
1542 EXPECT_EQ((size_t)0, e.index);
1543 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1544 EXPECT_EQ(TYPE_INT32, e.type);
1545 EXPECT_EQ((size_t)1, e.count);
1546 EXPECT_EQ(newFrameCount, *e.data.i32);
1547
1548 // Update when there's no more room
1549
1550 result = update_camera_metadata_entry(m2,
1551 0, &newFrameCounts, 4, &e);
1552 EXPECT_EQ(ERROR, result);
1553
1554 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
1555 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
1556
1557 EXPECT_EQ((size_t)0, e.index);
1558 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1559 EXPECT_EQ(TYPE_INT32, e.type);
1560 EXPECT_EQ((size_t)1, e.count);
1561 EXPECT_EQ(newFrameCount, *e.data.i32);
1562
1563 // Update when there's no data room, but change fits into entry
1564
1565 newFrameCount = 5;
1566 result = update_camera_metadata_entry(m2,
1567 0, &newFrameCount, 1, &e);
1568 EXPECT_EQ(OK, result);
1569
1570 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
1571 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
1572
1573 EXPECT_EQ((size_t)0, e.index);
1574 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1575 EXPECT_EQ(TYPE_INT32, e.type);
1576 EXPECT_EQ((size_t)1, e.count);
1577 EXPECT_EQ(newFrameCount, *e.data.i32);
1578
1579 result = find_camera_metadata_entry(m2,
1580 ANDROID_REQUEST_FRAME_COUNT, &e);
1581
1582 EXPECT_EQ(OK, result);
1583 EXPECT_EQ((size_t)0, e.index);
1584 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1585 EXPECT_EQ(TYPE_INT32, e.type);
1586 EXPECT_EQ((size_t)1, e.count);
1587 EXPECT_EQ(newFrameCount, *e.data.i32);
1588
1589 result = get_camera_metadata_entry(m2, 1, &e);
1590 EXPECT_EQ((size_t)1, e.index);
1591 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1592 EXPECT_EQ(TYPE_INT64, e.type);
1593 EXPECT_EQ((size_t)2, e.count);
1594 EXPECT_EQ(newExposures[0], e.data.i64[0]);
1595 EXPECT_EQ(newExposures[1], e.data.i64[1]);
1596
1597 for (size_t i = 2; i < num_entries; i++) {
1598 camera_metadata_entry_t e2;
1599 result = get_camera_metadata_entry(m2, i, &e2);
1600 EXPECT_EQ(OK, result);
1601 EXPECT_EQ(i, e2.index);
1602 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1603 EXPECT_EQ(TYPE_INT64, e2.type);
1604 int64_t exposureTime = 100 * i;
1605 EXPECT_EQ(exposureTime, *e2.data.i64);
1606 }
1607
1608 // Update when there's no data room, but data size doesn't change
1609
1610 newExposures[0] = 1000;
1611
1612 result = update_camera_metadata_entry(m2,
1613 1, newExposures, 2, &e);
1614 EXPECT_EQ(OK, result);
1615
1616 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
1617 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
1618
1619 EXPECT_EQ((size_t)1, e.index);
1620 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1621 EXPECT_EQ(TYPE_INT64, e.type);
1622 EXPECT_EQ((size_t)2, e.count);
1623 EXPECT_EQ(newExposures[0], e.data.i64[0]);
1624 EXPECT_EQ(newExposures[1], e.data.i64[1]);
1625
1626 result = find_camera_metadata_entry(m2,
1627 ANDROID_REQUEST_FRAME_COUNT, &e);
1628
1629 EXPECT_EQ(OK, result);
1630 EXPECT_EQ((size_t)0, e.index);
1631 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1632 EXPECT_EQ(TYPE_INT32, e.type);
1633 EXPECT_EQ((size_t)1, e.count);
1634 EXPECT_EQ(newFrameCount, *e.data.i32);
1635
1636 for (size_t i = 2; i < num_entries; i++) {
1637 camera_metadata_entry_t e2;
1638 result = get_camera_metadata_entry(m2, i, &e2);
1639 EXPECT_EQ(OK, result);
1640 EXPECT_EQ(i, e2.index);
1641 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1642 EXPECT_EQ(TYPE_INT64, e2.type);
1643 int64_t exposureTime = 100 * i;
1644 EXPECT_EQ(exposureTime, *e2.data.i64);
1645 }
1646
1647 // Update when there's no data room, but data size shrinks
1648
1649 result = update_camera_metadata_entry(m2,
1650 1, &newExposureTime, 1, &e);
1651 EXPECT_EQ(OK, result);
1652
1653 num_data -= calculate_camera_metadata_entry_data_size(TYPE_INT64, 2);
1654 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT64, 1);
1655
1656 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2));
1657 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2));
1658
1659 EXPECT_EQ((size_t)1, e.index);
1660 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag);
1661 EXPECT_EQ(TYPE_INT64, e.type);
1662 EXPECT_EQ((size_t)1, e.count);
1663 EXPECT_EQ(newExposureTime, e.data.i64[0]);
1664
1665 result = find_camera_metadata_entry(m2,
1666 ANDROID_REQUEST_FRAME_COUNT, &e);
1667
1668 EXPECT_EQ(OK, result);
1669 EXPECT_EQ((size_t)0, e.index);
1670 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag);
1671 EXPECT_EQ(TYPE_INT32, e.type);
1672 EXPECT_EQ((size_t)1, e.count);
1673 EXPECT_EQ(newFrameCount, *e.data.i32);
1674
1675 for (size_t i = 2; i < num_entries; i++) {
1676 camera_metadata_entry_t e2;
1677 result = get_camera_metadata_entry(m2, i, &e2);
1678 EXPECT_EQ(OK, result);
1679 EXPECT_EQ(i, e2.index);
1680 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag);
1681 EXPECT_EQ(TYPE_INT64, e2.type);
1682 int64_t exposureTime = 100 * i;
1683 EXPECT_EQ(exposureTime, *e2.data.i64);
1684 }
1685
1686 }
1687
TEST(camera_metadata,memcpy)1688 TEST(camera_metadata, memcpy) {
1689 camera_metadata_t *m = NULL;
1690 const size_t entry_capacity = 50;
1691 const size_t data_capacity = 450;
1692
1693 int result;
1694
1695 m = allocate_camera_metadata(entry_capacity, data_capacity);
1696
1697 add_test_metadata(m, 5);
1698
1699 size_t m_size = get_camera_metadata_size(m);
1700 uint8_t *dst = new uint8_t[m_size];
1701
1702 memcpy(dst, m, m_size);
1703
1704 camera_metadata_t *m2 = reinterpret_cast<camera_metadata_t*>(dst);
1705
1706 ASSERT_EQ(get_camera_metadata_size(m),
1707 get_camera_metadata_size(m2));
1708 EXPECT_EQ(get_camera_metadata_compact_size(m),
1709 get_camera_metadata_compact_size(m2));
1710 ASSERT_EQ(get_camera_metadata_entry_count(m),
1711 get_camera_metadata_entry_count(m2));
1712 EXPECT_EQ(get_camera_metadata_entry_capacity(m),
1713 get_camera_metadata_entry_capacity(m2));
1714 EXPECT_EQ(get_camera_metadata_data_count(m),
1715 get_camera_metadata_data_count(m2));
1716 EXPECT_EQ(get_camera_metadata_data_capacity(m),
1717 get_camera_metadata_data_capacity(m2));
1718
1719 camera_metadata_entry_t e1, e2;
1720 for (size_t i = 0; i < get_camera_metadata_entry_count(m); i++) {
1721 result = get_camera_metadata_entry(m, i, &e1);
1722 ASSERT_EQ(OK, result);
1723 result = get_camera_metadata_entry(m2, i, &e2);
1724 ASSERT_EQ(OK, result);
1725
1726 EXPECT_EQ(e1.index, e2.index);
1727 EXPECT_EQ(e1.tag, e2.tag);
1728 ASSERT_EQ(e1.type, e2.type);
1729 ASSERT_EQ(e1.count, e2.count);
1730
1731 ASSERT_TRUE(!memcmp(e1.data.u8, e2.data.u8,
1732 camera_metadata_type_size[e1.type] * e1.count));
1733 }
1734
1735 // Make sure updating one metadata buffer doesn't change the other
1736
1737 int64_t double_exposure_time[] = { 100, 200 };
1738
1739 result = update_camera_metadata_entry(m, 0,
1740 double_exposure_time,
1741 sizeof(double_exposure_time)/sizeof(int64_t), NULL);
1742 EXPECT_EQ(OK, result);
1743
1744 result = get_camera_metadata_entry(m, 0, &e1);
1745 ASSERT_EQ(OK, result);
1746 result = get_camera_metadata_entry(m2, 0, &e2);
1747 ASSERT_EQ(OK, result);
1748
1749 EXPECT_EQ(e1.index, e2.index);
1750 EXPECT_EQ(e1.tag, e2.tag);
1751 ASSERT_EQ(e1.type, e2.type);
1752 ASSERT_EQ((size_t)2, e1.count);
1753 ASSERT_EQ((size_t)1, e2.count);
1754 EXPECT_EQ(100, e1.data.i64[0]);
1755 EXPECT_EQ(200, e1.data.i64[1]);
1756 EXPECT_EQ(100, e2.data.i64[0]);
1757
1758 // And in the reverse direction as well
1759
1760 double_exposure_time[0] = 300;
1761 result = update_camera_metadata_entry(m2, 0,
1762 double_exposure_time,
1763 sizeof(double_exposure_time)/sizeof(int64_t), NULL);
1764 EXPECT_EQ(OK, result);
1765
1766 result = get_camera_metadata_entry(m, 0, &e1);
1767 ASSERT_EQ(OK, result);
1768 result = get_camera_metadata_entry(m2, 0, &e2);
1769 ASSERT_EQ(OK, result);
1770
1771 EXPECT_EQ(e1.index, e2.index);
1772 EXPECT_EQ(e1.tag, e2.tag);
1773 ASSERT_EQ(e1.type, e2.type);
1774 ASSERT_EQ((size_t)2, e1.count);
1775 ASSERT_EQ((size_t)2, e2.count);
1776 EXPECT_EQ(100, e1.data.i64[0]);
1777 EXPECT_EQ(200, e1.data.i64[1]);
1778 EXPECT_EQ(300, e2.data.i64[0]);
1779 EXPECT_EQ(200, e2.data.i64[1]);
1780
1781 EXPECT_EQ(OK, validate_camera_metadata_structure(m2, &m_size));
1782
1783 delete dst;
1784 FINISH_USING_CAMERA_METADATA(m);
1785 }
1786
TEST(camera_metadata,data_alignment)1787 TEST(camera_metadata, data_alignment) {
1788 // Verify that when we store the data, the data aligned as we expect
1789 camera_metadata_t *m = NULL;
1790 const size_t entry_capacity = 50;
1791 const size_t data_capacity = 450;
1792 char dummy_data[data_capacity] = {0,};
1793
1794 int m_types[] = {
1795 TYPE_BYTE,
1796 TYPE_INT32,
1797 TYPE_FLOAT,
1798 TYPE_INT64,
1799 TYPE_DOUBLE,
1800 TYPE_RATIONAL
1801 };
1802 const size_t (&m_type_sizes)[NUM_TYPES] = camera_metadata_type_size;
1803 size_t m_type_align[] = {
1804 _Alignas(uint8_t), // BYTE
1805 _Alignas(int32_t), // INT32
1806 _Alignas(float), // FLOAT
1807 _Alignas(int64_t), // INT64
1808 _Alignas(double), // DOUBLE
1809 _Alignas(camera_metadata_rational_t), // RATIONAL
1810 };
1811 /* arbitrary tags. the important thing is that their type
1812 corresponds to m_type_sizes[i]
1813 */
1814 int m_type_tags[] = {
1815 ANDROID_REQUEST_TYPE,
1816 ANDROID_REQUEST_ID,
1817 ANDROID_LENS_FOCUS_DISTANCE,
1818 ANDROID_SENSOR_EXPOSURE_TIME,
1819 ANDROID_JPEG_GPS_COORDINATES,
1820 ANDROID_CONTROL_AE_COMPENSATION_STEP
1821 };
1822
1823 /*
1824 if the asserts fail, its because we added more types.
1825 this means the test should be updated to include more types.
1826 */
1827 ASSERT_EQ((size_t)NUM_TYPES, sizeof(m_types)/sizeof(m_types[0]));
1828 ASSERT_EQ((size_t)NUM_TYPES, sizeof(m_type_align)/sizeof(m_type_align[0]));
1829 ASSERT_EQ((size_t)NUM_TYPES, sizeof(m_type_tags)/sizeof(m_type_tags[0]));
1830
1831 for (int m_type = 0; m_type < (int)NUM_TYPES; ++m_type) {
1832
1833 ASSERT_EQ(m_types[m_type],
1834 get_camera_metadata_tag_type(m_type_tags[m_type]));
1835
1836 // misalignment possibilities are [0,type_size) for any type pointer
1837 for (size_t i = 0; i < m_type_sizes[m_type]; ++i) {
1838
1839 /* data_count = 1, we may store data in the index.
1840 data_count = 10, we will store data separately
1841 */
1842 for (int data_count = 1; data_count <= 10; data_count += 9) {
1843
1844 m = allocate_camera_metadata(entry_capacity, data_capacity);
1845
1846 // add dummy data to test various different padding requirements
1847 ASSERT_EQ(OK,
1848 add_camera_metadata_entry(m,
1849 m_type_tags[TYPE_BYTE],
1850 &dummy_data[0],
1851 data_count + i));
1852 // insert the type we care to test
1853 ASSERT_EQ(OK,
1854 add_camera_metadata_entry(m, m_type_tags[m_type],
1855 &dummy_data[0], data_count));
1856
1857 // now check the alignment for our desired type. it should be ok
1858 camera_metadata_ro_entry_t entry = camera_metadata_ro_entry_t();
1859 ASSERT_EQ(OK,
1860 find_camera_metadata_ro_entry(m, m_type_tags[m_type],
1861 &entry));
1862
1863 void* data_ptr = (void*)entry.data.u8;
1864 void* aligned_ptr = (void*)((uintptr_t)data_ptr & ~(m_type_align[m_type] - 1));
1865 EXPECT_EQ(aligned_ptr, data_ptr) <<
1866 "Wrong alignment for type " <<
1867 camera_metadata_type_names[m_type] <<
1868 " with " << (data_count + i) << " dummy bytes and " <<
1869 " data_count " << data_count <<
1870 " expected alignment was: " << m_type_align[m_type];
1871
1872 FINISH_USING_CAMERA_METADATA(m);
1873 }
1874 }
1875 }
1876 }
1877