dom/camera/DOMCameraCapabilities.cpp

   1 /* This Source Code Form is subject to the terms of the Mozilla Public
   2  * License, v. 2.0. If a copy of the MPL was not distributed with this file,
   3  * You can obtain one at http://mozilla.org/MPL/2.0/. */
   4
   5 #include <cstring>
   6 #include <cstdlib>
   7 #include "base/basictypes.h"
   8 #include "nsDOMClassInfo.h"
   9 #include "jsapi.h"
  10 #include "DOMCameraControl.h"
  11 #include "DOMCameraCapabilities.h"
  12 #include "CameraCommon.h"
  13
  14 using namespace mozilla;
  15
  16 DOMCI_DATA(CameraCapabilities, nsICameraCapabilities)
  17
  18 NS_IMPL_CYCLE_COLLECTION_0(DOMCameraCapabilities)
  19
  20 NS_INTERFACE_MAP_BEGIN_CYCLE_COLLECTION(DOMCameraCapabilities)
  21   NS_INTERFACE_MAP_ENTRY(nsISupports)
  22   NS_INTERFACE_MAP_ENTRY(nsICameraCapabilities)
  23   NS_DOM_INTERFACE_MAP_ENTRY_CLASSINFO(CameraCapabilities)
  24 NS_INTERFACE_MAP_END
  25
  26 NS_IMPL_CYCLE_COLLECTING_ADDREF(DOMCameraCapabilities)
  27 NS_IMPL_CYCLE_COLLECTING_RELEASE(DOMCameraCapabilities)
  28
  29 static nsresult
  30 ParseZoomRatioItemAndAdd(JSContext* aCx, JSObject* aArray, uint32_t aIndex, const char* aStart, char** aEnd)
  31 {
  32   if (!*aEnd) {
  33     // make 'aEnd' follow the same semantics as strchr().
  34     aEnd = nullptr;
  35   }
  36
  37   /**
  38    * The by-100 divisor is Gonk-specific.  For now, assume other platforms
  39    * return actual fractoinal multipliers.
  40    */
  41   double d = strtod(aStart, aEnd);
  42 #if MOZ_WIDGET_GONK
  43   d /= 100;
  44 #endif
  45
  46   jsval v = JS_NumberValue(d);
  47
  48   if (!JS_SetElement(aCx, aArray, aIndex, &v)) {
  49     return NS_ERROR_FAILURE;
  50   }
  51
  52   return NS_OK;
  53 }
  54
  55 static nsresult
  56 ParseStringItemAndAdd(JSContext* aCx, JSObject* aArray, uint32_t aIndex, const char* aStart, char** aEnd)
  57 {
  58   JSString* s;
  59
  60   if (*aEnd) {
  61     s = JS_NewStringCopyN(aCx, aStart, *aEnd - aStart);
  62   } else {
  63     s = JS_NewStringCopyZ(aCx, aStart);
  64   }
  65   if (!s) {
  66     return NS_ERROR_OUT_OF_MEMORY;
  67   }
  68
  69   jsval v = STRING_TO_JSVAL(s);
  70   if (!JS_SetElement(aCx, aArray, aIndex, &v)) {
  71     return NS_ERROR_FAILURE;
  72   }
  73
  74   return NS_OK;
  75 }
  76
  77 static nsresult
  78 ParseDimensionItemAndAdd(JSContext* aCx, JSObject* aArray, uint32_t aIndex, const char* aStart, char** aEnd)
  79 {
  80   char* x;
  81
  82   if (!*aEnd) {
  83     // make 'aEnd' follow the same semantics as strchr().
  84     aEnd = nullptr;
  85   }
  86
  87   jsval w = INT_TO_JSVAL(strtol(aStart, &x, 10));
  88   jsval h = INT_TO_JSVAL(strtol(x + 1, aEnd, 10));
  89
  90   JSObject* o = JS_NewObject(aCx, nullptr, nullptr, nullptr);
  91   if (!o) {
  92     return NS_ERROR_OUT_OF_MEMORY;
  93   }
  94
  95   if (!JS_SetProperty(aCx, o, "width", &w)) {
  96     return NS_ERROR_FAILURE;
  97   }
  98   if (!JS_SetProperty(aCx, o, "height", &h)) {
  99     return NS_ERROR_FAILURE;
 100   }
 101
 102   jsval v = OBJECT_TO_JSVAL(o);
 103   if (!JS_SetElement(aCx, aArray, aIndex, &v)) {
 104     return NS_ERROR_FAILURE;
 105   }
 106
 107   return NS_OK;
 108 }
 109
 110 nsresult
 111 DOMCameraCapabilities::ParameterListToNewArray(JSContext* aCx, JSObject** aArray, uint32_t aKey, ParseItemAndAddFunc aParseItemAndAdd)
 112 {
 113   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 114
 115   const char* value = mCamera->GetParameterConstChar(aKey);
 116   if (!value) {
 117     // in case we get nonsense data back
 118     *aArray = nullptr;
 119     return NS_OK;
 120   }
 121
 122   *aArray = JS_NewArrayObject(aCx, 0, nullptr);
 123   if (!*aArray) {
 124     return NS_ERROR_OUT_OF_MEMORY;
 125   }
 126
 127   const char* p = value;
 128   uint32_t index = 0;
 129   nsresult rv;
 130   char* q;
 131
 132   while (p) {
 133     /**
 134      * In C's string.h, strchr() is declared as returning 'char*'; in C++'s
 135      * cstring, it is declared as returning 'const char*', _except_ in MSVC,
 136      * where the C version is declared to return const like the C++ version.
 137      *
 138      * Unfortunately, for both cases, strtod() and strtol() take a 'char**' as
 139      * the end-of-conversion pointer, so we need to cast away strchr()'s
 140      * const-ness here to make the MSVC build everything happy.
 141      */
 142     q = const_cast<char*>(strchr(p, ','));
 143     if (q != p) { // skip consecutive delimiters, just in case
 144       rv = aParseItemAndAdd(aCx, *aArray, index, p, &q);
 145       NS_ENSURE_SUCCESS(rv, rv);
 146       ++index;
 147     }
 148     p = q;
 149     if (p) {
 150       ++p;
 151     }
 152   }
 153
 154   return JS_FreezeObject(aCx, *aArray) ? NS_OK : NS_ERROR_FAILURE;
 155 }
 156
 157 nsresult
 158 DOMCameraCapabilities::StringListToNewObject(JSContext* aCx, JS::Value* aArray, uint32_t aKey)
 159 {
 160   JSObject* array;
 161
 162   nsresult rv = ParameterListToNewArray(aCx, &array, aKey, ParseStringItemAndAdd);
 163   NS_ENSURE_SUCCESS(rv, rv);
 164
 165   *aArray = OBJECT_TO_JSVAL(array);
 166   return NS_OK;
 167 }
 168
 169 nsresult
 170 DOMCameraCapabilities::DimensionListToNewObject(JSContext* aCx, JS::Value* aArray, uint32_t aKey)
 171 {
 172   JSObject* array;
 173   nsresult rv;
 174
 175   rv = ParameterListToNewArray(aCx, &array, aKey, ParseDimensionItemAndAdd);
 176   NS_ENSURE_SUCCESS(rv, rv);
 177
 178   *aArray = OBJECT_TO_JSVAL(array);
 179   return NS_OK;
 180 }
 181
 182 /* readonly attribute jsval previewSizes; */
 183 NS_IMETHODIMP
 184 DOMCameraCapabilities::GetPreviewSizes(JSContext* cx, JS::Value* aPreviewSizes)
 185 {
 186   return DimensionListToNewObject(cx, aPreviewSizes, CAMERA_PARAM_SUPPORTED_PREVIEWSIZES);
 187 }
 188
 189 /* readonly attribute jsval pictureSizes; */
 190 NS_IMETHODIMP
 191 DOMCameraCapabilities::GetPictureSizes(JSContext* cx, JS::Value* aPictureSizes)
 192 {
 193   return DimensionListToNewObject(cx, aPictureSizes, CAMERA_PARAM_SUPPORTED_PICTURESIZES);
 194 }
 195
 196 /* readonly attribute jsval fileFormats; */
 197 NS_IMETHODIMP
 198 DOMCameraCapabilities::GetFileFormats(JSContext* cx, JS::Value* aFileFormats)
 199 {
 200   return StringListToNewObject(cx, aFileFormats, CAMERA_PARAM_SUPPORTED_PICTUREFORMATS);
 201 }
 202
 203 /* readonly attribute jsval whiteBalanceModes; */
 204 NS_IMETHODIMP
 205 DOMCameraCapabilities::GetWhiteBalanceModes(JSContext* cx, JS::Value* aWhiteBalanceModes)
 206 {
 207   return StringListToNewObject(cx, aWhiteBalanceModes, CAMERA_PARAM_SUPPORTED_WHITEBALANCES);
 208 }
 209
 210 /* readonly attribute jsval sceneModes; */
 211 NS_IMETHODIMP
 212 DOMCameraCapabilities::GetSceneModes(JSContext* cx, JS::Value* aSceneModes)
 213 {
 214   return StringListToNewObject(cx, aSceneModes, CAMERA_PARAM_SUPPORTED_SCENEMODES);
 215 }
 216
 217 /* readonly attribute jsval effects; */
 218 NS_IMETHODIMP
 219 DOMCameraCapabilities::GetEffects(JSContext* cx, JS::Value* aEffects)
 220 {
 221   return StringListToNewObject(cx, aEffects, CAMERA_PARAM_SUPPORTED_EFFECTS);
 222 }
 223
 224 /* readonly attribute jsval flashModes; */
 225 NS_IMETHODIMP
 226 DOMCameraCapabilities::GetFlashModes(JSContext* cx, JS::Value* aFlashModes)
 227 {
 228   return StringListToNewObject(cx, aFlashModes, CAMERA_PARAM_SUPPORTED_FLASHMODES);
 229 }
 230
 231 /* readonly attribute jsval focusModes; */
 232 NS_IMETHODIMP
 233 DOMCameraCapabilities::GetFocusModes(JSContext* cx, JS::Value* aFocusModes)
 234 {
 235   return StringListToNewObject(cx, aFocusModes, CAMERA_PARAM_SUPPORTED_FOCUSMODES);
 236 }
 237
 238 /* readonly attribute long maxFocusAreas; */
 239 NS_IMETHODIMP
 240 DOMCameraCapabilities::GetMaxFocusAreas(JSContext* cx, int32_t* aMaxFocusAreas)
 241 {
 242   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 243
 244   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_MAXFOCUSAREAS);
 245   if (!value) {
 246     // in case we get nonsense data back
 247     *aMaxFocusAreas = 0;
 248     return NS_OK;
 249   }
 250
 251   *aMaxFocusAreas = atoi(value);
 252   return NS_OK;
 253 }
 254
 255 /* readonly attribute double minExposureCompensation; */
 256 NS_IMETHODIMP
 257 DOMCameraCapabilities::GetMinExposureCompensation(JSContext* cx, double* aMinExposureCompensation)
 258 {
 259   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 260
 261   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_MINEXPOSURECOMPENSATION);
 262   if (!value) {
 263     // in case we get nonsense data back
 264     *aMinExposureCompensation = 0;
 265     return NS_OK;
 266   }
 267
 268   *aMinExposureCompensation = atof(value);
 269   return NS_OK;
 270 }
 271
 272 /* readonly attribute double maxExposureCompensation; */
 273 NS_IMETHODIMP
 274 DOMCameraCapabilities::GetMaxExposureCompensation(JSContext* cx, double* aMaxExposureCompensation)
 275 {
 276   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 277
 278   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_MAXEXPOSURECOMPENSATION);
 279   if (!value) {
 280     // in case we get nonsense data back
 281     *aMaxExposureCompensation = 0;
 282     return NS_OK;
 283   }
 284
 285   *aMaxExposureCompensation = atof(value);
 286   return NS_OK;
 287 }
 288
 289 /* readonly attribute double stepExposureCompensation; */
 290 NS_IMETHODIMP
 291 DOMCameraCapabilities::GetStepExposureCompensation(JSContext* cx, double* aStepExposureCompensation)
 292 {
 293   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 294
 295   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_EXPOSURECOMPENSATIONSTEP);
 296   if (!value) {
 297     // in case we get nonsense data back
 298     *aStepExposureCompensation = 0;
 299     return NS_OK;
 300   }
 301
 302   *aStepExposureCompensation = atof(value);
 303   return NS_OK;
 304 }
 305
 306 /* readonly attribute long maxMeteringAreas; */
 307 NS_IMETHODIMP
 308 DOMCameraCapabilities::GetMaxMeteringAreas(JSContext* cx, int32_t* aMaxMeteringAreas)
 309 {
 310   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 311
 312   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_MAXMETERINGAREAS);
 313   if (!value) {
 314     // in case we get nonsense data back
 315     *aMaxMeteringAreas = 0;
 316     return NS_OK;
 317   }
 318
 319   *aMaxMeteringAreas = atoi(value);
 320   return NS_OK;
 321 }
 322
 323 /* readonly attribute jsval zoomRatios; */
 324 NS_IMETHODIMP
 325 DOMCameraCapabilities::GetZoomRatios(JSContext* cx, JS::Value* aZoomRatios)
 326 {
 327   NS_ENSURE_TRUE(mCamera, NS_ERROR_NOT_AVAILABLE);
 328
 329   const char* value = mCamera->GetParameterConstChar(CAMERA_PARAM_SUPPORTED_ZOOM);
 330   if (!value || strcmp(value, "true") != 0) {
 331     // if zoom is not supported, return a null object
 332     *aZoomRatios = JSVAL_NULL;
 333     return NS_OK;
 334   }
 335
 336   JSObject* array;
 337
 338   nsresult rv = ParameterListToNewArray(cx, &array, CAMERA_PARAM_SUPPORTED_ZOOMRATIOS, ParseZoomRatioItemAndAdd);
 339   NS_ENSURE_SUCCESS(rv, rv);
 340
 341   *aZoomRatios = OBJECT_TO_JSVAL(array);
 342   return NS_OK;
 343 }
 344
 345 /* readonly attribute jsval videoSizes; */
 346 NS_IMETHODIMP
 347 DOMCameraCapabilities::GetVideoSizes(JSContext* cx, JS::Value* aVideoSizes)
 348 {
 349   return DimensionListToNewObject(cx, aVideoSizes, CAMERA_PARAM_SUPPORTED_VIDEOSIZES);
 350 }