Home | History | Annotate | Download | only in camera
      1 /*
      2 **
      3 ** Copyright 2008, The Android Open Source Project
      4 **
      5 ** Licensed under the Apache License, Version 2.0 (the "License");
      6 ** you may not use this file except in compliance with the License.
      7 ** You may obtain a copy of the License at
      8 **
      9 **     http://www.apache.org/licenses/LICENSE-2.0
     10 **
     11 ** Unless required by applicable law or agreed to in writing, software
     12 ** distributed under the License is distributed on an "AS IS" BASIS,
     13 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     14 ** See the License for the specific language governing permissions and
     15 ** limitations under the License.
     16 */
     17 
     18 #define LOG_TAG "CameraParams2"
     19 // #define LOG_NDEBUG 0
     20 #include <utils/Log.h>
     21 
     22 #include <string.h>
     23 #include <stdlib.h>
     24 #include <camera/CameraParameters2.h>
     25 
     26 namespace android {
     27 
     28 CameraParameters2::CameraParameters2()
     29                 : mMap()
     30 {
     31 }
     32 
     33 CameraParameters2::~CameraParameters2()
     34 {
     35 }
     36 
     37 String8 CameraParameters2::flatten() const
     38 {
     39     String8 flattened("");
     40     size_t size = mMap.size();
     41 
     42     for (size_t i = 0; i < size; i++) {
     43         String8 k, v;
     44         k = mMap.keyAt(i);
     45         v = mMap.valueAt(i);
     46 
     47         flattened += k;
     48         flattened += "=";
     49         flattened += v;
     50         if (i != size-1)
     51             flattened += ";";
     52     }
     53 
     54     ALOGV("%s: Flattened params = %s", __FUNCTION__, flattened.string());
     55 
     56     return flattened;
     57 }
     58 
     59 void CameraParameters2::unflatten(const String8 &params)
     60 {
     61     const char *a = params.string();
     62     const char *b;
     63 
     64     mMap.clear();
     65 
     66     for (;;) {
     67         // Find the bounds of the key name.
     68         b = strchr(a, '=');
     69         if (b == 0)
     70             break;
     71 
     72         // Create the key string.
     73         String8 k(a, (size_t)(b-a));
     74 
     75         // Find the value.
     76         a = b+1;
     77         b = strchr(a, ';');
     78         if (b == 0) {
     79             // If there's no semicolon, this is the last item.
     80             String8 v(a);
     81             mMap.add(k, v);
     82             break;
     83         }
     84 
     85         String8 v(a, (size_t)(b-a));
     86         mMap.add(k, v);
     87         a = b+1;
     88     }
     89 }
     90 
     91 
     92 void CameraParameters2::set(const char *key, const char *value)
     93 {
     94     // XXX i think i can do this with strspn()
     95     if (strchr(key, '=') || strchr(key, ';')) {
     96         //XXX ALOGE("Key \"%s\"contains invalid character (= or ;)", key);
     97         return;
     98     }
     99 
    100     if (strchr(value, '=') || strchr(value, ';')) {
    101         //XXX ALOGE("Value \"%s\"contains invalid character (= or ;)", value);
    102         return;
    103     }
    104 
    105     // Replacing a value updates the key's order to be the new largest order
    106     ssize_t res = mMap.replaceValueFor(String8(key), String8(value));
    107     LOG_ALWAYS_FATAL_IF(res < 0, "replaceValueFor(%s,%s) failed", key, value);
    108 }
    109 
    110 void CameraParameters2::set(const char *key, int value)
    111 {
    112     char str[16];
    113     sprintf(str, "%d", value);
    114     set(key, str);
    115 }
    116 
    117 void CameraParameters2::setFloat(const char *key, float value)
    118 {
    119     char str[16];  // 14 should be enough. We overestimate to be safe.
    120     snprintf(str, sizeof(str), "%g", value);
    121     set(key, str);
    122 }
    123 
    124 const char *CameraParameters2::get(const char *key) const
    125 {
    126     ssize_t idx = mMap.indexOfKey(String8(key));
    127     if (idx < 0) {
    128         return NULL;
    129     } else {
    130         return mMap.valueAt(idx).string();
    131     }
    132 }
    133 
    134 int CameraParameters2::getInt(const char *key) const
    135 {
    136     const char *v = get(key);
    137     if (v == 0)
    138         return -1;
    139     return strtol(v, 0, 0);
    140 }
    141 
    142 float CameraParameters2::getFloat(const char *key) const
    143 {
    144     const char *v = get(key);
    145     if (v == 0) return -1;
    146     return strtof(v, 0);
    147 }
    148 
    149 status_t CameraParameters2::compareSetOrder(const char *key1, const char *key2,
    150         int *order) const {
    151     if (key1 == NULL) {
    152         ALOGE("%s: key1 must not be NULL", __FUNCTION__);
    153         return BAD_VALUE;
    154     } else if (key2 == NULL) {
    155         ALOGE("%s: key2 must not be NULL", __FUNCTION__);
    156         return BAD_VALUE;
    157     } else if (order == NULL) {
    158         ALOGE("%s: order must not be NULL", __FUNCTION__);
    159         return BAD_VALUE;
    160     }
    161 
    162     ssize_t index1 = mMap.indexOfKey(String8(key1));
    163     ssize_t index2 = mMap.indexOfKey(String8(key2));
    164     if (index1 < 0) {
    165         ALOGW("%s: Key1 (%s) was not set", __FUNCTION__, key1);
    166         return NAME_NOT_FOUND;
    167     } else if (index2 < 0) {
    168         ALOGW("%s: Key2 (%s) was not set", __FUNCTION__, key2);
    169         return NAME_NOT_FOUND;
    170     }
    171 
    172     *order = (index1 == index2) ? 0  :
    173              (index1 < index2)  ? -1 :
    174              1;
    175 
    176     return OK;
    177 }
    178 
    179 void CameraParameters2::remove(const char *key)
    180 {
    181     mMap.removeItem(String8(key));
    182 }
    183 
    184 // Parse string like "640x480" or "10000,20000"
    185 static int parse_pair(const char *str, int *first, int *second, char delim,
    186                       char **endptr = NULL)
    187 {
    188     // Find the first integer.
    189     char *end;
    190     int w = (int)strtol(str, &end, 10);
    191     // If a delimeter does not immediately follow, give up.
    192     if (*end != delim) {
    193         ALOGE("Cannot find delimeter (%c) in str=%s", delim, str);
    194         return -1;
    195     }
    196 
    197     // Find the second integer, immediately after the delimeter.
    198     int h = (int)strtol(end+1, &end, 10);
    199 
    200     *first = w;
    201     *second = h;
    202 
    203     if (endptr) {
    204         *endptr = end;
    205     }
    206 
    207     return 0;
    208 }
    209 
    210 static void parseSizesList(const char *sizesStr, Vector<Size> &sizes)
    211 {
    212     if (sizesStr == 0) {
    213         return;
    214     }
    215 
    216     char *sizeStartPtr = (char *)sizesStr;
    217 
    218     while (true) {
    219         int width, height;
    220         int success = parse_pair(sizeStartPtr, &width, &height, 'x',
    221                                  &sizeStartPtr);
    222         if (success == -1 || (*sizeStartPtr != ',' && *sizeStartPtr != '\0')) {
    223             ALOGE("Picture sizes string \"%s\" contains invalid character.", sizesStr);
    224             return;
    225         }
    226         sizes.push(Size(width, height));
    227 
    228         if (*sizeStartPtr == '\0') {
    229             return;
    230         }
    231         sizeStartPtr++;
    232     }
    233 }
    234 
    235 void CameraParameters2::setPreviewSize(int width, int height)
    236 {
    237     char str[32];
    238     sprintf(str, "%dx%d", width, height);
    239     set(CameraParameters::KEY_PREVIEW_SIZE, str);
    240 }
    241 
    242 void CameraParameters2::getPreviewSize(int *width, int *height) const
    243 {
    244     *width = *height = -1;
    245     // Get the current string, if it doesn't exist, leave the -1x-1
    246     const char *p = get(CameraParameters::KEY_PREVIEW_SIZE);
    247     if (p == 0)  return;
    248     parse_pair(p, width, height, 'x');
    249 }
    250 
    251 void CameraParameters2::getPreferredPreviewSizeForVideo(int *width, int *height) const
    252 {
    253     *width = *height = -1;
    254     const char *p = get(CameraParameters::KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO);
    255     if (p == 0)  return;
    256     parse_pair(p, width, height, 'x');
    257 }
    258 
    259 void CameraParameters2::getSupportedPreviewSizes(Vector<Size> &sizes) const
    260 {
    261     const char *previewSizesStr = get(CameraParameters::KEY_SUPPORTED_PREVIEW_SIZES);
    262     parseSizesList(previewSizesStr, sizes);
    263 }
    264 
    265 void CameraParameters2::setVideoSize(int width, int height)
    266 {
    267     char str[32];
    268     sprintf(str, "%dx%d", width, height);
    269     set(CameraParameters::KEY_VIDEO_SIZE, str);
    270 }
    271 
    272 void CameraParameters2::getVideoSize(int *width, int *height) const
    273 {
    274     *width = *height = -1;
    275     const char *p = get(CameraParameters::KEY_VIDEO_SIZE);
    276     if (p == 0) return;
    277     parse_pair(p, width, height, 'x');
    278 }
    279 
    280 void CameraParameters2::getSupportedVideoSizes(Vector<Size> &sizes) const
    281 {
    282     const char *videoSizesStr = get(CameraParameters::KEY_SUPPORTED_VIDEO_SIZES);
    283     parseSizesList(videoSizesStr, sizes);
    284 }
    285 
    286 void CameraParameters2::setPreviewFrameRate(int fps)
    287 {
    288     set(CameraParameters::KEY_PREVIEW_FRAME_RATE, fps);
    289 }
    290 
    291 int CameraParameters2::getPreviewFrameRate() const
    292 {
    293     return getInt(CameraParameters::KEY_PREVIEW_FRAME_RATE);
    294 }
    295 
    296 void CameraParameters2::getPreviewFpsRange(int *min_fps, int *max_fps) const
    297 {
    298     *min_fps = *max_fps = -1;
    299     const char *p = get(CameraParameters::KEY_PREVIEW_FPS_RANGE);
    300     if (p == 0) return;
    301     parse_pair(p, min_fps, max_fps, ',');
    302 }
    303 
    304 void CameraParameters2::setPreviewFpsRange(int min_fps, int max_fps)
    305 {
    306     String8 str = String8::format("%d,%d", min_fps, max_fps);
    307     set(CameraParameters::KEY_PREVIEW_FPS_RANGE, str.string());
    308 }
    309 
    310 void CameraParameters2::setPreviewFormat(const char *format)
    311 {
    312     set(CameraParameters::KEY_PREVIEW_FORMAT, format);
    313 }
    314 
    315 const char *CameraParameters2::getPreviewFormat() const
    316 {
    317     return get(CameraParameters::KEY_PREVIEW_FORMAT);
    318 }
    319 
    320 void CameraParameters2::setPictureSize(int width, int height)
    321 {
    322     char str[32];
    323     sprintf(str, "%dx%d", width, height);
    324     set(CameraParameters::KEY_PICTURE_SIZE, str);
    325 }
    326 
    327 void CameraParameters2::getPictureSize(int *width, int *height) const
    328 {
    329     *width = *height = -1;
    330     // Get the current string, if it doesn't exist, leave the -1x-1
    331     const char *p = get(CameraParameters::KEY_PICTURE_SIZE);
    332     if (p == 0) return;
    333     parse_pair(p, width, height, 'x');
    334 }
    335 
    336 void CameraParameters2::getSupportedPictureSizes(Vector<Size> &sizes) const
    337 {
    338     const char *pictureSizesStr = get(CameraParameters::KEY_SUPPORTED_PICTURE_SIZES);
    339     parseSizesList(pictureSizesStr, sizes);
    340 }
    341 
    342 void CameraParameters2::setPictureFormat(const char *format)
    343 {
    344     set(CameraParameters::KEY_PICTURE_FORMAT, format);
    345 }
    346 
    347 const char *CameraParameters2::getPictureFormat() const
    348 {
    349     return get(CameraParameters::KEY_PICTURE_FORMAT);
    350 }
    351 
    352 void CameraParameters2::dump() const
    353 {
    354     ALOGD("dump: mMap.size = %zu", mMap.size());
    355     for (size_t i = 0; i < mMap.size(); i++) {
    356         String8 k, v;
    357         k = mMap.keyAt(i);
    358         v = mMap.valueAt(i);
    359         ALOGD("%s: %s\n", k.string(), v.string());
    360     }
    361 }
    362 
    363 status_t CameraParameters2::dump(int fd, const Vector<String16>& args) const
    364 {
    365     (void)args;
    366     const size_t SIZE = 256;
    367     char buffer[SIZE];
    368     String8 result;
    369     snprintf(buffer, 255, "CameraParameters2::dump: mMap.size = %zu\n", mMap.size());
    370     result.append(buffer);
    371     for (size_t i = 0; i < mMap.size(); i++) {
    372         String8 k, v;
    373         k = mMap.keyAt(i);
    374         v = mMap.valueAt(i);
    375         snprintf(buffer, 255, "\t%s: %s\n", k.string(), v.string());
    376         result.append(buffer);
    377     }
    378     write(fd, result.string(), result.size());
    379     return NO_ERROR;
    380 }
    381 
    382 }; // namespace android
    383