Gitiles
Code Review Sign In
gerrit-public.fairphone.software / fp2-dev / platform / hardware / samsung_slsi / exynos5 / c15a6b003394494149ef7d65ae35c38755cb8b93 / . / libcamera2 / MetadataConverter.cpp
blob: b0948bcfb0a6e8f07f3bc0da5a92f8836f4feb44 [file] [log] [blame]
Jiyoung Shinc15a6b02012-06-05 01:08:14 -0700[diff] [blame^]1/*
2**
3** Copyright 2008, The Android Open Source Project
4** Copyright 2012, Samsung Electronics Co. LTD
5**
6** Licensed under the Apache License, Version 2.0 (the "License");
7** you may not use this file except in compliance with the License.
8** You may obtain a copy of the License at
9**
10** http://www.apache.org/licenses/LICENSE-2.0
11**
12** Unless required by applicable law or agreed to in writing, software
13** distributed under the License is distributed on an "AS IS" BASIS,
14** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15** See the License for the specific language governing permissions and
16** limitations under the License.
17*/
18
19/*!
20 * \file MetadataConverter.cpp
21 * \brief source file for Metadata converter ( for camera hal2 implementation )
22 * \author Sungjoong Kang(sj3.kang@samsung.com)
23 * \date 2012/05/31
24 *
25 * <b>Revision History: </b>
26 * - 2012/05/31 : Sungjoong Kang(sj3.kang@samsung.com) \n
27 * Initial Release
28 */
29
30//#define LOG_NDEBUG 0
31#define LOG_TAG "MetadataConverter"
32#include <utils/Log.h>
33
34#include "MetadataConverter.h"
35
36namespace android {
37
38
39MetadataConverter::MetadataConverter()
40{
41 return;
42}
43
44
45MetadataConverter::~MetadataConverter()
46{
47 ALOGV("DEBUG(%s):", __func__);
48 return;
49}
50
51status_t MetadataConverter::CheckEntryTypeMismatch(camera_metadata_entry_t * entry,
52 uint8_t type)
53{
54 if (!(entry->type==type))
55 {
56 ALOGV("DEBUG(%s):Metadata Missmatch tag(%s) type (%d) count(%d)",
57 __func__, get_camera_metadata_tag_name(entry->tag), entry->type, entry->count);
58 return BAD_VALUE;
59 }
60 return NO_ERROR;
61}
62
63status_t MetadataConverter::CheckEntryTypeMismatch(camera_metadata_entry_t * entry,
64 uint8_t type, size_t count)
65{
66 if (!((entry->type==type)&&(entry->count==count)))
67 {
68 ALOGV("DEBUG(%s):Metadata Missmatch tag(%s) type (%d) count(%d)",
69 __func__, get_camera_metadata_tag_name(entry->tag), entry->type, entry->count);
70 return BAD_VALUE;
71 }
72 return NO_ERROR;
73}
74
75status_t MetadataConverter::ToInternalCtl(camera_metadata_t * request, camera2_ctl_metadata_NEW_t * dst)
76{
77 uint32_t num_entry = 0;
78 uint32_t index = 0;
79 uint32_t i = 0;
80 camera_metadata_entry_t curr_entry;
81
82 ALOGV("DEBUG(%s):", __func__);
83 if (request == NULL || dst == NULL)
84 return BAD_VALUE;
85
86 num_entry = (uint32_t)get_camera_metadata_data_count(request);
87 for (index = 0 ; index < num_entry ; index++) {
88
89 if (get_camera_metadata_entry(request, index, &curr_entry)==0) {
90 //ALOGV("### MetadataConverter.ToInternalCtl. tag(%x)", curr_entry.tag);
91 switch (curr_entry.tag) {
92
93 case ANDROID_LENS_FOCUS_DISTANCE:
94 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
95 break;
96 dst->ctl.lens.focusDistance = curr_entry.data.f[0];
97 break;
98
99 case ANDROID_LENS_APERTURE:
100 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
101 break;
102 dst->ctl.lens.aperture = curr_entry.data.f[0];
103 break;
104
105 case ANDROID_LENS_FOCAL_LENGTH:
106 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
107 break;
108 dst->ctl.lens.focalLength = curr_entry.data.f[0];
109 break;
110
111 case ANDROID_LENS_FILTER_DENSITY:
112 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 1))
113 break;
114 dst->ctl.lens.filterDensity = curr_entry.data.f[0];
115 break;
116
117 case ANDROID_LENS_OPTICAL_STABILIZATION_MODE:
118 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
119 break;
120 dst->ctl.lens.opticalStabilizationMode =
121 (optical_stabilization_mode_NEW_t)curr_entry.data.u8[0];
122 break;
123
124
125
126 case ANDROID_SENSOR_EXPOSURE_TIME:
127 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
128 break;
129 dst->ctl.sensor.exposureTime = curr_entry.data.i64[0];
130 break;
131
132 case ANDROID_SENSOR_FRAME_DURATION:
133 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
134 break;
135 dst->ctl.sensor.frameDuration = curr_entry.data.i64[0];
136 break;
137
138 case ANDROID_SENSOR_SENSITIVITY:
139 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
140 break;
141 dst->ctl.sensor.sensitivity = curr_entry.data.i32[0];
142 break;
143
144
145
146 case ANDROID_FLASH_MODE:
147 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
148 break;
149 dst->ctl.flash.flashMode = (flash_mode_NEW_t)curr_entry.data.u8[0];
150 break;
151
152 case ANDROID_FLASH_FIRING_POWER:
153 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
154 break;
155 dst->ctl.flash.firingPower = curr_entry.data.u8[0];
156 break;
157
158 case ANDROID_FLASH_FIRING_TIME:
159 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
160 break;
161 dst->ctl.flash.firingTime = curr_entry.data.i64[0];
162 break;
163
164
165
166 case ANDROID_HOT_PIXEL_MODE:
167 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
168 break;
169 dst->ctl.hotpixel.mode = (hotpixel_mode_NEW_t)curr_entry.data.u8[0];
170 break;
171
172
173
174 case ANDROID_DEMOSAIC_MODE:
175 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
176 break;
177 dst->ctl.demosaic.mode = (demosaic_mode_NEW_t)curr_entry.data.u8[0];
178 break;
179
180
181
182 case ANDROID_NOISE_MODE:
183 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
184 break;
185 dst->ctl.noise.mode = (noise_mode_NEW_t)curr_entry.data.u8[0];
186 break;
187
188 case ANDROID_NOISE_STRENGTH:
189 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
190 break;
191 dst->ctl.noise.strength= curr_entry.data.u8[0];
192 break;
193
194
195
196 case ANDROID_SHADING_MODE:
197 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
198 break;
199 dst->ctl.shading.mode = (shading_mode_NEW_t)curr_entry.data.u8[0];
200 break;
201
202
203
204 case ANDROID_GEOMETRIC_MODE:
205 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
206 break;
207 dst->ctl.geometric.mode = (geometric_mode_NEW_t)curr_entry.data.u8[0];
208 break;
209
210
211
212 case ANDROID_COLOR_MODE:
213 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
214 break;
215 dst->ctl.color.mode = (colorcorrection_mode_NEW_t)curr_entry.data.u8[0];
216 break;
217
218 case ANDROID_COLOR_TRANSFORM:
219 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 9))
220 break;
221 for (i=0 ; i<curr_entry.count ; i++)
222 dst->ctl.color.transform[i] = curr_entry.data.f[i];
223 break;
224
225
226
227 case ANDROID_TONEMAP_MODE:
228 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
229 break;
230 dst->ctl.tonemap.mode = (tonemap_mode_NEW_t)curr_entry.data.u8[0];
231 break;
232
233 case ANDROID_TONEMAP_CURVE_RED:
234 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 32))
235 break;
236 for (i=0 ; i<curr_entry.count ; i++)
237 dst->ctl.tonemap.curveRed[i] = curr_entry.data.f[i];
238 break;
239
240 case ANDROID_TONEMAP_CURVE_GREEN:
241 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 32))
242 break;
243 for (i=0 ; i<curr_entry.count ; i++)
244 dst->ctl.tonemap.curveGreen[i] = curr_entry.data.f[i];
245 break;
246
247 case ANDROID_TONEMAP_CURVE_BLUE:
248 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_FLOAT, 32))
249 break;
250 for (i=0 ; i<curr_entry.count ; i++)
251 dst->ctl.tonemap.curveBlue[i] = curr_entry.data.f[i];
252 break;
253
254
255
256 case ANDROID_EDGE_MODE:
257 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
258 break;
259 dst->ctl.edge.mode = (edge_mode_NEW_t)curr_entry.data.u8[0];
260 break;
261
262 case ANDROID_EDGE_STRENGTH:
263 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
264 break;
265 dst->ctl.edge.strength = (edge_mode_NEW_t)curr_entry.data.u8[0];
266 break;
267
268
269
270 case ANDROID_SCALER_CROP_REGION:
271 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 3))
272 break;
273 for (i=0 ; i<curr_entry.count ; i++)
274 dst->ctl.scaler.cropRegion[i] = curr_entry.data.i32[i];
275 break;
276
277
278
279 case ANDROID_JPEG_QUALITY:
280 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
281 break;
282 dst->ctl.jpeg.quality= curr_entry.data.i32[0];
283 break;
284
285 case ANDROID_JPEG_THUMBNAIL_SIZE:
286 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 2))
287 break;
288 for (i=0 ; i<curr_entry.count ; i++)
289 dst->ctl.jpeg.thumbnailSize[i] = curr_entry.data.i32[i];
290 break;
291
292 case ANDROID_JPEG_THUMBNAIL_QUALITY:
293 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
294 break;
295 dst->ctl.jpeg.thumbnailQuality= curr_entry.data.i32[0];
296 break;
297
298 case ANDROID_JPEG_GPS_COORDINATES:
299 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_DOUBLE, 2)) // needs check
300 break;
301 for (i=0 ; i<curr_entry.count ; i++)
302 dst->ctl.jpeg.gpsCoordinates[i] = curr_entry.data.d[i];
303 break;
304
305 case ANDROID_JPEG_GPS_PROCESSING_METHOD:
306 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 32))
307 break;
308 for (i=0 ; i<curr_entry.count ; i++)
309 dst->ctl.jpeg.gpsProcessingMethod[i] = curr_entry.data.u8[i];
310 break;
311
312 case ANDROID_JPEG_GPS_TIMESTAMP:
313 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT64, 1))
314 break;
315 dst->ctl.jpeg.gpsTimestamp = curr_entry.data.i64[0];
316 break;
317
318 case ANDROID_JPEG_ORIENTATION:
319 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
320 break;
321 dst->ctl.jpeg.orientation = curr_entry.data.i32[0];
322 break;
323
324
325
326 case ANDROID_STATS_FACE_DETECT_MODE:
327 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
328 break;
329 dst->ctl.stats.faceDetectMode = (facedetect_mode_NEW_t)curr_entry.data.u8[0];
330 break;
331
332 case ANDROID_STATS_HISTOGRAM_MODE:
333 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
334 break;
335 dst->ctl.stats.histogramMode = (histogram_mode_NEW_t)curr_entry.data.u8[0];
336 break;
337
338 case ANDROID_STATS_SHARPNESS_MAP_MODE:
339 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
340 break;
341 dst->ctl.stats.sharpnessMapMode = (sharpnessmap_mode_NEW_t)curr_entry.data.u8[0];
342 break;
343
344
345
346 case ANDROID_CONTROL_CAPTURE_INTENT:
347 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
348 break;
349 dst->ctl.aa.captureIntent = (aa_captureintent_NEW_t)curr_entry.data.u8[0];
350 break;
351
352 case ANDROID_CONTROL_MODE:
353 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
354 break;
355 dst->ctl.aa.mode = (aa_mode_NEW_t)curr_entry.data.u8[0];
356 break;
357
358 case ANDROID_CONTROL_EFFECT_MODE:
359 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
360 break;
361 dst->ctl.aa.effect_mode = (aa_effect_mode_NEW_t)curr_entry.data.u8[0];
362 break;
363
364 case ANDROID_CONTROL_SCENE_MODE:
365 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
366 break;
367 dst->ctl.aa.scene_mode = (aa_scene_mode_NEW_t)curr_entry.data.u8[0];
368 break;
369
370 case ANDROID_CONTROL_VIDEO_STABILIZATION_MODE:
371 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
372 break;
373 dst->ctl.aa.videoStabilizationMode = (aa_video_stab_mode_NEW_t)curr_entry.data.u8[0];
374 break;
375
376 case ANDROID_CONTROL_AE_MODE:
377 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
378 break;
379 dst->ctl.aa.aeMode= (aa_aemode_NEW_t)curr_entry.data.u8[0];
380 break;
381
382 case ANDROID_CONTROL_AE_REGIONS:
383 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 5))
384 break;
385 for (i=0 ; i<curr_entry.count ; i++)
386 dst->ctl.aa.aeRegions[i] = curr_entry.data.i32[i];
387 break;
388
389 case ANDROID_CONTROL_AE_EXP_COMPENSATION:
390 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
391 break;
392 dst->ctl.aa.aeExpCompensation= (aa_aemode_NEW_t)curr_entry.data.i32[0];
393 break;
394
395 case ANDROID_CONTROL_AE_TARGET_FPS_RANGE:
396 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 2))
397 break;
398 for (i=0 ; i<curr_entry.count ; i++)
399 dst->ctl.aa.aeTargetFpsRange[i] = curr_entry.data.i32[i];
400 break;
401
402 case ANDROID_CONTROL_AE_ANTIBANDING_MODE:
403 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
404 break;
405 dst->ctl.aa.aeAntibandingMode = (aa_ae_antibanding_mode_NEW_t)curr_entry.data.u8[0];
406 break;
407
408 case ANDROID_CONTROL_AWB_MODE:
409 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
410 break;
411 dst->ctl.aa.awbMode = (aa_awbmode_NEW_t)curr_entry.data.u8[0];
412 break;
413
414 case ANDROID_CONTROL_AWB_REGIONS:
415 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 5))
416 break;
417 for (i=0 ; i<curr_entry.count ; i++)
418 dst->ctl.aa.awbRegions[i] = curr_entry.data.i32[i];
419 break;
420
421 case ANDROID_CONTROL_AF_MODE:
422 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
423 break;
424 dst->ctl.aa.afMode = (aa_afmode_NEW_t)curr_entry.data.u8[0];
425 break;
426
427 case ANDROID_CONTROL_AF_REGIONS:
428 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 5))
429 break;
430 for (i=0 ; i<curr_entry.count ; i++)
431 dst->ctl.aa.afRegions[i] = curr_entry.data.i32[i];
432 break;
433
434
435
436 case ANDROID_REQUEST_ID:
437 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
438 break;
439 dst->ctl.request.id = curr_entry.data.i32[0];
440 ALOGV("DEBUG(%s): ANDROID_REQUEST_ID (%d)", __func__, dst->ctl.request.id);
441 break;
442
443 case ANDROID_REQUEST_METADATA_MODE:
444 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE, 1))
445 break;
446 dst->ctl.request.metadataMode = (metadata_mode_NEW_t)curr_entry.data.u8[0];
447 ALOGV("DEBUG(%s): ANDROID_REQUEST_METADATA_MODE (%d)", __func__, (int)( dst->ctl.request.metadataMode));
448 break;
449
450 case ANDROID_REQUEST_OUTPUT_STREAMS:
451 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_BYTE))
452 break;
453 for (i=0 ; i<curr_entry.count ; i++)
454 dst->ctl.request.outputStreams[i] = curr_entry.data.u8[i];
455 dst->ctl.request.numOutputStream = curr_entry.count;
456 break;
457
458 case ANDROID_REQUEST_FRAME_COUNT:
459 if (NO_ERROR != CheckEntryTypeMismatch(&curr_entry, TYPE_INT32, 1))
460 break;
461 dst->ctl.request.frameCount = curr_entry.data.i32[0];
462 ALOGV("DEBUG(%s): ANDROID_REQUEST_FRAME_COUNT (%d)", __func__, dst->ctl.request.frameCount);
463 break;
464
465 default:
466 ALOGD("DEBUG(%s):Bad Metadata tag (%d)", __func__, curr_entry.tag);
467 break;
468 }
469 }
470 }
471
472 return NO_ERROR;
473}
474
475
476
477
478status_t MetadataConverter::ToDynamicMetadata(camera2_ctl_metadata_NEW_t * metadata, camera_metadata_t * dst)
479{
480 status_t res;
481
482 ALOGV("DEBUG(%s): TEMP version using original request METADATA", __func__);
483 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_ID,
484 &(metadata->ctl.request.id), 1))
485 return NO_MEMORY;
486
487 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_METADATA_MODE,
488 &(metadata->ctl.request.metadataMode), 1))
489 return NO_MEMORY;
490
491 // needs check!
492 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_FRAME_COUNT,
493 &(metadata->ctl.request.frameCount), 1))
494 return NO_MEMORY;
495
496
497 if (metadata->ctl.request.metadataMode == METADATA_MODE_NONE_NEW) {
498 ALOGV("DEBUG(%s): METADATA_MODE_NONE", __func__);
499 return NO_ERROR;
500 }
501
502 ALOGV("DEBUG(%s): METADATA_MODE_FULL", __func__);
503
504
505 return NO_ERROR;
506
507
508}
509
510#if 0 // blocked for alpha version
511
512status_t MetadataConverter::ToDynamicMetadata(camera2_ctl_metadata_t * metadata, camera_metadata_t * dst)
513{
514 status_t res;
515
516 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_ID,
517 &(metadata->dm.request.id), 1))
518 return NO_MEMORY;
519
520 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_METADATA_MODE,
521 &(metadata->dm.request.metadataMode), 1))
522 return NO_MEMORY;
523
524 // needs check!
525 if (0 != add_camera_metadata_entry(dst, ANDROID_REQUEST_FRAME_COUNT,
526 &(metadata->dm.request.frameCount), 1))
527 return NO_MEMORY;
528
529
530 if (metadata->dm.request.metadataMode == METADATA_MODE_NONE) {
531 ALOGD("DEBUG(%s): METADATA_MODE_NONE", __func__);
532 return NO_ERROR;
533 }
534
535 ALOGD("DEBUG(%s): METADATA_MODE_FULL", __func__);
536
537 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_FOCUS_DISTANCE,
538 &(metadata->dm.lens.focusDistance), 1))
539 return NO_MEMORY;
540
541 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_APERTURE,
542 &(metadata->dm.lens.aperture), 1))
543 return NO_MEMORY;
544
545 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_FOCAL_LENGTH,
546 &(metadata->dm.lens.focalLength), 1))
547 return NO_MEMORY;
548
549 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_FILTER_DENSITY,
550 &(metadata->dm.lens.filterDensity), 1))
551 return NO_MEMORY;
552
553 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_OPTICAL_STABILIZATION_MODE,
554 &(metadata->dm.lens.opticalStabilizationMode), 1))
555 return NO_MEMORY;
556
557 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_APERTURE,
558 &(metadata->dm.lens.aperture), 1))
559 return NO_MEMORY;
560
561 if (0 != add_camera_metadata_entry(dst, ANDROID_LENS_FOCUS_RANGE,
562 &(metadata->dm.lens.focusRange[0]), 2))
563 return NO_MEMORY;
564
565
566
567 if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_EXPOSURE_TIME,
568 &(metadata->dm.sensor.exposureTime), 1))
569 return NO_MEMORY;
570
571 if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_FRAME_DURATION,
572 &(metadata->dm.sensor.frameDuration), 1))
573 return NO_MEMORY;
574
575 if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_SENSITIVITY,
576 &(metadata->dm.sensor.sensitivity), 1))
577 return NO_MEMORY;
578
579 if (0 != add_camera_metadata_entry(dst, ANDROID_SENSOR_TIMESTAMP,
580 &(metadata->dm.sensor.timeStamp), 1))
581 return NO_MEMORY;
582
583
584
585 if (0 != add_camera_metadata_entry(dst, ANDROID_FLASH_MODE,
586 &(metadata->dm.flash.flashMode), 1))
587 return NO_MEMORY;
588
589 if (0 != add_camera_metadata_entry(dst, ANDROID_FLASH_FIRING_POWER,
590 &(metadata->dm.flash.firingPower), 1))
591 return NO_MEMORY;
592
593 if (0 != add_camera_metadata_entry(dst, ANDROID_FLASH_FIRING_TIME,
594 &(metadata->dm.flash.firingPower), 1))
595 return NO_MEMORY;
596
597
598
599 if (0 != add_camera_metadata_entry(dst, ANDROID_HOT_PIXEL_MODE,
600 &(metadata->dm.hotpixel.mode), 1))
601 return NO_MEMORY;
602
603
604
605 if (0 != add_camera_metadata_entry(dst, ANDROID_DEMOSAIC_MODE,
606 &(metadata->dm.demosaic.mode), 1))
607 return NO_MEMORY;
608
609
610
611 if (0 != add_camera_metadata_entry(dst, ANDROID_NOISE_MODE,
612 &(metadata->dm.noise.mode), 1))
613 return NO_MEMORY;
614
615 if (0 != add_camera_metadata_entry(dst, ANDROID_NOISE_STRENGTH,
616 &(metadata->dm.noise.strength), 1))
617 return NO_MEMORY;
618
619
620 if (0 != add_camera_metadata_entry(dst, ANDROID_SHADING_MODE,
621 &(metadata->dm.shading.mode), 1))
622 return NO_MEMORY;
623
624
625
626 if (0 != add_camera_metadata_entry(dst, ANDROID_GEOMETRIC_MODE,
627 &(metadata->dm.geometric.mode), 1))
628 return NO_MEMORY;
629
630
631
632 if (0 != add_camera_metadata_entry(dst, ANDROID_COLOR_MODE,
633 &(metadata->dm.color.mode), 1))
634 return NO_MEMORY;
635
636 if (0 != add_camera_metadata_entry(dst, ANDROID_COLOR_TRANSFORM,
637 &(metadata->dm.color.transform), 9))
638 return NO_MEMORY;
639
640
641
642 if (0 != add_camera_metadata_entry(dst, ANDROID_TONEMAP_MODE,
643 &(metadata->dm.tonemap.mode), 1))
644 return NO_MEMORY;
645
646 if (0 != add_camera_metadata_entry(dst, ANDROID_TONEMAP_CURVE_RED,
647 &(metadata->dm.tonemap.curveRed), 32))
648 return NO_MEMORY;
649
650 if (0 != add_camera_metadata_entry(dst, ANDROID_TONEMAP_CURVE_GREEN,
651 &(metadata->dm.tonemap.curveGreen), 32))
652 return NO_MEMORY;
653
654 if (0 != add_camera_metadata_entry(dst, ANDROID_TONEMAP_CURVE_BLUE,
655 &(metadata->dm.tonemap.curveBlue), 32))
656 return NO_MEMORY;
657
658
659
660 if (0 != add_camera_metadata_entry(dst, ANDROID_EDGE_MODE,
661 &(metadata->dm.edge.mode), 1))
662 return NO_MEMORY;
663
664 if (0 != add_camera_metadata_entry(dst, ANDROID_EDGE_STRENGTH,
665 &(metadata->dm.edge.strength), 1))
666 return NO_MEMORY;
667
668
669
670 if (0 != add_camera_metadata_entry(dst, ANDROID_SCALER_CROP_REGION,
671 &(metadata->dm.scaler.cropRegion), 3))
672 return NO_MEMORY;
673
674
675
676 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_QUALITY,
677 &(metadata->dm.jpeg.quality), 1))
678 return NO_MEMORY;
679
680 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_THUMBNAIL_SIZE,
681 &(metadata->dm.jpeg.thumbnailSize), 2))
682 return NO_MEMORY;
683
684 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_THUMBNAIL_QUALITY,
685 &(metadata->dm.jpeg.thumbnailQuality), 1))
686 return NO_MEMORY;
687
688 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_COORDINATES,
689 &(metadata->dm.jpeg.gpsCoordinates), 2)) // needs check
690 return NO_MEMORY;
691
692 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_PROCESSING_METHOD,
693 &(metadata->dm.jpeg.gpsProcessingMethod), 32))
694 return NO_MEMORY;
695
696 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_GPS_TIMESTAMP,
697 &(metadata->dm.jpeg.gpsTimestamp), 1))
698 return NO_MEMORY;
699
700 if (0 != add_camera_metadata_entry(dst, ANDROID_JPEG_ORIENTATION,
701 &(metadata->dm.jpeg.orientation), 1))
702 return NO_MEMORY;
703
704
705
706 if (0 != add_camera_metadata_entry(dst, ANDROID_STATS_FACE_DETECT_MODE,
707 &(metadata->dm.stats.faceDetectMode), 1))
708 return NO_MEMORY;
709
710 // TODO : more stat entries
711
712
713
714 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_MODE,
715 &(metadata->dm.aa.mode), 1))
716 return NO_MEMORY;
717
718 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_CAPTURE_INTENT,
719 &(metadata->dm.aa.captureIntent), 1))
720 return NO_MEMORY;
721
722 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_EFFECT_MODE,
723 &(metadata->dm.aa.effect_mode), 1))
724 return NO_MEMORY;
725
726 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_MODE,
727 &(metadata->dm.aa.aeMode), 1))
728 return NO_MEMORY;
729
730 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_REGIONS,
731 &(metadata->dm.aa.aeRegions), 5))
732 return NO_MEMORY;
733
734 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_EXP_COMPENSATION,
735 &(metadata->dm.aa.aeExpCompensation), 1))
736 return NO_MEMORY;
737
738 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AE_STATE,
739 &(metadata->dm.aa.aeState), 1))
740 return NO_MEMORY;
741
742 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AWB_MODE,
743 &(metadata->dm.aa.awbMode), 1))
744 return NO_MEMORY;
745
746 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AWB_REGIONS,
747 &(metadata->dm.aa.awbRegions), 5))
748 return NO_MEMORY;
749
750 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AWB_STATE,
751 &(metadata->dm.aa.awbState), 1))
752 return NO_MEMORY;
753
754 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AF_MODE,
755 &(metadata->dm.aa.afMode), 1))
756 return NO_MEMORY;
757
758 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AF_REGIONS,
759 &(metadata->dm.aa.afRegions), 5))
760 return NO_MEMORY;
761
762 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_AF_STATE,
763 &(metadata->dm.aa.afState), 1))
764 return NO_MEMORY;
765
766 if (0 != add_camera_metadata_entry(dst, ANDROID_CONTROL_VIDEO_STABILIZATION_MODE,
767 &(metadata->dm.aa.videoStabilizationMode), 1))
768 return NO_MEMORY;
769
770
771 return NO_ERROR;
772
773/*
774typedef struct camera2_dm {
775 camera2_request_dm_t request;
776 camera2_lens_dm_t lens;
777 camera2_sensor_dm_t sensor;
778 camera2_flash_dm_t flash;
779 camera2_hotpixel_dm_t hotpixel;
780 camera2_demosaic_dm_t demosaic;
781 camera2_noisereduction_dm_t noise;
782 camera2_shading_dm_t shading;
783 camera2_geometric_dm_t geometric;
784 camera2_colorcorrection_dm_t color;
785 camera2_tonemap_dm_t tonemap;
786 camera2_edge_dm_t edge;
787 camera2_scaler_dm_t scaler;
788 camera2_jpeg_dm_t jpeg;
789 camera2_stats_dm_t stats;
790 camera2_aa_dm_t aa;
791} camera2_dm_t;
792*/
793
794}
795#endif
796
797
798}; // namespace android