android开发，通过摄像头采集视频 MediaCodec实时编解码

原创 已于 2023-03-24 18:01:36 修改 · 7.2k 阅读 · 13 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#编解码 #MediaCodec #摄像头采集

于 2018-02-05 15:29:52 首次发布

最近在使用研究录屏投屏功能的实现，用到了MediaCodec编解码，之前有做过安卓摄像头实时采集与传输相关的研究。想实现用MediaCodec 编解码实时传播的功能，先做了一个通过摄像头采集视频编解码投屏功能的实现。后续有空再完成摄像头采集视频实时编解码并传播功能的DEMO。

下面是MediaCodec实时编解码核心代码：

编码：

package com.qiandu.cameracodec;

import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.os.Build;
import android.util.Log;

import java.util.Iterator;
import java.util.LinkedList;
import java.util.Queue;

public class SvcEncoder {
	
	private final int SPACIAL_LAYER_CAPACITY = 4;
	private int mMaxSpacialLayerIndex = 0;
	private AvcEncoder[] 	mAvcEncoders = null;
	private SvcEncodeSpacialParam[]	mSvcEncodeParams = null;
	private final String MIME_TYPE = "video/avc";
	private int mPrimeColorFormat = 0; //
	public static final String KEY_COLORFORMAT = "key_colorformat";
	public static final String KEY_WIDTH = "key_width";
	public static final String KEY_HEIGHT = "key_height";
	
	Queue<VideoBufferInfo>[] mRawDataQueue = null;
	private int mPeriodIDR = 60;	/*seconds*/
	
	
	private static MediaCodecInfo selectCodec(String mimeType) {
	     int numCodecs = MediaCodecList.getCodecCount();
	     for (int i = 0; i < numCodecs; i++) {
	         MediaCodecInfo codecInfo = MediaCodecList.getCodecInfoAt(i);

	         if (!codecInfo.isEncoder()) {
	             continue;
	         }

	         String[] types = codecInfo.getSupportedTypes();
	         for (int j = 0; j < types.length; j++) {
	             if (types[j].equalsIgnoreCase(mimeType)) {
	            	 Log.d("AvcEncoder", "selectCodec OK, get "+mimeType);
	                 return codecInfo;
	             }
	         }
	     }
	     return null;
	 }
	
	public int Init()
	{
		Log.i("SvcEnc", "Init ++");
		MediaCodecInfo codecInfo = selectCodec(MIME_TYPE);

	    MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(MIME_TYPE);
	    for (int i = 0; i < capabilities.colorFormats.length && mPrimeColorFormat == 0; i++) {
	        int format = capabilities.colorFormats[i];
	        switch (format) {
	        //primary color formats
	        case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:				/*I420 --- YUV4:2:0 --- Nvidia Tegra 3, Samsu */
	        case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:		/*yv12 --- YVU4:2:0 --- ?*/
	        case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:			/*NV12 --- Qualcomm Adreno330/320*/
	        case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:	/*NV21 --- TI OMAP */
	        case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
	        case MediaCodecInfo.CodecCapabilities.COLOR_QCOM_FormatYUV420SemiPlanar:
	        	mPrimeColorFormat = format;
	        	Log.d("AvcEncoder", "get supportted color format " + format);
	            break;
	        default:
	            Log.d("AvcEncoder", "Skipping unsupported color format " + format);
	            break;
	        }
	    }
	    
	    mAvcEncoders = new AvcEncoder[SPACIAL_LAYER_CAPACITY];
	    mSvcEncodeParams = new SvcEncodeSpacialParam[SPACIAL_LAYER_CAPACITY];
	    
	    mRawDataQueue = (LinkedList<VideoBufferInfo>[])new LinkedList<?>[SPACIAL_LAYER_CAPACITY];
	    for (int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
	    {
	    	mRawDataQueue[i] = new LinkedList<VideoBufferInfo>();
	    }
	    
	    
	    
	    Log.i("SvcEnc", "Init --");
	    return 0;
	}
	
	public int Uninit()
	{
		Log.i("SvcEnc", "Uninit ++");
		if (mAvcEncoders == null)
		{
			return 1;
		}
		
		UninitAvcEncoders();
		mSvcEncodeParams = null;
		mRawDataQueue = null;
		//mMaxSpacialLayerIndex = 0;
		Log.i("SvcEnc", "Uninit --");
		return 0;
	}
	
	private void UninitAvcEncoders()
	{
		for(int i=0;i<mAvcEncoders.length;i++)
	    {
	    	if(mAvcEncoders[i] != null)
	    	{
	    		mAvcEncoders[i].Uninit();
	    		mAvcEncoders[i] = null;
	    	}
	    }
	}
	
	public int GetSpacialLayerCapacity()
	{
		return SPACIAL_LAYER_CAPACITY;
	}
	
	//usage:
	//int capa = GetSpacialLayerCapacity();
	//SvcEncodeSpacialParam[] params = new SvcEncodeSpacialParam[capa];
	//param[3].mWidth = ....
	public int Configure(SvcEncodeSpacialParam[] enc_params, int period_idr/*seconds*/)
	{
		Log.i("SvcEnc", "Configure ++");
		if (mAvcEncoders == null || enc_params.length > SPACIAL_LAYER_CAPACITY)
		{
			return 1;
		}
		
		for (int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
		{
			if (i < enc_params.length)
			{
				if (enc_params[i] != null && enc_params[i].isMeValid() == true)
				{
					if (mAvcEncoders[i] == null)
					{
						mAvcEncoders[i] = new AvcEncoder();
						mAvcEncoders[i].Init(mPrimeColorFormat, null);
					}
					
					mPeriodIDR = period_idr;
					mAvcEncoders[i].setInt(AvcEncoder.KEY_IDR_INTERVAL, mPeriodIDR);
					
					mAvcEncoders[i].tryConfig(enc_params[i].mWidth, enc_params[i].mHeight, enc_params[i].mFrameRate, enc_params[i].mBitrate);
					if (mSvcEncodeParams[i] != enc_params[i])
						mSvcEncodeParams[i] = enc_params[i].clone();
					if (mMaxSpacialLayerIndex < i)
						mMaxSpacialLayerIndex = i;
				}
				else
				{
					mSvcEncodeParams[i] = null;
				}
				
			}
			else
			{
				mSvcEncodeParams[i] = null;
			}
		}

		
		Log.i("SvcEnc", "Configure --");
		return 0;
	}
	
	//usage: int[] v = new int[1];
	public boolean queryInt(String key, int[] value)
	{
		if (key.equals(KEY_COLORFORMAT))
		{
			value[0] = mPrimeColorFormat;
			return true;
		}
		
		return false;
	}
	
	
	public int Start()
	{
		Log.i("SvcEnc", "Start ++");
		if (mAvcEncoders == null)
		{
			return 1;
		}
		
		for(int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
		{
			if (mSvcEncodeParams[i] != null)
			{
				if (mAvcEncoders[i] != null)
				{
					mAvcEncoders[i].start();
				}
			}
		}

		Log.i("SvcEnc", "Start --");
		return 0;
	}
	
	public int Stop()
	{
		Log.i("SvcEnc", "Stop ++");
		if (mAvcEncoders == null)
		{
			return 1;
		}

		for(int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
		{
			if (mSvcEncodeParams[i] != null)
			{
				if (mAvcEncoders[i] != null)
				{
					mAvcEncoders[i].stop();
				}
			}
		}
		
		Log.i("SvcEnc", "Stop --");
		return 0;
	}
	
	public int Flush()
	{
		Log.i("SvcEnc", "Flush ++");
		if (mAvcEncoders == null)
		{
			return 1;
		}
		
		for(int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
		{
			if (mSvcEncodeParams[i] != null)
			{
				if (mAvcEncoders[i] != null)
				{
					mAvcEncoders[i].flush();
				}
			}
		}
		
		Log.i("SvcEnc", "Flush --");
		return 0;
	}
	
	public int SetBitrateOnFly(int spacial_idx, int bps)
	{
		Log.i("SvcEnc", "_idx="+spacial_idx+",bps="+bps);
		if (mAvcEncoders == null || spacial_idx >= SPACIAL_LAYER_CAPACITY)
		{
			return 1;
		}
		
		if (mSvcEncodeParams[spacial_idx] != null)
		{
			if (mAvcEncoders[spacial_idx] != null)
			{
				mAvcEncoders[spacial_idx].SetBitrateOnFly(bps);
			}
		}
		
		return 0;
	}
	
	
	public int RequestKeyFrameSoon()
	{
		Log.i("SvcEnc", "RequestKeyFrameSoon");
		if (mAvcEncoders == null)
		{
			return 1;
		}
		
		if (Build.VERSION.SDK_INT < 19)
		{
			Stop();
			//hard code, for compatible
	    	if (Build.VERSION.SDK_INT <= 17)	//for "CP-DX80"
	    	{
	    		UninitAvcEncoders();
	    		Configure(mSvcEncodeParams, mPeriodIDR);
	    	}
	    	Start();
		}
		else {
			for(int i=0;i<SPACIAL_LAYER_CAPACITY;i++)
			{
				if (mSvcEncodeParams[i] != null)
				{
					if (mAvcEncoders[i] != null)
					{
						mAvcEncoders[i].RequestKeyFrameSoon();
					}
				}
			}
		}
		
		return 0;
	}
	
	public int InputRawBuffer(/*in*/byte[] bytes, /*in*/int len, /*in*/long timestamp, /*flag*/int flag)
	{
		int res = AvcUtils.R_UNKNOWN;
		//rookie stage now
		if (mAvcEncoders == null)
		{
			return res;
		}
		
		//init some values
		int[] dst_width = new int[1];
		int[] dst_height = new int[1];
		if (mAvcEncoders[mMaxSpacialLayerIndex] != null)
		{
			mAvcEncoders[mMaxSpacialLayerIndex].queryInt(AvcEncoder.KEY_WIDTH, dst_width);
			mAvcEncoders[mMaxSpacialLayerIndex].queryInt(AvcEncoder.KEY_HEIGHT, dst_height);
		}
		int raw_siz_check = (int) (RawUtils.BytesPerPixel(mPrimeColorFormat) * dst_width[0] * dst_height[0]);
		if (raw_siz_check > len)
		{
			res = AvcUtils.R_INVALIDATE_BUFFER_SIZE;
			return res;
		}
		
		int src_width = 0;
		int src_height = 0;
		byte[] src_yuv = bytes;
		byte[] dst_yuv = bytes;
		
		for (int i=mMaxSpacialLayerIndex;i>=0;i--)
		{
			if (mSvcEncodeParams[i] != null)
			{
				if (mAvcEncoders[i] != null)
				{
					src_yuv = dst_yuv;
					dst_yuv = null;
					src_width = dst_width[0];
					src_height = dst_height[0];
					mAvcEncoders[i].queryInt(AvcEncoder.KEY_WIDTH, dst_width);
					mAvcEncoders[i].queryInt(AvcEncoder.KEY_HEIGHT, dst_height);
					
					dst_yuv = RawUtils.YuvDownsample(mPrimeColorFormat, src_yuv, src_width, src_height, dst_width[0], dst_height[0]);
					if (dst_yuv != null)
					{
						int blen = (int) (RawUtils.BytesPerPixel(mPrimeColorFormat) * dst_width[0] * dst_height[0]);
						if (mRawDataQueue[i] != null)
						{
							//For pro
							VideoBufferInfo info = new VideoBufferInfo();
							info.buffer = dst_yuv;
							info.size = blen;
							info.timestamp = timestamp;
							info.flag = flag;
							mRawDataQueue[i].add(info);
							
							Iterator<VideoBufferInfo> ite = mRawDataQueue[i].iterator();
							while (ite.hasNext())
							{
								VideoBufferInfo infoo = ite.next();
								res = mAvcEncoders[i].InputRawBuffer(dst_yuv, blen, timestamp, flag);
								if (res != AvcUtils.R_BUFFER_OK)
								{
									break;
								}
								infoo.buffer = null;
								infoo = null;
								ite.remove();
							}
						}
						else
						{
							res = mAvcEncoders[i].InputRawBuffer(dst_yuv, blen, timestamp, flag);
						}
					}	//if (dst_yuv != null)
				}	//if (mAvcEncoders[i] != null)
			}	//if (mSvcEncodeParams[i] != null)
		}	//for()
		
		dst_yuv = null;
		return res;
	}
	public int OutputAvcBuffer(/*in*/byte[] bytes, /*in, out*/int[] len, /*out*/SvcEncodeOutputParam output)
	{
		int res = AvcUtils.R_UNKNOWN;
		//rookie stage now
		if (mAvcEncoders == null)
		{
			return AvcUtils.R_UNKNOWN;
		}
		
		int layeridx = mMaxSpacialLayerIndex;
		for (;layeridx>=0;layeridx--)
		{
			if (mSvcEncodeParams[layeridx] != null)
			{
				if (mAvcEncoders[layeridx] != null)
				{
					long[] ts = new long[1];
					int[] flag = new int[1];
					res = mAvcEncoders[layeridx].OutputAvcBuffer(bytes, len, ts, flag);
					if (AvcUtils.R_BUFFER_OK == res)
					{
						int[] width = new int[1];
						int[] height = new int[1];
						mAvcEncoders[layeridx].queryInt(AvcEncoder.KEY_WIDTH, width);
						mAvcEncoders[layeridx].queryInt(AvcEncoder.KEY_HEIGHT, height);
						output.timestamp = ts[0];
						output.layernumber = mMaxSpacialLayerIndex + 1;
						output.layerindex = layeridx;
						output.layerwidth = width[0];
						output.layerheight = height[0];
						/*
						 * 	.....
						 * 
						 * 
						 * */
					
					
						break;
					}
				}
			}
		}

		
		return res;
		
	}
	
}

解码：

package com.qiandu.cameracodec;

import android.media.MediaCodec;
import android.media.MediaCodec.BufferInfo;
import android.media.MediaFormat;
import android.util.Log;
import android.view.Surface;

import java.io.IOException;
import java.nio.ByteBuffer;


public class AvcDecoder
{	
	public static final int STATUS_INVALID = 0;
	public static final int STATUS_LOADED = 1;
	public static final int STATUS_IDLE = 2;
	public static final int STATUS_EXEC = 3;
	public static final int STATUS_WAIT = 5;
	
	
	private MediaCodec mMC = null;
	private String MIME_TYPE = "video/avc";
	private MediaFormat mMF = null;
	private ByteBuffer[] mInputBuffers = null;
	private ByteBuffer[] mOutputBuffers = null;
	private BufferInfo mBI = null;
	private int mStatus = STATUS_INVALID;
	private final int BUFFER_TIMEOUT = 0; //microseconds
    private final int RENDER_DELAY_VALUE = 1;	
	private int mDecodeRenderDelayCount = 0;
	
	
	public int Init()
	{
		Log.i("AvcDecoder", "Init");
		try {
			mMC = MediaCodec.createDecoderByType(MIME_TYPE);
			mStatus = STATUS_LOADED;
			mBI = new BufferInfo();
			Log.i("AvcDecoder", "Init, createDecoderByType");
		} catch (IOException e) {
			e.printStackTrace();
		}

		return 0;
	}
	
	public int tryConfig(Surface surface, byte[] sps, byte[] pps)
	{
		int[] width = new int[1];
		int[] height = new int[1];
		
		AvcUtils.parseSPS(sps, width, height);
		
		mMF = MediaFormat.createVideoFormat(MIME_TYPE, width[0], height[0]);
		
		mMF.setByteBuffer("csd-0", ByteBuffer.wrap(sps));
		mMF.setByteBuffer("csd-1", ByteBuffer.wrap(pps));
		mMF.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, width[0] * height[0]);
		
		mMC.configure(mMF, surface, null, 0);
		Log.i("AvcDecoder", "Init, configure");
		mStatus = STATUS_IDLE;
		
		return 0;
	}
	
	public void Uninit()
	{
		Log.i("AvcDecoder", "Uninit");
		stop();
		mMC.release();
		mMC = null;
		mBI = null;
	}
	
	public void start()
	{
		Log.i("AvcDecoder", "start");
		if (mStatus == STATUS_EXEC)
最低0.47元/天 解锁文章

200万优质内容无限畅学
Android MediaCodec编码camera NV21数据
dodo128的博客
04-21 1689
视频编码 说明： 使用MediaCodec对由Camera采集的数据进行编码 1.采集视频数据 参数设置： 帧率：30fps 视频size：1280 x 720 视频比特率：1280 x 720 x 2 mCameraId = if(cameraType == TYPE_FRONT) Camera.CameraInfo.CAMERA_FACING_FRONT else Camera.CameraI...
Android 采用MediaCodec实现Camera预览视频编解码
12-14
Android MediaCodec 实现Camera预览帧数据编解码并投射至另外的SurfaceView显示，另外附加Camera2的使用。
Android开发之初识Camera图像采集
wangxiaohigh
08-24 137
Android开发之初识Camera图像采集 /* * Android开发之初识camera图像采集 * 北京Android俱乐部群：167839253 * Created on: 2011-8-24 * Author: blueeagle * Email: liujiaxiang@gmail.com */ 下面记录一个简单的相机的制作方法。 制作相机，首先需要添加照相的权限。添...
android 媒体框架之MediaCodec
最新发布
aningxiaoxixi的博客
05-31 1942
MediaCodec 是 Android 底层多媒体框架的核心组件，负责高效处理音视频编解码任务。：避免频繁申请内存，提升性能（尤其高清视频）。硬件加速：优先选择设备专属编解码器（如。MediaCodec 通过。是同步与错误恢复的关键。
【Android】Android Camera实时数据采集及通过MediaCodec硬编码编码数据的流程
weixin_30568591的博客
01-17 503
吐槽： 　　其实常用流程都差不多，但是有时候还是会忘记某一步的详细用法，但是各位朋友请注意，官方已经不推荐Camera类的使用（现在是android.hardware.camera2），但无奈公司项目之前是使用Camera类实现的，并且Camera2貌似是基于API 21以上的，这Android 7的风声都放出来了，可是6.0现在出了3个多月了市场占有率也才貌似3%不到，什么时候才能有个标准...
Android-Camera2-Video-MediaCodec
05-18
Android-Camera2Video-MediaCodec 带有Camera2的Android MediaCodec
Android使用MediaCodec将摄像头采集的视频编码为h264
08-25
Android使用MediaCodec将摄像头采集的视频编码为h264 Android平台上，MediaCodec是Android 4.1（Jelly Bean）引入的一个新的多媒体编码解码器框架，它提供了一个统一的接口来访问各种硬件编码器和解码器。...
Android采集摄像头图像--MediaCodec编码
07-21
本篇文章将深入探讨如何利用Android的MediaCodec API来从摄像头采集图像并进行硬件编码，以及如何通过FFmpeg实现软件编码。我们还将讨论`MainActivity.java`文件中可能涉及的关键代码段。 首先，Android的...
Android摄像头图像采集与MediaCodec硬编码实践
标题中提到的“Android采集摄像头图像--MediaCodec编码”，涉及到了Android应用开发中实时视频数据处理的核心技术。我们首先需要了解的是Android中摄像头的使用，以及如何使用MediaCodec API进行视频数据的硬编码...
Android摄像头采集H264及H264解码播放
01-23
通过以上步骤，你可以实现Android摄像头采集H264数据并进行解码播放的功能。在实际项目中，你可能还需要考虑其他因素，例如视频编码参数的调整、音频同步、网络传输等。提供的压缩包文件“Android摄像解码播放”可能...
Android摄像头采集视频并编码H264存储
06-23
可以完美运行，摄像头采集视频，进行H264编码并存储到SD卡上，希望对大家有帮助
android环境下摄像头数据采集及显示
05-01
这里将摄像头采集及视频图像绘制放在一个模块中，比较便于管理及维护，同时在使用时，因为该类继承自view类，所以可以向操作很多view类一样，将其添加到任何布局中，在与采集的数据宽高比例保持一致的前提下，在页面显示上可以非常灵活的控制视图尺寸大小。
Android MediaCodec实现摄像头数据硬编解码全过程
热门推荐
无止无休
05-27 1万+
MediaCodec h264硬编解码 摄像头
android studio中mediaCodec解码摄像头数据避坑
m0_62602360的博客
01-22 2113
anroid studio mediacodec开发避坑篇
Android APP 音视频（03）CameraX预览与MediaCodec编码
wangdsh的博客
07-23 2054
CameraX 是一个由 Google 开发的 Android Jetpack 库，旨在简化 Android 应用中的相机操作。它提供了一个一致的 API 界面，使得开发者可以更容易地在应用中集成和使用相机功能。简化的 API：CameraX 提供了一个简单且一致的 API，使得开发者可以轻松地访问相机硬件，而无需处理底层的复杂性。兼容性：CameraX 支持从 Android 5.0（API 级别 21）到最新版本的 Android 系统，确保了广泛的设备兼容性。预览和捕获。
Anroid camera + mediacodec
u011270282的专栏
10-21 865
具体代码参考：https://github.com/google/grafika/tree/master/src/com/android/grafika 主要流程： 1、生成一个oes textrure 2、通过上面生成的oes  texture，new一个surfacetexture，设置回调surfacetexture.setOnFrameAvailableListener(CB);
Android中使用MediaCodec硬件解码,高效率得到YUV格式帧,快速保存JPEG图片(不使用OpenGL)(附Demo)...
dielucui7698的博客
11-19 1305
MediaCodec的使用demo： https://github.com/vecio/MediaCodecDemo https://github.com/taehwandev/MediaCodecExample http://bigflake.com/mediacodec/ 以下文章转载自： https://www.polarxiong.com/archiv...
android camera采集、H264编码与Rtmp推流
irainsa的博客
02-23 1663
以上就是H264编码的核心代码了，填充AVFrame，再完成编码，AVFrame data中存储的是编码前的数据，经编码后AVPacket data中存储的是压缩编码后的数据，再通过 RtmpStreamer::SendFrame()将编码后的数据发送出去。这样就完成了编码与推流的整个流程，那么是如何完成编码的?
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值