【FFmpeg 系列】编解码（六）

已于 2022-03-10 08:50:04 修改
阅读量2.3k 收藏 1
点赞数
分类专栏： FFmpeg 文章标签： 音视频
于 2022-03-03 11:12:40 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u011035026/article/details/123248030
版权
1、FFmpeg 对 H264 进行编码
  • API：
<!-- 编码步骤 -->
// 查找编码器
avcodec_find_encoder_by_name()
// 设置编码参数，并打开编码器
avcodec_open2()
// 编码
avcodec_encode_video2()
  • 示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavcodec/avcodec.h>
#include <libavutil/opt.h>
#include <libavutil/imgutils.h>

int main(int argc, char **argv) {
    const char *filename, *codec_name;
    const AVCodec *codec;
    AVCodecContext *c = NULL;
    int i, ret, x, y, got_output;
    FILE *f;
    AVFrame *frame;
    AVPacket pkt;
    uint8_t endcode[] = {0, 0, 1, 0xb7};

    if (argc <= 2) {
        fprintf(stderr, "Usage: %s <output file> <codec name>\n", argv[0]);
        exit(0);
    }
    filename = argv[1];
    codec_name = argv[2];

    avcodec_register_all();

    /* find the mpeg1video encoder */
    codec = avcodec_find_encoder_by_name(codec_name);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    c = avcodec_alloc_context3(codec);
    if (!c) {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }

    /* put sample parameters */
    c->bit_rate = 400000;
    /* resolution must be a multiple of two */
    c->width = 352;
    c->height = 288;
    /* frames per second */
    c->time_base = (AVRational) {1, 25};
    c->framerate = (AVRational) {25, 1};

    /* emit one intra frame every ten frames
     * check frame pict_type before passing frame
     * to encoder, if frame->pict_type is AV_PICTURE_TYPE_I
     * then gop_size is ignored and the output of encoder
     * will always be I frame irrespective to gop_size
     */
    c->gop_size = 10;
    c->max_b_frames = 1;
    c->pix_fmt = AV_PIX_FMT_YUV420P;

    if (codec->id == AV_CODEC_ID_H264)
        av_opt_set(c->priv_data, "preset", "slow", 0);

    /* open it */
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    f = fopen(filename, "wb");
    if (!f) {
        fprintf(stderr, "Could not open %s\n", filename);
        exit(1);
    }

    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }
    frame->format = c->pix_fmt;
    frame->width = c->width;
    frame->height = c->height;

    ret = av_frame_get_buffer(frame, 32);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate the video frame data\n");
        exit(1);
    }

    /* encode 1 second of video */
    for (i = 0; i < 25; i++) {
        av_init_packet(&pkt);
        pkt.data = NULL;    // packet data will be allocated by the encoder
        pkt.size = 0;

        fflush(stdout);

        /* make sure the frame data is writable */
        ret = av_frame_make_writable(frame);
        if (ret < 0)
            exit(1);

        /* prepare a dummy image */
        /* Y */
        for (y = 0; y < c->height; y++) {
            for (x = 0; x < c->width; x++) {
                frame->data[0][y * frame->linesize[0] + x] = x + y + i * 3;
            }
        }

        /* Cb and Cr */
        for (y = 0; y < c->height / 2; y++) {
            for (x = 0; x < c->width / 2; x++) {
                frame->data[1][y * frame->linesize[1] + x] = 128 + y + i * 2;
                frame->data[2][y * frame->linesize[2] + x] = 64 + x + i * 5;
            }
        }

        frame->pts = i;

        /* encode the image */
        ret = avcodec_encode_video2(c, &pkt, frame, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            exit(1);
        }

        if (got_output) {
            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
            fwrite(pkt.data, 1, pkt.size, f);
            av_packet_unref(&pkt);
        }
    }

    /* get the delayed frames */
    for (got_output = 1; got_output; i++) {
        fflush(stdout);

        ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            exit(1);
        }

        if (got_output) {
            printf("Write frame %3d (size=%5d)\n", i, pkt.size);
            fwrite(pkt.data, 1, pkt.size, f);
            av_packet_unref(&pkt);
        }
    }

    /* add sequence end code to have a real MPEG file */
    fwrite(endcode, 1, sizeof(endcode), f);
    fclose(f);

    avcodec_free_context(&c);
    av_frame_free(&frame);

    return 0;
}
  • 编译与运行：
clang -g -o 9_ff_encode_video 9_ff_encode_video.c `pkg-config --cflags --libs libavutil libavcodec`

// 执行编译后的结果：
./9_ff_encode_video ./files/encode.h264 libx264
2、FFmpeg 对 H264 进行解码
  • API：
<!-- 文文件 -->
// 添加头文件
libavcodec/avcodec.h

<!-- 常见的数据结构 -->
// 编码器结构体
AVCodec
// 编码器上下文
AVCodecContext
// 解码后的帧
AVFrame

<!-- 结构体内存的分配与释放 -->
// 分配空间
av_frame_alloc()
// 释放空间
av_frame_free()
// 编码器分配的上下文
avcodec_alloc_context3()
// 编码器分配的上下文释放
avcodec_free_context()

<!-- 解码步骤 -->
// 查找解码器
avcodec_find_decoder()
// 打开解码器
avcodec_open2()
// 解码
avcodec_decode_video2()
  • 示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavformat/avformat.h>
#include <libavcodec/avcodec.h>
#include <libswscale/swscale.h>

#define INBUF_SIZE 4096

#define WORD uint16_t
#define DWORD uint32_t
#define LONG int32_t

#pragma pack(2)
typedef struct tagBITMAPFILEHEADER {
    WORD bfType;
    DWORD bfSize;
    WORD bfReserved1;
    WORD bfReserved2;
    DWORD bfOffBits;
} BITMAPFILEHEADER, *PBITMAPFILEHEADER;

typedef struct tagBITMAPINFOHEADER {
    DWORD biSize;
    LONG biWidth;
    LONG biHeight;
    WORD biPlanes;
    WORD biBitCount;
    DWORD biCompression;
    DWORD biSizeImage;
    LONG biXPelsPerMeter;
    LONG biYPelsPerMeter;
    DWORD biClrUsed;
    DWORD biClrImportant;
} BITMAPINFOHEADER, *PBITMAPINFOHEADER;

void saveBMP(struct SwsContext *img_convert_ctx, AVFrame *frame, char *filename) {
    //1 先进行转换,  YUV420=>RGB24:
    int w = frame->width;
    int h = frame->height;


    int numBytes = avpicture_get_size(AV_PIX_FMT_BGR24, w, h);
    uint8_t *buffer = (uint8_t *) av_malloc(numBytes * sizeof(uint8_t));


    AVFrame *pFrameRGB = av_frame_alloc();
    /* buffer is going to be written to rawvideo file, no alignment */
    /*
    if (av_image_alloc(pFrameRGB->data, pFrameRGB->linesize,
                              w, h, AV_PIX_FMT_BGR24, pix_fmt, 1) < 0) {
        fprintf(stderr, "Could not allocate destination image\n");
        exit(1);
    }
    */
    avpicture_fill((AVPicture *) pFrameRGB, buffer, AV_PIX_FMT_BGR24, w, h);

    sws_scale(img_convert_ctx, frame->data, frame->linesize,
              0, h, pFrameRGB->data, pFrameRGB->linesize);

    //2 构造 BITMAPINFOHEADER
    BITMAPINFOHEADER header;
    header.biSize = sizeof(BITMAPINFOHEADER);


    header.biWidth = w;
    header.biHeight = h * (-1);
    header.biBitCount = 24;
    header.biCompression = 0;
    header.biSizeImage = 0;
    header.biClrImportant = 0;
    header.biClrUsed = 0;
    header.biXPelsPerMeter = 0;
    header.biYPelsPerMeter = 0;
    header.biPlanes = 1;

    //3 构造文件头
    BITMAPFILEHEADER bmpFileHeader = {0,};
    //HANDLE hFile = NULL;
    DWORD dwTotalWriten = 0;
    DWORD dwWriten;

    bmpFileHeader.bfType = 0x4d42; //'BM';
    bmpFileHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + numBytes;
    bmpFileHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER);

    FILE *pf = fopen(filename, "wb");
    fwrite(&bmpFileHeader, sizeof(BITMAPFILEHEADER), 1, pf);
    fwrite(&header, sizeof(BITMAPINFOHEADER), 1, pf);
    fwrite(pFrameRGB->data[0], 1, numBytes, pf);
    fclose(pf);


    //释放资源
    //av_free(buffer);
    av_freep(&pFrameRGB[0]);
    av_free(pFrameRGB);
}

static void pgm_save(unsigned char *buf, int wrap, int xsize, int ysize,
                     char *filename) {
    FILE *f;
    int i;

    f = fopen(filename, "w");
    fprintf(f, "P5\n%d %d\n%d\n", xsize, ysize, 255);
    for (i = 0; i < ysize; i++)
        fwrite(buf + i * wrap, 1, xsize, f);
    fclose(f);
}

static int decode_write_frame(const char *outfilename, AVCodecContext *avctx,
                              struct SwsContext *img_convert_ctx, AVFrame *frame, int *frame_count, AVPacket *pkt,
                              int last) {
    int len, got_frame;
    char buf[1024];

    len = avcodec_decode_video2(avctx, frame, &got_frame, pkt);
    if (len < 0) {
        fprintf(stderr, "Error while decoding frame %d\n", *frame_count);
        return len;
    }
    if (got_frame) {
        printf("Saving %sframe %3d\n", last ? "last " : "", *frame_count);
        fflush(stdout);

        /* the picture is allocated by the decoder, no need to free it */
        snprintf(buf, sizeof(buf), "%s-%d.bmp", outfilename, *frame_count);

        /*
        pgm_save(frame->data[0], frame->linesize[0],
                 frame->width, frame->height, buf);
        */

        saveBMP(img_convert_ctx, frame, buf);

        (*frame_count)++;
    }
    return 0;
}

int main(int argc, char **argv) {
    int ret;

    FILE *f;

    const char *filename, *outfilename;

    AVFormatContext *fmt_ctx = NULL;

    const AVCodec *codec;
    AVCodecContext *c = NULL;

    AVStream *st = NULL;
    int stream_index;

    int frame_count;
    AVFrame *frame;

    struct SwsContext *img_convert_ctx;

    //uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
    AVPacket avpkt;

    if (argc <= 2) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        exit(0);
    }
    filename = argv[1];
    outfilename = argv[2];

    /* register all formats and codecs */
    av_register_all();

    /* open input file, and allocate format context */
    if (avformat_open_input(&fmt_ctx, filename, NULL, NULL) < 0) {
        fprintf(stderr, "Could not open source file %s\n", filename);
        exit(1);
    }

    /* retrieve stream information */
    if (avformat_find_stream_info(fmt_ctx, NULL) < 0) {
        fprintf(stderr, "Could not find stream information\n");
        exit(1);
    }

    /* dump input information to stderr */
    av_dump_format(fmt_ctx, 0, filename, 0);

    av_init_packet(&avpkt);

    /* set end of buffer to 0 (this ensures that no overreading happens for damaged MPEG streams) */
    //memset(inbuf + INBUF_SIZE, 0, AV_INPUT_BUFFER_PADDING_SIZE);
    //

    ret = av_find_best_stream(fmt_ctx, AVMEDIA_TYPE_VIDEO, -1, -1, NULL, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not find %s stream in input file '%s'\n",
                av_get_media_type_string(AVMEDIA_TYPE_VIDEO), filename);
        return ret;
    }

    stream_index = ret;
    st = fmt_ctx->streams[stream_index];

    /* find decoder for the stream */
    codec = avcodec_find_decoder(st->codecpar->codec_id);
    if (!codec) {
        fprintf(stderr, "Failed to find %s codec\n",
                av_get_media_type_string(AVMEDIA_TYPE_VIDEO));
        return AVERROR(EINVAL);
    }


    /* find the MPEG-1 video decoder */
    /*
    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }
    */

    c = avcodec_alloc_context3(NULL);
    if (!c) {
        fprintf(stderr, "Could not allocate video codec context\n");
        exit(1);
    }

    /* Copy codec parameters from input stream to output codec context */
    if ((ret = avcodec_parameters_to_context(c, st->codecpar)) < 0) {
        fprintf(stderr, "Failed to copy %s codec parameters to decoder context\n",
                av_get_media_type_string(AVMEDIA_TYPE_VIDEO));
        return ret;
    }


    /*
    if (codec->capabilities & AV_CODEC_CAP_TRUNCATED)
        c->flags |= AV_CODEC_FLAG_TRUNCATED; // we do not send complete frames
    */

    /* For some codecs, such as msmpeg4 and mpeg4, width and height
       MUST be initialized there because this information is not
       available in the bitstream. */

    /* open it */
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    /*
    f = fopen(filename, "rb");
    if (!f) {
        fprintf(stderr, "Could not open %s\n", filename);
        exit(1);
    }
    */

    img_convert_ctx = sws_getContext(c->width, c->height,
                                     c->pix_fmt,
                                     c->width, c->height,
                                     AV_PIX_FMT_BGR24,
                                     SWS_BICUBIC, NULL, NULL, NULL);

    if (img_convert_ctx == NULL) {
        fprintf(stderr, "Cannot initialize the conversion context\n");
        exit(1);
    }

    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate video frame\n");
        exit(1);
    }

    frame_count = 0;
    while (av_read_frame(fmt_ctx, &avpkt) >= 0) {
        /*
        avpkt.size = fread(inbuf, 1, INBUF_SIZE, f);
        if (avpkt.size == 0)
            break;
        */

        /* NOTE1: some codecs are stream based (mpegvideo, mpegaudio)
           and this is the only method to use them because you cannot
           know the compressed data size before analysing it.

           BUT some other codecs (msmpeg4, mpeg4) are inherently frame
           based, so you must call them with all the data for one
           frame exactly. You must also initialize 'width' and
           'height' before initializing them. */

        /* NOTE2: some codecs allow the raw parameters (frame size,
           sample rate) to be changed at any frame. We handle this, so
           you should also take care of it */

        /* here, we use a stream based decoder (mpeg1video), so we
           feed decoder and see if it could decode a frame */
        //avpkt.data = inbuf;
        //while (avpkt.size > 0)
        if (avpkt.stream_index == stream_index) {
            if (decode_write_frame(outfilename, c, img_convert_ctx, frame, &frame_count, &avpkt, 0) < 0)
                exit(1);
        }

        av_packet_unref(&avpkt);
    }

    /* Some codecs, such as MPEG, transmit the I- and P-frame with a
       latency of one frame. You must do the following to have a
       chance to get the last frame of the video. */
    avpkt.data = NULL;
    avpkt.size = 0;
    decode_write_frame(outfilename, c, img_convert_ctx, frame, &frame_count, &avpkt, 1);

    fclose(f);

    avformat_close_input(&fmt_ctx);

    sws_freeContext(img_convert_ctx);
    avcodec_free_context(&c);
    av_frame_free(&frame);

    return 0;
}
  • 编译与运行：
clang -g -o 10_ff_decode_video 10_ff_decode_video.c `pkg-config --cflags --libs libavformat libavcodec libswscale`

// 执行编译后的结果：(注意 images 需存在)
./10_ff_decode_video ./files/sample.h264 ./files/images/image
3、FFmpeg 对 AAC 进行编码
  • API：
<!-- 编码步骤（与视频相同） -->
// 查找编码器
avcodec_find_encoder_by_name()
// 设置编码参数，并打开编码器
avcodec_open2()
// 编码
avcodec_encodec_audio2()
  • 示例：
#include <stdint.h>
#include <stdio.h>
#include <stdlib.h>

#include <libavcodec/avcodec.h>

#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/frame.h>
#include <libavutil/samplefmt.h>

/* check that a given sample format is supported by the encoder */
static int check_sample_fmt(const AVCodec *codec, enum AVSampleFormat sample_fmt) {
    const enum AVSampleFormat *p = codec->sample_fmts;

    while (*p != AV_SAMPLE_FMT_NONE) {
        if (*p == sample_fmt)
            return 1;
        p++;
    }
    return 0;
}

/* just pick the highest supported samplerate */
static int select_sample_rate(const AVCodec *codec) {
    const int *p;
    int best_samplerate = 0;

    if (!codec->supported_samplerates)
        return 44100;

    p = codec->supported_samplerates;
    while (*p) {
        if (!best_samplerate || abs(44100 - *p) < abs(44100 - best_samplerate))
            best_samplerate = *p;
        p++;
    }
    return best_samplerate;
}

/* select layout with the highest channel count */
static int select_channel_layout(const AVCodec *codec) {
    const uint64_t *p;
    uint64_t best_ch_layout = 0;
    int best_nb_channels = 0;

    if (!codec->channel_layouts)
        return AV_CH_LAYOUT_STEREO;

    p = codec->channel_layouts;
    while (*p) {
        int nb_channels = av_get_channel_layout_nb_channels(*p);

        if (nb_channels > best_nb_channels) {
            best_ch_layout = *p;
            best_nb_channels = nb_channels;
        }
        p++;
    }
    return best_ch_layout;
}

int main(int argc, char **argv) {
    const char *filename;
    const AVCodec *codec;
    AVCodecContext *c = NULL;
    AVFrame *frame;
    AVPacket pkt;
    int i, j, k, ret, got_output;
    FILE *f;
    uint16_t *samples;
    float t, tincr;

    if (argc <= 1) {
        fprintf(stderr, "Usage: %s <output file>\n", argv[0]);
        return 0;
    }
    filename = argv[1];

    /* register all the codecs */
    avcodec_register_all();

    /* find the MP2 encoder */
    codec = avcodec_find_encoder(AV_CODEC_ID_MP2);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    c = avcodec_alloc_context3(codec);
    if (!c) {
        fprintf(stderr, "Could not allocate audio codec context\n");
        exit(1);
    }

    /* put sample parameters */
    c->bit_rate = 64000;

    /* check that the encoder supports s16 pcm input */
    c->sample_fmt = AV_SAMPLE_FMT_S16;
    if (!check_sample_fmt(codec, c->sample_fmt)) {
        fprintf(stderr, "Encoder does not support sample format %s",
                av_get_sample_fmt_name(c->sample_fmt));
        exit(1);
    }

    /* select other audio parameters supported by the encoder */
    c->sample_rate = select_sample_rate(codec);
    c->channel_layout = select_channel_layout(codec);
    c->channels = av_get_channel_layout_nb_channels(c->channel_layout);

    /* open it */
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    f = fopen(filename, "wb");
    if (!f) {
        fprintf(stderr, "Could not open %s\n", filename);
        exit(1);
    }

    /* frame containing input raw audio */
    frame = av_frame_alloc();
    if (!frame) {
        fprintf(stderr, "Could not allocate audio frame\n");
        exit(1);
    }

    frame->nb_samples = c->frame_size;
    frame->format = c->sample_fmt;
    frame->channel_layout = c->channel_layout;

    /* allocate the data buffers */
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate audio data buffers\n");
        exit(1);
    }

    /* encode a single tone sound */
    t = 0;
    tincr = 2 * M_PI * 440.0 / c->sample_rate;
    for (i = 0; i < 200; i++) {
        av_init_packet(&pkt);
        pkt.data = NULL; // packet data will be allocated by the encoder
        pkt.size = 0;

        /* make sure the frame is writable -- makes a copy if the encoder
         * kept a reference internally */
        ret = av_frame_make_writable(frame);
        if (ret < 0)
            exit(1);
        samples = (uint16_t *) frame->data[0];

        for (j = 0; j < c->frame_size; j++) {
            samples[2 * j] = (int) (sin(t) * 10000);

            for (k = 1; k < c->channels; k++)
                samples[2 * j + k] = samples[2 * j];
            t += tincr;
        }
        /* encode the samples */
        ret = avcodec_encode_audio2(c, &pkt, frame, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding audio frame\n");
            exit(1);
        }
        if (got_output) {
            fwrite(pkt.data, 1, pkt.size, f);
            av_packet_unref(&pkt);
        }
    }

    /* get the delayed frames */
    for (got_output = 1; got_output; i++) {
        ret = avcodec_encode_audio2(c, &pkt, NULL, &got_output);
        if (ret < 0) {
            fprintf(stderr, "Error encoding frame\n");
            exit(1);
        }

        if (got_output) {
            fwrite(pkt.data, 1, pkt.size, f);
            av_packet_unref(&pkt);
        }
    }
    fclose(f);

    av_frame_free(&frame);
    avcodec_free_context(&c);

    return 0;
}
  • 编译与运行：
clang -g -o 11_ff_encode_audio 11_ff_encode_audio.c `pkg-config --cflags --libs libavcodec libavutil`

// 执行编译后的结果：
./11_ff_encode_audio ./files/encode.aac
4、FFmpeg 对 AAC 进行解码
  • API：
<!-- 编码步骤（与视频相同） -->
// 查找编码器
avcodec_find_encoder_by_name()
// 设置编码参数，并打开编码器
avcodec_open2()
// 编码
avcodec_encodec_audio2()
  • 示例：
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <libavutil/frame.h>
#include <libavutil/mem.h>

#include <libavcodec/avcodec.h>
#include <libavformat/avformat.h>
#include <libswresample/swresample.h>

#define AUDIO_INBUF_SIZE     20480
#define AUDIO_REFILL_THRESH  4096
#define MAX_AUDIO_FRAME_SIZE 192000

int main(int argc, char **argv) {
    int i, ret;

    //error message
    int err_code;
    char errors[1024];

    int audiostream_index = -1;

    //codec parameters
    int len = 0;
    const AVCodec *codec = NULL;
    AVCodecContext *c = NULL;
    AVFormatContext *pFormatCtx = NULL;

    //file parameters
    FILE *f, *outfile;
    const char *outfilename, *filename;

    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];

    AVPacket avpkt;
    AVFrame *decoded_frame = NULL;

    if (argc <= 2) {
        fprintf(stderr, "Usage: %s <input file> <output file>\n", argv[0]);
        exit(0);
    }

    filename = argv[1];
    outfilename = argv[2];

    av_init_packet(&avpkt);
    decoded_frame = av_frame_alloc();
    if (!decodced_frame) {
        fprintf(stderr, "Could not allocate audio frame\n");
        exit(1);
    }

    /* open input file, and allocate format context */
    if ((err_code = avformat_open_input(&pFormatCtx, filename, NULL, NULL)) < 0) {
        av_strerror(err_code, errors, 1024);
        fprintf(stderr, "Could not open source file %s, %d(%s)\n", filename, err_code, errors);
        return -1;
    }

    //Retrieve stream information
    if (avformat_find_stream_info(pFormatCtx, NULL) < 0)
        return -1; // Couldn't find stream information

    //Dump information about file onto standard error
    av_dump_format(pFormatCtx, 0, filename, 0);

    //get index of audio stream
    for (i = 0; i < pFormatCtx->nb_streams; i++) {
        if (pFormatCtx->streams[i]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
            audiostream_index = i;
        }
    }

    c = avcodec_alloc_context3(NULL);
    if (!c) {
        fprintf(stderr, "Could not allocate audio codec context\n");
        exit(1);
    }

    ret = avcodec_parameters_to_context(c, pFormatCtx->streams[audiostream_index]->codecpar);
    if (ret < 0) {
        return -1;
    }

    codec = avcodec_find_decoder(c->codec_id);
    if (!codec) {
        fprintf(stderr, "Codec not found\n");
        exit(1);
    }

    //Out Audio Param
    uint64_t out_channel_layout = AV_CH_LAYOUT_STEREO;

    //AAC:1024  MP3:1152
    int out_nb_samples = c->frame_size;
    int out_sample_rate = 44100;
    int out_channels = av_get_channel_layout_nb_channels(out_channel_layout);

    //Out Buffer Size
    int out_buffer_size = av_samples_get_buffer_size(NULL,
                                                     out_channels,
                                                     out_nb_samples,
                                                     AV_SAMPLE_FMT_S16,
                                                     1);

    uint8_t *out_buffer = (uint8_t *) av_malloc(MAX_AUDIO_FRAME_SIZE * 2);
    int64_t in_channel_layout = av_get_default_channel_layout(c->channels);

    struct SwrContext *audio_convert_ctx;
    audio_convert_ctx = swr_alloc();
    audio_convert_ctx = swr_alloc_set_opts(audio_convert_ctx,
                                           out_channel_layout,
                                           AV_SAMPLE_FMT_S16,
                                           out_sample_rate,
                                           in_channel_layout,
                                           c->sample_fmt,
                                           c->sample_rate,
                                           0,
                                           NULL);
    swr_init(audio_convert_ctx);

    /* open it */
    if (avcodec_open2(c, codec, NULL) < 0) {
        fprintf(stderr, "Could not open codec\n");
        exit(1);
    }

    outfile = fopen(outfilename, "wb");
    if (!outfile) {
        av_free(c);
        exit(1);
    }

    while (1) {

        int ret;
        int i, ch;
        int got_frame = 0;

        ret = av_read_frame(pFormatCtx, &avpkt);
        if (ret == AVERROR(EAGAIN)) {
            av_usleep(100);
            continue;
        } else if (ret < 0) {
            break;
        }

        //如果不是音频则跳过
        if (avpkt.stream_index != audiostream_index) {
            av_packet_unref(&avpkt);
            continue;
        }

        len = avcodec_decode_audio2(c, decoded_frame, &got_frame, &avpkt);
        if (len < 0) {
            av_strerror(len, errors, 1024);
            fprintf(stderr, "Error while decoding, err_code:%d, err:%s\n", len, errors);
            exit(1);
        }
        if (got_frame) {
            /* if a frame has been decoded, output it */
            int data_size = av_get_bytes_per_sample(c->sample_fmt);
            if (data_size < 0) {
                /* This should not occur, checking just for paranoia */
                fprintf(stderr, "Failed to calculate data size\n");
                exit(1);
            }
            swr_convert(audio_convert_ctx,
                        &out_buffer,
                        MAX_AUDIO_FRAME_SIZE,
                        (const uint8_t **) decoded_frame->data,
                        decoded_frame->nb_samples);

            fwrite(out_buffer, 1, out_buffer_size, outfile);

        }
        avpkt.size -= len;
        avpkt.data += len;
        avpkt.dts = avpkt.pts = AV_NOPTS_VALUE;
    }

    fclose(outfile);

    avcodec_free_context(&c);
    av_frame_free(&decoded_frame);

    return 0;
}
  • 编译与运行：
clang -g -o 12_ff_decode_audio 12_ff_decode_audio.c `pkg-config --cflags --libs libavutil libavcodec libavformat libswresample`

// 执行编译后的结果：
./12_ff_decode_audio ./files/sample.mp4 ./files/decode.aac
5、为什么编码后的视频少了几帧数据？
思路：
在没有新的要编码的数据给编码器之后，在编码器的缓冲区中还有一些数据没有编码，需要将在编码器缓冲区中的数据强制编码器输出出来。
点拨：
应在编码之后再次调用avcodec_encode_video2方法，并将输入数据设置为NULL。如下所示：
ret = avcodec_encode_video2(c, &pkt, NULL, &got_output);
6、视频抽取图片
描述：
视频抽取图片时，指定了每秒抽取一张图片，那么这张图片是随机的一帧，还是优规律的呢？
思路：
要理解这个问题你要清楚视频帧排列的时间戳是多少？
点拨：
抽取图片时，会根据时间戳的变化抽取出第一张时间戳发生变化的图片。如果第2秒的第一帧的时间戳是1004毫秒，那么你取出的第二张图片的时间是1040毫秒。
xing.tang
关注
专栏目录
FFmpeg音频编解码处理详解
程序猿老樊的博客
02-29 1299
FFmpeg是一个非常强大的工具，它可以处理几乎所有类型的音频编解码任务。通过对FFmpeg的了解和实践，你可以轻松地转换音频格式、调整音质、添加效果以及执行更复杂的音频处理任务。在音频编解码的核心是对输入信号的精确理解和对输出需求的控制，而FFmpeg提供了这一切所需的工具和选项。
ffmpeg
qq_37003193的博客
06-08 1022
FFmpeg操作音视频 1、发展历史及它用来解决什么问题 FFmpeg项目最初是由Fabrice Bellard发起的，从2004年起由Michael Niedermayer领导进行维护。许多FFmpeg的开发者同时也是MPlayer项目的成员，FFmpeg在MPlayer项目中是被设计为服务器版本进行开发。 2011年3月13日，FFmpeg部分开发人员决定另组Libav，同时制定了一套关于项目...
笔记：FFMPEG 中的几个不同的 time_base
zxw_tiantan的博客
03-16 1219
1、AVCodecContext 中的 time_base 2、AVStream 中的 time_base 3、AVCodecContext 中的 pkt_timebase 具体含义待解。 经验之谈： 一、第 2 个和第 3 个time_base值相同，与第 1 个 time_base 值不相同。 二、应用FFMPEG进行编码、解码过程中，如果要获取正确的PTS，应使用
ffplay 拉流报错Could not find codec parameters for stream 0 (Video: h264, none): unspecified size
最新发布
mynaiskey的博客
08-16 248
从上面看出是stream0即video有问题，就是服务器端的video发的有问题。有可能只发了音频数据，而没发视频数据。音视频拉流时，客户端输入。
使用FFmpeg库实现视频编码
RunningZyx的博客
09-08 861
1.FFmpeg进行视频编解码所需要的结构 .AVCodec :AVCodec结构保存了一个编解码器的实例，实现实际的编码功能。通常我们在程序中定义一个指向AVCodec                  结构的指针指向该实例。 .AVCodecContext :AVCodecContext表示AVCodec所代表的上下文信息，保存了AVCodec所需要的一些参数。对于实现
ffmpeg 时基timebase、时间戳pts/dts、延时控制delay
热爱生活，忠于自己
04-24 6042
ffmpeg中在不同是层（封装、编解码、数据）的采样率不同，为精确描述该其数值，使用结构AVRational来描述时基这一概念。一个时间戳在不同的时基下进行变化，获取精确延时(av_usleep函数)。
ffmpeg解码
qq_52484093的博客
04-19 1402
avcodec_send_packet avcodec_receive_frame H264 帧分割 ffmpeg -i v1080.mp4 -s 400x300 test.h264 我们使用这个命令生成一个编码后的 h264 文件。 基于 ffmpeg 接口完成视频解码 117_test_decode.cpp #include <iostream> #include <fstream> using namespace std...
ffmpeg硬解码-jetson平台
05-14
FFmpeg是一款强大的开源多媒体处理工具，它包含了音视频编码、解码、转码、封装、解封、过滤等多种功能。在Jetson平台上进行硬解码是利用设备的硬件加速能力来处理视频解码任务，以降低CPU的负载并提高效率。Jetson...
Qt 5+ffmpeg5.1.4实现视频播放器，含ffmpeg视频编解码源码(本地文件、http、rtsp)、项目源码+注释
05-12
FFmpeg是一个开源的多媒体框架，包含了一系列用于处理音频和视频的库，如libavcodec（编解码库）、libavformat（容器格式解析库）和libavfilter（滤镜库）。在这个项目中，FFmpeg的核心作用是进行视频和音频的编解码...
ffmpeg-适配英伟达Jetson的ffmpeg流媒体编解码库-附项目源码+编译流程教程-优质项目实战.zip
06-07
FFmpeg是一款强大的开源多媒体处理工具，它包含了音视频编解码、封装、转换、流媒体等功能，被广泛应用于各种多媒体应用开发中。本项目专为英伟达Jetson系列嵌入式平台进行了优化，旨在提供高效能的流媒体编解码能力...
ffmpeg编解码，解封装封装
09-11
FFmpeg是一款强大的开源工具，主要用于音频和视频的处理，包括编解码、解封装和过滤等操作。在本文中，我们将深入探讨FFmpeg的核心概念及其在实际应用中的使用。 首先，我们要理解“编解码”这个术语。编解码是指将...
ffmpeg打开视频解码器失败：Could not find codec parameters for stream 0 (Video: h264): unspecified size...
热门推荐
weixin_34187822的博客
08-07 2万+
在使用ffmpeg进行拉流分离音视频数据再解码播放操作的时候； 有时候经常会报错： Could not find codec parameters for stream 0 (Video: h264): unspecified size ffmpeg默认使用udp方式传输，在使用：avformat_find_stream_info 会出现返回 codec_id ==AV_CODEC_ID_N...
ffmpeg视频编码AV_CODEC_ID_H264 Codec not find解决方法
lanlanlan12345的专栏
03-22 1万+
基于Cygwin平台，在Eclipse上建立C project，使用FFmpeg开源库进行视频编解码工作。可以将H.264编码格式的视频解码成YUV数据。但是对YUV数据编码为H.264时遇到了问题，使用FFmpeg提供的示例程序，报错AV_CODEC_ID_H264 Codec notfound. 使用avcodec_find_encoder(AV_CODEC_ID_H264)测试，返回结果总是
ffmpeg Encoder (codec mp3) not found for output stream #0:0
weixin_35755823的博客
01-24 488
这个错误信息表示在使用 ffmpeg 进行转码时，没有找到可用的 mp3 编码器。这可能是因为 ffmpeg 没有被正确配置或者没有包含 mp3 编码器。可以尝试重新安装 ffmpeg，确保包含 mp3 编码器或者在编译 ffmpeg 时启用 mp3 编码器的选项。 ...
Could not find codec parameters for stream 0 (Video: h264, none)
牛肉胡辣汤
11-04 2911
当遇到错误信息 "Could not find codec parameters for stream 0 (Video: h264, none)"时，我们应该先检查播放器或视频处理工具的版本，并确保安装了相应的解码器。如果问题仍然存在，可以考虑视频文件是否损坏，并尝试转码视频格式。在解决该问题时，理解错误的原因和适当的解决方法是非常重要的。
FFmpeg 解码 avcodec_find_decoder AVCodecContext
u010141160的博客
08-10 7618
avcodec_find_decoder （1）解码模块第一步：获取解码器 avcodec_find_decoder（）FFmpeg的解码器编码器都存在avcodec的结构体中 (2) 解码前保证用到的解码器已经注册好 avcodec_register_all();(过期) （3）通过解封装之后，从avstream里面获取CodecID ，通过CodecID来查找decoder AVC...
ffmpeg 报错Encoder (codec h264) not found for output stream #0:0
weixin_43680337的博客
03-26 5874
使用ffmpeg 制作流媒体的视频文件,同样的命令在本地的windows环境是正常的，在linux 上就不行了。 报错了 根据最后一行的提示， Encoder (codec h264) not found for output stream #0:0 大概可以确定是缺少了h264编码器 。 本地window是下载编译好的ffmpeg 直接使用的，但是linux是自己编译的，肯定是配置不一致导致的。我在linux 使用的的版本是 windows 使用的版本和配置是 所以现在的关键
rtsp ffmpeg获取码流
lx0307的博客
09-07 1550
avformat_find_stream_info： [rtsp @ 00802280] Could not find codec parameters for stream 0 (Video: h264, none): unspecified size Consider increasing the value for the ‘analyzeduration’ (0) and ‘probesize’ (5000000) options 解决方案： AVDictionary* avdic = NULL;
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值