The Tor Browser / file revision

 /* This Source Code Form is subject to the terms of the Mozilla Public

  * License, v. 2.0. If a copy of the MPL was not distributed with this file,

  * You can obtain one at http://mozilla.org/MPL/2.0/. */

 #ifndef DOM_CAMERA_CAMERA_RECORDER_PROFILES_H

 #define DOM_CAMERA_CAMERA_RECORDER_PROFILES_H

 #include "nsISupportsImpl.h"

 #include "nsMimeTypes.h"

 #include "nsAutoPtr.h"

 #include "nsTArray.h"

 #include "jsapi.h"

 #include "CameraCommon.h"

 namespace mozilla {

 class CameraControlImpl;

 class RecorderVideoProfile

 {

 public:

   RecorderVideoProfile(uint32_t aCameraId, uint32_t aQualityIndex);

   virtual ~RecorderVideoProfile();

   int GetBitrate() const    { return mBitrate; }

   int GetFramerate() const  { return mFramerate; }

   int GetWidth() const      { return mWidth; }

   int GetHeight() const     { return mHeight; }

   enum Codec {

     H263,

     H264,

     MPEG4SP,

     UNKNOWN

   };

   Codec GetCodec() const    { return mCodec; }

   const char* GetCodecName() const

   {

     switch (mCodec) {

       case H263:    return "h263";

       case H264:    return "h264";

       case MPEG4SP: return "mpeg4sp";

       default:      return nullptr;

     }

   }

   nsresult GetJsObject(JSContext* aCx, JSObject** aObject);

 protected:

   uint32_t mCameraId;

   uint32_t mQualityIndex;

   Codec mCodec;

   int mBitrate;

   int mFramerate;

   int mWidth;

   int mHeight;

 };

 class RecorderAudioProfile

 {

 public:

   RecorderAudioProfile(uint32_t aCameraId, uint32_t aQualityIndex);

   virtual ~RecorderAudioProfile();

   int GetBitrate() const    { return mBitrate; }

   int GetSamplerate() const { return mSamplerate; }

   int GetChannels() const   { return mChannels; }

   enum Codec {

     AMRNB,

     AMRWB,

     AAC,

     UNKNOWN

   };

 public:

   Codec GetCodec() const    { return mCodec; }

   const char* GetCodecName() const

   {

     switch (mCodec) {

       case AMRNB: return "amrnb";

       case AMRWB: return "amrwb";

       case AAC:   return "aac";

       default:    return nullptr;

     }

   }

   nsresult GetJsObject(JSContext* aCx, JSObject** aObject);

 protected:

   uint32_t mCameraId;

   uint32_t mQualityIndex;

   Codec mCodec;

   int mBitrate;

   int mSamplerate;

   int mChannels;

 };

 class RecorderProfile

 {

 public:

   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RecorderProfile)

   RecorderProfile(uint32_t aCameraId, uint32_t aQualityIndex);

   virtual const RecorderVideoProfile* GetVideoProfile() const = 0;

   virtual const RecorderAudioProfile* GetAudioProfile() const = 0;

   const char* GetName() const { return mName; }

   enum FileFormat {

     THREE_GPP,

     MPEG4,

     UNKNOWN

   };

   FileFormat GetFileFormat() const { return mFileFormat; }

   const char* GetFileFormatName() const

   {

     switch (mFileFormat) {

       case THREE_GPP: return "3gp";

       case MPEG4:     return "mp4";

       default:        return nullptr;

     }

   }

   const char* GetFileMimeType() const

   {

     switch (mFileFormat) {

       case THREE_GPP: return VIDEO_3GPP;

       case MPEG4:     return VIDEO_MP4;

       default:        return nullptr;

     }

   }

   virtual nsresult GetJsObject(JSContext* aCx, JSObject** aObject) = 0;

 protected:

   virtual ~RecorderProfile();

   uint32_t mCameraId;

   uint32_t mQualityIndex;

   const char* mName;

   FileFormat mFileFormat;

 };

 template <class Audio, class Video>

 class RecorderProfileBase : public RecorderProfile

 {

 public:

   RecorderProfileBase(uint32_t aCameraId, uint32_t aQualityIndex)

     : RecorderProfile(aCameraId, aQualityIndex)

     , mVideo(aCameraId, aQualityIndex)

     , mAudio(aCameraId, aQualityIndex)

   {

     DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);

   }

   virtual ~RecorderProfileBase()

   {

     DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);

   }

   const RecorderVideoProfile* GetVideoProfile() const { return &mVideo; }

   const RecorderAudioProfile* GetAudioProfile() const { return &mAudio; }

   nsresult GetJsObject(JSContext* aCx, JSObject** aObject)

   {

     NS_ENSURE_TRUE(aObject, NS_ERROR_INVALID_ARG);

     const char* format = GetFileFormatName();

     if (!format) {

       // the profile must have a file format

       return NS_ERROR_FAILURE;

     }

     JS::Rooted<JSObject*> o(aCx, JS_NewObject(aCx, nullptr, JS::NullPtr(), JS::NullPtr()));

     if (!o) {

       return NS_ERROR_OUT_OF_MEMORY;

     }

     JS::Rooted<JSString*> s(aCx, JS_NewStringCopyZ(aCx, format));

     JS::Rooted<JS::Value> v(aCx, STRING_TO_JSVAL(s));

     if (!JS_SetProperty(aCx, o, "format", v)) {

       return NS_ERROR_FAILURE;

     }

     JS::Rooted<JSObject*> video(aCx);

     nsresult rv = mVideo.GetJsObject(aCx, video.address());

     NS_ENSURE_SUCCESS(rv, rv);

     v = OBJECT_TO_JSVAL(video);

     if (!JS_SetProperty(aCx, o, "video", v)) {

       return NS_ERROR_FAILURE;

     }

     JS::Rooted<JSObject*> audio(aCx);

     rv = mAudio.GetJsObject(aCx, audio.address());

     NS_ENSURE_SUCCESS(rv, rv);

     v = OBJECT_TO_JSVAL(audio);

     if (!JS_SetProperty(aCx, o, "audio", v)) {

       return NS_ERROR_FAILURE;

     }

     *aObject = o;

     return NS_OK;

   }

 protected:

   Video mVideo;

   Audio mAudio;

 };

 class RecorderProfileManager

 {

 public:

   NS_INLINE_DECL_THREADSAFE_REFCOUNTING(RecorderProfileManager)

   virtual bool IsSupported(uint32_t aQualityIndex) const { return true; }

   virtual already_AddRefed<RecorderProfile> Get(uint32_t aQualityIndex) const = 0;

   uint32_t GetMaxQualityIndex() const { return mMaxQualityIndex; }

   nsresult GetJsObject(JSContext* aCx, JSObject** aObject) const;

 protected:

   RecorderProfileManager(uint32_t aCameraId);

   virtual ~RecorderProfileManager();

   uint32_t mCameraId;

   uint32_t mMaxQualityIndex;

 };

 } // namespace mozilla

 #endif // DOM_CAMERA_CAMERA_RECORDER_PROFILES_H