| /* |
| * Copyright (c) 2011 The WebRTC project authors. All Rights Reserved. |
| * |
| * Use of this source code is governed by a BSD-style license |
| * that can be found in the LICENSE file in the root of the source |
| * tree. An additional intellectual property rights grant can be found |
| * in the file PATENTS. All contributing project authors may |
| * be found in the AUTHORS file in the root of the source tree. |
| */ |
| |
| #include "video_render_android_surface_view.h" |
| #include "critical_section_wrapper.h" |
| #include "common_video/libyuv/include/libyuv.h" |
| #include "tick_util.h" |
| #ifdef ANDROID_NDK_8_OR_ABOVE |
| #include <android/bitmap.h> |
| #endif |
| |
| |
| #ifdef ANDROID_LOG |
| #include <stdio.h> |
| #include <android/log.h> |
| |
| #undef WEBRTC_TRACE |
| #define WEBRTC_TRACE(a,b,c,...) __android_log_print(ANDROID_LOG_DEBUG, "*WEBRTC*", __VA_ARGS__) |
| #else |
| #include "trace.h" |
| #endif |
| |
| namespace webrtc { |
| |
| AndroidSurfaceViewRenderer::AndroidSurfaceViewRenderer(const WebRtc_Word32 id, |
| const VideoRenderType videoRenderType, |
| void* window, |
| const bool fullscreen) |
| : |
| VideoRenderAndroid(id,videoRenderType,window,fullscreen), |
| _javaRenderObj(NULL), |
| _javaRenderClass(NULL) |
| { |
| } |
| |
| AndroidSurfaceViewRenderer::~AndroidSurfaceViewRenderer() |
| { |
| WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "AndroidSurfaceViewRenderer dtor"); |
| if(g_jvm) |
| { |
| // get the JNI env for this thread |
| bool isAttached = false; |
| JNIEnv* env = NULL; |
| if (g_jvm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) |
| { |
| // try to attach the thread and get the env |
| // Attach this thread to JVM |
| jint res = g_jvm->AttachCurrentThread(&env, NULL); |
| |
| // Get the JNI env for this thread |
| if ((res < 0) || !env) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Could not attach thread to JVM (%d, %p)", __FUNCTION__, res, env); |
| env=NULL; |
| } |
| else |
| { |
| isAttached = true; |
| } |
| } |
| env->DeleteGlobalRef(_javaRenderObj); |
| env->DeleteGlobalRef(_javaRenderClass); |
| |
| if (isAttached) |
| { |
| if (g_jvm->DetachCurrentThread() < 0) |
| { |
| WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, _id, "%s: Could not detach thread from JVM", __FUNCTION__); |
| } |
| } |
| } |
| } |
| |
| |
| WebRtc_Word32 |
| AndroidSurfaceViewRenderer::Init() |
| { |
| WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s", __FUNCTION__); |
| if (!g_jvm) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "(%s): Not a valid Java VM pointer.", __FUNCTION__); |
| return -1; |
| } |
| if(!_ptrWindow) |
| { |
| WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, _id, "(%s): No window have been provided.", __FUNCTION__); |
| return -1; |
| } |
| |
| // get the JNI env for this thread |
| bool isAttached = false; |
| JNIEnv* env = NULL; |
| if (g_jvm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) |
| { |
| // try to attach the thread and get the env |
| // Attach this thread to JVM |
| jint res = g_jvm->AttachCurrentThread(&env, NULL); |
| |
| // Get the JNI env for this thread |
| if ((res < 0) || !env) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Could not attach thread to JVM (%d, %p)", __FUNCTION__, res, env); |
| return -1; |
| } |
| isAttached = true; |
| } |
| |
| // get the ViESurfaceRender class |
| jclass javaRenderClassLocal = env->FindClass("org/webrtc/videoengine/ViESurfaceRenderer"); |
| if (!javaRenderClassLocal) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not find ViESurfaceRenderer", __FUNCTION__); |
| return -1; |
| } |
| |
| // create a global reference to the class (to tell JNI that we are referencing it after this function has returned) |
| _javaRenderClass = reinterpret_cast<jclass>(env->NewGlobalRef(javaRenderClassLocal)); |
| if (!_javaRenderClass) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not create Java ViESurfaceRenderer class reference", __FUNCTION__); |
| return -1; |
| } |
| |
| // Delete local class ref, we only use the global ref |
| env->DeleteLocalRef(javaRenderClassLocal); |
| |
| // get the method ID for the constructor |
| jmethodID cid = env->GetMethodID(_javaRenderClass, "<init>", "(Landroid/view/SurfaceView;)V"); |
| if (cid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get constructor ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| |
| // construct the object |
| jobject javaRenderObjLocal = env->NewObject(_javaRenderClass, cid, _ptrWindow); |
| if (!javaRenderObjLocal) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not create Java Render", __FUNCTION__); |
| return -1; |
| } |
| |
| // create a reference to the object (to tell JNI that we are referencing it |
| // after this function has returned) |
| _javaRenderObj = env->NewGlobalRef(javaRenderObjLocal); |
| if (!_javaRenderObj) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not create Java SurfaceRender object reference", __FUNCTION__); |
| return -1; |
| } |
| |
| // Detach this thread if it was attached |
| if (isAttached) |
| { |
| if (g_jvm->DetachCurrentThread() < 0) |
| { |
| WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, _id, "%s: Could not detach thread from JVM", __FUNCTION__); |
| } |
| } |
| |
| WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s done", __FUNCTION__); |
| return 0; |
| |
| } |
| AndroidStream* |
| AndroidSurfaceViewRenderer::CreateAndroidRenderChannel(WebRtc_Word32 streamId, |
| WebRtc_Word32 zOrder, |
| const float left, |
| const float top, |
| const float right, |
| const float bottom, |
| VideoRenderAndroid& renderer) |
| { |
| WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s: Id %d", __FUNCTION__,streamId); |
| AndroidSurfaceViewChannel* stream=new AndroidSurfaceViewChannel(streamId,g_jvm,renderer,_javaRenderObj); |
| if(stream && stream->Init(zOrder,left,top,right,bottom)==0) |
| return stream; |
| else |
| delete stream; |
| return NULL; |
| } |
| |
| |
| |
| |
| |
| |
| AndroidSurfaceViewChannel::AndroidSurfaceViewChannel(WebRtc_UWord32 streamId,JavaVM* jvm,VideoRenderAndroid& renderer,jobject javaRenderObj) |
| : |
| _id(streamId), |
| _renderCritSect(*CriticalSectionWrapper::CreateCriticalSection()), |
| _renderer(renderer), |
| _jvm(jvm), |
| _javaRenderObj(javaRenderObj), |
| _bitmapWidth(0), |
| _bitmapHeight(0) |
| { |
| |
| } |
| AndroidSurfaceViewChannel::~AndroidSurfaceViewChannel() |
| { |
| WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "AndroidSurfaceViewChannel dtor"); |
| delete &_renderCritSect; |
| if(_jvm) |
| { |
| // get the JNI env for this thread |
| bool isAttached = false; |
| JNIEnv* env = NULL; |
| if (_jvm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) |
| { |
| // try to attach the thread and get the env |
| // Attach this thread to JVM |
| jint res = _jvm->AttachCurrentThread(&env, NULL); |
| |
| // Get the JNI env for this thread |
| if ((res < 0) || !env) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Could not attach thread to JVM (%d, %p)", __FUNCTION__, res, env); |
| env=NULL; |
| } |
| else |
| { |
| isAttached = true; |
| } |
| } |
| |
| #ifdef ANDROID_NDK_8_OR_ABOVE |
| env->DeleteGlobalRef(_javaBitmapObj); |
| #else |
| env->DeleteGlobalRef(_javaByteBufferObj); |
| #endif |
| if (isAttached) |
| { |
| if (_jvm->DetachCurrentThread() < 0) |
| { |
| WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, _id, "%s: Could not detach thread from JVM", __FUNCTION__); |
| } |
| } |
| } |
| } |
| |
| WebRtc_Word32 |
| AndroidSurfaceViewChannel::Init(WebRtc_Word32 /*zOrder*/, |
| const float left, |
| const float top, |
| const float right, |
| const float bottom) |
| { |
| |
| WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s: AndroidSurfaceViewChannel", __FUNCTION__); |
| if (!_jvm) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer,_id, "%s: Not a valid Java VM pointer", __FUNCTION__); |
| return -1; |
| } |
| |
| if((top>1 || top<0) || (right>1 || right<0) || (bottom>1 || bottom<0) || (left>1 || left<0)) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Wrong coordinates", |
| __FUNCTION__); |
| return -1; |
| } |
| |
| |
| // get the JNI env for this thread |
| bool isAttached = false; |
| JNIEnv* env = NULL; |
| if (_jvm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) |
| { |
| // try to attach the thread and get the env |
| // Attach this thread to JVM |
| jint res = _jvm->AttachCurrentThread(&env, NULL); |
| |
| // Get the JNI env for this thread |
| if ((res < 0) || !env) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Could not attach thread to JVM (%d, %p)", __FUNCTION__, res, env); |
| return -1; |
| } |
| isAttached = true; |
| } |
| |
| jclass javaRenderClass = env->FindClass("org/webrtc/videoengine/ViESurfaceRenderer"); |
| if (!javaRenderClass) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not find ViESurfaceRenderer", __FUNCTION__); |
| return -1; |
| } |
| #ifdef ANDROID_NDK_8_OR_ABOVE |
| // get the method ID for the CreateBitmap |
| _createBitmapCid = env->GetMethodID(_javaRenderClass, "CreateBitmap", "(II)Landroid/graphics/Bitmap;"); |
| if (_createBitmapCid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get CreateBitmap ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| // get the method ID for the DrawBitmap function |
| _drawBitmapCid = env->GetMethodID(_javaRenderClass, "DrawBitmap", "()V"); |
| if (_drawBitmapCid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get DrawBitmap ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| #else |
| // get the method ID for the CreateIntArray |
| _createByteBufferCid = env->GetMethodID(javaRenderClass, "CreateByteBuffer", "(II)Ljava/nio/ByteBuffer;"); |
| if (_createByteBufferCid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get CreateByteBuffer ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| |
| // get the method ID for the DrawByteBuffer function |
| _drawByteBufferCid = env->GetMethodID(javaRenderClass, "DrawByteBuffer", "()V"); |
| if (_drawByteBufferCid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get DrawByteBuffer ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| #endif |
| |
| // get the method ID for the SetCoordinates function |
| _setCoordinatesCid = env->GetMethodID(javaRenderClass, "SetCoordinates", "(FFFF)V"); |
| if (_setCoordinatesCid == NULL) |
| { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not get SetCoordinates ID", __FUNCTION__); |
| return -1; /* exception thrown */ |
| } |
| |
| env->CallVoidMethod(_javaRenderObj,_setCoordinatesCid,left,top,right,bottom); |
| |
| // Detach this thread if it was attached |
| if (isAttached) |
| { |
| if (_jvm->DetachCurrentThread() < 0) |
| { |
| WEBRTC_TRACE(kTraceWarning, kTraceVideoRenderer, _id, "%s: Could not detach thread from JVM", __FUNCTION__); |
| } |
| } |
| |
| |
| WEBRTC_TRACE(kTraceDebug, kTraceVideoRenderer, _id, "%s: AndroidSurfaceViewChannel done", __FUNCTION__); |
| return 0; |
| } |
| |
| |
| WebRtc_Word32 AndroidSurfaceViewChannel::RenderFrame(const WebRtc_UWord32 /*streamId*/, VideoFrame& videoFrame) |
| { |
| // WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer,_id, "%s:" ,__FUNCTION__); |
| _renderCritSect.Enter(); |
| _bufferToRender.SwapFrame(videoFrame); |
| _renderCritSect.Leave(); |
| _renderer.ReDraw(); |
| return 0; |
| } |
| |
| |
| /*Implements AndroidStream |
| * Calls the Java object and render the buffer in _bufferToRender |
| */ |
| void AndroidSurfaceViewChannel::DeliverFrame(JNIEnv* jniEnv) { |
| _renderCritSect.Enter(); |
| |
| #ifdef ANDROID_NDK_8_OR_ABOVE |
| if (_bitmapWidth != _bufferToRender.Width() || |
| _bitmapHeight != _bufferToRender.Height()) { |
| // Create the bitmap to write to |
| WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "%s: Creating bitmap %u " |
| "%u", __FUNCTION__, _bufferToRender.Width(), |
| _bufferToRender.Height()); |
| if (_javaBitmapObj) { |
| jniEnv->DeleteGlobalRef(_javaBitmapObj); |
| _javaBitmapObj = NULL; |
| } |
| jobject javaBitmap = jniEnv->CallObjectMethod(_javaRenderObj, |
| _createBitmapCid, |
| videoFrame.Width(), |
| videoFrame.Height()); |
| _javaBitmapObj = jniEnv->NewGlobalRef(javaBitmap); |
| if (!_javaBitmapObj) { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not " |
| "create Java Bitmap object reference", __FUNCTION__); |
| _renderCritSect.Leave(); |
| return; |
| } else { |
| _bitmapWidth=_bufferToRender.Width(); |
| _bitmapHeight=_bufferToRender.Height(); |
| } |
| } |
| void* pixels; |
| if (_javaBitmapObj && |
| AndroidBitmap_lockPixels(jniEnv, _javaBitmapObj, &pixels) >= 0) { |
| WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "%s: Locked bitmap", |
| __FUNCTION__); |
| // Convert I420 straight into the Java bitmap. |
| int ret = ConvertI420ToRGB565((unsigned char* )_bufferToRender.Buffer(), |
| (unsigned char* ) pixels, |
| _bitmapWidth, _bitmapHeight); |
| if (ret < 0) { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Color conversion " |
| "failed.", __FUNCTION__); |
| } |
| |
| AndroidBitmap_unlockPixels(jniEnv, _javaBitmapObj); |
| // Draw the Surface. |
| jniEnv->CallVoidMethod(_javaRenderObj,_drawCid); |
| |
| } else { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Could not lock " |
| "bitmap", __FUNCTION__); |
| } |
| _renderCritSect.Leave(); |
| |
| #else |
| if (_bitmapWidth != _bufferToRender.Width() || |
| _bitmapHeight != _bufferToRender.Height()) { |
| WEBRTC_TRACE(kTraceInfo, kTraceVideoRenderer, _id, "%s: New render size %d " |
| "%d",__FUNCTION__, |
| _bufferToRender.Width(), _bufferToRender.Height()); |
| if (_javaByteBufferObj) { |
| jniEnv->DeleteGlobalRef(_javaByteBufferObj); |
| _javaByteBufferObj = NULL; |
| _directBuffer = NULL; |
| } |
| jobject javaByteBufferObj = |
| jniEnv->CallObjectMethod(_javaRenderObj, _createByteBufferCid, |
| _bufferToRender.Width(), |
| _bufferToRender.Height()); |
| _javaByteBufferObj = jniEnv->NewGlobalRef(javaByteBufferObj); |
| if (!_javaByteBufferObj) { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: could not " |
| "create Java ByteBuffer object reference", __FUNCTION__); |
| _renderCritSect.Leave(); |
| return; |
| } else { |
| _directBuffer = static_cast<unsigned char*> |
| (jniEnv->GetDirectBufferAddress(_javaByteBufferObj)); |
| _bitmapWidth = _bufferToRender.Width(); |
| _bitmapHeight = _bufferToRender.Height(); |
| } |
| } |
| |
| if(_javaByteBufferObj && _bitmapWidth && _bitmapHeight) { |
| // Android requires a vertically flipped image compared to std convert. |
| // This is done by giving a negative height input. |
| const int conversionResult = |
| ConvertI420ToRGB565((unsigned char* )_bufferToRender.Buffer(), |
| _directBuffer, _bitmapWidth, -_bitmapHeight); |
| if (conversionResult < 0) { |
| WEBRTC_TRACE(kTraceError, kTraceVideoRenderer, _id, "%s: Color conversion" |
| " failed.", __FUNCTION__); |
| _renderCritSect.Leave(); |
| return; |
| } |
| } |
| _renderCritSect.Leave(); |
| // Draw the Surface |
| jniEnv->CallVoidMethod(_javaRenderObj, _drawByteBufferCid); |
| #endif |
| } |
| |
| } // namespace webrtc |
| |
