repositories / deb_libhybris.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Imported Debian patch 0.1.0+git20131207+e452e83-0ubuntu12
[deb_libhybris.git] / debian / patches / debian-changes
1 Subject: Collected Debian patches for libhybris
2 Author: Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
3
4 The libhybris package is maintained in Git rather than maintaining
5 patches as separate files, and separating the patches doesn't seem to
6 be worth the effort. They are therefore all included in this single
7 Debian patch.
8
9 For full commit history and separated commits, see the packaging Git
10 repository.
11 --- /dev/null
12 +++ libhybris-0.1.0+git20131207+e452e83/compat/Android.common.mk
13 @@ -0,0 +1,10 @@
14 +# define ANDROID_VERSION MAJOR, MINOR and PATCH
15 +
16 +ANDROID_VERSION_MAJOR := $(word 1, $(subst ., , $(PLATFORM_VERSION)))
17 +ANDROID_VERSION_MINOR := $(word 2, $(subst ., , $(PLATFORM_VERSION)))
18 +ANDROID_VERSION_PATCH := $(word 3, $(subst ., , $(PLATFORM_VERSION)))
19 +
20 +LOCAL_CFLAGS += \
21 + -DANDROID_VERSION_MAJOR=$(ANDROID_VERSION_MAJOR) \
22 + -DANDROID_VERSION_MINOR=$(ANDROID_VERSION_MINOR) \
23 + -DANDROID_VERSION_PATCH=$(ANDROID_VERSION_PATCH)
24 --- libhybris-0.1.0+git20131207+e452e83.orig/compat/camera/Android.mk
25 +++ libhybris-0.1.0+git20131207+e452e83/compat/camera/Android.mk
26 @@ -1,5 +1,6 @@
27 LOCAL_PATH:= $(call my-dir)
28 include $(CLEAR_VARS)
29 +include $(LOCAL_PATH)/../Android.common.mk
30
31 HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
32
33 --- libhybris-0.1.0+git20131207+e452e83.orig/compat/camera/camera_compatibility_layer.cpp
34 +++ libhybris-0.1.0+git20131207+e452e83/compat/camera/camera_compatibility_layer.cpp
35 @@ -27,17 +27,25 @@
36 #include <binder/ProcessState.h>
37 #include <camera/Camera.h>
38 #include <camera/CameraParameters.h>
39 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
40 #include <gui/SurfaceTexture.h>
41 +#else
42 +#include <gui/GLConsumer.h>
43 +#endif
44 #include <ui/GraphicBuffer.h>
45
46 +#include <GLES2/gl2.h>
47 +#include <GLES2/gl2ext.h>
48 +
49 #undef LOG_TAG
50 #define LOG_TAG "CameraCompatibilityLayer"
51 #include <utils/KeyedVector.h>
52 #include <utils/Log.h>
53 +#include <utils/String16.h>
54
55 #define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
56
57 -// From android::SurfaceTexture::FrameAvailableListener
58 +// From android::GLConsumer::FrameAvailableListener
59 void CameraControl::onFrameAvailable()
60 {
61 REPORT_FUNCTION();
62 @@ -170,7 +178,11 @@ CameraControl* android_camera_connect_to
63
64 CameraControl* cc = new CameraControl();
65 cc->listener = listener;
66 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR>=3
67 + cc->camera = android::Camera::connect(camera_id, android::String16("hybris"), android::Camera::USE_CALLING_UID);
68 +#else
69 cc->camera = android::Camera::connect(camera_id);
70 +#endif
71
72 if (cc->camera == NULL)
73 return NULL;
74 @@ -511,30 +523,57 @@ void android_camera_set_preview_texture(
75 assert(control);
76
77 static const bool allow_synchronous_mode = false;
78 + static const bool is_controlled_by_app = true;
79
80 android::sp<android::NativeBufferAlloc> native_alloc(
81 new android::NativeBufferAlloc()
82 );
83
84 android::sp<android::BufferQueue> buffer_queue(
85 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
86 new android::BufferQueue(false, NULL, native_alloc)
87 +#else
88 + new android::BufferQueue(NULL, native_alloc)
89 +#endif
90 );
91
92 if (control->preview_texture == NULL) {
93 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
94 control->preview_texture = android::sp<android::SurfaceTexture>(
95 new android::SurfaceTexture(
96 +#else
97 + control->preview_texture = android::sp<android::GLConsumer>(
98 + new android::GLConsumer(
99 +#endif
100 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
101 texture_id,
102 allow_synchronous_mode,
103 GL_TEXTURE_EXTERNAL_OES,
104 true,
105 buffer_queue));
106 +#else
107 + buffer_queue,
108 + texture_id,
109 + GL_TEXTURE_EXTERNAL_OES,
110 + true,
111 + is_controlled_by_app));
112 +#endif
113 }
114
115 control->preview_texture->setFrameAvailableListener(
116 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
117 android::sp<android::SurfaceTexture::FrameAvailableListener>(control));
118 +#else
119 + android::sp<android::GLConsumer::FrameAvailableListener>(control));
120 +#endif
121 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
122 control->camera->setPreviewTexture(control->preview_texture->getBufferQueue());
123 +#else
124 + control->camera->setPreviewTarget(buffer_queue);
125 +#endif
126 }
127
128 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
129 void android_camera_set_preview_surface(CameraControl* control, SfSurface* surface)
130 {
131 REPORT_FUNCTION();
132 @@ -544,6 +583,7 @@ void android_camera_set_preview_surface(
133 android::Mutex::Autolock al(control->guard);
134 control->camera->setPreviewDisplay(surface->surface);
135 }
136 +#endif
137
138 void android_camera_start_preview(CameraControl* control)
139 {
140 --- libhybris-0.1.0+git20131207+e452e83.orig/compat/input/Android.mk
141 +++ libhybris-0.1.0+git20131207+e452e83/compat/input/Android.mk
142 @@ -18,6 +18,11 @@ LOCAL_SHARED_LIBRARIES := \
143 libgui \
144 libandroidfw
145
146 +HAS_LIBINPUTSERVICE := $(shell test $(ANDROID_VERSION_MAJOR) -eq 4 -a $(ANDROID_VERSION_MINOR) -gt 2 && echo true)
147 +ifeq ($(HAS_LIBINPUTSERVICE),true)
148 +LOCAL_SHARED_LIBRARIES += libinputservice
149 +endif
150 +
151 LOCAL_C_INCLUDES := \
152 $(HYBRIS_PATH)/include \
153 external/skia/include/core \
154 --- /dev/null
155 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/Android.mk
156 @@ -0,0 +1,109 @@
157 +LOCAL_PATH:= $(call my-dir)
158 +include $(CLEAR_VARS)
159 +include $(LOCAL_PATH)/../Android.common.mk
160 +
161 +HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
162 +
163 +LOCAL_CFLAGS += -std=gnu++0x
164 +
165 +LOCAL_SRC_FILES:= \
166 + media_compatibility_layer.cpp \
167 + media_codec_layer.cpp \
168 + media_codec_list.cpp \
169 + media_format_layer.cpp \
170 + surface_texture_client_hybris.cpp \
171 + recorder_compatibility_layer.cpp
172 +
173 +LOCAL_MODULE:= libmedia_compat_layer
174 +LOCAL_MODULE_TAGS := optional
175 +
176 +LOCAL_SHARED_LIBRARIES := \
177 + libcutils \
178 + libcamera_client \
179 + libutils \
180 + libbinder \
181 + libhardware \
182 + libui \
183 + libgui \
184 + libstagefright \
185 + libstagefright_foundation \
186 + libEGL \
187 + libGLESv2 \
188 + libmedia
189 +
190 +LOCAL_C_INCLUDES := \
191 + $(HYBRIS_PATH)/include \
192 + frameworks/base/media/libstagefright/include \
193 + frameworks/base/include/media/stagefright \
194 + frameworks/base/include/media
195 +
196 +include $(BUILD_SHARED_LIBRARY)
197 +
198 +include $(CLEAR_VARS)
199 +include $(LOCAL_PATH)/../Android.common.mk
200 +
201 +LOCAL_SRC_FILES:= \
202 + direct_media_test.cpp
203 +
204 +LOCAL_MODULE:= direct_media_test
205 +LOCAL_MODULE_TAGS := optional
206 +
207 +LOCAL_C_INCLUDES := \
208 + $(HYBRIS_PATH)/include \
209 + bionic \
210 + bionic/libstdc++/include \
211 + external/gtest/include \
212 + external/stlport/stlport \
213 + external/skia/include/core \
214 + frameworks/base/include
215 +
216 +LOCAL_SHARED_LIBRARIES := \
217 + libis_compat_layer \
218 + libsf_compat_layer \
219 + libmedia_compat_layer \
220 + libcutils \
221 + libutils \
222 + libbinder \
223 + libhardware \
224 + libui \
225 + libgui \
226 + libEGL \
227 + libGLESv2
228 +
229 +include $(BUILD_EXECUTABLE)
230 +
231 +include $(CLEAR_VARS)
232 +include $(LOCAL_PATH)/../Android.common.mk
233 +
234 +LOCAL_CFLAGS += -Wno-multichar -D SIMPLE_PLAYER -std=gnu++0x
235 +
236 +LOCAL_SRC_FILES:= \
237 + media_codec_layer.cpp \
238 + media_codec_list.cpp \
239 + media_format_layer.cpp \
240 + codec.cpp \
241 + SimplePlayer.cpp
242 +
243 +LOCAL_SHARED_LIBRARIES := \
244 + libstagefright \
245 + libstagefright_foundation \
246 + liblog \
247 + libutils \
248 + libbinder \
249 + libmedia \
250 + libgui \
251 + libcutils \
252 + libui
253 +
254 +LOCAL_C_INCLUDES:= \
255 + $(HYBRIS_PATH)/include \
256 + frameworks/av/media/libstagefright \
257 + frameworks/native/include/media/openmax \
258 + frameworks/base/media/libstagefright/include \
259 + frameworks/base/include/media/stagefright \
260 + frameworks/base/include/media
261 +
262 +LOCAL_MODULE:= codec
263 +LOCAL_MODULE_TAGS := optional
264 +
265 +include $(BUILD_EXECUTABLE)
266 --- /dev/null
267 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/SimplePlayer.cpp
268 @@ -0,0 +1,777 @@
269 +/*
270 + * Copyright (C) 2012 The Android Open Source Project
271 + *
272 + * Licensed under the Apache License, Version 2.0 (the "License");
273 + * you may not use this file except in compliance with the License.
274 + * You may obtain a copy of the License at
275 + *
276 + * http://www.apache.org/licenses/LICENSE-2.0
277 + *
278 + * Unless required by applicable law or agreed to in writing, software
279 + * distributed under the License is distributed on an "AS IS" BASIS,
280 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
281 + * See the License for the specific language governing permissions and
282 + * limitations under the License.
283 + */
284 +
285 +//#define LOG_NDEBUG 0
286 +#define LOG_TAG "SimplePlayer"
287 +#include <utils/Log.h>
288 +
289 +#include "SimplePlayer.h"
290 +
291 +#include <gui/Surface.h>
292 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
293 +#include <gui/SurfaceTextureClient.h>
294 +#endif
295 +#include <media/AudioTrack.h>
296 +#include <media/ICrypto.h>
297 +#include <media/stagefright/foundation/ABuffer.h>
298 +#include <media/stagefright/foundation/ADebug.h>
299 +#include <media/stagefright/foundation/AMessage.h>
300 +#include <media/stagefright/MediaCodec.h>
301 +#include <media/stagefright/MediaErrors.h>
302 +#include <media/stagefright/NativeWindowWrapper.h>
303 +#include <media/stagefright/NuMediaExtractor.h>
304 +
305 +#define USE_MEDIA_CODEC_LAYER
306 +
307 +namespace android {
308 +
309 +SimplePlayer::SimplePlayer()
310 + : mState(UNINITIALIZED),
311 + mDoMoreStuffGeneration(0),
312 + mStartTimeRealUs(-1ll) {
313 +}
314 +
315 +SimplePlayer::~SimplePlayer() {
316 +}
317 +
318 +// static
319 +status_t PostAndAwaitResponse(
320 + const sp<AMessage> &msg, sp<AMessage> *response) {
321 + status_t err = msg->postAndAwaitResponse(response);
322 + printf("%s\n", __PRETTY_FUNCTION__);
323 +
324 + if (err != OK) {
325 + return err;
326 + }
327 +
328 + if (!(*response)->findInt32("err", &err)) {
329 + err = OK;
330 + }
331 +
332 + return err;
333 +}
334 +status_t SimplePlayer::setDataSource(const char *path) {
335 + sp<AMessage> msg = new AMessage(kWhatSetDataSource, id());
336 + msg->setString("path", path);
337 + sp<AMessage> response;
338 + return PostAndAwaitResponse(msg, &response);
339 +}
340 +
341 +status_t SimplePlayer::setSurface(const sp<ISurfaceTexture> &surfaceTexture) {
342 + sp<AMessage> msg = new AMessage(kWhatSetSurface, id());
343 +
344 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
345 + sp<SurfaceTextureClient> surfaceTextureClient;
346 + if (surfaceTexture != NULL) {
347 + surfaceTextureClient = new SurfaceTextureClient(surfaceTexture);
348 + }
349 +#else
350 + sp<Surface> surfaceTextureClient;
351 + if (surfaceTexture != NULL) {
352 + surfaceTextureClient = new Surface(surfaceTexture);
353 + }
354 +#endif
355 +
356 + msg->setObject(
357 + "native-window", new NativeWindowWrapper(surfaceTextureClient));
358 +
359 + sp<AMessage> response;
360 + return PostAndAwaitResponse(msg, &response);
361 +}
362 +
363 +status_t SimplePlayer::prepare() {
364 + sp<AMessage> msg = new AMessage(kWhatPrepare, id());
365 + sp<AMessage> response;
366 + return PostAndAwaitResponse(msg, &response);
367 +}
368 +
369 +status_t SimplePlayer::start() {
370 + printf("%s\n", __PRETTY_FUNCTION__);
371 + sp<AMessage> msg = new AMessage(kWhatStart, id());
372 + sp<AMessage> response;
373 + return PostAndAwaitResponse(msg, &response);
374 +}
375 +
376 +status_t SimplePlayer::stop() {
377 + sp<AMessage> msg = new AMessage(kWhatStop, id());
378 + sp<AMessage> response;
379 + return PostAndAwaitResponse(msg, &response);
380 +}
381 +
382 +status_t SimplePlayer::reset() {
383 + sp<AMessage> msg = new AMessage(kWhatReset, id());
384 + sp<AMessage> response;
385 + return PostAndAwaitResponse(msg, &response);
386 +}
387 +
388 +void SimplePlayer::onMessageReceived(const sp<AMessage> &msg) {
389 + switch (msg->what()) {
390 + case kWhatSetDataSource:
391 + {
392 + status_t err;
393 + if (mState != UNINITIALIZED) {
394 + err = INVALID_OPERATION;
395 + } else {
396 + CHECK(msg->findString("path", &mPath));
397 + mState = UNPREPARED;
398 + }
399 +
400 + uint32_t replyID;
401 + CHECK(msg->senderAwaitsResponse(&replyID));
402 +
403 + sp<AMessage> response = new AMessage;
404 + response->setInt32("err", err);
405 + response->postReply(replyID);
406 + break;
407 + }
408 +
409 + case kWhatSetSurface:
410 + {
411 + status_t err;
412 + if (mState != UNPREPARED) {
413 + err = INVALID_OPERATION;
414 + } else {
415 + sp<RefBase> obj;
416 + CHECK(msg->findObject("native-window", &obj));
417 +
418 + mNativeWindow = static_cast<NativeWindowWrapper *>(obj.get());
419 +
420 + err = OK;
421 + }
422 +
423 + uint32_t replyID;
424 + CHECK(msg->senderAwaitsResponse(&replyID));
425 +
426 + sp<AMessage> response = new AMessage;
427 + response->setInt32("err", err);
428 + response->postReply(replyID);
429 + break;
430 + }
431 +
432 + case kWhatPrepare:
433 + {
434 + status_t err;
435 + if (mState != UNPREPARED) {
436 + err = INVALID_OPERATION;
437 + } else {
438 + err = onPrepare();
439 +
440 + if (err == OK) {
441 + mState = STOPPED;
442 + }
443 + }
444 +
445 + uint32_t replyID;
446 + CHECK(msg->senderAwaitsResponse(&replyID));
447 +
448 + sp<AMessage> response = new AMessage;
449 + response->setInt32("err", err);
450 + response->postReply(replyID);
451 + break;
452 + }
453 +
454 + case kWhatStart:
455 + {
456 + status_t err = OK;
457 +
458 + if (mState == UNPREPARED) {
459 + err = onPrepare();
460 +
461 + if (err == OK) {
462 + mState = STOPPED;
463 + }
464 + }
465 +
466 + if (err == OK) {
467 + if (mState != STOPPED) {
468 + err = INVALID_OPERATION;
469 + } else {
470 + err = onStart();
471 +
472 + if (err == OK) {
473 + mState = STARTED;
474 + }
475 + }
476 + }
477 +
478 + uint32_t replyID;
479 + CHECK(msg->senderAwaitsResponse(&replyID));
480 +
481 + sp<AMessage> response = new AMessage;
482 + response->setInt32("err", err);
483 + response->postReply(replyID);
484 + break;
485 + }
486 +
487 + case kWhatStop:
488 + {
489 + status_t err;
490 +
491 + if (mState != STARTED) {
492 + err = INVALID_OPERATION;
493 + } else {
494 + err = onStop();
495 +
496 + if (err == OK) {
497 + mState = STOPPED;
498 + }
499 + }
500 +
501 + uint32_t replyID;
502 + CHECK(msg->senderAwaitsResponse(&replyID));
503 +
504 + sp<AMessage> response = new AMessage;
505 + response->setInt32("err", err);
506 + response->postReply(replyID);
507 + break;
508 + }
509 +
510 + case kWhatReset:
511 + {
512 + status_t err = OK;
513 +
514 + if (mState == STARTED) {
515 + CHECK_EQ(onStop(), (status_t)OK);
516 + mState = STOPPED;
517 + }
518 +
519 + if (mState == STOPPED) {
520 + err = onReset();
521 + mState = UNINITIALIZED;
522 + }
523 +
524 + uint32_t replyID;
525 + CHECK(msg->senderAwaitsResponse(&replyID));
526 +
527 + sp<AMessage> response = new AMessage;
528 + response->setInt32("err", err);
529 + response->postReply(replyID);
530 + break;
531 + }
532 +
533 + case kWhatDoMoreStuff:
534 + {
535 + int32_t generation;
536 + CHECK(msg->findInt32("generation", &generation));
537 +
538 + if (generation != mDoMoreStuffGeneration) {
539 + break;
540 + }
541 +
542 + status_t err = onDoMoreStuff();
543 +
544 + if (err == OK) {
545 + msg->post(10000ll);
546 + }
547 + break;
548 + }
549 +
550 + default:
551 + TRESPASS();
552 + }
553 +}
554 +
555 +status_t SimplePlayer::onPrepare() {
556 + CHECK_EQ(mState, UNPREPARED);
557 + printf("%s\n", __PRETTY_FUNCTION__);
558 +
559 + mExtractor = new NuMediaExtractor;
560 +
561 + status_t err = mExtractor->setDataSource(mPath.c_str());
562 +
563 + if (err != OK) {
564 + mExtractor.clear();
565 + return err;
566 + }
567 +
568 + if (mCodecLooper == NULL) {
569 + mCodecLooper = new ALooper;
570 + mCodecLooper->start();
571 + }
572 +
573 + bool haveAudio = false;
574 + bool haveVideo = false;
575 + for (size_t i = 0; i < mExtractor->countTracks(); ++i) {
576 + sp<AMessage> format;
577 + status_t err = mExtractor->getTrackFormat(i, &format);
578 + CHECK_EQ(err, (status_t)OK);
579 +
580 + AString mime;
581 + int32_t width = 0, height = 0, maxInputSize = 0;
582 + int64_t durationUs = 0;
583 + sp<ABuffer> csd0, csd1;
584 +#ifdef USE_MEDIA_CODEC_LAYER
585 + MediaFormat mformat;
586 +#endif
587 + CHECK(format->findString("mime", &mime));
588 +
589 + if (!haveAudio && !strncasecmp(mime.c_str(), "audio/", 6)) {
590 + //haveAudio = true;
591 + printf("*** Have audio but skipping it!\n");
592 + continue;
593 + } else if (!haveVideo && !strncasecmp(mime.c_str(), "video/", 6)) {
594 + haveVideo = true;
595 + CHECK(format->findInt32("width", &width));
596 + CHECK(format->findInt32("height", &height));
597 + CHECK(format->findInt64("durationUs", &durationUs));
598 + CHECK(format->findInt32("max-input-size", &maxInputSize));
599 + CHECK(format->findBuffer("csd-0", &csd0));
600 + CHECK(format->findBuffer("csd-1", &csd1));
601 +#ifdef USE_MEDIA_CODEC_LAYER
602 + mformat = media_format_create_video_format(mime.c_str(), width, height, durationUs, maxInputSize);
603 + media_format_set_byte_buffer(mformat, "csd-0", csd0->data(), csd0->size());
604 + media_format_set_byte_buffer(mformat, "csd-1", csd1->data(), csd1->size());
605 +#endif
606 + } else {
607 + continue;
608 + }
609 +
610 + err = mExtractor->selectTrack(i);
611 + CHECK_EQ(err, (status_t)OK);
612 +
613 + CodecState *state =
614 + &mStateByTrackIndex.editValueAt(
615 + mStateByTrackIndex.add(i, CodecState()));
616 +
617 + state->mNumFramesWritten = 0;
618 +#ifdef USE_MEDIA_CODEC_LAYER
619 + state->mCodecDelegate = media_codec_create_by_codec_type(mime.c_str());
620 + state->mCodec = media_codec_get(state->mCodecDelegate);
621 + CHECK(state->mCodecDelegate != NULL);
622 +#else
623 + state->mCodec = MediaCodec::CreateByType(
624 + mCodecLooper, mime.c_str(), false /* encoder */);
625 +#endif
626 +
627 + CHECK(state->mCodec != NULL);
628 +
629 +#ifdef USE_MEDIA_CODEC_LAYER
630 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
631 + err = media_codec_configure(state->mCodecDelegate, mformat, mNativeWindow->getSurfaceTextureClient().get(), 0);
632 +#else
633 + err = media_codec_configure(state->mCodecDelegate, mformat, mNativeWindow->getSurface().get(), 0);
634 +#endif
635 +#else
636 + err = state->mCodec->configure(
637 + format,
638 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
639 + mNativeWindow->getSurfaceTextureClient(),
640 +#else
641 + mNativeWindow->getSurface(),
642 +#endif
643 + NULL /* crypto */,
644 + 0 /* flags */);
645 +#endif
646 +
647 + CHECK_EQ(err, (status_t)OK);
648 +
649 + size_t j = 0;
650 + sp<ABuffer> buffer;
651 + // Place the CSD data into the source buffer
652 + while (format->findBuffer(StringPrintf("csd-%d", j).c_str(), &buffer)) {
653 + state->mCSD.push_back(buffer);
654 +
655 + ++j;
656 + }
657 + }
658 +
659 + for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
660 + CodecState *state = &mStateByTrackIndex.editValueAt(i);
661 +
662 +#ifdef USE_MEDIA_CODEC_LAYER
663 + status_t err = media_codec_start(state->mCodecDelegate);
664 +#else
665 + status_t err = state->mCodec->start();
666 +#endif
667 + CHECK_EQ(err, (status_t)OK);
668 +
669 +#ifdef USE_MEDIA_CODEC_LAYER
670 + size_t nInputBuffers = media_codec_get_input_buffers_size(state->mCodecDelegate);
671 + ALOGD("nInputBuffers: %u", nInputBuffers);
672 + for (size_t i=0; i<nInputBuffers; i++)
673 + {
674 + uint8_t *data = media_codec_get_nth_input_buffer(state->mCodecDelegate, i);
675 + CHECK(data != NULL);
676 + size_t size = media_codec_get_nth_input_buffer_capacity(state->mCodecDelegate, i);
677 + ALOGD("input buffer[%d] size: %d", i, size);
678 + sp<ABuffer> buf = new ABuffer(data, size);
679 + state->mBuffers[0].insertAt(new ABuffer(data, size), i);
680 + }
681 +#else
682 + err = state->mCodec->getInputBuffers(&state->mBuffers[0]);
683 + CHECK_EQ(err, (status_t)OK);
684 +#endif
685 +
686 + err = state->mCodec->getOutputBuffers(&state->mBuffers[1]);
687 + CHECK_EQ(err, (status_t)OK);
688 +
689 + for (size_t j = 0; j < state->mCSD.size(); ++j) {
690 + const sp<ABuffer> &srcBuffer = state->mCSD.itemAt(j);
691 +
692 + size_t index;
693 +#ifdef USE_MEDIA_CODEC_LAYER
694 + err = media_codec_dequeue_input_buffer(state->mCodecDelegate, &index, -1ll);
695 +#else
696 + err = state->mCodec->dequeueInputBuffer(&index, -1ll);
697 +#endif
698 + CHECK_EQ(err, (status_t)OK);
699 +
700 + const sp<ABuffer> &dstBuffer = state->mBuffers[0].itemAt(index);
701 +
702 + CHECK_LE(srcBuffer->size(), dstBuffer->capacity());
703 + dstBuffer->setRange(0, srcBuffer->size());
704 + memcpy(dstBuffer->data(), srcBuffer->data(), srcBuffer->size());
705 +
706 +#ifdef USE_MEDIA_CODEC_LAYER
707 + MediaCodecBufferInfo bufInfo;
708 + bufInfo.index = index;
709 + bufInfo.offset = 0;
710 + bufInfo.size = dstBuffer->size();
711 + bufInfo.presentation_time_us = 0ll;
712 + bufInfo.flags = MediaCodec::BUFFER_FLAG_CODECCONFIG;
713 +
714 + err = media_codec_queue_input_buffer(
715 + state->mCodecDelegate,
716 + &bufInfo);
717 +
718 +#else
719 + err = state->mCodec->queueInputBuffer(
720 + index,
721 + 0,
722 + dstBuffer->size(),
723 + 0ll,
724 + MediaCodec::BUFFER_FLAG_CODECCONFIG);
725 +#endif
726 + CHECK_EQ(err, (status_t)OK);
727 + }
728 + }
729 +
730 + return OK;
731 +}
732 +
733 +status_t SimplePlayer::onStart() {
734 + CHECK_EQ(mState, STOPPED);
735 +
736 + mStartTimeRealUs = -1ll;
737 +
738 + sp<AMessage> msg = new AMessage(kWhatDoMoreStuff, id());
739 + msg->setInt32("generation", ++mDoMoreStuffGeneration);
740 + msg->post();
741 +
742 + return OK;
743 +}
744 +
745 +status_t SimplePlayer::onStop() {
746 + CHECK_EQ(mState, STARTED);
747 +
748 + ++mDoMoreStuffGeneration;
749 +
750 + return OK;
751 +}
752 +
753 +status_t SimplePlayer::onReset() {
754 + CHECK_EQ(mState, STOPPED);
755 +
756 + for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
757 + CodecState *state = &mStateByTrackIndex.editValueAt(i);
758 +
759 + CHECK_EQ(state->mCodec->release(), (status_t)OK);
760 + }
761 +
762 + mStartTimeRealUs = -1ll;
763 +
764 + mStateByTrackIndex.clear();
765 + mCodecLooper.clear();
766 + mExtractor.clear();
767 + mNativeWindow.clear();
768 + mPath.clear();
769 +
770 + return OK;
771 +}
772 +
773 +status_t SimplePlayer::onDoMoreStuff() {
774 + ALOGV("onDoMoreStuff");
775 + for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
776 + CodecState *state = &mStateByTrackIndex.editValueAt(i);
777 +
778 + status_t err;
779 + do {
780 + size_t index;
781 +#ifdef USE_MEDIA_CODEC_LAYER
782 + err = media_codec_dequeue_input_buffer(state->mCodecDelegate, &index, 0ll);
783 +#else
784 + err = state->mCodec->dequeueInputBuffer(&index);
785 +#endif
786 +
787 + if (err == OK) {
788 + ALOGD("dequeued input buffer on track %d",
789 + mStateByTrackIndex.keyAt(i));
790 +
791 + state->mAvailInputBufferIndices.push_back(index);
792 + } else {
793 + ALOGD("dequeueInputBuffer on track %d returned %d",
794 + mStateByTrackIndex.keyAt(i), err);
795 + }
796 + } while (err == OK);
797 +
798 + do {
799 +#ifdef USE_MEDIA_CODEC_LAYER
800 + BufferInfo info;
801 + MediaCodecBufferInfo bufInfo;
802 + err = media_codec_dequeue_output_buffer(
803 + state->mCodecDelegate,
804 + &bufInfo,
805 + 0ll);
806 +
807 + info.mIndex = bufInfo.index;
808 + info.mOffset = bufInfo.offset;
809 + info.mSize = bufInfo.size;
810 + info.mPresentationTimeUs = bufInfo.presentation_time_us;
811 + info.mFlags = bufInfo.flags;
812 +
813 +#else
814 + BufferInfo info;
815 + err = state->mCodec->dequeueOutputBuffer(
816 + &info.mIndex,
817 + &info.mOffset,
818 + &info.mSize,
819 + &info.mPresentationTimeUs,
820 + &info.mFlags);
821 +#endif
822 +
823 + if (err == OK) {
824 + ALOGV("dequeued output buffer on track %d",
825 + mStateByTrackIndex.keyAt(i));
826 +
827 + state->mAvailOutputBufferInfos.push_back(info);
828 + } else if (err == INFO_FORMAT_CHANGED) {
829 + err = onOutputFormatChanged(mStateByTrackIndex.keyAt(i), state);
830 + CHECK_EQ(err, (status_t)OK);
831 + } else if (err == INFO_OUTPUT_BUFFERS_CHANGED) {
832 + err = state->mCodec->getOutputBuffers(&state->mBuffers[1]);
833 + CHECK_EQ(err, (status_t)OK);
834 + } else {
835 + ALOGV("dequeueOutputBuffer on track %d returned %d",
836 + mStateByTrackIndex.keyAt(i), err);
837 + }
838 + } while (err == OK
839 + || err == INFO_FORMAT_CHANGED
840 + || err == INFO_OUTPUT_BUFFERS_CHANGED);
841 + }
842 +
843 + for (;;) {
844 + size_t trackIndex;
845 + status_t err = mExtractor->getSampleTrackIndex(&trackIndex);
846 +
847 + if (err != OK) {
848 + ALOGI("encountered input EOS.");
849 + break;
850 + } else {
851 + CodecState *state = &mStateByTrackIndex.editValueFor(trackIndex);
852 +
853 + if (state->mAvailInputBufferIndices.empty()) {
854 + break;
855 + }
856 +
857 + size_t index = *state->mAvailInputBufferIndices.begin();
858 + state->mAvailInputBufferIndices.erase(
859 + state->mAvailInputBufferIndices.begin());
860 +
861 + const sp<ABuffer> &dstBuffer =
862 + state->mBuffers[0].itemAt(index);
863 +
864 + err = mExtractor->readSampleData(dstBuffer);
865 + CHECK_EQ(err, (status_t)OK);
866 +
867 + int64_t timeUs;
868 + CHECK_EQ(mExtractor->getSampleTime(&timeUs), (status_t)OK);
869 +
870 +#ifdef USE_MEDIA_CODEC_LAYER
871 + MediaCodecBufferInfo bufInfo;
872 + bufInfo.index = index;
873 + bufInfo.offset = dstBuffer->offset();
874 + bufInfo.size = dstBuffer->size();
875 + bufInfo.presentation_time_us = timeUs;
876 + bufInfo.flags = 0;
877 +
878 + err = media_codec_queue_input_buffer(
879 + state->mCodecDelegate,
880 + &bufInfo);
881 +
882 +#else
883 + err = state->mCodec->queueInputBuffer(
884 + index,
885 + dstBuffer->offset(),
886 + dstBuffer->size(),
887 + timeUs,
888 + 0);
889 +#endif
890 + CHECK_EQ(err, (status_t)OK);
891 +
892 + ALOGV("enqueued input data on track %d", trackIndex);
893 +
894 + err = mExtractor->advance();
895 + CHECK_EQ(err, (status_t)OK);
896 + }
897 + }
898 +
899 + int64_t nowUs = ALooper::GetNowUs();
900 +
901 + if (mStartTimeRealUs < 0ll) {
902 + mStartTimeRealUs = nowUs + 1000000ll;
903 + }
904 +
905 + for (size_t i = 0; i < mStateByTrackIndex.size(); ++i) {
906 + CodecState *state = &mStateByTrackIndex.editValueAt(i);
907 +
908 + while (!state->mAvailOutputBufferInfos.empty()) {
909 + BufferInfo *info = &*state->mAvailOutputBufferInfos.begin();
910 +
911 + int64_t whenRealUs = info->mPresentationTimeUs + mStartTimeRealUs;
912 + int64_t lateByUs = nowUs - whenRealUs;
913 +
914 + if (lateByUs > -10000ll) {
915 + bool release = true;
916 +
917 + if (lateByUs > 30000ll) {
918 + ALOGI("track %d buffer late by %lld us, dropping.",
919 + mStateByTrackIndex.keyAt(i), lateByUs);
920 + state->mCodec->releaseOutputBuffer(info->mIndex);
921 + } else {
922 + if (state->mAudioTrack != NULL) {
923 + const sp<ABuffer> &srcBuffer =
924 + state->mBuffers[1].itemAt(info->mIndex);
925 +
926 + renderAudio(state, info, srcBuffer);
927 +
928 + if (info->mSize > 0) {
929 + release = false;
930 + }
931 + }
932 +
933 + if (release) {
934 +#ifdef USE_MEDIA_CODEC_LAYER
935 + ALOGD("Rendering output buffer index %d and releasing", info->mIndex);
936 + state->mCodec->renderOutputBufferAndRelease(
937 + info->mIndex);
938 +#else
939 + ALOGD("Releasing output buffer index %d", info->mIndex);
940 + state->mCodec->releaseOutputBuffer(info->mIndex);
941 +#endif
942 + }
943 + }
944 +
945 + if (release) {
946 + state->mAvailOutputBufferInfos.erase(
947 + state->mAvailOutputBufferInfos.begin());
948 +
949 + info = NULL;
950 + } else {
951 + break;
952 + }
953 + } else {
954 + ALOGV("track %d buffer early by %lld us.",
955 + mStateByTrackIndex.keyAt(i), -lateByUs);
956 + break;
957 + }
958 + }
959 + }
960 +
961 + return OK;
962 +}
963 +
964 +status_t SimplePlayer::onOutputFormatChanged(
965 + size_t trackIndex, CodecState *state) {
966 + sp<AMessage> format;
967 + status_t err = state->mCodec->getOutputFormat(&format);
968 +
969 + if (err != OK) {
970 + return err;
971 + }
972 +
973 + AString mime;
974 + CHECK(format->findString("mime", &mime));
975 +
976 + if (!strncasecmp(mime.c_str(), "audio/", 6)) {
977 + int32_t channelCount;
978 + int32_t sampleRate;
979 + CHECK(format->findInt32("channel-count", &channelCount));
980 + CHECK(format->findInt32("sample-rate", &sampleRate));
981 +
982 + state->mAudioTrack = new AudioTrack(
983 + AUDIO_STREAM_MUSIC,
984 + sampleRate,
985 + AUDIO_FORMAT_PCM_16_BIT,
986 + audio_channel_out_mask_from_count(channelCount),
987 + 0);
988 +
989 + state->mNumFramesWritten = 0;
990 + }
991 +
992 + return OK;
993 +}
994 +
995 +void SimplePlayer::renderAudio(
996 + CodecState *state, BufferInfo *info, const sp<ABuffer> &buffer) {
997 + CHECK(state->mAudioTrack != NULL);
998 +
999 + if (state->mAudioTrack->stopped()) {
1000 + state->mAudioTrack->start();
1001 + }
1002 +
1003 + uint32_t numFramesPlayed;
1004 + CHECK_EQ(state->mAudioTrack->getPosition(&numFramesPlayed), (status_t)OK);
1005 +
1006 + uint32_t numFramesAvailableToWrite =
1007 + state->mAudioTrack->frameCount()
1008 + - (state->mNumFramesWritten - numFramesPlayed);
1009 +
1010 + size_t numBytesAvailableToWrite =
1011 + numFramesAvailableToWrite * state->mAudioTrack->frameSize();
1012 +
1013 + size_t copy = info->mSize;
1014 + if (copy > numBytesAvailableToWrite) {
1015 + copy = numBytesAvailableToWrite;
1016 + }
1017 +
1018 + if (copy == 0) {
1019 + return;
1020 + }
1021 +
1022 + int64_t startTimeUs = ALooper::GetNowUs();
1023 +
1024 + ssize_t nbytes = state->mAudioTrack->write(
1025 + buffer->base() + info->mOffset, copy);
1026 +
1027 + CHECK_EQ(nbytes, (ssize_t)copy);
1028 +
1029 + int64_t delayUs = ALooper::GetNowUs() - startTimeUs;
1030 +
1031 + uint32_t numFramesWritten = nbytes / state->mAudioTrack->frameSize();
1032 +
1033 + if (delayUs > 2000ll) {
1034 + ALOGW("AudioTrack::write took %lld us, numFramesAvailableToWrite=%u, "
1035 + "numFramesWritten=%u",
1036 + delayUs, numFramesAvailableToWrite, numFramesWritten);
1037 + }
1038 +
1039 + info->mOffset += nbytes;
1040 + info->mSize -= nbytes;
1041 +
1042 + state->mNumFramesWritten += numFramesWritten;
1043 +}
1044 +
1045 +} // namespace android
1046 --- /dev/null
1047 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/SimplePlayer.h
1048 @@ -0,0 +1,120 @@
1049 +/*
1050 + * Copyright (C) 2012 The Android Open Source Project
1051 + *
1052 + * Licensed under the Apache License, Version 2.0 (the "License");
1053 + * you may not use this file except in compliance with the License.
1054 + * You may obtain a copy of the License at
1055 + *
1056 + * http://www.apache.org/licenses/LICENSE-2.0
1057 + *
1058 + * Unless required by applicable law or agreed to in writing, software
1059 + * distributed under the License is distributed on an "AS IS" BASIS,
1060 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1061 + * See the License for the specific language governing permissions and
1062 + * limitations under the License.
1063 + */
1064 +
1065 +#include <media/stagefright/foundation/AHandler.h>
1066 +#include <media/stagefright/foundation/AString.h>
1067 +#include <utils/KeyedVector.h>
1068 +
1069 +#include <hybris/media/media_codec_layer.h>
1070 +
1071 +namespace android {
1072 +
1073 +struct ABuffer;
1074 +struct ALooper;
1075 +struct AudioTrack;
1076 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
1077 +struct ISurfaceTexture;
1078 +#else
1079 +struct IGraphicBufferProducer;
1080 +#endif
1081 +struct MediaCodec;
1082 +struct NativeWindowWrapper;
1083 +struct NuMediaExtractor;
1084 +
1085 +struct SimplePlayer : public AHandler {
1086 + SimplePlayer();
1087 +
1088 + status_t setDataSource(const char *path);
1089 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
1090 + status_t setSurface(const sp<ISurfaceTexture> &surfaceTexture);
1091 +#else
1092 + status_t setSurface(const sp<IGraphicBufferProducer> &surfaceTexture);
1093 +#endif
1094 + status_t prepare();
1095 + status_t start();
1096 + status_t stop();
1097 + status_t reset();
1098 +
1099 +protected:
1100 + virtual ~SimplePlayer();
1101 +
1102 + virtual void onMessageReceived(const sp<AMessage> &msg);
1103 +
1104 +private:
1105 + enum State {
1106 + UNINITIALIZED,
1107 + UNPREPARED,
1108 + STOPPED,
1109 + STARTED
1110 + };
1111 +
1112 + enum {
1113 + kWhatSetDataSource,
1114 + kWhatSetSurface,
1115 + kWhatPrepare,
1116 + kWhatStart,
1117 + kWhatStop,
1118 + kWhatReset,
1119 + kWhatDoMoreStuff,
1120 + };
1121 +
1122 + struct BufferInfo {
1123 + size_t mIndex;
1124 + size_t mOffset;
1125 + size_t mSize;
1126 + int64_t mPresentationTimeUs;
1127 + uint32_t mFlags;
1128 + };
1129 +
1130 + struct CodecState
1131 + {
1132 + sp<MediaCodec> mCodec;
1133 + MediaCodecDelegate mCodecDelegate;
1134 + Vector<sp<ABuffer> > mCSD;
1135 + Vector<sp<ABuffer> > mBuffers[2];
1136 +
1137 + List<size_t> mAvailInputBufferIndices;
1138 + List<BufferInfo> mAvailOutputBufferInfos;
1139 +
1140 + sp<AudioTrack> mAudioTrack;
1141 + uint32_t mNumFramesWritten;
1142 + };
1143 +
1144 + State mState;
1145 + AString mPath;
1146 + sp<NativeWindowWrapper> mNativeWindow;
1147 +
1148 + sp<NuMediaExtractor> mExtractor;
1149 + sp<ALooper> mCodecLooper;
1150 + KeyedVector<size_t, CodecState> mStateByTrackIndex;
1151 + int32_t mDoMoreStuffGeneration;
1152 +
1153 + int64_t mStartTimeRealUs;
1154 +
1155 + status_t onPrepare();
1156 + status_t onStart();
1157 + status_t onStop();
1158 + status_t onReset();
1159 + status_t onDoMoreStuff();
1160 + status_t onOutputFormatChanged(size_t trackIndex, CodecState *state);
1161 +
1162 + void renderAudio(
1163 + CodecState *state, BufferInfo *info, const sp<ABuffer> &buffer);
1164 +
1165 + DISALLOW_EVIL_CONSTRUCTORS(SimplePlayer);
1166 +};
1167 +
1168 +} // namespace android
1169 --- /dev/null
1170 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/codec.cpp
1171 @@ -0,0 +1,433 @@
1172 +/*
1173 + * Copyright (C) 2012 The Android Open Source Project
1174 + *
1175 + * Licensed under the Apache License, Version 2.0 (the "License");
1176 + * you may not use this file except in compliance with the License.
1177 + * You may obtain a copy of the License at
1178 + *
1179 + * http://www.apache.org/licenses/LICENSE-2.0
1180 + *
1181 + * Unless required by applicable law or agreed to in writing, software
1182 + * distributed under the License is distributed on an "AS IS" BASIS,
1183 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1184 + * See the License for the specific language governing permissions and
1185 + * limitations under the License.
1186 + */
1187 +
1188 +#define LOG_NDEBUG 0
1189 +#define LOG_TAG "codec"
1190 +#include <utils/Log.h>
1191 +
1192 +#include "SimplePlayer.h"
1193 +
1194 +#include <binder/IServiceManager.h>
1195 +#include <binder/ProcessState.h>
1196 +#include <media/ICrypto.h>
1197 +#include <media/IMediaPlayerService.h>
1198 +#include <media/stagefright/foundation/ABuffer.h>
1199 +#include <media/stagefright/foundation/ADebug.h>
1200 +#include <media/stagefright/foundation/ALooper.h>
1201 +#include <media/stagefright/foundation/AMessage.h>
1202 +#include <media/stagefright/foundation/AString.h>
1203 +#include <media/stagefright/DataSource.h>
1204 +#include <media/stagefright/MediaCodec.h>
1205 +#include <media/stagefright/MediaCodecList.h>
1206 +#include <media/stagefright/MediaDefs.h>
1207 +#include <media/stagefright/NuMediaExtractor.h>
1208 +#include <gui/ISurfaceComposer.h>
1209 +#include <gui/SurfaceComposerClient.h>
1210 +#include <ui/DisplayInfo.h>
1211 +
1212 +static void usage(const char *me) {
1213 + fprintf(stderr, "usage: %s [-a] use audio\n"
1214 + "\t\t[-v] use video\n"
1215 + "\t\t[-p] playback\n"
1216 + "\t\t[-S] allocate buffers from a surface\n",
1217 + me);
1218 +
1219 + exit(1);
1220 +}
1221 +
1222 +namespace android {
1223 +
1224 +struct CodecState {
1225 + sp<MediaCodec> mCodec;
1226 + Vector<sp<ABuffer> > mInBuffers;
1227 + Vector<sp<ABuffer> > mOutBuffers;
1228 + bool mSignalledInputEOS;
1229 + bool mSawOutputEOS;
1230 + int64_t mNumBuffersDecoded;
1231 + int64_t mNumBytesDecoded;
1232 + bool mIsAudio;
1233 +};
1234 +
1235 +} // namespace android
1236 +
1237 +static int decode(
1238 + const android::sp<android::ALooper> &looper,
1239 + const char *path,
1240 + bool useAudio,
1241 + bool useVideo,
1242 + const android::sp<android::Surface> &surface) {
1243 + using namespace android;
1244 +
1245 + static int64_t kTimeout = 500ll;
1246 +
1247 + sp<NuMediaExtractor> extractor = new NuMediaExtractor;
1248 + if (extractor->setDataSource(path) != OK) {
1249 + fprintf(stderr, "unable to instantiate extractor.\n");
1250 + return 1;
1251 + }
1252 +
1253 + KeyedVector<size_t, CodecState> stateByTrack;
1254 +
1255 + bool haveAudio = false;
1256 + bool haveVideo = false;
1257 + for (size_t i = 0; i < extractor->countTracks(); ++i) {
1258 + sp<AMessage> format;
1259 + status_t err = extractor->getTrackFormat(i, &format);
1260 + CHECK_EQ(err, (status_t)OK);
1261 +
1262 + AString mime;
1263 + CHECK(format->findString("mime", &mime));
1264 +
1265 + bool isAudio = !strncasecmp(mime.c_str(), "audio/", 6);
1266 + bool isVideo = !strncasecmp(mime.c_str(), "video/", 6);
1267 +
1268 + if (useAudio && !haveAudio && isAudio) {
1269 + haveAudio = true;
1270 + } else if (useVideo && !haveVideo && isVideo) {
1271 + haveVideo = true;
1272 + } else {
1273 + continue;
1274 + }
1275 +
1276 + ALOGV("selecting track %d", i);
1277 +
1278 + err = extractor->selectTrack(i);
1279 + CHECK_EQ(err, (status_t)OK);
1280 +
1281 + CodecState *state =
1282 + &stateByTrack.editValueAt(stateByTrack.add(i, CodecState()));
1283 +
1284 + state->mNumBytesDecoded = 0;
1285 + state->mNumBuffersDecoded = 0;
1286 + state->mIsAudio = isAudio;
1287 +
1288 + state->mCodec = MediaCodec::CreateByType(
1289 + looper, mime.c_str(), false /* encoder */);
1290 +
1291 + CHECK(state->mCodec != NULL);
1292 +
1293 + err = state->mCodec->configure(
1294 + format, isVideo ? surface : NULL,
1295 + NULL /* crypto */,
1296 + 0 /* flags */);
1297 +
1298 + CHECK_EQ(err, (status_t)OK);
1299 +
1300 + state->mSignalledInputEOS = false;
1301 + state->mSawOutputEOS = false;
1302 + }
1303 +
1304 + CHECK(!stateByTrack.isEmpty());
1305 +
1306 + int64_t startTimeUs = ALooper::GetNowUs();
1307 +
1308 + for (size_t i = 0; i < stateByTrack.size(); ++i) {
1309 + CodecState *state = &stateByTrack.editValueAt(i);
1310 +
1311 + sp<MediaCodec> codec = state->mCodec;
1312 +
1313 + CHECK_EQ((status_t)OK, codec->start());
1314 +
1315 + CHECK_EQ((status_t)OK, codec->getInputBuffers(&state->mInBuffers));
1316 + CHECK_EQ((status_t)OK, codec->getOutputBuffers(&state->mOutBuffers));
1317 +
1318 + ALOGV("got %d input and %d output buffers",
1319 + state->mInBuffers.size(), state->mOutBuffers.size());
1320 + }
1321 +
1322 + bool sawInputEOS = false;
1323 +
1324 + for (;;) {
1325 + if (!sawInputEOS) {
1326 + size_t trackIndex;
1327 + status_t err = extractor->getSampleTrackIndex(&trackIndex);
1328 +
1329 + if (err != OK) {
1330 + ALOGV("saw input eos");
1331 + sawInputEOS = true;
1332 + } else {
1333 + CodecState *state = &stateByTrack.editValueFor(trackIndex);
1334 +
1335 + size_t index;
1336 + err = state->mCodec->dequeueInputBuffer(&index, kTimeout);
1337 +
1338 + if (err == OK) {
1339 + ALOGV("filling input buffer %d", index);
1340 +
1341 + const sp<ABuffer> &buffer = state->mInBuffers.itemAt(index);
1342 +
1343 + err = extractor->readSampleData(buffer);
1344 + CHECK_EQ(err, (status_t)OK);
1345 +
1346 + int64_t timeUs;
1347 + err = extractor->getSampleTime(&timeUs);
1348 + CHECK_EQ(err, (status_t)OK);
1349 +
1350 + uint32_t bufferFlags = 0;
1351 +
1352 + err = state->mCodec->queueInputBuffer(
1353 + index,
1354 + 0 /* offset */,
1355 + buffer->size(),
1356 + timeUs,
1357 + bufferFlags);
1358 +
1359 + CHECK_EQ(err, (status_t)OK);
1360 +
1361 + extractor->advance();
1362 + } else {
1363 + CHECK_EQ(err, -EAGAIN);
1364 + }
1365 + }
1366 + } else {
1367 + for (size_t i = 0; i < stateByTrack.size(); ++i) {
1368 + CodecState *state = &stateByTrack.editValueAt(i);
1369 +
1370 + if (!state->mSignalledInputEOS) {
1371 + size_t index;
1372 + status_t err =
1373 + state->mCodec->dequeueInputBuffer(&index, kTimeout);
1374 +
1375 + if (err == OK) {
1376 + ALOGV("signalling input EOS on track %d", i);
1377 +
1378 + err = state->mCodec->queueInputBuffer(
1379 + index,
1380 + 0 /* offset */,
1381 + 0 /* size */,
1382 + 0ll /* timeUs */,
1383 + MediaCodec::BUFFER_FLAG_EOS);
1384 +
1385 + CHECK_EQ(err, (status_t)OK);
1386 +
1387 + state->mSignalledInputEOS = true;
1388 + } else {
1389 + CHECK_EQ(err, -EAGAIN);
1390 + }
1391 + }
1392 + }
1393 + }
1394 +
1395 + bool sawOutputEOSOnAllTracks = true;
1396 + for (size_t i = 0; i < stateByTrack.size(); ++i) {
1397 + CodecState *state = &stateByTrack.editValueAt(i);
1398 + if (!state->mSawOutputEOS) {
1399 + sawOutputEOSOnAllTracks = false;
1400 + break;
1401 + }
1402 + }
1403 +
1404 + if (sawOutputEOSOnAllTracks) {
1405 + break;
1406 + }
1407 +
1408 + for (size_t i = 0; i < stateByTrack.size(); ++i) {
1409 + CodecState *state = &stateByTrack.editValueAt(i);
1410 +
1411 + if (state->mSawOutputEOS) {
1412 + continue;
1413 + }
1414 +
1415 + size_t index;
1416 + size_t offset;
1417 + size_t size;
1418 + int64_t presentationTimeUs;
1419 + uint32_t flags;
1420 + status_t err = state->mCodec->dequeueOutputBuffer(
1421 + &index, &offset, &size, &presentationTimeUs, &flags,
1422 + kTimeout);
1423 +
1424 + if (err == OK) {
1425 + ALOGV("draining output buffer %d, time = %lld us",
1426 + index, presentationTimeUs);
1427 +
1428 + ++state->mNumBuffersDecoded;
1429 + state->mNumBytesDecoded += size;
1430 +
1431 + err = state->mCodec->releaseOutputBuffer(index);
1432 + CHECK_EQ(err, (status_t)OK);
1433 +
1434 + if (flags & MediaCodec::BUFFER_FLAG_EOS) {
1435 + ALOGV("reached EOS on output.");
1436 +
1437 + state->mSawOutputEOS = true;
1438 + }
1439 + } else if (err == INFO_OUTPUT_BUFFERS_CHANGED) {
1440 + ALOGV("INFO_OUTPUT_BUFFERS_CHANGED");
1441 + CHECK_EQ((status_t)OK,
1442 + state->mCodec->getOutputBuffers(&state->mOutBuffers));
1443 +
1444 + ALOGV("got %d output buffers", state->mOutBuffers.size());
1445 + } else if (err == INFO_FORMAT_CHANGED) {
1446 + sp<AMessage> format;
1447 + CHECK_EQ((status_t)OK, state->mCodec->getOutputFormat(&format));
1448 +
1449 + ALOGV("INFO_FORMAT_CHANGED: %s", format->debugString().c_str());
1450 + } else {
1451 + CHECK_EQ(err, -EAGAIN);
1452 + }
1453 + }
1454 + }
1455 +
1456 + int64_t elapsedTimeUs = ALooper::GetNowUs() - startTimeUs;
1457 +
1458 + for (size_t i = 0; i < stateByTrack.size(); ++i) {
1459 + CodecState *state = &stateByTrack.editValueAt(i);
1460 +
1461 + CHECK_EQ((status_t)OK, state->mCodec->release());
1462 +
1463 + if (state->mIsAudio) {
1464 + ALOGD("track %d: %lld bytes received. %.2f KB/sec\n",
1465 + i,
1466 + state->mNumBytesDecoded,
1467 + state->mNumBytesDecoded * 1E6 / 1024 / elapsedTimeUs);
1468 + } else {
1469 + ALOGD("track %d: %lld frames decoded, %.2f fps. %lld bytes "
1470 + "received. %.2f KB/sec\n",
1471 + i,
1472 + state->mNumBuffersDecoded,
1473 + state->mNumBuffersDecoded * 1E6 / elapsedTimeUs,
1474 + state->mNumBytesDecoded,
1475 + state->mNumBytesDecoded * 1E6 / 1024 / elapsedTimeUs);
1476 + }
1477 + }
1478 +
1479 + return 0;
1480 +}
1481 +
1482 +int main(int argc, char **argv) {
1483 + using namespace android;
1484 +
1485 + const char *me = argv[0];
1486 +
1487 + bool useAudio = false;
1488 + bool useVideo = false;
1489 + bool playback = false;
1490 + bool useSurface = false;
1491 +
1492 + int res;
1493 + while ((res = getopt(argc, argv, "havpSD")) >= 0) {
1494 + switch (res) {
1495 + case 'a':
1496 + {
1497 + useAudio = true;
1498 + break;
1499 + }
1500 +
1501 + case 'v':
1502 + {
1503 + useVideo = true;
1504 + break;
1505 + }
1506 +
1507 + case 'p':
1508 + {
1509 + playback = true;
1510 + break;
1511 + }
1512 +
1513 + case 'S':
1514 + {
1515 + useSurface = true;
1516 + break;
1517 + }
1518 +
1519 + case '?':
1520 + case 'h':
1521 + default:
1522 + {
1523 + usage(me);
1524 + }
1525 + }
1526 + }
1527 +
1528 + argc -= optind;
1529 + argv += optind;
1530 +
1531 + if (argc != 1) {
1532 + usage(me);
1533 + }
1534 +
1535 + if (!useAudio && !useVideo) {
1536 + useAudio = useVideo = true;
1537 + }
1538 +
1539 + ProcessState::self()->startThreadPool();
1540 +
1541 + DataSource::RegisterDefaultSniffers();
1542 +
1543 + sp<ALooper> looper = new ALooper;
1544 + looper->start();
1545 +
1546 + sp<SurfaceComposerClient> composerClient;
1547 + sp<SurfaceControl> control;
1548 + sp<Surface> surface;
1549 +
1550 + if (playback || (useSurface && useVideo)) {
1551 + composerClient = new SurfaceComposerClient;
1552 + CHECK_EQ(composerClient->initCheck(), (status_t)OK);
1553 +
1554 + sp<IBinder> display(SurfaceComposerClient::getBuiltInDisplay(
1555 + ISurfaceComposer::eDisplayIdMain));
1556 + DisplayInfo info;
1557 + SurfaceComposerClient::getDisplayInfo(display, &info);
1558 + ssize_t displayWidth = info.w;
1559 + ssize_t displayHeight = info.h;
1560 +
1561 + ALOGV("display is %ld x %ld\n", displayWidth, displayHeight);
1562 +
1563 + control = composerClient->createSurface(
1564 + String8("A Surface"),
1565 + displayWidth,
1566 + displayHeight,
1567 + PIXEL_FORMAT_RGB_565,
1568 + 0);
1569 +
1570 + CHECK(control != NULL);
1571 + CHECK(control->isValid());
1572 +
1573 + SurfaceComposerClient::openGlobalTransaction();
1574 + CHECK_EQ(control->setLayer(INT_MAX), (status_t)OK);
1575 + CHECK_EQ(control->show(), (status_t)OK);
1576 + SurfaceComposerClient::closeGlobalTransaction();
1577 +
1578 + surface = control->getSurface();
1579 + CHECK(surface != NULL);
1580 + }
1581 +
1582 + if (playback) {
1583 + sp<SimplePlayer> player = new SimplePlayer;
1584 + looper->registerHandler(player);
1585 +
1586 + player->setDataSource(argv[0]);
1587 + player->setSurface(surface->getSurfaceTexture());
1588 + player->start();
1589 + ALOGD("Playing for 60 seconds\n");
1590 + sleep(60);
1591 + player->stop();
1592 + player->reset();
1593 + } else {
1594 + decode(looper, argv[0], useAudio, useVideo, surface);
1595 + }
1596 +
1597 + if (playback || (useSurface && useVideo)) {
1598 + composerClient->dispose();
1599 + }
1600 +
1601 + looper->stop();
1602 +
1603 + return 0;
1604 +}
1605 --- /dev/null
1606 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/direct_media_test.cpp
1607 @@ -0,0 +1,417 @@
1608 +/*
1609 + * Copyright (C) 2013 Canonical Ltd
1610 + *
1611 + * Licensed under the Apache License, Version 2.0 (the "License");
1612 + * you may not use this file except in compliance with the License.
1613 + * You may obtain a copy of the License at
1614 + *
1615 + * http://www.apache.org/licenses/LICENSE-2.0
1616 + *
1617 + * Unless required by applicable law or agreed to in writing, software
1618 + * distributed under the License is distributed on an "AS IS" BASIS,
1619 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
1620 + * See the License for the specific language governing permissions and
1621 + * limitations under the License.
1622 + *
1623 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
1624 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
1625 + */
1626 +
1627 +#include <hybris/media/media_compatibility_layer.h>
1628 +#include "direct_media_test.h"
1629 +
1630 +#include <utils/Errors.h>
1631 +
1632 +#include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
1633 +
1634 +#include <GLES2/gl2.h>
1635 +#include <GLES2/gl2ext.h>
1636 +
1637 +#include <sys/stat.h>
1638 +#include <sys/types.h>
1639 +#include <fcntl.h>
1640 +#include <unistd.h>
1641 +
1642 +#include <cassert>
1643 +#include <cstdio>
1644 +#include <cstdlib>
1645 +#include <cstring>
1646 +
1647 +using namespace android;
1648 +
1649 +static float DestWidth = 0.0, DestHeight = 0.0;
1650 +// Actual video dimmensions
1651 +static int Width = 0, Height = 0;
1652 +
1653 +static GLfloat positionCoordinates[8];
1654 +
1655 +MediaPlayerWrapper *player = NULL;
1656 +
1657 +void calculate_position_coordinates()
1658 +{
1659 + // Assuming cropping output for now
1660 + float x = 1, y = 1;
1661 +
1662 + // Black borders
1663 + x = float(Width / DestWidth);
1664 + y = float(Height / DestHeight);
1665 +
1666 + // Make the larger side be 1
1667 + if (x > y) {
1668 + y /= x;
1669 + x = 1;
1670 + } else {
1671 + x /= y;
1672 + y = 1;
1673 + }
1674 +
1675 + positionCoordinates[0] = -x;
1676 + positionCoordinates[1] = y;
1677 + positionCoordinates[2] = -x;
1678 + positionCoordinates[3] = -y;
1679 + positionCoordinates[4] = x;
1680 + positionCoordinates[5] = -y;
1681 + positionCoordinates[6] = x;
1682 + positionCoordinates[7] = y;
1683 +}
1684 +
1685 +WindowRenderer::WindowRenderer(int width, int height)
1686 + : mThreadCmd(CMD_IDLE)
1687 +{
1688 + createThread(threadStart, this);
1689 +}
1690 +
1691 +WindowRenderer::~WindowRenderer()
1692 +{
1693 +}
1694 +
1695 +int WindowRenderer::threadStart(void* self)
1696 +{
1697 + ((WindowRenderer *)self)->glThread();
1698 + return 0;
1699 +}
1700 +
1701 +void WindowRenderer::glThread()
1702 +{
1703 + printf("%s\n", __PRETTY_FUNCTION__);
1704 +
1705 + Mutex::Autolock autoLock(mLock);
1706 +}
1707 +
1708 +struct ClientWithSurface
1709 +{
1710 + SfClient* client;
1711 + SfSurface* surface;
1712 +};
1713 +
1714 +ClientWithSurface client_with_surface(bool setup_surface_with_egl)
1715 +{
1716 + ClientWithSurface cs = ClientWithSurface();
1717 +
1718 + cs.client = sf_client_create();
1719 +
1720 + if (!cs.client) {
1721 + printf("Problem creating client ... aborting now.");
1722 + return cs;
1723 + }
1724 +
1725 + static const size_t primary_display = 0;
1726 +
1727 + DestWidth = sf_get_display_width(primary_display);
1728 + DestHeight = sf_get_display_height(primary_display);
1729 + printf("Primary display width: %f, height: %f\n", DestWidth, DestHeight);
1730 +
1731 + SfSurfaceCreationParameters params = {
1732 + 0,
1733 + 0,
1734 + (int) DestWidth,
1735 + (int) DestHeight,
1736 + -1, //PIXEL_FORMAT_RGBA_8888,
1737 + 15000,
1738 + 0.5f,
1739 + setup_surface_with_egl, // Do not associate surface with egl, will be done by camera HAL
1740 + "MediaCompatLayerTestSurface"
1741 + };
1742 +
1743 + cs.surface = sf_surface_create(cs.client, &params);
1744 +
1745 + if (!cs.surface) {
1746 + printf("Problem creating surface ... aborting now.");
1747 + return cs;
1748 + }
1749 +
1750 + sf_surface_make_current(cs.surface);
1751 +
1752 + return cs;
1753 +}
1754 +
1755 +struct RenderData
1756 +{
1757 + static const char *vertex_shader()
1758 + {
1759 + return
1760 + "attribute vec4 a_position; \n"
1761 + "attribute vec2 a_texCoord; \n"
1762 + "uniform mat4 m_texMatrix; \n"
1763 + "varying vec2 v_texCoord; \n"
1764 + "varying float topDown; \n"
1765 + "void main() \n"
1766 + "{ \n"
1767 + " gl_Position = a_position; \n"
1768 + " v_texCoord = (m_texMatrix * vec4(a_texCoord, 0.0, 1.0)).xy;\n"
1769 + "} \n";
1770 + }
1771 +
1772 + static const char *fragment_shader()
1773 + {
1774 + return
1775 + "#extension GL_OES_EGL_image_external : require \n"
1776 + "precision mediump float; \n"
1777 + "varying vec2 v_texCoord; \n"
1778 + "uniform samplerExternalOES s_texture; \n"
1779 + "void main() \n"
1780 + "{ \n"
1781 + " gl_FragColor = texture2D( s_texture, v_texCoord );\n"
1782 + "} \n";
1783 + }
1784 +
1785 + static GLuint loadShader(GLenum shaderType, const char* pSource)
1786 + {
1787 + GLuint shader = glCreateShader(shaderType);
1788 +
1789 + if (shader) {
1790 + glShaderSource(shader, 1, &pSource, NULL);
1791 + glCompileShader(shader);
1792 + GLint compiled = 0;
1793 + glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
1794 +
1795 + if (!compiled) {
1796 + GLint infoLen = 0;
1797 + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
1798 + if (infoLen) {
1799 + char* buf = (char*) malloc(infoLen);
1800 + if (buf) {
1801 + glGetShaderInfoLog(shader, infoLen, NULL, buf);
1802 + fprintf(stderr, "Could not compile shader %d:\n%s\n",
1803 + shaderType, buf);
1804 + free(buf);
1805 + }
1806 + glDeleteShader(shader);
1807 + shader = 0;
1808 + }
1809 + }
1810 + } else {
1811 + printf("Error, during shader creation: %i\n", glGetError());
1812 + }
1813 +
1814 + return shader;
1815 + }
1816 +
1817 + static GLuint create_program(const char* pVertexSource, const char* pFragmentSource)
1818 + {
1819 + GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
1820 + if (!vertexShader) {
1821 + printf("vertex shader not compiled\n");
1822 + return 0;
1823 + }
1824 +
1825 + GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
1826 + if (!pixelShader) {
1827 + printf("frag shader not compiled\n");
1828 + return 0;
1829 + }
1830 +
1831 + GLuint program = glCreateProgram();
1832 + if (program) {
1833 + glAttachShader(program, vertexShader);
1834 + glAttachShader(program, pixelShader);
1835 + glLinkProgram(program);
1836 + GLint linkStatus = GL_FALSE;
1837 + glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
1838 +
1839 + if (linkStatus != GL_TRUE) {
1840 + GLint bufLength = 0;
1841 + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
1842 + if (bufLength) {
1843 + char* buf = (char*) malloc(bufLength);
1844 + if (buf) {
1845 + glGetProgramInfoLog(program, bufLength, NULL, buf);
1846 + fprintf(stderr, "Could not link program:\n%s\n", buf);
1847 + free(buf);
1848 + }
1849 + }
1850 + glDeleteProgram(program);
1851 + program = 0;
1852 + }
1853 + }
1854 +
1855 + return program;
1856 + }
1857 +
1858 + RenderData() : program_object(create_program(vertex_shader(), fragment_shader()))
1859 + {
1860 + position_loc = glGetAttribLocation(program_object, "a_position");
1861 + tex_coord_loc = glGetAttribLocation(program_object, "a_texCoord");
1862 + sampler_loc = glGetUniformLocation(program_object, "s_texture");
1863 + matrix_loc = glGetUniformLocation(program_object, "m_texMatrix");
1864 + }
1865 +
1866 + // Handle to a program object
1867 + GLuint program_object;
1868 + // Attribute locations
1869 + GLint position_loc;
1870 + GLint tex_coord_loc;
1871 + // Sampler location
1872 + GLint sampler_loc;
1873 + // Matrix location
1874 + GLint matrix_loc;
1875 +};
1876 +
1877 +static int setup_video_texture(ClientWithSurface *cs, GLuint *preview_texture_id)
1878 +{
1879 + assert(cs != NULL);
1880 + assert(preview_texture_id != NULL);
1881 +
1882 + sf_surface_make_current(cs->surface);
1883 +
1884 + glGenTextures(1, preview_texture_id);
1885 + glClearColor(0, 0, 0, 0);
1886 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
1887 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
1888 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
1889 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
1890 +
1891 + android_media_set_preview_texture(player, *preview_texture_id);
1892 +
1893 + return 0;
1894 +}
1895 +
1896 +static void print_gl_error(unsigned int line)
1897 +{
1898 + GLint error = glGetError();
1899 + printf("GL error: %#04x (line: %d)\n", error, line);
1900 +}
1901 +
1902 +static int update_gl_buffer(RenderData *render_data, EGLDisplay *disp, EGLSurface *surface)
1903 +{
1904 + assert(disp != NULL);
1905 + assert(surface != NULL);
1906 +
1907 + GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
1908 +
1909 + const GLfloat textureCoordinates[] = {
1910 + 1.0f, 1.0f,
1911 + 0.0f, 1.0f,
1912 + 0.0f, 0.0f,
1913 + 1.0f, 0.0f
1914 + };
1915 +
1916 + calculate_position_coordinates();
1917 +
1918 + glClear(GL_COLOR_BUFFER_BIT);
1919 + // Use the program object
1920 + glUseProgram(render_data->program_object);
1921 + // Enable attributes
1922 + glEnableVertexAttribArray(render_data->position_loc);
1923 + glEnableVertexAttribArray(render_data->tex_coord_loc);
1924 + // Load the vertex position
1925 + glVertexAttribPointer(render_data->position_loc,
1926 + 2,
1927 + GL_FLOAT,
1928 + GL_FALSE,
1929 + 0,
1930 + positionCoordinates);
1931 + // Load the texture coordinate
1932 + glVertexAttribPointer(render_data->tex_coord_loc,
1933 + 2,
1934 + GL_FLOAT,
1935 + GL_FALSE,
1936 + 0,
1937 + textureCoordinates);
1938 +
1939 + GLfloat matrix[16];
1940 + android_media_surface_texture_get_transformation_matrix(player, matrix);
1941 +
1942 + glUniformMatrix4fv(render_data->matrix_loc, 1, GL_FALSE, matrix);
1943 +
1944 + glActiveTexture(GL_TEXTURE0);
1945 + // Set the sampler texture unit to 0
1946 + glUniform1i(render_data->sampler_loc, 0);
1947 + glUniform1i(render_data->matrix_loc, 0);
1948 + android_media_update_surface_texture(player);
1949 + glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
1950 + //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
1951 + glDisableVertexAttribArray(render_data->position_loc);
1952 + glDisableVertexAttribArray(render_data->tex_coord_loc);
1953 +
1954 + eglSwapBuffers(*disp, *surface);
1955 +
1956 + return 0;
1957 +}
1958 +
1959 +void set_video_size_cb(int height, int width, void *context)
1960 +{
1961 + printf("Video height: %d, width: %d\n", height, width);
1962 + printf("Video dest height: %f, width: %f\n", DestHeight, DestWidth);
1963 +
1964 + Height = height;
1965 + Width = width;
1966 +}
1967 +
1968 +int main(int argc, char **argv)
1969 +{
1970 + if (argc < 2) {
1971 + printf("Usage: direct_media_test <video_to_play>\n");
1972 + return EXIT_FAILURE;
1973 + }
1974 +
1975 + player = android_media_new_player();
1976 + if (player == NULL) {
1977 + printf("Problem creating new media player.\n");
1978 + return EXIT_FAILURE;
1979 + }
1980 +
1981 + // Set player event cb for when the video size is known:
1982 + android_media_set_video_size_cb(player, set_video_size_cb, NULL);
1983 +
1984 + printf("Setting data source to: %s.\n", argv[1]);
1985 +
1986 + if (android_media_set_data_source(player, argv[1]) != OK) {
1987 + printf("Failed to set data source: %s\n", argv[1]);
1988 + return EXIT_FAILURE;
1989 + }
1990 +
1991 + WindowRenderer renderer(DestWidth, DestHeight);
1992 +
1993 + printf("Creating EGL surface.\n");
1994 + ClientWithSurface cs = client_with_surface(true /* Associate surface with egl. */);
1995 + if (!cs.surface) {
1996 + printf("Problem acquiring surface for preview");
1997 + return EXIT_FAILURE;
1998 + }
1999 +
2000 + printf("Creating GL texture.\n");
2001 + GLuint preview_texture_id;
2002 + EGLDisplay disp = sf_client_get_egl_display(cs.client);
2003 + EGLSurface surface = sf_surface_get_egl_surface(cs.surface);
2004 +
2005 + sf_surface_make_current(cs.surface);
2006 + if (setup_video_texture(&cs, &preview_texture_id) != OK) {
2007 + printf("Problem setting up GL texture for video surface.\n");
2008 + return EXIT_FAILURE;
2009 + }
2010 +
2011 + RenderData render_data;
2012 +
2013 + printf("Starting video playback.\n");
2014 + android_media_play(player);
2015 +
2016 + printf("Updating gl buffer continuously...\n");
2017 + while (android_media_is_playing(player)) {
2018 + update_gl_buffer(&render_data, &disp, &surface);
2019 + }
2020 +
2021 + android_media_stop(player);
2022 +
2023 + return EXIT_SUCCESS;
2024 +}
2025 --- /dev/null
2026 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/direct_media_test.h
2027 @@ -0,0 +1,58 @@
2028 +/*
2029 + * Copyright (C) 2013 Canonical Ltd
2030 + *
2031 + * Licensed under the Apache License, Version 2.0 (the "License");
2032 + * you may not use this file except in compliance with the License.
2033 + * You may obtain a copy of the License at
2034 + *
2035 + * http://www.apache.org/licenses/LICENSE-2.0
2036 + *
2037 + * Unless required by applicable law or agreed to in writing, software
2038 + * distributed under the License is distributed on an "AS IS" BASIS,
2039 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2040 + * See the License for the specific language governing permissions and
2041 + * limitations under the License.
2042 + *
2043 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
2044 + */
2045 +
2046 +#ifndef DIRECT_MEDIA_TEST_H_
2047 +#define DIRECT_MEDIA_TEST_H_
2048 +
2049 +#include <EGL/egl.h>
2050 +#include <GLES2/gl2.h>
2051 +#include <utils/threads.h>
2052 +
2053 +namespace android {
2054 +
2055 +class RenderInput;
2056 +
2057 +class WindowRenderer
2058 +{
2059 +public:
2060 + WindowRenderer(int width, int height);
2061 + ~WindowRenderer();
2062 +
2063 +private:
2064 + // The GL thread functions
2065 + static int threadStart(void* self);
2066 + void glThread();
2067 +
2068 + // These variables are used to communicate between the GL thread and
2069 + // other threads.
2070 + Mutex mLock;
2071 + Condition mCond;
2072 + enum {
2073 + CMD_IDLE,
2074 + CMD_RENDER_INPUT,
2075 + CMD_RESERVE_TEXTURE,
2076 + CMD_DELETE_TEXTURE,
2077 + CMD_QUIT,
2078 + };
2079 + int mThreadCmd;
2080 + RenderInput* mThreadRenderInput;
2081 + GLuint mThreadTextureId;
2082 +};
2083 +} // android
2084 +
2085 +#endif
2086 --- /dev/null
2087 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_codec_layer.cpp
2088 @@ -0,0 +1,763 @@
2089 +/*
2090 + * Copyright (C) 2013 Canonical Ltd
2091 + *
2092 + * Licensed under the Apache License, Version 2.0 (the "License");
2093 + * you may not use this file except in compliance with the License.
2094 + * You may obtain a copy of the License at
2095 + *
2096 + * http://www.apache.org/licenses/LICENSE-2.0
2097 + *
2098 + * Unless required by applicable law or agreed to in writing, software
2099 + * distributed under the License is distributed on an "AS IS" BASIS,
2100 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2101 + * See the License for the specific language governing permissions and
2102 + * limitations under the License.
2103 + *
2104 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
2105 + */
2106 +
2107 +// Uncomment to enable verbose debug output
2108 +#define LOG_NDEBUG 0
2109 +
2110 +#undef LOG_TAG
2111 +#define LOG_TAG "MediaCodecLayer"
2112 +
2113 +#include <hybris/media/media_codec_layer.h>
2114 +#include <hybris/media/media_compatibility_layer.h>
2115 +#include <hybris/media/media_format_layer.h>
2116 +
2117 +#include "media_format_layer_priv.h"
2118 +#include "surface_texture_client_hybris_priv.h"
2119 +
2120 +#include <fcntl.h>
2121 +#include <sys/stat.h>
2122 +
2123 +#include <binder/ProcessState.h>
2124 +
2125 +#include <media/stagefright/foundation/AHandler.h>
2126 +#include <media/stagefright/foundation/AString.h>
2127 +#include <media/ICrypto.h>
2128 +#include <media/stagefright/foundation/ABuffer.h>
2129 +#include <media/stagefright/foundation/ADebug.h>
2130 +#include <media/stagefright/foundation/AMessage.h>
2131 +#include <media/stagefright/MediaCodec.h>
2132 +#include <media/stagefright/MediaErrors.h>
2133 +#include <media/stagefright/NativeWindowWrapper.h>
2134 +
2135 +#include <utils/Vector.h>
2136 +#include <utils/Log.h>
2137 +#include <utils/RefBase.h>
2138 +
2139 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__);
2140 +
2141 +using namespace android;
2142 +
2143 +struct _MediaCodecDelegate : public AHandler
2144 +{
2145 +public:
2146 + typedef sp<_MediaCodecDelegate> Ptr;
2147 +
2148 + explicit _MediaCodecDelegate(void *context);
2149 + virtual ~_MediaCodecDelegate();
2150 +
2151 +protected:
2152 + virtual void onMessageReceived(const sp<AMessage> &msg) { }
2153 +
2154 +public:
2155 + sp<MediaCodec> media_codec;
2156 + sp<ALooper> looper;
2157 +
2158 + Vector<sp<ABuffer> > input_buffers;
2159 + Vector<sp<ABuffer> > output_buffers;
2160 + List<MediaCodecBufferInfo> available_output_buffer_infos;
2161 + List<size_t> available_input_buffer_indices;
2162 + bool output_format_changed;
2163 + bool hardware_rendering;
2164 +
2165 + void *context;
2166 + unsigned int refcount;
2167 +};
2168 +
2169 +_MediaCodecDelegate::_MediaCodecDelegate(void *context)
2170 + : output_format_changed(false),
2171 + hardware_rendering(false),
2172 + context(context),
2173 + refcount(1)
2174 +{
2175 + REPORT_FUNCTION()
2176 +}
2177 +
2178 +_MediaCodecDelegate::~_MediaCodecDelegate()
2179 +{
2180 + REPORT_FUNCTION()
2181 +}
2182 +
2183 +static inline _MediaCodecDelegate *get_internal_delegate(MediaCodecDelegate delegate)
2184 +{
2185 + if (delegate == NULL)
2186 + {
2187 + ALOGE("delegate must not be NULL");
2188 + return NULL;
2189 + }
2190 +
2191 + _MediaCodecDelegate *d = static_cast<_MediaCodecDelegate*>(delegate);
2192 + // Some simple sanity checks that must be true for a valid MediaCodecDelegate instance
2193 + if (d->media_codec == NULL || d->refcount < 1)
2194 + return NULL;
2195 +
2196 + return d;
2197 +}
2198 +
2199 +MediaCodecDelegate media_codec_create_by_codec_name(const char *name)
2200 +{
2201 + REPORT_FUNCTION()
2202 +
2203 + if (name == NULL)
2204 + {
2205 + ALOGE("name must not be NULL");
2206 + return NULL;
2207 + }
2208 +
2209 + ALOGD("Creating codec '%s'", name);
2210 +
2211 + ProcessState::self()->startThreadPool();
2212 +
2213 + _MediaCodecDelegate *d(new _MediaCodecDelegate(NULL));
2214 + d->looper = new ALooper;
2215 + d->looper->start();
2216 +
2217 + d->media_codec = android::MediaCodec::CreateByComponentName(d->looper, name);
2218 +
2219 + return d;
2220 +}
2221 +
2222 +#ifdef SIMPLE_PLAYER
2223 +MediaCodec* media_codec_get(MediaCodecDelegate delegate)
2224 +{
2225 + REPORT_FUNCTION()
2226 +
2227 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2228 + if (d == NULL)
2229 + return NULL;
2230 +
2231 + return d->media_codec.get();
2232 +}
2233 +#endif
2234 +
2235 +MediaCodecDelegate media_codec_create_by_codec_type(const char *type)
2236 +{
2237 + REPORT_FUNCTION()
2238 +
2239 + if (type == NULL)
2240 + {
2241 + ALOGE("type must not be NULL");
2242 + return NULL;
2243 + }
2244 +
2245 + ALOGD("Creating codec by type '%s'", type);
2246 +
2247 + ProcessState::self()->startThreadPool();
2248 +
2249 + _MediaCodecDelegate *d(new _MediaCodecDelegate(NULL));
2250 + d->looper = new ALooper;
2251 + d->looper->start();
2252 +
2253 + d->media_codec = android::MediaCodec::CreateByType(d->looper, type, false);
2254 +
2255 + return d;
2256 +}
2257 +
2258 +void media_codec_delegate_destroy(MediaCodecDelegate delegate)
2259 +{
2260 + REPORT_FUNCTION()
2261 +
2262 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2263 + if (d == NULL)
2264 + {
2265 + ALOGE("d == NULL, cannot destroy MediaCodecDelegate instance");
2266 + return;
2267 + }
2268 +
2269 + ALOGI("Releasing media_codec");
2270 + d->media_codec->release();
2271 + ALOGI("Stopping looper");
2272 + d->looper->stop();
2273 +
2274 + ALOGI("Setting refcount = 0");
2275 + d->refcount = 0;
2276 +
2277 + ALOGI("Deleting the MediaCodecDelegate instance");
2278 + delete d;
2279 +}
2280 +
2281 +void media_codec_delegate_ref(MediaCodecDelegate delegate)
2282 +{
2283 + REPORT_FUNCTION()
2284 +
2285 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2286 + if (d == NULL)
2287 + return;
2288 +
2289 + d->refcount++;
2290 +}
2291 +
2292 +void media_codec_delegate_unref(MediaCodecDelegate delegate)
2293 +{
2294 + REPORT_FUNCTION()
2295 +
2296 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2297 + if (d == NULL)
2298 + {
2299 + ALOGE("d == NULL, cannot unref MediaCodecDelegate instance");
2300 + return;
2301 + }
2302 +
2303 + if (d->refcount > 1)
2304 + d->refcount--;
2305 + else
2306 + media_codec_delegate_destroy (delegate);
2307 +}
2308 +
2309 +#ifdef SIMPLE_PLAYER
2310 +int media_codec_configure(MediaCodecDelegate delegate, MediaFormat format, void *nativeWindow, uint32_t flags)
2311 +#else
2312 +int media_codec_configure(MediaCodecDelegate delegate, MediaFormat format, SurfaceTextureClientHybris stc, uint32_t flags)
2313 +#endif
2314 +{
2315 + REPORT_FUNCTION()
2316 +
2317 + if (format == NULL)
2318 + {
2319 + ALOGE("format must not be NULL");
2320 + return BAD_VALUE;
2321 + }
2322 +
2323 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2324 + if (d == NULL)
2325 + return BAD_VALUE;
2326 +
2327 + _MediaFormat *format_priv = static_cast<_MediaFormat*>(format);
2328 +#ifndef SIMPLE_PLAYER
2329 + _SurfaceTextureClientHybris *stch = static_cast<_SurfaceTextureClientHybris*>(stc);
2330 +#endif
2331 +
2332 + sp<AMessage> aformat = new AMessage;
2333 + aformat->setString("mime", format_priv->mime.c_str());
2334 + if (format_priv->duration_us > 0)
2335 + aformat->setInt64("durationUs", format_priv->duration_us);
2336 + aformat->setInt32("width", format_priv->width);
2337 + aformat->setInt32("height", format_priv->height);
2338 + if (format_priv->max_input_size > 0)
2339 + aformat->setInt32("max-input-size", format_priv->max_input_size);
2340 +
2341 + ALOGD("Format: %s", aformat->debugString().c_str());
2342 +
2343 +#ifdef SIMPLE_PLAYER
2344 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
2345 + sp<SurfaceTextureClient> surfaceTextureClient = static_cast<SurfaceTextureClient*>(nativeWindow);
2346 +#else
2347 + sp<Surface> surfaceTextureClient = static_cast<Surface*>(nativeWindow);
2348 +#endif
2349 + // TODO: Don't just pass NULL for the security when DRM is needed
2350 + d->media_codec->configure(aformat, surfaceTextureClient, NULL, flags);
2351 +#else
2352 + ALOGD("SurfaceTextureClientHybris: %p", stch);
2353 +
2354 + // Make sure we're ready to configure the codec and the Surface/SurfaceTextureClient together
2355 + if (stch != NULL && stch->hardwareRendering() && stch->isReady())
2356 + {
2357 + ALOGD("Doing hardware decoding with hardware rendering");
2358 + // TODO: Don't just pass NULL for the security when DRM is needed
2359 + d->media_codec->configure(aformat, stch, NULL, flags);
2360 + }
2361 + else
2362 + {
2363 + ALOGD("Doing hardware decoding path with software rendering");
2364 + // This scenario is for hardware video decoding, but software rendering, therefore there's
2365 + // no need to pass a valid Surface/SurfaceTextureClient instance to configure()
2366 + d->media_codec->configure(aformat, NULL, NULL, flags);
2367 + }
2368 +
2369 +#endif
2370 +
2371 + return OK;
2372 +}
2373 +
2374 +int media_codec_set_surface_texture_client(MediaCodecDelegate delegate, SurfaceTextureClientHybris stc)
2375 +{
2376 + REPORT_FUNCTION()
2377 +
2378 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2379 + if (d == NULL)
2380 + return BAD_VALUE;
2381 + if (stc == NULL)
2382 + {
2383 + ALOGE("stc must not be NULL");
2384 + return BAD_VALUE;
2385 + }
2386 +
2387 + _SurfaceTextureClientHybris *stcu = static_cast<_SurfaceTextureClientHybris*>(stc);
2388 + status_t err = native_window_api_connect(stcu, NATIVE_WINDOW_API_MEDIA);
2389 + if (err != OK)
2390 + {
2391 + ALOGE("native_window_api_connect returned an error: %s (%d)", strerror(-err), err);
2392 + return err;
2393 + }
2394 +
2395 + return OK;
2396 +}
2397 +
2398 +int media_codec_queue_csd(MediaCodecDelegate delegate, MediaFormat format)
2399 +{
2400 + REPORT_FUNCTION()
2401 +
2402 + if (format == NULL)
2403 + {
2404 + ALOGE("format must not be NULL");
2405 + return BAD_VALUE;
2406 + }
2407 +
2408 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2409 + _MediaFormat *format_priv = static_cast<_MediaFormat*>(format);
2410 + assert(format_priv->csd != NULL);
2411 +
2412 + status_t err = OK;
2413 +
2414 + Vector<sp<ABuffer> > input_bufs[1];
2415 + err = d->media_codec->getInputBuffers(&input_bufs[0]);
2416 + CHECK_EQ(err, static_cast<status_t>(OK));
2417 +
2418 + for (size_t i=0; i<2; ++i)
2419 + {
2420 + const sp<ABuffer> &srcBuffer = format_priv->csd;
2421 +
2422 + size_t index = 0;
2423 + err = d->media_codec->dequeueInputBuffer(&index, -1ll);
2424 + CHECK_EQ(err, static_cast<status_t>(OK));
2425 +
2426 + const sp<ABuffer> &dstBuffer = input_bufs[0].itemAt(index);
2427 +
2428 + CHECK_LE(srcBuffer->size(), dstBuffer->capacity());
2429 + dstBuffer->setRange(0, srcBuffer->size());
2430 + memcpy(dstBuffer->data(), srcBuffer->data(), srcBuffer->size());
2431 +
2432 + AString err_msg;
2433 + err = d->media_codec->queueInputBuffer(
2434 + index,
2435 + 0,
2436 + dstBuffer->size(),
2437 + 0ll,
2438 + MediaCodec::BUFFER_FLAG_CODECCONFIG);
2439 + CHECK_EQ(err, static_cast<status_t>(OK));
2440 + }
2441 +
2442 + return err;
2443 +}
2444 +
2445 +int media_codec_start(MediaCodecDelegate delegate)
2446 +{
2447 + REPORT_FUNCTION()
2448 +
2449 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2450 + if (d == NULL)
2451 + return BAD_VALUE;
2452 +
2453 + return d->media_codec->start();
2454 +}
2455 +
2456 +int media_codec_stop(MediaCodecDelegate delegate)
2457 +{
2458 + REPORT_FUNCTION()
2459 +
2460 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2461 + if (d == NULL)
2462 + return BAD_VALUE;
2463 +
2464 + return d->media_codec->stop();
2465 +}
2466 +
2467 +int media_codec_release(MediaCodecDelegate delegate)
2468 +{
2469 + REPORT_FUNCTION()
2470 +
2471 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2472 + if (d == NULL)
2473 + return BAD_VALUE;
2474 +
2475 + return d->media_codec->release();
2476 +}
2477 +
2478 +int media_codec_flush(MediaCodecDelegate delegate)
2479 +{
2480 + REPORT_FUNCTION()
2481 +
2482 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2483 + if (d == NULL)
2484 + return BAD_VALUE;
2485 +
2486 + d->available_output_buffer_infos.clear();
2487 +
2488 + return d->media_codec->flush();
2489 +}
2490 +
2491 +size_t media_codec_get_input_buffers_size(MediaCodecDelegate delegate)
2492 +{
2493 + REPORT_FUNCTION()
2494 +
2495 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2496 + if (d == NULL)
2497 + return BAD_VALUE;
2498 +
2499 + status_t ret = d->media_codec->getInputBuffers(&d->input_buffers);
2500 + if (ret != OK)
2501 + {
2502 + ALOGE("Failed to get input buffers size");
2503 + return 0;
2504 + }
2505 + ALOGD("Got %d input buffers", d->input_buffers.size());
2506 +
2507 + return d->input_buffers.size();
2508 +}
2509 +
2510 +uint8_t *media_codec_get_nth_input_buffer(MediaCodecDelegate delegate, size_t n)
2511 +{
2512 + REPORT_FUNCTION()
2513 +
2514 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2515 + if (d == NULL)
2516 + return NULL;
2517 +
2518 + if (d->input_buffers.size() == 0)
2519 + {
2520 + status_t ret = d->media_codec->getInputBuffers(&d->input_buffers);
2521 + if (ret != OK)
2522 + {
2523 + ALOGE("Failed to get input buffers");
2524 + return NULL;
2525 + }
2526 + }
2527 +
2528 + if (n > d->input_buffers.size())
2529 + {
2530 + ALOGE("Failed to get %uth input buffer, n > total buffer size", n);
2531 + return NULL;
2532 + }
2533 +
2534 + return d->input_buffers.itemAt(n).get()->data();
2535 +}
2536 +
2537 +size_t media_codec_get_nth_input_buffer_capacity(MediaCodecDelegate delegate, size_t n)
2538 +{
2539 + REPORT_FUNCTION()
2540 +
2541 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2542 + if (d == NULL)
2543 + return BAD_VALUE;
2544 +
2545 + Vector<sp<ABuffer> > input_buffers;
2546 + status_t ret = d->media_codec->getInputBuffers(&input_buffers);
2547 + if (ret != OK)
2548 + {
2549 + ALOGE("Failed to get input buffers");
2550 + return 0;
2551 + }
2552 +
2553 + if (n > input_buffers.size())
2554 + {
2555 + ALOGE("Failed to get %uth input buffer capacity, n > total buffer size", n);
2556 + return 0;
2557 + }
2558 +
2559 + return input_buffers[n].get()->capacity();
2560 +}
2561 +
2562 +size_t media_codec_get_output_buffers_size(MediaCodecDelegate delegate)
2563 +{
2564 + REPORT_FUNCTION()
2565 +
2566 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2567 + if (d == NULL)
2568 + return BAD_VALUE;
2569 +
2570 + status_t ret = d->media_codec->getOutputBuffers(&d->output_buffers);
2571 + if (ret != OK)
2572 + {
2573 + ALOGE("Failed to get output buffers size");
2574 + return 0;
2575 + }
2576 + ALOGD("Got %d output buffers", d->output_buffers.size());
2577 +
2578 + return d->output_buffers.size();
2579 +}
2580 +
2581 +uint8_t *media_codec_get_nth_output_buffer(MediaCodecDelegate delegate, size_t n)
2582 +{
2583 + REPORT_FUNCTION()
2584 +
2585 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2586 + if (d == NULL)
2587 + return NULL;
2588 +
2589 + status_t ret = d->media_codec->getOutputBuffers(&d->output_buffers);
2590 + if (ret != OK)
2591 + {
2592 + ALOGE("Failed to get output buffers");
2593 + return NULL;
2594 + }
2595 +
2596 + if (n > d->output_buffers.size())
2597 + {
2598 + ALOGE("Failed to get %uth output buffer, n > total buffer size", n);
2599 + return NULL;
2600 + }
2601 +
2602 + return d->output_buffers.itemAt(n).get()->data();
2603 +}
2604 +
2605 +size_t media_codec_get_nth_output_buffer_capacity(MediaCodecDelegate delegate, size_t n)
2606 +{
2607 + REPORT_FUNCTION()
2608 +
2609 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2610 + if (d == NULL)
2611 + return BAD_VALUE;
2612 +
2613 + status_t ret = d->media_codec->getOutputBuffers(&d->output_buffers);
2614 + if (ret != OK)
2615 + {
2616 + ALOGE("Failed to get output buffers");
2617 + return 0;
2618 + }
2619 +
2620 + if (n > d->output_buffers.size())
2621 + {
2622 + ALOGE("Failed to get %uth output buffer capacity, n > total buffer size", n);
2623 + return 0;
2624 + }
2625 +
2626 + return d->output_buffers[n].get()->capacity();
2627 +}
2628 +
2629 +#define INFO_TRY_AGAIN_LATER -1
2630 +#define INFO_OUTPUT_FORMAT_CHANGED -2
2631 +#define INFO_OUTPUT_BUFFERS_CHANGED -4
2632 +
2633 +int media_codec_dequeue_output_buffer(MediaCodecDelegate delegate, MediaCodecBufferInfo *info, int64_t timeout_us)
2634 +{
2635 + REPORT_FUNCTION()
2636 +
2637 + if (info == NULL)
2638 + {
2639 + ALOGE("info must not be NULL");
2640 + return BAD_VALUE;
2641 + }
2642 +
2643 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2644 + if (d == NULL)
2645 + return BAD_VALUE;
2646 +
2647 + int ret = d->media_codec->dequeueOutputBuffer(&info->index, &info->offset, &info->size, &info->presentation_time_us, &info->flags, timeout_us);
2648 + ALOGD("dequeueOutputBuffer() ret: %d", ret);
2649 + info->render_retries = 0;
2650 +
2651 + if (ret == -EAGAIN)
2652 + {
2653 + ALOGD("dequeueOutputBuffer returned %d", ret);
2654 + return INFO_TRY_AGAIN_LATER;
2655 + }
2656 + else if (ret & ~INFO_OUTPUT_BUFFERS_CHANGED)
2657 + {
2658 + ALOGD("Output buffers changed (ret: %d)", ret);
2659 + return INFO_OUTPUT_BUFFERS_CHANGED + 1;
2660 + }
2661 + // FIXME: Get rid of the hardcoded -10 and replace with more elegant solution
2662 + else if (ret & ~(INFO_FORMAT_CHANGED - 10))
2663 + {
2664 + ALOGD("Output buffer format changed (ret: %d)", ret);
2665 + d->output_format_changed = true;
2666 + return -2;
2667 + }
2668 +
2669 + ALOGD("Dequeued output buffer:\n-----------------------");
2670 + ALOGD("index: %u", info->index);
2671 + ALOGD("offset: %d", info->offset);
2672 + ALOGD("size: %d", info->size);
2673 + ALOGD("presentation_time_us: %lld", info->presentation_time_us);
2674 + ALOGD("flags: %d", info->flags);
2675 +
2676 + // Keep track of the used output buffer info
2677 + d->available_output_buffer_infos.push_back(*info);
2678 +
2679 + return OK;
2680 +}
2681 +
2682 +int media_codec_queue_input_buffer(MediaCodecDelegate delegate, const MediaCodecBufferInfo *info)
2683 +{
2684 + REPORT_FUNCTION()
2685 +
2686 + if (info == NULL)
2687 + {
2688 + ALOGE("info must not be NULL");
2689 + return BAD_VALUE;
2690 + }
2691 +
2692 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2693 + if (d == NULL)
2694 + return BAD_VALUE;
2695 +
2696 + // Make sure that there is at least one dequeued input buffer available
2697 + if (d->available_input_buffer_indices.empty())
2698 + {
2699 + ALOGE("Input buffer index %d has not been dequeued, cannot queue input buffer", info->index);
2700 + return BAD_VALUE;
2701 + }
2702 +
2703 + const size_t index = *d->available_input_buffer_indices.begin();
2704 + d->available_input_buffer_indices.erase(d->available_input_buffer_indices.begin());
2705 +
2706 + ALOGD("info->index: %d", index);
2707 + ALOGD("info->offset: %d", info->offset);
2708 + ALOGD("info->size: %d", info->size);
2709 + ALOGD("info->presentation_time_us: %lld", info->presentation_time_us);
2710 + ALOGD("info->flags: %d", info->flags);
2711 +
2712 + AString err_msg;
2713 + status_t ret = d->media_codec->queueInputBuffer(index, info->offset, info->size,
2714 + info->presentation_time_us, info->flags, &err_msg);
2715 + if (ret != OK)
2716 + {
2717 + ALOGE("Failed to queue input buffer (err: %d, index: %d)", ret, index);
2718 + ALOGE("Detailed error message: %s", err_msg.c_str());
2719 + }
2720 +
2721 + return ret;
2722 +}
2723 +
2724 +int media_codec_dequeue_input_buffer(MediaCodecDelegate delegate, size_t *index, int64_t timeout_us)
2725 +{
2726 + REPORT_FUNCTION()
2727 +
2728 + if (index == NULL)
2729 + {
2730 + ALOGE("index must not be NULL");
2731 + return BAD_VALUE;
2732 + }
2733 +
2734 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2735 + if (d == NULL)
2736 + return BAD_VALUE;
2737 +
2738 + status_t ret = d->media_codec->dequeueInputBuffer(index, timeout_us);
2739 + if (ret == -EAGAIN)
2740 + {
2741 + ALOGD("dequeueInputBuffer returned %d, tried timeout: %d", ret, timeout_us);
2742 + return INFO_TRY_AGAIN_LATER;
2743 + }
2744 + else if (ret == OK)
2745 + {
2746 + ALOGD("Dequeued input buffer (index: %d)", *index);
2747 + d->available_input_buffer_indices.push_back(*index);
2748 + }
2749 + else
2750 + ALOGE("Failed to dequeue input buffer (err: %d, index: %d)", ret, *index);
2751 +
2752 + return ret;
2753 +}
2754 +
2755 +int media_codec_release_output_buffer(MediaCodecDelegate delegate, size_t index, uint8_t render)
2756 +{
2757 + REPORT_FUNCTION()
2758 + ALOGV("Requesting to release output buffer index: %d, render: %d", index, render);
2759 +
2760 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2761 + if (d == NULL)
2762 + return BAD_VALUE;
2763 +
2764 + status_t ret = OK;
2765 +
2766 + auto it = d->available_output_buffer_infos.begin();
2767 + while (it != d->available_output_buffer_infos.end())
2768 + {
2769 + MediaCodecBufferInfo *info = &*it;
2770 + ALOGD("info index: %d", info->index);
2771 + ALOGD("info render_retries: %u", info->render_retries);
2772 + if (info->render_retries == 1)
2773 + {
2774 + ALOGV("Rendering and releasing output buffer %d from the available indices list", info->index);
2775 + ret = d->media_codec->renderOutputBufferAndRelease(info->index);
2776 + if (ret != OK)
2777 + {
2778 + ALOGE("Failed to release output buffer (ret: %d, index: %d)", ret, info->index);
2779 + ++info->render_retries;
2780 + }
2781 + else
2782 + {
2783 + ALOGV("Successfully rendered output buffer %d on a second try.", info->index);
2784 + d->available_output_buffer_infos.erase(it);
2785 + }
2786 + }
2787 + else if (info->render_retries > 1)
2788 + {
2789 + ALOGV("Tried to render output buffer %d twice, dropping.", info->index);
2790 + ret = d->media_codec->releaseOutputBuffer(info->index);
2791 + d->available_output_buffer_infos.erase(d->available_output_buffer_infos.begin());
2792 + }
2793 +
2794 + ++it;
2795 + }
2796 +
2797 + MediaCodecBufferInfo *info = &*d->available_output_buffer_infos.begin();
2798 + // Either render and release the output buffer, or just release.
2799 + if (render)
2800 + {
2801 + ALOGV("Rendering and releasing output buffer %d from the available indices list", info->index);
2802 + ret = d->media_codec->renderOutputBufferAndRelease(info->index);
2803 + }
2804 + else
2805 + {
2806 + ALOGV("Releasing output buffer %d from the available indices list", info->index);
2807 + ret = d->media_codec->releaseOutputBuffer(info->index);
2808 + }
2809 + if (ret != OK)
2810 + {
2811 + ALOGE("Failed to release output buffer (ret: %d, index: %d)", ret, info->index);
2812 + ++info->render_retries;
2813 + } else {
2814 + ALOGV("Released output buffer %d from the available buffer infos list", info->index);
2815 + d->available_output_buffer_infos.erase(d->available_output_buffer_infos.begin());
2816 + }
2817 +
2818 + return ret;
2819 +}
2820 +
2821 +MediaFormat media_codec_get_output_format(MediaCodecDelegate delegate)
2822 +{
2823 + REPORT_FUNCTION()
2824 +
2825 + _MediaCodecDelegate *d = get_internal_delegate(delegate);
2826 + if (d == NULL)
2827 + return NULL;
2828 +
2829 + _MediaFormat *f = new _MediaFormat();
2830 +
2831 + sp<AMessage> msg_format;
2832 + status_t ret = d->media_codec->getOutputFormat(&msg_format);
2833 + if (ret != OK)
2834 + {
2835 + ALOGE("Failed to get the output format");
2836 + return NULL;
2837 + }
2838 +
2839 + ALOGD("Output format: %s", msg_format->debugString().c_str());
2840 +
2841 + CHECK(msg_format->findString("mime", &f->mime));
2842 + CHECK(msg_format->findInt32("width", &f->width));
2843 + CHECK(msg_format->findInt32("height", &f->height));
2844 + CHECK(msg_format->findInt32("stride", &f->stride));
2845 + CHECK(msg_format->findInt32("slice-height", &f->slice_height));
2846 + CHECK(msg_format->findInt32("color-format", &f->color_format));
2847 + Rect crop;
2848 + CHECK(msg_format->findRect("crop", &crop.left, &crop.top, &crop.right, &crop.bottom));
2849 +
2850 + return f;
2851 +}
2852 --- /dev/null
2853 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_codec_list.cpp
2854 @@ -0,0 +1,228 @@
2855 +/*
2856 + * Copyright (C) 2013 Canonical Ltd
2857 + *
2858 + * Licensed under the Apache License, Version 2.0 (the "License");
2859 + * you may not use this file except in compliance with the License.
2860 + * You may obtain a copy of the License at
2861 + *
2862 + * http://www.apache.org/licenses/LICENSE-2.0
2863 + *
2864 + * Unless required by applicable law or agreed to in writing, software
2865 + * distributed under the License is distributed on an "AS IS" BASIS,
2866 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
2867 + * See the License for the specific language governing permissions and
2868 + * limitations under the License.
2869 + *
2870 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
2871 + */
2872 +
2873 +// Uncomment to enable verbose debug output
2874 +#define LOG_NDEBUG 0
2875 +
2876 +#undef LOG_TAG
2877 +#define LOG_TAG "MediaCodecList"
2878 +
2879 +#include <hybris/media/media_codec_list.h>
2880 +
2881 +#include <media/stagefright/foundation/AString.h>
2882 +#include <media/stagefright/MediaCodecList.h>
2883 +
2884 +#include <utils/Log.h>
2885 +#include <utils/Vector.h>
2886 +
2887 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__);
2888 +
2889 +using namespace android;
2890 +
2891 +ssize_t media_codec_list_find_codec_by_type(const char *type, bool encoder, size_t startIndex)
2892 +{
2893 + REPORT_FUNCTION()
2894 + return MediaCodecList::getInstance()->findCodecByType(type, encoder, startIndex);
2895 +}
2896 +
2897 +ssize_t media_codec_list_find_codec_by_name(const char *name)
2898 +{
2899 + REPORT_FUNCTION()
2900 + return MediaCodecList::getInstance()->findCodecByName(name);
2901 +}
2902 +
2903 +size_t media_codec_list_count_codecs()
2904 +{
2905 + REPORT_FUNCTION()
2906 + return MediaCodecList::getInstance()->countCodecs();
2907 +}
2908 +
2909 +void media_codec_list_get_codec_info_at_id(size_t index)
2910 +{
2911 + REPORT_FUNCTION()
2912 +}
2913 +
2914 +const char *media_codec_list_get_codec_name(size_t index)
2915 +{
2916 + REPORT_FUNCTION()
2917 + return MediaCodecList::getInstance()->getCodecName(index);
2918 +}
2919 +
2920 +bool media_codec_list_is_encoder(size_t index)
2921 +{
2922 + REPORT_FUNCTION()
2923 + return MediaCodecList::getInstance()->isEncoder(index);
2924 +}
2925 +
2926 +size_t media_codec_list_get_num_supported_types(size_t index)
2927 +{
2928 + REPORT_FUNCTION()
2929 +
2930 + Vector<AString> types;
2931 + status_t err = MediaCodecList::getInstance()->getSupportedTypes(index, &types);
2932 + if (err != OK)
2933 + {
2934 + ALOGE("Failed to get the number of supported codec types (err: %d)", err);
2935 + return 0;
2936 + }
2937 + ALOGD("Number of supported codec types: %d", types.size());
2938 +
2939 + return types.size();
2940 +}
2941 +
2942 +size_t media_codec_list_get_nth_supported_type_len(size_t index, size_t n)
2943 +{
2944 + REPORT_FUNCTION()
2945 +
2946 + Vector<AString> types;
2947 + status_t err = MediaCodecList::getInstance()->getSupportedTypes(index, &types);
2948 +
2949 + return types[n].size();
2950 +}
2951 +
2952 +int media_codec_list_get_nth_supported_type(size_t index, char *type, size_t n)
2953 +{
2954 + REPORT_FUNCTION()
2955 +
2956 + if (type == NULL)
2957 + {
2958 + ALOGE("types must not be NULL");
2959 + return BAD_VALUE;
2960 + }
2961 +
2962 + Vector<AString> types;
2963 + status_t err = MediaCodecList::getInstance()->getSupportedTypes(index, &types);
2964 + for (size_t i=0; i<types[n].size(); ++i)
2965 + type[i] = types.itemAt(n).c_str()[i];
2966 +
2967 + return err;
2968 +}
2969 +
2970 +static void media_codec_list_get_num_codec_capabilities(size_t index, const char *type, size_t *num_profile_levels, size_t *num_color_formats)
2971 +{
2972 + REPORT_FUNCTION()
2973 +
2974 + Vector<MediaCodecList::ProfileLevel> profile_levels;
2975 + Vector<uint32_t> color_formats;
2976 + ALOGD("index: %d, type: '%s'", index, type);
2977 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
2978 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &color_formats);
2979 +#else
2980 + uint32_t flags;
2981 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &color_formats, &flags);
2982 +#endif
2983 + if (err != OK)
2984 + {
2985 + ALOGE("Failed to get the number of supported codec capabilities (err: %d)", err);
2986 + return;
2987 + }
2988 +
2989 + if (num_profile_levels != NULL)
2990 + {
2991 + ALOGD("Number of codec profile levels: %d", profile_levels.size());
2992 + *num_profile_levels = profile_levels.size();
2993 + }
2994 + if (num_color_formats != NULL)
2995 + {
2996 + ALOGD("Number of codec color formats: %d", color_formats.size());
2997 + *num_color_formats = color_formats.size();
2998 + }
2999 +}
3000 +
3001 +size_t media_codec_list_get_num_profile_levels(size_t index, const char *type)
3002 +{
3003 + REPORT_FUNCTION()
3004 +
3005 + size_t num = 0;
3006 + media_codec_list_get_num_codec_capabilities(index, type, &num, NULL);
3007 +
3008 + return num;
3009 +}
3010 +
3011 +size_t media_codec_list_get_num_color_formats(size_t index, const char *type)
3012 +{
3013 + REPORT_FUNCTION()
3014 +
3015 + size_t num = 0;
3016 + media_codec_list_get_num_codec_capabilities(index, type, NULL, &num);
3017 +
3018 + return num;
3019 +}
3020 +
3021 +int media_codec_list_get_nth_codec_profile_level(size_t index, const char *type, profile_level *pro_level, size_t n)
3022 +{
3023 + REPORT_FUNCTION()
3024 +
3025 + if (type == NULL)
3026 + {
3027 + ALOGE("types must not be NULL");
3028 + return BAD_VALUE;
3029 + }
3030 +
3031 + if (pro_level == NULL)
3032 + {
3033 + ALOGE("pro_level must not be NULL");
3034 + return BAD_VALUE;
3035 + }
3036 +
3037 + Vector<MediaCodecList::ProfileLevel> profile_levels;
3038 + Vector<uint32_t> formats;
3039 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
3040 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &formats);
3041 +#else
3042 + uint32_t flags;
3043 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &formats, &flags);
3044 +#endif
3045 + if (err != OK)
3046 + {
3047 + ALOGE("Failed to get the nth codec profile level (err: %d)", err);
3048 + return 0;
3049 + }
3050 +
3051 + pro_level->profile = profile_levels[n].mProfile;
3052 + pro_level->level = profile_levels[n].mLevel;
3053 +
3054 + return err;
3055 +}
3056 +
3057 +int media_codec_list_get_codec_color_formats(size_t index, const char *type, uint32_t *color_formats)
3058 +{
3059 + REPORT_FUNCTION()
3060 +
3061 + Vector<MediaCodecList::ProfileLevel> profile_levels;
3062 + Vector<uint32_t> formats;
3063 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
3064 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &formats);
3065 +#else
3066 + uint32_t flags;
3067 + status_t err = MediaCodecList::getInstance()->getCodecCapabilities(index, type, &profile_levels, &formats, &flags);
3068 +#endif
3069 + if (err != OK)
3070 + {
3071 + ALOGE("Failed to get the number of supported codec types (err: %d)", err);
3072 + return 0;
3073 + }
3074 +
3075 + for (size_t i=0; i<formats.size(); ++i)
3076 + {
3077 + color_formats[i] = formats[i];
3078 + ALOGD("Color format [%d]: %d", i, formats[i]);
3079 + }
3080 +
3081 + return OK;
3082 +}
3083 --- /dev/null
3084 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_compatibility_layer.cpp
3085 @@ -0,0 +1,660 @@
3086 +/*
3087 + * Copyright (C) 2013 Canonical Ltd
3088 + *
3089 + * Licensed under the Apache License, Version 2.0 (the "License");
3090 + * you may not use this file except in compliance with the License.
3091 + * You may obtain a copy of the License at
3092 + *
3093 + * http://www.apache.org/licenses/LICENSE-2.0
3094 + *
3095 + * Unless required by applicable law or agreed to in writing, software
3096 + * distributed under the License is distributed on an "AS IS" BASIS,
3097 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3098 + * See the License for the specific language governing permissions and
3099 + * limitations under the License.
3100 + *
3101 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
3102 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
3103 + */
3104 +
3105 +// Uncomment to enable verbose debug output
3106 +#define LOG_NDEBUG 0
3107 +
3108 +#undef LOG_TAG
3109 +#define LOG_TAG "MediaCompatibilityLayer"
3110 +
3111 +#include <hybris/media/media_compatibility_layer.h>
3112 +
3113 +#include <fcntl.h>
3114 +#include <sys/stat.h>
3115 +
3116 +#include <media/mediaplayer.h>
3117 +
3118 +#include <binder/ProcessState.h>
3119 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3120 +#include <gui/SurfaceTexture.h>
3121 +#else
3122 +#include <gui/GLConsumer.h>
3123 +#endif
3124 +
3125 +#include <GLES2/gl2.h>
3126 +#include <GLES2/gl2ext.h>
3127 +
3128 +#include <ui/GraphicBuffer.h>
3129 +
3130 +#include <utils/Log.h>
3131 +
3132 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
3133 +
3134 +namespace android
3135 +{
3136 +NativeBufferAlloc::NativeBufferAlloc() {
3137 +}
3138 +
3139 +NativeBufferAlloc::~NativeBufferAlloc() {
3140 +}
3141 +
3142 +sp<GraphicBuffer> NativeBufferAlloc::createGraphicBuffer(uint32_t w, uint32_t h,
3143 + PixelFormat format, uint32_t usage, status_t* error) {
3144 + sp<GraphicBuffer> graphicBuffer(new GraphicBuffer(w, h, format, usage));
3145 + status_t err = graphicBuffer->initCheck();
3146 + *error = err;
3147 + if (err != 0 || graphicBuffer->handle == 0) {
3148 + if (err == NO_MEMORY) {
3149 + GraphicBuffer::dumpAllocationsToSystemLog();
3150 + }
3151 + ALOGI("GraphicBufferAlloc::createGraphicBuffer(w=%d, h=%d) "
3152 + "failed (%s), handle=%p",
3153 + w, h, strerror(-err), graphicBuffer->handle);
3154 + return 0;
3155 + }
3156 + return graphicBuffer;
3157 +}
3158 +}
3159 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3160 +struct FrameAvailableListener : public android::SurfaceTexture::FrameAvailableListener
3161 +#else
3162 +struct FrameAvailableListener : public android::GLConsumer::FrameAvailableListener
3163 +#endif
3164 +{
3165 + public:
3166 + FrameAvailableListener()
3167 + : set_video_texture_needs_update_cb(NULL),
3168 + video_texture_needs_update_context(NULL)
3169 + {
3170 + }
3171 +
3172 + // From android::GLConsumer/SurfaceTexture::FrameAvailableListener
3173 + void onFrameAvailable()
3174 + {
3175 + if (set_video_texture_needs_update_cb != NULL)
3176 + set_video_texture_needs_update_cb(video_texture_needs_update_context);
3177 + }
3178 +
3179 + void setVideoTextureNeedsUpdateCb(on_video_texture_needs_update cb, void *context)
3180 + {
3181 + set_video_texture_needs_update_cb = cb;
3182 + video_texture_needs_update_context = context;
3183 + }
3184 +
3185 + private:
3186 + on_video_texture_needs_update set_video_texture_needs_update_cb;
3187 + void *video_texture_needs_update_context;
3188 +};
3189 +
3190 +class MediaPlayerListenerWrapper : public android::MediaPlayerListener
3191 +{
3192 + public:
3193 + MediaPlayerListenerWrapper()
3194 + : set_video_size_cb(NULL),
3195 + video_size_context(NULL),
3196 + error_cb(NULL),
3197 + error_context(NULL),
3198 + playback_complete_cb(NULL),
3199 + playback_complete_context(NULL),
3200 + media_prepared_cb(NULL),
3201 + media_prepared_context(NULL)
3202 + {
3203 + }
3204 +
3205 + void notify(int msg, int ext1, int ext2, const android::Parcel *obj)
3206 + {
3207 + ALOGV("\tmsg: %d, ext1: %d, ext2: %d \n", msg, ext1, ext2);
3208 +
3209 + switch (msg) {
3210 + case android::MEDIA_PREPARED:
3211 + ALOGV("\tMEDIA_PREPARED msg\n");
3212 + if (media_prepared_cb != NULL)
3213 + media_prepared_cb(media_prepared_context);
3214 + else
3215 + ALOGW("Failed to signal media prepared, callback not set.");
3216 + break;
3217 + case android::MEDIA_PLAYBACK_COMPLETE:
3218 + ALOGV("\tMEDIA_PLAYBACK_COMPLETE msg\n");
3219 + if (playback_complete_cb != NULL)
3220 + playback_complete_cb(playback_complete_context);
3221 + else
3222 + ALOGW("Failed to signal end of playback, callback not set.");
3223 + break;
3224 + case android::MEDIA_BUFFERING_UPDATE:
3225 + ALOGV("\tMEDIA_BUFFERING_UPDATE msg\n");
3226 + break;
3227 + case android::MEDIA_SEEK_COMPLETE:
3228 + ALOGV("\tMEDIA_SEEK_COMPLETE msg\n");
3229 + break;
3230 + case android::MEDIA_SET_VIDEO_SIZE:
3231 + ALOGV("\tMEDIA_SET_VIDEO_SIZE msg\n");
3232 + if (set_video_size_cb != NULL)
3233 + set_video_size_cb(ext2, ext1, video_size_context);
3234 + else
3235 + ALOGE("Failed to set video size. set_video_size_cb is NULL.");
3236 + break;
3237 + case android::MEDIA_TIMED_TEXT:
3238 + ALOGV("\tMEDIA_TIMED_TEXT msg\n");
3239 + break;
3240 + case android::MEDIA_ERROR:
3241 + ALOGV("\tMEDIA_ERROR msg\n");
3242 + // TODO: Extend this cb to include the error message
3243 + if (error_cb != NULL)
3244 + error_cb(error_context);
3245 + else
3246 + ALOGE("Failed to signal error to app layer, callback not set.");
3247 + break;
3248 + case android::MEDIA_INFO:
3249 + ALOGV("\tMEDIA_INFO msg\n");
3250 + break;
3251 + default:
3252 + ALOGV("\tUnknown media msg\n");
3253 + }
3254 + }
3255 +
3256 + void setVideoSizeCb(on_msg_set_video_size cb, void *context)
3257 + {
3258 + REPORT_FUNCTION();
3259 +
3260 + set_video_size_cb = cb;
3261 + video_size_context = context;
3262 + }
3263 +
3264 + void setErrorCb(on_msg_error cb, void *context)
3265 + {
3266 + REPORT_FUNCTION();
3267 +
3268 + error_cb = cb;
3269 + error_context = context;
3270 + }
3271 +
3272 + void setPlaybackCompleteCb(on_playback_complete cb, void *context)
3273 + {
3274 + REPORT_FUNCTION();
3275 +
3276 + playback_complete_cb = cb;
3277 + playback_complete_context = context;
3278 + }
3279 +
3280 + void setMediaPreparedCb(on_media_prepared cb, void *context)
3281 + {
3282 + REPORT_FUNCTION();
3283 +
3284 + media_prepared_cb = cb;
3285 + media_prepared_context = context;
3286 + }
3287 +
3288 + private:
3289 + on_msg_set_video_size set_video_size_cb;
3290 + void *video_size_context;
3291 + on_msg_error error_cb;
3292 + void *error_context;
3293 + on_playback_complete playback_complete_cb;
3294 + void *playback_complete_context;
3295 + on_media_prepared media_prepared_cb;
3296 + void *media_prepared_context;
3297 +};
3298 +
3299 +// ----- MediaPlayer Wrapper ----- //
3300 +
3301 +struct MediaPlayerWrapper : public android::MediaPlayer
3302 +{
3303 + public:
3304 + MediaPlayerWrapper()
3305 + : MediaPlayer(),
3306 + texture(NULL),
3307 + media_player_listener(new MediaPlayerListenerWrapper()),
3308 + frame_listener(new FrameAvailableListener),
3309 + left_volume(1), // Set vol to 100% for this track by default
3310 + right_volume(1),
3311 + source_fd(-1)
3312 + {
3313 + setListener(media_player_listener);
3314 + // Update the live volume with the cached values
3315 + MediaPlayer::setVolume(left_volume, right_volume);
3316 + }
3317 +
3318 + ~MediaPlayerWrapper()
3319 + {
3320 + reset();
3321 + source_fd = -1;
3322 + }
3323 +
3324 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3325 + android::status_t setVideoSurfaceTexture(const android::sp<android::SurfaceTexture> &surfaceTexture)
3326 +#else
3327 + android::status_t setVideoSurfaceTexture(android::sp<android::BufferQueue> bq, const android::sp<android::GLConsumer> &surfaceTexture)
3328 +#endif
3329 + {
3330 + REPORT_FUNCTION();
3331 +
3332 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3333 + surfaceTexture->getBufferQueue()->setBufferCount(5);
3334 +#else
3335 + bq->setBufferCount(5);
3336 +#endif
3337 + texture = surfaceTexture;
3338 + texture->setFrameAvailableListener(frame_listener);
3339 +
3340 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3341 + return MediaPlayer::setVideoSurfaceTexture(surfaceTexture->getBufferQueue());
3342 +#else
3343 + return MediaPlayer::setVideoSurfaceTexture(bq);
3344 +#endif
3345 + }
3346 +
3347 + void updateGLConsumer()
3348 + {
3349 + assert(texture != NULL);
3350 + texture->updateTexImage();
3351 + }
3352 +
3353 + void get_transformation_matrix_for_surface_texture(GLfloat* matrix)
3354 + {
3355 + assert(texture != NULL);
3356 + texture->getTransformMatrix(matrix);
3357 + }
3358 +
3359 + void setVideoSizeCb(on_msg_set_video_size cb, void *context)
3360 + {
3361 + REPORT_FUNCTION();
3362 +
3363 + assert(media_player_listener != NULL);
3364 + media_player_listener->setVideoSizeCb(cb, context);
3365 + }
3366 +
3367 + void setVideoTextureNeedsUpdateCb(on_video_texture_needs_update cb, void *context)
3368 + {
3369 + REPORT_FUNCTION();
3370 +
3371 + assert(frame_listener != NULL);
3372 + frame_listener->setVideoTextureNeedsUpdateCb(cb, context);
3373 + }
3374 +
3375 + void setErrorCb(on_msg_error cb, void *context)
3376 + {
3377 + REPORT_FUNCTION();
3378 +
3379 + assert(media_player_listener != NULL);
3380 + media_player_listener->setErrorCb(cb, context);
3381 + }
3382 +
3383 + void setPlaybackCompleteCb(on_playback_complete cb, void *context)
3384 + {
3385 + REPORT_FUNCTION();
3386 +
3387 + assert(media_player_listener != NULL);
3388 + media_player_listener->setPlaybackCompleteCb(cb, context);
3389 + }
3390 +
3391 + void setMediaPreparedCb(on_media_prepared cb, void *context)
3392 + {
3393 + REPORT_FUNCTION();
3394 +
3395 + assert(media_player_listener != NULL);
3396 + media_player_listener->setMediaPreparedCb(cb, context);
3397 + }
3398 +
3399 + void getVolume(float *leftVolume, float *rightVolume)
3400 + {
3401 + *leftVolume = left_volume;
3402 + *rightVolume = right_volume;
3403 + }
3404 +
3405 + android::status_t setVolume(float leftVolume, float rightVolume)
3406 + {
3407 + REPORT_FUNCTION();
3408 +
3409 + left_volume = leftVolume;
3410 + right_volume = rightVolume;
3411 + return MediaPlayer::setVolume(leftVolume, rightVolume);
3412 + }
3413 +
3414 + int getSourceFd() const { return source_fd; }
3415 + void setSourceFd(int fd) { source_fd = fd; }
3416 +
3417 + private:
3418 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3419 + android::sp<android::SurfaceTexture> texture;
3420 +#else
3421 + android::sp<android::GLConsumer> texture;
3422 +#endif
3423 + android::sp<MediaPlayerListenerWrapper> media_player_listener;
3424 + android::sp<FrameAvailableListener> frame_listener;
3425 + float left_volume;
3426 + float right_volume;
3427 + int source_fd;
3428 +}; // MediaPlayerWrapper
3429 +
3430 +using namespace android;
3431 +
3432 +// ----- Media Player C API Implementation ----- //
3433 +
3434 +void android_media_set_video_size_cb(MediaPlayerWrapper *mp, on_msg_set_video_size cb, void *context)
3435 +{
3436 + REPORT_FUNCTION();
3437 +
3438 + if (mp == NULL) {
3439 + ALOGE("mp must not be NULL");
3440 + return;
3441 + }
3442 +
3443 + mp->setVideoSizeCb(cb, context);
3444 +}
3445 +
3446 +void android_media_set_video_texture_needs_update_cb(MediaPlayerWrapper *mp, on_video_texture_needs_update cb, void *context)
3447 +{
3448 + REPORT_FUNCTION();
3449 +
3450 + if (mp == NULL) {
3451 + ALOGE("mp must not be NULL");
3452 + return;
3453 + }
3454 +
3455 + mp->setVideoTextureNeedsUpdateCb(cb, context);
3456 +}
3457 +
3458 +void android_media_set_error_cb(MediaPlayerWrapper *mp, on_msg_error cb, void *context)
3459 +{
3460 + REPORT_FUNCTION();
3461 +
3462 + if (mp == NULL) {
3463 + ALOGE("mp must not be NULL");
3464 + return;
3465 + }
3466 +
3467 + mp->setErrorCb(cb, context);
3468 +}
3469 +
3470 +void android_media_set_playback_complete_cb(MediaPlayerWrapper *mp, on_playback_complete cb, void *context)
3471 +{
3472 + REPORT_FUNCTION();
3473 +
3474 + if (mp == NULL) {
3475 + ALOGE("mp must not be NULL");
3476 + return;
3477 + }
3478 +
3479 + mp->setPlaybackCompleteCb(cb, context);
3480 +}
3481 +
3482 +void android_media_set_media_prepared_cb(MediaPlayerWrapper *mp, on_media_prepared cb, void *context)
3483 +{
3484 + REPORT_FUNCTION();
3485 +
3486 + if (mp == NULL) {
3487 + ALOGE("mp must not be NULL");
3488 + return;
3489 + }
3490 +
3491 + mp->setMediaPreparedCb(cb, context);
3492 +}
3493 +
3494 +MediaPlayerWrapper *android_media_new_player()
3495 +{
3496 + REPORT_FUNCTION();
3497 +
3498 + MediaPlayerWrapper *mp = new MediaPlayerWrapper();
3499 + if (mp == NULL) {
3500 + ALOGE("Failed to create new MediaPlayerWrapper instance.");
3501 + return NULL;
3502 + }
3503 +
3504 + // Required for internal player state processing. Without this, prepare() and start() hang.
3505 + ProcessState::self()->startThreadPool();
3506 +
3507 + return mp;
3508 +}
3509 +
3510 +int android_media_set_data_source(MediaPlayerWrapper *mp, const char* url)
3511 +{
3512 + REPORT_FUNCTION();
3513 +
3514 + if (mp == NULL) {
3515 + ALOGE("mp must not be NULL");
3516 + return BAD_VALUE;
3517 + }
3518 +
3519 + if (url == NULL) {
3520 + ALOGE("url must not be NULL");
3521 + return BAD_VALUE;
3522 + }
3523 +
3524 + ALOGD("url: %s", url);
3525 +
3526 + String16 src(url);
3527 + if (src.startsWith(String16("http://")) == true) {
3528 + ALOGD("HTTP source URL detected");
3529 + mp->setDataSource(url, NULL);
3530 + } else {
3531 + ALOGD("File source URL detected");
3532 + int fd = open(url, O_RDONLY);
3533 + if (fd < 0)
3534 + {
3535 + ALOGE("Failed to open source data at: %s\n", url);
3536 + return BAD_VALUE;
3537 + }
3538 +
3539 + mp->setSourceFd(fd);
3540 +
3541 + struct stat st;
3542 + stat(url, &st);
3543 +
3544 + ALOGD("source file length: %lld\n", st.st_size);
3545 +
3546 + mp->setDataSource(fd, 0, st.st_size);
3547 + }
3548 + mp->prepare();
3549 +
3550 + return OK;
3551 +}
3552 +
3553 +int android_media_set_preview_texture(MediaPlayerWrapper *mp, int texture_id)
3554 +{
3555 + REPORT_FUNCTION();
3556 +
3557 + if (mp == NULL) {
3558 + ALOGE("mp must not be NULL");
3559 + return BAD_VALUE;
3560 + }
3561 +
3562 + android::sp<android::NativeBufferAlloc> native_alloc(
3563 + new android::NativeBufferAlloc()
3564 + );
3565 +
3566 + android::sp<android::BufferQueue> buffer_queue(
3567 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
3568 + new android::BufferQueue(false, NULL, native_alloc)
3569 +#else
3570 + new android::BufferQueue(NULL, native_alloc)
3571 +#endif
3572 + );
3573 +
3574 + static const bool allow_synchronous_mode = true;
3575 + // Create a new GLConsumer/SurfaceTexture from the texture_id in synchronous mode (don't wait on all data in the buffer)
3576 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
3577 + mp->setVideoSurfaceTexture(android::sp<android::SurfaceTexture>(
3578 + new android::SurfaceTexture(
3579 +#else
3580 + mp->setVideoSurfaceTexture(buffer_queue, android::sp<android::GLConsumer>(
3581 + new android::GLConsumer(
3582 +#endif
3583 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
3584 + texture_id,
3585 + allow_synchronous_mode,
3586 + GL_TEXTURE_EXTERNAL_OES,
3587 + true,
3588 + buffer_queue)));
3589 +#else
3590 + buffer_queue,
3591 + texture_id,
3592 + GL_TEXTURE_EXTERNAL_OES,
3593 + true,
3594 + false)));
3595 +#endif
3596 +
3597 + return OK;
3598 +}
3599 +
3600 +void android_media_update_surface_texture(MediaPlayerWrapper *mp)
3601 +{
3602 + if (mp == NULL) {
3603 + ALOGE("mp must not be NULL");
3604 + return;
3605 + }
3606 +
3607 + mp->updateGLConsumer();
3608 +}
3609 +
3610 +void android_media_surface_texture_get_transformation_matrix(MediaPlayerWrapper *mp, GLfloat* matrix)
3611 +{
3612 + if (mp == NULL) {
3613 + ALOGE("mp must not be NULL");
3614 + return;
3615 + }
3616 +
3617 + mp->get_transformation_matrix_for_surface_texture(matrix);
3618 +}
3619 +
3620 +int android_media_play(MediaPlayerWrapper *mp)
3621 +{
3622 + REPORT_FUNCTION();
3623 +
3624 + if (mp == NULL) {
3625 + ALOGE("mp must not be NULL");
3626 + return BAD_VALUE;
3627 + }
3628 +
3629 + mp->start();
3630 + const char *tmp = mp->isPlaying() ? "yes" : "no";
3631 + ALOGV("Is playing?: %s\n", tmp);
3632 +
3633 + return OK;
3634 +}
3635 +
3636 +int android_media_pause(MediaPlayerWrapper *mp)
3637 +{
3638 + REPORT_FUNCTION();
3639 +
3640 + if (mp == NULL) {
3641 + ALOGE("mp must not be NULL");
3642 + return BAD_VALUE;
3643 + }
3644 +
3645 + mp->pause();
3646 +
3647 + return OK;
3648 +}
3649 +
3650 +int android_media_stop(MediaPlayerWrapper *mp)
3651 +{
3652 + REPORT_FUNCTION();
3653 +
3654 + if (mp == NULL) {
3655 + ALOGE("mp must not be NULL");
3656 + return BAD_VALUE;
3657 + }
3658 +
3659 + mp->stop();
3660 +
3661 + int fd = mp->getSourceFd();
3662 + if (fd > -1)
3663 + close(fd);
3664 +
3665 + return OK;
3666 +}
3667 +
3668 +bool android_media_is_playing(MediaPlayerWrapper *mp)
3669 +{
3670 + if (mp != NULL) {
3671 + if (mp->isPlaying())
3672 + return true;
3673 + }
3674 +
3675 + return false;
3676 +}
3677 +
3678 +int android_media_seek_to(MediaPlayerWrapper *mp, int msec)
3679 +{
3680 + REPORT_FUNCTION();
3681 +
3682 + if (mp == NULL) {
3683 + ALOGE("mp must not be NULL");
3684 + return BAD_VALUE;
3685 + }
3686 +
3687 + return mp->seekTo(msec);
3688 +}
3689 +
3690 +int android_media_get_current_position(MediaPlayerWrapper *mp, int *msec)
3691 +{
3692 + if (mp == NULL) {
3693 + ALOGE("mp must not be NULL");
3694 + return BAD_VALUE;
3695 + }
3696 +
3697 + return mp->getCurrentPosition(msec);
3698 +}
3699 +
3700 +int android_media_get_duration(MediaPlayerWrapper *mp, int *msec)
3701 +{
3702 + REPORT_FUNCTION();
3703 +
3704 + if (mp == NULL) {
3705 + ALOGE("mp must not be NULL");
3706 + return BAD_VALUE;
3707 + }
3708 +
3709 + return mp->getDuration(msec);
3710 +}
3711 +
3712 +int android_media_get_volume(MediaPlayerWrapper *mp, int *volume)
3713 +{
3714 + REPORT_FUNCTION();
3715 +
3716 + if (volume == NULL) {
3717 + ALOGE("volume must not be NULL");
3718 + return BAD_VALUE;
3719 + }
3720 +
3721 + if (mp == NULL) {
3722 + ALOGE("mp must not be NULL");
3723 + return BAD_VALUE;
3724 + }
3725 +
3726 + float left_volume = 0, right_volume = 0;
3727 + mp->getVolume(&left_volume, &right_volume);
3728 + *volume = left_volume * 100;
3729 +
3730 + return OK;
3731 +}
3732 +
3733 +int android_media_set_volume(MediaPlayerWrapper *mp, int volume)
3734 +{
3735 + REPORT_FUNCTION();
3736 +
3737 + if (mp == NULL) {
3738 + ALOGE("mp must not be NULL");
3739 + return BAD_VALUE;
3740 + }
3741 +
3742 + float left_volume = float(volume / 100);
3743 + float right_volume = float(volume / 100);
3744 + return mp->setVolume(left_volume, right_volume);
3745 +}
3746 --- /dev/null
3747 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_format_layer.cpp
3748 @@ -0,0 +1,245 @@
3749 +/*
3750 + * Copyright (C) 2013 Canonical Ltd
3751 + *
3752 + * Licensed under the Apache License, Version 2.0 (the "License");
3753 + * you may not use this file except in compliance with the License.
3754 + * You may obtain a copy of the License at
3755 + *
3756 + * http://www.apache.org/licenses/LICENSE-2.0
3757 + *
3758 + * Unless required by applicable law or agreed to in writing, software
3759 + * distributed under the License is distributed on an "AS IS" BASIS,
3760 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
3761 + * See the License for the specific language governing permissions and
3762 + * limitations under the License.
3763 + *
3764 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
3765 + */
3766 +
3767 +// Uncomment to enable verbose debug output
3768 +#define LOG_NDEBUG 0
3769 +
3770 +#undef LOG_TAG
3771 +#define LOG_TAG "MediaFormatLayer"
3772 +
3773 +#include <hybris/media/media_format_layer.h>
3774 +#include "media_format_layer_priv.h"
3775 +
3776 +#include <assert.h>
3777 +
3778 +#include <utils/Log.h>
3779 +
3780 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__);
3781 +
3782 +using namespace android;
3783 +
3784 +static inline _MediaFormat *get_internal_format(MediaFormat format)
3785 +{
3786 + if (format == NULL)
3787 + {
3788 + ALOGE("format must not be NULL");
3789 + return NULL;
3790 + }
3791 +
3792 + _MediaFormat *mf = static_cast<_MediaFormat*>(format);
3793 + assert(mf->refcount >= 1);
3794 +
3795 + return mf;
3796 +}
3797 +
3798 +MediaFormat media_format_create_video_format(const char *mime, int32_t width, int32_t height, int64_t duration_us, int32_t max_input_size)
3799 +{
3800 + REPORT_FUNCTION()
3801 +
3802 + _MediaFormat *format = new _MediaFormat();
3803 + format->mime = AString(mime);
3804 + format->width = width;
3805 + format->height = height;
3806 + format->duration_us = duration_us;
3807 + format->max_input_size = max_input_size;
3808 +
3809 + return format;
3810 +}
3811 +
3812 +void media_format_destroy(MediaFormat format)
3813 +{
3814 + REPORT_FUNCTION()
3815 +
3816 + _MediaFormat *mf = get_internal_format(format);
3817 + if (mf == NULL)
3818 + return;
3819 +
3820 + if (mf->refcount)
3821 + return;
3822 +
3823 + delete mf;
3824 +}
3825 +
3826 +void media_format_ref(MediaFormat format)
3827 +{
3828 + REPORT_FUNCTION()
3829 +
3830 + _MediaFormat *mf = get_internal_format(format);
3831 + if (mf == NULL)
3832 + return;
3833 +
3834 + mf->refcount++;
3835 +}
3836 +
3837 +void media_format_unref(MediaFormat format)
3838 +{
3839 + REPORT_FUNCTION()
3840 +
3841 + _MediaFormat *mf = get_internal_format(format);
3842 + if (mf == NULL)
3843 + return;
3844 +
3845 + if (mf->refcount)
3846 + mf->refcount--;
3847 +}
3848 +
3849 +void media_format_set_byte_buffer(MediaFormat format, const char *key, uint8_t *data, size_t size)
3850 +{
3851 + REPORT_FUNCTION()
3852 +
3853 + _MediaFormat *mf = get_internal_format(format);
3854 + if (mf == NULL)
3855 + return;
3856 + if (key == NULL || data == NULL || size == 0)
3857 + return;
3858 +
3859 + mf->csd_key_name = AString(key);
3860 + mf->csd = sp<ABuffer>(new ABuffer(data, size));
3861 +}
3862 +
3863 +const char* media_format_get_mime(MediaFormat format)
3864 +{
3865 + REPORT_FUNCTION()
3866 +
3867 + _MediaFormat *mf = get_internal_format(format);
3868 + if (mf == NULL)
3869 + return NULL;
3870 +
3871 + return mf->mime.c_str();
3872 +}
3873 +
3874 +int64_t media_format_get_duration_us(MediaFormat format)
3875 +{
3876 + REPORT_FUNCTION()
3877 +
3878 + _MediaFormat *mf = get_internal_format(format);
3879 + if (mf == NULL)
3880 + return 0;
3881 +
3882 + return mf->duration_us;
3883 +}
3884 +
3885 +int32_t media_format_get_width(MediaFormat format)
3886 +{
3887 + REPORT_FUNCTION()
3888 +
3889 + _MediaFormat *mf = get_internal_format(format);
3890 + if (mf == NULL)
3891 + return 0;
3892 +
3893 + return mf->width;
3894 +}
3895 +
3896 +int32_t media_format_get_height(MediaFormat format)
3897 +{
3898 + REPORT_FUNCTION()
3899 +
3900 + _MediaFormat *mf = get_internal_format(format);
3901 + if (mf == NULL)
3902 + return 0;
3903 +
3904 + return mf->height;
3905 +}
3906 +
3907 +int32_t media_format_get_max_input_size(MediaFormat format)
3908 +{
3909 + REPORT_FUNCTION()
3910 +
3911 + _MediaFormat *mf = get_internal_format(format);
3912 + if (mf == NULL)
3913 + return 0;
3914 +
3915 + return mf->max_input_size;
3916 +}
3917 +
3918 +int32_t media_format_get_stride(MediaFormat format)
3919 +{
3920 + REPORT_FUNCTION()
3921 +
3922 + _MediaFormat *mf = get_internal_format(format);
3923 + if (mf == NULL)
3924 + return 0;
3925 +
3926 + return mf->stride;
3927 +}
3928 +
3929 +int32_t media_format_get_slice_height(MediaFormat format)
3930 +{
3931 + REPORT_FUNCTION()
3932 +
3933 + _MediaFormat *mf = get_internal_format(format);
3934 + if (mf == NULL)
3935 + return 0;
3936 +
3937 + return mf->height;
3938 +}
3939 +
3940 +int32_t media_format_get_color_format(MediaFormat format)
3941 +{
3942 + REPORT_FUNCTION()
3943 +
3944 + _MediaFormat *mf = get_internal_format(format);
3945 + if (mf == NULL)
3946 + return 0;
3947 +
3948 + return mf->color_format;
3949 +}
3950 +
3951 +int32_t media_format_get_crop_left(MediaFormat format)
3952 +{
3953 + REPORT_FUNCTION()
3954 +
3955 + _MediaFormat *mf = get_internal_format(format);
3956 + if (mf == NULL)
3957 + return 0;
3958 +
3959 + return mf->crop_left;
3960 +}
3961 +
3962 +int32_t media_format_get_crop_right(MediaFormat format)
3963 +{
3964 + REPORT_FUNCTION()
3965 +
3966 + _MediaFormat *mf = get_internal_format(format);
3967 + if (mf == NULL)
3968 + return 0;
3969 +
3970 + return mf->crop_right;
3971 +}
3972 +
3973 +int32_t media_format_get_crop_top(MediaFormat format)
3974 +{
3975 + REPORT_FUNCTION()
3976 +
3977 + _MediaFormat *mf = get_internal_format(format);
3978 + if (mf == NULL)
3979 + return 0;
3980 +
3981 + return mf->crop_top;
3982 +}
3983 +
3984 +int32_t media_format_get_crop_bottom(MediaFormat format)
3985 +{
3986 + REPORT_FUNCTION()
3987 +
3988 + _MediaFormat *mf = get_internal_format(format);
3989 + if (mf == NULL)
3990 + return 0;
3991 +
3992 + return mf->crop_bottom;
3993 +}
3994 --- /dev/null
3995 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_format_layer_priv.cpp
3996 @@ -0,0 +1,50 @@
3997 +/*
3998 + * Copyright (C) 2013 Canonical Ltd
3999 + *
4000 + * Licensed under the Apache License, Version 2.0 (the "License");
4001 + * you may not use this file except in compliance with the License.
4002 + * You may obtain a copy of the License at
4003 + *
4004 + * http://www.apache.org/licenses/LICENSE-2.0
4005 + *
4006 + * Unless required by applicable law or agreed to in writing, software
4007 + * distributed under the License is distributed on an "AS IS" BASIS,
4008 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4009 + * See the License for the specific language governing permissions and
4010 + * limitations under the License.
4011 + *
4012 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
4013 + */
4014 +
4015 +#include <stddef.h>
4016 +#include <unistd.h>
4017 +
4018 +#include <media/stagefright/foundation/AString.h>
4019 +
4020 +#include <utils/RefBase.h>
4021 +
4022 +#ifdef __cplusplus
4023 +extern "C" {
4024 +#endif
4025 +
4026 +struct _MediaFormat : public RefBase
4027 +{
4028 + _MediaFormat()
4029 + : refcount(1)
4030 + {
4031 + }
4032 +
4033 + AString mime;
4034 + int64_t duration_us;
4035 + int32_t width;
4036 + int32_t height;
4037 + int32_t max_input_size;
4038 +
4039 + unsigned int refcount;
4040 +};
4041 +
4042 +#ifdef __cplusplus
4043 +}
4044 +#endif
4045 +
4046 +#endif
4047 --- /dev/null
4048 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/media_format_layer_priv.h
4049 @@ -0,0 +1,68 @@
4050 +/*
4051 + * Copyright (C) 2013 Canonical Ltd
4052 + *
4053 + * Licensed under the Apache License, Version 2.0 (the "License");
4054 + * you may not use this file except in compliance with the License.
4055 + * You may obtain a copy of the License at
4056 + *
4057 + * http://www.apache.org/licenses/LICENSE-2.0
4058 + *
4059 + * Unless required by applicable law or agreed to in writing, software
4060 + * distributed under the License is distributed on an "AS IS" BASIS,
4061 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4062 + * See the License for the specific language governing permissions and
4063 + * limitations under the License.
4064 + *
4065 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
4066 + */
4067 +
4068 +#ifndef MEDIA_FORMAT_LAYER_PRIV_H_
4069 +#define MEDIA_FORMAT_LAYER_PRIV_H_
4070 +
4071 +#include <stddef.h>
4072 +#include <unistd.h>
4073 +
4074 +#include <media/stagefright/foundation/AString.h>
4075 +#include <media/stagefright/foundation/ABuffer.h>
4076 +
4077 +#include <utils/RefBase.h>
4078 +
4079 +struct _MediaFormat : public android::RefBase
4080 +{
4081 + _MediaFormat()
4082 + : duration_us(0),
4083 + width(0),
4084 + height(0),
4085 + max_input_size(0),
4086 + csd(NULL),
4087 + stride(0),
4088 + slice_height(0),
4089 + color_format(0),
4090 + crop_left(0),
4091 + crop_right(0),
4092 + crop_top(0),
4093 + crop_bottom(0),
4094 + refcount(1)
4095 + {
4096 + }
4097 +
4098 + android::AString mime;
4099 + int64_t duration_us;
4100 + int32_t width;
4101 + int32_t height;
4102 + int32_t max_input_size;
4103 + android::AString csd_key_name;
4104 + android::sp<android::ABuffer> csd;
4105 +
4106 + int32_t stride;
4107 + int32_t slice_height;
4108 + int32_t color_format;
4109 + int32_t crop_left;
4110 + int32_t crop_right;
4111 + int32_t crop_top;
4112 + int32_t crop_bottom;
4113 +
4114 + unsigned int refcount;
4115 +};
4116 +
4117 +#endif // MEDIA_FORMAT_LAYER_PRIV_H_
4118 --- /dev/null
4119 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/recorder_compatibility_layer.cpp
4120 @@ -0,0 +1,457 @@
4121 +/*
4122 + * Copyright (C) 2013 Canonical Ltd
4123 + *
4124 + * Licensed under the Apache License, Version 2.0 (the "License");
4125 + * you may not use this file except in compliance with the License.
4126 + * You may obtain a copy of the License at
4127 + *
4128 + * http://www.apache.org/licenses/LICENSE-2.0
4129 + *
4130 + * Unless required by applicable law or agreed to in writing, software
4131 + * distributed under the License is distributed on an "AS IS" BASIS,
4132 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4133 + * See the License for the specific language governing permissions and
4134 + * limitations under the License.
4135 + *
4136 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
4137 + * Guenter Schwann <guenter.schwann@canonical.com>
4138 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
4139 + */
4140 +
4141 +#include <hybris/internal/camera_control.h>
4142 +#include <hybris/media/recorder_compatibility_layer.h>
4143 +
4144 +#include <camera/Camera.h>
4145 +#include <camera/ICamera.h>
4146 +#include <media/mediarecorder.h>
4147 +
4148 +//#define LOG_NDEBUG 0
4149 +#undef LOG_TAG
4150 +#define LOG_TAG "MediaRecorderCompatibilityLayer"
4151 +#include <utils/KeyedVector.h>
4152 +#include <utils/Log.h>
4153 +
4154 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__)
4155 +
4156 +/*!
4157 + * \brief The MediaRecorderListenerWrapper class is used to listen to events
4158 + * from the MediaRecorder
4159 + */
4160 +class MediaRecorderListenerWrapper : public android::MediaRecorderListener
4161 +{
4162 + public:
4163 + MediaRecorderListenerWrapper()
4164 + : error_cb(NULL),
4165 + error_context(NULL)
4166 + {
4167 + }
4168 +
4169 + void notify(int msg, int ext1, int ext2)
4170 + {
4171 + ALOGV("\tmsg: %d, ext1: %d, ext2: %d \n", msg, ext1, ext2);
4172 +
4173 + switch (msg) {
4174 + case android::MEDIA_RECORDER_EVENT_ERROR:
4175 + ALOGV("\tMEDIA_RECORDER_EVENT_ERROR msg\n");
4176 + // TODO: Extend this cb to include the error message
4177 + if (error_cb != NULL)
4178 + error_cb(error_context);
4179 + else
4180 + ALOGE("Failed to signal error to app layer, callback not set.");
4181 + break;
4182 + default:
4183 + ALOGV("\tUnknown notification\n");
4184 + }
4185 + }
4186 +
4187 + void setErrorCb(on_recorder_msg_error cb, void *context)
4188 + {
4189 + REPORT_FUNCTION();
4190 + error_cb = cb;
4191 + error_context = context;
4192 + }
4193 +
4194 + private:
4195 + on_recorder_msg_error error_cb;
4196 + void *error_context;
4197 +};
4198 +
4199 +/*!
4200 + * \brief The MediaRecorderWrapper struct wraps the MediaRecorder class
4201 + */
4202 +struct MediaRecorderWrapper : public android::MediaRecorder
4203 +{
4204 + public:
4205 + MediaRecorderWrapper()
4206 + : MediaRecorder(),
4207 + media_recorder_listener(new MediaRecorderListenerWrapper())
4208 + {
4209 + setListener(media_recorder_listener);
4210 + }
4211 +
4212 + ~MediaRecorderWrapper()
4213 + {
4214 + reset();
4215 + }
4216 +
4217 + void setErrorCb(on_recorder_msg_error cb, void *context)
4218 + {
4219 + REPORT_FUNCTION();
4220 +
4221 + assert(media_recorder_listener != NULL);
4222 + media_recorder_listener->setErrorCb(cb, context);
4223 + }
4224 +
4225 + private:
4226 + android::sp<MediaRecorderListenerWrapper> media_recorder_listener;
4227 +};
4228 +
4229 +
4230 +using namespace android;
4231 +
4232 +/*!
4233 + * \brief android_recorder_set_error_cb
4234 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4235 + * \param cb The callback function to be called when a recording error occurs
4236 + * \param context
4237 + */
4238 +void android_recorder_set_error_cb(MediaRecorderWrapper *mr, on_recorder_msg_error cb,
4239 + void *context)
4240 +{
4241 + REPORT_FUNCTION();
4242 +
4243 + if (mr == NULL) {
4244 + ALOGE("mr must not be NULL");
4245 + return;
4246 + }
4247 +
4248 + mr->setErrorCb(cb, context);
4249 +}
4250 +
4251 +/*!
4252 + * \brief android_media_new_recorder creates a new MediaRecorder
4253 + * \return New MediaRecorder object, or NULL if the object could not be created.
4254 + */
4255 +MediaRecorderWrapper *android_media_new_recorder()
4256 +{
4257 + REPORT_FUNCTION();
4258 +
4259 + MediaRecorderWrapper *mr = new MediaRecorderWrapper;
4260 + if (mr == NULL) {
4261 + ALOGE("Failed to create new MediaRecorderWrapper instance.");
4262 + return NULL;
4263 + }
4264 +
4265 + return mr;
4266 +}
4267 +
4268 +/*!
4269 + * \brief android_recorder_initCheck
4270 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4271 + * \return negative value if an error occured
4272 + */
4273 +int android_recorder_initCheck(MediaRecorderWrapper *mr)
4274 +{
4275 + REPORT_FUNCTION();
4276 +
4277 + if (mr == NULL) {
4278 + ALOGE("mr must not be NULL");
4279 + return BAD_VALUE;
4280 + }
4281 +
4282 + return mr->initCheck();
4283 +}
4284 +
4285 +/*!
4286 + * \brief android_recorder_setCamera sets the camera object for recording videos
4287 + * from the camera
4288 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4289 + * \param control Wrapper for the camera (see camera in hybris)
4290 + * \return negative value if an error occured
4291 + */
4292 +int android_recorder_setCamera(MediaRecorderWrapper *mr, CameraControl* control)
4293 +{
4294 + REPORT_FUNCTION();
4295 +
4296 + if (mr == NULL) {
4297 + ALOGE("mr must not be NULL");
4298 + return BAD_VALUE;
4299 + }
4300 + if (control == NULL) {
4301 + ALOGE("control must not be NULL");
4302 + return BAD_VALUE;
4303 + }
4304 +
4305 + return mr->setCamera(control->camera->remote(), control->camera->getRecordingProxy());
4306 +}
4307 +
4308 +/*!
4309 + * \brief android_recorder_setVideoSource sets the video source.
4310 + * If no video source is set, only audio is recorded.
4311 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4312 + * \param vs The video source. It's either the camera of gralloc buffer
4313 + * \return negative value if an error occured
4314 + */
4315 +int android_recorder_setVideoSource(MediaRecorderWrapper *mr, VideoSource vs)
4316 +{
4317 + REPORT_FUNCTION();
4318 +
4319 + if (mr == NULL) {
4320 + ALOGE("mr must not be NULL");
4321 + return BAD_VALUE;
4322 + }
4323 +
4324 + return mr->setVideoSource(static_cast<int>(vs));
4325 +}
4326 +
4327 +/*!
4328 + * \brief android_recorder_setAudioSource
4329 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4330 + * \param as The audio source.
4331 + * \return negative value if an error occured
4332 + */
4333 +int android_recorder_setAudioSource(MediaRecorderWrapper *mr, AudioSource as)
4334 +{
4335 + REPORT_FUNCTION();
4336 +
4337 + if (mr == NULL) {
4338 + ALOGE("mr must not be NULL");
4339 + return BAD_VALUE;
4340 + }
4341 +
4342 + return mr->setAudioSource(static_cast<int>(as));
4343 +}
4344 +
4345 +/*!
4346 + * \brief android_recorder_setOutputFormat
4347 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4348 + * \param of The output file format
4349 + * \return negative value if an error occured
4350 + */
4351 +int android_recorder_setOutputFormat(MediaRecorderWrapper *mr, OutputFormat of)
4352 +{
4353 + REPORT_FUNCTION();
4354 +
4355 + if (mr == NULL) {
4356 + ALOGE("mr must not be NULL");
4357 + return BAD_VALUE;
4358 + }
4359 +
4360 + return mr->setOutputFormat(static_cast<int>(of));
4361 +}
4362 +
4363 +/*!
4364 + * \brief android_recorder_setVideoEncoder
4365 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4366 + * \param ve The video encoder sets the codec for the video
4367 + * \return negative value if an error occured
4368 + */
4369 +int android_recorder_setVideoEncoder(MediaRecorderWrapper *mr, VideoEncoder ve)
4370 +{
4371 + REPORT_FUNCTION();
4372 +
4373 + if (mr == NULL) {
4374 + ALOGE("mr must not be NULL");
4375 + return BAD_VALUE;
4376 + }
4377 +
4378 + return mr->setVideoEncoder(static_cast<int>(ve));
4379 +}
4380 +
4381 +/*!
4382 + * \brief android_recorder_setAudioEncoder
4383 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4384 + * \param ae The audio encoder sets the codec for the audio
4385 + * \return negative value if an error occured
4386 + */
4387 +int android_recorder_setAudioEncoder(MediaRecorderWrapper *mr, AudioEncoder ae)
4388 +{
4389 + REPORT_FUNCTION();
4390 +
4391 + if (mr == NULL) {
4392 + ALOGE("mr must not be NULL");
4393 + return BAD_VALUE;
4394 + }
4395 +
4396 + return mr->setAudioEncoder(static_cast<int>(ae));
4397 +}
4398 +
4399 +/*!
4400 + * \brief android_recorder_setOutputFile sets the output file to the given file descriptor
4401 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4402 + * \param fd File descriptor of an open file, that the stream can be written to
4403 + * \return negative value if an error occured
4404 + */
4405 +int android_recorder_setOutputFile(MediaRecorderWrapper *mr, int fd)
4406 +{
4407 + REPORT_FUNCTION();
4408 +
4409 + if (mr == NULL) {
4410 + ALOGE("mr must not be NULL");
4411 + return BAD_VALUE;
4412 + }
4413 +
4414 + return mr->setOutputFile(fd, 0, 0);
4415 +}
4416 +
4417 +/*!
4418 + * \brief android_recorder_setVideoSize
4419 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4420 + * \param width width for the video to record
4421 + * \param height height for the video to record
4422 + * \return negative value if an error occured
4423 + */
4424 +int android_recorder_setVideoSize(MediaRecorderWrapper *mr, int width, int height)
4425 +{
4426 + REPORT_FUNCTION();
4427 +
4428 + if (mr == NULL) {
4429 + ALOGE("mr must not be NULL");
4430 + return BAD_VALUE;
4431 + }
4432 +
4433 + return mr->setVideoSize(width, height);
4434 +}
4435 +
4436 +/*!
4437 + * \brief android_recorder_setVideoFrameRate
4438 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4439 + * \param frames_per_second Frames per second has typical values for a movie clip in 720p is 30
4440 + * \return negative value if an error occured
4441 + */
4442 +int android_recorder_setVideoFrameRate(MediaRecorderWrapper *mr, int frames_per_second)
4443 +{
4444 + REPORT_FUNCTION();
4445 +
4446 + if (mr == NULL) {
4447 + ALOGE("mr must not be NULL");
4448 + return BAD_VALUE;
4449 + }
4450 +
4451 + return mr->setVideoFrameRate(frames_per_second);
4452 +}
4453 +
4454 +/*!
4455 + * \brief android_recorder_setParameters sets a parameter. Even those without
4456 + * explicit function.
4457 + * For possible parameters look for example in StagefrightRecorder::setParameter()
4458 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4459 + * \param parameters list of parameters. format is "parameter1=value;parameter2=value"
4460 + * \return negative value if an error occured
4461 + */
4462 +int android_recorder_setParameters(MediaRecorderWrapper *mr, const char* parameters)
4463 +{
4464 + REPORT_FUNCTION();
4465 +
4466 + if (mr == NULL) {
4467 + ALOGE("mr must not be NULL");
4468 + return BAD_VALUE;
4469 + }
4470 +
4471 + String8 params(parameters);
4472 + return mr->setParameters(params);
4473 +}
4474 +
4475 +/*!
4476 + * \brief android_recorder_start starts the recording.
4477 + * The MediaRecorder has to be in state "prepared"
4478 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4479 + * \return negative value if an error occured
4480 + */
4481 +int android_recorder_start(MediaRecorderWrapper *mr)
4482 +{
4483 + REPORT_FUNCTION();
4484 +
4485 + if (mr == NULL) {
4486 + ALOGE("mr must not be NULL");
4487 + return BAD_VALUE;
4488 + }
4489 +
4490 + return mr->start();
4491 +}
4492 +
4493 +/*!
4494 + * \brief android_recorder_stop Stops a running recording.
4495 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4496 + * \return negative value if an error occured
4497 + */
4498 +int android_recorder_stop(MediaRecorderWrapper *mr)
4499 +{
4500 + REPORT_FUNCTION();
4501 +
4502 + if (mr == NULL) {
4503 + ALOGE("mr must not be NULL");
4504 + return BAD_VALUE;
4505 + }
4506 +
4507 + return mr->stop();
4508 +}
4509 +
4510 +/*!
4511 + * \brief android_recorder_prepare put the MediaRecorder into state "prepare"
4512 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4513 + * \return negative value if an error occured
4514 + */
4515 +int android_recorder_prepare(MediaRecorderWrapper *mr)
4516 +{
4517 + REPORT_FUNCTION();
4518 +
4519 + if (mr == NULL) {
4520 + ALOGE("mr must not be NULL");
4521 + return BAD_VALUE;
4522 + }
4523 +
4524 + return mr->prepare();
4525 +}
4526 +
4527 +/*!
4528 + * \brief android_recorder_reset resets the MediaRecorder
4529 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4530 + * \return negative value if an error occured
4531 + */
4532 +int android_recorder_reset(MediaRecorderWrapper *mr)
4533 +{
4534 + REPORT_FUNCTION();
4535 +
4536 + if (mr == NULL) {
4537 + ALOGE("mr must not be NULL");
4538 + return BAD_VALUE;
4539 + }
4540 +
4541 + return mr->reset();
4542 +}
4543 +
4544 +/*!
4545 + * \brief android_recorder_close closes the MediaRecorder
4546 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4547 + * \return negative value if an error occured
4548 + */
4549 +int android_recorder_close(MediaRecorderWrapper *mr)
4550 +{
4551 + REPORT_FUNCTION();
4552 +
4553 + if (mr == NULL) {
4554 + ALOGE("mr must not be NULL");
4555 + return BAD_VALUE;
4556 + }
4557 +
4558 + return mr->close();
4559 +}
4560 +
4561 +/*!
4562 + * \brief android_recorder_release releases the MediaRecorder resources
4563 + * This deletes the object. So don't use it after calling this function.
4564 + * \param mr A MediaRecorderWrapper instance, created by calling android_media_new_recorder()
4565 + * \return negative value if an error occured
4566 + */
4567 +int android_recorder_release(MediaRecorderWrapper *mr)
4568 +{
4569 + REPORT_FUNCTION();
4570 +
4571 + if (mr == NULL) {
4572 + ALOGE("mr must not be NULL");
4573 + return BAD_VALUE;
4574 + }
4575 +
4576 + return mr->release();
4577 +}
4578 --- /dev/null
4579 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/surface_texture_client_hybris.cpp
4580 @@ -0,0 +1,333 @@
4581 +/*
4582 + * Copyright (C) 2013 Canonical Ltd
4583 + *
4584 + * Licensed under the Apache License, Version 2.0 (the "License");
4585 + * you may not use this file except in compliance with the License.
4586 + * You may obtain a copy of the License at
4587 + *
4588 + * http://www.apache.org/licenses/LICENSE-2.0
4589 + *
4590 + * Unless required by applicable law or agreed to in writing, software
4591 + * distributed under the License is distributed on an "AS IS" BASIS,
4592 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4593 + * See the License for the specific language governing permissions and
4594 + * limitations under the License.
4595 + *
4596 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
4597 + */
4598 +
4599 +// Uncomment to enable verbose debug output
4600 +#define LOG_NDEBUG 0
4601 +
4602 +#undef LOG_TAG
4603 +#define LOG_TAG "SurfaceTextureClientHybris"
4604 +
4605 +#include <hybris/media/surface_texture_client_hybris.h>
4606 +#include "surface_texture_client_hybris_priv.h"
4607 +
4608 +#include <ui/GraphicBuffer.h>
4609 +#include <utils/Log.h>
4610 +#include <ui/Region.h>
4611 +#include <gui/Surface.h>
4612 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4613 +#include <gui/SurfaceTextureClient.h>
4614 +#endif
4615 +
4616 +#include <GLES2/gl2.h>
4617 +#include <GLES2/gl2ext.h>
4618 +
4619 +#define REPORT_FUNCTION() ALOGV("%s \n", __PRETTY_FUNCTION__);
4620 +
4621 +using namespace android;
4622 +
4623 +// ----- Begin _SurfaceTextureClientHybris API ----- //
4624 +
4625 +static inline _SurfaceTextureClientHybris *get_internal_stch(SurfaceTextureClientHybris stc, const char * func)
4626 +{
4627 + if (stc == NULL)
4628 + {
4629 + ALOGE("stc must not be NULL (%s)", func);
4630 + return NULL;
4631 + }
4632 +
4633 + _SurfaceTextureClientHybris *s = static_cast<_SurfaceTextureClientHybris*>(stc);
4634 + assert(s->refcount >= 1);
4635 +
4636 + return s;
4637 +}
4638 +
4639 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4640 +_SurfaceTextureClientHybris::_SurfaceTextureClientHybris()
4641 + : refcount(1),
4642 + ready(false)
4643 +{
4644 + REPORT_FUNCTION()
4645 +}
4646 +#endif
4647 +
4648 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR>=4
4649 +_SurfaceTextureClientHybris::_SurfaceTextureClientHybris(const sp<BufferQueue> &bq)
4650 + : Surface::Surface(bq, true),
4651 + refcount(1),
4652 + ready(false)
4653 +{
4654 + REPORT_FUNCTION()
4655 +}
4656 +#endif
4657 +
4658 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4659 +_SurfaceTextureClientHybris::_SurfaceTextureClientHybris(const _SurfaceTextureClientHybris &stch)
4660 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4661 + : SurfaceTextureClient::SurfaceTextureClient(),
4662 +#else
4663 + : Surface::Surface(new BufferQueue(), true),
4664 +#endif
4665 + refcount(stch.refcount),
4666 + ready(false)
4667 +{
4668 + REPORT_FUNCTION()
4669 +}
4670 +
4671 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4672 +_SurfaceTextureClientHybris::_SurfaceTextureClientHybris(const sp<ISurfaceTexture> &st)
4673 + : SurfaceTextureClient::SurfaceTextureClient(st),
4674 +#else
4675 +_SurfaceTextureClientHybris::_SurfaceTextureClientHybris(const sp<IGraphicBufferProducer> &st)
4676 + : Surface::Surface(st, true),
4677 +#endif
4678 + refcount(1),
4679 + ready(false)
4680 +{
4681 + REPORT_FUNCTION()
4682 +}
4683 +#endif
4684 +
4685 +_SurfaceTextureClientHybris::~_SurfaceTextureClientHybris()
4686 +{
4687 + REPORT_FUNCTION()
4688 +
4689 + ready = false;
4690 +}
4691 +
4692 +bool _SurfaceTextureClientHybris::isReady() const
4693 +{
4694 + return ready;
4695 +}
4696 +
4697 +int _SurfaceTextureClientHybris::dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd)
4698 +{
4699 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4700 + return SurfaceTextureClient::dequeueBuffer(buffer, fenceFd);
4701 +#else
4702 + return Surface::dequeueBuffer(buffer, fenceFd);
4703 +#endif
4704 +}
4705 +
4706 +int _SurfaceTextureClientHybris::queueBuffer(ANativeWindowBuffer* buffer, int fenceFd)
4707 +{
4708 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4709 + return SurfaceTextureClient::queueBuffer(buffer, fenceFd);
4710 +#else
4711 + return Surface::queueBuffer(buffer, fenceFd);
4712 +#endif
4713 +}
4714 +
4715 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4716 +void _SurfaceTextureClientHybris::setISurfaceTexture(const sp<ISurfaceTexture>& surface_texture)
4717 +{
4718 + SurfaceTextureClient::setISurfaceTexture(surface_texture);
4719 +#else
4720 +void _SurfaceTextureClientHybris::setISurfaceTexture(const sp<IGraphicBufferProducer>& surface_texture)
4721 +{
4722 + // We don't need to set up the IGraphicBufferProducer as stc needs it when created
4723 +#endif
4724 +
4725 + // Ready for rendering
4726 + ready = true;
4727 +}
4728 +
4729 +void _SurfaceTextureClientHybris::setHardwareRendering(bool do_hardware_rendering)
4730 +{
4731 + hardware_rendering = do_hardware_rendering;
4732 +}
4733 +
4734 +bool _SurfaceTextureClientHybris::hardwareRendering()
4735 +{
4736 + return hardware_rendering;
4737 +}
4738 +
4739 +// ----- End _SurfaceTextureClientHybris API ----- //
4740 +
4741 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4742 +static inline void set_surface(_SurfaceTextureClientHybris *stch, const sp<SurfaceTexture> &surface_texture)
4743 +#else
4744 +static inline void set_surface(_SurfaceTextureClientHybris *stch, const sp<GLConsumer> &surface_texture)
4745 +#endif
4746 +{
4747 + REPORT_FUNCTION()
4748 +
4749 + if (stch == NULL)
4750 + return;
4751 +
4752 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4753 + stch->setISurfaceTexture(surface_texture->getBufferQueue());
4754 +#else
4755 + stch->setISurfaceTexture(stch->getIGraphicBufferProducer());
4756 +#endif
4757 +}
4758 +
4759 +SurfaceTextureClientHybris surface_texture_client_create_by_id(unsigned int texture_id)
4760 +{
4761 + REPORT_FUNCTION()
4762 +
4763 + if (texture_id == 0)
4764 + {
4765 + ALOGE("Cannot create new SurfaceTextureClientHybris, texture id must be > 0.");
4766 + return NULL;
4767 + }
4768 +
4769 + // Use a new native buffer allocator vs the default one, which means it'll use the proper one
4770 + // that will allow rendering to work with Mir
4771 + sp<NativeBufferAlloc> native_alloc(new NativeBufferAlloc());
4772 +
4773 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
4774 + sp<BufferQueue> buffer_queue(new BufferQueue(false, NULL, native_alloc));
4775 + _SurfaceTextureClientHybris *stch(new _SurfaceTextureClientHybris);
4776 +#else
4777 + sp<BufferQueue> buffer_queue(new BufferQueue(NULL, native_alloc));
4778 + _SurfaceTextureClientHybris *stch(new _SurfaceTextureClientHybris(buffer_queue));
4779 +#endif
4780 +
4781 + ALOGD("stch: %p (%s)", stch, __PRETTY_FUNCTION__);
4782 +
4783 + if (stch->surface_texture != NULL)
4784 + stch->surface_texture.clear();
4785 +
4786 + const bool allow_synchronous_mode = true;
4787 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4788 + stch->surface_texture = new SurfaceTexture(texture_id, allow_synchronous_mode, GL_TEXTURE_EXTERNAL_OES, true, buffer_queue);
4789 + set_surface(stch, stch->surface_texture);
4790 +#else
4791 + stch->surface_texture = new GLConsumer(buffer_queue, texture_id, GL_TEXTURE_EXTERNAL_OES, true, true);
4792 +#endif
4793 + set_surface(stch, stch->surface_texture);
4794 +
4795 + return stch;
4796 +}
4797 +
4798 +uint8_t surface_texture_client_is_ready_for_rendering(SurfaceTextureClientHybris stc)
4799 +{
4800 + REPORT_FUNCTION()
4801 +
4802 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4803 + if (s == NULL)
4804 + return false;
4805 +
4806 + return static_cast<uint8_t>(s->isReady());
4807 +}
4808 +
4809 +uint8_t surface_texture_client_hardware_rendering(SurfaceTextureClientHybris stc)
4810 +{
4811 + REPORT_FUNCTION()
4812 +
4813 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4814 + if (s == NULL)
4815 + return false;
4816 +
4817 + return s->hardwareRendering();
4818 +}
4819 +
4820 +void surface_texture_client_set_hardware_rendering(SurfaceTextureClientHybris stc, uint8_t hardware_rendering)
4821 +{
4822 + REPORT_FUNCTION()
4823 +
4824 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4825 + if (s == NULL)
4826 + return;
4827 +
4828 + s->setHardwareRendering(static_cast<bool>(hardware_rendering));
4829 +}
4830 +
4831 +void surface_texture_client_get_transformation_matrix(SurfaceTextureClientHybris stc, float *matrix)
4832 +{
4833 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4834 + if (s == NULL)
4835 + return;
4836 +
4837 + s->surface_texture->getTransformMatrix(static_cast<GLfloat*>(matrix));
4838 +}
4839 +
4840 +void surface_texture_client_update_texture(SurfaceTextureClientHybris stc)
4841 +{
4842 + REPORT_FUNCTION()
4843 +
4844 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4845 + if (s == NULL)
4846 + return;
4847 +
4848 + s->surface_texture->updateTexImage();
4849 +}
4850 +
4851 +void surface_texture_client_destroy(SurfaceTextureClientHybris stc)
4852 +{
4853 + REPORT_FUNCTION()
4854 +
4855 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4856 + if (s == NULL)
4857 + {
4858 + ALOGE("s == NULL, cannot destroy SurfaceTextureClientHybris instance");
4859 + return;
4860 + }
4861 +
4862 + s->refcount = 0;
4863 +
4864 + delete s;
4865 +}
4866 +
4867 +void surface_texture_client_ref(SurfaceTextureClientHybris stc)
4868 +{
4869 + REPORT_FUNCTION()
4870 +
4871 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4872 + if (s == NULL)
4873 + return;
4874 +
4875 + s->refcount++;
4876 +}
4877 +
4878 +void surface_texture_client_unref(SurfaceTextureClientHybris stc)
4879 +{
4880 + REPORT_FUNCTION()
4881 +
4882 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4883 + if (s == NULL)
4884 + {
4885 + ALOGE("s == NULL, cannot unref SurfaceTextureClientHybris instance");
4886 + return;
4887 + }
4888 +
4889 + if (s->refcount > 1)
4890 + s->refcount--;
4891 + else
4892 + surface_texture_client_destroy (stc);
4893 +}
4894 +
4895 +void surface_texture_client_set_surface_texture(SurfaceTextureClientHybris stc, EGLNativeWindowType native_window)
4896 +{
4897 + _SurfaceTextureClientHybris *s = get_internal_stch(stc, __PRETTY_FUNCTION__);
4898 + if (s == NULL)
4899 + return;
4900 +
4901 + if (native_window == NULL)
4902 + {
4903 + ALOGE("native_window must not be NULL");
4904 + return;
4905 + }
4906 +
4907 + sp<Surface> surface = static_cast<Surface*>(native_window);
4908 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4909 + s->setISurfaceTexture(surface->getSurfaceTexture());
4910 +#else
4911 + s->setISurfaceTexture(surface->getIGraphicBufferProducer());
4912 +#endif
4913 +}
4914 --- /dev/null
4915 +++ libhybris-0.1.0+git20131207+e452e83/compat/media/surface_texture_client_hybris_priv.h
4916 @@ -0,0 +1,68 @@
4917 +/*
4918 + * Copyright (C) 2013 Canonical Ltd
4919 + *
4920 + * Licensed under the Apache License, Version 2.0 (the "License");
4921 + * you may not use this file except in compliance with the License.
4922 + * You may obtain a copy of the License at
4923 + *
4924 + * http://www.apache.org/licenses/LICENSE-2.0
4925 + *
4926 + * Unless required by applicable law or agreed to in writing, software
4927 + * distributed under the License is distributed on an "AS IS" BASIS,
4928 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
4929 + * See the License for the specific language governing permissions and
4930 + * limitations under the License.
4931 + *
4932 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
4933 + */
4934 +
4935 +#include <gui/Surface.h>
4936 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4937 +#include <gui/SurfaceTextureClient.h>
4938 +#else
4939 +#include <gui/GLConsumer.h>
4940 +#endif
4941 +
4942 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4943 +struct _SurfaceTextureClientHybris : public android::SurfaceTextureClient
4944 +#else
4945 +struct _SurfaceTextureClientHybris : public android::Surface
4946 +#endif
4947 +{
4948 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4949 + _SurfaceTextureClientHybris();
4950 +#endif
4951 + _SurfaceTextureClientHybris(const _SurfaceTextureClientHybris &stch);
4952 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4953 + _SurfaceTextureClientHybris(const android::sp<android::ISurfaceTexture> &st);
4954 +#else
4955 + _SurfaceTextureClientHybris(const android::sp<android::BufferQueue> &bq);
4956 +#endif
4957 + ~_SurfaceTextureClientHybris();
4958 +
4959 + /** Has a texture id or EGLNativeWindowType been passed in, meaning rendering will function? **/
4960 + bool isReady() const;
4961 +
4962 +public:
4963 + int dequeueBuffer(ANativeWindowBuffer** buffer, int* fenceFd);
4964 + int queueBuffer(ANativeWindowBuffer* buffer, int fenceFd);
4965 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4966 + void setISurfaceTexture(const android::sp<android::ISurfaceTexture>& surface_texture);
4967 +#else
4968 + void setISurfaceTexture(const android::sp<android::IGraphicBufferProducer>& surface_texture);
4969 +#endif
4970 + void setHardwareRendering(bool do_hardware_rendering);
4971 + bool hardwareRendering();
4972 +
4973 + unsigned int refcount;
4974 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
4975 + android::sp<android::SurfaceTexture> surface_texture;
4976 +#else
4977 + android::sp<android::GLConsumer> surface_texture;
4978 +#endif
4979 +
4980 +private:
4981 + bool ready;
4982 + bool hardware_rendering;
4983 +};
4984 +
4985 --- libhybris-0.1.0+git20131207+e452e83.orig/compat/ui/Android.mk
4986 +++ libhybris-0.1.0+git20131207+e452e83/compat/ui/Android.mk
4987 @@ -1,5 +1,6 @@
4988 LOCAL_PATH:= $(call my-dir)
4989 include $(CLEAR_VARS)
4990 +include $(LOCAL_PATH)/../Android.common.mk
4991
4992 HYBRIS_PATH := $(LOCAL_PATH)/../../hybris
4993
4994 --- libhybris-0.1.0+git20131207+e452e83.orig/compat/ui/ui_compatibility_layer.cpp
4995 +++ libhybris-0.1.0+git20131207+e452e83/compat/ui/ui_compatibility_layer.cpp
4996 @@ -126,6 +126,7 @@ void* graphic_buffer_get_native_buffer(s
4997 return buffer->self->getNativeBuffer();
4998 }
4999
5000 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
5001 void graphic_buffer_set_index(struct graphic_buffer *buffer, int index)
5002 {
5003 return buffer->self->setIndex(index);
5004 @@ -135,6 +136,7 @@ int graphic_buffer_get_index(struct grap
5005 {
5006 return buffer->self->getIndex();
5007 }
5008 +#endif
5009
5010 int graphic_buffer_init_check(struct graphic_buffer *buffer)
5011 {
5012 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/Makefile.am
5013 +++ libhybris-0.1.0+git20131207+e452e83/hybris/Makefile.am
5014 @@ -4,7 +4,7 @@ if HAS_ANDROID_4_2_0
5015 SUBDIRS += libsync
5016 endif
5017
5018 -SUBDIRS += egl glesv1 glesv2 ui sf input camera
5019 +SUBDIRS += egl glesv1 glesv2 ui sf input camera media
5020 if HAS_LIBNFC_NXP_HEADERS
5021 SUBDIRS += libnfc_nxp libnfc_ndef_nxp
5022 endif
5023 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/hooks.c
5024 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/hooks.c
5025 @@ -27,6 +27,7 @@
5026 #include <stdio_ext.h>
5027 #include <stddef.h>
5028 #include <stdlib.h>
5029 +#include <limits.h>
5030 #include <malloc.h>
5031 #include <string.h>
5032 #include <strings.h>
5033 @@ -42,6 +43,10 @@
5034 #include <sys/ipc.h>
5035 #include <sys/shm.h>
5036
5037 +#include <linux/futex.h>
5038 +#include <sys/syscall.h>
5039 +#include <sys/time.h>
5040 +
5041 #include <netdb.h>
5042 #include <unistd.h>
5043 #include <syslog.h>
5044 @@ -64,8 +69,12 @@ static int locale_inited = 0;
5045
5046 #define ANDROID_MUTEX_SHARED_MASK 0x2000
5047 #define ANDROID_COND_SHARED_MASK 0x0001
5048 +#define ANDROID_COND_COUNTER_INCREMENT 0x0002
5049 +#define ANDROID_COND_COUNTER_MASK (~ANDROID_COND_SHARED_MASK)
5050 #define ANDROID_RWLOCKATTR_SHARED_MASK 0x0010
5051
5052 +#define ANDROID_COND_IS_SHARED(c) (((c)->value & ANDROID_COND_SHARED_MASK) != 0)
5053 +
5054 /* For the static initializer types */
5055 #define ANDROID_PTHREAD_MUTEX_INITIALIZER 0
5056 #define ANDROID_PTHREAD_RECURSIVE_MUTEX_INITIALIZER 0x4000
5057 @@ -87,6 +96,11 @@ struct _hook {
5058 void *func;
5059 };
5060
5061 +/* pthread cond struct as done in Android */
5062 +typedef struct {
5063 + int volatile value;
5064 +} android_cond_t;
5065 +
5066 /* Helpers */
5067 static int hybris_check_android_shared_mutex(unsigned int mutex_addr)
5068 {
5069 @@ -109,9 +123,59 @@ static int hybris_check_android_shared_c
5070 (cond_addr & ANDROID_COND_SHARED_MASK))
5071 return 1;
5072
5073 + /* In case android is setting up cond_addr with a negative value,
5074 + * used for error control */
5075 + if (cond_addr > HYBRIS_SHM_MASK_TOP)
5076 + return 1;
5077 +
5078 + return 0;
5079 +}
5080 +
5081 +/* Based on Android's Bionic pthread implementation.
5082 + * This is just needed when we have a shared cond with Android */
5083 +static int __android_pthread_cond_pulse(android_cond_t *cond, int counter)
5084 +{
5085 + long flags;
5086 + int fret;
5087 +
5088 + if (cond == NULL)
5089 + return EINVAL;
5090 +
5091 + flags = (cond->value & ~ANDROID_COND_COUNTER_MASK);
5092 + for (;;) {
5093 + long oldval = cond->value;
5094 + long newval = 0;
5095 + /* In our case all we need to do is make sure the negative value
5096 + * is under our range, which is the last 0xF from SHM_MASK */
5097 + if (oldval < -12)
5098 + newval = ((oldval + ANDROID_COND_COUNTER_INCREMENT) &
5099 + ANDROID_COND_COUNTER_MASK) | flags;
5100 + else
5101 + newval = ((oldval - ANDROID_COND_COUNTER_INCREMENT) &
5102 + ANDROID_COND_COUNTER_MASK) | flags;
5103 + if (__sync_bool_compare_and_swap(&cond->value, oldval, newval))
5104 + break;
5105 + }
5106 +
5107 + int pshared = cond->value & ANDROID_COND_SHARED_MASK;
5108 + fret = syscall(SYS_futex , &cond->value,
5109 + pshared ? FUTEX_WAKE : FUTEX_WAKE_PRIVATE, counter,
5110 + NULL, NULL, NULL);
5111 + LOGD("futex based pthread_cond_*, value %d, counter %d, ret %d",
5112 + cond->value, counter, fret);
5113 return 0;
5114 }
5115
5116 +int android_pthread_cond_broadcast(android_cond_t *cond)
5117 +{
5118 + return __android_pthread_cond_pulse(cond, INT_MAX);
5119 +}
5120 +
5121 +int android_pthread_cond_signal(android_cond_t *cond)
5122 +{
5123 + return __android_pthread_cond_pulse(cond, 1);
5124 +}
5125 +
5126 static void hybris_set_mutex_attr(unsigned int android_value, pthread_mutexattr_t *attr)
5127 {
5128 /* Init already sets as PTHREAD_MUTEX_NORMAL */
5129 @@ -577,8 +641,8 @@ static int my_pthread_cond_broadcast(pth
5130 {
5131 unsigned int value = (*(unsigned int *) cond);
5132 if (hybris_check_android_shared_cond(value)) {
5133 - LOGD("shared condition with Android, not broadcasting.");
5134 - return 0;
5135 + LOGD("Shared condition with Android, broadcasting with futex.");
5136 + return android_pthread_cond_broadcast((android_cond_t *) cond);
5137 }
5138
5139 pthread_cond_t *realcond = (pthread_cond_t *) value;
5140 @@ -598,8 +662,8 @@ static int my_pthread_cond_signal(pthrea
5141 unsigned int value = (*(unsigned int *) cond);
5142
5143 if (hybris_check_android_shared_cond(value)) {
5144 - LOGD("Shared condition with Android, not signaling.");
5145 - return 0;
5146 + LOGD("Shared condition with Android, broadcasting with futex.");
5147 + return android_pthread_cond_signal((android_cond_t *) cond);
5148 }
5149
5150 pthread_cond_t *realcond = (pthread_cond_t *) value;
5151 @@ -1217,6 +1281,56 @@ FP_ATTRIB static double my_strtod(const
5152 return strtod_l(nptr, endptr, hybris_locale);
5153 }
5154
5155 +static int __my_system_property_read(const void *pi, char *name, char *value)
5156 +{
5157 + return property_get(name, value, NULL);
5158 +}
5159 +
5160 +static int __my_system_property_get(const char *name, char *value)
5161 +{
5162 + return property_get(name, value, NULL);
5163 +}
5164 +
5165 +static int __my_system_property_foreach(void (*propfn)(const void *pi, void *cookie), void *cookie)
5166 +{
5167 + return 0;
5168 +}
5169 +
5170 +static const void *__my_system_property_find(const char *name)
5171 +{
5172 + return NULL;
5173 +}
5174 +
5175 +static unsigned int __my_system_property_serial(const void *pi)
5176 +{
5177 + return 0;
5178 +}
5179 +
5180 +static int __my_system_property_wait(const void *pi)
5181 +{
5182 + return 0;
5183 +}
5184 +
5185 +static int __my_system_property_update(void *pi, const char *value, unsigned int len)
5186 +{
5187 + return 0;
5188 +}
5189 +
5190 +static int __my_system_property_add(const char *name, unsigned int namelen, const char *value, unsigned int valuelen)
5191 +{
5192 + return 0;
5193 +}
5194 +
5195 +static unsigned int __my_system_property_wait_any(unsigned int serial)
5196 +{
5197 + return 0;
5198 +}
5199 +
5200 +static const void *__my_system_property_find_nth(unsigned n)
5201 +{
5202 + return NULL;
5203 +}
5204 +
5205 extern int __cxa_atexit(void (*)(void*), void*, void*);
5206
5207 static struct _hook hooks[] = {
5208 @@ -1449,6 +1563,17 @@ static struct _hook hooks[] = {
5209 /* grp.h */
5210 {"getgrgid", getgrgid},
5211 {"__cxa_atexit", __cxa_atexit},
5212 + {"__system_property_read", __my_system_property_read},
5213 + {"__system_property_get", __my_system_property_get},
5214 + {"__system_property_set", property_set},
5215 + {"__system_property_foreach", __my_system_property_foreach},
5216 + {"__system_property_find", __my_system_property_find},
5217 + {"__system_property_serial", __my_system_property_serial},
5218 + {"__system_property_wait", __my_system_property_wait},
5219 + {"__system_property_update", __my_system_property_update},
5220 + {"__system_property_add", __my_system_property_add},
5221 + {"__system_property_wait_any", __my_system_property_wait_any},
5222 + {"__system_property_find_nth", __my_system_property_find_nth},
5223 {NULL, NULL},
5224 };
5225
5226 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/hooks_shm.c
5227 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/hooks_shm.c
5228 @@ -123,7 +123,9 @@ static void _hybris_shm_init()
5229 else {
5230 LOGD("Creating a new shared memory segment.");
5231
5232 - _hybris_shm_fd = shm_open(HYBRIS_SHM_PATH, O_RDWR | O_CREAT, 0660);
5233 + mode_t pumask = umask(0);
5234 + _hybris_shm_fd = shm_open(HYBRIS_SHM_PATH, O_RDWR | O_CREAT, 0666);
5235 + umask(pumask);
5236 if (_hybris_shm_fd >= 0) {
5237 ftruncate( _hybris_shm_fd, size_to_map );
5238 /* Map the memory object */
5239 @@ -171,11 +173,12 @@ static void _hybris_shm_extend_region()
5240
5241 /*
5242 * Determine if the pointer that has been extracted by hybris is
5243 - * pointing to an address in the shared memory
5244 + * pointing to an address in the shared memory.
5245 */
5246 int hybris_is_pointer_in_shm(void *ptr)
5247 {
5248 - if ((unsigned int)ptr >= HYBRIS_SHM_MASK)
5249 + if (((unsigned int) ptr >= HYBRIS_SHM_MASK) &&
5250 + ((unsigned int) ptr <= HYBRIS_SHM_MASK_TOP))
5251 return 1;
5252
5253 return 0;
5254 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/hooks_shm.h
5255 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/hooks_shm.h
5256 @@ -20,6 +20,9 @@
5257
5258 #include <stddef.h>
5259
5260 +/* Leave space to workaround the issue that Android might pass negative int values */
5261 +#define HYBRIS_SHM_MASK_TOP 0xFFFFFFF0UL
5262 +
5263 typedef unsigned int hybris_shm_pointer_t;
5264
5265 /*
5266 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/jb/dlfcn.c
5267 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/jb/dlfcn.c
5268 @@ -78,7 +78,7 @@ const char *android_dlerror(void)
5269 void *android_dlsym(void *handle, const char *symbol)
5270 {
5271 soinfo *found;
5272 - Elf32_Sym *sym;
5273 + Elf_Sym *sym;
5274 unsigned bind;
5275
5276 pthread_mutex_lock(&dl_lock);
5277 @@ -142,7 +142,7 @@ int android_dladdr(const void *addr, Dl_
5278 info->dli_fbase = (void*)si->base;
5279
5280 /* Determine if any symbol in the library contains the specified address */
5281 - Elf32_Sym *sym = find_containing_symbol(addr, si);
5282 + Elf_Sym *sym = find_containing_symbol(addr, si);
5283
5284 if(sym != NULL) {
5285 info->dli_sname = si->strtab + sym->st_name;
5286 @@ -192,7 +192,7 @@ int android_dl_iterate_phdr(int (*cb)(st
5287 #endif
5288
5289
5290 -static Elf32_Sym libdl_symtab[] = {
5291 +static Elf_Sym libdl_symtab[] = {
5292 // total length of libdl_info.strtab, including trailing 0
5293 // This is actually the the STH_UNDEF entry. Technically, it's
5294 // supposed to have st_name == 0, but instead, it points to an index
5295 @@ -200,45 +200,45 @@ static Elf32_Sym libdl_symtab[] = {
5296 { st_name: sizeof(ANDROID_LIBDL_STRTAB) - 1,
5297 },
5298 { st_name: 0, // starting index of the name in libdl_info.strtab
5299 - st_value: (Elf32_Addr) &android_dlopen,
5300 + st_value: (Elf_Addr) &android_dlopen,
5301 st_info: STB_GLOBAL << 4,
5302 st_shndx: 1,
5303 },
5304 { st_name: 7,
5305 - st_value: (Elf32_Addr) &android_dlclose,
5306 + st_value: (Elf_Addr) &android_dlclose,
5307 st_info: STB_GLOBAL << 4,
5308 st_shndx: 1,
5309 },
5310 { st_name: 15,
5311 - st_value: (Elf32_Addr) &android_dlsym,
5312 + st_value: (Elf_Addr) &android_dlsym,
5313 st_info: STB_GLOBAL << 4,
5314 st_shndx: 1,
5315 },
5316 { st_name: 21,
5317 - st_value: (Elf32_Addr) &android_dlerror,
5318 + st_value: (Elf_Addr) &android_dlerror,
5319 st_info: STB_GLOBAL << 4,
5320 st_shndx: 1,
5321 },
5322 { st_name: 29,
5323 - st_value: (Elf32_Addr) &android_dladdr,
5324 + st_value: (Elf_Addr) &android_dladdr,
5325 st_info: STB_GLOBAL << 4,
5326 st_shndx: 1,
5327 },
5328 #ifdef ANDROID_ARM_LINKER
5329 { st_name: 36,
5330 - st_value: (Elf32_Addr) &android_dl_unwind_find_exidx,
5331 + st_value: (Elf_Addr) &android_dl_unwind_find_exidx,
5332 st_info: STB_GLOBAL << 4,
5333 st_shndx: 1,
5334 },
5335 #elif defined(ANDROID_X86_LINKER)
5336 { st_name: 36,
5337 - st_value: (Elf32_Addr) &android_dl_iterate_phdr,
5338 + st_value: (Elf_Addr) &android_dl_iterate_phdr,
5339 st_info: STB_GLOBAL << 4,
5340 st_shndx: 1,
5341 },
5342 #elif defined(ANDROID_SH_LINKER)
5343 { st_name: 36,
5344 - st_value: (Elf32_Addr) &android_dl_iterate_phdr,
5345 + st_value: (Elf_Addr) &android_dl_iterate_phdr,
5346 st_info: STB_GLOBAL << 4,
5347 st_shndx: 1,
5348 },
5349 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/jb/linker.c
5350 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/jb/linker.c
5351 @@ -381,10 +381,10 @@ android_dl_iterate_phdr(int (*cb)(struct
5352 }
5353 #endif
5354
5355 -static Elf32_Sym *_elf_lookup(soinfo *si, unsigned hash, const char *name)
5356 +static Elf_Sym *_elf_lookup(soinfo *si, unsigned hash, const char *name)
5357 {
5358 - Elf32_Sym *s;
5359 - Elf32_Sym *symtab = si->symtab;
5360 + Elf_Sym *s;
5361 + Elf_Sym *symtab = si->symtab;
5362 const char *strtab = si->strtab;
5363 unsigned n;
5364
5365 @@ -426,11 +426,11 @@ static unsigned elfhash(const char *_nam
5366 return h;
5367 }
5368
5369 -static Elf32_Sym *
5370 +static Elf_Sym *
5371 _do_lookup(soinfo *si, const char *name, unsigned *base)
5372 {
5373 unsigned elf_hash = elfhash(name);
5374 - Elf32_Sym *s;
5375 + Elf_Sym *s;
5376 unsigned *d;
5377 soinfo *lsi = si;
5378 int i;
5379 @@ -502,17 +502,17 @@ done:
5380 /* This is used by dl_sym(). It performs symbol lookup only within the
5381 specified soinfo object and not in any of its dependencies.
5382 */
5383 -Elf32_Sym *lookup_in_library(soinfo *si, const char *name)
5384 +Elf_Sym *lookup_in_library(soinfo *si, const char *name)
5385 {
5386 return _elf_lookup(si, elfhash(name), name);
5387 }
5388
5389 /* This is used by dl_sym(). It performs a global symbol lookup.
5390 */
5391 -Elf32_Sym *lookup(const char *name, soinfo **found, soinfo *start)
5392 +Elf_Sym *lookup(const char *name, soinfo **found, soinfo *start)
5393 {
5394 unsigned elf_hash = elfhash(name);
5395 - Elf32_Sym *s = NULL;
5396 + Elf_Sym *s = NULL;
5397 soinfo *si;
5398
5399 if(start == NULL) {
5400 @@ -553,7 +553,7 @@ soinfo *find_containing_library(const vo
5401 return NULL;
5402 }
5403
5404 -Elf32_Sym *find_containing_symbol(const void *addr, soinfo *si)
5405 +Elf_Sym *find_containing_symbol(const void *addr, soinfo *si)
5406 {
5407 unsigned int i;
5408 unsigned soaddr = (unsigned)addr - si->base;
5409 @@ -561,7 +561,7 @@ Elf32_Sym *find_containing_symbol(const
5410 /* Search the library's symbol table for any defined symbol which
5411 * contains this address */
5412 for(i=0; i<si->nchain; i++) {
5413 - Elf32_Sym *sym = &si->symtab[i];
5414 + Elf_Sym *sym = &si->symtab[i];
5415
5416 if(sym->st_shndx != SHN_UNDEF &&
5417 soaddr >= sym->st_value &&
5418 @@ -576,7 +576,7 @@ Elf32_Sym *find_containing_symbol(const
5419 #if 0
5420 static void dump(soinfo *si)
5421 {
5422 - Elf32_Sym *s = si->symtab;
5423 + Elf_Sym *s = si->symtab;
5424 unsigned n;
5425
5426 for(n = 0; n < si->nchain; n++) {
5427 @@ -705,7 +705,7 @@ is_prelinked(int fd, const char *name)
5428 static int
5429 verify_elf_object(void *base, const char *name)
5430 {
5431 - Elf32_Ehdr *hdr = (Elf32_Ehdr *) base;
5432 + Elf_Ehdr *hdr = (Elf_Ehdr *) base;
5433
5434 if (hdr->e_ident[EI_MAG0] != ELFMAG0) return -1;
5435 if (hdr->e_ident[EI_MAG1] != ELFMAG1) return -1;
5436 @@ -750,8 +750,8 @@ get_lib_extents(int fd, const char *name
5437 unsigned min_vaddr = 0xffffffff;
5438 unsigned max_vaddr = 0;
5439 unsigned char *_hdr = (unsigned char *)__hdr;
5440 - Elf32_Ehdr *ehdr = (Elf32_Ehdr *)_hdr;
5441 - Elf32_Phdr *phdr;
5442 + Elf_Ehdr *ehdr = (Elf_Ehdr *)_hdr;
5443 + Elf_Phdr *phdr;
5444 int cnt;
5445
5446 TRACE("[ %5d Computing extents for '%s'. ]\n", pid, name);
5447 @@ -770,7 +770,7 @@ get_lib_extents(int fd, const char *name
5448 TRACE("[ %5d - Non-prelinked library '%s' found. ]\n", pid, name);
5449 }
5450
5451 - phdr = (Elf32_Phdr *)(_hdr + ehdr->e_phoff);
5452 + phdr = (Elf_Phdr *)(_hdr + ehdr->e_phoff);
5453
5454 /* find the min/max p_vaddrs from all the PT_LOAD segments so we can
5455 * get the range. */
5456 @@ -885,12 +885,12 @@ err:
5457 static int
5458 load_segments(int fd, void *header, soinfo *si)
5459 {
5460 - Elf32_Ehdr *ehdr = (Elf32_Ehdr *)header;
5461 - Elf32_Phdr *phdr = (Elf32_Phdr *)((unsigned char *)header + ehdr->e_phoff);
5462 - Elf32_Addr base = (Elf32_Addr) si->base;
5463 + Elf_Ehdr *ehdr = (Elf_Ehdr *)header;
5464 + Elf_Phdr *phdr = (Elf_Phdr *)((unsigned char *)header + ehdr->e_phoff);
5465 + Elf_Addr base = (Elf_Addr) si->base;
5466 int cnt;
5467 unsigned len;
5468 - Elf32_Addr tmp;
5469 + Elf_Addr tmp;
5470 unsigned char *pbase;
5471 unsigned char *extra_base;
5472 unsigned extra_len;
5473 @@ -956,7 +956,7 @@ load_segments(int fd, void *header, soin
5474 * | |
5475 * _+---------------------+ page boundary
5476 */
5477 - tmp = (Elf32_Addr)(((unsigned)pbase + len + PAGE_SIZE - 1) &
5478 + tmp = (Elf_Addr)(((unsigned)pbase + len + PAGE_SIZE - 1) &
5479 (~PAGE_MASK));
5480 if (tmp < (base + phdr->p_vaddr + phdr->p_memsz)) {
5481 extra_len = base + phdr->p_vaddr + phdr->p_memsz - tmp;
5482 @@ -1020,7 +1020,7 @@ load_segments(int fd, void *header, soin
5483 phdr->p_vaddr, phdr->p_memsz);
5484 goto fail;
5485 }
5486 - si->gnu_relro_start = (Elf32_Addr) (base + phdr->p_vaddr);
5487 + si->gnu_relro_start = (Elf_Addr) (base + phdr->p_vaddr);
5488 si->gnu_relro_len = (unsigned) phdr->p_memsz;
5489 } else {
5490 #ifdef ANDROID_ARM_LINKER
5491 @@ -1067,11 +1067,11 @@ fail:
5492 */
5493 #if 0
5494 static unsigned
5495 -get_wr_offset(int fd, const char *name, Elf32_Ehdr *ehdr)
5496 +get_wr_offset(int fd, const char *name, Elf_Ehdr *ehdr)
5497 {
5498 - Elf32_Shdr *shdr_start;
5499 - Elf32_Shdr *shdr;
5500 - int shdr_sz = ehdr->e_shnum * sizeof(Elf32_Shdr);
5501 + Elf_Shdr *shdr_start;
5502 + Elf_Shdr *shdr;
5503 + int shdr_sz = ehdr->e_shnum * sizeof(Elf_Shdr);
5504 int cnt;
5505 unsigned wr_offset = 0xffffffff;
5506
5507 @@ -1104,7 +1104,7 @@ load_library(const char *name)
5508 unsigned req_base;
5509 const char *bname;
5510 soinfo *si = NULL;
5511 - Elf32_Ehdr *hdr;
5512 + Elf_Ehdr *hdr;
5513
5514 if(fd == -1) {
5515 DL_ERR("Library '%s' not found", name);
5516 @@ -1161,8 +1161,8 @@ load_library(const char *name)
5517
5518 /* this might not be right. Technically, we don't even need this info
5519 * once we go through 'load_segments'. */
5520 - hdr = (Elf32_Ehdr *)si->base;
5521 - si->phdr = (Elf32_Phdr *)((unsigned char *)si->base + hdr->e_phoff);
5522 + hdr = (Elf_Ehdr *)si->base;
5523 + si->phdr = (Elf_Phdr *)((unsigned char *)si->base + hdr->e_phoff);
5524 si->phnum = hdr->e_phnum;
5525 /**/
5526
5527 @@ -1261,7 +1261,7 @@ unsigned unload_library(soinfo *si)
5528 * in link_image. This is needed to undo the DT_NEEDED hack below.
5529 */
5530 if ((si->gnu_relro_start != 0) && (si->gnu_relro_len != 0)) {
5531 - Elf32_Addr start = (si->gnu_relro_start & ~PAGE_MASK);
5532 + Elf_Addr start = (si->gnu_relro_start & ~PAGE_MASK);
5533 unsigned len = (si->gnu_relro_start - start) + si->gnu_relro_len;
5534 if (mprotect((void *) start, len, PROT_READ | PROT_WRITE) < 0)
5535 DL_ERR("%5d %s: could not undo GNU_RELRO protections. "
5536 @@ -1304,16 +1304,16 @@ unsigned unload_library(soinfo *si)
5537 }
5538
5539 /* TODO: don't use unsigned for addrs below. It works, but is not
5540 - * ideal. They should probably be either uint32_t, Elf32_Addr, or unsigned
5541 + * ideal. They should probably be either uint32_t, Elf_Addr, or unsigned
5542 * long.
5543 */
5544 -static int reloc_library(soinfo *si, Elf32_Rel *rel, unsigned count)
5545 +static int reloc_library(soinfo *si, Elf_Rel *rel, unsigned count)
5546 {
5547 - Elf32_Sym *symtab = si->symtab;
5548 + Elf_Sym *symtab = si->symtab;
5549 const char *strtab = si->strtab;
5550 - Elf32_Sym *s;
5551 + Elf_Sym *s;
5552 unsigned base;
5553 - Elf32_Rel *start = rel;
5554 + Elf_Rel *start = rel;
5555 unsigned idx;
5556
5557 for (idx = 0; idx < count; ++idx) {
5558 @@ -1712,7 +1712,7 @@ static int nullify_closed_stdio (void)
5559 static int link_image(soinfo *si, unsigned wr_offset)
5560 {
5561 unsigned *d;
5562 - Elf32_Phdr *phdr = si->phdr;
5563 + Elf_Phdr *phdr = si->phdr;
5564 int phnum = si->phnum;
5565
5566 INFO("[ %5d linking %s ]\n", pid, si->name);
5567 @@ -1795,7 +1795,7 @@ static int link_image(soinfo *si, unsign
5568 phdr->p_vaddr, phdr->p_memsz);
5569 goto fail;
5570 }
5571 - si->gnu_relro_start = (Elf32_Addr) (si->base + phdr->p_vaddr);
5572 + si->gnu_relro_start = (Elf_Addr) (si->base + phdr->p_vaddr);
5573 si->gnu_relro_len = (unsigned) phdr->p_memsz;
5574 }
5575 }
5576 @@ -1822,7 +1822,7 @@ static int link_image(soinfo *si, unsign
5577 si->strtab = (const char *) (si->base + *d);
5578 break;
5579 case DT_SYMTAB:
5580 - si->symtab = (Elf32_Sym *) (si->base + *d);
5581 + si->symtab = (Elf_Sym *) (si->base + *d);
5582 break;
5583 case DT_PLTREL:
5584 if(*d != DT_REL) {
5585 @@ -1831,13 +1831,13 @@ static int link_image(soinfo *si, unsign
5586 }
5587 break;
5588 case DT_JMPREL:
5589 - si->plt_rel = (Elf32_Rel*) (si->base + *d);
5590 + si->plt_rel = (Elf_Rel*) (si->base + *d);
5591 break;
5592 case DT_PLTRELSZ:
5593 si->plt_rel_count = *d / 8;
5594 break;
5595 case DT_REL:
5596 - si->rel = (Elf32_Rel*) (si->base + *d);
5597 + si->rel = (Elf_Rel*) (si->base + *d);
5598 break;
5599 case DT_RELSZ:
5600 si->rel_count = *d / 8;
5601 @@ -1869,7 +1869,7 @@ static int link_image(soinfo *si, unsign
5602 pid, si->name, si->init_array);
5603 break;
5604 case DT_INIT_ARRAYSZ:
5605 - si->init_array_count = ((unsigned)*d) / sizeof(Elf32_Addr);
5606 + si->init_array_count = ((unsigned)*d) / sizeof(Elf_Addr);
5607 break;
5608 case DT_FINI_ARRAY:
5609 si->fini_array = (unsigned *)(si->base + *d);
5610 @@ -1877,7 +1877,7 @@ static int link_image(soinfo *si, unsign
5611 pid, si->name, si->fini_array);
5612 break;
5613 case DT_FINI_ARRAYSZ:
5614 - si->fini_array_count = ((unsigned)*d) / sizeof(Elf32_Addr);
5615 + si->fini_array_count = ((unsigned)*d) / sizeof(Elf_Addr);
5616 break;
5617 case DT_PREINIT_ARRAY:
5618 si->preinit_array = (unsigned *)(si->base + *d);
5619 @@ -1885,7 +1885,7 @@ static int link_image(soinfo *si, unsign
5620 pid, si->name, si->preinit_array);
5621 break;
5622 case DT_PREINIT_ARRAYSZ:
5623 - si->preinit_array_count = ((unsigned)*d) / sizeof(Elf32_Addr);
5624 + si->preinit_array_count = ((unsigned)*d) / sizeof(Elf_Addr);
5625 break;
5626 case DT_TEXTREL:
5627 /* TODO: make use of this. */
5628 @@ -1987,7 +1987,7 @@ static int link_image(soinfo *si, unsign
5629 #endif
5630
5631 if (si->gnu_relro_start != 0 && si->gnu_relro_len != 0) {
5632 - Elf32_Addr start = (si->gnu_relro_start & ~PAGE_MASK);
5633 + Elf_Addr start = (si->gnu_relro_start & ~PAGE_MASK);
5634 unsigned len = (si->gnu_relro_start - start) + si->gnu_relro_len;
5635 if (mprotect((void *) start, len, PROT_READ) < 0) {
5636 DL_ERR("%5d GNU_RELRO mprotect of library '%s' failed: %d (%s)\n",
5637 @@ -2170,7 +2170,7 @@ sanitize:
5638 while(vecs[0] != 0){
5639 switch(vecs[0]){
5640 case AT_PHDR:
5641 - si->phdr = (Elf32_Phdr*) vecs[1];
5642 + si->phdr = (Elf_Phdr*) vecs[1];
5643 break;
5644 case AT_PHNUM:
5645 si->phnum = (int) vecs[1];
5646 @@ -2190,7 +2190,7 @@ sanitize:
5647 si->base = 0;
5648 for ( nn = 0; nn < si->phnum; nn++ ) {
5649 if (si->phdr[nn].p_type == PT_PHDR) {
5650 - si->base = (Elf32_Addr) si->phdr - si->phdr[nn].p_vaddr;
5651 + si->base = (Elf_Addr) si->phdr - si->phdr[nn].p_vaddr;
5652 break;
5653 }
5654 }
5655 @@ -2303,9 +2303,9 @@ static unsigned find_linker_base(unsigne
5656 */
5657 unsigned __linker_init(unsigned **elfdata) {
5658 unsigned linker_addr = find_linker_base(elfdata);
5659 - Elf32_Ehdr *elf_hdr = (Elf32_Ehdr *) linker_addr;
5660 - Elf32_Phdr *phdr =
5661 - (Elf32_Phdr *)((unsigned char *) linker_addr + elf_hdr->e_phoff);
5662 + Elf_Ehdr *elf_hdr = (Elf_Ehdr *) linker_addr;
5663 + Elf_Phdr *phdr =
5664 + (Elf_Phdr *)((unsigned char *) linker_addr + elf_hdr->e_phoff);
5665
5666 soinfo linker_so;
5667 memset(&linker_so, 0, sizeof(soinfo));
5668 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/jb/linker.h
5669 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/jb/linker.h
5670 @@ -38,6 +38,26 @@
5671 #define PAGE_SIZE 4096
5672 #define PAGE_MASK 4095
5673
5674 +#if defined(__x86_64__)
5675 +typedef Elf64_Ehdr Elf_Ehdr;
5676 +typedef Elf64_Shdr Elf_Shdr;
5677 +typedef Elf64_Sym Elf_Sym;
5678 +typedef Elf64_Addr Elf_Addr;
5679 +typedef Elf64_Phdr Elf_Phdr;
5680 +typedef Elf64_Half Elf_Half;
5681 +typedef Elf64_Rel Elf_Rel;
5682 +typedef Elf64_Rela Elf_Rela;
5683 +#else
5684 +typedef Elf32_Ehdr Elf_Ehdr;
5685 +typedef Elf32_Shdr Elf_Shdr;
5686 +typedef Elf32_Sym Elf_Sym;
5687 +typedef Elf32_Addr Elf_Addr;
5688 +typedef Elf32_Phdr Elf_Phdr;
5689 +typedef Elf32_Half Elf_Half;
5690 +typedef Elf32_Rel Elf_Rel;
5691 +typedef Elf32_Rela Elf_Rela;
5692 +#endif
5693 +
5694 void debugger_init();
5695 const char *addr_to_name(unsigned addr);
5696
5697 @@ -55,10 +75,10 @@ struct link_map
5698 /* needed for dl_iterate_phdr to be passed to the callbacks provided */
5699 struct dl_phdr_info
5700 {
5701 - Elf32_Addr dlpi_addr;
5702 + Elf_Addr dlpi_addr;
5703 const char *dlpi_name;
5704 - const Elf32_Phdr *dlpi_phdr;
5705 - Elf32_Half dlpi_phnum;
5706 + const Elf_Phdr *dlpi_phdr;
5707 + Elf_Half dlpi_phnum;
5708 };
5709
5710
5711 @@ -90,7 +110,7 @@ typedef struct soinfo soinfo;
5712 struct soinfo
5713 {
5714 const char name[SOINFO_NAME_LEN];
5715 - Elf32_Phdr *phdr;
5716 + Elf_Phdr *phdr;
5717 int phnum;
5718 unsigned entry;
5719 unsigned base;
5720 @@ -107,7 +127,7 @@ struct soinfo
5721 unsigned flags;
5722
5723 const char *strtab;
5724 - Elf32_Sym *symtab;
5725 + Elf_Sym *symtab;
5726
5727 unsigned nbucket;
5728 unsigned nchain;
5729 @@ -116,10 +136,10 @@ struct soinfo
5730
5731 unsigned *plt_got;
5732
5733 - Elf32_Rel *plt_rel;
5734 + Elf_Rel *plt_rel;
5735 unsigned plt_rel_count;
5736
5737 - Elf32_Rel *rel;
5738 + Elf_Rel *rel;
5739 unsigned rel_count;
5740
5741 unsigned *preinit_array;
5742 @@ -144,7 +164,7 @@ struct soinfo
5743
5744 int constructors_called;
5745
5746 - Elf32_Addr gnu_relro_start;
5747 + Elf_Addr gnu_relro_start;
5748 unsigned gnu_relro_len;
5749
5750 };
5751 @@ -202,10 +222,10 @@ extern soinfo libdl_info;
5752
5753 soinfo *find_library(const char *name);
5754 unsigned unload_library(soinfo *si);
5755 -Elf32_Sym *lookup_in_library(soinfo *si, const char *name);
5756 -Elf32_Sym *lookup(const char *name, soinfo **found, soinfo *start);
5757 +Elf_Sym *lookup_in_library(soinfo *si, const char *name);
5758 +Elf_Sym *lookup(const char *name, soinfo **found, soinfo *start);
5759 soinfo *find_containing_library(const void *addr);
5760 -Elf32_Sym *find_containing_symbol(const void *addr, soinfo *si);
5761 +Elf_Sym *find_containing_symbol(const void *addr, soinfo *si);
5762 const char *linker_get_error(void);
5763 void call_constructors_recursive(soinfo *si);
5764
5765 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/common/jb/linker_format.c
5766 +++ libhybris-0.1.0+git20131207+e452e83/hybris/common/jb/linker_format.c
5767 @@ -268,7 +268,7 @@ static int log_vprint(int prio, const ch
5768 result = vformat_buffer(buf, sizeof buf, fmt, args);
5769
5770 if (log_fd < 0) {
5771 - log_fd = open("/dev/log/main", O_WRONLY);
5772 + log_fd = open("/dev/alog/main", O_WRONLY);
5773 if (log_fd < 0) {
5774 log_fd = fileno(stdout); // kernel doesn't have android log
5775 return result;
5776 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/configure.ac
5777 +++ libhybris-0.1.0+git20131207+e452e83/hybris/configure.ac
5778 @@ -184,6 +184,8 @@ AC_CONFIG_FILES([
5779 input/libis.pc
5780 camera/Makefile
5781 camera/libcamera.pc
5782 + media/Makefile
5783 + media/libmedia.pc
5784 include/Makefile
5785 utils/Makefile
5786 tests/Makefile
5787 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/hardware/hardware.c
5788 +++ libhybris-0.1.0+git20131207+e452e83/hybris/hardware/hardware.c
5789 @@ -17,6 +17,7 @@
5790
5791 #include <dlfcn.h>
5792 #include <stddef.h>
5793 +#include <errno.h>
5794 #include <android/hardware/hardware.h>
5795 #include <hybris/internal/binding.h>
5796
5797 @@ -26,15 +27,20 @@ static int (*_hw_get_module)(const char
5798
5799 static int (*_hw_get_module_by_class)(const char *class_id, const char *inst, const struct hw_module_t **module) = NULL;
5800
5801 -#define HARDWARE_DLSYM(fptr, sym) do { if (_libhardware == NULL) { _init_lib_hardware(); }; if (*(fptr) == NULL) { *(fptr) = (void *) android_dlsym(_libhardware, sym); } } while (0)
5802 +#define HARDWARE_DLSYM(fptr, sym) do { if (*(fptr) == NULL) { *(fptr) = (void *) android_dlsym(_libhardware, sym); } } while (0)
5803
5804 -static void _init_lib_hardware()
5805 +static void *_init_lib_hardware()
5806 {
5807 - _libhardware = (void *) android_dlopen("/system/lib/libhardware.so", RTLD_LAZY);
5808 + if (!_libhardware)
5809 + _libhardware = (void *) android_dlopen("/system/lib/libhardware.so", RTLD_LAZY);
5810 + return _libhardware;
5811 }
5812
5813 int hw_get_module(const char *id, const struct hw_module_t **module)
5814 {
5815 + if (!_init_lib_hardware())
5816 + return -EINVAL;
5817 +
5818 HARDWARE_DLSYM(&_hw_get_module, "hw_get_module");
5819 return (*_hw_get_module)(id, module);
5820 }
5821 @@ -42,6 +48,9 @@ int hw_get_module(const char *id, const
5822 int hw_get_module_by_class(const char *class_id, const char *inst,
5823 const struct hw_module_t **module)
5824 {
5825 + if (!_init_lib_hardware())
5826 + return -EINVAL;
5827 +
5828 HARDWARE_DLSYM(&_hw_get_module_by_class, "hw_get_module_by_class");
5829 return (*_hw_get_module_by_class)(class_id, inst, module);
5830 }
5831 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/include/Makefile.am
5832 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/Makefile.am
5833 @@ -65,6 +65,15 @@ propertiesincludedir = $(includedir)/hyb
5834 propertiesinclude_HEADERS = \
5835 hybris/properties/properties.h
5836
5837 +mediaincludedir = $(includedir)/hybris/media
5838 +mediainclude_HEADERS = \
5839 + hybris/media/media_compatibility_layer.h \
5840 + hybris/media/media_codec_layer.h \
5841 + hybris/media/media_codec_list.h \
5842 + hybris/media/media_format_layer.h \
5843 + hybris/media/surface_texture_client_hybris.h \
5844 + hybris/media/recorder_compatibility_layer.h
5845 +
5846 dlfcnincludedir = $(includedir)/hybris/dlfcn
5847 dlfcninclude_HEADERS = \
5848 hybris/dlfcn/dlfcn.h
5849 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/include/hybris/input/input_stack_compatibility_layer.h
5850 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/input/input_stack_compatibility_layer.h
5851 @@ -109,6 +109,7 @@ extern "C" {
5852 int input_area_height;
5853 };
5854
5855 + int android_input_check_availability();
5856 void android_input_stack_initialize(
5857 struct AndroidEventListener* listener,
5858 struct InputStackConfiguration* input_stack_configuration);
5859 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/include/hybris/internal/camera_control.h
5860 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/internal/camera_control.h
5861 @@ -19,7 +19,11 @@
5862
5863 #include <camera/Camera.h>
5864 #include <camera/CameraParameters.h>
5865 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
5866 #include <gui/SurfaceTexture.h>
5867 +#else
5868 +#include <gui/GLConsumer.h>
5869 +#endif
5870
5871 #include <stdint.h>
5872 #include <unistd.h>
5873 @@ -31,15 +35,22 @@ extern "C" {
5874 struct CameraControlListener;
5875
5876 struct CameraControl : public android::CameraListener,
5877 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
5878 public android::SurfaceTexture::FrameAvailableListener
5879 +#else
5880 + public android::GLConsumer::FrameAvailableListener
5881 +#endif
5882 {
5883 android::Mutex guard;
5884 CameraControlListener* listener;
5885 android::sp<android::Camera> camera;
5886 android::CameraParameters camera_parameters;
5887 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=2
5888 android::sp<android::SurfaceTexture> preview_texture;
5889 -
5890 - // From android::SurfaceTexture::FrameAvailableListener
5891 +#else
5892 + android::sp<android::GLConsumer> preview_texture;
5893 +#endif
5894 + // From android::SurfaceTexture/GLConsumer::FrameAvailableListener
5895 void onFrameAvailable();
5896
5897 // From android::CameraListener
5898 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/include/hybris/internal/surface_flinger_compatibility_layer_internal.h
5899 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/internal/surface_flinger_compatibility_layer_internal.h
5900 @@ -25,6 +25,7 @@
5901
5902 #include <utils/misc.h>
5903
5904 +#include <gui/Surface.h>
5905 #include <gui/SurfaceComposerClient.h>
5906 #include <ui/PixelFormat.h>
5907 #include <ui/Region.h>
5908 --- /dev/null
5909 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/media_codec_layer.h
5910 @@ -0,0 +1,93 @@
5911 +/*
5912 + * Copyright (C) 2013 Canonical Ltd
5913 + *
5914 + * Licensed under the Apache License, Version 2.0 (the "License");
5915 + * you may not use this file except in compliance with the License.
5916 + * You may obtain a copy of the License at
5917 + *
5918 + * http://www.apache.org/licenses/LICENSE-2.0
5919 + *
5920 + * Unless required by applicable law or agreed to in writing, software
5921 + * distributed under the License is distributed on an "AS IS" BASIS,
5922 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
5923 + * See the License for the specific language governing permissions and
5924 + * limitations under the License.
5925 + *
5926 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
5927 + */
5928 +
5929 +#ifndef MEDIA_CODEC_LAYER_H_
5930 +#define MEDIA_CODEC_LAYER_H_
5931 +
5932 +#include <stdint.h>
5933 +#include <unistd.h>
5934 +
5935 +#ifdef SIMPLE_PLAYER
5936 +#include <media/stagefright/MediaCodec.h>
5937 +#endif
5938 +
5939 +#include <hybris/media/media_format_layer.h>
5940 +#include <hybris/media/surface_texture_client_hybris.h>
5941 +
5942 +#ifdef __cplusplus
5943 +extern "C" {
5944 +#endif
5945 +
5946 + typedef void* MediaCodecDelegate;
5947 +
5948 + typedef void (*on_texture_needs_update)(void *context);
5949 + void media_codec_set_texture_needs_update_cb(MediaCodecDelegate delegate, on_texture_needs_update cb, void *context);
5950 +
5951 + MediaCodecDelegate media_codec_create_by_codec_name(const char *name);
5952 + MediaCodecDelegate media_codec_create_by_codec_type(const char *type);
5953 +
5954 +#ifdef SIMPLE_PLAYER
5955 + android::MediaCodec* media_codec_get(MediaCodecDelegate delegate);
5956 +#endif
5957 +
5958 + void media_codec_delegate_destroy(MediaCodecDelegate delegate);
5959 + void media_codec_delegate_ref(MediaCodecDelegate delegate);
5960 + void media_codec_delegate_unref(MediaCodecDelegate delegate);
5961 +
5962 +#ifdef SIMPLE_PLAYER
5963 + int media_codec_configure(MediaCodecDelegate delegate, MediaFormat format, void *nativeWindow, uint32_t flags);
5964 +#else
5965 + int media_codec_configure(MediaCodecDelegate delegate, MediaFormat format, SurfaceTextureClientHybris stc, uint32_t flags);
5966 +#endif
5967 + int media_codec_set_surface_texture_client(MediaCodecDelegate delegate, SurfaceTextureClientHybris stc);
5968 +
5969 + int media_codec_queue_csd(MediaCodecDelegate delegate, MediaFormat format);
5970 + int media_codec_start(MediaCodecDelegate delegate);
5971 + int media_codec_stop(MediaCodecDelegate delegate);
5972 + int media_codec_release(MediaCodecDelegate delegate);
5973 + int media_codec_flush(MediaCodecDelegate delegate);
5974 + size_t media_codec_get_input_buffers_size(MediaCodecDelegate delegate);
5975 + uint8_t *media_codec_get_nth_input_buffer(MediaCodecDelegate delegate, size_t n);
5976 + size_t media_codec_get_nth_input_buffer_capacity(MediaCodecDelegate delegate, size_t n);
5977 + size_t media_codec_get_output_buffers_size(MediaCodecDelegate delegate);
5978 + uint8_t *media_codec_get_nth_output_buffer(MediaCodecDelegate delegate, size_t n);
5979 + size_t media_codec_get_nth_output_buffer_capacity(MediaCodecDelegate delegate, size_t n);
5980 +
5981 + struct _MediaCodecBufferInfo
5982 + {
5983 + size_t index;
5984 + size_t offset;
5985 + size_t size;
5986 + int64_t presentation_time_us;
5987 + uint32_t flags;
5988 + uint8_t render_retries;
5989 + };
5990 + typedef struct _MediaCodecBufferInfo MediaCodecBufferInfo;
5991 +
5992 + int media_codec_dequeue_output_buffer(MediaCodecDelegate delegate, MediaCodecBufferInfo *info, int64_t timeout_us);
5993 + int media_codec_queue_input_buffer(MediaCodecDelegate delegate, const MediaCodecBufferInfo *info);
5994 + int media_codec_dequeue_input_buffer(MediaCodecDelegate delegate, size_t *index, int64_t timeout_us);
5995 + int media_codec_release_output_buffer(MediaCodecDelegate delegate, size_t index, uint8_t render);
5996 +
5997 + MediaFormat media_codec_get_output_format(MediaCodecDelegate delegate);
5998 +
5999 +#ifdef __cplusplus
6000 +}
6001 +#endif
6002 +
6003 +#endif // MEDIA_CODEC_LAYER_H_
6004 --- /dev/null
6005 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/media_codec_list.h
6006 @@ -0,0 +1,56 @@
6007 +/*
6008 + * Copyright (C) 2013 Canonical Ltd
6009 + *
6010 + * Licensed under the Apache License, Version 2.0 (the "License");
6011 + * you may not use this file except in compliance with the License.
6012 + * You may obtain a copy of the License at
6013 + *
6014 + * http://www.apache.org/licenses/LICENSE-2.0
6015 + *
6016 + * Unless required by applicable law or agreed to in writing, software
6017 + * distributed under the License is distributed on an "AS IS" BASIS,
6018 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6019 + * See the License for the specific language governing permissions and
6020 + * limitations under the License.
6021 + *
6022 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6023 + */
6024 +
6025 +#ifndef MEDIA_CODEC_LIST_PRIV_H_
6026 +#define MEDIA_CODEC_LIST_PRIV_H_
6027 +
6028 +#include <stddef.h>
6029 +#include <stdbool.h>
6030 +#include <unistd.h>
6031 +
6032 +#ifdef __cplusplus
6033 +extern "C" {
6034 +#endif
6035 +
6036 + ssize_t media_codec_list_find_codec_by_type(const char *type, bool encoder, size_t startIndex);
6037 + ssize_t media_codec_list_find_codec_by_name(const char *name);
6038 + size_t media_codec_list_count_codecs();
6039 + void media_codec_list_get_codec_info_at_id(size_t index);
6040 + const char *media_codec_list_get_codec_name(size_t index);
6041 + bool media_codec_list_is_encoder(size_t index);
6042 + size_t media_codec_list_get_num_supported_types(size_t index);
6043 + size_t media_codec_list_get_nth_supported_type_len(size_t index, size_t n);
6044 + int media_codec_list_get_nth_supported_type(size_t index, char *type, size_t n);
6045 +
6046 + struct _profile_level
6047 + {
6048 + uint32_t profile;
6049 + uint32_t level;
6050 + };
6051 + typedef struct _profile_level profile_level;
6052 +
6053 + size_t media_codec_list_get_num_profile_levels(size_t index, const char*);
6054 + size_t media_codec_list_get_num_color_formats(size_t index, const char*);
6055 + int media_codec_list_get_nth_codec_profile_level(size_t index, const char *type, profile_level *pro_level, size_t n);
6056 + int media_codec_list_get_codec_color_formats(size_t index, const char *type, uint32_t *color_formats);
6057 +
6058 +#ifdef __cplusplus
6059 +}
6060 +#endif
6061 +
6062 +#endif // MEDIA_CODEC_LIST_PRIV_H_
6063 --- /dev/null
6064 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/media_compatibility_layer.h
6065 @@ -0,0 +1,75 @@
6066 +/*
6067 + * Copyright (C) 2013 Canonical Ltd
6068 + *
6069 + * Licensed under the Apache License, Version 2.0 (the "License");
6070 + * you may not use this file except in compliance with the License.
6071 + * You may obtain a copy of the License at
6072 + *
6073 + * http://www.apache.org/licenses/LICENSE-2.0
6074 + *
6075 + * Unless required by applicable law or agreed to in writing, software
6076 + * distributed under the License is distributed on an "AS IS" BASIS,
6077 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6078 + * See the License for the specific language governing permissions and
6079 + * limitations under the License.
6080 + *
6081 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6082 + */
6083 +
6084 +#ifndef MEDIA_COMPATIBILITY_LAYER_H_
6085 +#define MEDIA_COMPATIBILITY_LAYER_H_
6086 +
6087 +#include <stdint.h>
6088 +#include <unistd.h>
6089 +#include <stdbool.h>
6090 +
6091 +#include <GLES2/gl2.h>
6092 +
6093 +#ifdef __cplusplus
6094 +extern "C" {
6095 +#endif
6096 +
6097 + // Common compat calls
6098 + int media_compat_check_availability();
6099 +
6100 + // Callback types
6101 + typedef void (*on_msg_set_video_size)(int height, int width, void *context);
6102 + typedef void (*on_video_texture_needs_update)(void *context);
6103 + typedef void (*on_msg_error)(void *context);
6104 + typedef void (*on_playback_complete)(void *context);
6105 + typedef void (*on_media_prepared)(void *context);
6106 +
6107 + struct MediaPlayerWrapper;
6108 +
6109 + // ----- Start of C API ----- //
6110 +
6111 + // Callback setters
6112 + void android_media_set_video_size_cb(struct MediaPlayerWrapper *mp, on_msg_set_video_size cb, void *context);
6113 + void android_media_set_video_texture_needs_update_cb(struct MediaPlayerWrapper *mp, on_video_texture_needs_update cb, void *context);
6114 + void android_media_set_error_cb(struct MediaPlayerWrapper *mp, on_msg_error cb, void *context);
6115 + void android_media_set_playback_complete_cb(struct MediaPlayerWrapper *mp, on_playback_complete cb, void *context);
6116 + void android_media_set_media_prepared_cb(struct MediaPlayerWrapper *mp, on_media_prepared cb, void *context);
6117 +
6118 + // Main player control API
6119 + struct MediaPlayerWrapper *android_media_new_player();
6120 + int android_media_set_data_source(struct MediaPlayerWrapper *mp, const char* url);
6121 + int android_media_set_preview_texture(struct MediaPlayerWrapper *mp, int texture_id);
6122 + void android_media_update_surface_texture(struct MediaPlayerWrapper *mp);
6123 + void android_media_surface_texture_get_transformation_matrix(struct MediaPlayerWrapper *mp, GLfloat*matrix);
6124 + int android_media_play(struct MediaPlayerWrapper *mp);
6125 + int android_media_pause(struct MediaPlayerWrapper *mp);
6126 + int android_media_stop(struct MediaPlayerWrapper *mp);
6127 + bool android_media_is_playing(struct MediaPlayerWrapper *mp);
6128 +
6129 + int android_media_seek_to(struct MediaPlayerWrapper *mp, int msec);
6130 + int android_media_get_current_position(struct MediaPlayerWrapper *mp, int *msec);
6131 + int android_media_get_duration(struct MediaPlayerWrapper *mp, int *msec);
6132 +
6133 + int android_media_get_volume(struct MediaPlayerWrapper *mp, int *volume);
6134 + int android_media_set_volume(struct MediaPlayerWrapper *mp, int volume);
6135 +
6136 +#ifdef __cplusplus
6137 +}
6138 +#endif
6139 +
6140 +#endif // MEDIA_COMPATIBILITY_LAYER_H_
6141 --- /dev/null
6142 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/media_format_layer.h
6143 @@ -0,0 +1,58 @@
6144 +/*
6145 + * Copyright (C) 2013 Canonical Ltd
6146 + *
6147 + * Licensed under the Apache License, Version 2.0 (the "License");
6148 + * you may not use this file except in compliance with the License.
6149 + * You may obtain a copy of the License at
6150 + *
6151 + * http://www.apache.org/licenses/LICENSE-2.0
6152 + *
6153 + * Unless required by applicable law or agreed to in writing, software
6154 + * distributed under the License is distributed on an "AS IS" BASIS,
6155 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6156 + * See the License for the specific language governing permissions and
6157 + * limitations under the License.
6158 + *
6159 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6160 + */
6161 +
6162 +#ifndef MEDIA_FORMAT_LAYER_H_
6163 +#define MEDIA_FORMAT_LAYER_H_
6164 +
6165 +#include <stddef.h>
6166 +#include <unistd.h>
6167 +
6168 +#ifdef __cplusplus
6169 +extern "C" {
6170 +#endif
6171 +
6172 + typedef void* MediaFormat;
6173 +
6174 + MediaFormat media_format_create_video_format(const char *mime, int32_t width, int32_t height, int64_t duration_us, int32_t max_input_size);
6175 +
6176 + void media_format_destroy(MediaFormat format);
6177 + void media_format_ref(MediaFormat format);
6178 + void media_format_unref(MediaFormat format);
6179 +
6180 + void media_format_set_byte_buffer(MediaFormat format, const char *key, uint8_t *data, size_t size);
6181 +
6182 + const char* media_format_get_mime(MediaFormat format);
6183 + int64_t media_format_get_duration_us(MediaFormat format);
6184 + int32_t media_format_get_width(MediaFormat format);
6185 + int32_t media_format_get_height(MediaFormat format);
6186 + int32_t media_format_get_max_input_size(MediaFormat format);
6187 + int32_t media_format_get_stride(MediaFormat format);
6188 + int32_t media_format_get_slice_height(MediaFormat format);
6189 + int32_t media_format_get_color_format(MediaFormat format);
6190 + int32_t media_format_get_crop_left(MediaFormat format);
6191 + int32_t media_format_get_crop_right(MediaFormat format);
6192 + int32_t media_format_get_crop_top(MediaFormat format);
6193 + int32_t media_format_get_crop_bottom(MediaFormat format);
6194 +
6195 + // TODO: Add getter for CSD buffer
6196 +
6197 +#ifdef __cplusplus
6198 +}
6199 +#endif
6200 +
6201 +#endif // MEDIA_FORMAT_LAYER_H_
6202 --- /dev/null
6203 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/recorder_compatibility_layer.h
6204 @@ -0,0 +1,126 @@
6205 +/*
6206 + * Copyright (C) 2013 Canonical Ltd
6207 + *
6208 + * Licensed under the Apache License, Version 2.0 (the "License");
6209 + * you may not use this file except in compliance with the License.
6210 + * You may obtain a copy of the License at
6211 + *
6212 + * http://www.apache.org/licenses/LICENSE-2.0
6213 + *
6214 + * Unless required by applicable law or agreed to in writing, software
6215 + * distributed under the License is distributed on an "AS IS" BASIS,
6216 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6217 + * See the License for the specific language governing permissions and
6218 + * limitations under the License.
6219 + */
6220 +
6221 +#ifndef RECORDER_COMPATIBILITY_LAYER_H_
6222 +#define RECORDER_COMPATIBILITY_LAYER_H_
6223 +
6224 +#include <stdint.h>
6225 +#include <unistd.h>
6226 +#include <stdint.h>
6227 +#include <stdbool.h>
6228 +
6229 +#ifdef __cplusplus
6230 +extern "C" {
6231 +#endif
6232 +
6233 + struct MediaRecorderWrapper;
6234 + struct CameraControl;
6235 +
6236 + // values are from andoid /frameworks/av/include/media/mediarecorder.h
6237 + typedef enum
6238 + {
6239 + ANDROID_VIDEO_SOURCE_DEFAULT = 0,
6240 + ANDROID_VIDEO_SOURCE_CAMERA = 1,
6241 + ANDROID_VIDEO_SOURCE_GRALLOC_BUFFER = 2
6242 + } VideoSource;
6243 +
6244 + // values are from andoid /system/core/include/system/audio.h
6245 + typedef enum
6246 + {
6247 + ANDROID_AUDIO_SOURCE_DEFAULT = 0,
6248 + ANDROID_AUDIO_SOURCE_MIC = 1,
6249 + ANDROID_AUDIO_SOURCE_VOICE_UPLINK = 2,
6250 + ANDROID_AUDIO_SOURCE_VOICE_DOWNLINK = 3,
6251 + ANDROID_AUDIO_SOURCE_VOICE_CALL = 4,
6252 + ANDROID_AUDIO_SOURCE_CAMCORDER = 5,
6253 + ANDROID_AUDIO_SOURCE_VOICE_RECOGNITION = 6,
6254 + ANDROID_AUDIO_SOURCE_VOICE_COMMUNICATION = 7,
6255 + ANDROID_AUDIO_SOURCE_REMOTE_SUBMIX = 8,
6256 + ANDROID_AUDIO_SOURCE_CNT,
6257 + ANDROID_AUDIO_SOURCE_MAX = ANDROID_AUDIO_SOURCE_CNT - 1
6258 + } AudioSource;
6259 +
6260 + // values are from andoid /frameworks/av/include/media/mediarecorder.h
6261 + typedef enum
6262 + {
6263 + ANDROID_OUTPUT_FORMAT_DEFAULT = 0,
6264 + ANDROID_OUTPUT_FORMAT_THREE_GPP = 1,
6265 + ANDROID_OUTPUT_FORMAT_MPEG_4 = 2,
6266 + ANDROID_OUTPUT_FORMAT_AUDIO_ONLY_START = 3,
6267 + /* These are audio only file formats */
6268 + ANDROID_OUTPUT_FORMAT_RAW_AMR = 3, //to be backward compatible
6269 + ANDROID_OUTPUT_FORMAT_AMR_NB = 3,
6270 + ANDROID_OUTPUT_FORMAT_AMR_WB = 4,
6271 + ANDROID_OUTPUT_FORMAT_AAC_ADIF = 5,
6272 + ANDROID_OUTPUT_FORMAT_AAC_ADTS = 6,
6273 + /* Stream over a socket, limited to a single stream */
6274 + ANDROID_OUTPUT_FORMAT_RTP_AVP = 7,
6275 + /* H.264/AAC data encapsulated in MPEG2/TS */
6276 + ANDROID_OUTPUT_FORMAT_MPEG2TS = 8
6277 + } OutputFormat;
6278 +
6279 + // values are from andoid /frameworks/av/include/media/mediarecorder.h
6280 + typedef enum
6281 + {
6282 + ANDROID_VIDEO_ENCODER_DEFAULT = 0,
6283 + ANDROID_VIDEO_ENCODER_H263 = 1,
6284 + ANDROID_VIDEO_ENCODER_H264 = 2,
6285 + ANDROID_VIDEO_ENCODER_MPEG_4_SP = 3
6286 + } VideoEncoder;
6287 +
6288 + // values are from andoid /frameworks/av/include/media/mediarecorder.h
6289 + typedef enum
6290 + {
6291 + ANDROID_AUDIO_ENCODER_DEFAULT = 0,
6292 + ANDROID_AUDIO_ENCODER_AMR_NB = 1,
6293 + ANDROID_AUDIO_ENCODER_AMR_WB = 2,
6294 + ANDROID_AUDIO_ENCODER_AAC = 3,
6295 + ANDROID_AUDIO_ENCODER_HE_AAC = 4,
6296 + ANDROID_AUDIO_ENCODER_AAC_ELD = 5
6297 + } AudioEncoder;
6298 +
6299 + // Callback types
6300 + typedef void (*on_recorder_msg_error)(void *context);
6301 +
6302 + // Callback setters
6303 + void android_recorder_set_error_cb(struct MediaRecorderWrapper *mr, on_recorder_msg_error cb,
6304 + void *context);
6305 +
6306 + // Main recorder control API
6307 + struct MediaRecorderWrapper *android_media_new_recorder();
6308 + int android_recorder_initCheck(struct MediaRecorderWrapper *mr);
6309 + int android_recorder_setCamera(struct MediaRecorderWrapper *mr, struct CameraControl* control);
6310 + int android_recorder_setVideoSource(struct MediaRecorderWrapper *mr, VideoSource vs);
6311 + int android_recorder_setAudioSource(struct MediaRecorderWrapper *mr, AudioSource as);
6312 + int android_recorder_setOutputFormat(struct MediaRecorderWrapper *mr, OutputFormat of);
6313 + int android_recorder_setVideoEncoder(struct MediaRecorderWrapper *mr, VideoEncoder ve);
6314 + int android_recorder_setAudioEncoder(struct MediaRecorderWrapper *mr, AudioEncoder ae);
6315 + int android_recorder_setOutputFile(struct MediaRecorderWrapper *mr, int fd);
6316 + int android_recorder_setVideoSize(struct MediaRecorderWrapper *mr, int width, int height);
6317 + int android_recorder_setVideoFrameRate(struct MediaRecorderWrapper *mr, int frames_per_second);
6318 + int android_recorder_setParameters(struct MediaRecorderWrapper *mr, const char* parameters);
6319 + int android_recorder_start(struct MediaRecorderWrapper *mr);
6320 + int android_recorder_stop(struct MediaRecorderWrapper *mr);
6321 + int android_recorder_prepare(struct MediaRecorderWrapper *mr);
6322 + int android_recorder_reset(struct MediaRecorderWrapper *mr);
6323 + int android_recorder_close(struct MediaRecorderWrapper *mr);
6324 + int android_recorder_release(struct MediaRecorderWrapper *mr);
6325 +
6326 +#ifdef __cplusplus
6327 +}
6328 +#endif
6329 +
6330 +#endif
6331 --- /dev/null
6332 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/media/surface_texture_client_hybris.h
6333 @@ -0,0 +1,63 @@
6334 +/*
6335 + * Copyright (C) 2013 Canonical Ltd
6336 + *
6337 + * Licensed under the Apache License, Version 2.0 (the "License");
6338 + * you may not use this file except in compliance with the License.
6339 + * You may obtain a copy of the License at
6340 + *
6341 + * http://www.apache.org/licenses/LICENSE-2.0
6342 + *
6343 + * Unless required by applicable law or agreed to in writing, software
6344 + * distributed under the License is distributed on an "AS IS" BASIS,
6345 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6346 + * See the License for the specific language governing permissions and
6347 + * limitations under the License.
6348 + *
6349 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6350 + */
6351 +
6352 +#ifndef SURFACE_TEXTURE_CLIENT_HYBRIS_H_
6353 +#define SURFACE_TEXTURE_CLIENT_HYBRIS_H_
6354 +
6355 +#include <stdint.h>
6356 +#include <unistd.h>
6357 +
6358 +#include <EGL/egl.h>
6359 +
6360 +#ifdef __ARM_PCS_VFP
6361 +#define FP_ATTRIB __attribute__((pcs("aapcs")))
6362 +#else
6363 +#define FP_ATTRIB
6364 +#endif
6365 +
6366 +#ifdef __cplusplus
6367 +extern "C" {
6368 +#endif
6369 +
6370 + // Taken from native_window.h
6371 + enum {
6372 + WINDOW_FORMAT_RGBA_8888 = 1,
6373 + WINDOW_FORMAT_RGBX_8888 = 2,
6374 + WINDOW_FORMAT_RGB_565 = 4,
6375 + };
6376 +
6377 + typedef void* SurfaceTextureClientHybris;
6378 +
6379 + //SurfaceTextureClientHybris surface_texture_client_get_instance();
6380 + SurfaceTextureClientHybris surface_texture_client_create(EGLNativeWindowType native_window);
6381 + SurfaceTextureClientHybris surface_texture_client_create_by_id(unsigned int texture_id);
6382 + uint8_t surface_texture_client_is_ready_for_rendering(SurfaceTextureClientHybris stc);
6383 + uint8_t surface_texture_client_hardware_rendering(SurfaceTextureClientHybris stc);
6384 + void surface_texture_client_set_hardware_rendering(SurfaceTextureClientHybris stc, uint8_t hardware_rendering);
6385 + void surface_texture_client_get_transformation_matrix(SurfaceTextureClientHybris stc, float *matrix) FP_ATTRIB;
6386 + void surface_texture_client_update_texture(SurfaceTextureClientHybris stc);
6387 + void surface_texture_client_destroy(SurfaceTextureClientHybris stc);
6388 + void surface_texture_client_ref(SurfaceTextureClientHybris stc);
6389 + void surface_texture_client_unref(SurfaceTextureClientHybris stc);
6390 + void surface_texture_client_set_surface_texture(SurfaceTextureClientHybris stc, EGLNativeWindowType native_window);
6391 +
6392 +#ifdef __cplusplus
6393 +}
6394 +#endif
6395 +
6396 +#endif // SURFACE_TEXTURE_CLIENT_HYBRIS_H_
6397 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/include/hybris/ui/ui_compatibility_layer.h
6398 +++ libhybris-0.1.0+git20131207+e452e83/hybris/include/hybris/ui/ui_compatibility_layer.h
6399 @@ -50,8 +50,10 @@ extern "C" {
6400
6401 void* graphic_buffer_get_native_buffer(struct graphic_buffer *buffer);
6402
6403 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
6404 void graphic_buffer_set_index(struct graphic_buffer *buffer, int index);
6405 int graphic_buffer_get_index(struct graphic_buffer *buffer);
6406 +#endif
6407
6408 int graphic_buffer_init_check(struct graphic_buffer *buffer);
6409
6410 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/input/is.c
6411 +++ libhybris-0.1.0+git20131207+e452e83/hybris/input/is.c
6412 @@ -28,6 +28,14 @@
6413
6414 HYBRIS_LIBRARY_INITIALIZE(is, COMPAT_LIBRARY_PATH);
6415
6416 +int android_input_check_availability()
6417 +{
6418 + /* Both are defined via HYBRIS_LIBRARY_INITIALIZE */
6419 + if (!is_handle)
6420 + hybris_is_initialize();
6421 + return is_handle ? 1 : 0;
6422 +}
6423 +
6424 HYBRIS_IMPLEMENT_VOID_FUNCTION2(is, android_input_stack_initialize,
6425 struct AndroidEventListener*, struct InputStackConfiguration*);
6426 HYBRIS_IMPLEMENT_VOID_FUNCTION0(is, android_input_stack_start);
6427 --- /dev/null
6428 +++ libhybris-0.1.0+git20131207+e452e83/hybris/media/Makefile.am
6429 @@ -0,0 +1,17 @@
6430 +lib_LTLIBRARIES = \
6431 + libmedia.la
6432 +
6433 +libmedia_la_SOURCES = media.c
6434 +libmedia_la_CFLAGS = -I$(top_srcdir)/include
6435 +if WANT_TRACE
6436 +libmedia_la_CFLAGS += -DDEBUG
6437 +endif
6438 +if WANT_DEBUG
6439 +libmedia_la_CFLAGS += -ggdb -O0
6440 +endif
6441 +libmedia_la_LDFLAGS = \
6442 + $(top_builddir)/common/libhybris-common.la \
6443 + -version-info "1":"0":"0"
6444 +
6445 +pkgconfigdir = $(libdir)/pkgconfig
6446 +pkgconfig_DATA = libmedia.pc
6447 --- /dev/null
6448 +++ libhybris-0.1.0+git20131207+e452e83/hybris/media/libmedia.pc.in
6449 @@ -0,0 +1,10 @@
6450 +prefix=@prefix@
6451 +exec_prefix=${prefix}
6452 +libdir=@libdir@
6453 +includedir=@includedir@
6454 +
6455 +Name: hybris-media
6456 +Description: libhybris media library
6457 +Version: @VERSION@
6458 +Libs: -L${libdir} -lhybris-common -lmedia
6459 +Cflags: -I${includedir}
6460 --- /dev/null
6461 +++ libhybris-0.1.0+git20131207+e452e83/hybris/media/media.c
6462 @@ -0,0 +1,272 @@
6463 +/*
6464 + * Copyright (C) 2013 Canonical Ltd
6465 + *
6466 + * Licensed under the Apache License, Version 2.0 (the "License");
6467 + * you may not use this file except in compliance with the License.
6468 + * You may obtain a copy of the License at
6469 + *
6470 + * http://www.apache.org/licenses/LICENSE-2.0
6471 + *
6472 + * Unless required by applicable law or agreed to in writing, software
6473 + * distributed under the License is distributed on an "AS IS" BASIS,
6474 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6475 + * See the License for the specific language governing permissions and
6476 + * limitations under the License.
6477 + *
6478 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6479 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
6480 + */
6481 +
6482 +#include <assert.h>
6483 +#include <dlfcn.h>
6484 +#include <stddef.h>
6485 +#include <stdbool.h>
6486 +
6487 +#include <hybris/internal/binding.h>
6488 +#include <hybris/media/media_compatibility_layer.h>
6489 +#include <hybris/media/recorder_compatibility_layer.h>
6490 +#include <hybris/media/media_codec_layer.h>
6491 +#include <hybris/media/media_codec_list.h>
6492 +#include <hybris/media/media_format_layer.h>
6493 +#include <hybris/media/surface_texture_client_hybris.h>
6494 +
6495 +#define COMPAT_LIBRARY_PATH "/system/lib/libmedia_compat_layer.so"
6496 +
6497 +#ifdef __ARM_PCS_VFP
6498 +#define FP_ATTRIB __attribute__((pcs("aapcs")))
6499 +#else
6500 +#define FP_ATTRIB
6501 +#endif
6502 +
6503 +HYBRIS_LIBRARY_INITIALIZE(media, COMPAT_LIBRARY_PATH);
6504 +
6505 +int media_compat_check_availability()
6506 +{
6507 + /* Both are defined via HYBRIS_LIBRARY_INITIALIZE */
6508 + hybris_media_initialize();
6509 + return media_handle ? 1 : 0;
6510 +}
6511 +
6512 +HYBRIS_IMPLEMENT_FUNCTION0(media, struct MediaPlayerWrapper*,
6513 + android_media_new_player);
6514 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, android_media_update_surface_texture,
6515 + struct MediaPlayerWrapper*);
6516 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_media_play,
6517 + struct MediaPlayerWrapper*);
6518 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_media_pause,
6519 + struct MediaPlayerWrapper*);
6520 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_media_stop,
6521 + struct MediaPlayerWrapper*);
6522 +HYBRIS_IMPLEMENT_FUNCTION1(media, bool, android_media_is_playing,
6523 + struct MediaPlayerWrapper*);
6524 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_seek_to,
6525 + struct MediaPlayerWrapper*, int);
6526 +
6527 +// Setters
6528 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_set_data_source,
6529 + struct MediaPlayerWrapper*, const char*);
6530 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_set_preview_texture,
6531 + struct MediaPlayerWrapper*, int);
6532 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_set_volume,
6533 + struct MediaPlayerWrapper*, int);
6534 +
6535 +// Getters
6536 +HYBRIS_IMPLEMENT_VOID_FUNCTION2(media, android_media_surface_texture_get_transformation_matrix,
6537 + struct MediaPlayerWrapper*, float*);
6538 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_get_current_position,
6539 + struct MediaPlayerWrapper*, int*);
6540 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_get_duration,
6541 + struct MediaPlayerWrapper*, int*);
6542 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_media_get_volume,
6543 + struct MediaPlayerWrapper*, int*);
6544 +
6545 +// Callbacks
6546 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_media_set_video_size_cb,
6547 + struct MediaPlayerWrapper*, on_msg_set_video_size, void*);
6548 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_media_set_video_texture_needs_update_cb,
6549 + struct MediaPlayerWrapper*, on_video_texture_needs_update, void*);
6550 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_media_set_error_cb,
6551 + struct MediaPlayerWrapper*, on_msg_error, void*);
6552 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_media_set_playback_complete_cb,
6553 + struct MediaPlayerWrapper*, on_playback_complete, void*);
6554 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_media_set_media_prepared_cb,
6555 + struct MediaPlayerWrapper*, on_media_prepared, void*);
6556 +
6557 +// Media Codecs
6558 +HYBRIS_IMPLEMENT_FUNCTION1(media, MediaCodecDelegate,
6559 + media_codec_create_by_codec_name, const char*);
6560 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_codec_delegate_destroy,
6561 + MediaCodecDelegate);
6562 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_codec_delegate_ref,
6563 + MediaCodecDelegate);
6564 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_codec_delegate_unref,
6565 + MediaCodecDelegate);
6566 +
6567 +#ifdef SIMPLE_PLAYER
6568 +HYBRIS_IMPLEMENT_FUNCTION4(media, int, media_codec_configure,
6569 + MediaCodecDelegate, MediaFormat, void*, uint32_t);
6570 +#else
6571 +HYBRIS_IMPLEMENT_FUNCTION4(media, int, media_codec_configure,
6572 + MediaCodecDelegate, MediaFormat, SurfaceTextureClientHybris, uint32_t);
6573 +#endif
6574 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, media_codec_set_surface_texture_client,
6575 + MediaCodecDelegate, SurfaceTextureClientHybris);
6576 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, media_codec_queue_csd,
6577 + MediaCodecDelegate, MediaFormat);
6578 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, media_codec_start,
6579 + MediaCodecDelegate);
6580 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, media_codec_stop,
6581 + MediaCodecDelegate);
6582 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, media_codec_release,
6583 + MediaCodecDelegate);
6584 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, media_codec_flush,
6585 + MediaCodecDelegate);
6586 +HYBRIS_IMPLEMENT_FUNCTION1(media, size_t, media_codec_get_input_buffers_size,
6587 + MediaCodecDelegate);
6588 +HYBRIS_IMPLEMENT_FUNCTION2(media, uint8_t*, media_codec_get_nth_input_buffer,
6589 + MediaCodecDelegate, size_t);
6590 +HYBRIS_IMPLEMENT_FUNCTION2(media, size_t, media_codec_get_nth_input_buffer_capacity,
6591 + MediaCodecDelegate, size_t);
6592 +HYBRIS_IMPLEMENT_FUNCTION1(media, size_t, media_codec_get_output_buffers_size,
6593 + MediaCodecDelegate);
6594 +HYBRIS_IMPLEMENT_FUNCTION2(media, uint8_t*, media_codec_get_nth_output_buffer,
6595 + MediaCodecDelegate, size_t);
6596 +HYBRIS_IMPLEMENT_FUNCTION2(media, size_t, media_codec_get_nth_output_buffer_capacity,
6597 + MediaCodecDelegate, size_t);
6598 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, media_codec_dequeue_output_buffer,
6599 + MediaCodecDelegate, MediaCodecBufferInfo*, int64_t);
6600 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, media_codec_queue_input_buffer,
6601 + MediaCodecDelegate, const MediaCodecBufferInfo*);
6602 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, media_codec_dequeue_input_buffer,
6603 + MediaCodecDelegate, size_t*, int64_t);
6604 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, media_codec_release_output_buffer,
6605 + MediaCodecDelegate, size_t, uint8_t);
6606 +HYBRIS_IMPLEMENT_FUNCTION1(media, MediaFormat, media_codec_get_output_format,
6607 + MediaCodecDelegate);
6608 +
6609 +HYBRIS_IMPLEMENT_FUNCTION3(media, ssize_t, media_codec_list_find_codec_by_type,
6610 + const char*, bool, size_t);
6611 +HYBRIS_IMPLEMENT_FUNCTION1(media, ssize_t, media_codec_list_find_codec_by_name,
6612 + const char *);
6613 +HYBRIS_IMPLEMENT_FUNCTION0(media, size_t, media_codec_list_count_codecs);
6614 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_codec_list_get_codec_info_at_id,
6615 + size_t);
6616 +HYBRIS_IMPLEMENT_FUNCTION1(media, const char*, media_codec_list_get_codec_name,
6617 + size_t);
6618 +HYBRIS_IMPLEMENT_FUNCTION1(media, bool, media_codec_list_is_encoder,
6619 + size_t);
6620 +HYBRIS_IMPLEMENT_FUNCTION1(media, size_t, media_codec_list_get_num_supported_types,
6621 + size_t);
6622 +HYBRIS_IMPLEMENT_FUNCTION2(media, size_t, media_codec_list_get_nth_supported_type_len,
6623 + size_t, size_t);
6624 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, media_codec_list_get_nth_supported_type,
6625 + size_t, char *, size_t);
6626 +HYBRIS_IMPLEMENT_FUNCTION2(media, size_t, media_codec_list_get_num_profile_levels,
6627 + size_t, const char*);
6628 +HYBRIS_IMPLEMENT_FUNCTION2(media, size_t, media_codec_list_get_num_color_formats,
6629 + size_t, const char*);
6630 +HYBRIS_IMPLEMENT_FUNCTION4(media, int, media_codec_list_get_nth_codec_profile_level,
6631 + size_t, const char*, profile_level*, size_t);
6632 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, media_codec_list_get_codec_color_formats,
6633 + size_t, const char*, uint32_t*);
6634 +
6635 +HYBRIS_IMPLEMENT_FUNCTION5(media, MediaFormat, media_format_create_video_format,
6636 + const char*, int32_t, int32_t, int64_t, int32_t);
6637 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_format_destroy,
6638 + MediaFormat);
6639 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_format_ref,
6640 + MediaFormat);
6641 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, media_format_unref,
6642 + MediaFormat);
6643 +HYBRIS_IMPLEMENT_VOID_FUNCTION4(media, media_format_set_byte_buffer,
6644 + MediaFormat, const char*, uint8_t*, size_t);
6645 +HYBRIS_IMPLEMENT_FUNCTION1(media, const char*, media_format_get_mime,
6646 + MediaFormat);
6647 +HYBRIS_IMPLEMENT_FUNCTION1(media, int64_t, media_format_get_duration_us,
6648 + MediaFormat);
6649 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_width,
6650 + MediaFormat);
6651 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_height,
6652 + MediaFormat);
6653 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_max_input_size,
6654 + MediaFormat);
6655 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_stride,
6656 + MediaFormat);
6657 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_slice_height,
6658 + MediaFormat);
6659 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_color_format,
6660 + MediaFormat);
6661 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_crop_left,
6662 + MediaFormat);
6663 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_crop_right,
6664 + MediaFormat);
6665 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_crop_top,
6666 + MediaFormat);
6667 +HYBRIS_IMPLEMENT_FUNCTION1(media, int32_t, media_format_get_crop_bottom,
6668 + MediaFormat);
6669 +
6670 +// SurfaceTextureClientHybris
6671 +HYBRIS_IMPLEMENT_FUNCTION1(media, SurfaceTextureClientHybris,
6672 + surface_texture_client_create, EGLNativeWindowType);
6673 +HYBRIS_IMPLEMENT_FUNCTION1(media, SurfaceTextureClientHybris,
6674 + surface_texture_client_create_by_id, unsigned int);
6675 +HYBRIS_IMPLEMENT_FUNCTION1(media, uint8_t,
6676 + surface_texture_client_is_ready_for_rendering, SurfaceTextureClientHybris);
6677 +HYBRIS_IMPLEMENT_FUNCTION1(media, uint8_t,
6678 + surface_texture_client_hardware_rendering, SurfaceTextureClientHybris);
6679 +HYBRIS_IMPLEMENT_VOID_FUNCTION2(media, surface_texture_client_set_hardware_rendering,
6680 + SurfaceTextureClientHybris, uint8_t);
6681 +HYBRIS_IMPLEMENT_VOID_FUNCTION2(media, surface_texture_client_get_transformation_matrix,
6682 + SurfaceTextureClientHybris, GLfloat*);
6683 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, surface_texture_client_update_texture,
6684 + SurfaceTextureClientHybris);
6685 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, surface_texture_client_destroy,
6686 + SurfaceTextureClientHybris);
6687 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, surface_texture_client_ref,
6688 + SurfaceTextureClientHybris);
6689 +HYBRIS_IMPLEMENT_VOID_FUNCTION1(media, surface_texture_client_unref,
6690 + SurfaceTextureClientHybris);
6691 +HYBRIS_IMPLEMENT_VOID_FUNCTION2(media, surface_texture_client_set_surface_texture,
6692 + SurfaceTextureClientHybris, EGLNativeWindowType);
6693 +
6694 +// Recorder
6695 +HYBRIS_IMPLEMENT_FUNCTION0(media, struct MediaRecorderWrapper*,
6696 + android_media_new_recorder);
6697 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_initCheck,
6698 + struct MediaRecorderWrapper*);
6699 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setCamera,
6700 + struct MediaRecorderWrapper*, struct CameraControl*);
6701 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setVideoSource,
6702 + struct MediaRecorderWrapper*, VideoSource);
6703 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setAudioSource,
6704 + struct MediaRecorderWrapper*, AudioSource);
6705 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setOutputFormat,
6706 + struct MediaRecorderWrapper*, OutputFormat);
6707 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setVideoEncoder,
6708 + struct MediaRecorderWrapper*, VideoEncoder);
6709 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setAudioEncoder,
6710 + struct MediaRecorderWrapper*, AudioEncoder);
6711 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setOutputFile,
6712 + struct MediaRecorderWrapper*, int);
6713 +HYBRIS_IMPLEMENT_FUNCTION3(media, int, android_recorder_setVideoSize,
6714 + struct MediaRecorderWrapper*, int, int);
6715 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setVideoFrameRate,
6716 + struct MediaRecorderWrapper*, int);
6717 +HYBRIS_IMPLEMENT_FUNCTION2(media, int, android_recorder_setParameters,
6718 + struct MediaRecorderWrapper*, const char*);
6719 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_start,
6720 + struct MediaRecorderWrapper*);
6721 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_stop,
6722 + struct MediaRecorderWrapper*);
6723 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_prepare,
6724 + struct MediaRecorderWrapper*);
6725 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_reset,
6726 + struct MediaRecorderWrapper*);
6727 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_close,
6728 + struct MediaRecorderWrapper*);
6729 +HYBRIS_IMPLEMENT_FUNCTION1(media, int, android_recorder_release,
6730 + struct MediaRecorderWrapper*);
6731 +
6732 +// Recorder Callbacks
6733 +HYBRIS_IMPLEMENT_VOID_FUNCTION3(media, android_recorder_set_error_cb,
6734 + struct MediaRecorderWrapper *, on_recorder_msg_error, void*);
6735 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/tests/Makefile.am
6736 +++ libhybris-0.1.0+git20131207+e452e83/hybris/tests/Makefile.am
6737 @@ -7,6 +7,8 @@ bin_PROGRAMS = \
6738 test_sensors \
6739 test_input \
6740 test_camera \
6741 + test_media \
6742 + test_recorder \
6743 test_gps
6744
6745 if HAS_ANDROID_4_2_0
6746 @@ -140,6 +142,28 @@ test_camera_LDADD = \
6747 $(top_builddir)/camera/libcamera.la \
6748 $(top_builddir)/input/libis.la
6749
6750 +test_media_SOURCES = test_media.c
6751 +test_media_CFLAGS = \
6752 + -I$(top_srcdir)/include
6753 +test_media_LDADD = \
6754 + $(top_builddir)/common/libhybris-common.la \
6755 + $(top_builddir)/egl/libEGL.la \
6756 + $(top_builddir)/glesv2/libGLESv2.la \
6757 + $(top_builddir)/media/libmedia.la \
6758 + $(top_builddir)/sf/libsf.la
6759 +
6760 +test_recorder_SOURCES = test_recorder.c
6761 +test_recorder_CFLAGS = \
6762 + -I$(top_srcdir)/include
6763 +test_recorder_LDADD = \
6764 + $(top_builddir)/common/libhybris-common.la \
6765 + $(top_builddir)/egl/libEGL.la \
6766 + $(top_builddir)/glesv2/libGLESv2.la \
6767 + $(top_builddir)/media/libmedia.la \
6768 + $(top_builddir)/camera/libcamera.la \
6769 + $(top_builddir)/input/libis.la \
6770 + $(top_builddir)/sf/libsf.la
6771 +
6772 test_gps_SOURCES = test_gps.c
6773 test_gps_CFLAGS = -pthread \
6774 -I$(top_srcdir)/include \
6775 --- /dev/null
6776 +++ libhybris-0.1.0+git20131207+e452e83/hybris/tests/test_media.c
6777 @@ -0,0 +1,373 @@
6778 +/*
6779 + * Copyright (C) 2013 Canonical Ltd
6780 + *
6781 + * Licensed under the Apache License, Version 2.0 (the "License");
6782 + * you may not use this file except in compliance with the License.
6783 + * You may obtain a copy of the License at
6784 + *
6785 + * http://www.apache.org/licenses/LICENSE-2.0
6786 + *
6787 + * Unless required by applicable law or agreed to in writing, software
6788 + * distributed under the License is distributed on an "AS IS" BASIS,
6789 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
6790 + * See the License for the specific language governing permissions and
6791 + * limitations under the License.
6792 + *
6793 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
6794 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
6795 + */
6796 +
6797 +#include <hybris/media/media_compatibility_layer.h>
6798 +#include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
6799 +
6800 +#include <EGL/egl.h>
6801 +#include <GLES2/gl2.h>
6802 +#include <GLES2/gl2ext.h>
6803 +
6804 +#include <assert.h>
6805 +#include <stdlib.h>
6806 +#include <stdio.h>
6807 +#include <string.h>
6808 +#include <stdbool.h>
6809 +#include <limits.h>
6810 +#include <fcntl.h>
6811 +#include <unistd.h>
6812 +#include <sys/stat.h>
6813 +#include <sys/types.h>
6814 +
6815 +enum {
6816 + OK = 0,
6817 + NO_ERROR = 0,
6818 +};
6819 +
6820 +static float DestWidth = 0.0, DestHeight = 0.0;
6821 +// Actual video dimmensions
6822 +static int Width = 0, Height = 0;
6823 +
6824 +static GLuint gProgram;
6825 +static GLuint gaPositionHandle, gaTexHandle, gsTextureHandle, gmTexMatrix;
6826 +
6827 +static GLfloat positionCoordinates[8];
6828 +
6829 +struct MediaPlayerWrapper *player = NULL;
6830 +
6831 +void calculate_position_coordinates()
6832 +{
6833 + // Assuming cropping output for now
6834 + float x = 1, y = 1;
6835 +
6836 + // Black borders
6837 + x = (float) (Width / DestWidth);
6838 + y = (float) (Height / DestHeight);
6839 +
6840 + // Make the larger side be 1
6841 + if (x > y) {
6842 + y /= x;
6843 + x = 1;
6844 + } else {
6845 + x /= y;
6846 + y = 1;
6847 + }
6848 +
6849 + positionCoordinates[0] = -x;
6850 + positionCoordinates[1] = y;
6851 + positionCoordinates[2] = -x;
6852 + positionCoordinates[3] = -y;
6853 + positionCoordinates[4] = x;
6854 + positionCoordinates[5] = -y;
6855 + positionCoordinates[6] = x;
6856 + positionCoordinates[7] = y;
6857 +}
6858 +
6859 +struct ClientWithSurface
6860 +{
6861 + struct SfClient* client;
6862 + struct SfSurface* surface;
6863 +};
6864 +
6865 +struct ClientWithSurface client_with_surface(bool setup_surface_with_egl)
6866 +{
6867 + struct ClientWithSurface cs;
6868 +
6869 + cs.client = sf_client_create();
6870 +
6871 + if (!cs.client) {
6872 + printf("Problem creating client ... aborting now.");
6873 + return cs;
6874 + }
6875 +
6876 + static const size_t primary_display = 0;
6877 +
6878 + DestWidth = sf_get_display_width(primary_display);
6879 + DestHeight = sf_get_display_height(primary_display);
6880 + printf("Primary display width: %f, height: %f\n", DestWidth, DestHeight);
6881 +
6882 + SfSurfaceCreationParameters params = {
6883 + 0,
6884 + 0,
6885 + DestWidth,
6886 + DestHeight,
6887 + -1, //PIXEL_FORMAT_RGBA_8888,
6888 + 15000,
6889 + 0.5f,
6890 + setup_surface_with_egl, // Do not associate surface with egl, will be done by camera HAL
6891 + "MediaCompatLayerTestSurface"
6892 + };
6893 +
6894 + cs.surface = sf_surface_create(cs.client, &params);
6895 +
6896 + if (!cs.surface) {
6897 + printf("Problem creating surface ... aborting now.");
6898 + return cs;
6899 + }
6900 +
6901 + sf_surface_make_current(cs.surface);
6902 +
6903 + return cs;
6904 +}
6905 +
6906 +static const char *vertex_shader()
6907 +{
6908 + return
6909 + "attribute vec4 a_position; \n"
6910 + "attribute vec2 a_texCoord; \n"
6911 + "uniform mat4 m_texMatrix; \n"
6912 + "varying vec2 v_texCoord; \n"
6913 + "varying float topDown; \n"
6914 + "void main() \n"
6915 + "{ \n"
6916 + " gl_Position = a_position; \n"
6917 + " v_texCoord = (m_texMatrix * vec4(a_texCoord, 0.0, 1.0)).xy;\n"
6918 + "} \n";
6919 +}
6920 +
6921 +static const char *fragment_shader()
6922 +{
6923 + return
6924 + "#extension GL_OES_EGL_image_external : require \n"
6925 + "precision mediump float; \n"
6926 + "varying vec2 v_texCoord; \n"
6927 + "uniform samplerExternalOES s_texture; \n"
6928 + "void main() \n"
6929 + "{ \n"
6930 + " gl_FragColor = texture2D( s_texture, v_texCoord );\n"
6931 + "} \n";
6932 +}
6933 +
6934 +static GLuint loadShader(GLenum shaderType, const char* pSource)
6935 +{
6936 + GLuint shader = glCreateShader(shaderType);
6937 +
6938 + if (shader) {
6939 + glShaderSource(shader, 1, &pSource, NULL);
6940 + glCompileShader(shader);
6941 + GLint compiled = 0;
6942 + glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
6943 +
6944 + if (!compiled) {
6945 + GLint infoLen = 0;
6946 + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
6947 + if (infoLen) {
6948 + char* buf = (char*) malloc(infoLen);
6949 + if (buf) {
6950 + glGetShaderInfoLog(shader, infoLen, NULL, buf);
6951 + fprintf(stderr, "Could not compile shader %d:\n%s\n",
6952 + shaderType, buf);
6953 + free(buf);
6954 + }
6955 + glDeleteShader(shader);
6956 + shader = 0;
6957 + }
6958 + }
6959 + } else {
6960 + printf("Error, during shader creation: %i\n", glGetError());
6961 + }
6962 +
6963 + return shader;
6964 +}
6965 +
6966 +static GLuint create_program(const char* pVertexSource, const char* pFragmentSource)
6967 +{
6968 + GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
6969 + if (!vertexShader) {
6970 + printf("vertex shader not compiled\n");
6971 + return 0;
6972 + }
6973 +
6974 + GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
6975 + if (!pixelShader) {
6976 + printf("frag shader not compiled\n");
6977 + return 0;
6978 + }
6979 +
6980 + GLuint program = glCreateProgram();
6981 + if (program) {
6982 + glAttachShader(program, vertexShader);
6983 + glAttachShader(program, pixelShader);
6984 + glLinkProgram(program);
6985 + GLint linkStatus = GL_FALSE;
6986 +
6987 + glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
6988 + if (linkStatus != GL_TRUE) {
6989 + GLint bufLength = 0;
6990 + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
6991 + if (bufLength) {
6992 + char* buf = (char*) malloc(bufLength);
6993 + if (buf) {
6994 + glGetProgramInfoLog(program, bufLength, NULL, buf);
6995 + fprintf(stderr, "Could not link program:\n%s\n", buf);
6996 + free(buf);
6997 + }
6998 + }
6999 + glDeleteProgram(program);
7000 + program = 0;
7001 + }
7002 + }
7003 +
7004 + return program;
7005 +}
7006 +
7007 +static int setup_video_texture(struct ClientWithSurface *cs, GLuint *preview_texture_id)
7008 +{
7009 + assert(cs != NULL);
7010 + assert(preview_texture_id != NULL);
7011 +
7012 + sf_surface_make_current(cs->surface);
7013 +
7014 + glGenTextures(1, preview_texture_id);
7015 + glClearColor(0, 0, 0, 0);
7016 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
7017 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
7018 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
7019 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
7020 +
7021 + android_media_set_preview_texture(player, *preview_texture_id);
7022 +
7023 + return 0;
7024 +}
7025 +
7026 +void set_video_size_cb(int height, int width, void *context)
7027 +{
7028 + printf("Video height: %d, width: %d\n", height, width);
7029 + printf("Video dest height: %f, width: %f\n", DestHeight, DestWidth);
7030 +
7031 + Height = height;
7032 + Width = width;
7033 +}
7034 +
7035 +void media_prepared_cb(void *context)
7036 +{
7037 + printf("Media is prepared for playback.\n");
7038 +}
7039 +
7040 +int main(int argc, char **argv)
7041 +{
7042 + if (argc < 2) {
7043 + printf("Usage: test_media <video_to_play>\n");
7044 + return EXIT_FAILURE;
7045 + }
7046 +
7047 + player = android_media_new_player();
7048 + if (player == NULL) {
7049 + printf("Problem creating new media player.\n");
7050 + return EXIT_FAILURE;
7051 + }
7052 +
7053 + // Set player event cb for when the video size is known:
7054 + android_media_set_video_size_cb(player, set_video_size_cb, NULL);
7055 + android_media_set_media_prepared_cb(player, media_prepared_cb, NULL);
7056 +
7057 + printf("Setting data source to: %s.\n", argv[1]);
7058 +
7059 + if (android_media_set_data_source(player, argv[1]) != OK) {
7060 + printf("Failed to set data source: %s\n", argv[1]);
7061 + return EXIT_FAILURE;
7062 + }
7063 +
7064 + printf("Creating EGL surface.\n");
7065 + struct ClientWithSurface cs = client_with_surface(true /* Associate surface with egl. */);
7066 + if (!cs.surface) {
7067 + printf("Problem acquiring surface for preview");
7068 + return EXIT_FAILURE;
7069 + }
7070 +
7071 + printf("Creating GL texture.\n");
7072 +
7073 + GLuint preview_texture_id;
7074 + EGLDisplay disp = sf_client_get_egl_display(cs.client);
7075 + EGLSurface surface = sf_surface_get_egl_surface(cs.surface);
7076 +
7077 + sf_surface_make_current(cs.surface);
7078 +
7079 + if (setup_video_texture(&cs, &preview_texture_id) != OK) {
7080 + printf("Problem setting up GL texture for video surface.\n");
7081 + return EXIT_FAILURE;
7082 + }
7083 +
7084 + printf("Starting video playback.\n");
7085 + android_media_play(player);
7086 +
7087 + while (android_media_is_playing(player)) {
7088 + GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
7089 +
7090 + const GLfloat textureCoordinates[] = {
7091 + 1.0f, 1.0f,
7092 + 0.0f, 1.0f,
7093 + 0.0f, 0.0f,
7094 + 1.0f, 0.0f
7095 + };
7096 +
7097 + android_media_update_surface_texture(player);
7098 +
7099 + calculate_position_coordinates();
7100 +
7101 + gProgram = create_program(vertex_shader(), fragment_shader());
7102 + gaPositionHandle = glGetAttribLocation(gProgram, "a_position");
7103 + gaTexHandle = glGetAttribLocation(gProgram, "a_texCoord");
7104 + gsTextureHandle = glGetUniformLocation(gProgram, "s_texture");
7105 + gmTexMatrix = glGetUniformLocation(gProgram, "m_texMatrix");
7106 +
7107 + glClear(GL_COLOR_BUFFER_BIT);
7108 +
7109 + // Use the program object
7110 + glUseProgram(gProgram);
7111 + // Enable attributes
7112 + glEnableVertexAttribArray(gaPositionHandle);
7113 + glEnableVertexAttribArray(gaTexHandle);
7114 + // Load the vertex position
7115 + glVertexAttribPointer(gaPositionHandle,
7116 + 2,
7117 + GL_FLOAT,
7118 + GL_FALSE,
7119 + 0,
7120 + positionCoordinates);
7121 + // Load the texture coordinate
7122 + glVertexAttribPointer(gaTexHandle,
7123 + 2,
7124 + GL_FLOAT,
7125 + GL_FALSE,
7126 + 0,
7127 + textureCoordinates);
7128 +
7129 + GLfloat matrix[16];
7130 + android_media_surface_texture_get_transformation_matrix(player, matrix);
7131 +
7132 + glUniformMatrix4fv(gmTexMatrix, 1, GL_FALSE, matrix);
7133 +
7134 + glActiveTexture(GL_TEXTURE0);
7135 + // Set the sampler texture unit to 0
7136 + glUniform1i(gsTextureHandle, 0);
7137 + glUniform1i(gmTexMatrix, 0);
7138 + android_media_update_surface_texture(player);
7139 + glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
7140 + //glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
7141 + glDisableVertexAttribArray(gaPositionHandle);
7142 + glDisableVertexAttribArray(gaTexHandle);
7143 +
7144 + eglSwapBuffers(disp, surface);
7145 + }
7146 +
7147 + android_media_stop(player);
7148 +
7149 + return EXIT_SUCCESS;
7150 +}
7151 --- /dev/null
7152 +++ libhybris-0.1.0+git20131207+e452e83/hybris/tests/test_recorder.c
7153 @@ -0,0 +1,490 @@
7154 +/*
7155 + * Copyright (C) 2013 Canonical Ltd
7156 + *
7157 + * Licensed under the Apache License, Version 2.0 (the "License");
7158 + * you may not use this file except in compliance with the License.
7159 + * You may obtain a copy of the License at
7160 + *
7161 + * http://www.apache.org/licenses/LICENSE-2.0
7162 + *
7163 + * Unless required by applicable law or agreed to in writing, software
7164 + * distributed under the License is distributed on an "AS IS" BASIS,
7165 + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
7166 + * See the License for the specific language governing permissions and
7167 + * limitations under the License.
7168 + *
7169 + * Authored by: Jim Hodapp <jim.hodapp@canonical.com>
7170 + * Guenter Schwann <guenter.schwann@canonical.com>
7171 + * Ricardo Salveti de Araujo <ricardo.salveti@canonical.com>
7172 + */
7173 +
7174 +#include <hybris/camera/camera_compatibility_layer.h>
7175 +#include <hybris/camera/camera_compatibility_layer_capabilities.h>
7176 +
7177 +#include <hybris/media/recorder_compatibility_layer.h>
7178 +
7179 +#include <hybris/input/input_stack_compatibility_layer.h>
7180 +#include <hybris/input/input_stack_compatibility_layer_codes_key.h>
7181 +#include <hybris/input/input_stack_compatibility_layer_flags_key.h>
7182 +
7183 +#include <hybris/surface_flinger/surface_flinger_compatibility_layer.h>
7184 +
7185 +#include <EGL/egl.h>
7186 +#include <GLES2/gl2.h>
7187 +#include <GLES2/gl2ext.h>
7188 +
7189 +#include <assert.h>
7190 +#include <stdlib.h>
7191 +#include <stdio.h>
7192 +#include <string.h>
7193 +#include <stdbool.h>
7194 +#include <limits.h>
7195 +#include <fcntl.h>
7196 +#include <unistd.h>
7197 +#include <sys/stat.h>
7198 +#include <sys/types.h>
7199 +
7200 +int shot_counter = 1;
7201 +int32_t current_zoom_level = 1;
7202 +bool new_camera_frame_available = true;
7203 +struct MediaRecorderWrapper *mr = 0;
7204 +GLuint preview_texture_id = 0;
7205 +
7206 +static GLuint gProgram;
7207 +static GLuint gaPositionHandle, gaTexHandle, gsTextureHandle, gmTexMatrix;
7208 +
7209 +void error_msg_cb(void* context)
7210 +{
7211 + printf("%s \n", __PRETTY_FUNCTION__);
7212 +}
7213 +
7214 +void shutter_msg_cb(void* context)
7215 +{
7216 + printf("%s \n", __PRETTY_FUNCTION__);
7217 +}
7218 +
7219 +void zoom_msg_cb(void* context, int32_t new_zoom_level)
7220 +{
7221 + printf("%s \n", __PRETTY_FUNCTION__);
7222 +
7223 + struct CameraControl* cc = (struct CameraControl*) context;
7224 + static int zoom;
7225 + current_zoom_level = new_zoom_level;
7226 +}
7227 +
7228 +void autofocus_msg_cb(void* context)
7229 +{
7230 + printf("%s \n", __PRETTY_FUNCTION__);
7231 +}
7232 +
7233 +void raw_data_cb(void* data, uint32_t data_size, void* context)
7234 +{
7235 + printf("%s: %d \n", __PRETTY_FUNCTION__, data_size);
7236 +}
7237 +
7238 +void jpeg_data_cb(void* data, uint32_t data_size, void* context)
7239 +{
7240 + printf("%s: %d \n", __PRETTY_FUNCTION__, data_size);
7241 + struct CameraControl* cc = (struct CameraControl*) context;
7242 + android_camera_start_preview(cc);
7243 +}
7244 +
7245 +void size_cb(void* ctx, int width, int height)
7246 +{
7247 + printf("Supported size: [%d,%d]\n", width, height);
7248 +}
7249 +
7250 +void preview_texture_needs_update_cb(void* ctx)
7251 +{
7252 + new_camera_frame_available = true;
7253 +}
7254 +
7255 +void on_new_input_event(struct Event* event, void* context)
7256 +{
7257 + assert(context);
7258 +
7259 + if (event->type == KEY_EVENT_TYPE && event->action == ISCL_KEY_EVENT_ACTION_UP) {
7260 + printf("We have got a key event: %d \n", event->details.key.key_code);
7261 +
7262 + struct CameraControl* cc = (struct CameraControl*) context;
7263 +
7264 + int ret;
7265 + switch (event->details.key.key_code) {
7266 + case ISCL_KEYCODE_VOLUME_UP:
7267 + printf("Starting video recording\n");
7268 +
7269 + android_camera_unlock(cc);
7270 +
7271 + ret = android_recorder_setCamera(mr, cc);
7272 + if (ret < 0) {
7273 + printf("android_recorder_setCamera() failed\n");
7274 + return;
7275 + }
7276 + //state initial / idle
7277 + ret = android_recorder_setAudioSource(mr, ANDROID_AUDIO_SOURCE_CAMCORDER);
7278 + if (ret < 0) {
7279 + printf("android_recorder_setAudioSource() failed\n");
7280 + return;
7281 + }
7282 + ret = android_recorder_setVideoSource(mr, ANDROID_VIDEO_SOURCE_CAMERA);
7283 + if (ret < 0) {
7284 + printf("android_recorder_setVideoSource() failed\n");
7285 + return;
7286 + }
7287 + //state initialized
7288 + ret = android_recorder_setOutputFormat(mr, ANDROID_OUTPUT_FORMAT_MPEG_4);
7289 + if (ret < 0) {
7290 + printf("android_recorder_setOutputFormat() failed\n");
7291 + return;
7292 + }
7293 + //state DataSourceConfigured
7294 + ret = android_recorder_setAudioEncoder(mr, ANDROID_AUDIO_ENCODER_AAC);
7295 + if (ret < 0) {
7296 + printf("android_recorder_setAudioEncoder() failed\n");
7297 + return;
7298 + }
7299 + ret = android_recorder_setVideoEncoder(mr, ANDROID_VIDEO_ENCODER_H264);
7300 + if (ret < 0) {
7301 + printf("android_recorder_setVideoEncoder() failed\n");
7302 + return;
7303 + }
7304 +
7305 + int fd;
7306 + fd = open("/tmp/test_video_recorder.avi", O_WRONLY | O_CREAT, S_IRUSR | S_IWUSR);
7307 + if (fd < 0) {
7308 + printf("Could not open file for video recording\n");
7309 + printf("FD: %i\n", fd);
7310 + return;
7311 + }
7312 + ret = android_recorder_setOutputFile(mr, fd);
7313 + if (ret < 0) {
7314 + printf("android_recorder_setOutputFile() failed\n");
7315 + return;
7316 + }
7317 +
7318 + ret = android_recorder_setVideoSize(mr, 1280, 720);
7319 + if (ret < 0) {
7320 + printf("android_recorder_setVideoSize() failed\n");
7321 + return;
7322 + }
7323 + ret = android_recorder_setVideoFrameRate(mr, 30);
7324 + if (ret < 0) {
7325 + printf("android_recorder_setVideoFrameRate() failed\n");
7326 + return;
7327 + }
7328 +
7329 + ret = android_recorder_prepare(mr);
7330 + if (ret < 0) {
7331 + printf("android_recorder_prepare() failed\n");
7332 + return;
7333 + }
7334 + //state prepared
7335 + ret = android_recorder_start(mr);
7336 + if (ret < 0) {
7337 + printf("android_recorder_start() failed\n");
7338 + return;
7339 + }
7340 + break;
7341 + case ISCL_KEYCODE_VOLUME_DOWN:
7342 + printf("Stoping video recording\n");
7343 + ret = android_recorder_stop(mr);
7344 +
7345 + printf("Stoping video recording returned\n");
7346 + if (ret < 0) {
7347 + printf("android_recorder_stop() failed\n");
7348 + return;
7349 + }
7350 + printf("Stopped video recording\n");
7351 + ret = android_recorder_reset(mr);
7352 + if (ret < 0) {
7353 + printf("android_recorder_reset() failed\n");
7354 + return;
7355 + }
7356 + printf("Reset video recorder\n");
7357 + break;
7358 + }
7359 + }
7360 +}
7361 +
7362 +struct ClientWithSurface
7363 +{
7364 + struct SfClient* client;
7365 + struct SfSurface* surface;
7366 +};
7367 +
7368 +struct ClientWithSurface client_with_surface(bool setup_surface_with_egl)
7369 +{
7370 + struct ClientWithSurface cs;
7371 +
7372 + cs.client = sf_client_create();
7373 +
7374 + if (!cs.client) {
7375 + printf("Problem creating client ... aborting now.");
7376 + return cs;
7377 + }
7378 +
7379 + static const size_t primary_display = 0;
7380 +
7381 + SfSurfaceCreationParameters params = {
7382 + 0,
7383 + 0,
7384 + sf_get_display_width(primary_display),
7385 + sf_get_display_height(primary_display),
7386 + -1, //PIXEL_FORMAT_RGBA_8888,
7387 + 15000,
7388 + 0.5f,
7389 + setup_surface_with_egl, // Do not associate surface with egl, will be done by camera HAL
7390 + "CameraCompatLayerTestSurface"
7391 + };
7392 +
7393 + cs.surface = sf_surface_create(cs.client, &params);
7394 +
7395 + if (!cs.surface) {
7396 + printf("Problem creating surface ... aborting now.");
7397 + return cs;
7398 + }
7399 +
7400 + sf_surface_make_current(cs.surface);
7401 +
7402 + return cs;
7403 +}
7404 +
7405 +static const char* vertex_shader()
7406 +{
7407 + return
7408 + "#extension GL_OES_EGL_image_external : require \n"
7409 + "attribute vec4 a_position; \n"
7410 + "attribute vec2 a_texCoord; \n"
7411 + "uniform mat4 m_texMatrix; \n"
7412 + "varying vec2 v_texCoord; \n"
7413 + "varying float topDown; \n"
7414 + "void main() \n"
7415 + "{ \n"
7416 + " gl_Position = a_position; \n"
7417 + " v_texCoord = a_texCoord; \n"
7418 + // " v_texCoord = (m_texMatrix * vec4(a_texCoord, 0.0, 1.0)).xy;\n"
7419 + //" topDown = v_texCoord.y; \n"
7420 + "} \n";
7421 +}
7422 +
7423 +static const char* fragment_shader()
7424 +{
7425 + return
7426 + "#extension GL_OES_EGL_image_external : require \n"
7427 + "precision mediump float; \n"
7428 + "varying vec2 v_texCoord; \n"
7429 + "uniform samplerExternalOES s_texture; \n"
7430 + "void main() \n"
7431 + "{ \n"
7432 + " gl_FragColor = texture2D( s_texture, v_texCoord );\n"
7433 + "} \n";
7434 +}
7435 +
7436 +static GLuint loadShader(GLenum shaderType, const char* pSource) {
7437 + GLuint shader = glCreateShader(shaderType);
7438 +
7439 + if (shader) {
7440 + glShaderSource(shader, 1, &pSource, NULL);
7441 + glCompileShader(shader);
7442 + GLint compiled = 0;
7443 + glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
7444 +
7445 + if (!compiled) {
7446 + GLint infoLen = 0;
7447 + glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &infoLen);
7448 + if (infoLen) {
7449 + char* buf = (char*) malloc(infoLen);
7450 + if (buf) {
7451 + glGetShaderInfoLog(shader, infoLen, NULL, buf);
7452 + fprintf(stderr, "Could not compile shader %d:\n%s\n",
7453 + shaderType, buf);
7454 + free(buf);
7455 + }
7456 + glDeleteShader(shader);
7457 + shader = 0;
7458 + }
7459 + }
7460 + } else {
7461 + printf("Error, during shader creation: %i\n", glGetError());
7462 + }
7463 +
7464 + return shader;
7465 +}
7466 +
7467 +static GLuint create_program(const char* pVertexSource, const char* pFragmentSource) {
7468 + GLuint vertexShader = loadShader(GL_VERTEX_SHADER, pVertexSource);
7469 + if (!vertexShader) {
7470 + printf("vertex shader not compiled\n");
7471 + return 0;
7472 + }
7473 +
7474 + GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, pFragmentSource);
7475 + if (!pixelShader) {
7476 + printf("frag shader not compiled\n");
7477 + return 0;
7478 + }
7479 +
7480 + GLuint program = glCreateProgram();
7481 + if (program) {
7482 + glAttachShader(program, vertexShader);
7483 + glAttachShader(program, pixelShader);
7484 + glLinkProgram(program);
7485 + GLint linkStatus = GL_FALSE;
7486 +
7487 + glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
7488 + if (linkStatus != GL_TRUE) {
7489 + GLint bufLength = 0;
7490 + glGetProgramiv(program, GL_INFO_LOG_LENGTH, &bufLength);
7491 + if (bufLength) {
7492 + char* buf = (char*) malloc(bufLength);
7493 + if (buf) {
7494 + glGetProgramInfoLog(program, bufLength, NULL, buf);
7495 + fprintf(stderr, "Could not link program:\n%s\n", buf);
7496 + free(buf);
7497 + }
7498 + }
7499 + glDeleteProgram(program);
7500 + program = 0;
7501 + }
7502 + }
7503 +
7504 + return program;
7505 +}
7506 +
7507 +int main(int argc, char** argv)
7508 +{
7509 + printf("Test application for video recording using the camera\n");
7510 + printf("Recording start with volume up button. And stops with volume down.\n");
7511 + printf("The result is stored to /root/test_video.avi\n\n");
7512 +
7513 + struct CameraControlListener listener;
7514 + memset(&listener, 0, sizeof(listener));
7515 + listener.on_msg_error_cb = error_msg_cb;
7516 + listener.on_msg_shutter_cb = shutter_msg_cb;
7517 + listener.on_msg_focus_cb = autofocus_msg_cb;
7518 + listener.on_msg_zoom_cb = zoom_msg_cb;
7519 +
7520 + listener.on_data_raw_image_cb = raw_data_cb;
7521 + listener.on_data_compressed_image_cb = jpeg_data_cb;
7522 + listener.on_preview_texture_needs_update_cb = preview_texture_needs_update_cb;
7523 + struct CameraControl* cc = android_camera_connect_to(BACK_FACING_CAMERA_TYPE,
7524 + &listener);
7525 + if (cc == NULL) {
7526 + printf("Problem connecting to camera");
7527 + return 1;
7528 + }
7529 +
7530 + listener.context = cc;
7531 +
7532 + mr = android_media_new_recorder();
7533 +
7534 + struct AndroidEventListener event_listener;
7535 + event_listener.on_new_event = on_new_input_event;
7536 + event_listener.context = cc;
7537 +
7538 + struct InputStackConfiguration input_configuration = { false, 25000 };
7539 +
7540 + android_input_stack_initialize(&event_listener, &input_configuration);
7541 + android_input_stack_start();
7542 +
7543 + android_camera_dump_parameters(cc);
7544 +
7545 + printf("Supported video sizes:\n");
7546 + android_camera_enumerate_supported_video_sizes(cc, size_cb, NULL);
7547 +
7548 + int min_fps, max_fps, current_fps;
7549 +
7550 + android_camera_set_preview_size(cc, 1280, 720);
7551 +
7552 + int width, height;
7553 + android_camera_get_video_size(cc, &width, &height);
7554 + printf("Current video size: [%d,%d]\n", width, height);
7555 +
7556 + struct ClientWithSurface cs = client_with_surface(true /* Associate surface with egl. */);
7557 +
7558 + if (!cs.surface) {
7559 + printf("Problem acquiring surface for preview");
7560 + return 1;
7561 + }
7562 +
7563 + EGLDisplay disp = sf_client_get_egl_display(cs.client);
7564 + EGLSurface surface = sf_surface_get_egl_surface(cs.surface);
7565 +
7566 + sf_surface_make_current(cs.surface);
7567 +
7568 + gProgram = create_program(vertex_shader(), fragment_shader());
7569 + gaPositionHandle = glGetAttribLocation(gProgram, "a_position");
7570 + gaTexHandle = glGetAttribLocation(gProgram, "a_texCoord");
7571 + gsTextureHandle = glGetUniformLocation(gProgram, "s_texture");
7572 + gmTexMatrix = glGetUniformLocation(gProgram, "m_texMatrix");
7573 +
7574 + glGenTextures(1, &preview_texture_id);
7575 + glClearColor(1.0, 0., 0.5, 1.);
7576 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
7577 + glTexParameteri(GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
7578 + glTexParameteri(
7579 + GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
7580 + glTexParameteri(
7581 + GL_TEXTURE_EXTERNAL_OES, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
7582 + android_camera_set_preview_texture(cc, preview_texture_id);
7583 + android_camera_start_preview(cc);
7584 +
7585 + GLfloat transformation_matrix[16];
7586 + android_camera_get_preview_texture_transformation(cc, transformation_matrix);
7587 + glUniformMatrix4fv(gmTexMatrix, 1, GL_FALSE, transformation_matrix);
7588 +
7589 + printf("Started camera preview.\n");
7590 +
7591 + while (true) {
7592 + /*if (new_camera_frame_available)
7593 + {
7594 + printf("Updating texture");
7595 + new_camera_frame_available = false;
7596 + }*/
7597 + static GLfloat vVertices[] = { 0.0f, 0.0f, 0.0f, // Position 0
7598 + 0.0f, 0.0f, // TexCoord 0
7599 + 0.0f, 1.0f, 0.0f, // Position 1
7600 + 0.0f, 1.0f, // TexCoord 1
7601 + 1.0f, 1.0f, 0.0f, // Position 2
7602 + 1.0f, 1.0f, // TexCoord 2
7603 + 1.0f, 0.0f, 0.0f, // Position 3
7604 + 1.0f, 0.0f // TexCoord 3
7605 + };
7606 +
7607 + GLushort indices[] = { 0, 1, 2, 0, 2, 3 };
7608 +
7609 + // Set the viewport
7610 + // Clear the color buffer
7611 + glClear(GL_COLOR_BUFFER_BIT);
7612 + // Use the program object
7613 + glUseProgram(gProgram);
7614 + // Enable attributes
7615 + glEnableVertexAttribArray(gaPositionHandle);
7616 + glEnableVertexAttribArray(gaTexHandle);
7617 + // Load the vertex position
7618 + glVertexAttribPointer(gaPositionHandle,
7619 + 3,
7620 + GL_FLOAT,
7621 + GL_FALSE,
7622 + 5 * sizeof(GLfloat),
7623 + vVertices);
7624 + // Load the texture coordinate
7625 + glVertexAttribPointer(gaTexHandle,
7626 + 2,
7627 + GL_FLOAT,
7628 + GL_FALSE,
7629 + 5 * sizeof(GLfloat),
7630 + vVertices+3);
7631 +
7632 + glActiveTexture(GL_TEXTURE0);
7633 + // Set the sampler texture unit to 0
7634 + glUniform1i(gsTextureHandle, 0);
7635 + glUniform1i(gmTexMatrix, 0);
7636 + android_camera_update_preview_texture(cc);
7637 + glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_SHORT, indices);
7638 + glDisableVertexAttribArray(gaPositionHandle);
7639 + glDisableVertexAttribArray(gaTexHandle);
7640 +
7641 + eglSwapBuffers(disp, surface);
7642 + }
7643 +}
7644 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/tests/test_ui.c
7645 +++ libhybris-0.1.0+git20131207+e452e83/hybris/tests/test_ui.c
7646 @@ -52,8 +52,10 @@ int main(int argc, char **argv)
7647 graphic_buffer_lock(buffer, GRALLOC_USAGE_HW_RENDER, &vaddr);
7648 graphic_buffer_unlock(buffer);
7649
7650 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
7651 graphic_buffer_set_index(buffer, 11);
7652 assert(graphic_buffer_get_index(buffer) == 11);
7653 +#endif
7654
7655 graphic_buffer_free(buffer);
7656
7657 --- libhybris-0.1.0+git20131207+e452e83.orig/hybris/ui/ui.c
7658 +++ libhybris-0.1.0+git20131207+e452e83/hybris/ui/ui.c
7659 @@ -48,9 +48,11 @@ HYBRIS_IMPLEMENT_FUNCTION1(ui, uint32_t,
7660 struct graphic_buffer*);
7661 HYBRIS_IMPLEMENT_FUNCTION1(ui, void*, graphic_buffer_get_native_buffer,
7662 struct graphic_buffer*);
7663 +#if ANDROID_VERSION_MAJOR==4 && ANDROID_VERSION_MINOR<=3
7664 HYBRIS_IMPLEMENT_VOID_FUNCTION2(ui, graphic_buffer_set_index,
7665 struct graphic_buffer*, int);
7666 HYBRIS_IMPLEMENT_FUNCTION1(ui, int, graphic_buffer_get_index,
7667 struct graphic_buffer*);
7668 +#endif
7669 HYBRIS_IMPLEMENT_FUNCTION1(ui, int, graphic_buffer_init_check,
7670 struct graphic_buffer*);
libhybris Piment Noir Debian package repository