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

骑猪看日落 2023-01-14 11:00 159阅读 0赞

两种方法：  
设置回调打断函数和设置超时

超时
     av_dict_set(&inputDic, "stimeout", "2*1000*1000", 0); // milliseconds
     
     //打断回调
      m_avformatCtx->interrupt_callback.callback = interrupt_cb;
      m_avformatCtx->interrupt_callback.opaque = this;
      //两者有什么区别吗?接着往下看

那么这个回调函数在什么时候起作用呢，以前一直以为是网络超时后执行，后来看源码发现不是，这个函数是在执行poll之前调用  
这里我们以输入rtsp://xxxx/xxx为例  
在下面init\_input中确认AVInputFormat

AVInputFormat ff_rtsp_demuxer = { 
        .name           = "rtsp",
        .long_name      = NULL_IF_CONFIG_SMALL("RTSP input"),
        .priv_data_size = sizeof(RTSPState),
        .read_probe     = rtsp_probe,
        .read_header    = rtsp_read_header,
        .read_packet    = rtsp_read_packet,
        .read_close     = rtsp_read_close,
        .read_seek      = rtsp_read_seek,
        .flags          = AVFMT_NOFILE,
        .read_play      = rtsp_read_play,
        .read_pause     = rtsp_read_pause,
        .priv_class     = &rtsp_demuxer_class,
    };

这是调用栈  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MDcwNw_size_16_color_FFFFFF_t_70]  
其中rtsp\_read\_head 就是if ((ret = s->iformat->read\_header(s)) < 0)这里执行的。  
有关网络IO阻塞的要看nework.h network.c这两个文件  
另外最关键的就是tcp\_open了，有一步是ff\_connect\_parallel，在这里进行start\_connect\_attempt，这里有真正的connect，在这里注意下，作者在这里设置了 ff\_socket\_nonblock(attempt->fd, 1);  
int ff\_socket\_nonblock(int socket, int enable)，也就是说作者将socket设置为了非阻塞，也就是ffmpeg中socket是非阻塞的。

avformat_open_input-->init_input（）
     s->iformat->read_header(s)--> ff_rtsp_connect(s)-->ffurl_connect(*puc, options)-->
     url_open2()-->tcp_open()-->ff_connect_parallel()--> start_connect_attempt（）-->ff_socket()-->
     ff_socket_nonblock(attempt->fd, 1)-->connect()-->
     ff_poll_interrupt()-->
    
    //因为在上面connect中将fd设置为非阻塞，所以在这里通过poll来确认是否连接上服务端
      static int ff_poll_interrupt(struct pollfd *p, nfds_t nfds, int timeout,AVIOInterruptCB *cb)
    { 
    // 这个run 是我们这里设置的喔 av_dict_set(&inputDic, "stimeout", "2*1000*1000", 0); // milliseconds
        int runs = timeout / POLLING_TIME;
        int ret = 0;
    
        do { 
        //每次poll之前执行一次ff_check_interrupt，这个函数里面调用的就是我们前面设置的打断回调函数
        //所以跟我想的不一样，他是poll之前，不是之后，只要返回非0就返回
            if (ff_check_interrupt(cb))
                return AVERROR_EXIT;
           //#define POLLING_TIME 100 /// Time in milliseconds between interrupt check
           //也就是poll的超时是作者写死的milliseconds 千分之一秒100毫秒
           
            ret = poll(p, nfds, POLLING_TIME);
            if (ret != 0) { 
                if (ret < 0)
                    ret = ff_neterrno();
                if (ret == AVERROR(EINTR))
                    continue;
                break;
            }
            //相当于我们设置的超时是100毫秒的倍数，确定循环几次
        } while (timeout <= 0 || runs-- > 0);//我们设置的超时在这里
        
    
        if (!ret)
            return AVERROR(ETIMEDOUT);
        return ret;
    }

int avformat_open_input(AVFormatContext **ps, const char *filename,
                            ff_const59 AVInputFormat *fmt除非内存中读取，否则一般为null, AVDictionary **options)
                            
    { 
    //----------------------------------
    调用堆栈信息
    https://blog.csdn.net/weixin_43360707/article/details/116054164
    //--------------------------------
        AVFormatContext *s = *ps;
        int i, ret = 0;
        AVDictionary *tmp = NULL;
        ID3v2ExtraMeta *id3v2_extra_meta = NULL;
    //如果是空，则申请地址
        if (!s && !(s = avformat_alloc_context()))
            return AVERROR(ENOMEM);
                /** * A class for logging and @ref avoptions. Set by avformat_alloc_context(). * Exports (de)muxer private options if they exist. */
        //这是AVFormatContext 第一个参数const AVClass *av_class;
        if (!s->av_class) { 
            av_log(NULL, AV_LOG_ERROR, "Input context has not been properly allocated by avformat_alloc_context() and is not NULL either\n");
            return AVERROR(EINVAL);
        }
        if (fmt)
        //copy AVInputFormat
            s->iformat = fmt;
    
        if (options)
        //将optin拷贝一份
            av_dict_copy(&tmp, *options, 0);
    
        if (s->pb) // must be before any goto fail
            s->flags |= AVFMT_FLAG_CUSTOM_IO;
    //设置参数av_opt_set_dict2（）
        if ((ret = av_opt_set_dict(s, &tmp)) < 0)
            goto fail;
    
        if (!(s->url = av_strdup(filename ? filename : ""))) { 、、filename=url
            ret = AVERROR(ENOMEM);
            goto fail;
        }
    
    #if FF_API_FORMAT_FILENAME
    FF_DISABLE_DEPRECATION_WARNINGS
        av_strlcpy(s->filename, filename ? filename : "", sizeof(s->filename));
    FF_ENABLE_DEPRECATION_WARNINGS
    #endif
    //注意这里确认AVInputFormat格式，rtsp的话，就是ff_rtsp_demuxer
        if ((ret = init_input(s, filename, &tmp)) < 0)
            goto fail;
        s->probe_score = ret;
    //这里设置白名单和黑
        if (!s->protocol_whitelist && s->pb && s->pb->protocol_whitelist) { 
            s->protocol_whitelist = av_strdup(s->pb->protocol_whitelist);
            if (!s->protocol_whitelist) { 
                ret = AVERROR(ENOMEM);
                goto fail;
            }
        }
    
        if (!s->protocol_blacklist && s->pb && s->pb->protocol_blacklist) { 
            s->protocol_blacklist = av_strdup(s->pb->protocol_blacklist);
            if (!s->protocol_blacklist) { 
                ret = AVERROR(ENOMEM);
                goto fail;
            }
        }
    
        if (s->format_whitelist && av_match_list(s->iformat->name, s->format_whitelist, ',') <= 0) { 
            av_log(s, AV_LOG_ERROR, "Format not on whitelist \'%s\'\n", s->format_whitelist);
            ret = AVERROR(EINVAL);
            goto fail;
        }
    
        avio_skip(s->pb, s->skip_initial_bytes);
    
        /* Check filename in case an image number is expected. */
        if (s->iformat->flags & AVFMT_NEEDNUMBER) { 
            if (!av_filename_number_test(filename)) { 
                ret = AVERROR(EINVAL);
                goto fail;
            }
        }
    
        s->duration = s->start_time = AV_NOPTS_VALUE;
    
        /* Allocate private data. */
        //这里根据iformat给privateFpei kongjian 
        if (s->iformat->priv_data_size > 0) { 
            if (!(s->priv_data = av_mallocz(s->iformat->priv_data_size))) { 
                ret = AVERROR(ENOMEM);
                goto fail;
            }
            //这里给priv_data赋值
            if (s->iformat->priv_class) { 
                *(const AVClass **) s->priv_data = s->iformat->priv_class;
                //设置默认值
                av_opt_set_defaults(s->priv_data);
                //这里为private设置
                if ((ret = av_opt_set_dict(s->priv_data, &tmp)) < 0)
                    goto fail;
            }
        }
    
        /* e.g. AVFMT_NOFILE formats will not have a AVIOContext */
        if (s->pb)
            ff_id3v2_read_dict(s->pb, &s->internal->id3v2_meta, ID3v2_DEFAULT_MAGIC, &id3v2_extra_meta);
    
    
        if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->iformat->read_header)
        //在这里会执行一次打断函数 ，这里readheader是一个回调函数，这个是init_input这里确定出来的
            if ((ret = s->iformat->read_header(s)) < 0)
                goto fail;
    
        if (!s->metadata) { 
            s->metadata = s->internal->id3v2_meta;
            s->internal->id3v2_meta = NULL;
        } else if (s->internal->id3v2_meta) { 
            av_log(s, AV_LOG_WARNING, "Discarding ID3 tags because more suitable tags were found.\n");
            av_dict_free(&s->internal->id3v2_meta);
        }
    
        if (id3v2_extra_meta) { 
            if (!strcmp(s->iformat->name, "mp3") || !strcmp(s->iformat->name, "aac") ||
                !strcmp(s->iformat->name, "tta") || !strcmp(s->iformat->name, "wav")) { 
                if ((ret = ff_id3v2_parse_apic(s, id3v2_extra_meta)) < 0)
                    goto close;
                if ((ret = ff_id3v2_parse_chapters(s, id3v2_extra_meta)) < 0)
                    goto close;
                if ((ret = ff_id3v2_parse_priv(s, id3v2_extra_meta)) < 0)
                    goto close;
            } else
                av_log(s, AV_LOG_DEBUG, "demuxer does not support additional id3 data, skipping\n");
        }
        ff_id3v2_free_extra_meta(&id3v2_extra_meta);
    
        if ((ret = avformat_queue_attached_pictures(s)) < 0)
            goto close;
    
        if (!(s->flags&AVFMT_FLAG_PRIV_OPT) && s->pb && !s->internal->data_offset)
            s->internal->data_offset = avio_tell(s->pb);
    
        s->internal->raw_packet_buffer_remaining_size = RAW_PACKET_BUFFER_SIZE;
    
        update_stream_avctx(s);
    
        for (i = 0; i < s->nb_streams; i++)
            s->streams[i]->internal->orig_codec_id = s->streams[i]->codecpar->codec_id;
    
        if (options) { 
            av_dict_free(options);
            *options = tmp;
        }
        *ps = s;
        return 0;
    
    close:
        if (s->iformat->read_close)
            s->iformat->read_close(s);
    fail:
        ff_id3v2_free_extra_meta(&id3v2_extra_meta);
        av_dict_free(&tmp);
        if (s->pb && !(s->flags & AVFMT_FLAG_CUSTOM_IO))
            avio_closep(&s->pb);
        avformat_free_context(s);
        *ps = NULL;
        return ret;
    }
    
    * return non zero if error */
    *
    }
    
    
    
    ********************************************
    //这里设置option选项
    int av_opt_set_dict(void *obj, AVDictionary **options)
    { 
        return av_opt_set_dict2(obj, options, 0);
    }
    
    int av_opt_set_dict2(void *obj, AVDictionary **options, int search_flags)
    { 
        AVDictionaryEntry *t = NULL;
        AVDictionary    *tmp = NULL;
        int ret = 0;
    
        if (!options)
            return 0;
    
    //这里他typedef struct AVDictionaryEntry { 
    // char *key;
    // char *value;
    //} AVDictionaryEntry;
    //那么第一个就是
    //t @0x7ffd70001450 AVDictionaryEntry
    // key "rtsp_transport" char*
    // value "tcp" char*
    // key "stimeout" char*
    // value "100*100" char*
    
        while ((t = av_dict_get(*options, "", t, AV_DICT_IGNORE_SUFFIX))) { 
            ret = av_opt_set(obj, t->key, t->value, search_flags);//search_flags=0
            if (ret == AVERROR_OPTION_NOT_FOUND)
                ret = av_dict_set(&tmp, t->key, t->value, 0);
            if (ret < 0) { 
                av_log(obj, AV_LOG_ERROR, "Error setting option %s to value %s.\n", t->key, t->value);
                av_dict_free(&tmp);
                return ret;
            }
            ret = 0;
        }
        av_dict_free(options);
        *options = tmp;
        return ret;
    }
    
    AVDictionaryEntry *av_dict_get(const AVDictionary *m, const char *key,
                                   const AVDictionaryEntry *prev, int flags)
    { 
        unsigned int i, j;
    
        if (!m)
            return NULL;
    
        if (prev)
            i = prev - m->elems + 1;
        else
            i = 0;
    
        for (; i < m->count; i++) { 
        //s 就是rtsp_transport
            const char *s = m->elems[i].key;
            if (flags & AV_DICT_MATCH_CASE)
                for (j = 0; s[j] == key[j] && key[j]; j++)
                    ;
            else
            //转出小写
                for (j = 0; av_toupper(s[j]) == av_toupper(key[j]) && key[j]; j++)
                    ;
            if (key[j])
                continue;
            if (s[j] && !(flags & AV_DICT_IGNORE_SUFFIX))
                continue;
                //返回第一个
            return &m->elems[i];
        }
        return NULL;
    }
    
    
    //name就是rtsp_transport val= tcp
    int av_opt_set(void *obj, const char *name, const char *val, int search_flags)
    { 
        int ret = 0;
        void *dst, *target_obj;
        //
        const AVOption *o = av_opt_find2(obj, name, NULL, 0, search_flags, &target_obj);
        if (!o || !target_obj)
            return AVERROR_OPTION_NOT_FOUND;
        if (!val && (o->type != AV_OPT_TYPE_STRING &&
                     o->type != AV_OPT_TYPE_PIXEL_FMT && o->type != AV_OPT_TYPE_SAMPLE_FMT &&
                     o->type != AV_OPT_TYPE_IMAGE_SIZE && o->type != AV_OPT_TYPE_VIDEO_RATE &&
                     o->type != AV_OPT_TYPE_DURATION && o->type != AV_OPT_TYPE_COLOR &&
                     o->type != AV_OPT_TYPE_CHANNEL_LAYOUT && o->type != AV_OPT_TYPE_BOOL))
            return AVERROR(EINVAL);
    
        if (o->flags & AV_OPT_FLAG_READONLY)
            return AVERROR(EINVAL);
    
        if (o->flags & AV_OPT_FLAG_DEPRECATED)
            av_log(obj, AV_LOG_WARNING, "The \"%s\" option is deprecated: %s\n", name, o->help);
    
        dst = ((uint8_t *)target_obj) + o->offset;
        switch (o->type) { 
        case AV_OPT_TYPE_BOOL:
            return set_string_bool(obj, o, val, dst);
        case AV_OPT_TYPE_STRING:
            return set_string(obj, o, val, dst);
        case AV_OPT_TYPE_BINARY:
            return set_string_binary(obj, o, val, dst);
        case AV_OPT_TYPE_FLAGS:
        case AV_OPT_TYPE_INT:
        case AV_OPT_TYPE_INT64:
        case AV_OPT_TYPE_UINT64:
        case AV_OPT_TYPE_FLOAT:
        case AV_OPT_TYPE_DOUBLE:
        case AV_OPT_TYPE_RATIONAL:
            return set_string_number(obj, target_obj, o, val, dst);
        case AV_OPT_TYPE_IMAGE_SIZE:
            return set_string_image_size(obj, o, val, dst);
        case AV_OPT_TYPE_VIDEO_RATE: { 
            AVRational tmp;
            ret = set_string_video_rate(obj, o, val, &tmp);
            if (ret < 0)
                return ret;
            return write_number(obj, o, dst, 1, tmp.den, tmp.num);
        }
        case AV_OPT_TYPE_PIXEL_FMT:
            return set_string_pixel_fmt(obj, o, val, dst);
        case AV_OPT_TYPE_SAMPLE_FMT:
            return set_string_sample_fmt(obj, o, val, dst);
        case AV_OPT_TYPE_DURATION:
            { 
                int64_t usecs = 0;
                if (val) { 
                    if ((ret = av_parse_time(&usecs, val, 1)) < 0) { 
                        av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as duration\n", val);
                        return ret;
                    }
                }
                if (usecs < o->min || usecs > o->max) { 
                    av_log(obj, AV_LOG_ERROR, "Value %f for parameter '%s' out of range [%g - %g]\n",
                           usecs / 1000000.0, o->name, o->min / 1000000.0, o->max / 1000000.0);
                    return AVERROR(ERANGE);
                }
                *(int64_t *)dst = usecs;
                return 0;
            }
        case AV_OPT_TYPE_COLOR:
            return set_string_color(obj, o, val, dst);
        case AV_OPT_TYPE_CHANNEL_LAYOUT:
            if (!val || !strcmp(val, "none")) { 
                *(int64_t *)dst = 0;
            } else { 
                int64_t cl = av_get_channel_layout(val);
                if (!cl) { 
                    av_log(obj, AV_LOG_ERROR, "Unable to parse option value \"%s\" as channel layout\n", val);
                    ret = AVERROR(EINVAL);
                }
                *(int64_t *)dst = cl;
                return ret;
            }
            break;
        }
    
        av_log(obj, AV_LOG_ERROR, "Invalid option type.\n");
        return AVERROR(EINVAL);
    }
    
    
    
    const AVOption *av_opt_find2(void *obj, const char *name, const char *unit,
                                 int opt_flags, int search_flags, void **target_obj)
    { 
        const AVClass  *c;
        const AVOption *o = NULL;
    
        if(!obj)
            return NULL;
    //这里把obj转为AVClass，avformat第一个元素就是ta 
        c= *(AVClass**)obj;
    
        if (!c)
            return NULL;
    //没有children 所以直接跳过
        if (search_flags & AV_OPT_SEARCH_CHILDREN) { 
            if (search_flags & AV_OPT_SEARCH_FAKE_OBJ) { 
                const AVClass *child = NULL;
                while (child = av_opt_child_class_next(c, child))
                    if (o = av_opt_find2(&child, name, unit, opt_flags, search_flags, NULL))
                        return o;
            } else { 
                void *child = NULL;
                while (child = av_opt_child_next(obj, child))
                    if (o = av_opt_find2(child, name, unit, opt_flags, search_flags, target_obj))
                        return o;
            }
        }
    //返回o name "rtsp_transport" char*
    		o	@0x7ffff0b6a100	AVOption
    			default_val	@0x7ffff0b6a118	union { ...}
    				dbl	0	double
    				i64	0	int64_t
    				q	@0x7ffff0b6a118	AVRational
    				str	0x0	char*
    			flags	3	int
    			help	0x0	char*
    			max	2147483647	double
    			min	-2147483648	double
    			name	"avioflags"	char*
    			offset	1292	int
    			type	AV_OPT_TYPE_FLAGS (0)	enum AVOptionType
    			unit	"avioflags"	char*
    		obj	0x7ffd70002c40	void*
    		opt_flags	0	int
    		search_flags	0	int
    		target_obj	0x7ffd70002070	void*
    		unit	0x0	char*
    		//------------------------------------
    		
        while (o = av_opt_next(obj, o)) { 
        //zhe这里没看懂？？？？？？？
        //o->name=avioflags name=rtsp+ransport 这里比较
        //https://blog.csdn.net/weixin_43360707/article/details/116056658
            if (!strcmp(o->name, name) && (o->flags & opt_flags) == opt_flags &&
                ((!unit && o->type != AV_OPT_TYPE_CONST) ||
                 (unit  && o->type == AV_OPT_TYPE_CONST && o->unit && !strcmp(o->unit, unit)))) { 
                if (target_obj) { 
                    if (!(search_flags & AV_OPT_SEARCH_FAKE_OBJ))
                        *target_obj = obj;
                    else
                        *target_obj = NULL;
                }
                return o;
            }
        }
        return NULL;
    }
    
    
    
    const AVOption *av_opt_next(const void *obj, const AVOption *last)
    { 
        const AVClass *class;
        if (!obj)
            return NULL;
        class = *(const AVClass**)obj;
        //-----
    	Locals		class堆栈消息 zhe这是rtsp_transport进入的时候的堆栈
    		class	@0x7ffff0b6a0a0	AVClass
    			category	AV_CLASS_CATEGORY_MUXER (3)	AVClassCategory
    			child_class_next	0x7ffff0a7a850 <format_child_class_next>	const struct AVClass *(const struct AVClass *)*
    			child_next	0x7ffff0a7a660 <format_child_next>	void *(void *, void *)*
    			class_name	"AVFormatContext"	char*
    			get_category	0x7ffff0a7a6c0 <get_category>	AVClassCategory (void *)*
    			item_name	0x7ffff0a7a820 <format_to_name>	const char *(void *)*
    			log_level_offset_offset	0	int
    			option	@0x7ffff0b6a100	struct AVOption
    				default_val	@0x7ffff0b6a118	union { ...}
    				flags	3	int//zhe这个是写死的
    				help	0x0	char*
    				max	2147483647	double
    				min	-2147483648	double
    				name	"avioflags"	char*
    				offset	1292	int
    				type	AV_OPT_TYPE_FLAGS (0)	enum AVOptionType
    				unit	"avioflags"	char*
    			parent_log_context_offset	0	int
    			query_ranges	0x0	int (struct AVOptionRanges **, void *, const char *, int)*
    			version	3679076	int
    		last	0x0	AVOption*//主要就是跟这个比较
    		obj	0x7ffd6c002c40	void*
    	Inspector		
    	Expressions		
    		up	<no such value>	 
    		url_protocols	@0x7ffff0b76680	URLProtocol*[29]
    	Return Value		
    	Tooltip		
    		AVERROR_OPTION_NOT_FOUND	-1414549496	int
    		AV_OPT_SEARCH_FAKE_OBJ	2	int
    		Error	<no such value>	 
    		av_dict_get	6215344901628760051	AVDictionaryEntry *(const AVDictionary *, const char *, const AVDictionaryEntry *, int)
    		av_dict_set	6215344901628760051	int (AVDictionary **, const char *, const char *, int)
    		av_opt_set	9890282197563084787	int (void *, const char *, const char *, int)
    
    这是stimeout进入时的堆栈
    	Locals		
    		class	@0x7ffff0b76f60	AVClass
    			category	AV_CLASS_CATEGORY_NA (0)	AVClassCategory
    			child_class_next	0x0	const struct AVClass *(const struct AVClass *)*
    			child_next	0x0	void *(void *, void *)*
    			class_name	"RTSP demuxer"	char* //这里已经实例化了class了
    			get_category	0x0	AVClassCategory (void *)*
    			item_name	0x7fffef180650 <av_default_item_name>	const char *(void *)*
    			log_level_offset_offset	0	int
    			option	@0x7ffff0b6df80	struct AVOption
    				default_val	@0x7ffff0b6df98	union { ...}
    				flags	2	int
    				help	"do not start playing the stream immediately"	char*
    				max	1	double
    				min	0	double
    				name	"initial_pause"	char*
    				offset	5864	int
    				type	AV_OPT_TYPE_BOOL (18)	enum AVOptionType
    				unit	0x0	char*
    			parent_log_context_offset	0	int
    			query_ranges	0x0	int (struct AVOptionRanges **, void *, const char *, int)*
    			version	3679076	int
    		last	0x0	AVOption*
    		obj	0x7ffd6c0032c0	void*
    	Inspector		
    	Expressions		
    		up	<no such value>	 
    		url_protocols	@0x7ffff0b76680	URLProtocol*[29]
    	Return Value		
    	Tooltip		
    		AVERROR_OPTION_NOT_FOUND	-1414549496	int
    		AV_OPT_SEARCH_FAKE_OBJ	2	int
    		Error	<no such value>	 
    		av_dict_get	6215344901628760051	AVDictionaryEntry *(const AVDictionary *, const char *, const AVDictionaryEntry *, int)
    		av_dict_set	6215344901628760051	int (AVDictionary **, const char *, const char *, int)
    		av_opt_child_class_next	5258103515776946163	const AVClass *(const AVClass *, const AVClass *)
    		av_opt_set	9890282197563084787	int (void *, const char *, const char *, int)
    
    //-----
    //last一直在变化
        if (!last && class && class->option && class->option[0].name)
        //在这里直接返回
            return class->option;
        if (last && last[1].name)
            return ++last;
        return NULL;
    }
    
    /* Open input file and probe the format if necessary. */
    static int init_input(AVFormatContext *s, const char *filename,
                          AVDictionary **options)
    { 
        int ret;
        AVProbeData pd = {  filename, NULL, 0 };
        int score = AVPROBE_SCORE_RETRY;
    
        if (s->pb) { 
            s->flags |= AVFMT_FLAG_CUSTOM_IO;
            if (!s->iformat)
                return av_probe_input_buffer2(s->pb, &s->iformat, filename,
                                             s, 0, s->format_probesize);
            else if (s->iformat->flags & AVFMT_NOFILE)
                av_log(s, AV_LOG_WARNING, "Custom AVIOContext makes no sense and "
                                          "will be ignored with AVFMT_NOFILE format.\n");
            return 0;
        }
    
        if ((s->iformat && s->iformat->flags & AVFMT_NOFILE) ||
            (!s->iformat && (s->iformat = av_probe_input_format2(&pd, 0, &score))))
            return score;
    这个只有在内存中读取数据的时候才有用，包括avio_flags 以及options
        if ((ret = s->io_open(s, &s->pb, filename, AVIO_FLAG_READ | s->avio_flags, options)) < 0)
            return ret;
    
        if (s->iformat)
            return 0;
        return av_probe_input_buffer2(s->pb, &s->iformat, filename,
                                     s, 0, s->format_probesize);
    }
    
    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;
    
        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)) { 
                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 { 
        //对于avformat_Open_input是在这里执行
        //这里的open_timeout，rw_timeout都是前面设置的2s
            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;
    }
    //这里是rtsp_read_header
    static int rtsp_read_header(AVFormatContext *s)
    { 
        RTSPState *rt = s->priv_data;
        int ret;
    //进入的堆栈信息https://blog.csdn.net/weixin_43360707/article/details/116057577
        if (rt->initial_timeout > 0)
            rt->rtsp_flags |= RTSP_FLAG_LISTEN;
    
        if (rt->rtsp_flags & RTSP_FLAG_LISTEN) { 
            ret = rtsp_listen(s);
            if (ret)
                return ret;
        } else { 
        //作为客户端，执行函数在这里
            ret = ff_rtsp_connect(s);
            if (ret)
                return ret;
    
            rt->real_setup_cache = !s->nb_streams ? NULL :
                av_mallocz_array(s->nb_streams, 2 * sizeof(*rt->real_setup_cache));
            if (!rt->real_setup_cache && s->nb_streams)
                return AVERROR(ENOMEM);
            rt->real_setup = rt->real_setup_cache + s->nb_streams;
    
            if (rt->initial_pause) { 
                /* do not start immediately */
            } else { 
                if ((ret = rtsp_read_play(s)) < 0) { 
                    ff_rtsp_close_streams(s);
                    ff_rtsp_close_connections(s);
                    return ret;
                }
            }
        }
    
        return 0;
    }

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3dlaXhpbl80MzM2MDcwNw_size_16_color_FFFFFF_t_70]: /images/20221022/95193473c94443d9b6f76e945403f10e.png