android2.0源码下视频无法播放的解决办法

用下列文件替换掉系统中的，之后进行编译即可。

 

frameworks/base/libs/surfaceflinger/LayerBuffer.cpp

/* * Copyright (C) 2007 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */#include <stdlib.h>#include <stdint.h>#include <math.h>#include <sys/types.h>#include <utils/Errors.h>#include <utils/Log.h>#include <utils/StopWatch.h>#include <ui/GraphicBuffer.h>#include <ui/PixelFormat.h>#include <ui/FramebufferNativeWindow.h>#include <hardware/copybit.h>#include "LayerBuffer.h"#include "SurfaceFlinger.h"#include "DisplayHardware/DisplayHardware.h"namespace android {// ---------------------------------------------------------------------------const uint32_t LayerBuffer::typeInfo = LayerBaseClient::typeInfo | 0x20;const char* const LayerBuffer::typeID = "LayerBuffer";gralloc_module_t const* LayerBuffer::sGrallocModule = 0;// ---------------------------------------------------------------------------LayerBuffer::LayerBuffer(SurfaceFlinger* flinger, DisplayID display, const sp<Client>& client, int32_t i) : LayerBaseClient(flinger, display, client, i), mNeedsBlending(false){}LayerBuffer::~LayerBuffer(){}void LayerBuffer::onFirstRef(){ LayerBaseClient::onFirstRef(); mSurface = new SurfaceLayerBuffer(mFlinger, clientIndex(), const_cast<LayerBuffer *>(this)); hw_module_t const* module = (hw_module_t const*)sGrallocModule; if (!module) { // NOTE: technically there is a race here, but it shouldn't // cause any problem since hw_get_module() always returns // the same value. if (hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &module) == 0) { sGrallocModule = (gralloc_module_t const *)module; } }}sp<LayerBaseClient::Surface> LayerBuffer::createSurface() const{ return mSurface;}status_t LayerBuffer::ditch(){ mSurface.clear(); return NO_ERROR;}bool LayerBuffer::needsBlending() const { return mNeedsBlending;}void LayerBuffer::setNeedsBlending(bool blending) { mNeedsBlending = blending;}void LayerBuffer::postBuffer(ssize_t offset){ sp<Source> source(getSource()); if (source != 0) source->postBuffer(offset);}void LayerBuffer::unregisterBuffers(){ sp<Source> source(clearSource()); if (source != 0) source->unregisterBuffers();}uint32_t LayerBuffer::doTransaction(uint32_t flags){ sp<Source> source(getSource()); if (source != 0) source->onTransaction(flags); return LayerBase::doTransaction(flags); }void LayerBuffer::unlockPageFlip(const Transform& planeTransform, Region& outDirtyRegion){ // this code-path must be as tight as possible, it's called each time // the screen is composited. sp<Source> source(getSource()); if (source != 0) source->onVisibilityResolved(planeTransform); LayerBase::unlockPageFlip(planeTransform, outDirtyRegion); }void LayerBuffer::onDraw(const Region& clip) const{ sp<Source> source(getSource()); if (LIKELY(source != 0)) { source->onDraw(clip); } else { clearWithOpenGL(clip); }}bool LayerBuffer::transformed() const{ sp<Source> source(getSource()); if (LIKELY(source != 0)) return source->transformed(); return false;}void LayerBuffer::serverDestroy(){ sp<Source> source(clearSource()); if (source != 0) { source->destroy(); }}/** * This creates a "buffer" source for this surface */status_t LayerBuffer::registerBuffers(const ISurface::BufferHeap& buffers){ Mutex::Autolock _l(mLock); if (mSource != 0) return INVALID_OPERATION; sp<BufferSource> source = new BufferSource(*this, buffers); status_t result = source->getStatus(); if (result == NO_ERROR) { mSource = source; } return result;} /** * This creates an "overlay" source for this surface */sp<OverlayRef> LayerBuffer::createOverlay(uint32_t w, uint32_t h, int32_t f){ sp<OverlayRef> result; Mutex::Autolock _l(mLock); if (mSource != 0) return result; sp<OverlaySource> source = new OverlaySource(*this, &result, w, h, f); if (result != 0) { mSource = source; } return result;}sp<LayerBuffer::Source> LayerBuffer::getSource() const { Mutex::Autolock _l(mLock); return mSource;}sp<LayerBuffer::Source> LayerBuffer::clearSource() { sp<Source> source; Mutex::Autolock _l(mLock); source = mSource; mSource.clear(); return source;}// ============================================================================// LayerBuffer::SurfaceLayerBuffer// ============================================================================LayerBuffer::SurfaceLayerBuffer::SurfaceLayerBuffer(const sp<SurfaceFlinger>& flinger, SurfaceID id, const sp<LayerBuffer>& owner) : LayerBaseClient::Surface(flinger, id, owner->getIdentity(), owner){}LayerBuffer::SurfaceLayerBuffer::~SurfaceLayerBuffer(){ unregisterBuffers();}status_t LayerBuffer::SurfaceLayerBuffer::registerBuffers( const ISurface::BufferHeap& buffers){ sp<LayerBuffer> owner(getOwner()); if (owner != 0) return owner->registerBuffers(buffers); return NO_INIT;}void LayerBuffer::SurfaceLayerBuffer::postBuffer(ssize_t offset){ sp<LayerBuffer> owner(getOwner()); if (owner != 0) owner->postBuffer(offset);}void LayerBuffer::SurfaceLayerBuffer::unregisterBuffers(){ sp<LayerBuffer> owner(getOwner()); if (owner != 0) owner->unregisterBuffers();}sp<OverlayRef> LayerBuffer::SurfaceLayerBuffer::createOverlay( uint32_t w, uint32_t h, int32_t format) { sp<OverlayRef> result; sp<LayerBuffer> owner(getOwner()); if (owner != 0) result = owner->createOverlay(w, h, format); return result;}// ============================================================================// LayerBuffer::Buffer// ============================================================================LayerBuffer::Buffer::Buffer(const ISurface::BufferHeap& buffers, ssize_t offset) : mBufferHeap(buffers){ NativeBuffer& src(mNativeBuffer); src.img.handle = 0; gralloc_module_t const * module = LayerBuffer::getGrallocModule(); if (module) { if (module->perform) { int err = module->perform(module, GRALLOC_MODULE_PERFORM_CREATE_HANDLE_FROM_BUFFER, buffers.heap->heapID(), buffers.heap->getSize(), offset, buffers.heap->base(), &src.img.handle); if (err != NO_ERROR) return; } src.crop.l = 0; src.crop.t = 0; src.crop.r = buffers.w; src.crop.b = buffers.h; src.img.w = buffers.hor_stride ?: buffers.w; src.img.h = buffers.ver_stride ?: buffers.h; src.img.format = buffers.format; src.img.base = (void*)(intptr_t(buffers.heap->base()) + offset); }}LayerBuffer::Buffer::~Buffer(){ NativeBuffer& src(mNativeBuffer); if (src.img.handle) { native_handle_delete(src.img.handle); }}// ============================================================================// LayerBuffer::Source// LayerBuffer::BufferSource// LayerBuffer::OverlaySource// ============================================================================LayerBuffer::Source::Source(LayerBuffer& layer) : mLayer(layer){ }LayerBuffer::Source::~Source() { }void LayerBuffer::Source::onDraw(const Region& clip) const {}void LayerBuffer::Source::onTransaction(uint32_t flags) {}void LayerBuffer::Source::onVisibilityResolved( const Transform& planeTransform) {}void LayerBuffer::Source::postBuffer(ssize_t offset) {}void LayerBuffer::Source::unregisterBuffers() {}bool LayerBuffer::Source::transformed() const { return mLayer.mTransformed; }// ---------------------------------------------------------------------------LayerBuffer::BufferSource::BufferSource(LayerBuffer& layer, const ISurface::BufferHeap& buffers) : Source(layer), mStatus(NO_ERROR), mBufferSize(0){ if (buffers.heap == NULL) { // this is allowed, but in this case, it is illegal to receive // postBuffer(). The surface just erases the framebuffer with // fully transparent pixels. mBufferHeap = buffers; mLayer.setNeedsBlending(false); return; } status_t err = (buffers.heap->heapID() >= 0) ? NO_ERROR : NO_INIT; if (err != NO_ERROR) { LOGE("LayerBuffer::BufferSource: invalid heap (%s)", strerror(err)); mStatus = err; return; } PixelFormatInfo info; err = getPixelFormatInfo(buffers.format, &info); if (err != NO_ERROR) { LOGE("LayerBuffer::BufferSource: invalid format %d (%s)", buffers.format, strerror(err)); mStatus = err; return; } if (buffers.hor_stride<0 || buffers.ver_stride<0) { LOGE("LayerBuffer::BufferSource: invalid parameters " "(w=%d, h=%d, xs=%d, ys=%d)", buffers.w, buffers.h, buffers.hor_stride, buffers.ver_stride); mStatus = BAD_VALUE; return; } mBufferHeap = buffers; mLayer.setNeedsBlending((info.h_alpha - info.l_alpha) > 0); mBufferSize = info.getScanlineSize(buffers.hor_stride)*buffers.ver_stride; mLayer.forceVisibilityTransaction();}LayerBuffer::BufferSource::~BufferSource(){ if (mTexture.name != -1U) { glDeleteTextures(1, &mTexture.name); } if (mTexture.image != EGL_NO_IMAGE_KHR) { EGLDisplay dpy(mLayer.mFlinger->graphicPlane(0).getEGLDisplay()); eglDestroyImageKHR(dpy, mTexture.image); }}void LayerBuffer::BufferSource::postBuffer(ssize_t offset){ ISurface::BufferHeap buffers; { // scope for the lock Mutex::Autolock _l(mBufferSourceLock); buffers = mBufferHeap; if (buffers.heap != 0) { const size_t memorySize = buffers.heap->getSize(); if ((size_t(offset) + mBufferSize) > memorySize) { LOGE("LayerBuffer::BufferSource::postBuffer() " "invalid buffer (offset=%d, size=%d, heap-size=%d", int(offset), int(mBufferSize), int(memorySize)); return; } } } sp<Buffer> buffer; if (buffers.heap != 0) { buffer = new LayerBuffer::Buffer(buffers, offset); if (buffer->getStatus() != NO_ERROR) buffer.clear(); setBuffer(buffer); mLayer.invalidate(); }}void LayerBuffer::BufferSource::unregisterBuffers(){ Mutex::Autolock _l(mBufferSourceLock); mBufferHeap.heap.clear(); mBuffer.clear(); mLayer.invalidate();}sp<LayerBuffer::Buffer> LayerBuffer::BufferSource::getBuffer() const{ Mutex::Autolock _l(mBufferSourceLock); return mBuffer;}void LayerBuffer::BufferSource::setBuffer(const sp<LayerBuffer::Buffer>& buffer){ Mutex::Autolock _l(mBufferSourceLock); mBuffer = buffer;}bool LayerBuffer::BufferSource::transformed() const{ return mBufferHeap.transform ? true : Source::transformed(); }void LayerBuffer::BufferSource::onDraw(const Region& clip) const { sp<Buffer> ourBuffer(getBuffer()); if (UNLIKELY(ourBuffer == 0)) { // nothing to do, we don't have a buffer mLayer.clearWithOpenGL(clip); return; } status_t err = NO_ERROR; NativeBuffer src(ourBuffer->getBuffer()); const Rect transformedBounds(mLayer.getTransformedBounds()); if (UNLIKELY(mTexture.name == -1LU)) { mTexture.name = mLayer.createTexture(); }#if defined(EGL_ANDROID_image_native_buffer) if (mLayer.mFlags & DisplayHardware::DIRECT_TEXTURE) { // NOTE: Assume the buffer is allocated with the proper USAGE flags sp<GraphicBuffer> graphicBuffer = new GraphicBuffer( src.crop.r, src.crop.b, src.img.format, GraphicBuffer::USAGE_HW_TEXTURE, src.img.w, src.img.handle, false); graphicBuffer->setVerticalStride(src.img.h); err = mLayer.initializeEglImage(graphicBuffer, &mTexture); }#endif else { err = INVALID_OPERATION; } if (err != NO_ERROR) { // slower fallback GGLSurface t; t.version = sizeof(GGLSurface); t.width = src.crop.r; t.height = src.crop.b; t.stride = src.img.w; t.vstride= src.img.h; t.format = src.img.format; t.data = (GGLubyte*)src.img.base; const Region dirty(Rect(t.width, t.height)); mLayer.loadTexture(&mTexture, dirty, t); } mTexture.transform = mBufferHeap.transform; mLayer.drawWithOpenGL(clip, mTexture);}// ---------------------------------------------------------------------------LayerBuffer::OverlaySource::OverlaySource(LayerBuffer& layer, sp<OverlayRef>* overlayRef, uint32_t w, uint32_t h, int32_t format) : Source(layer), mVisibilityChanged(false), mOverlay(0), mOverlayHandle(0), mOverlayDevice(0){ overlay_control_device_t* overlay_dev = mLayer.mFlinger->getOverlayEngine(); if (overlay_dev == NULL) { // overlays not supported return; } mOverlayDevice = overlay_dev; overlay_t* overlay = overlay_dev->createOverlay(overlay_dev, w, h, format); if (overlay == NULL) { // couldn't create the overlay (no memory? no more overlays?) return; } // enable dithering... overlay_dev->setParameter(overlay_dev, overlay, OVERLAY_DITHER, OVERLAY_ENABLE); mOverlay = overlay; mWidth = overlay->w; mHeight = overlay->h; mFormat = overlay->format; mWidthStride = overlay->w_stride; mHeightStride = overlay->h_stride; mInitialized = false; mOverlayHandle = overlay->getHandleRef(overlay); sp<OverlayChannel> channel = new OverlayChannel( &layer ); *overlayRef = new OverlayRef(mOverlayHandle, channel, mWidth, mHeight, mFormat, mWidthStride, mHeightStride); mLayer.mFlinger->signalEvent();}LayerBuffer::OverlaySource::~OverlaySource(){ if (mOverlay && mOverlayDevice) { overlay_control_device_t* overlay_dev = mOverlayDevice; overlay_dev->destroyOverlay(overlay_dev, mOverlay); }}void LayerBuffer::OverlaySource::onDraw(const Region& clip) const{ // this would be where the color-key would be set, should we need it. GLclampx red = 0; GLclampx green = 0; GLclampx blue = 0; mLayer.clearWithOpenGL(clip, red, green, blue, 0);}void LayerBuffer::OverlaySource::onTransaction(uint32_t flags){ const Layer::State& front(mLayer.drawingState()); const Layer::State& temp(mLayer.currentState()); if (temp.sequence != front.sequence) { mVisibilityChanged = true; }}void LayerBuffer::OverlaySource::onVisibilityResolved( const Transform& planeTransform){ // this code-path must be as tight as possible, it's called each time // the screen is composited. if (UNLIKELY(mOverlay != 0)) { if (mVisibilityChanged || !mInitialized) { mVisibilityChanged = false; mInitialized = true; const Rect bounds(mLayer.getTransformedBounds()); int x = bounds.left; int y = bounds.top; int w = bounds.width(); int h = bounds.height(); // we need a lock here to protect "destroy" Mutex::Autolock _l(mOverlaySourceLock); if (mOverlay) { overlay_control_device_t* overlay_dev = mOverlayDevice; overlay_dev->setPosition(overlay_dev, mOverlay, x,y,w,h); overlay_dev->setParameter(overlay_dev, mOverlay, OVERLAY_TRANSFORM, mLayer.getOrientation()); overlay_dev->commit(overlay_dev, mOverlay); } } }}void LayerBuffer::OverlaySource::destroy(){ // we need a lock here to protect "onVisibilityResolved" Mutex::Autolock _l(mOverlaySourceLock); if (mOverlay && mOverlayDevice) { overlay_control_device_t* overlay_dev = mOverlayDevice; overlay_dev->destroyOverlay(overlay_dev, mOverlay); mOverlay = 0; }}// ---------------------------------------------------------------------------}; // namespace android

 

frameworks/base/opengl/include/EGL/eglext.h

#ifndef __eglext_h_#define __eglext_h_#ifdef __cplusplusextern "C" {#endif/*** Copyright (c) 2007-2009 The Khronos Group Inc.**** Permission is hereby granted, free of charge, to any person obtaining a** copy of this software and/or associated documentation files (the** "Materials"), to deal in the Materials without restriction, including** without limitation the rights to use, copy, modify, merge, publish,** distribute, sublicense, and/or sell copies of the Materials, and to** permit persons to whom the Materials are furnished to do so, subject to** the following conditions:**** The above copyright notice and this permission notice shall be included** in all copies or substantial portions of the Materials.**** THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,** EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF** MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.** IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY** CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,** TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE** MATERIALS OR THE USE OR OTHER DEALINGS IN THE MATERIALS.*/#include <EGL/eglplatform.h>/*************************************************************//* Header file version number *//* Current version at http://www.khronos.org/registry/egl/ *//* $Revision: 7244 $ on $Date: 2009-01-20 17:06:59 -0800 (Tue, 20 Jan 2009) $ */#define EGL_EGLEXT_VERSION 3#ifndef EGL_KHR_config_attribs#define EGL_KHR_config_attribs 1#define EGL_CONFORMANT_KHR 0x3042 /* EGLConfig attribute */#define EGL_VG_COLORSPACE_LINEAR_BIT_KHR 0x0020 /* EGL_SURFACE_TYPE bitfield */#define EGL_VG_ALPHA_FORMAT_PRE_BIT_KHR 0x0040 /* EGL_SURFACE_TYPE bitfield */#endif#ifndef EGL_KHR_lock_surface#define EGL_KHR_lock_surface 1#define EGL_READ_SURFACE_BIT_KHR 0x0001 /* EGL_LOCK_USAGE_HINT_KHR bitfield */#define EGL_WRITE_SURFACE_BIT_KHR 0x0002 /* EGL_LOCK_USAGE_HINT_KHR bitfield */#define EGL_LOCK_SURFACE_BIT_KHR 0x0080 /* EGL_SURFACE_TYPE bitfield */#define EGL_OPTIMAL_FORMAT_BIT_KHR 0x0100 /* EGL_SURFACE_TYPE bitfield */#define EGL_MATCH_FORMAT_KHR 0x3043 /* EGLConfig attribute */#define EGL_FORMAT_RGB_565_EXACT_KHR 0x30C0 /* EGL_MATCH_FORMAT_KHR value */#define EGL_FORMAT_RGB_565_KHR 0x30C1 /* EGL_MATCH_FORMAT_KHR value */#define EGL_FORMAT_RGBA_8888_EXACT_KHR 0x30C2 /* EGL_MATCH_FORMAT_KHR value */#define EGL_FORMAT_RGBA_8888_KHR 0x30C3 /* EGL_MATCH_FORMAT_KHR value */#define EGL_MAP_PRESERVE_PIXELS_KHR 0x30C4 /* eglLockSurfaceKHR attribute */#define EGL_LOCK_USAGE_HINT_KHR 0x30C5 /* eglLockSurfaceKHR attribute */#define EGL_BITMAP_POINTER_KHR 0x30C6 /* eglQuerySurface attribute */#define EGL_BITMAP_PITCH_KHR 0x30C7 /* eglQuerySurface attribute */#define EGL_BITMAP_ORIGIN_KHR 0x30C8 /* eglQuerySurface attribute */#define EGL_BITMAP_PIXEL_RED_OFFSET_KHR 0x30C9 /* eglQuerySurface attribute */#define EGL_BITMAP_PIXEL_GREEN_OFFSET_KHR 0x30CA /* eglQuerySurface attribute */#define EGL_BITMAP_PIXEL_BLUE_OFFSET_KHR 0x30CB /* eglQuerySurface attribute */#define EGL_BITMAP_PIXEL_ALPHA_OFFSET_KHR 0x30CC /* eglQuerySurface attribute */#define EGL_BITMAP_PIXEL_LUMINANCE_OFFSET_KHR 0x30CD /* eglQuerySurface attribute */#define EGL_LOWER_LEFT_KHR 0x30CE /* EGL_BITMAP_ORIGIN_KHR value */#define EGL_UPPER_LEFT_KHR 0x30CF /* EGL_BITMAP_ORIGIN_KHR value */#ifdef EGL_EGLEXT_PROTOTYPESEGLAPI EGLBoolean EGLAPIENTRY eglLockSurfaceKHR (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);EGLAPI EGLBoolean EGLAPIENTRY eglUnlockSurfaceKHR (EGLDisplay display, EGLSurface surface);#endif /* EGL_EGLEXT_PROTOTYPES */typedef EGLBoolean (EGLAPIENTRYP PFNEGLLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface, const EGLint *attrib_list);typedef EGLBoolean (EGLAPIENTRYP PFNEGLUNLOCKSURFACEKHRPROC) (EGLDisplay display, EGLSurface surface);#endif#ifndef EGL_KHR_image#define EGL_KHR_image 1#define EGL_NATIVE_PIXMAP_KHR 0x30B0 /* eglCreateImageKHR target */typedef void *EGLImageKHR;#define EGL_NO_IMAGE_KHR ((EGLImageKHR)0)#ifdef EGL_EGLEXT_PROTOTYPESEGLAPI EGLImageKHR EGLAPIENTRY eglCreateImageKHR (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);EGLAPI EGLBoolean EGLAPIENTRY eglDestroyImageKHR (EGLDisplay dpy, EGLImageKHR image);#endif /* EGL_EGLEXT_PROTOTYPES */typedef EGLImageKHR (EGLAPIENTRYP PFNEGLCREATEIMAGEKHRPROC) (EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list);typedef EGLBoolean (EGLAPIENTRYP PFNEGLDESTROYIMAGEKHRPROC) (EGLDisplay dpy, EGLImageKHR image);#endif#ifndef EGL_KHR_vg_parent_image#define EGL_KHR_vg_parent_image 1#define EGL_VG_PARENT_IMAGE_KHR 0x30BA /* eglCreateImageKHR target */#endif#ifndef EGL_KHR_gl_texture_2D_image#define EGL_KHR_gl_texture_2D_image 1#define EGL_GL_TEXTURE_2D_KHR 0x30B1 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_LEVEL_KHR 0x30BC /* eglCreateImageKHR attribute */#endif#ifndef EGL_KHR_gl_texture_cubemap_image#define EGL_KHR_gl_texture_cubemap_image 1#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_X_KHR 0x30B3 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_X_KHR 0x30B4 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Y_KHR 0x30B5 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Y_KHR 0x30B6 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_CUBE_MAP_POSITIVE_Z_KHR 0x30B7 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_CUBE_MAP_NEGATIVE_Z_KHR 0x30B8 /* eglCreateImageKHR target */#endif#ifndef EGL_KHR_gl_texture_3D_image#define EGL_KHR_gl_texture_3D_image 1#define EGL_GL_TEXTURE_3D_KHR 0x30B2 /* eglCreateImageKHR target */#define EGL_GL_TEXTURE_ZOFFSET_KHR 0x30BD /* eglCreateImageKHR attribute */#endif#ifndef EGL_KHR_gl_renderbuffer_image#define EGL_KHR_gl_renderbuffer_image 1#define EGL_GL_RENDERBUFFER_KHR 0x30B9 /* eglCreateImageKHR target */#endif#ifndef EGL_KHR_image_base#define EGL_KHR_image_base 1/* Most interfaces defined by EGL_KHR_image_pixmap above */#define EGL_IMAGE_PRESERVED_KHR 0x30D2 /* eglCreateImageKHR attribute */#endif#ifndef EGL_KHR_image_pixmap#define EGL_KHR_image_pixmap 1/* Interfaces defined by EGL_KHR_image above */#endif#ifndef EGL_ANDROID_image_native_buffer//#define EGL_ANDROID_image_native_buffer 1struct android_native_buffer_t;#define EGL_NATIVE_BUFFER_ANDROID 0x3140 /* eglCreateImageKHR target */#endif#ifndef EGL_ANDROID_get_render_buffer#define EGL_ANDROID_get_render_buffer 1#ifdef EGL_EGLEXT_PROTOTYPESEGLAPI EGLClientBuffer EGLAPIENTRY eglGetRenderBufferANDROID(EGLDisplay dpy, EGLSurface draw);#endiftypedef EGLClientBuffer (EGLAPIENTRYP PFNEGLGETRENDERBUFFERANDROIDPROC) (EGLDisplay dpy, EGLSurface draw);#endif#ifndef EGL_ANDROID_swap_rectangle#define EGL_ANDROID_swap_rectangle 1#ifdef EGL_EGLEXT_PROTOTYPESEGLAPI EGLBoolean EGLAPIENTRY eglSetSwapRectangleANDROID (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height);#endif /* EGL_EGLEXT_PROTOTYPES */typedef EGLBoolean (EGLAPIENTRYP PFNEGLSETSWAPRECTANGLEANDROIDPROC) (EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height);#endif#ifdef __cplusplus}#endif#endif