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