diff --git a/client/site_tests/camera_V4L2/src/Makefile b/client/site_tests/camera_V4L2/src/Makefile
index c44cc80..d3c88fa 100644
--- a/client/site_tests/camera_V4L2/src/Makefile
+++ b/client/site_tests/camera_V4L2/src/Makefile
@@ -2,20 +2,31 @@
 # Use of this source code is governed by a BSD-style license that can be
 # found in the LICENSE file.
 
-LDFLAGS =  -lrt -ldl
+PKG_CONFIG ?= pkg-config
+DEP_LIBS = libchrome-$(BASE_VER)
+CXXFLAGS += $(shell $(PKG_CONFIG) --cflags $(DEP_LIBS))
 
-LDFLAGS_UNITTEST = -lrt
+LDFLAGS = -lrt -ldl -std=c++11
+LDFLAGS += $(shell $(PKG_CONFIG) --libs $(DEP_LIBS))
+
+LDFLAGS_UNITTEST = -lrt -std=c++11
+LDFLAGS_UNITTEST += $(shell $(PKG_CONFIG) --libs $(DEP_LIBS))
 
 LDFLAGS_HELPER = -lrt
 
-SRC = media_v4l2_device.cc  \
-      media_v4l2_test.cc
+SRC = \
+	camera_characteristics.cc \
+	media_v4l2_device.cc  \
+	media_v4l2_test.cc
 
-SRC_UNITTEST = media_v4l2_device.cc \
-               media_v4l2_unittest.cc
+SRC_UNITTEST = \
+	camera_characteristics.cc \
+	media_v4l2_device.cc \
+	media_v4l2_unittest.cc
 
-SRC_HELPER = media_v4l2_device.cc \
-             media_v4l2_is_capture_device.cc
+SRC_HELPER = \
+	media_v4l2_device.cc \
+	media_v4l2_is_capture_device.cc
 
 TARGET = ../media_v4l2_test
 
diff --git a/client/site_tests/camera_V4L2/src/camera_characteristics.cc b/client/site_tests/camera_V4L2/src/camera_characteristics.cc
new file mode 100644
index 0000000..fa8eec0
--- /dev/null
+++ b/client/site_tests/camera_V4L2/src/camera_characteristics.cc
@@ -0,0 +1,295 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#include "camera_characteristics.h"
+
+#include <ctype.h>
+
+#include <ios>
+#include <sstream>
+
+#include <base/files/file_util.h>
+#include <base/logging.h>
+
+// /etc/camera/camera_characteristics.conf contains camera information which
+// driver cannot provide.
+static const char kCameraCharacteristicsConfigFile[] =
+    "/etc/camera/camera_characteristics.conf";
+
+/* Common parameters */
+static const char kLensFacing[] = "lens_facing";
+static const char kSensorOrientation[] = "sensor_orientation";
+static const char kUsbVidPid[] = "usb_vid_pid";
+static const char kLensInfoAvailableFocalLengths[] =
+    "lens_info_available_focal_lengths";
+static const char kLensInfoMinimumFocusDistance[] =
+    "lens_info_minimum_focus_distance";
+static const char kLensInfoOptimalFocusDistance[] =
+    "lens_info_optimal_focus_distance";
+
+/* HAL v1 parameters */
+static const char kHorizontalViewAngle_16_9[] = "horizontal_view_angle_16_9";
+static const char kHorizontalViewAngle_4_3[] = "horizontal_view_angle_4_3";
+static const char kVerticalViewAngle_16_9[] = "vertical_view_angle_16_9";
+static const char kVerticalViewAngle_4_3[] = "vertical_view_angle_4_3";
+
+/* HAL v3 parameters */
+static const char kLensInfoAvailableApertures[] =
+    "lens_info_available_apertures";
+static const char kSensorInfoPhysicalSize[] = "sensor_info_physical_size";
+static const char kSensorInfoPixelArraySize[] = "sensor_info_pixel_array_size";
+
+/* Special parameters */
+static const char kFramesToSkipAfterStreamon[] =
+    "frames_to_skip_after_streamon";
+static const char kResolution1280x960Unsupported[] =
+    "resolution_1280x960_unsupported";
+static const char kConstantFramerateUnsupported[] =
+    "constant_framerate_unsupported";
+
+static const struct DeviceInfo kDefaultCharacteristics = {
+  "",     // device_path
+  "",     // usb_vid
+  "",     // usb_pid
+  0,      // lens_facing
+  0,      // sensor_orientation
+  0,      // frames_to_skip_after_streamon
+  66.5,   // horizontal_view_angle_16_9
+  0.0,    // horizontal_view_angle_4_3
+  {1.6},  // lens_info_available_focal_lengths
+  0.3,    // lens_info_minimum_focus_distance
+  0.5,    // lens_info_optimal_focus_distance
+  42.5,   // vertical_view_angle_16_9
+  0.0,    // vertical_view_angle_4_3
+  false,  // resolution_1280x960_unsupported
+  false   // constant_framerate_unsupported
+};
+
+CameraCharacteristics::CameraCharacteristics() {
+}
+
+CameraCharacteristics::~CameraCharacteristics() {
+}
+
+const DeviceInfos CameraCharacteristics::GetCharacteristicsFromFile(
+    const std::unordered_map<std::string, std::string>& devices) {
+  const base::FilePath path(kCameraCharacteristicsConfigFile);
+  FILE* file = base::OpenFile(path, "r");
+  if (!file) {
+    LOG(ERROR) << __func__ << ": Can't open file "
+               << kCameraCharacteristicsConfigFile
+               << ". Use default characteristics instead";
+    DeviceInfos device_infos;
+    for (const auto& device : devices) {
+      device_infos.push_back(kDefaultCharacteristics);
+      size_t pos = device.first.find(":");
+      if (pos != std::string::npos) {
+        // If configuration file doesn't exist, the two attributes should be
+        // true.
+        device_infos.back().resolution_1280x960_unsupported = true;
+        device_infos.back().constant_framerate_unsupported = true;
+
+        device_infos.back().device_path = device.second;
+        device_infos.back().usb_vid = device.first.substr(0, pos - 1);
+        device_infos.back().usb_pid = device.first.substr(pos + 1);
+      } else {
+        LOG(ERROR) << __func__ << ": Invalid device: " << device.first;
+      }
+    }
+    return device_infos;
+  }
+
+  DeviceInfos tmp_device_infos;
+  char buffer[256], key[256], value[256];
+  uint32_t camera_id;
+  uint32_t module_id = -1;
+  std::string vid, pid;
+  while (fgets(buffer, sizeof(buffer), file)) {
+    // Skip comments and empty lines.
+    if (buffer[0] == '#' || buffer[0] == '\n') {
+      continue;
+    }
+
+    if (sscanf(buffer, "%[^=]=%s", key, value) != 2) {
+      LOG(ERROR) << __func__ << ": Illegal format: " << buffer;
+      continue;
+    }
+    std::vector<char*> sub_keys;
+    char* sub_key = strtok(key, ".");
+    while (sub_key) {
+      sub_keys.push_back(sub_key);
+      sub_key = strtok(NULL, ".");
+    }
+
+    if (sscanf(sub_keys[0], "camera%u", &camera_id) != 1) {
+      LOG(ERROR) << __func__ << ": Illegal format: " << sub_keys[0];
+      continue;
+    }
+    if (camera_id > tmp_device_infos.size()) {
+      // Camera id should be ascending by one.
+      LOG(ERROR) << __func__ << ": Invalid camera id: " << camera_id;
+      continue;
+    } else if (camera_id == tmp_device_infos.size()) {
+      tmp_device_infos.push_back(kDefaultCharacteristics);
+    }
+
+    uint32_t tmp_module_id;
+    // Convert value to lower case.
+    for (char* p = value; *p; ++p) *p = tolower(*p);
+
+    if (sscanf(sub_keys[1], "module%u", &tmp_module_id) != 1) {
+      AddPerCameraCharacteristic(
+          camera_id, sub_keys[1], value, &tmp_device_infos);
+    } else {
+      if (tmp_module_id != module_id) {
+        vid.clear();
+        pid.clear();
+        module_id = tmp_module_id;
+      }
+      if (strcmp(sub_keys[2], kUsbVidPid) == 0) {
+        char tmp_vid[256], tmp_pid[256];
+        if (sscanf(value, "%[0-9a-z]:%[0-9a-z]", tmp_vid, tmp_pid) != 2) {
+          LOG(ERROR) << __func__ << ": Invalid format: " << sub_keys[2];
+          continue;
+        }
+        vid = tmp_vid;
+        pid = tmp_pid;
+        const auto& device = devices.find(value);
+        if (device != devices.end()) {
+          tmp_device_infos[camera_id].usb_vid = vid;
+          tmp_device_infos[camera_id].usb_pid = pid;
+          tmp_device_infos[camera_id].device_path = device->second;
+        }
+
+        VLOG(1) << __func__ << ": Camera" << camera_id << " "
+                << kUsbVidPid << ": " << value;
+      } else if (!vid.empty() && !pid.empty()) {
+        // Some characteristics are module-specific, so only matched ones are
+        // selected.
+        if (tmp_device_infos[camera_id].usb_vid != vid ||
+            tmp_device_infos[camera_id].usb_pid != pid) {
+          VLOG(1) << __func__ << ": Mismatched module: "
+                  << "vid: " << vid << " pid: " << pid;
+          continue;
+        }
+        AddPerModuleCharacteristic(
+            camera_id, sub_keys[2], value, &tmp_device_infos);
+      } else {
+        // Characteristic usb_vid_pid should come before other module-specific
+        // characteristics.
+        LOG(ERROR) << __func__ << ": Illegal format."
+                   << " usb_vid_pid should come before: " << buffer;
+      }
+    }
+  }
+  base::CloseFile(file);
+
+  DeviceInfos device_infos;
+  // Some devices use the same camera_characteristics.conf and have different
+  // number of cameras.
+  for (size_t id = 0; id < tmp_device_infos.size(); ++id) {
+    if (tmp_device_infos[id].device_path.empty()) {
+      LOG(INFO) << __func__ << ": No matching module for camera" << id;
+    } else {
+      device_infos.push_back(tmp_device_infos[id]);
+    }
+  }
+  return device_infos;
+}
+
+void CameraCharacteristics::AddPerCameraCharacteristic(
+    uint32_t camera_id, const char* characteristic, const char* value,
+    DeviceInfos* device_infos) {
+  VLOG(1) << __func__ << ": " << characteristic << ": " << value;
+  if (strcmp(characteristic, kLensFacing) == 0) {
+    (*device_infos)[camera_id].lens_facing = strtol(value, NULL, 10);
+  } else if (strcmp(characteristic, kSensorOrientation) == 0) {
+    (*device_infos)[camera_id].sensor_orientation = strtol(value, NULL, 10);
+  } else if (strcmp(characteristic, kResolution1280x960Unsupported) == 0) {
+    std::istringstream is(value);
+    is >> std::boolalpha
+       >> (*device_infos)[camera_id].resolution_1280x960_unsupported;
+  } else if (strcmp(characteristic, kConstantFramerateUnsupported) == 0) {
+    std::istringstream is(value);
+    is >> std::boolalpha
+       >> (*device_infos)[camera_id].constant_framerate_unsupported;
+  } else {
+    LOG(ERROR) << __func__ << ": Unknown characteristic: " << characteristic
+               << " value: " << value;
+  }
+}
+
+void CameraCharacteristics::AddPerModuleCharacteristic(
+    uint32_t camera_id, const char* characteristic, const char* value,
+    DeviceInfos* device_infos) {
+  if (strcmp(characteristic, kFramesToSkipAfterStreamon) == 0) {
+    VLOG(1) << __func__ << ": " << characteristic << ": " << value;
+    (*device_infos)[camera_id].frames_to_skip_after_streamon =
+        strtol(value, NULL, 10);
+  } else if (strcmp(characteristic, kHorizontalViewAngle_16_9) == 0) {
+    AddFloatValue(value, kHorizontalViewAngle_16_9,
+                  &(*device_infos)[camera_id].horizontal_view_angle_16_9);
+  } else if (strcmp(characteristic, kHorizontalViewAngle_4_3) == 0) {
+    AddFloatValue(value, kHorizontalViewAngle_4_3,
+                  &(*device_infos)[camera_id].horizontal_view_angle_4_3);
+  } else if (strcmp(characteristic, kLensInfoAvailableFocalLengths) == 0) {
+    (*device_infos)[camera_id].lens_info_available_focal_lengths.clear();
+    char tmp_value[256];
+    strcpy(tmp_value, value);
+    char* focal_length = strtok(tmp_value, ",");
+    while (focal_length) {
+      float tmp_focal_length = strtof(focal_length, NULL);
+      if (tmp_focal_length != 0.0) {
+        VLOG(1) << __func__ << ": " << characteristic << ": "
+                << tmp_focal_length;
+        (*device_infos)[camera_id].lens_info_available_focal_lengths.push_back(
+            tmp_focal_length);
+      } else {
+        LOG(ERROR) << __func__ << ": Invalid " << characteristic << ": "
+                   << value;
+        (*device_infos)[camera_id].lens_info_available_focal_lengths.clear();
+        (*device_infos)[camera_id].lens_info_available_focal_lengths.push_back(
+            kDefaultCharacteristics.lens_info_available_focal_lengths[0]);
+        break;
+      }
+      focal_length = strtok(NULL, ",");
+    }
+  } else if (strcmp(characteristic, kLensInfoMinimumFocusDistance) == 0) {
+    AddFloatValue(value, kLensInfoMinimumFocusDistance,
+                  &(*device_infos)[camera_id].lens_info_minimum_focus_distance);
+  } else if (strcmp(characteristic, kLensInfoOptimalFocusDistance) == 0) {
+    AddFloatValue(value, kLensInfoOptimalFocusDistance,
+                  &(*device_infos)[camera_id].lens_info_optimal_focus_distance);
+  } else if (strcmp(characteristic, kVerticalViewAngle_16_9) == 0) {
+    AddFloatValue(value, kVerticalViewAngle_16_9,
+                  &(*device_infos)[camera_id].vertical_view_angle_16_9);
+  } else if (strcmp(characteristic, kVerticalViewAngle_4_3) == 0) {
+    AddFloatValue(value, kVerticalViewAngle_4_3,
+                  &(*device_infos)[camera_id].vertical_view_angle_4_3);
+  } else if (strcmp(characteristic, kLensInfoAvailableApertures) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else if (strcmp(characteristic, kSensorInfoPhysicalSize) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else if (strcmp(characteristic, kSensorInfoPixelArraySize) == 0) {
+    /* Do nothing. This is for hal v3 */
+  } else {
+    LOG(ERROR) << __func__ << ": Unknown characteristic: " << characteristic
+               << " value: " << value;
+  }
+}
+
+void CameraCharacteristics::AddFloatValue(const char* value,
+                                          const char* characteristic_name,
+                                          float* characteristic) {
+  float tmp_value = strtof(value, NULL);
+  if (tmp_value != 0.0) {
+    VLOG(1) << __func__ << ": " << characteristic_name << ": " << value;
+    *characteristic = tmp_value;
+  } else {
+    LOG(ERROR) << __func__ << ": Invalid " << characteristic_name
+               << ": " << value;
+  }
+}
diff --git a/client/site_tests/camera_V4L2/src/camera_characteristics.h b/client/site_tests/camera_V4L2/src/camera_characteristics.h
new file mode 100644
index 0000000..3d2310b
--- /dev/null
+++ b/client/site_tests/camera_V4L2/src/camera_characteristics.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2016 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef CAMERA_CHARACTERISTICS_H_
+#define CAMERA_CHARACTERISTICS_H_
+
+#include "common_types.h"
+
+#include <unordered_map>
+
+#include <base/macros.h>
+
+// CameraCharacteristics reads the file /etc/camera/camera_characteristics.conf.
+// There are several assumptions of the config file:
+//  1. Each line should be at most 256 characters long.
+//  2. camera id should be in ascending order (i.e., 0, 1, 2, ...).
+//  3. usb_vid_pid should be the first subkey.
+//  4. All configs of a module should be put together.
+//
+// Example of the config file:
+//  camera0.lens_facing=0
+//  camera0.sensor_orientation=0
+//  camera0.module0.usb_vid_pid=0123:4567
+//  camera0.module0.horizontal_view_angle=68.4
+//  camera0.module0.lens_info_available_focal_lengths=1.64
+//  camera0.module0.lens_info_minimum_focus_distance=0.22
+//  camera0.module0.lens_info_optimal_focus_distance=0.5
+//  camera0.module0.vertical_view_angle=41.6
+//  camera0.module1.usb_vid_pid=89ab:cdef
+//  camera0.module1.lens_info_available_focal_lengths=1.69,2
+//  camera1.lens_facing=1
+//  camera1.sensor_orientation=180
+class CameraCharacteristics {
+ public:
+  CameraCharacteristics();
+  ~CameraCharacteristics();
+
+  // Parses /etc/camera/camera_characteristics.conf.
+  // Returns DeviceInfos with default characteristics if the config file doesn't
+  // exist.
+  const DeviceInfos GetCharacteristicsFromFile(
+      const std::unordered_map<std::string, std::string>& devices);
+
+ private:
+  void AddPerCameraCharacteristic(
+      uint32_t camera_id, const char* characteristic, const char* value,
+      DeviceInfos* device_infos);
+  void AddPerModuleCharacteristic(
+      uint32_t camera_id, const char* characteristic, const char* value,
+      DeviceInfos* device_infos);
+  void AddFloatValue(const char* value, const char* characteristic_name,
+                     float* characteristic);
+
+  DISALLOW_COPY_AND_ASSIGN(CameraCharacteristics);
+};
+
+#endif  // CAMERA_CHARACTERISTICS_H_
diff --git a/client/site_tests/camera_V4L2/src/common_types.h b/client/site_tests/camera_V4L2/src/common_types.h
new file mode 100644
index 0000000..f16d143
--- /dev/null
+++ b/client/site_tests/camera_V4L2/src/common_types.h
@@ -0,0 +1,60 @@
+/*
+ * Copyright 2015 The Chromium OS Authors. All rights reserved.
+ * Use of this source code is governed by a BSD-style license that can be
+ * found in the LICENSE file.
+ */
+
+#ifndef COMMON_TYPES_H_
+#define COMMON_TYPES_H_
+
+#include <string>
+#include <vector>
+
+// The types in this file should match Android camera HAL.
+
+struct DeviceInfo {
+  std::string device_path;
+  std::string usb_vid; // USB vender id
+  std::string usb_pid; // USB product id
+  uint32_t lens_facing; // Direction the camera faces relative to device screen.
+  // Clockwise angle through which the output image needs to be rotated to be
+  // upright on the device screen in its native orientation.
+  int32_t sensor_orientation;
+  uint32_t frames_to_skip_after_streamon;
+  float horizontal_view_angle_16_9;
+  float horizontal_view_angle_4_3;
+  std::vector<float> lens_info_available_focal_lengths;
+  float lens_info_minimum_focus_distance;
+  float lens_info_optimal_focus_distance;
+  float vertical_view_angle_16_9;
+  float vertical_view_angle_4_3;
+  // The camera doesn't support 1280x960 resolution when the maximum resolution
+  // of the camear is larger than 1080p.
+  bool resolution_1280x960_unsupported;
+  // The camera doesn't support constant frame rate. That means HAL cannot set
+  // V4L2_CID_EXPOSURE_AUTO_PRIORITY to 0 to have constant frame rate in low
+  // light environment.
+  bool constant_framerate_unsupported;
+};
+
+typedef std::vector<DeviceInfo> DeviceInfos;
+
+struct SupportedFormat {
+  SupportedFormat() {}
+  SupportedFormat(uint32_t w, uint32_t h, uint32_t fmt, uint32_t fps)
+      : width(w), height(h), fourcc(fmt) {
+    frame_rates.push_back(fps);
+  }
+  uint32_t width;
+  uint32_t height;
+  uint32_t fourcc;
+  // All the supported frame rates in fps with given width, height, and
+  // pixelformat. This is not sorted. For example, suppose width, height, and
+  // fourcc are 640x480 YUYV. If frameRates are 15.0 and 30.0, the camera
+  // supports outputting  640X480 YUYV in 15fps or 30fps.
+  std::vector<uint32_t> frame_rates;
+};
+
+typedef std::vector<SupportedFormat> SupportedFormats;
+
+#endif