Decoding_Encoding例程（ffmpeg编解码）

最新推荐文章于 2022-08-15 19:42:09 发布
最新推荐文章于 2022-08-15 19:42:09 发布
阅读量758 收藏
点赞数
文章标签： FFmpeg
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/lldbuaa/article/details/79982543
版权

*有人会好奇说例程你放出来有什么用，我要说的是，如果例程你直接能跑通，那么浏览器右上角有个×，点一下就好了
**这也是我感觉不爽的地方，例程居然一堆错误……
要是环境配置有错误也就罢了，毕竟那是自己的事情；要是版本升级导致的错误也就罢了，最多就是疏于维护；但是出现abc级的错误就很难让我理解了……
*这篇只是把我调好的代码发上来，对报错的地方有些注释，如果有人看到了，手痒打算跑跑例程，可以参考
**环境配置参考前面的日志，这里略去不提
*具体的流程分析估计要放到后面的一篇里面了 那篇就见不到全部的代码了
下面是代码 

#include "stdafx.h"//要放到第一位
#include <math.h>
extern "C" //LNK2019
{
#include <libavutil/opt.h>
#include <libavcodec/avcodec.h>
#include <libavutil/channel_layout.h>
#include <libavutil/common.h>
#include <libavutil/imgutils.h>
#include <libavutil/mathematics.h>
#include <libavutil/samplefmt.h>
}
#define INBUF_SIZE 4096
#define AUDIO_INBUF_SIZE 20480
#define AUDIO_REFILL_THRESH 4096
//安全报错，填写下面一行代码
#pragma warning( disable : 4996)
//尝试通过添加lib来解决LNK1107错误  取消附加依赖项内部所有dll
#pragma comment(lib , "avcodec.lib")
#pragma comment(lib , "avdevice.lib")
#pragma comment(lib , "avfilter.lib")
#pragma comment(lib , "avformat.lib")
#pragma comment(lib , "avutil.lib")
#pragma comment(lib , "postproc.lib")
#pragma comment(lib , "swresample.lib")
#pragma comment(lib , "swscale.lib")

/* check that a given sample format is supported by the encoder */
static int check_sample_fmt(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(AVCodec *codec)
{
    const int *p;
    int best_samplerate = 0;

    if (!codec->supported_samplerates)
        return 44100;

    p = codec->supported_samplerates;
    while (*p) {
        best_samplerate = FFMAX(*p, best_samplerate);
        p++;
    }
    return best_samplerate;
}

/* select layout with the highest channel count */
static int select_channel_layout(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;
}

/* Audio encoding example*/
static void audio_encode_example(const char *filename)
{
    AVCodec *codec;
    AVCodecContext *c = NULL;
    AVFrame *frame;
    AVPacket pkt;
    int i, j, k, ret, got_output;
    int buffer_size;
    FILE *f;
    uint16_t *samples;
    float t, tincr;

    printf("Encode audio file %s\n", filename);

    /* 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;

    /* the codec gives us the frame size, in samples,
    * we calculate the size of the samples buffer in bytes */
    buffer_size = av_samples_get_buffer_size(NULL, c->channels, c->frame_size,
        c->sample_fmt, 0);
    if (buffer_size < 0) {
        fprintf(stderr, "Could not get sample buffer size\n");
        exit(1);
    }
    //此处报错，用强制转换
    samples =(uint16_t *)av_malloc(buffer_size);
    if (!samples) {
        fprintf(stderr, "Could not allocate %d bytes for samples buffer\n",
            buffer_size);
        exit(1);
    }
    /* setup the data pointers in the AVFrame */
    ret = avcodec_fill_audio_frame(frame, c->channels, c->sample_fmt,
        (const uint8_t*)samples, buffer_size, 0);
    if (ret < 0) {
        fprintf(stderr, "Could not setup audio frame\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;

        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_freep(&samples);
    av_frame_free(&frame);
    avcodec_close(c);
    av_free(c);
}

/** Audio decoding.*/
static void audio_decode_example(const char *outfilename, const char *filename)
{
    AVCodec *codec;
    AVCodecContext *c = NULL;
    int len;
    FILE *f, *outfile;
    uint8_t inbuf[AUDIO_INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
    AVPacket avpkt;
    AVFrame *decoded_frame = NULL;

    av_init_packet(&avpkt);

    printf("Decode audio file %s to %s\n", filename, outfilename);

    /* find the mpeg audio decoder */
    codec = avcodec_find_decoder(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);
    }

    /* 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);
    }
    outfile = fopen(outfilename, "wb");
    if (!outfile) {
        av_free(c);
        exit(1);
    }

    /* decode until eof */
    avpkt.data = inbuf;
    avpkt.size = fread(inbuf, 1, AUDIO_INBUF_SIZE, f);

    while (avpkt.size > 0) {
        int i, ch;
        int got_frame = 0;

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

        len = avcodec_decode_audio4(c, decoded_frame, &got_frame, &avpkt);
        if (len < 0) {
            fprintf(stderr, "Error while decoding\n");
            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);
            }
            for (i = 0; i<decoded_frame->nb_samples; i++)
                for (ch = 0; ch<c->channels; ch++)
                    fwrite(decoded_frame->data[ch] + data_size*i, 1, data_size, outfile);
        }
        avpkt.size -= len;
        avpkt.data += len;
        avpkt.dts =
            avpkt.pts = AV_NOPTS_VALUE;
        if (avpkt.size < AUDIO_REFILL_THRESH) {
            /* Refill the input buffer, to avoid trying to decode
            * incomplete frames. Instead of this, one could also use
            * a parser, or use a proper container format through
            * libavformat. */
            memmove(inbuf, avpkt.data, avpkt.size);
            avpkt.data = inbuf;
            len = fread(avpkt.data + avpkt.size, 1,
                AUDIO_INBUF_SIZE - avpkt.size, f);
            if (len > 0)
                avpkt.size += len;
        }
    }

    fclose(outfile);
    fclose(f);

    avcodec_close(c);
    av_free(c);
    av_frame_free(&decoded_frame);
}

/** Video encoding example*/
//codec_id报错，查找avcodec_find_encoder定义，可知，enum AVCodecID类型定义codec_id
static void video_encode_example(const char *filename, enum AVCodecID codec_id)
{
    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 };

    printf("Encode video file %s\n", filename);

    /* find the mpeg1 video encoder */
    codec = avcodec_find_encoder(codec_id);
    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 };
    /* 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;

    /* the image can be allocated by any means and av_image_alloc() is
    * just the most convenient way if av_malloc() is to be used */
    ret = av_image_alloc(frame->data, frame->linesize, c->width, c->height,
        c->pix_fmt, 32);
    if (ret < 0) {
        fprintf(stderr, "Could not allocate raw picture buffer\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);
        /* 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_close(c);
    av_free(c);
    av_freep(&frame->data[0]);
    av_frame_free(&frame);
    printf("\n");
}

/** Video decoding example*/

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,
    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), outfilename, *frame_count);
        pgm_save(frame->data[0], frame->linesize[0],
            frame->width, frame->height, buf);
        (*frame_count)++;
    }
    if (pkt->data) {
        pkt->size -= len;
        pkt->data += len;
    }
    return 0;
}

static void video_decode_example(const char *outfilename, const char *filename)
{
    AVCodec *codec;
    AVCodecContext *c = NULL;
    int frame_count;
    FILE *f;
    AVFrame *frame;
    uint8_t inbuf[INBUF_SIZE + AV_INPUT_BUFFER_PADDING_SIZE];
    AVPacket avpkt;

    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);

    printf("Decode video file %s to %s\n", filename, outfilename);

    /* find the mpeg1 video decoder */
    codec = avcodec_find_decoder(AV_CODEC_ID_MPEG1VIDEO);
    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);
    }

    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);
    }

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

    frame_count = 0;
    for (;;) {
        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 (decode_write_frame(outfilename, c, frame, &frame_count, &avpkt, 0) < 0)
                exit(1);
    }

    /* 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, frame, &frame_count, &avpkt, 1);

    fclose(f);

    avcodec_close(c);
    av_free(c);
    av_frame_free(&frame);
    printf("\n");
}

int main(int argc, char **argv)
{
    const char *output_type;

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

    if (argc < 2) {
        printf("usage: %s output_type\n"
            "API example program to decode/encode a media stream with libavcodec.\n"
            "This program generates a synthetic stream and encodes it to a file\n"
            "named test.h264, test.mp2 or test.mpg depending on output_type.\n"
            "The encoded stream is then decoded and written to a raw data output.\n"
            "output_type must be chosen between 'h264', 'mp2', 'mpg'.\n",
            argv[0]);
        return 1;
    }
    output_type = argv[1];

    if (!strcmp(output_type, "h264")) {
        video_encode_example("test.h264", AV_CODEC_ID_H264);
    }         
    else if (!strcmp(output_type, "mp2")) {
        audio_encode_example("test.mp2");
        audio_decode_example("test.pcm", "test.mp2");
    }
    else if (!strcmp(output_type, "mpg")) {
        video_encode_example("test.mpg", AV_CODEC_ID_MPEG1VIDEO);
        video_decode_example("test%02d.pgm", "test.mpg");
    }
    else {
        fprintf(stderr, "Invalid output type '%s', choose between 'h264', 'mp2', or 'mpg'\n",
            output_type);
        return 1;
    }
    return 0;
}

然后接下来 为了提高说服力 放一个结果的图片
test.h264在streameye 里面播放
这里写图片描述

lldbuaa
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
ffmpeg中抽取建立的进行编码、解码（'h264', 'mp2', 'mpg'）
12-28
VS2010工程，从ffmpeg中提取代码，加以修改，添加ffmpeg库 VS2010 64位下编译通过。 运行后再工程根目录会生成视频文件。 用于ffmpeg库的编码、解码学习。
ffmpeg decoding_encoding windows下代码
03-22
ffmpeg 音视频编解码windows下编译代码 加详细注释 适合新手学习ffmpeg使用 需要的下载
解读ffmpeg例程decoding_encoding.c
lidedongsn
10-16 2514
解读ffmpeg例程decoding_encoding.c
FFmpeg示例程序合集-批量编译脚本
热门推荐
雷霄骅(leixiaohua1020)的专栏
02-23 1万+
此前做了一系列有关FFmpeg的示例程序，组成了《最简单的FFmpeg示例程序合集》，其中包含了如下项目：simplest ffmpeg player:                  最简单的基于FFmpeg的视频播放器simplest ffmpeg audio player:       最简单的基于FFmpeg的音频播放器simplest ffmpeg pic encoder:
Encoding & Decoding
小雨的博客
08-15 1316
encoding和decoding
ffmpeg使用例子
dujianxiong的博客
01-27 1162
视频截取 old_ifs="$IFS" ; IFS=$'\n'; files=`ls *.mkv` for name in $files; do dua=`ffprobe -i ./${name} -show_entries format=duration -v quiet -of csv="p=0"` dura=`expr ${dua%.*} - 80`; ffmpeg -i ....
LDPC_sim_v1_decoding_encoding_AWGN_LDPC_standard_
10-03
标题“LDPC_sim_v1_decoding_encoding_AWGN_LDPC_standard_”暗示了这是一个关于低密度奇偶校验（Low-Density Parity Check, LDPC）码在Matlab环境中进行模拟的项目，涉及到编码和解码过程，以及在加性高斯白噪声...
FFMPEG_SDK_.rar_container pts_dts_ffmpeg pts_解码DTS
09-21
本教程将深入探讨FFMPEG如何处理容器格式以及PTS（Presentation Time Stamp）和DTS（Decoding Time Stamp）的概念，这对于理解和优化视频解码过程至关重要。 首先，我们要理解容器格式。容器是多媒体数据的封装形式...
RunLengthEnCodingandDecoding_decoding_run_runlengthencoding_
10-04
标题“RunLengthEnCodingandDecoding_decoding_run_runlengthencoding_”指的是使用RLE进行图像的压缩和解压缩过程。** RLE的基本原理是将连续出现的相同值（例如，图像中的同一颜色像素）替换为该值和它连续出现的...
lsb.zip_LSB_lsb decoding_lsb matlab_lsb原码_lsb解码
09-21
这个压缩包"lsb.zip"包含了关于LSB编码、解码以及加密的相关内容，特别是使用MATLAB语言实现的源码。 LSB编码是将秘密信息转化为二进制形式，然后替换图像像素的LSB位。例如，如果一个像素原本的二进制值是10101010...
ffmpeg命令手册及例程（官网）-2021.pdf
12-03
ffmpeg最新版命令手册和相关例程详细说明
第一个ffmpeg程序
02-05
实现从视频中保存了几幅图片。 一、参考的资料 http://blog.sina.com.cn/s/blog_4178f4bf01018wqh.html http://www.guanggua.com/question/24057248-FFmpeg-undefined-references-to-av_frame_alloc.html 二、所有的环境 1.win10 2.vs2015 4.ffmpeg-3.4.1-win64
ffmpeg编解码详细过程
12-15
ffmpeg编解码详细过程,以及ffmpeg开发中常见的问题
ffmpeg的简单例子
Pine的专栏
02-20 1673
http://www.ffmpeg.com.cn/index.php/Output_example.c   ffmpeg项目中很典型的一个例程 http://www.rosoo.net/a/201110/15191.html   音视频文件码率与大小计算 http://blog.csdn.net/derryzhang/article/details/5133083  视频知识基础：什么是T
ffmpeg0.6例程
12-17 418
ffmpeg0.6例程 gcc -o test tutorial01.c-lavcodec -lavformat -lswscale -lavutil -I/opt/ffmpeg-x86/include-L/opt/ffmpeg-x86/lib ./test input.avi // tutorial01.c // Code based on a tutor
circe Encoding和Decoding
十万小时之旅
01-16 603
Encoder[A]是将A类型转化成JSON的函数，Decoder[A]是将Json转化成一个A对象或者是exception的函数。   circe提供了scala标准库中类型的的implicit函数，可以方便的对String，Int等基本类型进行处理，同时也提供了List[A]、Option[A]和其他泛型类型的处理，只要是A有对应的Encoder。   可以使用 .asJson 将...
decoding_encoding.c
闲云野鹤专栏
12-23 494
doc/examples/decoding_encoding.c /* * Copyright (c) 2001 Fabrice Bellard * * Permission is hereby granted, free of charge, to any person obtaining a copy * of this software and associated
encoding / decoding
eastage的专栏
01-19 627
<br />1.  Players and how they support encoding / decoding<br />http://www.matroska.org/technical/guides/playback/windows/index.html
encoding & decoding
MyFreeIT
06-02 388
编码是按照规则把字符转换成对应的二进制，并写入存储。而解码是读取存储，把二进制转成成字符。编码最终是为了存储，而解码最终是为了用户可以看懂。打印字符（96） + 控制字符（32） = 128 个，通过一个Byte就可以完成编码。最高位为0，其它7位代表2^7=128个字符，所以标准ASCII字符集是不能存储汉字。 例如：0100 0001 表示 2 ^6 + 2 ^0 = 65.在标准ASCII字符集的基础上，利用最高位后，编码的范围变为（1000 0000 ~ 1111 1111）即：128255。标
ffmpeg视频编解码的过程
最新发布
09-07
FFmpeg是一个开源的跨平台多媒体处理工具，其中包含了众多的音视频编解码器。下面是FFmpeg中视频编解码的大致过程： 1. 解封装（Demuxing）：从输入文件中读取音视频数据，并将其分离成音频流和视频流。 2. 解码...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值