camera_metadata_tests.cpp revision f5fb8a5516876c5a48cc44b4f1c99504e0b9f245
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 "gtest/gtest.h" 24#include "system/camera_metadata.h" 25 26#include "camera_metadata_tests_fake_vendor.h" 27 28#define EXPECT_NULL(x) EXPECT_EQ((void*)0, x) 29#define EXPECT_NOT_NULL(x) EXPECT_NE((void*)0, x) 30 31#define OK 0 32#define ERROR 1 33#define NOT_FOUND (-ENOENT) 34 35TEST(camera_metadata, allocate_normal) { 36 camera_metadata_t *m = NULL; 37 const size_t entry_capacity = 5; 38 const size_t data_capacity = 32; 39 40 m = allocate_camera_metadata(entry_capacity, data_capacity); 41 42 EXPECT_NOT_NULL(m); 43 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m)); 44 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 45 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m)); 46 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 47 48 free_camera_metadata(m); 49} 50 51TEST(camera_metadata, allocate_nodata) { 52 camera_metadata_t *m = NULL; 53 54 m = allocate_camera_metadata(1, 0); 55 56 EXPECT_NOT_NULL(m); 57 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m)); 58 EXPECT_EQ((size_t)1, get_camera_metadata_entry_capacity(m)); 59 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m)); 60 EXPECT_EQ((size_t)0, get_camera_metadata_data_capacity(m)); 61 62 free_camera_metadata(m); 63} 64 65TEST(camera_metadata, allocate_nothing) { 66 camera_metadata_t *m = NULL; 67 68 m = allocate_camera_metadata(0, 0); 69 70 EXPECT_NULL(m); 71} 72 73TEST(camera_metadata, place_normal) { 74 camera_metadata_t *m = NULL; 75 void *buf = NULL; 76 77 const size_t entry_capacity = 5; 78 const size_t data_capacity = 32; 79 80 size_t buf_size = calculate_camera_metadata_size(entry_capacity, 81 data_capacity); 82 83 EXPECT_TRUE(buf_size > 0); 84 85 buf = malloc(buf_size); 86 87 EXPECT_NOT_NULL(buf); 88 89 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity); 90 91 EXPECT_EQ(buf, (uint8_t*)m); 92 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m)); 93 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 94 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m)); 95 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 96 97 free(buf); 98} 99 100TEST(camera_metadata, place_nospace) { 101 camera_metadata_t *m = NULL; 102 void *buf = NULL; 103 104 const size_t entry_capacity = 5; 105 const size_t data_capacity = 32; 106 107 size_t buf_size = calculate_camera_metadata_size(entry_capacity, 108 data_capacity); 109 110 EXPECT_GT(buf_size, (size_t)0); 111 112 buf_size--; 113 114 buf = malloc(buf_size); 115 116 EXPECT_NOT_NULL(buf); 117 118 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity); 119 120 EXPECT_NULL(m); 121 122 free(buf); 123} 124 125TEST(camera_metadata, place_extraspace) { 126 camera_metadata_t *m = NULL; 127 uint8_t *buf = NULL; 128 129 const size_t entry_capacity = 5; 130 const size_t data_capacity = 32; 131 const size_t extra_space = 10; 132 133 size_t buf_size = calculate_camera_metadata_size(entry_capacity, 134 data_capacity); 135 136 EXPECT_GT(buf_size, (size_t)0); 137 138 buf_size += extra_space; 139 140 buf = (uint8_t*)malloc(buf_size); 141 142 EXPECT_NOT_NULL(buf); 143 144 m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity); 145 146 EXPECT_EQ((uint8_t*)m, buf); 147 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m)); 148 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 149 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m)); 150 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 151 EXPECT_EQ(buf + buf_size - extra_space, (uint8_t*)m + get_camera_metadata_size(m)); 152 153 free(buf); 154} 155 156TEST(camera_metadata, get_size) { 157 camera_metadata_t *m = NULL; 158 const size_t entry_capacity = 5; 159 const size_t data_capacity = 32; 160 161 m = allocate_camera_metadata(entry_capacity, data_capacity); 162 163 EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity), 164 get_camera_metadata_size(m) ); 165 166 EXPECT_EQ(calculate_camera_metadata_size(0,0), 167 get_camera_metadata_compact_size(m) ); 168 169 free_camera_metadata(m); 170} 171 172TEST(camera_metadata, add_get_normal) { 173 camera_metadata_t *m = NULL; 174 const size_t entry_capacity = 5; 175 const size_t data_capacity = 80; 176 177 m = allocate_camera_metadata(entry_capacity, data_capacity); 178 179 int result; 180 size_t data_used = 0; 181 size_t entries_used = 0; 182 183 // INT64 184 185 int64_t exposure_time = 1000000000; 186 result = add_camera_metadata_entry(m, 187 ANDROID_SENSOR_EXPOSURE_TIME, 188 &exposure_time, 1); 189 EXPECT_EQ(OK, result); 190 data_used += calculate_camera_metadata_entry_data_size( 191 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1); 192 entries_used++; 193 194 // INT32 195 196 int32_t sensitivity = 800; 197 result = add_camera_metadata_entry(m, 198 ANDROID_SENSOR_SENSITIVITY, 199 &sensitivity, 1); 200 EXPECT_EQ(OK, result); 201 data_used += calculate_camera_metadata_entry_data_size( 202 get_camera_metadata_tag_type(ANDROID_SENSOR_SENSITIVITY), 1); 203 entries_used++; 204 205 // FLOAT 206 207 float focusDistance = 0.5f; 208 result = add_camera_metadata_entry(m, 209 ANDROID_LENS_FOCUS_DISTANCE, 210 &focusDistance, 1); 211 EXPECT_EQ(OK, result); 212 data_used += calculate_camera_metadata_entry_data_size( 213 get_camera_metadata_tag_type(ANDROID_LENS_FOCUS_DISTANCE), 1); 214 entries_used++; 215 216 // Array of FLOAT 217 218 float colorTransform[9] = { 219 0.9f, 0.0f, 0.0f, 220 0.2f, 0.5f, 0.0f, 221 0.0f, 0.1f, 0.7f 222 }; 223 result = add_camera_metadata_entry(m, 224 ANDROID_COLOR_TRANSFORM, 225 colorTransform, 9); 226 EXPECT_EQ(OK, result); 227 data_used += calculate_camera_metadata_entry_data_size( 228 get_camera_metadata_tag_type(ANDROID_COLOR_TRANSFORM), 9); 229 entries_used++; 230 231 // Check added entries 232 233 camera_metadata_entry entry; 234 result = get_camera_metadata_entry(m, 235 0, &entry); 236 EXPECT_EQ(OK, result); 237 EXPECT_EQ(0, (int)entry.index); 238 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, entry.tag); 239 EXPECT_EQ(TYPE_INT64, entry.type); 240 EXPECT_EQ((size_t)1, entry.count); 241 EXPECT_EQ(exposure_time, *entry.data.i64); 242 243 result = get_camera_metadata_entry(m, 244 1, &entry); 245 EXPECT_EQ(OK, result); 246 EXPECT_EQ((size_t)1, entry.index); 247 EXPECT_EQ(ANDROID_SENSOR_SENSITIVITY, entry.tag); 248 EXPECT_EQ(TYPE_INT32, entry.type); 249 EXPECT_EQ((size_t)1, entry.count); 250 EXPECT_EQ(sensitivity, *entry.data.i32); 251 252 result = get_camera_metadata_entry(m, 253 2, &entry); 254 EXPECT_EQ(OK, result); 255 EXPECT_EQ((size_t)2, entry.index); 256 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 257 EXPECT_EQ(TYPE_FLOAT, entry.type); 258 EXPECT_EQ((size_t)1, entry.count); 259 EXPECT_EQ(focusDistance, *entry.data.f); 260 261 result = get_camera_metadata_entry(m, 262 3, &entry); 263 EXPECT_EQ(OK, result); 264 EXPECT_EQ((size_t)3, entry.index); 265 EXPECT_EQ(ANDROID_COLOR_TRANSFORM, entry.tag); 266 EXPECT_EQ(TYPE_FLOAT, entry.type); 267 EXPECT_EQ((size_t)9, entry.count); 268 for (unsigned int i=0; i < entry.count; i++) { 269 EXPECT_EQ(colorTransform[i], entry.data.f[i] ); 270 } 271 272 EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity), 273 get_camera_metadata_size(m) ); 274 275 EXPECT_EQ(calculate_camera_metadata_size(entries_used, data_used), 276 get_camera_metadata_compact_size(m) ); 277 278 IF_ALOGV() { 279 dump_camera_metadata(m, 0, 2); 280 } 281 282 free_camera_metadata(m); 283} 284 285void add_test_metadata(camera_metadata_t *m, int entry_count) { 286 287 EXPECT_NOT_NULL(m); 288 289 int result; 290 size_t data_used = 0; 291 size_t entries_used = 0; 292 int64_t exposure_time; 293 for (int i=0; i < entry_count; i++ ) { 294 exposure_time = 100 + i * 100; 295 result = add_camera_metadata_entry(m, 296 ANDROID_SENSOR_EXPOSURE_TIME, 297 &exposure_time, 1); 298 EXPECT_EQ(OK, result); 299 data_used += calculate_camera_metadata_entry_data_size( 300 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1); 301 entries_used++; 302 } 303 EXPECT_EQ(data_used, get_camera_metadata_data_count(m)); 304 EXPECT_EQ(entries_used, get_camera_metadata_entry_count(m)); 305 EXPECT_GT(get_camera_metadata_data_capacity(m), 306 get_camera_metadata_data_count(m)); 307} 308 309TEST(camera_metadata, add_get_toomany) { 310 camera_metadata_t *m = NULL; 311 const size_t entry_capacity = 5; 312 const size_t data_capacity = 50; 313 int result; 314 315 m = allocate_camera_metadata(entry_capacity, data_capacity); 316 317 add_test_metadata(m, entry_capacity); 318 319 int32_t sensitivity = 100; 320 result = add_camera_metadata_entry(m, 321 ANDROID_SENSOR_SENSITIVITY, 322 &sensitivity, 1); 323 324 EXPECT_EQ(ERROR, result); 325 326 camera_metadata_entry entry; 327 for (unsigned int i=0; i < entry_capacity; i++) { 328 int64_t exposure_time = 100 + i * 100; 329 result = get_camera_metadata_entry(m, 330 i, &entry); 331 EXPECT_EQ(OK, result); 332 EXPECT_EQ(i, entry.index); 333 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, entry.tag); 334 EXPECT_EQ(TYPE_INT64, entry.type); 335 EXPECT_EQ((size_t)1, entry.count); 336 EXPECT_EQ(exposure_time, *entry.data.i64); 337 } 338 entry.tag = 1234; 339 entry.type = 56; 340 entry.data.u8 = NULL; 341 entry.count = 7890; 342 result = get_camera_metadata_entry(m, 343 entry_capacity, &entry); 344 EXPECT_EQ(ERROR, result); 345 EXPECT_EQ((uint32_t)1234, entry.tag); 346 EXPECT_EQ((uint8_t)56, entry.type); 347 EXPECT_EQ(NULL, entry.data.u8); 348 EXPECT_EQ((size_t)7890, entry.count); 349 350 IF_ALOGV() { 351 dump_camera_metadata(m, 0, 2); 352 } 353 354 free_camera_metadata(m); 355} 356 357TEST(camera_metadata, copy_metadata) { 358 camera_metadata_t *m = NULL; 359 const size_t entry_capacity = 50; 360 const size_t data_capacity = 450; 361 362 int result; 363 364 m = allocate_camera_metadata(entry_capacity, data_capacity); 365 366 add_test_metadata(m, entry_capacity); 367 368 size_t buf_size = get_camera_metadata_compact_size(m); 369 EXPECT_LT((size_t)0, buf_size); 370 371 uint8_t *buf = (uint8_t*)malloc(buf_size); 372 EXPECT_NOT_NULL(buf); 373 374 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 375 EXPECT_NOT_NULL(m2); 376 EXPECT_EQ(buf, (uint8_t*)m2); 377 EXPECT_EQ(get_camera_metadata_entry_count(m), 378 get_camera_metadata_entry_count(m2)); 379 EXPECT_EQ(get_camera_metadata_data_count(m), 380 get_camera_metadata_data_count(m2)); 381 EXPECT_EQ(get_camera_metadata_entry_capacity(m2), 382 get_camera_metadata_entry_count(m2)); 383 EXPECT_EQ(get_camera_metadata_data_capacity(m2), 384 get_camera_metadata_data_count(m2)); 385 386 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 387 camera_metadata_entry e1, e2; 388 int result; 389 result = get_camera_metadata_entry(m, i, &e1); 390 EXPECT_EQ(OK, result); 391 result = get_camera_metadata_entry(m2, i, &e2); 392 EXPECT_EQ(OK, result); 393 EXPECT_EQ(e1.index, e2.index); 394 EXPECT_EQ(e1.tag, e2.tag); 395 EXPECT_EQ(e1.type, e2.type); 396 EXPECT_EQ(e1.count, e2.count); 397 for (unsigned int j=0; 398 j < e1.count * camera_metadata_type_size[e1.type]; 399 j++) { 400 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 401 } 402 } 403 404 free(buf); 405 406 free_camera_metadata(m); 407} 408 409TEST(camera_metadata, copy_metadata_extraspace) { 410 camera_metadata_t *m = NULL; 411 const size_t entry_capacity = 12; 412 const size_t data_capacity = 100; 413 414 const size_t extra_space = 10; 415 416 int result; 417 418 m = allocate_camera_metadata(entry_capacity, data_capacity); 419 420 add_test_metadata(m, entry_capacity); 421 422 size_t buf_size = get_camera_metadata_compact_size(m); 423 EXPECT_LT((size_t)0, buf_size); 424 buf_size += extra_space; 425 426 uint8_t *buf = (uint8_t*)malloc(buf_size); 427 EXPECT_NOT_NULL(buf); 428 429 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 430 EXPECT_NOT_NULL(m2); 431 EXPECT_EQ(buf, (uint8_t*)m2); 432 EXPECT_EQ(get_camera_metadata_entry_count(m), 433 get_camera_metadata_entry_count(m2)); 434 EXPECT_EQ(get_camera_metadata_data_count(m), 435 get_camera_metadata_data_count(m2)); 436 EXPECT_EQ(get_camera_metadata_entry_capacity(m2), 437 get_camera_metadata_entry_count(m2)); 438 EXPECT_EQ(get_camera_metadata_data_capacity(m2), 439 get_camera_metadata_data_count(m2)); 440 EXPECT_EQ(buf + buf_size - extra_space, 441 (uint8_t*)m2 + get_camera_metadata_size(m2) ); 442 443 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 444 camera_metadata_entry e1, e2; 445 446 int result; 447 result = get_camera_metadata_entry(m, i, &e1); 448 EXPECT_EQ(OK, result); 449 EXPECT_EQ(i, e1.index); 450 result = get_camera_metadata_entry(m2, i, &e2); 451 EXPECT_EQ(OK, result); 452 EXPECT_EQ(e1.index, e2.index); 453 EXPECT_EQ(e1.tag, e2.tag); 454 EXPECT_EQ(e1.type, e2.type); 455 EXPECT_EQ(e1.count, e2.count); 456 for (unsigned int j=0; 457 j < e1.count * camera_metadata_type_size[e1.type]; 458 j++) { 459 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 460 } 461 } 462 463 free(buf); 464 465 free_camera_metadata(m); 466} 467 468TEST(camera_metadata, copy_metadata_nospace) { 469 camera_metadata_t *m = NULL; 470 const size_t entry_capacity = 5; 471 const size_t data_capacity = 50; 472 473 int result; 474 475 m = allocate_camera_metadata(entry_capacity, data_capacity); 476 477 add_test_metadata(m, entry_capacity); 478 479 size_t buf_size = get_camera_metadata_compact_size(m); 480 EXPECT_LT((size_t)0, buf_size); 481 482 buf_size--; 483 484 uint8_t *buf = (uint8_t*)malloc(buf_size); 485 EXPECT_NOT_NULL(buf); 486 487 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 488 EXPECT_NULL(m2); 489 490 free(buf); 491 492 free_camera_metadata(m); 493} 494 495TEST(camera_metadata, append_metadata) { 496 camera_metadata_t *m = NULL; 497 const size_t entry_capacity = 5; 498 const size_t data_capacity = 50; 499 500 int result; 501 502 m = allocate_camera_metadata(entry_capacity, data_capacity); 503 504 add_test_metadata(m, entry_capacity); 505 506 camera_metadata_t *m2 = NULL; 507 508 m2 = allocate_camera_metadata(entry_capacity*2, data_capacity*2); 509 EXPECT_NOT_NULL(m2); 510 511 result = append_camera_metadata(m2, m); 512 513 EXPECT_EQ(OK, result); 514 515 EXPECT_EQ(get_camera_metadata_entry_count(m), 516 get_camera_metadata_entry_count(m2)); 517 EXPECT_EQ(get_camera_metadata_data_count(m), 518 get_camera_metadata_data_count(m2)); 519 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2)); 520 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2)); 521 522 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 523 camera_metadata_entry e1, e2; 524 int result; 525 result = get_camera_metadata_entry(m, i, &e1); 526 EXPECT_EQ(OK, result); 527 EXPECT_EQ(i, e1.index); 528 result = get_camera_metadata_entry(m2, i, &e2); 529 EXPECT_EQ(OK, result); 530 EXPECT_EQ(e1.index, e2.index); 531 EXPECT_EQ(e1.tag, e2.tag); 532 EXPECT_EQ(e1.type, e2.type); 533 EXPECT_EQ(e1.count, e2.count); 534 for (unsigned int j=0; 535 j < e1.count * camera_metadata_type_size[e1.type]; 536 j++) { 537 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 538 } 539 } 540 541 result = append_camera_metadata(m2, m); 542 543 EXPECT_EQ(OK, result); 544 545 EXPECT_EQ(get_camera_metadata_entry_count(m)*2, 546 get_camera_metadata_entry_count(m2)); 547 EXPECT_EQ(get_camera_metadata_data_count(m)*2, 548 get_camera_metadata_data_count(m2)); 549 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2)); 550 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2)); 551 552 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) { 553 camera_metadata_entry e1, e2; 554 555 int result; 556 result = get_camera_metadata_entry(m, 557 i % entry_capacity, &e1); 558 EXPECT_EQ(OK, result); 559 EXPECT_EQ(i % entry_capacity, e1.index); 560 result = get_camera_metadata_entry(m2, 561 i, &e2); 562 EXPECT_EQ(OK, result); 563 EXPECT_EQ(i, e2.index); 564 EXPECT_EQ(e1.tag, e2.tag); 565 EXPECT_EQ(e1.type, e2.type); 566 EXPECT_EQ(e1.count, e2.count); 567 for (unsigned int j=0; 568 j < e1.count * camera_metadata_type_size[e1.type]; 569 j++) { 570 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 571 } 572 } 573 574 free_camera_metadata(m); 575 free_camera_metadata(m2); 576} 577 578TEST(camera_metadata, append_metadata_nospace) { 579 camera_metadata_t *m = NULL; 580 const size_t entry_capacity = 5; 581 const size_t data_capacity = 50; 582 583 int result; 584 585 m = allocate_camera_metadata(entry_capacity, data_capacity); 586 587 add_test_metadata(m, entry_capacity); 588 589 camera_metadata_t *m2 = NULL; 590 591 m2 = allocate_camera_metadata(entry_capacity-1, data_capacity); 592 EXPECT_NOT_NULL(m2); 593 594 result = append_camera_metadata(m2, m); 595 596 EXPECT_EQ(ERROR, result); 597 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m2)); 598 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m2)); 599 600 free_camera_metadata(m); 601 free_camera_metadata(m2); 602} 603 604TEST(camera_metadata, append_metadata_onespace) { 605 camera_metadata_t *m = NULL; 606 const size_t entry_capacity = 5; 607 const size_t data_capacity = 50; 608 const size_t entry_capacity2 = entry_capacity * 2 - 2; 609 const size_t data_capacity2 = data_capacity * 2; 610 int result; 611 612 m = allocate_camera_metadata(entry_capacity, data_capacity); 613 614 add_test_metadata(m, entry_capacity); 615 616 camera_metadata_t *m2 = NULL; 617 618 m2 = allocate_camera_metadata(entry_capacity2, data_capacity2); 619 EXPECT_NOT_NULL(m2); 620 621 result = append_camera_metadata(m2, m); 622 623 EXPECT_EQ(OK, result); 624 625 EXPECT_EQ(get_camera_metadata_entry_count(m), 626 get_camera_metadata_entry_count(m2)); 627 EXPECT_EQ(get_camera_metadata_data_count(m), 628 get_camera_metadata_data_count(m2)); 629 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2)); 630 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2)); 631 632 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 633 camera_metadata_entry e1, e2; 634 635 int result; 636 result = get_camera_metadata_entry(m, i, &e1); 637 EXPECT_EQ(OK, result); 638 EXPECT_EQ(i, e1.index); 639 result = get_camera_metadata_entry(m2, i, &e2); 640 EXPECT_EQ(OK, result); 641 EXPECT_EQ(e1.index, e2.index); 642 EXPECT_EQ(e1.tag, e2.tag); 643 EXPECT_EQ(e1.type, e2.type); 644 EXPECT_EQ(e1.count, e2.count); 645 for (unsigned int j=0; 646 j < e1.count * camera_metadata_type_size[e1.type]; 647 j++) { 648 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 649 } 650 } 651 652 result = append_camera_metadata(m2, m); 653 654 EXPECT_EQ(ERROR, result); 655 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_count(m2)); 656 EXPECT_EQ(get_camera_metadata_data_count(m), 657 get_camera_metadata_data_count(m2)); 658 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2)); 659 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2)); 660 661 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) { 662 camera_metadata_entry e1, e2; 663 664 int result; 665 result = get_camera_metadata_entry(m, 666 i % entry_capacity, &e1); 667 EXPECT_EQ(OK, result); 668 EXPECT_EQ(i % entry_capacity, e1.index); 669 result = get_camera_metadata_entry(m2, i, &e2); 670 EXPECT_EQ(OK, result); 671 EXPECT_EQ(i, e2.index); 672 EXPECT_EQ(e1.tag, e2.tag); 673 EXPECT_EQ(e1.type, e2.type); 674 EXPECT_EQ(e1.count, e2.count); 675 for (unsigned int j=0; 676 j < e1.count * camera_metadata_type_size[e1.type]; 677 j++) { 678 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 679 } 680 } 681 682 free_camera_metadata(m); 683 free_camera_metadata(m2); 684} 685 686TEST(camera_metadata, vendor_tags) { 687 camera_metadata_t *m = NULL; 688 const size_t entry_capacity = 5; 689 const size_t data_capacity = 50; 690 int result; 691 692 m = allocate_camera_metadata(entry_capacity, data_capacity); 693 694 uint8_t superMode = 5; 695 result = add_camera_metadata_entry(m, 696 FAKEVENDOR_SENSOR_SUPERMODE, 697 &superMode, 1); 698 EXPECT_EQ(ERROR, result); 699 700 result = add_camera_metadata_entry(m, 701 ANDROID_REQUEST_METADATA_MODE, 702 &superMode, 1); 703 EXPECT_EQ(OK, result); 704 705 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 706 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 707 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 708 709 set_camera_metadata_vendor_tag_ops(&fakevendor_query_ops); 710 711 result = add_camera_metadata_entry(m, 712 FAKEVENDOR_SENSOR_SUPERMODE, 713 &superMode, 1); 714 EXPECT_EQ(OK, result); 715 716 result = add_camera_metadata_entry(m, 717 ANDROID_REQUEST_METADATA_MODE, 718 &superMode, 1); 719 EXPECT_EQ(OK, result); 720 721 result = add_camera_metadata_entry(m, 722 FAKEVENDOR_SCALER_END, 723 &superMode, 1); 724 EXPECT_EQ(ERROR, result); 725 726 EXPECT_STREQ("com.fakevendor.sensor", 727 get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 728 EXPECT_STREQ("superMode", 729 get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 730 EXPECT_EQ(TYPE_BYTE, 731 get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 732 733 EXPECT_STREQ("com.fakevendor.scaler", 734 get_camera_metadata_section_name(FAKEVENDOR_SCALER_END)); 735 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SCALER_END)); 736 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SCALER_END)); 737 738 set_camera_metadata_vendor_tag_ops(NULL); 739 740 result = add_camera_metadata_entry(m, 741 FAKEVENDOR_SENSOR_SUPERMODE, 742 &superMode, 1); 743 EXPECT_EQ(ERROR, result); 744 745 result = add_camera_metadata_entry(m, 746 ANDROID_REQUEST_METADATA_MODE, 747 &superMode, 1); 748 EXPECT_EQ(OK, result); 749 750 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 751 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 752 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 753 754 free_camera_metadata(m); 755} 756 757TEST(camera_metadata, add_all_tags) { 758 int total_tag_count = 0; 759 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) { 760 total_tag_count += camera_metadata_section_bounds[i][1] - 761 camera_metadata_section_bounds[i][0]; 762 } 763 int entry_data_count = 3; 764 int conservative_data_space = total_tag_count * entry_data_count * 8; 765 uint8_t data[entry_data_count * 8]; 766 int32_t *data_int32 = (int32_t *)data; 767 float *data_float = (float *)data; 768 int64_t *data_int64 = (int64_t *)data; 769 double *data_double = (double *)data; 770 camera_metadata_rational_t *data_rational = 771 (camera_metadata_rational_t *)data; 772 773 camera_metadata_t *m = allocate_camera_metadata(total_tag_count, 774 conservative_data_space); 775 776 ASSERT_NE((void*)NULL, (void*)m); 777 778 int result; 779 780 int counter = 0; 781 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) { 782 for (uint32_t tag = camera_metadata_section_bounds[i][0]; 783 tag < camera_metadata_section_bounds[i][1]; 784 tag++, counter++) { 785 int type = get_camera_metadata_tag_type(tag); 786 ASSERT_NE(-1, type); 787 788 switch (type) { 789 case TYPE_BYTE: 790 data[0] = tag & 0xFF; 791 data[1] = (tag >> 8) & 0xFF; 792 data[2] = (tag >> 16) & 0xFF; 793 break; 794 case TYPE_INT32: 795 data_int32[0] = tag; 796 data_int32[1] = i; 797 data_int32[2] = counter; 798 break; 799 case TYPE_FLOAT: 800 data_float[0] = tag; 801 data_float[1] = i; 802 data_float[2] = counter / (float)total_tag_count; 803 break; 804 case TYPE_INT64: 805 data_int64[0] = (int64_t)tag | ( (int64_t)tag << 32); 806 data_int64[1] = i; 807 data_int64[2] = counter; 808 break; 809 case TYPE_DOUBLE: 810 data_double[0] = tag; 811 data_double[1] = i; 812 data_double[2] = counter / (double)total_tag_count; 813 break; 814 case TYPE_RATIONAL: 815 data_rational[0].numerator = tag; 816 data_rational[0].denominator = 1; 817 data_rational[1].numerator = i; 818 data_rational[1].denominator = 1; 819 data_rational[2].numerator = counter; 820 data_rational[2].denominator = total_tag_count; 821 break; 822 default: 823 FAIL() << "Unknown type field encountered:" << type; 824 break; 825 } 826 result = add_camera_metadata_entry(m, 827 tag, 828 data, 829 entry_data_count); 830 ASSERT_EQ(OK, result); 831 832 } 833 } 834 835 IF_ALOGV() { 836 dump_camera_metadata(m, 0, 2); 837 } 838 839 free_camera_metadata(m); 840} 841 842TEST(camera_metadata, sort_metadata) { 843 camera_metadata_t *m = NULL; 844 const size_t entry_capacity = 5; 845 const size_t data_capacity = 100; 846 847 int result; 848 849 m = allocate_camera_metadata(entry_capacity, data_capacity); 850 851 // Add several unique entries in non-sorted order 852 853 float colorTransform[9] = { 854 0.9f, 0.0f, 0.0f, 855 0.2f, 0.5f, 0.0f, 856 0.0f, 0.1f, 0.7f 857 }; 858 result = add_camera_metadata_entry(m, 859 ANDROID_COLOR_TRANSFORM, 860 colorTransform, 9); 861 EXPECT_EQ(OK, result); 862 863 float focus_distance = 0.5f; 864 result = add_camera_metadata_entry(m, 865 ANDROID_LENS_FOCUS_DISTANCE, 866 &focus_distance, 1); 867 EXPECT_EQ(OK, result); 868 869 int64_t exposure_time = 1000000000; 870 result = add_camera_metadata_entry(m, 871 ANDROID_SENSOR_EXPOSURE_TIME, 872 &exposure_time, 1); 873 EXPECT_EQ(OK, result); 874 875 int32_t sensitivity = 800; 876 result = add_camera_metadata_entry(m, 877 ANDROID_SENSOR_SENSITIVITY, 878 &sensitivity, 1); 879 EXPECT_EQ(OK, result); 880 881 // Test unsorted find 882 camera_metadata_entry_t entry; 883 result = find_camera_metadata_entry(m, 884 ANDROID_LENS_FOCUS_DISTANCE, 885 &entry); 886 EXPECT_EQ(OK, result); 887 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 888 EXPECT_EQ((size_t)1, entry.index); 889 EXPECT_EQ(TYPE_FLOAT, entry.type); 890 EXPECT_EQ((size_t)1, entry.count); 891 EXPECT_EQ(focus_distance, *entry.data.f); 892 893 result = find_camera_metadata_entry(m, 894 ANDROID_NOISE_STRENGTH, 895 &entry); 896 EXPECT_EQ(NOT_FOUND, result); 897 EXPECT_EQ((size_t)1, entry.index); 898 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 899 EXPECT_EQ(TYPE_FLOAT, entry.type); 900 EXPECT_EQ((size_t)1, entry.count); 901 EXPECT_EQ(focus_distance, *entry.data.f); 902 903 // Sort 904 IF_ALOGV() { 905 std::cout << "Pre-sorted metadata" << std::endl; 906 dump_camera_metadata(m, 0, 2); 907 } 908 909 result = sort_camera_metadata(m); 910 EXPECT_EQ(OK, result); 911 912 IF_ALOGV() { 913 std::cout << "Sorted metadata" << std::endl; 914 dump_camera_metadata(m, 0, 2); 915 } 916 917 // Test sorted find 918 919 result = find_camera_metadata_entry(m, 920 ANDROID_LENS_FOCUS_DISTANCE, 921 &entry); 922 EXPECT_EQ(OK, result); 923 EXPECT_EQ((size_t)0, entry.index); 924 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 925 EXPECT_EQ(TYPE_FLOAT, entry.type); 926 EXPECT_EQ((size_t)1, (size_t)entry.count); 927 EXPECT_EQ(focus_distance, *entry.data.f); 928 929 result = find_camera_metadata_entry(m, 930 ANDROID_NOISE_STRENGTH, 931 &entry); 932 EXPECT_EQ(NOT_FOUND, result); 933 EXPECT_EQ((size_t)0, entry.index); 934 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 935 EXPECT_EQ(TYPE_FLOAT, entry.type); 936 EXPECT_EQ((size_t)1, entry.count); 937 EXPECT_EQ(focus_distance, *entry.data.f); 938 939 940 free_camera_metadata(m); 941} 942 943TEST(camera_metadata, delete_metadata) { 944 camera_metadata_t *m = NULL; 945 const size_t entry_capacity = 50; 946 const size_t data_capacity = 450; 947 948 int result; 949 950 m = allocate_camera_metadata(entry_capacity, data_capacity); 951 952 size_t num_entries = 5; 953 size_t data_per_entry = 954 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 955 size_t num_data = num_entries * data_per_entry; 956 957 // Delete an entry with data 958 959 add_test_metadata(m, num_entries); 960 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 961 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 962 963 result = delete_camera_metadata_entry(m, 1); 964 EXPECT_EQ(OK, result); 965 num_entries--; 966 num_data -= data_per_entry; 967 968 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 969 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 970 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 971 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 972 973 result = delete_camera_metadata_entry(m, 4); 974 EXPECT_EQ(ERROR, result); 975 976 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 977 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 978 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 979 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 980 981 for (size_t i = 0; i < num_entries; i++) { 982 camera_metadata_entry e; 983 result = get_camera_metadata_entry(m, i, &e); 984 EXPECT_EQ(OK, result); 985 EXPECT_EQ(i, e.index); 986 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 987 EXPECT_EQ(TYPE_INT64, e.type); 988 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 989 EXPECT_EQ(exposureTime, *e.data.i64); 990 } 991 992 // Delete an entry with no data, at end of array 993 994 int32_t frameCount = 12; 995 result = add_camera_metadata_entry(m, 996 ANDROID_REQUEST_FRAME_COUNT, 997 &frameCount, 1); 998 EXPECT_EQ(OK, result); 999 num_entries++; 1000 1001 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1002 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1003 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1004 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1005 1006 camera_metadata_entry e; 1007 result = get_camera_metadata_entry(m, 4, &e); 1008 EXPECT_EQ(OK, result); 1009 1010 EXPECT_EQ((size_t)4, e.index); 1011 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1012 EXPECT_EQ(TYPE_INT32, e.type); 1013 EXPECT_EQ((size_t)1, e.count); 1014 EXPECT_EQ(frameCount, *e.data.i32); 1015 1016 result = delete_camera_metadata_entry(m, 4); 1017 EXPECT_EQ(OK, result); 1018 1019 num_entries--; 1020 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1021 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1022 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1023 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1024 1025 result = delete_camera_metadata_entry(m, 4); 1026 EXPECT_EQ(ERROR, result); 1027 1028 result = get_camera_metadata_entry(m, 4, &e); 1029 EXPECT_EQ(ERROR, result); 1030 1031 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1032 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1033 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1034 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1035 1036 // Delete with extra data on end of array 1037 result = delete_camera_metadata_entry(m, 3); 1038 EXPECT_EQ(OK, result); 1039 num_entries--; 1040 num_data -= data_per_entry; 1041 1042 for (size_t i = 0; i < num_entries; i++) { 1043 camera_metadata_entry e2; 1044 result = get_camera_metadata_entry(m, i, &e2); 1045 EXPECT_EQ(OK, result); 1046 EXPECT_EQ(i, e2.index); 1047 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1048 EXPECT_EQ(TYPE_INT64, e2.type); 1049 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 1050 EXPECT_EQ(exposureTime, *e2.data.i64); 1051 } 1052 1053 // Delete without extra data in front of array 1054 1055 frameCount = 1001; 1056 result = add_camera_metadata_entry(m, 1057 ANDROID_REQUEST_FRAME_COUNT, 1058 &frameCount, 1); 1059 EXPECT_EQ(OK, result); 1060 num_entries++; 1061 1062 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1063 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1064 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1065 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1066 1067 result = sort_camera_metadata(m); 1068 EXPECT_EQ(OK, result); 1069 1070 result = find_camera_metadata_entry(m, 1071 ANDROID_REQUEST_FRAME_COUNT, &e); 1072 EXPECT_EQ(OK, result); 1073 EXPECT_EQ((size_t)0, e.index); 1074 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1075 EXPECT_EQ(TYPE_INT32, e.type); 1076 EXPECT_EQ((size_t)1, e.count); 1077 EXPECT_EQ(frameCount, *e.data.i32); 1078 1079 result = delete_camera_metadata_entry(m, e.index); 1080 EXPECT_EQ(OK, result); 1081 num_entries--; 1082 1083 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1084 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1085 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1086 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1087 1088 for (size_t i = 0; i < num_entries; i++) { 1089 camera_metadata_entry e2; 1090 result = get_camera_metadata_entry(m, i, &e2); 1091 EXPECT_EQ(OK, result); 1092 EXPECT_EQ(i, e2.index); 1093 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1094 EXPECT_EQ(TYPE_INT64, e2.type); 1095 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 1096 EXPECT_EQ(exposureTime, *e2.data.i64); 1097 } 1098} 1099 1100TEST(camera_metadata, update_metadata) { 1101 camera_metadata_t *m = NULL; 1102 const size_t entry_capacity = 50; 1103 const size_t data_capacity = 450; 1104 1105 int result; 1106 1107 m = allocate_camera_metadata(entry_capacity, data_capacity); 1108 1109 size_t num_entries = 5; 1110 size_t data_per_entry = 1111 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 1112 size_t num_data = num_entries * data_per_entry; 1113 1114 add_test_metadata(m, num_entries); 1115 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1116 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1117 1118 // Update with same-size data, doesn't fit in entry 1119 1120 int64_t newExposureTime = 1000; 1121 camera_metadata_entry_t e; 1122 result = update_camera_metadata_entry(m, 1123 0, &newExposureTime, 1, &e); 1124 EXPECT_EQ(OK, result); 1125 1126 EXPECT_EQ((size_t)0, e.index); 1127 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1128 EXPECT_EQ(TYPE_INT64, e.type); 1129 EXPECT_EQ((size_t)1, e.count); 1130 EXPECT_EQ(newExposureTime, *e.data.i64); 1131 1132 e.count = 0; 1133 result = get_camera_metadata_entry(m, 1134 0, &e); 1135 1136 EXPECT_EQ((size_t)0, e.index); 1137 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1138 EXPECT_EQ(TYPE_INT64, e.type); 1139 EXPECT_EQ((size_t)1, e.count); 1140 EXPECT_EQ(newExposureTime, *e.data.i64); 1141 1142 for (size_t i = 1; i < num_entries; i++) { 1143 camera_metadata_entry e2; 1144 result = get_camera_metadata_entry(m, i, &e2); 1145 EXPECT_EQ(OK, result); 1146 EXPECT_EQ(i, e2.index); 1147 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1148 EXPECT_EQ(TYPE_INT64, e2.type); 1149 int64_t exposureTime = 100 + 100 * i; 1150 EXPECT_EQ(exposureTime, *e2.data.i64); 1151 } 1152 1153 // Update with larger data 1154 int64_t newExposures[2] = { 5000, 6000 }; 1155 result = update_camera_metadata_entry(m, 1156 0, newExposures, 2, &e); 1157 EXPECT_EQ(OK, result); 1158 num_data += data_per_entry; 1159 1160 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1161 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1162 1163 EXPECT_EQ((size_t)0, e.index); 1164 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1165 EXPECT_EQ(TYPE_INT64, e.type); 1166 EXPECT_EQ((size_t)2, e.count); 1167 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1168 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1169 1170 e.count = 0; 1171 result = get_camera_metadata_entry(m, 1172 0, &e); 1173 1174 EXPECT_EQ((size_t)0, e.index); 1175 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1176 EXPECT_EQ(TYPE_INT64, e.type); 1177 EXPECT_EQ((size_t)2, e.count); 1178 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1179 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1180 1181 for (size_t i = 1; i < num_entries; i++) { 1182 camera_metadata_entry e2; 1183 result = get_camera_metadata_entry(m, i, &e2); 1184 EXPECT_EQ(OK, result); 1185 EXPECT_EQ(i, e2.index); 1186 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1187 EXPECT_EQ(TYPE_INT64, e2.type); 1188 int64_t exposureTime = 100 + 100 * i; 1189 EXPECT_EQ(exposureTime, *e2.data.i64); 1190 } 1191 1192 // Update with smaller data 1193 newExposureTime = 100; 1194 result = update_camera_metadata_entry(m, 1195 0, &newExposureTime, 1, &e); 1196 EXPECT_EQ(OK, result); 1197 1198 num_data -= data_per_entry; 1199 1200 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1201 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1202 1203 EXPECT_EQ((size_t)0, e.index); 1204 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1205 EXPECT_EQ(TYPE_INT64, e.type); 1206 EXPECT_EQ((size_t)1, e.count); 1207 EXPECT_EQ(newExposureTime, *e.data.i64); 1208 1209 e.count = 0; 1210 result = get_camera_metadata_entry(m, 1211 0, &e); 1212 1213 EXPECT_EQ((size_t)0, e.index); 1214 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1215 EXPECT_EQ(TYPE_INT64, e.type); 1216 EXPECT_EQ((size_t)1, e.count); 1217 EXPECT_EQ(newExposureTime, *e.data.i64); 1218 1219 for (size_t i = 1; i < num_entries; i++) { 1220 camera_metadata_entry e2; 1221 result = get_camera_metadata_entry(m, i, &e2); 1222 EXPECT_EQ(OK, result); 1223 EXPECT_EQ(i, e2.index); 1224 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1225 EXPECT_EQ(TYPE_INT64, e2.type); 1226 int64_t exposureTime = 100 + 100 * i; 1227 EXPECT_EQ(exposureTime, *e2.data.i64); 1228 } 1229 1230 // Update with size fitting in entry 1231 1232 int32_t frameCount = 1001; 1233 result = add_camera_metadata_entry(m, 1234 ANDROID_REQUEST_FRAME_COUNT, 1235 &frameCount, 1); 1236 EXPECT_EQ(OK, result); 1237 num_entries++; 1238 1239 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1240 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1241 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1242 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1243 1244 result = sort_camera_metadata(m); 1245 EXPECT_EQ(OK, result); 1246 1247 result = find_camera_metadata_entry(m, 1248 ANDROID_REQUEST_FRAME_COUNT, &e); 1249 EXPECT_EQ(OK, result); 1250 EXPECT_EQ((size_t)0, e.index); 1251 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1252 EXPECT_EQ(TYPE_INT32, e.type); 1253 EXPECT_EQ((size_t)1, e.count); 1254 EXPECT_EQ(frameCount, *e.data.i32); 1255 1256 int32_t newFrameCount = 0x12349876; 1257 result = update_camera_metadata_entry(m, 1258 0, &newFrameCount, 1, &e); 1259 1260 EXPECT_EQ(OK, result); 1261 EXPECT_EQ((size_t)0, e.index); 1262 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1263 EXPECT_EQ(TYPE_INT32, e.type); 1264 EXPECT_EQ((size_t)1, e.count); 1265 EXPECT_EQ(newFrameCount, *e.data.i32); 1266 1267 result = find_camera_metadata_entry(m, 1268 ANDROID_REQUEST_FRAME_COUNT, &e); 1269 1270 EXPECT_EQ(OK, result); 1271 EXPECT_EQ((size_t)0, e.index); 1272 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1273 EXPECT_EQ(TYPE_INT32, e.type); 1274 EXPECT_EQ((size_t)1, e.count); 1275 EXPECT_EQ(newFrameCount, *e.data.i32); 1276 1277 for (size_t i = 1; i < num_entries; i++) { 1278 camera_metadata_entry e2; 1279 result = get_camera_metadata_entry(m, i, &e2); 1280 EXPECT_EQ(OK, result); 1281 EXPECT_EQ(i, e2.index); 1282 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1283 EXPECT_EQ(TYPE_INT64, e2.type); 1284 int64_t exposureTime = 100 * i; 1285 EXPECT_EQ(exposureTime, *e2.data.i64); 1286 } 1287 1288 // Update to bigger than entry 1289 1290 int32_t newFrameCounts[4] = { 0x0, 0x1, 0x10, 0x100 }; 1291 1292 result = update_camera_metadata_entry(m, 1293 0, &newFrameCounts, 4, &e); 1294 1295 EXPECT_EQ(OK, result); 1296 1297 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT32, 1298 4); 1299 1300 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1301 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1302 1303 EXPECT_EQ((size_t)0, e.index); 1304 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1305 EXPECT_EQ(TYPE_INT32, e.type); 1306 EXPECT_EQ((size_t)4, e.count); 1307 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]); 1308 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]); 1309 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]); 1310 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]); 1311 1312 e.count = 0; 1313 1314 result = find_camera_metadata_entry(m, 1315 ANDROID_REQUEST_FRAME_COUNT, &e); 1316 1317 EXPECT_EQ(OK, result); 1318 EXPECT_EQ((size_t)0, e.index); 1319 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1320 EXPECT_EQ(TYPE_INT32, e.type); 1321 EXPECT_EQ((size_t)4, e.count); 1322 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]); 1323 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]); 1324 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]); 1325 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]); 1326 1327 for (size_t i = 1; i < num_entries; i++) { 1328 camera_metadata_entry e2; 1329 result = get_camera_metadata_entry(m, i, &e2); 1330 EXPECT_EQ(OK, result); 1331 EXPECT_EQ(i, e2.index); 1332 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1333 EXPECT_EQ(TYPE_INT64, e2.type); 1334 int64_t exposureTime = 100 * i; 1335 EXPECT_EQ(exposureTime, *e2.data.i64); 1336 } 1337 1338 // Update to smaller than entry 1339 result = update_camera_metadata_entry(m, 1340 0, &newFrameCount, 1, &e); 1341 1342 EXPECT_EQ(OK, result); 1343 1344 num_data -= camera_metadata_type_size[TYPE_INT32] * 4; 1345 1346 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1347 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1348 1349 EXPECT_EQ((size_t)0, e.index); 1350 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1351 EXPECT_EQ(TYPE_INT32, e.type); 1352 EXPECT_EQ((size_t)1, e.count); 1353 EXPECT_EQ(newFrameCount, *e.data.i32); 1354 1355 result = find_camera_metadata_entry(m, 1356 ANDROID_REQUEST_FRAME_COUNT, &e); 1357 1358 EXPECT_EQ(OK, result); 1359 EXPECT_EQ((size_t)0, e.index); 1360 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1361 EXPECT_EQ(TYPE_INT32, e.type); 1362 EXPECT_EQ((size_t)1, e.count); 1363 EXPECT_EQ(newFrameCount, *e.data.i32); 1364 1365 for (size_t i = 1; i < num_entries; i++) { 1366 camera_metadata_entry_t e2; 1367 result = get_camera_metadata_entry(m, i, &e2); 1368 EXPECT_EQ(OK, result); 1369 EXPECT_EQ(i, e2.index); 1370 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1371 EXPECT_EQ(TYPE_INT64, e2.type); 1372 int64_t exposureTime = 100 * i; 1373 EXPECT_EQ(exposureTime, *e2.data.i64); 1374 } 1375 1376 // Setup new buffer with no spare data space 1377 1378 result = update_camera_metadata_entry(m, 1379 1, newExposures, 2, &e); 1380 EXPECT_EQ(OK, result); 1381 1382 num_data += data_per_entry; 1383 1384 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1385 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1386 1387 EXPECT_EQ((size_t)1, e.index); 1388 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1389 EXPECT_EQ(TYPE_INT64, e.type); 1390 EXPECT_EQ((size_t)2, e.count); 1391 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1392 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1393 1394 camera_metadata_t *m2; 1395 m2 = allocate_camera_metadata(get_camera_metadata_entry_count(m), 1396 get_camera_metadata_data_count(m)); 1397 EXPECT_NOT_NULL(m2); 1398 1399 result = append_camera_metadata(m2, m); 1400 EXPECT_EQ(OK, result); 1401 1402 result = find_camera_metadata_entry(m2, 1403 ANDROID_REQUEST_FRAME_COUNT, &e); 1404 1405 EXPECT_EQ(OK, result); 1406 EXPECT_EQ((size_t)0, e.index); 1407 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1408 EXPECT_EQ(TYPE_INT32, e.type); 1409 EXPECT_EQ((size_t)1, e.count); 1410 EXPECT_EQ(newFrameCount, *e.data.i32); 1411 1412 // Update when there's no more room 1413 1414 result = update_camera_metadata_entry(m2, 1415 0, &newFrameCounts, 4, &e); 1416 EXPECT_EQ(ERROR, result); 1417 1418 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1419 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1420 1421 EXPECT_EQ((size_t)0, e.index); 1422 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1423 EXPECT_EQ(TYPE_INT32, e.type); 1424 EXPECT_EQ((size_t)1, e.count); 1425 EXPECT_EQ(newFrameCount, *e.data.i32); 1426 1427 // Update when there's no data room, but change fits into entry 1428 1429 newFrameCount = 5; 1430 result = update_camera_metadata_entry(m2, 1431 0, &newFrameCount, 1, &e); 1432 EXPECT_EQ(OK, result); 1433 1434 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1435 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1436 1437 EXPECT_EQ((size_t)0, e.index); 1438 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1439 EXPECT_EQ(TYPE_INT32, e.type); 1440 EXPECT_EQ((size_t)1, e.count); 1441 EXPECT_EQ(newFrameCount, *e.data.i32); 1442 1443 result = find_camera_metadata_entry(m2, 1444 ANDROID_REQUEST_FRAME_COUNT, &e); 1445 1446 EXPECT_EQ(OK, result); 1447 EXPECT_EQ((size_t)0, e.index); 1448 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1449 EXPECT_EQ(TYPE_INT32, e.type); 1450 EXPECT_EQ((size_t)1, e.count); 1451 EXPECT_EQ(newFrameCount, *e.data.i32); 1452 1453 result = get_camera_metadata_entry(m2, 1, &e); 1454 EXPECT_EQ((size_t)1, e.index); 1455 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1456 EXPECT_EQ(TYPE_INT64, e.type); 1457 EXPECT_EQ((size_t)2, e.count); 1458 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1459 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1460 1461 for (size_t i = 2; i < num_entries; i++) { 1462 camera_metadata_entry_t e2; 1463 result = get_camera_metadata_entry(m2, i, &e2); 1464 EXPECT_EQ(OK, result); 1465 EXPECT_EQ(i, e2.index); 1466 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1467 EXPECT_EQ(TYPE_INT64, e2.type); 1468 int64_t exposureTime = 100 * i; 1469 EXPECT_EQ(exposureTime, *e2.data.i64); 1470 } 1471 1472 // Update when there's no data room, but data size doesn't change 1473 1474 newExposures[0] = 1000; 1475 1476 result = update_camera_metadata_entry(m2, 1477 1, newExposures, 2, &e); 1478 EXPECT_EQ(OK, result); 1479 1480 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1481 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1482 1483 EXPECT_EQ((size_t)1, e.index); 1484 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1485 EXPECT_EQ(TYPE_INT64, e.type); 1486 EXPECT_EQ((size_t)2, e.count); 1487 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1488 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1489 1490 result = find_camera_metadata_entry(m2, 1491 ANDROID_REQUEST_FRAME_COUNT, &e); 1492 1493 EXPECT_EQ(OK, result); 1494 EXPECT_EQ((size_t)0, e.index); 1495 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1496 EXPECT_EQ(TYPE_INT32, e.type); 1497 EXPECT_EQ((size_t)1, e.count); 1498 EXPECT_EQ(newFrameCount, *e.data.i32); 1499 1500 for (size_t i = 2; i < num_entries; i++) { 1501 camera_metadata_entry_t e2; 1502 result = get_camera_metadata_entry(m2, i, &e2); 1503 EXPECT_EQ(OK, result); 1504 EXPECT_EQ(i, e2.index); 1505 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1506 EXPECT_EQ(TYPE_INT64, e2.type); 1507 int64_t exposureTime = 100 * i; 1508 EXPECT_EQ(exposureTime, *e2.data.i64); 1509 } 1510 1511 // Update when there's no data room, but data size shrinks 1512 1513 result = update_camera_metadata_entry(m2, 1514 1, &newExposureTime, 1, &e); 1515 EXPECT_EQ(OK, result); 1516 1517 num_data -= calculate_camera_metadata_entry_data_size(TYPE_INT64, 2); 1518 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 1519 1520 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1521 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1522 1523 EXPECT_EQ((size_t)1, e.index); 1524 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1525 EXPECT_EQ(TYPE_INT64, e.type); 1526 EXPECT_EQ((size_t)1, e.count); 1527 EXPECT_EQ(newExposureTime, e.data.i64[0]); 1528 1529 result = find_camera_metadata_entry(m2, 1530 ANDROID_REQUEST_FRAME_COUNT, &e); 1531 1532 EXPECT_EQ(OK, result); 1533 EXPECT_EQ((size_t)0, e.index); 1534 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1535 EXPECT_EQ(TYPE_INT32, e.type); 1536 EXPECT_EQ((size_t)1, e.count); 1537 EXPECT_EQ(newFrameCount, *e.data.i32); 1538 1539 for (size_t i = 2; i < num_entries; i++) { 1540 camera_metadata_entry_t e2; 1541 result = get_camera_metadata_entry(m2, i, &e2); 1542 EXPECT_EQ(OK, result); 1543 EXPECT_EQ(i, e2.index); 1544 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1545 EXPECT_EQ(TYPE_INT64, e2.type); 1546 int64_t exposureTime = 100 * i; 1547 EXPECT_EQ(exposureTime, *e2.data.i64); 1548 } 1549 1550} 1551