自学教程：C++ url_fclose函数代码示例

char * read_page(char * url){    URL_FILE * page = url_fopen(url, "rb");    if (page == NULL)        return NULL;    char * result = (char *)malloc(1024 * 1024);    if (result == NULL)    {        url_fclose(page);        return NULL;    }    result[0] = '/0';    if (page != NULL)    {        char buffer[8];        int n = 0;        n = url_fread(buffer, 1, 8, page);        while(n > 0)        {            strncat(result, buffer, n);            n = url_fread(buffer, 1, 8, page);        }    }    url_fclose(page);    return result;}

void CFFMPEGLoader::Delete() {    for(UINT i=0; i<FFMPEG_PACKET_MAX_SIZE; i++) {        if(pktLastAudio[i].data)            av_free_packet(&pktLastAudio[i]);        if(pktLastVideo[i].data)            av_free_packet(&pktLastVideo[i]);    }    if (pVideoStream)        avcodec_close(pVideoStream->codec);    if (pAudioStream)        avcodec_close(pAudioStream->codec);    if(pFrameRGB!=NULL)        av_free(pFrameRGB);    if(pFrame!=NULL)        av_free(pFrame);    if(pVCodecCon!=NULL)        avcodec_close(pVCodecCon);    if(pFormatCon!=NULL) {        if(!bOutput)            av_close_input_file(pFormatCon);        else {            if (!(pFormatCon->oformat->flags & AVFMT_NOFILE)) {                /* close the output file */#ifndef WIN32                url_fclose(pFormatCon->pb);#else                url_fclose(&pFormatCon->pb);#endif            }            av_free(pFormatCon);        }    }}

/* * Import data into GPDB. */Datumgphdfsprotocol_import(PG_FUNCTION_ARGS){	char     *data;	int	      datlen;	size_t    nread = 0;	gphdfs_import_t *myData;	/* Must be called via the external table format manager */	if (!CALLED_AS_EXTPROTOCOL(fcinfo))		elog(ERROR, "cannot execute gphdfsprotocol_import outside protocol manager");	/* Get our internal description of the protocol */	myData = (gphdfs_import_t*) EXTPROTOCOL_GET_USER_CTX(fcinfo);	/* =======================================================================	 *                            DO LAST CALL	 *                            Nothing to be done if it has already been closed	 * ======================================================================= */	if (EXTPROTOCOL_IS_LAST_CALL(fcinfo))	{		if (myData != NULL && !myData->importDone)			url_fclose(myData->importFile, false, "gphdfs protocol");		PG_RETURN_INT32(0);	}	/* =======================================================================	 *                            DO OPEN	 * ======================================================================= */	if (myData == NULL)	{		myData = palloc(sizeof(gphdfs_import_t));		myData->importFile = gphdfs_fopen(fcinfo, false);		myData->importDone = false;		EXTPROTOCOL_SET_USER_CTX(fcinfo, myData);	}	/* =======================================================================	 *                            DO THE IMPORT	 * ======================================================================= */	data 	= EXTPROTOCOL_GET_DATABUF(fcinfo);	datlen 	= EXTPROTOCOL_GET_DATALEN(fcinfo);	if (datlen > 0 && !myData->importDone)		nread = url_execute_fread(data, datlen, myData->importFile, NULL);	/* =======================================================================	 *                            DO CLOSE	 *                            close early to raise error early	 * ======================================================================= */	if (nread == 0)	{		myData->importDone = true;		url_fclose(myData->importFile, true, "gphdfs protocol");	}	PG_RETURN_INT32((int)nread);}

static int yuv_read(ByteIOContext *f,                    int (*alloc_cb)(void *opaque, AVImageInfo *info), void *opaque){    ByteIOContext pb1, *pb = &pb1;    int img_size, ret;    char fname[1024], *p;    int size;    URLContext *h;    AVImageInfo info1, *info = &info1;    img_size = url_fsize(f);    /* XXX: hack hack */    h = url_fileno(f);    url_get_filename(h, fname, sizeof(fname));    if (infer_size(&info->width, &info->height, img_size) < 0) {        return AVERROR_IO;    }    info->pix_fmt = PIX_FMT_YUV420P;    ret = alloc_cb(opaque, info);    if (ret)        return ret;    size = info->width * info->height;    p = strrchr(fname, '.');    if (!p || p[1] != 'Y')        return AVERROR_IO;    get_buffer(f, info->pict.data[0], size);    p[1] = 'U';    if (url_fopen(pb, fname, URL_RDONLY) < 0)        return AVERROR_IO;    get_buffer(pb, info->pict.data[1], size / 4);    url_fclose(pb);    p[1] = 'V';    if (url_fopen(pb, fname, URL_RDONLY) < 0)        return AVERROR_IO;    get_buffer(pb, info->pict.data[2], size / 4);    url_fclose(pb);    return 0;}

    ~impl() {        if (swsCtx)            sws_freeContext(swsCtx);        if (codecCtx)            avcodec_close(codecCtx);        if (buffer0)            av_free(buffer0);        if (frame0)            av_free(frame0);        if (buffer1)            av_free(buffer1);        if (frame1)            av_free(frame1);        if (output_buffer)            av_free(output_buffer);        if (formatCtx) {            for(unsigned i = 0; i < formatCtx->nb_streams; i++) {                av_freep(&formatCtx->streams[i]->codec);                av_freep(&formatCtx->streams[i]);            }            if (formatCtx->pb) {                #if LIBAVFORMAT_VERSION_MAJOR >= 54                    avio_close(formatCtx->pb);                #else                    url_fclose(formatCtx->pb);                #endif            }            av_free(formatCtx);        }    }

static int img_read_packet(AVFormatContext *s1, AVPacket *pkt){    VideoData *s = s1->priv_data;    char filename[1024];    int i;    int size[3]={0}, ret[3]={0};    ByteIOContext f1[3], *f[3]= {&f1[0], &f1[1], &f1[2]};    AVCodecContext *codec= s1->streams[0]->codec;    if (!s->is_pipe) {        /* loop over input */        if (s1->loop_input && s->img_number > s->img_last) {            s->img_number = s->img_first;        }        if (av_get_frame_filename(filename, sizeof(filename),                                  s->path, s->img_number)<0 && s->img_number > 1)            return AVERROR_IO;        for(i=0; i<3; i++){            if (url_fopen(f[i], filename, URL_RDONLY) < 0)                return AVERROR_IO;            size[i]= url_fsize(f[i]);            if(codec->codec_id != CODEC_ID_RAWVIDEO)                break;            filename[ strlen(filename) - 1 ]= 'U' + i;        }        if(codec->codec_id == CODEC_ID_RAWVIDEO && !codec->width)            infer_size(&codec->width, &codec->height, size[0]);    } else {        f[0] = &s1->pb;        if (url_feof(f[0]))            return AVERROR_IO;        size[0]= 4096;    }    av_new_packet(pkt, size[0] + size[1] + size[2]);    pkt->stream_index = 0;    pkt->flags |= PKT_FLAG_KEY;    pkt->size= 0;    for(i=0; i<3; i++){        if(size[i]){            ret[i]= get_buffer(f[i], pkt->data + pkt->size, size[i]);            if (!s->is_pipe)                url_fclose(f[i]);            if(ret[i]>0)                pkt->size += ret[i];        }    }    if (ret[0] <= 0 || ret[1]<0 || ret[2]<0) {        av_free_packet(pkt);        return AVERROR_IO; /* signal EOF */    } else {        s->img_count++;        s->img_number++;        return 0;    }}

void close_video_file(){/* write the trailer, if any.  the trailer must be written     * before you close the CodecContexts open when you wrote the     * header; otherwise write_trailer may try to use memory that     * was freed on av_codec_close() */    av_write_trailer(oc);    /* close each codec */    if (video_st)        close_video(oc, video_st);    /* free the streams */    for(i = 0; i < oc->nb_streams; i++) {        av_freep(&oc->streams[i]->codec);        av_freep(&oc->streams[i]);    }    if (!(fmt->flags & AVFMT_NOFILE)) {        /* close the output file */        url_fclose(oc->pb);    }    /* free the stream */    av_free(oc);}

static int list_open(URLContext *h, const char *filename, int flags){	struct list_mgt *mgt;	int ret;	ByteIOContext *bio;	mgt=av_malloc(sizeof(struct list_mgt));	if(!mgt)		return AVERROR(ENOMEM);	memset(mgt,0,sizeof(*mgt));	mgt->filename=filename+5;	mgt->flags=flags;	if((ret=list_open_internet(&bio,mgt,mgt->filename,flags| URL_MINI_BUFFER | URL_NO_LP_BUFFER))!=0)	{		av_free(mgt);		return ret;	}	lp_lock_init(&mgt->mutex,NULL);	mgt->current_item=mgt->item_list;	mgt->cur_uio=NULL; 	h->is_streamed=1;	h->is_slowmedia=1;	if(mgt->full_time>0 && mgt->have_list_end)		h->support_time_seek=1;	h->priv_data = mgt;		url_fclose(bio);	return 0;}

static int rtsp_read_close(AVFormatContext *s){    RTSPState *rt = s->priv_data;    RTSPHeader reply1, *reply = &reply1;    char cmd[1024];#if 0    /* NOTE: it is valid to flush the buffer here */    if (rt->protocol == RTSP_PROTOCOL_RTP_TCP) {        url_fclose(&rt->rtsp_gb);    }#endif    snprintf(cmd, sizeof(cmd),             "TEARDOWN %s RTSP/1.0/r/n",             s->filename);    rtsp_send_cmd(s, cmd, reply, NULL);    if (ff_rtsp_callback) {        ff_rtsp_callback(RTSP_ACTION_CLIENT_TEARDOWN, rt->session_id,                         NULL, 0, NULL);    }    rtsp_close_streams(rt);    url_close(rt->rtsp_hd);    return 0;}

static int img_write_packet(AVFormatContext *s, AVPacket *pkt){    VideoData *img = s->priv_data;    ByteIOContext pb1, *pb;    char filename[1024];    if (!img->is_pipe) {        if (get_frame_filename(filename, sizeof(filename),                                img->path, img->img_number) < 0 && img->img_number>1)            return AVERROR_IO;        pb = &pb1;        if (url_fopen(pb, filename, URL_WRONLY) < 0)            return AVERROR_IO;    } else {        pb = &s->pb;    }    put_buffer(pb, pkt->data, pkt->size);    put_flush_packet(pb);    if (!img->is_pipe) {        url_fclose(pb);    }    img->img_number++;    return 0;}

int main(int argc, char **argv){	URL_FILE *handle;	char buffer[BUFSIZE];	if(argc > 1)		strcpy(BASE,argv[1]);	else {		fprintf(stderr, "Usage: %s BaseURL/n",argv[0]);		exit(1);	}			handle = url_fopen(BASE, "r");	if (!handle) {		fprintf(stderr,"couldn't url_fopen() %s/n", BASE);		return 2;	}	while(!url_feof(handle)) {		url_fgets(buffer,sizeof(buffer),handle);		strlower(buffer);		fputs(buffer,stdout);		char *cur, link[BUFSIZE], full_link[BUFSIZE];		cur = buffer;		while ((cur = nextURL(cur)) != NULL) {			getURL(cur, link, BUFSIZE-1);			normalise(link, full_link, BUFSIZE-1);			printf("%s/n",full_link);			cur += strlen(link);		}	}	url_fclose(handle);	return 0;}

void VideoWriterThread::close(){    if (m_pOutputFormatContext) {        av_write_trailer(m_pOutputFormatContext);        avcodec_close(m_pVideoStream->codec);        for (unsigned int i=0; i<m_pOutputFormatContext->nb_streams; i++) {            AVStream* pStream = m_pOutputFormatContext->streams[i];            pStream->discard = AVDISCARD_ALL;            av_freep(&m_pOutputFormatContext->streams[i]->codec);            av_freep(&m_pOutputFormatContext->streams[i]);        }        if (!(m_pOutputFormat->flags & AVFMT_NOFILE)) {#if LIBAVCODEC_VERSION_INT > AV_VERSION_INT(53, 8, 0)            avio_close(m_pOutputFormatContext->pb);#else                        url_fclose(m_pOutputFormatContext->pb);#endif        }        av_free(m_pOutputFormatContext);        av_free(m_pVideoBuffer);        av_free(m_pConvertedFrame);        av_free(m_pPictureBuffer);        sws_freeContext(m_pFrameConversionContext);        m_pOutputFormatContext = 0;    }}

void CLOSE(){	mpg123_close(musicfile);	mpg123_delete(musicfile);	if ( fd > -1 )	{		close( fd );		fd = -1;	}	if ( Type == 2 )	{		delete[] data;		if ( f )			url_fclose(f);		f = NULL;	}	if ( Type == 2 )		unloadCURL();	IsPlaying = false;	pix = QImage();	id3Str.clear();	_DATA_BUFF = 0;}

//___________________________________________________________________________uint8_t lavMuxer::close( void ){	if(_running)	{		_running=0;		// Flush		// Cause deadlock :		av_write_trailer(oc);		url_fclose(&oc->pb);	}	if(audio_st)	{		 av_free(audio_st);	}	if(video_st)	{		 av_free(video_st);	}	video_st=NULL;	audio_st=NULL;	if(oc)		av_free(oc);	oc=NULL;	return 1;}

/*=======================================================================================*/int url_is_file_list(ByteIOContext *s,const char *filename){	int ret;	list_demux_t *demux;	ByteIOContext *lio=s;	int64_t	   *oldpos=0;	if(!lio)	{		ret=url_fopen(&lio,filename,AVIO_FLAG_READ);		if(ret!=0)		{ 		return AVERROR(EIO); 		}	}	else{		oldpos=url_ftell(lio);	}	demux=probe_demux(lio,filename);	if(lio!=s)	{		url_fclose(lio);	}	else	{		url_fseek(lio, oldpos, SEEK_SET);	}	return demux!=NULL?100:0;}

static int list_open_internet(ByteIOContext **pbio,struct list_mgt *mgt,const char *filename, int flags){	list_demux_t *demux;	int ret;	ByteIOContext *bio;	ret=url_fopen(&bio,filename,flags);	if(ret!=0)		{			return AVERROR(EIO); 		}	demux=probe_demux(bio,filename);	if(!demux)	{		ret=-1;		goto error;	}	ret=demux->parser(mgt,bio);	if(ret<=0)	{		ret=-1;		goto error;	}	*pbio=bio;	return 0;error:	if(bio)		url_fclose(bio);	return ret;}

/// Move on to next fragment IF NEEDED (changes file)/// This method won't change file if it's not ready tovoid advance_fragment(EncoderJob &jobSpec) {	// Check to see if this frame should be split.	if (should_advance(jobSpec)) {		jobSpec.SplitNextKey = (jobSpec.a_pts > jobSpec.v_pts) ? (jobSpec.a_pts) : (jobSpec.v_pts);		jobSpec.SegmentNumber++;#ifdef NEW_M2TS		jobSpec.p->CloseFile();		sprintf(jobSpec.oc->filename, "%s-%05u.ts", jobSpec.BaseDirectory, jobSpec.SegmentNumber);		int track_ids[2] = {120, 121};		uint8_t track_types[2] = {Pests::TT_H264, Pests::TT_MpegAudio};		jobSpec.p->StartFile(jobSpec.oc->filename, track_ids, track_types, 2);#else		url_fclose(jobSpec.oc->pb);		sprintf(jobSpec.oc->filename, "%s-%05u.ts", jobSpec.BaseDirectory, jobSpec.SegmentNumber);		if (url_fopen(&jobSpec.oc->pb, jobSpec.oc->filename, URL_WRONLY) < 0) {			fprintf(stderr, "Could not open '%s'/n", jobSpec.oc->filename);			jobSpec.IsValid = false;			return;		}		av_write_header(jobSpec.oc);#endif	}}

AVFormatWriter::~AVFormatWriter(){    QMutexLocker locker(avcodeclock);    if (m_pkt)    {        delete m_pkt;        m_pkt = NULL;    }    if (m_ctx)    {        av_write_trailer(m_ctx);        url_fclose(m_ctx->pb);        for(unsigned int i = 0; i < m_ctx->nb_streams; i++) {            av_freep(&m_ctx->streams[i]);        }        av_free(m_ctx);        m_ctx = NULL;    }    if (m_videoOutBuf)        delete [] m_videoOutBuf;}

VideoStream::~VideoStream(){	/* close each codec */	if (ost)	{#if ZM_FFMPEG_SVN		avcodec_close(ost->codec);#else		avcodec_close(&ost->codec);#endif		av_free(opicture->data[0]);		av_free(opicture);		if (tmp_opicture)		{			av_free(tmp_opicture->data[0]);			av_free(tmp_opicture);		}		av_free(video_outbuf);	}	/* write the trailer, if any */	av_write_trailer(ofc);		/* free the streams */	for( int i = 0; i < ofc->nb_streams; i++)	{		av_freep(&ofc->streams[i]);	}	if (!(of->flags & AVFMT_NOFILE))	{		/* close the output file */#if ZM_FFMPEG_SVN#if LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51,2,1)		avio_close(ofc->pb);#else		url_fclose(ofc->pb);#endif#else		url_fclose(&ofc->pb);#endif	}	/* free the stream */	av_free(ofc);}

AVFormatContext *ff_rtp_chain_mux_open(AVFormatContext *s, AVStream *st,                                       URLContext *handle, int packet_size){    AVFormatContext *rtpctx;    int ret;    AVOutputFormat *rtp_format = av_guess_format("rtp", NULL, NULL);    if (!rtp_format)        return NULL;    /* Allocate an AVFormatContext for each output stream */    rtpctx = avformat_alloc_context();    if (!rtpctx)        return NULL;    rtpctx->oformat = rtp_format;    if (!av_new_stream(rtpctx, 0)) {        av_free(rtpctx);        return NULL;    }    /* Copy the max delay setting; the rtp muxer reads this. */    rtpctx->max_delay = s->max_delay;    /* Copy other stream parameters. */    rtpctx->streams[0]->sample_aspect_ratio = st->sample_aspect_ratio;    /* Set the synchronized start time. */    rtpctx->start_time_realtime = s->start_time_realtime;    /* Remove the local codec, link to the original codec     * context instead, to give the rtp muxer access to     * codec parameters. */    av_free(rtpctx->streams[0]->codec);    rtpctx->streams[0]->codec = st->codec;    if (handle) {        url_fdopen(&rtpctx->pb, handle);    } else        url_open_dyn_packet_buf(&rtpctx->pb, packet_size);    ret = av_write_header(rtpctx);    if (ret) {        if (handle) {            url_fclose(rtpctx->pb);        } else {            uint8_t *ptr;            url_close_dyn_buf(rtpctx->pb, &ptr);            av_free(ptr);        }        av_free(rtpctx->streams[0]);        av_free(rtpctx);        return NULL;    }    /* Copy the RTP AVStream timebase back to the original AVStream */    st->time_base = rtpctx->streams[0]->time_base;    return rtpctx;}

static int img_write_packet(AVFormatContext *s, AVPacket *pkt){    VideoData *img = s->priv_data;    ByteIOContext pb1[3], *pb[3]= {&pb1[0], &pb1[1], &pb1[2]};    char filename[1024];    AVCodecContext *codec= s->streams[ pkt->stream_index ]->codec;    int i;    if (!img->is_pipe) {        if (av_get_frame_filename(filename, sizeof(filename),                                  img->path, img->img_number) < 0 && img->img_number>1)            return AVERROR_IO;        for(i=0; i<3; i++){            if (url_fopen(pb[i], filename, URL_WRONLY) < 0)                return AVERROR_IO;            if(codec->codec_id != CODEC_ID_RAWVIDEO)                break;            filename[ strlen(filename) - 1 ]= 'U' + i;        }    } else {        pb[0] = &s->pb;    }    if(codec->codec_id == CODEC_ID_RAWVIDEO){        int ysize = codec->width * codec->height;        put_buffer(pb[0], pkt->data        , ysize);        put_buffer(pb[1], pkt->data + ysize, (pkt->size - ysize)/2);        put_buffer(pb[2], pkt->data + ysize +(pkt->size - ysize)/2, (pkt->size - ysize)/2);        put_flush_packet(pb[1]);        put_flush_packet(pb[2]);        url_fclose(pb[1]);        url_fclose(pb[2]);    }else{        put_buffer(pb[0], pkt->data, pkt->size);    }    put_flush_packet(pb[0]);    if (!img->is_pipe) {        url_fclose(pb[0]);    }    img->img_number++;    return 0;}

void VideoFFmpegWriter::finish(){	if( _error == IGNORE_FINISH )		return;	av_write_trailer( _avformatOptions );	avcodec_close( _stream->codec );	if( !( _avformatOptions->oformat->flags & AVFMT_NOFILE ) )		url_fclose( _avformatOptions->pb );	freeFormat();}

// note that there is no sane way to easily free a context w/o free_context()// so this will probably leakstatic void avformat_free_context(AVFormatContext *ctx){    if(ctx->pb)	url_fclose(ctx->pb);    for(int i = 0; i < ctx->nb_streams; i++) {	if(ctx->streams[i]->codec)	    avcodec_close(ctx->streams[i]->codec);	av_freep(&ctx->streams[i]->codec);	av_freep(&ctx->streams[i]);    }    av_free(ctx);}

int sj_index_load(char *filename, SJ_IndexContext *sj_ic){    ByteIOContext pb;    register_protocol(&file_protocol);    if (url_fopen(&pb, filename, URL_RDONLY) < 0) {        // file could not be open        return -1;    }    sj_ic->size = url_fsize(&pb) - HEADER_SIZE;    sj_ic->index_num = (sj_ic->size / INDEX_SIZE);    sj_ic->indexes = av_malloc(sj_ic->index_num * sizeof(Index));    int64_t magic = get_le64(&pb);    if (magic != 0x534A2D494E444558LL) {        // not an index file        url_fclose(&pb);        return -2;    }    sj_ic->version = get_byte(&pb);    sj_ic->start_pts = get_le64(&pb);    sj_ic->start_dts = get_le64(&pb);    sj_ic->start_timecode.frames = get_byte(&pb);    sj_ic->start_timecode.seconds = get_byte(&pb);    sj_ic->start_timecode.minutes = get_byte(&pb);    sj_ic->start_timecode.hours = get_byte(&pb);    if (!sj_ic->index_num) {        // empty index        url_fclose(&pb);        return -4;    }    for(int i = 0; i < sj_ic->index_num; i++) {        read_index(&sj_ic->indexes[i], &pb);    }    url_fclose(&pb);    return 0;}

/* XXX: use llseek */static int64_t list_seek(URLContext *h, int64_t pos, int whence){	struct list_mgt *mgt = h->priv_data;	struct list_item *item,*item1;	if (whence == AVSEEK_BUFFERED_TIME)	{		int64_t buffed_time=0;		if(mgt->current_item && mgt->current_item->duration>0){			//av_log(NULL, AV_LOG_INFO, "list_seek uui=%ld,size=%lld/n",mgt->cur_uio,url_fsize(mgt->cur_uio));			if(mgt->cur_uio && url_fsize(mgt->cur_uio)>0){				//av_log(NULL, AV_LOG_INFO, "list_seek start_time=%ld,pos=%lld/n",mgt->current_item->start_time,url_buffed_pos(mgt->cur_uio));				buffed_time=mgt->current_item->start_time+url_buffed_pos(mgt->cur_uio)*mgt->current_item->duration/url_fsize(mgt->cur_uio);			}			else{				buffed_time=mgt->current_item->start_time;			}		}		av_log(NULL, AV_LOG_INFO, "list current buffed_time=%lld/n",buffed_time);		return buffed_time;	}		av_log(NULL, AV_LOG_INFO, "list_seek pos=%lld,whence=%x/n",pos,whence);	if (whence == AVSEEK_SIZE)        return mgt->file_size;	if (whence == AVSEEK_FULLTIME)	{		if(mgt->have_list_end)			return mgt->full_time;		else			return -1;	}		if(whence == AVSEEK_TO_TIME && pos>=0 && pos<mgt->full_time)	{		av_log(NULL, AV_LOG_INFO, "list_seek to Time =%lld,whence=%x/n",pos,whence);		for(item=mgt->item_list;item;item=item->next)		{			if(item->start_time<=pos && pos <item->start_time+item->duration)			{					if(mgt->cur_uio)					url_fclose(mgt->cur_uio);				mgt->cur_uio=NULL;				mgt->current_item=item;				av_log(NULL, AV_LOG_INFO, "list_seek to item->file =%s/n",item->file);				return item->start_time;/*pos=0;*/			}		}	}	av_log(NULL, AV_LOG_INFO, "list_seek failed/n");	return -1;

ComponentResult FFAvi_MovieImportValidateDataRef(ff_global_ptr storage, Handle dataRef, OSType dataRefType, UInt8 *valid){	ComponentResult result = noErr;	DataHandler dataHandler = NULL;	uint8_t buf[PROBE_BUF_SIZE + FF_INPUT_BUFFER_PADDING_SIZE] = {0};	AVProbeData pd;	ByteIOContext *byteContext;	/* default */	*valid = 0;		/* Get a data handle and read a probe of data */	result = OpenADataHandler(dataRef, dataRefType, NULL, 0, NULL, kDataHCanRead, &dataHandler);	if(result || !dataHandler) goto bail;		pd.buf = buf;	pd.buf_size = PROBE_BUF_SIZE;		result = DataHScheduleData(dataHandler, (Ptr)pd.buf, 0, PROBE_BUF_SIZE, 0, NULL, NULL);	require_noerr(result,bail);		FFInitFFmpeg();	storage->format = av_probe_input_format(&pd, 1);	if(storage->format != NULL) {		*valid = 255; /* This means we can read the data */				/* we don't do MJPEG's Huffman tables right yet, and DV video seems to have 		an aspect ratio coded in the bitstream that ffmpeg doesn't read, so let Apple's 		AVI importer handle AVIs with these two video types */		if (IS_AVI(storage->componentType)) {			/* Prepare the iocontext structure */			result = url_open_dataref(&byteContext, dataRef, dataRefType, NULL, NULL, NULL);			require_noerr(result, bail);						OSType fourcc = get_avi_strf_fourcc(byteContext);			enum CodecID id = ff_codec_get_id(ff_codec_bmp_tags, BSWAP(fourcc));						if (id == CODEC_ID_MJPEG || id == CODEC_ID_DVVIDEO || id == CODEC_ID_RAWVIDEO || id == CODEC_ID_MSVIDEO1 || id == CODEC_ID_MSRLE)				*valid = 0;						url_fclose(byteContext);		}	}		bail:		if(dataHandler)			CloseComponent(dataHandler);		return result;} /* FFAvi_MovieImportValidateDataRef() */

/* Closes a video file. */void ffmpeg_close(struct ffmpeg *ffmpeg){    unsigned int i;    /* close each codec */    if (ffmpeg->video_st) {        pthread_mutex_lock(&global_lock);        avcodec_close(AVSTREAM_CODEC_PTR(ffmpeg->video_st));        pthread_mutex_unlock(&global_lock);        av_freep(&ffmpeg->picture);        free(ffmpeg->video_outbuf);    }    /* write the trailer, if any */    av_write_trailer(ffmpeg->oc);    /* free the streams */    for (i = 0; i < ffmpeg->oc->nb_streams; i++)         av_freep(&ffmpeg->oc->streams[i]);        if (!(ffmpeg->oc->oformat->flags & AVFMT_NOFILE)) {        /* close the output file */#if LIBAVFORMAT_BUILD >= (52<<16)         url_fclose(ffmpeg->oc->pb);#else        url_fclose(&ffmpeg->oc->pb);#endif /* LIBAVFORMAT_BUILD >= (52<<16) */    }    /* free the stream */    av_free(ffmpeg->oc);#if LIBAVFORMAT_BUILD >= 4629    av_free(ffmpeg->c);#endif    free(ffmpeg);}

QString InternetFormatSupport( const char* address ){	loadCURL();	if ( !CURLloaded )		return "";	mpg123_handle *mus = mpg123_new(NULL, NULL);	mpg123_open_feed( mus );	URL_FILE *f = url_fopen( address );	if ( !f )	{		unloadCURL();		return "";	}	char *data;	int _DATA_BUFF;	if ( !getDataBuff( f, url_fread, _DATA_BUFF, &data ) )	{		url_fclose(f);		unloadCURL();		return "";	}	int bread = url_fread(data+10, 1, _DATA_BUFF-10, f);	mpg123_decode( mus, (const unsigned char*)data, bread, 0,0,0 );	bool loaded = getMusInfo( mus, 0,0,0,0,0, -1, "" );	mpg123_close(mus);	mpg123_delete(mus);	delete[] data;	url_fclose(f);	unloadCURL();	if ( loaded )		return plugName;	else		return "";}

bool AVFormatWriter::CloseFile(void){    if (m_ctx)    {        av_write_trailer(m_ctx);        url_fclose(m_ctx->pb);        for(unsigned int i = 0; i < m_ctx->nb_streams; i++) {            av_freep(&m_ctx->streams[i]);        }        av_free(m_ctx);        m_ctx = NULL;    }    return true;}