对最近Android项目中的视频编解码的总结

最近的项目是一个智能摄像头的项目，对于我们Android客户端来讲，肯定核心的是就是音视频编解码了。对于硬件端，也就是摄像头端，在我接手项目的时候，他们都已经订好了技术方案。往客户端（iOS,Android，PC）三端传输的数据是音视频分开的。音频通过G711u，视频通过H264。我们客户端这边需要做的就是解码H264拿到未压缩的视频帧，和转码G711u到PCM可以播放 ***

视频解码，一开始由于项目紧张，人员也比较缺，这边没有懂视频的解码。所以当时就随便在网络上搜罗了一个H264的解码器（只有SO库），没想到的是竟然可以用。所以本着互联网思维（这里省略100个呵呵），我们就临时用了这个解码器，虽然效果不理想但是还算可以用。后来到了项目中期，我们开始自己学习写解码器。这里推荐三个搭建Android Stuido 搭建NDK开发环境的文章。

1. 超级简单的Android Studio jni 实现(无需命令行)
2. Android Studio使用gradle-experimental构建NDK工程(无需Android.mk、Application.mk文件)
3. Android Studio NDk调试(基于gradle-experimental插件与LLDB)

下面是我的Gradle的配置,供大家参考

apply plugin: 'com.android.model.application'

model {
    android {
        compileSdkVersion 23
        buildToolsVersion "23.0.3"

        defaultConfig.with {
            applicationId "liufei.person.ffmpegproject"
            minSdkVersion.apiLevel = 15
            targetSdkVersion.apiLevel = 23
        }
    }
    android.ndk {
        moduleName = "MyLibrary"
        ldLibs.addAll(['android', 'log'])
    }

    repositories {
        MyLibrary(PrebuiltLibraries) {

            ffmpeg {
                binaries.withType(SharedLibraryBinary) {
                    sharedLibraryFile = file("src/main/jni/libffmpeg.so");
                }
            }
        }
    }
    android.productFlavors {
        create("arm") {
            ndk.abiFilters.add("armeabi")
        }
        create("arm7") {
            ndk.abiFilters.add("armeabi-v7a")
        }
        // To include all cpu architectures, leaves abiFilters emptycreate("all")
    }
    android.sources {
        main {
            jni {
                exportedHeaders  {
                    srcDir "src/main/jni/include"
                }
                dependencies{
                    library "ffmpeg"

                }
            }
        }
    }
    android.buildTypes {
        release {
            minifyEnabled = false
            proguardFiles.add(file('proguard-rules.txt'))
        }
    }

}

dependencies {
    compile fileTree(include: ['*.jar'], dir: 'libs')
    testCompile 'junit:junit:4.12'
    compile 'com.android.support:appcompat-v7:23.2.1'
    compile 'com.android.support:cardview-v7:23.+'
    compile 'com.android.support:design:23.2.1'
}

在搭建好环境后，就是视频编解码的相关知识，这里推荐雷霄骅(leixiaohua1020)的专栏,里面对于音视频编码的讲解真的是面面俱到，并且例子很丰富。对我这样的音视频编解码的新手真的很有帮助。通过阅读和总结雷神的例子，结合我的实际需求，下面是我自己实现的H264视频的解码程序

unsigned int *rgb_2_pix = NULL;
unsigned int *r_2_pix = NULL;
unsigned int *g_2_pix = NULL;
unsigned int *b_2_pix = NULL;


typedef struct DecoderContext {
    int color_format;
    struct AVCodec *codec;
    struct AVCodecContext *codec_ctx;
    struct AVFrame *src_frame;
    struct AVFrame *dst_frame;
    struct SwsContext *convert_ctx;
    int frame_ready;
    long timeBase;
    int frameIndex;
} DecoderContext;

static void set_ctx(JNIEnv *env, jobject thiz, void *ctx) {
    jclass cls = (*env)->GetObjectClass(env, thiz);
    //最后一个参数的含义表示这个属性的类型为 int
    jfieldID fid = (*env)->GetFieldID(env, cls, "cdata", "I");
    //为fid 设值为ctx...相当于给个映射 和java层，然后在get
    (*env)->SetIntField(env, thiz, fid, (jint) ctx);
}
static long getCurrentTimeStamp(){
    //得到的单位是 nanosecond 级别的，所以要除以1000
    clock_t t = clock();
    return t / 1000;
}
static void *get_ctx(JNIEnv *env, jobject thiz) {
    jclass cls = (*env)->GetObjectClass(env, thiz);
    jfieldID fid = (*env)->GetFieldID(env, cls, "cdata", "I");
    return (void *) (*env)->GetIntField(env, thiz, fid);
}

static void av_log_callback(void *ptr, int level, const char *fmt, __va_list vl) {
    static char line[1024] = {0};
    vsnprintf(line, sizeof(line), fmt, vl);
    D(line);
}

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved) {
    av_register_all();
    av_log_set_callback(av_log_callback);
    return JNI_VERSION_1_4;
}

JNIEXPORT void JNI_OnUnload(JavaVM *vm, void *reserved) {

}
/*
 * thiz 是调用这个Jni接口函数的java object
 */
JNIEXPORT void JNICALL Java_person_walker_natives_H264Decoder_nativeInit(JNIEnv *env, jobject thiz,
                                                                       jint color_format) {
    D("get into init method");
    DecoderContext *ctx = calloc(1, sizeof(DecoderContext));

    D("Creating native H264 decoder context");

    switch (color_format) {
        case COLOR_FORMAT_YUV420:
            ctx->color_format = PIX_FMT_YUV420P;
            break;
        case COLOR_FORMAT_RGB565LE:
            ctx->color_format = PIX_FMT_RGB565LE;
            break;
        case COLOR_FORMAT_BGR32:
            ctx->color_format = PIX_FMT_BGR32;
            break;
    }
    ctx->codec = avcodec_find_decoder(CODEC_ID_H264);
    ctx->codec_ctx = avcodec_alloc_context3(ctx->codec);
    //ctx->codec_ctx->pix_fmt = PIX_FMT_YUV420P;
    //ctx->codec_ctx->flags2 |= CODEC_FLAG2_CHUNKS;

    ctx->src_frame = av_frame_alloc();
    ctx->dst_frame = av_frame_alloc();
    ctx->timeBase = getCurrentTimeStamp();
    ctx->frameIndex = 0;
    avcodec_open2(ctx->codec_ctx, ctx->codec, NULL);
    //为这个对象的cdata设置数据
    set_ctx(env, thiz, ctx);
}

JNIEXPORT void JNICALL Java_person_walker_natives_H264Decoder_nativeDestroy(JNIEnv *env,
                                                                          jobject thiz) {
    DecoderContext *ctx = get_ctx(env, thiz);

    D("Destroying native H264 decoder context");

    avcodec_close(ctx->codec_ctx);
    avcodec_free_context(&(ctx->codec_ctx));
    av_free(ctx->src_frame);
    av_free(ctx->dst_frame);
    free(ctx);
}

JNIEXPORT jint JNICALL Java_person_walker_natives_H264Decoder_consumeNalUnitsFromDirectBuffer(
        JNIEnv *env, jobject thiz,
        jbyteArray nal_units, jint num_bytes, jlong pkt_pts) {
    DecoderContext *ctx = get_ctx(env, thiz);
    void *buf = NULL;
    if (nal_units == NULL) {
        D("Received null buffer, sending empty packet to decoder");
    }
    else {
        buf  = (*env) -> GetByteArrayElements(env,nal_units,0);
        if (buf == NULL) {
            /*  buf = (*env)->GetByteArrayElements(env, nal_units);
              if (buf == NULL) {*/
            D("Error getting direct buffer address");
            (*env)->ReleaseByteArrayElements(env, nal_units, buf, 0);
            return -1;
        }
    }
    long pts = getCurrentTimeStamp() - ctx->timeBase;
    //将buf,这里指的是传入进来的H264数据组合成packet 结构体对象
    AVPacket packet = {
            .data = (uint8_t *) buf,
            .size = num_bytes,
    };

    int frameFinished = 0;
    //将packet里面的数据decode解码到 ctx->指向的src_frame中去，AvCodecContext已经初始化 在init时候
    //作用是解码一帧数据
    int res = avcodec_decode_video2(ctx->codec_ctx, ctx->src_frame, &frameFinished, &packet);
    //int res2 = avcodec_decode_video2(ctx->codec_ctx, ctx->src_frame, &frameFinished, &packet);
    if (frameFinished)
        ctx->frame_ready = 1;
    D("goted frame is : %d", frameFinished);
    (*env)->ReleaseByteArrayElements(env, nal_units, buf, 0);

    return res;
}

JNIEXPORT jboolean JNICALL Java_person_walker_natives_H264Decoder_isFrameReady(JNIEnv *env,
                                                                             jobject thiz) {
    DecoderContext *ctx = get_ctx(env, thiz);
    return ctx->frame_ready ? JNI_TRUE : JNI_FALSE;
}

JNIEXPORT jint JNICALL Java_person_walker_natives_H264Decoder_getWidth(JNIEnv *env, jobject thiz) {
    DecoderContext *ctx = get_ctx(env, thiz);
    return ctx->codec_ctx->width;
}

JNIEXPORT jint JNICALL Java_person_walker_natives_H264Decoder_getHeight(JNIEnv *env, jobject thiz) {
    DecoderContext *ctx = get_ctx(env, thiz);
    return ctx->codec_ctx->height;
}

JNIEXPORT jint JNICALL Java_person_walker_natives_H264Decoder_getOutputByteSize(JNIEnv *env,
                                                                              jobject thiz) {
    DecoderContext *ctx = get_ctx(env, thiz);
    return avpicture_get_size(ctx->color_format, ctx->codec_ctx->width, ctx->codec_ctx->height);
}

JNIEXPORT jint JNICALL JNICALL Java_person_walker_natives_H264Decoder_decodeFrameToDirectBuffer
        (JNIEnv *env, jobject thiz, jbyteArray out_buffer, jint out_len) {
    DecoderContext *ctx = get_ctx(env, thiz);

/*  if (!ctx->frame_ready)
  return -1;*/

    void *out_buf = (*env)->GetByteArrayElements(env, out_buffer, 0);
    if (out_buf == NULL) {
        D("Error getting direct buffer address");
        return -2;
    }

    // long out_buf_len = i

    int pic_buf_size = avpicture_get_size(ctx->color_format, ctx->codec_ctx->width,
                                          ctx->codec_ctx->height);

    if (out_len 

音频解码

其实我们工程里面并有涉及到音频解码的内容，更多是音频的转码和编码压缩。这里重点说一下音频的压缩编码。因为我们的项目里面确实是用到了G711u转码到PCM的内容，但是我们是利用的网络上开源的代码，这里就不详细说了。对于PCM编码.我们后来是放弃了FFMpeg利用的ANdroid 新推出的mediacodec API.下面上代码

Mediacodec 初始化

    private void initMediaCodec() {
        //查找机器所支持的编码器
        try {
            mAebi = new MediaCodec.BufferInfo();
            presentationTimeUs = System.currentTimeMillis();
            mediaCodec = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC);
            MediaFormat aformat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, 8000, 1);
            aformat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
            aformat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 0);
            aformat.setInteger(MediaFormat.KEY_BIT_RATE, 24000);
            mediaCodec.configure(aformat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
            mediaCodec.start();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }`re>

编码过程

        try {
            ByteBuffer[] inBuffers = mediaCodec.getInputBuffers();
            ByteBuffer[] outBuffers = mediaCodec.getOutputBuffers();

            if (true) {
                int inBufferIndex = 0;
                inBufferIndex = mediaCodec.dequeueInputBuffer(-1);
                //Log.i(TAG, String.format("try to dequeue input vbuffer, ii=%d", inBufferIndex));
                if (inBufferIndex >= 0) {
           //这个inBuffers是我们保存原始PCM的buffer数组
                    ByteBuffer bb = inBuffers[inBufferIndex];
                    bb.clear();
                    bb.put(bytes, 0, size);
                    long pts = System.currentTimeMillis() - presentationTimeUs;
                    mediaCodec.queueInputBuffer(inBufferIndex, 0, size, pts, 0);
                }
            }

            while (true) {
                int outBufferIndex = mediaCodec.dequeueOutputBuffer(mAebi, 0);
                if (outBufferIndex >= 0) {
                    ByteBuffer bb = outBuffers[outBufferIndex];

                    int outPacketSize = mAebi.size + 7;//头部大小加buffer大小
                    bb.position(mAebi.offset);
                    bb.limit(mAebi.offset + mAebi.size);
                    byte[] outBytes = new byte[outPacketSize];
        //对于PCM编码，一定不要忘记为AAC数据加上ADT头
                    addADTStoPacket(outBytes, outPacketSize);
                    bb.get(outBytes, 7, mAebi.size);
                    bb.position(mAebi.offset);
                    mPcmDatas.offer(outBytes, 100, TimeUnit.MILLISECONDS);
                    mediaCodec.releaseOutputBuffer(outBufferIndex, false);
                } else {
                    break;
                }
            }
        } catch (InterruptedException e) {
            e.printStackTrace();
        } catch (IllegalStateException e){
            e.printStackTrace();
        }

// (Must match defines in person.walker.androidh264decoder.H264Decoder.java)

//short *tmp_pic=NULL;

为编码好的AAC数据添加AAC头

/**
     * AAC每个数据块钱都要添加ADTS头，不然播放不了
     *
     * @param packet
     * @param packetLen
     */
    private void addADTStoPacket(byte[] packet, int packetLen) {
        int profile = 2; // AAC LC
        int freqIdx = 11; // 8KHz
        int chanCfg = 1; // 单声道

        // fill in ADTS data
        packet[0] = (byte) 0xFF;
        packet[1] = (byte) 0xF9;
        packet[2] = (byte) (((profile - 1) 

总结

---

从项目一开始设计到音视频编码，到自学完成入门，再到应用到项目中，前前后后也花了不少时间。一开始以为音视频编解码是一个很是高大上工程，但是真正接触到才体会到，虽然音视频编解码确实是很高深，但是使用起来并不困难，因为前人已经为你走过了很多路，能让你快速掌握并且应用到项目中。即使遇到问题，也可以通过各种问答社区例如stackoverflow 寻找到解决办法。