Remove the video capture module on Android.

webrtc/modules/video_capture/android/device_info_android.cc

-/*
- *  Copyright (c) 2012 The WebRTC project authors. All Rights Reserved.
- *
- *  Use of this source code is governed by a BSD-style license
- *  that can be found in the LICENSE file in the root of the source
- *  tree. An additional intellectual property rights grant can be found
- *  in the file PATENTS.  All contributing project authors may
- *  be found in the AUTHORS file in the root of the source tree.
- */
-
-#include "webrtc/modules/video_capture/android/device_info_android.h"
-
-#include <algorithm>
-#include <sstream>
-#include <vector>
-
-#include "unicode/unistr.h"
-#include "webrtc/base/json.h"
-#include "webrtc/modules/video_capture/android/video_capture_android.h"
-#include "webrtc/system_wrappers/interface/logging.h"
-#include "webrtc/system_wrappers/interface/ref_count.h"
-#include "webrtc/system_wrappers/interface/trace.h"
-
-namespace webrtc {
-
-namespace videocapturemodule {
-
-// Helper for storing lists of pairs of ints.  Used e.g. for resolutions & FPS
-// ranges.
-typedef std::pair<int, int> IntPair;
-typedef std::vector<IntPair> IntPairs;
-
-static std::string IntPairsToString(const IntPairs& pairs, char separator) {
-  std::stringstream stream;
-  for (size_t i = 0; i < pairs.size(); ++i) {
-    if (i > 0)
-      stream << ", ";
-    stream << "(" << pairs[i].first << separator << pairs[i].second << ")";
-  }
-  return stream.str();
-}
-
-struct AndroidCameraInfo {
-  std::string name;
-  bool front_facing;
-  int orientation;
-  IntPairs resolutions;  // Pairs are: (width,height).
-  // Pairs are (min,max) in units of FPS*1000 ("milli-frame-per-second").
-  IntPairs mfpsRanges;
-
-  std::string ToString() {
-    std::stringstream stream;
-    stream << "Name: [" << name << "], MFPS ranges: ["
-           << IntPairsToString(mfpsRanges, ':')
-           << "], front_facing: " << front_facing
-           << ", orientation: " << orientation << ", resolutions: ["
-           << IntPairsToString(resolutions, 'x') << "]";
-    return stream.str();
-  }
-};
-
-// Camera info; populated during DeviceInfoAndroid::Initialize() and immutable
-// thereafter.
-static std::vector<AndroidCameraInfo>* g_camera_info = NULL;
-
-// Set |*index| to the index of |name| in g_camera_info or return false if no
-// match found.
-static bool FindCameraIndexByName(const std::string& name, size_t* index) {
-  for (size_t i = 0; i < g_camera_info->size(); ++i) {
-    if (g_camera_info->at(i).name == name) {
-      *index = i;
-      return true;
-    }
-  }
-  return false;
-}
-
-// Returns a pointer to the named member of g_camera_info, or NULL if no match
-// is found.
-static AndroidCameraInfo* FindCameraInfoByName(const std::string& name) {
-  size_t index = 0;
-  if (FindCameraIndexByName(name, &index))
-    return &g_camera_info->at(index);
-  return NULL;
-}
-
-// static
-void DeviceInfoAndroid::Initialize(JNIEnv* jni) {
-  // TODO(henrike): this "if" would make a lot more sense as an assert, but
-  // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_GetVideoEngine() and
-  // Java_org_webrtc_videoengineapp_ViEAndroidJavaAPI_Terminate() conspire to
-  // prevent this.  Once that code is made to only
-  // VideoEngine::SetAndroidObjects() once per process, this can turn into an
-  // assert.
-  if (g_camera_info)
-    return;
-
-  g_camera_info = new std::vector<AndroidCameraInfo>();
-  jclass j_info_class =
-      jni->FindClass("org/webrtc/videoengine/VideoCaptureDeviceInfoAndroid");
-  assert(j_info_class);
-  jmethodID j_initialize = jni->GetStaticMethodID(
-      j_info_class, "getDeviceInfo", "()Ljava/lang/String;");
-  jstring j_json_info = static_cast<jstring>(
-      jni->CallStaticObjectMethod(j_info_class, j_initialize));
-
-  const jchar* jchars = jni->GetStringChars(j_json_info, NULL);
-  icu::UnicodeString ustr(jchars, jni->GetStringLength(j_json_info));
-  jni->ReleaseStringChars(j_json_info, jchars);
-  std::string json_info;
-  ustr.toUTF8String(json_info);
-
-  Json::Value cameras;
-  Json::Reader reader(Json::Features::strictMode());
-  bool parsed = reader.parse(json_info, cameras);
-  if (!parsed) {
-    std::stringstream stream;
-    stream << "Failed to parse configuration:\n"
-           << reader.getFormattedErrorMessages();
-    assert(false);
-    return;
-  }
-  for (Json::ArrayIndex i = 0; i < cameras.size(); ++i) {
-    const Json::Value& camera = cameras[i];
-    AndroidCameraInfo info;
-    info.name = camera["name"].asString();
-    info.front_facing = camera["front_facing"].asBool();
-    info.orientation = camera["orientation"].asInt();
-    Json::Value sizes = camera["sizes"];
-    for (Json::ArrayIndex j = 0; j < sizes.size(); ++j) {
-      const Json::Value& size = sizes[j];
-      info.resolutions.push_back(std::make_pair(
-          size["width"].asInt(), size["height"].asInt()));
-    }
-    Json::Value mfpsRanges = camera["mfpsRanges"];
-    for (Json::ArrayIndex j = 0; j < mfpsRanges.size(); ++j) {
-      const Json::Value& mfpsRange = mfpsRanges[j];
-      info.mfpsRanges.push_back(std::make_pair(mfpsRange["min_mfps"].asInt(),
-                                               mfpsRange["max_mfps"].asInt()));
-    }
-    g_camera_info->push_back(info);
-  }
-}
-
-void DeviceInfoAndroid::DeInitialize() {
-  if (g_camera_info) {
-    delete g_camera_info;
-    g_camera_info = NULL;
-  }
-}
-
-VideoCaptureModule::DeviceInfo* VideoCaptureImpl::CreateDeviceInfo(
-    const int32_t id) {
-  return new videocapturemodule::DeviceInfoAndroid(id);
-}
-
-DeviceInfoAndroid::DeviceInfoAndroid(const int32_t id) :
-    DeviceInfoImpl(id) {
-}
-
-DeviceInfoAndroid::~DeviceInfoAndroid() {
-}
-
-bool DeviceInfoAndroid::FindCameraIndex(const char* deviceUniqueIdUTF8,
-                                        size_t* index) {
-  return FindCameraIndexByName(deviceUniqueIdUTF8, index);
-}
-
-int32_t DeviceInfoAndroid::Init() {
-  return 0;
-}
-
-uint32_t DeviceInfoAndroid::NumberOfDevices() {
-  return g_camera_info->size();
-}
-
-int32_t DeviceInfoAndroid::GetDeviceName(
-    uint32_t deviceNumber,
-    char* deviceNameUTF8,
-    uint32_t deviceNameLength,
-    char* deviceUniqueIdUTF8,
-    uint32_t deviceUniqueIdUTF8Length,
-    char* /*productUniqueIdUTF8*/,
-    uint32_t /*productUniqueIdUTF8Length*/) {
-  if (deviceNumber >= g_camera_info->size())
-    return -1;
-  const AndroidCameraInfo& info = g_camera_info->at(deviceNumber);
-  if (info.name.length() + 1 > deviceNameLength ||
-      info.name.length() + 1 > deviceUniqueIdUTF8Length) {
-    return -1;
-  }
-  memcpy(deviceNameUTF8, info.name.c_str(), info.name.length() + 1);
-  memcpy(deviceUniqueIdUTF8, info.name.c_str(), info.name.length() + 1);
-  return 0;
-}
-
-int32_t DeviceInfoAndroid::CreateCapabilityMap(
-    const char* deviceUniqueIdUTF8) {
-  _captureCapabilities.clear();
-  const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
-  if (info == NULL)
-    return -1;
-
-  for (size_t i = 0; i < info->resolutions.size(); ++i) {
-    for (size_t j = 0; j < info->mfpsRanges.size(); ++j) {
-      const IntPair& size = info->resolutions[i];
-      const IntPair& mfpsRange = info->mfpsRanges[j];
-      VideoCaptureCapability cap;
-      cap.width = size.first;
-      cap.height = size.second;
-      cap.maxFPS = mfpsRange.second / 1000;
-      cap.expectedCaptureDelay = kExpectedCaptureDelay;
-      cap.rawType = kVideoNV21;
-      _captureCapabilities.push_back(cap);
-    }
-  }
-  return _captureCapabilities.size();
-}
-
-int32_t DeviceInfoAndroid::GetOrientation(const char* deviceUniqueIdUTF8,
-                                          VideoRotation& orientation) {
-  const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
-  if (info == NULL ||
-      VideoCaptureImpl::RotationFromDegrees(info->orientation,
-                                            &orientation) != 0) {
-    return -1;
-  }
-  return 0;
-}
-
-void DeviceInfoAndroid::GetMFpsRange(const char* deviceUniqueIdUTF8,
-                                     int max_fps_to_match,
-                                     int* min_mfps, int* max_mfps) {
-  const AndroidCameraInfo* info = FindCameraInfoByName(deviceUniqueIdUTF8);
-  if (info == NULL)
-    return;
-  int desired_mfps = max_fps_to_match * 1000;
-  int best_diff_mfps = 0;
-  LOG(LS_INFO) << "Search for best target mfps " << desired_mfps;
-  // Search for best fps range with preference shifted to constant fps modes.
-  for (size_t i = 0; i < info->mfpsRanges.size(); ++i) {
-    int diff_mfps = abs(info->mfpsRanges[i].first - desired_mfps) +
-        abs(info->mfpsRanges[i].second - desired_mfps) +
-        (info->mfpsRanges[i].second - info->mfpsRanges[i].first) / 2;
-    LOG(LS_INFO) << "Fps range " << info->mfpsRanges[i].first << ":" <<
-        info->mfpsRanges[i].second << ". Distance: " << diff_mfps;
-    if (i == 0 || diff_mfps < best_diff_mfps) {
-      best_diff_mfps = diff_mfps;
-      *min_mfps = info->mfpsRanges[i].first;
-      *max_mfps = info->mfpsRanges[i].second;
-    }
-  }
-}
-
-}  // namespace videocapturemodule
-}  // namespace webrtc