dom/camera/FallbackCameraPlatform.h
author Mike Hommey <mh+mozilla@glandium.org>
Sat, 23 Jan 2016 11:40:24 -0800
changeset 281396 1378b39a9085890ce142e6933ebd50b6537f4ec5
parent 268184 e8c7dfe727cd970e2c3294934e2927b14143c205
permissions -rw-r--r--
Bug 1242074 - Avoid going back and forth between FasterMake and RecursiveMake; r=gps FasterMake needs some RecursiveMake install manifests to have been processed before doing its work, so we can actually end up processing them twice because of the going back and forth from FasterMake in the hybrid build system. Set the dependency at the RecursiveMake level when doing an hybrid build.

/*
 * Copyright (C) 2008 The Android Open Source Project
 * Copyright (C) 2015 Mozilla Foundation
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

#ifndef DOM_CAMERA_FALLBACKCAMERAPLATFORM_H
#define DOM_CAMERA_FALLBACKCAMERAPLATFORM_H

#include <inttypes.h>
#include <string.h>

typedef struct {
  int32_t id;
  int32_t score;
  int32_t rect[4];
  int32_t left_eye[2];
  int32_t right_eye[2];
  int32_t mouth[2];
} camera_face_t;

typedef struct {
  uint32_t number_of_faces;
  camera_face_t* faces;
} camera_frame_metadata_t;

namespace android {
  enum camcorder_quality {
    CAMCORDER_QUALITY_LOW,
    CAMCORDER_QUALITY_HIGH,
    CAMCORDER_QUALITY_QCIF,
    CAMCORDER_QUALITY_CIF,
    CAMCORDER_QUALITY_480P,
    CAMCORDER_QUALITY_720P,
    CAMCORDER_QUALITY_1080P,
    CAMCORDER_QUALITY_QVGA,
    CAMCORDER_QUALITY_VGA,
    CAMCORDER_QUALITY_LIST_START = CAMCORDER_QUALITY_LOW,
    CAMCORDER_QUALITY_LIST_END = CAMCORDER_QUALITY_VGA
  };

  enum output_format {
    OUTPUT_FORMAT_THREE_GPP,
    OUTPUT_FORMAT_MPEG_4
  };

  enum video_encoder {
    VIDEO_ENCODER_H263,
    VIDEO_ENCODER_H264,
    VIDEO_ENCODER_MPEG_4_SP
  };

  enum audio_encoder {
    AUDIO_ENCODER_AMR_WB,
    AUDIO_ENCODER_AMR_NB,
    AUDIO_ENCODER_AAC
  };

  template <class T>
  class sp final
  {
  public:
    sp()
      : mPtr(nullptr)
    { }

    sp(T *aPtr)
      : mPtr(aPtr)
    { }

    virtual ~sp()         { }
    T* get() const        { return mPtr; }
    void clear()          { mPtr = nullptr; }
    T* operator->() const { return get(); }

  private:
    RefPtr<T> mPtr;
  };

  typedef uint64_t nsecs_t;

  enum error_t {
    OK = 0,
    UNKNOWN_ERROR,
    INVALID_OPERATION
  };

  enum camera_msg_t {
    CAMERA_MSG_SHUTTER,
    CAMERA_MSG_COMPRESSED_IMAGE
  };

  class String8 final
  {
  public:
    String8()                  { }
    String8(const char* aData) { mData.AssignASCII(aData); }
    virtual ~String8()         { }
    const char* string() const { return mData.Data(); }

  private:
    nsCString mData;
  };

  enum camera_facing_t {
    CAMERA_FACING_BACK,
    CAMERA_FACING_FRONT
  };

  struct CameraInfo {
    camera_facing_t facing;
  };

  class Camera final : public nsISupports
  {
  public:
    NS_DECL_ISUPPORTS;

    void disconnect()                         { }
    String8 getParameters()                   { return String8(); }
    int setParameters(const String8& aParams) { return UNKNOWN_ERROR; }
    int storeMetaDataInBuffers(bool aEnabled) { return UNKNOWN_ERROR; }
    int autoFocus()                           { return UNKNOWN_ERROR; }
    int cancelAutoFocus()                     { return UNKNOWN_ERROR; }
    int takePicture(uint32_t flags)           { return UNKNOWN_ERROR; }
    int startPreview()                        { return UNKNOWN_ERROR; }
    int stopPreview()                         { return UNKNOWN_ERROR; }
    int startRecording()                      { return UNKNOWN_ERROR; }
    int stopRecording()                       { return UNKNOWN_ERROR; }
    int startFaceDetection()                  { return UNKNOWN_ERROR; }
    int stopFaceDetection()                   { return UNKNOWN_ERROR; }
    static int32_t getNumberOfCameras()       { return 2; }

    static int getCameraInfo(int32_t aDevice, CameraInfo* aInfo)
    {
      switch (aDevice) {
        case 0:
          aInfo->facing = CAMERA_FACING_BACK;
          break;
        case 1:
          aInfo->facing = CAMERA_FACING_FRONT;
          break;
        default:
          return UNKNOWN_ERROR;
      }
      return OK;
    }

  protected:
    Camera()          { }
    virtual ~Camera() { }

  private:
    Camera(const Camera&) = delete;
    Camera& operator=(const Camera&) = delete;
  };

  class CameraParameters final
  {
  public:
    static const char KEY_PREVIEW_SIZE[];
    static const char KEY_SUPPORTED_PREVIEW_SIZES[];
    static const char KEY_PREVIEW_FPS_RANGE[];
    static const char KEY_SUPPORTED_PREVIEW_FPS_RANGE[];
    static const char KEY_PREVIEW_FORMAT[];
    static const char KEY_SUPPORTED_PREVIEW_FORMATS[];
    static const char KEY_PREVIEW_FRAME_RATE[];
    static const char KEY_SUPPORTED_PREVIEW_FRAME_RATES[];
    static const char KEY_PICTURE_SIZE[];
    static const char KEY_SUPPORTED_PICTURE_SIZES[];
    static const char KEY_PICTURE_FORMAT[];
    static const char KEY_SUPPORTED_PICTURE_FORMATS[];
    static const char KEY_JPEG_THUMBNAIL_WIDTH[];
    static const char KEY_JPEG_THUMBNAIL_HEIGHT[];
    static const char KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES[];
    static const char KEY_JPEG_THUMBNAIL_QUALITY[];
    static const char KEY_JPEG_QUALITY[];
    static const char KEY_ROTATION[];
    static const char KEY_GPS_LATITUDE[];
    static const char KEY_GPS_LONGITUDE[];
    static const char KEY_GPS_ALTITUDE[];
    static const char KEY_GPS_TIMESTAMP[];
    static const char KEY_GPS_PROCESSING_METHOD[];
    static const char KEY_WHITE_BALANCE[];
    static const char KEY_SUPPORTED_WHITE_BALANCE[];
    static const char KEY_EFFECT[];
    static const char KEY_SUPPORTED_EFFECTS[];
    static const char KEY_ANTIBANDING[];
    static const char KEY_SUPPORTED_ANTIBANDING[];
    static const char KEY_SCENE_MODE[];
    static const char KEY_SUPPORTED_SCENE_MODES[];
    static const char KEY_FLASH_MODE[];
    static const char KEY_SUPPORTED_FLASH_MODES[];
    static const char KEY_FOCUS_MODE[];
    static const char KEY_SUPPORTED_FOCUS_MODES[];
    static const char KEY_MAX_NUM_FOCUS_AREAS[];
    static const char KEY_FOCUS_AREAS[];
    static const char KEY_FOCAL_LENGTH[];
    static const char KEY_HORIZONTAL_VIEW_ANGLE[];
    static const char KEY_VERTICAL_VIEW_ANGLE[];
    static const char KEY_EXPOSURE_COMPENSATION[];
    static const char KEY_MAX_EXPOSURE_COMPENSATION[];
    static const char KEY_MIN_EXPOSURE_COMPENSATION[];
    static const char KEY_EXPOSURE_COMPENSATION_STEP[];
    static const char KEY_AUTO_EXPOSURE_LOCK[];
    static const char KEY_AUTO_EXPOSURE_LOCK_SUPPORTED[];
    static const char KEY_AUTO_WHITEBALANCE_LOCK[];
    static const char KEY_AUTO_WHITEBALANCE_LOCK_SUPPORTED[];
    static const char KEY_MAX_NUM_METERING_AREAS[];
    static const char KEY_METERING_AREAS[];
    static const char KEY_ZOOM[];
    static const char KEY_MAX_ZOOM[];
    static const char KEY_ZOOM_RATIOS[];
    static const char KEY_ZOOM_SUPPORTED[];
    static const char KEY_SMOOTH_ZOOM_SUPPORTED[];
    static const char KEY_FOCUS_DISTANCES[];
    static const char KEY_VIDEO_SIZE[];
    static const char KEY_SUPPORTED_VIDEO_SIZES[];
    static const char KEY_MAX_NUM_DETECTED_FACES_HW[];
    static const char KEY_MAX_NUM_DETECTED_FACES_SW[];
    static const char KEY_PREFERRED_PREVIEW_SIZE_FOR_VIDEO[];
    static const char KEY_VIDEO_FRAME_FORMAT[];
    static const char KEY_RECORDING_HINT[];
    static const char KEY_VIDEO_SNAPSHOT_SUPPORTED[];
    static const char KEY_VIDEO_STABILIZATION[];
    static const char KEY_VIDEO_STABILIZATION_SUPPORTED[];
    static const char KEY_LIGHTFX[];
  };

  class MediaProfiles final
  {
  public:
    static MediaProfiles* getInstance() {
      if (!sMediaProfiles) {
        sMediaProfiles = new MediaProfiles();
      }
      return sMediaProfiles;
    }

    bool hasCamcorderProfile(int aCameraId, camcorder_quality aQuality) const {
      switch (aQuality) {
        case CAMCORDER_QUALITY_LOW:
        case CAMCORDER_QUALITY_HIGH:
        case CAMCORDER_QUALITY_QVGA:
        case CAMCORDER_QUALITY_VGA:
          return true;
        default:
          break;
      }
      return false;
    }

    int getCamcorderProfileParamByName(const char* aParameter, int aCameraId, camcorder_quality aQuality) const {
      switch (aQuality) {
        case CAMCORDER_QUALITY_LOW:
        case CAMCORDER_QUALITY_QVGA:
          if (strcmp(aParameter, "vid.width") == 0) {
            return 320;
          } else if (strcmp(aParameter, "vid.height") == 0) {
            return 240;
          } else if (strcmp(aParameter, "vid.fps") == 0) {
            return 30;
          }
          return 0;
        case CAMCORDER_QUALITY_HIGH:
        case CAMCORDER_QUALITY_VGA:
          if (strcmp(aParameter, "vid.width") == 0) {
            return 640;
          } else if (strcmp(aParameter, "vid.height") == 0) {
            return 480;
          } else if (strcmp(aParameter, "vid.fps") == 0) {
            return 30;
          }
          return 0;
        default:
          break;
      }
      return -1;
    }

  protected:
    MediaProfiles()          { }
    virtual ~MediaProfiles() { }

  private:
    MediaProfiles(const MediaProfiles&) = delete;
    MediaProfiles& operator=(const MediaProfiles&) = delete;

    static MediaProfiles* sMediaProfiles;
  };
}

#endif