ffmpg example学习一

最新推荐文章于 2024-04-24 18:34:14 发布
最新推荐文章于 2024-04-24 18:34:14 发布
阅读量794 收藏 1
点赞数 1
CC 4.0 BY-SA版权
分类专栏： ffmpeg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/Jianchi0001/article/details/118049492

计划根据ffmpeg的example学习ffmpeg，编译方法是：先编译ffmpeg的代码，然后使用命令make example编译提供的example文件，在/doc/example下面就可以看到编译后的执行文件。 ffmpeg的版本为：ffmpeg version N-102034-gc8197f73e6
本篇学习encode_video.c

AVCodec

const AVCodec *codec;
codec = avcodec_find_encoder_by_name(codec_name);

avcodec_find_encoder_by_name函数的实现在libavcodec/allcodecs.c中

AVCodec *avcodec_find_encoder_by_name(const char *name)
{
    return find_codec_by_name(name, av_codec_is_encoder);
}

static AVCodec *find_codec_by_name(const char *name, int (*x)(const AVCodec *))
{
    void *i = 0;
    const AVCodec *p;
    if (!name)
        return NULL;

    while ((p = av_codec_iterate(&i))) {
        if (!x(p))
            continue;
        if (strcmp(name, p->name) == 0)
            return (AVCodec*)p;
    }

    return NULL;
}

可以看出通过av_codec_iterate函数逐一对比当前支持的codec name和传入的codec name

const AVCodec *av_codec_iterate(void **opaque)
{
    uintptr_t i = (uintptr_t)*opaque;
    const AVCodec *c = codec_list[i];

    ff_thread_once(&av_codec_static_init, av_codec_init_static);

    if (c)
        *opaque = (void*)(i + 1);

    return c;
}

关键的语句是ff_thread_once(&av_codec_static_init, av_codec_init_static);线程启动时只创建一次，即只调用一次av_codec_init_static来初始化可支持codec

static void av_codec_init_static(void)
{
    for (int i = 0; codec_list[i]; i++) {
        if (codec_list[i]->init_static_data)
            codec_list[i]->init_static_data((AVCodec*)codec_list[i]);
    }
}

支持的codec存在codec_list数组里。libavcodec/allcodecs.c文件中通过下面导入了可支持的codec列表
#include “libavcodec/codec_list.c”
例如h263的定义：

AVCodec ff_h263_encoder = {
    .name           = "h263",
    .long_name      = NULL_IF_CONFIG_SMALL("H.263 / H.263-1996"),
    .type           = AVMEDIA_TYPE_VIDEO,
    .id             = AV_CODEC_ID_H263,
    .priv_data_size = sizeof(MpegEncContext),
    .init           = ff_mpv_encode_init,
    .encode2        = ff_mpv_encode_picture,
    .close          = ff_mpv_encode_end,
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP,
    .pix_fmts= (const enum AVPixelFormat[]){AV_PIX_FMT_YUV420P, AV_PIX_FMT_NONE},
    .priv_class     = &h263_class,
};

AVCodecContext

AVCodecContext，存储该视频/音频流使用解码方式的相关数据；每个AVCodecContext中对应一个AVCodec，包含该视频/音频对应的解码器。

前面确定了编码器，然后通过avcodec_alloc_context3创建AVCodecContext对象，并设置一系列参数

 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;

然后使用确定的AVCodec 打开AVCodecContext对象，比较重要的两件事一是创建了一个AVCodecInternal对象，一个是init AVCodec
ret = avcodec_open2(c, codec, NULL);

int attribute_align_arg avcodec_open2(AVCodecContext *avctx, const AVCodec *codec, AVDictionary **options)
{
    int ret = 0;
    int codec_init_ok = 0;
    AVDictionary *tmp = NULL;
    AVCodecInternal *avci;

    if (avcodec_is_open(avctx))
        return 0;
//判断创建AVCodecContext时传入的AVCodec和当前传入的AVCodec参数如果存在的话，是相同的
    if (!codec && !avctx->codec) {
        av_log(avctx, AV_LOG_ERROR, "No codec provided to avcodec_open2()\n");
        return AVERROR(EINVAL);
    }
    if (codec && avctx->codec && codec != avctx->codec) {
        av_log(avctx, AV_LOG_ERROR, "This AVCodecContext was allocated for %s, "
                                    "but %s passed to avcodec_open2()\n", avctx->codec->name, codec->name);
        return AVERROR(EINVAL);
    }
   //如果当前参数为null，则使用创建AVCodecContext时传入的AVCodec
    if (!codec)
        codec = avctx->codec;

    if ((avctx->codec_type == AVMEDIA_TYPE_UNKNOWN || avctx->codec_type == codec->type) &&
        avctx->codec_id == AV_CODEC_ID_NONE) {
        avctx->codec_type = codec->type;
        avctx->codec_id   = codec->id;
    }
    if (avctx->codec_id != codec->id || (avctx->codec_type != codec->type &&
                                         avctx->codec_type != AVMEDIA_TYPE_ATTACHMENT)) {
        av_log(avctx, AV_LOG_ERROR, "Codec type or id mismatches\n");
        return AVERROR(EINVAL);
    }
    avctx->codec = codec;

    if (avctx->extradata_size < 0 || avctx->extradata_size >= FF_MAX_EXTRADATA_SIZE)
        return AVERROR(EINVAL);

    if (options)
        av_dict_copy(&tmp, *options, 0);
//使用ff_mutex_unlock加锁
    lock_avcodec(codec);
//下面代码创建和初始化AVCodecInternal对象
    avci = av_mallocz(sizeof(*avci));
    if (!avci) {
        ret = AVERROR(ENOMEM);
        goto end;
    }
    avctx->internal = avci;

#if FF_API_OLD_ENCDEC
    avci->to_free = av_frame_alloc();
    avci->compat_decode_frame = av_frame_alloc();
    avci->compat_encode_packet = av_packet_alloc();
    if (!avci->to_free || !avci->compat_decode_frame || !avci->compat_encode_packet) {
        ret = AVERROR(ENOMEM);
        goto free_and_end;
    }
#endif
    avci->buffer_frame = av_frame_alloc();
    avci->buffer_pkt = av_packet_alloc();
    avci->es.in_frame = av_frame_alloc();
    avci->ds.in_pkt = av_packet_alloc();
    avci->last_pkt_props = av_packet_alloc();
    avci->pkt_props = av_fifo_alloc(sizeof(*avci->last_pkt_props));
    if (!avci->buffer_frame || !avci->buffer_pkt          ||
        !avci->es.in_frame  || !avci->ds.in_pkt           ||
        !avci->last_pkt_props || !avci->pkt_props) {
        ret = AVERROR(ENOMEM);
        goto free_and_end;
    }

    avci->skip_samples_multiplier = 1;
//下面又是对一些参数判断，check是否valid
    if (codec->priv_data_size > 0) {
        if (!avctx->priv_data) {
            avctx->priv_data = av_mallocz(codec->priv_data_size);
            if (!avctx->priv_data) {
                ret = AVERROR(ENOMEM);
                goto free_and_end;
            }
            if (codec->priv_class) {
                *(const AVClass **)avctx->priv_data = codec->priv_class;
                av_opt_set_defaults(avctx->priv_data);
            }
        }
        if (codec->priv_class && (ret = av_opt_set_dict(avctx->priv_data, &tmp)) < 0)
            goto free_and_end;
    } else {
        avctx->priv_data = NULL;
    }
    if ((ret = av_opt_set_dict(avctx, &tmp)) < 0)
        goto free_and_end;

    if (avctx->codec_whitelist && av_match_list(codec->name, avctx->codec_whitelist, ',') <= 0) {
        av_log(avctx, AV_LOG_ERROR, "Codec (%s) not on whitelist \'%s\'\n", codec->name, avctx->codec_whitelist);
        ret = AVERROR(EINVAL);
        goto free_and_end;
    }

    // only call ff_set_dimensions() for non H.264/VP6F/DXV codecs so as not to overwrite previously setup dimensions
    if (!(avctx->coded_width && avctx->coded_height && avctx->width && avctx->height &&
          (avctx->codec_id == AV_CODEC_ID_H264 || avctx->codec_id == AV_CODEC_ID_VP6F || avctx->codec_id == AV_CODEC_ID_DXV))) {
        if (avctx->coded_width && avctx->coded_height)
            ret = ff_set_dimensions(avctx, avctx->coded_width, avctx->coded_height);
        else if (avctx->width && avctx->height)
            ret = ff_set_dimensions(avctx, avctx->width, avctx->height);
        if (ret < 0)
            goto free_and_end;
    }

    if ((avctx->coded_width || avctx->coded_height || avctx->width || avctx->height)
        && (  av_image_check_size2(avctx->coded_width, avctx->coded_height, avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0
           || av_image_check_size2(avctx->width,       avctx->height,       avctx->max_pixels, AV_PIX_FMT_NONE, 0, avctx) < 0)) {
        av_log(avctx, AV_LOG_WARNING, "Ignoring invalid width/height values\n");
        ff_set_dimensions(avctx, 0, 0);
    }

    if (avctx->width > 0 && avctx->height > 0) {
        if (av_image_check_sar(avctx->width, avctx->height,
                               avctx->sample_aspect_ratio) < 0) {
            av_log(avctx, AV_LOG_WARNING, "ignoring invalid SAR: %u/%u\n",
                   avctx->sample_aspect_ratio.num,
                   avctx->sample_aspect_ratio.den);
            avctx->sample_aspect_ratio = (AVRational){ 0, 1 };
        }
    }

    if (avctx->channels > FF_SANE_NB_CHANNELS || avctx->channels < 0) {
        av_log(avctx, AV_LOG_ERROR, "Too many or invalid channels: %d\n", avctx->channels);
        ret = AVERROR(EINVAL);
        goto free_and_end;
    }

    if (avctx->sample_rate < 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid sample rate: %d\n", avctx->sample_rate);
        ret = AVERROR(EINVAL);
        goto free_and_end;
    }
    if (avctx->block_align < 0) {
        av_log(avctx, AV_LOG_ERROR, "Invalid block align: %d\n", avctx->block_align);
        ret = AVERROR(EINVAL);
        goto free_and_end;
    }

    avctx->frame_number = 0;
    avctx->codec_descriptor = avcodec_descriptor_get(avctx->codec_id);

    if ((avctx->codec->capabilities & AV_CODEC_CAP_EXPERIMENTAL) &&
        avctx->strict_std_compliance > FF_COMPLIANCE_EXPERIMENTAL) {
        const char *codec_string = av_codec_is_encoder(codec) ? "encoder" : "decoder";
        const AVCodec *codec2;
        av_log(avctx, AV_LOG_ERROR,
               "The %s '%s' is experimental but experimental codecs are not enabled, "
               "add '-strict %d' if you want to use it.\n",
               codec_string, codec->name, FF_COMPLIANCE_EXPERIMENTAL);
        codec2 = av_codec_is_encoder(codec) ? avcodec_find_encoder(codec->id) : avcodec_find_decoder(codec->id);
        if (!(codec2->capabilities & AV_CODEC_CAP_EXPERIMENTAL))
            av_log(avctx, AV_LOG_ERROR, "Alternatively use the non experimental %s '%s'.\n",
                codec_string, codec2->name);
        ret = AVERROR_EXPERIMENTAL;
        goto free_and_end;
    }

    if (avctx->codec_type == AVMEDIA_TYPE_AUDIO &&
        (!avctx->time_base.num || !avctx->time_base.den)) {
        avctx->time_base.num = 1;
        avctx->time_base.den = avctx->sample_rate;
    }

    if (av_codec_is_encoder(avctx->codec))
        ret = ff_encode_preinit(avctx);
    else
        ret = ff_decode_preinit(avctx);
    if (ret < 0)
        goto free_and_end;

    if (!HAVE_THREADS)
        av_log(avctx, AV_LOG_WARNING, "Warning: not compiled with thread support, using thread emulation\n");

    if (CONFIG_FRAME_THREAD_ENCODER && av_codec_is_encoder(avctx->codec)) {
        unlock_avcodec(codec); //we will instantiate a few encoders thus kick the counter to prevent false detection of a problem
        ret = ff_frame_thread_encoder_init(avctx, options ? *options : NULL);
        lock_avcodec(codec);
        if (ret < 0)
            goto free_and_end;
    }

    if (HAVE_THREADS
        && !(avci->frame_thread_encoder && (avctx->active_thread_type&FF_THREAD_FRAME))) {
        ret = ff_thread_init(avctx);
        if (ret < 0) {
            goto free_and_end;
        }
    }
    if (!HAVE_THREADS && !(codec->caps_internal & FF_CODEC_CAP_AUTO_THREADS))
        avctx->thread_count = 1;
//
    if (   avctx->codec->init && (!(avctx->active_thread_type&FF_THREAD_FRAME)
        || avci->frame_thread_encoder)) {
        ret = avctx->codec->init(avctx);
        if (ret < 0) {
            codec_init_ok = -1;
            goto free_and_end;
        }
        codec_init_ok = 1;
    }

    ret=0;

    if (av_codec_is_decoder(avctx->codec)) {
        if (!avctx->bit_rate)
            avctx->bit_rate = get_bit_rate(avctx);
        /* validate channel layout from the decoder */
        if (avctx->channel_layout) {
            int channels = av_get_channel_layout_nb_channels(avctx->channel_layout);
            if (!avctx->channels)
                avctx->channels = channels;
            else if (channels != avctx->channels) {
                char buf[512];
                av_get_channel_layout_string(buf, sizeof(buf), -1, avctx->channel_layout);
                av_log(avctx, AV_LOG_WARNING,
                       "Channel layout '%s' with %d channels does not match specified number of channels %d: "
                       "ignoring specified channel layout\n",
                       buf, channels, avctx->channels);
                avctx->channel_layout = 0;
            }
        }
        if (avctx->channels && avctx->channels < 0 ||
            avctx->channels > FF_SANE_NB_CHANNELS) {
            ret = AVERROR(EINVAL);
            goto free_and_end;
        }
        if (avctx->bits_per_coded_sample < 0) {
            ret = AVERROR(EINVAL);
            goto free_and_end;
        }

#if FF_API_AVCTX_TIMEBASE
        if (avctx->framerate.num > 0 && avctx->framerate.den > 0)
            avctx->time_base = av_inv_q(av_mul_q(avctx->framerate, (AVRational){avctx->ticks_per_frame, 1}));
#endif
    }
    if (codec->priv_data_size > 0 && avctx->priv_data && codec->priv_class) {
        av_assert0(*(const AVClass **)avctx->priv_data == codec->priv_class);
    }

end:
    unlock_avcodec(codec);
    if (options) {
        av_dict_free(options);
        *options = tmp;
    }

    return ret;
free_and_end:
    if (avctx->codec && avctx->codec->close &&
        (codec_init_ok > 0 || (codec_init_ok < 0 &&
         avctx->codec->caps_internal & FF_CODEC_CAP_INIT_CLEANUP)))
        avctx->codec->close(avctx);

    if (HAVE_THREADS && avci->thread_ctx)
        ff_thread_free(avctx);

    if (codec->priv_class && avctx->priv_data)
        av_opt_free(avctx->priv_data);
    av_opt_free(avctx);

    if (av_codec_is_encoder(avctx->codec)) {
#if FF_API_CODED_FRAME
FF_DISABLE_DEPRECATION_WARNINGS
        av_frame_free(&avctx->coded_frame);
FF_ENABLE_DEPRECATION_WARNINGS
#endif
        av_freep(&avctx->extradata);
        avctx->extradata_size = 0;
    }

    av_dict_free(&tmp);
    av_freep(&avctx->priv_data);
    if (av_codec_is_decoder(avctx->codec))
        av_freep(&avctx->subtitle_header);

#if FF_API_OLD_ENCDEC
    av_frame_free(&avci->to_free);
    av_frame_free(&avci->compat_decode_frame);
    av_packet_free(&avci->compat_encode_packet);
#endif
    av_frame_free(&avci->buffer_frame);
    av_packet_free(&avci->buffer_pkt);
    av_packet_free(&avci->last_pkt_props);
    av_fifo_freep(&avci->pkt_props);

    av_packet_free(&avci->ds.in_pkt);
    av_frame_free(&avci->es.in_frame);
    av_bsf_free(&avci->bsf);

    av_buffer_unref(&avci->pool);
    av_freep(&avci);
    avctx->internal = NULL;
    avctx->codec = NULL;
    goto end;
}

测试使用的是libx264，看ff_libx264_encoder的定义，实现函数为X264_init

AVCodec ff_libx264_encoder = {
    .name             = "libx264",
    .long_name        = NULL_IF_CONFIG_SMALL("libx264 H.264 / AVC / MPEG-4 AVC / MPEG-4 part 10"),
    .type             = AVMEDIA_TYPE_VIDEO,
    .id               = AV_CODEC_ID_H264,
    .priv_data_size   = sizeof(X264Context),
    .init             = X264_init,
    .encode2          = X264_frame,
    .close            = X264_close,
    .capabilities     = AV_CODEC_CAP_DELAY | AV_CODEC_CAP_OTHER_THREADS |
                        AV_CODEC_CAP_ENCODER_REORDERED_OPAQUE,
    .caps_internal    = FF_CODEC_CAP_AUTO_THREADS,
    .priv_class       = &x264_class,
    .defaults         = x264_defaults,
#if X264_BUILD < 153
    .init_static_data = X264_init_static,
#else
    .pix_fmts         = pix_fmts_all,
#endif
    .caps_internal  = FF_CODEC_CAP_INIT_CLEANUP | FF_CODEC_CAP_AUTO_THREADS
#if X264_BUILD >= 158
                      | FF_CODEC_CAP_INIT_THREADSAFE
#endif
                      ,
    .wrapper_name     = "libx264",
};

AVPacket

通过 av_packet_alloc方法创建AVPacket对象，存储编码后的数据，然后通过av_packet_free方法释放。如果是视频流，则包含一帧数据，如果是音频流，则可能包含几帧数据

AVPacket *av_packet_alloc(void)
{
    AVPacket *pkt = av_mallocz(sizeof(AVPacket));
    if (!pkt)
        return pkt;

    get_packet_defaults(pkt);

    return pkt;
}

AVFrame

通过av_frame_alloc方法创建AVFrame对象，存储未编码的数据，即raw数据

AVFrame一般是allocated一次，然后通过av_frame_unref()释放数据并恢复到原始状态，从而可以多次使用。数据存在AVFrame.buf / AVFrame.extended_buf中

	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;
	//分配buffer，来存储audio/video数据，注意第二次参数表示读取数据时字节按多少对齐，例如设置为32，则一行的字节数不是32的倍数的话，会填充成32的倍数，造成花屏现象
    ret = av_frame_get_buffer(frame, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate the video frame data\n");
        exit(1);
    }

encode

 /* encode 1 second of video */
 //encode 25帧数据，即1s
    for (i = 0; i < 25; i++) {
        fflush(stdout);

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

		//将要编码的数据分别放到frame->data[]里
        /* 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 */
        encode(c, frame, pkt, f);
    }

static void encode(AVCodecContext *enc_ctx, AVFrame *frame, AVPacket *pkt,
                   FILE *outfile)
{
    int ret;

    /* send the frame to the encoder */
    if (frame)
        printf("Send frame %3"PRId64"\n", frame->pts);
	//将要编码的当前帧数据发送到codec里
    ret = avcodec_send_frame(enc_ctx, frame);
    if (ret < 0) {
        fprintf(stderr, "Error sending a frame for encoding\n");
        exit(1);
    }

    while (ret >= 0) {
    	//接收编码后的数据，AVPacket对象
        ret = avcodec_receive_packet(enc_ctx, pkt);
        if (ret == AVERROR(EAGAIN) || ret == AVERROR_EOF)
            return;
        else if (ret < 0) {
            fprintf(stderr, "Error during encoding\n");
            exit(1);
        }

        printf("Write packet %3"PRId64" (size=%5d)\n", pkt->pts, pkt->size);
        //将编码后的数据直接写入文件
        fwrite(pkt->data, 1, pkt->size, outfile);
        //AVPacket对象要重复使用，所以要先unref
        av_packet_unref(pkt);
    }
}

encode的函数调用流程图：
在这里插入图片描述

end

	//发送null的时候，表示要flush
  /* flush the encoder */
    encode(c, NULL, pkt, f);

    /* add sequence end code to have a real MPEG file */
    if (codec->id == AV_CODEC_ID_MPEG1VIDEO || codec->id == AV_CODEC_ID_MPEG2VIDEO)
        fwrite(endcode, 1, sizeof(endcode), f);
    fclose(f);

	//最后要将对象给free
    avcodec_free_context(&c);
    av_frame_free(&frame);
    av_packet_free(&pkt);
FFMpeg Example实例合集
fdsafwagdagadg6576的专栏
02-14 847
examples/scaling_video.cffmpeg学习十三：图像数据格式的转换与图像的缩放_阳光玻璃杯-优快云博客
FFmpeg版Helloworld（Android平台）
分享音视频技术
05-21 907
对于程序员来说，学习一门新技术的第一个demo，一般都是helloworld；因此本文主要是阐述基于ffmpeg开发的第一个demo，基于Android平台的。
FFMPEG之example编译
yefei123123的博客
10-23 589
按照提示添加 --disable-x86asm 选项，然后通过--prefix指定安装路径(建议使用绝对路径)，并指定编译生成动态库。./configure --disable-x86asm --prefix=路径 --enable-shared。直接make && make install，等待完成。--prefix=安装路径。依赖的动态库没有加载，用ldd查看所有依赖的库。进入examples目录 make会报错。
FFMpeg中的实例output_example.c的编译
点滴点点滴滴
01-18 3713
                 FFMpeg中的实例output_example.c的编译关于ffmpeg在windows上的编译，在www.ffmpeg.com.cn上有详细的讲解，在成功编译好ffmpeg后，便在MSVC中编译ffmpeg自带的实例output_example.c。首先自己在MSVC下建立一个空的控制台的应用程序，将output_example.c加入到工程中。由于在
ffmpeg examples
06-12
官方ffmpeg 3.02 下的 examples代码
vs2005环境下CELayoutEditor源码编译详细步骤
weixin_30906425的博客
11-17 249
vs2005环境下CELayoutEditor源码编译详细步骤 今天初试了一下CEGUI的官方编辑器——CELayoutEditor，其过程真可谓“饱受挫折”。现简要写下其源码的编译过程，已使可能会用到的朋友少走些弯路 1.要编译CELayoutEditor，自然需要先编译CEGUI的东东，有2种选择： ...
OSG中的示例程序简介
动感程序
05-21 3712
<br />1.example_osganimate<br />一）演示了路径动画的使用（AnimationPath、AnimationPathCallback），路径动画回调可以作用在Camera、CameraView、MatrixTransform、PositionAttitudeTransform等四种类型的节点上。<br />二）演示了osgSim::OverlayNode的使用<br /><br />2.example_osganimationeasemotion<br />一）演示了osgAni
FFMPEG Example
douzi949389的博客
02-20 1644
#include &lt;stdio.h&gt; #include &lt;string.h&gt; extern "C" { #include "libavformat/avformat.h" #include "libavutil/dict.h" }; #pragma comment(lib, "avformat.lib") #pragma comm
ffmpeg c++ examples 理解
长虹剑的专栏
12-14 3375
前言 ffmpeg 编译需要装很多三方库，还要配置 测试使用时大致过程如下 Dffmpeg="xxx/bin/ffmpeg" inp_ffmpeg="$Dffmpeg/include/" lib_ffmpeg="$Dffmpeg/lib/" lib_mp3="xxx/libmp3lame/lib" # 其实我把h264也放这里了 g++ -std=c++11 -I $inp_ffmpeg src/$NM.cpp -L $lib_ffmpeg -L $lib_mp3 -lavdevice -lavfilter
FFmpeg常用实例详解
最新发布
marsjin的专栏
04-24 1468
vf "scale=1920:1080:force_original_aspect_ratio=decrease,pad=1920:1080:(ow-iw)/2:(oh-ih)/2:black"：使用视频滤镜进行处理，将视频缩放为 1920x1080 的尺寸，并且保持原始宽高比缩小，同时进行填充，填充的颜色为黑色。视频的分辨率也会影响文件的大小，可以使用 -s 选项指定输出文件的分辨率。在某些情况下，比特率的适当缩减对视频的观看效果并不会产生太大的影响（人眼察觉的范围内）。
FFmpeg example
09-01
vc2008编译成功的ffmpeg库及测试工程.zip FFmpeg
FFmpeg SDK开发手册(以output_example为示例)
北雨南萍
11-13 2610
FFmpeg 中比较重要的函数以及数据结构如下： 1. 数据结构： (1) AVFormatContext (2) AVOutputFormat (3) AVInputFormat (4) AVCodecContext (5) AVCodec (6) AVFrame (7) AVPacket (8) AVPicture (9) AVStream 2. 初始化函数：
mac上编译ffmpeg并跑examples
老中医的博客
02-09 610
编译出来的执行文件在mac_build的bin目录下，若要基于ffmpeg的api开发，则include和lib目录就是所需要的了。而原来的doc/examples中的例子都。要运行ffmpeg的examples，首先编译安装ffmpeg各库，然后再编译运行其examples，在上面的。以上就是基于ffmpeg release/5.1分支编译运行，并跑examples的步骤。至此，examples编译完成，可以跑examples了。下载ffmpeg源码，并切换到分支。
ffmpeg概述 及 examples/transcoding.c源码阅读
z2625349336的博客
10-15 979
1、ffmpeg命令行工具 ffmpeg编译完后，主要包括三个工具，ffmpeg，ffplay，ffprobe ffmpeg 非常强大的音视频转换工具，可以用来对音视频进行解码、滤波、叠加等操作，流程主要包括解码、滤波、编码三个步骤， 对应源码中的fftools/ffmpeg.c文件 ffplay 在mac或windows播放音视频， 对应源码中的fftools/ffplay.c文件 ffprobe ffprobe从多媒体流中收集信息，并以人类和机器可读的方式进行打印
ffmpeg example演示教程 -VideoDecode
lyy901135的博客
07-09 2811
FFMPEG Example-01 decode_video.c 本人刚开始学习ffmpeg，写此博客作为笔记，也希望能帮助其他刚入门的童鞋！ffmpeg源码下载和编译本文就直接跳过，源码doc/example路径下有很多demo，可以为我们演示ffmpeg的api如何使用，对我们理解ffmpeg的api有很大帮助。本文将介绍decode_video.c如何编译使用。 代码主体框架： 1、根据Co...
ffmpeg example decode_video 升级方案
itisyang
07-03 535
以 MPEG-1 为例的视频解码例子，不含封装，只解析裸流 流程： 视频数据包初始化，av_packet_alloc 查找 MPEG-1 解码器， avcodec_find_decoder 数据解析器初始化，av_parser_init 解码结构初始化，avcodec_alloc_context3 打开解码器，avcodec_open2 打开视频文件，fopen 解码视频帧初始化，av_frame_alloc 循环 读文件，fread 解析数据包，av_parser_pars
FFmpeg-examples-transcode_aac
回头太难
07-31 1310
源码来源于官网FFmpeg-example：https://github.com/FFmpeg/FFmpeg/blob/master/doc/examples/transcoding.c 该example官网例子还使用avcodec_encode_audio4 API，以下使用了新的API avcodec_send_packet/avcodec_receive_frame等 Version:F
单个编译ffmpeg/doc/examples下测试
qq_22655153的博客
02-12 2211
Makefile.example内容如下 # use pkg-config for getting CFLAGS and LDLIBS FFMPEG_LIBS= libavdevice \ libavformat \ libavfilter \ libavcodec
ffmpeg使用语法
在水一方
11-23 808
ffmpeg [[options][`-i input_file]]... {[options] output_file}...如果没有输入文件，那么视音频捕捉就会起作用。作为通用的规则，选项一般用于下一个特定的文件。如果你给 –b 64选项，改选会设置下一个视频速率。对于原始输入文件，格式选项可能是需要的。缺省情况下，ffmpeg试图尽可能的无损转换，采用与输入同样的音
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值