ffmpeg中为方便对资源进行访问，定义了两个结构体，URLContext中是对具体资源文件进行操作的上下文，URLProtocol则是在将资源进行分类的基础上，对某一类资源操作的函数集，熟悉Linux设备驱动程序的话，很容易联想到file_operations结构体

typedef struct URLContext

 {

     const AVClass *av_class;    /**< information for av_log(). Set by url_open(). */

     struct URLProtocol *prot;

     void *priv_data;

     char *filename;             /**< specified URL */

     int flags;

     int max_packet_size;        /**< if non zero, the stream is packetized with this max packet size */

     int is_streamed;            /**< true if streamed (no seek possible), default = false */

     int is_connected;

     AVIOInterruptCB interrupt_callback;

     int64_t rw_timeout;         /**< maximum time to wait for (network) read/write operation completion, in mcs */

 }

 URLContext;

typedef struct URLProtocol

 {

     const char *name;

     int     (*url_open)( URLContext *h, const char *url, int flags);

     /**

      * This callback is to be used by protocols which open further nested

      * protocols. options are then to be passed to ffurl_open()/ffurl_connect()

      * for those nested protocols.

      */

     int     (*url_open2)(URLContext *h, const char *url, int flags, AVDictionary **options);

     /**

      * Read data from the protocol.

      * If data is immediately available (even less than size), EOF is

      * reached or an error occurs (including EINTR), return immediately.

      * Otherwise:

      * In non-blocking mode, return AVERROR(EAGAIN) immediately.

      * In blocking mode, wait for data/EOF/error with a short timeout (0.1s),

      * and return AVERROR(EAGAIN) on timeout.

      * Checking interrupt_callback, looping on EINTR and EAGAIN and until

      * enough data has been read is left to the calling function; see

      * retry_transfer_wrapper in avio.c.

      */

     int     (*url_read)( URLContext *h, unsigned char *buf, int size);

     int     (*url_write)(URLContext *h, const unsigned char *buf, int size);

     int64_t (*url_seek)( URLContext *h, int64_t pos, int whence);

     int     (*url_close)(URLContext *h);

     struct URLProtocol *next;

     int (*url_read_pause)(URLContext *h, int pause);

     int64_t (*url_read_seek)(URLContext *h, int stream_index,

                              int64_t timestamp, int flags);

     int (*url_get_file_handle)(URLContext *h);

     int (*url_get_multi_file_handle)(URLContext *h, int **handles,

                                      int *numhandles);

     int (*url_shutdown)(URLContext *h, int flags);

     int priv_data_size;

     const AVClass *priv_data_class;

     int flags;

     int (*url_check)(URLContext *h, int mask);

 }

 URLProtocol;

在代码中搜索url_open，很容易能够找到ffmpeg中支持的几个协议：

URLProtocol ff_bluray_protocol =

 {

     .name            = "bluray",

     .url_close       = bluray_close,

     .url_open        = bluray_open,

     .url_read        = bluray_read,

     .url_seek        = bluray_seek,

     .priv_data_size  = sizeof(BlurayContext),

     .priv_data_class = &bluray_context_class,

 };

URLProtocol ff_data_protocol =

 {

     .name           = "data",

     .url_open       = data_open,

     .url_close      = data_close,

     .url_read       = data_read,

     .priv_data_size = sizeof(DataContext),

 };

URLProtocol ff_file_protocol =

 {

     .name                = "file",

     .url_open            = file_open,

     .url_read            = file_read,

     .url_write           = file_write,

     .url_seek            = file_seek,

     .url_close           = file_close,

     .url_get_file_handle = file_get_handle,

     .url_check           = file_check,

     .priv_data_size      = sizeof(FileContext),

     .priv_data_class     = &file_class,

 };

URLProtocol ff_pipe_protocol =

 {

     .name                = "pipe",

     .url_open            = pipe_open,

     .url_read            = file_read,

     .url_write           = file_write,

     .url_get_file_handle = file_get_handle,

     .url_check           = file_check,

     .priv_data_size      = sizeof(FileContext),

     .priv_data_class     = &pipe_class,

 };

URLProtocol ff_ftp_protocol =

 {

     .name                = "ftp",

     .url_open            = ftp_open,

     .url_read            = ftp_read,

     .url_write           = ftp_write,

     .url_seek            = ftp_seek,

     .url_close           = ftp_close,

     .url_get_file_handle = ftp_get_file_handle,

     .url_shutdown        = ftp_shutdown,

     .priv_data_size      = sizeof(FTPContext),

     .priv_data_class     = &ftp_context_class,

     .flags               = URL_PROTOCOL_FLAG_NETWORK,

 };

URLProtocol ff_hls_protocol =

 {

     .name           = "hls",

     .url_open       = hls_open,

     .url_read       = hls_read,

     .url_close      = hls_close,

     .flags          = URL_PROTOCOL_FLAG_NESTED_SCHEME,

     .priv_data_size = sizeof(HLSContext),

 };

URLProtocol ff_httpproxy_protocol =

 {

     .name                = "httpproxy",

     .url_open            = http_proxy_open,

     .url_read            = http_buf_read,

     .url_write           = http_proxy_write,

     .url_close           = http_proxy_close,

     .url_get_file_handle = http_get_file_handle,

     .priv_data_size      = sizeof(HTTPContext),

     .flags               = URL_PROTOCOL_FLAG_NETWORK,

 };

... 还有很多协议，不全部列出了，例如tcp, udp, ...

支持这些协议而定义的结构体在av_register_all()函数被调用时而注册，例如：

 REGISTER_PROTOCOL(FILE,             file);

#define REGISTER_PROTOCOL(X, x)                                         \

     {                                                                   \

         extern URLProtocol ff_##x##_protocol;                           \

         if (CONFIG_##X##_PROTOCOL)                                      \

             ffurl_register_protocol(&ff_##x##_protocol);                \

     }

ffurl_register_protocol(&ff_file_protocol);

int ffurl_register_protocol(URLProtocol *protocol)

 {

     URLProtocol **p;

     p = &first_protocol;

     while (*p != NULL)

         p = &(*p)->next;

     *p             = protocol;

     protocol->next = NULL;

     return ;

 }

注册到以static URLProtocol *first_protocol = NULL;为头的一个链表中，每一个协议结构体是链表中的一项；

以avio_open2为例：

int avio_open2(AVIOContext **s, const char *filename, int flags,

                const AVIOInterruptCB *int_cb, AVDictionary **options)

 {

     URLContext *h;

     int err;

     err = ffurl_open(&h, filename, flags, int_cb, options);

     if (err < )

         return err;

     err = ffio_fdopen(s, h);

     if (err < )

     {

         ffurl_close(h);

         return err;

     }

     return ;

 }

ffurl_open--->ffurl_alloc--->static struct URLProtocol *url_find_protocol(const char *filename)

url_find_protocol函数会根据filename判断协议，这个函数的定义没太看懂，但是其作用，无非是先判断具体的协议，然后根据判读出来的协议，调用

URLProtocol *ffurl_protocol_next(URLProtocol *prev)

 {

     return prev ? prev->next : first_protocol;

 }

函数，在之前注册的first_protocol链表上找到相应的协议结构体，然后返回给函数url_alloc_for_protocol，在这个函数中，则是根据判断的协议，生成URLContext结构体，

uc = av_mallocz(sizeof(URLContext) + strlen(filename) + );

*puc = uc;

在ffurl_open函数中，ffurl_alloc函数返回之后，URLContext **puc结构体就已经被设置完毕，然后在ffurl_open函数中，再调用ret = ffurl_connect(*puc, options);

int ffurl_connect(URLContext *uc, AVDictionary **options)

 {

     int err =

         uc->prot->url_open2 ? uc->prot->url_open2(uc,

                                                   uc->filename,

                                                   uc->flags,

                                                   options) :

         uc->prot->url_open(uc, uc->filename, uc->flags);

     if (err)

         return err;

     uc->is_connected = ;

     /* We must be careful here as ffurl_seek() could be slow,

      * for example for http */

     if ((uc->flags & AVIO_FLAG_WRITE) || !strcmp(uc->prot->name, "file"))

         if (!uc->is_streamed && ffurl_seek(uc, , SEEK_SET) < )

             uc->is_streamed = ;

     return ;

 }

prot是协议，在url_alloc_for_protocol函数中设置的：uc->prot            = up;

然后url_open2， url_open都是在协议结构体中定义的函数指针，以"file"协议为例：

URLProtocol ff_file_protocol =

{

    .name                = "file",

    .url_open            = file_open,

    .url_read            = file_read,

    .url_write           = file_write,

    .url_seek            = file_seek,

    .url_close           = file_close,

    .url_get_file_handle = file_get_handle,

    .url_check           = file_check,

    .priv_data_size      = sizeof(FileContext),

    .priv_data_class     = &file_class,

};

url_open2是NULL，则调用url_open函数指针指向的函数file_open：

static int file_open(URLContext *h, const char *filename, int flags)

 {

     FileContext *c = h->priv_data;

     int access;

     int fd;

     struct stat st;

     av_strstart(filename, "file:", &filename);

     if (flags & AVIO_FLAG_WRITE && flags & AVIO_FLAG_READ) {

         access = O_CREAT | O_RDWR;

         if (c->trunc)

             access |= O_TRUNC;

     } else if (flags & AVIO_FLAG_WRITE) {

         access = O_CREAT | O_WRONLY;

         if (c->trunc)

             access |= O_TRUNC;

     } else {

         access = O_RDONLY;

     }

 #ifdef O_BINARY

     access |= O_BINARY;

 #endif

     fd = avpriv_open(filename, access, );

     if (fd == -)

         return AVERROR(errno);

     c->fd = fd;

     h->is_streamed = !fstat(fd, &st) && S_ISFIFO(st.st_mode);

     return ;

}