camera_metadata_tests.cpp revision d8afb4d1a4245b2a9d722cbb358a4d6febed89cf 
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#include "gtest/gtest.h"
18#include "system/camera_metadata.h"
19
20#include "camera_metadata_tests_fake_vendor.h"
21
22#define EXPECT_NULL(x)     EXPECT_EQ((void*)0, x)
23#define EXPECT_NOT_NULL(x) EXPECT_NE((void*)0, x)
24
25#define OK    0
26#define ERROR 1
27
28TEST(camera_metadata, allocate_normal) {
29    camera_metadata_t *m = NULL;
30    const size_t entry_capacity = 5;
31    const size_t data_capacity = 32;
32
33    m = allocate_camera_metadata(entry_capacity, data_capacity);
34
35    EXPECT_NOT_NULL(m);
36    EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
37    EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
38    EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
39    EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
40
41    free_camera_metadata(m);
42}
43
44TEST(camera_metadata, allocate_nodata) {
45    camera_metadata_t *m = NULL;
46
47    m = allocate_camera_metadata(1, 0);
48
49    EXPECT_NOT_NULL(m);
50    EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
51    EXPECT_EQ((size_t)1, get_camera_metadata_entry_capacity(m));
52    EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
53    EXPECT_EQ((size_t)0, get_camera_metadata_data_capacity(m));
54
55    free_camera_metadata(m);
56}
57
58TEST(camera_metadata, allocate_nothing) {
59    camera_metadata_t *m = NULL;
60
61    m = allocate_camera_metadata(0, 0);
62
63    EXPECT_NULL(m);
64}
65
66TEST(camera_metadata, place_normal) {
67    camera_metadata_t *m = NULL;
68    void *buf = NULL;
69
70    const size_t entry_capacity = 5;
71    const size_t data_capacity = 32;
72
73    size_t buf_size = calculate_camera_metadata_size(entry_capacity,
74            data_capacity);
75
76    EXPECT_TRUE(buf_size > 0);
77
78    buf = malloc(buf_size);
79
80    EXPECT_NOT_NULL(buf);
81
82    m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
83
84    EXPECT_EQ(buf, (uint8_t*)m);
85    EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
86    EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
87    EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
88    EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
89
90    free(buf);
91}
92
93TEST(camera_metadata, place_nospace) {
94    camera_metadata_t *m = NULL;
95    void *buf = NULL;
96
97    const size_t entry_capacity = 5;
98    const size_t data_capacity = 32;
99
100    size_t buf_size = calculate_camera_metadata_size(entry_capacity,
101            data_capacity);
102
103    EXPECT_GT(buf_size, (size_t)0);
104
105    buf_size--;
106
107    buf = malloc(buf_size);
108
109    EXPECT_NOT_NULL(buf);
110
111    m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
112
113    EXPECT_NULL(m);
114
115    free(buf);
116}
117
118TEST(camera_metadata, place_extraspace) {
119    camera_metadata_t *m = NULL;
120    uint8_t *buf = NULL;
121
122    const size_t entry_capacity = 5;
123    const size_t data_capacity = 32;
124    const size_t extra_space = 10;
125
126    size_t buf_size = calculate_camera_metadata_size(entry_capacity,
127            data_capacity);
128
129    EXPECT_GT(buf_size, (size_t)0);
130
131    buf_size += extra_space;
132
133    buf = (uint8_t*)malloc(buf_size);
134
135    EXPECT_NOT_NULL(buf);
136
137    m = place_camera_metadata(buf, buf_size, entry_capacity, data_capacity);
138
139    EXPECT_EQ((uint8_t*)m, buf);
140    EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m));
141    EXPECT_EQ(entry_capacity, get_camera_metadata_entry_capacity(m));
142    EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m));
143    EXPECT_EQ(data_capacity, get_camera_metadata_data_capacity(m));
144    EXPECT_EQ(buf + buf_size - extra_space, (uint8_t*)m + get_camera_metadata_size(m));
145
146    free(buf);
147}
148
149TEST(camera_metadata, get_size) {
150    camera_metadata_t *m = NULL;
151    const size_t entry_capacity = 5;
152    const size_t data_capacity = 32;
153
154    m = allocate_camera_metadata(entry_capacity, data_capacity);
155
156    EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity),
157            get_camera_metadata_size(m) );
158
159    EXPECT_EQ(calculate_camera_metadata_size(0,0),
160            get_camera_metadata_compact_size(m) );
161
162    free_camera_metadata(m);
163}
164
165TEST(camera_metadata, add_get_normal) {
166    camera_metadata_t *m = NULL;
167    const size_t entry_capacity = 5;
168    const size_t data_capacity = 80;
169
170    m = allocate_camera_metadata(entry_capacity, data_capacity);
171
172    int result;
173    size_t data_used = 0;
174    size_t entries_used = 0;
175
176    // INT64
177
178    int64_t exposure_time = 1000000000;
179    result = add_camera_metadata_entry(m,
180            ANDROID_SENSOR_EXPOSURE_TIME,
181            &exposure_time, 1);
182    EXPECT_EQ(OK, result);
183    data_used += calculate_camera_metadata_entry_data_size(
184            get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1);
185    entries_used++;
186
187    // INT32
188
189    int32_t sensitivity = 800;
190    result = add_camera_metadata_entry(m,
191            ANDROID_SENSOR_SENSITIVITY,
192            &sensitivity, 1);
193    EXPECT_EQ(OK, result);
194    data_used += calculate_camera_metadata_entry_data_size(
195            get_camera_metadata_tag_type(ANDROID_SENSOR_SENSITIVITY), 1);
196    entries_used++;
197
198    // FLOAT
199
200    float focusDistance = 0.5f;
201    result = add_camera_metadata_entry(m,
202            ANDROID_LENS_FOCUS_DISTANCE,
203            &focusDistance, 1);
204    EXPECT_EQ(OK, result);
205    data_used += calculate_camera_metadata_entry_data_size(
206            get_camera_metadata_tag_type(ANDROID_LENS_FOCUS_DISTANCE), 1);
207    entries_used++;
208
209    // Array of FLOAT
210
211    float colorTransform[9] = {
212        0.9f, 0.0f, 0.0f,
213        0.2f, 0.5f, 0.0f,
214        0.0f, 0.1f, 0.7f
215    };
216    result = add_camera_metadata_entry(m,
217            ANDROID_COLOR_TRANSFORM,
218            colorTransform, 9);
219    EXPECT_EQ(OK, result);
220    data_used += calculate_camera_metadata_entry_data_size(
221            get_camera_metadata_tag_type(ANDROID_COLOR_TRANSFORM), 9);
222    entries_used++;
223
224    // Check added entries
225
226    uint32_t tag = 0;
227    uint8_t type = 0;
228    int32_t *data_int32;
229    int64_t *data_int64;
230    float *data_float;
231    size_t data_count = 0;
232
233    result = get_camera_metadata_entry(m,
234            0, &tag, &type, (void**)&data_int64, &data_count);
235    EXPECT_EQ(OK, result);
236    EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, tag);
237    EXPECT_EQ(TYPE_INT64, type);
238    EXPECT_EQ((size_t)1, data_count);
239    EXPECT_EQ(exposure_time, *data_int64);
240
241    result = get_camera_metadata_entry(m,
242            1, &tag, &type, (void**)&data_int32, &data_count);
243    EXPECT_EQ(OK, result);
244    EXPECT_EQ(ANDROID_SENSOR_SENSITIVITY, tag);
245    EXPECT_EQ(TYPE_INT32, type);
246    EXPECT_EQ((size_t)1, data_count);
247    EXPECT_EQ(sensitivity, *data_int32);
248
249    result = get_camera_metadata_entry(m,
250            2, &tag, &type, (void**)&data_float, &data_count);
251    EXPECT_EQ(OK, result);
252    EXPECT_EQ(ANDROID_LENS_FOCUS_DISTANCE, tag);
253    EXPECT_EQ(TYPE_FLOAT, type);
254    EXPECT_EQ((size_t)1, data_count);
255    EXPECT_EQ(focusDistance, *data_float);
256
257    result = get_camera_metadata_entry(m,
258            3, &tag, &type, (void**)&data_float, &data_count);
259    EXPECT_EQ(OK, result);
260    EXPECT_EQ(ANDROID_COLOR_TRANSFORM, tag);
261    EXPECT_EQ(TYPE_FLOAT, type);
262    EXPECT_EQ((size_t)9, data_count);
263    for (unsigned int i=0; i < data_count; i++) {
264        EXPECT_EQ(colorTransform[i], data_float[i] );
265    }
266
267    EXPECT_EQ(calculate_camera_metadata_size(entry_capacity, data_capacity),
268            get_camera_metadata_size(m) );
269
270    EXPECT_EQ(calculate_camera_metadata_size(entries_used, data_used),
271            get_camera_metadata_compact_size(m) );
272
273    dump_camera_metadata(m, 2);
274
275    free_camera_metadata(m);
276}
277
278void add_test_metadata(camera_metadata_t *m, int entry_count) {
279
280    EXPECT_NOT_NULL(m);
281
282    int result;
283    size_t data_used = 0;
284    size_t entries_used = 0;
285    int64_t exposure_time;
286    for (int i=0; i < entry_count; i++ ) {
287        exposure_time = 100 + i * 100;
288        result = add_camera_metadata_entry(m,
289                ANDROID_SENSOR_EXPOSURE_TIME,
290                &exposure_time, 1);
291        EXPECT_EQ(OK, result);
292        data_used += calculate_camera_metadata_entry_data_size(
293                get_camera_metadata_tag_type(ANDROID_SENSOR_EXPOSURE_TIME), 1);
294        entries_used++;
295    }
296    EXPECT_EQ(data_used, get_camera_metadata_data_count(m));
297    EXPECT_EQ(entries_used, get_camera_metadata_entry_count(m));
298    EXPECT_GT(get_camera_metadata_data_capacity(m),
299            get_camera_metadata_data_count(m));
300}
301
302TEST(camera_metadata, add_get_toomany) {
303    camera_metadata_t *m = NULL;
304    const size_t entry_capacity = 5;
305    const size_t data_capacity = 50;
306    int result;
307
308    m = allocate_camera_metadata(entry_capacity, data_capacity);
309
310    add_test_metadata(m, entry_capacity);
311
312    int32_t sensitivity = 100;
313    result = add_camera_metadata_entry(m,
314            ANDROID_SENSOR_SENSITIVITY,
315            &sensitivity, 1);
316
317    EXPECT_EQ(ERROR, result);
318
319    uint32_t tag = 0;
320    uint8_t type = 0;
321    int32_t *data_int32;
322    size_t data_count = 0;
323    for (unsigned int i=0; i < entry_capacity; i++) {
324        int64_t exposure_time = 100 + i * 100;
325        result = get_camera_metadata_entry(m,
326                i, &tag, &type, (void**)&data_int32, &data_count);
327        EXPECT_EQ(OK, result);
328        EXPECT_EQ(ANDROID_SENSOR_EXPOSURE_TIME, tag);
329        EXPECT_EQ(TYPE_INT64, type);
330        EXPECT_EQ((size_t)1, data_count);
331        EXPECT_EQ(exposure_time, *data_int32);
332    }
333    tag = 0;
334    type = 0;
335    data_int32 = NULL;
336    data_count = 0;
337    result = get_camera_metadata_entry(m,
338            entry_capacity, &tag, &type, (void**)&data_int32, &data_count);
339    EXPECT_EQ(ERROR, result);
340    EXPECT_EQ((uint32_t)0, tag);
341    EXPECT_EQ((uint8_t)0, type);
342    EXPECT_EQ((size_t)0, data_count);
343    EXPECT_EQ(NULL, data_int32);
344
345    dump_camera_metadata(m, 2);
346
347    free_camera_metadata(m);
348}
349
350TEST(camera_metadata, copy_metadata) {
351    camera_metadata_t *m = NULL;
352    const size_t entry_capacity = 50;
353    const size_t data_capacity = 450;
354
355    int result;
356
357    m = allocate_camera_metadata(entry_capacity, data_capacity);
358
359    add_test_metadata(m, entry_capacity);
360
361    size_t buf_size = get_camera_metadata_compact_size(m);
362    EXPECT_LT((size_t)0, buf_size);
363
364    uint8_t *buf = (uint8_t*)malloc(buf_size);
365    EXPECT_NOT_NULL(buf);
366
367    camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
368    EXPECT_NOT_NULL(m2);
369    EXPECT_EQ(buf, (uint8_t*)m2);
370    EXPECT_EQ(get_camera_metadata_entry_count(m),
371            get_camera_metadata_entry_count(m2));
372    EXPECT_EQ(get_camera_metadata_data_count(m),
373            get_camera_metadata_data_count(m2));
374    EXPECT_EQ(get_camera_metadata_entry_capacity(m2),
375            get_camera_metadata_entry_count(m2));
376    EXPECT_EQ(get_camera_metadata_data_capacity(m2),
377            get_camera_metadata_data_count(m2));
378
379    for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
380        uint32_t tag, tag2;
381        uint8_t type, type2;
382        uint8_t *data, *data2;
383        size_t   data_count, data_count2;
384
385        int result;
386        result = get_camera_metadata_entry(m,
387                i, &tag, &type, (void**)&data, &data_count);
388        EXPECT_EQ(OK, result);
389        result = get_camera_metadata_entry(m2,
390                i, &tag2, &type2, (void**)&data2, &data_count2);
391        EXPECT_EQ(OK, result);
392        EXPECT_EQ(tag, tag2);
393        EXPECT_EQ(type, type2);
394        EXPECT_EQ(data_count, data_count2);
395        for (unsigned int j=0; j < data_count; j++) {
396            EXPECT_EQ(data[j], data2[j]);
397        }
398    }
399
400    free(buf);
401
402    free_camera_metadata(m);
403}
404
405TEST(camera_metadata, copy_metadata_extraspace) {
406    camera_metadata_t *m = NULL;
407    const size_t entry_capacity = 12;
408    const size_t data_capacity = 100;
409
410    const size_t extra_space = 10;
411
412    int result;
413
414    m = allocate_camera_metadata(entry_capacity, data_capacity);
415
416    add_test_metadata(m, entry_capacity);
417
418    size_t buf_size = get_camera_metadata_compact_size(m);
419    EXPECT_LT((size_t)0, buf_size);
420    buf_size += extra_space;
421
422    uint8_t *buf = (uint8_t*)malloc(buf_size);
423    EXPECT_NOT_NULL(buf);
424
425    camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
426    EXPECT_NOT_NULL(m2);
427    EXPECT_EQ(buf, (uint8_t*)m2);
428    EXPECT_EQ(get_camera_metadata_entry_count(m),
429            get_camera_metadata_entry_count(m2));
430    EXPECT_EQ(get_camera_metadata_data_count(m),
431            get_camera_metadata_data_count(m2));
432    EXPECT_EQ(get_camera_metadata_entry_capacity(m2),
433            get_camera_metadata_entry_count(m2));
434    EXPECT_EQ(get_camera_metadata_data_capacity(m2),
435            get_camera_metadata_data_count(m2));
436    EXPECT_EQ(buf + buf_size - extra_space,
437            (uint8_t*)m2 + get_camera_metadata_size(m2) );
438
439    for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
440        uint32_t tag, tag2;
441        uint8_t type, type2;
442        uint8_t *data, *data2;
443        size_t   data_count, data_count2;
444
445        int result;
446        result = get_camera_metadata_entry(m,
447                i, &tag, &type, (void**)&data, &data_count);
448        EXPECT_EQ(OK, result);
449        result = get_camera_metadata_entry(m2,
450                i, &tag2, &type2, (void**)&data2, &data_count2);
451        EXPECT_EQ(OK, result);
452        EXPECT_EQ(tag, tag2);
453        EXPECT_EQ(type, type2);
454        EXPECT_EQ(data_count, data_count2);
455        for (unsigned int j=0; j < data_count; j++) {
456            EXPECT_EQ(data[j], data2[j]);
457        }
458    }
459
460    free(buf);
461
462    free_camera_metadata(m);
463}
464
465TEST(camera_metadata, copy_metadata_nospace) {
466    camera_metadata_t *m = NULL;
467    const size_t entry_capacity = 5;
468    const size_t data_capacity = 50;
469
470    int result;
471
472    m = allocate_camera_metadata(entry_capacity, data_capacity);
473
474    add_test_metadata(m, entry_capacity);
475
476    size_t buf_size = get_camera_metadata_compact_size(m);
477    EXPECT_LT((size_t)0, buf_size);
478
479    buf_size--;
480
481    uint8_t *buf = (uint8_t*)malloc(buf_size);
482    EXPECT_NOT_NULL(buf);
483
484    camera_metadata_t *m2 = copy_camera_metadata(buf, buf_size, m);
485    EXPECT_NULL(m2);
486
487    free(buf);
488
489    free_camera_metadata(m);
490}
491
492TEST(camera_metadata, append_metadata) {
493    camera_metadata_t *m = NULL;
494    const size_t entry_capacity = 5;
495    const size_t data_capacity = 50;
496
497    int result;
498
499    m = allocate_camera_metadata(entry_capacity, data_capacity);
500
501    add_test_metadata(m, entry_capacity);
502
503    camera_metadata_t *m2 = NULL;
504
505    m2 = allocate_camera_metadata(entry_capacity*2, data_capacity*2);
506    EXPECT_NOT_NULL(m2);
507
508    result = append_camera_metadata(m2, m);
509
510    EXPECT_EQ(OK, result);
511
512    EXPECT_EQ(get_camera_metadata_entry_count(m), get_camera_metadata_entry_count(m2));
513    EXPECT_EQ(get_camera_metadata_data_count(m),  get_camera_metadata_data_count(m2));
514    EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2));
515    EXPECT_EQ(data_capacity*2,  get_camera_metadata_data_capacity(m2));
516
517    for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
518        uint32_t tag, tag2;
519        uint8_t type, type2;
520        uint8_t *data, *data2;
521        size_t   data_count, data_count2;
522
523        int result;
524        result = get_camera_metadata_entry(m,
525                i, &tag, &type, (void**)&data, &data_count);
526        EXPECT_EQ(OK, result);
527        result = get_camera_metadata_entry(m2,
528                i, &tag2, &type2, (void**)&data2, &data_count2);
529        EXPECT_EQ(OK, result);
530        EXPECT_EQ(tag, tag2);
531        EXPECT_EQ(type, type2);
532        EXPECT_EQ(data_count, data_count2);
533        for (unsigned int j=0; j < data_count; j++) {
534            EXPECT_EQ(data[j], data2[j]);
535        }
536    }
537
538    result = append_camera_metadata(m2, m);
539
540    EXPECT_EQ(OK, result);
541
542    EXPECT_EQ(get_camera_metadata_entry_count(m)*2, get_camera_metadata_entry_count(m2));
543    EXPECT_EQ(get_camera_metadata_data_count(m)*2,  get_camera_metadata_data_count(m2));
544    EXPECT_EQ(entry_capacity*2, get_camera_metadata_entry_capacity(m2));
545    EXPECT_EQ(data_capacity*2,  get_camera_metadata_data_capacity(m2));
546
547    for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) {
548        uint32_t tag, tag2;
549        uint8_t type, type2;
550        uint8_t *data, *data2;
551        size_t   data_count, data_count2;
552
553        int result;
554        result = get_camera_metadata_entry(m,
555                i % entry_capacity, &tag, &type, (void**)&data, &data_count);
556        EXPECT_EQ(OK, result);
557        result = get_camera_metadata_entry(m2,
558                i, &tag2, &type2, (void**)&data2, &data_count2);
559        EXPECT_EQ(OK, result);
560        EXPECT_EQ(tag, tag2);
561        EXPECT_EQ(type, type2);
562        EXPECT_EQ(data_count, data_count2);
563        for (unsigned int j=0; j < data_count; j++) {
564            EXPECT_EQ(data[j], data2[j]);
565        }
566    }
567
568    free_camera_metadata(m);
569    free_camera_metadata(m2);
570}
571
572TEST(camera_metadata, append_metadata_nospace) {
573    camera_metadata_t *m = NULL;
574    const size_t entry_capacity = 5;
575    const size_t data_capacity = 50;
576
577    int result;
578
579    m = allocate_camera_metadata(entry_capacity, data_capacity);
580
581    add_test_metadata(m, entry_capacity);
582
583    camera_metadata_t *m2 = NULL;
584
585    m2 = allocate_camera_metadata(entry_capacity-1, data_capacity);
586    EXPECT_NOT_NULL(m2);
587
588    result = append_camera_metadata(m2, m);
589
590    EXPECT_EQ(ERROR, result);
591    EXPECT_EQ((size_t)0, get_camera_metadata_entry_count(m2));
592    EXPECT_EQ((size_t)0, get_camera_metadata_data_count(m2));
593
594    free_camera_metadata(m);
595    free_camera_metadata(m2);
596}
597
598TEST(camera_metadata, append_metadata_onespace) {
599    camera_metadata_t *m = NULL;
600    const size_t entry_capacity = 5;
601    const size_t data_capacity = 50;
602    const size_t entry_capacity2 = entry_capacity * 2 - 2;
603    const size_t data_capacity2 = data_capacity * 2;
604    int result;
605
606    m = allocate_camera_metadata(entry_capacity, data_capacity);
607
608    add_test_metadata(m, entry_capacity);
609
610    camera_metadata_t *m2 = NULL;
611
612    m2 = allocate_camera_metadata(entry_capacity2, data_capacity2);
613    EXPECT_NOT_NULL(m2);
614
615    result = append_camera_metadata(m2, m);
616
617    EXPECT_EQ(OK, result);
618
619    EXPECT_EQ(get_camera_metadata_entry_count(m), get_camera_metadata_entry_count(m2));
620    EXPECT_EQ(get_camera_metadata_data_count(m),  get_camera_metadata_data_count(m2));
621    EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2));
622    EXPECT_EQ(data_capacity2,  get_camera_metadata_data_capacity(m2));
623
624    for (unsigned int i=0; i < get_camera_metadata_entry_count(m); i++) {
625        uint32_t tag, tag2;
626        uint8_t type, type2;
627        uint8_t *data, *data2;
628        size_t   data_count, data_count2;
629
630        int result;
631        result = get_camera_metadata_entry(m,
632                i, &tag, &type, (void**)&data, &data_count);
633        EXPECT_EQ(OK, result);
634        result = get_camera_metadata_entry(m2,
635                i, &tag2, &type2, (void**)&data2, &data_count2);
636        EXPECT_EQ(OK, result);
637        EXPECT_EQ(tag, tag2);
638        EXPECT_EQ(type, type2);
639        EXPECT_EQ(data_count, data_count2);
640        for (unsigned int j=0; j < data_count; j++) {
641            EXPECT_EQ(data[j], data2[j]);
642        }
643    }
644
645    result = append_camera_metadata(m2, m);
646
647    EXPECT_EQ(ERROR, result);
648    EXPECT_EQ(entry_capacity, get_camera_metadata_entry_count(m2));
649    EXPECT_EQ(get_camera_metadata_data_count(m),
650            get_camera_metadata_data_count(m2));
651    EXPECT_EQ(entry_capacity2, get_camera_metadata_entry_capacity(m2));
652    EXPECT_EQ(data_capacity2,  get_camera_metadata_data_capacity(m2));
653
654    for (unsigned int i=0; i < get_camera_metadata_entry_count(m2); i++) {
655        uint32_t tag, tag2;
656        uint8_t type, type2;
657        uint8_t *data, *data2;
658        size_t   data_count, data_count2;
659
660        int result;
661        result = get_camera_metadata_entry(m,
662                i % entry_capacity, &tag, &type, (void**)&data, &data_count);
663        EXPECT_EQ(OK, result);
664        result = get_camera_metadata_entry(m2,
665                i, &tag2, &type2, (void**)&data2, &data_count2);
666        EXPECT_EQ(OK, result);
667        EXPECT_EQ(tag, tag2);
668        EXPECT_EQ(type, type2);
669        EXPECT_EQ(data_count, data_count2);
670        for (unsigned int j=0; j < data_count; j++) {
671            EXPECT_EQ(data[j], data2[j]);
672        }
673    }
674
675    free_camera_metadata(m);
676    free_camera_metadata(m2);
677}
678
679TEST(camera_metadata, vendor_tags) {
680    camera_metadata_t *m = NULL;
681    const size_t entry_capacity = 5;
682    const size_t data_capacity = 50;
683    int result;
684
685    m = allocate_camera_metadata(entry_capacity, data_capacity);
686
687    uint8_t superMode = 5;
688    result = add_camera_metadata_entry(m,
689            FAKEVENDOR_SENSOR_SUPERMODE,
690            &superMode, 1);
691    EXPECT_EQ(ERROR, result);
692
693    result = add_camera_metadata_entry(m,
694            ANDROID_REQUEST_METADATA_MODE,
695            &superMode, 1);
696    EXPECT_EQ(OK, result);
697
698    EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
699    EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
700    EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
701
702    set_camera_metadata_vendor_tag_ops(&fakevendor_query_ops);
703
704    result = add_camera_metadata_entry(m,
705            FAKEVENDOR_SENSOR_SUPERMODE,
706            &superMode, 1);
707    EXPECT_EQ(OK, result);
708
709    result = add_camera_metadata_entry(m,
710            ANDROID_REQUEST_METADATA_MODE,
711            &superMode, 1);
712    EXPECT_EQ(OK, result);
713
714    result = add_camera_metadata_entry(m,
715            FAKEVENDOR_SCALER_END,
716            &superMode, 1);
717    EXPECT_EQ(ERROR, result);
718
719    EXPECT_STREQ("com.fakevendor.sensor",
720            get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
721    EXPECT_STREQ("superMode",
722            get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
723    EXPECT_EQ(TYPE_BYTE,
724            get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
725
726    EXPECT_STREQ("com.fakevendor.scaler",
727            get_camera_metadata_section_name(FAKEVENDOR_SCALER_END));
728    EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SCALER_END));
729    EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SCALER_END));
730
731    set_camera_metadata_vendor_tag_ops(NULL);
732
733    result = add_camera_metadata_entry(m,
734            FAKEVENDOR_SENSOR_SUPERMODE,
735            &superMode, 1);
736    EXPECT_EQ(ERROR, result);
737
738    result = add_camera_metadata_entry(m,
739            ANDROID_REQUEST_METADATA_MODE,
740            &superMode, 1);
741    EXPECT_EQ(OK, result);
742
743    EXPECT_NULL(get_camera_metadata_section_name(FAKEVENDOR_SENSOR_SUPERMODE));
744    EXPECT_NULL(get_camera_metadata_tag_name(FAKEVENDOR_SENSOR_SUPERMODE));
745    EXPECT_EQ(-1, get_camera_metadata_tag_type(FAKEVENDOR_SENSOR_SUPERMODE));
746
747    free_camera_metadata(m);
748}
749
750TEST(camera_metadata, add_all_tags) {
751    int total_tag_count = 0;
752    for (int i = 0; i < ANDROID_SECTION_COUNT; i++) {
753        total_tag_count += camera_metadata_section_bounds[i][1] -
754                camera_metadata_section_bounds[i][0];
755    }
756    int entry_data_count = 3;
757    int conservative_data_space = total_tag_count * entry_data_count * 8;
758    uint8_t data[entry_data_count * 8];
759    int32_t *data_int32 = (int32_t *)data;
760    float *data_float   = (float *)data;
761    int64_t *data_int64 = (int64_t *)data;
762    double *data_double = (double *)data;
763    camera_metadata_rational_t *data_rational = (camera_metadata_rational_t *)data;
764
765    camera_metadata_t *m = allocate_camera_metadata(total_tag_count, conservative_data_space);
766
767    ASSERT_NE((void*)NULL, (void*)m);
768
769    int result;
770
771    int counter = 0;
772    for (int i = 0; i < ANDROID_SECTION_COUNT; i++) {
773        for (uint32_t tag = camera_metadata_section_bounds[i][0];
774                tag < camera_metadata_section_bounds[i][1];
775             tag++, counter++) {
776            int type = get_camera_metadata_tag_type(tag);
777            ASSERT_NE(-1, type);
778
779            switch (type) {
780                case TYPE_BYTE:
781                    data[0] = tag & 0xFF;
782                    data[1] = (tag >> 8) & 0xFF;
783                    data[2] = (tag >> 16) & 0xFF;
784                    break;
785                case TYPE_INT32:
786                    data_int32[0] = tag;
787                    data_int32[1] = i;
788                    data_int32[2] = counter;
789                    break;
790                case TYPE_FLOAT:
791                    data_float[0] = tag;
792                    data_float[1] = i;
793                    data_float[2] = counter / (float)total_tag_count;
794                    break;
795                case TYPE_INT64:
796                    data_int64[0] = (int64_t)tag | ( (int64_t)tag << 32);
797                    data_int64[1] = i;
798                    data_int64[2] = counter;
799                    break;
800                case TYPE_DOUBLE:
801                    data_double[0] = tag;
802                    data_double[1] = i;
803                    data_double[2] = counter / (double)total_tag_count;
804                    break;
805                case TYPE_RATIONAL:
806                    data_rational[0].numerator = tag;
807                    data_rational[0].denominator = 1;
808                    data_rational[1].numerator = i;
809                    data_rational[1].denominator = 1;
810                    data_rational[2].numerator = counter;
811                    data_rational[2].denominator = total_tag_count;
812                    break;
813                default:
814                    FAIL() << "Unknown type field encountered:" << type;
815                    break;
816            }
817            result = add_camera_metadata_entry(m,
818                    tag,
819                    data,
820                    entry_data_count);
821            ASSERT_EQ(OK, result);
822
823        }
824    }
825
826    dump_camera_metadata(m, 2);
827
828    free_camera_metadata(m);
829}
830