ffmpeg解码视音频

最新推荐文章于 2019-08-08 09:50:05 发布

山西茄子

最新推荐文章于 2019-08-08 09:50:05 发布

阅读量1k

点赞数

分类专栏： ffmpeg--h264

ffmpeg--h264 专栏收录该内容

13 篇文章 3 订阅

订阅专栏

包含三个例子，解码视频（不转YUV），解码视频（转YUV），解码音频。

解码视频（不转YUV）

如果有一段不知道编码格式的视频码流，用ffmpeg解码的流程如下：

av_register_all();
    avformat_network_init();

    AVFormatContext * pFormatCtx = avformat_alloc_context();

    AVCodecContext          *pCodecCtxv;
    AVCodec                  *pCodec;
    AVFrame                  *m_pFrame;
    if (avformat_open_input (&pFormatCtx, file, NULL, NULL) != 0)
    {
        return -1;
    }
// Retrieve stream information
    if (avformat_find_stream_info (pFormatCtx, NULL) < 0)
    {
        // Couldn't find stream information
        return -1;
    }
    int videoStream = -1;
    for (int i = 0; i < pFormatCtx->nb_streams; i++)
    {
        if (pFormatCtx->streams[i]->codec->codec_type ==
                AVMEDIA_TYPE_VIDEO)
        {
            videoStream = i;
        }
    }

    pCodecCtxv = pFormatCtx->streams[videoStream]->codec;

   pCodec = avcodec_find_decoder(pCodecCtxv->codec_id);
   if (pCodec == NULL) {
       printf("Codec not found.\n");
       return -1;
   }

    m_pFrame = av_frame_alloc();
    if(NULL==pCodecCtxv ||NULL==m_pFrame)
        return -1;

   if (avcodec_open2(pCodecCtxv, pCodec,NULL) < 0) {
       printf("Could not open codec.\n");
       return -1;
   }

    AVPacket packet;
    int nWidth = pCodecCtxv->width;
    int nHeight = pCodecCtxv->height;
    int nFrame = 0;
    int    got_picture;
    u_char *pyuv = new u_char[nWidth*nHeight*3/2];
    while (av_read_frame(pFormatCtx, &packet) >= 0 )
    {
        printf("nFrame = %d\n",nFrame++);
        int len = -1;
        int ret = avcodec_decode_video2(pCodecCtxv, m_pFrame, &got_picture, &packet);

         if(ret>0)
        {
            printf("dec suc\n");

            uint8_t* PtrY = NULL;   uint8_t* PtrU = NULL;   uint8_t* PtrV = NULL;
            //YUV data linesize
            int    iSizeY = 0; int iSizeU = 0;   int    iSizeV = 0;
            PtrY = m_pFrame->data[0];   PtrU = m_pFrame->data[1];    PtrV = m_pFrame->data[2];

            iSizeY = m_pFrame->linesize[0]; iSizeU = m_pFrame->linesize[1];

            iSizeV = m_pFrame->linesize[2];

            int ndatalen = 0;

            unsigned int i = 0;
            for (i = 0; i < nHeight; i++)
            {
                //SaveData(PtrY,nWidth);
                memcpy(pyuv+ndatalen, PtrY,nWidth);
                ndatalen+=nWidth;
                PtrY += iSizeY;
            }

            for (i = 0; i < nHeight/2; i++)
            {
                //SaveData(PtrV,nWidth/2);
                memcpy(pyuv+ndatalen, PtrV,nWidth/2);

                ndatalen+=nWidth/2;
                PtrV += iSizeV;
            }

            for (i = 0; i < nHeight/2; i++)
            {
                memcpy(pyuv+ndatalen, PtrY,nWidth/2);
                ndatalen+=nWidth/2;
                //SaveData(PtrU,nWidth/2);
                PtrU += iSizeU;
            }
        }
        else
        {
            printf(" dec faild\n");
        }
        av_free_packet(&packet);
    }

以上代码加上头文件即可，裸h264,裸mepg2,裸mpeg4，含视频的AVI已测过。

解码视频（转YUV）

#include <stdio.h>
#include <stdlib.h>
//编码
#include "libavcodec/avcodec.h"
//封装格式处理
#include "libavformat/avformat.h"
//像素处理
#include "libswscale/swscale.h"

int main()
{
    //获取输入输出文件名
    const char *input = "test.mp4";
    const char *output = "test.yuv";

    //1.注册所有组件
    av_register_all();

    //封装格式上下文，统领全局的结构体，保存了视频文件封装格式的相关信息
    AVFormatContext *pFormatCtx = avformat_alloc_context();

    //2.打开输入视频文件
    if (avformat_open_input(&pFormatCtx, input, NULL, NULL) != 0)
    {
        printf("%s","无法打开输入视频文件");
        return;
    }
    //3.获取视频文件信息
    if (avformat_find_stream_info(pFormatCtx,NULL) < 0)
    {
        printf("%s","无法获取视频文件信息");
        return;
    }
    //获取视频流的索引位置
    //遍历所有类型的流（音频流、视频流、字幕流），找到视频流
    int v_stream_idx = -1;
    int i = 0;
    //number of streams
    for (; i < pFormatCtx->nb_streams; i++)
    {
        //流的类型
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_VIDEO)
        {
            v_stream_idx = i;
            break;
        }
    }

    if (v_stream_idx == -1)
    {
        printf("%s","找不到视频流\n");
        return;
    }
    //只有知道视频的编码方式，才能够根据编码方式去找到解码器
    //获取视频流中的编解码上下文
    AVCodecContext *pCodecCtx = pFormatCtx->streams[v_stream_idx]->codec;
    //4.根据编解码上下文中的编码id查找对应的解码
    AVCodec *pCodec = avcodec_find_decoder(pCodecCtx->codec_id);
    if (pCodec == NULL)
    {
        printf("%s","找不到解码器\n");
        return;
    }
    //5.打开解码器
    if (avcodec_open2(pCodecCtx,pCodec,NULL)<0)
    {
        printf("%s","解码器无法打开\n");
        return;
    }
    //输出视频信息
    printf("视频的文件格式：%s",pFormatCtx->iformat->name);
    printf("视频时长：%d", (pFormatCtx->duration)/1000000);
    printf("视频的宽高：%d,%d",pCodecCtx->width,pCodecCtx->height);
    printf("解码器的名称：%s",pCodec->name);
    //准备读取
    //AVPacket用于存储一帧一帧的压缩数据（H264）
    //缓冲区，开辟空间
    AVPacket *packet = (AVPacket*)av_malloc(sizeof(AVPacket));
    //AVFrame用于存储解码后的像素数据(YUV)
    //内存分配
    AVFrame *pFrame = av_frame_alloc();
    //YUV420
    AVFrame *pFrameYUV = av_frame_alloc();
    //只有指定了AVFrame的像素格式、画面大小才能真正分配内存
    //缓冲区分配内存

uint8_t *out_buffer = (uint8_t *)av_malloc(avpicture_get_size(AV_PIX_FMT_YUV420P,

pCodecCtx->width, pCodecCtx->height));

//初始化缓冲区

avpicture_fill((AVPicture *)pFrameYUV, out_buffer, AV_PIX_FMT_YUV420P,

pCodecCtx->width, pCodecCtx->height);
//用于转码（缩放）的参数，转之前的宽高，转之后的宽高，格式等

struct SwsContext *sws_ctx =

sws_getContext(pCodecCtx->width,pCodecCtx->height,pCodecCtx->pix_fmt,

pCodecCtx->width, pCodecCtx->height, AV_PIX_FMT_YUV420P,

SWS_BICUBIC, NULL, NULL, NULL);

    int got_picture, ret;
    FILE *fp_yuv = fopen(output, "wb+");
    int frame_count = 0;
    //6.一帧一帧的读取压缩数据
    while (av_read_frame(pFormatCtx, packet) >= 0)
    {
        //只要视频压缩数据（根据流的索引位置判断）
        if (packet->stream_index == v_stream_idx)
        {
            //7.解码一帧视频压缩数据，得到视频像素数据
            ret = avcodec_decode_video2(pCodecCtx, pFrame, &got_picture, packet);
            if (ret < 0)
            {
                printf("%s","解码错误");
                return;
            }
            //为0说明解码完成，非0正在解码
            if (got_picture)
            {
                //AVFrame转为像素格式YUV420，宽高
                //2 6输入、输出数据
                //3 7输入、输出画面一行的数据的大小 AVFrame 转换是一行一行转换的
                //4 输入数据第一列要转码的位置从0开始
                //5 输入画面的高度
                sws_scale(sws_ctx, pFrame->data, pFrame->linesize, 0, pCodecCtx->height,
                          pFrameYUV->data, pFrameYUV->linesize);

                //输出到YUV文件
                //AVFrame像素帧写入文件
                //data解码后的图像像素数据（音频采样数据）
                //Y 亮度 UV 色度（压缩了）人对亮度更加敏感
                //U V 个数是Y的1/4
                int y_size = pCodecCtx->width * pCodecCtx->height;
                fwrite(pFrameYUV->data[0], 1, y_size, fp_yuv);
                fwrite(pFrameYUV->data[1], 1, y_size / 4, fp_yuv);
                fwrite(pFrameYUV->data[2], 1, y_size / 4, fp_yuv);

                frame_count++;
                printf("解码第%d帧\n",frame_count);
            }
        }
        //释放资源
        av_free_packet(packet);
    }
    fclose(fp_yuv);
    av_frame_free(&pFrame);
    avcodec_close(pCodecCtx);
    avformat_free_context(pFormatCtx);
}

说明：

AVFrame 存放从AVPacket中解码出来的原始数据，其必须通过av_frame_alloc来创建，通过av_frame_free来释放。和AVPacket类似，AVFrame中也有一块数据缓存空间，
在调用av_frame_alloc的时候并不会为这块缓存区域分配空间，需要使用其他的方法。在解码的过程使用了两个AVFrame，这两个AVFrame分配缓存空间的方法也不相同

一个AVFrame用来存放从AVPacket中解码出来的原始数据，这个AVFrame的数据缓存空间通过调avcodec_decode_video分配和填充。
另一个AVFrame用来存放将解码出来的原始数据变换为需要的数据格式（例如RGB，RGBA）的数据，这个AVFrame需要手动的分配数据缓存空间。代码如下：

AVFrame* pFrameYUV;
pFrameYUV = av_frame_alloc();
// 手动为 pFrameYUV分配数据缓存空间
int numBytes = avpicture_get_size(AV_PIX_FMT_YUV420P,pCodecCtx->widht,pCodecCtx->width);
uint8_t* buffer = (uint8_t*)av_malloc(numBytes * sizeof(uint8_t));
// 将分配的数据缓存空间和AVFrame关联起来
avpicture_fill((AVPicture *)pFrameYUV, buffer, AV_PIX_FMT_YUV420P,pCodecCtx->width, pCodecCtx->height)

首先计算需要缓存空间大小，调用av_malloc分配缓存空间，最后调用avpicture_fill将分配的缓存空间和AVFrame关联起来。
调用av_frame_free来释放AVFrame，该函数不止释放AVFrame本身的空间，还会释放掉包含在其内的其他对象动态申请的空间，例如上面的缓存空间。

av_malloc和av_free，FFmpeg并没有提供垃圾回收机制，所有的内存管理都要手动进行。av_malloc只是在申请内存空间的时候会考虑到内存对齐（2字节，4字节对齐），
其申请的空间要调用av_free释放。

解码音频

#include <stdlib.h>
#include <stdio.h>
#include <unistd.h>
//封装格式
#include "libavformat/avformat.h"
//解码
#include "libavcodec/avcodec.h"
//缩放
#include "libswscale/swscale.h"
#include "libswresample/swresample.h"
int main (void)
{
    //1.注册组件
    av_register_all();
    //封装格式上下文
    AVFormatContext *pFormatCtx = avformat_alloc_context();
    //2.打开输入音频文件
    if (avformat_open_input(&pFormatCtx, "test.mp3", NULL, NULL) != 0) {
        printf("%s", "打开输入音频文件失败");
        return;
    }
    //3.获取音频信息
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0) {
        printf("%s", "获取音频信息失败");
        return;
    }
    //音频解码，需要找到对应的AVStream所在的pFormatCtx->streams的索引位置
    int audio_stream_idx = -1;
    int i = 0;
    for (; i < pFormatCtx->nb_streams; i++) {
        //根据类型判断是否是音频流
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            audio_stream_idx = i;
            break;
        }
    }
    //4.获取解码器
    //根据索引拿到对应的流,根据流拿到解码器上下文
    AVCodecContext *pCodeCtx = pFormatCtx->streams[audio_stream_idx]->codec;
    //再根据上下文拿到编解码id，通过该id拿到解码器
    AVCodec *pCodec = avcodec_find_decoder(pCodeCtx->codec_id);
    if (pCodec == NULL) {
        printf("%s", "无法解码");
        return;
    }
    //5.打开解码器
    if (avcodec_open2(pCodeCtx, pCodec, NULL) < 0) {
        printf("%s", "编码器无法打开");
        return;
    }
    //编码数据
    AVPacket *packet = av_malloc(sizeof(AVPacket));
    //解压缩数据
    AVFrame *frame = av_frame_alloc();
    //frame->16bit 44100 PCM 统一音频采样格式与采样率
    SwrContext *swrCtx = swr_alloc();
    //重采样设置选项-----------------------------------------------------------start
    //输入的采样格式
    enum AVSampleFormat in_sample_fmt = pCodeCtx->sample_fmt;
    //输出的采样格式 16bit PCM
    enum AVSampleFormat out_sample_fmt = AV_SAMPLE_FMT_S16;
   //输入的采样率
    int in_sample_rate = pCodeCtx->sample_rate;
    //输出的采样率
    int out_sample_rate = 44100;
    //输入的声道布局
    uint64_t in_ch_layout = pCodeCtx->channel_layout;
    //输出的声道布局
    uint64_t out_ch_layout = AV_CH_LAYOUT_MONO;
    swr_alloc_set_opts(swrCtx, out_ch_layout, out_sample_fmt, out_sample_rate, in_ch_layout, in_sample_fmt,
    in_sample_rate, 0, NULL);
    swr_init(swrCtx);
    //重采样设置选项-----------------------------------------------------------end
    //获取输出的声道个数
    int out_channel_nb = av_get_channel_layout_nb_channels(out_ch_layout);
    //存储pcm数据
    uint8_t *out_buffer = (uint8_t *) av_malloc(2 * 44100);
    FILE *fp_pcm = fopen("out.pcm", "wb");
    int ret, got_frame, framecount = 0;
    //6.一帧一帧读取压缩的音频数据AVPacket
    while (av_read_frame(pFormatCtx, packet) >= 0) {
        if (packet->stream_index == audio_stream_idx) {
            //解码AVPacket->AVFrame
            ret = avcodec_decode_audio4(pCodeCtx, frame, &got_frame, packet);
            if (ret < 0) {
                printf("%s", "解码完成");
            }
            //非0，正在解码
            if (got_frame) {
                printf("解码%d帧", framecount++);
                swr_convert(swrCtx, &out_buffer, 2 * 44100, frame->data, frame->nb_samples);
                //获取sample的size
                int out_buffer_size = av_samples_get_buffer_size(NULL, out_channel_nb, frame->nb_samples,
                        out_sample_fmt, 1);
                //写入文件进行测试
                fwrite(out_buffer, 1, out_buffer_size, fp_pcm);
            }
        }
        av_free_packet(packet);
    }
    fclose(fp_pcm);
    av_frame_free(&frame);
    av_free(out_buffer);
    swr_free(&swrCtx);
    avcodec_close(pCodeCtx);
    avformat_close_input(&pFormatCtx);
    return 0;
}