在Android平台上实现H264解码

在Android平台上实现H264解码，一般采用开源的ffmpeg来实现，那么这就涉及一个问题：如何在android平台上移植ffmpeg?

这个移植的方法在网上有一大推，本人看得头晕，所以采用了一个取巧的办法：在android平台上编译XBMC的时候，编译成功后，在目录~/xbmc-android/tools/android/packaging/xbmc/lib/armeabi-v7a/ 下面就有编译好的ffmpeg的库，直接提取出来用就可以了

注：关于如何在android平台上编译XBMC，请看我之前的博文： http://www.linuxidc.com/Linux/2013-08/88544.htm

那么有了android平台上ffmpeg的库，如何在android平台上测试H264解码呢？

新建android app工程ffmpeg_android

gedit ./.bashrc

将 /opt/android-sdk-linux/tools 添加到 "PATH"环境变量中

android list targets

android create project --target 1 --name ffmpeg_android --path ~/workspace/ffmpeg_android --package com.modukaikai.ffmpeg --activity ffmpegActivity

 

将xbmc中的ffmpeg源码拷贝到工程ffmpeg_android的jni目录下

mkdir ~/workspace/ffmpeg_android/jni

cp -R ~/xbmc-android/lib/ffmpeg ~/workspace/ffmpeg_android/jni/

 

H264解码器的实现

vim ~/workspace/ffmpeg_android/jni/h264_decoder.h

以下是h264_decoder.h的代码：

#ifndef h264_decoder_h 
#define h264_decoder_h

extern "C" 
{ 
#include "libavformat/avformat.h" 
#include "libswscale/swscale.h" 
#include "libavcodec/avcodec.h" 

typedef void (*tp_avcodec_register_all)(void);
typedef AVCodec *(*tp_avcodec_find_decoder)(enum AVCodecID id);
typedef AVCodecContext *(*tp_avcodec_alloc_context3)(const AVCodec *codec);
typedef int (*tp_avcodec_open2)(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
typedef AVFrame *(*tp_avcodec_alloc_frame)(void);
typedef void (*tp_avcodec_free_frame)(AVFrame **frame);
typedef int (*tp_avcodec_decode_video2)(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt);
typedef int (*tp_avcodec_close)(AVCodecContext *avctx);
typedef void (*tp_av_free)(void *ptr);
typedef void (*tp_av_init_packet)(AVPacket *pkt);

class H264DecoderInterface
{
public:
H264DecoderInterface()
{
p_avcodec_register_all = NULL;
p_avcodec_find_decoder = NULL;
p_avcodec_alloc_context3 = NULL;
p_avcodec_open2 = NULL;
p_avcodec_alloc_frame = NULL;
p_avcodec_free_frame = NULL;
p_avcodec_decode_video2 = NULL;
p_avcodec_close = NULL;
p_av_free = NULL;
p_av_init_packet = NULL;
};

~H264DecoderInterface()
{
};

void (*p_avcodec_register_all)(void);
AVCodec *(*p_avcodec_find_decoder)(enum AVCodecID id);
AVCodecContext *(*p_avcodec_alloc_context3)(const AVCodec *codec);
int (*p_avcodec_open2)(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options);
AVFrame *(*p_avcodec_alloc_frame)(void);
void (*p_avcodec_free_frame)(AVFrame **frame);
int (*p_avcodec_decode_video2)(AVCodecContext *avctx, AVFrame *picture, int *got_picture_ptr, const AVPacket *avpkt);
int (*p_avcodec_close)(AVCodecContext *avctx);
void (*p_av_free)(void *ptr);
void (*p_av_init_packet)(AVPacket *pkt);
};

class h264_decoder 
{ 
public:
static bool loadLibrary(const char *libDir);
static bool unloadLibrary();

h264_decoder(); 
~h264_decoder();

bool open_h264_decoder(); 
unsigned long h264_decoder_process(unsigned char* pSrcData, unsigned long srcDataLen, unsigned char* pDstData, bool& bNoOutputDecData); 
bool close_h264_decoder(); 

void setFrameRate(int frameRate); 
void setResolution(int width, int height); 

private:
static void* avcodec_handle; 
static void* avfilter_handle; 
static void* avformat_handle; 
static void* avutil_handle; 
static void* postproc_handle; 
static void* swresample_handle; 
static void* swscale_handle;
static H264DecoderInterface *p_H264DecoderInterface;

struct AVCodec *p_AVCodec; 
struct AVCodecContext *p_AVCodecContext; 
struct AVFrame *p_AVFrame; 
struct AVPacket avPacket; 

int got_frame; 

bool isOpened; 

int video_frameRate; 
int video_width; 
int video_height; 
}; 
} 

#endif

vim ~/workspace/ffmpeg_Android/jni/h264_decoder.cpp

以下是h264_decoder.cpp的代码：

#include "h264_decoder.h"
#include <dlfcn.h> 
#include <string.h>

void* h264_decoder::avcodec_handle = NULL; 
void* h264_decoder::avfilter_handle = NULL; 
void* h264_decoder::avformat_handle = NULL; 
void* h264_decoder::avutil_handle = NULL; 
void* h264_decoder::postproc_handle = NULL; 
void* h264_decoder::swresample_handle = NULL; 
void* h264_decoder::swscale_handle = NULL;
H264DecoderInterface* h264_decoder::p_H264DecoderInterface = NULL;

bool h264_decoder::loadLibrary(const char *libDir)
{
char libPath[200];

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libavutil-52-arm.so"); 
h264_decoder::avutil_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::avutil_handle){ printf("load avutil library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libavcodec-54-arm.so");
h264_decoder::avcodec_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::avcodec_handle){ printf("load avcodec library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libavformat-54-arm.so"); 
h264_decoder::avformat_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::avformat_handle){ printf("load avformat library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libswresample-0-arm.so"); 
h264_decoder::swresample_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::swresample_handle){ printf("load swresample library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libpostproc-52-arm.so"); 
h264_decoder::postproc_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::postproc_handle){ printf("load postproc library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libswscale-2-arm.so"); 
h264_decoder::swscale_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::swscale_handle){ printf("load swscale library fail!\n"); printf("%s\n",dlerror());}

memset(libPath,0,sizeof(char)*200);
strcpy(libPath,libDir);
strcat(libPath,"/libavfilter-3-arm.so"); 
h264_decoder::avfilter_handle= dlopen(libPath, RTLD_NOW);
if(!h264_decoder::avfilter_handle){ printf("load avfilter library fail!\n"); printf("%s\n",dlerror());}


if(!h264_decoder::avcodec_handle || !h264_decoder::avfilter_handle || !h264_decoder::avformat_handle || !h264_decoder::avutil_handle || !h264_decoder::postproc_handle || !h264_decoder::swresample_handle || !h264_decoder::swscale_handle){
printf("load ffmpeg library fail!\n");
h264_decoder::unloadLibrary();
return false;
}else{
printf("load ffmpeg library success!\n");
}

h264_decoder::p_H264DecoderInterface = new H264DecoderInterface();
h264_decoder::p_H264DecoderInterface->p_avcodec_register_all = (tp_avcodec_register_all)dlsym(h264_decoder::avcodec_handle, "avcodec_register_all");
h264_decoder::p_H264DecoderInterface->p_avcodec_find_decoder = (tp_avcodec_find_decoder)dlsym(h264_decoder::avcodec_handle, "avcodec_find_decoder");
h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_context3 = (tp_avcodec_alloc_context3)dlsym(h264_decoder::avcodec_handle, "avcodec_alloc_context3");
h264_decoder::p_H264DecoderInterface->p_avcodec_open2 = (tp_avcodec_open2)dlsym(h264_decoder::avcodec_handle,"avcodec_open2");
h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_frame = (tp_avcodec_alloc_frame)dlsym(h264_decoder::avcodec_handle, "avcodec_alloc_frame");
h264_decoder::p_H264DecoderInterface->p_avcodec_free_frame = (tp_avcodec_free_frame)dlsym(h264_decoder::avcodec_handle, "avcodec_free_frame");
h264_decoder::p_H264DecoderInterface->p_avcodec_decode_video2 = (tp_avcodec_decode_video2)dlsym(h264_decoder::avcodec_handle, "avcodec_decode_video2");
h264_decoder::p_H264DecoderInterface->p_avcodec_close = (tp_avcodec_close)dlsym(h264_decoder::avcodec_handle, "avcodec_close");
h264_decoder::p_H264DecoderInterface->p_av_init_packet = (tp_av_init_packet)dlsym(h264_decoder::avcodec_handle, "av_init_packet");
h264_decoder::p_H264DecoderInterface->p_av_free = (tp_av_free)dlsym(h264_decoder::avutil_handle, "av_free");

if(!h264_decoder::p_H264DecoderInterface || !h264_decoder::p_H264DecoderInterface->p_avcodec_register_all || !h264_decoder::p_H264DecoderInterface->p_avcodec_find_decoder || !h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_context3 || !h264_decoder::p_H264DecoderInterface->p_avcodec_open2 || !h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_frame || !h264_decoder::p_H264DecoderInterface->p_avcodec_free_frame || !h264_decoder::p_H264DecoderInterface->p_avcodec_decode_video2 || !h264_decoder::p_H264DecoderInterface->p_avcodec_close || !h264_decoder::p_H264DecoderInterface->p_av_init_packet || !h264_decoder::p_H264DecoderInterface->p_av_free){
printf("load function symbols from ffmpeg library fail!\n");
h264_decoder::unloadLibrary();
return false;
}else{
printf("load function symbols from ffmpeg library success!\n");
}

return true;
}

bool h264_decoder::unloadLibrary()
{
if(h264_decoder::avcodec_handle)
{
dlclose(h264_decoder::avcodec_handle);
h264_decoder::avcodec_handle = NULL;
}

if(h264_decoder::avfilter_handle)
{
dlclose(h264_decoder::avfilter_handle);
h264_decoder::avfilter_handle = NULL;
} 

if(h264_decoder::avformat_handle)
{
dlclose(h264_decoder::avformat_handle);
h264_decoder::avformat_handle = NULL;
} 

if(h264_decoder::avutil_handle)
{
dlclose(h264_decoder::avutil_handle);
h264_decoder::avutil_handle = NULL;
}

if(h264_decoder::postproc_handle)
{
dlclose(h264_decoder::postproc_handle);
h264_decoder::postproc_handle = NULL;
}

if(h264_decoder::swresample_handle)
{
dlclose(h264_decoder::swresample_handle);
h264_decoder::swresample_handle = NULL;
}

if(h264_decoder::swscale_handle)
{
dlclose(h264_decoder::swscale_handle);
h264_decoder::swscale_handle = NULL;
}

if(h264_decoder::p_H264DecoderInterface)
{
delete h264_decoder::p_H264DecoderInterface;
h264_decoder::p_H264DecoderInterface = NULL;
}

return true;
}

h264_decoder::h264_decoder() 
{ 
p_AVCodec = NULL; 
p_AVCodecContext = NULL; 
p_AVFrame = NULL; 

isOpened = false; 

video_frameRate = 25; 
video_width = 0; 
video_height = 0; 

got_frame = 0; 

h264_decoder::p_H264DecoderInterface->p_av_init_packet(&avPacket);

} 

h264_decoder::~h264_decoder() 
{ 
this->close_h264_decoder(); 
}

void h264_decoder::setFrameRate(int frameRate) 
{ 
this->video_frameRate = frameRate; 
} 
void h264_decoder::setResolution(int width, int height) 
{ 
this->video_width = width; 
this->video_height = height; 
} 

bool h264_decoder::open_h264_decoder() 
{ 
if (isOpened) 
{ 
return true; 
} 

h264_decoder::p_H264DecoderInterface->p_avcodec_register_all(); 

p_AVCodec = h264_decoder::p_H264DecoderInterface->p_avcodec_find_decoder(AV_CODEC_ID_H264); 

if (NULL != p_AVCodec){ 
p_AVCodecContext = h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_context3(p_AVCodec); 

if (p_AVCodecContext != NULL){ 

p_AVCodecContext->time_base.num = 1; 
p_AVCodecContext->time_base.den = video_frameRate; 
p_AVCodecContext->bit_rate = 0; 
p_AVCodecContext->frame_number = 1; 
p_AVCodecContext->codec_type = AVMEDIA_TYPE_VIDEO; 

p_AVCodecContext->width = video_width; 
p_AVCodecContext->height = video_height; 

if (h264_decoder::p_H264DecoderInterface->p_avcodec_open2(p_AVCodecContext,p_AVCodec,NULL)==0){ 
p_AVFrame = h264_decoder::p_H264DecoderInterface->p_avcodec_alloc_frame(); 

if (p_AVFrame){ 
isOpened = true; 
return true; 
}else{ 
return false; 
} 

}else{ 
return false; 
} 

}else{ 
return false; 
} 
}else{ 
return false; 
} 

} 

unsigned long h264_decoder::h264_decoder_process(unsigned char* pSrcData, unsigned long srcDataLen, unsigned char* pDstData, bool& bNoOutputDecData) 
{ 
avPacket.data = pSrcData; 
avPacket.size = srcDataLen; 
avPacket.flags = AV_PKT_FLAG_KEY; 

int returnValue = h264_decoder::p_H264DecoderInterface->p_avcodec_decode_video2(p_AVCodecContext,p_AVFrame,&got_frame,&avPacket); 

if (returnValue<=0) 
{ 
bNoOutputDecData = true; 
return returnValue; 
} 

if (got_frame) 
{ 
// YUV 
for (int i = 0, nDataLen = 0; i<3; i++) 
{ 
int nShift = (i==0)?0:1; 

unsigned char* pYUVData = p_AVFrame->data[i]; 

for (int j=0; j<(p_AVCodecContext->height >> nShift); j++) 
{ 
memcpy(pDstData+nDataLen, pYUVData,(p_AVCodecContext->width >> nShift)); 
pYUVData += p_AVFrame->linesize[i]; 
nDataLen += (p_AVCodecContext->width >> nShift); 
} 
} 

bNoOutputDecData = false; 
}else{ 
bNoOutputDecData = true; 
} 

got_frame = 0; 

return returnValue; 
} 

bool h264_decoder::close_h264_decoder() 
{ 
if (p_AVFrame) 
{ 
h264_decoder::p_H264DecoderInterface->p_avcodec_free_frame(&p_AVFrame); 
p_AVFrame = NULL; 
} 

if (p_AVCodecContext) 
{ 
h264_decoder::p_H264DecoderInterface->p_avcodec_close(p_AVCodecContext); 
h264_decoder::p_H264DecoderInterface->p_av_free(p_AVCodecContext); 
p_AVCodecContext = NULL; 
} 

p_AVCodec = NULL; 

isOpened = false; 

video_frameRate = 25; 
video_width = 0; 
video_height = 0; 

got_frame = 0; 

h264_decoder::p_H264DecoderInterface->p_av_init_packet(&avPacket); 

return true; 
}

vim ~/workspace/ffmpeg_android/jni/ffmpeg_main.cpp

以下是ffmpeg_main.cpp的代码：

#include "h264_decoder.h"

int main(int argc, char* argv[]) 
{
if(!h264_decoder::loadLibrary("/data/ffmpeg/ffmpeg_libs"))
{
return -1;
}

h264_decoder *p_decoder = NULL; 
p_decoder = new h264_decoder;
if(!p_decoder)
{
return -1;
} 

FILE *inputFile = NULL; 
FILE *outputFile = NULL;

inputFile = fopen("h264_640x480.h264","rb");
if(!inputFile){
printf("open h264_640x480.h264 fail!\n");
return -1;
} 
outputFile = fopen("yuv_640x480.yuv","wb");
if(!outputFile){
printf("open yuv_640x480.yuv fail!\n");
return -1;
}


unsigned char *inputData; 
unsigned char *outputData; 

inputData = (unsigned char *)malloc(640*480*3/2*sizeof(unsigned char)); 
outputData = (unsigned char *)malloc(640*480*3/2*sizeof(unsigned char)); 

unsigned long inputDataSizeArray[10] = {2896,1406,1952,2218,1190,3228,706,2418,2038,1871}; 

bool bNoOutputDecData = true; 

p_decoder->setFrameRate(25); 
p_decoder->setResolution(640,480);


if(!p_decoder->open_h264_decoder())
{
printf("open_h264_decoder fail!\n");
return -1;
} 

printf("start decode ...\n"); 

for (int i=0; i < 10; i++) 
{ 
fread(inputData,1,inputDataSizeArray[i],inputFile); 

bNoOutputDecData = true; 
unsigned long res = p_decoder->h264_decoder_process(inputData,inputDataSizeArray[i],outputData,bNoOutputDecData); 

if (res>0 && !bNoOutputDecData) 
{ 
fwrite(outputData,640*480*3/2,1,outputFile); 
} 
} 

printf("end decode ...\n"); 

p_decoder->close_h264_decoder();
delete p_decoder;
p_decoder = NULL;

fclose(inputFile); 
fclose(outputFile); 


if (inputData) 
{ 
free(inputData); 
inputData = NULL; 
} 

if (outputData) 
{ 
free(outputData); 
outputData = NULL; 
} 

h264_decoder::unloadLibrary();

return 0; 
}