1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 #ifndef __COMMON_HOST_CONNECTION_H 17 #define __COMMON_HOST_CONNECTION_H 18 19 #include "IOStream.h" 20 #include "renderControl_enc.h" 21 #include "ChecksumCalculator.h" 22 23 #include <string> 24 25 class GLEncoder; 26 struct gl_client_context_t; 27 class GL2Encoder; 28 struct gl2_client_context_t; 29 30 // SyncImpl determines the presence of host/guest OpenGL fence sync 31 // capabilities. It corresponds exactly to EGL_ANDROID_native_fence_sync 32 // capability, but for the emulator, we need to make sure that 33 // OpenGL pipe protocols match, so we use a special extension name 34 // here. 35 // SYNC_IMPL_NONE means that the native fence sync capability is 36 // not present, and we will end up using the equivalent of glFinish 37 // in order to preserve buffer swapping order. 38 // SYNC_IMPL_NATIVE_SYNC means that we do have native fence sync 39 // capability, and we will use a fence fd to synchronize buffer swaps. 40 enum SyncImpl { 41 SYNC_IMPL_NONE = 0, 42 SYNC_IMPL_NATIVE_SYNC = 1 43 }; 44 // Interface: 45 // If this GL extension string shows up, we use 46 // SYNC_IMPL_NATIVE_SYNC, otherwise we use SYNC_IMPL_NONE. 47 // This string is always updated to require the _latest_ 48 // version of Android emulator native sync in this system image; 49 // otherwise, we do not use the feature. 50 static const char kRCNativeSync[] = "ANDROID_EMU_native_sync_v2"; 51 52 // ExtendedRCEncoderContext is an extended version of renderControl_encoder_context_t 53 // that will be used to track SyncImpl. 54 class ExtendedRCEncoderContext : public renderControl_encoder_context_t { 55 public: 56 ExtendedRCEncoderContext(IOStream *stream, ChecksumCalculator *checksumCalculator) 57 : renderControl_encoder_context_t(stream, checksumCalculator) { } 58 void setSyncImpl(SyncImpl syncImpl) { m_syncImpl = syncImpl; } 59 bool hasNativeSync() const { return m_syncImpl == SYNC_IMPL_NATIVE_SYNC; } 60 private: 61 SyncImpl m_syncImpl; 62 }; 63 64 class HostConnection 65 { 66 public: 67 static HostConnection *get(); 68 static void exit(); 69 ~HostConnection(); 70 71 GLEncoder *glEncoder(); 72 GL2Encoder *gl2Encoder(); 73 ExtendedRCEncoderContext *rcEncoder(); 74 ChecksumCalculator *checksumHelper() { return &m_checksumHelper; } 75 76 void flush() { 77 if (m_stream) { 78 m_stream->flush(); 79 } 80 } 81 82 void setGrallocOnly(bool gralloc_only) { 83 m_grallocOnly = gralloc_only; 84 } 85 86 bool isGrallocOnly() const { return m_grallocOnly; } 87 88 private: 89 HostConnection(); 90 static gl_client_context_t *s_getGLContext(); 91 static gl2_client_context_t *s_getGL2Context(); 92 93 std::string queryGLExtensions(ExtendedRCEncoderContext *rcEnc); 94 // setProtocol initilizes GL communication protocol for checksums 95 // should be called when m_rcEnc is created 96 void setChecksumHelper(ExtendedRCEncoderContext *rcEnc); 97 void queryAndSetSyncImpl(ExtendedRCEncoderContext *rcEnc); 98 99 private: 100 IOStream *m_stream; 101 GLEncoder *m_glEnc; 102 GL2Encoder *m_gl2Enc; 103 ExtendedRCEncoderContext *m_rcEnc; 104 ChecksumCalculator m_checksumHelper; 105 std::string m_glExtensions; 106 bool m_grallocOnly; 107 }; 108 109 #endif 110