MediaCodec解码，yuv贴图播放的实现

最近在研究stagefright视频显示时发现，yuv数据是在render里直接在surface上显示的，不需要yuv转换成RGB。参考AsomePlayer的代码，视频的每一帧是通过调用了SoftwareRenderer来渲染显示的，我参考SoftwareRenderer来直接render yuv数据显示。

　　这样的方式可以实现一些常用的功能，比如以后摄像头采集到的yuv，可以直接丢yuv数据到surface显示，无需耗时耗效率的yuv转RGB了。也可以使用MediaCode解码媒体文件，解码后的yuv数据直接贴图在surface上显示（android的播放器就是如此实现）。但是自己控制实现yuv贴图，可以实现yuv格式的转化，拉伸，旋转等操作。

     本文介绍从SoftwareRenderer提取核心部分代码，自己来实现yuv的显示。

　　SoftwareRenderer就只有三个方法，一个构造函数，一个析构函数，还有一个负责显示的render方法。构造方法里有个很重要的地方native_window_set_buffers_geometry这里是配置即将申请的图形缓冲区的宽高和颜色空间，忽略了这个地方，画面将用默认的值显示，将造成显示不正确。render函数里最重要的三个地方，一个的dequeBuffer，一个是mapper，一个是queue_buffer。

1. native_window_set_buffers_geometry;//设置宽高以及颜色空间yuv420  
2. native_window_dequeue_buffer_and_wait;//根据以上配置申请图形缓冲区  
3. mapper.lock(buf->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, bounds, &dst));//将申请到的图形缓冲区跨进程映射到用户空间  
4. memcpy(dst, data, dst_y_size + dst_c_size*2);//填充yuv数据到图形缓冲区  
5. mNativeWindow->queueBuffer;//显示  

以上五步是surface显示图形必不可少的五步。

#include <jni.h>
#include <android_runtime/AndroidRuntime.h>
#include <android_runtime/android_view_Surface.h>
#include <gui/Surface.h>
#include <assert.h>
#include <utils/Log.h>
#include <JNIHelp.h>
#include <media/stagefright/foundation/ADebug.h>
#include <ui/GraphicBufferMapper.h>
#include <cutils/properties.h>
using namespace android;

static uint64_t g_ulPts = 0;
static int hWidth = 0;
static int hHeight = 0;
static int halFormat = HAL_PIXEL_FORMAT_YV12;//颜色空间
static sp<Surface> surface;

static int ALIGN(int x, int y) {
// y must be a power of 2.
return (x + y - 1) & ~(y - 1);
}

static void render(
const void *data, size_t size, const sp<ANativeWindow> &nativeWindow){//,int width,int height) {
ALOGE("[%s]%d",__FILE__,__LINE__);
sp<ANativeWindow> mNativeWindow = nativeWindow;
int err;
int mCropWidth = hWidth;
int mCropHeight = hHeight;


int bufWidth = (mCropWidth + 1) & ~1;//按2对齐
int bufHeight = (mCropHeight + 1) & ~1;


ANativeWindowBuffer *buf;//描述buffer
//申请一块空闲的图形缓冲区
if ((err = native_window_dequeue_buffer_and_wait(mNativeWindow.get(),
&buf)) != 0) {
ALOGW("Surface::dequeueBuffer returned error %d", err);
return;
}

GraphicBufferMapper &mapper = GraphicBufferMapper::get();

Rect bounds(mCropWidth, mCropHeight);

void *dst;
CHECK_EQ(0, mapper.lock(//用来锁定一个图形缓冲区并将缓冲区映射到用户进程
buf->handle, GRALLOC_USAGE_SW_WRITE_OFTEN, bounds, &dst));//dst就指向图形缓冲区首地址

if (true){
const uint8_t *src_y = (const uint8_t *)data;
const uint8_t *src_u = (const uint8_t *)data + hWidth * hHeight;
const uint8_t *src_v = src_u + (hWidth / 2 * hHeight / 2);

uint8_t *dst_y = (uint8_t *)dst;
size_t dst_y_size = buf->stride * buf->height;
size_t dst_c_stride = ALIGN(buf->stride / 2, 16);
size_t dst_c_size = dst_c_stride * buf->height / 2;
uint8_t *dst_v = dst_y + dst_y_size;
uint8_t *dst_u = dst_v + dst_c_size;

for (int y = 0; y < mCropHeight; ++y) {
memcpy(dst_y, src_y, mCropWidth);

src_y += hWidth;
dst_y += buf->stride;
}

for (int y = 0; y < (mCropHeight + 1) / 2; ++y) {
memcpy(dst_u, src_u, (mCropWidth + 1) / 2);
memcpy(dst_v, src_v, (mCropWidth + 1) / 2);

src_u += hWidth / 2;
src_v += hWidth / 2;
dst_u += dst_c_stride;
dst_v += dst_c_stride;
}
}

CHECK_EQ(0, mapper.unlock(buf->handle));
native_window_set_buffers_timestamp(mNativeWindow.get(), g_ulPts);
ALOGW("Surface::queueBuffer returned");
if ((err = mNativeWindow->queueBuffer(mNativeWindow.get(), buf,
-1)) != 0) {
ALOGW("Surface::queueBuffer returned error %d", err);
}
buf = NULL;
}

static void nativeTest(){
ALOGE("[%s]%d",__FILE__,__LINE__);
}

static jboolean
nativeSetVideoSurface(JNIEnv *env, jobject thiz, jobject jsurface,jint width,jint height){
ALOGE("[%s]%d",__FILE__,__LINE__);
surface = android_view_Surface_getSurface(env, jsurface);
hWidth = width;
hHeight = height;
if(android::Surface::isValid(surface)){
ALOGE("surface is valid ");
}else {
ALOGE("surface is invalid ");
return false;
}
ALOGE("[%s][%d]\n",__FILE__,__LINE__);
sp<ANativeWindow> mNativeWindow = surface;
// Width must be multiple of 32???
//很重要,配置宽高和和指定颜色空间yuv420
//如果这里不配置好，下面deque_buffer只能去申请一个默认宽高的图形缓冲区
CHECK_EQ(0, native_window_set_buffers_geometry(
mNativeWindow.get(),
hWidth,
hHeight,
halFormat));
/*CHECK_EQ(0,
native_window_set_usage(
mNativeWindow.get(),
GRALLOC_USAGE_SW_READ_NEVER | GRALLOC_USAGE_SW_WRITE_OFTEN
| GRALLOC_USAGE_HW_TEXTURE | GRALLOC_USAGE_EXTERNAL_DISP));*/

CHECK_EQ(0,
native_window_set_scaling_mode(
mNativeWindow.get(),
NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW));//使用surfaceView能正常显示，显示效果也很好
// NATIVE_WINDOW_SCALING_MODE_SCALE_CROP));//使用这个模式surfaceView会花屏，textureView不会，textureView显示效果差，不清晰
g_ulPts = 0;
return true;
}
static void
nativeShowYUV(JNIEnv *env, jobject thiz,jbyteArray yuvData){//,jint width,jint height){
//ALOGE("width = %d,height = %d",width,height);
jint len = env->GetArrayLength(yuvData);
ALOGE("len = %d",len);
jbyte *byteBuf = env->GetByteArrayElements(yuvData, 0);
render(byteBuf,len,surface);
g_ulPts += 16000;
env->ReleaseByteArrayElements(yuvData, byteBuf, 0);
}
static JNINativeMethod gMethods[] = {
{"nativeTest", "()V", (void *)nativeTest},
{"nativeSetVideoSurface", "(Landroid/view/Surface;II)Z", (void *)nativeSetVideoSurface},
{"nativeShowYUV", "([B)V", (void *)nativeShowYUV},
};

static const char* const kClassPathName = "com/hpplay/happyplay/mainServer";

// This function only registers the native methods
static int register_com_example_myyuvviewer(JNIEnv *env)
{
ALOGE("[%s]%d",__FILE__,__LINE__);
return AndroidRuntime::registerNativeMethods(env,
kClassPathName, gMethods, NELEM(gMethods));
}

jint JNI_OnLoad(JavaVM* vm, void* reserved)
{
ALOGE("[%s]%d",__FILE__,__LINE__);
JNIEnv* env = NULL;
jint result = -1;

if (vm->GetEnv((void**) &env, JNI_VERSION_1_4) != JNI_OK) {
ALOGE("ERROR: GetEnv failed\n");
goto bail;
}
assert(env != NULL);
ALOGE("[%s]%d",__FILE__,__LINE__);
if (register_com_example_myyuvviewer(env) < 0) {
ALOGE("ERROR: MediaPlayer native registration failed\n");
goto bail;
}

/* success -- return valid version number */
result = JNI_VERSION_1_4;

bail:
return result;
}

 

Android.mk (依赖的库比较少)

1. LOCAL_PATH:= $(call my-dir)  
2. include $(CLEAR_VARS)  
3.   
4. LOCAL_SRC_FILES:= \  
5.     main.cpp  
6.       
7. LOCAL_SHARED_LIBRARIES := \  
8.     libcutils \  
9.     libutils \  
10.     libbinder \  
11.     libui \  
12.     libgui \  
13.     libstagefright_foundation  
14.       
15. LOCAL_MODULE:= MyShowYUV  
16.   
17. LOCAL_MODULE_TAGS := tests  
18.   
19. include $(BUILD_EXECUTABLE)  

 

 

本例子，使用Java创建UI并联合JNI层操作surface来直接显示yuv数据（yv12），开发环境为Android 4.4，全志A23平台。

1. package com.example.myyuvviewer;  
2.   
3. import java.io.File;  
4. import java.io.FileInputStream;  
5. import android.app.Activity;  
6. import android.os.Bundle;  
7. import android.os.Environment;  
8. import android.util.Log;  
9. import android.view.Surface;  
10. import android.view.SurfaceHolder;  
11. import android.view.SurfaceHolder.Callback;  
12. import android.view.SurfaceView;  
13.   
14. public class MainActivity extends Activity {  
15.   
16.     final private String TAG = "MyYUVViewer";  
17.     final private String FILE_NAME = "yuv_320_240.yuv";  
18.     private int width = 320;  
19.     private int height = 240;  
20.     private int size = width * height * 3/2;  
21.       
22.     @Override  
23.     protected void onCreate(Bundle savedInstanceState) {  
24.         super.onCreate(savedInstanceState);  
25.         setContentView(R.layout.activity_main);  
26.         nativeTest();  
27.         SurfaceView surfaceview = (SurfaceView) findViewById(R.id.surfaceView);  
28.         SurfaceHolder holder = surfaceview.getHolder();  
29.         holder.addCallback(new Callback(){  
30.   
31.             @Override  
32.             public void surfaceCreated(SurfaceHolder holder) {  
33.                 // TODO Auto-generated method stub  
34.                 Log.d(TAG,"surfaceCreated");  
35.                 byte[]yuvArray = new byte[size];  
36.                 readYUVFile(yuvArray, FILE_NAME);  
37.                 nativeSetVideoSurface(holder.getSurface(),width,height);  
38.                 nativeShowYUV(yuvArray);  
39.             }  
40.   
41.             @Override  
42.             public void surfaceChanged(SurfaceHolder holder, int format,  
43.                     int width, int height) {  
44.                 // TODO Auto-generated method stub  
45.                   
46.             }  
47.   
48.             @Override  
49.             public void surfaceDestroyed(SurfaceHolder holder) {  
50.                 // TODO Auto-generated method stub  
51.                   
52.             }});  
53.     }  
54.       
55.     private boolean readYUVFile(byte[] yuvArray,String filename){  
56.         try {  
57.             // 如果手机插入了SD卡，而且应用程序具有访问SD的权限  
58.             if (Environment.getExternalStorageState().equals(  
59.                     Environment.MEDIA_MOUNTED)) {  
60.                 // 获取SD卡对应的存储目录  
61.                 File sdCardDir = Environment.getExternalStorageDirectory();  
62.                 // 获取指定文件对应的输入流  
63.                 FileInputStream fis = new FileInputStream(  
64.                         sdCardDir.getCanonicalPath() +"/" + filename);  
65.                 fis.read(yuvArray, 0, size);  
66.                 fis.close();  
67.                 return true;  
68.             } else {  
69.                 return false;  
70.             }  
71.         }catch (Exception e) {  
72.             e.printStackTrace();  
73.             return false;  
74.         }  
75.     }  
76.     private native void nativeTest();  
77.     private native boolean nativeSetVideoSurface(Surface surface,int width,int height);  
78.     private native void nativeShowYUV(byte[] yuvArray);  
79.     static {  
80.         System.loadLibrary("showYUV");  
81.     }  
82. }  

activity_main.xml

<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"    

 android:layout_width="fill_parent"    

android:layout_height="fill_parent"    

android:orientation="vertical" >    

<SurfaceView    

android:id="@+id/surfaceView"    

android:layout_width="fill_parent"    

android:layout_height="360dp" />   

</LinearLayout>  

生成的so文件复制到Java项目里 与src并列的libs/armeabi目录下，没有就手动创建目录，

这样Eclipse会自动把so库打包进apk。

上述例子我没有测试过。

我是使用了Mediacodec来解码视频，解码后的yuv直接调用jni来贴图实现。JNI部分的实现是一样的，测试结果视频能正常显示。

MediaCodec的用法请参考api文档使用，这里给出MediaCodec解码后的步骤

outputBufferIndex = mPlaybackService.mMC.dequeueOutputBuffer(bufferInfo,33000);
if ( outputBufferIndex == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED)
{
outputBuffers = mPlaybackService.mMC.getOutputBuffers();
MiniLog.i(TAG,"MediaCodec outputBuffers Changed " + outputBufferIndex);
}
else if ( outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED)
{
outputBuffers = mPlaybackService.mMC.getOutputBuffers();
MiniLog.i(TAG,"MediaCodec outputformat Changed " + mPlaybackService.mMC.getOutputFormat());
MediaFormat mf = mPlaybackService.mMC.getOutputFormat();
mf.setInteger("width", mPlaybackService.mWidth);
mf.setInteger("height", mPlaybackService.mHeight);
yuvwidth = mPlaybackService.mWidth;
yuvheight = mPlaybackService.mHeight;
nativeSetVideoSurface(mPlaybackService.mS,yuvwidth,yuvheight);
}
else if (outputBufferIndex >= 0)
{
ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];
byte[] outData = new byte[bufferInfo.size];
outputBuffer.get(outData, 0, bufferInfo.size);

nativeShowYUV(outData);//,yuvwidth,yuvheight);
outputBuffer.clear();
mPlaybackService.mMC.releaseOutputBuffer(outputBufferIndex, true);

}

 

渲染yuv数据的两种思考方法

思路1：在Java中将Surface指针传递到jni层，lock之后就可以获得SurfaceInfo，进而取得要显示的surface格式、高度、宽度，在2.2/2.3版本，surface的Format一般都是RGB565格式，只用做一个颜色空间的转换，scaler就可以将yuv数据显示出来。
颜色空间转换和Scaler算是比较耗时的操作了。如何提高效率，scaler最好能交给Android的底层函数去做，如果有gpu的，底层函数直接会利用gpu，效率非常高，又不占用cpu资源。

思路2：
   参考framework中的AwesomePlayer，里面利用AwesomeLocalRenderer/AwesomeRemoteRenderer来实现解码出来的数据显示，这个效率应该非常高，但是平台的关联性会增加很多。
   调用接口比较简单，
   首先创建一个render，
               mVideoRenderer = new AwesomeRemoteRenderer(
                mClient.interface()->createRenderer(
                        mISurface, component,
                        (OMX_COLOR_FORMATTYPE)format,
                        decodedWidth, decodedHeight,
                        mVideoWidth, mVideoHeight,
                        rotationDegrees));

  直接调用render函数就可以显示了。
    virtual void render(MediaBuffer *buffer) {
        void *id;
        if (buffer->meta_data()->findPointer(kKeyBufferID, &id)) {
            mTarget->render((IOMX::buffer_id)id);
        }
    }
   其它的参数都很容易获得，关键是buffer_id 怎么获得？OMXCodec.cpp中有相关的可以参考。

 

参考资料

1、博客（出处：http://blog.csdn.net/tung214/article/details/37762487）

2、android源码里的/frameworks/av/media/libstagefright/AwesomePlayer.cpp 

                          /frameworks/av/media/libstagefright/colorconversion/SoftwareRenderer.cpp

3、MediaCodec的api接口

 

 

遇到的坑：

1、贴图到surfaceView的surface，横屏的分辨率能正常显示，但颜色值不对，竖屏分辨率的图显示花屏

     原因应该是yuv格式有很多，需要转换。显示的时候也跟分辩率相关。以下参数的修改就可能能解决问题。

　　CHECK_EQ(0,
　　native_window_set_scaling_mode(
　　mNativeWindow.get(),
　　NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW));//使用surfaceView能正常显示，显示效果也很好
　　// NATIVE_WINDOW_SCALING_MODE_SCALE_CROP));//使用这个模式surfaceView会花屏，textureView不会，textureView显示效果差，不清晰

2、使用surfaceView能正常显示yuv，但是如果连续贴图，surfaceView显示渲染速度跟不上，会很卡顿。

     这个跟函数调用流程有关，surface设置函数nativeSetVideoSurface，只在视频的第一帧显示时设置，后续就视频帧来就直接调用nativeShowYUV

    视频显示需要native_window_set_buffers_geometry native_window_set_scaling_mode不应该放到nativeShowYUV函数里去执行，因为这两个函数在同一个视频流里，只要设置一次就行了，如果放到nativeShowYUV里，每一帧数据都要执行一次这两个函数，效率会很低。造成显示速度跟不上，如果解码使用的是MediaCodec，解码也会堵塞。所以需要把这连个函数放到nativeSetVideoSurface里，在一开始设置一次就行了，这个相当于初始化。这样能使速度明显提升。

 

3、使用SerfaceView及TextureView的差异

　　a、使用TextrueView显示不清晰

　   b、使用TextrueView的渲染速度快，在（坑2）的情况下，比surfaceView快多了。

      c、使用TextrueView情况下，NATIVE_WINDOW_SCALING_MODE_SCALE_CROP NATIVE_WINDOW_SCALING_MODE_SCALE_TO_WINDOW都一样。

 

我是参考了android的系统源码，相当于直接扣出来的，遇到的问题其实不算多。很多都是参数的设置，调用流程的控制不对引起的。而且这种做法跟平台的差异相关，我使用的平台surfaceView跟textureView的效果差异挺大。网上有很多大神，用ffmpeg解码，也是yuv贴图，甚至yuv转rgb后显示，或者yuv格式的转换，旋转等操作，这些实现起来遇到的问题应该会比较多。

 

另外，建议遇到问题时候，多请教，跟身边的人讨论下，有时候遇到问题卡主了，应该多换换思路，换个方向。同时网上的参考，大家也应该根据实际情况使用，有时候别人的方案，能正常使用，但是应用到自己的程序，遇到问题，有可能是应用场景不一样，比如我参考http://blog.csdn.net/tung214/article/details/37762487里的实现没错，能正常显示，但是该例子有可能只是为了实现单图显示。而我的应用需要连续显示播放，所以完全照搬，就会遇到卡顿的问题了。如果有源码参考的情况下，大家还是要多看看源码，http://blog.csdn.net/tung214/article/details/37762487里的实现是参照android源码，可以当做启发，自己参照源码实现一遍，会了解得比较透彻。

 

 

 

转载于:https://www.cnblogs.com/seven-sky/p/6038297.html