Android关于H.264的软编和硬编

╰半橙微兮° 2022-05-21 09:26 406阅读 0赞

第六章的最后一篇分析了，之前分析摄像头预览画面的流程[https://blog.csdn.net/a568478312/article/details/80725180][https_blog.csdn.net_a568478312_article_details_80725180]。这里主要就是分析编码方面的核心代码。

#### 软编 ####

创建编码器，并开启编码和下载线程。

我们在得到相机纹理，并且经过一系列的处理之后，绘制到屏幕上。并且将最终处理后的纹理id以及EGLContext传入编码器，这样通过共享EGLContext我们就可以跨线程使用同一个纹理ID了。接下来就是初始化原始数据的队列，开启一个编码线程以及一个读取数据的线程。

void SoftEncoderAdapter::createEncoder(EGLCore* eglCore, int inputTexId) {
        this->loadTextureContext = eglCore->getContext();
        this->texId = inputTexId;
        startTime = -1;
        videoFramePool = YUY2VideoFramePool::GetInstance();
        videoFramePool->initYUY2PacketQueue();
        pthread_create(&x264EncoderThread, NULL, startEncodeThread, this);
        _msg = MSG_WINDOW_SET;
        pthread_create(&imageDownloadThread, NULL, startDownloadThread, this);
    }

接下来在图像处理完成之后会绘制到屏幕上，最后进行编码

void MVRecordingPreviewController::renderFrame() {
        if (NULL != eglCore && !isInSwitchingCamera) {
    //      long startTimeMills = getCurrentTime();
            if (startTime == -1) {
                startTime = getCurrentTime();
            }
            float position = ((float) (getCurrentTime() - startTime)) / 1000.0f;
            this->processVideoFrame(position);
            if (previewSurface != EGL_NO_SURFACE) {
                this->draw();
            }
    //          LOGI("process Frame waste TimeMills 【%d】", (int)(getCurrentTime() - startTimeMills));
            if (isEncoding) {
                encoder->encode();
            }
        }
    }

这里计算帧数，然后通知到的是下载线程进行处理，也就是读取像素并存入队列中。这个处理完之前会一直等待。

void SoftEncoderAdapter::encode(){
        while (_msg == MSG_WINDOW_SET || NULL == eglCore) {
            usleep(100 * 1000);
        }
        if (startTime == -1)
            startTime = getCurrentTime();
        int64_t curTime = getCurrentTime() - startTime;
        // need drop frames
        int expectedFrameCount = (int)(curTime/1000.0f*frameRate+0.5f);
        if (expectedFrameCount < encodedFrameCount) {
            LOGI("expectedFrameCount is %d while encodedFrameCount is %d", expectedFrameCount, encodedFrameCount);
            return;
        }
        encodedFrameCount++;
        pthread_mutex_lock(&previewThreadLock);
        pthread_mutex_lock(&mLock);
        pthread_cond_signal(&mCondition);
        pthread_mutex_unlock(&mLock);
        pthread_cond_wait(&previewThreadCondition, &previewThreadLock);
        pthread_mutex_unlock(&previewThreadLock);
    }

接下来看下载线程的处理，同样是一个OpenGL 的绘制流程处理。

void SoftEncoderAdapter::renderLoop() {
        bool renderingEnabled = true;
        while (renderingEnabled) {
            pthread_mutex_lock(&mLock);
            switch (_msg) {
            case MSG_WINDOW_SET:
                LOGI("receive msg MSG_WINDOW_SET");
                initialize();
                break;
            case MSG_RENDER_LOOP_EXIT:
                LOGI("receive msg MSG_RENDER_LOOP_EXIT");
                renderingEnabled = false;
                destroy();
                break;
            default:
                break;
            }
            _msg = MSG_NONE;
            if (NULL != eglCore) {
                eglCore->makeCurrent(copyTexSurface);
                this->loadTexture();
                pthread_cond_wait(&mCondition, &mLock);
            }
            pthread_mutex_unlock(&mLock);
        }
        return;
    }

初始化这里的OpenGL环境流程，这里是创建的离屏buffer，毕竟我们也不需要画到屏幕上了。

bool SoftEncoderAdapter::initialize() {
        pixelSize = videoWidth * videoHeight * PIXEL_BYTE_SIZE;
        hostGPUCopier = new HostGPUCopier();
        eglCore = new EGLCore();
        eglCore->init(loadTextureContext);
        copyTexSurface = eglCore->createOffscreenSurface(videoWidth, videoHeight);
        eglCore->makeCurrent(copyTexSurface);
        renderer = new VideoGLSurfaceRender();
        renderer->init(videoWidth, videoHeight);
        glGenFramebuffers(1, &mFBO);
        //初始化outputTexId
        glGenTextures(1, &outputTexId);
        glBindTexture(GL_TEXTURE_2D, outputTexId);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
        glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, videoWidth, videoHeight, 0, GL_RGBA, GL_UNSIGNED_BYTE, 0);
        glBindTexture(GL_TEXTURE_2D, 0);
        return true;
    }

接下来我们看下载线程的绘制读取逻辑,为了减少glReadPixel的时间，在GPU里将数据转为YUV422，然后再进行读取，这样读取时间会减少一半。

void SoftEncoderAdapter::loadTexture() {
        if(-1 == startTime){
            return;
        }
        //1:拷贝纹理到我们的临时纹理
        int recordingDuration = getCurrentTime() - startTime;
        glViewport(0, 0, videoWidth, videoHeight);
        glBindFramebuffer(GL_FRAMEBUFFER, mFBO);
        checkGlError("glBindFramebuffer FBO");
        long startTimeMills = getCurrentTime();
        renderer->renderToTexture(texId, outputTexId);
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    //  LOGI("copy TexId waste timeMils 【%d】", (int)(getCurrentTime() - startTimeMills));
        this->signalPreviewThread();
        //2:从显存Download到内存
        startTimeMills = getCurrentTime();
        byte* packetBuffer = new byte[pixelSize];
        hostGPUCopier->copyYUY2Image(outputTexId, packetBuffer, videoWidth, videoHeight);
    //  LOGI("Download Texture waste timeMils 【%d】", (int)(getCurrentTime() - startTimeMills));
        //3:构造LiveVideoPacket放到videoFramePool里面
        LiveVideoFrame* videoFrame = new LiveVideoFrame();
        videoFrame->buffer = packetBuffer;
        videoFrame->size = pixelSize;
        videoFrame->timeMills = recordingDuration;
    //  LOGI("recordingDuration 【%d】", recordingDuration);
        videoFramePool->pushYUY2PacketToQueue(videoFrame);
    }

转换成YUV422的逻辑shader。主要就是使用向量的点乘，每次取两个像素来合成一个像素，配合RGB转YUV的公式进行填充。关于公式[https://www.cnblogs.com/huxiaopeng/p/5653257.html][https_www.cnblogs.com_huxiaopeng_p_5653257.html]这篇文章是讲的比较清楚的，我们最终需要获取的是YCbCr，其实就是YUV的压缩和偏移版本。这里是取的第一个像素的YUV和第二个像素的Y来进行合成的。

static char * convertToYUY2FragmentShaderStr =
        "varying highp vec2 texCoord;\n"
        "uniform sampler2D sampler;\n"
        "uniform mediump vec4 coefY;\n"
        "uniform mediump vec4 coefU;\n"
        "uniform mediump vec4 coefV;\n"
        "uniform highp float sPerHalfTexel;\n"
        "void main()\n"
        "{\n"
        "    highp vec2 texelOffset = vec2(sPerHalfTexel, 0);\n"
        "    lowp vec4 leftRGBA = texture2D(sampler, texCoord - texelOffset);\n"
        "    lowp vec4 rightRGBA = texture2D(sampler, texCoord + texelOffset);\n"
        "    lowp vec4 left = vec4(leftRGBA.rgb, 1);\n"
        "    lowp float y0 = dot(left, coefY);\n"
        "    lowp float y1 = dot(vec4(rightRGBA.rgb, 1), coefY);\n"
        "    lowp float u0 = dot(left, coefU);\n"
        "    lowp float v0 = dot(left, coefV);\n"
        "    gl_FragColor = vec4(y0, u0, y1, v0);\n"
        "}\n";

接下来就是绘制到FBO的纹理中了，这里的逻辑我就不提出来说了，仅仅只是通常的纹理绘制，也就是一个矩形而已。接下来就是读取数据了，读取的宽度减少了一半。

void HostGPUCopier::downloadImageFromTexture(GLuint texId, void *imageBuf, unsigned int imageWidth, unsigned int imageHeight) {
        // Set texture's min/mag filter to ensure frame buffer completeness
        glBindTexture(GL_TEXTURE_2D, texId);
        checkGlError("glBindTexture texId");
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
    
        glBindFramebuffer(GL_FRAMEBUFFER, FBO);
        checkGlError("glBindFramebuffer");
        // Attach texture to frame buffer
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texId, 0);
        checkGlError("glFramebufferTexture2D...");
    
        // Download image
        glReadPixels(0, 0, (GLsizei) imageWidth, (GLsizei) imageHeight, GL_RGBA, GL_UNSIGNED_BYTE, (GLvoid *) imageBuf);
        checkGlError("glReadPixels() failed!");
    
        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, 0, 0);
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
    }

上面的都完成之后将时间戳什么的都封装一下，放入队列中。也就是这点代码。

void SoftEncoderAdapter::loadTexture() {
            .....
        //3:构造LiveVideoPacket放到videoFramePool里面
        LiveVideoFrame* videoFrame = new LiveVideoFrame();
        videoFrame->buffer = packetBuffer;
        videoFrame->size = pixelSize;
        videoFrame->timeMills = recordingDuration;
    //  LOGI("recordingDuration 【%d】", recordingDuration);
        videoFramePool->pushYUY2PacketToQueue(videoFrame);
    }

生产者已经分析完了，我们再看消费者，编码线程的逻辑。整体逻辑，初始化编码器，然后从队列取出yuv数据进行编码，写入文件。

void SoftEncoderAdapter::startEncode() {
        encoder = new VideoX264Encoder();
        encoder->init(videoWidth, videoHeight, videoBitRate, frameRate, h264File);
        LiveVideoFrame *videoFrame = NULL;
        while(true){
            if (videoFramePool->getYUY2Packet(&videoFrame, true) < 0) {
                LOGI("videoFramePool->getRecordingVideoPacket return negetive value...");
                break;
            }
            if(videoFrame){
                //调用编码器编码这一帧数据
                encoder->encode(videoFrame);
                delete videoFrame;
                videoFrame = NULL;
            }
        }
        if(NULL != encoder){
            encoder->destroy();
            delete encoder;
            encoder = NULL;
        }
    }

初始化编码器，首先找到H264的编码器，然后创建解码器的上下文，这里我们需要配置的参数

*  pix\_fmt 数据格式
 *  width 宽度
 *  height 高度
 *  time\_base 时间基 (1/fps)
 *  gop\_size 图像组的帧数，也就是两个I帧的间隔，会影响图像质量
 *  max\_b\_frames 两个非B帧之间的最大B帧数，0将不使用B帧
 *  设置了为可变率控制 参考这里[https://blog.csdn.net/austinblog/article/details/28426587][https_blog.csdn.net_austinblog_article_details_28426587]  
    pCodecCtx->flags |= CODEC\_FLAG\_QSCALE;  
    pCodecCtx->bit\_rate = videoBitRate;  
    pCodecCtx->rc\_min\_rate = videoBitRate - delta \* 1000;  
    pCodecCtx->rc\_max\_rate = videoBitRate + delta \* 1000;
 *  i\_quant\_factor p和i的量化系数比例因子，越接近1，P帧越清楚
 *  rc\_buffer\_size bit流的大小
 *  设置ffmpeg编码延迟，这几行代码，设置的参数可以在这里查到[https://trac.ffmpeg.org/wiki/Encode/H.264][https_trac.ffmpeg.org_wiki_Encode_H.264]  
    // 新增语句，设置为编码延迟  
    av\_opt\_set(pCodecCtx->priv\_data, “preset”, “ultrafast”, 0);  
    // 实时编码关键看这句，上面那条无所谓  
    av\_opt\_set(pCodecCtx->priv\_data, “tune”, “zerolatency”, 0);  
    av\_opt\_set(pCodecCtx->priv\_data, “profile”, “main”, 0);

int VideoX264Encoder::allocVideoStream(int width, int height, int videoBitRate, float frameRate) {
        pCodec = avcodec_find_encoder(AV_CODEC_ID_H264);
        if (!pCodec) {
            LOGI("Can not find encoder! \n");
            return -1;
        }
        pCodecCtx = avcodec_alloc_context3(pCodec);
        /* resolution must be a multiple of two */
        pCodecCtx->pix_fmt = AV_PIX_FMT_YUV420P;
        pCodecCtx->width = width;
        pCodecCtx->height = height;
        /* frames per second */
        pCodecCtx->time_base.num = 1;
        pCodecCtx->time_base.den = frameRate;
        /* emit one intra frame every ten frames */
        pCodecCtx->gop_size = (int) frameRate;
        pCodecCtx->max_b_frames = 0;
    
        LOGI("************* gop size is %.2f videoBitRate is %d *************", frameRate, videoBitRate);
        pCodecCtx->flags |= CODEC_FLAG_QSCALE;
        pCodecCtx->i_quant_factor = 0.8;
        pCodecCtx->qmin = 10;
        pCodecCtx->qmax = 30;
        pCodecCtx->bit_rate = videoBitRate;
        pCodecCtx->rc_min_rate = videoBitRate - delta * 1000;
        pCodecCtx->rc_max_rate = videoBitRate + delta * 1000;
        pCodecCtx->rc_buffer_size = videoBitRate * 2;
        //H.264
        // 新增语句，设置为编码延迟
        av_opt_set(pCodecCtx->priv_data, "preset", "ultrafast", 0);
        // 实时编码关键看这句，上面那条无所谓
        av_opt_set(pCodecCtx->priv_data, "tune", "zerolatency", 0);
        av_opt_set(pCodecCtx->priv_data, "profile", "main", 0);
        if (avcodec_open2(pCodecCtx, pCodec, NULL) < 0) {
            LOGI("Failed to open encoder! \n");
            return -1;
        }
    
        return 0;
    }

分配两个AVFrame

void VideoX264Encoder::allocAVFrame() {
        // target yuv420p buffer
        pFrame = av_frame_alloc();
        int pictureInYUV420PSize = avpicture_get_size(pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
        picture_buf = (uint8_t *) av_malloc(pictureInYUV420PSize);
        avpicture_fill((AVPicture *) pFrame, picture_buf, pCodecCtx->pix_fmt, pCodecCtx->width, pCodecCtx->height);
        // origin yuy2 buffer
        video_yuy2_frame = av_frame_alloc();
        int pictureInYUY2Size = avpicture_get_size(ORIGIN_COLOR_FORMAT, pCodecCtx->width, pCodecCtx->height);
        yuy2_picture_buf = (uint8_t *) av_malloc(pictureInYUY2Size);
        avpicture_fill((AVPicture *) video_yuy2_frame, yuy2_picture_buf, ORIGIN_COLOR_FORMAT, pCodecCtx->width, pCodecCtx->height);
    }

上面的准备完毕之后就可以拿出yuy2数据来进行编码了，看编码逻辑，首先是先将数据转为yuv420，然后送入编码。yuy2\_to\_yuv420p的neon优化可以看[ARM NEON指令集总结][ARM NEON] ，我把这个分析写进去了。  
接下来就是设置pFrame的pts，然后再编码，最后写文件即可。

int VideoX264Encoder::encode(LiveVideoFrame * videoFrame) {
        memcpy(yuy2_picture_buf, videoFrame->buffer, videoFrame->size);
        yuy2_to_yuv420p(reinterpret_cast<const uint8_t *const *>(video_yuy2_frame->data), video_yuy2_frame->linesize, pCodecCtx->width, pCodecCtx->height, pFrame->data, pFrame->linesize);
        int presentationTimeMills = videoFrame->timeMills;
        AVRational time_base = {
       1, 1000};
        int64_t pts = presentationTimeMills / 1000.0f / av_q2d(time_base);
        pFrame->pts = pts;
        AVPacket pkt = { 0 };
        int got_packet;
        av_init_packet(&pkt);
        int ret = avcodec_encode_video2(pCodecCtx, &pkt, pFrame, &got_packet);
        if (ret < 0) {
            LOGI("Error encoding video frame: %s\n", av_err2str(ret));
            ret = -1;
        } else if (got_packet && pkt.size) {
            fwrite(pkt.data, 1, pkt.size, h264File);
        } else {
            LOGI("No Output Frame...");
        }
        av_free_packet(&pkt);
        return ret;
    }

#### 硬编 ####

硬编我们通过结合MediaCodec的java层来使用。

首先创建编码器，调用了java层的两个方法，并且获取一个surface

void HWEncoderAdapter::createHWEncoder(JNIEnv *env) {
        jclass jcls = env->GetObjectClass(obj);
        jmethodID createMediaCodecSurfaceEncoderFunc = env->GetMethodID(jcls,
                "createMediaCodecSurfaceEncoderFromNative", "(IIII)V");
        env->CallVoidMethod(obj, createMediaCodecSurfaceEncoderFunc, videoWidth, videoHeight,
                videoBitRate, (int) frameRate);
        jmethodID getEncodeSurfaceFromNativeFunc = env->GetMethodID(jcls,
                "getEncodeSurfaceFromNative", "()Landroid/view/Surface;");
        jobject surface = env->CallObjectMethod(obj,
                getEncodeSurfaceFromNativeFunc);
        // 2 create window surface
        ANativeWindow* encoderWindow = ANativeWindow_fromSurface(env, surface);
        encoderSurface = eglCore->createWindowSurface(encoderWindow);
        renderer = new VideoGLSurfaceRender();
        renderer->init(videoWidth, videoHeight);
    }

看java层的代码吧，就是下面两个方法。

public MediaCodecSurfaceEncoder(int width, int height, int bitRate, int frameRate) throws Exception {
            MediaFormat format = MediaFormat.createVideoFormat(MIME_TYPE, width, height);
            format.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
            format.setInteger(MediaFormat.KEY_BIT_RATE, bitRate);
            format.setInteger(MediaFormat.KEY_FRAME_RATE, frameRate);
            format.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, IFRAME_INTERVAL);
            if (VERBOSE)
                Log.d(TAG, "format: " + format);
            try {
                mEncoder = MediaCodec.createEncoderByType(MIME_TYPE);
                mEncoder.configure(format, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
                mInputSurface = mEncoder.createInputSurface();
                mEncoder.start();
            } catch (Exception e) {
                throw e;
            }
        }

/**
         * Returns the encoder's input surface.
         */
        public Surface getInputSurface() {
            return mInputSurface;
        }

我们拿到surface之后，接下来就是利用egl来创建一个windowSurface，并且将有数据的纹理绘制到这个surface上，和普通绘制纹理流程一样。接着设置pts。

void HWEncoderAdapter::encode() {
        if (startTime == -1)
            startTime = getCurrentTime();
        int64_t curTime = getCurrentTime() - startTime;
        int expectedFrameCount = (int)(curTime / 1000.0f * frameRate + 0.5f);
        if (expectedFrameCount < encodedFrameCount) {
            // need drop frames
            return;
        }
        encodedFrameCount++;
        if(EGL_NO_SURFACE != encoderSurface){
            eglCore->makeCurrent(encoderSurface);
            renderer->renderToView(texId, videoWidth, videoHeight);
            eglCore->setPresentationTime(encoderSurface, ((khronos_stime_nanoseconds_t) curTime) * 1000000);
            handler->postMessage(new Message(FRAME_AVAILIBLE));
            if (!eglCore->swapBuffers(encoderSurface)) {
                LOGE("eglSwapBuffers(encoderSurface) returned error %d", eglGetError());
            }
        }
    }

下一步就是讲Native层创建的byte数组送入Java层进行编码。

void HWEncoderAdapter::drainEncodedData() {
        JNIEnv *env;
        int status = 0;
        bool needAttach = false;
        status = g_jvm->GetEnv((void **) (&env), JNI_VERSION_1_4);
        if (status < 0) {
            if (g_jvm->AttachCurrentThread(&env, NULL) != JNI_OK) {
                LOGE("%s: AttachCurrentThread() failed", __FUNCTION__);
                return;
            }
            needAttach = true;
        }
        jclass jcls = env->GetObjectClass(obj);
        jmethodID drainEncoderFunc = env->GetMethodID(jcls, "pullH264StreamFromDrainEncoderFromNative", "([B)J");
        long bufferSize = (long)env->CallLongMethod(obj, drainEncoderFunc, outputBuffer);
        byte* outputData = (uint8_t*)env->GetByteArrayElements(outputBuffer, 0);    // get data
        int size = (int)bufferSize;
    //  .....
    }

MediaCodec编码H.264流程如下，我们就无需手动在inputBuffer中输入了，直接输出来活得编码之后的数据。

public long pullH264StreamFromDrainEncoderFromNative(byte[] returnedData) {
            long val = 0;
    
            try {
    
                mBufferInfo = new MediaCodec.BufferInfo();
                ByteBuffer[] encoderOutputBuffers = mEncoder.getOutputBuffers();
                int encoderStatus = mEncoder.dequeueOutputBuffer(mBufferInfo, TIMEOUT_USEC);
                if (encoderStatus == MediaCodec.INFO_TRY_AGAIN_LATER) {
                    // no output available yet
                    Log.i(TAG, "no output available yet");
                } else if (encoderStatus == MediaCodec.INFO_OUTPUT_BUFFERS_CHANGED) {
                    Log.i(TAG, " not expected for an encoder");
                    encoderOutputBuffers = mEncoder.getOutputBuffers();
                } else if (encoderStatus == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
                    MediaFormat mEncodedFormat = mEncoder.getOutputFormat();
                    Log.d(TAG, "encoder output format changed: " + mEncodedFormat);
                } else if (encoderStatus < 0) {
                    // let's ignore it
                    Log.w(TAG, "unexpected result from encoder.dequeueOutputBuffer: " + encoderStatus);
                } else {
                    ByteBuffer encodedData = encoderOutputBuffers[encoderStatus];
                    if (encodedData == null) {
                        throw new RuntimeException("encoderOutputBuffer " + encoderStatus + " was null");
                    }
                    //代表这个是一个媒体配置的数据，而不是媒体数据
                    if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                        // The codec config data was pulled out when we got the
                        // INFO_OUTPUT_FORMAT_CHANGED status. The MediaMuxer won't
                        // accept
                        // a single big blob -- it wants separate csd-0/csd-1 chunks
                        // --
                        // so simply saving this off won't work.
                        if (VERBOSE)
                            Log.d(TAG, "ignoring BUFFER_FLAG_CODEC_CONFIG, mBufferInfo.size = " + mBufferInfo.size);
    
                        if (mBufferInfo.size != 0) {
                            encodedData.position(mBufferInfo.offset);
                            encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
    
                            val = mBufferInfo.size;
    
                            encodedData.get(returnedData, 0, mBufferInfo.size);
                        } else {
                            Log.i(TAG, "why mBufferInfo.size is equals 0");
                        }
    
                        mBufferInfo.size = 0;
                    }
                    if (mBufferInfo.presentationTimeUs >= lastPresentationTimeUs) {
                        if (mBufferInfo.size != 0) {
                            encodedData.position(mBufferInfo.offset);
                            encodedData.limit(mBufferInfo.offset + mBufferInfo.size);
                            lastPresentationTimeUs = mBufferInfo.presentationTimeUs;
                            val = mBufferInfo.size;
    
                            encodedData.get(returnedData, 0, mBufferInfo.size);
    
                            if (VERBOSE) {
                                Log.d(TAG, "sent " + mBufferInfo.size + " bytes to muxer, ts="
                                        + mBufferInfo.presentationTimeUs);
                            }
                        } else {
                            Log.i(TAG, "why mBufferInfo.size is equals 0");
                        }
                    } else {
                        Log.d(TAG, "mBufferInfo.presentationTimeUs < lastPresentationTimeUs");
                    }
    
                    mEncoder.releaseOutputBuffer(encoderStatus, false);
    
                    if ((mBufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                        Log.w(TAG, "reached end of stream unexpectedly");
                    }
                }
            } catch (Exception e) {
                e.printStackTrace();
            }
    
            return val;
        }

从MediaCodec拿到数据之后，还需要注意的是，MediaCodec编码的关键帧么有pps,sps，所以我们需要在关键帧的时候加上去。关于H.264的结构推荐看这篇文章[从零了解H264结构][H264]。

void HWEncoderAdapter::drainEncodedData() {
        //....
    
        // push to queue
        int nalu_type = (outputData[4] & 0x1F);
        if (H264_NALU_TYPE_SEQUENCE_PARAMETER_SET == nalu_type) {
            spsppsBufferSize = size;
            spsppsBuffer = new byte[spsppsBufferSize];
            memcpy(spsppsBuffer, outputData, spsppsBufferSize);
        } else if(NULL != spsppsBuffer){
            if(H264_NALU_TYPE_IDR_PICTURE == nalu_type) {
                fwrite(spsppsBuffer, 1, spsppsBufferSize, h264File);
            }
            fwrite(outputData, 1, size, h264File);
        }
        //...
    }

硬编也分析到这里了，第六章总算是结束了。

[参考源码][Link 1]

[https_blog.csdn.net_a568478312_article_details_80725180]: https://blog.csdn.net/a568478312/article/details/80725180
[https_www.cnblogs.com_huxiaopeng_p_5653257.html]: https://www.cnblogs.com/huxiaopeng/p/5653257.html
[https_blog.csdn.net_austinblog_article_details_28426587]: https://blog.csdn.net/austinblog/article/details/28426587
[https_trac.ffmpeg.org_wiki_Encode_H.264]: https://trac.ffmpeg.org/wiki/Encode/H.264
[ARM NEON]: https://blog.csdn.net/a568478312/article/details/80937797
[H264]: http://www.iosxxx.com/blog/2017-08-09-%E4%BB%8E%E9%9B%B6%E4%BA%86%E8%A7%A3H264%E7%BB%93%E6%9E%84.html
[Link 1]: https://github.com/zhanxiaokai/Android-CameraPreviewRecorder