Merge lp:~morphis/platform-api/add-hybris-compat-layer into lp:platform-api

[Simon Fels]

Adding Android compatibility from libhybris which should not be part of libhybris anymore as its Ubuntu specific and already dropped upstream.

Adding Android compatibility from libhybris which should not be part of libhybris anymore as its Ubuntu specific and already dropped upstream.

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:317
No commit message was specified in the merge proposal. Click on the following link and set the commit message (if you want a jenkins rebuild you need to trigger it yourself):
https://code.launchpad.net/~morphis/platform-api/add-hybris-compat-layer/+merge/281987/+edit-commit-message

http://jenkins.qa.ubuntu.com/job/platform-api-ci/455/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/68/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/68/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/68/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/455/rebuild

review: Needs Fixing (continuous-integration)

[Simon Fels (morphis)]

CI must fail as this depends on newer libhybris/android-headers packages not yet in the overlay ppa or the xenial archive.

[lp:~morphis/platform-api/add-hybris-compat-layer]

318. By Simon Fels on 2016-01-08

Add necessary debian packaging

319. By Simon Fels on 2016-01-08

Correct pkgconfig file references

320. By Simon Fels on 2016-01-08

Add temporary build-dep on libhybris-dev

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:320
http://jenkins.qa.ubuntu.com/job/platform-api-ci/456/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/69/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/69/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/69/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/456/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/platform-api/add-hybris-compat-layer]

321. By Simon Fels on 2016-01-09

Only depend on hybris for platforms its available on

322. By Simon Fels on 2016-01-09

Check correct variable to find out if hybris is available or not

323. By Simon Fels on 2016-01-09

Add arch specifier for android-headers too

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:323
http://jenkins.qa.ubuntu.com/job/platform-api-ci/457/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/70/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/70/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/70/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/457/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/platform-api/add-hybris-compat-layer]

324. By Simon Fels on 2016-01-10

Correct android-headers dependency

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:324
http://jenkins.qa.ubuntu.com/job/platform-api-ci/458/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/71/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/71/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/71/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/458/rebuild

review: Needs Fixing (continuous-integration)

[lp:~morphis/platform-api/add-hybris-compat-layer]

325. By Simon Fels on 2016-01-11

debian: only build on platforms we support

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:325
http://jenkins.qa.ubuntu.com/job/platform-api-ci/459/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-amd64-ci/72/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-armhf-ci/72/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/platform-api-vivid-i386-ci/72/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/platform-api-ci/459/rebuild

review: Needs Fixing (continuous-integration)

Unmerged revisions

325. By Simon Fels on 2016-01-11

debian: only build on platforms we support

324. By Simon Fels on 2016-01-10

Correct android-headers dependency

323. By Simon Fels on 2016-01-09

Add arch specifier for android-headers too

322. By Simon Fels on 2016-01-09

Check correct variable to find out if hybris is available or not

321. By Simon Fels on 2016-01-09

Only depend on hybris for platforms its available on

320. By Simon Fels on 2016-01-08

Add temporary build-dep on libhybris-dev

319. By Simon Fels on 2016-01-08

Correct pkgconfig file references

318. By Simon Fels on 2016-01-08

Add necessary debian packaging

317. By Simon Fels on 2016-01-08

Integrate libhybris compatibility layer

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2015-03-25 23:01:58 +0000
+++ CMakeLists.txt	2016-01-11 14:31:46 +0000
@@ -60,16 +60,15 @@
 find_package(PkgConfig)
 pkg_check_modules(MIRCLIENT REQUIRED mirclient)
 
-# Try to find hybris, and disable hybris from build if not found
-find_library(Hybris
-  NAMES hybris-common
-)
+pkg_check_modules(HYBRIS_COMMON hybris-common)
 
-if(NOT Hybris)
+if(NOT HYBRIS_COMMON_FOUND)
   message(STATUS "Notice: libhybris-common.so not found, disabling hybris support")
   set(ENABLE_HYBRIS_IMPLEMENTATION OFF)
 endif()
 
+pkg_check_modules(ANDROID_HEADERS android-headers)
+
 include_directories(include)
 include_directories(android/include)
 include_directories(

=== added directory 'android/compat'
=== added file 'android/compat/Android.common.mk'
--- android/compat/Android.common.mk	1970-01-01 00:00:00 +0000
+++ android/compat/Android.common.mk	2016-01-11 14:31:46 +0000
@@ -0,0 +1,10 @@
+# define ANDROID_VERSION MAJOR, MINOR and PATCH
+
+ANDROID_VERSION_MAJOR := $(word 1, $(subst ., , $(PLATFORM_VERSION)))
+ANDROID_VERSION_MINOR := $(word 2, $(subst ., , $(PLATFORM_VERSION)))
+ANDROID_VERSION_PATCH := $(word 3, $(subst ., , $(PLATFORM_VERSION)))
+
+LOCAL_CFLAGS += \
+	-DANDROID_VERSION_MAJOR=$(ANDROID_VERSION_MAJOR) \
+	-DANDROID_VERSION_MINOR=$(ANDROID_VERSION_MINOR) \
+	-DANDROID_VERSION_PATCH=$(ANDROID_VERSION_PATCH)

=== added directory 'android/compat/camera'
=== added file 'android/compat/camera/Android.mk'
--- android/compat/camera/Android.mk	1970-01-01 00:00:00 +0000
+++ android/compat/camera/Android.mk	2016-01-11 14:31:46 +0000
@@ -0,0 +1,58 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
+
+LOCAL_SRC_FILES := camera_compatibility_layer.cpp
+
+LOCAL_MODULE := libcamera_compat_layer
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include
+
+LOCAL_SHARED_LIBRARIES := \
+	libcutils \
+	libcamera_client \
+	libutils \
+	libbinder \
+	libhardware \
+	libui \
+	libgui
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+
+HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
+
+LOCAL_SRC_FILES := direct_camera_test.cpp
+
+LOCAL_MODULE := direct_camera_test
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include \
+	bionic \
+	bionic/libstdc++/include \
+	external/gtest/include \
+	external/stlport/stlport \
+	external/skia/include/core \
+
+LOCAL_SHARED_LIBRARIES := \
+	libis_compat_layer \
+	libsf_compat_layer \
+	libcamera_compat_layer \
+	libmedia_compat_layer \
+	libcutils \
+	libcamera_client \
+	libutils \
+	libbinder \
+	libhardware \
+	libui \
+	libgui \
+	libEGL \
+	libGLESv2
+
+include $(BUILD_EXECUTABLE)

=== added file 'android/compat/camera/camera_compatibility_layer.cpp'
--- android/compat/camera/camera_compatibility_layer.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/camera/camera_compatibility_layer.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,1016 @@
+/*
+ * Copyright (C) 2013-2014 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *				Ricardo Salveti de Araujo <[e-mail]>
+ *				Jim Hodapp <[e-mail]>
+ */
+
+//#define LOG_NDEBUG 0
+
+#include <hybris/internal/camera_control.h>
+#include <hybris/camera/camera_compatibility_layer.h>
+#include <hybris/camera/camera_compatibility_layer_capabilities.h>
+#include <hybris/camera/camera_compatibility_layer_configuration_translator.h>
+
+#include <hybris/internal/surface_flinger_compatibility_layer_internal.h>
+
+#include <binder/ProcessState.h>
+#include <camera/Camera.h>
+#include <camera/CameraParameters.h>
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+#include <gui/SurfaceTexture.h>
+#else
+#include <gui/GLConsumer.h>
+#endif
+#if ANDROID_VERSION_MAJOR==5
+#include <gui/IGraphicBufferProducer.h>
+#endif
+#include <ui/GraphicBuffer.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#undef LOG_TAG
+#define LOG_TAG "CameraCompatibilityLayer"
+#include <utils/Debug.h>
+#include <utils/Errors.h>
+#include <utils/KeyedVector.h>
+#include <utils/Log.h>
+#include <utils/String16.h>
+
+#include <gui/NativeBufferAlloc.h>
+
+#include <cstring>
+
+#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
+
+using android::CompileTimeAssert; // So COMPILE_TIME_ASSERT works
+
+// From android::GLConsumer::FrameAvailableListener
+#if ANDROID_VERSION_MAJOR==5 && ANDROID_VERSION_MINOR>=1
+  void CameraControl::onFrameAvailable(const android::BufferItem& item)
+#else
+  void CameraControl::onFrameAvailable()
+#endif
+{
+	REPORT_FUNCTION();
+	if (listener)
+		listener->on_preview_texture_needs_update_cb(listener->context);
+}
+
+// From android::CameraListener
+void CameraControl::notify(int32_t msg_type, int32_t ext1, int32_t ext2)
+{
+	REPORT_FUNCTION();
+	printf("\text1: %d, ext2: %d \n", ext1, ext2);
+
+	if (!listener)
+		return;
+
+	switch (msg_type) {
+	case CAMERA_MSG_ERROR:
+		if (listener->on_msg_error_cb)
+			listener->on_msg_error_cb(listener->context);
+		break;
+	case CAMERA_MSG_SHUTTER:
+		if (listener->on_msg_shutter_cb)
+			listener->on_msg_shutter_cb(listener->context);
+		break;
+	case CAMERA_MSG_ZOOM:
+		if (listener->on_msg_zoom_cb)
+			listener->on_msg_zoom_cb(listener->context, ext1);
+		break;
+	case CAMERA_MSG_FOCUS:
+		if (listener->on_msg_focus_cb)
+			listener->on_msg_focus_cb(listener->context);
+		break;
+	default:
+		break;
+	}
+}
+
+void CameraControl::postData(
+		int32_t msg_type,
+		const android::sp<android::IMemory>& data,
+		camera_frame_metadata_t* metadata)
+{
+	REPORT_FUNCTION();
+
+	if (!listener)
+		return;
+
+	switch (msg_type) {
+	case CAMERA_MSG_RAW_IMAGE:
+		if (listener->on_data_raw_image_cb)
+			listener->on_data_raw_image_cb(data->pointer(), data->size(), listener->context);
+		break;
+	case CAMERA_MSG_COMPRESSED_IMAGE:
+		if (listener->on_data_compressed_image_cb)
+			listener->on_data_compressed_image_cb(data->pointer(), data->size(), listener->context);
+		break;
+	case CAMERA_MSG_PREVIEW_FRAME:
+		if (listener->on_preview_frame_cb)
+			listener->on_preview_frame_cb(data->pointer(), data->size(), listener->context);
+	default:
+		break;
+	}
+}
+
+void CameraControl::postDataTimestamp(
+		nsecs_t timestamp,
+		int32_t msg_type,
+		const android::sp<android::IMemory>& data)
+{
+	REPORT_FUNCTION();
+	(void) timestamp;
+	(void) msg_type;
+	(void) data;
+}
+
+namespace android
+{
+NativeBufferAlloc::NativeBufferAlloc() {
+}
+
+NativeBufferAlloc::~NativeBufferAlloc() {
+}
+
+sp<GraphicBuffer> NativeBufferAlloc::createGraphicBuffer(uint32_t w, uint32_t h,
+		PixelFormat format, uint32_t usage, status_t* error) {
+	sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(w, h, format, usage));
+	status_t err = graphicBuffer->initCheck();
+	*error = err;
+	if (err != 0 || graphicBuffer->handle == 0) {
+		if (err == NO_MEMORY) {
+			GraphicBuffer::dumpAllocationsToSystemLog();
+		}
+		ALOGI("GraphicBufferAlloc::createGraphicBuffer(w=%d, h=%d) "
+				"failed (%s), handle=%p",
+				w, h, strerror(-err), graphicBuffer->handle);
+		return 0;
+	}
+	return graphicBuffer;
+}
+}
+
+int android_camera_get_number_of_devices()
+{
+	REPORT_FUNCTION();
+	return android::Camera::getNumberOfCameras();
+}
+
+int android_camera_get_device_info(int32_t camera_id, int* facing, int* orientation)
+{
+	REPORT_FUNCTION();
+
+	if (!facing || !orientation)
+		return android::BAD_VALUE;
+
+	COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CAMERA_FACING_BACK == static_cast<int>(BACK_FACING_CAMERA_TYPE));
+	COMPILE_TIME_ASSERT_FUNCTION_SCOPE(CAMERA_FACING_FRONT == static_cast<int>(FRONT_FACING_CAMERA_TYPE));
+
+	android::CameraInfo ci;
+
+	int rv = android::Camera::getCameraInfo(camera_id, &ci);
+	if (rv != android::OK)
+		return rv;
+
+	*facing = ci.facing;
+	*orientation = ci.orientation;
+
+	return android::OK;
+}
+
+CameraControl* android_camera_connect_to(CameraType camera_type, CameraControlListener* listener)
+{
+	REPORT_FUNCTION();
+
+	const int32_t camera_count = android::Camera::getNumberOfCameras();
+
+	for (int32_t camera_id = 0; camera_id < camera_count; camera_id++) {
+		android::CameraInfo ci;
+		android::Camera::getCameraInfo(camera_id, &ci);
+
+		if (ci.facing != camera_type)
+			continue;
+
+		return android_camera_connect_by_id(camera_id, listener);
+	}
+
+	return NULL;
+}
+
+CameraControl* android_camera_connect_by_id(int32_t camera_id, struct CameraControlListener* listener)
+{
+	if (camera_id < 0 || camera_id >= android::Camera::getNumberOfCameras())
+		return NULL;
+
+	android::sp<CameraControl> cc = new CameraControl();
+	cc->listener = listener;
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR>=3 || ANDROID_VERSION_MAJOR==5
+	cc->camera = android::Camera::connect(camera_id, android::String16("hybris"), android::Camera::USE_CALLING_UID);
+#else
+	cc->camera = android::Camera::connect(camera_id);
+#endif
+
+	if (cc->camera == NULL)
+		return NULL;
+
+	cc->camera_parameters = android::CameraParameters(cc->camera->getParameters());
+
+	// android::Camera holds a strong reference to the listener, keeping
+	// |cc| alive
+	cc->camera->setListener(cc);
+	cc->camera->lock();
+
+	// TODO: Move this to a more generic component
+	android::ProcessState::self()->startThreadPool();
+
+	return cc.get();
+}
+
+void android_camera_disconnect(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	if (control->preview_texture != NULL)
+		control->preview_texture->abandon();
+
+	control->camera->disconnect();
+	control->camera->unlock();
+}
+
+int android_camera_lock(CameraControl* control)
+{
+	android::Mutex::Autolock al(control->guard);
+	return control->camera->lock();
+}
+
+int android_camera_unlock(CameraControl* control)
+{
+	android::Mutex::Autolock al(control->guard);
+	return control->camera->unlock();
+}
+
+void android_camera_delete(CameraControl* control)
+{
+	android::sp<android::Camera> camera = control->camera;
+	control->camera.clear();
+	camera.clear();
+}
+
+void android_camera_dump_parameters(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	printf("%s \n", control->camera->getParameters().string());
+}
+
+void android_camera_set_flash_mode(CameraControl* control, FlashMode mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_FLASH_MODE,
+			flash_modes[mode]);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_flash_mode(CameraControl* control, FlashMode* mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	static const char* flash_mode = control->camera_parameters.get(
+			android::CameraParameters::KEY_FLASH_MODE);
+	if (flash_mode)
+		*mode = flash_modes_lut.valueFor(android::String8(flash_mode));
+	else
+		*mode = FLASH_MODE_OFF;
+}
+
+void android_camera_enumerate_supported_flash_modes(CameraControl* control, flash_mode_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	android::String8 raw_modes;
+	raw_modes = android::String8(
+			control->camera_parameters.get(
+				android::CameraParameters::KEY_SUPPORTED_FLASH_MODES));
+
+	const char delimiter[2] = ",";
+	char *token;
+	android::String8 mode;
+	char *raw_modes_mutable = strdup(raw_modes.string());
+
+	token = strtok(raw_modes_mutable, delimiter);
+
+	while (token != NULL) {
+		uint32_t index = flash_modes_lut.indexOfKey(mode);
+
+		mode = android::String8(token);
+		if (flash_modes_lut.indexOfKey(mode) >= 0) {
+			cb(ctx, flash_modes_lut.valueFor(mode));
+		}
+		token = strtok(NULL, delimiter);
+	}
+}
+
+void android_camera_set_white_balance_mode(CameraControl* control, WhiteBalanceMode mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_WHITE_BALANCE,
+			white_balance_modes[mode]);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_white_balance_mode(CameraControl* control, WhiteBalanceMode* mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*mode = white_balance_modes_lut.valueFor(
+			android::String8(
+				control->camera_parameters.get(
+					android::CameraParameters::KEY_WHITE_BALANCE)));
+}
+
+void android_camera_set_scene_mode(CameraControl* control, SceneMode mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_SCENE_MODE,
+			scene_modes[mode]);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_enumerate_supported_scene_modes(CameraControl* control, scene_mode_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	android::String8 raw_modes;
+	raw_modes = android::String8(
+					control->camera_parameters.get(
+						android::CameraParameters::KEY_SUPPORTED_SCENE_MODES));
+
+	const char delimiter[2] = ",";
+	char *token;
+	android::String8 mode;
+	char *raw_modes_mutable = strdup(raw_modes.string());
+
+	token = strtok(raw_modes_mutable, delimiter);
+
+	while (token != NULL) {
+		mode = android::String8(token);
+		cb(ctx, scene_modes_lut.valueFor(mode));
+		token = strtok(NULL, delimiter);
+	}
+}
+
+void android_camera_get_scene_mode(CameraControl* control, SceneMode* mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*mode = scene_modes_lut.valueFor(
+			android::String8(
+				control->camera_parameters.get(
+					android::CameraParameters::KEY_SCENE_MODE)));
+}
+
+void android_camera_set_auto_focus_mode(CameraControl* control, AutoFocusMode mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_FOCUS_MODE,
+			auto_focus_modes[mode]);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_auto_focus_mode(CameraControl* control, AutoFocusMode* mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*mode = auto_focus_modes_lut.valueFor(
+			android::String8(
+				control->camera_parameters.get(
+					android::CameraParameters::KEY_FOCUS_MODE)));
+}
+
+
+void android_camera_set_effect_mode(CameraControl* control, EffectMode mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_EFFECT,
+			effect_modes[mode]);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_effect_mode(CameraControl* control, EffectMode* mode)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*mode = effect_modes_lut.valueFor(
+			android::String8(
+				control->camera_parameters.get(
+					android::CameraParameters::KEY_EFFECT)));
+}
+
+void android_camera_get_preview_fps_range(CameraControl* control, int* min, int* max)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.getPreviewFpsRange(min, max);
+}
+
+void android_camera_set_preview_fps(CameraControl* control, int fps)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera_parameters.setPreviewFrameRate(fps);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_preview_fps(CameraControl* control, int* fps)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	*fps = control->camera_parameters.getPreviewFrameRate();
+}
+
+void android_camera_enumerate_supported_preview_sizes(CameraControl* control, size_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	android::Vector<android::Size> sizes;
+	control->camera_parameters.getSupportedPreviewSizes(sizes);
+
+	for (unsigned int i = 0; i < sizes.size(); i++) {
+		cb(ctx, sizes[i].width, sizes[i].height);
+	}
+}
+
+void android_camera_enumerate_supported_picture_sizes(CameraControl* control, size_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	android::Vector<android::Size> sizes;
+	control->camera_parameters.getSupportedPictureSizes(sizes);
+
+	for (unsigned int i = 0; i < sizes.size(); i++) {
+		cb(ctx, sizes[i].width, sizes[i].height);
+	}
+}
+
+void android_camera_get_preview_size(CameraControl* control, int* width, int* height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.getPreviewSize(width, height);
+}
+
+void android_camera_set_preview_size(CameraControl* control, int width, int height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.setPreviewSize(width, height);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_picture_size(CameraControl* control, int* width, int* height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.getPictureSize(width, height);
+}
+
+void android_camera_set_thumbnail_size(struct CameraControl* control, int width, int height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH,
+			width);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT,
+			height);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_thumbnail_size(struct CameraControl* control, int* width, int* height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*width = atoi(control->camera_parameters.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_WIDTH));
+	*height = atoi(control->camera_parameters.get(android::CameraParameters::KEY_JPEG_THUMBNAIL_HEIGHT));
+}
+
+void android_camera_enumerate_supported_thumbnail_sizes(struct CameraControl* control, size_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	// e.g. 800x600,320x240
+	android::String8 sizes = android::String8(
+			control->camera_parameters.get(
+				android::CameraParameters::KEY_SUPPORTED_JPEG_THUMBNAIL_SIZES));
+
+	const char delimiter[2] = ",";
+	const char size_delimiter[2] = "x";
+	char *token, *save_ptr, *save_ptr1;
+	int height = 0, width = 0;
+	char *sizes_mutable = strdup(sizes.string());
+
+	ALOGD("Supported thumbnail sizes: %s", sizes.string());
+	// Get the first <width>x<height to the left of ','
+	token = strtok_r(sizes_mutable, delimiter, &save_ptr);
+
+	while (token != NULL) {
+		// Parse <width>x<height> token
+		char *w = strtok_r(token, size_delimiter, &save_ptr1);
+		char *h = strtok_r(NULL, size_delimiter, &save_ptr1);
+		width = atoi(w);
+		height = atoi(h);
+		if (width > 0 && height > 0)
+			cb(ctx, width, height);
+		// Get the next <width>x<height> pair
+		token = strtok_r(NULL, delimiter, &save_ptr);
+	}
+}
+
+void android_camera_set_picture_size(CameraControl* control, int width, int height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.setPictureSize(width, height);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_current_zoom(CameraControl* control, int* zoom)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*zoom = control->camera_parameters.getInt(android::CameraParameters::KEY_ZOOM);
+}
+
+void android_camera_get_max_zoom(CameraControl* control, int* zoom)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*zoom = control->camera_parameters.getInt(android::CameraParameters::KEY_MAX_ZOOM);
+}
+
+void android_camera_set_display_orientation(CameraControl* control, int32_t clockwise_rotation_degree)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	static const int32_t ignored_parameter = 0;
+	control->camera->sendCommand(CAMERA_CMD_SET_DISPLAY_ORIENTATION, clockwise_rotation_degree, ignored_parameter);
+}
+
+void android_camera_get_preview_texture_transformation(CameraControl* control, float m[16])
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	if (control->preview_texture == NULL)
+		return;
+
+	control->preview_texture->getTransformMatrix(m);
+}
+
+void android_camera_update_preview_texture(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	control->preview_texture->updateTexImage();
+}
+
+void android_camera_set_preview_texture(CameraControl* control, int texture_id)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	static const bool allow_synchronous_mode = false;
+	static const bool is_controlled_by_app = true;
+
+	android::sp<android::NativeBufferAlloc> native_alloc(
+			new android::NativeBufferAlloc()
+			);
+
+#if ANDROID_VERSION_MAJOR==5
+	android::sp<android::IGraphicBufferProducer> producer;
+	android::sp<android::IGraphicBufferConsumer> consumer;
+	android::BufferQueue::createBufferQueue(&producer, &consumer);
+#else
+	android::sp<android::BufferQueue> buffer_queue(
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
+			new android::BufferQueue(false, NULL, native_alloc)
+#else
+			new android::BufferQueue(NULL)
+#endif
+			);
+#endif
+
+	if (control->preview_texture == NULL) {
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+		control->preview_texture = android::sp<android::SurfaceTexture>(
+				new android::SurfaceTexture(
+#else
+		control->preview_texture = android::sp<android::GLConsumer>(
+				new android::GLConsumer(
+#endif
+#if ANDROID_VERSION_MAJOR==5
+					consumer,
+					texture_id,
+					GL_TEXTURE_EXTERNAL_OES,
+					true,
+					is_controlled_by_app));
+#elif ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
+					texture_id,
+					allow_synchronous_mode,
+					GL_TEXTURE_EXTERNAL_OES,
+					true,
+					buffer_queue));
+#else
+					buffer_queue,
+					texture_id,
+					GL_TEXTURE_EXTERNAL_OES,
+					true,
+					is_controlled_by_app));
+#endif
+	}
+
+	control->preview_texture->setFrameAvailableListener(
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+			android::sp<android::SurfaceTexture::FrameAvailableListener>(control));
+#else
+			android::sp<android::GLConsumer::FrameAvailableListener>(control));
+#endif
+
+#if ANDROID_VERSION_MAJOR==5
+	control->camera->setPreviewTarget(producer);
+#elif ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
+	control->camera->setPreviewTexture(control->preview_texture->getBufferQueue());
+#else
+	control->camera->setPreviewTarget(buffer_queue);
+#endif
+}
+
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+void android_camera_set_preview_surface(CameraControl* control, SfSurface* surface)
+{
+	REPORT_FUNCTION();
+	assert(control);
+	assert(surface);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->setPreviewDisplay(surface->surface);
+}
+#endif
+
+void android_camera_start_preview(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->startPreview();
+}
+
+void android_camera_stop_preview(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->stopPreview();
+}
+
+void android_camera_start_autofocus(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->autoFocus();
+}
+
+void android_camera_stop_autofocus(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->cancelAutoFocus();
+}
+
+void android_camera_start_zoom(CameraControl* control, int32_t zoom)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	static const int ignored_argument = 0;
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->sendCommand(CAMERA_CMD_START_SMOOTH_ZOOM,
+			zoom,
+			ignored_argument);
+}
+
+// Adjust the zoom level immediately as opposed to smoothly zoomin gin.
+void android_camera_set_zoom(CameraControl* control, int32_t zoom)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_ZOOM,
+			zoom);
+
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_stop_zoom(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	static const int ignored_argument = 0;
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera->sendCommand(CAMERA_CMD_STOP_SMOOTH_ZOOM,
+			ignored_argument,
+			ignored_argument);
+}
+
+void android_camera_take_snapshot(CameraControl* control)
+{
+	REPORT_FUNCTION();
+	assert(control);
+	android::Mutex::Autolock al(control->guard);
+	control->camera->takePicture(CAMERA_MSG_SHUTTER | CAMERA_MSG_COMPRESSED_IMAGE);
+}
+
+int android_camera_set_preview_callback_mode(CameraControl* control, PreviewCallbackMode mode)
+{
+	REPORT_FUNCTION();
+
+	if (!control)
+		return android::BAD_VALUE;
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera->setPreviewCallbackFlags(
+		mode == PREVIEW_CALLBACK_ENABLED ?
+			CAMERA_FRAME_CALLBACK_FLAG_CAMCORDER : CAMERA_FRAME_CALLBACK_FLAG_NOOP);
+
+	return android::OK;
+}
+
+void android_camera_set_preview_format(CameraControl* control, CameraPixelFormat pf)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_PREVIEW_FORMAT,
+			camera_pixel_formats[pf]);
+
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_preview_format(CameraControl* control, CameraPixelFormat* pf)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	*pf = pixel_formats_lut.valueFor(
+			android::String8(
+				control->camera_parameters.get(
+					android::CameraParameters::KEY_PREVIEW_FORMAT)));
+}
+
+void android_camera_set_focus_region(
+		CameraControl* control,
+		FocusRegion* region)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	static const char* focus_region_pattern = "(%d,%d,%d,%d,%d)";
+	static char focus_region[256];
+	snprintf(focus_region,
+			sizeof(focus_region),
+			focus_region_pattern,
+			region->left,
+			region->top,
+			region->right,
+			region->bottom,
+			region->weight);
+
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_FOCUS_AREAS,
+			focus_region);
+
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_reset_focus_region(CameraControl* control)
+{
+	static FocusRegion region = { 0, 0, 0, 0, 0 };
+
+	android_camera_set_focus_region(control, &region);
+}
+
+void android_camera_set_rotation(CameraControl* control, int rotation)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_ROTATION,
+			rotation);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_set_location(CameraControl* control, const float* latitude, const float* longitude, const float* altitude, int timestamp, const char* method)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera_parameters.setFloat(
+			android::CameraParameters::KEY_GPS_LATITUDE,
+			*latitude);
+	control->camera_parameters.setFloat(
+			android::CameraParameters::KEY_GPS_LONGITUDE,
+			*longitude);
+	control->camera_parameters.setFloat(
+			android::CameraParameters::KEY_GPS_ALTITUDE,
+			*altitude);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_GPS_TIMESTAMP,
+			timestamp);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_GPS_PROCESSING_METHOD,
+			method);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_enumerate_supported_video_sizes(CameraControl* control, size_callback cb, void* ctx)
+{
+	REPORT_FUNCTION();
+	assert(control);
+	assert(cb);
+
+	android::Mutex::Autolock al(control->guard);
+	android::Vector<android::Size> sizes;
+	control->camera_parameters.getSupportedVideoSizes(sizes);
+
+	for (unsigned int i = 0; i < sizes.size(); i++) {
+		cb(ctx, sizes[i].width, sizes[i].height);
+	}
+}
+
+void android_camera_get_video_size(CameraControl* control, int* width, int* height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.getVideoSize(width, height);
+}
+
+void android_camera_set_video_size(CameraControl* control, int width, int height)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+
+	control->camera_parameters.setVideoSize(width, height);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_set_jpeg_quality(CameraControl* control, int quality)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	control->camera_parameters.set(
+			android::CameraParameters::KEY_JPEG_QUALITY,
+			quality);
+	control->camera->setParameters(control->camera_parameters.flatten());
+}
+
+void android_camera_get_jpeg_quality(CameraControl* control, int* quality)
+{
+	REPORT_FUNCTION();
+	assert(control);
+
+	android::Mutex::Autolock al(control->guard);
+	*quality = atoi(control->camera_parameters.get(
+            android::CameraParameters::KEY_JPEG_QUALITY));
+}

=== added file 'android/compat/camera/direct_camera_test.cpp'
--- android/compat/camera/direct_camera_test.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/camera/direct_camera_test.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,683 @@
+/*
+ * Copyright (C) 2013-2014 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *				Ricardo Salveti de Araujo <[e-mail]>
+ *				Jim Hodapp <[e-mail]>
+ */
+
+#include <hybris/camera/camera_compatibility_layer.h>
+#include <hybris/camera/camera_compatibility_layer_capabilities.h>
+#include <hybris/media/media_recorder_layer.h>
+
+#include <hybris/input/input_stack_compatibility_layer.h>
+#include <hybris/input/input_stack_compatibility_layer_codes_key.h>
+#include <hybris/input/input_stack_compatibility_layer_flags_key.h>
+#include <hybris/input/input_stack_compatibility_layer_flags_motion.h>
+
+#include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
+
+#include <gui/ISurfaceComposer.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+int shot_counter = 1;
+int32_t current_zoom_level = 1;
+bool new_camera_frame_available = true;
+static CameraControl* camera_control = NULL;
+int camera_width = 0, camera_height = 0;
+int thumbnail_width = 0, thumbnail_height = 0;
+static MediaRecorderWrapper *recorder = NULL;
+bool recording = false;
+
+EffectMode next_effect()
+{
+	static EffectMode current_effect = EFFECT_MODE_NONE;
+
+	EffectMode next = current_effect;
+
+	switch (current_effect) {
+	case EFFECT_MODE_NONE:
+		next = EFFECT_MODE_MONO;
+		break;
+	case EFFECT_MODE_MONO:
+		next = EFFECT_MODE_NEGATIVE;
+		break;
+	case EFFECT_MODE_NEGATIVE:
+		next = EFFECT_MODE_SOLARIZE;
+		break;
+	case EFFECT_MODE_SOLARIZE:
+		next = EFFECT_MODE_SEPIA;
+		break;
+	case EFFECT_MODE_SEPIA:
+		next = EFFECT_MODE_POSTERIZE;
+		break;
+	case EFFECT_MODE_POSTERIZE:
+		next = EFFECT_MODE_WHITEBOARD;
+		break;
+	case EFFECT_MODE_WHITEBOARD:
+		next = EFFECT_MODE_BLACKBOARD;
+		break;
+	case EFFECT_MODE_BLACKBOARD:
+		next = EFFECT_MODE_AQUA;
+		break;
+	case EFFECT_MODE_AQUA:
+		next = EFFECT_MODE_NONE;
+		break;
+	}
+
+	current_effect = next;
+	return next;
+}
+
+void error_msg_cb(void* context)
+{
+	printf("%s \n", __PRETTY_FUNCTION__);
+}
+
+void shutter_msg_cb(void* context)
+{
+	printf("%s \n", __PRETTY_FUNCTION__);
+}
+
+void zoom_msg_cb(void* context, int32_t new_zoom_level)
+{
+	printf("%s \n", __PRETTY_FUNCTION__);
+
+	CameraControl* cc = static_cast<CameraControl*>(context);
+	static int zoom;
+	android_camera_get_current_zoom(cc, &zoom);
+	printf("\t Current zoom: %d\n", zoom);
+	current_zoom_level = new_zoom_level;
+}
+
+void autofocus_msg_cb(void* context)
+{
+	printf("%s \n", __PRETTY_FUNCTION__);
+}
+
+void raw_data_cb(void* data, uint32_t data_size, void* context)
+{
+	printf("%s: %d \n", __PRETTY_FUNCTION__, data_size);
+}
+
+void jpeg_data_cb(void* data, uint32_t data_size, void* context)
+{
+	printf("%s: %d \n", __PRETTY_FUNCTION__, data_size);
+
+	char fn[256];
+	sprintf(fn, "/cache/shot_%d.jpeg", shot_counter);
+	int fd = open(fn, O_RDWR | O_CREAT, S_IRUSR | S_IWUSR | S_IRGRP | S_IWGRP | S_IROTH);
+	write(fd, data, data_size);
+	close(fd);
+	shot_counter++;
+
+	CameraControl* cc = static_cast<CameraControl*>(context);
+	android_camera_start_preview(cc);
+}
+
+void size_cb(void* ctx, int width, int height)
+{
+	printf("Supported size: [%d,%d]\n", width, height);
+	if (width == 1024 && height == 768) {
+		camera_width = 1024;
+		camera_height = 768;
+	}
+}
+
+void thumbnail_size_cb(void* ctx, int width, int height)
+{
+	static bool do_once = true;
+	printf("Supported thumbnail size: [%d,%d]\n", width, height);
+	if (do_once) {
+		printf("Selecting thumbnail size: [%dx%d]\n", width, height);
+		thumbnail_width = width;
+		thumbnail_height = height;
+	}
+}
+
+struct RenderData
+{
+	static const char* vertex_shader()
+	{
+		return
+			"#extension GL_OES_EGL_image_external : require				 \n"
+			"attribute vec4 a_position;									 \n"
+			"attribute vec2 a_texCoord;									 \n"
+			"uniform mat4 m_texMatrix;									 \n"
+			"varying vec2 v_texCoord;									 \n"
+			"varying float topDown;										 \n"
+			"void main()												 \n"
+			"{															 \n"
+			"	gl_Position = a_position;								 \n"
+			"	v_texCoord = a_texCoord;								 \n"
+			//				  "   v_texCoord = (m_texMatrix * vec4(a_texCoord, 0.0, 1.0)).xy;\n"
+			//"   topDown = v_texCoord.y;								   \n"
+			"}															 \n";
+	}
+
+	static const char* fragment_shader()
+	{
+		return
+			"#extension GL_OES_EGL_image_external : require		 \n"
+			"precision mediump float;							 \n"
+			"varying vec2 v_texCoord;							 \n"
+			"uniform samplerExternalOES s_texture;				 \n"
+			"void main()										 \n"
+			"{													 \n"
+			"  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
+			"}													 \n";
+	}
+
+	static GLuint loadShader(GLenum shaderType, const char* pSource)
+	{
+		GLuint shader = glCreateShader(shaderType);
+
+		if (shader) {
+			glShaderSource(shader, 1, &pSource, NULL);
+			glCompileShader(shader);
+			GLint compiled = 0;
+			glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+
+			if (!compiled) {
+				GLint infoLen = 0;
+				glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+				if (infoLen) {
+					char* buf = (char*) malloc(infoLen);
+					if (buf) {
+						glGetShaderInfoLog(shader, infoLen, NULL, buf);
+						fprintf(stderr, "Could not compile shader %d:\n%s\n",
+								shaderType, buf);
+						free(buf);
+					}
+					glDeleteShader(shader);
+					shader = 0;
+				}
+			}
+		} else {
+			printf("Error, during shader creation: %i\n", glGetError());
+		}
+
+		return shader;
+	}
+
+	static GLuint create_program(const char* pVertexSource, const char* pFragmentSource)
+	{
+		GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
+		if (!vertexShader) {
+			printf("vertex shader not compiled\n");
+			return 0;
+		}
+
+		GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
+		if (!pixelShader) {
+			printf("frag shader not compiled\n");
+			return 0;
+		}
+
+		GLuint program = glCreateProgram();
+		if (program) {
+			glAttachShader(program, vertexShader);
+			glAttachShader(program, pixelShader);
+			glLinkProgram(program);
+			GLint linkStatus = GL_FALSE;
+			glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+
+			if (linkStatus != GL_TRUE) {
+				GLint bufLength = 0;
+				glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
+				if (bufLength) {
+					char* buf = (char*) malloc(bufLength);
+					if (buf) {
+						glGetProgramInfoLog(program, bufLength, NULL, buf);
+						fprintf(stderr, "Could not link program:\n%s\n", buf);
+						free(buf);
+					}
+				}
+				glDeleteProgram(program);
+				program = 0;
+			}
+		}
+
+		return program;
+	}
+
+	RenderData() : program_object(create_program(vertex_shader(), fragment_shader()))
+	{
+		position_loc = glGetAttribLocation(program_object, "a_position");
+		tex_coord_loc = glGetAttribLocation(program_object, "a_texCoord");
+		sampler_loc = glGetUniformLocation(program_object, "s_texture");
+		matrix_loc = glGetUniformLocation(program_object, "m_texMatrix");
+	}
+
+	// Handle to a program object
+	GLuint program_object;
+	// Attribute locations
+	GLint  position_loc;
+	GLint  tex_coord_loc;
+	// Sampler location
+	GLint sampler_loc;
+	// Matrix location
+	GLint matrix_loc;
+};
+
+
+static RenderData render_data;
+static EGLDisplay disp;
+static EGLSurface surface;
+
+void preview_texture_needs_update_cb(void* ctx)
+{
+	ALOGD("Updating preview texture");
+	new_camera_frame_available = true;
+	static GLfloat vVertices[] = { 0.0f, 0.0f, 0.0f, // Position 0
+		0.0f, 0.0f, // TexCoord 0
+		0.0f, 1.0f, 0.0f, // Position 1
+		0.0f, 1.0f, // TexCoord 1
+		1.0f, 1.0f, 0.0f, // Position 2
+		1.0f, 1.0f, // TexCoord 2
+		1.0f, 0.0f, 0.0f, // Position 3
+		1.0f, 0.0f // TexCoord 3
+	};
+
+	GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
+
+	// Set the viewport
+	// Clear the color buffer
+	glClear(GL_COLOR_BUFFER_BIT);
+	// Use the program object
+	glUseProgram(render_data.program_object);
+	// Enable attributes
+	glEnableVertexAttribArray(render_data.position_loc);
+	glEnableVertexAttribArray(render_data.tex_coord_loc);
+	// Load the vertex position
+	glVertexAttribPointer(render_data.position_loc,
+			3,
+			GL_FLOAT,
+			GL_FALSE,
+			5 * sizeof(GLfloat),
+			vVertices);
+	// Load the texture coordinate
+	glVertexAttribPointer(render_data.tex_coord_loc,
+			2,
+			GL_FLOAT,
+			GL_FALSE,
+			5 * sizeof(GLfloat),
+			vVertices+3);
+
+	glActiveTexture(GL_TEXTURE0);
+	// Set the sampler texture unit to 0
+	glUniform1i(render_data.sampler_loc, 0);
+	glUniform1i(render_data.matrix_loc, 0);
+	ALOGD("Updating the preview texture");
+	if (camera_control != NULL)
+		android_camera_update_preview_texture(camera_control);
+	glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
+	glDisableVertexAttribArray(render_data.position_loc);
+	glDisableVertexAttribArray(render_data.tex_coord_loc);
+
+	eglSwapBuffers(disp, surface);
+}
+
+static void errorCB(void *context)
+{
+	ALOGE("Error while recording.");
+}
+
+static MediaRecorderWrapper *start_video_recording(CameraControl *camera_control)
+{
+	int ret = 0;
+	struct MediaRecorderWrapper *recorder = android_media_new_recorder();
+	android_recorder_set_error_cb(recorder, &errorCB, NULL);
+
+	ALOGD("Unlocking camera");
+	android_camera_unlock(camera_control);
+	if (recorder == NULL)
+		ALOGW("recorder is NULL: %d", __LINE__);
+
+	ret = android_recorder_setCamera(recorder, camera_control);
+	if (ret < 0) {
+		ALOGE("android_recorder_setCamera() failed");
+		return NULL;
+	}
+	ret = android_recorder_setAudioSource(recorder, ANDROID_AUDIO_SOURCE_CAMCORDER);
+	if (ret < 0) {
+		ALOGE("android_recorder_setAudioSource() failed");
+		return NULL;
+	}
+	ret = android_recorder_setVideoSource(recorder, ANDROID_VIDEO_SOURCE_CAMERA);
+	if (ret < 0) {
+		ALOGE("android_recorder_setVideoSource() failed");
+		return NULL;
+	}
+	ret = android_recorder_setOutputFormat(recorder, ANDROID_OUTPUT_FORMAT_MPEG_4);
+	if (ret < 0) {
+		ALOGE("android_recorder_setOutputFormat() failed");
+		return NULL;
+	}
+	ret = android_recorder_setAudioEncoder(recorder, ANDROID_AUDIO_ENCODER_AAC);
+	if (ret < 0) {
+		ALOGE("android_recorder_setAudioEncoder() failed");
+		return NULL;
+	}
+	ret = android_recorder_setVideoEncoder(recorder, ANDROID_VIDEO_ENCODER_H264);
+	if (ret < 0) {
+		ALOGE("android_recorder_setVideoEncoder() failed");
+		return NULL;
+	}
+	int fd = -1;
+	char *out_file = "/cache/test_recording.mp4";
+	fd = open(out_file, O_WRONLY | O_CREAT,
+			  S_IRUSR | S_IWUSR | S_IRGRP | S_IROTH);
+	if (fd < 0) {
+		ALOGE("Couldn't open output video file for recording: %s", out_file);
+		return NULL;
+	}
+	ret = android_recorder_setOutputFile(recorder, fd);
+	if (ret < 0) {
+		ALOGE("android_recorder_setOutputFile() failed");
+		return NULL;
+	}
+	ret = android_recorder_setVideoSize(recorder, camera_width, camera_height);
+	if (ret < 0) {
+		ALOGE("android_recorder_setVideoSize() failed");
+		return NULL;
+	}
+	ret = android_recorder_setVideoFrameRate(recorder, 30);
+	if (ret < 0) {
+		ALOGE("android_recorder_setVideoFrameRate() failed");
+		return NULL;
+	}
+	android_recorder_setParameters(recorder, "video-param-encoding-bitrate=5505024"); // 7*1024*768
+	android_recorder_setParameters(recorder, "audio-param-encoding-bitrate=48000");
+	android_recorder_setParameters(recorder, "audio-param-number-of-channels=2");
+	android_recorder_setParameters(recorder, "audio-param-sampling-rate=96000");
+	android_recorder_setParameters(recorder, "video-param-rotation-angle-degrees=90");
+	ALOGD("Preparing video recording");
+	ret = android_recorder_prepare(recorder);
+	if (ret < 0) {
+		ALOGE("android_recorder_prepare() failed");
+		return NULL;
+	}
+	ALOGD("Starting video recording");
+	ret = android_recorder_start(recorder);
+	if (ret < 0) {
+		ALOGE("android_recorder_start() failed");
+		return NULL;
+	}
+
+	return recorder;
+}
+
+static void stop_video_recording(MediaRecorderWrapper *recorder)
+{
+	if (recording) {
+		ALOGD("Stopping video recording");
+		android_recorder_stop(recorder);
+		android_recorder_reset(recorder);
+		android_recorder_release(recorder);
+		ALOGD("Stopped video recording");
+	}
+}
+
+void on_new_input_event(Event* event, void* context)
+{
+	assert(context);
+
+	if (event->type == KEY_EVENT_TYPE && event->action == ISCL_KEY_EVENT_ACTION_UP) {
+		printf("We got a key event: %d \n", event->details.key.key_code);
+
+		CameraControl* cc = static_cast<CameraControl*>(context);
+
+		switch(event->details.key.key_code) {
+		case ISCL_KEYCODE_VOLUME_UP:
+			printf("Starting video recording to /cache/test_recording.mp4\n");
+			start_video_recording(cc);
+			recording = true;
+			break;
+		case ISCL_KEYCODE_VOLUME_DOWN:
+			printf("Stopping video recording\n");
+			stop_video_recording(recorder);
+			recording = false;
+			break;
+		case ISCL_KEYCODE_POWER:
+			printf("\tTaking a photo now.\n");
+			android_camera_take_snapshot(cc);
+			break;
+		case ISCL_KEYCODE_HEADSETHOOK:
+			printf("\tSwitching effect.\n");
+			android_camera_set_effect_mode(cc, next_effect());
+		}
+	} else if (event->type == MOTION_EVENT_TYPE &&
+			event->details.motion.pointer_count == 1) {
+		if ((event->action & ISCL_MOTION_EVENT_ACTION_MASK) == ISCL_MOTION_EVENT_ACTION_UP) {
+			printf("\tMotion event(Action up): (%f, %f) \n",
+					event->details.motion.pointer_coordinates[0].x,
+					event->details.motion.pointer_coordinates[0].y);
+		}
+
+		if ((event->action & ISCL_MOTION_EVENT_ACTION_MASK) == ISCL_MOTION_EVENT_ACTION_DOWN) {
+			printf("\tMotion event(Action down): (%f, %f) \n",
+					event->details.motion.pointer_coordinates[0].x,
+					event->details.motion.pointer_coordinates[0].y);
+		}
+	}
+}
+
+struct ClientWithSurface
+{
+	SfClient* client;
+	SfSurface* surface;
+};
+
+ClientWithSurface client_with_surface(bool setup_surface_with_egl)
+{
+	ClientWithSurface cs = ClientWithSurface();
+
+	cs.client = sf_client_create();
+
+	if (!cs.client) {
+		printf("Problem creating client ... aborting now.");
+		return cs;
+	}
+
+	static const size_t primary_display = 0;
+
+	SfSurfaceCreationParameters params = {
+		0,
+		0,
+		(int) sf_get_display_width(primary_display),
+		(int) sf_get_display_height(primary_display),
+		-1, //PIXEL_FORMAT_RGBA_8888,
+		15000,
+		0.5f,
+		setup_surface_with_egl, // Do not associate surface with egl, will be done by camera HAL
+		"CameraCompatLayerTestSurface"
+	};
+
+	cs.surface = sf_surface_create(cs.client, &params);
+
+	if (!cs.surface) {
+		printf("Problem creating surface ... aborting now.");
+		return cs;
+	}
+
+	sf_surface_make_current(cs.surface);
+
+	return cs;
+}
+
+#define PRINT_GLERROR() printf("GL error@%d: %x\n", __LINE__, glGetError());
+
+int main(int argc, char** argv)
+{
+	CameraControlListener listener;
+	memset(&listener, 0, sizeof(listener));
+	listener.on_msg_error_cb = error_msg_cb;
+	listener.on_msg_shutter_cb = shutter_msg_cb;
+	listener.on_msg_focus_cb = autofocus_msg_cb;
+	listener.on_msg_zoom_cb = zoom_msg_cb;
+
+	listener.on_data_raw_image_cb = raw_data_cb;
+	listener.on_data_compressed_image_cb = jpeg_data_cb;
+	listener.on_preview_texture_needs_update_cb = preview_texture_needs_update_cb;
+	camera_control = android_camera_connect_to(BACK_FACING_CAMERA_TYPE,
+			&listener);
+
+	if (camera_control == NULL) {
+		printf("Problem connecting to camera");
+		return 1;
+	}
+	listener.context = camera_control;
+
+	AndroidEventListener event_listener;
+	event_listener.on_new_event = on_new_input_event;
+	event_listener.context = camera_control;
+
+	InputStackConfiguration input_configuration = {
+		enable_touch_point_visualization : true,
+		default_layer_for_touch_point_visualization : 10000,
+		input_area_width : 1024,
+		input_area_height : 1024
+	};
+
+	android_input_stack_initialize(&event_listener, &input_configuration);
+	android_input_stack_start();
+
+	// Set the still photo size
+	android_camera_enumerate_supported_picture_sizes(camera_control, size_cb, NULL);
+	if (camera_width == 0 && camera_height == 0) {
+		camera_width = 320;
+		camera_height = 240;
+	}
+	android_camera_set_picture_size(camera_control, camera_width, camera_height);
+
+	// Set the still photo thumbnail size
+	android_camera_enumerate_supported_thumbnail_sizes(camera_control, thumbnail_size_cb, NULL);
+	if (thumbnail_width == 0 && thumbnail_height == 0) {
+		thumbnail_width = 320;
+		thumbnail_height = 240;
+	}
+	android_camera_set_thumbnail_size(camera_control, thumbnail_width, thumbnail_height);
+
+	AutoFocusMode af_mode;
+	android_camera_get_auto_focus_mode(camera_control, &af_mode);
+	printf("Current af mode: %d \n", af_mode);
+
+	int zoom;
+	android_camera_set_zoom(camera_control, 0);
+	android_camera_get_max_zoom(camera_control, &zoom);
+	printf("Max zoom: %d \n", zoom);
+
+	android_camera_enumerate_supported_video_sizes(camera_control, size_cb, NULL);
+	android_camera_enumerate_supported_preview_sizes(camera_control, size_cb, NULL);
+	android_camera_set_preview_size(camera_control, camera_width, camera_height);
+
+	int min_fps, max_fps, current_fps;
+	android_camera_get_preview_fps_range(camera_control, &min_fps, &max_fps);
+	printf("Preview fps range: [%d,%d]\n", min_fps, max_fps);
+	android_camera_get_preview_fps(camera_control, &current_fps);
+	printf("Current preview fps range: %d\n", current_fps);
+
+#if 0
+	android_camera_dump_parameters(camera_control);
+
+	android_camera_set_display_orientation(camera_control, 90);
+
+	int width, height;
+	android_camera_get_preview_size(camera_control, &width, &height);
+	printf("Current preview size: [%d,%d]\n", width, height);
+	android_camera_get_picture_size(camera_control, &width, &height);
+	printf("Current picture size: [%d,%d]\n", width, height);
+	android_camera_get_current_zoom(camera_control, &zoom);
+	printf("Current zoom: %d \n", zoom);
+
+	EffectMode effect_mode;
+	FlashMode flash_mode;
+	WhiteBalanceMode wb_mode;
+	//SceneMode scene_mode;
+	CameraPixelFormat pixel_format;
+	android_camera_get_effect_mode(camera_control, &effect_mode);
+	printf("Current effect mode: %d \n", effect_mode);
+	android_camera_get_flash_mode(camera_control, &flash_mode);
+	printf("Current flash mode: %d \n", flash_mode);
+	android_camera_get_white_balance_mode(camera_control, &wb_mode);
+	ALOGD("Current wb mode: %d \n", wb_mode);
+#if 0
+	// Disabled, causes the test app to crash
+	android_camera_get_scene_mode(camera_control, &scene_mode);
+	printf("Current scene mode: %d \n", scene_mode);
+#endif
+	android_camera_get_preview_format(camera_control, &pixel_format);
+	printf("Current preview pixel format: %d \n", pixel_format);
+	//android_camera_set_focus_region(camera_control, -200, -200, 200, 200, 300);
+#endif
+
+	printf("Creating client with surface");
+	ClientWithSurface cs = client_with_surface(true /* Associate surface with egl. */);
+
+	if (!cs.surface) {
+		printf("Problem acquiring surface for preview");
+		return 1;
+	}
+	printf("Finished creating client with surface\n");
+
+	disp = sf_client_get_egl_display(cs.client);
+	surface = sf_surface_get_egl_surface(cs.surface);
+
+	GLuint preview_texture_id;
+	printf("Getting a texture id\n");
+	glGenTextures(1, &preview_texture_id);
+	glClearColor(1.0, 0., 0.5, 1.);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(
+			GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(
+			GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	printf("About to set preview texture\n");
+	android_camera_set_preview_texture(camera_control, preview_texture_id);
+#if 0
+	android_camera_set_effect_mode(camera_control, EFFECT_MODE_SEPIA);
+	android_camera_set_flash_mode(camera_control, FLASH_MODE_AUTO);
+	android_camera_set_auto_focus_mode(camera_control, AUTO_FOCUS_MODE_CONTINUOUS_PICTURE);
+#endif
+	android_camera_start_preview(camera_control);
+
+	GLfloat transformation_matrix[16];
+	android_camera_get_preview_texture_transformation(camera_control, transformation_matrix);
+	glUniformMatrix4fv(render_data.matrix_loc, 1, GL_FALSE, transformation_matrix);
+
+	printf("Started camera preview.\n");
+
+	while (1) {
+		usleep(50);
+	}
+
+	stop_video_recording(recorder);
+	android_camera_stop_preview(camera_control);
+	android_camera_disconnect(camera_control);
+}

=== added directory 'android/compat/input'
=== added file 'android/compat/input/Android.mk'
--- android/compat/input/Android.mk	1970-01-01 00:00:00 +0000
+++ android/compat/input/Android.mk	2016-01-11 14:31:46 +0000
@@ -0,0 +1,77 @@
+LOCAL_PATH := $(call my-dir)
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
+
+LOCAL_CFLAGS += -std=gnu++0x
+
+LOCAL_SRC_FILES:= input_compatibility_layer.cpp
+
+LOCAL_MODULE:= libis_compat_layer
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+	libinput \
+	libcutils \
+	libutils \
+	libskia \
+	libgui \
+	libandroidfw
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include \
+	external/skia/include/core
+
+HAS_LIBINPUTSERVICE := $(shell test $(ANDROID_VERSION_MAJOR) -eq 4 -a $(ANDROID_VERSION_MINOR) -gt 2 && echo true)
+ifeq ($(HAS_LIBINPUTSERVICE),true)
+LOCAL_SHARED_LIBRARIES += libinputservice
+LOCAL_C_INCLUDES += frameworks/base/services/input
+endif
+
+HAS_LIBINPUTFLINGER := $(shell test $(ANDROID_VERSION_MAJOR) -eq 5 && echo true)
+ifeq ($(HAS_LIBINPUTFLINGER),true)
+LOCAL_SHARED_LIBRARIES += libinputflinger libinputservice
+LOCAL_C_INCLUDES += \
+	frameworks/base/libs/input \
+	frameworks/native/services
+endif
+
+
+
+
+include $(BUILD_SHARED_LIBRARY)
+
+include $(CLEAR_VARS)
+
+HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
+
+LOCAL_CFLAGS += -std=gnu++0x
+
+LOCAL_SRC_FILES:= \
+	direct_input_test.cpp
+
+LOCAL_MODULE:= direct_input_test
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include \
+	bionic \
+	bionic/libstdc++/include \
+	external/gtest/include \
+	external/stlport/stlport \
+	external/skia/include/core
+
+LOCAL_SHARED_LIBRARIES := \
+	libis_compat_layer \
+	libcutils \
+	libutils \
+	libskia \
+	libgui \
+	libandroidfw
+
+static_libraries := \
+	libgtest \
+	libgtest_main
+
+include $(BUILD_EXECUTABLE)

=== added file 'android/compat/input/direct_input_test.cpp'
--- android/compat/input/direct_input_test.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/input/direct_input_test.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,85 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *              Ricardo Salveti de Araujo <[e-mail]>
+ */
+
+#include <hybris/input/input_stack_compatibility_layer.h>
+
+#include <gtest/gtest.h>
+#include <utils/threads.h>
+
+#include <signal.h>
+
+namespace
+{
+
+bool g_stop = false;
+
+void signal_handler(int)
+{
+	g_stop = true;
+}
+
+void on_new_event(Event* event, void* context)
+{
+	printf("%s", __PRETTY_FUNCTION__);
+
+	printf("\tEventType: %d \n", event->type);
+	printf("\tdevice_id: %d \n", event->device_id);
+	printf("\tsource_id: %d \n", event->source_id);
+	printf("\taction: %d \n", event->action);
+	printf("\tflags: %d \n", event->flags);
+	printf("\tmeta_state: %d \n", event->meta_state);
+
+	switch (event->type) {
+	case MOTION_EVENT_TYPE:
+		printf("\tdetails.motion.event_time: %lld\n",
+				event->details.motion.event_time);
+		printf("\tdetails.motion.pointer_coords.x: %f\n",
+				event->details.motion.pointer_coordinates[0].x);
+		printf("\tdetails.motion.pointer_coords.y: %f\n",
+				event->details.motion.pointer_coordinates[0].y);
+		break;
+	default:
+		break;
+	}
+}
+
+}
+
+int main(int argc, char** argv)
+{
+	g_stop = false;
+	signal(SIGINT, signal_handler);
+
+	AndroidEventListener listener;
+	listener.on_new_event = on_new_event;
+	listener.context = NULL;
+
+	InputStackConfiguration config = {
+		enable_touch_point_visualization : true,
+		default_layer_for_touch_point_visualization : 10000,
+		input_area_width : 1024,
+		input_area_height : 1024
+	};
+
+	android_input_stack_initialize(&listener, &config);
+	android_input_stack_start_waiting_for_flag(&g_stop);
+
+	android_input_stack_stop();
+	android_input_stack_shutdown();
+}

=== added file 'android/compat/input/input_compatibility_layer.cpp'
--- android/compat/input/input_compatibility_layer.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/input/input_compatibility_layer.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,384 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Thomas Voß <[e-mail]>
+ *              Ricardo Salveti de Araujo <[e-mail]>
+ */
+
+#include <hybris/input/input_stack_compatibility_layer.h>
+
+#if ANDROID_VERSION_MAJOR<=4
+  #include "InputListener.h"
+  #include "InputReader.h"
+#elif ANDROID_VERSION_MAJOR==5
+  #include "inputflinger/InputListener.h"
+  #include "inputflinger/InputReader.h"
+#endif
+
+#include "PointerController.h"
+#include "SpriteController.h"
+#include <gui/ISurfaceComposer.h>
+#include <gui/SurfaceComposerClient.h>
+
+#undef LOG_TAG
+#define LOG_TAG "InputStackCompatibilityLayer"
+#include <utils/Log.h>
+
+namespace
+{
+static bool enable_verbose_function_reporting = false;
+}
+
+#define REPORT_FUNCTION() ALOGV("%s\n", __PRETTY_FUNCTION__);
+
+namespace
+{
+
+class DefaultPointerControllerPolicy : public android::PointerControllerPolicyInterface
+{
+public:
+	static const size_t bitmap_width = 64;
+	static const size_t bitmap_height = 64;
+
+	DefaultPointerControllerPolicy()
+	{
+#if ANDROID_VERSION_MAJOR<=4
+		bitmap.setConfig(
+				SkBitmap::kARGB_8888_Config,
+				bitmap_width,
+				bitmap_height);
+#elif ANDROID_VERSION_MAJOR==5
+		SkColorType ct = SkBitmapConfigToColorType(SkBitmap::kARGB_8888_Config);
+		bitmap.setInfo(
+				SkImageInfo::Make(bitmap_width,
+					bitmap_height,
+					ct,
+					SkAlphaType::kPremul_SkAlphaType),
+				0);
+#endif
+		bitmap.allocPixels();
+
+		// Icon for spot touches
+		bitmap.eraseARGB(125, 0, 255, 0);
+		spotTouchIcon = android::SpriteIcon(
+				bitmap,
+				bitmap_width/2,
+				bitmap_height/2);
+
+		// Icon for anchor touches
+		bitmap.eraseARGB(125, 0, 0, 255);
+		spotAnchorIcon = android::SpriteIcon(
+				bitmap,
+				bitmap_width/2,
+				bitmap_height/2);
+
+		// Icon for hovering touches
+		bitmap.eraseARGB(125, 255, 0, 0);
+		spotHoverIcon = android::SpriteIcon(
+				bitmap,
+				bitmap_width/2,
+				bitmap_height/2);
+	}
+
+	void loadPointerResources(android::PointerResources* outResources)
+	{
+		outResources->spotHover = spotHoverIcon.copy();
+		outResources->spotTouch = spotTouchIcon.copy();
+		outResources->spotAnchor = spotAnchorIcon.copy();
+	}
+
+	android::SpriteIcon spotHoverIcon;
+	android::SpriteIcon spotTouchIcon;
+	android::SpriteIcon spotAnchorIcon;
+	SkBitmap bitmap;
+};
+
+class DefaultInputReaderPolicyInterface : public android::InputReaderPolicyInterface
+{
+public:
+	static const int32_t internal_display_id = android::ISurfaceComposer::eDisplayIdMain;
+	static const int32_t external_display_id = android::ISurfaceComposer::eDisplayIdHdmi;
+
+	DefaultInputReaderPolicyInterface(
+			InputStackConfiguration* configuration,
+			const android::sp<android::Looper>& looper)
+			: looper(looper),
+		default_layer_for_touch_point_visualization(configuration->default_layer_for_touch_point_visualization),
+		input_area_width(configuration->input_area_width),
+		input_area_height(configuration->input_area_height)
+	{
+		default_configuration.showTouches = configuration->enable_touch_point_visualization;
+
+		android::DisplayViewport viewport;
+		viewport.setNonDisplayViewport(input_area_width, input_area_height);
+		viewport.displayId = android::ISurfaceComposer::eDisplayIdMain;
+		default_configuration.setDisplayInfo(
+				false, /* external */
+				viewport);
+	}
+
+	void getReaderConfiguration(android::InputReaderConfiguration* outConfig)
+	{
+		*outConfig = default_configuration;
+	}
+
+	android::sp<android::PointerControllerInterface> obtainPointerController(int32_t deviceId)
+	{
+		(void) deviceId;
+
+		android::sp<android::SpriteController> sprite_controller(
+				new android::SpriteController(
+					looper,
+					default_layer_for_touch_point_visualization));
+		android::sp<android::PointerController> pointer_controller(
+				new android::PointerController(
+					android::sp<DefaultPointerControllerPolicy>(new DefaultPointerControllerPolicy()),
+					looper,
+					sprite_controller));
+		pointer_controller->setPresentation(
+				android::PointerControllerInterface::PRESENTATION_SPOT);
+
+		pointer_controller->setDisplayViewport(input_area_width, input_area_height, 0);
+		return pointer_controller;
+	}
+
+	virtual void notifyInputDevicesChanged(const android::Vector<android::InputDeviceInfo>& inputDevices) {
+		mInputDevices = inputDevices;
+	}
+
+#if ANDROID_VERSION_MAJOR<=4
+	virtual android::sp<android::KeyCharacterMap> getKeyboardLayoutOverlay(const android::String8& inputDeviceDescriptor) {
+#elif ANDROID_VERSION_MAJOR==5
+	virtual android::sp<android::KeyCharacterMap> getKeyboardLayoutOverlay(const android::InputDeviceIdentifier& identifier) {
+#endif
+		return NULL;
+	}
+
+	virtual android::String8 getDeviceAlias(const android::InputDeviceIdentifier& identifier) {
+		return android::String8::empty();
+	}
+
+#if ANDROID_VERSION_MAJOR==5
+	virtual android::TouchAffineTransformation getTouchAffineTransformation(const android::String8& inputDeviceDescriptor, int32_t surfaceRotation) {
+		return android::TouchAffineTransformation();
+	}
+#endif
+
+private:
+	android::sp<android::Looper> looper;
+	int default_layer_for_touch_point_visualization;
+	android::InputReaderConfiguration default_configuration;
+	android::Vector<android::InputDeviceInfo> mInputDevices;
+	int input_area_width;
+	int input_area_height;
+};
+
+class ExportedInputListener : public android::InputListenerInterface
+{
+public:
+	ExportedInputListener(AndroidEventListener* external_listener) : external_listener(external_listener)
+	{
+	}
+
+	void notifyConfigurationChanged(const android::NotifyConfigurationChangedArgs* args)
+	{
+		REPORT_FUNCTION();
+		(void) args;
+	}
+
+	void notifyKey(const android::NotifyKeyArgs* args)
+	{
+		REPORT_FUNCTION();
+
+		current_event.type = KEY_EVENT_TYPE;
+		current_event.device_id = args->deviceId;
+		current_event.source_id = args->source;
+		current_event.action = args->action;
+		current_event.flags = args->flags;
+		current_event.meta_state = args->metaState;
+
+		current_event.details.key.key_code = args->keyCode;
+		current_event.details.key.scan_code = args->scanCode;
+		current_event.details.key.down_time = args->downTime;
+		current_event.details.key.event_time = args->eventTime;
+
+		current_event.details.key.is_system_key = false;
+
+		external_listener->on_new_event(&current_event, external_listener->context);
+	}
+
+	void notifyMotion(const android::NotifyMotionArgs* args)
+	{
+		REPORT_FUNCTION();
+
+		current_event.type = MOTION_EVENT_TYPE;
+		current_event.device_id = args->deviceId;
+		current_event.source_id = args->source;
+		current_event.action = args->action;
+		current_event.flags = args->flags;
+		current_event.meta_state = args->metaState;
+
+		current_event.details.motion.button_state = args->buttonState;
+		current_event.details.motion.down_time = args->downTime;
+		current_event.details.motion.event_time = args->eventTime;
+		current_event.details.motion.edge_flags = args->edgeFlags;
+		current_event.details.motion.x_precision = args->xPrecision;
+		current_event.details.motion.y_precision = args->yPrecision;
+		current_event.details.motion.pointer_count = args->pointerCount;
+
+		for (unsigned int i = 0; i < current_event.details.motion.pointer_count; i++) {
+			current_event.details.motion.pointer_coordinates[i].id = args->pointerProperties[i].id;
+			current_event.details.motion.pointer_coordinates[i].x
+				= current_event.details.motion.pointer_coordinates[i].raw_x
+				= args->pointerCoords[i].getX();
+			current_event.details.motion.pointer_coordinates[i].y
+				= current_event.details.motion.pointer_coordinates[i].raw_y
+				= args->pointerCoords[i].getY();
+			current_event.details.motion.pointer_coordinates[i].touch_major
+				= args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR);
+			current_event.details.motion.pointer_coordinates[i].touch_minor
+				= args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR);
+			current_event.details.motion.pointer_coordinates[i].pressure
+				= args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE);
+			current_event.details.motion.pointer_coordinates[i].size
+				= args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_SIZE);
+			current_event.details.motion.pointer_coordinates[i].orientation
+				= args->pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);
+
+		}
+
+		external_listener->on_new_event(&current_event, external_listener->context);
+	}
+
+	void notifySwitch(const android::NotifySwitchArgs* args)
+	{
+		REPORT_FUNCTION();
+		current_event.type = HW_SWITCH_EVENT_TYPE;
+
+		current_event.details.hw_switch.event_time = args->eventTime;
+		current_event.details.hw_switch.policy_flags = args->policyFlags;
+		current_event.details.hw_switch.switch_values = args->switchValues;
+		current_event.details.hw_switch.switch_mask = args->switchMask;
+
+		external_listener->on_new_event(&current_event, external_listener->context);
+	}
+
+	void notifyDeviceReset(const android::NotifyDeviceResetArgs* args)
+	{
+		REPORT_FUNCTION();
+		(void) args;
+	}
+
+private:
+	AndroidEventListener* external_listener;
+	Event current_event;
+};
+
+class LooperThread : public android::Thread
+{
+public:
+	static const int default_poll_timeout_ms = -1;
+
+	LooperThread(const android::sp<android::Looper>& looper) : looper(looper)
+	{
+	}
+
+private:
+	bool threadLoop()
+	{
+		if (ALOOPER_POLL_ERROR == looper->pollAll(default_poll_timeout_ms))
+			return false;
+		return true;
+	}
+
+	android::sp<android::Looper> looper;
+};
+
+struct State : public android::RefBase
+{
+	State(AndroidEventListener* listener,
+			InputStackConfiguration* configuration)
+			: looper(new android::Looper(false)),
+			looper_thread(new LooperThread(looper)),
+			event_hub(new android::EventHub()),
+			input_reader_policy(new DefaultInputReaderPolicyInterface(configuration, looper)),
+			input_listener(new ExportedInputListener(listener)),
+			input_reader(new android::InputReader(
+						event_hub,
+						input_reader_policy,
+						input_listener)),
+			input_reader_thread(new android::InputReaderThread(input_reader))
+	{
+	}
+
+	~State()
+	{
+		input_reader_thread->requestExit();
+	}
+
+	android::sp<android::Looper> looper;
+	android::sp<LooperThread> looper_thread;
+
+	android::sp<android::EventHubInterface> event_hub;
+	android::sp<android::InputReaderPolicyInterface> input_reader_policy;
+	android::sp<android::InputListenerInterface> input_listener;
+	android::sp<android::InputReaderInterface> input_reader;
+	android::sp<android::InputReaderThread> input_reader_thread;
+
+	android::Condition wait_condition;
+	android::Mutex wait_guard;
+};
+
+android::sp<State> global_state;
+
+}
+
+void android_input_stack_initialize(AndroidEventListener* listener, InputStackConfiguration* config)
+{
+	global_state = new State(listener, config);
+}
+
+void android_input_stack_loop_once()
+{
+	global_state->input_reader->loopOnce();
+}
+
+void android_input_stack_start()
+{
+	global_state->input_reader_thread->run();
+	global_state->looper_thread->run();
+}
+
+void android_input_stack_start_waiting_for_flag(bool* flag)
+{
+	global_state->input_reader_thread->run();
+	global_state->looper_thread->run();
+
+	while (!*flag) {
+		global_state->wait_condition.waitRelative(
+				global_state->wait_guard,
+				10 * 1000 * 1000);
+	}
+}
+
+void android_input_stack_stop()
+{
+	global_state->input_reader_thread->requestExit();
+}
+
+void android_input_stack_shutdown()
+{
+	global_state = NULL;
+}

=== added directory 'android/compat/media'
=== added file 'android/compat/media/Android.mk'
--- android/compat/media/Android.mk	1970-01-01 00:00:00 +0000
+++ android/compat/media/Android.mk	2016-01-11 14:31:46 +0000
@@ -0,0 +1,187 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+LOCAL_SRC_FILES := \
+	camera_service.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+	libcameraservice \
+	libmedialogservice \
+	libcutils \
+	libmedia \
+	libmedia_compat_layer \
+	libmediaplayerservice \
+	libutils \
+	liblog \
+	libbinder
+
+LOCAL_C_INCLUDES := \
+    frameworks/av/media/libmediaplayerservice \
+    frameworks/av/services/medialog \
+    frameworks/av/services/camera/libcameraservice
+
+IS_ANDROID_5 := $(shell test $(ANDROID_VERSION_MAJOR) -eq 5 && echo true)
+ifeq ($(IS_ANDROID_5),true)
+LOCAL_C_INCLUDES += system/media/camera/include
+endif
+
+LOCAL_MODULE := camera_service
+
+LOCAL_32_BIT_ONLY := true
+
+include $(BUILD_EXECUTABLE)
+
+# -------------------------------------------------
+
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
+
+LOCAL_CFLAGS += -std=gnu++0x
+
+ifeq ($(BOARD_HAS_MEDIA_PLAYER_PAUSE),true)
+LOCAL_CFLAGS += -DBOARD_HAS_MEDIA_PLAYER_PAUSE
+endif
+
+LOCAL_SRC_FILES:= \
+	media_compatibility_layer.cpp \
+	media_codec_layer.cpp \
+	media_codec_list.cpp \
+	media_format_layer.cpp \
+	surface_texture_client_hybris.cpp \
+	decoding_service.cpp \
+	media_recorder_layer.cpp \
+	media_recorder.cpp \
+	media_recorder_client.cpp \
+	media_recorder_factory.cpp \
+	media_recorder_observer.cpp
+
+LOCAL_MODULE:= libmedia_compat_layer
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_SHARED_LIBRARIES := \
+	libcutils \
+	libcamera_client \
+	libutils \
+	libbinder \
+	libhardware \
+	libui \
+	libgui \
+	libstagefright \
+	libstagefright_foundation \
+	libEGL \
+	libGLESv2 \
+	libmedia \
+	libaudioutils \
+	libmediaplayerservice
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include \
+	frameworks/base/media/libstagefright/include \
+	frameworks/base/include/media/stagefright \
+	frameworks/base/include/media \
+	frameworks/av/media \
+	frameworks/av/media/libstagefright/include \
+	frameworks/av/include \
+	frameworks/native/include \
+	system/media/audio_utils/include \
+	frameworks/av/services/camera/libcameraservice
+
+IS_ANDROID_5 := $(shell test $(ANDROID_VERSION_MAJOR) -eq 5 && echo true)
+ifeq ($(IS_ANDROID_5),true)
+LOCAL_C_INCLUDES += frameworks/native/include/media/openmax
+endif
+
+ifeq ($(strip $(MTK_CAMERA_BSP_SUPPORT)),yes)
+LOCAL_C_INCLUDES += $(TOP)/mediatek/kernel/include/linux/vcodec
+LOCAL_SHARED_LIBRARIES += \
+	libvcodecdrv
+
+LOCAL_C_INCLUDES+= \
+	$(TOP)/$(MTK_PATH_SOURCE)/frameworks-ext/av/media/libmediaplayerservice \
+	$(TOP)/$(MTK_PATH_SOURCE)/frameworks-ext/av/include \
+	$(TOP)/$(MTK_PATH_SOURCE)/frameworks-ext/av/media/libstagefright/include \
+	$(TOP)/$(MTK_PATH_PLATFORM)/frameworks/libmtkplayer \
+	$(TOP)/$(MTK_PATH_SOURCE)/frameworks/av/include
+endif
+
+LOCAL_32_BIT_ONLY := true
+
+include $(BUILD_SHARED_LIBRARY)
+
+# -------------------------------------------------
+
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+LOCAL_SRC_FILES:= \
+	direct_media_test.cpp
+
+LOCAL_MODULE:= direct_media_test
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_C_INCLUDES := \
+	$(HYBRIS_PATH)/include \
+	bionic \
+	bionic/libstdc++/include \
+	external/gtest/include \
+	external/stlport/stlport \
+	external/skia/include/core \
+	frameworks/base/include
+
+LOCAL_SHARED_LIBRARIES := \
+	libis_compat_layer \
+	libsf_compat_layer \
+	libmedia_compat_layer \
+	libcutils \
+	libutils \
+	libbinder \
+	libhardware \
+	libui \
+	libgui \
+	libEGL \
+	libGLESv2
+
+LOCAL_32_BIT_ONLY := true
+
+include $(BUILD_EXECUTABLE)
+
+include $(CLEAR_VARS)
+include $(LOCAL_PATH)/../Android.common.mk
+
+LOCAL_CFLAGS += -Wno-multichar -D SIMPLE_PLAYER -std=gnu++0x
+
+LOCAL_SRC_FILES:= \
+	media_codec_layer.cpp \
+	media_codec_list.cpp \
+	media_format_layer.cpp \
+	codec.cpp \
+	SimplePlayer.cpp
+
+LOCAL_SHARED_LIBRARIES := \
+	libstagefright \
+	libstagefright_foundation \
+	liblog \
+	libutils \
+	libbinder \
+	libmedia \
+	libgui \
+	libcutils \
+	libui
+
+LOCAL_C_INCLUDES:= \
+	$(HYBRIS_PATH)/include \
+	frameworks/av/media/libstagefright \
+	frameworks/native/include/media/openmax \
+	frameworks/base/media/libstagefright/include \
+	frameworks/base/include/media/stagefright \
+	frameworks/base/include/media
+
+LOCAL_MODULE:= codec
+LOCAL_MODULE_TAGS := optional
+
+LOCAL_32_BIT_ONLY := true
+
+include $(BUILD_EXECUTABLE)

=== added file 'android/compat/media/SimplePlayer.cpp'
--- android/compat/media/SimplePlayer.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/media/SimplePlayer.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,777 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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.
+ */
+
+//#define LOG_NDEBUG 0
+#define LOG_TAG "SimplePlayer"
+#include <utils/Log.h>
+
+#include "SimplePlayer.h"
+
+#include <gui/Surface.h>
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+#include <gui/SurfaceTextureClient.h>
+#endif
+#include <media/AudioTrack.h>
+#include <media/ICrypto.h>
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MediaErrors.h>
+#include <media/stagefright/NativeWindowWrapper.h>
+#include <media/stagefright/NuMediaExtractor.h>
+
+#define USE_MEDIA_CODEC_LAYER
+
+namespace android {
+
+SimplePlayer::SimplePlayer()
+    : mState(UNINITIALIZED),
+      mDoMoreStuffGeneration(0),
+      mStartTimeRealUs(-1ll) {
+}
+
+SimplePlayer::~SimplePlayer() {
+}
+
+// static
+status_t PostAndAwaitResponse(
+        const sp<AMessage> &msg, sp<AMessage> *response) {
+    status_t err = msg->postAndAwaitResponse(response);
+    printf("%s\n", __PRETTY_FUNCTION__);
+
+    if (err != OK) {
+        return err;
+    }
+
+    if (!(*response)->findInt32("err", &err)) {
+        err = OK;
+    }
+
+    return err;
+}
+status_t SimplePlayer::setDataSource(const char *path) {
+    sp<AMessage> msg = new AMessage(kWhatSetDataSource, id());
+    msg->setString("path", path);
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+status_t SimplePlayer::setSurface(const sp<ISurfaceTexture> &surfaceTexture) {
+    sp<AMessage> msg = new AMessage(kWhatSetSurface, id());
+
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+    sp<SurfaceTextureClient> surfaceTextureClient;
+    if (surfaceTexture != NULL) {
+        surfaceTextureClient = new SurfaceTextureClient(surfaceTexture);
+    }
+#else
+    sp<Surface> surfaceTextureClient;
+    if (surfaceTexture != NULL) {
+        surfaceTextureClient = new Surface(surfaceTexture);
+    }
+#endif
+
+    msg->setObject(
+            "native-window", new NativeWindowWrapper(surfaceTextureClient));
+
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+status_t SimplePlayer::prepare() {
+    sp<AMessage> msg = new AMessage(kWhatPrepare, id());
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+status_t SimplePlayer::start() {
+    printf("%s\n", __PRETTY_FUNCTION__);
+    sp<AMessage> msg = new AMessage(kWhatStart, id());
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+status_t SimplePlayer::stop() {
+    sp<AMessage> msg = new AMessage(kWhatStop, id());
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+status_t SimplePlayer::reset() {
+    sp<AMessage> msg = new AMessage(kWhatReset, id());
+    sp<AMessage> response;
+    return PostAndAwaitResponse(msg, &response);
+}
+
+void SimplePlayer::onMessageReceived(const sp<AMessage> &msg) {
+    switch (msg->what()) {
+        case kWhatSetDataSource:
+        {
+            status_t err;
+            if (mState != UNINITIALIZED) {
+                err = INVALID_OPERATION;
+            } else {
+                CHECK(msg->findString("path", &mPath));
+                mState = UNPREPARED;
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatSetSurface:
+        {
+            status_t err;
+            if (mState != UNPREPARED) {
+                err = INVALID_OPERATION;
+            } else {
+                sp<RefBase> obj;
+                CHECK(msg->findObject("native-window", &obj));
+
+                mNativeWindow = static_cast<NativeWindowWrapper *>(obj.get());
+
+                err = OK;
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatPrepare:
+        {
+            status_t err;
+            if (mState != UNPREPARED) {
+                err = INVALID_OPERATION;
+            } else {
+                err = onPrepare();
+
+                if (err == OK) {
+                    mState = STOPPED;
+                }
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatStart:
+        {
+            status_t err = OK;
+
+            if (mState == UNPREPARED) {
+                err = onPrepare();
+
+                if (err == OK) {
+                    mState = STOPPED;
+                }
+            }
+
+            if (err == OK) {
+                if (mState != STOPPED) {
+                    err = INVALID_OPERATION;
+                } else {
+                    err = onStart();
+
+                    if (err == OK) {
+                        mState = STARTED;
+                    }
+                }
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatStop:
+        {
+            status_t err;
+
+            if (mState != STARTED) {
+                err = INVALID_OPERATION;
+            } else {
+                err = onStop();
+
+                if (err == OK) {
+                    mState = STOPPED;
+                }
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatReset:
+        {
+            status_t err = OK;
+
+            if (mState == STARTED) {
+                CHECK_EQ(onStop(), (status_t)OK);
+                mState = STOPPED;
+            }
+
+            if (mState == STOPPED) {
+                err = onReset();
+                mState = UNINITIALIZED;
+            }
+
+            uint32_t replyID;
+            CHECK(msg->senderAwaitsResponse(&replyID));
+
+            sp<AMessage> response = new AMessage;
+            response->setInt32("err", err);
+            response->postReply(replyID);
+            break;
+        }
+
+        case kWhatDoMoreStuff:
+        {
+            int32_t generation;
+            CHECK(msg->findInt32("generation", &generation));
+
+            if (generation != mDoMoreStuffGeneration) {
+                break;
+            }
+
+            status_t err = onDoMoreStuff();
+
+            if (err == OK) {
+                msg->post(10000ll);
+            }
+            break;
+        }
+
+        default:
+            TRESPASS();
+    }
+}
+
+status_t SimplePlayer::onPrepare() {
+    CHECK_EQ(mState, UNPREPARED);
+    printf("%s\n", __PRETTY_FUNCTION__);
+
+    mExtractor = new NuMediaExtractor;
+
+    status_t err = mExtractor->setDataSource(mPath.c_str());
+
+    if (err != OK) {
+        mExtractor.clear();
+        return err;
+    }
+
+    if (mCodecLooper == NULL) {
+        mCodecLooper = new ALooper;
+        mCodecLooper->start();
+    }
+
+    bool haveAudio = false;
+    bool haveVideo = false;
+    for (size_t i = 0; i < mExtractor->countTracks(); ++i) {
+        sp<AMessage> format;
+        status_t err = mExtractor->getTrackFormat(i, &format);
+        CHECK_EQ(err, (status_t)OK);
+
+        AString mime;
+        int32_t width = 0, height = 0, maxInputSize = 0;
+        int64_t durationUs = 0;
+        sp<ABuffer> csd0, csd1;
+#ifdef USE_MEDIA_CODEC_LAYER
+        MediaFormat mformat;
+#endif
+        CHECK(format->findString("mime", &mime));
+
+        if (!haveAudio && !strncasecmp(mime.c_str(), "audio/", 6)) {
+            //haveAudio = true;
+            printf("*** Have audio but skipping it!\n");
+            continue;
+        } else if (!haveVideo && !strncasecmp(mime.c_str(), "video/", 6)) {
+            haveVideo = true;
+            CHECK(format->findInt32("width", &width));
+            CHECK(format->findInt32("height", &height));
+            CHECK(format->findInt64("durationUs", &durationUs));
+            CHECK(format->findInt32("max-input-size", &maxInputSize));
+            CHECK(format->findBuffer("csd-0", &csd0));
+            CHECK(format->findBuffer("csd-1", &csd1));
+#ifdef USE_MEDIA_CODEC_LAYER
+            mformat = media_format_create_video_format(mime.c_str(), width, height, durationUs, maxInputSize);
+            media_format_set_byte_buffer(mformat, "csd-0", csd0->data(), csd0->size());
+            media_format_set_byte_buffer(mformat, "csd-1", csd1->data(), csd1->size());
+#endif
+        } else {
+            continue;
+        }
+
+        err = mExtractor->selectTrack(i);
+        CHECK_EQ(err, (status_t)OK);
+
+        CodecState *state =
+            &mStateByTrackIndex.editValueAt(
+                    mStateByTrackIndex.add(i, CodecState()));
+
+        state->mNumFramesWritten = 0;
+#ifdef USE_MEDIA_CODEC_LAYER
+        state->mCodecDelegate = media_codec_create_by_codec_type(mime.c_str());
+        state->mCodec = media_codec_get(state->mCodecDelegate);
+        CHECK(state->mCodecDelegate != NULL);
+#else
+        state->mCodec = MediaCodec::CreateByType(
+                mCodecLooper, mime.c_str(), false /* encoder */);
+#endif
+
+        CHECK(state->mCodec != NULL);
+
+#ifdef USE_MEDIA_CODEC_LAYER
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+        err = media_codec_configure(state->mCodecDelegate, mformat, mNativeWindow->getSurfaceTextureClient().get(), 0);
+#else
+        err = media_codec_configure(state->mCodecDelegate, mformat, mNativeWindow->getSurface().get(), 0);
+#endif
+#else
+        err = state->mCodec->configure(
+                format,
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+                mNativeWindow->getSurfaceTextureClient(),
+#else
+                mNativeWindow->getSurface(),
+#endif
+                NULL /* crypto */,
+                0 /* flags */);
+#endif
+
+        CHECK_EQ(err, (status_t)OK);
+
+        size_t j = 0;
+        sp<ABuffer> buffer;
+        // Place the CSD data into the source buffer
+        while (format->findBuffer(StringPrintf("csd-%d", j).c_str(), &buffer)) {
+            state->mCSD.push_back(buffer);
+
+            ++j;
+        }
+    }
+
+    for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
+        CodecState *state = &mStateByTrackIndex.editValueAt(i);
+
+#ifdef USE_MEDIA_CODEC_LAYER
+        status_t err = media_codec_start(state->mCodecDelegate);
+#else
+        status_t err = state->mCodec->start();
+#endif
+        CHECK_EQ(err, (status_t)OK);
+
+#ifdef USE_MEDIA_CODEC_LAYER
+        size_t nInputBuffers = media_codec_get_input_buffers_size(state->mCodecDelegate);
+        ALOGD("nInputBuffers: %u", nInputBuffers);
+        for (size_t i=0; i<nInputBuffers; i++)
+        {
+            uint8_t *data = media_codec_get_nth_input_buffer(state->mCodecDelegate, i);
+            CHECK(data != NULL);
+            size_t size = media_codec_get_nth_input_buffer_capacity(state->mCodecDelegate, i);
+            ALOGD("input buffer[%d] size: %d", i, size);
+            sp<ABuffer> buf = new ABuffer(data, size);
+            state->mBuffers[0].insertAt(new ABuffer(data, size), i);
+        }
+#else
+        err = state->mCodec->getInputBuffers(&state->mBuffers[0]);
+        CHECK_EQ(err, (status_t)OK);
+#endif
+
+        err = state->mCodec->getOutputBuffers(&state->mBuffers[1]);
+        CHECK_EQ(err, (status_t)OK);
+
+        for (size_t j = 0; j < state->mCSD.size(); ++j) {
+            const sp<ABuffer> &srcBuffer = state->mCSD.itemAt(j);
+
+            size_t index;
+#ifdef USE_MEDIA_CODEC_LAYER
+            err = media_codec_dequeue_input_buffer(state->mCodecDelegate, &index, -1ll);
+#else
+            err = state->mCodec->dequeueInputBuffer(&index, -1ll);
+#endif
+            CHECK_EQ(err, (status_t)OK);
+
+            const sp<ABuffer> &dstBuffer = state->mBuffers[0].itemAt(index);
+
+            CHECK_LE(srcBuffer->size(), dstBuffer->capacity());
+            dstBuffer->setRange(0, srcBuffer->size());
+            memcpy(dstBuffer->data(), srcBuffer->data(), srcBuffer->size());
+
+#ifdef USE_MEDIA_CODEC_LAYER
+            MediaCodecBufferInfo bufInfo;
+            bufInfo.index = index;
+            bufInfo.offset = 0;
+            bufInfo.size = dstBuffer->size();
+            bufInfo.presentation_time_us = 0ll;
+            bufInfo.flags = MediaCodec::BUFFER_FLAG_CODECCONFIG;
+
+            err = media_codec_queue_input_buffer(
+                    state->mCodecDelegate,
+                    &bufInfo);
+
+#else
+            err = state->mCodec->queueInputBuffer(
+                    index,
+                    0,
+                    dstBuffer->size(),
+                    0ll,
+                    MediaCodec::BUFFER_FLAG_CODECCONFIG);
+#endif
+            CHECK_EQ(err, (status_t)OK);
+        }
+    }
+
+    return OK;
+}
+
+status_t SimplePlayer::onStart() {
+    CHECK_EQ(mState, STOPPED);
+
+    mStartTimeRealUs = -1ll;
+
+    sp<AMessage> msg = new AMessage(kWhatDoMoreStuff, id());
+    msg->setInt32("generation", ++mDoMoreStuffGeneration);
+    msg->post();
+
+    return OK;
+}
+
+status_t SimplePlayer::onStop() {
+    CHECK_EQ(mState, STARTED);
+
+    ++mDoMoreStuffGeneration;
+
+    return OK;
+}
+
+status_t SimplePlayer::onReset() {
+    CHECK_EQ(mState, STOPPED);
+
+    for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
+        CodecState *state = &mStateByTrackIndex.editValueAt(i);
+
+        CHECK_EQ(state->mCodec->release(), (status_t)OK);
+    }
+
+    mStartTimeRealUs = -1ll;
+
+    mStateByTrackIndex.clear();
+    mCodecLooper.clear();
+    mExtractor.clear();
+    mNativeWindow.clear();
+    mPath.clear();
+
+    return OK;
+}
+
+status_t SimplePlayer::onDoMoreStuff() {
+    ALOGV("onDoMoreStuff");
+    for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
+        CodecState *state = &mStateByTrackIndex.editValueAt(i);
+
+        status_t err;
+        do {
+            size_t index;
+#ifdef USE_MEDIA_CODEC_LAYER
+            err = media_codec_dequeue_input_buffer(state->mCodecDelegate, &index, 0ll);
+#else
+            err = state->mCodec->dequeueInputBuffer(&index);
+#endif
+
+            if (err == OK) {
+                ALOGD("dequeued input buffer on track %d",
+                      mStateByTrackIndex.keyAt(i));
+
+                state->mAvailInputBufferIndices.push_back(index);
+            } else {
+                ALOGD("dequeueInputBuffer on track %d returned %d",
+                      mStateByTrackIndex.keyAt(i), err);
+            }
+        } while (err == OK);
+
+        do {
+#ifdef USE_MEDIA_CODEC_LAYER
+            BufferInfo info;
+            MediaCodecBufferInfo bufInfo;
+            err = media_codec_dequeue_output_buffer(
+                    state->mCodecDelegate,
+                    &bufInfo,
+                    0ll);
+
+            info.mIndex = bufInfo.index;
+            info.mOffset = bufInfo.offset;
+            info.mSize = bufInfo.size;
+            info.mPresentationTimeUs = bufInfo.presentation_time_us;
+            info.mFlags = bufInfo.flags;
+
+#else
+            BufferInfo info;
+            err = state->mCodec->dequeueOutputBuffer(
+                    &info.mIndex,
+                    &info.mOffset,
+                    &info.mSize,
+                    &info.mPresentationTimeUs,
+                    &info.mFlags);
+#endif
+
+            if (err == OK) {
+                ALOGV("dequeued output buffer on track %d",
+                      mStateByTrackIndex.keyAt(i));
+
+                state->mAvailOutputBufferInfos.push_back(info);
+            } else if (err == INFO_FORMAT_CHANGED) {
+                err = onOutputFormatChanged(mStateByTrackIndex.keyAt(i), state);
+                CHECK_EQ(err, (status_t)OK);
+            } else if (err == INFO_OUTPUT_BUFFERS_CHANGED) {
+                err = state->mCodec->getOutputBuffers(&state->mBuffers[1]);
+                CHECK_EQ(err, (status_t)OK);
+            } else {
+                ALOGV("dequeueOutputBuffer on track %d returned %d",
+                      mStateByTrackIndex.keyAt(i), err);
+            }
+        } while (err == OK
+                || err == INFO_FORMAT_CHANGED
+                || err == INFO_OUTPUT_BUFFERS_CHANGED);
+    }
+
+    for (;;) {
+        size_t trackIndex;
+        status_t err = mExtractor->getSampleTrackIndex(&trackIndex);
+
+        if (err != OK) {
+            ALOGI("encountered input EOS.");
+            break;
+        } else {
+            CodecState *state = &mStateByTrackIndex.editValueFor(trackIndex);
+
+            if (state->mAvailInputBufferIndices.empty()) {
+                break;
+            }
+
+            size_t index = *state->mAvailInputBufferIndices.begin();
+            state->mAvailInputBufferIndices.erase(
+                    state->mAvailInputBufferIndices.begin());
+
+            const sp<ABuffer> &dstBuffer =
+                state->mBuffers[0].itemAt(index);
+
+            err = mExtractor->readSampleData(dstBuffer);
+            CHECK_EQ(err, (status_t)OK);
+
+            int64_t timeUs;
+            CHECK_EQ(mExtractor->getSampleTime(&timeUs), (status_t)OK);
+
+#ifdef USE_MEDIA_CODEC_LAYER
+            MediaCodecBufferInfo bufInfo;
+            bufInfo.index = index;
+            bufInfo.offset = dstBuffer->offset();
+            bufInfo.size = dstBuffer->size();
+            bufInfo.presentation_time_us = timeUs;
+            bufInfo.flags = 0;
+
+            err = media_codec_queue_input_buffer(
+                    state->mCodecDelegate,
+                    &bufInfo);
+
+#else
+            err = state->mCodec->queueInputBuffer(
+                    index,
+                    dstBuffer->offset(),
+                    dstBuffer->size(),
+                    timeUs,
+                    0);
+#endif
+            CHECK_EQ(err, (status_t)OK);
+
+            ALOGV("enqueued input data on track %d", trackIndex);
+
+            err = mExtractor->advance();
+            CHECK_EQ(err, (status_t)OK);
+        }
+    }
+
+    int64_t nowUs = ALooper::GetNowUs();
+
+    if (mStartTimeRealUs < 0ll) {
+        mStartTimeRealUs = nowUs + 1000000ll;
+    }
+
+    for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
+        CodecState *state = &mStateByTrackIndex.editValueAt(i);
+
+        while (!state->mAvailOutputBufferInfos.empty()) {
+            BufferInfo *info = &*state->mAvailOutputBufferInfos.begin();
+
+            int64_t whenRealUs = info->mPresentationTimeUs + mStartTimeRealUs;
+            int64_t lateByUs = nowUs - whenRealUs;
+
+            if (lateByUs > -10000ll) {
+                bool release = true;
+
+                if (lateByUs > 30000ll) {
+                    ALOGI("track %d buffer late by %lld us, dropping.",
+                          mStateByTrackIndex.keyAt(i), lateByUs);
+                    state->mCodec->releaseOutputBuffer(info->mIndex);
+                } else {
+                    if (state->mAudioTrack != NULL) {
+                        const sp<ABuffer> &srcBuffer =
+                            state->mBuffers[1].itemAt(info->mIndex);
+
+                        renderAudio(state, info, srcBuffer);
+
+                        if (info->mSize > 0) {
+                            release = false;
+                        }
+                    }
+
+                    if (release) {
+#ifdef USE_MEDIA_CODEC_LAYER
+                        ALOGD("Rendering output buffer index %d and releasing", info->mIndex);
+                        state->mCodec->renderOutputBufferAndRelease(
+                                info->mIndex);
+#else
+                        ALOGD("Releasing output buffer index %d", info->mIndex);
+                        state->mCodec->releaseOutputBuffer(info->mIndex);
+#endif
+                    }
+                }
+
+                if (release) {
+                    state->mAvailOutputBufferInfos.erase(
+                            state->mAvailOutputBufferInfos.begin());
+
+                    info = NULL;
+                } else {
+                    break;
+                }
+            } else {
+                ALOGV("track %d buffer early by %lld us.",
+                      mStateByTrackIndex.keyAt(i), -lateByUs);
+                break;
+            }
+        }
+    }
+
+    return OK;
+}
+
+status_t SimplePlayer::onOutputFormatChanged(
+        size_t trackIndex, CodecState *state) {
+    sp<AMessage> format;
+    status_t err = state->mCodec->getOutputFormat(&format);
+
+    if (err != OK) {
+        return err;
+    }
+
+    AString mime;
+    CHECK(format->findString("mime", &mime));
+
+    if (!strncasecmp(mime.c_str(), "audio/", 6)) {
+        int32_t channelCount;
+        int32_t sampleRate;
+        CHECK(format->findInt32("channel-count", &channelCount));
+        CHECK(format->findInt32("sample-rate", &sampleRate));
+
+        state->mAudioTrack = new AudioTrack(
+                AUDIO_STREAM_MUSIC,
+                sampleRate,
+                AUDIO_FORMAT_PCM_16_BIT,
+                audio_channel_out_mask_from_count(channelCount),
+                0);
+
+        state->mNumFramesWritten = 0;
+    }
+
+    return OK;
+}
+
+void SimplePlayer::renderAudio(
+        CodecState *state, BufferInfo *info, const sp<ABuffer> &buffer) {
+    CHECK(state->mAudioTrack != NULL);
+
+    if (state->mAudioTrack->stopped()) {
+        state->mAudioTrack->start();
+    }
+
+    uint32_t numFramesPlayed;
+    CHECK_EQ(state->mAudioTrack->getPosition(&numFramesPlayed), (status_t)OK);
+
+    uint32_t numFramesAvailableToWrite =
+        state->mAudioTrack->frameCount()
+            - (state->mNumFramesWritten - numFramesPlayed);
+
+    size_t numBytesAvailableToWrite =
+        numFramesAvailableToWrite * state->mAudioTrack->frameSize();
+
+    size_t copy = info->mSize;
+    if (copy > numBytesAvailableToWrite) {
+        copy = numBytesAvailableToWrite;
+    }
+
+    if (copy == 0) {
+        return;
+    }
+
+    int64_t startTimeUs = ALooper::GetNowUs();
+
+    ssize_t nbytes = state->mAudioTrack->write(
+            buffer->base() + info->mOffset, copy);
+
+    CHECK_EQ(nbytes, (ssize_t)copy);
+
+    int64_t delayUs = ALooper::GetNowUs() - startTimeUs;
+
+    uint32_t numFramesWritten = nbytes / state->mAudioTrack->frameSize();
+
+    if (delayUs > 2000ll) {
+        ALOGW("AudioTrack::write took %lld us, numFramesAvailableToWrite=%u, "
+              "numFramesWritten=%u",
+              delayUs, numFramesAvailableToWrite, numFramesWritten);
+    }
+
+    info->mOffset += nbytes;
+    info->mSize -= nbytes;
+
+    state->mNumFramesWritten += numFramesWritten;
+}
+
+}  // namespace android

=== added file 'android/compat/media/SimplePlayer.h'
--- android/compat/media/SimplePlayer.h	1970-01-01 00:00:00 +0000
+++ android/compat/media/SimplePlayer.h	2016-01-11 14:31:46 +0000
@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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 <media/stagefright/foundation/AHandler.h>
+#include <media/stagefright/foundation/AString.h>
+#include <utils/KeyedVector.h>
+
+#include <hybris/media/media_codec_layer.h>
+
+namespace android {
+
+struct ABuffer;
+struct ALooper;
+struct AudioTrack;
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+struct ISurfaceTexture;
+#else
+struct IGraphicBufferProducer;
+#endif
+struct MediaCodec;
+struct NativeWindowWrapper;
+struct NuMediaExtractor;
+
+struct SimplePlayer : public AHandler {
+    SimplePlayer();
+
+    status_t setDataSource(const char *path);
+#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
+    status_t setSurface(const sp<ISurfaceTexture> &surfaceTexture);
+#else
+    status_t setSurface(const sp<IGraphicBufferProducer> &surfaceTexture);
+#endif
+    status_t prepare();
+    status_t start();
+    status_t stop();
+    status_t reset();
+
+protected:
+    virtual ~SimplePlayer();
+
+    virtual void onMessageReceived(const sp<AMessage> &msg);
+
+private:
+    enum State {
+        UNINITIALIZED,
+        UNPREPARED,
+        STOPPED,
+        STARTED
+    };
+
+    enum {
+        kWhatSetDataSource,
+        kWhatSetSurface,
+        kWhatPrepare,
+        kWhatStart,
+        kWhatStop,
+        kWhatReset,
+        kWhatDoMoreStuff,
+    };
+
+    struct BufferInfo {
+        size_t mIndex;
+        size_t mOffset;
+        size_t mSize;
+        int64_t mPresentationTimeUs;
+        uint32_t mFlags;
+    };
+
+    struct CodecState
+    {
+        sp<MediaCodec> mCodec;
+        MediaCodecDelegate mCodecDelegate;
+        Vector<sp<ABuffer> > mCSD;
+        Vector<sp<ABuffer> > mBuffers[2];
+
+        List<size_t> mAvailInputBufferIndices;
+        List<BufferInfo> mAvailOutputBufferInfos;
+
+        sp<AudioTrack> mAudioTrack;
+        uint32_t mNumFramesWritten;
+    };
+
+    State mState;
+    AString mPath;
+    sp<NativeWindowWrapper> mNativeWindow;
+
+    sp<NuMediaExtractor> mExtractor;
+    sp<ALooper> mCodecLooper;
+    KeyedVector<size_t, CodecState> mStateByTrackIndex;
+    int32_t mDoMoreStuffGeneration;
+
+    int64_t mStartTimeRealUs;
+
+    status_t onPrepare();
+    status_t onStart();
+    status_t onStop();
+    status_t onReset();
+    status_t onDoMoreStuff();
+    status_t onOutputFormatChanged(size_t trackIndex, CodecState *state);
+
+    void renderAudio(
+            CodecState *state, BufferInfo *info, const sp<ABuffer> &buffer);
+
+    DISALLOW_EVIL_CONSTRUCTORS(SimplePlayer);
+};
+
+}  // namespace android

=== added file 'android/compat/media/camera_service.cpp'
--- android/compat/media/camera_service.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/media/camera_service.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#define LOG_NDEBUG 0
+#undef LOG_TAG
+#define LOG_TAG "CameraServiceCompatLayer"
+
+#include "media_recorder_factory.h"
+#include "media_recorder.h"
+
+#include <media/camera_record_service.h>
+#include <CameraService.h>
+
+#include <signal.h>
+
+#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
+
+using namespace android;
+
+/*!
+ * \brief main() instantiates the MediaRecorderFactory Binder server and the CameraService
+ */
+int main(int argc, char** argv)
+{
+    signal(SIGPIPE, SIG_IGN);
+
+    ALOGV("Starting camera services (MediaRecorderFactory, CameraRecordService & CameraService)");
+
+    // Instantiate the in-process MediaRecorderFactory which is responsible
+    // for creating a new IMediaRecorder (MediaRecorder) instance over Binder
+    MediaRecorderFactory::instantiate();
+    // Enable audio recording for camera recording
+    CameraRecordService::instantiate();
+    CameraService::instantiate();
+    ProcessState::self()->startThreadPool();
+    IPCThreadState::self()->joinThreadPool();
+}

=== added file 'android/compat/media/codec.cpp'
--- android/compat/media/codec.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/media/codec.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,433 @@
+/*
+ * Copyright (C) 2012 The Android Open Source Project
+ *
+ * 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.
+ */
+
+#define LOG_NDEBUG 0
+#define LOG_TAG "codec"
+#include <utils/Log.h>
+
+#include "SimplePlayer.h"
+
+#include <binder/IServiceManager.h>
+#include <binder/ProcessState.h>
+#include <media/ICrypto.h>
+#include <media/IMediaPlayerService.h>
+#include <media/stagefright/foundation/ABuffer.h>
+#include <media/stagefright/foundation/ADebug.h>
+#include <media/stagefright/foundation/ALooper.h>
+#include <media/stagefright/foundation/AMessage.h>
+#include <media/stagefright/foundation/AString.h>
+#include <media/stagefright/DataSource.h>
+#include <media/stagefright/MediaCodec.h>
+#include <media/stagefright/MediaCodecList.h>
+#include <media/stagefright/MediaDefs.h>
+#include <media/stagefright/NuMediaExtractor.h>
+#include <gui/ISurfaceComposer.h>
+#include <gui/SurfaceComposerClient.h>
+#include <ui/DisplayInfo.h>
+
+static void usage(const char *me) {
+    fprintf(stderr, "usage: %s [-a] use audio\n"
+                    "\t\t[-v] use video\n"
+                    "\t\t[-p] playback\n"
+                    "\t\t[-S] allocate buffers from a surface\n",
+                    me);
+
+    exit(1);
+}
+
+namespace android {
+
+struct CodecState {
+    sp<MediaCodec> mCodec;
+    Vector<sp<ABuffer> > mInBuffers;
+    Vector<sp<ABuffer> > mOutBuffers;
+    bool mSignalledInputEOS;
+    bool mSawOutputEOS;
+    int64_t mNumBuffersDecoded;
+    int64_t mNumBytesDecoded;
+    bool mIsAudio;
+};
+
+}  // namespace android
+
+static int decode(
+        const android::sp<android::ALooper> &looper,
+        const char *path,
+        bool useAudio,
+        bool useVideo,
+        const android::sp<android::Surface> &surface) {
+    using namespace android;
+
+    static int64_t kTimeout = 500ll;
+
+    sp<NuMediaExtractor> extractor = new NuMediaExtractor;
+    if (extractor->setDataSource(path) != OK) {
+        fprintf(stderr, "unable to instantiate extractor.\n");
+        return 1;
+    }
+
+    KeyedVector<size_t, CodecState> stateByTrack;
+
+    bool haveAudio = false;
+    bool haveVideo = false;
+    for (size_t i = 0; i < extractor->countTracks(); ++i) {
+        sp<AMessage> format;
+        status_t err = extractor->getTrackFormat(i, &format);
+        CHECK_EQ(err, (status_t)OK);
+
+        AString mime;
+        CHECK(format->findString("mime", &mime));
+
+        bool isAudio = !strncasecmp(mime.c_str(), "audio/", 6);
+        bool isVideo = !strncasecmp(mime.c_str(), "video/", 6);
+
+        if (useAudio && !haveAudio && isAudio) {
+            haveAudio = true;
+        } else if (useVideo && !haveVideo && isVideo) {
+            haveVideo = true;
+        } else {
+            continue;
+        }
+
+        ALOGV("selecting track %d", i);
+
+        err = extractor->selectTrack(i);
+        CHECK_EQ(err, (status_t)OK);
+
+        CodecState *state =
+            &stateByTrack.editValueAt(stateByTrack.add(i, CodecState()));
+
+        state->mNumBytesDecoded = 0;
+        state->mNumBuffersDecoded = 0;
+        state->mIsAudio = isAudio;
+
+        state->mCodec = MediaCodec::CreateByType(
+                looper, mime.c_str(), false /* encoder */);
+
+        CHECK(state->mCodec != NULL);
+
+        err = state->mCodec->configure(
+                format, isVideo ? surface : NULL,
+                NULL /* crypto */,
+                0 /* flags */);
+
+        CHECK_EQ(err, (status_t)OK);
+
+        state->mSignalledInputEOS = false;
+        state->mSawOutputEOS = false;
+    }
+
+    CHECK(!stateByTrack.isEmpty());
+
+    int64_t startTimeUs = ALooper::GetNowUs();
+
+    for (size_t i = 0; i < stateByTrack.size(); ++i) {
+        CodecState *state = &stateByTrack.editValueAt(i);
+
+        sp<MediaCodec> codec = state->mCodec;
+
+        CHECK_EQ((status_t)OK, codec->start());
+
+        CHECK_EQ((status_t)OK, codec->getInputBuffers(&state->mInBuffers));
+        CHECK_EQ((status_t)OK, codec->getOutputBuffers(&state->mOutBuffers));
+
+        ALOGV("got %d input and %d output buffers",
+              state->mInBuffers.size(), state->mOutBuffers.size());
+    }
+
+    bool sawInputEOS = false;
+
+    for (;;) {
+        if (!sawInputEOS) {
+            size_t trackIndex;
+            status_t err = extractor->getSampleTrackIndex(&trackIndex);
+
+            if (err != OK) {
+                ALOGV("saw input eos");
+                sawInputEOS = true;
+            } else {
+                CodecState *state = &stateByTrack.editValueFor(trackIndex);
+
+                size_t index;
+                err = state->mCodec->dequeueInputBuffer(&index, kTimeout);
+
+                if (err == OK) {
+                    ALOGV("filling input buffer %d", index);
+
+                    const sp<ABuffer> &buffer = state->mInBuffers.itemAt(index);
+
+                    err = extractor->readSampleData(buffer);
+                    CHECK_EQ(err, (status_t)OK);
+
+                    int64_t timeUs;
+                    err = extractor->getSampleTime(&timeUs);
+                    CHECK_EQ(err, (status_t)OK);
+
+                    uint32_t bufferFlags = 0;
+
+                    err = state->mCodec->queueInputBuffer(
+                            index,
+                            0 /* offset */,
+                            buffer->size(),
+                            timeUs,
+                            bufferFlags);
+
+                    CHECK_EQ(err, (status_t)OK);
+
+                    extractor->advance();
+                } else {
+                    CHECK_EQ(err, -EAGAIN);
+                }
+            }
+        } else {
+            for (size_t i = 0; i < stateByTrack.size(); ++i) {
+                CodecState *state = &stateByTrack.editValueAt(i);
+
+                if (!state->mSignalledInputEOS) {
+                    size_t index;
+                    status_t err =
+                        state->mCodec->dequeueInputBuffer(&index, kTimeout);
+
+                    if (err == OK) {
+                        ALOGV("signalling input EOS on track %d", i);
+
+                        err = state->mCodec->queueInputBuffer(
+                                index,
+                                0 /* offset */,
+                                0 /* size */,
+                                0ll /* timeUs */,
+                                MediaCodec::BUFFER_FLAG_EOS);
+
+                        CHECK_EQ(err, (status_t)OK);
+
+                        state->mSignalledInputEOS = true;
+                    } else {
+                        CHECK_EQ(err, -EAGAIN);
+                    }
+                }
+            }
+        }
+
+        bool sawOutputEOSOnAllTracks = true;
+        for (size_t i = 0; i < stateByTrack.size(); ++i) {
+            CodecState *state = &stateByTrack.editValueAt(i);
+            if (!state->mSawOutputEOS) {
+                sawOutputEOSOnAllTracks = false;
+                break;
+            }
+        }
+
+        if (sawOutputEOSOnAllTracks) {
+            break;
+        }
+
+        for (size_t i = 0; i < stateByTrack.size(); ++i) {
+            CodecState *state = &stateByTrack.editValueAt(i);
+
+            if (state->mSawOutputEOS) {
+                continue;
+            }
+
+            size_t index;
+            size_t offset;
+            size_t size;
+            int64_t presentationTimeUs;
+            uint32_t flags;
+            status_t err = state->mCodec->dequeueOutputBuffer(
+                    &index, &offset, &size, &presentationTimeUs, &flags,
+                    kTimeout);
+
+            if (err == OK) {
+                ALOGV("draining output buffer %d, time = %lld us",
+                      index, presentationTimeUs);
+
+                ++state->mNumBuffersDecoded;
+                state->mNumBytesDecoded += size;
+
+                err = state->mCodec->releaseOutputBuffer(index);
+                CHECK_EQ(err, (status_t)OK);
+
+                if (flags & MediaCodec::BUFFER_FLAG_EOS) {
+                    ALOGV("reached EOS on output.");
+
+                    state->mSawOutputEOS = true;
+                }
+            } else if (err == INFO_OUTPUT_BUFFERS_CHANGED) {
+                ALOGV("INFO_OUTPUT_BUFFERS_CHANGED");
+                CHECK_EQ((status_t)OK,
+                         state->mCodec->getOutputBuffers(&state->mOutBuffers));
+
+                ALOGV("got %d output buffers", state->mOutBuffers.size());
+            } else if (err == INFO_FORMAT_CHANGED) {
+                sp<AMessage> format;
+                CHECK_EQ((status_t)OK, state->mCodec->getOutputFormat(&format));
+
+                ALOGV("INFO_FORMAT_CHANGED: %s", format->debugString().c_str());
+            } else {
+                CHECK_EQ(err, -EAGAIN);
+            }
+        }
+    }
+
+    int64_t elapsedTimeUs = ALooper::GetNowUs() - startTimeUs;
+
+    for (size_t i = 0; i < stateByTrack.size(); ++i) {
+        CodecState *state = &stateByTrack.editValueAt(i);
+
+        CHECK_EQ((status_t)OK, state->mCodec->release());
+
+        if (state->mIsAudio) {
+            ALOGD("track %d: %lld bytes received. %.2f KB/sec\n",
+                   i,
+                   state->mNumBytesDecoded,
+                   state->mNumBytesDecoded * 1E6 / 1024 / elapsedTimeUs);
+        } else {
+            ALOGD("track %d: %lld frames decoded, %.2f fps. %lld bytes "
+                   "received. %.2f KB/sec\n",
+                   i,
+                   state->mNumBuffersDecoded,
+                   state->mNumBuffersDecoded * 1E6 / elapsedTimeUs,
+                   state->mNumBytesDecoded,
+                   state->mNumBytesDecoded * 1E6 / 1024 / elapsedTimeUs);
+        }
+    }
+
+    return 0;
+}
+
+int main(int argc, char **argv) {
+    using namespace android;
+
+    const char *me = argv[0];
+
+    bool useAudio = false;
+    bool useVideo = false;
+    bool playback = false;
+    bool useSurface = false;
+
+    int res;
+    while ((res = getopt(argc, argv, "havpSD")) >= 0) {
+        switch (res) {
+            case 'a':
+            {
+                useAudio = true;
+                break;
+            }
+
+            case 'v':
+            {
+                useVideo = true;
+                break;
+            }
+
+            case 'p':
+            {
+                playback = true;
+                break;
+            }
+
+            case 'S':
+            {
+                useSurface = true;
+                break;
+            }
+
+            case '?':
+            case 'h':
+            default:
+            {
+                usage(me);
+            }
+        }
+    }
+
+    argc -= optind;
+    argv += optind;
+
+    if (argc != 1) {
+        usage(me);
+    }
+
+    if (!useAudio && !useVideo) {
+        useAudio = useVideo = true;
+    }
+
+    ProcessState::self()->startThreadPool();
+
+    DataSource::RegisterDefaultSniffers();
+
+    sp<ALooper> looper = new ALooper;
+    looper->start();
+
+    sp<SurfaceComposerClient> composerClient;
+    sp<SurfaceControl> control;
+    sp<Surface> surface;
+
+    if (playback || (useSurface && useVideo)) {
+        composerClient = new SurfaceComposerClient;
+        CHECK_EQ(composerClient->initCheck(), (status_t)OK);
+
+        sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
+                ISurfaceComposer::eDisplayIdMain));
+        DisplayInfo info;
+        SurfaceComposerClient::getDisplayInfo(display, &info);
+        ssize_t displayWidth = info.w;
+        ssize_t displayHeight = info.h;
+
+        ALOGV("display is %ld x %ld\n", displayWidth, displayHeight);
+
+        control = composerClient->createSurface(
+                String8("A Surface"),
+                displayWidth,
+                displayHeight,
+                PIXEL_FORMAT_RGB_565,
+                0);
+
+        CHECK(control != NULL);
+        CHECK(control->isValid());
+
+        SurfaceComposerClient::openGlobalTransaction();
+        CHECK_EQ(control->setLayer(INT_MAX), (status_t)OK);
+        CHECK_EQ(control->show(), (status_t)OK);
+        SurfaceComposerClient::closeGlobalTransaction();
+
+        surface = control->getSurface();
+        CHECK(surface != NULL);
+    }
+
+    if (playback) {
+        sp<SimplePlayer> player = new SimplePlayer;
+        looper->registerHandler(player);
+
+        player->setDataSource(argv[0]);
+        player->setSurface(surface->getSurfaceTexture());
+        player->start();
+        ALOGD("Playing for 60 seconds\n");
+        sleep(60);
+        player->stop();
+        player->reset();
+    } else {
+        decode(looper, argv[0], useAudio, useVideo, surface);
+    }
+
+    if (playback || (useSurface && useVideo)) {
+        composerClient->dispose();
+    }
+
+    looper->stop();
+
+    return 0;
+}

=== added file 'android/compat/media/decoding_service.cpp'
--- android/compat/media/decoding_service.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/media/decoding_service.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,366 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+// Uncomment to enable verbose debug output
+#define LOG_NDEBUG 0
+
+#undef LOG_TAG
+#define LOG_TAG "DecodingService"
+
+#include "decoding_service_priv.h"
+
+#include <binder/IServiceManager.h>
+#include <binder/Parcel.h>
+#include <binder/IPCThreadState.h>
+#include <binder/ProcessState.h>
+#include <binder/BpBinder.h>
+
+typedef void* EGLDisplay;
+typedef void* EGLSyncKHR;
+
+#include <ui/GraphicBuffer.h>
+#include <gui/GraphicBufferAlloc.h>
+#include <gui/IGraphicBufferProducer.h>
+#include <gui/IGraphicBufferConsumer.h>
+#include <gui/Surface.h>
+#include <gui/NativeBufferAlloc.h>
+
+namespace android {
+
+IMPLEMENT_META_INTERFACE(DecodingService, "android.media.IDecodingService");
+IMPLEMENT_META_INTERFACE(DecodingServiceSession, "android.media.IDecodingServiceSession");
+
+enum {
+    GET_IGRAPHICBUFFERCONSUMER = IBinder::FIRST_CALL_TRANSACTION,
+    GET_IGRAPHICBUFFERPRODUCER,
+    REGISTER_SESSION,
+    UNREGISTER_SESSION,
+};
+
+// ----------------------------------------------------------------------
+
+status_t BnDecodingService::onTransact(
+    uint32_t code, const Parcel& data, Parcel* reply, uint32_t flags)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    switch (code) {
+        case GET_IGRAPHICBUFFERCONSUMER: {
+            CHECK_INTERFACE(IDecodingService, data, reply);
+            sp<IGraphicBufferConsumer> gbc;
+            status_t res = getIGraphicBufferConsumer(&gbc);
+
+            reply->writeStrongBinder(gbc->asBinder());
+            reply->writeInt32(res);
+
+            return NO_ERROR;
+        } break;
+        case GET_IGRAPHICBUFFERPRODUCER: {
+            CHECK_INTERFACE(IDecodingService, data, reply);
+            sp<IGraphicBufferProducer> gbp;
+            status_t res = getIGraphicBufferProducer(&gbp);
+
+            reply->writeStrongBinder(gbp->asBinder());
+            reply->writeInt32(res);
+
+            return NO_ERROR;
+        } break;
+        case REGISTER_SESSION: {
+            CHECK_INTERFACE(IDecodingService, data, reply);
+            sp<IBinder> binder = data.readStrongBinder();
+            uint32_t handle = data.readInt32();
+            sp<IDecodingServiceSession> session(new BpDecodingServiceSession(binder));
+            registerSession(session, handle);
+
+            return NO_ERROR;
+        } break;
+        case UNREGISTER_SESSION: {
+            CHECK_INTERFACE(IDecodingService, data, reply);
+            unregisterSession();
+
+            return NO_ERROR;
+        } break;
+        default:
+            return BBinder::onTransact(code, data, reply, flags);
+    }
+}
+
+status_t BpDecodingService::getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    Parcel data, reply;
+    data.writeInterfaceToken(IDecodingService::getInterfaceDescriptor());
+    remote()->transact(GET_IGRAPHICBUFFERCONSUMER, data, &reply);
+    *gbc = interface_cast<IGraphicBufferConsumer>(reply.readStrongBinder());
+    return reply.readInt32();
+}
+
+status_t BpDecodingService::getIGraphicBufferProducer(sp<IGraphicBufferProducer>* gbp)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    Parcel data, reply;
+    data.writeInterfaceToken(IDecodingService::getInterfaceDescriptor());
+    remote()->transact(GET_IGRAPHICBUFFERPRODUCER, data, &reply);
+    *gbp = interface_cast<IGraphicBufferProducer>(reply.readStrongBinder());
+    return NO_ERROR;
+}
+
+status_t BpDecodingService::registerSession(const sp<IDecodingServiceSession>& session, uint32_t handle)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    Parcel data, reply;
+    data.writeInterfaceToken(IDecodingService::getInterfaceDescriptor());
+    data.writeStrongBinder(session->asBinder());
+    data.writeInt32(handle);
+    remote()->transact(REGISTER_SESSION, data, &reply);
+    return NO_ERROR;
+}
+
+status_t BpDecodingService::unregisterSession()
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    Parcel data, reply;
+    data.writeInterfaceToken(IDecodingService::getInterfaceDescriptor());
+    remote()->transact(UNREGISTER_SESSION, data, &reply);
+    return NO_ERROR;
+}
+
+sp<DecodingService> DecodingService::decoding_service = NULL;
+
+DecodingService::DecodingService()
+    : client_death_cb(NULL),
+      client_death_context(NULL)
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+DecodingService::~DecodingService()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+void DecodingService::instantiate()
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    defaultServiceManager()->addService(
+            String16(IDecodingService::exported_service_name()), service_instance());
+    ALOGD("Added Binder service '%s' to ServiceManager", IDecodingService::exported_service_name());
+
+    service_instance()->createBufferQueue();
+}
+
+sp<DecodingService>& DecodingService::service_instance()
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+
+    // TODO Add a mutex here
+    if (decoding_service == NULL)
+    {
+        ALOGD("Creating new static instance of DecodingService");
+        decoding_service = new DecodingService();
+    }
+
+    return decoding_service;
+}
+
+void DecodingService::setDecodingClientDeathCb(DecodingClientDeathCbHybris cb, uint32_t handle, void* context)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+
+    ClientCb *holder = (ClientCb*) malloc(sizeof(ClientCb));
+    holder->cb = cb;
+    holder->context = context;
+
+    clients.add(handle, holder);
+}
+
+status_t DecodingService::getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc)
+{
+    // TODO: Make sure instantiate() has been called first
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    pid_t pid = IPCThreadState::self()->getCallingPid();
+    ALOGD("Calling Pid: %d", pid);
+
+#if ANDROID_VERSION_MAJOR==5
+    *gbc = consumer;
+#else
+    *gbc = buffer_queue;
+#endif
+
+    return OK;
+}
+
+status_t DecodingService::getIGraphicBufferProducer(sp<IGraphicBufferProducer>* gbp)
+{
+    pid_t pid = IPCThreadState::self()->getCallingPid();
+    ALOGD("Calling Pid: %d", pid);
+
+#if ANDROID_VERSION_MAJOR==5
+    *gbp = producer;
+#else
+    *gbp = buffer_queue;
+#endif
+    ALOGD("producer(gbp): %p", (void*)gbp->get());
+    return OK;
+}
+
+status_t DecodingService::registerSession(const sp<IDecodingServiceSession>& session, uint32_t handle)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+
+    // Add session/handle to running clients map and connect death observer
+    status_t ret = session->asBinder()->linkToDeath(sp<IBinder::DeathRecipient>(this));
+    clientCbs.add(session->asBinder(), clients.valueFor(handle));
+    clients.removeItem(handle);
+
+    // Create a new BufferQueue instance so that the next created client plays
+    // video correctly
+    createBufferQueue();
+
+    return ret;
+}
+
+status_t DecodingService::unregisterSession()
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    if (session != NULL)
+    {
+        session->asBinder()->unlinkToDeath(this);
+        session.clear();
+        // Reset the BufferQueue instance so that the next created client plays
+        // video correctly
+#if ANDROID_VERSION_MAJOR==5
+        producer.clear();
+        consumer.clear();
+#else
+        buffer_queue.clear();
+#endif
+    }
+
+    return OK;
+}
+
+void DecodingService::createBufferQueue()
+{
+    // Use a new native buffer allocator vs the default one, which means it'll use the proper one
+    // that will allow rendering to work with Mir
+    sp<IGraphicBufferAlloc> g_buffer_alloc(new GraphicBufferAlloc());
+
+    // This BuferQueue is shared between the client and the service
+#if ANDROID_VERSION_MAJOR==5
+    BufferQueue::createBufferQueue(&producer, &consumer);
+#elif ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
+    sp<NativeBufferAlloc> native_alloc(new NativeBufferAlloc());
+    buffer_queue = new BufferQueue(false, NULL, native_alloc);
+#else
+    buffer_queue = new BufferQueue(NULL);
+    ALOGD("buffer_queue: %p", (void*)buffer_queue.get());
+#endif
+#if ANDROID_VERSION_MAJOR==5
+    producer->setBufferCount(5);
+#else
+    buffer_queue->setBufferCount(5);
+#endif
+}
+
+void DecodingService::binderDied(const wp<IBinder>& who)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+
+    sp<IBinder> sp = who.promote();
+    ClientCb *cb = clientCbs.valueFor(sp);
+
+    if (cb && cb->cb != NULL) {
+        cb->cb(cb->context);
+        free(cb);
+        clientCbs.removeItem(sp);
+    }
+
+    unregisterSession();
+}
+
+sp<BpDecodingService> DecodingClient::decoding_service = NULL;
+
+DecodingClient::DecodingClient()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+
+    ProcessState::self()->startThreadPool();
+}
+
+DecodingClient::~DecodingClient()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+sp<BpDecodingService>& DecodingClient::service_instance()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+    // TODO: Add a mutex here
+    if (decoding_service == NULL)
+    {
+        ALOGD("Creating a new static BpDecodingService instance");
+        sp<IServiceManager> service_manager = defaultServiceManager();
+        sp<IBinder> service = service_manager->getService(
+                String16(IDecodingService::exported_service_name()));
+        decoding_service = new BpDecodingService(service);
+    }
+
+    return decoding_service;
+}
+
+status_t DecodingClient::getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    return service_instance()->getIGraphicBufferConsumer(gbc);
+}
+
+// IDecodingServiceSession
+
+BpDecodingServiceSession::BpDecodingServiceSession(const sp<IBinder>& impl)
+    : BpInterface<IDecodingServiceSession>(impl)
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+BpDecodingServiceSession::~BpDecodingServiceSession()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+BnDecodingServiceSession::BnDecodingServiceSession()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+BnDecodingServiceSession::~BnDecodingServiceSession()
+{
+    ALOGD("%s", __PRETTY_FUNCTION__);
+}
+
+status_t BnDecodingServiceSession::onTransact(uint32_t code, const Parcel& data,
+            Parcel* reply, uint32_t flags)
+{
+    ALOGD("Entering %s", __PRETTY_FUNCTION__);
+
+    return NO_ERROR;
+}
+
+// ----- C API ----- //
+
+
+}; // namespace android

=== added file 'android/compat/media/decoding_service_priv.h'
--- android/compat/media/decoding_service_priv.h	1970-01-01 00:00:00 +0000
+++ android/compat/media/decoding_service_priv.h	2016-01-11 14:31:46 +0000
@@ -0,0 +1,208 @@
+/*
+ * Copyright (C) 2014 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#ifndef DECODING_SERVICE_PRIV_H_
+#define DECODING_SERVICE_PRIV_H_
+
+#include "surface_texture_client_hybris_priv.h"
+
+#include <binder/IInterface.h>
+#include <binder/Parcel.h>
+
+namespace android {
+
+typedef struct {
+    DecodingClientDeathCbHybris cb;
+    void *context;
+} ClientCb;
+
+class IGraphicBufferConsumer;
+class IGraphicBufferProducer;
+class BufferQueue;
+class GLConsumer;
+
+class IDecodingServiceSession : public IInterface
+{
+public:
+    DECLARE_META_INTERFACE(DecodingServiceSession);
+
+    static const char* exported_service_name() { return "android.media.IDecodingServiceSession"; }
+
+};
+
+class BnDecodingServiceSession : public BnInterface<IDecodingServiceSession>
+{
+public:
+    BnDecodingServiceSession();
+    virtual ~BnDecodingServiceSession();
+
+    virtual status_t onTransact(uint32_t code, const Parcel& data,
+                                Parcel* reply, uint32_t flags = 0);
+};
+
+enum {
+    SET_DECODING_CLIENT_DEATH_CB = IBinder::FIRST_CALL_TRANSACTION,
+};
+
+class BpDecodingServiceSession : public BpInterface<IDecodingServiceSession>
+{
+public:
+    BpDecodingServiceSession(const sp<IBinder>& impl);
+    ~BpDecodingServiceSession();
+};
+
+class IDecodingService: public IInterface
+{
+public:
+    DECLARE_META_INTERFACE(DecodingService);
+
+    static const char* exported_service_name() { return "android.media.IDecodingService"; }
+
+    virtual status_t getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc) = 0;
+    virtual status_t getIGraphicBufferProducer(sp<IGraphicBufferProducer>* gbp) = 0;
+    virtual status_t registerSession(const sp<IDecodingServiceSession>& session, uint32_t handle) = 0;
+    virtual status_t unregisterSession() = 0;
+};
+
+class BnDecodingService: public BnInterface<IDecodingService>
+{
+public:
+    virtual status_t onTransact( uint32_t code,
+                                 const Parcel& data,
+                                 Parcel* reply,
+                                 uint32_t flags = 0);
+};
+
+class BpDecodingService: public BpInterface<IDecodingService>
+{
+public:
+    BpDecodingService(const sp<IBinder>& impl)
+        : BpInterface<IDecodingService>(impl)
+    {
+        ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    }
+
+    virtual status_t getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc);
+    virtual status_t getIGraphicBufferProducer(sp<IGraphicBufferProducer>* gbp);
+    virtual status_t registerSession(const sp<IDecodingServiceSession>& session, uint32_t handle);
+    virtual status_t unregisterSession();
+};
+
+class DecodingService : public BnDecodingService,
+                        public IBinder::DeathRecipient
+{
+public:
+    DecodingService();
+    virtual ~DecodingService();
+    /** Adds the decoding service to the default service manager in Binder **/
+    static void instantiate();
+    static sp<DecodingService>& service_instance();
+
+    virtual void setDecodingClientDeathCb(DecodingClientDeathCbHybris cb, uint32_t handle, void* context);
+
+    // IDecodingService interface:
+    virtual status_t getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc);
+    virtual status_t getIGraphicBufferProducer(sp<IGraphicBufferProducer>* gbp);
+
+    virtual status_t registerSession(const sp<IDecodingServiceSession>& session, uint32_t handle);
+    virtual status_t unregisterSession();
+
+    /** Get notified when the Binder connection to the client dies **/
+    virtual void binderDied(const wp<IBinder>& who);
+
+protected:
+    virtual void createBufferQueue();
+
+private:
+    static sp<DecodingService> decoding_service;
+#if ANDROID_VERSION_MAJOR==5
+    sp<IGraphicBufferProducer> producer;
+    sp<IGraphicBufferConsumer> consumer;
+#else
+    sp<BufferQueue> buffer_queue;
+#endif
+    sp<IDecodingServiceSession> session;
+    DecodingClientDeathCbHybris client_death_cb;
+    void *client_death_context;
+    KeyedVector< uint32_t, ClientCb* > clients;
+    KeyedVector< sp<IBinder>, ClientCb* > clientCbs;
+};
+
+class DecodingClient
+{
+public:
+    DecodingClient();
+    virtual ~DecodingClient();
+
+    static sp<BpDecodingService>& service_instance();
+
+    virtual status_t getIGraphicBufferConsumer(sp<IGraphicBufferConsumer>* gbc);
+
+private:
+    static sp<BpDecodingService> decoding_service;
+};
+
+struct IGBCWrapper
+{
+    IGBCWrapper(const sp<IGraphicBufferConsumer>& igbc)
+    {
+        consumer = igbc;
+    }
+
+    sp<IGraphicBufferConsumer> consumer;
+};
+
+struct IGBPWrapper
+{
+    IGBPWrapper(const sp<IGraphicBufferProducer>& igbp)
+    {
+        producer = igbp;
+    }
+
+    sp<IGraphicBufferProducer> producer;
+};
+
+struct GLConsumerWrapper
+{
+    GLConsumerWrapper(const sp<_GLConsumerHybris>& gl_consumer)
+    {
+        consumer = gl_consumer;
+    }
+
+    sp<_GLConsumerHybris> consumer;
+};
+
+struct DSSessionWrapper
+{
+    DSSessionWrapper(const sp<IDecodingServiceSession>& session)
+    {
+        ALOGD("Entering %s", __PRETTY_FUNCTION__);
+        this->session = session;
+    }
+
+    ~DSSessionWrapper()
+    {
+        ALOGD("Entering %s", __PRETTY_FUNCTION__);
+    }
+
+    sp<IDecodingServiceSession> session;
+};
+
+}; // namespace android
+
+#endif

=== added file 'android/compat/media/direct_media_test.cpp'
--- android/compat/media/direct_media_test.cpp	1970-01-01 00:00:00 +0000
+++ android/compat/media/direct_media_test.cpp	2016-01-11 14:31:46 +0000
@@ -0,0 +1,417 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ *              Ricardo Salveti de Araujo <[e-mail]>
+ */
+
+#include <hybris/media/media_compatibility_layer.h>
+#include "direct_media_test.h"
+
+#include <utils/Errors.h>
+
+#include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
+
+#include <GLES2/gl2.h>
+#include <GLES2/gl2ext.h>
+
+#include <sys/stat.h>
+#include <sys/types.h>
+#include <fcntl.h>
+#include <unistd.h>
+
+#include <cassert>
+#include <cstdio>
+#include <cstdlib>
+#include <cstring>
+
+using namespace android;
+
+static float DestWidth = 0.0, DestHeight = 0.0;
+// Actual video dimmensions
+static int Width = 0, Height = 0;
+
+static GLfloat positionCoordinates[8];
+
+MediaPlayerWrapper *player = NULL;
+
+void calculate_position_coordinates()
+{
+	// Assuming cropping output for now
+	float x = 1, y = 1;
+
+	// Black borders
+	x = float(Width / DestWidth);
+	y = float(Height / DestHeight);
+
+	// Make the larger side be 1
+	if (x > y) {
+		y /= x;
+		x = 1;
+	} else {
+		x /= y;
+		y = 1;
+	}
+
+	positionCoordinates[0] = -x;
+	positionCoordinates[1] = y;
+	positionCoordinates[2] = -x;
+	positionCoordinates[3] = -y;
+	positionCoordinates[4] = x;
+	positionCoordinates[5] = -y;
+	positionCoordinates[6] = x;
+	positionCoordinates[7] = y;
+}
+
+WindowRenderer::WindowRenderer(int width, int height)
+	: mThreadCmd(CMD_IDLE)
+{
+	createThread(threadStart, this);
+}
+
+WindowRenderer::~WindowRenderer()
+{
+}
+
+int WindowRenderer::threadStart(void* self)
+{
+	((WindowRenderer *)self)->glThread();
+	return 0;
+}
+
+void WindowRenderer::glThread()
+{
+	printf("%s\n", __PRETTY_FUNCTION__);
+
+	Mutex::Autolock autoLock(mLock);
+}
+
+struct ClientWithSurface
+{
+	SfClient* client;
+	SfSurface* surface;
+};
+
+ClientWithSurface client_with_surface(bool setup_surface_with_egl)
+{
+	ClientWithSurface cs = ClientWithSurface();
+
+	cs.client = sf_client_create();
+
+	if (!cs.client) {
+		printf("Problem creating client ... aborting now.");
+		return cs;
+	}
+
+	static const size_t primary_display = 0;
+
+	DestWidth = sf_get_display_width(primary_display);
+	DestHeight = sf_get_display_height(primary_display);
+	printf("Primary display width: %f, height: %f\n", DestWidth, DestHeight);
+
+	SfSurfaceCreationParameters params = {
+		0,
+		0,
+		(int) DestWidth,
+		(int) DestHeight,
+		-1, //PIXEL_FORMAT_RGBA_8888,
+		15000,
+		0.5f,
+		setup_surface_with_egl, // Do not associate surface with egl, will be done by camera HAL
+		"MediaCompatLayerTestSurface"
+	};
+
+	cs.surface = sf_surface_create(cs.client, &params);
+
+	if (!cs.surface) {
+		printf("Problem creating surface ... aborting now.");
+		return cs;
+	}
+
+	sf_surface_make_current(cs.surface);
+
+	return cs;
+}
+
+struct RenderData
+{
+	static const char *vertex_shader()
+	{
+		return
+			"attribute vec4 a_position;                                  \n"
+			"attribute vec2 a_texCoord;                                  \n"
+			"uniform mat4 m_texMatrix;                                   \n"
+			"varying vec2 v_texCoord;                                    \n"
+			"varying float topDown;                                      \n"
+			"void main()                                                 \n"
+			"{                                                           \n"
+			"   gl_Position = a_position;                                \n"
+			"   v_texCoord = (m_texMatrix * vec4(a_texCoord, 0.0, 1.0)).xy;\n"
+			"}                                                           \n";
+	}
+
+	static const char *fragment_shader()
+	{
+		return
+			"#extension GL_OES_EGL_image_external : require      \n"
+			"precision mediump float;                            \n"
+			"varying vec2 v_texCoord;                            \n"
+			"uniform samplerExternalOES s_texture;               \n"
+			"void main()                                         \n"
+			"{                                                   \n"
+			"  gl_FragColor = texture2D( s_texture, v_texCoord );\n"
+			"}                                                   \n";
+	}
+
+	static GLuint loadShader(GLenum shaderType, const char* pSource)
+	{
+		GLuint shader = glCreateShader(shaderType);
+
+		if (shader) {
+			glShaderSource(shader, 1, &pSource, NULL);
+			glCompileShader(shader);
+			GLint compiled = 0;
+			glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
+
+			if (!compiled) {
+				GLint infoLen = 0;
+				glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
+				if (infoLen) {
+					char* buf = (char*) malloc(infoLen);
+					if (buf) {
+						glGetShaderInfoLog(shader, infoLen, NULL, buf);
+						fprintf(stderr, "Could not compile shader %d:\n%s\n",
+								shaderType, buf);
+						free(buf);
+					}
+					glDeleteShader(shader);
+					shader = 0;
+				}
+			}
+		} else {
+			printf("Error, during shader creation: %i\n", glGetError());
+		}
+
+		return shader;
+	}
+
+	static GLuint create_program(const char* pVertexSource, const char* pFragmentSource)
+	{
+		GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
+		if (!vertexShader) {
+			printf("vertex shader not compiled\n");
+			return 0;
+		}
+
+		GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
+		if (!pixelShader) {
+			printf("frag shader not compiled\n");
+			return 0;
+		}
+
+		GLuint program = glCreateProgram();
+		if (program) {
+			glAttachShader(program, vertexShader);
+			glAttachShader(program, pixelShader);
+			glLinkProgram(program);
+			GLint linkStatus = GL_FALSE;
+			glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
+
+			if (linkStatus != GL_TRUE) {
+				GLint bufLength = 0;
+				glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
+				if (bufLength) {
+					char* buf = (char*) malloc(bufLength);
+					if (buf) {
+						glGetProgramInfoLog(program, bufLength, NULL, buf);
+						fprintf(stderr, "Could not link program:\n%s\n", buf);
+						free(buf);
+					}
+				}
+				glDeleteProgram(program);
+				program = 0;
+			}
+		}
+
+		return program;
+	}
+
+	RenderData() : program_object(create_program(vertex_shader(), fragment_shader()))
+	{
+		position_loc = glGetAttribLocation(program_object, "a_position");
+		tex_coord_loc = glGetAttribLocation(program_object, "a_texCoord");
+		sampler_loc = glGetUniformLocation(program_object, "s_texture");
+		matrix_loc = glGetUniformLocation(program_object, "m_texMatrix");
+	}
+
+	// Handle to a program object
+	GLuint program_object;
+	// Attribute locations
+	GLint position_loc;
+	GLint tex_coord_loc;
+	// Sampler location
+	GLint sampler_loc;
+	// Matrix location
+	GLint matrix_loc;
+};
+
+static int setup_video_texture(ClientWithSurface *cs, GLuint *preview_texture_id)
+{
+	assert(cs != NULL);
+	assert(preview_texture_id != NULL);
+
+	sf_surface_make_current(cs->surface);
+
+	glGenTextures(1, preview_texture_id);
+	glClearColor(0, 0, 0, 0);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+	android_media_set_preview_texture(player, *preview_texture_id);
+
+	return 0;
+}
+
+static void print_gl_error(unsigned int line)
+{
+	GLint error = glGetError();
+	printf("GL error: %#04x (line: %d)\n", error, line);
+}
+
+static int update_gl_buffer(RenderData *render_data, EGLDisplay *disp, EGLSurface *surface)
+{
+	assert(disp != NULL);
+	assert(surface != NULL);
+
+	GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
+
+	const GLfloat textureCoordinates[] = {
+		1.0f,  1.0f,
+		0.0f,  1.0f,
+		0.0f,  0.0f,
+		1.0f,  0.0f
+	};
+
+	calculate_position_coordinates();
+
+	glClear(GL_COLOR_BUFFER_BIT);
+	// Use the program object
+	glUseProgram(render_data->program_object);
+	// Enable attributes
+	glEnableVertexAttribArray(render_data->position_loc);
+	glEnableVertexAttribArray(render_data->tex_coord_loc);
+	// Load the vertex position
+	glVertexAttribPointer(render_data->position_loc,
+			2,
+			GL_FLOAT,
+			GL_FALSE,
+			0,
+			positionCoordinates);
+	// Load the texture coordinate
+	glVertexAttribPointer(render_data->tex_coord_loc,
+			2,
+			GL_FLOAT,
+			GL_FALSE,
+			0,
+			textureCoordinates);
+
+	GLfloat matrix[16];
+	android_media_surface_texture_get_transformation_matrix(player, matrix);
+
+	glUniformMatrix4fv(render_data->matrix_loc, 1, GL_FALSE, matrix);
+
+	glActiveTexture(GL_TEXTURE0);
+	// Set the sampler texture unit to 0
+	glUniform1i(render_data->sampler_loc, 0);
+	glUniform1i(render_data->matrix_loc, 0);
+	android_media_update_surface_texture(player);
+	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+	//glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
+	glDisableVertexAttribArray(render_data->position_loc);
+	glDisableVertexAttribArray(render_data->tex_coord_loc);
+
+	eglSwapBuffers(*disp, *surface);
+
+	return 0;
+}
+
+void set_video_size_cb(int height, int width, void *context)
+{
+	printf("Video height: %d, width: %d\n", height, width);
+	printf("Video dest height: %f, width: %f\n", DestHeight, DestWidth);
+
+	Height = height;
+	Width = width;
+}
+
+int main(int argc, char **argv)
+{
+	if (argc < 2) {
+		printf("Usage: direct_media_test <video_to_play>\n");
+		return EXIT_FAILURE;
+	}
+
+	player = android_media_new_player();
+	if (player == NULL) {
+		printf("Problem creating new media player.\n");
+		return EXIT_FAILURE;
+	}
+
+	// Set player event cb for when the video size is known:
+	android_media_set_video_size_cb(player, set_video_size_cb, NULL);
+
+	printf("Setting data source to: %s.\n", argv[1]);
+
+	if (android_media_set_data_source(player, argv[1]) != OK) {
+		printf("Failed to set data source: %s\n", argv[1]);
+		return EXIT_FAILURE;
+	}
+
+	WindowRenderer renderer(DestWidth, DestHeight);
+
+	printf("Creating EGL surface.\n");
+	ClientWithSurface cs = client_with_surface(true /* Associate surface with egl. */);
+	if (!cs.surface) {
+		printf("Problem acquiring surface for preview");
+		return EXIT_FAILURE;
+	}
+
+	printf("Creating GL texture.\n");
+	GLuint preview_texture_id;
+	EGLDisplay disp = sf_client_get_egl_display(cs.client);
+	EGLSurface surface = sf_surface_get_egl_surface(cs.surface);
+
+	sf_surface_make_current(cs.surface);
+	if (setup_video_texture(&cs, &preview_texture_id) != OK) {
+		printf("Problem setting up GL texture for video surface.\n");
+		return EXIT_FAILURE;
+	}
+
+	RenderData render_data;
+
+	printf("Starting video playback.\n");
+	android_media_play(player);
+
+	printf("Updating gl buffer continuously...\n");
+	while (android_media_is_playing(player)) {
+		update_gl_buffer(&render_data, &disp, &surface);
+	}
+
+	android_media_stop(player);
+
+	return EXIT_SUCCESS;
+}

=== added file 'android/compat/media/direct_media_test.h'
--- android/compat/media/direct_media_test.h	1970-01-01 00:00:00 +0000
+++ android/compat/media/direct_media_test.h	2016-01-11 14:31:46 +0000
@@ -0,0 +1,58 @@
+/*
+ * Copyright (C) 2013 Canonical Ltd
+ *
+ * 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.
+ *
+ * Authored by: Jim Hodapp <[e-mail]>
+ */
+
+#ifndef DIRECT_MEDIA_TEST_H_