AndroidCameraCapabilities.java revision c36e3c983c232dc45ed31f3d8e98d8cdd7ac14ba 
1/*
2 * Copyright (C) 2014 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
17package com.android.ex.camera2.portability;
18
19import android.graphics.Point;
20import android.hardware.Camera;
21
22import com.android.ex.camera2.portability.debug.Log;
23
24import java.util.Collections;
25import java.util.Comparator;
26import java.util.List;
27
28/**
29 * The subclass of {@link CameraCapabilities} for Android Camera 1 API.
30 */
31public class AndroidCameraCapabilities extends CameraCapabilities {
32
33    private static Log.Tag TAG = new Log.Tag("AndroidCameraCapabilities");
34
35    private FpsComparator mFpsComparator = new FpsComparator();
36    private SizeComparator mSizeComparator = new SizeComparator();
37
38    AndroidCameraCapabilities(Camera.Parameters p) {
39        super(new AndroidCameraCapabilityStringifier());
40        mMaxExposureCompensation = p.getMaxExposureCompensation();
41        mMinExposureCompensation = p.getMinExposureCompensation();
42        mExposureCompensationStep = p.getExposureCompensationStep();
43        mMaxNumOfFacesSupported = p.getMaxNumDetectedFaces();
44        mMaxNumOfMeteringArea = p.getMaxNumMeteringAreas();
45        mSupportedPreviewFormats.addAll(p.getSupportedPreviewFormats());
46        mSupportedPictureFormats.addAll(p.getSupportedPictureFormats());
47        buildPreviewFpsRange(p);
48        buildPreviewSizes(p);
49        buildVideoSizes(p);
50        buildPictureSizes(p);
51        buildSceneModes(p);
52        buildFlashModes(p);
53        buildFocusModes(p);
54        buildWhiteBalances(p);
55
56        if (p.isZoomSupported()) {
57            mSupportedFeatures.add(Feature.ZOOM);
58        }
59        if (p.isVideoSnapshotSupported()) {
60            mSupportedFeatures.add(Feature.VIDEO_SNAPSHOT);
61        }
62        if (p.isAutoExposureLockSupported()) {
63            mSupportedFeatures.add(Feature.AUTO_EXPOSURE_LOCK);
64        }
65        if (p.isAutoWhiteBalanceLockSupported()) {
66            mSupportedFeatures.add(Feature.AUTO_WHITE_BALANCE_LOCK);
67        }
68        if (supports(FocusMode.AUTO)) {
69            mMaxNumOfFocusAreas = p.getMaxNumFocusAreas();
70            if (mMaxNumOfFocusAreas > 0) {
71                mSupportedFeatures.add(Feature.FOCUS_AREA);
72            }
73        }
74        if (mMaxNumOfMeteringArea > 0) {
75            mSupportedFeatures.add(Feature.METERING_AREA);
76        }
77    }
78
79    AndroidCameraCapabilities(AndroidCameraCapabilities src) {
80        super(src);
81    }
82
83    private void buildPreviewFpsRange(Camera.Parameters p) {
84        List<int[]> supportedPreviewFpsRange = p.getSupportedPreviewFpsRange();
85        if (supportedPreviewFpsRange != null) {
86            mSupportedPreviewFpsRange.addAll(supportedPreviewFpsRange);
87        }
88        Collections.sort(mSupportedPreviewFpsRange, mFpsComparator);
89    }
90
91    private void buildPreviewSizes(Camera.Parameters p) {
92        List<Camera.Size> supportedPreviewSizes = p.getSupportedPreviewSizes();
93        if (supportedPreviewSizes != null) {
94            for (Camera.Size s : supportedPreviewSizes) {
95                mSupportedPreviewSizes.add(new Point(s.width, s.height));
96            }
97        }
98        Collections.sort(mSupportedPreviewSizes, mSizeComparator);
99    }
100
101    private void buildVideoSizes(Camera.Parameters p) {
102        List<Camera.Size> supportedVideoSizes = p.getSupportedVideoSizes();
103        if (supportedVideoSizes != null) {
104            for (Camera.Size s : supportedVideoSizes) {
105                mSupportedVideoSizes.add(new Point(s.width, s.height));
106            }
107        }
108        Collections.sort(mSupportedVideoSizes, mSizeComparator);
109    }
110
111    private void buildPictureSizes(Camera.Parameters p) {
112        List<Camera.Size> supportedPictureSizes = p.getSupportedPictureSizes();
113        if (supportedPictureSizes != null) {
114            for (Camera.Size s : supportedPictureSizes) {
115                mSupportedPictureSizes.add(new Point(s.width, s.height));
116            }
117        }
118        Collections.sort(mSupportedPictureSizes, mSizeComparator);
119
120    }
121
122    private void buildSceneModes(Camera.Parameters p) {
123        List<String> supportedSceneModes = p.getSupportedSceneModes();
124        if (supportedSceneModes != null) {
125            for (String scene : supportedSceneModes) {
126                if (Camera.Parameters.SCENE_MODE_AUTO.equals(scene)) {
127                    mSupportedSceneModes.add(SceneMode.AUTO);
128                } else if (Camera.Parameters.SCENE_MODE_ACTION.equals(scene)) {
129                    mSupportedSceneModes.add(SceneMode.ACTION);
130                } else if (Camera.Parameters.SCENE_MODE_BARCODE.equals(scene)) {
131                    mSupportedSceneModes.add(SceneMode.BARCODE);
132                } else if (Camera.Parameters.SCENE_MODE_BEACH.equals(scene)) {
133                    mSupportedSceneModes.add(SceneMode.BEACH);
134                } else if (Camera.Parameters.SCENE_MODE_CANDLELIGHT.equals(scene)) {
135                    mSupportedSceneModes.add(SceneMode.CANDLELIGHT);
136                } else if (Camera.Parameters.SCENE_MODE_FIREWORKS.equals(scene)) {
137                    mSupportedSceneModes.add(SceneMode.FIREWORKS);
138                } else if (Camera.Parameters.SCENE_MODE_HDR.equals(scene)) {
139                    mSupportedSceneModes.add(SceneMode.HDR);
140                } else if (Camera.Parameters.SCENE_MODE_LANDSCAPE.equals(scene)) {
141                    mSupportedSceneModes.add(SceneMode.LANDSCAPE);
142                } else if (Camera.Parameters.SCENE_MODE_NIGHT.equals(scene)) {
143                    mSupportedSceneModes.add(SceneMode.NIGHT);
144                } else if (Camera.Parameters.SCENE_MODE_NIGHT_PORTRAIT.equals(scene)) {
145                    mSupportedSceneModes.add(SceneMode.NIGHT_PORTRAIT);
146                } else if (Camera.Parameters.SCENE_MODE_PARTY.equals(scene)) {
147                    mSupportedSceneModes.add(SceneMode.PARTY);
148                } else if (Camera.Parameters.SCENE_MODE_PORTRAIT.equals(scene)) {
149                    mSupportedSceneModes.add(SceneMode.PORTRAIT);
150                } else if (Camera.Parameters.SCENE_MODE_SNOW.equals(scene)) {
151                    mSupportedSceneModes.add(SceneMode.SNOW);
152                } else if (Camera.Parameters.SCENE_MODE_SPORTS.equals(scene)) {
153                    mSupportedSceneModes.add(SceneMode.SPORTS);
154                } else if (Camera.Parameters.SCENE_MODE_STEADYPHOTO.equals(scene)) {
155                    mSupportedSceneModes.add(SceneMode.STEADYPHOTO);
156                } else if (Camera.Parameters.SCENE_MODE_SUNSET.equals(scene)) {
157                    mSupportedSceneModes.add(SceneMode.SUNSET);
158                } else if (Camera.Parameters.SCENE_MODE_THEATRE.equals(scene)) {
159                    mSupportedSceneModes.add(SceneMode.THEATRE);
160                }
161            }
162        }
163    }
164
165    private void buildFlashModes(Camera.Parameters p) {
166        List<String> supportedFlashModes = p.getSupportedFlashModes();
167        if (supportedFlashModes != null) {
168            for (String flash : supportedFlashModes) {
169                if (Camera.Parameters.FLASH_MODE_AUTO.equals(flash)) {
170                    mSupportedFlashModes.add(FlashMode.AUTO);
171                } else if (Camera.Parameters.FLASH_MODE_OFF.equals(flash)) {
172                    mSupportedFlashModes.add(FlashMode.OFF);
173                } else if (Camera.Parameters.FLASH_MODE_ON.equals(flash)) {
174                    mSupportedFlashModes.add(FlashMode.ON);
175                } else if (Camera.Parameters.FLASH_MODE_RED_EYE.equals(flash)) {
176                    mSupportedFlashModes.add(FlashMode.RED_EYE);
177                }
178            }
179        }
180    }
181
182    private void buildFocusModes(Camera.Parameters p) {
183        List<String> supportedFocusModes = p.getSupportedFocusModes();
184        if (supportedFocusModes != null) {
185            for (String focus : supportedFocusModes) {
186                if (Camera.Parameters.FOCUS_MODE_AUTO.equals(focus)) {
187                    mSupportedFocusModes.add(FocusMode.AUTO);
188                } else if (Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE.equals(focus)) {
189                    mSupportedFocusModes.add(FocusMode.CONTINUOUS_PICTURE);
190                } else if (Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO.equals(focus)) {
191                    mSupportedFocusModes.add(FocusMode.CONTINUOUS_VIDEO);
192                } else if (Camera.Parameters.FOCUS_MODE_EDOF.equals(focus)) {
193                    mSupportedFocusModes.add(FocusMode.EXTENDED_DOF);
194                } else if (Camera.Parameters.FOCUS_MODE_FIXED.equals(focus)) {
195                    mSupportedFocusModes.add(FocusMode.FIXED);
196                } else if (Camera.Parameters.FOCUS_MODE_INFINITY.equals(focus)) {
197                    mSupportedFocusModes.add(FocusMode.INFINITY);
198                } else if (Camera.Parameters.FOCUS_MODE_MACRO.equals(focus)) {
199                    mSupportedFocusModes.add(FocusMode.MACRO);
200                }
201            }
202        }
203    }
204
205    private void buildWhiteBalances(Camera.Parameters p) {
206        List<String> supportedWhiteBalances = p.getSupportedFocusModes();
207        if (supportedWhiteBalances != null) {
208            for (String wb : supportedWhiteBalances) {
209                if (Camera.Parameters.WHITE_BALANCE_AUTO.equals(wb)) {
210                    mSupportedWhiteBalances.add(WhiteBalance.AUTO);
211                } else if (Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT.equals(wb)) {
212                    mSupportedWhiteBalances.add(WhiteBalance.CLOUDY_DAYLIGHT);
213                } else if (Camera.Parameters.WHITE_BALANCE_DAYLIGHT.equals(wb)) {
214                    mSupportedWhiteBalances.add(WhiteBalance.DAYLIGHT);
215                } else if (Camera.Parameters.WHITE_BALANCE_FLUORESCENT.equals(wb)) {
216                    mSupportedWhiteBalances.add(WhiteBalance.FLUORESCENT);
217                } else if (Camera.Parameters.WHITE_BALANCE_INCANDESCENT.equals(wb)) {
218                    mSupportedWhiteBalances.add(WhiteBalance.INCANDESCENT);
219                } else if (Camera.Parameters.WHITE_BALANCE_SHADE.equals(wb)) {
220                    mSupportedWhiteBalances.add(WhiteBalance.SHADE);
221                } else if (Camera.Parameters.WHITE_BALANCE_TWILIGHT.equals(wb)) {
222                    mSupportedWhiteBalances.add(WhiteBalance.TWILIGHT);
223                } else if (Camera.Parameters.WHITE_BALANCE_WARM_FLUORESCENT.equals(wb)) {
224                    mSupportedWhiteBalances.add(WhiteBalance.WARM_FLUORESCENT);
225                }
226            }
227        }
228    }
229
230    private static class FpsComparator implements Comparator<int[]> {
231        @Override
232        public int compare(int[] fps1, int[] fps2) {
233            return (fps1[0] == fps2[0] ? fps1[1] - fps2[1] : fps1[0] - fps2[0]);
234        }
235    }
236
237    private static class SizeComparator implements Comparator<Point> {
238
239        @Override
240        public int compare(Point size1, Point size2) {
241            return (size1.x == size2.x ? size1.y - size2.y : size1.x - size2.x);
242        }
243    }
244
245    private static class AndroidCameraCapabilityStringifier implements Stringifier {
246
247        @Override
248        public String stringify(FocusMode focus) {
249            switch (focus) {
250                case AUTO:
251                    return Camera.Parameters.FOCUS_MODE_AUTO;
252                case CONTINUOUS_PICTURE:
253                    return Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE;
254                case CONTINUOUS_VIDEO:
255                    return Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO;
256                case EXTENDED_DOF:
257                    return Camera.Parameters.FOCUS_MODE_EDOF;
258                case FIXED:
259                    return Camera.Parameters.FOCUS_MODE_FIXED;
260                case INFINITY:
261                    return Camera.Parameters.FOCUS_MODE_INFINITY;
262                case MACRO:
263                    return Camera.Parameters.FOCUS_MODE_MACRO;
264            }
265            return null;
266        }
267
268        @Override
269        public FocusMode focusModeFromString(String val) {
270            if (val.equals(Camera.Parameters.FOCUS_MODE_AUTO)) {
271                return FocusMode.AUTO;
272            } else if (val.equals(Camera.Parameters.FOCUS_MODE_CONTINUOUS_PICTURE)) {
273                return FocusMode.CONTINUOUS_PICTURE;
274            } else if (val.equals(Camera.Parameters.FOCUS_MODE_CONTINUOUS_VIDEO)) {
275                return FocusMode.CONTINUOUS_VIDEO;
276            } else if (val.equals(Camera.Parameters.FOCUS_MODE_EDOF)) {
277                return FocusMode.EXTENDED_DOF;
278            } else if (val.equals(Camera.Parameters.FOCUS_MODE_FIXED)) {
279                return FocusMode.FIXED;
280            } else if (val.equals(Camera.Parameters.FOCUS_MODE_INFINITY)) {
281                return FocusMode.INFINITY;
282            } else if (val.equals(Camera.Parameters.FOCUS_MODE_MACRO)) {
283                return FocusMode.MACRO;
284            } else {
285                return null;
286            }
287        }
288
289        @Override
290        public String stringify(FlashMode flash) {
291            switch (flash) {
292                case AUTO:
293                    return Camera.Parameters.FLASH_MODE_AUTO;
294                case OFF:
295                    return Camera.Parameters.FLASH_MODE_OFF;
296                case ON:
297                    return Camera.Parameters.FLASH_MODE_ON;
298                case TORCH:
299                    return Camera.Parameters.FLASH_MODE_TORCH;
300                case RED_EYE:
301                    return Camera.Parameters.FLASH_MODE_RED_EYE;
302            }
303            return null;
304        }
305
306        @Override
307        public FlashMode flashModeFromString(String val) {
308            if (val.equals(Camera.Parameters.FLASH_MODE_AUTO)) {
309                return FlashMode.AUTO;
310            } else if (val.equals(Camera.Parameters.FLASH_MODE_OFF)) {
311                return FlashMode.OFF;
312            } else if (val.equals(Camera.Parameters.FLASH_MODE_ON)) {
313                return FlashMode.ON;
314            } else if (val.equals(Camera.Parameters.FLASH_MODE_TORCH)) {
315                return FlashMode.TORCH;
316            } else if (val.equals(Camera.Parameters.FLASH_MODE_RED_EYE)) {
317                return FlashMode.RED_EYE;
318            } else {
319                return null;
320            }
321        }
322
323        @Override
324        public String stringify(SceneMode scene) {
325            switch (scene) {
326                case AUTO:
327                    return Camera.Parameters.SCENE_MODE_AUTO;
328                case ACTION:
329                    return Camera.Parameters.SCENE_MODE_ACTION;
330                case BARCODE:
331                    return Camera.Parameters.SCENE_MODE_BARCODE;
332                case BEACH:
333                    return Camera.Parameters.SCENE_MODE_BEACH;
334                case CANDLELIGHT:
335                    return Camera.Parameters.SCENE_MODE_CANDLELIGHT;
336                case FIREWORKS:
337                    return Camera.Parameters.SCENE_MODE_FIREWORKS;
338                case HDR:
339                    return Camera.Parameters.SCENE_MODE_HDR;
340                case LANDSCAPE:
341                    return Camera.Parameters.SCENE_MODE_LANDSCAPE;
342                case NIGHT:
343                    return Camera.Parameters.SCENE_MODE_NIGHT;
344                case NIGHT_PORTRAIT:
345                    return Camera.Parameters.SCENE_MODE_NIGHT_PORTRAIT;
346                case PARTY:
347                    return Camera.Parameters.SCENE_MODE_PARTY;
348                case PORTRAIT:
349                    return Camera.Parameters.SCENE_MODE_PORTRAIT;
350                case SNOW:
351                    return Camera.Parameters.SCENE_MODE_SNOW;
352                case SPORTS:
353                    return Camera.Parameters.SCENE_MODE_SPORTS;
354                case STEADYPHOTO:
355                    return Camera.Parameters.SCENE_MODE_STEADYPHOTO;
356                case SUNSET:
357                    return Camera.Parameters.SCENE_MODE_SUNSET;
358                case THEATRE:
359                    return Camera.Parameters.SCENE_MODE_THEATRE;
360            }
361            return null;
362        }
363
364        @Override
365        public SceneMode sceneModeFromString(String val) {
366            if (val.equals(Camera.Parameters.SCENE_MODE_AUTO)) {
367                return SceneMode.AUTO;
368            } else if (val.equals(Camera.Parameters.SCENE_MODE_ACTION)) {
369                return SceneMode.ACTION;
370            } else if (val.equals(Camera.Parameters.SCENE_MODE_BARCODE)) {
371                return SceneMode.BARCODE;
372            } else if (val.equals(Camera.Parameters.SCENE_MODE_BEACH)) {
373                return SceneMode.BEACH;
374            } else if (val.equals(Camera.Parameters.SCENE_MODE_CANDLELIGHT)) {
375                return SceneMode.CANDLELIGHT;
376            } else if (val.equals(Camera.Parameters.SCENE_MODE_FIREWORKS)) {
377                return SceneMode.FIREWORKS;
378            } else if (val.equals(Camera.Parameters.SCENE_MODE_HDR)) {
379                return SceneMode.HDR;
380            } else if (val.equals(Camera.Parameters.SCENE_MODE_LANDSCAPE)) {
381                return SceneMode.LANDSCAPE;
382            } else if (val.equals(Camera.Parameters.SCENE_MODE_NIGHT)) {
383                return SceneMode.NIGHT;
384            } else if (val.equals(Camera.Parameters.SCENE_MODE_NIGHT_PORTRAIT)) {
385                return SceneMode.NIGHT_PORTRAIT;
386            } else if (val.equals(Camera.Parameters.SCENE_MODE_PARTY)) {
387                return SceneMode.PARTY;
388            } else if (val.equals(Camera.Parameters.SCENE_MODE_PORTRAIT)) {
389                return SceneMode.PORTRAIT;
390            } else if (val.equals(Camera.Parameters.SCENE_MODE_SNOW)) {
391                return SceneMode.SNOW;
392            } else if (val.equals(Camera.Parameters.SCENE_MODE_SPORTS)) {
393                return SceneMode.SPORTS;
394            } else if (val.equals(Camera.Parameters.SCENE_MODE_STEADYPHOTO)) {
395                return SceneMode.STEADYPHOTO;
396            } else if (val.equals(Camera.Parameters.SCENE_MODE_SUNSET)) {
397                return SceneMode.SUNSET;
398            } else if (val.equals(Camera.Parameters.SCENE_MODE_THEATRE)) {
399                return SceneMode.THEATRE;
400            } else {
401                return null;
402            }
403        }
404
405        @Override
406        public String stringify(WhiteBalance wb) {
407            switch (wb) {
408                case AUTO:
409                    return Camera.Parameters.WHITE_BALANCE_AUTO;
410                case CLOUDY_DAYLIGHT:
411                    return Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT;
412                case DAYLIGHT:
413                    return Camera.Parameters.WHITE_BALANCE_DAYLIGHT;
414                case FLUORESCENT:
415                    return Camera.Parameters.WHITE_BALANCE_FLUORESCENT;
416                case INCANDESCENT:
417                    return Camera.Parameters.WHITE_BALANCE_INCANDESCENT;
418                case SHADE:
419                    return Camera.Parameters.WHITE_BALANCE_SHADE;
420                case TWILIGHT:
421                    return Camera.Parameters.WHITE_BALANCE_TWILIGHT;
422                case WARM_FLUORESCENT:
423                    return Camera.Parameters.WHITE_BALANCE_WARM_FLUORESCENT;
424            }
425            return null;
426        }
427
428        @Override
429        public WhiteBalance whiteBalanceFromString(String val) {
430            if (val.equals(Camera.Parameters.WHITE_BALANCE_AUTO)) {
431                return WhiteBalance.AUTO;
432            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_CLOUDY_DAYLIGHT)) {
433                return WhiteBalance.CLOUDY_DAYLIGHT;
434            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_DAYLIGHT)) {
435                return WhiteBalance.DAYLIGHT;
436            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_FLUORESCENT)) {
437                return WhiteBalance.FLUORESCENT;
438            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_INCANDESCENT)) {
439                return WhiteBalance.INCANDESCENT;
440            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_SHADE)) {
441                return WhiteBalance.SHADE;
442            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_TWILIGHT)) {
443                return WhiteBalance.TWILIGHT;
444            } else if (val.equals(Camera.Parameters.WHITE_BALANCE_WARM_FLUORESCENT)) {
445                return WhiteBalance.WARM_FLUORESCENT;
446            } else {
447                return null;
448            }
449        }
450    }
451}
452