GVKun编程网logo

Android jpeglib 和 pnglib

28

在本文中,我们将给您介绍关于Androidjpeglib和pnglib的详细内容,此外,我们还将为您提供关于/usr/include/glib-2.0/glib/gtypes.h:34:24:fata

在本文中,我们将给您介绍关于Android jpeglib 和 pnglib的详细内容,此外,我们还将为您提供关于/usr/include/glib-2.0/glib/gtypes.h:34:24: fatal error: glibconfig.h: No such file or directory、Android OpenGL ES - EGL C++实现、Android OpenGL ES - EGL源码解析以及C++实现、Android studio 模拟器报错: Qt library not found at /Users/dubox/Library/Android/sdk/emulator/lib64/qt/lib的知识。

本文目录一览:

Android jpeglib 和 pnglib

Android jpeglib 和 pnglib

Androidstudio 编译jpeglib 和 pnglig的 so的简单记录

编译多个SO: 用ADD_subdirectory 添加多个目录, 生产多个SO

 

 

#添加子目录,将自动找到子目录中的CMakeLists.txt ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/src/main/cpp/png) ADD_SUBDIRECTORY(${PROJECT_SOURCE_DIR}/src/main/cpp/jpeg)

mylibrary/CMakeLists.txt    png 和 jpeg 目录下有源码和CMakeLists.txt 生产SO, 

cmake_minimum_required(VERSION 3.4.1)

#设置生成的so动态库最后输出的路径
set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_SOURCE_DIR}/libs/${ANDROID_ABI})

#添加子目录,将自动找到子目录中的CMakeLists.txt
ADD_subdirectory(${PROJECT_SOURCE_DIR}/src/main/cpp/png)
ADD_subdirectory(${PROJECT_SOURCE_DIR}/src/main/cpp/jpeg)

 

 

测试libjpeg 和libpng:

可以从编译出来的aar中解压得到so

NativeFunc.java
public class NativeFunc {
    static { System.loadLibrary("native-lib"); }

    //测试libjpeg, 保存bitmap到/sdcard/image_test_save.jpeg
    public static native void saveJpeg(Bitmap bitmap);
    //测试libpng, 保存bitmap到/sdcard/image_test_save.png
    public static native void savePng(Bitmap bitmap);
}

//native-lib.cpp 

#include <jni.h>
#include <string>
#include <android/bitmap.h>
#include <android/log.h>
extern "C" {
#include "jpeg/jpeglib.h"
}
#include "png/png.h"

#define  LOG_TAG    "native_lib"
#define  LOGI(...)  __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__)
#define  LOGE(...)  __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__)


static void init_buffer(struct jpeg_compress_struct * c) {
}


static boolean empty_buffer(struct jpeg_compress_struct * compress_struct) {
    return TRUE;
}

static void term_buffer(struct jpeg_compress_struct * c) {
}

GLOBAL(void)
write_JPEG_Buff(uint8_t *buffPtr, int image_width, int image_height,
                JSAMPLE *imageBuffer, int resolution,  int *numCompBytes) {
    struct jpeg_error_mgr jerr;

    struct jpeg_compress_struct cinfo = {
            .client_data = NULL, .err = jpeg_std_error(&jerr)
    };

    jpeg_create_compress(&cinfo);
    struct jpeg_destination_mgr dm = {
            .init_destination = init_buffer, .empty_output_buffer = empty_buffer,
            .term_destination = term_buffer, .next_output_byte = buffPtr,
            .free_in_buffer = (size_t) image_width * image_height * 3
    };
    cinfo.dest = &dm;
    cinfo.image_width = (jdiMENSION) image_width;
    cinfo.image_height = (jdiMENSION) image_height;

    cinfo.in_color_space = JCS_EXT_RGBA;
    cinfo.jpeg_color_space = JCS_EXT_RGBA;
    cinfo.input_components = 4;


    jpeg_set_defaults(&cinfo);

    jpeg_set_quality(&cinfo, 95, TRUE); // TRUE = limit to baseline-JPEG values
    cinfo.MCUs_per_row = (jdiMENSION) image_width;
    cinfo.MCU_rows_in_scan = (jdiMENSION) image_height;

    jpeg_start_compress(&cinfo, TRUE);

    int row_stride; // physical row width in image buffer
    row_stride = image_width * cinfo.input_components; // JSAMPLEs per row in imageBuffer

    JSAMPROW row_pointer[1]; // pointer to JSAMPLE row[s]
    while (cinfo.next_scanline < cinfo.image_height) {
        row_pointer[0] = &imageBuffer[cinfo.next_scanline * row_stride];
        (void) jpeg_write_scanlines(&cinfo, row_pointer, 1);
    }

    jpeg_finish_compress(&cinfo);
    jpeg_destroy_compress(&cinfo);
    *numCompBytes = (int) (cinfo.dest->next_output_byte - buffPtr);
}

//测试libjpeg, 保存bitmap到/sdcard/image_test_save.jpeg
extern "C" JNIEXPORT void JNICALL
Java_com_lightin_imagedemo_NativeFunc_saveJpeg(
        jnienv *env,
        jclass type, /* this */
        jobject bitmap) {
    AndroidBitmapInfo  info;
    int ret;
    int width = 0;
    int height = 0;
    void*              pixels;
    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
        LOGE("AndroidBitmap_getInfo() Failed ! error=%d", ret);
        return;
    }
    width = info.width;
    height = info.height;

    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
        LOGE("Bitmap format is not RGBA_8888 !");
        return;
    }

    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
        LOGE("AndroidBitmap_lockPixels() Failed ! error=%d", ret);
    }

    char fileName[100];
    sprintf(fileName,"/sdcard/image_test_save.jpeg");
    FILE *file;
    file = fopen(fileName, "wb");
    int *ybuf = (int *)malloc(sizeof(int) * (width*height));
    int outSize;

    write_JPEG_Buff((uint8_t*)ybuf,width,height,(JSAMPLE *)pixels,0, &outSize);

    fwrite((unsigned char *)ybuf, outSize, 1, file);
    fclose(file);

    if(ybuf) free(ybuf);

    AndroidBitmap_unlockPixels(env, bitmap);

}


int writePng(char* png_file_name, unsigned char*  pixels , int width, int height, int bit_depth){

    png_structp png_ptr;

    png_infop info_ptr;

    FILE *png_file = fopen(png_file_name, "wb");


    if (!png_file)
    {
        return -1;
    }
    png_ptr = png_create_write_struct(PNG_LIBPNG_VER_STRING, NULL, NULL, NULL);
    if(png_ptr == NULL)
    {
        printf("ERROR:png_create_write_struct/n");
        fclose(png_file);
        return 0;
    }
    info_ptr = png_create_info_struct(png_ptr);
    if(info_ptr == NULL)
    {
        printf("ERROR:png_create_info_struct/n");
        png_destroy_write_struct(&png_ptr, NULL);
        return 0;
    }
    png_init_io(png_ptr, png_file);
    png_set_IHDR(png_ptr, info_ptr, width, height, bit_depth, PNG_COLOR_TYPE_RGB_ALPHA,
                 PNG_INTERLACE_NONE, PNG_COMPRESSION_TYPE_BASE, PNG_FILTER_TYPE_BASE);


    png_colorp palette = (png_colorp)png_malloc(png_ptr, PNG_MAX_PALETTE_LENGTH * sizeof(png_color));
    if (!palette) {
        fclose(png_file);
        png_destroy_write_struct(&png_ptr, &info_ptr);
        return false;
    }
    png_set_pltE(png_ptr, info_ptr, palette, PNG_MAX_PALETTE_LENGTH);
    png_write_info(png_ptr, info_ptr);
    png_set_packing(png_ptr);
    //这里就是图像数据了
    png_bytepp rows = (png_bytepp)png_malloc(png_ptr, height * sizeof(png_bytep));
    for (int i = 0; i < height; ++i)
    {
        rows[i] = (png_bytep)(pixels + (i) * width*4 );
    }

    png_write_image(png_ptr, rows);
    delete[] rows;
    png_write_end(png_ptr, info_ptr);
    png_free(png_ptr, palette);
    palette=NULL;
    png_destroy_write_struct(&png_ptr, &info_ptr);
    fclose(png_file);

    return 0;
}

//测试libpng, 保存bitmap到/sdcard/image_test_save.png
extern "C" JNIEXPORT void JNICALL
Java_com_lightin_imagedemo_NativeFunc_savePng(
        jnienv *env,
        jclass type/* this */,
        jobject bitmap) {

    AndroidBitmapInfo  info;
    int ret;
    int width = 0;
    int height = 0;
    void*              pixels;
    if ((ret = AndroidBitmap_getInfo(env, bitmap, &info)) < 0) {
        LOGE("AndroidBitmap_getInfo() Failed ! error=%d", ret);
        return;
    }
    width = info.width;
    height = info.height;

    if (info.format != ANDROID_BITMAP_FORMAT_RGBA_8888) {
        LOGE("Bitmap format is not RGBA_8888 !");
        return;
    }

    if ((ret = AndroidBitmap_lockPixels(env, bitmap, &pixels)) < 0) {
        LOGE("AndroidBitmap_lockPixels() Failed ! error=%d", ret);
    }

    char fileName[100];
    sprintf(fileName,"/sdcard/image_test_save.png");

    writePng(fileName,( unsigned char*)pixels,width,height,8);

    AndroidBitmap_unlockPixels(env, bitmap);

}

 

/usr/include/glib-2.0/glib/gtypes.h:34:24: fatal error: glibconfig.h: No such file or directory

/usr/include/glib-2.0/glib/gtypes.h:34:24: fatal error: glibconfig.h: No such file or directory

cc -DDEBUG -mtune=core2 -O2 \
-onvideo nvideo.c \
-I/usr/include/atk-1.0 \
-I/usr/include/cairo \
-I/usr/include/gdk-pixbuf-2.0 \
-I/usr/include/glib-2.0 \
-I/usr/include/gtk-3.0 \
-I/usr/include/pango-1.0 \
-I/usr/include/libxml2 \
-I/usr/lib/x86_64-linux-gnu/glib-2.0/include \
-lpthread \
-lgtk-3 -lgobject-2.0 -lgthread-2.0 \
-lxml2
In file included from /usr/include/glib-2.0/glib/galloca.h:34:0,
from /usr/include/glib-2.0/glib.h:32,
from /usr/include/gtk-3.0/gdk/gdkconfig.h:13,
from /usr/include/gtk-3.0/gdk/gdk.h:32,
from /usr/include/gtk-3.0/gtk/gtk.h:32,
from nvideo.c:11:
/usr/include/glib-2.0/glib/gtypes.h:34:24: fatal error: glibconfig.h: No such file or directory
compilation terminated.
make: *** [edit] Error 1

因为之前已经安装了 gtk 开发包,所以理论上不应该出现找不到.h 文件的问题。最后发现问题出在 - I/usr/lib/x86_64-linux-gnu/glib-2.0/include 参数上。因为之前使用的 64 位,所以这个位置没有问题,但是现在我用的是 32 位系统,所以导致这个路径指错了,增加 - I/usr/lib/i386-linux-gnu/glib-2.0/include 即可。

实际使用应该使用 pkg-config 来配置这个路径的,但是我想手工去完成这个事情,所以导致了这个问题。还弄得满世界去找是不是少装了哪个开发包~~:)

Android OpenGL ES - EGL C++实现

Android OpenGL ES - EGL C++实现

PS
本篇继续上一篇的内容,我们来对Native EGL环境实现的各个步骤进行详细解析

EGL Native层的实现

上一篇文章Android OpenGL ES - EGL源码解析以及C++实现

我们还是先来回顾一下流程图
在这里插入图片描述

以及代码

 //(1) 将线程附加到虚拟机,并获取env
     if (that->m_jvm_for_thread->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE(that->TAG, "线程初始化异常");
            return; 
     }
     // (2) 初始化 EGL 
    if (!that->InitEGL()) {
         //解除线程和jvm关联
         that->m_jvm_for_thread->DetachCurrentThread();
         return; 
     }
     
     //进入循环
    while (true) {
            //根据OpenGL渲染状态进入不同的处理
            switch (that->m_state) {
                //刷新Surface,从外面设置Surface后m_state置为该状态,说明已经从外部(java层)获得Surface的对象了
                case FRESH_SURFACE:
                     LOGI(that->TAG, "Loop Render FRESH_SURFACE")
                     // (3) 初始化Window
                     that->InitDspWindow(env);
                     // (4) 创建EglSurface
                     that->CreateSurface();
                     // m_state置为RENDERING状态进入渲染
                     that->m_state = RENDERING;
                     break; 
                 case RENDERING:
                    LOGI(that->TAG, "Loop Render RENDERING")
                    // (5) 渲染
                    that->Render();
                    break; 
               
                 case STOP:
                    LOGI(that->TAG, "Loop Render STOP")
                    //(6) 解除线程和jvm关联
                     that->ReleaseRender();
                     that->m_jvm_for_thread->DetachCurrentThread();
                     return; 
                case SURFACE_DESTROY:
                    LOGI(that->TAG, "Loop Render SURFACE_DESTROY")
                    //(7) 释放资源
                    that->DestroySurface();
                    that->m_state = NO_SURFACE;
                    break; 
                case NO_SURFACE:
                default:
                    break;
     }
    usleep(20000);
 }
}

首先第(1)步将线程附加到虚拟机,并获取env,这一步简单明了,我们从第(2)步开始

EGL封装准备

我们在上一篇就知道了EGL的一些基础知识,EGLDiaplay,EGLConfig,EGLSurface,EGLContext,我们需要把这些基础类进行封装,那么如何进行封装呢,我们先看一下对于我们上篇文章中自定义的GLRender类需要什么
gl_render.h

//Surface引用,必须要使用引用,否则无法在线程中操作
jobject m_surface_ref = NULL;
//本地屏幕
ANativeWindow *m_native_window = NULL;
//EGL显示表面 注意这里是我们自定义的EglSurface包装类而不是系统提供的EGLSurface哦
EglSurface *m_egl_surface = NULL;

对于gl_render来说输入的是外部的Surface对象,我们这里的是jobject m_surface_ref,那么输出需要的是ANativeWindow,EglSurface

关于ANativeWindow可以查看官方文档ANativeWindow

那么EglSurface呢,

egl_surface.h

class EglSurface {
private:
    const char *TAG = "EglSurface";
    //本地屏幕
     ANativeWindow *m_native_window = NULL;
     //封装了EGLDisplay EGLConfig EGLContext的自定义类
     EglCore *m_core;
     //EGL API提供的 EGLSurface
     EGLSurface m_surface;
}
可以看到我们上面的定义的思想也是V(View)和C(Controller)进行了分离。

egl_core.h

class EglCore {
private:
    const char *TAG = "EglCore";
     //EGL显示窗口
     EGLDisplay m_egl_dsp = EGL_NO_DISPLAY;
     //EGL上下文
     EGLContext m_egl_context = EGL_NO_CONTEXT;
     //EGL配置
     EGLConfig m_egl_config;
}

有了上面的准备工作后,我们就跟着流程图的步骤来一步步走

(2)初始化EGL

gl_render.cpp

bool GLRender::InitEGL() {
    //创建EglSurface对象
    m_egl_surface = new EglSurface();
    //调用EglSurface的init方法
    return m_egl_surface->Init();
}

egl_surface.cpp

PS
我们上面也说了EGL的初始化主要是对EGLDisplay EGLConfig EGLContext的操作,所以现在是对EGLCore的操作
EglSurface::EglSurface() {
    //创建EGLCore
    m_core = new EglCore();
}

bool EglSurface::Init() {
    //调用EGLCore的init方法
    return m_core->Init(NULL);
}

egl_core.cpp

EglCore::EglCore() {
}


bool EglCore::Init(EGLContext share_ctx) {
    if (m_egl_dsp != EGL_NO_DISPLAY) {
        LOGE(TAG, "EGL already set up")
        return true;
     }
    if (share_ctx == NULL) {
            share_ctx = EGL_NO_CONTEXT;
     }
     //获取Dispaly
    m_egl_dsp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
     if (m_egl_dsp == EGL_NO_DISPLAY || eglGetError() != EGL_SUCCESS) {
            LOGE(TAG, "EGL init display fail")
            return false;
     }
        EGLint major_ver, minor_ver;
     //初始化egl
     EGLBoolean success = eglInitialize(m_egl_dsp, &major_ver, &minor_ver);
     if (success != EGL_TRUE || eglGetError() != EGL_SUCCESS) {
            LOGE(TAG, "EGL init fail")
            return false;
     }
        LOGI(TAG, "EGL version: %d.%d", major_ver, minor_ver)
     //获取EGLConfig   
     m_egl_config = GetEGLConfig();
     const EGLint attr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
     //创建EGLContext
     m_egl_context = eglCreateContext(m_egl_dsp, m_egl_config, share_ctx, attr);
     if (m_egl_context == EGL_NO_CONTEXT) {
            LOGE(TAG, "EGL create fail, error is %x", eglGetError());
     return false; }
        EGLint egl_format;
     success = eglGetConfigAttrib(m_egl_dsp, m_egl_config, EGL_NATIVE_VISUAL_ID, &egl_format);
     if (success != EGL_TRUE || eglGetError() != EGL_SUCCESS) {
            LOGE(TAG, "EGL get config fail, error is %x", eglGetError())
            return false;
     }
    LOGI(TAG, "EGL init success")
    return true;
}

EGLConfig EglCore::GetEGLConfig() {
    EGLint numConfigs;
    EGLConfig config;

    //希望的最小配置,
    static const EGLint CONFIG_ATTRIBS[] = {
            EGL_BUFFER_SIZE, EGL_DONT_CARE,
            EGL_RED_SIZE, 8,//R 位数
            EGL_GREEN_SIZE, 8,//G 位数
            EGL_BLUE_SIZE, 8,//B 位数
            EGL_ALPHA_SIZE, 8,//A 位数
            EGL_DEPTH_SIZE, 16,//深度
            EGL_STENCIL_SIZE, EGL_DONT_CARE,
            EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
            EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
            EGL_NONE // the end 结束标志
    };
    //根据你所设定的最小配置系统会选择一个满足你最低要求的配置,这个真正的配置往往要比你期望的属性更多
    EGLBoolean success = eglChooseConfig(m_egl_dsp, CONFIG_ATTRIBS, &config, 1, &numConfigs);
    if (!success || eglGetError() != EGL_SUCCESS) {
        LOGE(TAG, "EGL config fail")
        return NULL;
    }
    return config;
}

(3)创建Window

gl_render.cpp

void GLRender::InitDspWindow(JNIEnv *env) {
    //传进来的Surface对象的引用
    if (m_surface_ref != NULL) {
        // 初始化窗口
        m_native_window = ANativeWindow_fromSurface(env, m_surface_ref);

        // 绘制区域的宽高
        m_window_width = ANativeWindow_getWidth(m_native_window);
        m_window_height = ANativeWindow_getHeight(m_native_window);

        //设置宽高限制缓冲区中的像素数量
        ANativeWindow_setBuffersGeometry(m_native_window, m_window_width,
                                         m_window_height, WINDOW_FORMAT_RGBA_8888);

        LOGD(TAG, "View Port width: %d, height: %d", m_window_width, m_window_height)
    }
}

(4)创建EglSurface并绑定到线程

gl_render.cpp

void GLRender::CreateSurface() {
    m_egl_surface->CreateEglSurface(m_native_window, m_window_width, m_window_height);
    glViewport(0, 0, m_window_width, m_window_height);
}

egl_surface.cpp

/**
 * 
 * @param native_window 传入上一步创建的ANativeWindow
 * @param width 
 * @param height 
 */
void EglSurface::CreateEglSurface(ANativeWindow *native_window, int width, int height) {
    if (native_window != NULL) {
        this->m_native_window = native_window;
        m_surface = m_core->CreateWindSurface(m_native_window);
    } else {
        m_surface = m_core->CreateOffScreenSurface(width, height);
    }
    if (m_surface == NULL) {
        LOGE(TAG, "EGL create window surface fail")
        Release();
    }
    MakeCurrent();
}

void EglSurface::MakeCurrent() {
    m_core->MakeCurrent(m_surface);
}

egl_core.cpp

EGLSurface EglCore::CreateWindSurface(ANativeWindow *window) {
    //调用EGL Native API创建Window Surface
    EGLSurface surface = eglCreateWindowSurface(m_egl_dsp, m_egl_config, window, 0);
    if (eglGetError() != EGL_SUCCESS) {
        LOGI(TAG, "EGL create window surface fail")
        return NULL;
    }
    return surface;
}

void EglCore::MakeCurrent(EGLSurface egl_surface) {
    //调用EGL Native API 绑定渲染环境到当前线程
    if (!eglMakeCurrent(m_egl_dsp, egl_surface, egl_surface, m_egl_context)) {
        LOGE(TAG, "EGL make current fail");
    }
}

(5)渲染

gl_render.cpp

void GLRender::Render() {
    if (RENDERING == m_state) {
        pImageRender->DoDraw();//画画画....
        m_egl_surface->SwapBuffers();
    }
}

egl_surface.cpp

void EglSurface::SwapBuffers() {
    m_core->SwapBuffer(m_surface);
}

egl_core.cpp

void EglCore::SwapBuffer(EGLSurface egl_surface) {
    //调用EGL Native API
    eglSwapBuffers(m_egl_dsp, egl_surface);
}

后面的停止与销毁就交给读者自行研究了。

代码

EGLDemoActivity.java

EGL Native

Android OpenGL ES - EGL源码解析以及C++实现

Android OpenGL ES - EGL源码解析以及C++实现

PS
我们在前面的文章中就说过关于EGL的出现原因以及其作用

OpenGL 是一个跨平台的API,而不同的操作系统(Windows,Android,IOS)各有自己的屏幕渲染实现。所以OpenGL定义了一个中间接口层EGL(Embedded Graphics Library)标准,具体实现交给各个操作系统本身

EGL

简单来说EGL是一个中间接口层,是一个规范,由于OpenGL的跨平台性,所以说这个规范显得尤其重要,不管各个操作系统如何蹦跶,都不能脱离我所定义的规范。

EGL的一些基础知识

  • EGLDisplay

EGL定义的一个抽象的系统显示类,用于操作设备窗口。

  • EGLConfig

EGL配置,如rgba位数

  • EGLSurface

渲染缓存,一块内存空间,所有要渲染到屏幕上的图像数据,都要先缓存在EGLSurface上。

  • EGLContext

OpenGL上下文,用于存储OpenGL的绘制状态信息、数据。

初始化EGL的过程可以说是对上面几个信息进行配置的过程

OpenGL ES绘图完整流程

我们在使用Java GLSurfaceView的时候其实只是自定义了Render,该Render实现了GLsurfaceView.Renderer接口,然后自定义的Render中的3个方法就会得到回调,Android 系统其实帮我省掉了其中的很多步骤。所以我们这里来看一下完整流程
(1). 获取显示设备(对应于上面的EGLDisplay)

/*
 * Get an EGL instance */
 mEgl = (EGL10) EGLContext.getEGL();
 
/*
 * Get to the default display. */
 mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);

(2). 初始化EGL

int[] version = new int[2];
//初始化屏幕
if(!mEgl.eglInitialize(mEglDisplay, version)) {
    throw new RuntimeException("eglInitialize failed");
}

(3). 选择Config(用EGLConfig配置参数)

//这段代码的作用是选择EGL配置, 即可以自己先设定好一个你希望的EGL配置,比如说RGB三种颜色各占几位,你可以随便配,而EGL可能不能满足你所有的要求,于是它会返回一些与你的要求最接近的配置供你选择。
if (!egl.eglChooseConfig(display, mConfigSpec, configs, numConfigs,
 num_config)) {
    throw new IllegalArgumentException("eglChooseConfig#2 failed");
}

(4). 创建EGLContext

//从上一步EGL返回的配置列表中选择一种配置,用来创建EGL Context。
egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT,
 mEGLContextClientVersion != 0 ? attrib_list : null);

(5). 获取EGLSurface

//创建一个窗口Surface,可以看成屏幕所对应的内存
 egl.eglCreateWindowSurface(display, config, nativeWindow, null)
PS
这里的nativeWindow是GLSurfaceView的surfaceHolder

(6). 绑定渲染环境到当前线程

/*
 * Before we can issue GL commands, we need to make sure * the context is current and bound to a surface. */
 if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
    /*
    * Could not make the context current, probably because the underlying * SurfaceView surface has been destroyed. */ 
     logEglErrorAsWarning("EGLHelper", "eglMakeCurrent", mEgl.eglGetError());
     return false;
 }

循环绘制

loop:{
    //绘制中....
    //(7).交换缓冲区
    mEglHelper.swap();
}

public int swap() {
    if (! mEgl.eglSwapBuffers(mEglDisplay, mEglSurface)) {
        return mEgl.eglGetError();
    }
    return EGL10.EGL_SUCCESS;
}

Java - GLSurfaceView/GLTextureView

上面我们介绍了EGL的一些基础知识,接着我们来看在GLSurfaceView/GLTextureView中EGL的具体实现,我们来从源码上剖析Android系统EGL及GL线程

GLThread

我们来看一下GLThread,GLThread也是从普通的Thread类继承而来,理论上就是一个普通的线程,为什么它拥有OpenGL绘图能力?继续往下看,里面最重要的部分就是guardedRun()方法

static class GLThread extends Thread {
    ...
    @Override
    public void run() {
      
        try {
                guardedRun();
         } catch (InterruptedException e) {
                // fall thru and exit normally
         } finally {
                sGLThreadManager.threadExiting(this);
         }
    }
}

让我们来看一下guardedRun()方法里有什么东西,guardedRun()里大致做的事情:

private void guardedRun() throws InterruptedException {
    while(true){
        //if ready to draw
        ...
        mEglHelper.start();//对应于上面完整流程中的(1)(2)(3)(4)
        
        ...
        mEglHelper.createSurface()//对应于上面完整流程中的(5)(6)
        
        ...
        回调GLSurfaceView.Renderer的onSurfaceCreated();
        ...
        回调GLSurfaceView.Renderer的onSurfaceChanged();
        ...
        回调GLSurfaceView.Renderer的onDrawFrame();
        
        ...
         mEglHelper.swap();//对应于上面完整流程中的(5)(7)
    }
}

从上面我们的分析得知GLSurfaceView 中的GLThread就是一个普通的线程,只不过它按照了OpenGL绘图的完整流程正确地操作了下来,因此它有OpenGL的绘图能力。那么,如果我们自己创建一个线程,也按这样的操作方法,那我们也可以在自己创建的线程里绘图吗?答案是肯定的(这不正是EGL的接口意义),下面我会给出EGL在Native C/C++中的实现。

Native - EGL

Android Native环境中并不存在现成的EGL环境,所以我们在进行OpenGL的NDK开发时就必须自己实现EGL环境,那么如何实现呢,我们只需要参照GLSurfaceView中的GLThread的写法就能实现Native中的EGL

PS
一下的内容可能需要你对C/C++以及NDK 有一定熟悉

第1步实现类似于Java GLSurfaceView中的GLThread的功能

gl_render.h

class GLRender {
    private:
         const char *TAG = "GLRender";
         //OpenGL渲染状态
         enum STATE {
             NO_SURFACE, //没有有效的surface
             FRESH_SURFACE, //持有一个为初始化的新的surface
             RENDERING, //初始化完毕,可以开始渲染
             SURFACE_DESTROY, //surface销毁
             STOP //停止绘制
         };
         JNIEnv *m_env = NULL;
         //线程依附的jvm环境
         JavaVM *m_jvm_for_thread = NULL;
         //Surface引用,必须要使用引用,否则无法在线程中操作
         jobject m_surface_ref = NULL;
         //本地屏幕
         ANativeWindow *m_native_window = NULL;
         //EGL显示表面
         EglSurface *m_egl_surface = NULL;
         int m_window_width = 0;
         int m_window_height = 0;
         
         // 绘制代理器
         ImageRender *pImageRender;
         
         //OpenGL渲染状态
         STATE m_state = NO_SURFACE;
         // 初始化相关的方法
         void InitRenderThread();
         bool InitEGL();
         void InitDspWindow(JNIEnv *env);
         // 创建/销毁 Surface void CreateSurface();
         void DestroySurface();
         // 渲染方法
         void Render();
         void ReleaseSurface();
         void ReleaseWindow();
         // 渲染线程回调方法
         static void sRenderThread(std::shared_ptr<GLRender> that);
    public:
         GLRender(JNIEnv *env);
         ~GLRender();
         //外部传入Surface
         void SetSurface(jobject surface);
      
         void Stop();
         void SetBitmapRender(ImageRender *bitmapRender);
        // 释放资源相关方法
         void ReleaseRender();
         
         ImageRender *GetImageRender();
};

gl_render.cpp

//构造函数
GLRender::GLRender(JNIEnv *env) {
     this->m_env = env;
     //获取JVM虚拟机,为创建线程作准备
     env->GetJavaVM(&m_jvm_for_thread);
     InitRenderThread();
}
//析构函数
GLRender::~GLRender() {
    delete m_egl_surface;
}

//初始化渲染线程
void GLRender::InitRenderThread() {
    // 使用智能指针,线程结束时,自动删除本类指针
     std::shared_ptr<GLRender> that(this);
     std::thread t(sRenderThread, that);
     t.detach();
}

//线程回调函数
void GLRender::sRenderThread(std::shared_ptr<GLRender> that) {
    JNIEnv *env;
     //(1) 将线程附加到虚拟机,并获取env
     if (that->m_jvm_for_thread->AttachCurrentThread(&env, NULL) != JNI_OK) {
            LOGE(that->TAG, "线程初始化异常");
            return; 
     }
     // (2) 初始化 EGL 
    if (!that->InitEGL()) {
         //解除线程和jvm关联
         that->m_jvm_for_thread->DetachCurrentThread();
         return; 
     }
     
     //进入循环
    while (true) {
            //根据OpenGL渲染状态进入不同的处理
            switch (that->m_state) {
                //刷新Surface,从外面设置Surface后m_state置为该状态,说明已经从外部(java层)获得Surface的对象了
                case FRESH_SURFACE:
                     LOGI(that->TAG, "Loop Render FRESH_SURFACE")
                     // (3) 初始化Window
                     that->InitDspWindow(env);
                     // (4) 创建EglSurface
                     that->CreateSurface();
                     // m_state置为RENDERING状态进入渲染
                     that->m_state = RENDERING;
                     break; 
                 case RENDERING:
                    LOGI(that->TAG, "Loop Render RENDERING")
                    // (5) 渲染
                    that->Render();
                    break; 
               
                 case STOP:
                    LOGI(that->TAG, "Loop Render STOP")
                    //(6) 解除线程和jvm关联
                     that->ReleaseRender();
                     that->m_jvm_for_thread->DetachCurrentThread();
                     return; 
                case SURFACE_DESTROY:
                    LOGI(that->TAG, "Loop Render SURFACE_DESTROY")
                    //(7) 释放资源
                    that->DestroySurface();
                    that->m_state = NO_SURFACE;
                    break; 
                case NO_SURFACE:
                default:
                    break;
     }
    usleep(20000);
 }
}

我们定义的GLRender各个流程代码里已经标注了步骤,虽然代码量比较多,但是我们的c++ class分析也是跟java类似,
image.png

PS
上图中的(3)(4)等步骤对应于代码中的步骤注释

小结

本篇文章我们介绍了EGL,以及分析了Java 中GLSurfaceView中的EGL实现,然后我们试着参照Java端的代码实现Native中的EGL环境,关于代码以及流程图中的细节,我们下篇再来分析。

Android studio 模拟器报错: Qt library not found at /Users/dubox/Library/Android/sdk/emulator/lib64/qt/lib

Android studio 模拟器报错: Qt library not found at /Users/dubox/Library/Android/sdk/emulator/lib64/qt/lib

运行 Android studio 的模拟器 ,报错:

2018/1/15
下午8:54	Emulator: [140736041808704]:ERROR:./android/qt/qt_setup.cpp:28:Qt library not found at /Users/dubox/Library/Android/sdk/emulator/lib64/qt/lib

下午8:54	Emulator: Could not launch ''/Users/dubox/Library/Android/sdk/emulator/qemu/darwin-x86_64/qemu-system-i386'': No such file or directory

下午8:54	Emulator: Process finished with exit code 2

上网查了半天,原因竟是:

这一项没有勾。。。

 

今天关于Android jpeglib 和 pnglib的分享就到这里,希望大家有所收获,若想了解更多关于/usr/include/glib-2.0/glib/gtypes.h:34:24: fatal error: glibconfig.h: No such file or directory、Android OpenGL ES - EGL C++实现、Android OpenGL ES - EGL源码解析以及C++实现、Android studio 模拟器报错: Qt library not found at /Users/dubox/Library/Android/sdk/emulator/lib64/qt/lib等相关知识,可以在本站进行查询。

本文标签: