Android(安卓)FFmpeg

#include

#include"FFDemux.h"

#include"ChaoLog.h"

#include"ChaoDecode.h"

#include"FFDecode.h"

#include"ChaoVideoView.h"

#include"ChaoEGL.h"

#include"ChaoShader.h"

#include"GLVideoView.h"

#include"ChaoResample.h"

#include"FFResample.h"

#include"ChaoAudioPlay.h"

#include"SLAudioPlay.h"

#defineLOGW(...) __android_log_print(ANDROID_LOG_WARN,"ChaoPlayer", __VA_ARGS__)

#defineLOGE(...) __android_log_print(ANDROID_LOG_ERROR,"ChaoPlayer", __VA_ARGS__)

#defineLOGI(...) __android_log_print(ANDROID_LOG_INFO,"ChaoPlayer", __VA_ARGS__)

#defineLOGD(...) __android_log_print(ANDROID_LOG_DEBUG,"ChaoPlayer", __VA_ARGS__)

extern"C"{

#include

}

#include

usingnamespacestd;

//把分数转换成浮点型

staticdoubler2d(AVRational r) {

returnr.num==0|| r.den==0?0: (double)r.num/ (double)r.den;

}

//当前时间戳 clock

longlongGetNowMs() {

structtimevaltv;

gettimeofday(&tv,NULL);

intsec = tv.tv_sec%360000;

longlongt = sec *1000+ tv.tv_usec/1000;

returnt;

}

/*********************音频播放OpenSLES ****************************/

//1.创建引擎

staticSLObjectItf engineSL =NULL;

SLEngineItfCreateSL() {

SLresult re;

SLEngineItf en;

re =slCreateEngine(&engineSL,0,0,0,0,0);//创建引擎对象

if(re != SL_RESULT_SUCCESS)//失败

returnNULL;

re = (*engineSL)->Realize(engineSL, SL_BOOLEAN_FALSE);//成功等待对象创建

if(re != SL_RESULT_SUCCESS)

returnNULL;

re = (*engineSL)->GetInterface(engineSL, SL_IID_ENGINE, &en);//获取接口

if(re != SL_RESULT_SUCCESS)

returnNULL;

returnen;

}

//播放Pcm音频文件

voidPcmCall(SLAndroidSimpleBufferQueueItf bf,void*context) {

LOGI("PcmCall");

staticFILE*fp =NULL;

staticchar*buf =NULL;

if(!buf) {

buf =newchar[1024*1024];

}

if(!fp) {

fp =fopen("/sdcard/Music/test.pcm","rb");

}

if(!fp)

return;

if(feof(fp) ==0) {//打开成功

intlen =fread(buf,1,1024, fp);

if(len >0)

(*bf)->Enqueue(bf, buf, len);//发送音频

}

//顶点着色器glsl

#defineGET_STR(x) #x

staticconstchar*vertexShader = GET_STR(

attribute vec4 aPosition;//顶点坐标

attribute vec2 aTexCoord;//材质顶点坐标

varying vec2 vTexCoord;//输出的材质坐标

voidmain(){

vTexCoord =vec2(aTexCoord.x,1.0- aTexCoord.y);

gl_Position = aPosition;//显示顶点

}

);

//片元着色器,软解码和部分x86硬解码

staticconstchar*fragYUV420P = GET_STR(

precision mediumpfloat;//精度

varying vec2 vTexCoord;//顶点着色器传递的坐标

uniform sampler2D yTexture;//输入的材质（不透明灰度，单像素）

uniform sampler2D uTexture;

uniform sampler2D vTexture;

voidmain(){

vec3 yuv;

vec3 rgb;

yuv.r=texture2D(yTexture,vTexCoord).r;

yuv.g=texture2D(uTexture,vTexCoord).r-0.5;

yuv.b=texture2D(vTexture,vTexCoord).r-0.5;

rgb =mat3(1.0,1.0,1.0,

0.0,-0.39465,2.03211,

1.13983,-0.58060,0.0)*yuv;

//输出像素颜色

gl_FragColor =vec4(rgb,1.0);

}

);

GLintInitShader(constchar*code, GLint type) {

//创建shader

GLint sh =glCreateShader(type);

if(sh ==0) {

LOGD("glCreateShader %d failed!", type);

return0;

}

//加载shader

glShaderSource(sh,

1,//shader数量

&code,//shader代码

0);//代码长度

//编译shader

glCompileShader(sh);

//获取编译情况

GLint status;

glGetShaderiv(sh, GL_COMPILE_STATUS, &status);

if(status ==0) {

LOGD("glCompileShader failed!");

return0;

}

LOGD("glCompileShader success!");

returnsh;

}

classTestObs:publicChaoObserver{

public:

voidUpdate(ChaoData d) {

//CHAOLOGI("TestObs Update data size is %d", d.size);

}

};

ChaoVideoView *view =NULL;

extern"C"

JNIEXPORT

jintJNI_OnLoad(JavaVM *vm,void*res) {

FFDecode::InitHard(vm);

TestObs *tobs =newTestObs();

ChaoDemux *de =newFFDemux();

de->Open("/sdcard/Movies/1080.mp4");

ChaoDecode *vdecode =newFFDecode();

vdecode->Open(de->GetVPara(),true);

ChaoDecode *adecode =newFFDecode();

adecode->Open(de->GetAPara());

de->AddObs(vdecode);

de->AddObs(adecode);

view =newGLVideoView();

vdecode->AddObs(view);

ChaoResample *resample =newFFResample();

ChaoParameter outPara = de->GetAPara();

resample->Open(de->GetAPara(), outPara);

adecode->AddObs(resample);

ChaoAudioPlay *audioPlay =newSLAudioPlay();

audioPlay->StartPlay(outPara);

resample->AddObs(audioPlay);

de->Start();

vdecode->Start();

adecode->Start();

returnJNI_VERSION_1_4;

}

extern"C"

JNIEXPORT jstring JNICALL

Java_com_lichao_chaoplayer_MainActivity_stringFromJNI(JNIEnv *env, jobject/*this*/) {

std::string hello ="Hello from C++";

//1 创建引擎

SLEngineItf eng =CreateSL();

if(eng){

LOGD("CreateSL success！");

}else{

LOGD("CreateSL failed！");

}

//2 创建混音器

SLObjectItf mix =NULL;

SLresult re =0;

re = (*eng)->CreateOutputMix(eng, &mix,0,0,0);//1 引擎 2 输出的混音器 345配置项音效

if(re != SL_RESULT_SUCCESS) {

LOGD("SL_RESULT_SUCCESS failed!");

}

re = (*mix)->Realize(mix, SL_BOOLEAN_FALSE);//实例化对象 1 对象 2 等待创建完毕

if(re != SL_RESULT_SUCCESS) {

LOGD("(*mix)->Realize failed!");

}

SLDataLocator_OutputMix outMix = {SL_DATALOCATOR_OUTPUTMIX, mix};//用来存放声音给音频

SLDataSink audioSink= {&outMix,0};

//3 配置音频信息

//缓冲队列

SLDataLocator_AndroidSimpleBufferQueue que = {SL_DATALOCATOR_ANDROIDSIMPLEBUFFERQUEUE,10};

//音频格式

SLDataFormat_PCM pcm = {

SL_DATAFORMAT_PCM,

2,//声道数

SL_SAMPLINGRATE_44_1,

SL_PCMSAMPLEFORMAT_FIXED_16,

SL_SPEAKER_FRONT_LEFT|SL_SPEAKER_FRONT_RIGHT,

SL_BYTEORDER_LITTLEENDIAN//字节序，小端

};

SLDataSource ds = {&que,&pcm};

//4 创建播放器

SLObjectItf player =NULL;

SLPlayItf iplayer =NULL;

SLAndroidSimpleBufferQueueItf pcmQue =NULL;//存放地址

constSLInterfaceID ids[] = {SL_IID_BUFFERQUEUE};

constSLboolean req[] = {SL_BOOLEAN_TRUE};

//创建播放器 1 引擎 2 播放器对象 3 数据源信息 4 混音器 5 6 7

re = (*eng)->CreateAudioPlayer(eng, &player, &ds, &audioSink,sizeof(ids) /sizeof(SLInterfaceID), ids, req);

if(re != SL_RESULT_SUCCESS) {

LOGD("CreateAudioPlayer failed!");

}else{

LOGD("CreateAudioPlayer success!");

}

(*player)->Realize(player, SL_BOOLEAN_FALSE);//实例化

//获取player接口

re = (*player)->GetInterface(player, SL_IID_PLAY,&iplayer);

if(re != SL_RESULT_SUCCESS) {

LOGD("GetInterface SL_IID_PLAY failed!");

}

re = (*player)->GetInterface(player, SL_IID_BUFFERQUEUE, &pcmQue);//获取播放用的接口

if(re != SL_RESULT_SUCCESS) {

LOGD("GetInterface SL_IID_BUFFERQUEUE failed!");

}

//设置回调函数，播放队列空调用

(*pcmQue)->RegisterCallback(pcmQue, PcmCall,0);

//设置为播放状态

(*iplayer)->SetPlayState(iplayer, SL_PLAYSTATE_PLAYING);

//启动队列回调

(*pcmQue)->Enqueue(pcmQue,"",1);

returnenv->NewStringUTF(hello.c_str());

}

extern"C"

JNIEXPORTvoidJNICALL

Java_com_lichao_chaoplayer_ChaoPlay_Open(JNIEnv *env, jobject instance, jstring url_, jobject surface) {

constchar*path = env->GetStringUTFChars(url_,0);

//初始化解封装

av_register_all();

//初始化网络

avformat_network_init();

avcodec_register_all();

//打开文件

AVFormatContext *ic =NULL;

intre =avformat_open_input(&ic, path,0,0);

if(re !=0) {

//打开失败输出错误原因

LOGE("avformat_open_input failed!:%s",av_err2str(re));

return;

}

LOGI("avformat_open_input %s success!", path);

//获取视频流信息加这句能保证flv格式视频（没格式信息的视频）

re =avformat_find_stream_info(ic,0);

if(re !=0) {

LOGW("avformat_find_stream_info failed");

}

//duration总时长微秒 nb_streams流的数量

LOGW("duration = %lld nb_streams = %d", ic->duration, ic->nb_streams);

//遍历流信息

intfps =0;//帧率

intvideoStream =0;//视频流

intaudioStream =1;//音频流

for(inti =0; i < ic->nb_streams; i++) {

AVStream *as = ic->streams[i];

if(as->codecpar->codec_type== AVMEDIA_TYPE_VIDEO) {

LOGW("视频数据");

videoStream = i;

fps =r2d(as->avg_frame_rate);

LOGW("fps = %d, width=%d height=%d codecId=%d pixFormat=%d", fps,

as->codecpar->width,//宽度

as->codecpar->height,//高度

as->codecpar->codec_id,//编码器

as->codecpar->format//编码器格式

);

}elseif(as->codecpar->codec_type== AVMEDIA_TYPE_AUDIO) {

LOGW("音频数据");

audioStream = i;

LOGW("sample_rate=%d channels=%d sample_format=%d",

as->codecpar->sample_rate,//音频采样率

as->codecpar->channels,//通道数

as->codecpar->format//格式

);

}

//获取音频流数据

audioStream =av_find_best_stream(ic, AVMEDIA_TYPE_AUDIO, -1, -1,NULL,0);

LOGW("av_find_best_stream audioStream = %d", audioStream);

/*********************************打开视频解码器****************************************/

//解码器--软解码

AVCodec *codec =avcodec_find_decoder(ic->streams[videoStream]->codecpar->codec_id);

//硬解码

codec =avcodec_find_decoder_by_name("h264_mediacodec");

if(!codec) {

LOGW("AVCodec find decoder failed");

return;

}

//视频解码器初始化

AVCodecContext *vc =avcodec_alloc_context3(codec);

//复制视频

avcodec_parameters_to_context(vc, ic->streams[videoStream]->codecpar);

//线程数量

vc->thread_count=8;

//打开解码器

re =avcodec_open2(vc,0,0);

if(re !=0) {

LOGW("avcodec_open2 video failed");

return;

}

/*********************************打开音频解码器****************************************/

//软解码器

AVCodec *acodec =avcodec_find_decoder(ic->streams[audioStream]->codecpar->codec_id);

if(!acodec) {

LOGW("AVCodec find decoder failed");

return;

}

//视频解码器初始化

AVCodecContext *ac =avcodec_alloc_context3(acodec);

//复制视频

avcodec_parameters_to_context(ac, ic->streams[audioStream]->codecpar);

//线程数量

ac->thread_count=8;

//打开解码器

re =avcodec_open2(ac,0,0);

if(re !=0) {

LOGW("avcodec_open2 audio failed");

return;

}

//读取帧数据

AVPacket *pkt =av_packet_alloc();

AVFrame *frame =av_frame_alloc();

longlongstart =GetNowMs();

intframeCount =0;

//初始化像素格式转换的上下文

SwsContext *vctx =NULL;

intoutWidth =1280;

intoutHeight =720;

char*rgb =newchar[1920*1080*4];

char*pcm =newchar[48000*4*2];

//音频重采样上下文初始化

SwrContext *actx =swr_alloc();

actx =swr_alloc_set_opts(actx,

av_get_default_channel_layout(2),//音频输出通道数

AV_SAMPLE_FMT_S16,//输出格式

ac->sample_rate,//输出样本率

av_get_default_channel_layout(ac->channels),//输入格式

ac->sample_fmt,//输入格式

ac->sample_rate,//输入样本采样率

0,0);

re =swr_init(actx);

if(re !=0) {

LOGW("swr_init failed!");

}else{

LOGW("swr_init success!");

}

//显示窗口初始化

ANativeWindow *nwin =ANativeWindow_fromSurface(env, surface);

ANativeWindow_setBuffersGeometry(nwin,outWidth,outHeight, WINDOW_FORMAT_RGBA_8888);

ANativeWindow_Buffer wbuf;

for(;;) {

//超过三秒

if(GetNowMs() - start >=3000) {

LOGW("now decode fps is %d", frameCount /3);

start =GetNowMs();

frameCount =0;

}

intre =av_read_frame(ic, pkt);

if(re !=0) {

LOGW("读取到结尾处!");

//20秒

intpos =20*r2d(ic->streams[videoStream]->time_base);

//跳20秒往后找和找关键帧

av_seek_frame(ic, videoStream, pos, AVSEEK_FLAG_BACKWARD|AVSEEK_FLAG_FRAME );

continue;

}

AVCodecContext *cc = vc;

if(pkt->stream_index== audioStream)

cc = ac;

//LOGW("stream = %d size =%d pts=%lld flag=%d", pkt->stream_index, pkt->size, pkt->pts, pkt->flags);

//发送到线程中解码

re =avcodec_send_packet(cc, pkt);

//清理

intp = pkt->pts;

av_packet_unref(pkt);

if(re !=0) {

//失败

LOGW("avcodec_send_packet failed!");

continue;

}

for(;;) {

re =avcodec_receive_frame(cc, frame);

if(re !=0) {

break;

}

//LOGW("avcodec_receive_frame %lld", frame->pts);

//如果是视频帧

if(cc == vc) {

frameCount++;

//像素格式初始化

vctx =sws_getCachedContext(vctx,

frame->width,

frame->height,

(AVPixelFormat)frame->format,

outWidth,

outHeight,

AV_PIX_FMT_RGBA,

SWS_FAST_BILINEAR,

0,0,0);

if(!vctx) {

LOGW("sws_getCachedContext failed!");

}else{

//显示大小转换

uint8_t*data[AV_NUM_DATA_POINTERS] = {0};

data[0] =(uint8_t*)rgb;

intlines[AV_NUM_DATA_POINTERS] = {0};//一行宽度的大小

lines[0] = outWidth *4;

inth =sws_scale(vctx,

(constuint8_t**)frame->data,

frame->linesize,0,

frame->height,

data,lines);

LOGW("sws_scale = %d", h);

if(h >0) {

ANativeWindow_lock(nwin,&wbuf,0);

uint8_t*dst = (uint8_t*)wbuf.bits;

memcpy(dst,rgb,outWidth*outHeight *4);

ANativeWindow_unlockAndPost(nwin);

}

}else{

//音频

uint8_t*out[2] = {0};

out[0] = (uint8_t*) pcm;

//音频重采样

intlen =swr_convert(actx,out,

frame->nb_samples,

(constuint8_t**)frame->data,

frame->nb_samples);

LOGW("swr_convert = %d", len);

}

deletergb;

deletepcm;

//关闭上下文

avformat_close_input(&ic);

env->ReleaseStringUTFChars(url_, path);

}

extern"C"

JNIEXPORTvoidJNICALL

Java_com_lichao_chaoplayer_ChaoPlay_Yuv(JNIEnv *env, jobject instance, jstring url_, jobject surface) {

constchar*url = env->GetStringUTFChars(url_,0);

LOGD("open url is %s", url);

FILE*fp =fopen(url,"rb");

if(!fp) {

LOGD("open file %s failed!", url);

return;

}

//获取原始窗口

ANativeWindow *nwin =ANativeWindow_fromSurface(env,surface);

//1 EGL display创建和初始化

EGLDisplay display =eglGetDisplay(EGL_DEFAULT_DISPLAY);//创建

if(display == EGL_NO_DISPLAY) {

LOGD("eglGetDisplay failed!");

return;

}

if(EGL_TRUE !=eglInitialize(display,0,0)) {//初始化

LOGD("eglInitialize failed!");

return;

}

//2 surface

//输出配置

EGLConfig config;

EGLint configNum;

//输入配置

EGLint configSpec[] = {

EGL_RED_SIZE,8,

EGL_GREEN_SIZE,8,

EGL_BLUE_SIZE,8,

EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE

};

//surface窗口配置

if(EGL_TRUE !=eglChooseConfig(display, configSpec, &config,1, &configNum)) {

LOGD("eglChooseConfig failed!");

return;

}

//创建surface

EGLSurface winSurface =eglCreateWindowSurface(display, config, nwin,0);

if(winSurface == EGL_NO_SURFACE) {

LOGD("eglCreateWindowSurface failed!");

return;

}

//3 context 创建关联的上下文

constEGLint ctxAttr[] = {

EGL_CONTEXT_CLIENT_VERSION,2, EGL_NONE

};

EGLContext context =eglCreateContext(display, config, EGL_NO_CONTEXT, ctxAttr);

if(context == EGL_NO_CONTEXT) {

LOGD("eglCreateContext failed!");

return;

}

if(EGL_TRUE !=eglMakeCurrent(display, winSurface, winSurface, context)) {

LOGD("eglMakeCurrent failed!");

return;

}

LOGD("EGL Init Success!");

//顶点和片元shader初始化

//顶点shader初始化

GLint vsh =InitShader(vertexShader, GL_VERTEX_SHADER);

//片元yuv420 shader初始化

GLint fsh =InitShader(fragYUV420P, GL_FRAGMENT_SHADER);

//创建渲染程序

GLint program =glCreateProgram();

if(program ==0) {

LOGD("glCreateProgram failed!");

return;

}

//渲染程序中加入着色器代码

glAttachShader(program, vsh);

glAttachShader(program, fsh);

//链接程序

glLinkProgram(program);

GLint status =0;

glGetProgramiv(program ,GL_LINK_STATUS, &status);

if(status != GL_TRUE) {

LOGD("glLinkProgram failed!");

return;

}

glUseProgram(program);//激活渲染程序

LOGD("glLinkProgram success!");

/*****************************************************************/

//加入三维顶点数据两个三角形组成正方形

staticfloatvers[] = {

1.0f,-1.0f,0.0f,

-1.0f,-1.0f,0.0f,

1.0f,1.0f,0.0f,

-1.0f,1.0f,0.0f,

};

GLuint apos = (GLuint)glGetAttribLocation(program,"aPosition");

glEnableVertexAttribArray(apos);

//传递顶点

glVertexAttribPointer(apos,3, GL_FLOAT,GL_FALSE,12, vers);

//加入材质坐标数据

staticfloattxts[] = {

1.0f,0.0f,//右下

0.0f,0.0f,

1.0f,1.0f,

0.0,1.0

};

GLuint atex = (GLuint)glGetAttribLocation(program,"aTexCoord");

glEnableVertexAttribArray(atex);

glVertexAttribPointer(atex,2, GL_FLOAT,GL_FALSE,8, txts);

intwidth =424;

intheight =240;

//材质纹理初始化

//设置纹理层

glUniform1i(glGetUniformLocation(program,"yTexture"),0);//对于纹理第1层

glUniform1i(glGetUniformLocation(program,"uTexture"),1);//对于纹理第2层

glUniform1i(glGetUniformLocation(program,"vTexture"),2);//对于纹理第3层

//创建opengl纹理

GLuint texts[3] = {0};

//创建三个纹理

glGenTextures(3, texts);

//设置纹理属性

glBindTexture(GL_TEXTURE_2D, texts[0]);

//缩小的过滤器

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

//设置纹理的格式和大小

glTexImage2D(GL_TEXTURE_2D,

0,//细节基本 0默认

GL_LUMINANCE,//gpu内部格式亮度，灰度图

width, height,//拉升到全屏

0,//边框

GL_LUMINANCE,//数据的像素格式亮度，灰度图要与上面一致

GL_UNSIGNED_BYTE,//像素的数据类型

NULL//纹理的数据

);

//设置纹理属性

glBindTexture(GL_TEXTURE_2D, texts[1]);

//缩小的过滤器

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

//设置纹理的格式和大小

glTexImage2D(GL_TEXTURE_2D,

0,//细节基本 0默认

GL_LUMINANCE,//gpu内部格式亮度，灰度图

width/2, height/2,//拉升到全屏

0,//边框

GL_LUMINANCE,//数据的像素格式亮度，灰度图要与上面一致

GL_UNSIGNED_BYTE,//像素的数据类型

NULL//纹理的数据

);

//设置纹理属性

glBindTexture(GL_TEXTURE_2D, texts[2]);

//缩小的过滤器

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);

//设置纹理的格式和大小

glTexImage2D(GL_TEXTURE_2D,

0,//细节基本 0默认

GL_LUMINANCE,//gpu内部格式亮度，灰度图

width/2, height/2,//拉升到全屏

0,//边框

GL_LUMINANCE,//数据的像素格式亮度，灰度图要与上面一致

GL_UNSIGNED_BYTE,//像素的数据类型

NULL//纹理的数据

);

/*****************************************************************/

//纹理的修改和显示

unsignedchar*buf[3] = {0};

buf[0] =newunsignedchar[width * height];

buf[1] =newunsignedchar[width * height /4];

buf[2] =newunsignedchar[width * height /4];

for(inti =0; i <10000; i++) {

//420p yyyyyyyy uu vv

if(feof(fp) ==0) {

fread(buf[0],1, width*height, fp);

fread(buf[1],1, width*height /4, fp);

fread(buf[2],1, width*height /4, fp);

}

//激活第1层纹理,绑定到创建的opengl纹理

glActiveTexture(GL_TEXTURE0);

glBindTexture(GL_TEXTURE_2D, texts[0]);

//替换纹理内容

glTexSubImage2D(GL_TEXTURE_2D,0,0,0, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, buf[0]);

//激活第2层纹理,绑定到创建的opengl纹理

glActiveTexture(GL_TEXTURE0 +1);

glBindTexture(GL_TEXTURE_2D, texts[1]);

//替换纹理内容

glTexSubImage2D(GL_TEXTURE_2D,0,0,0, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, buf[1]);

//激活第2层纹理,绑定到创建的opengl纹理

glActiveTexture(GL_TEXTURE0 +2);

glBindTexture(GL_TEXTURE_2D, texts[2]);

//替换纹理内容

glTexSubImage2D(GL_TEXTURE_2D,0,0,0, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, buf[2]);

//三维绘制

glDrawArrays(GL_TRIANGLE_STRIP,0,4);

//窗口显示

eglSwapBuffers(display, winSurface);

}

env->ReleaseStringUTFChars(url_, url);

}

extern"C"

JNIEXPORT jstring JNICALL

Java_com_lichao_chaoplayer_MainActivity_TestJNI(JNIEnv *env, jobject instance) {

std::string hello ="Hello from C++";

returnenv->NewStringUTF(hello.c_str());

}

extern"C"

JNIEXPORTvoidJNICALL

Java_com_lichao_chaoplayer_ChaoPlay_InitView(JNIEnv *env, jobject instance, jobject surface) {

ANativeWindow *win =ANativeWindow_fromSurface(env,surface);

view->SetRender(win);

//ChaoEGL::Get()->Init(win);

//ChaoShader shader;

//shader.Init();

}

更多相关文章

随机推荐