X264编码实现

/**
*
* 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

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");
}