av_probe_input_buffer函数中的数据流向

最新推荐文章于 2024-09-24 19:00:00 发布
最新推荐文章于 2024-09-24 19:00:00 发布
阅读量532 收藏 1
点赞数
分类专栏： embedded

简介

本文主要探索在转码前探测流格式和流信息完成后，怎样将处理过的数据进行转码，而不至于丢失。 
这个问题实际上就是要探索ffmpeg中的读取数据和缓冲数据系统是如何运作的。了解了这些可以帮助 
我们在转码过程中方便的处理数据。

各函数探索

从内存获取数据的设置方法

从内存获取数据时，调用如下

AVIOContext * inpb = avio_alloc_context(Buf, BUF_SIZE, 0, dataFromUser, read_data, NULL, NULL);
if (!inpb)
{
    av_log(NULL, AV_LOG_FATAL, "avio alloc failed!\n");
    exit_program(1);
}
if (av_probe_input_buffer(inpb, &file_iformat, "", NULL, 0, 0) < 0) 
{
    av_log(NULL, AV_LOG_FATAL, "probe failed!\n");
    exit_program(1);
} 
ic->pb = inpb;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12

av_probe_input_buffer

参数 
offset表示AVIOContext的缓冲区中从哪个偏移开始分析 
max_probe_size表示最多探测多少数据

int av_probe_input_buffer(AVIOContext *pb, AVInputFormat **fmt,
                          const char *filename, void *logctx,
                          unsigned int offset, unsigned int max_probe_size)
{
    int ret = av_probe_input_buffer2(pb, fmt, filename, logctx, offset, max_probe_size);
    return ret < 0 ? ret : 0;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
#define PROBE_BUF_MIN 2048
#define PROBE_BUF_MAX (1 << 20)

int av_probe_input_buffer2(AVIOContext *pb, AVInputFormat **fmt,
                          const char *filename, void *logctx,
                          unsigned int offset, unsigned int max_probe_size)
{
    AVProbeData pd = { filename ? filename : "" };
    uint8_t *buf = NULL;
    int ret = 0, probe_size, buf_offset = 0;
    int score = 0;
    int ret2;

    if (!max_probe_size)
        max_probe_size = PROBE_BUF_MAX;//设置默认值为
    else if (max_probe_size < PROBE_BUF_MIN) {
        av_log(logctx, AV_LOG_ERROR,
               "Specified probe size value %u cannot be < %u\n", max_probe_size, PROBE_BUF_MIN);
        return AVERROR(EINVAL);
    }

    if (offset >= max_probe_size)
        return AVERROR(EINVAL);

    if (pb->av_class) {
        uint8_t *mime_type_opt = NULL;
        char *semi;
        av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type_opt);
        pd.mime_type = (const char *)mime_type_opt;
        semi = pd.mime_type ? strchr(pd.mime_type, ';') : NULL;
        if (semi) {
            *semi = '\0';
        }
    }
#if 0
    if (!*fmt && pb->av_class && av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type) >= 0 && mime_type) {
        if (!av_strcasecmp(mime_type, "audio/aacp")) {
            *fmt = av_find_input_format("aac");
        }
        av_freep(&mime_type);
    }
#endif
    //probe_size从PROBE_BUF_MIN开始分配，并每次读取这么多。直到max_probe_size或者已经探测到流格式为止。
    for (probe_size = PROBE_BUF_MIN; probe_size <= max_probe_size && !*fmt;
         probe_size = FFMIN(probe_size << 1,
                            FFMAX(max_probe_size, probe_size + 1))) {
        score = probe_size < max_probe_size ? AVPROBE_SCORE_RETRY : 0;
        //分配探测的临时内存，随着探测的次数增加而增大
        /* Read probe data. */
        if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
            goto fail;
        //后有详细介绍
        if ((ret = avio_read(pb, buf + buf_offset,
                             probe_size - buf_offset)) < 0) {
            /* Fail if error was not end of file, otherwise, lower score. */
            if (ret != AVERROR_EOF)
                goto fail;

            score = 0;
            ret   = 0;          /* error was end of file, nothing read */
        }
        buf_offset += ret;
        //跳过指定的偏移，将数据给pd。av_probe_input_format2函数分析要用到。
        if (buf_offset < offset)
            continue;
        pd.buf_size = buf_offset - offset;
        pd.buf = &buf[offset];
        //将最后AVPROBE_PADDING_SIZE字节赋值为0，防止读越界
        memset(pd.buf + pd.buf_size, 0, AVPROBE_PADDING_SIZE);

        /* Guess file format. */
        *fmt = av_probe_input_format2(&pd, 1, &score);
        if (*fmt) {
            /* This can only be true in the last iteration. */
            if (score <= AVPROBE_SCORE_RETRY) {
                av_log(logctx, AV_LOG_WARNING,
                       "Format %s detected only with low score of %d, "
                       "misdetection possible!\n", (*fmt)->name, score);
            } else
                av_log(logctx, AV_LOG_DEBUG,
                       "Format %s probed with size=%d and score=%d\n",
                       (*fmt)->name, probe_size, score);
#if 0
            FILE *f = fopen("probestat.tmp", "ab");
            fprintf(f, "probe_size:%d format:%s score:%d filename:%s\n", probe_size, (*fmt)->name, score, filename);
            fclose(f);
#endif
        }
    }

    if (!*fmt)
        ret = AVERROR_INVALIDDATA;

fail:
    /* Rewind. Reuse probe buffer to avoid seeking. */
    //将buf中的buf_offset大小的数据放到pb中。
    ret2 = ffio_rewind_with_probe_data(pb, &buf, buf_offset);
    if (ret >= 0)
        ret = ret2;

    av_freep(&pd.mime_type);
    return ret < 0 ? ret : score;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103

avio_read

如果AVIOContext的缓存去中有数据，优先将数据拷到buf中，如果size不够再读实际数据到AVIOContext的缓存中 
后再拷贝到buf中。直到读结束或者size读够。

int avio_read(AVIOContext *s, unsigned char *buf, int size)
{
    int len, size1;

    size1 = size;
    while (size > 0) {
        //得出AVIOContext中的缓存和需要读入的大小的最小值
        len = FFMIN(s->buf_end - s->buf_ptr, size);
        //因为size>0所以len=0表示AVIOContext中没有数据了。反之AVIOContext中有缓存。
        if (len == 0 || s->write_flag) {
            if((s->direct || size > s->buffer_size) && !s->update_checksum) {
                //不经过AVIOContext的缓存直接读进buf中
                // bypass the buffer and read data directly into buf
                if(s->read_packet)
                    len = s->read_packet(s->opaque, buf, size);

                if (len <= 0) {
                    /* do not modify buffer if EOF reached so that a seek back can
                    be done without rereading data */
                    s->eof_reached = 1;
                    if(len<0)
                        s->error= len;
                    break;
                } else {
                    s->pos += len;
                    s->bytes_read += len;
                    size -= len;
                    buf += len;
                    // reset the buffer
                    s->buf_ptr = s->buffer;
                    s->buf_end = s->buffer/* + len*/;
                }
            } else {
                fill_buffer(s);//后有详细分析
                len = s->buf_end - s->buf_ptr;
                if (len == 0)
                    break;
            }
        } else {
            //直接从AVIOContext的缓存中往buf中写数据
            memcpy(buf, s->buf_ptr, len);
            buf += len;
            s->buf_ptr += len;
            size -= len;
        }
    }
    if (size1 == size) {
        if (s->error)      return s->error;
        if (avio_feof(s))  return AVERROR_EOF;
    }
    return size1 - size;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53

fill_buffer

将调用之前注册的读数据函数，将数据读入AVIOContext的缓冲区中。

static void fill_buffer(AVIOContext *s)
{
    int max_buffer_size = s->max_packet_size ?
                          s->max_packet_size : IO_BUFFER_SIZE;
    uint8_t *dst        = s->buf_end - s->buffer + max_buffer_size < s->buffer_size ?
                          s->buf_end : s->buffer;
    int len             = s->buffer_size - (dst - s->buffer);

    /* can't fill the buffer without read_packet, just set EOF if appropriate */
    if (!s->read_packet && s->buf_ptr >= s->buf_end)
        s->eof_reached = 1;

    /* no need to do anything if EOF already reached */
    if (s->eof_reached)
        return;

    if (s->update_checksum && dst == s->buffer) {
        if (s->buf_end > s->checksum_ptr)
            s->checksum = s->update_checksum(s->checksum, s->checksum_ptr,
                                             s->buf_end - s->checksum_ptr);
        s->checksum_ptr = s->buffer;
    }

    /* make buffer smaller in case it ended up large after probing */
    //如果AVIOContext的缓存区大小过大，重新分配缓存去。ffio_rewind_with_probe_data中会导致缓存增大的，之后有说明
    if (s->read_packet && s->orig_buffer_size && s->buffer_size > s->orig_buffer_size) {
        if (dst == s->buffer) {
            int ret = ffio_set_buf_size(s, s->orig_buffer_size);
            if (ret < 0)
                av_log(s, AV_LOG_WARNING, "Failed to decrease buffer size\n");

            s->checksum_ptr = dst = s->buffer;
        }
        av_assert0(len >= s->orig_buffer_size);
        len = s->orig_buffer_size;
    }
    //实际的读数据函数
    if (s->read_packet)
        len = s->read_packet(s->opaque, dst, len);
    else
        len = 0;
    if (len <= 0) {
        /* do not modify buffer if EOF reached so that a seek back can
           be done without rereading data */
        s->eof_reached = 1;
        if (len < 0)
            s->error = len;
    } else {
        //修改AVIOContext中的缓冲区信息
        s->pos += len;
        s->buf_ptr = dst;
        s->buf_end = dst + len;
        s->bytes_read += len;
    }
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56

av_probe_input_format2

AVInputFormat *av_probe_input_format2(AVProbeData *pd, int is_opened, int *score_max)
{
    int score_ret;
    AVInputFormat *fmt = av_probe_input_format3(pd, is_opened, &score_ret);
    if (score_ret > *score_max) {
        *score_max = score_ret;
        return fmt;
    } else
        return NULL;
}
AVInputFormat *av_probe_input_format3(AVProbeData *pd, int is_opened,
                                      int *score_ret)
{
    AVProbeData lpd = *pd;
    AVInputFormat *fmt1 = NULL, *fmt;
    int score, score_max = 0;
    const static uint8_t zerobuffer[AVPROBE_PADDING_SIZE];
    enum nodat {
        NO_ID3,
        ID3_ALMOST_GREATER_PROBE,
        ID3_GREATER_PROBE,
        ID3_GREATER_MAX_PROBE,
    } nodat = NO_ID3;

    if (!lpd.buf)
        lpd.buf = (unsigned char *) zerobuffer;
    //对mp3格式的检查。可能是。没有仔细看
    if (lpd.buf_size > 10 && ff_id3v2_match(lpd.buf, ID3v2_DEFAULT_MAGIC)) {
        int id3len = ff_id3v2_tag_len(lpd.buf);
        if (lpd.buf_size > id3len + 16) {
            if (lpd.buf_size < 2LL*id3len + 16)
                nodat = ID3_ALMOST_GREATER_PROBE;
            lpd.buf      += id3len;
            lpd.buf_size -= id3len;
        } else if (id3len >= PROBE_BUF_MAX) {
            nodat = ID3_GREATER_MAX_PROBE;
        } else
            nodat = ID3_GREATER_PROBE;
    }

    fmt = NULL;
    while ((fmt1 = av_iformat_next(fmt1))) {
        if (!is_opened == !(fmt1->flags & AVFMT_NOFILE) && strcmp(fmt1->name, "image2"))
            continue;
        score = 0;
        /*libavformat\h264dec.c中
        FF_DEF_RAWVIDEO_DEMUXER(h264, "raw H.264 video", h264_probe, "h26l,h264,264,avc", AV_CODEC_ID_H264)
        定义了ff_h264_demuxer
        libavformat\m4vdec.c中
        FF_DEF_RAWVIDEO_DEMUXER2(m4v, "raw MPEG-4 video", mpeg4video_probe, "m4v",
                         AV_CODEC_ID_MPEG4, AVFMT_GENERIC_INDEX | AVFMT_TS_DISCONT)
        定义了ff_m4v_demuxer
        h264_probe和mpeg4video_probe俩函数分别对应探测h264和mpeg4码流的。

        libavformat\rawdec.h和libavformat\rawdec.c中定义了FF_DEF_RAWVIDEO_DEMUXER和FF_DEF_RAWVIDEO_DEMUXER2
        .read_packet    = ff_raw_read_partial_packet,读包函数都是这个。
        */
        if (fmt1->read_probe) {
            score = fmt1->read_probe(&lpd);
            if (score)
                av_log(NULL, AV_LOG_TRACE, "Probing %s score:%d size:%d\n", fmt1->name, score, lpd.buf_size);
            if (fmt1->extensions && av_match_ext(lpd.filename, fmt1->extensions)) {
                switch (nodat) {
                case NO_ID3:
                    score = FFMAX(score, 1);
                    break;
                case ID3_GREATER_PROBE:
                case ID3_ALMOST_GREATER_PROBE:
                    score = FFMAX(score, AVPROBE_SCORE_EXTENSION / 2 - 1);
                    break;
                case ID3_GREATER_MAX_PROBE:
                    score = FFMAX(score, AVPROBE_SCORE_EXTENSION);
                    break;
                }
            }
        } else if (fmt1->extensions) {
            if (av_match_ext(lpd.filename, fmt1->extensions))
                score = AVPROBE_SCORE_EXTENSION;
        }
        if (av_match_name(lpd.mime_type, fmt1->mime_type)) {
            if (AVPROBE_SCORE_MIME > score) {
                av_log(NULL, AV_LOG_DEBUG, "Probing %s score:%d increased to %d due to MIME type\n", fmt1->name, score, AVPROBE_SCORE_MIME);
                score = AVPROBE_SCORE_MIME;
            }
        }
        if (score > score_max) {
            score_max = score;
            fmt       = fmt1;
        } else if (score == score_max)
            fmt = NULL;
    }
    if (nodat == ID3_GREATER_PROBE)
        score_max = FFMIN(AVPROBE_SCORE_EXTENSION / 2 - 1, score_max);
    *score_ret = score_max;

    return fmt;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98

av_iformat_next

如下这些涉及到输入输出文件格式的链表

libavformat\format.c
static AVInputFormat *first_iformat = NULL;
/** head of registered output format linked list */
static AVOutputFormat *first_oformat = NULL;

static AVInputFormat **last_iformat = &first_iformat;
static AVOutputFormat **last_oformat = &first_oformat;

AVInputFormat *av_iformat_next(const AVInputFormat *f)
{
    if (f)
        return f->next;
    else
        return first_iformat;
}

AVOutputFormat *av_oformat_next(const AVOutputFormat *f)
{
    if (f)
        return f->next;
    else
        return first_oformat;
}

void av_register_input_format(AVInputFormat *format)
{
    AVInputFormat **p = last_iformat;

    // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
    while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
        p = &(*p)->next;

    if (!format->next)
        last_iformat = &format->next;
}

void av_register_output_format(AVOutputFormat *format)
{
    AVOutputFormat **p = last_oformat;

    // Note, format could be added after the first 2 checks but that implies that *p is no longer NULL
    while(p != &format->next && !format->next && avpriv_atomic_ptr_cas((void * volatile *)p, NULL, format))
        p = &(*p)->next;

    if (!format->next)
        last_oformat = &format->next;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
libavformat\allformats.c

#define REGISTER_MUXER(X, x)                                            \
    {                                                                   \
        extern AVOutputFormat ff_##x##_muxer;                           \
        if (CONFIG_##X##_MUXER)                                         \
            av_register_output_format(&ff_##x##_muxer);                 \
    }

#define REGISTER_DEMUXER(X, x)                                          \
    {                                                                   \
        extern AVInputFormat ff_##x##_demuxer;                          \
        if (CONFIG_##X##_DEMUXER)                                       \
            av_register_input_format(&ff_##x##_demuxer);                \
    }

#define REGISTER_MUXDEMUX(X, x) REGISTER_MUXER(X, x); REGISTER_DEMUXER(X, x)


void av_register_all(void)
{
    static int initialized;

    if (initialized)
        return;

    avcodec_register_all();

    /* (de)muxers */
    REGISTER_MUXER   (A64,              a64);
    REGISTER_DEMUXER (AA,               aa);
    REGISTER_DEMUXER (AAC,              aac);
    REGISTER_MUXDEMUX(AC3,              ac3);
    REGISTER_DEMUXER (ACM,              acm);
    REGISTER_DEMUXER (ACT,              act);
    REGISTER_DEMUXER (ADF,              adf);
    REGISTER_DEMUXER (ADP,              adp);
    REGISTER_DEMUXER (ADS,              ads);
    REGISTER_MUXER   (ADTS,             adts);
    ......
    REGISTER_MUXDEMUX(H263,             h263);
    REGISTER_MUXDEMUX(H264,             h264);//用到了ff_h264_demuxer
    ......
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43

以上罗列的一系列代码也比较简单。不过多介绍。

ffio_rewind_with_probe_data

将bufp中的buf_size数据放到AVIOContext中。供之后的函数处理。不然这些数据在临时缓存bufp中就丢失了。 
这一步很关键。

int ffio_rewind_with_probe_data(AVIOContext *s, unsigned char **bufp, int buf_size)
{
    int64_t buffer_start;
    int buffer_size;
    int overlap, new_size, alloc_size;
    uint8_t *buf = *bufp;

    if (s->write_flag) {
        av_freep(bufp);
        return AVERROR(EINVAL);
    }

    buffer_size = s->buf_end - s->buffer;

    /* the buffers must touch or overlap */
    if ((buffer_start = s->pos - buffer_size) > buf_size) {
        av_freep(bufp);
        return AVERROR(EINVAL);
    }

    overlap = buf_size - buffer_start;
    new_size = buf_size + buffer_size - overlap;

    //这几步导致AVIOContext的缓存地址和大小会有变化。
    alloc_size = FFMAX(s->buffer_size, new_size);
    if (alloc_size > buf_size)
        if (!(buf = (*bufp) = av_realloc_f(buf, 1, alloc_size)))
            return AVERROR(ENOMEM);

    if (new_size > buf_size) {
        memcpy(buf + buf_size, s->buffer + overlap, buffer_size - overlap);
        buf_size = new_size;
    }
    //释放了之前的缓存区
    av_free(s->buffer);
    s->buf_ptr = s->buffer = buf;
    s->buffer_size = alloc_size;
    s->pos = buf_size;
    s->buf_end = s->buf_ptr + buf_size;
    s->eof_reached = 0;
    s->must_flush = 0;

    return 0;
}
少林达摩祖师
关注
专栏目录
LwIP 之十 详解 TCP RAW 编程、示例、API 源码、数据流
技术干货
05-27 490
LwIP 使用一个 struct tcp_pcb 结构来封装一个 TCP 通信实例，一个 tcp_pcb 处理一个 TCP 通信。struct tcp_pcb 封装了通信所需要所有参数，而对于数据包，则通过回调函数的形式传递给用户（由于通信涉及链接，因此涉及的回调比较多 tcp_recv_fn recv;、tcp_connected_fn connected;、tcp_poll_fn poll; 等）
Android InputFliger流程分析,从内核 Hid到EventHub,InputRead,InputDispatcher(一)
LILI007的专栏
06-28 537
fdfasfd
ffmpeg中关于read_probe(AVProbeData *)函数的问题
xujinquan19的专栏
09-13 2104
我研究代码时发现AVInputFormat *fmt  ，fmt的确定是由read_probe完成的，read_probe将文件头信息与每种demuxer进行匹配，虽然看上去每种匹配不是很相同，但是我觉得原理是一样的，哪位大牛能解释下，在各种demuxer中，是怎么确定需要的demuxer呢？ 谢谢！   http://www.chinavideo.org/viewthread.php?tid
FFmpeg av_probe_input_buffer函数剖析以及优化
weixin_34071713的博客
11-11 823
函数调用关系 av_probe_input_buffer调用av_probe_input_buffer2进行整一个码流格式的分析过程。 其中调用avio_read进行码流数据的读取，将缓存数据保存在AVProbeData定义的buf里面， 然后调用av_probe_input_format2(AVProbeData *pd, int is_opened,...
音视频入门基础：FLV专题（5）——FFmpeg源码中，判断某文件是否为FLV文件的实现
最新发布
崔杰城的博客
09-24 2225
FFmpeg源码中实现容器格式检测的函数是av_probe_input_format3函数，其内部通过循环while ((fmt1 = av_demuxer_iterate(&i))) 拿到所有容器格式对应的AVInputFormat结构，然后通过score = fmt1->read_probe(&lpd)语句执行不同容器格式对应的解析函数，根据是否能被解析，以及匹配程度，来判断出这是哪种容器格式。而FLV文件对应的解析函数就是flv_probe函数。
FFmpeg Invalid data found when processing input
柳鲲鹏
06-28 1万+
you shuold recompile
3个重点，20个函数分析，浅析FFmpeg转码过程
a410974689的博客
01-12 1796
写在前面 最近在做和转码有关的项目，接触到ffmpeg这个神器。从一开始简单的写脚本直接调用ffmpeg的可执行文件做些转码的工作，到后来需要写程序调用ffmpeg的API。虽然上网搜了别人的demo稍微改改顺利完成了工作，但是对于ffmpeg这个黑盒子，还是有些好奇心和担心（项目中使用不了解的代码总是不那么放心），于是抽空翻了翻ffmpeg的源码，整理成文章给大家分享分享。 由于我并非做音频出身，对于音频一窍不通。ffmpeg整个也非常庞大，所以这篇文章从ffmpeg提供的转码的demo开始，侧重于讲清楚
FFmpeg源代码简单分析：avformat_open_input()
热门推荐
雷霄骅(leixiaohua1020)的专栏
03-05 7万+
本文简单分析FFmpeg中一个常用的函数：avformat_open_input()。该函数用于打开多媒体数据并且获得一些相关的信息。
Linux input系统数据上报流程
weixin_33947521的博客
12-04 2522
作为鸡生蛋系列文章,这里主要关注Linux input系统,主要为触摸事件上报流程. 读该文章最好有对linux驱动的入门知识.其实当你自己去分析了input系统后,再分析别的就相对很轻松了,linux里好多套路都差不多的. 本文例子以ft6236.c驱动为例, 当然你也可以用goodix或者别的触摸来分析.但是分析基于的内核版本用4.1...
Linux Alsa音频驱动框架(声卡的运行以及PCM数据流读写)
EmLinuxDeveloper的博客
06-08 1168
在alsa lib层会有snd_pcm_hw_params_set_period_size_near和snd_pcm_hw_params_set_buffer_size_near，之所有是near，是因为这两个接口都是设置接近值，如果硬件不支持设定的值，会设置硬件能提供的接近值，如果硬件层buffer_bytes_max和period_bytes_max设置很小，那么上层如果设置很大，那么上层设置就不会成功，最大只能是硬件的设定值；
ffmpeg系列-解复用流程解析
Mr_xkHuang的专栏
04-24 2258
从我的笔记ffmpeg-mov格式与分离器实现详解一文中，我们已经知道了mov的demuxer相关实现。本文主要来分析demuxer的流程。 1.结构流程图 从上面的结构图中我们可以看到AVFormatContext的iformat指向AVInputFormat。 2.实现流程图 3.avformat_open_input函数作用 首先看函数的声明 int avformat_open_input...
ffmpeg源码分析之媒体打开过程
wodamazi
12-05 868
从打开文件开始．入口函数是avformat_open_input(),下面是对此函数的分析//参数ps包含一切媒体相关的上下文结构，有它就有了一切，本函数如果打开媒体成功， //会返回一个AVFormatContext的实例． //参数filename是媒体文件名或URL． //参数fmt是要打开的媒体格式的操作结构，因为是读，所以是inputFormat．此处可以 //传入一个调用者定义的inp...
Invalid data found when processing input
隔壁老王呀的专栏
08-04 3万+
流程描述：我把每一帧原始YUV图像数据，构造成Y4M(YUV4MPEG2)格式的流，然后使用ffmpeg编码成h264格式进行RTMP推流。 ffmpeg执行avformat_open_input打开文件和执行avformat_find_stream_info探测流都正常，但在执行avformat_write_header报错：Invalid data found when processing input。
ffmpeg 如何探测网络流格式/如何从内存中获取数据
weixin_34290096的博客
08-09 594
一般ffmpeg都是直接从文件中读取或者从网络流中读取，比如rtp://xx.xx.xx.xx:xxxx。 事实上也支持从内存中获取。 函数avio_alloc_context()实现该功能。 [html]view plaincopy print? AVIOContext*avio_alloc_context( ...
FFmpeg：通过AVIOContext访问的自定义缓冲区中读取数据(附完整源代码)
希望我的博客，能帮上你解决学习中工作中所遇到的问题
01-04 255
FFmpeg：通过AVIOContext访问的自定义缓冲区中读取数据(附完整源代码)
ffmpeg 自定义数据来源， 可以是文件，可以是内存，可以是网络， 爱咋的咋的
我呢D浪子又点会有初恋啊
08-07 6442
ffmpeg 自定义数据来源， 可以是文件，可以是内存，可以是网络， 爱咋的咋的 // ffmpeg_custom_context.cpp : Defines the entry point for the console application. // #include "stdafx.h" extern "C" { #include };
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值