Android Mediacodec H.264文件播放

最新推荐文章于 2024-07-23 00:12:22 发布
最新推荐文章于 2024-07-23 00:12:22 发布
阅读量1.9k 收藏 1
点赞数
分类专栏： android multimedia opengl es 文章标签： android h.264 mediacodec
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/keen_zuxwang/article/details/78090814
版权
android 同时被 3 个专栏收录
62 篇文章 1 订阅
订阅专栏
opengl es
18 篇文章 0 订阅
订阅专栏
multimedia
16 篇文章 1 订阅
订阅专栏

读取h.264视频文件的每一帧送Mediacodec 解码/Surface 显示

H264FileDecodeActivity.java

public class H264FileDecodeActivity extends Activity 
     implements SurfaceHolder.Callback, OnClickListener, TextureView.SurfaceTextureListener, OnFrameAvailableListener {

    private SurfaceView testSurfaceView;

    private TextureView textureView;

    private SurfaceHolder holder;
    //文件路径
    //private String path0 = Environment.getExternalStorageDirectory() + "/H265_22f.h265";
    private String path = Environment.getExternalStorageDirectory() + "/mediacodec_1.264"; // 须修改为自己的视频文件路径

    private String TAG = "H264FileDecodeActivity";
    private int width, height;
    //解码器
    private MediaCodec mCodec;
    private boolean isFirst = true;

    // 需要解码的类型
    private final static String MIME_TYPE = "video/avc"; // H.264 Advanced Video
    private final static int TIME_INTERNAL = 5;

    //文件读取完成标识
    private boolean isFinish = false;
    //这个值用于找到第一个帧头后，继续寻找第二个帧头，如果解码失败可以尝试缩小这个值
    private int FRAME_MIN_LEN = 8; //1024;
    //一般H264帧大小不超过200k,如果解码失败可以尝试增大这个值
    private static final int FRAME_MAX_LEN = 300 * 1024;
    //根据帧率获取的解码每帧需要休眠的时间,根据实际帧率进行操作
    private int PRE_FRAME_TIME = 1000 / 25;

    //保存完整数据帧
    byte[] frame = new byte[FRAME_MAX_LEN];
    //每次从文件读取的数据
    byte[] readData = new byte[10 * 1024];
    //当前帧长度
    int frameLen = 0;
    int headFirstIndex;
    int headSecondIndex;
    int frameNum;

    //读取文件解码线程
    UpdateDecoder updateDecoderT;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_h264);

        testSurfaceView = (SurfaceView) findViewById(R.id.surfaceview);
        holder = testSurfaceView.getHolder();
        holder.addCallback(this);

        textureView = (TextureView) findViewById(R.id.textureview);
        textureView.setSurfaceTextureListener(this);

        Button btn = (Button) findViewById(R.id.takePhoto);
        btn.setOnClickListener(this);

        nalu = new NaluUnit();
        isFinish = false;
    }

    Handler myHandler = new Handler() {  
        public void handleMessage(Message msg) {   
             switch (msg.what) {   
                  case 2:
                      byte[] sendBuf = mQueue0.poll();
                      onFrame(sendBuf, 0, sendBuf.length);
                      break; 
                  case 1:
                      Log.d(TAG,"  onFrame 1  ");
                      onFrame((byte[])msg.obj, 0, msg.arg1);  
                      break;
                  case 0:
                      Log.d(TAG,"  onFrame 0  ");
                      onFrame((byte[])msg.obj, 0, msg.arg1);   
                      break; 
                  default :
                      break;
             }   
             super.handleMessage(msg);   
        }   
    }; 


    private  LinkedBlockingQueue<ByteBuffer> mQueue;
    private  LinkedBlockingQueue<byte[]> mQueue0;

    int waitC = 0;
    class UpdateDecoder extends Thread{
        private boolean runFlag;
        public void init(){ 
            //mList = new ArrayList<ByteBuffer>(); //new ArrayList<ByteBuffer>(8)
            mQueue = new LinkedBlockingQueue<ByteBuffer>(); 
            mQueue0 = new LinkedBlockingQueue<byte[]>(); 
        }

        public void pushBuf(byte[] buf, int offset, int len)
        {
            //ByteBuffer buffer = ByteBuffer.allocate(len);
            //buffer.put(buf,offset,len);
            //mQueue.offer(buffer);
            byte[] frameD = new byte[len];
            System.arraycopy(frameD, 0, buf, offset, len);
            mQueue0.offer(frameD);
        }

        public void updataStop()
        {
            runFlag = false;
            mQueue0.clear();
        }

        @Override  
        public void run() {
            runFlag = true;

            Log.i("UpdateDecoder", " UpdateDecoder  mQueue.size() = "+mQueue0.size());
            while(runFlag){     
                if(mQueue0.size() <= 0){
                    try {
                        Thread.sleep(40);
                    } catch (InterruptedException e) {
                        e.printStackTrace();
                    }
                }
                while(mQueue0.size() > 0){
                    //ByteBuffer sendBuf = mQueue.poll();
                    //onFrame(sendBuf.array(), 0, sendBuf.capacity());
                    //byte[] sendBuf = mQueue0.poll();
                    try {   
                        //onFrame(sendBuf, 0, sendBuf.length);  
                        Message message = new Message();   
                        message.what = 2;     
                        myHandler.sendMessage(message);
                        try {
                            Thread.sleep(40);
                        } catch (InterruptedException e) {
                            e.printStackTrace();
                        }

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

    @Override
    public void onSurfaceTextureAvailable(SurfaceTexture surface, int width, int height) {
        this.width  = width;
        this.height = height;
        Log.i(TAG, "onSurfaceTextureAvailable:  width = " + width + ", height = " + height);
        startCodec();
    }

    @Override
    public void onFrameAvailable(SurfaceTexture surfaceTexture) {
        // TODO Auto-generated method stub

    }

    @Override
    public void onSurfaceTextureSizeChanged(SurfaceTexture surface, int width, int height) {
        Log.i(TAG, "onSurfaceTextureSizeChanged: width = " + width + ", height = " + height);
    }

    @Override
    public boolean onSurfaceTextureDestroyed(SurfaceTexture surface) {
        stopCodec();
        return false;
    }

    @Override
    public void onSurfaceTextureUpdated(SurfaceTexture surface) {

    }

    @Override
    public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {

    }

    @Override
    public void surfaceCreated(SurfaceHolder holder) {
        width  = holder.getSurfaceFrame().width();
        height = holder.getSurfaceFrame().height();
        Log.i(TAG, "surfaceCreated:  width = " + width + ", height = " + height);
        //startCodec();

        //updateDecoderT = new UpdateDecoder();
        //updateDecoderT.init();
        //updateDecoderT.start();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {
        //stopCodec();

        //updateDecoderT.updataStop();
    }

    @Override
    public void onClick(View v) {
        // TODO Auto-generated method stub
        if(!isFinish) {
           doDecoder();
           //doDecodec();
        }
    }

    public void startCodec() {
        if (isFirst) {
            initDecoder();
        }
    }

    private class DecoderCallback extends MediaCodec.Callback{
        @Override
        public void onInputBufferAvailable(MediaCodec codec, int index) {
             if(nalu.size != 0) {
                 ByteBuffer inputBuffer = mCodec.getInputBuffer(index);
                 long timestamp = mCount++ * 1000000 / 25;
                 //Log.i(TAG," nalu type = "+ nalu.type+", nalu.size = "+nalu.size); 
                 inputBuffer.clear();
                 inputBuffer.put(nalu.data, 0, nalu.size);
                 mCodec.queueInputBuffer(index, 0, nalu.size, timestamp, 0);    
             }    
        }

        @Override
        public void onOutputBufferAvailable(MediaCodec codec, int index, MediaCodec.BufferInfo info) {
            //ByteBuffer encodedData = codec.getOutputBuffer(index);
            //encodedData.position(info.offset);
            //encodedData.limit(info.offset + info.size);
            codec.releaseOutputBuffer(index, true);   
        }

        @Override
        public void onError(MediaCodec codec, MediaCodec.CodecException e) {
            Log.d(TAG, "Error: " + e);
        }

        @Override
        public void onOutputFormatChanged(MediaCodec codec, MediaFormat format) {
            Log.d(TAG, "encoder output format changed: " + format);
        }
    }

    private void initDecoder() {
        try {
            //根据需要解码的类型创建解码器
            mCodec = MediaCodec.createDecoderByType(MIME_TYPE);
        } catch (IOException e) {
            e.printStackTrace();
        }
        MediaFormat mediaFormat = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
        //MediaFormat mediaFormat = MediaFormat.createVideoFormat(MediaFormat.MIMETYPE_VIDEO_AVC, width, height);
        //mediaFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatYUV420Flexible);

        //SurfaceView
        //mCodec.configure(mediaFormat, holder.getSurface(), null, 0); //直接解码送surface显示

        //TextureView
        SurfaceTexture texture = textureView.getSurfaceTexture();
        texture.setDefaultBufferSize(width, height);
        //texture.setOnFrameAvailableListener(this);
        Surface surface0 = new Surface(texture);
        mCodec.configure(mediaFormat, surface0, null, 0); //直接解码送surface显示

        // mCodec.setCallback(new DecoderCallback());
        //开始解码
        mCodec.start();
        isFirst = false;
    }

    public void stopCodec() {
        try {
            mCodec.stop();
            mCodec.release();
            mCodec = null;
            isFirst  = true;
            isFinish = true;
        } catch (Exception e) {
            e.printStackTrace();
            mCodec = null;
        }
    }

    int mCount = 0;

    public void onFrame(byte[] buf, int offset, int length) {
        //-1表示一直等待；0表示不等待；其他大于0的参数表示等待毫秒数
        int inputBufferIndex = mCodec.dequeueInputBuffer(-1);
        if (inputBufferIndex >= 0) {
            ByteBuffer inputBuffer =  mCodec.getInputBuffer(inputBufferIndex);
            inputBuffer.clear();
            inputBuffer.put(buf, offset, length); 
            //解码
            long timestamp = mCount * 1000000 / 25;
            mCodec.queueInputBuffer(inputBufferIndex, 0, length,  timestamp, 0); 
            mCount++;
        }

        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
        int outputBufferIndex = mCodec.dequeueOutputBuffer(bufferInfo, 0); //10
        //循环解码，直到数据全部解码完成
        while (outputBufferIndex >= 0) {
            //logger.d("outputBufferIndex = " + outputBufferIndex);
            mCodec.releaseOutputBuffer(outputBufferIndex, true);
            outputBufferIndex = mCodec.dequeueOutputBuffer(bufferInfo, 0);
        }
    }

    private int findHead(byte[] data, int offset, int max) {
        int i;
        for (i = offset; i <= max; i++) {
            if (isHead(data, i))
                break;
        }
        //检测到最大值，未发现帧头
        if (i == max) {
            i = -1;
        }
        return i;
    }

    private boolean isHead(byte[] data, int offset) {
        boolean result = false;
        // 00 00 00 01 x
        if (data[offset] == 0x00 && data[offset + 1] == 0x00
                && data[offset + 2] == 0x00 && data[3] == 0x01 && isVideoFrameHeadType(data[offset + 4])) {
            result = true;
        }
        // 00 00 01 x
        if (data[offset] == 0x00 && data[offset + 1] == 0x00
                && data[offset + 2] == 0x01 && isVideoFrameHeadType(data[offset + 3])) {
            result = true;
        }
        return result;
    }


    private boolean isVideoFrameHeadType(byte head) {
        return head == (byte) 0x65 || head == (byte) 0x61 || head == (byte) 0x41 || head == (byte) 0x67 || head == (byte) 0x68 ;
    }


    public void doDecodec() {
        final File file = new File(path);
        Log.e(TAG," path = "+path);
        if (file.exists()) {
            try {
                new Thread() {
                    public void run() {
                        //循环读取数据
                        FileInputStream fis = null;
                        try {
                            fis = new FileInputStream(file);
                        } catch (FileNotFoundException e1) {
                            // TODO Auto-generated catch block
                            e1.printStackTrace();
                        }
                        //开始时间
                        long startTime = System.currentTimeMillis();
                        frameNum = 0;
                        FRAME_MIN_LEN = 8;
                        while (!isFinish) {
                            try {
                                if (fis.available() > 0) 
                                {
                                    int readLen = fis.read(readData);
                                    //当前长度小于最大值
                                    if (frameLen + readLen < FRAME_MAX_LEN) {
                                        //将readData拷贝到frame
                                        System.arraycopy(readData, 0, frame, frameLen, readLen);
                                        //修改frameLen
                                        frameLen += readLen;
                                        //寻找第一个帧头
                                        headFirstIndex = findHead(frame, 0, frameLen);
                                        while (headFirstIndex >= 0 && isHead(frame, headFirstIndex)) {
                                            //寻找第二个帧头
                                            headSecondIndex = findHead(frame, headFirstIndex + FRAME_MIN_LEN, frameLen);
                                            //如果第二个帧头存在，则两个帧头之间的就是一帧完整的数据
                                            if (headSecondIndex > 0 && isHead(frame, headSecondIndex)) {
                                                Log.e("MediacodecT"," frame length : " + (headSecondIndex - headFirstIndex));
                                                //视频解码
                                                onFrame(frame, headFirstIndex, headSecondIndex - headFirstIndex);
                                                System.arraycopy(frame, headSecondIndex, frame, 0, frameLen-headSecondIndex);
                                                frameLen = frameLen - headSecondIndex;

                                                frameNum++;
                                                if(frameNum == 4) {
                                                   FRAME_MIN_LEN = 1024;
                                                }
                                                long time = PRE_FRAME_TIME - (System.currentTimeMillis() - startTime);
                                                if (time > 0) {
                                                    try {
                                                        Thread.sleep(time);
                                                    } catch (InterruptedException e) {
                                                        e.printStackTrace();
                                                    }
                                                }
                                                startTime = System.currentTimeMillis();
                                                //继续寻找数据帧
                                                headFirstIndex = findHead(frame, 0, frameLen);
                                            } else {
                                                //找不到第二个帧头
                                                headFirstIndex = -1;
                                            }
                                        }
                                    } else {
                                        //如果长度超过最大值，frameLen置0
                                        frameLen = 0;
                                    }
                                } else {
                                    //文件读取结束
                                    isFinish = true;
                                }
                            } catch (IOException e) {
                                // TODO Auto-generated catch block
                                e.printStackTrace();
                            }
                        }
                        isFinish = false;
                        Log.i(TAG, "         frameNum     "+frameNum);
                    }
                }.start();
            } catch (Exception e) {
                e.printStackTrace();
            } 
        } 
    }

    NaluUnit nalu;
    public class NaluUnit {
         byte[] data;
         int size;
         int type;

         public NaluUnit() {
             data = new byte[20*1024];
             size = 0; 
         }
    }

    public  void  doDecoder() 
    {
        final File file = new File(path); 
        if(!file.exists() || !file.canRead()){
            Log.e(TAG,"failed to open h264 file.");
            return;
        }
        Log.e(TAG," path = "+path);
        Log.e(TAG,"        readH264FromFile       ");

        new Thread() 
        {
            public void run() {
              int readlen = 0;
              int writelen = 0;
              int i = 0;
              int pos = 0;
              boolean findFlag = false;
              FileInputStream fis = null;
              try {
                 fis = new FileInputStream(file);
              } catch (FileNotFoundException e1) {
                // TODO Auto-generated catch block
                e1.printStackTrace();
              }
              //每次从文件读取的数据
              frameNum = 0;
              long startTime = System.currentTimeMillis();
              while (!isFinish) 
              {
                 try {
                    if(fis.available() > 0) {
                        readlen = fis.read(frame, pos, frame.length-pos);
                        if(readlen<=0) {
                           break;
                        }
                        readlen += pos;

                        i   = 0;
                        pos = 0;
                        writelen = readlen;
                        while(i < readlen-4) {
                            findFlag = false;
                            if(frame[i++] == 0x00 && frame[i++] == 0x00 && frame[i++] == 0x00 && frame[i++] == 0x01)
                            {
                                pos = i;
                                while (pos < readlen-4) {
                                    if(frame[pos++] == 0x00 && frame[pos++] == 0x00 && frame[pos++] == 0x00 && frame[pos++] == 0x01) {
                                        findFlag = true;
                                        break;
                                    }
                                }
                                if(findFlag){
                                    nalu.size = pos-i;
                                    nalu.type = frame[i]&0x1f;              
                                    System.arraycopy(frame, i-4, nalu.data, 0, nalu.size); 
                                    Log.i(TAG," nalu type = "+ nalu.type+", nalu.size = "+nalu.size); 
                                    onFrame(frame, i-4, pos-i); // start code + nalu 送解码器
                                    frameNum++;
                                    long time = PRE_FRAME_TIME - (System.currentTimeMillis() - startTime);
                                    if (time > 0) {
                                        try {
                                            Thread.sleep(time);
                                        } catch (InterruptedException e) {
                                            e.printStackTrace();
                                        }
                                    }
                                    startTime = System.currentTimeMillis();

                                    i = pos-4;
                                    writelen = i;
                                }else {
                                    writelen = i-4;
                                    break;
                                }
                            }
                        }

                        if(writelen>0 && writelen<readlen) {                 
                            System.arraycopy(frame, writelen, frame, 0, readlen-writelen);
                            Log.i(TAG, " readlen = "+readlen+", writelen = "+writelen);
                        }
                        pos = readlen-writelen;
                    }else {
                        isFinish = true;
                    }
                 } catch (IOException e) {
                    // TODO Auto-generated catch block
                    Log.e(TAG, "  error =  "+e.getMessage());
                    e.printStackTrace();
                 }
              } 
              isFinish = false;
              Log.i(TAG, "         frameNum     "+frameNum);
           }
        }.start();
    }

}

布局文件：

<RelativeLayout xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:layout_width="match_parent"
    android:layout_height="match_parent" >

    <SurfaceView
        android:id="@+id/surfaceview"
        android:layout_width="640px"
        android:layout_height="480px" />

    <TextureView
        android:id="@+id/textureview"
        android:layout_below="@id/surfaceview"
        android:layout_width="640px"
        android:layout_height="480px" 
        android:layout_marginTop="20dp"/>

    <Button
        android:id="@+id/takePhoto"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:background="@drawable/btn_camera_all_click"
        android:layout_alignParentBottom="true"
        android:layout_centerHorizontal="true" 
        android:layout_marginBottom="10dip"/>
</RelativeLayout>

效果图：
这里写图片描述

keen_zuxwang
关注
专栏目录
实现android H.264的实时播放
12-22
实现android H.264的实时播放，大家可以参考下，适合于做视频监控的去测试开发
Android使用MediaCodec硬解码播放H264格式视频文件
热门推荐
true100的专栏
01-03 3万+
前些时间，通过各种搜索加请教了好几个同行的朋友，在他们的指点下实现： RTSP+H264实时视频播放播放及把实时视频流保存到手机SD卡中，再对保存的H264格式文件进行播放等基本功能。 非常感谢这些朋友的无私帮忙，在实现功能的同时，我也把他们提供的一些代码加自己的修改简单记录下来，希望能给有需要的朋友一点点帮助。 这篇博客就是简单记录用MediaCodec +SurfaceView解码播
Android APP 音视频（01）MediaCodec解码H264码流
最新发布
wangdsh的博客
07-23 1903
H.264，也被称为MPEG-4 AVC（Advanced Video Coding），是一种广泛使用的数字视频压缩标准，主要用于视频编码。H.264标准由ITU-T视频编码专家组（VCEG）和ISO/IEC动态图像专家组（MPEG）共同开发，旨在提供比之前的视频编码标准更高的数据压缩效率。H.264是一种基于块的编码技术，它将视频帧分为多个宏块（Macroblocks，MBs），每个宏块包含亮度信息和色度信息。帧类型，I帧（Intra-coded frames）
Android平台使用MediaCodec进行H264格式的视频编解码
程序猿Ricky的日常干货
01-28 1万+
Android平台使用MediaCodec进行H264格式的视频编解码 Android多媒体简介 MediaCodec MediaExtractor MediaMux H264关键词 Android多媒体简介 提起android中的多媒体，就不得不提两个类，那就是MediaPlayer和MediaRecorder，这两个是分别用来进行音视频播放和录制的类。这两个类都可以在java中调...
MediaCodec视频编码H264流程及参考demo
分享音视频技术
11-09 2402
本文则讲解使用MediaCodec进行视频编码的流程，主要通过一个例子，从摄像头采集数据，并将数据编码为h264文件。
android6.0 MediaCodec H.264解码测试
08-06
在Android 6.0（API级别23）中，MediaCodec已经支持了H.264视频编解码，这是一项广泛使用的高效视频压缩标准。本篇文章将深入探讨在Android 6.0上使用MediaCodec进行H.264视频流的硬解码测试，以及如何在不同硬件...
android MediaCodec 实现h264硬编解码全过程
05-27
MediaCodec 实现h264硬编解码全过程，视频数据从摄像头读出 yv12格式，转换为I420，投递给encoder,再从encoder取出编码后的h264数据投递给decoder后显示到surfaceView; 实现了udp将h264数据发送到指定主机，可通过...
Android MediaCodec 硬解码H264
11-21
在Android平台上，MediaCodec是一个非常重要的组件，它提供...在实际项目中，结合`MediaExtractor`用于从媒体文件中提取数据，以及`SurfaceView`或`TextureView`显示视频画面，可以构建出完整的H264视频播放解决方案。
Android硬解码H264,AAC文件 Demo
06-27
Android利用MediaCodec硬解码H264,AAC文件并播放Demo。相关博客：http://blog.csdn.net/a512337862/article/details/72629755和http://blog.csdn.net/a512337862/article/details/72629755
Android H.264视频编解码
05-29
在Android平台上进行H.264视频编解码是一项关键的技术任务，特别是在开发涉及多媒体通信、视频播放或流媒体应用时。H.264，全称Advanced Video Coding（高级视频编码），是一种高效的视频压缩标准，它允许在有限带宽...
在Native层实现MediaCodec H264 编码.zip
11-02
文章《Android 视频硬件编码：在Native层实现MediaCodec H264 编码 Demon》提供了详细的实践指导。 1. **H264编码**： H264（也称为AVC，Advanced Video Coding）是一种高压缩效率的视频编码标准，它通过使用更...
Android利用MediaCodec硬解码H264,AAC文件并播放Demo
11-11
本文将详细讲解如何利用MediaCodec进行H264和AAC的硬解码，并播放视频文件。 首先，理解H264和AAC。H264是一种高效能的视频编码标准，它在保持视频质量的同时，显著降低了数据存储和传输的需求。AAC（Advanced ...
Android使用MediaCodec将摄像头采集的视频编码为h264
08-25
MediaCodec可以用来编码和解码多种格式的视频和音频，包括H.264、H.265、VP8、VP9、AAC等。 在Android平台上，MediaCodec可以用来将摄像头采集的视频编码为h264。下面是使用MediaCodec将摄像头采集的视频编码为h264...
Android H.264视频编解码.zip
03-01
3. 视频播放：通过ExoPlayer或MediaPlayer库，可以解码并播放H.264编码的视频文件。 六、挑战与优化 在实际应用中，需要注意内存管理、线程同步以及错误处理等问题。此外，不同的Android设备可能对H.264的支持程度...
Android H264数据解帧和播放.zip
06-02
总的来说，Android平台上的H264解帧和播放涉及到数据的分离、MediaCodec的解码操作以及SurfaceView的使用。这一过程需要理解H264编码格式，熟悉Android的多媒体API，并能有效管理解码器和渲染器的工作流程。掌握这些...
【Android音视频开发】【007】SurfaceView实现H264播放器
天天向上 Up Up Up (*^▽^*)
12-25 1090
在前面，我们已经通过MediaCodec实现了一个AvcDecoder，可以播放H264码流数据 但是AvcDecoder需要手动和Surface绑定，仍然不太方便 这篇文章我们进一步封装，将MediaCodec和SurfaceView集合，实现一个带H264解码功能的控件
音视频6.4——h264文件解码输出到Surface
wygsqsj的博客
11-12 3852
音视频开发路线： Android 音视频开发入门指南_Jhuster的专栏的技术博客_51CTO博客_android 音视频开发入门 demo地址： GitHub - wygsqsj/videoPath: 音视频学习路线demo 获取Surface 首先获取surface,我们MediaCodec解析出来的数据需要放到Surface中进行渲染，获取到surface之后开启解码线程 protected void onCreate(Bundle savedInstanceState) {
Android MediaCodec+OpenGL视频编解码实践笔记
lidec的专栏
06-29 8022
Android MediaCodec+OpenGL视频编解码实践笔记 本文总结了Android MediaCodec配合OpenGL进行视频编解码以及渲染的相关流程。文中提供一个Demo，主要涉及调用Android MediaCodec进行编解码，以及渲染相关流程，针对实际工程中SurfaceView推后台等情况进行优化，渲染部分主要参考了Grafik，目前主要在rk3288平台验证。 1.Demo提供的测试功能 H264编码以及保存视频 H264解码渲染 Opengl绘制相机视频帧 VP8解码
Android Camera to H264 with MediaCodec: A Step-by-Step Guide
"本文主要介绍了如何在Android平台上利用MediaCodec API将摄像头采集的视频流进行H.264编码。首先，我们将从创建一个基本的Android Activity开始，它包含一个SurfaceView用于显示预览画面，并实现SurfaceHolder....
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值