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