The Tor Browser: dom/camera/GonkRecorderProfiles.cpp@a63d609f5ebe (annotated)

dom/camera/GonkRecorderProfiles.cpp@a63d609f5ebe (annotated)

dom/camera/GonkRecorderProfiles.cpp

Thu, 15 Jan 2015 15:55:04 +0100

author: Michael Schloh von Bennewitz <michael@schloh.com>
date: Thu, 15 Jan 2015 15:55:04 +0100
branch: TOR_BUG_9701
changeset 9: a63d609f5ebe
permissions: -rw-r--r--

Back out 97036ab72558 which inappropriately compared turds to third parties.

 /*
  * Copyright (C) 2012 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.
  */
 #include "GonkRecorderProfiles.h"
 #include <media/MediaProfiles.h>
 #include "GonkRecorder.h"
 #include "CameraControlImpl.h"
 #include "CameraCommon.h"
 using namespace mozilla;
 using namespace android;
 #define DEF_GONK_RECORDER_PROFILE(e, n) e##_INDEX,
 enum {
   #include "GonkRecorderProfiles.def"
   PROFILE_COUNT
 };
 #define DEF_GONK_RECORDER_PROFILE(e, n) { n, e },
 static struct {
   const char* name;
   int quality;
 } ProfileList[] = {
   #include "GonkRecorderProfiles.def"
   { nullptr, 0 }
 };
 static MediaProfiles* sMediaProfiles = nullptr;
 static bool
 IsQualitySupported(uint32_t aCameraId, uint32_t aQualityIndex)
 {
   if (!sMediaProfiles) {
     sMediaProfiles = MediaProfiles::getInstance();
   }
   camcorder_quality q = static_cast<camcorder_quality>(ProfileList[aQualityIndex].quality);
   return sMediaProfiles->hasCamcorderProfile(static_cast<int>(aCameraId), q);
 }
 static int
 GetProfileParam(uint32_t aCameraId, uint32_t aQualityIndex, const char* aParam)
 {
   if (!sMediaProfiles) {
     sMediaProfiles = MediaProfiles::getInstance();
   }
   camcorder_quality q = static_cast<camcorder_quality>(ProfileList[aQualityIndex].quality);
   return sMediaProfiles->getCamcorderProfileParamByName(aParam, static_cast<int>(aCameraId), q);
 }
 /**
  * Recorder profile.
  */
 static RecorderProfile::FileFormat
 TranslateFileFormat(output_format aFileFormat)
 {
   switch (aFileFormat) {
     case OUTPUT_FORMAT_THREE_GPP: return RecorderProfile::THREE_GPP;
     case OUTPUT_FORMAT_MPEG_4:    return RecorderProfile::MPEG4;
     default:                      return RecorderProfile::UNKNOWN;
   }
 }
 GonkRecorderProfile::GonkRecorderProfile(uint32_t aCameraId, uint32_t aQualityIndex)
   : RecorderProfileBase<GonkRecorderAudioProfile, GonkRecorderVideoProfile>(aCameraId, aQualityIndex)
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p, mCameraId=%d, mQualityIndex=%d\n", __func__, __LINE__, this, mCameraId, mQualityIndex);
   mPlatformOutputFormat = static_cast<output_format>(GetProfileParam(mCameraId, mQualityIndex, "file.format"));
   mFileFormat = TranslateFileFormat(mPlatformOutputFormat);
   if (aQualityIndex < PROFILE_COUNT) {
     mName = ProfileList[aQualityIndex].name;
     DOM_CAMERA_LOGI("Created camera %d profile index %d: '%s'\n", mCameraId, mQualityIndex, mName);
   }
 }
 GonkRecorderProfile::~GonkRecorderProfile()
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 }
 nsresult
 GonkRecorderProfile::ConfigureRecorder(GonkRecorder* aRecorder)
 {
   static const size_t SIZE = 256;
   char buffer[SIZE];
   // set all the params
   CHECK_SETARG(aRecorder->setAudioSource(AUDIO_SOURCE_CAMCORDER));
   CHECK_SETARG(aRecorder->setVideoSource(VIDEO_SOURCE_CAMERA));
   CHECK_SETARG(aRecorder->setOutputFormat(GetOutputFormat()));
   CHECK_SETARG(aRecorder->setVideoFrameRate(mVideo.GetFramerate()));
   CHECK_SETARG(aRecorder->setVideoSize(mVideo.GetWidth(), mVideo.GetHeight()));
   CHECK_SETARG(aRecorder->setVideoEncoder(mVideo.GetPlatformCodec()));
   CHECK_SETARG(aRecorder->setAudioEncoder(mAudio.GetPlatformCodec()));
   snprintf(buffer, SIZE, "video-param-encoding-bitrate=%d", mVideo.GetBitrate());
   CHECK_SETARG(aRecorder->setParameters(String8(buffer)));
   snprintf(buffer, SIZE, "audio-param-encoding-bitrate=%d", mAudio.GetBitrate());
   CHECK_SETARG(aRecorder->setParameters(String8(buffer)));
   snprintf(buffer, SIZE, "audio-param-number-of-channels=%d", mAudio.GetChannels());
   CHECK_SETARG(aRecorder->setParameters(String8(buffer)));
   snprintf(buffer, SIZE, "audio-param-sampling-rate=%d", mAudio.GetSamplerate());
   CHECK_SETARG(aRecorder->setParameters(String8(buffer)));
   return NS_OK;
 }
 /**
  * Recorder audio profile.
  */
 static RecorderAudioProfile::Codec
 TranslateAudioCodec(audio_encoder aCodec)
 {
   switch (aCodec) {
     case AUDIO_ENCODER_AMR_NB:  return RecorderAudioProfile::AMRNB;
     case AUDIO_ENCODER_AMR_WB:  return RecorderAudioProfile::AMRWB;
     case AUDIO_ENCODER_AAC:     return RecorderAudioProfile::AAC;
     default:                    return RecorderAudioProfile::UNKNOWN;
   }
 }
 GonkRecorderAudioProfile::GonkRecorderAudioProfile(uint32_t aCameraId, uint32_t aQualityIndex)
   : RecorderAudioProfile(aCameraId, aQualityIndex)
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p, mCameraId=%d, mQualityIndex=%d\n", __func__, __LINE__, this, mCameraId, mQualityIndex);
   mPlatformCodec = static_cast<audio_encoder>(GetProfileParam(mCameraId, mQualityIndex, "aud.codec"));
   mCodec = TranslateAudioCodec(mPlatformCodec);
   mBitrate = GetProfileParam(mCameraId, mQualityIndex, "aud.bps");
   mSamplerate = GetProfileParam(mCameraId, mQualityIndex, "aud.hz");
   mChannels = GetProfileParam(mCameraId, mQualityIndex, "aud.ch");
 }
 GonkRecorderAudioProfile::~GonkRecorderAudioProfile()
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 }
 /**
  * Recorder video profile.
  */
 static RecorderVideoProfile::Codec
 TranslateVideoCodec(video_encoder aCodec)
 {
   switch (aCodec) {
     case VIDEO_ENCODER_H263:      return RecorderVideoProfile::H263;
     case VIDEO_ENCODER_H264:      return RecorderVideoProfile::H264;
     case VIDEO_ENCODER_MPEG_4_SP: return RecorderVideoProfile::MPEG4SP;
     default:                      return RecorderVideoProfile::UNKNOWN;
   }
 }
 GonkRecorderVideoProfile::GonkRecorderVideoProfile(uint32_t aCameraId, uint32_t aQualityIndex)
   : RecorderVideoProfile(aCameraId, aQualityIndex)
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p, mCameraId=%d, mQualityIndex=%d\n", __func__, __LINE__, this, mCameraId, mQualityIndex);
   mPlatformCodec = static_cast<video_encoder>(GetProfileParam(mCameraId, mQualityIndex, "vid.codec"));
   mCodec = TranslateVideoCodec(mPlatformCodec);
   mBitrate = GetProfileParam(mCameraId, mQualityIndex, "vid.bps");
   mFramerate = GetProfileParam(mCameraId, mQualityIndex, "vid.fps");
   mWidth = GetProfileParam(mCameraId, mQualityIndex, "vid.width");
   mHeight = GetProfileParam(mCameraId, mQualityIndex, "vid.height");
 }
 GonkRecorderVideoProfile::~GonkRecorderVideoProfile()
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 }
 GonkRecorderProfileManager::GonkRecorderProfileManager(uint32_t aCameraId)
   : RecorderProfileManager(aCameraId)
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
   mMaxQualityIndex = sizeof(ProfileList) / sizeof(ProfileList[0]) - 1;
 }
 GonkRecorderProfileManager::~GonkRecorderProfileManager()
 {
   DOM_CAMERA_LOGT("%s:%d : this=%p\n", __func__, __LINE__, this);
 }
 bool
 GonkRecorderProfileManager::IsSupported(uint32_t aQualityIndex) const
 {
   if (!IsQualitySupported(mCameraId, aQualityIndex)) {
     // This profile is not supported
     return false;
   }
   int width = GetProfileParam(mCameraId, aQualityIndex, "vid.width");
   int height = GetProfileParam(mCameraId, aQualityIndex, "vid.height");
   if (width == -1 || height == -1) {
     // This would be unexpected, but we handle it just in case
     DOM_CAMERA_LOGE("Camera %d recorder profile %d has width=%d, height=%d\n", mCameraId, aQualityIndex, width, height);
     return false;
   }
   for (uint32_t i = 0; i < mSupportedSizes.Length(); ++i) {
     if (static_cast<uint32_t>(width) == mSupportedSizes[i].width &&
       static_cast<uint32_t>(height) == mSupportedSizes[i].height)
     {
       return true;
     }
   }
   return false;
 }
 already_AddRefed<RecorderProfile>
 GonkRecorderProfileManager::Get(uint32_t aQualityIndex) const
 {
   // This overrides virtual RecorderProfileManager::Get(...)
   DOM_CAMERA_LOGT("%s:%d : aQualityIndex=%d\n", __func__, __LINE__, aQualityIndex);
   nsRefPtr<RecorderProfile> profile = new GonkRecorderProfile(mCameraId, aQualityIndex);
   return profile.forget();
 }
 already_AddRefed<GonkRecorderProfile>
 GonkRecorderProfileManager::Get(const char* aProfileName) const
 {
   DOM_CAMERA_LOGT("%s:%d : aProfileName='%s'\n", __func__, __LINE__, aProfileName);
   for (uint32_t i = 0; i < mMaxQualityIndex; ++i) {
     if (strcmp(ProfileList[i].name, aProfileName) == 0) {
       nsRefPtr<GonkRecorderProfile> profile = nullptr;
       if (IsSupported(i)) {
         profile = new GonkRecorderProfile(mCameraId, i);
         return profile.forget();
       }
       return nullptr;
     }
   }
   DOM_CAMERA_LOGW("Couldn't file recorder profile named '%s'\n", aProfileName);
   return nullptr;
 }

The Tor Browser / annotate

dom/camera/GonkRecorderProfiles.cpp@a63d609f5ebe (annotated)

dom/camera/GonkRecorderProfiles.cpp