Android & IOS视频录制技术方案

转载文章请注明出处：http://write.blog.csdn.net/postedit/48104617

移动端视频录制的技术方案，我所能想到并且尝试过的，有如下几种：

方案一： 用系统开发sdk录制的接口。

弊端：

 1）： 不能更改视频比例，一般都有该手机屏幕分辨率所对应得视频录制分辨率，另外手机系统提供得分辨率一般为4：3或接近4：3，即全屏录制。为了保证用户录制时看到的视频视频和最终生成得视频一致，那么在录制界面上也需要全屏显示才行。（IOS可以再生成视频之后调用系统接口裁剪，不过在Iphone6上一份中视频也要用户等待大约十秒钟才能裁剪完成，毕竟解码+处理+编码是很耗时得操作。后面具体说），方案三四五可以解决。
 2）： （仅Android系统，IOS不纯在该问题）竖屏录制生成的视频拿到pc端用大多数播放器播放出来都是被旋转的。其实并不是视频被播放器旋转了，而是视频本身就是旋转的。因为手机默认是横屏录制，也就是无论你怎么拿着手机，传送到视频压缩时候，每一帧都是横着的，所以假如视频是竖屏录制，被传送过去时候会被旋转，旋转的度数取决于用户摄像头的方向。之所以手机上播放是正常得，那是因为Android会在录制时候调用重力感应判断出方向，并且在视频流的头文件中填入度数，在调用android开发sdk所提供得接口播放视频得时候，会解析该角度，并在播放时候作出旋转，而大多数播放器是忽视该参数的，比如：Mplayer  VLC 都不会作出旋转。解析视频头文件的开源库应该都能解析该参数，列出ffmpeg解析该参数得代码：

/*
*read rotation angle by video param and key
*return angle in [0,360]
*/
char* get_video_metadate(char* key ,AVFormatContext *ic, AVStream *video_st)
{
	char *value; 	
	if (!ic) {
		return 0;
	}

	if (key) {
		if (av_dict_get(ic->metadata, key, NULL, AV_DICT_IGNORE_SUFFIX)) {
			value =av_dict_get(ic->metadata, key, NULL, AV_DICT_IGNORE_SUFFIX)->value;
		}else if (video_st && av_dict_get(video_st->metadata, key, NULL,
		AV_DICT_IGNORE_SUFFIX)) {
			value = av_dict_get(video_st->metadata, key, NULL,
			AV_DICT_IGNORE_SUFFIX)->value;
		}
	}
	return value;
	
}

/*
*read rotation angle by param
*@param ic :the context of video
*@param video_st: the video avstream 
*@return angle in [0,360]
*/
int get_rotation_byparam(AVFormatContext *ic, AVStream *video_st)
{
	char * value;
	int ret;
	value = get_video_metadate("rotate",ic,video_st);
    if(value ==NULL)
        return 0;
    else if((strcmp(value,"90")&&strcmp(value,"180")&&strcmp(value,"270")))
		ret = 0;
	else
    {
	    ret = chartoint(value);
        
    }
	if(ret!=90&&ret!=180&&ret!=270)
		ret = 0;
    dmprint("[@metadate]the rotation angle is ",ret);
	return (ret > 0 && ret < 360) ? ret : 0;
}

其实就是解析头文件中"rotate"所对应的value。另外头文件中还有很多内容，例如分辨率、时长、日期、地址等。这是使用ffmpeg，Android上使用mp4info这个第三方jar包也可已实现，而且轻量级，比ffmpeg小很多。（方案二三四五可以解决）。

3） 文件过大。Android端可选摄像头所采用的分辨率，通过：Camera.Parameters 中的 setPreviewSize ( w , h ) ;方法定义。但是前提是系统必须拥有该分辨率选项，并不是该分辨率是可以你随意填写的， 需要事先通过 getSupportedPictureSizes() 方法获取所支持的分辨率，然后从中挑选一个最理想的。但是有一些手机所支持得分辨率组合很少，比如魅族的那个魅蓝，如果没有记错只支持一个：1920*1280，再加上一般手机录制得视频帧率是30 等等这些参数的默认值，虽然Android默认是h264高效率压缩编码，但是用系统默认参数所录制的视频也是很大的。很多手机录制1分钟视频大小近百兆。假如想要通过网络上传，这种方案基本就可以毙掉了。（使用方案三四五可以解决）。

4） （IOS不存在该问题）不支持断点录制。现在移动端大多短视频录制的APP都支持断点录制，而用使用Android系统封装得接口录制时候，每次录制都要重定向一个输出文件（使用方案二三四五可以解决）。

优点：
1）因为有硬件加速，所以速度很快，而且质量很好。
2）开发轻松，有现成接口可调用。

实现：
现成接口，网上资料很多，还有官方文档，不再列出。

方案二：（针对Android 不支持断点录制和视频旋转的问题） 使用系统录制接口+mp4parser

用户点击暂停时候，重定向mp4文件，然后通过mp4parser合并每段mp4.

mp4parser是个轻量级的jar包，android上可以直接导入使用。所提供的接口可以实现拼接分割mp4文件。它并没有更改帧得内容，只是再解析mp4得各种BOX，然后更改pts和头文件，分割，合并。所以速度还是可以接受的。

缺点：
1） 仍然存在文件过大得问题。
2） 仍然局限于系统提供得分辨率。

优点：
1） 导入的库较小。
2） 速度理想。


实现：
录制视频代码省去，列出拼接mp4代码：

List fileList = new ArrayList();
List moviesList = new LinkedList();
fileList.add("/1387865774255.mp4");
fileList.add("/1387865800664.mp4");

try
{
	for (String file : fileList)
	{
		moviesList.add(MovieCreator.build(file));
	}
}
catch (IOException e)
{
	e.printStackTrace();
}
		
List videoTracks = new LinkedList();
List audioTracks = new LinkedList();
for (Movie m : moviesList)
{
	for (Track t : m.getTracks())
	{
		if (t.getHandler().equals("soun"))
		{
			audioTracks.add(t);
		}
		if (t.getHandler().equals("vide"))
		{
			videoTracks.add(t);
		}
	}
}

Movie result = new Movie();

try
{
	if (audioTracks.size() > 0) 
	{
		result.addTrack(new AppendTrack(audioTracks.toArray(new Track[audioTracks.size()])));
	}
	if (videoTracks.size() > 0) 
	{
		result.addTrack(new AppendTrack(videoTracks.toArray(new Track[videoTracks.size()])));
	}
}
catch (IOException e)
{
	// TODO Auto-generated catch block
	e.printStackTrace();
}

Container out = new DefaultMp4Builder().build(result);

try
{
	FileChannel fc = new RandomAccessFile("output.mp4", "rw").getChannel();
	out.writeContainer(fc);
	fc.close();
}
catch (Exception e)
{
	// TODO Auto-generated catch block
	e.printStackTrace();
}
		
moviesList.clear();
fileList.clear();

此部分代码出自： http://cstriker1407.info/blog/android-application-development-notes-mp4parser/。
简单看了下，用了这么多movie和集合，效率较低，有时间换成自己优化后的代码。

另外他也可以实现视频旋转：

IsoFile isoFile = new IsoFile(getCompleteFilePath(i));
        Movie m = new Movie();

        List trackBoxes = isoFile.getMovieBox().getBoxes(
                TrackBox.class);

        for (TrackBox trackBox : trackBoxes) {

            trackBox.getTrackHeaderBox().setMatrix(Matrix.ROTATE_90);
            m.addTrack(new Mp4TrackImpl(trackBox));

        }
        inMovies[i - 1] = m;

方案三：（IOS不可用）mp4parser+mp4v2 + x264+系统录音

用x264压缩每帧数据，通过系统录制aac，使用mp4v2合并每段音视频，再通过mp4parser拼接每段mp4.
缺点：

1） 开发复杂，无论是UI还是ndk都是比较麻烦的，而且涉及到音视频同步得问题。

优点：
1） 导入的库较小。
2） 解决方案一中所提到的所有弊端。

实现：

步骤一：
先要交叉编译mp4V2 和 x264.
步骤二：
android上从摄像头定时（时间间隔控制不好，视频会出现假卡顿现象）获取图像data，获取得数据没有yuv420p的，所以需要格式转换，为了令用户录制时候看到得视频和生成视频一致，需要ui作出遮挡，然后裁剪。java层通过重力感应判断摄像头方向进行旋转。网上现有的得算法效率太低，日后会给出优化后的针对android的算法。
步骤三：
通过jni传送给x264进行编码，列出jni关键代码：
准备：

JNIEXPORT jint JNICALL Java_com_dangyutao_test_encode_startEncode(
		JNIEnv *env, jclass class, jstring jstr, jint w, jint h, jint o,jboolean inv) {
	//定义屏幕录制方向
	if(o!=3&&o!=0)
	{
		isInversion = inv;
		orientation = o;
	}

	//初始化编码器
	WIDTH = w;
	HEIGHT = h;
	yuv_size = w * h * 3 / 2;
	x264_param_t param;
	x264_param_default(@param);
	x264_param_default_preset(@param, "ultrafast", "zerolatency");

	param.i_threads = ENCODE_THREAD;
	param.i_width = WIDTH;
	param.i_height = HEIGHT;
	param.i_fps_num = FPS;
	param.i_fps_den = 1;
	param.i_frame_total = 0;
	param.i_csp = CSP;
	param.i_keyint_min = FPS*3;
	param.i_keyint_max = FPS*10;
	param.i_bframe=30;
	param.i_bframe_bias = 100;
	param.rc.i_qp_min = 25;
	param.rc.i_qp_max =50;

	param.rc.i_rc_method = X264_RC_CRF;//参数i_rc_method表示码率控制，CQP(恒定质量/视频很大，码率 和 图像效果参数失效)，CRF(恒定码率/会根据参数定义)，ABR(平均码率/会根据参数设定)

	param.rc.i_bitrate = 2000000;
	//图片质量损失损失  越小越清晰，默认23 最小0
	param.rc.f_rf_constant = 3;


	//流参数*/
	/*
	 param.i_bframe = 5;
	 param.b_open_gop = 0;
	 param.i_bframe_pyramid = 0;
	 param.i_bframe_adaptive = X264_B_ADAPT_TRELLIS;

	 param.b_annexb = 1;
	 */
	x264_param_apply_profile(¶m, "baseline");
	encoder = x264_encoder_open(¶m);

	 //初始化输入文件描述符
	 outf = open(jstringTostring(env, jstr), O_CREAT | O_WRONLY, 444);
	 if (outf < 0) {
		 x264_encoder_close(encoder);
		 free(yuv_buffer);
		 close(inf);
		 return -1;
	 }
 	//申請處理的緩存内存
	 yuv = (uint8_t *) malloc(WIDTH * HEIGHT * 3 / 2);
	 return 0;
}

添加帧数据：

JNIEXPORT jint JNICALL Java_com_dangyutao_test_encode_addDetailFrameByBuff(
		JNIEnv *env, jclass class, jbyteArray jb, jint nw, jint nh, jint w,
		jint h, jboolean isFrontCamera) {
	jbyte* dataPtr = (*env)->GetByteArrayElements(env, jb, NULL);
	uint8_t* buffer = (uint8_t*) dataPtr;

	detailYuvPic(buffer, yuv, nw, nh, w, h, isFrontCamera);

	//初始化pic——in
	x264_picture_alloc(&pic_in, CSP, WIDTH, HEIGHT);

	//用java传来的buff，将yuvbuff填充，
	yuv_buffer = (uint8_t*) yuv;

	/*
	 //rgb:
	 pic_in.img.i_plane = 1;
	 pic_in.img.plane[0] = yuv_buffer;
	 pic_in.img.i_stride[0] = 3 * WIDTH;
	 */

	//yuv420:将yuvbuff 填充进pic_in
	pic_in.img.plane[0] = yuv_buffer;
	pic_in.img.plane[1] = &yuv_buffer[WIDTH * HEIGHT];

	pic_in.img.plane[2] = &yuv_buffer[WIDTH * HEIGHT * 5 / 4];

	pic_in.img.i_plane = 3;
	/*
	 pic_in.img.i_stride[0] = WIDTH;
	 pic_in.img.i_stride[1] = WIDTH / 2;
	 pic_in.img.i_stride[2] = WIDTH / 2;
	 */
	pic_in.img.i_csp = CSP;
	//pic_in.i_type = X264_TYPE_AUTO;
	//编码

	x264_nal_t *nals;
	int nnal;
	pic_in.i_pts = i_pts++;

	x264_encoder_encode(encoder, &nals, &nnal, &pic_in, &pic_out);
	x264_nal_t *nal;
	for (nal = nals; nal < nals + nnal; nal++) {
		write(outf, nal->p_payload, nal->i_payload);
	}

	//释放多余内存
	(*env)->ReleaseByteArrayElements(env, jb, dataPtr, JNI_ABORT);
	//LOG("ENCODE OVER");
	return 0;

}

扫尾:

JNIEXPORT jint JNICALL Java_com_dangyutao_test_encode_finishEncode(
		JNIEnv *env, jclass class) {
	//扫尾
	x264_encoder_close(encoder);
	free(yuv);
	close(outf);
	//free(yuv_buffer); //添加buff时内存已经释放
	return 0;
}

步骤四：用mp4V2合并每段音视频
参考：http://blog.csdn.net/yaorongzhen123/article/details/8467529
http://www.cnblogs.com/lidabo/p/3832634.html；

步骤五：用mp4parser合并每段mp4文件。
方案二中已给出代码。


方案四：系统录制+ffmpeg直接编译使用（android ios都可用）

ffmpeg 的 功能真的很强大，而且通过新filter库可以实现视频处理得大多数功能，不过库的也很大。拿过来ffmpeg得源码稍微修改编译之后，可以通过很简单的接口调用，具体调用命令可以看ffmpeg得官网。系统录制视频，录制完成后通过ffmpeg做后期处理，旋转转码裁剪等。

优点
1） 功能强大
2） 开发简单
缺点：
1） 库过大
2）本质是录制完成后再用ffmpeg做处理，所以 需要用户等待得时间很长，android上用nexus4做测试，基本跟视频长度等长，即一份钟视频转码需要大约一份钟（只是这样得时间概念，并不精准。）

实现：
交叉编译即可。

方案五：ffmpeg基础上二次开发。
通过ffmpeg编码每帧视频。再音视频合并。
优点：
1） 功能强大。

缺点：
1） 开发难度大，ffmpeg得头文件比x264多太多。
2） 相比x264效率不高。ffmpeg编码模块也是调用x264，但是在测试时候发现，相比直接用x264效率差很多，主要是因为ffmpeg是面向对象架构的，其中有很多每必要得模块都在不停得初始化（只是猜测，源码并没有细看），每个模块得使用都有相应得context。
3） 库大
4） 相比系统录制再转码速度快。由于这是在二次开发，所以可以直接通过ffmpeg进行生成视频，nexus4基本是零延迟。录制完成后即刻生成理想得视频，不用用户等待。
5） 效率高。跟我实现得算法相比，ffmpeg的scale和filter的速度真是很快，自己很好奇的深究源码，发现原来算法大同小异，只是它是直接使用汇编指令，跳过系统直接调用cpu。
实现：

代码太多日后详细给出，关键流程：

初始化    AVCodecContext；参数详解也在日后给出。
配置输入输出的。
编码  avcodec_encode_video2(temp->pCodecCtx, &encode_pkt, writeframe, &got_picture);
关闭流。释放内存。



方案六：ffmpeg+x264

这种方案以我本人经验是最好的。但是开发难度也跟着上来。这种开发方案有很多，音频可以直接录制pcm，交给ffmpeg中得faac压缩，也可以用系统录制aac，然后使用x264对每帧编码，再用ffmpeg做音视频合并，ffmpeg还可以提供后期处理。

优点：
1） 解决以上所提到得所有弊端。

缺点：
1） 开发难度大。
2） 库大。
实现方案：参考以上。
列出ffmpeg合并音视频的代码：

int dm_mux(char* h264file,char *aacfile, char* mp4file,int usefilter)
{

	
	AVOutputFormat *ofmt = NULL;
	//Input AVFormatContext and Output AVFormatContext
	AVFormatContext *ifmt_ctx_v = NULL, *ifmt_ctx_a = NULL,*ofmt_ctx = NULL;
	AVPacket pkt;
	int ret, i,retu =0,filter_ret=0;
//	int fps;
	int videoindex_v=-1,videoindex_out=-1;
	int audioindex_a=-1,audioindex_out=-1;
	int frame_index=0;
	int64_t cur_pts_v=0,cur_pts_a=0;
	//set file path
	const char *in_filename_v = h264file;
	const char *in_filename_a = aacfile;
	const char *out_filename = mp4file;
	AVBitStreamFilterContext* aacbsfc;

	//register before use
	av_register_all();
	//open Input and set avformatcontext
	if ((ret = avformat_open_input(&ifmt_ctx_a, in_filename_a, 0, 0)) < 0) {
		retu = -1;//-1 mean audio file opened failed
		dmprint("open audio file failed",ret);
		goto end;
	}
	if ((ret = avformat_open_input(&ifmt_ctx_v, in_filename_v, 0, 0)) < 0) {
		retu = -2; //-2 mean video file opened failed
		dmprint("open video file failed",ret);
		goto end;
	}
	if ((ret = avformat_find_stream_info(ifmt_ctx_v, 0)) < 0) {

		retu = -3; //-3 mean get video info failed
		dmprint("get video info failed",ret);
		goto end;
	}


	if ((ret = avformat_find_stream_info(ifmt_ctx_a, 0)) < 0) {
		retu = -4;//-4 mean get audio info failed
		dmprint("get audio info failed ret = ",ret);
		goto end;
	}

	//open Output
	avformat_alloc_output_context2(&ofmt_ctx, NULL, NULL, out_filename);
	if (!ofmt_ctx) {
		dmprint("open output file failed",ret);
		retu = -5;
		goto end;
	}
	ofmt = ofmt_ctx->oformat;
	//find all video stream input type
	for (i = 0; i < ifmt_ctx_v->nb_streams; i++) {
		//Create output AVStream according to input AVStream
		if(ifmt_ctx_v->streams[i]->codec->codec_type==AVMEDIA_TYPE_VIDEO){
		AVStream *in_stream = ifmt_ctx_v->streams[i];
		AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);
		videoindex_v=i;
		if (!out_stream) {
			dmprint_string( "Failed allocating output stream");
			retu = -6;
			goto end;
		}
		videoindex_out=out_stream->index;
		//Copy the settings of AVCodecContext
		if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
			dmprint_string( "Failed to copy context from input to output stream codec context");
			retu = -7;
			goto end;
		}
		out_stream->codec->codec_tag = 0;
		if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
			out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
		break;
		}
	}

	//find all audio stream input type
	for (i = 0; i < ifmt_ctx_a->nb_streams; i++) {
		//Create output AVStream according to input AVStream
		if(ifmt_ctx_a->streams[i]->codec->codec_type==AVMEDIA_TYPE_AUDIO){
			AVStream *in_stream = ifmt_ctx_a->streams[i];
			AVStream *out_stream = avformat_new_stream(ofmt_ctx, in_stream->codec->codec);
			audioindex_a=i;
			if (!out_stream) {
				dmprint_string("Failed allocating output stream");
				retu = -8;
				goto end;
			}
			audioindex_out=out_stream->index;
			//Copy the settings of AVCodecContext
			if (avcodec_copy_context(out_stream->codec, in_stream->codec) < 0) {
				dmprint_string( "Failed to copy context from input to output stream codec context");
				retu =-9;
				goto end;
			}
			out_stream->codec->codec_tag = 0;
			if (ofmt_ctx->oformat->flags & AVFMT_GLOBALHEADER)
				out_stream->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;

			break;
		}
	}

	//Open output file
	if (!(ofmt->flags & AVFMT_NOFILE)) {
		if (avio_open(&ofmt_ctx->pb, out_filename, AVIO_FLAG_WRITE) < 0) {
			dmprint_string( "Could not open output file ");
			retu = -10;
			goto end;
		}
	}
	//Write file header
	if (avformat_write_header(ofmt_ctx, NULL) < 0) {
		dmprint_string( "Error occurred when opening output file");
		retu = -11;
		goto end;
	}
	if(usefilter)
		aacbsfc = av_bitstream_filter_init("aac_adtstoasc");

	while (IS_GOING) {
		AVFormatContext *ifmt_ctx;
		int stream_index=0;
		AVStream *in_stream, *out_stream;
		//Get an AVPacket
		if(av_compare_ts(cur_pts_v,ifmt_ctx_v->streams[videoindex_v]->time_base,cur_pts_a,
					ifmt_ctx_a->streams[audioindex_a]->time_base) <= 0)
		{
			ifmt_ctx=ifmt_ctx_v;
			stream_index=videoindex_out;
			if(av_read_frame(ifmt_ctx, &pkt) >= 0){

				do{
					in_stream  = ifmt_ctx->streams[pkt.stream_index];
					out_stream = ofmt_ctx->streams[stream_index];
					if(pkt.stream_index==videoindex_v){

						//Simple Write PTS
						if(pkt.pts==AV_NOPTS_VALUE){

							//Write PTS
							AVRational time_base1=in_stream->time_base;
							//Duration between 2 frames (us)
							int64_t calc_duration=(double)AV_TIME_BASE/av_q2d(in_stream->r_frame_rate);
							//Parameters
							pkt.pts=(double)(frame_index*calc_duration)/(double)(av_q2d(time_base1)*AV_TIME_BASE);
							pkt.dts=pkt.pts;
							pkt.duration=(double)calc_duration/(double)(av_q2d(time_base1)*AV_TIME_BASE);
							frame_index++;
						}
						cur_pts_v=pkt.pts;
						break;
					}
				}
				while(av_read_frame(ifmt_ctx, &pkt) >= 0);
			}
			else
			{
				break;
			}
		}
		else
		{
			ifmt_ctx=ifmt_ctx_a;
			stream_index=audioindex_out;
			if(av_read_frame(ifmt_ctx, &pkt) >= 0){
				do
				{
					in_stream  = ifmt_ctx->streams[pkt.stream_index];
					out_stream = ofmt_ctx->streams[stream_index];
					if(pkt.stream_index==audioindex_a)
					{
						//Simple Write PTS
						if(pkt.pts==AV_NOPTS_VALUE)
						{
							//Write PTS
							AVRational time_base1=in_stream->time_base;
							//Duration between 2 frames (us)
							int64_t calc_duration=(double)AV_TIME_BASE/av_q2d(in_stream->r_frame_rate);
							//Parameters
							pkt.pts=(double)(frame_index*calc_duration)/(double)(av_q2d(time_base1)*AV_TIME_BASE);
							pkt.dts=pkt.pts;
							pkt.duration=(double)calc_duration/(double)(av_q2d(time_base1)*AV_TIME_BASE);
							frame_index++;
						}
						cur_pts_a=pkt.pts;
						break;
					}
				}
				while(av_read_frame(ifmt_ctx, &pkt) >= 0);
			}
			else
			{
				break;
			}

		}
		if(usefilter)
			filter_ret = av_bitstream_filter_filter(aacbsfc, out_stream->codec, NULL, &pkt.data,&pkt.size, pkt.data, pkt.size, 0);
		if(filter_ret)
		{
			dmprint_string("failt to use :filter");
			retu = -10;
			goto end;
			
		}
		//Convert PTS/DTS
		pkt.pts = av_rescale_q_rnd(pkt.pts, in_stream->time_base, out_stream->time_base,(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
		pkt.dts = av_rescale_q_rnd(pkt.dts, in_stream->time_base, out_stream->time_base,(AV_ROUND_NEAR_INF|AV_ROUND_PASS_MINMAX));
		pkt.duration = av_rescale_q(pkt.duration, in_stream->time_base, out_stream->time_base);
		pkt.pos = -1;
		pkt.stream_index=stream_index;
		
		//Write
		if (av_interleaved_write_frame(ofmt_ctx, &pkt) < 0) {
			av_free_packet(&pkt);
			dmprint_string( "Error muxing packet");
			break;
		}
		//av_packet_unref(&pkt);		
			//av_interleaved_write_frame(ofmt_ctx, &pkt);
		av_free_packet(&pkt);
	}

	if(IS_GOING)
	{
		//Write file trailer
		av_write_trailer(ofmt_ctx);
		
	}
	else
		retu =RET_CLOSE;//-77 mean is close by user
	if(usefilter)
		av_bitstream_filter_close(aacbsfc);
end:
	avformat_close_input(&ifmt_ctx_v);
	avformat_close_input(&ifmt_ctx_a); 
	/* close output */
	if (ofmt_ctx && !(ofmt->flags & AVFMT_NOFILE))
		avio_close(ofmt_ctx->pb);
	avformat_free_context(ofmt_ctx);
    avformat_free_context(ifmt_ctx_v);
    avformat_free_context(ifmt_ctx_a);
	if (ret < 0 && ret != AVERROR_EOF) {
		dmprint_string( "Error occurred.");
	}
	dmprint("return is ",retu);
	return retu;
}

假如音频是拥有封装格式得需要使用那个滤镜。


以上是我所尝试过的移动端视频录制得技术方案，如果有其他方案，望告知，谢谢。欢迎交流。