Android MediaCodec实现摄像头数据硬编解码全过程

最新推荐文章于 2024-03-08 14:00:00 发布
最新推荐文章于 2024-03-08 14:00:00 发布
阅读量1w 收藏 13
点赞数 1
分类专栏： ios & android 多媒体技术 文章标签： android 编码 MediaCodec h264硬编解码
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/bxjie/article/details/46046415
版权

MediaCodec 实现h264硬编解码全过程，视频数据从摄像头读出 yv12格式，转换为I420(同yuv420p)，投递给encoder,再从encoder取出编码后的h264数据投递给decoder后显示到surfaceView;
代码中实现了利用udp将h264数据发送到指定主机，可通过vlc播放(时延有些高，尚未处理)，另外实现了可以读取本地264文件流投递给解码器播放；

import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.net.DatagramPacket;
import java.net.DatagramSocket;
import java.net.InetAddress;
import java.net.SocketException;
import java.net.UnknownHostException;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;

import android.support.v7.app.ActionBarActivity;
import android.annotation.SuppressLint;
import android.graphics.ImageFormat;
import android.graphics.Paint;
import android.hardware.Camera;
import android.hardware.Camera.Size;
import android.media.MediaCodec;
import android.media.MediaCodecInfo;
import android.media.MediaCodecList;
import android.media.MediaFormat;
import android.os.Bundle;
import android.util.Log;
import android.view.Surface;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
import android.view.View;
import android.view.Window;
import android.view.View.OnClickListener;


@SuppressLint("NewApi") 
public class CameraActivity extends ActionBarActivity implements SurfaceHolder.Callback,Camera.PreviewCallback,OnClickListener{


    private static final String TAG = "StudyCamera";
    private static final int FRAME_RATE = 15;
    private static final String REMOTE_HOST= "192.168.1.105";
    private static final short REMOTE_HOST_PORT = 5000;
    private static final String H264FILE = "/sdcard/test.h264";



    private boolean bOpening = false;
    private SurfaceView surfaceView;
    private SurfaceHolder surfaceHolder;

    private Surface mSurface;
    private Camera  mCamera;
    private int     mCameraWidth,mCameraHeight;
    private int     mSurfaceWidth,mSurfaceHeight;
    private MediaCodec mMediaEncoder;
    private MediaCodec mMediaDecoder;
    private Paint       paint;

    private InetAddress address;
    private DatagramSocket socket;
    private UdpSendTask netSendTask;
    private H264FileTask h264FileTask;

    private int mFrameIndex = 0;
    private byte[] mEncoderH264Buf;
    private byte[] mMediaHead = null;  

    private byte[] mYuvBuffer = new byte[1280*720*3/2];

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);

        setContentView(R.layout.activity_camera);
        findViewById(R.id.btnOpen).setOnClickListener(this);
        findViewById(R.id.btnClose).setOnClickListener(this);

        mCameraWidth =640;
        mCameraHeight = 480;
        if(!setupView()){
            Log.e(TAG, "failed to setupView");
            return;
        }   


        paint = new Paint();
        mMediaEncoder = null;
        mMediaDecoder = null;
        mSurface = null;

        mEncoderH264Buf = new byte[10240];

        netSendTask = new UdpSendTask();
        netSendTask.init();
        netSendTask.start();
    }



    @Override
    public void onClick(View view)
    {
        switch(view.getId())
        {
        case R.id.btnOpen:
            {


                 if(!setupCamera()){
                    Log.e(TAG, "failed to setupCamera");
                    return;
                }

                if(!startCamera()){
                    Log.e(TAG, "failed to openCamera");
                    return;
                }



                //play h264 file test
                //startPlayH264File();


            }
            break;
        case R.id.btnClose:
            {
                if(!stopCamera()){
                    Log.e(TAG, "failed to stopCamera");
                    return;
                }
            }
            break;
        }
    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {  
        Log.i(TAG, "surfaceCreated.");  
    }  

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width,  
            int height) {  
        Log.i(TAG,"surfaceChanged w:"+width+" h:"+height);
        mSurface = surfaceHolder.getSurface();

        mSurfaceWidth = width;
        mSurfaceHeight = height;

        /*
         * get canvas from surface holder with draw something
         * */
//        Surface surface = holder.getSurface();
//        if(!setupDecoder(surface,"video/avc",mCameraWidth,mCameraHeight)){
//          releaseCamera();
//          Log.e(TAG, "failed to setupEncoder");
//          return;
//      }

//      Canvas c = holder.lockCanvas();
//      paint.setColor(Color.WHITE);
//      paint.setStrokeWidth(4);
//      c.drawRect(0, 0, width, height, paint);
//      paint.setColor(Color.BLACK);
//      paint.setTextSize(30);
//      paint.setStrokeWidth(1);        
//      c.drawText("http://blog.csdn.net/", 100, 100, paint);


//        Bitmap bitmap = null;
//        bitmap = BitmapFactory.decodeResource(getResources(), R.drawable.waiting);
//        if (bitmap != null) {
//            float left=(c.getWidth()-bitmap.getWidth())/2;
//            float top=(c.getHeight()-bitmap.getHeight())/2;
//            c.drawBitmap(bitmap, left, top, paint);
//        }
//
//        holder.unlockCanvasAndPost(c);
    }  

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {  
        Log.i(TAG,"surfaceDestroyed");
        mSurface = null;
        releaseCamera();
    }  


    @Override
    public void onPreviewFrame(byte[] rawData, Camera camera)
    {
        int w = camera.getParameters().getPreviewSize().width; 
        int h = camera.getParameters().getPreviewSize().height; 
        int format = camera.getParameters().getPreviewFormat();
        Log.d(TAG,"preview frame format:"+format+" size:"+rawData.length+" w:"+w+" h:"+h);


        if(mMediaEncoder == null){
            if(!setupEncoder("video/avc",w,h)){
                releaseCamera();
                Log.e(TAG, "failed to setupEncoder");
                return;
            }
        }

        assert(mSurface != null);
        if(mMediaDecoder == null){
            if(!setupDecoder(mSurface,"video/avc",w,h)){
                releaseCamera();
                Log.e(TAG, "failed to setupDecoder");
                return;
            }
        }

        //convert yv12 to i420
        swapYV12toI420(rawData, mYuvBuffer, w, h);
        System.arraycopy(mYuvBuffer, 0, rawData,0,rawData.length);

        //set h264 buffer to zero.
        for(int i=0;i<mEncoderH264Buf.length;i++)
            mEncoderH264Buf[i]=0;
        int encoderRet = offerEncoder(rawData,mEncoderH264Buf);
        if(encoderRet > 0){
            Log.d(TAG,"encoder output h264 buffer len:"+encoderRet);
            /**
             * send to VLC client by udp://@port;
             */
            netSendTask.pushBuf(mEncoderH264Buf,encoderRet);

            /**
             * push data to decoder
             */
            offerDecoder(mEncoderH264Buf,encoderRet);
        }


        //reset buff to camera.
        camera.addCallbackBuffer(rawData);
    }

    /**
     * 
     */
    private boolean setupView()
    {
        Log.d(TAG,"fall in setupView");


        if (null != surfaceHolder) {
            surfaceHolder.removeCallback(this);
            surfaceView = null;
        }
        if (null != surfaceView) {
            surfaceView = null;
        }

        surfaceView = (SurfaceView)findViewById(R.id.surfaceView);
        surfaceHolder = surfaceView.getHolder();
        surfaceHolder.setType(SurfaceHolder.SURFACE_TYPE_PUSH_BUFFERS);
        surfaceHolder.addCallback(this);
        return true;
    }

    private boolean setupCamera()
    {
        Log.d(TAG,"fall in setupCamera");
        if (null != mCamera) {
            mCamera.release();
            mCamera = null;
        }

        mCamera = Camera.open(); // Turn on the camera

        Camera.Parameters parameters = mCamera.getParameters(); // Camera parameters to obtain
        List<Size> listSize = parameters.getSupportedVideoSizes();
        for(int i=0;listSize != null && i<listSize.size();i++){
            Size size = listSize.get(i);
            Log.d(TAG, "supportedSize:"+size.width+"-"+size.height);
        }

        int width = mCameraWidth,height = mCameraHeight;

        List<Integer> listFormats = parameters.getSupportedPreviewFormats();
        for(int i=0;i<listFormats.size();i++){
            Integer format = listFormats.get(i);
            Log.d(TAG, "supportedFormat:"+format);
        }

        parameters.setFlashMode("off"); // 无闪光灯  
        parameters.setWhiteBalance(Camera.Parameters.WHITE_BALANCE_AUTO);  
        parameters.setSceneMode(Camera.Parameters.SCENE_MODE_AUTO);  
        parameters.setFocusMode(Camera.Parameters.FOCUS_MODE_AUTO);   
        //parameters.setPreviewFormat(ImageFormat.NV21);
        parameters.setPreviewFormat(ImageFormat.YV12);
        parameters.setPreviewSize(width, height);
        parameters.setPictureSize(width, height);

        Log.d(TAG,"setup Camera w:"+width+" h:"+height);
        mCamera.setParameters(parameters); // Setting camera parameters


        //alloc buffer for camera callback data with once.
        byte[] rawBuf = new byte[mCameraWidth * mCameraHeight * 3 / 2];  
        mCamera.addCallbackBuffer(rawBuf);

        /*set the buffer must be use setPreviewCallbackWithBuffer*/
        //mCamera.setPreviewCallback(this);
        mCamera.setPreviewCallbackWithBuffer(this);

        //unused preview display to surface view by first;
        /*
        try {
            mCamera.setPreviewDisplay(surfaceHolder); // Set Preview
            mCamera.setDisplayOrientation(90);
        } catch (IOException e) {
            Log.e(TAG,"failed to setPreviewDisplay");
            mCamera.release();// release camera  
            mCamera = null; 
            return false;
        }
        */

        return true;
    }

    private boolean startCamera(){
        Log.d(TAG,"fall in startCamera");
        if(bOpening)return false;
        mCamera.startPreview(); // Start Preview  
        bOpening = true;
        return true;
    }

    private boolean stopCamera(){
        Log.d(TAG,"fall in stop Camera");
        if(!bOpening)return false;

        mCamera.stopPreview();// stop preview 
        bOpening = false;
        return true;
    }

    private boolean releaseCamera()
    {
        Log.d(TAG,"fall in release Camera");
        mCamera.stopPreview();
        mCamera.release(); // Release camera resources  
        mCamera = null; 
        return true;
    }


    private boolean setupEncoder(String mime, int width, int height)
    {
        int colorFormat = selectColorFormat(selectCodec(mime), mime);
        Log.d(TAG,"setupEncoder "+mime+" colorFormat:"+colorFormat+" w:"+width+" h:"+height);

        mMediaEncoder = MediaCodec.createEncoderByType(mime);  
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(mime, width, height);
        mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, 125000);  
        mediaFormat.setInteger(MediaFormat.KEY_FRAME_RATE, FRAME_RATE);  
        //mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar);
        mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, colorFormat);
        mediaFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 5);
        mMediaEncoder.configure(mediaFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);  
        mMediaEncoder.start();

        return true;
    }

    private boolean setupDecoder(Surface surface,String mime,int width, int height){
        Log.d(TAG,"setupDecoder surface:"+surface+" mime:"+mime+" w:"+width+" h:"+height);

        MediaFormat mediaFormat = MediaFormat.createVideoFormat(mime,width,height);     
        mMediaDecoder = MediaCodec.createDecoderByType(mime);
        if (mMediaDecoder == null) {
            Log.e("DecodeActivity", "createDecoderByType fail!");
            return false;
        }

        /*
        int codecCount = MediaCodecList.getCodecCount();
        for(int i=0;i<codecCount;i++){
            MediaCodecInfo info =MediaCodecList.getCodecInfoAt(i);
            Log.d(TAG,"codec:"+info.getName());
        }*/

        mMediaDecoder.configure(mediaFormat, surface, null, 0);  
        mMediaDecoder.start();

        return true;
    }

    private int offerEncoder(byte[] input,byte[] output) {

        int pos = 0;          
        try {
            ByteBuffer[] inputBuffers = mMediaEncoder.getInputBuffers();
            ByteBuffer[] outputBuffers = mMediaEncoder.getOutputBuffers();
            int inputBufferIndex = mMediaEncoder.dequeueInputBuffer(-1);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
                Log.d(TAG,"offerEncoder InputBufSize: " +inputBuffer.capacity()+" inputSize: "+input.length + " bytes");
                inputBuffer.clear();
                inputBuffer.put(input);
                mMediaEncoder.queueInputBuffer(inputBufferIndex, 0, input.length, 0, 0);

            }

            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
            int outputBufferIndex = mMediaEncoder.dequeueOutputBuffer(bufferInfo,0);
            while (outputBufferIndex >= 0) {
                ByteBuffer outputBuffer = outputBuffers[outputBufferIndex];

                byte[] data = new byte[bufferInfo.size];
                outputBuffer.get(data);

                Log.d(TAG,"offerEncoder InputBufSize:"+outputBuffer.capacity()+" outputSize:"+ data.length + " bytes written");

                if(mMediaHead != null)  
                {                 
                    System.arraycopy(data, 0,  output, pos, data.length);  
                    pos += data.length;  
                } else // 保存pps sps 只有开始时 第一个帧里有， 保存起来后面用
                {
                    Log.d(TAG, "offer Encoder save sps head,len:"+data.length);
                    ByteBuffer spsPpsBuffer = ByteBuffer.wrap(data);
                    if (spsPpsBuffer.getInt() == 0x00000001) {
                        mMediaHead = new byte[data.length];
                        System.arraycopy(data, 0, mMediaHead, 0, data.length);
                    } else {
                        Log.e(TAG,"not found media head.");
                        return -1;
                    }
                }

                mMediaEncoder.releaseOutputBuffer(outputBufferIndex, false);
                outputBufferIndex = mMediaEncoder.dequeueOutputBuffer(bufferInfo, 0);


            }

            if(output[4] == 0x65) //key frame   编码器生成关键帧时只有 00 00 00 01 65 没有pps sps， 要加上  
            {
                System.arraycopy(output, 0,  input, 0, pos);  
                System.arraycopy(mMediaHead, 0,  output, 0, mMediaHead.length);  
                System.arraycopy(input, 0,  output, mMediaHead.length, pos);  
                pos += mMediaHead.length;  
            }  

        } catch (Throwable t) {
            t.printStackTrace();
        }
        return pos;
    }


    private  void offerDecoder(byte[] input,int length) {
        try {
            ByteBuffer[] inputBuffers = mMediaDecoder.getInputBuffers();
            int inputBufferIndex = mMediaDecoder.dequeueInputBuffer(-1);
            if (inputBufferIndex >= 0) {
                ByteBuffer inputBuffer = inputBuffers[inputBufferIndex];
                long timestamp = mFrameIndex++ * 1000000 / FRAME_RATE;
                Log.d(TAG,"offerDecoder timestamp: " +timestamp+" inputSize: "+length + " bytes");
                inputBuffer.clear();
                inputBuffer.put(input,0,length);
                mMediaDecoder.queueInputBuffer(inputBufferIndex, 0, length, timestamp, 0);
            }

            MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
            int outputBufferIndex = mMediaDecoder.dequeueOutputBuffer(bufferInfo,0);
            while (outputBufferIndex >= 0) {
                Log.d(TAG,"offerDecoder OutputBufSize:"+bufferInfo.size+ " bytes written");

                //If a valid surface was specified when configuring the codec, 
                //passing true renders this output buffer to the surface.  
                mMediaDecoder.releaseOutputBuffer(outputBufferIndex, true);
                outputBufferIndex = mMediaDecoder.dequeueOutputBuffer(bufferInfo, 0);
            }
        } catch (Throwable t) {
            t.printStackTrace(); 
        }
    }


    private void startPlayH264File()
    {
        assert(mSurface != null);
        if(mMediaDecoder == null){
            if(!setupDecoder(mSurface,"video/avc",mSurfaceWidth,mSurfaceHeight)){
                Log.e(TAG, "failed to setupDecoder");
                return;
            }
        }

        h264FileTask = new H264FileTask();
        h264FileTask.start();
    }


    private void swapYV12toI420(byte[] yv12bytes, byte[] i420bytes, int width, int height)   
    {        
        System.arraycopy(yv12bytes, 0, i420bytes, 0,width*height);
        System.arraycopy(yv12bytes, width*height+width*height/4, i420bytes, width*height,width*height/4);  
        System.arraycopy(yv12bytes, width*height, i420bytes, width*height+width*height/4,width*height/4);    
    }    


    private void readH264FromFile(){

        File file = new File(H264FILE);
        if(!file.exists() || !file.canRead()){
            Log.e(TAG,"failed to open h264 file.");
            return;
        }

        try {
            int len = 0;
            FileInputStream fis = new FileInputStream(file);
            byte[] buf = new byte[1024];
            while ((len = fis.read(buf)) > 0){
                offerDecoder(buf, len);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch(IOException e){
            e.printStackTrace();
        }

        return;     
    }


    /**
     * Returns the first codec capable of encoding the specified MIME type, or null if no
     * match was found.
     */
    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)) {
                    return codecInfo;
                }
            }
        }
        return null;
    }

    /**
     * Returns a color format that is supported by the codec and by this test code.  If no
     * match is found, this throws a test failure -- the set of formats known to the test
     * should be expanded for new platforms.
     */
    private static int selectColorFormat(MediaCodecInfo codecInfo, String mimeType) {
        MediaCodecInfo.CodecCapabilities capabilities = codecInfo.getCapabilitiesForType(mimeType);
        for (int i = 0; i < capabilities.colorFormats.length; i++) {
            int colorFormat = capabilities.colorFormats[i];
            if (isRecognizedFormat(colorFormat)) {
                return colorFormat;
            }
        }
        Log.e(TAG,"couldn't find a good color format for " + codecInfo.getName() + " / " + mimeType);
        return 0;   // not reached
    }

    /**
     * Returns true if this is a color format that this test code understands (i.e. we know how
     * to read and generate frames in this format).
     */
    private static boolean isRecognizedFormat(int colorFormat) {
        switch (colorFormat) {
            // these are the formats we know how to handle for this test
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Planar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420SemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420PackedSemiPlanar:
            case MediaCodecInfo.CodecCapabilities.COLOR_TI_FormatYUV420PackedSemiPlanar:
                return true;
            default:
                return false;
        }
    }



    class H264FileTask extends Thread{
        @Override
        public void run() {
            Log.d(TAG,"fall in H264File Read thread");
            readH264FromFile();
        }
    }

    class UdpSendTask extends Thread{
        private ArrayList<ByteBuffer> mList;
        public void init()
        {
            try {  
                socket = new DatagramSocket();  
                address = InetAddress.getByName(REMOTE_HOST);  
            } catch (SocketException e) {  
                e.printStackTrace();  
            } catch (UnknownHostException e) {
                e.printStackTrace();  
            }

            mList = new ArrayList<ByteBuffer>();

        }
        public void pushBuf(byte[] buf,int len)
        {
            ByteBuffer buffer = ByteBuffer.allocate(len);
            buffer.put(buf,0,len);
            mList.add(buffer);
        }

        @Override  
        public void run() {
            Log.d(TAG,"fall in udp send thread");
            while(true){
                if(mList.size() <= 0){
                    try {
                        Thread.sleep(100);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                while(mList.size() > 0){
                    ByteBuffer sendBuf = mList.get(0);
                    try {         
                        Log.d(TAG,"send udp packet len:"+sendBuf.capacity());
                        DatagramPacket packet=new DatagramPacket(sendBuf.array(),sendBuf.capacity(), address,REMOTE_HOST_PORT);  
                        socket.send(packet);  
                    } catch (Throwable t) {
                        t.printStackTrace();
                    }
                    mList.remove(0);
                }   
            }
        }  
    }

}

源码下载：http://download.csdn.net/detail/b_xjie/8744773

白錵錵
关注
  • 1
    点赞
  • 踩
  • 13
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 2
    评论
专栏目录
android MediaCodec 实现h264硬编解码全过程
05-27
MediaCodec 实现h264硬编解码全过程，视频数据从摄像头读出 yv12格式，转换为I420，投递给encoder,再从encoder取出编码后的h264数据投递给decoder后显示到surfaceView; 实现了udp将h264数据发送到指定主机，可通过vlc播放; 备有可以读取本地264文件流投递给解码器播放； 小米 4.4.2 测试通过.
Android 采用MediaCodec实现Camera预览视频编解码
12-14
Android MediaCodec 实现Camera预览帧数据编解码并投射至另外的SurfaceView显示，另外附加Camera2的使用。
Android屏幕共享-硬编码硬解码
最新发布
m0_73443478的博客
03-08 1056
Android屏幕共享-硬编码硬解码
Android 拍照、截图事件监听实现源码
01-08
Android 拍照、截图事件监听实现源码 通过监听media文件夹实现
Android-Camera2-Video-MediaCodec
05-18
Android-Camera2Video-MediaCodec 带有Camera2的Android MediaCodec
android wifi网络摄像头源代码
07-22
源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码 源于android开源项目， 网络摄像头源代码
MediaCodec 高效解码得到标准 YUV420P 格式帧
weixin_34006468的博客
02-01 639
前言 本文从简书迁移，原文地址：www.jianshu.com/p/1ff123409… 因为项目中需要对解码后的 YUV420P 格式数据做一些处理，在之前是使用 ffmpeg 软解的方式得到 YUV420P，但随着图像像素的提升，ffmpeg 的效率已经影响到软件的体验了，故使用 Android 上 MediaCodec 硬解的方式提高效率。 概述 参考 MediaCodec 的官方文档：...
android开发，通过摄像头采集视频 MediaCodec实时编解码
a289973483的博客
02-05 6901
最近在使用研究录屏投屏功能的实现，用到了MediaCodec编解码，之前有做过安卓摄像头实时采集与传输相关的研究。想实现用MediaCodec 编解码实时传播的功能，先做了一个通过摄像头采集视频MediaCodec实时编解码的DEMO。后续有空再完成摄像头采集视频实时编解码并传播功能的DEMO。 下面是MediaCodec实时编解码核心代码： 编码： package com.qian
android studio中mediaCodec解码摄像头数据避坑
m0_62602360的博客
01-22 1032
anroid studio mediacodec开发避坑篇
Android上Camera获取byte数据在native层进行转换（转）
迷彩狼的博客
04-13 843
openCV的C++底层库用在android里面open()不了，遂换了种方式。用原生Camera的视频流封装成Mat再进行操作。 转发自：https://blog.csdn.net/Taily_Duan/article/details/52756166我只能说是真的牛逼 这个单通道的，代码是jni的： jbyte * pBuf = (jbyte*)env->GetByteArrayElements(yuv, 0); int width = w; int height = .
Android音视频开发（四）——MediaCodec：解码视频，得到YUV值，一帧一帧加载到SD卡中保存。
indeedes的博客
05-24 6020
我们上一节了解了MediaExtractor、MediaMuxer、MediaFormat、MediaCodec.BufferInfo。重复的内容我就不再赘述了，假如有上面的四个的一些补充还是会写一下。接下来我们学习MediaCodec，本节篇幅会比较长，知识点较多，请耐心品味。 一、MediaCodec ​ MediaCodec类可用于访问低级媒体编解码器，即编码器/解码器组件。它是Android低级多媒体支持基础设施的一部分(通常与MediaExtractor, ...
Android 用MediaCodec实现视频硬解码
12-28
Android 用MediaCodec实现视频硬解码 发送视频流 写文件 可播放
Android MediaCodec 硬解码H264
11-21
Android MediaCodec 硬解码H264，包括h264文件，以及另一个硬解码例子。
Android 实时MediaCodec音频硬编解码播放
12-02
实时MediaCodec音频硬编解码，音频录制，编码，解码，播放都正常，本人已亲自测试
Android 硬解码MediaCodecDemo
12-12
1 MediaCodec硬解码demo 2 包含h264码流资源 3 包含如何处理硬解码过程中出现的各种crash／anr／黑屏
关于airplay协议实现镜像功能研究
热门推荐
无止无休
09-26 3万+
最近在学习关于airplay相关协议,将了解到的内容记录下来，如有理解错误，请大神指正。   Airplay可以实现将设备中音频、视频、图像通过本地无线网络发送远端设备；Airplay功能实现利用了很多标准协议，包括multicast DNS,HTTP,RTSP,RTP,RAOP,NTP，见下表1： AirPlay Technology Display photos
DirectFB环境搭建
无止无休
08-13 1721
下载DirectFB http://directfb.org/downloads/Core/DirectFB-1.2/
DirectShow 播放视频
无止无休
09-23 1121
  CComPtr m_pPlaybackGraph;// Create a graph to play the requested file hr = m_pPlaybackGraph.CoCreateInstance(CLSID_FilterGraph);ASSERT(m_pPlaybackGraph);// Render the media file
android mediacodec 解码
12-29
Android Mediacodec 是 Android 平台上用于进行音频和视频解码的类库。它允许开发者可以直接访问底层的多媒体编解码器，并对音频和视频数据进行解码和编码操作，能够更加高效地操作多媒体数据。 使用 Mediacodec 进行解码时，首先需要创建一个 Mediacodec 对象，然后配置解码器的参数，例如指定要解码的音频或视频格式、创建输入和输出的数据流等。接下来，可以将需要解码的数据传入解码器的输入缓冲区中，解码器将会自动进行解码操作，并将解码后的数据输出到输出缓冲区中。最后，开发者可以从输出缓冲区中获取解码后的数据，进行后续的处理或者显示操作。 Mediacodec 的优势在于它可以直接利用硬件加速来进行解码操作，因此在解码大量多媒体数据时能够取得更好的性能表现。同时，它也提供了比较底层的接口，使得开发者可以更加灵活地控制解码的过程，以满足不同的需求。 总的来说，Android Mediacodec 是一个强大的多媒体解码库，可以帮助开发者在 Android 平台上更加高效地进行音频和视频解码操作。通过它，开发者可以获得更好的性能和更加灵活的控制能力，为多媒体应用程序的开发带来了很大的便利。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

白錵錵

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值