ffmpeg中avformat_open_input超时设置（第二篇）

太过爱你忘了你带给我的痛 2023-01-16 02:50 87阅读 0赞

int ff_rtsp_connect(AVFormatContext *s)
    { 
        RTSPState *rt = s->priv_data;
        char proto[128], host[1024], path[1024];
        char tcpname[1024], cmd[2048], auth[128];
        const char *lower_rtsp_proto = "tcp";
        int port, err, tcp_fd;
        RTSPMessageHeader reply1, *reply = &reply1;
        int lower_transport_mask = 0;
        int default_port = RTSP_DEFAULT_PORT;
        int https_tunnel = 0;
        char real_challenge[64] = "";
        struct sockaddr_storage peer;
        socklen_t peer_len = sizeof(peer);
    
        if (rt->rtp_port_max < rt->rtp_port_min) { 
            av_log(s, AV_LOG_ERROR, "Invalid UDP port range, max port %d less "
                                    "than min port %d\n", rt->rtp_port_max,
                                                          rt->rtp_port_min);
            return AVERROR(EINVAL);
        }
    
        if (!ff_network_init())
            return AVERROR(EIO);
    
        if (s->max_delay < 0) /* Not set by the caller */
            s->max_delay = s->iformat ? DEFAULT_REORDERING_DELAY : 0;
    
        rt->control_transport = RTSP_MODE_PLAIN;
        if (rt->lower_transport_mask & ((1 << RTSP_LOWER_TRANSPORT_HTTP) |
                                        (1 << RTSP_LOWER_TRANSPORT_HTTPS))) { 
            https_tunnel = !!(rt->lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_HTTPS));
            rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
            rt->control_transport = RTSP_MODE_TUNNEL;
        }
        /* Only pass through valid flags from here */
        rt->lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
    
    redirect:
        memset(&reply1, 0, sizeof(reply1));
        /* extract hostname and port */
        av_url_split(proto, sizeof(proto), auth, sizeof(auth),
                     host, sizeof(host), &port, path, sizeof(path), s->url);
    
        if (!strcmp(proto, "rtsps")) { 
            lower_rtsp_proto         = "tls";
            default_port             = RTSPS_DEFAULT_PORT;
            rt->lower_transport_mask = 1 << RTSP_LOWER_TRANSPORT_TCP;
        }
    
        if (*auth) { 
            av_strlcpy(rt->auth, auth, sizeof(rt->auth));
        }
        if (port < 0)
            port = default_port;
    
        lower_transport_mask = rt->lower_transport_mask;
    
        if (!lower_transport_mask)
            lower_transport_mask = (1 << RTSP_LOWER_TRANSPORT_NB) - 1;
    
        if (s->oformat) { 
            /* Only UDP or TCP - UDP multicast isn't supported. */
            lower_transport_mask &= (1 << RTSP_LOWER_TRANSPORT_UDP) |
                                    (1 << RTSP_LOWER_TRANSPORT_TCP);
            if (!lower_transport_mask || rt->control_transport == RTSP_MODE_TUNNEL) { 
                av_log(s, AV_LOG_ERROR, "Unsupported lower transport method, "
                                        "only UDP and TCP are supported for output.\n");
                err = AVERROR(EINVAL);
                goto fail;
            }
        }
    
        /* Construct the URI used in request; this is similar to s->url, * but with authentication credentials removed and RTSP specific options * stripped out. */
         * //这里是构造rt->control_uri，输入时kong,shuch输出为
         * rtsp://172.0.8.21:9980/2/analysis
         * /
        ff_url_join(rt->control_uri, sizeof(rt->control_uri), proto, NULL,
                    host, port, "%s", path);
    
        if (rt->control_transport == RTSP_MODE_TUNNEL) { 
            /* set up initial handshake for tunneling */
            char httpname[1024];
            char sessioncookie[17];
            char headers[1024];
            AVDictionary *options = NULL;
    
            av_dict_set_int(&options, "timeout", rt->stimeout, 0);
    
            ff_url_join(httpname, sizeof(httpname), https_tunnel ? "https" : "http", auth, host, port, "%s", path);
            snprintf(sessioncookie, sizeof(sessioncookie), "%08x%08x",
                     av_get_random_seed(), av_get_random_seed());
    
            /* GET requests */
            if (ffurl_alloc(&rt->rtsp_hd, httpname, AVIO_FLAG_READ,
                            &s->interrupt_callback) < 0) { 
                err = AVERROR(EIO);
                goto fail;
            }
    
            /* generate GET headers */
            snprintf(headers, sizeof(headers),
                     "x-sessioncookie: %s\r\n"
                     "Accept: application/x-rtsp-tunnelled\r\n"
                     "Pragma: no-cache\r\n"
                     "Cache-Control: no-cache\r\n",
                     sessioncookie);
            av_opt_set(rt->rtsp_hd->priv_data, "headers", headers, 0);
    
            if (!rt->rtsp_hd->protocol_whitelist && s->protocol_whitelist) { 
                rt->rtsp_hd->protocol_whitelist = av_strdup(s->protocol_whitelist);
                if (!rt->rtsp_hd->protocol_whitelist) { 
                    err = AVERROR(ENOMEM);
                    goto fail;
                }
            }
    
            /* complete the connection */
            //在这里连接rtsp服务器
            if (ffurl_connect(rt->rtsp_hd, &options)) { 
                av_dict_free(&options);
                err = AVERROR(EIO);
                goto fail;
            }
    
            /* POST requests */
            if (ffurl_alloc(&rt->rtsp_hd_out, httpname, AVIO_FLAG_WRITE,
                            &s->interrupt_callback) < 0 ) { 
                err = AVERROR(EIO);
                goto fail;
            }
    
            /* generate POST headers */
            snprintf(headers, sizeof(headers),
                     "x-sessioncookie: %s\r\n"
                     "Content-Type: application/x-rtsp-tunnelled\r\n"
                     "Pragma: no-cache\r\n"
                     "Cache-Control: no-cache\r\n"
                     "Content-Length: 32767\r\n"
                     "Expires: Sun, 9 Jan 1972 00:00:00 GMT\r\n",
                     sessioncookie);
            av_opt_set(rt->rtsp_hd_out->priv_data, "headers", headers, 0);
            av_opt_set(rt->rtsp_hd_out->priv_data, "chunked_post", "0", 0);
            av_opt_set(rt->rtsp_hd_out->priv_data, "send_expect_100", "0", 0);
    
            /* Initialize the authentication state for the POST session. The HTTP * protocol implementation doesn't properly handle multi-pass * authentication for POST requests, since it would require one of * the following: * - implementing Expect: 100-continue, which many HTTP servers * don't support anyway, even less the RTSP servers that do HTTP * tunneling * - sending the whole POST data until getting a 401 reply specifying * what authentication method to use, then resending all that data * - waiting for potential 401 replies directly after sending the * POST header (waiting for some unspecified time) * Therefore, we copy the full auth state, which works for both basic * and digest. (For digest, we would have to synchronize the nonce * count variable between the two sessions, if we'd do more requests * with the original session, though.) */
            ff_http_init_auth_state(rt->rtsp_hd_out, rt->rtsp_hd);
    
            /* complete the connection */
            if (ffurl_connect(rt->rtsp_hd_out, &options)) { 
                av_dict_free(&options);
                err = AVERROR(EIO);
                goto fail;
            }
            av_dict_free(&options);
        } else { 
            int ret;
            /* open the tcp connection */
            //这里构造tcpname"tcp://172.0.8.21:9980?timeout=100000
            ff_url_join(tcpname, sizeof(tcpname), lower_rtsp_proto, NULL,
                        host, port,
                        "?timeout=%d", rt->stimeout);
                        //这个里面更新分配URLContext **puc
            if ((ret = ffurl_open_whitelist(&rt->rtsp_hd, tcpname, AVIO_FLAG_READ_WRITE,
                           &s->interrupt_callback, NULL, s->protocol_whitelist, s->protocol_blacklist, NULL)) < 0) { 
                err = ret;
                goto fail;
            }
            //这里设置了tcp中flag
            rt->rtsp_hd_out = rt->rtsp_hd;
    	Locals		
    		auth	"\000\000\000\000\00"... (128)	char[128]
    		cmd	"e\000\000\000\000\00000l�\177\000\000@\037\000l"... (2048)	char[2048]
    		default_port	554	int
    		err	<optimized out>	
    		host	"172.0.8.21\000\00"... (1024)	char[1024]
    		https_tunnel	<optimized out>	
    		lower_rtsp_proto	"tcp"	char*
    		lower_transport_mask	2	int
    		path	"/2/analysis\000\000\0"... (1024)	char[1024]
    		peer	@0x7ffdcd3ea8c0	struct sockaddr_storage
    		peer_len	128	socklen_t
    		port	9980	int
    		proto	"rtsp\000\000\0000"... (128)	char[128]
    		real_challenge	"\000\000\000"	char[64]
    		reply	@0x7ffdcd3ea940	RTSPMessageHeader
    		reply1	@0x7ffdcd3ea940	RTSPMessageHeader
    		rt	@0x7ffd6c0032c0	RTSPState
    			accept_dynamic_rate	0	int
    			asf_ctx	0x0	AVFormatContext*
    			asf_pb_pos	0	uint64_t
    			auth	"\000\000\000"... (128)	char[128]
    			auth_state	@0x7ffd6c0035cc	HTTPAuthState
    			buffer_size	-1	int
    			class	@0x7ffff0b76f60	AVClass
    			control_transport	RTSP_MODE_PLAIN (0)	enum RTSPControlTransport
    			control_uri	"rtsp://172.0.8.21:9980/2/analysis\000\0"... (1024)	char[1024]
    			cur_transport_priv	0x0	void*
    			default_lang	"\000\000\000\000"	char[4]
    			get_parameter_supported	0	int
    			initial_pause	0	int
    			initial_timeout	-1	int
    			last_cmd_time	0	int64_t
    			last_reply	"\000\000\000\00"... (2048)	char[2048]
    			last_subscription	"\000\000\000\0"... (1024)	char[1024]
    			lower_transport	RTSP_LOWER_TRANSPORT_UDP (0)	enum RTSPLowerTransport
    			lower_transport_mask	2	int
    			max_p	0	int
    			media_type_mask	15	int
    			nb_byes	0	int
    			nb_rtsp_streams	0	int
    			need_subscription	0	int
    			p	0x0	struct pollfd*
    			packets	0	uint64_t
    			pkt_size	-1	int
    			real_challenge	"\000\000\000\"	char[64]
    			real_setup	0x0	enum AVDiscard*
    			real_setup_cache	0x0	enum AVDiscard*
    			recvbuf	0x0	uint8_t*
    			recvbuf_len	0	int
    			recvbuf_pos	0	int
    			reordering_queue_size	-1	int
    			rtp_muxer_flags	0	int
    			rtp_port_max	65000	int
    			rtp_port_min	5000	int
    			rtsp_flags	0	int
    			rtsp_hd	@0x7ffd6c004bc0	URLContext
    				av_class	@0x7ffff0b72c00	AVClass
    				filename	"tcp://172.0.8.21:9980?timeout=100000"	char*
    			这里确定了是3    flags	3	int
    				interrupt_callback	@0x7ffd6c004bf0	AVIOInterruptCB
    				is_connected	1	int
    				is_streamed	1	int
    				max_packet_size	0	int
    				min_packet_size	0	int
    				priv_data	0x7ffd6c004cc0	void*
    				prot	@0x7ffff0b6f9a0	struct URLProtocol
    				protocol_blacklist	0x0	char*
    				protocol_whitelist	0x0	char*
    				rw_timeout	100000	int64_t
    			rtsp_hd_out	@0x7ffd6c004bc0	URLContext
    			rtsp_streams	0x0	struct RTSPStream**
    			seek_timestamp	0	int64_t
    			seq	0	int
    			server_type	RTSP_SERVER_RTP (0)	enum RTSPServerType
    			session_id	"\000\000\000\0"... (512)	char[512]
    			state	RTSP_STATE_IDLE (0)	enum RTSPClientState
    			stimeout	100000	int
    			timeout	0	int
    			transport	RTSP_TRANSPORT_RTP (0)	enum RTSPTransport
    			ts	0x0	struct MpegTSContext*
    			user_agent	"Lavf58.32.104"	char*
    		s	@0x7ffd6c002c40	AVFormatContext
    		tcp_fd	<optimized out>	
    		tcpname	"tcp://172.0.8.21:9980?timeout=100000\000\000\"... (1024)	char[1024]
    	Inspector		
    	Expressions		
    	Return Value		
    	Tooltip		
    		ff_rtsp_connect	6215344901628760051	int (AVFormatContext *)
    		//这是一个堆栈的参数
    
        }
        rt->seq = 0;
    
        tcp_fd = ffurl_get_file_handle(rt->rtsp_hd);
        if (tcp_fd < 0) { 
            err = tcp_fd;
            goto fail;
        }
        if (!getpeername(tcp_fd, (struct sockaddr*) &peer, &peer_len)) { 
            getnameinfo((struct sockaddr*) &peer, peer_len, host, sizeof(host),
                        NULL, 0, NI_NUMERICHOST);
        }
    
        /* request options supported by the server; this also detects server * type */
        for (rt->server_type = RTSP_SERVER_RTP;;) { 
            cmd[0] = 0;
            if (rt->server_type == RTSP_SERVER_REAL)
                av_strlcat(cmd,
                           /* * The following entries are required for proper * streaming from a Realmedia server. They are * interdependent in some way although we currently * don't quite understand how. Values were copied * from mplayer SVN r23589. * ClientChallenge is a 16-byte ID in hex * CompanyID is a 16-byte ID in base64 */
                           "ClientChallenge: 9e26d33f2984236010ef6253fb1887f7\r\n"
                           "PlayerStarttime: [28/03/2003:22:50:23 00:00]\r\n"
                           "CompanyID: KnKV4M4I/B2FjJ1TToLycw==\r\n"
                           "GUID: 00000000-0000-0000-0000-000000000000\r\n",
                           sizeof(cmd));
            ff_rtsp_send_cmd(s, "OPTIONS", rt->control_uri, cmd, reply, NULL);
            if (reply->status_code != RTSP_STATUS_OK) { 
                err = ff_rtsp_averror(reply->status_code, AVERROR_INVALIDDATA);
                goto fail;
            }
    
            /* detect server type if not standard-compliant RTP */
            if (rt->server_type != RTSP_SERVER_REAL && reply->real_challenge[0]) { 
                rt->server_type = RTSP_SERVER_REAL;
                continue;
            } else if (!av_strncasecmp(reply->server, "WMServer/", 9)) { 
                rt->server_type = RTSP_SERVER_WMS;
            } else if (rt->server_type == RTSP_SERVER_REAL)
                strcpy(real_challenge, reply->real_challenge);
            break;
        }
    
        if (CONFIG_RTSP_DEMUXER && s->iformat)
            err = ff_rtsp_setup_input_streams(s, reply);
        else if (CONFIG_RTSP_MUXER)
            err = ff_rtsp_setup_output_streams(s, host);
        else
            av_assert0(0);
        if (err)
            goto fail;
    
        do { 
            int lower_transport = ff_log2_tab[lower_transport_mask &
                                      ~(lower_transport_mask - 1)];
    
            if ((lower_transport_mask & (1 << RTSP_LOWER_TRANSPORT_TCP))
                    && (rt->rtsp_flags & RTSP_FLAG_PREFER_TCP))
                lower_transport = RTSP_LOWER_TRANSPORT_TCP;
    
            err = ff_rtsp_make_setup_request(s, host, port, lower_transport,
                                     rt->server_type == RTSP_SERVER_REAL ?
                                         real_challenge : NULL);
            if (err < 0)
                goto fail;
            lower_transport_mask &= ~(1 << lower_transport);
            if (lower_transport_mask == 0 && err == 1) { 
                err = AVERROR(EPROTONOSUPPORT);
                goto fail;
            }
        } while (err);
    
        rt->lower_transport_mask = lower_transport_mask;
        av_strlcpy(rt->real_challenge, real_challenge, sizeof(rt->real_challenge));
        rt->state = RTSP_STATE_IDLE;
        rt->seek_timestamp = 0; /* default is to start stream at position zero */
        return 0;
     fail:
        ff_rtsp_close_streams(s);
        ff_rtsp_close_connections(s);
        if (reply->status_code >=300 && reply->status_code < 400 && s->iformat) { 
            char *new_url = av_strdup(reply->location);
            if (!new_url) { 
                err = AVERROR(ENOMEM);
                goto fail2;
            }
            ff_format_set_url(s, new_url);
            rt->session_id[0] = '\0';
            av_log(s, AV_LOG_INFO, "Status %d: Redirecting to %s\n",
                   reply->status_code,
                   s->url);
            goto redirect;
        }
     fail2:
        ff_network_close();
        return err;
    }
    #endif /* CONFIG_RTSP_DEMUXER || CONFIG_RTSP_MUXER */
    //---------------------------
    
    int ffurl_open_whitelist(URLContext **puc, const char *filename, int flags,
                             const AVIOInterruptCB *int_cb, AVDictionary **options,
                             const char *whitelist, const char* blacklist,
                             URLContext *parent)
    { 
        AVDictionary *tmp_opts = NULL;
        AVDictionaryEntry *e;
        //分配空间
        int ret = ffurl_alloc(puc, filename, flags, int_cb);
        if (ret < 0)
            return ret;
        if (parent)
        //输入是空parent
            av_opt_copy(*puc, parent);
            //option也是null
        if (options &&
            (ret = av_opt_set_dict(*puc, options)) < 0)
            goto fail;
            //这里因为传入的option是空所以跳过
        if (options && (*puc)->prot->priv_data_class &&
            (ret = av_opt_set_dict((*puc)->priv_data, options)) < 0)
            goto fail;
    
        if (!options)
            options = &tmp_opts;
    
        av_assert0(!whitelist ||
                   !(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
                   !strcmp(whitelist, e->value));
        av_assert0(!blacklist ||
                   !(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
                   !strcmp(blacklist, e->value));
    
        if ((ret = av_dict_set(options, "protocol_whitelist", whitelist, 0)) < 0)
            goto fail;
    
        if ((ret = av_dict_set(options, "protocol_blacklist", blacklist, 0)) < 0)
            goto fail;
    
        if ((ret = av_opt_set_dict(*puc, options)) < 0)
            goto fail;
    
        ret = ffurl_connect(*puc, options);
    
        if (!ret)
            return 0;
    fail:
        ffurl_close(*puc);
        *puc = NULL;
        return ret;
    }
    
    //puc是null
    int ffurl_alloc(URLContext **puc, const char *filename, int flags,
                    const AVIOInterruptCB *int_cb)
    { 
        const URLProtocol *p = NULL;
    // Locals 
    		filename	"tcp://172.0.8.21:9980?timeout=100000"	char*
    		flags	3	int  //在这里确定
    		int_cb	@0x7ffd6c003108	AVIOInterruptCB
    		p	0x0	URLProtocol*
    		puc	0x0	URLContext*
    
    //寻找协议，这里找到的是tcp
        p = url_find_protocol(filename);
        if (p)
           return url_alloc_for_protocol(puc, p, filename, flags, int_cb);
    
        *puc = NULL;
        if (av_strstart(filename, "https:", NULL) || av_strstart(filename, "tls:", NULL))
            av_log(NULL, AV_LOG_WARNING, "https protocol not found, recompile FFmpeg with "
                                         "openssl, gnutls "
                                         "or securetransport enabled.\n");
        return AVERROR_PROTOCOL_NOT_FOUND;
    }
    
    
    static const struct URLProtocol *url_find_protocol(const char *filename)
    { 
        const URLProtocol **protocols;
        char proto_str[128], proto_nested[128], *ptr;
        size_t proto_len = strspn(filename, URL_SCHEME_CHARS);
        int i;
    
        if (filename[proto_len] != ':' &&
            (strncmp(filename, "subfile,", 8) || !strchr(filename + proto_len + 1, ':')) ||
            is_dos_path(filename))
            strcpy(proto_str, "file");
        else
            av_strlcpy(proto_str, filename,
                       FFMIN(proto_len + 1, sizeof(proto_str)));
    
        av_strlcpy(proto_nested, proto_str, sizeof(proto_nested));
        if ((ptr = strchr(proto_nested, '+')))
            *ptr = '\0';
    //这里获取到协议列表protocols是个全局变量
    //https://blog.csdn.net/weixin_43360707/article/details/116046791
        protocols = ffurl_get_protocols(NULL, NULL);
        if (!protocols)
            return NULL;
        for (i = 0; protocols[i]; i++) { 
                const URLProtocol *up = protocols[i];
                //这里选择
            if (!strcmp(proto_str, up->name)) { 
                av_freep(&protocols);
                return up;
            }
            if (up->flags & URL_PROTOCOL_FLAG_NESTED_SCHEME &&
                !strcmp(proto_nested, up->name)) { 
                av_freep(&protocols);
                return up;
            }
        }
        av_freep(&protocols);
    
        return NULL;
    }
    
    
    
    static int url_alloc_for_protocol(URLContext **puc, const URLProtocol *up,
                                      const char *filename, int flags,
                                      const AVIOInterruptCB *int_cb)
    { 
        URLContext *uc;
        int err;
    
    #if CONFIG_NETWORK
        if (up->flags & URL_PROTOCOL_FLAG_NETWORK && !ff_network_init())
            return AVERROR(EIO);
    #endif
        if ((flags & AVIO_FLAG_READ) && !up->url_read) { 
            av_log(NULL, AV_LOG_ERROR,
                   "Impossible to open the '%s' protocol for reading\n", up->name);
            return AVERROR(EIO);
        }
        if ((flags & AVIO_FLAG_WRITE) && !up->url_write) { 
            av_log(NULL, AV_LOG_ERROR,
                   "Impossible to open the '%s' protocol for writing\n", up->name);
            return AVERROR(EIO);
        }
        uc = av_mallocz(sizeof(URLContext) + strlen(filename) + 1);
        if (!uc) { 
            err = AVERROR(ENOMEM);
            goto fail;
        }
    这里赋值
        uc->av_class = &ffurl_context_class;
        uc->filename = (char *)&uc[1];
        strcpy(uc->filename, filename);
        uc->prot            = up;//zheli fuzhi
        uc->flags           = flags;
        uc->is_streamed     = 0; /* default = not streamed */
        uc->max_packet_size = 0; /* default: stream file */
        if (up->priv_data_size) { 
            uc->priv_data = av_mallocz(up->priv_data_size);
            if (!uc->priv_data) { 
                err = AVERROR(ENOMEM);
                goto fail;
            }
            if (up->priv_data_class) { 
                int proto_len= strlen(up->name);
                char *start = strchr(uc->filename, ',');
                *(const AVClass **)uc->priv_data = up->priv_data_class;
                av_opt_set_defaults(uc->priv_data);
                if(!strncmp(up->name, uc->filename, proto_len) && uc->filename + proto_len == start){ 
                    int ret= 0;
                    char *p= start;
                    char sep= *++p;
                    char *key, *val;
                    p++;
    
                    if (strcmp(up->name, "subfile"))
                        ret = AVERROR(EINVAL);
    
                    while(ret >= 0 && (key= strchr(p, sep)) && p<key && (val = strchr(key+1, sep))){ 
                        *val= *key= 0;
                        if (strcmp(p, "start") && strcmp(p, "end")) { 
                            ret = AVERROR_OPTION_NOT_FOUND;
                        } else
                            ret= av_opt_set(uc->priv_data, p, key+1, 0);
                        if (ret == AVERROR_OPTION_NOT_FOUND)
                            av_log(uc, AV_LOG_ERROR, "Key '%s' not found.\n", p);
                        *val= *key= sep;
                        p= val+1;
                    }
                    if(ret<0 || p!=key){ 
                        av_log(uc, AV_LOG_ERROR, "Error parsing options string %s\n", start);
                        av_freep(&uc->priv_data);
                        av_freep(&uc);
                        err = AVERROR(EINVAL);
                        goto fail;
                    }
                    memmove(start, key+1, strlen(key));
                }
            }
        }
        if (int_cb)
            uc->interrupt_callback = *int_cb;
    
        *puc = uc;
        return 0;
    fail:
        *puc = NULL;
        if (uc)
            av_freep(&uc->priv_data);
        av_freep(&uc);
    #if CONFIG_NETWORK
        if (up->flags & URL_PROTOCOL_FLAG_NETWORK)
            ff_network_close();
    #endif
        return err;
    }
    //返回URLProtocol
    const URLProtocol **ffurl_get_protocols(const char *whitelist,
                                            const char *blacklist)
    { 
        const URLProtocol **ret;
        int i, ret_idx = 0;
    
        ret = av_mallocz_array(FF_ARRAY_ELEMS(url_protocols), sizeof(*ret));
        if (!ret)
            return NULL;
    
        for (i = 0; url_protocols[i]; i++) { 
            const URLProtocol *up = url_protocols[i];
    
            if (whitelist && *whitelist && !av_match_name(up->name, whitelist))
                continue;
            if (blacklist && *blacklist && av_match_name(up->name, blacklist))
                continue;
    
            ret[ret_idx++] = up;
        }
    
        return ret;
    }
    
    
    
    
    //zh这里传入的option是空
    int ffurl_connect(URLContext *uc, AVDictionary **options)
    { 
        int err;
        AVDictionary *tmp_opts = NULL;
        AVDictionaryEntry *e;
    
        if (!options)
            options = &tmp_opts;
    
        // Check that URLContext was initialized correctly and lists are matching if set
        av_assert0(!(e=av_dict_get(*options, "protocol_whitelist", NULL, 0)) ||
                   (uc->protocol_whitelist && !strcmp(uc->protocol_whitelist, e->value)));
        av_assert0(!(e=av_dict_get(*options, "protocol_blacklist", NULL, 0)) ||
                   (uc->protocol_blacklist && !strcmp(uc->protocol_blacklist, e->value)));
    
        if (uc->protocol_whitelist && av_match_list(uc->prot->name, uc->protocol_whitelist, ',') <= 0) { 
            av_log(uc, AV_LOG_ERROR, "Protocol '%s' not on whitelist '%s'!\n", uc->prot->name, uc->protocol_whitelist);
            return AVERROR(EINVAL);
        }
    
        if (uc->protocol_blacklist && av_match_list(uc->prot->name, uc->protocol_blacklist, ',') > 0) { 
            av_log(uc, AV_LOG_ERROR, "Protocol '%s' on blacklist '%s'!\n", uc->prot->name, uc->protocol_blacklist);
            return AVERROR(EINVAL);
        }
    
        if (!uc->protocol_whitelist && uc->prot->default_whitelist) { 
            av_log(uc, AV_LOG_DEBUG, "Setting default whitelist '%s'\n", uc->prot->default_whitelist);
            uc->protocol_whitelist = av_strdup(uc->prot->default_whitelist);
            if (!uc->protocol_whitelist) { 
                return AVERROR(ENOMEM);
            }
        } else if (!uc->protocol_whitelist)
            av_log(uc, AV_LOG_DEBUG, "No default whitelist set\n"); // This should be an error once all declare a default whitelist
    
        if ((err = av_dict_set(options, "protocol_whitelist", uc->protocol_whitelist, 0)) < 0)
            return err;
        if ((err = av_dict_set(options, "protocol_blacklist", uc->protocol_blacklist, 0)) < 0)
            return err;
    //在这里与t服务器connect,
    uc	@0x7ffd6c004bc0	URLContext
    			av_class	@0x7ffff0b72c00	AVClass
    			filename	"tcp://172.0.8.21:9980?timeout=100000"	char*
    			flags	3	int
    			interrupt_callback	@0x7ffd6c004bf0	AVIOInterruptCB
    			is_connected	0	int
    			is_streamed	0	int
    			max_packet_size	0	int
    			min_packet_size	0	int
    			priv_data	0x7ffd6c004cc0	void*
    			prot	@0x7ffff0b6f9a0	struct URLProtocol
    				default_whitelist	0x0	char*
    				flags	2	int
    				name	"tcp"	char*
    				priv_data_class	@0x7ffff0b774c0	AVClass
    				priv_data_size	48	int
    				url_accept	0x7ffff0ac47b0 <tcp_accept>	int (URLContext *, URLContext **)*
    				url_check	0x0	int (URLContext *, int)*
    				url_close	0x7ffff0ac4090 <tcp_close>	int (URLContext *)*
    				url_close_dir	0x0	int (URLContext *)*
    				url_delete	0x0	int (URLContext *)*
    				url_get_file_handle	0x7ffff0ac4050 <tcp_get_file_handle>	int (URLContext *)*
    				url_get_multi_file_handle	0x0	int (URLContext *, int **, int *)*
    				url_get_short_seek	0x7ffff0ac46d0 <tcp_get_window_size>	int (URLContext *)*
    				url_handshake	0x0	int (URLContext *)*
    				url_move	0x0	int (URLContext *, URLContext *)*
    				url_open	0x7ffff0ac4280 <tcp_open>	int (URLContext *, const char *, int)*
    				url_open2	0x0	int (URLContext *, const char *, int, AVDictionary **)*
    				url_open_dir	0x0	int (URLContext *)*
    				url_read	0x7ffff0ac40b0 <tcp_read>	int (URLContext *, unsigned char *, int)*
    				url_read_dir	0x0	int (URLContext *, AVIODirEntry **)*
    				url_read_pause	0x0	int (URLContext *, int)*
    				url_read_seek	0x0	int64_t (URLContext *, int, int64_t, int)*
    				url_seek	0x0	int64_t (URLContext *, int64_t, int)*
    				url_shutdown	0x7ffff0ac4060 <tcp_shutdown>	int (URLContext *, int)*
    				url_write	0x7ffff0ac4740 <tcp_write>	int (URLContext *, const unsigned char *, int)*
    			protocol_blacklist	0x0	char*
    			protocol_whitelist	0x0	char*
    			rw_timeout	0	int64_t为什么是0 qianm前面一直没有赋值
    
    
    、、--------
        err =
            uc->prot->url_open2 ? uc->prot->url_open2(uc,
                                                      uc->filename,
                                                      uc->flags,
                                                      options) :
            uc->prot->url_open(uc, uc->filename, uc->flags);
    
        av_dict_set(options, "protocol_whitelist", NULL, 0);
        av_dict_set(options, "protocol_blacklist", NULL, 0);
    
        if (err)
            return err;
        uc->is_connected = 1;
        /* 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, 0, SEEK_SET) < 0)
                uc->is_streamed = 1;
        return 0;
    }
    
    const URLProtocol ff_tcp_protocol = { 
        .name                = "tcp",
        .url_open            = tcp_open,
        .url_accept          = tcp_accept,
        .url_read            = tcp_read,
        .url_write           = tcp_write,
        .url_close           = tcp_close,
        .url_get_file_handle = tcp_get_file_handle,
        .url_get_short_seek  = tcp_get_window_size,
        .url_shutdown        = tcp_shutdown,
        .priv_data_size      = sizeof(TCPContext),
        .flags               = URL_PROTOCOL_FLAG_NETWORK,
        .priv_data_class     = &tcp_class,
    };
    
    
    /* return non zero if error */
    static int tcp_open(URLContext *h, const char *uri, int flags)
    { 
        struct addrinfo hints = {  0 }, *ai, *cur_ai;
        int port, fd = -1;
        TCPContext *s = h->priv_data;
        const char *p;
        char buf[256];
        int ret;
        char hostname[1024],proto[1024],path[1024];
        char portstr[10];
        s->open_timeout = 5000000;
    //分离proto="tcp“”
        av_url_split(proto, sizeof(proto), NULL, 0, hostname, sizeof(hostname),
            &port, path, sizeof(path), uri);
        if (strcmp(proto, "tcp"))
            return AVERROR(EINVAL);
        if (port <= 0 || port >= 65536) { 
            av_log(h, AV_LOG_ERROR, "Port missing in uri\n");
            return AVERROR(EINVAL);
        }
        p = strchr(uri, '?');
        if (p) { 
            if (av_find_info_tag(buf, sizeof(buf), "listen", p)) { 
                char *endptr = NULL;
                s->listen = strtol(buf, &endptr, 10);
                /* assume if no digits were found it is a request to enable it */
                if (buf == endptr)
                    s->listen = 1;
            }
            if (av_find_info_tag(buf, sizeof(buf), "timeout", p)) { 
            //在这里给raw_timeout赋值filename "tcp://172.0.8.21:9980?timeout=100000" char*
            //堆栈数据https://blog.csdn.net/weixin_43360707/article/details/116059754
                s->rw_timeout = strtol(buf, NULL, 10);
            }
            if (av_find_info_tag(buf, sizeof(buf), "listen_timeout", p)) { 
                s->listen_timeout = strtol(buf, NULL, 10);
            }
        }
        if (s->rw_timeout >= 0) { 
            s->open_timeout =
            h->rw_timeout   = s->rw_timeout;
        }
        hints.ai_family = AF_UNSPEC;
        hints.ai_socktype = SOCK_STREAM;
        snprintf(portstr, sizeof(portstr), "%d", port);
        if (s->listen)
            hints.ai_flags |= AI_PASSIVE;
        if (!hostname[0])
            ret = getaddrinfo(NULL, portstr, &hints, &ai);
        else
            ret = getaddrinfo(hostname, portstr, &hints, &ai);
        if (ret) { 
            av_log(h, AV_LOG_ERROR,
                   "Failed to resolve hostname %s: %s\n",
                   hostname, gai_strerror(ret));
            return AVERROR(EIO);
        }
    
        cur_ai = ai;
    
    #if HAVE_STRUCT_SOCKADDR_IN6
        // workaround for IOS9 getaddrinfo in IPv6 only network use hardcode IPv4 address can not resolve port number.
        if (cur_ai->ai_family == AF_INET6){ 
            struct sockaddr_in6 * sockaddr_v6 = (struct sockaddr_in6 *)cur_ai->ai_addr;
            if (!sockaddr_v6->sin6_port){ 
                sockaddr_v6->sin6_port = htons(port);
            }
        }
    #endif
    
        if (s->listen > 0) { 
            while (cur_ai && fd < 0) { 
                fd = ff_socket(cur_ai->ai_family,
                               cur_ai->ai_socktype,
                               cur_ai->ai_protocol);
                if (fd < 0) { 
                    ret = ff_neterrno();
                    cur_ai = cur_ai->ai_next;
                }
            }
            if (fd < 0)
                goto fail1;
            customize_fd(s, fd);
        }
    
        if (s->listen == 2) { 
            // multi-client
            if ((ret = ff_listen(fd, cur_ai->ai_addr, cur_ai->ai_addrlen)) < 0)
                goto fail1;
        } else if (s->listen == 1) { 
            // single client
            if ((ret = ff_listen_bind(fd, cur_ai->ai_addr, cur_ai->ai_addrlen,
                                      s->listen_timeout, h)) < 0)
                goto fail1;
            // Socket descriptor already closed here. Safe to overwrite to client one.
            fd = ret;
        } else { 
        //真真在这里执行
            ret = ff_connect_parallel(ai, s->open_timeout / 1000, 3, h, &fd, customize_fd, s);
            if (ret < 0)
                goto fail1;
        }
    
        h->is_streamed = 1;
        s->fd = fd;
    
        freeaddrinfo(ai);
        return 0;
    
     fail1:
        if (fd >= 0)
            closesocket(fd);
        freeaddrinfo(ai);
        return ret;
    }
    
    
    
    int ff_connect_parallel(struct addrinfo *addrs, int timeout_ms_per_address,
                            int parallel, URLContext *h, int *fd,
                            void (*customize_fd)(void *, int), void *customize_ctx)
    { 
        struct ConnectionAttempt attempts[3];
        struct pollfd pfd[3];
        int nb_attempts = 0, i, j;
        int64_t next_attempt_us = av_gettime_relative(), next_deadline_us;
        int last_err = AVERROR(EIO);
        socklen_t optlen;
        char errbuf[100], hostbuf[100], portbuf[20];
    
        if (parallel > FF_ARRAY_ELEMS(attempts))
            parallel = FF_ARRAY_ELEMS(attempts);
    
        print_address_list(h, addrs, "Original list of addresses");
        // This mutates the list, but the head of the list is still the same
        // element, so the caller, who owns the list, doesn't need to get
        // an updated pointer.
        interleave_addrinfo(addrs);
        print_address_list(h, addrs, "Interleaved list of addresses");
    
        while (nb_attempts > 0 || addrs) { 
            // Start a new connection attempt, if possible.
            if (nb_attempts < parallel && addrs) { 
                getnameinfo(addrs->ai_addr, addrs->ai_addrlen,
                            hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
                            NI_NUMERICHOST | NI_NUMERICSERV);
                av_log(h, AV_LOG_VERBOSE, "Starting connection attempt to %s port %s\n",
                                          hostbuf, portbuf);
             //在这里连接了
                last_err = start_connect_attempt(&attempts[nb_attempts], &addrs,
                                                 timeout_ms_per_address, h,
                                                 customize_fd, customize_ctx);
                if (last_err < 0) { 
                    av_strerror(last_err, errbuf, sizeof(errbuf));
                    av_log(h, AV_LOG_VERBOSE, "Connected attempt failed: %s\n",
                                              errbuf);
                    continue;
                }
                if (last_err > 0) { 
                    for (i = 0; i < nb_attempts; i++)
                        closesocket(attempts[i].fd);
                    *fd = attempts[nb_attempts].fd;
                    return 0;
                }
                pfd[nb_attempts].fd = attempts[nb_attempts].fd;
                pfd[nb_attempts].events = POLLOUT;
                next_attempt_us = av_gettime_relative() + NEXT_ATTEMPT_DELAY_MS * 1000;
                nb_attempts++;
            }
    
            av_assert0(nb_attempts > 0);
            // The connection attempts are sorted from oldest to newest, so the
            // first one will have the earliest deadline.
            next_deadline_us = attempts[0].deadline_us;
            // If we can start another attempt in parallel, wait until that time.
            if (nb_attempts < parallel && addrs)
                next_deadline_us = FFMIN(next_deadline_us, next_attempt_us);
                //conncect后在这里监听
            last_err = ff_poll_interrupt(pfd, nb_attempts,
                                         (next_deadline_us - av_gettime_relative())/1000,
                                         &h->interrupt_callback);
            if (last_err < 0 && last_err != AVERROR(ETIMEDOUT))
                break;
    
            // Check the status from the poll output.
            for (i = 0; i < nb_attempts; i++) { 
                last_err = 0;
                if (pfd[i].revents) { 
                    // Some sort of action for this socket, check its status (either
                    // a successful connection or an error).
                    optlen = sizeof(last_err);
                    if (getsockopt(attempts[i].fd, SOL_SOCKET, SO_ERROR, &last_err, &optlen))
                        last_err = ff_neterrno();
                    else if (last_err != 0)
                        last_err = AVERROR(last_err);
                    if (last_err == 0) { 
                        // Everything is ok, we seem to have a successful
                        // connection. Close other sockets and return this one.
                        for (j = 0; j < nb_attempts; j++)
                            if (j != i)
                                closesocket(attempts[j].fd);
                        *fd = attempts[i].fd;
                        getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
                                    hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
                                    NI_NUMERICHOST | NI_NUMERICSERV);
                        av_log(h, AV_LOG_VERBOSE, "Successfully connected to %s port %s\n",
                                                  hostbuf, portbuf);
                        return 0;
                    }
                }
                if (attempts[i].deadline_us < av_gettime_relative() && !last_err)
                    last_err = AVERROR(ETIMEDOUT);
                if (!last_err)
                    continue;
                // Error (or timeout) for this socket; close the socket and remove
                // it from the attempts/pfd arrays, to let a new attempt start
                // directly.
                getnameinfo(attempts[i].addr->ai_addr, attempts[i].addr->ai_addrlen,
                            hostbuf, sizeof(hostbuf), portbuf, sizeof(portbuf),
                            NI_NUMERICHOST | NI_NUMERICSERV);
                av_strerror(last_err, errbuf, sizeof(errbuf));
                av_log(h, AV_LOG_VERBOSE, "Connection attempt to %s port %s "
                                          "failed: %s\n", hostbuf, portbuf, errbuf);
                closesocket(attempts[i].fd);
                memmove(&attempts[i], &attempts[i + 1],
                        (nb_attempts - i - 1) * sizeof(*attempts));
                memmove(&pfd[i], &pfd[i + 1],
                        (nb_attempts - i - 1) * sizeof(*pfd));
                i--;
                nb_attempts--;
            }
        }
        for (i = 0; i < nb_attempts; i++)
            closesocket(attempts[i].fd);
        if (last_err >= 0)
            last_err = AVERROR(ECONNREFUSED);
        if (last_err != AVERROR_EXIT) { 
            av_strerror(last_err, errbuf, sizeof(errbuf));
            av_log(h, AV_LOG_ERROR, "Connection to %s failed: %s\n",
                   h->filename, errbuf);
        }
        return last_err;
    }
    
    
    
    
    // Returns < 0 on error, 0 on successfully started connection attempt,
    // > 0 for a connection that succeeded already.
    static int start_connect_attempt(struct ConnectionAttempt *attempt,
                                     struct addrinfo **ptr, int timeout_ms,
                                     URLContext *h,
                                     void (*customize_fd)(void *, int), void *customize_ctx)
    { 
        struct addrinfo *ai = *ptr;
        int ret;
    
        *ptr = ai->ai_next;
    
        attempt->fd = ff_socket(ai->ai_family, ai->ai_socktype, ai->ai_protocol);
        if (attempt->fd < 0)
            return ff_neterrno();
        attempt->deadline_us = av_gettime_relative() + timeout_ms * 1000;
        attempt->addr = ai;
    
        ff_socket_nonblock(attempt->fd, 1);
    
        if (customize_fd)
            customize_fd(customize_ctx, attempt->fd);
    //在这里connect
        while ((ret = connect(attempt->fd, ai->ai_addr, ai->ai_addrlen))) { 
            ret = ff_neterrno();
            switch (ret) { 
            case AVERROR(EINTR):
                if (ff_check_interrupt(&h->interrupt_callback)) { 
                    closesocket(attempt->fd);
                    attempt->fd = -1;
                    return AVERROR_EXIT;
                }
                continue;
            case AVERROR(EINPROGRESS):
            case AVERROR(EAGAIN):
                return 0;
            default:
                closesocket(attempt->fd);
                attempt->fd = -1;
                return ret;
            }
        }
        return 1;
    }
    
    static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout,
                                 AVIOInterruptCB *cb)
    { 
        int runs = timeout / POLLING_TIME;、
        int ret = 0;
    
        do { 
            if (ff_check_interrupt(cb))
                return AVERROR_EXIT;
            ret = poll(p, nfds, POLLING_TIME);
            if (ret != 0) { 
                if (ret < 0)
                    ret = ff_neterrno();
                if (ret == AVERROR(EINTR))
                    continue;
                break;
            }
            //我们设置的时间在这里循环
        } while (timeout <= 0 || runs-- > 0);
    
        if (!ret)
            return AVERROR(ETIMEDOUT);
        return ret;
    }