android基于ffmpeg的简单视频播发器 播放视频

最新推荐文章于 2024-08-08 08:35:24 发布
最新推荐文章于 2024-08-08 08:35:24 发布
阅读量1.2k 收藏 1
点赞数
分类专栏： ffmpeg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010302327/article/details/78427365
版权

视频播放用到opengl，因为ffmpeg是c写的，所以我就用c++写opengl，c不会写

把生成的so文件和include文件夹复制到项目的app\libs文件夹

CMakeLists.txt文件代码

cmake_minimum_required(VERSION 3.4.1)


add_library( native-lib
             SHARED
             src/main/cpp/native-lib.cpp
             src/main/cpp/OpenGLUtils.cpp
             src/main/cpp/ShaderUtils.cpp
             src/main/cpp/EGLUtils.cpp
             )

find_library( log-lib
              log )

set(distribution_DIR ../../../../libs)
set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=gnu++11")
set(CMAKE_VERBOSE_MAKEFILE on)
include_directories(libs/include)

add_library( avcodec-57
             SHARED
             IMPORTED)
add_library( avdevice-57
             SHARED
             IMPORTED)
add_library( avfilter-6
             SHARED
             IMPORTED)
add_library( avformat-57
             SHARED
             IMPORTED)
add_library( avutil-55
             SHARED
             IMPORTED)
add_library( swresample-2
             SHARED
             IMPORTED)
add_library( swscale-4
             SHARED
             IMPORTED)
set_target_properties( avcodec-57
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libavcodec-57.so)
set_target_properties( avdevice-57
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libavdevice-57.so)
set_target_properties( avfilter-6
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libavfilter-6.so)
set_target_properties( avformat-57
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libavformat-57.so)
set_target_properties( avutil-55
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libavutil-55.so)
set_target_properties( swresample-2
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libswresample-2.so)
set_target_properties( swscale-4
                       PROPERTIES IMPORTED_LOCATION
                       ${distribution_DIR}/${ANDROID_ABI}/libswscale-4.so)

target_link_libraries( native-lib

                       avcodec-57
                       avdevice-57
                       avfilter-6
                       avformat-57
                       avutil-55
                       swresample-2
                       swscale-4

                       ${log-lib}
                       android
                       EGL
                       GLESv2
                       )
引入opengl，egl和android包，都要用到

java代码

setContentView(R.layout.activity_main);
SurfaceView surfaceView = findViewById(R.id.surface_view);

surfaceView.getHolder().addCallback(new SurfaceHolder.Callback() {
    @Override
    public void surfaceCreated(SurfaceHolder holder) {

    }

    @Override
    public void surfaceChanged(final SurfaceHolder holder, int format, int width, int height) {
        Thread thread = new Thread(){
            @Override
            public void run() {
                super.run();
                String videoPath = "/storage/emulated/0/baiduNetdisk/season09.mp4";
                videoPlay(videoPath,holder.getSurface());
            }
        };
        thread.start();
    }

    @Override
    public void surfaceDestroyed(SurfaceHolder holder) {

    }
});
很简单，主要是调用 

public native void videoPlay(String path, Surface surface);
来进行处理

c++代码

const char *path = env->GetStringUTFChars(path_, 0);
// TODO

av_register_all();
AVFormatContext *fmt_ctx = avformat_alloc_context();
if (avformat_open_input(&fmt_ctx, path, NULL, NULL) < 0) {
    return;
}
if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
    return;
}
AVStream *avStream = NULL;
int video_stream_index = -1;
for (int i = 0; i < fmt_ctx->nb_streams; i++) {
    if (fmt_ctx->streams[i]->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
        avStream = fmt_ctx->streams[i];
        video_stream_index = i;
        break;
    }
}
if (video_stream_index == -1) {
    return;
}
AVCodecContext *codec_ctx = avcodec_alloc_context3(NULL);
avcodec_parameters_to_context(codec_ctx, avStream->codecpar);

AVCodec *avCodec = avcodec_find_decoder(codec_ctx->codec_id);
if (avcodec_open2(codec_ctx, avCodec, NULL) < 0) {
    return;
}

ANativeWindow* nativeWindow = ANativeWindow_fromSurface(env,surface);

AVFrame *yuvFrame = av_frame_alloc();

EGLUtils *eglUtils = new EGLUtils();
eglUtils->initEGL(nativeWindow);

OpenGLUtils *openGLUtils = new OpenGLUtils();
openGLUtils->surfaceCreated();
openGLUtils->surfaceChanged(eglUtils->getWidth(),eglUtils->getHeight());
openGLUtils->initTexture(codec_ctx->width,codec_ctx->height);

int y_size = codec_ctx->width * codec_ctx->height;
AVPacket *pkt = (AVPacket *) malloc(sizeof(AVPacket));
av_new_packet(pkt, y_size);
int ret;
while (1) {
    if (av_read_frame(fmt_ctx, pkt) < 0) {
        av_packet_unref(pkt);
        break;
    }
    if (pkt->stream_index == video_stream_index) {
        ret = avcodec_send_packet(codec_ctx, pkt);
        if (ret < 0 && ret != AVERROR(EAGAIN) && ret != AVERROR_EOF) {
            av_packet_unref(pkt);
            continue;
        }
        ret = avcodec_receive_frame(codec_ctx, yuvFrame);
        if (ret < 0 && ret != AVERROR_EOF) {
            av_packet_unref(pkt);
            continue;
        }

        openGLUtils->updateTexture(yuvFrame->width,yuvFrame->height,yuvFrame->data[0],yuvFrame->data[1],yuvFrame->data[2]);
        openGLUtils->surfaceDraw();
        eglUtils->drawEGL();

        av_packet_unref(pkt);
    }
    av_packet_unref(pkt);
}
av_frame_free(&yuvFrame);
avcodec_close(codec_ctx);
avformat_close_input(&fmt_ctx);

env->ReleaseStringUTFChars(path_, path);
引入的包 

#include <android/native_window.h>
#include <android/native_window_jni.h>
#include "EGLUtils.h"
#include "OpenGLUtils.h"
extern "C" {
#include "libavformat/avformat.h"
#include "libavfilter/avfiltergraph.h"
}

因为ffmpeg用c写的，所以c++引入时要用extern不然会报错

EGLUtils和OpenGLUtils是我自己写的opengl渲染代码

EGLUtils.h

#ifndef VIDEOPLAY_EGLUTILS_H
#define VIDEOPLAY_EGLUTILS_H

#include <EGL/egl.h>
class EGLUtils {
public:

    EGLUtils();
    ~EGLUtils();

    void initEGL(ANativeWindow *nativeWindow);

    void drawEGL();
    int getWidth();
    int getHeight();

private:
    EGLConfig eglConf;
    EGLSurface eglWindow;
    EGLContext eglCtx;
    EGLDisplay eglDisp;

    int windowWidth;
    int windowHeight;

    void releaseEGL();
};


#endif //VIDEOPLAY_EGLUTILS_H
EGLUtils.cpp 

#include "EGLUtils.h"
EGLUtils::EGLUtils() {

}
EGLUtils::~EGLUtils() {
    releaseEGL();
}

void EGLUtils::initEGL(ANativeWindow *nativeWindow) {
    EGLint configSpec[] = { EGL_RED_SIZE, 8,
                            EGL_GREEN_SIZE, 8,
                            EGL_BLUE_SIZE, 8,
                            EGL_SURFACE_TYPE, EGL_WINDOW_BIT, EGL_NONE };

    eglDisp = eglGetDisplay(EGL_DEFAULT_DISPLAY);
    EGLint eglMajVers, eglMinVers;
    EGLint numConfigs;
    eglInitialize(eglDisp, &eglMajVers, &eglMinVers);
    eglChooseConfig(eglDisp, configSpec, &eglConf, 1, &numConfigs);

    eglWindow = eglCreateWindowSurface(eglDisp, eglConf,nativeWindow, NULL);

    eglQuerySurface(eglDisp,eglWindow,EGL_WIDTH,&windowWidth);
    eglQuerySurface(eglDisp,eglWindow,EGL_HEIGHT,&windowHeight);
    const EGLint ctxAttr[] = {
            EGL_CONTEXT_CLIENT_VERSION, 2,
            EGL_NONE
    };
    eglCtx = eglCreateContext(eglDisp, eglConf,EGL_NO_CONTEXT, ctxAttr);
    eglMakeCurrent(eglDisp, eglWindow, eglWindow, eglCtx);
}
int EGLUtils::getWidth() {
    return windowWidth;
}
int EGLUtils::getHeight(){
    return windowHeight;
}
void EGLUtils::releaseEGL() {
    eglMakeCurrent(eglDisp, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
    eglDestroyContext(eglDisp, eglCtx);

    eglDestroySurface(eglDisp, eglWindow);
    eglTerminate(eglDisp);

    eglDisp = EGL_NO_DISPLAY;

    eglWindow = EGL_NO_SURFACE;
    eglCtx = EGL_NO_CONTEXT;
}
void EGLUtils::drawEGL() {
    eglSwapBuffers(eglDisp, eglWindow);
}
OpenGLUtils.h 

#ifndef VIDEOPLAY_OPENGLUTILS_H
#define VIDEOPLAY_OPENGLUTILS_H


#include <GLES2/gl2.h>

class OpenGLUtils {
public:
    OpenGLUtils();
    ~OpenGLUtils();

    void surfaceCreated();

    void surfaceChanged(int width, int height);

    void initTexture(int width,int height);

    void updateTexture(int width,int height,void *bufY,void *bufU,void *bufV);

    void surfaceDraw();
    void release();
private:

    GLuint programId;

    GLuint aPositionHandle;
    GLuint aTextureCoordHandle;
    GLuint textureSamplerHandle[3];

    GLuint textureId[3];

    float *vertexData;
    float *textureVertexData;

    int viewWidth,viewHeight;
    int videoWidth,videoHeight;
    int screenWidth, screenHeight;

    void viewport();

};


#endif
OpenGLUtils.cpp 

#include "OpenGLUtils.h"
#include "ShaderUtils.h"

OpenGLUtils::OpenGLUtils() {
    vertexData = new float[12]{
            1.0f, -1.0f, 0.0f,
            -1.0f, -1.0f, 0.0f,
            1.0f, 1.0f, 0.0f,
            -1.0f, 1.0f, 0.0f
    };

    textureVertexData = new float[8]{
            1.0f, 0.0f,//右下
            0.0f, 0.0f,//左下
            1.0f, 1.0f,//右上
            0.0f, 1.0f//左上
    };
}

OpenGLUtils::~OpenGLUtils() {
    release();
}

void OpenGLUtils::surfaceCreated() {
    ShaderUtils *shaderUtils = new ShaderUtils();
    programId = shaderUtils->getYUVShader();

    aPositionHandle = (GLuint) glGetAttribLocation(programId, "aPosition");
    aTextureCoordHandle = (GLuint) glGetAttribLocation(programId, "aTexCoord");

    textureSamplerHandle[0] = (GLuint) glGetUniformLocation(programId, "yTexture");
    textureSamplerHandle[1] = (GLuint) glGetUniformLocation(programId, "uTexture");
    textureSamplerHandle[2] = (GLuint) glGetUniformLocation(programId, "vTexture");
    delete shaderUtils;

    glUseProgram(programId);
    glEnableVertexAttribArray(aPositionHandle);
    glVertexAttribPointer(aPositionHandle, 3, GL_FLOAT, GL_FALSE,
            12, vertexData);

    glEnableVertexAttribArray(aTextureCoordHandle);
    glVertexAttribPointer(aTextureCoordHandle, 2, GL_FLOAT, GL_FALSE, 8, textureVertexData);


}

void OpenGLUtils::surfaceChanged(int width, int height) {
    screenWidth = width;
    screenHeight = height;
}

void OpenGLUtils::initTexture(int width, int height) {

    videoWidth = width;
    videoHeight = height;

    glGenTextures(1,&textureId[0]);
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D,textureId[0]);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width, height, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
    glUniform1i(textureSamplerHandle[0],0);

    glGenTextures(1,&textureId[1]);
    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D,textureId[1]);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width/2, height/2, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
    glUniform1i(textureSamplerHandle[1],1);


    glGenTextures(1,&textureId[2]);
    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D,textureId[2]);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MIN_FILTER,
                    GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D,GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexImage2D(GL_TEXTURE_2D, 0, GL_LUMINANCE, width/2, height/2, 0,
                 GL_LUMINANCE, GL_UNSIGNED_BYTE, NULL);
    glUniform1i(textureSamplerHandle[2],2);


    viewport();
}

void OpenGLUtils::updateTexture(int width, int height, void *bufY, void *bufU, void *bufV) {
    glActiveTexture(GL_TEXTURE0);
    glBindTexture(GL_TEXTURE_2D, textureId[0]);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_LUMINANCE, GL_UNSIGNED_BYTE, bufY);

    glActiveTexture(GL_TEXTURE1);
    glBindTexture(GL_TEXTURE_2D, textureId[1]);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, bufU);

    glActiveTexture(GL_TEXTURE2);
    glBindTexture(GL_TEXTURE_2D, textureId[2]);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width/2, height/2, GL_LUMINANCE, GL_UNSIGNED_BYTE, bufV);

}

void OpenGLUtils::surfaceDraw() {
    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);
}

void OpenGLUtils::viewport() {
    int left,top;
    if(screenHeight > screenWidth){
        left = 0;
        viewWidth = screenWidth;
        viewHeight = (int)(videoHeight*1.0f/videoWidth*viewWidth);
        top = (screenHeight - viewHeight)/2;
    }else{
        top = 0;
        viewHeight = screenHeight;
        viewWidth = (int)(videoWidth*1.0f/videoHeight*viewHeight);
        left = (screenWidth - viewWidth)/2;
    }
    glViewport(left, top, viewWidth, viewHeight);
}

void OpenGLUtils::release() {
    glDeleteProgram(programId);
    glDeleteTextures(3,textureId);
}
还有shader文件，用来显示YUV格式的图像

ShaderUtils.h

#ifndef VIDEOPLAY_SHADERUTILS_H
#define VIDEOPLAY_SHADERUTILS_H

#include <GLES2/gl2.h>
class ShaderUtils {
public:
    GLuint createProgram(const char *vertexSource, const char *fragmentSource);

    GLuint loadShader(GLenum shaderType, const char *source);

    GLuint getYUVShader();
};


#endif
ShaderUtils.cpp 

#include <malloc.h>
#include "ShaderUtils.h"
#define GET_STR(x) #x
const char *vertexYUVShaderString = GET_STR(
        attribute vec4 aPosition;
        attribute vec2 aTexCoord;
        varying vec2 vTexCoord;
        void main() {
            vTexCoord=vec2(aTexCoord.x,1.0-aTexCoord.y);
            gl_Position = aPosition;
        }
);
const char *fragmentYUVSShaderString = GET_STR(
        precision mediump float;
        varying vec2 vTexCoord;
        uniform sampler2D yTexture;
        uniform sampler2D uTexture;
        uniform sampler2D vTexture;
        void main() {
            vec3 yuv;
            vec3 rgb;
            yuv.r = texture2D(yTexture, vTexCoord).r;
            yuv.g = texture2D(uTexture, vTexCoord).r - 0.5;
            yuv.b = texture2D(vTexture, vTexCoord).r - 0.5;
            rgb = mat3(1.0,       1.0,         1.0,
                       0.0,       -0.39465,  2.03211,
                       1.13983, -0.58060,  0.0) * yuv;
            gl_FragColor = vec4(rgb, 1.0);
        }
);
GLuint ShaderUtils::getYUVShader(){
    return createProgram(vertexYUVShaderString,fragmentYUVSShaderString);
}
GLuint ShaderUtils::createProgram(const char *vertexSource, const char *fragmentSource) {
    GLuint vertexShader = loadShader(GL_VERTEX_SHADER, vertexSource);
    if (!vertexShader) {
        return 0;
    }
    GLuint pixelShader = loadShader(GL_FRAGMENT_SHADER, fragmentSource);
    if (!pixelShader) {
        return 0;
    }

    GLuint program = glCreateProgram();
    if (program != 0) {
        glAttachShader(program, vertexShader);
        glAttachShader(program, pixelShader);
        glLinkProgram(program);
        GLint  linkStatus = 0;
        glGetProgramiv(program, GL_LINK_STATUS, &linkStatus);
        if (!linkStatus) {
            GLint info_length = 0;
            glGetProgramiv(program, GL_INFO_LOG_LENGTH, &info_length);
            if(info_length){
                char* buf = (char*)malloc(info_length * sizeof(char));
                glGetProgramInfoLog(program, info_length, NULL, buf);
                free(buf);
            }
            glDeleteProgram(program);
            program = 0;
        }
    }
    return program;
}
GLuint ShaderUtils::loadShader(GLenum shaderType, const char *source) {
    GLuint shader = glCreateShader(shaderType);
    if (shader != 0) {
        glShaderSource(shader,1, &source,NULL);
        glCompileShader(shader);
        GLint compiled = 0;
        glGetShaderiv(shader, GL_COMPILE_STATUS, &compiled);
        if (!compiled) {
            GLint info_length = 0;
            glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &info_length);
            if(info_length){
                char* buf = (char*)malloc(info_length * sizeof(char));
                if(buf){ glGetShaderInfoLog(shader, info_length, NULL, buf);
                }
                free(buf);
            }
            glDeleteShader(shader);shader = 0;
        }
    }
    return shader;
}
shader代码是拿雷神的

这些代码只是显示解码出来的图像，没有做时间矫正，所以就是快进画面，播放速度就是解码速度









红色与青色
关注
专栏目录
android-ffmpeg-player:一个基于 ffmpeg 的安卓视频播放器
07-22
android-ffmpeg-播放器 一个基于 ffmpeg 的安卓视频播放器
Android 基于ffmpeg开发简易播放器 - ffmpeg解封装
weixin_34128839的博客
06-11 320
ffmpeg解封装 需要调用ffmpeg的API首先需要引入对应的头文件： extern "C"{ #include &lt;libavcodec/avcodec.h&gt; #include &lt;libavformat/avformat.h&gt; } 复制代码1.初始化解封装 //初始化解封装 av_register_all(); //初始化网络，可以直接从服务器拉流 avformat_n...
Android开发-使用FFmpeg-Android进行音视频处理
最新发布
_彼岸雨敲窗_的博客
08-08 1018
随着移动互联网的飞速发展，音视频处理技术在现代应用中的地位越来越重要。FFmpeg 是一款强大的开源多媒体处理框架，广泛应用于视频编辑、转换等领域。本文将介绍基于 FFmpeg n4.0 版本编译运行在 Android 平台的音视频处理框架 FFmpeg-Android 。
FFmpeg实现Android音视频播放器【1】
weixin_40194067的博客
06-17 709
这一步主要是将视频文件中的视频和音频数据进行拆分。首先获取AVFormatContext对象，通过AVFormatContext打开音视频数据源（.mp4文件或者音视频流）
Android MediaCodec+OpenGL视频编解码实践笔记
lidec的专栏
06-29 8046
Android MediaCodec+OpenGL视频编解码实践笔记 本文总结了Android MediaCodec配合OpenGL进行视频编解码以及渲染的相关流程。文中提供一个Demo，主要涉及调用Android MediaCodec进行编解码，以及渲染相关流程，针对实际工程中SurfaceView推后台等情况进行优化，渲染部分主要参考了Grafik，目前主要在rk3288平台验证。 1.Demo提供的测试功能 H264编码以及保存视频 H264解码渲染 Opengl绘制相机视频帧 VP8解码
基于 FFmpeg 的跨平台视频播放器简明教程（十）：在 Android 运行 FFmpeg
记录学习的过程
10-26 1201
在前九章的学习中，我们已经成功地实现了一个基础的播放器，它拥有视频播放、音画同步、快进/快退等基本功能。当然，这个简易的示例还有许多可以优化的地方，比如添加更美观的用户界面，或者增加字幕功能等。然而，这并不是本教程的主要关注点。本系列文章更关注于跨平台播放器框架的构建，特别是在移动端。因此，从本章开始，我们将把重点转向 Android 端播放器的开发。前置知识包括一些 Android 的基本开发，以及 JNI 开发等。这些前置知识默认你有所了解，本文不会涉及。关于 JNI 可以参考笔者之前写的。
C++基于opencv与ffmpeg的视频编辑器源码.zip
06-02
C++基于opencv与ffmpeg的视频编辑器源码，C++开发，QT界面，基于opencv与ffmpeg的视频编辑器。+配置文件，C++基于opencv与ffmpeg的视频编辑器源码，C++开发，QT界面，基于opencv与ffmpeg的视频编辑器。+配置文件C++...
最简单的基于FFMPEG的视频编码器（修正）
06-08
尽管该视频编码器的代码十分简单，但是几乎包含了使用FFMPEG编码一个视频所有必备的API。十分适合FFmpeg的初学者。 工程基于VC2010。 使用了2014.5.6版本的FFmpeg类库。 注：这是修正版，增加了flush_encoder()...
FFmpeg4Android：视频播放
02-11
在Android平台上，由于系统自带的MediaPlayer可能无法满足所有格式的视频播放需求，因此，引入FFmpeg4Android能够极大地扩展Android应用的视频播放能力。 FFmpeg4Android提供了两个层次的播放机制：JNI层播放（原生...
基于ffmpeg无损视频压缩软件
05-29
FFmpeg是一款强大的开源多媒体处理...总的来说，基于FFmpeg的无损视频压缩软件结合Python可以实现高效、灵活的视频优化。通过调整参数和编写自动化脚本，我们可以根据需求平衡视频质量和文件大小，满足不同场景的需求。
android采用FFmpeg实现音视频合成与分离
08-26
Android 采用 FFmpeg 实现音视频合成与分离是指使用 FFmpeg 库在 Android 平台上实现音视频的合成和分离，包括音频提取、视频提取、音视频合成等功能。 音频提取是指从多媒体文件中提取音频流，使用 FFmpeg 命令行...
FFmpeg系列(二)-Android项目引入FFmpeg库播放视频
weixin_33831196的博客
04-11 228
在系列一中讲述了如何编译FFmpeg的源码，现在就在Android项目中引入我们编译出来的库，并实现播放一个在线视频的功能 新建Android工程 新建一个支持ndk的Android工程，在AS中新建工程就不再详述了，详细的新建ndk工程，可以参考AndroidStudio中使用JNI/NDK示例 需要注意的一点就是在新建导航中注意勾选Support C++这个选项，这样新建的Android工程就...
基于FFmpeg的简单Android视频播放器
qq_52703909的博客
01-14 1137
1. 模块分割首先对这个视频播放器所采用的一些部件要清楚。这个播放器主要可以拆分为4个部分：1.解码：FFmpeg2.音频输出：OpenSLES3.视频渲染：OpenGLES这些框架都是基于C的api，因此这次我们的主要工作将会集中在NDK部分。而关于NDK的一些知识，之前的博客也有讲过，所以这个工程会是对之前知识的一次综合运用。为了提高可移植性，对关键部件使用接口来规范其API接口。对于播放器内部，播放的音频数据格式为16位PCM，44.1kHz采样率，双声道。
FFmpeg打造Android万能音频播放器
01-05
FFmpeg打造Android万能音频播放器视频教程，移植FFmpeg到Android平台，利用FFmpeg解码音频数据并用OpenSL ES来播放，打造Android万能播放器。
Android 音视频深入 六 使用FFmpeg播放视频（附源码下载）
z979451341的博客
02-03 3401
本篇项目地址，求starhttps://github.com/979451341/Audio-and-video-learning-materials/tree/master/FFmpeg%E6%92%AD%E6%94%BE%E8%A7%86%E9%A2%91首先FFmpeg是c语言写的，所以我们需要NDK的技术，然后我使用的NDK使用Cmake的，一开始就是说如何将FFmpeg导入项目，使用我的...
基于FFmpeg的Android播放器
zuguorui的专栏
09-30 1885
Android视频播放器，解码基于FFmpeg，支持软硬解。视频渲染基于OpenGL ES。音频输出基于oboe。
基于FFmpeg和Android的音视频同步播放实现
老王的技术博客
06-23 3864
前言 在以前的博文中，我们通过FFmpeg解码，并基于OpenGL ES完成了视频的渲染，也完成了基于OpenSL ES实现的native音频注入播放。 本文将这两部分代码进行合并，并实现音视频的同步播放。 实现需求 基于FFmpeg实现视频解码，并通过OpenGL ES进行渲染； 基于OpenSL ES进行PCM注入播放； 播放时进行音视频同步； 关于音视频同步原理 本文不...
Android平台FFMPEG音视频处理方案研究
"这篇硕士论文详细探讨了在Android多媒体平台上基于FFmpeg的音视频处理方案，旨在为Android上的音视频开发提供技术指导。作者罗潇在导师黄红斌副教授的指导下，研究了如何利用FFmpeg在Android系统中实现音视频的处理...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值