X264编码实现
H264
H264的官方测试源码，由德国hhi研究所负责开发。
特点：实现了264所有的特性，由于是官方的测试源码，所以学术研究的算法都是在JM基础上实现并和JM进行比较。但其程序结构冗长，
只考虑引入各种新特性以提高编码性能，忽视了编码复杂度，其编码复杂度极高，不宜实用。
X264
网上自由组织联合开发的兼容264标准码流的编码器，创始人是一个法国人。X264在网上的口碑极佳。
特点：注重实用。和JM相比，在不明显降低编码性能的前提下，努力降低编码的计算复杂度，故X264摈弃了264中一些对编码性能贡献
微笑但计算复杂度极高的新特性，如多参考帧、帧间预测中不必要的块模式、CABAC等。
编码格式输出：
总的来说H264的码流的打包方式有两种，一种为annex-b byte stream format的格式，这个是绝大部分编码器的默认输出格式，就是
每个帧的开头的3~4个字节是H264的start_code,0x00000001或者0x000001。
另一种是原始的NAL打包格式，就是开始的若干字节（1，2，4字节）是NAL的长度，而不是start_code,此时必须借助某个全局的数据
来获得编码器的profile,level,PPS,SPS等信息才可以解码。
h264encoder.h
/**
*
* Created on: Dec 10, 2010
* Author: Henry.wen
*/
#ifndef _H264ENCODER_H
#define _H264ENCODER_H
#include <stdint.h>
#include <inttypes.h>
extern "C"
{
#include "matroska.h"
}
void save_image(const char* filePath, const void* bufferBase, int width, int height);
int encoder_init(const char* filePath, int width, int height);
int encoder_frame(const void* frame);
void encoder_close();
#endif
h264encoder.cpp
extern "C"
{
#include <matroska.h>
}
#include <skia/core/SkBitmap.h>
#include <skia/images/SkImageEncoder.h>
#include <android_runtime/AndroidRuntime.h>
#include "h264encoder.h"
#ifndef X264_MAX
#define X264_MAX( a, b ) ( (a) < (b) ? (b) : (a))
#endif
x264_param_t g_param;
x264_picture_t g_pic_in;
x264_picture_t g_pic_out;
x264_t *g_encoder = NULL;
int g_width = 0;
int g_height = 0;
FILE* g_file = 0;
int64_t g_pts = 0;
int g_flagInit = 0;
using namespace android;
static Mutex sg_mutexLock;
#ifndef LOGI
#define LOGI(...) ((void)__android_log_print("H264ENCODE", MOBIHEARTCAMERA_LOG_TAG, __VA_ARGS__))
#endif
void save_image(const char* filePath, const void* bufferBase, int width, int height)
{
Mutex::Autolock lock(sg_mutexLock);
SkBitmap b;
b.setConfig(SkBitmap::kARGB_8888_Config, width, height);
b.setPixels((void*)bufferBase);
SkImageEncoder::EncodeFile(filePath, b, SkImageEncoder::kJPEG_Type, SkImageEncoder::kDefaultQuality);
}
int encoder_init(const char* filePath, int width, int height)
{
LOGI("encoder_init ============begin");
if(g_flagInit != 0)
{
LOGI("encoder_init have encoding!");
return 0;
}
Mutex::Autolock lock(sg_mutexLock);
x264_param_default_preset(&g_param, "fast", "zerolatency");
g_param.i_width = width;
g_param.i_height = height;
g_param.i_fps_num = 25;
g_param.i_fps_den = 1;
g_width = width;
g_height = height;
g_param.i_keyint_max = 25;
g_param.b_intra_refresh = 1;
g_param.b_annexb = 1;
x264_param_apply_profile(&g_param, x264_profile_names[0]);
g_encoder = x264_encoder_open(&g_param);
if(g_encoder == 0)
{
LOGI("encoder_init open encoder fail!");
return -1;
}
g_param.rc.i_lookahead = 0;
if( 0 != x264_picture_alloc(&g_pic_in, X264_CSP_I420, width, height))//X264_CSP_I420
{
LOGI("encoder_init alloc picture fail!");
x264_encoder_close(g_encoder);
g_encoder = 0;
return -1;
}
g_file = fopen(filePath, "w+b");
if(g_file == NULL)
{
x264_encoder_close(g_encoder);
g_encoder = 0;
return -1;
}
g_flagInit = 1;
g_pts = 0;
return 0;
}
int encoder_frame(const void* frame)
{
LOGI("encoder_frame ============begin");
if(g_flagInit > 0)
{
Mutex::Autolock lock(sg_mutexLock);
g_pic_in.img.plane[0] = (uint8_t*)frame;
uint8_t* tmpBuffer_uv = g_pic_in.img.plane[0] + g_width * g_height;
uint8_t* tmpBuffer_u = g_pic_in.img.plane[1];
uint8_t* tmpBuffer_v = g_pic_in.img.plane[2];
int index = 0;
for(int j = 0, nCount = (g_height >> 1) * g_width; j < nCount; j +=2)
{
*(tmpBuffer_u + index) = *(tmpBuffer_uv + index);
*(tmpBuffer_v + index + 1) = *(tmpBuffer_uv + index + 1);
++index;
}
int nnal;
x264_nal_t *nals;
g_pic_in.i_pts = g_pts;
g_pic_in.i_type = X264_TYPE_AUTO;
int ret = x264_encoder_encode(g_encoder, &nals, &nnal, &g_pic_in, &g_pic_out);
if( ret < 0)
{
LOGI("encoder_frame encode frame fail, ret = %d", ret);
return 0;
}
++g_pts;
fwrite(nals[0].p_payload, ret, 1, g_file );
}
LOGI("encoder_frame ============end");
return 0;
}
void encoder_close()
{
LOGI("encoder_close ============begin");
Mutex::Autolock lock(sg_mutexLock);
if(g_encoder)
x264_encoder_close(g_encoder);
g_encoder = 0;
if(g_file)
fclose(g_file);
g_file = 0;
g_flagInit = 0;
LOGI("encoder_close ============end");
}