camera_metadata_tests.cpp revision b10d56ad43a91924d3666127963e5fdce725389c
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_GE(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, add_too_much_data) { 358 camera_metadata_t *m = NULL; 359 const size_t entry_capacity = 5; 360 int result; 361 size_t data_used = entry_capacity * calculate_camera_metadata_entry_data_size( 362 get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1); 363 m = allocate_camera_metadata(entry_capacity + 1, data_used); 364 365 366 add_test_metadata(m, entry_capacity); 367 368 int64_t exposure_time = 12345; 369 result = add_camera_metadata_entry(m, 370 ANDROID_SENSOR_EXPOSURE_TIME, 371 &exposure_time, 1); 372 EXPECT_EQ(ERROR, result); 373 374 free_camera_metadata(m); 375} 376 377TEST(camera_metadata, copy_metadata) { 378 camera_metadata_t *m = NULL; 379 const size_t entry_capacity = 50; 380 const size_t data_capacity = 450; 381 382 int result; 383 384 m = allocate_camera_metadata(entry_capacity, data_capacity); 385 386 add_test_metadata(m, entry_capacity); 387 388 size_t buf_size = get_camera_metadata_compact_size(m); 389 EXPECT_LT((size_t)0, buf_size); 390 391 uint8_t *buf = (uint8_t*)malloc(buf_size); 392 EXPECT_NOT_NULL(buf); 393 394 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 395 EXPECT_NOT_NULL(m2); 396 EXPECT_EQ(buf, (uint8_t*)m2); 397 EXPECT_EQ(get_camera_metadata_entry_count(m), 398 get_camera_metadata_entry_count(m2)); 399 EXPECT_EQ(get_camera_metadata_data_count(m), 400 get_camera_metadata_data_count(m2)); 401 EXPECT_EQ(get_camera_metadata_entry_capacity(m2), 402 get_camera_metadata_entry_count(m2)); 403 EXPECT_EQ(get_camera_metadata_data_capacity(m2), 404 get_camera_metadata_data_count(m2)); 405 406 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 407 camera_metadata_entry e1, e2; 408 int result; 409 result = get_camera_metadata_entry(m, i, &e1); 410 EXPECT_EQ(OK, result); 411 result = get_camera_metadata_entry(m2, i, &e2); 412 EXPECT_EQ(OK, result); 413 EXPECT_EQ(e1.index, e2.index); 414 EXPECT_EQ(e1.tag, e2.tag); 415 EXPECT_EQ(e1.type, e2.type); 416 EXPECT_EQ(e1.count, e2.count); 417 for (unsigned int j=0; 418 j < e1.count * camera_metadata_type_size[e1.type]; 419 j++) { 420 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 421 } 422 } 423 424 free(buf); 425 426 free_camera_metadata(m); 427} 428 429TEST(camera_metadata, copy_metadata_extraspace) { 430 camera_metadata_t *m = NULL; 431 const size_t entry_capacity = 12; 432 const size_t data_capacity = 100; 433 434 const size_t extra_space = 10; 435 436 int result; 437 438 m = allocate_camera_metadata(entry_capacity, data_capacity); 439 440 add_test_metadata(m, entry_capacity); 441 442 size_t buf_size = get_camera_metadata_compact_size(m); 443 EXPECT_LT((size_t)0, buf_size); 444 buf_size += extra_space; 445 446 uint8_t *buf = (uint8_t*)malloc(buf_size); 447 EXPECT_NOT_NULL(buf); 448 449 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 450 EXPECT_NOT_NULL(m2); 451 EXPECT_EQ(buf, (uint8_t*)m2); 452 EXPECT_EQ(get_camera_metadata_entry_count(m), 453 get_camera_metadata_entry_count(m2)); 454 EXPECT_EQ(get_camera_metadata_data_count(m), 455 get_camera_metadata_data_count(m2)); 456 EXPECT_EQ(get_camera_metadata_entry_capacity(m2), 457 get_camera_metadata_entry_count(m2)); 458 EXPECT_EQ(get_camera_metadata_data_capacity(m2), 459 get_camera_metadata_data_count(m2)); 460 EXPECT_EQ(buf + buf_size - extra_space, 461 (uint8_t*)m2 + get_camera_metadata_size(m2) ); 462 463 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 464 camera_metadata_entry e1, e2; 465 466 int result; 467 result = get_camera_metadata_entry(m, i, &e1); 468 EXPECT_EQ(OK, result); 469 EXPECT_EQ(i, e1.index); 470 result = get_camera_metadata_entry(m2, i, &e2); 471 EXPECT_EQ(OK, result); 472 EXPECT_EQ(e1.index, e2.index); 473 EXPECT_EQ(e1.tag, e2.tag); 474 EXPECT_EQ(e1.type, e2.type); 475 EXPECT_EQ(e1.count, e2.count); 476 for (unsigned int j=0; 477 j < e1.count * camera_metadata_type_size[e1.type]; 478 j++) { 479 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 480 } 481 } 482 483 free(buf); 484 485 free_camera_metadata(m); 486} 487 488TEST(camera_metadata, copy_metadata_nospace) { 489 camera_metadata_t *m = NULL; 490 const size_t entry_capacity = 5; 491 const size_t data_capacity = 50; 492 493 int result; 494 495 m = allocate_camera_metadata(entry_capacity, data_capacity); 496 497 add_test_metadata(m, entry_capacity); 498 499 size_t buf_size = get_camera_metadata_compact_size(m); 500 EXPECT_LT((size_t)0, buf_size); 501 502 buf_size--; 503 504 uint8_t *buf = (uint8_t*)malloc(buf_size); 505 EXPECT_NOT_NULL(buf); 506 507 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 508 EXPECT_NULL(m2); 509 510 free(buf); 511 512 free_camera_metadata(m); 513} 514 515TEST(camera_metadata, append_metadata) { 516 camera_metadata_t *m = NULL; 517 const size_t entry_capacity = 5; 518 const size_t data_capacity = 50; 519 520 int result; 521 522 m = allocate_camera_metadata(entry_capacity, data_capacity); 523 524 add_test_metadata(m, entry_capacity); 525 526 camera_metadata_t *m2 = NULL; 527 528 m2 = allocate_camera_metadata(entry_capacity*2, data_capacity*2); 529 EXPECT_NOT_NULL(m2); 530 531 result = append_camera_metadata(m2, m); 532 533 EXPECT_EQ(OK, result); 534 535 EXPECT_EQ(get_camera_metadata_entry_count(m), 536 get_camera_metadata_entry_count(m2)); 537 EXPECT_EQ(get_camera_metadata_data_count(m), 538 get_camera_metadata_data_count(m2)); 539 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2)); 540 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2)); 541 542 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 543 camera_metadata_entry e1, e2; 544 int result; 545 result = get_camera_metadata_entry(m, i, &e1); 546 EXPECT_EQ(OK, result); 547 EXPECT_EQ(i, e1.index); 548 result = get_camera_metadata_entry(m2, i, &e2); 549 EXPECT_EQ(OK, result); 550 EXPECT_EQ(e1.index, e2.index); 551 EXPECT_EQ(e1.tag, e2.tag); 552 EXPECT_EQ(e1.type, e2.type); 553 EXPECT_EQ(e1.count, e2.count); 554 for (unsigned int j=0; 555 j < e1.count * camera_metadata_type_size[e1.type]; 556 j++) { 557 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 558 } 559 } 560 561 result = append_camera_metadata(m2, m); 562 563 EXPECT_EQ(OK, result); 564 565 EXPECT_EQ(get_camera_metadata_entry_count(m)*2, 566 get_camera_metadata_entry_count(m2)); 567 EXPECT_EQ(get_camera_metadata_data_count(m)*2, 568 get_camera_metadata_data_count(m2)); 569 EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2)); 570 EXPECT_EQ(data_capacity*2, get_camera_metadata_data_capacity(m2)); 571 572 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) { 573 camera_metadata_entry e1, e2; 574 575 int result; 576 result = get_camera_metadata_entry(m, 577 i % entry_capacity, &e1); 578 EXPECT_EQ(OK, result); 579 EXPECT_EQ(i % entry_capacity, e1.index); 580 result = get_camera_metadata_entry(m2, 581 i, &e2); 582 EXPECT_EQ(OK, result); 583 EXPECT_EQ(i, e2.index); 584 EXPECT_EQ(e1.tag, e2.tag); 585 EXPECT_EQ(e1.type, e2.type); 586 EXPECT_EQ(e1.count, e2.count); 587 for (unsigned int j=0; 588 j < e1.count * camera_metadata_type_size[e1.type]; 589 j++) { 590 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 591 } 592 } 593 594 free_camera_metadata(m); 595 free_camera_metadata(m2); 596} 597 598TEST(camera_metadata, append_metadata_nospace) { 599 camera_metadata_t *m = NULL; 600 const size_t entry_capacity = 5; 601 const size_t data_capacity = 50; 602 603 int result; 604 605 m = allocate_camera_metadata(entry_capacity, data_capacity); 606 607 add_test_metadata(m, entry_capacity); 608 609 camera_metadata_t *m2 = NULL; 610 611 m2 = allocate_camera_metadata(entry_capacity-1, data_capacity); 612 EXPECT_NOT_NULL(m2); 613 614 result = append_camera_metadata(m2, m); 615 616 EXPECT_EQ(ERROR, result); 617 EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m2)); 618 EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m2)); 619 620 free_camera_metadata(m); 621 free_camera_metadata(m2); 622} 623 624TEST(camera_metadata, append_metadata_onespace) { 625 camera_metadata_t *m = NULL; 626 const size_t entry_capacity = 5; 627 const size_t data_capacity = 50; 628 const size_t entry_capacity2 = entry_capacity * 2 - 2; 629 const size_t data_capacity2 = data_capacity * 2; 630 int result; 631 632 m = allocate_camera_metadata(entry_capacity, data_capacity); 633 634 add_test_metadata(m, entry_capacity); 635 636 camera_metadata_t *m2 = NULL; 637 638 m2 = allocate_camera_metadata(entry_capacity2, data_capacity2); 639 EXPECT_NOT_NULL(m2); 640 641 result = append_camera_metadata(m2, m); 642 643 EXPECT_EQ(OK, result); 644 645 EXPECT_EQ(get_camera_metadata_entry_count(m), 646 get_camera_metadata_entry_count(m2)); 647 EXPECT_EQ(get_camera_metadata_data_count(m), 648 get_camera_metadata_data_count(m2)); 649 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2)); 650 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2)); 651 652 for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) { 653 camera_metadata_entry e1, e2; 654 655 int result; 656 result = get_camera_metadata_entry(m, i, &e1); 657 EXPECT_EQ(OK, result); 658 EXPECT_EQ(i, e1.index); 659 result = get_camera_metadata_entry(m2, i, &e2); 660 EXPECT_EQ(OK, result); 661 EXPECT_EQ(e1.index, e2.index); 662 EXPECT_EQ(e1.tag, e2.tag); 663 EXPECT_EQ(e1.type, e2.type); 664 EXPECT_EQ(e1.count, e2.count); 665 for (unsigned int j=0; 666 j < e1.count * camera_metadata_type_size[e1.type]; 667 j++) { 668 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 669 } 670 } 671 672 result = append_camera_metadata(m2, m); 673 674 EXPECT_EQ(ERROR, result); 675 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_count(m2)); 676 EXPECT_EQ(get_camera_metadata_data_count(m), 677 get_camera_metadata_data_count(m2)); 678 EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2)); 679 EXPECT_EQ(data_capacity2, get_camera_metadata_data_capacity(m2)); 680 681 for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) { 682 camera_metadata_entry e1, e2; 683 684 int result; 685 result = get_camera_metadata_entry(m, 686 i % entry_capacity, &e1); 687 EXPECT_EQ(OK, result); 688 EXPECT_EQ(i % entry_capacity, e1.index); 689 result = get_camera_metadata_entry(m2, i, &e2); 690 EXPECT_EQ(OK, result); 691 EXPECT_EQ(i, e2.index); 692 EXPECT_EQ(e1.tag, e2.tag); 693 EXPECT_EQ(e1.type, e2.type); 694 EXPECT_EQ(e1.count, e2.count); 695 for (unsigned int j=0; 696 j < e1.count * camera_metadata_type_size[e1.type]; 697 j++) { 698 EXPECT_EQ(e1.data.u8[j], e2.data.u8[j]); 699 } 700 } 701 702 free_camera_metadata(m); 703 free_camera_metadata(m2); 704} 705 706TEST(camera_metadata, vendor_tags) { 707 camera_metadata_t *m = NULL; 708 const size_t entry_capacity = 5; 709 const size_t data_capacity = 50; 710 int result; 711 712 m = allocate_camera_metadata(entry_capacity, data_capacity); 713 714 uint8_t superMode = 5; 715 result = add_camera_metadata_entry(m, 716 FAKEVENDOR_SENSOR_SUPERMODE, 717 &superMode, 1); 718 EXPECT_EQ(ERROR, result); 719 720 result = add_camera_metadata_entry(m, 721 ANDROID_REQUEST_METADATA_MODE, 722 &superMode, 1); 723 EXPECT_EQ(OK, result); 724 725 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 726 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 727 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 728 729 set_camera_metadata_vendor_tag_ops(&fakevendor_query_ops); 730 731 result = add_camera_metadata_entry(m, 732 FAKEVENDOR_SENSOR_SUPERMODE, 733 &superMode, 1); 734 EXPECT_EQ(OK, result); 735 736 result = add_camera_metadata_entry(m, 737 ANDROID_REQUEST_METADATA_MODE, 738 &superMode, 1); 739 EXPECT_EQ(OK, result); 740 741 result = add_camera_metadata_entry(m, 742 FAKEVENDOR_SCALER_END, 743 &superMode, 1); 744 EXPECT_EQ(ERROR, result); 745 746 EXPECT_STREQ("com.fakevendor.sensor", 747 get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 748 EXPECT_STREQ("superMode", 749 get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 750 EXPECT_EQ(TYPE_BYTE, 751 get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 752 753 EXPECT_STREQ("com.fakevendor.scaler", 754 get_camera_metadata_section_name(FAKEVENDOR_SCALER_END)); 755 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SCALER_END)); 756 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SCALER_END)); 757 758 set_camera_metadata_vendor_tag_ops(NULL); 759 760 result = add_camera_metadata_entry(m, 761 FAKEVENDOR_SENSOR_SUPERMODE, 762 &superMode, 1); 763 EXPECT_EQ(ERROR, result); 764 765 result = add_camera_metadata_entry(m, 766 ANDROID_REQUEST_METADATA_MODE, 767 &superMode, 1); 768 EXPECT_EQ(OK, result); 769 770 EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE)); 771 EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE)); 772 EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE)); 773 774 free_camera_metadata(m); 775} 776 777TEST(camera_metadata, add_all_tags) { 778 int total_tag_count = 0; 779 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) { 780 total_tag_count += camera_metadata_section_bounds[i][1] - 781 camera_metadata_section_bounds[i][0]; 782 } 783 int entry_data_count = 3; 784 int conservative_data_space = total_tag_count * entry_data_count * 8; 785 uint8_t data[entry_data_count * 8]; 786 int32_t *data_int32 = (int32_t *)data; 787 float *data_float = (float *)data; 788 int64_t *data_int64 = (int64_t *)data; 789 double *data_double = (double *)data; 790 camera_metadata_rational_t *data_rational = 791 (camera_metadata_rational_t *)data; 792 793 camera_metadata_t *m = allocate_camera_metadata(total_tag_count, 794 conservative_data_space); 795 796 ASSERT_NE((void*)NULL, (void*)m); 797 798 int result; 799 800 int counter = 0; 801 for (int i = 0; i < ANDROID_SECTION_COUNT; i++) { 802 for (uint32_t tag = camera_metadata_section_bounds[i][0]; 803 tag < camera_metadata_section_bounds[i][1]; 804 tag++, counter++) { 805 int type = get_camera_metadata_tag_type(tag); 806 ASSERT_NE(-1, type); 807 808 switch (type) { 809 case TYPE_BYTE: 810 data[0] = tag & 0xFF; 811 data[1] = (tag >> 8) & 0xFF; 812 data[2] = (tag >> 16) & 0xFF; 813 break; 814 case TYPE_INT32: 815 data_int32[0] = tag; 816 data_int32[1] = i; 817 data_int32[2] = counter; 818 break; 819 case TYPE_FLOAT: 820 data_float[0] = tag; 821 data_float[1] = i; 822 data_float[2] = counter / (float)total_tag_count; 823 break; 824 case TYPE_INT64: 825 data_int64[0] = (int64_t)tag | ( (int64_t)tag << 32); 826 data_int64[1] = i; 827 data_int64[2] = counter; 828 break; 829 case TYPE_DOUBLE: 830 data_double[0] = tag; 831 data_double[1] = i; 832 data_double[2] = counter / (double)total_tag_count; 833 break; 834 case TYPE_RATIONAL: 835 data_rational[0].numerator = tag; 836 data_rational[0].denominator = 1; 837 data_rational[1].numerator = i; 838 data_rational[1].denominator = 1; 839 data_rational[2].numerator = counter; 840 data_rational[2].denominator = total_tag_count; 841 break; 842 default: 843 FAIL() << "Unknown type field encountered:" << type; 844 break; 845 } 846 result = add_camera_metadata_entry(m, 847 tag, 848 data, 849 entry_data_count); 850 ASSERT_EQ(OK, result); 851 852 } 853 } 854 855 IF_ALOGV() { 856 dump_camera_metadata(m, 0, 2); 857 } 858 859 free_camera_metadata(m); 860} 861 862TEST(camera_metadata, sort_metadata) { 863 camera_metadata_t *m = NULL; 864 const size_t entry_capacity = 5; 865 const size_t data_capacity = 100; 866 867 int result; 868 869 m = allocate_camera_metadata(entry_capacity, data_capacity); 870 871 // Add several unique entries in non-sorted order 872 873 float colorTransform[9] = { 874 0.9f, 0.0f, 0.0f, 875 0.2f, 0.5f, 0.0f, 876 0.0f, 0.1f, 0.7f 877 }; 878 result = add_camera_metadata_entry(m, 879 ANDROID_COLOR_TRANSFORM, 880 colorTransform, 9); 881 EXPECT_EQ(OK, result); 882 883 float focus_distance = 0.5f; 884 result = add_camera_metadata_entry(m, 885 ANDROID_LENS_FOCUS_DISTANCE, 886 &focus_distance, 1); 887 EXPECT_EQ(OK, result); 888 889 int64_t exposure_time = 1000000000; 890 result = add_camera_metadata_entry(m, 891 ANDROID_SENSOR_EXPOSURE_TIME, 892 &exposure_time, 1); 893 EXPECT_EQ(OK, result); 894 895 int32_t sensitivity = 800; 896 result = add_camera_metadata_entry(m, 897 ANDROID_SENSOR_SENSITIVITY, 898 &sensitivity, 1); 899 EXPECT_EQ(OK, result); 900 901 // Test unsorted find 902 camera_metadata_entry_t entry; 903 result = find_camera_metadata_entry(m, 904 ANDROID_LENS_FOCUS_DISTANCE, 905 &entry); 906 EXPECT_EQ(OK, result); 907 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 908 EXPECT_EQ((size_t)1, entry.index); 909 EXPECT_EQ(TYPE_FLOAT, entry.type); 910 EXPECT_EQ((size_t)1, entry.count); 911 EXPECT_EQ(focus_distance, *entry.data.f); 912 913 result = find_camera_metadata_entry(m, 914 ANDROID_NOISE_STRENGTH, 915 &entry); 916 EXPECT_EQ(NOT_FOUND, result); 917 EXPECT_EQ((size_t)1, entry.index); 918 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 919 EXPECT_EQ(TYPE_FLOAT, entry.type); 920 EXPECT_EQ((size_t)1, entry.count); 921 EXPECT_EQ(focus_distance, *entry.data.f); 922 923 // Sort 924 IF_ALOGV() { 925 std::cout << "Pre-sorted metadata" << std::endl; 926 dump_camera_metadata(m, 0, 2); 927 } 928 929 result = sort_camera_metadata(m); 930 EXPECT_EQ(OK, result); 931 932 IF_ALOGV() { 933 std::cout << "Sorted metadata" << std::endl; 934 dump_camera_metadata(m, 0, 2); 935 } 936 937 // Test sorted find 938 939 result = find_camera_metadata_entry(m, 940 ANDROID_LENS_FOCUS_DISTANCE, 941 &entry); 942 EXPECT_EQ(OK, result); 943 EXPECT_EQ((size_t)0, entry.index); 944 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 945 EXPECT_EQ(TYPE_FLOAT, entry.type); 946 EXPECT_EQ((size_t)1, (size_t)entry.count); 947 EXPECT_EQ(focus_distance, *entry.data.f); 948 949 result = find_camera_metadata_entry(m, 950 ANDROID_NOISE_STRENGTH, 951 &entry); 952 EXPECT_EQ(NOT_FOUND, result); 953 EXPECT_EQ((size_t)0, entry.index); 954 EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, entry.tag); 955 EXPECT_EQ(TYPE_FLOAT, entry.type); 956 EXPECT_EQ((size_t)1, entry.count); 957 EXPECT_EQ(focus_distance, *entry.data.f); 958 959 960 free_camera_metadata(m); 961} 962 963TEST(camera_metadata, delete_metadata) { 964 camera_metadata_t *m = NULL; 965 const size_t entry_capacity = 50; 966 const size_t data_capacity = 450; 967 968 int result; 969 970 m = allocate_camera_metadata(entry_capacity, data_capacity); 971 972 size_t num_entries = 5; 973 size_t data_per_entry = 974 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 975 size_t num_data = num_entries * data_per_entry; 976 977 // Delete an entry with data 978 979 add_test_metadata(m, num_entries); 980 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 981 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 982 983 result = delete_camera_metadata_entry(m, 1); 984 EXPECT_EQ(OK, result); 985 num_entries--; 986 num_data -= data_per_entry; 987 988 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 989 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 990 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 991 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 992 993 result = delete_camera_metadata_entry(m, 4); 994 EXPECT_EQ(ERROR, result); 995 996 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 997 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 998 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 999 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1000 1001 for (size_t i = 0; i < num_entries; i++) { 1002 camera_metadata_entry e; 1003 result = get_camera_metadata_entry(m, i, &e); 1004 EXPECT_EQ(OK, result); 1005 EXPECT_EQ(i, e.index); 1006 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1007 EXPECT_EQ(TYPE_INT64, e.type); 1008 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 1009 EXPECT_EQ(exposureTime, *e.data.i64); 1010 } 1011 1012 // Delete an entry with no data, at end of array 1013 1014 int32_t frameCount = 12; 1015 result = add_camera_metadata_entry(m, 1016 ANDROID_REQUEST_FRAME_COUNT, 1017 &frameCount, 1); 1018 EXPECT_EQ(OK, result); 1019 num_entries++; 1020 1021 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1022 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1023 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1024 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1025 1026 camera_metadata_entry e; 1027 result = get_camera_metadata_entry(m, 4, &e); 1028 EXPECT_EQ(OK, result); 1029 1030 EXPECT_EQ((size_t)4, e.index); 1031 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1032 EXPECT_EQ(TYPE_INT32, e.type); 1033 EXPECT_EQ((size_t)1, e.count); 1034 EXPECT_EQ(frameCount, *e.data.i32); 1035 1036 result = delete_camera_metadata_entry(m, 4); 1037 EXPECT_EQ(OK, result); 1038 1039 num_entries--; 1040 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1041 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1042 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1043 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1044 1045 result = delete_camera_metadata_entry(m, 4); 1046 EXPECT_EQ(ERROR, result); 1047 1048 result = get_camera_metadata_entry(m, 4, &e); 1049 EXPECT_EQ(ERROR, result); 1050 1051 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1052 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1053 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1054 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1055 1056 // Delete with extra data on end of array 1057 result = delete_camera_metadata_entry(m, 3); 1058 EXPECT_EQ(OK, result); 1059 num_entries--; 1060 num_data -= data_per_entry; 1061 1062 for (size_t i = 0; i < num_entries; i++) { 1063 camera_metadata_entry e2; 1064 result = get_camera_metadata_entry(m, i, &e2); 1065 EXPECT_EQ(OK, result); 1066 EXPECT_EQ(i, e2.index); 1067 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1068 EXPECT_EQ(TYPE_INT64, e2.type); 1069 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 1070 EXPECT_EQ(exposureTime, *e2.data.i64); 1071 } 1072 1073 // Delete without extra data in front of array 1074 1075 frameCount = 1001; 1076 result = add_camera_metadata_entry(m, 1077 ANDROID_REQUEST_FRAME_COUNT, 1078 &frameCount, 1); 1079 EXPECT_EQ(OK, result); 1080 num_entries++; 1081 1082 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1083 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1084 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1085 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1086 1087 result = sort_camera_metadata(m); 1088 EXPECT_EQ(OK, result); 1089 1090 result = find_camera_metadata_entry(m, 1091 ANDROID_REQUEST_FRAME_COUNT, &e); 1092 EXPECT_EQ(OK, result); 1093 EXPECT_EQ((size_t)0, e.index); 1094 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1095 EXPECT_EQ(TYPE_INT32, e.type); 1096 EXPECT_EQ((size_t)1, e.count); 1097 EXPECT_EQ(frameCount, *e.data.i32); 1098 1099 result = delete_camera_metadata_entry(m, e.index); 1100 EXPECT_EQ(OK, result); 1101 num_entries--; 1102 1103 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1104 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1105 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1106 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1107 1108 for (size_t i = 0; i < num_entries; i++) { 1109 camera_metadata_entry e2; 1110 result = get_camera_metadata_entry(m, i, &e2); 1111 EXPECT_EQ(OK, result); 1112 EXPECT_EQ(i, e2.index); 1113 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1114 EXPECT_EQ(TYPE_INT64, e2.type); 1115 int64_t exposureTime = i < 1 ? 100 : 200 + 100 * i; 1116 EXPECT_EQ(exposureTime, *e2.data.i64); 1117 } 1118} 1119 1120TEST(camera_metadata, update_metadata) { 1121 camera_metadata_t *m = NULL; 1122 const size_t entry_capacity = 50; 1123 const size_t data_capacity = 450; 1124 1125 int result; 1126 1127 m = allocate_camera_metadata(entry_capacity, data_capacity); 1128 1129 size_t num_entries = 5; 1130 size_t data_per_entry = 1131 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 1132 size_t num_data = num_entries * data_per_entry; 1133 1134 add_test_metadata(m, num_entries); 1135 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1136 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1137 1138 // Update with same-size data, doesn't fit in entry 1139 1140 int64_t newExposureTime = 1000; 1141 camera_metadata_entry_t e; 1142 result = update_camera_metadata_entry(m, 1143 0, &newExposureTime, 1, &e); 1144 EXPECT_EQ(OK, result); 1145 1146 EXPECT_EQ((size_t)0, e.index); 1147 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1148 EXPECT_EQ(TYPE_INT64, e.type); 1149 EXPECT_EQ((size_t)1, e.count); 1150 EXPECT_EQ(newExposureTime, *e.data.i64); 1151 1152 e.count = 0; 1153 result = get_camera_metadata_entry(m, 1154 0, &e); 1155 1156 EXPECT_EQ((size_t)0, e.index); 1157 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1158 EXPECT_EQ(TYPE_INT64, e.type); 1159 EXPECT_EQ((size_t)1, e.count); 1160 EXPECT_EQ(newExposureTime, *e.data.i64); 1161 1162 for (size_t i = 1; i < num_entries; i++) { 1163 camera_metadata_entry e2; 1164 result = get_camera_metadata_entry(m, i, &e2); 1165 EXPECT_EQ(OK, result); 1166 EXPECT_EQ(i, e2.index); 1167 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1168 EXPECT_EQ(TYPE_INT64, e2.type); 1169 int64_t exposureTime = 100 + 100 * i; 1170 EXPECT_EQ(exposureTime, *e2.data.i64); 1171 } 1172 1173 // Update with larger data 1174 int64_t newExposures[2] = { 5000, 6000 }; 1175 result = update_camera_metadata_entry(m, 1176 0, newExposures, 2, &e); 1177 EXPECT_EQ(OK, result); 1178 num_data += data_per_entry; 1179 1180 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1181 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1182 1183 EXPECT_EQ((size_t)0, e.index); 1184 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1185 EXPECT_EQ(TYPE_INT64, e.type); 1186 EXPECT_EQ((size_t)2, e.count); 1187 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1188 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1189 1190 e.count = 0; 1191 result = get_camera_metadata_entry(m, 1192 0, &e); 1193 1194 EXPECT_EQ((size_t)0, e.index); 1195 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1196 EXPECT_EQ(TYPE_INT64, e.type); 1197 EXPECT_EQ((size_t)2, e.count); 1198 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1199 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1200 1201 for (size_t i = 1; 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 = 100 + 100 * i; 1209 EXPECT_EQ(exposureTime, *e2.data.i64); 1210 } 1211 1212 // Update with smaller data 1213 newExposureTime = 100; 1214 result = update_camera_metadata_entry(m, 1215 0, &newExposureTime, 1, &e); 1216 EXPECT_EQ(OK, result); 1217 1218 num_data -= data_per_entry; 1219 1220 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1221 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1222 1223 EXPECT_EQ((size_t)0, e.index); 1224 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1225 EXPECT_EQ(TYPE_INT64, e.type); 1226 EXPECT_EQ((size_t)1, e.count); 1227 EXPECT_EQ(newExposureTime, *e.data.i64); 1228 1229 e.count = 0; 1230 result = get_camera_metadata_entry(m, 1231 0, &e); 1232 1233 EXPECT_EQ((size_t)0, e.index); 1234 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1235 EXPECT_EQ(TYPE_INT64, e.type); 1236 EXPECT_EQ((size_t)1, e.count); 1237 EXPECT_EQ(newExposureTime, *e.data.i64); 1238 1239 for (size_t i = 1; i < num_entries; i++) { 1240 camera_metadata_entry e2; 1241 result = get_camera_metadata_entry(m, i, &e2); 1242 EXPECT_EQ(OK, result); 1243 EXPECT_EQ(i, e2.index); 1244 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1245 EXPECT_EQ(TYPE_INT64, e2.type); 1246 int64_t exposureTime = 100 + 100 * i; 1247 EXPECT_EQ(exposureTime, *e2.data.i64); 1248 } 1249 1250 // Update with size fitting in entry 1251 1252 int32_t frameCount = 1001; 1253 result = add_camera_metadata_entry(m, 1254 ANDROID_REQUEST_FRAME_COUNT, 1255 &frameCount, 1); 1256 EXPECT_EQ(OK, result); 1257 num_entries++; 1258 1259 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1260 EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m)); 1261 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1262 EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m)); 1263 1264 result = sort_camera_metadata(m); 1265 EXPECT_EQ(OK, result); 1266 1267 result = find_camera_metadata_entry(m, 1268 ANDROID_REQUEST_FRAME_COUNT, &e); 1269 EXPECT_EQ(OK, result); 1270 EXPECT_EQ((size_t)0, e.index); 1271 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1272 EXPECT_EQ(TYPE_INT32, e.type); 1273 EXPECT_EQ((size_t)1, e.count); 1274 EXPECT_EQ(frameCount, *e.data.i32); 1275 1276 int32_t newFrameCount = 0x12349876; 1277 result = update_camera_metadata_entry(m, 1278 0, &newFrameCount, 1, &e); 1279 1280 EXPECT_EQ(OK, result); 1281 EXPECT_EQ((size_t)0, e.index); 1282 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1283 EXPECT_EQ(TYPE_INT32, e.type); 1284 EXPECT_EQ((size_t)1, e.count); 1285 EXPECT_EQ(newFrameCount, *e.data.i32); 1286 1287 result = find_camera_metadata_entry(m, 1288 ANDROID_REQUEST_FRAME_COUNT, &e); 1289 1290 EXPECT_EQ(OK, result); 1291 EXPECT_EQ((size_t)0, e.index); 1292 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1293 EXPECT_EQ(TYPE_INT32, e.type); 1294 EXPECT_EQ((size_t)1, e.count); 1295 EXPECT_EQ(newFrameCount, *e.data.i32); 1296 1297 for (size_t i = 1; i < num_entries; i++) { 1298 camera_metadata_entry e2; 1299 result = get_camera_metadata_entry(m, i, &e2); 1300 EXPECT_EQ(OK, result); 1301 EXPECT_EQ(i, e2.index); 1302 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1303 EXPECT_EQ(TYPE_INT64, e2.type); 1304 int64_t exposureTime = 100 * i; 1305 EXPECT_EQ(exposureTime, *e2.data.i64); 1306 } 1307 1308 // Update to bigger than entry 1309 1310 int32_t newFrameCounts[4] = { 0x0, 0x1, 0x10, 0x100 }; 1311 1312 result = update_camera_metadata_entry(m, 1313 0, &newFrameCounts, 4, &e); 1314 1315 EXPECT_EQ(OK, result); 1316 1317 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT32, 1318 4); 1319 1320 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1321 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1322 1323 EXPECT_EQ((size_t)0, e.index); 1324 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1325 EXPECT_EQ(TYPE_INT32, e.type); 1326 EXPECT_EQ((size_t)4, e.count); 1327 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]); 1328 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]); 1329 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]); 1330 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]); 1331 1332 e.count = 0; 1333 1334 result = find_camera_metadata_entry(m, 1335 ANDROID_REQUEST_FRAME_COUNT, &e); 1336 1337 EXPECT_EQ(OK, result); 1338 EXPECT_EQ((size_t)0, e.index); 1339 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1340 EXPECT_EQ(TYPE_INT32, e.type); 1341 EXPECT_EQ((size_t)4, e.count); 1342 EXPECT_EQ(newFrameCounts[0], e.data.i32[0]); 1343 EXPECT_EQ(newFrameCounts[1], e.data.i32[1]); 1344 EXPECT_EQ(newFrameCounts[2], e.data.i32[2]); 1345 EXPECT_EQ(newFrameCounts[3], e.data.i32[3]); 1346 1347 for (size_t i = 1; i < num_entries; i++) { 1348 camera_metadata_entry e2; 1349 result = get_camera_metadata_entry(m, i, &e2); 1350 EXPECT_EQ(OK, result); 1351 EXPECT_EQ(i, e2.index); 1352 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1353 EXPECT_EQ(TYPE_INT64, e2.type); 1354 int64_t exposureTime = 100 * i; 1355 EXPECT_EQ(exposureTime, *e2.data.i64); 1356 } 1357 1358 // Update to smaller than entry 1359 result = update_camera_metadata_entry(m, 1360 0, &newFrameCount, 1, &e); 1361 1362 EXPECT_EQ(OK, result); 1363 1364 num_data -= camera_metadata_type_size[TYPE_INT32] * 4; 1365 1366 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1367 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1368 1369 EXPECT_EQ((size_t)0, e.index); 1370 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1371 EXPECT_EQ(TYPE_INT32, e.type); 1372 EXPECT_EQ((size_t)1, e.count); 1373 EXPECT_EQ(newFrameCount, *e.data.i32); 1374 1375 result = find_camera_metadata_entry(m, 1376 ANDROID_REQUEST_FRAME_COUNT, &e); 1377 1378 EXPECT_EQ(OK, result); 1379 EXPECT_EQ((size_t)0, e.index); 1380 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1381 EXPECT_EQ(TYPE_INT32, e.type); 1382 EXPECT_EQ((size_t)1, e.count); 1383 EXPECT_EQ(newFrameCount, *e.data.i32); 1384 1385 for (size_t i = 1; i < num_entries; i++) { 1386 camera_metadata_entry_t e2; 1387 result = get_camera_metadata_entry(m, i, &e2); 1388 EXPECT_EQ(OK, result); 1389 EXPECT_EQ(i, e2.index); 1390 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1391 EXPECT_EQ(TYPE_INT64, e2.type); 1392 int64_t exposureTime = 100 * i; 1393 EXPECT_EQ(exposureTime, *e2.data.i64); 1394 } 1395 1396 // Setup new buffer with no spare data space 1397 1398 result = update_camera_metadata_entry(m, 1399 1, newExposures, 2, &e); 1400 EXPECT_EQ(OK, result); 1401 1402 num_data += data_per_entry; 1403 1404 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1405 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1406 1407 EXPECT_EQ((size_t)1, e.index); 1408 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1409 EXPECT_EQ(TYPE_INT64, e.type); 1410 EXPECT_EQ((size_t)2, e.count); 1411 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1412 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1413 1414 camera_metadata_t *m2; 1415 m2 = allocate_camera_metadata(get_camera_metadata_entry_count(m), 1416 get_camera_metadata_data_count(m)); 1417 EXPECT_NOT_NULL(m2); 1418 1419 result = append_camera_metadata(m2, m); 1420 EXPECT_EQ(OK, result); 1421 1422 result = find_camera_metadata_entry(m2, 1423 ANDROID_REQUEST_FRAME_COUNT, &e); 1424 1425 EXPECT_EQ(OK, result); 1426 EXPECT_EQ((size_t)0, e.index); 1427 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1428 EXPECT_EQ(TYPE_INT32, e.type); 1429 EXPECT_EQ((size_t)1, e.count); 1430 EXPECT_EQ(newFrameCount, *e.data.i32); 1431 1432 // Update when there's no more room 1433 1434 result = update_camera_metadata_entry(m2, 1435 0, &newFrameCounts, 4, &e); 1436 EXPECT_EQ(ERROR, result); 1437 1438 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1439 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1440 1441 EXPECT_EQ((size_t)0, e.index); 1442 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1443 EXPECT_EQ(TYPE_INT32, e.type); 1444 EXPECT_EQ((size_t)1, e.count); 1445 EXPECT_EQ(newFrameCount, *e.data.i32); 1446 1447 // Update when there's no data room, but change fits into entry 1448 1449 newFrameCount = 5; 1450 result = update_camera_metadata_entry(m2, 1451 0, &newFrameCount, 1, &e); 1452 EXPECT_EQ(OK, result); 1453 1454 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1455 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1456 1457 EXPECT_EQ((size_t)0, e.index); 1458 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1459 EXPECT_EQ(TYPE_INT32, e.type); 1460 EXPECT_EQ((size_t)1, e.count); 1461 EXPECT_EQ(newFrameCount, *e.data.i32); 1462 1463 result = find_camera_metadata_entry(m2, 1464 ANDROID_REQUEST_FRAME_COUNT, &e); 1465 1466 EXPECT_EQ(OK, result); 1467 EXPECT_EQ((size_t)0, e.index); 1468 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1469 EXPECT_EQ(TYPE_INT32, e.type); 1470 EXPECT_EQ((size_t)1, e.count); 1471 EXPECT_EQ(newFrameCount, *e.data.i32); 1472 1473 result = get_camera_metadata_entry(m2, 1, &e); 1474 EXPECT_EQ((size_t)1, e.index); 1475 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1476 EXPECT_EQ(TYPE_INT64, e.type); 1477 EXPECT_EQ((size_t)2, e.count); 1478 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1479 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1480 1481 for (size_t i = 2; i < num_entries; i++) { 1482 camera_metadata_entry_t e2; 1483 result = get_camera_metadata_entry(m2, i, &e2); 1484 EXPECT_EQ(OK, result); 1485 EXPECT_EQ(i, e2.index); 1486 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1487 EXPECT_EQ(TYPE_INT64, e2.type); 1488 int64_t exposureTime = 100 * i; 1489 EXPECT_EQ(exposureTime, *e2.data.i64); 1490 } 1491 1492 // Update when there's no data room, but data size doesn't change 1493 1494 newExposures[0] = 1000; 1495 1496 result = update_camera_metadata_entry(m2, 1497 1, newExposures, 2, &e); 1498 EXPECT_EQ(OK, result); 1499 1500 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1501 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1502 1503 EXPECT_EQ((size_t)1, e.index); 1504 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1505 EXPECT_EQ(TYPE_INT64, e.type); 1506 EXPECT_EQ((size_t)2, e.count); 1507 EXPECT_EQ(newExposures[0], e.data.i64[0]); 1508 EXPECT_EQ(newExposures[1], e.data.i64[1]); 1509 1510 result = find_camera_metadata_entry(m2, 1511 ANDROID_REQUEST_FRAME_COUNT, &e); 1512 1513 EXPECT_EQ(OK, result); 1514 EXPECT_EQ((size_t)0, e.index); 1515 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1516 EXPECT_EQ(TYPE_INT32, e.type); 1517 EXPECT_EQ((size_t)1, e.count); 1518 EXPECT_EQ(newFrameCount, *e.data.i32); 1519 1520 for (size_t i = 2; i < num_entries; i++) { 1521 camera_metadata_entry_t e2; 1522 result = get_camera_metadata_entry(m2, i, &e2); 1523 EXPECT_EQ(OK, result); 1524 EXPECT_EQ(i, e2.index); 1525 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1526 EXPECT_EQ(TYPE_INT64, e2.type); 1527 int64_t exposureTime = 100 * i; 1528 EXPECT_EQ(exposureTime, *e2.data.i64); 1529 } 1530 1531 // Update when there's no data room, but data size shrinks 1532 1533 result = update_camera_metadata_entry(m2, 1534 1, &newExposureTime, 1, &e); 1535 EXPECT_EQ(OK, result); 1536 1537 num_data -= calculate_camera_metadata_entry_data_size(TYPE_INT64, 2); 1538 num_data += calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 1539 1540 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m2)); 1541 EXPECT_EQ(num_data, get_camera_metadata_data_count(m2)); 1542 1543 EXPECT_EQ((size_t)1, e.index); 1544 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e.tag); 1545 EXPECT_EQ(TYPE_INT64, e.type); 1546 EXPECT_EQ((size_t)1, e.count); 1547 EXPECT_EQ(newExposureTime, e.data.i64[0]); 1548 1549 result = find_camera_metadata_entry(m2, 1550 ANDROID_REQUEST_FRAME_COUNT, &e); 1551 1552 EXPECT_EQ(OK, result); 1553 EXPECT_EQ((size_t)0, e.index); 1554 EXPECT_EQ(ANDROID_REQUEST_FRAME_COUNT, e.tag); 1555 EXPECT_EQ(TYPE_INT32, e.type); 1556 EXPECT_EQ((size_t)1, e.count); 1557 EXPECT_EQ(newFrameCount, *e.data.i32); 1558 1559 for (size_t i = 2; i < num_entries; i++) { 1560 camera_metadata_entry_t e2; 1561 result = get_camera_metadata_entry(m2, i, &e2); 1562 EXPECT_EQ(OK, result); 1563 EXPECT_EQ(i, e2.index); 1564 EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, e2.tag); 1565 EXPECT_EQ(TYPE_INT64, e2.type); 1566 int64_t exposureTime = 100 * i; 1567 EXPECT_EQ(exposureTime, *e2.data.i64); 1568 } 1569 1570} 1571 1572TEST(camera_metadata, user_pointer) { 1573 camera_metadata_t *m = NULL; 1574 const size_t entry_capacity = 50; 1575 const size_t data_capacity = 450; 1576 1577 int result; 1578 1579 m = allocate_camera_metadata(entry_capacity, data_capacity); 1580 1581 size_t num_entries = 5; 1582 size_t data_per_entry = 1583 calculate_camera_metadata_entry_data_size(TYPE_INT64, 1); 1584 size_t num_data = num_entries * data_per_entry; 1585 1586 add_test_metadata(m, num_entries); 1587 EXPECT_EQ(num_entries, get_camera_metadata_entry_count(m)); 1588 EXPECT_EQ(num_data, get_camera_metadata_data_count(m)); 1589 1590 void* ptr; 1591 result = get_camera_metadata_user_pointer(m, &ptr); 1592 EXPECT_EQ(OK, result); 1593 EXPECT_NULL(ptr); 1594 1595 int testValue = 10; 1596 result = set_camera_metadata_user_pointer(m, &testValue); 1597 EXPECT_EQ(OK, result); 1598 1599 result = get_camera_metadata_user_pointer(m, &ptr); 1600 EXPECT_EQ(OK, result); 1601 EXPECT_EQ(&testValue, (int*)ptr); 1602 EXPECT_EQ(testValue, *(int*)ptr); 1603 1604 size_t buf_size = get_camera_metadata_compact_size(m); 1605 EXPECT_LT((size_t)0, buf_size); 1606 1607 uint8_t *buf = (uint8_t*)malloc(buf_size); 1608 EXPECT_NOT_NULL(buf); 1609 1610 camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m); 1611 EXPECT_NOT_NULL(m2); 1612 1613 result = get_camera_metadata_user_pointer(m2, &ptr); 1614 EXPECT_NULL(ptr); 1615 1616 free(buf); 1617 free_camera_metadata(m); 1618} 1619 1620TEST(camera_metadata, memcpy) { 1621 camera_metadata_t *m = NULL; 1622 const size_t entry_capacity = 50; 1623 const size_t data_capacity = 450; 1624 1625 int result; 1626 1627 m = allocate_camera_metadata(entry_capacity, data_capacity); 1628 1629 add_test_metadata(m, 5); 1630 1631 uint8_t *dst = new uint8_t[get_camera_metadata_size(m)]; 1632 1633 memcpy(dst, m, get_camera_metadata_size(m)); 1634 1635 camera_metadata_t *m2 = reinterpret_cast<camera_metadata_t*>(dst); 1636 1637 ASSERT_EQ(get_camera_metadata_size(m), 1638 get_camera_metadata_size(m2)); 1639 EXPECT_EQ(get_camera_metadata_compact_size(m), 1640 get_camera_metadata_compact_size(m2)); 1641 ASSERT_EQ(get_camera_metadata_entry_count(m), 1642 get_camera_metadata_entry_count(m2)); 1643 EXPECT_EQ(get_camera_metadata_entry_capacity(m), 1644 get_camera_metadata_entry_capacity(m2)); 1645 EXPECT_EQ(get_camera_metadata_data_count(m), 1646 get_camera_metadata_data_count(m2)); 1647 EXPECT_EQ(get_camera_metadata_data_capacity(m), 1648 get_camera_metadata_data_capacity(m2)); 1649 1650 camera_metadata_entry_t e1, e2; 1651 for (size_t i = 0; i < get_camera_metadata_entry_count(m); i++) { 1652 result = get_camera_metadata_entry(m, i, &e1); 1653 ASSERT_EQ(OK, result); 1654 result = get_camera_metadata_entry(m2, i, &e2); 1655 ASSERT_EQ(OK, result); 1656 1657 EXPECT_EQ(e1.index, e2.index); 1658 EXPECT_EQ(e1.tag, e2.tag); 1659 ASSERT_EQ(e1.type, e2.type); 1660 ASSERT_EQ(e1.count, e2.count); 1661 1662 ASSERT_TRUE(!memcmp(e1.data.u8, e2.data.u8, 1663 camera_metadata_type_size[e1.type] * e1.count)); 1664 } 1665 1666 // Make sure updating one metadata buffer doesn't change the other 1667 1668 int64_t double_exposure_time[] = { 100, 200 }; 1669 1670 result = update_camera_metadata_entry(m, 0, 1671 double_exposure_time, 1672 sizeof(double_exposure_time)/sizeof(int64_t), NULL); 1673 EXPECT_EQ(OK, result); 1674 1675 result = get_camera_metadata_entry(m, 0, &e1); 1676 ASSERT_EQ(OK, result); 1677 result = get_camera_metadata_entry(m2, 0, &e2); 1678 ASSERT_EQ(OK, result); 1679 1680 EXPECT_EQ(e1.index, e2.index); 1681 EXPECT_EQ(e1.tag, e2.tag); 1682 ASSERT_EQ(e1.type, e2.type); 1683 ASSERT_EQ((size_t)2, e1.count); 1684 ASSERT_EQ((size_t)1, e2.count); 1685 EXPECT_EQ(100, e1.data.i64[0]); 1686 EXPECT_EQ(200, e1.data.i64[1]); 1687 EXPECT_EQ(100, e2.data.i64[0]); 1688 1689 // And in the reverse direction as well 1690 1691 double_exposure_time[0] = 300; 1692 result = update_camera_metadata_entry(m2, 0, 1693 double_exposure_time, 1694 sizeof(double_exposure_time)/sizeof(int64_t), NULL); 1695 EXPECT_EQ(OK, result); 1696 1697 result = get_camera_metadata_entry(m, 0, &e1); 1698 ASSERT_EQ(OK, result); 1699 result = get_camera_metadata_entry(m2, 0, &e2); 1700 ASSERT_EQ(OK, result); 1701 1702 EXPECT_EQ(e1.index, e2.index); 1703 EXPECT_EQ(e1.tag, e2.tag); 1704 ASSERT_EQ(e1.type, e2.type); 1705 ASSERT_EQ((size_t)2, e1.count); 1706 ASSERT_EQ((size_t)2, e2.count); 1707 EXPECT_EQ(100, e1.data.i64[0]); 1708 EXPECT_EQ(200, e1.data.i64[1]); 1709 EXPECT_EQ(300, e2.data.i64[0]); 1710 EXPECT_EQ(200, e2.data.i64[1]); 1711 1712 delete dst; 1713 free_camera_metadata(m); 1714} 1715