视音频录制流程（二）

桃扇骨 2022-05-26 02:50 489阅读 0赞

接续：[https://blog.csdn.net/lin20044140410/article/details/80057981][https_blog.csdn.net_lin20044140410_article_details_80057981]

前面的过程漏了一点，就是camera设备的打开过程，也就是mCamera=Camera.open(CAMERA\_ID)，分析的recorder.setCamera(mCamera);中的参数就是open的返回值。open()的过程还是很长的，下面只关注跟cameraService，ICameraClient相关一小部分，以便跟前面的connect中的描述可以串起来。

连接camera设备的过程，是先获取cameraservice的句柄，然后执行cameraservice的connect方法。这个过程会创建一个cameraclient实例CameraDeviceClient，并作为出参回传给调用者，也就是device指向指针的指针。

Frameworks/av/service/camera/libcameraservice/cameraservice.cpp
    Status CameraService::connect(
            const sp<ICameraClient>& cameraClient,
            int cameraId,
            const String16& clientPackageName,
            int clientUid,
            int clientPid,
            /*out*/
            sp<ICamera>* device) {
        sp<Client> client = nullptr;
        ret = connectHelper<ICameraClient,Client>(cameraClient, id,
                CAMERA_HAL_API_VERSION_UNSPECIFIED, clientPackageName, clientUid, clientPid, API_1,
                /*legacyMode*/ false, /*shimUpdateOnly*/ false,
                /*out*/client);
    	*device = client;
    }

cameraclient的创建会根据hal版本和api版本，来确定具体的实例。

CameraService.cpp
    Status CameraService::makeClient(const sp<CameraService>& cameraService,
            const sp<IInterface>& cameraCb, const String16& packageName, const String8& cameraId,
            int facing, int clientPid, uid_t clientUid, int servicePid, bool legacyMode,
            int halVersion, int deviceVersion, apiLevel effectiveApiLevel,
            /*out*/sp<BasicClient>* client) {
    //默认配置下创建的是 CameraClient
    *client = new  CameraClient(cameraService, tmp, packageName, cameraIdToInt(cameraId),
                            facing, clientPid, clientUid, getpid(), legacyMode);
    //对于hal 3，api1，创建的 Camera2Client
    *client = new Camera2Client(cameraService, tmp, packageName, cameraIdToInt(cameraId),
                            facing, clientPid, clientUid, servicePid, legacyMode);
    //对于hal 3，api2，创建的 CameraDeviceClient
    *client = new CameraDeviceClient(cameraService, tmp, packageName, cameraId,
                            facing, clientPid, clientUid, servicePid);
    }

接着执行cameraclient的初始化，这个过程中会打开camera硬件设备。

设置camerasource的最后一步，camera的配置。

status_t CameraSource::configureCamera(
            CameraParameters* params,        int32_t width, int32_t height,        int32_t frameRate) {
    //这个过程，主要是用要求的视频大小，帧率来配置camera，如果没有请求视频宽高，帧率，将跳过，使用camera setting中的默认值。
    	if (width != -1 && height != -1) {…}
    	if (frameRate != -1) {….}
    }

这段分析都是从prepare()开始，到这里视频source已经准备好了。

５，继续prepare（），看下视频编码器的创建。

StagefrightRecorder.cpp
    status_t StagefrightRecorder::setupVideoEncoder(
            const sp<MediaSource> &cameraSource,
            sp<MediaCodecSource> *source) {
    //根据视频源camerasource，创建视频编码器。
    sp<MediaCodecSource> encoder = MediaCodecSource::Create(
                mLooper, format, cameraSource, mPersistentSurface, flags);
    //保存bufferproducer，用于buffer的申请。
        if (cameraSource == NULL) {
            mGraphicBufferProducer = encoder->getGraphicBufferProducer();
        }
    }

MediaCodecSource::Create()创建一个MediaCodecSource实例，给一些变量赋值，然后初始化init()-->initEncoder()。

MediaCodecSource.cpp
    status_t MediaCodecSource::initEncoder() {
    	Vector<AString> matchingCodecs;
    //根据设置的mime类型(MEDIA_MIMETYPE_VIDEO_MPEG4或者MEDIA_MIMETYPE_VIDEO_AVC)，查找匹配的编码器。
    	MediaCodecList::findMatchingCodecs(
    		outputMIME.c_str(), true /* encoder */,
    	((mFlags & FLAG_PREFER_SOFTWARE_CODEC) ? MediaCodecList::kPreferSoftwareCodecs : 0),
    		&matchingCodecs);
    //创建解码组件，执行其init()，configure()。
    	mEncoder = MediaCodec::CreateByComponentName(mCodecLooper, matchingCodecs[ix]);
    //kWhatEncoderActivity 消息的处理，通过feedEncoderInputBuffers填充编码输入buffer。
    	mEncoderActivityNotify = new AMessage(kWhatEncoderActivity, mReflector);
    	mEncoder→setCallback(mEncoderActivityNotify);
    //注意configure()的最后一个参数 MediaCodec::CONFIGURE_FLAG_ENCODE表示接下来要创建的是编码组件。
    	err = mEncoder->configure(  mOutputFormat,   NULL /* nativeWindow */,
                        NULL /* crypto */,   MediaCodec::CONFIGURE_FLAG_ENCODE);
    //start()，表示编码组件初始化已经成功完成，可以准备编码工作了，也就是将其OMX_CommandStateSet状态置为OMX_StateIdle。
    最终调用的是OMXNodeInstance.cpp中方法sendCommand()。
    	err = mEncoder->start();
    }

//这个方法会列出所有匹配mime格式的编码器，即是其中的参数matches，同时也会考虑优先软解，还是强制硬解。

void MediaCodecList::findMatchingCodecs(
            const char *mime, bool encoder, uint32_t flags,
            Vector<AString> *matches, Vector<AString> *owners) {
    	const sp<IMediaCodecList> list = getInstance();
    	const sp<MediaCodecInfo> info = list→getCodecInfo(matchIndex);
    	AString componentName = info→getCodecName();
    	matches->push(componentName);
    }

MediaCodec.cpp
    status_t MediaCodec::init(const AString &name, bool nameIsType, bool encoder) {
    //这里返回的实际是ACodec实例。
    	mCodec = GetCodecBase(name, nameIsType);
        mCodec->setCallback(
                std::unique_ptr<CodecBase::CodecCallback>(
                        new CodecCallback(new AMessage(kWhatCodecNotify, this))));
        mBufferChannel = mCodec->getBufferChannel();
        mBufferChannel->setCallback(
                std::unique_ptr<CodecBase::BufferCallback>(
                        new BufferCallback(new AMessage(kWhatCodecNotify, this))));
    //在 kWhatInit消息的处理中，分配编解码组件。具体调用是mCodec->initiateAllocateComponent(format);
    	sp<AMessage> msg = new AMessage(kWhatInit, this);
    }

MediaCodec.cpp
    status_t MediaCodec::configure(        const sp<AMessage> &format,        const sp<Surface> &surface,        	
    const sp<ICrypto> &crypto,        const sp<IDescrambler> &descrambler,        uint32_t flags) {
    //配置，启动编码组件，具体调用mCodec->initiateConfigureComponent(format);
    	sp<AMessage> msg = new AMessage(kWhatConfigure, this);
    }

Acodec.cpp
    //这个函数，编解码组件配置都会执行，比较长，
    status_t ACodec::configureCodec(        const char *mime, const sp<AMessage> &msg) {
    	if (video) {
    //确定是否使用软件渲染，是解码需要的。
    		bool usingSwRenderer = false;
    		if (haveNativeWindow && mComponentName.startsWith("OMX.google.")) {
    			usingSwRenderer = true;
    			(void)setPortMode(kPortIndexOutput, IOMX::kPortModePresetByteBuffer);
    		}else if (haveNativeWindow && !storingMetadataInDecodedBuffers()) {
    			err = setPortMode(kPortIndexOutput, IOMX::kPortModePresetANWBuffer);
    		}
    //创建编码或者解码器。
    		if (encoder) {
    			err = setupVideoEncoder(mime, msg, outputFormat, inputFormat);
    		}else {
                		err = setupVideoDecoder(mime, msg, haveNativeWindow, usingSwRenderer, outputFormat);
            	}
    	}
    …...
    }

再回到StagefrightRecorder.cpp中，前面编码组件的构建是从setupVideoEncoder()开始的，

StagefrightRecorder.cpp
    status_t StagefrightRecorder::setupMPEG4orWEBMRecording() {
    	sp<MediaWriter> writer;
            sp<MediaSource> mediaSource;
            err = setupMediaSource(&mediaSource);
            sp<MediaCodecSource> encoder;
            err = setupVideoEncoder(mediaSource, &encoder);
    //前面设置视频source(camerasource)，设置编码器都执行完了，接着是创建视频track，writer是Mpeg4Writer类型实例，
    Mpeg4Writer的作用就是分别把视频track和音频track写入到chunck中，然后打包写入到文件容器。
    	writer->addSource(encoder);
    }

MPEG4Writer.cpp
    status_t MPEG4Writer::addSource(const sp<IMediaSource> &source) {
    	const char *mime;
    	source->getFormat()->findCString(kKeyMIMEType, &mime);
    	bool isAudio = !strncasecmp(mime, "audio/", 6);
    //source是视频encorder，所以创建的视频track，如果是setupAudioEncoder()中调用addSource，传入的source是音频encorder，创建的就是音频track。
    	Track *track = new Track(this, source, 1 + mTracks.size());
    	mTracks.push_back(track);
    }

prepare()执行完，接下来就是start()方法的调用。

StagefrightRecorder.cpp
    status_t StagefrightRecorder::start() {
    	switch (mOutputFormat) {
    		        case OUTPUT_FORMAT_DEFAULT:
            	case OUTPUT_FORMAT_THREE_GPP:
            	case OUTPUT_FORMAT_MPEG_4:
            	case OUTPUT_FORMAT_WEBM:{
    			sp<MetaData> meta = new MetaData;
    			setupMPEG4orWEBMMetaData(&meta);
    //调用mepg4writer的start()方法。
    			status = mWriter->start(meta.get());
    		}
    	}
    }

对文件的读写，前提是先了解这个文件格式。

mpeg4文件格式解析，参考：[https://blog.csdn.net/chenchong\_219/article/details/44263691][https_blog.csdn.net_chenchong_219_article_details_44263691]

MPEG4Writer.cpp
    status_t MPEG4Writer::start(MetaData *param) {
    //先写入文件格式。
    	writeFtypBox(param);
    //为这个视频track创建一个线程，并从ThreadWrapper()函数开始运行，线程实际执行的是MPEG4Writer::threadFunc()函数，执行mp4文件的chunks的写入。
    	 status_t err = startWriterThread();
    //将会调用前面创建的视频track中的start()方法。
    	err = startTracks(param);
    }

重点看下Mpeg4Writer::Track的start()方法，媒体元数据的输入输出都在这里完成。

MPEG4Writer.cpp
    status_t MPEG4Writer::Track::start(MetaData *params) {
    	sp<MetaData> meta = new MetaData;
    //mSource是前面StagefrightRecorder::setupVideoEncoder()的返回值MediaCodecSource实例。
    	status_t err = mSource->start(meta.get());
    	pthread_create(&mThread, &attr, ThreadWrapper, this);
    }

从MediaCodecSource.cpp的start()方法，间接通过，MediaCodecSource::Puller的start()，调用了CameraSource.cpp的start()方法。
    CameraSource.cpp
    status_t CameraSource::start(MetaData *meta) {
    	if ((err = startCameraRecording()) == OK) {
    		mStarted = true;
    	}
    }

CameraSource.cpp
    status_t CameraSource::startCameraRecording() {
    //创建存储的buffers的内存块，作为本地视频元数据。
    	createVideoBufferMemoryHeap(sizeof(VideoNativeHandleMetadata), kDefaultVideoBufferCount);
    //启动camera录制，同时设置监听ProxyListener ，通过其回调dataCallbackTimestamp获取元数据。
    	if ((err = mCameraRecordingProxy->startRecording(new ProxyListener(this))) != OK) {...}
    }

void CameraSource::dataCallbackTimestamp(int64_t timestampUs,
            int32_t msgType __unused, const sp<IMemory> &data) {
    //camera返回的数据放在列表 mFramesReceived，然后通过mFrameAvailableCondition 唤醒一个线程。
    	mFramesReceived.push_back(data);
    	mFrameTimes.push_back(timeUs);
    	mFrameAvailableCondition.signal();
    }

mFrameAvailableCondition.signal();唤醒了那个线程呢？前面在MPEG4Writer::Track::start()创建了线程ThreadWrapper，这个线程运行后，通过mSource->read(&buffer)来读取camerasource中的数据，当列表无数据可读时，这个线程就会在read时进入wait，然后等camera返回的数据填充到列表mFramesReceived时，在唤醒，继续读取。这样camera返回的数据就到了MPEG4Writer::Track中。

ThreadWrapper直接调用了threadEntry。

status_t MPEG4Writer::Track::threadEntry() {
    //循环执行，通过camerasource的read拿到元数据。
    	while (!mDone && (err = mSource->read(&buffer)) == OK) {
    //执行编码。
    		f (mIsMPEG4) {                    copyCodecSpecificData((const uint8_t *)buffer->data() +
    			 buffer->range_offset(),                            buffer->range_length());
    		}
    //中间略去了很多代码，这里是根据timestampUs ，mChunkSamples 生成chunk。 先是调用MPEG4Writer::Track的bufferChunk()方法，
    生成一个chunk后，再调用MPEG4Writer的bufferChunk()方法，同时把生成的chunk作为参数传递到MPEG4Writer中，
    同时在MPEG4Writer::bufferChunk()中通过mChunkReadyCondition.signal()唤醒了另一个处于wait的线程。
    		mChunkSamples.push_back(copy);
    		bufferChunk(timestampUs);
    	}
    }

mChunkReadyCondition.signal()唤醒的是MPEG4Writer中线程ThreadWrapper，也就是MPEG4Writer中的threadFunc()方法。

void MPEG4Writer::threadFunc() {
    	while (!mDone) {
    //循环执行，读取MPEG4Writer::Track的bufferChunk()方法生成的chunk，
    		while (!mDone && !(chunkFound = findChunkToWrite(&chunk))) {
    			mChunkReadyCondition.wait(mLock);
    		}
    //将chunk写入文件容器。
    		writeChunkToFile(&chunk);
    		writeAllChunks();
    	}
    }
    到这里完成了视音频录制的。音频的处理类似。

MediaWriter是把音视频字幕track打包到容器中，播放时的逆过程是通过MediaExtractor来提取分离出容器中的音视频track。

对代码中类的命名说几句题外话，感觉这些大牛之所以是大牛，不仅仅在于专业技术够强，还在于对技术外的生活有很好的体察，所以他们定义的类名、方法名等做到了恰到好处，能让人望文生义，比如：MediaExtractor，其中的Extractor意思是萃取，萃取就是分离混合物中的单元，所以即使在没有具体了解MediaExtractor前，通过名字也能大概知道它的功能，就是萃取多媒体中的资源，多媒体资源都有那些呢，音频、视频、字幕，所以它的功能就是从容器中把这些资源分离出来。

再比如Choreographer，就是画面的渲染需要vsync信号的触发，应用的画面，包括动画的步进主要是通过注册callback到Choreographer中，然后Choreographer在vsync到来时，通知感兴趣的注册者。Choreographer意思是编舞的人，就像舞台上表演者什么时候该做什么动作，收腹提臀挺胸啥的，是由编舞的人事先定好的。类比过来，手机屏幕就是舞台，该显示什么内容也是要有"舞台指导"的，也即是Choreographer，所以看的出来，写这块代码的人一定是个热爱艺术的人。

[https_blog.csdn.net_lin20044140410_article_details_80057981]: https://blog.csdn.net/lin20044140410/article/details/80057981
[https_blog.csdn.net_chenchong_219_article_details_44263691]: https://blog.csdn.net/chenchong_219/article/details/44263691