android native层使用mediacodec(硬编解码) mediamuxer mediaExtractor做转码工具。

已于 2022-08-17 20:05:47 修改
阅读量1.2k 收藏
点赞数
文章标签： android
于 2022-08-17 11:14:00 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/cf125313/article/details/126373174
版权

android::sp<android::NuMediaExtractor> spMediaExtractor = new android::NuMediaExtractor(IMediaExtractor::EntryPoint::SDK);//传OTHER压力测试，setDataSource会卡住

       // android::sp<android::FileSource> spFsrc = new android::FileSource(srcPath.c_str());

        if(spMediaExtractor->setDataSource(NULL,srcPath.c_str()) != android::OK){

            return ErrCode::CodeRetEBADF;

        }

源码如下：

/*

 * @Descripttion:

 * @version:

 * @Author: chengfan

 * @Date: 2022-08-10 09:30:05

 * @LastEditors: chengfan

 * @LastEditTime: 2022-08-16 19:45:30

 */

#include "OffSensitive.hpp"

#include "MiscUtils.h"

#include <thread>

#include <media/openmax/OMX_IVCommon.h>

#include <media/stagefright/foundation/ABuffer.h>

#include <media/stagefright/foundation/AMessage.h>

#include <media/stagefright/MediaCodec.h>

#include <datasource/FileSource.h>

#include <media/IMediaHTTPService.h>

#include <media/stagefright/MediaErrors.h>

#include <media/stagefright/MediaMuxer.h>

#include <media/stagefright/NuMediaExtractor.h>

#include <gui/Surface.h>

#include <mediadrm/ICrypto.h>

#include <media/MediaCodecBuffer.h>

#include <utils/KeyedVector.h>

#define HAS_SUR 0

#if HAS_SUR

#include <ui/PixelFormat.h>

#include <gui/ISurfaceComposer.h>

#include <gui/SurfaceComposerClient.h>

#endif

using namespace android;

//using android::android::ALooper;

namespace yfcf

{

    OffSensitive *OffSensitive::pOffSensitive = nullptr;

    OffSensitive::OffSensitive()

    {

    }

    OffSensitive::~OffSensitive()

    {

    }

    OffSensitive *OffSensitive::getInstance()

    {

        if (pOffSensitive == nullptr)

            pOffSensitive = new OffSensitive();

        return pOffSensitive;

    }

    void OffSensitive::freeInstance()

    {

        delete pOffSensitive;

        pOffSensitive = nullptr;

    }

   

    struct AllPoints{

        NuMediaExtractor* extr;

        MediaCodec* vd;

        MediaCodec* ad;

        MediaMuxer* mux;

        MediaCodec* ve;

        MediaCodec* ae;

        bool * shouldEnd;

        bool muxStarted;

        bool mvStarted;

        bool maStarted;

        yuv420pHandler hd;

    };

    static void vdFunc(void* arg);

    static void adFunc(void* arg);

    static void veFunc(void* arg);

    static void aeFunc(void* arg);

    ErrCode OffSensitive::start(string srcPath, string dstDir , string dstFileName,yuv420pHandler hd)

    {

        size_t srcFileSize = get_file_size(srcPath.c_str());

        if( srcFileSize == 0){

            return ErrCode::CodeRetEINVAL;

        }

        uint64_t remainSpace =  check_par_remain(dstDir.c_str());

        if(remainSpace <= srcFileSize ){

            return ErrCode::CodeRetENOSPC;

        }

        bool shouldEnd = true;

        android::sp<android::NuMediaExtractor> spMediaExtractor = new android::NuMediaExtractor(IMediaExtractor::EntryPoint::OTHER);

       // android::sp<android::FileSource> spFsrc = new android::FileSource(srcPath.c_str());

        if(spMediaExtractor->setDataSource(NULL,srcPath.c_str()) != android::OK){

            return ErrCode::CodeRetEBADF;

        }

        size_t trackCnt = spMediaExtractor->countTracks();

        android::sp<android::AMessage> spFormat;

        android::AString mime;

        int32_t vTrackId = -1;

        sp<android::ALooper> spVideoDecLooper ;

        sp<MediaCodec> spVideoDec ;

        sp<android::ALooper> spVideoEncLooper ;

        sp<MediaCodec> spVideoEnc ;

        int32_t aTrackId = -1;

        sp<android::ALooper> spAudioDecLooper ;

        sp<MediaCodec> spAudioDec ;

        sp<android::ALooper> spAudioEncLooper ;

        sp<MediaCodec> spAudioEnc ;

        #if HAS_SUR

        sp<SurfaceComposerClient> mSession = new SurfaceComposerClient();

        sp<SurfaceControl> control = mSession->createSurface(String8("offsen"),

                                                              1920, 1080, PIXEL_FORMAT_RGBA_8888);

        SurfaceComposerClient::Transaction t;

        t.setLayer(control, 0x10000000);

        t.setLayerStack(control, 0);

        t.show(control);

        t.apply();

        sp<Surface> mFlingerSurface = control->getSurface();

        #endif

        for(size_t i = 0; i<trackCnt; i++){

            if(spMediaExtractor->getTrackFormat(i,&spFormat)!=OK || spFormat->findString("mime",&mime)==false )

                continue;

            int32_t br = 0;

            spFormat->findInt32("bitrate",&br);

            int32_t prof = -1;spFormat->findInt32("profile",&prof);

            if (strncasecmp(mime.c_str(),"video/",6)==0){

                int32_t w = 0;

                spFormat->findInt32("width",&w);

                int32_t h = 0;

                spFormat->findInt32("height",&h);

                float fr = 0.;

                spFormat->findFloat("frame-rate",&fr);

               

               

                LOGD(LOG_TAG,"w=%d h=%d fr=%f br=%d",w,h,fr,br);

               

                int32_t level = -1; spFormat->findInt32("level",&level);

                int32_t ifr = -1; spFormat->findInt32("frame-rate",&ifr);

               

                LOGD(LOG_TAG,"prof%d level=%d %d",prof,level,ifr);

                if(w==0 || h==0 ){

                    continue;

                }

                spVideoDecLooper = new android::ALooper();

                spVideoDecLooper->setName("video_dec");

                if(spVideoDecLooper->start() != OK){

                    LOGE(LOG_TAG,"video dec loop start err");

                    spVideoDecLooper.clear();

                    continue;

                }

                spVideoDec = MediaCodec::CreateByType(spVideoDecLooper,mime,false);

                if(spVideoDec.get() == nullptr){

                    spVideoDecLooper->stop();

                    spVideoDecLooper.clear();

                    LOGE(LOG_TAG,"create video dec err:%s",mime.c_str());

                    continue;

                }

              //  sp<Surface> spSurface;

              #if HAS_SUR

                if(spVideoDec->configure(spFormat,mFlingerSurface,NULL,0) != OK){

              #else

                if(spVideoDec->configure(spFormat,NULL,NULL,0) != OK){

              #endif

                    spVideoDecLooper->stop();

                    spVideoDecLooper.clear();

                    spVideoDec->release();

                    spVideoDec.clear();

                    LOGE(LOG_TAG,"configure video dec err");

                    continue;

                }

                sp<AMessage> veformat = new AMessage;

                veformat->setInt32("width", w);    

                veformat->setInt32("height", h);  

                veformat->setString("mime", "video/avc");  

                //OMX_COLOR_FormatYUV420Flexible  

                veformat->setInt32("color-format", OMX_COLOR_FormatYUV420Flexible);

                if(br<10)

                    br = w*h*58/10;

               // LOGW(LOG_TAG,"BR IS %d",br);

                veformat->setInt32("bitrate", br);

                if(fr>1.0)

                    veformat->setFloat("frame-rate",fr);

                if(ifr>2)

                    veformat->setInt32("frame-rate",ifr);

               // veformat->setInt32("level",level);

                //PROFILE_AVC_MAIN

                if(prof==-1)

                    prof = 2;

              //  veformat->setInt32("profile", prof);  

                veformat->setInt32("i-frame-interval", 5);  

                spVideoEncLooper = new android::ALooper();

                spVideoEncLooper->setName("video_enc");

                if(spVideoEncLooper->start() != OK){

                    spVideoDec->release();

                    spVideoDec.clear();

                    spVideoDecLooper->stop();

                    spVideoDecLooper.clear();

                    LOGE(LOG_TAG,"video enc loop start err");

                    spVideoEncLooper.clear();

                    continue;

                }

               

                spVideoEnc = MediaCodec::CreateByType(spVideoEncLooper,"video/avc",true);

                if(spVideoEnc.get() == nullptr){

                    spVideoEncLooper->stop();

                    spVideoEncLooper.clear();

                    LOGE(LOG_TAG,"create video enc err:%s",mime.c_str());

                    spVideoDecLooper->stop();

                    spVideoDecLooper.clear();

                    spVideoDec->release();

                    spVideoDec.clear();

                    continue;

                }

                if(spVideoEnc->configure(veformat,nullptr,nullptr,MediaCodec::CONFIGURE_FLAG_ENCODE) != OK){

                    spVideoEnc->release();

                    spVideoEnc.clear();

                    spVideoEncLooper->stop();

                    spVideoEncLooper.clear();

                    LOGE(LOG_TAG,"configure video enc err");

                    spVideoDec->release();

                    spVideoDec.clear();

                    spVideoDecLooper->stop();

                    spVideoDecLooper.clear();

                    continue;

                }

                if(YFUNLIKELY(spMediaExtractor->selectTrack(i)!=OK)){

                    LOGE(LOG_TAG,"extractor select video track err");

                }

                vTrackId = i;

                shouldEnd = false;

            }else if(strncasecmp(mime.c_str(),"audio/",6)==0 && spAudioDecLooper.get()==nullptr){

                int32_t sr = 0;

                spFormat->findInt32("sample-rate",&sr);

               

                int32_t mis = 0;

                spFormat->findInt32("max-input-size",&mis);

                int32_t chanelCnt= 0;

                spFormat->findInt32("channel-count",&chanelCnt);

                int32_t aacProf = -1;

                spFormat->findInt32("aac-profile",&aacProf);

                LOGD(LOG_TAG,"sr=%d  br=%d mis=%d chanelCnt=%d aac_profile=%d",sr,br,mis,chanelCnt,aacProf);

                if(spAudioEnc.get()){

                    LOGW(LOG_TAG,"audio codec already inited");

                    continue;

                }

                spAudioDecLooper = new android::ALooper();

                spAudioDecLooper->setName("audio_dec");

                if(spAudioDecLooper->start() != OK){

                    LOGE(LOG_TAG,"Audio dec loop start err");

                    spAudioDecLooper.clear();

                    continue;

                }

                spAudioDec = MediaCodec::CreateByType(spAudioDecLooper,mime,false);

                if(spAudioDec.get() == nullptr){

                    spAudioDecLooper->stop();

                    spAudioDecLooper.clear();

                    LOGE(LOG_TAG,"create Audio dec err:%s",mime.c_str());

                    continue;

                }

                if(spAudioDec->configure(spFormat,nullptr,nullptr,0) != OK){

                    spAudioDecLooper->stop();

                    spAudioDecLooper.clear();

                    spAudioDec->release();

                    spAudioDec.clear();

                    LOGE(LOG_TAG,"configure Audio dec err");

                    continue;

                }

                sp<AMessage> aeformat = new AMessage;

                aeformat->setString("mime", "audio/mp4a-latm");

                if(br<10)

                    br = 48000;    

                aeformat->setInt32("bitrate", 125000);

                if(sr<100)

                    sr = 48000;

                aeformat->setInt32("sample-rate",sr);

                if(mis<10)

                    mis =  65541; mis = 1048576;

                aeformat->setInt32("max-input-size",mis);

                aeformat->setInt32("channel-count",1);

              //  aeformat->setInt32("profile", prof);

                if(aacProf==-1)

                    aacProf = 2;

                aeformat->setInt32("aac-profile", aacProf);  

                spAudioEncLooper = new android::ALooper();

                spAudioEncLooper->setName("Audio_enc");

                if(spAudioEncLooper->start() != OK){

                    spAudioDecLooper->stop();

                    spAudioDecLooper.clear();

                    spAudioDec->release();

                    spAudioDec.clear();

                    LOGE(LOG_TAG,"Audio enc loop start err");

                    spAudioEncLooper.clear();

                    continue;

                }

                spAudioEnc = MediaCodec::CreateByType(spAudioEncLooper,"audio/mp4a-latm",true);

                if(spAudioEnc.get() == nullptr){

                    spAudioEncLooper->stop();

                    spAudioEncLooper.clear();

                    LOGE(LOG_TAG,"create Audio enc err:%s",mime.c_str());

                    spAudioDecLooper->stop();

                    spAudioDecLooper.clear();

                    spAudioDec->release();

                    spAudioDec.clear();

                    continue;

                }

                if(spAudioEnc->configure(aeformat,NULL,NULL,MediaCodec::CONFIGURE_FLAG_ENCODE) != OK){

                    spAudioEncLooper->stop();

                    spAudioEncLooper.clear();

                    spAudioEnc->release();

                    spAudioEnc.clear();

                    LOGE(LOG_TAG,"configure Audio enc err");

                    spAudioDecLooper->stop();

                    spAudioDecLooper.clear();

                    spAudioDec->release();

                    spAudioDec.clear();

                    continue;

                }

                if(YFUNLIKELY(spMediaExtractor->selectTrack(i)!=OK)){

                    LOGE(LOG_TAG,"extractor select Audio track err");

                }

                aTrackId = i;

                shouldEnd = false;

            }

        }

        if(shouldEnd){

            return ErrCode::CodeRetEBADF;

        }

        string dstFileFull = dstDir + dstFileName;

        int outFd = open( dstFileFull.c_str(), O_CREAT|O_CLOEXEC|O_TRUNC|O_RDWR,0666);

        if(outFd == -1){

            LOGE(LOG_TAG,"open file err %s %s",dstFileFull.c_str(),strerror(errno));

        }

        sp<MediaMuxer> spMediaMux = new MediaMuxer(outFd,MediaMuxer::OUTPUT_FORMAT_MPEG_4);

        if(vTrackId>=0){

            if(spVideoDec->start()!=OK)

                LOGE(LOG_TAG,"video dec start err,should never happen");    

        }

        if(aTrackId>=0){

            if(spAudioDec->start()!=OK)

                LOGE(LOG_TAG,"audio dec start err,should never happen");

        }

        AllPoints arg = {spMediaExtractor.get(),spVideoDec.get(),spAudioDec.get(),spMediaMux.get(),spVideoEnc.get(),spAudioEnc.get(),&shouldEnd,false,false,false,hd};

        std::thread vdTid(vdFunc,&arg);

        std::thread adTid(adFunc,&arg);

        size_t avTrackId = -1011;

        size_t buffIndex;

       

        status_t tmp;

        size_t sampSize;

        int64_t pts;

        AString err_str;

        sp<ABuffer> spAbuf;

        #if 0

        Vector<sp<MediaCodecBuffer>> vdBufs;

        spVideoDec->getInputBuffers(&vdBufs);

        Vector<sp<MediaCodecBuffer>> adBufs;

        spVideoDec->getInputBuffers(&adBufs);

        #endif

        while (!shouldEnd)

        {

            tmp = spMediaExtractor->getSampleTrackIndex(&avTrackId);

          //  LOGD(LOG_TAG,"avTrackId is %" PRIuFAST32,avTrackId);

            if(tmp == -1011){

                shouldEnd = true;

                LOGI(LOG_TAG,"EXTRACTOR end");

                break;

            }

            if(spMediaExtractor->getSampleSize(&sampSize) != OK || spMediaExtractor->getSampleTime(&pts)!= OK){

                LOGE(LOG_TAG,"this should never happen");

            }

            if(sampSize<=0){

                shouldEnd = true;

                LOGI(LOG_TAG,"EXTRACTOR end2");

                break;

            }

            if(avTrackId == vTrackId){

                while( (tmp = spVideoDec->dequeueInputBuffer(&buffIndex,70000))!=OK)

                {  

                    static uint32_t cnt = 0;

                    cnt++;

                    if(tmp!=-11)

                        cnt = 11;

                    if(cnt>=10){

                        LOGI(LOG_TAG,"VD dequeue ibuff err %d",tmp);

                        cnt = 0;

                    }

                   

                }

                sp<MediaCodecBuffer> spMediaCodecBuf;

                spVideoDec->getInputBuffer(buffIndex,&spMediaCodecBuf);

              //  spMediaCodecBuf = vdBufs.itemAt(buffIndex);

                spAbuf =  new ABuffer(spMediaCodecBuf->base(), spMediaCodecBuf->capacity());

                tmp =spMediaExtractor->readSampleData(spAbuf);

                if(tmp != OK){

                    LOGI(LOG_TAG,"V readSampleData err %" PRId32,tmp);

                    continue;

                }

                spMediaCodecBuf->setRange(spAbuf->offset(), spAbuf->size());

                tmp = spVideoDec->queueInputBuffer(buffIndex,spAbuf->offset(),spAbuf->size(),pts,0,&err_str);

                if(tmp!=OK){

                    LOGE(LOG_TAG,"V dec queue ibuff err:%d %s",tmp,err_str.c_str());

                }

                spMediaExtractor->advance();

            }else if(avTrackId == aTrackId){

                while( (tmp = spAudioDec->dequeueInputBuffer(&buffIndex,50000))!= OK){

                    LOGI(LOG_TAG,"aD dequeue ibuff err %" PRId32,tmp);

                    continue;

                }

                sp<MediaCodecBuffer> spMediaCodecBuf;

                while ( (tmp = spAudioDec->getInputBuffer(buffIndex,&spMediaCodecBuf))!=OK)

                {

                    LOGW(LOG_TAG,"a err %d bidx=%" PRIuFAST32,tmp,buffIndex);

                }

                spAbuf =  new ABuffer(spMediaCodecBuf->base(), spMediaCodecBuf->capacity());

                tmp =spMediaExtractor->readSampleData(spAbuf);

                if(tmp != OK){

                    LOGI(LOG_TAG,"a readSampleData err %" PRId32,tmp);

                    continue;

                }

                tmp = spAudioDec->queueInputBuffer(buffIndex,0,sampSize,pts,0,&err_str);

                if(tmp!=OK){

                    LOGE(LOG_TAG,"a dec queue ibuff err:%d %s",tmp,err_str.c_str());

                }

                spMediaExtractor->advance();

            }

        }

        vdTid.join();

        adTid.join();

        spMediaMux->stop();

        if(outFd!=-1)

            close(outFd);

        spVideoDec->stop();

        spVideoDec->release();

        spVideoDecLooper->stop();

        spVideoEnc->stop();

        spVideoEnc->release();

        spVideoEncLooper->stop();

        spAudioDec->stop();

        spAudioDec->release();

        spAudioDecLooper->stop();

        spAudioEnc->stop();

        spAudioEnc->release();

        spAudioEncLooper->stop();

        #if HAS_SUR

        mFlingerSurface.clear();

        control.clear();

        mSession.clear();

        #endif

        LOGI(LOG_TAG,"off-sensitive end");

        return  ErrCode::CodeRetOK;

    }

   

    void vdFunc(void* arg){

        AllPoints* all = (AllPoints*)arg;

        all->ve->start();

        size_t bufIdx;

        size_t offset = 0;

        size_t sampSize;

        int64_t pts;

        uint32_t oFlags;

        size_t oBufIdx;

        status_t tmp;

        sp<MediaCodecBuffer> spMcb;

        sp<MediaCodecBuffer> spMcbi;

        AString err_str;

        bool* shouldEnd = all->shouldEnd;

        std::thread veTid(veFunc,arg);

        while(*shouldEnd == false){

            oFlags = 0;

            tmp = all->vd->dequeueOutputBuffer(&bufIdx,&offset,&sampSize,&pts,&oFlags,20000);

            if((tmp!=OK && tmp!=-11)||oFlags>1 ){

                LOGD(LOG_TAG,"VD de obuf tmp=%d flag %d index=%" PRIuFAST32 ,tmp,oFlags,bufIdx);

               

            }

            if(tmp == -1012){

                sp<AMessage> format ;

                all->vd->getOutputFormat(&format);

                int32_t cf = -1;

                format->findInt32("color-format",&cf);

                LOGW(LOG_TAG,"VD COlor format is %d",cf);

            }

            if(tmp!=OK)

                continue;

            if(oFlags&MediaCodec::BUFFER_FLAG_EOS){

                *shouldEnd = true;

                break;

            }

            if(bufIdx>=0){

                all->vd->getOutputBuffer(bufIdx,&spMcb);

                if(all->hd)

                {

                    all->hd(spMcb->data(),spMcb->size());

                }

                while( (tmp = all->ve->dequeueInputBuffer(&oBufIdx,50000) ) !=OK){

                    LOGI(LOG_TAG,"VE de ibuf err %" PRId32,tmp);

                }

                all->ve->getInputBuffer(oBufIdx,&spMcbi);

                spMcbi->setRange(spMcb->offset(),spMcb->size());

                memcpy(spMcbi->data(),spMcb->data(),spMcb->size());

               

                tmp =all->ve->queueInputBuffer(oBufIdx,0,sampSize,pts,0,&err_str);

                if(tmp!=OK){

                    LOGW(LOG_TAG,"ve queue ibuf err %s %" PRId32,err_str.c_str(),tmp);

                }

                all->vd->releaseOutputBuffer(bufIdx);

            }

        }

        all->vd->flush();

        LOGI(LOG_TAG,"vd end");

        veTid.join();

    }

    static uint64_t avTs[2] = {0,0};

    void veFunc(void* arg){

        AllPoints* all = (AllPoints*)arg;

        size_t bufIdx;

        size_t offset = 0;

        size_t sampSize;

        int64_t pts;

        uint32_t oFlags;

        size_t oBufIdx;

        status_t tmp;

        sp<MediaCodecBuffer> spMcb;

        AString err_str;

        sp<AMessage> oFormat;

        bool* shouldEnd = all->shouldEnd;

        size_t vTrackIdE = -1;

        sp<ABuffer> spAbuf;

        while (*shouldEnd == false)

        {

            oFlags = 0;

            tmp = all->ve->dequeueOutputBuffer(&bufIdx,&offset,&sampSize,&pts,&oFlags,20000);

            if((tmp!=OK && tmp!=-11)||oFlags >1 ){

                LOGD(LOG_TAG,"Ve de obuf tmp=%d flag %d index=%" PRIuFAST32 ,tmp,oFlags,bufIdx);

               

            }

            switch (tmp)

            {

            case OK:{

                all->ve->getOutputBuffer(bufIdx,&spMcb);

                spAbuf = new ABuffer(spMcb->data(),spMcb->size());

                if(avTs[0]==0){

                    avTs[0] = bag_get_boot_time();

                    LOGW(LOG_TAG,"vpts=%" PRId64 ,pts);

                }

                if(all->muxStarted)

                    all->mux->writeSampleData(spAbuf,vTrackIdE,pts,oFlags);

                all->ve->releaseOutputBuffer(bufIdx);

            }

                break;

            case INFO_FORMAT_CHANGED:{

                all->ve->getOutputFormat(&oFormat);

                vTrackIdE = all->mux->addTrack(oFormat);

                //toDo lock

                all->mvStarted = true;

                if(all->maStarted){

                    all->mux->start();

                    all->muxStarted = true;

                }

               

            }

                break;

            default:

                break;

            }

            if(oFlags&MediaCodec::BUFFER_FLAG_EOS ){

                *shouldEnd = true;

                break;

            }

           

        }

        all->ve->flush();

        LOGI(LOG_TAG,"ve end");

    }

    void adFunc(void* arg){

        AllPoints* all = (AllPoints*)arg;

        all->ae->start();

        size_t bufIdx;

        size_t offset = 0;

        size_t sampSize;

        int64_t pts;

        uint32_t oFlags;

        size_t oBufIdx;

        status_t tmp;

        sp<MediaCodecBuffer> spMcb;

        sp<MediaCodecBuffer> spMcbi;

        AString err_str;

        bool* shouldEnd = all->shouldEnd;

        std::thread aeTid(aeFunc,arg);

        while(*shouldEnd == false){

            oFlags = 0;

            tmp = all->ad->dequeueOutputBuffer(&bufIdx,&offset,&sampSize,&pts,&oFlags,20000);

            if((tmp!=OK && tmp!=-11)||oFlags>1 ){        

                LOGD(LOG_TAG,"aD de obuf flag %d tmp=%d index=%" PRIuFAST32 ,oFlags,tmp,bufIdx);

               

            }

            if(oFlags&MediaCodec::BUFFER_FLAG_EOS ){

                *shouldEnd = true;

                break;

            }

            if(tmp == OK){

                all->ad->getOutputBuffer(bufIdx,&spMcb);

                while( (tmp = all->ae->dequeueInputBuffer(&oBufIdx,50000) ) !=OK){

                    LOGI(LOG_TAG,"aE de ibuf err %" PRId32,tmp);

                }

                all->ae->getInputBuffer(oBufIdx,&spMcbi);

             //   LOGD(LOG_TAG,"off=%" PRIuFAST32 "cap=%" PRIuFAST32,spMcb->offset(),spMcb->capacity());

                spMcbi->setRange(spMcb->offset(),spMcb->size());

                memcpy(spMcbi->data(),spMcb->data(),spMcb->size());

                tmp =all->ae->queueInputBuffer(oBufIdx,0,sampSize,pts,0,&err_str);

                if(tmp!=OK){

                    LOGW(LOG_TAG,"ae queue ibuf err %s %" PRId32,err_str.c_str(),tmp);

                }

               

                all->ad->releaseOutputBuffer(bufIdx);

            }

        }

        all->ad->flush();

        LOGI(LOG_TAG,"ad end");

        aeTid.join();

    }

    struct ABuffInfo{

        uint8_t* data;

        size_t dl;

        uint32_t oFlags;

        int64_t pts;

    };

    void aeFunc(void* arg){

        AllPoints* all = (AllPoints*)arg;

        size_t bufIdx;

        size_t offset = 0;

        size_t sampSize;

        int64_t pts;

        uint32_t oFlags;

        size_t oBufIdx;

        status_t tmp;

        sp<MediaCodecBuffer> spMcb;

        AString err_str;

        sp<AMessage> oFormat;

        bool* shouldEnd = all->shouldEnd;

        size_t aTrackIdE = -1;

        sp<ABuffer> spAbuf;

        Vector<ABuffInfo*> bufs;

        bufs.clear();

        int ccc=0;

        while (*shouldEnd == false)

        {

            oFlags = 0;

            tmp = all->ae->dequeueOutputBuffer(&bufIdx,&offset,&sampSize,&pts,&oFlags,20000);

            if((tmp!=OK && tmp!=-11)||oFlags>1 ){

                LOGD(LOG_TAG,"ae de obuf tmp=%d flag %d index=%" PRIuFAST32 ,tmp,oFlags,bufIdx);

               

            }

            switch (tmp)

            {

            case OK:{

                if(oFlags&MediaCodec::BUFFER_FLAG_EOS ){

                    *shouldEnd = true;

                    break;

                }else if(oFlags&MediaCodec::BUFFER_FLAG_CODECCONFIG){

                }

               

                all->ae->getOutputBuffer(bufIdx,&spMcb);

                spAbuf = new ABuffer(spMcb->data(),sampSize);

                static uint64_t loss = 0;

                static int64_t ps = 0;

                #if 1

                    ABuffInfo* bi = new ABuffInfo;

                    bi->data = (uint8_t*)malloc(sampSize);

                    memcpy(bi->data,spMcb->data(),sampSize);

                    bi->dl = sampSize;

                    bi->oFlags = oFlags;

                    bi->pts = pts;

                    bufs.add(bi);

                    ccc++;

                    #endif

                if(all->muxStarted){

                    #if 1

                   

                    for(size_t i =0 ;i<bufs.size();i++){

                        sp<ABuffer> ab = new ABuffer(bufs.editItemAt(i)->data,bufs.editItemAt(i)->dl);

                        tmp = all->mux->writeSampleData(ab,aTrackIdE,bufs.editItemAt(i)->pts,bufs.editItemAt(i)->oFlags);

                        if(tmp!=OK || bufs.editItemAt(i)->oFlags){

                            LOGE(LOG_TAG,"tmp-=%d %" PRIu32,tmp,bufs.editItemAt(i)->oFlags);

                        }

                        free(bufs.editItemAt(i)->data);

                        delete bufs.editItemAt(i);

                        bufs.removeAt(i);

                        break;

                    }

                    #endif

                    if(avTs[1]==0){

                        avTs[1] = bag_get_boot_time();

                        LOGW(LOG_TAG,"av %" PRIu64 " %" PRIu64,avTs[1],avTs[0]);

                        LOGW(LOG_TAG,"TS %" PRId64 " %" PRId64 " %" PRIu64,ps,pts,loss);

                        ps = pts;

                    }

                 //   tmp = all->mux->writeSampleData(spAbuf,aTrackIdE,pts,oFlags);

                   

                }

                else{

                    if(ps==0)

                        ps = pts;

                    loss+=sampSize;

                   

                }

               

                all->ae->releaseOutputBuffer(bufIdx);

            }

                break;

            case INFO_FORMAT_CHANGED:{

                all->ae->getOutputFormat(&oFormat);

                aTrackIdE = all->mux->addTrack(oFormat);

                //toDo lock

                all->maStarted = true;

                if(all->mvStarted){

                    all->mux->start();

                    all->muxStarted = true;

                }

            }

                break;

            default:

                break;

            }

           

           

        }

        all->ae->flush();

        LOGI(LOG_TAG,"ae end");

    }

}

无v邪
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
Andriod 录屏：AudioRecord、MediaProjection、MediaCodec、MediaMuxer
三木仔
12-10 2826
Android 为开发者提供了MediaRecorder的类，可以帮助录屏。但是重要的缺陷： MediaRecorder控制粒度很粗，无法完成更多的自定义功能，如对音频数据处理 MediaRecorder录制的效果很差，特别是音频效果。 为了更好的效果，最终决定利用AudioRecord、MediaProjection、MediaCodec、MediaMuxer几个重要的组件进行录屏。 这几个组件都涉及到很多的音视频的知识，建议先看之前的音视频相关的文章介绍。
【Android音视频开发】：AAC编码格式分析与MP4文件封装(MediaCodec+MediaMuxer)
weixin_42602900的博客
02-08 2822
ffmpeg开发之旅(3)：AAC编码格式分析与MP4文件封装(MediaCodec+MediaMuxer) (原文链接：http://blog.csdn.net/andrexpert/article/details/72523408) 1.AAC编码格式分析 (1)AAC简介 高级音频编码(AdvancedAudio Coding，AAC)一种基于MPEG-4的音频编码技术，它由杜比实验室、AT&T等公司共同研发，目的是替换MP3编码方式。作为一种高压缩比的音频压缩算法...
android硬编解码MediaCodec
wangbuji的博客
05-26 4884
一 mediacodec简介 MediaCodec 类可以用来访问底层媒体编解码器，即编码器/解码器的组件。 它是 Android 底层多媒体支持架构的一部分（通常与 MediaExtractor，MediaSync，MediaMuxer，MediaCrypto，MediaDrm，Image，Surface 和 AudioTrack 一起使用）。 编解码器可以处理三类数据：压缩数据、原始音频数据、原始视频数据。 a Compressed Buffers 压缩缓冲区 输...
Android 音视频入门 （四）- 记录一次MediaCodec + MediaMuxer的使用，血与泪的总结
最新发布
2401_84150107的博客
04-06 815
都说三年是程序员的一个坎，能否晋升或者提高自己的核心竞争力，这几年就十分关键。技术发展的这么快，从哪些方面开始学习，才能达到高级工程师水平，最后进阶到Android架构师/技术专家？我总结了这 5大块；我搜集整理过这几年阿里，以及腾讯，字节跳动，华为，小米等公司的面试题，把面试的要求和技术点梳理成一份大而全的“ Android架构师”面试 PDF（实际上比预期多花了不少精力），包含知识脉络 + 分支细节。Java语言与原理；大厂，小厂。Android面试先看你熟不熟悉Java语言高级UI与自定义view。
【音视频笔记】Mediacodec+Muxer生成mp4，浏览器无法播放问题处理
China_Style的专栏
09-21 943
用AudioRecord + MediaCodec + MediaMuxer生成MP4，用PC浏览器无法播放，但是其他播放器应用能播放。用ffprobe命令检查视频文件，有"[aac @ 0x7ffa3681f800] Input buffer exhausted before END"。记录一下我是如何解决这个问题的。
Android在NDK JNI中使用MediaMuxer合成mp4的流程
qq_27637465的博客
09-27 2048
如果不写这个结束包的话，保存的视频也可以播放，但是log会报一个录入音视频流没有正确结束的错误：mpeg4writer: stop() called but track is not started or stopped。这里写入的数据是h264/h265数据包的。音频部分大概也是在视频轨道的基础上再加一个音频轨道，如果有大佬在此基础上增加，可以A一下我，多谢了。前言：找了很久，很少有NDK层使用合成mp4的例程，由于我们使用的是实时流合成mp4的文件，基本所有的视频流都是在C++操作的。
android MediaCodec 实现h264硬编解码全过程
05-27
MediaCodec 实现h264硬编解码全过程，视频数据从摄像头读出 yv12格式，转换为I420，投递给encoder,再从encoder取出编码后的h264数据投递给decoder后显示到surfaceView; 实现了udp将h264数据发送到指定主机，可通过...
android mediacodec 硬编解码
12-30
实现mediacodec硬编解码，支持预览和解码图像同时在2个surface显示。三星s6亲测有效，有需要的就拿去吧。
Android 实时MediaCodec音频硬编解码播放
12-02
实时MediaCodec音频硬编解码，音频录制，编码，解码，播放都正常，本人已亲自测试
Android 硬解码MediaCodecDemo
12-12
1 MediaCodec硬解码demo 2 包含h264码流资源 3 包含如何处理硬解码过程中出现的各种crash／anr／黑屏
Android使用MediaCodeC与OpenGL硬解码 录制mp4音视频实现源码
11-02
将Camera数据显示到OpenGL ES渲染的图像中，并通过MediaCodeC 将 OpenGL ES 缓冲数据，硬编码写入到 mp4 视频文件中，完成视频的录制。 文件介绍请见： https://xiaxl.blog.csdn.net/article/details/72530314 ...
mediacodec c++.
12-11
实现在Android4.1以上的系统直接在jni c++ 使用MediaCodec，无需Android5.0以上。 提供了C++代码加载so库并动态导出符号的方法
Android中MediaMuxer和MediaCodec用例 - audio+video
世事难料，保持低调
06-18 4万+
在Android的多媒体类中，MediaMuxer和MediaCodec算是比较年轻的，它们是JB 4.1和JB 4.3才引入的。前者用于将音频和视频进行混合生成多媒体文件。缺点是目前只能支持一个audio track和一个video track，而且仅支持mp4输出。不过既然是新生事物，相信之后的版本应该会有大的改进。MediaCodec用于将音视频进行压缩编码，它有个比较牛X的地方是可以对Surface内容进行编码，如KK 4.4中屏幕录像功能就是用它实现的。
Android-->MediaMuxer,MediaCodec,AudioRecord及Camera实现音频视频混合MP4文件
热门推荐
<angcyo>菜鸟视角
04-02 5万+
本文相当长,读者请注意… 阅读之前,我喜欢你已经了解了以下内容: 1:https://github.com/saki4510t/AudioVideoRecordingSample 这个开源库介绍了, 音频和视频的录制, 其实已经够了~~~,不过视频的录制采用的是GLSurfaceView中的Surface方法, 并没有直接采用TextureView和Camera的PreviewCallb
Android 基于MediaCodec+MediaMuxer实现音视频录制合成
weixin_30587025的博客
08-01 1812
AudioVideoCodec 一款视频录像机，支持AudioRecord录音、MediaCodec输出AAC、MediaMuxer合成音频视频并输出mp4，支持自动对焦、屏幕亮度调节、录制视频时长监听、手势缩放调整焦距等 项目地址 音视频录制合成(github.com/MannaYang/A…) 单独音频录制播放(github.com/MannaYang/A…) 功能简介 目前包含基本的音频...
OpenGL.ES在Android上的简单实践：21-水印录制（MediaCodec输出h264+MediaMuxer合成mp4 上）
vx number：zzr_admin，拉入技术交流群。
06-01 3869
OpenGL.ES在Android上的简单实践：21-水印录制（MediaCodec输出h264+MediaMuxer合成mp4 上） 1、录制视频需要什么？ 在上篇文章，我们已经成功的满足了需求，在预览摄像头的同时加上一些简单的视频二次处理（水印）。接下来我们就是要把视频录制下来，这就涉及视频的编码范畴了。视频编解码知识点无论在哪个平台上的操作系统上，都是比较难的一个知识点。在Android...
Android音视频开发（四）——MediaCodec：解码视频，得到YUV值，一帧一帧加载到SD卡中保存。
indeedes的博客
05-24 6324
我们上一节了解了MediaExtractor、MediaMuxer、MediaFormat、MediaCodec.BufferInfo。重复的内容我就不再赘述了，假如有上面的四个的一些补充还是会写一下。接下来我们学习MediaCodec，本节篇幅会比较长，知识点较多，请耐心品味。 一、MediaCodec ​ MediaCodec类可用于访问低级媒体编解码器，即编码器/解码器组件。它是Android低级多媒体支持基础设施的一部分(通常与MediaExtractor, ...
Android 9.0 multimedia框架（一）加载media extractor组件
eatlemon的博客
07-22 958
multimedia框架之加载media extractor组件 Extractor概念关键类说明流程图DataSourceUpdateExtractorsIMediaExtractor Extractor概念 Extractor在multimedia框架扮演着解析器的角色，用于解析文件的封装。extractor会把视频文件解析成音频流和视频流，把音频文件解析成音频流。 关键类说明 NuMediaExtractor：在NuMediaExtractor中，会去保存RemoteMediaExtractor的
Android多媒体框架（7）—— stagefright中MediaMuxer源码分析
hunter800421的专栏
02-08 756
stagefright中MediaMuxer源码分析 私有属性定义 MediaMuxer.h中定义了一些类的属性： const OutputFormat mFormat; sp&amp;lt;MediaWriter&amp;gt; mWriter; Vector&amp;lt; sp&amp;lt;MediaAdapter&amp;gt; &amp;gt; mTrackList; // Each track has its...
android上，怎么使用mediacodec进行软解码
05-25
Android 中的 MediaCodec 类可以用于进行音频和视频的硬件加速编解码，也可以用于软解码。下面是一个使用 MediaCodec 进行软解码的简单示例： 1. 首先创建一个 MediaExtractor 对象，用于从媒体文件中提取音视频数据。 ```java MediaExtractor extractor = new MediaExtractor(); extractor.setDataSource(filePath); ``` 2. 根据需要解码的轨道类型（音频或视频），选择对应的轨道进行解码。 ```java int trackIndex = -1; for (int i = 0; i < extractor.getTrackCount(); i++) { MediaFormat format = extractor.getTrackFormat(i); String mime = format.getString(MediaFormat.KEY_MIME); if (mime.startsWith("audio/")) { // 解码音频轨道 trackIndex = i; break; } else if (mime.startsWith("video/")) { // 解码视频轨道 trackIndex = i; break; } } if (trackIndex == -1) { // 没有找到相应的轨道，退出 return; } extractor.selectTrack(trackIndex); ``` 3. 创建 MediaCodec 对象并进行配置。 ```java MediaFormat format = extractor.getTrackFormat(trackIndex); MediaCodec codec = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)); codec.configure(format, null, null, 0); codec.start(); ``` 4. 循环读取音视频数据并进行解码。读取的数据需要写入到 MediaCodec 的输入缓冲区中，然后调用 MediaCodec 的 dequeueInputBuffer() 方法获取已经被填充数据的输入缓冲区，并将其传递给 MediaCodec 进行解码。解码完成后，从 MediaCodec 的输出缓冲区中读取解码后的音视频数据。 ```java boolean inputEnd = false; boolean outputEnd = false; while (!outputEnd) { if (!inputEnd) { int inputBufferIndex = codec.dequeueInputBuffer(-1); if (inputBufferIndex >= 0) { ByteBuffer inputBuffer = codec.getInputBuffer(inputBufferIndex); int sampleSize = extractor.readSampleData(inputBuffer, 0); if (sampleSize < 0) { inputEnd = true; codec.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM); } else { codec.queueInputBuffer(inputBufferIndex, 0, sampleSize, extractor.getSampleTime(), 0); extractor.advance(); } } } int outputBufferIndex = codec.dequeueOutputBuffer(info, -1); if (outputBufferIndex >= 0) { if ((info.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) { outputEnd = true; } ByteBuffer outputBuffer = codec.getOutputBuffer(outputBufferIndex); // 处理解码后的音视频数据 codec.releaseOutputBuffer(outputBufferIndex, false); } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) { MediaFormat newFormat = codec.getOutputFormat(); // 处理输出格式的变化 } } ``` 5. 最后，释放资源。 ```java codec.stop(); codec.release(); extractor.release(); ``` 这只是一个简单的示例，实际上使用 MediaCodec 进行软解码需要考虑很多细节，例如解码后的音视频数据的处理、异常情况的处理等。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

无v邪

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

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

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

打赏作者

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

抵扣说明：

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

余额充值