camera/tests/camera_metadata_tests.cpp

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