ffmpeg基于avfilter-avfilergraph之重采样

已于 2022-11-14 16:44:31 修改
阅读量668 收藏 1
点赞数
分类专栏： ffmpeg 文章标签： 音视频
于 2022-05-12 13:48:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_42929891/article/details/124729397
版权
这是一个关于使用FFmpeg进行音频重采样的C语言实现，包括枚举类型定义、重采样句柄初始化、销毁、数据发送与接收函数。代码中包含了错误处理、日志打印功能，并提供了测试程序，用于读取输入PCM文件，经过重采样后写入输出PCM文件。
摘要由CSDN通过智能技术生成

对应ffmpeg的版本：

  configuration: --prefix=/home/zeng/share/ffmpeg/ffmpeg/build/ --enable-ffplay
  libavutil      57. 24.101 / 57. 24.101
  libavcodec     59. 25.100 / 59. 25.100
  libavformat    59. 20.101 / 59. 20.101
  libavdevice    59.  6.100 / 59.  6.100
  libavfilter     8. 29.100 /  8. 29.100
  libswscale      6.  6.100 /  6.  6.100
  libswresample   4.  6.100 /  4.  6.100

下面是头文件、接口封装及相关的测试程序

#ifndef __ANDROID_AMIXER_H__
#define __ANDROID_AMIXER_H__ 

typedef enum {
    LogAresample_None = 0,  //关闭日志输出
    LogAresample_Urgent,    //必须打的
    LogAresample_Fatal,     //致使级
    LogAresample_Error,     //错误级
    LogAresample_Warning,   //告警级
    LogAresample_Info,      //业务级
    LogAresample_Debug,     //调试级
    LogAresample_Trace,     //跟踪级
    LogAresample_Detail,    //详细级
    LogAresample_Cnt
} LogAresample;


typedef enum {
    Aresample_SAMPLE_FMT_NONE = -1,
    Aresample_SAMPLE_FMT_U8,          ///< unsigned 8 bits
    Aresample_SAMPLE_FMT_S16,         ///< signed 16 bits
    Aresample_SAMPLE_FMT_S32,         ///< signed 32 bits
    Aresample_SAMPLE_FMT_FLT,         ///< float
    Aresample_SAMPLE_FMT_DBL,         ///< double

    Aresample_SAMPLE_FMT_U8P,         ///< unsigned 8 bits, planar
    Aresample_SAMPLE_FMT_S16P,        ///< signed 16 bits, planar
    Aresample_SAMPLE_FMT_S32P,        ///< signed 32 bits, planar
    Aresample_SAMPLE_FMT_FLTP,        ///< float, planar
    Aresample_SAMPLE_FMT_DBLP,        ///< double, planar
    Aresample_SAMPLE_FMT_S64,         ///< signed 64 bits
    Aresample_SAMPLE_FMT_S64P,        ///< signed 64 bits, planar
} AresampleSampleFormat;

typedef int32_t (*AresamplePrint)(void *, const char *);

//从句柄获取重采样后的一帧数据
int32_t recvAresampleFilter(void *oObj, void *data, int32_t *size);
//将一帧待重采样的数据添加到句柄
int32_t sendAresampleFilter(void *oObj, void *data, int32_t size);
//销毁重采样句柄
void destoryAresampleFilter(void *oObj);
//初始化重采样句柄
void *InitAresampleFilter(int32_t outFrameMs,  
        int32_t inRate, int32_t inChan, AresampleSampleFormat inFormat, 
        int32_t outRate, int32_t outChan, AresampleSampleFormat outFormat);
//设置重采样日志相关的内容
int32_t setAresampleLog(void *priv, AresamplePrint print);

#endif /*__ANDROID_AMIXER_H__*/

#include <unistd.h>
#include <stdint.h>
#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libavfilter/buffersink.h>
#include <libavfilter/buffersrc.h>
#include <libavutil/channel_layout.h>
#include <libavutil/opt.h>
#include <libavutil/mem.h>
#include <libavutil/avstring.h>

#include "aresample.h"
/* #include <memwatch.h> */

/*************************************************/
/**************LogPrintf**************************/
/*************************************************/
static void *gPriv = NULL;
static AresamplePrint gPrint;
static LogAresample gLevel = LogAresample_Info;

static int AresampleLogPrintf(LogAresample level,
        const char *file, const char *func,
        int line, const char *format, ...) {
    char logBuf[1024];
    va_list args;
    int funcLine        = 0;

    if (level > gLevel) return -1;

    snprintf (logBuf, sizeof(logBuf), "[%s][%s][%d]", file, func, line);
    funcLine = strlen(logBuf);

    /*va_list*/
    va_start(args, format);
    vsnprintf(&logBuf[funcLine], sizeof(logBuf) - funcLine, format, args);
    va_end(args);
    /*va_list*/

    if (gPrint) {
        return gPrint(gPriv, logBuf);
    }

    return -1;
}

#define LogPrintf(level, ...)\
    AresampleLogPrintf(level, __FILE__, __FUNCTION__, __LINE__, __VA_ARGS__);

#ifndef DEBUG0
#define DEBUG0(...)
#endif
#ifndef DEBUG1
#define DEBUG1(...)     LogPrintf(LogAresample_Error, __VA_ARGS__);
#endif
#ifndef DEBUG2
#define DEBUG2(...)     LogPrintf(LogAresample_Debug, __VA_ARGS__);
#endif

#ifndef ERRP
#define ERRP(con, ret, flag, ...)               \
    if (con) {                              \
        DEBUG##flag(__VA_ARGS__)            \
        ret;                                \
    }
#endif

static enum AVSampleFormat getAresampleFormat(AresampleSampleFormat aformat) {
    enum AVSampleFormat format = AV_SAMPLE_FMT_NONE; 

    switch (aformat) {
        case Aresample_SAMPLE_FMT_U8:
            format = AV_SAMPLE_FMT_U8;
            break;
        case Aresample_SAMPLE_FMT_S16:
            format = AV_SAMPLE_FMT_S16;
            break;
        case Aresample_SAMPLE_FMT_S32:
            format = AV_SAMPLE_FMT_S32;
            break;
        case Aresample_SAMPLE_FMT_FLT:
            format = AV_SAMPLE_FMT_FLT;
            break;
        case Aresample_SAMPLE_FMT_DBL:
            format = AV_SAMPLE_FMT_DBL;
            break;
        case Aresample_SAMPLE_FMT_U8P:
            format = AV_SAMPLE_FMT_U8P;
            break;
        case Aresample_SAMPLE_FMT_S16P:
            format = AV_SAMPLE_FMT_S16P;
            break;
        case Aresample_SAMPLE_FMT_S32P:
            format = AV_SAMPLE_FMT_S32P;
            break;
        case Aresample_SAMPLE_FMT_FLTP:
            format = AV_SAMPLE_FMT_FLTP;
            break;
        case Aresample_SAMPLE_FMT_DBLP:
            format = AV_SAMPLE_FMT_DBLP;
            break;
        case Aresample_SAMPLE_FMT_S64:
            format = AV_SAMPLE_FMT_S64;
            break;
        case Aresample_SAMPLE_FMT_S64P:
            format = AV_SAMPLE_FMT_S64P;
            break;
        default:break;
    }

    return format;
}

int32_t setAresampleLog(void *priv, AresamplePrint print) {
    gPriv   = priv;
    gPrint  = print;
    return 0;
}

typedef struct {
    void *handle;
    void *sink;
    void *source;

    int32_t inRate;
    enum AVSampleFormat inFormat;
    AVChannelLayout inChLayout;
    int32_t  outRate;
    enum AVSampleFormat outFormat;
    AVChannelLayout outChLayout;
} AresampleFilter;

/* 
 * 参数1:输出帧长时长　
 * 参数2:输入采样率
 * 参数3:输入通道数
 * 参数4:输入采样格式
 * 参数5:输出采样率
 * 参数6:输出通道数
 * 参数7:输出采样格式
 */
void *InitAresampleFilter(int32_t outFrameMs, 
        int32_t inRate, int32_t inChan, AresampleSampleFormat inFormat, 
        int32_t outRate, int32_t outChan, AresampleSampleFormat outFormat)
{
    int32_t status                          = -1;
    enum AVSampleFormat iFormat             = AV_SAMPLE_FMT_NONE;
    enum AVSampleFormat oFormat             = AV_SAMPLE_FMT_NONE;
    AresampleFilter *aresample              = NULL;
    AVFilterGraph *graph                    = NULL;      
    const char *inName                      = NULL;
    const char *outName                     = NULL;
    AVFilterContext *buffersinkCtx          = NULL;
	AVFilterInOut *input                    = NULL;
    AVFilterInOut *output                   = NULL;
    const AVFilter *abuffersink             = NULL;
    AVFilterContext *buffersrcCtx           = NULL;
    const AVFilter *abuffersrc              = NULL;
    AVChannelLayout inChLayout;
    AVChannelLayout outChLayout;
    char args[512];
    char buf[64];

    ERRP(1 != inChan && 2 != inChan, goto ERR0, 1, 
            "set channes [%d] invalid, range to [1-2]\n", inChan);
    ERRP(1 != outChan && 2 != outChan, goto ERR0, 1, 
            "set channes [%d] invalid, range to [1-2]\n", outChan);
    ERRP(8000 != inRate 
            && 16000 != inRate 
            && 32000 != inRate 
            && 44100 != inRate 
            && 48000 != inRate 
            && 96000 != inRate, goto ERR0, 1, 
            "set inRate [%d] invalid, range to "
            "[8000-16000-32000-44100-48000-96000]\n", inRate);
    ERRP(8000 != outRate 
            && 16000 != outRate 
            && 32000 != outRate 
            && 44100 != outRate 
            && 48000 != outRate 
            && 96000 != outRate, goto ERR0, 1, 
            "set outRate [%d] invalid, range to "
            "[8000-16000-32000-44100-48000-96000]\n", outRate);

    abuffersrc = avfilter_get_by_name("abuffer");
    ERRP(abuffersrc == NULL, goto ERR0, 1, 
            "input get abuffer failure\n");

    abuffersink = avfilter_get_by_name("abuffersink");
    ERRP(abuffersink == NULL, goto ERR0, 1, "get abuffersin failure");

    iFormat = getAresampleFormat(inFormat);
    ERRP(AV_SAMPLE_FMT_NONE == iFormat, goto ERR0, 1, "get iFormat [%d] failure\n", inFormat);
    printf ("iFormat:%d\n", iFormat);

    oFormat = getAresampleFormat(outFormat);
    ERRP(AV_SAMPLE_FMT_NONE == oFormat, goto ERR0, 1, "get oFormat [%d] failure\n", outFormat);
    printf ("oFormat:%d\n", oFormat);

    av_channel_layout_default(&inChLayout, inChan);
    av_channel_layout_describe(&inChLayout, buf, sizeof(buf));
    snprintf (args, sizeof(args) - 1, 
            "sample_rate=%d:sample_fmt=%s:channel_layout=%s", 
            inRate, av_get_sample_fmt_name(iFormat), buf);
    printf ("args:%s\n", args);

    graph = avfilter_graph_alloc();
    ERRP(graph == NULL, goto ERR0, 1, "get graph instance failure\n");

    inName = av_strdup("in0");
    ERRP(inName == NULL, goto ERR1, 1, "inName strdup failure\n");

    LogPrintf(LogAresample_Info, "get in:%s\n", inName);
    status = avfilter_graph_create_filter(&buffersrcCtx, 
            abuffersrc, inName, args, NULL, graph);
    ERRP(status < 0, goto ERR1, 1, "create source filter %s failure\n", inName);

    outName = av_strdup("out0");
    ERRP(outName == NULL, goto ERR1, 1, "parse out failure\n");

    status = avfilter_graph_create_filter(&buffersinkCtx, 
            abuffersink, outName, NULL, NULL, graph);
    ERRP(status < 0, goto ERR1, 1, "create sink filter %s failrue\n", outName);

    status = av_opt_set_bin(buffersinkCtx, "sample_fmts",
            (uint8_t*)&oFormat, sizeof(oFormat),
            AV_OPT_SEARCH_CHILDREN);
    ERRP (status < 0, goto ERR1, 1, "Cannot set output sample oFormat\n");

    av_channel_layout_default(&outChLayout, outChan);
    av_channel_layout_describe(&outChLayout, buf, sizeof(buf));
    status = av_opt_set(buffersinkCtx, "ch_layouts", buf, AV_OPT_SEARCH_CHILDREN);
    ERRP (status < 0, goto ERR1, 1, "Cannot set output sample format\n");

    status = av_opt_set_bin(buffersinkCtx, "sample_rates",
            (uint8_t*)&outRate, sizeof(outRate), AV_OPT_SEARCH_CHILDREN);
    ERRP (status < 0, goto ERR1, 1, "Cannot set output sample rate\n");

    output               = avfilter_inout_alloc();
    ERRP(output == NULL, goto ERR1, 1, "alloc inout failrue\n");

    output->name         = (char *)inName;
    output->filter_ctx   = buffersrcCtx;
    output->pad_idx      = 0;
    output->next         = NULL;

    input               = avfilter_inout_alloc();
    ERRP(input == NULL, goto ERR1, 1, "alloc input inout failrue\n");
    input->name         = (char *)outName;
    input->filter_ctx   = buffersinkCtx;
    input->pad_idx      = 0;
    input->next         = NULL;

    //已经将所有权交给了output和input
    inName              = NULL;
    outName             = NULL;

    snprintf(args, sizeof(args), "[in0]aresample=%d[out0]", outRate);
    args[sizeof(args) - 1] = '\0';
    printf ("args:%s\n", args);

    status = avfilter_graph_parse_ptr(graph, args, &input, &output, NULL);
    ERRP(status < 0, goto ERR1, 1, "parse ptr(%s) failure\n", args);

    status = avfilter_graph_config(graph, NULL);
    ERRP(status < 0, goto ERR1, 1, "config ptr(%s) failure\n", args);

    aresample = (AresampleFilter *) av_mallocz (sizeof(*aresample));
    ERRP(aresample == NULL, goto ERR1, 1, "malloc AresampleFilter instance failure\n");

    aresample->handle       = graph;
    aresample->sink         = buffersinkCtx;

    aresample->inRate       = inRate;
    aresample->inChLayout   = inChLayout;
    aresample->inFormat     = iFormat;

    aresample->outRate      = outRate;
    aresample->outChLayout  = outChLayout;
    aresample->outFormat    = oFormat;

    aresample->source       = buffersrcCtx;

    av_buffersink_set_frame_size(buffersinkCtx, outFrameMs * outRate / 1000);

    LogPrintf(LogAresample_Info, "InitAresampleFilter suc\n");
    return aresample;
ERR1:
    if (input) avfilter_inout_free(&input);
    if (output) avfilter_inout_free(&output);
    if (outName) free((void *)outName);
    if (inName) free((void *)inName);
    if (graph) avfilter_graph_free(&graph);
ERR0:
    return NULL;
}

void destoryAresampleFilter(void *oObj) {
    AVFilterGraph *graph = NULL;
    AresampleFilter *aresample = (AresampleFilter *)oObj;

    if (aresample) {
        graph = (AVFilterGraph *)aresample->handle;
        if (graph) {
            avfilter_graph_free(&graph);
        }

        av_free(aresample);
    }
}

int32_t sendAresampleFilter(void *oObj, void *data, int32_t size) {
    int32_t status          = -1;
    AVFrame *frame          = NULL;
    AVFilterContext *inCtx  = NULL;
    AresampleFilter *aresample    = (AresampleFilter *)oObj;

    ERRP(oObj == NULL, return -1, 0);
    ERRP(data == NULL, return -1, 0);

    frame = av_frame_alloc();
    ERRP(frame == NULL, goto ERR0, 1, "av_frame_alloc failrue\n");

    if (aresample) {
        inCtx   = (AVFilterContext *)aresample->source;
        if (inCtx) {
            frame->sample_rate      = aresample->inRate;
            frame->ch_layout        = aresample->inChLayout;
            frame->format           = aresample->inFormat;
            frame->nb_samples       = size / (av_get_bytes_per_sample(aresample->inFormat) * aresample->inChLayout.nb_channels);
            status = av_frame_get_buffer(frame, 0);
            ERRP(status < 0, goto ERR1, 1, "av_frame_get_buffer failure\n");
            memcpy(frame->data[0], data, size);
            status = av_buffersrc_add_frame_flags(inCtx, frame, 0);
            ERRP(status < 0, goto ERR1, 1, "av_buffersrc_add_frame_flags %d", status);
        }
    }

ERR1:
    av_frame_free(&frame);
ERR0:
    return status;
}

/*
此处有关于Planar的新处理，如果想代码更通用，建议采用该接口
int32_t sendAresampleFilter(void *oObj, void *data[], int32_t size) {
    int32_t status          = -1;
    int32_t channels        = 0;
    int32_t isPlanar        = 0;
    AVFrame *frame          = NULL;
    AVFilterContext *inCtx  = NULL;
    AresampleFilter *aresample    = (AresampleFilter *)oObj;

    ERRP(oObj == NULL, return -1, 0);
    ERRP(data == NULL, return -1, 0);

    frame = av_frame_alloc();
    ERRP(frame == NULL, goto ERR0, 1, "av_frame_alloc failrue\n");

    if (aresample) {
        inCtx   = (AVFilterContext *)aresample->source;
        if (inCtx) {
            frame->sample_rate      = aresample->inRate;
            frame->ch_layout        = aresample->inChLayout;
            frame->format           = aresample->inFormat;
            frame->nb_samples       = size / (av_get_bytes_per_sample(aresample->inFormat) * aresample->inChLayout.nb_channels);
            printf ("frame->nb_samples:%d\n", frame->nb_samples);
            status = av_frame_get_buffer(frame, 0);
            ERRP(status < 0, goto ERR1, 1, "av_frame_get_buffer failure\n");
            isPlanar = av_sample_fmt_is_planar(aresample->inFormat);
            if (!isPlanar) {
                memcpy(frame->data[0], data[0], size);
            }
            else {
                for (channels = 0; channels < aresample->inChLayout.nb_channels; channels++) {
                    memcpy(frame->data[channels],
                            data[channels], size/aresample->inChLayout.nb_channels);
                }
            }
            status = av_buffersrc_add_frame_flags(inCtx, frame, 0);
            ERRP(status < 0, goto ERR1, 1, "av_buffersrc_add_frame_flags %d", status);
        }
    }

ERR1:
    av_frame_free(&frame);
ERR0:
    return status;
}
*/

int32_t recvAresampleFilter(void *oObj, void *data, int32_t *size) {
    int32_t status          = -1;
    AVFrame *frame          = NULL;
    AVFilterContext *outCtx = NULL;
    AresampleFilter *aresample    = (AresampleFilter *)oObj;

    ERRP(oObj == NULL, return -1, 0);
    ERRP(data == NULL, return -1, 0);

    frame = av_frame_alloc();
    ERRP(frame == NULL, goto ERR0, 1, "av_frame_alloc failrue\n");

    if (aresample) {
        outCtx   = (AVFilterContext *)aresample->sink;
        if (outCtx) {
            status = av_buffersink_get_frame_flags(outCtx, frame, 0);
            ERRP(status < 0, goto ERR1, 1, "av_buffersink_get_frame_flags:%d", status);

            *size = frame->nb_samples 
                * av_get_bytes_per_sample(frame->format) 
                * frame->ch_layout.nb_channels;
            memcpy(data, frame->data[0], *size);
        }
    }

ERR1:
    av_frame_free(&frame);
ERR0:
    return status;
}

#ifdef TEST_ARESAMPLE
int32_t print(void *priv, const char *strings) {
    printf ("%s", strings);
    return 0;
}

int main(int args, char *argv[]) {
    int32_t ret         = -1;
    void *pObj          = NULL;
    int32_t ibuffer[1920];
    int16_t obuffer[1920];

    if (args != 3) {
        printf ("args == 3 ==> ./aresample in.pcm out.pcm\n");
        return -1;
    }

    FILE *fpIn0 = fopen(argv[1], "r");
    FILE *fpOut = fopen(argv[2], "w+");

    setAresampleLog(NULL, print);

    pObj = InitAresampleFilter(10, 96000, 1, Aresample_SAMPLE_FMT_S32, 48000, 1, Aresample_SAMPLE_FMT_S16);
    if (pObj) {
        printf ("pObj:%p\n", pObj);
        while (1) {
            int size = fread(ibuffer, 1, sizeof(ibuffer), fpIn0);
            if (size != sizeof(ibuffer)) break;
            ret = sendAresampleFilter(pObj, ibuffer, sizeof(ibuffer));
            if (ret < 0) break;

            ret = recvAresampleFilter(pObj, obuffer, &size);
            if (ret < 0) break;


            fwrite(obuffer, 1, size, fpOut);
        }
    }

    fclose(fpIn0);
    fclose(fpOut);
    destoryAresampleFilter(pObj);

    return 0;
}
#endif
曾振振
关注
专栏目录
【音视频】音频重采样-avfilter（五）
hcmonk的博客
04-05 572
本篇介绍音频重采样技术，音频重采样其实跟视频转码有异曲同工之妙，可以理解为将源pcm转码为目标pcm供编码器编码使用，因为有时候只需要采样率很低的音频。 技术简介 使用ffmpeg的filter功能实现 使用模块（库） 使用ffmpeg的avfilter-7.dll 主要流程和代码 1、初始化重采样器 int AudioResampler::init(const AUDIO_FILTER_CTX& outCtx, const AUDIO_FILTER_CTX* inCtx0, const AUDIO
音频重采样和音量调整ffmpeg滤镜(二十一)
翻肚鱼儿的博客
10-28 2914
前言 ffmpeg内置了很多滤镜库，都封装在AVFilter模块中，通过这个滤镜模块可以用来更加方便的处理音视频。比如视频分辨率压缩滤镜scale(用来对视频的分辨率进行缩放)，视频翻转滤镜transpose(对视频进行上下左右的翻转)；音频格式转换滤镜aformat(它实际上最终是调用avresample滤镜实现的)，volume(用来调整音量大小)等等。 关于ffmpeg的滤镜AVFilter源码及编译 1、默认情况下libavfilter模块会编译如下文件： OBJS = allfilte
ffmpeg 音频重采样
都市无名者的博客
09-28 1233
ffmpeg 音频重采样
FFMPEG实现音频重采样
07-28
FFMPEG实现音频重采样,示例代码实现将PCM的交叉存储方式转换成平行存储方式
FFMPEG使用AVFilter音频重采样
歲月無聲
06-28 1092
使用ffmpeg录音或者转换视频格式时，有时需要对音频进行重新采样，这里使用AVFilter过滤器重采样，非常方便 .h文件 #pragma once /* * 使用过滤器对音频重新采样 * 本类使用4.13版本ffmpeg * 2019-6-27 */ #include <windows.h> #ifdef __cplusplus extern "C" { #endif #i...
ffmpeg 利用AVFilter音频重采样
WaitForDone的博客
07-15 2548
前段时间一直在搞pcm转aac ，一开始打算直接来一个frame就编码，但发现因为pcm音频包每个packet是320个字节，AAC每个Packet是1024个字节。所以要加入个filter来转换。不过你也可以自己弄个buffer，等包够1024再编码，不建议这样做。如果只是想研究就可以，因为pts那些很烦，很容易导致一些奇怪的问题出现。在此可以参考http://www.cnblogs.com/wa
[Cmake-Android音视频]ffmpeg3.4音频重采样
adolph_lu的博客
06-18 1667
[Cmake-Android]音视频总结： [Cmake-Android音视频]SDK，NDK基本介绍 [Cmake-Android音视频]NDK-r14b编译ffmpeg3.4支持neon,硬解码 [Cmake-Android音视频]创建支持ffmpeg3.4的项目 [Cmake-Android音视频]ffmpeg3.4实现解封装 [Cmake-An...
音频重采样
wd_cloud的专栏
11-18 645
音频重采样流程图 函数介绍 swr_alloc() 分配音频重采样的上下文 swr_alloc_set_opts(...) 设置音频重采样参数，可以通过音频的样本率来改变播放速度，但声音一般会失真 struct SwrContext *swr_alloc_set_opts(struct SwrContext *s, int64_t out_ch_layout, enum AVSampleFormat out_sample_fmt, int..
Android-音视频学习系列-(四)-一键编译-32-64-位-FFmpeg-4-2-2
最新发布
2401_84544434的博客
04-29 562
bin/sh#帮组选项#标准选项#–disable 代表关闭状态；–enable 代表开启状态#我们最终编译好的动态静态库位置，必须设置#开启静态库#关闭动态库#可以优化库的大小#我们不需要使用程序，不需要在Windows中执行，某.exe程序，我们只需要在代码中使用 [此命令操作的是下面三项]#使用FFmpeg命令#播放器#模块选项。
32位的支持h265的rtmp推流的ffmpeg6.0
07-02
10. swresample-4.dll：音频重采样库，用于在不同采样率和格式之间转换音频数据。 通过这些组件，用户可以在32位系统上使用FFmpeg进行H265编码并利用RTMP协议将编码后的视频流推送到服务器，适用于在线直播、视频...
FFmpeg对音频数据重采样生成PCM数据.zip
03-19
FFmpeg是一套可以用来记录、转换数字音频、视频，并能将其转化为流的开源计算机程序。采用LGPL或GPL许可证。它提供了录制、转换以及流化音视频的完整解决方案。它包含了非常先进的音频/视频编解码库libavcodec，为了保证高可移植性和编解码质量，libavcodec里很多code都是从头开发的。
FFmpeg 的介绍与使用
热门推荐
我的学习笔记
09-04 12万+
FFmpeg：Fast Forward Moving Picture Experts Group FFmpeg 命令行工具的使用 在 FFmpeg 官网 可以下载对应平台的可执行程序包，比如 Windows 平台的下载地址是：https://ffmpeg.zeranoe.com/builds/，下载解压后就能在 bin 文件夹下能看到三个可执行程序：ffmpeg、ffplay、ffprob...
【Android音视频开发】FFmpeg对音频数据重采样生成PCM数据
乔培宸的博客
10-11 633
基本概念： 采样率：每秒对音频数据采样的个数（44100hz） 采样位数：存储采样数据的位数(16bit 2字节) 输出声道：单声道、立体声（左右声道）等 重采样： 就是把目标音频按照一定的格式重新采样编码成新的音频数据， 方便统一处理，一般的采样标准是：44100HZ、16bit、双声道 FFmpeg重采样 采样对象：解码出来的音频帧（AVframe） 使用函数：SwrContext swr_ctx = swr_alloc_set_opts( struct SwrCon...
音视频基础—封装，解码，重采样，像素格式，Android NDK，ABI，samba，ffmpeg下载
qq_37802398的博客
02-22 273
封装 从文件中，把音视频读出来 解码 解压出来，之后，视频需要显示，需要转换成显卡支持的格式，音频需要播放，转换成声卡支持的格式 像素格式 ：视频需要转换像素格式 MPEG-4 :用于音频，视频信息的压缩编码标准 MPEG-4 Part 14 MPEG-4文件格式Part15 AVC文件格式 H264(AVC Part10) 常用的封装格式 AVI 压缩标准可任意选择 （现...
了解FFmpeg音频通道布局结构：AVChannelLayout结构体解析
探索C++编程的奥秘，分享深入的技术见解和实践，旨在激发读者创造力与解决问题的思维。
06-02 2746
了解FFmpeg音频通道布局结构：AVChannelLayout结构体解析
【QT项目——视频播放器——解封装】4.5AVformatContext结构体解析4.6AVStream4.11av_read_frame4.14整个解封装过程代码
weixin_42427696的博客
09-15 640
整个解封装过程代码
FFmpeg采坑记录——aformat过滤器输出的linesize大小和音频编码后stream_index
SanShuiGeGe的博客
08-19 876
FFmpeg采坑记录——aformat过滤器输出的linesize大小和音频编码后stream_index
FFmpeg源码分析：获取声道布局与声道数
徐福记456
12-17 2万+
FFmpeg在libavutil模块封装有获取声道布局与声道数的API。声道布局包括：单声道、立体声道、环绕声道、5.0声道、5.1声道、7.0声道、7.1声道等。声道掩码包括：前方左边、前方右边、前方中央、低频、后方左边、后方右边、后方中央、左环绕、右环绕等。声道布局、声道名字和声道位置可以互相转换。
ffmpeg学习——音频源
成长之路
10-09 1820
缓冲音频帧，作为滤镜链图中有效的组成（起点）它主要编程使用，特别是通过中的接口进行调用。
ffmpeg-release-essentials.7z和ffmpeg-release-full以及ffmpeg-release-full-shared.7z有什么区别
06-02
`ffmpeg-release-essentials.7z` 和 `ffmpeg-release-full.7z` 的区别已经解释过了，它们之间的区别在于包含的内容不同。 而 `ffmpeg-release-full-shared.7z` 是针对开发人员的版本，它包含了完整的 FFmpeg 发布...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值