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