* Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
*/
-/* #define DEBUG */
-
#include "avformat.h"
#include "avio_internal.h"
#include "internal.h"
#include "libavcodec/bytestream.h"
#include "libavutil/opt.h"
#include "libavutil/dict.h"
+#include "libavutil/internal.h"
#include "libavutil/pixdesc.h"
#include "metadata.h"
#include "id3v2.h"
return LICENSE_PREFIX LIBAV_LICENSE + sizeof(LICENSE_PREFIX) - 1;
}
-/** head of registered input format linked list */
-static AVInputFormat *first_iformat = NULL;
-/** head of registered output format linked list */
-static AVOutputFormat *first_oformat = NULL;
-
-AVInputFormat *av_iformat_next(AVInputFormat *f)
-{
- if(f) return f->next;
- else return first_iformat;
-}
-
-AVOutputFormat *av_oformat_next(AVOutputFormat *f)
-{
- if(f) return f->next;
- else return first_oformat;
-}
-
-void av_register_input_format(AVInputFormat *format)
-{
- AVInputFormat **p;
- p = &first_iformat;
- while (*p != NULL) p = &(*p)->next;
- *p = format;
- format->next = NULL;
-}
+/* an arbitrarily chosen "sane" max packet size -- 50M */
+#define SANE_CHUNK_SIZE (50000000)
-void av_register_output_format(AVOutputFormat *format)
-{
- AVOutputFormat **p;
- p = &first_oformat;
- while (*p != NULL) p = &(*p)->next;
- *p = format;
- format->next = NULL;
-}
-
-int av_match_ext(const char *filename, const char *extensions)
+/*
+ * Read the data in sane-sized chunks and append to pkt.
+ * Return the number of bytes read or an error.
+ */
+static int append_packet_chunked(AVIOContext *s, AVPacket *pkt, int size)
{
- const char *ext, *p;
- char ext1[32], *q;
+ int64_t chunk_size = size;
+ int orig_pos = pkt->pos; // av_grow_packet might reset pos
+ int orig_size = pkt->size;
+ int ret = 0;
- if(!filename)
- return 0;
+ do {
+ int prev_size = pkt->size;
+ int read_size;
- ext = strrchr(filename, '.');
- if (ext) {
- ext++;
- p = extensions;
- for(;;) {
- q = ext1;
- while (*p != '\0' && *p != ',' && q-ext1<sizeof(ext1)-1)
- *q++ = *p++;
- *q = '\0';
- if (!av_strcasecmp(ext1, ext))
- return 1;
- if (*p == '\0')
- break;
- p++;
+ /*
+ * When the caller requests a lot of data, limit it to the amount left
+ * in file or SANE_CHUNK_SIZE when it is not known
+ */
+ if (size > SANE_CHUNK_SIZE) {
+ int64_t filesize = avio_size(s) - avio_tell(s);
+ chunk_size = FFMAX(filesize, SANE_CHUNK_SIZE);
}
- }
- return 0;
-}
-
-static int match_format(const char *name, const char *names)
-{
- const char *p;
- int len, namelen;
-
- if (!name || !names)
- return 0;
-
- namelen = strlen(name);
- while ((p = strchr(names, ','))) {
- len = FFMAX(p - names, namelen);
- if (!av_strncasecmp(name, names, len))
- return 1;
- names = p+1;
- }
- return !av_strcasecmp(name, names);
-}
+ read_size = FFMIN(size, chunk_size);
-AVOutputFormat *av_guess_format(const char *short_name, const char *filename,
- const char *mime_type)
-{
- AVOutputFormat *fmt = NULL, *fmt_found;
- int score_max, score;
+ ret = av_grow_packet(pkt, read_size);
+ if (ret < 0)
+ break;
- /* specific test for image sequences */
-#if CONFIG_IMAGE2_MUXER
- if (!short_name && filename &&
- av_filename_number_test(filename) &&
- ff_guess_image2_codec(filename) != AV_CODEC_ID_NONE) {
- return av_guess_format("image2", NULL, NULL);
- }
-#endif
- /* Find the proper file type. */
- fmt_found = NULL;
- score_max = 0;
- while ((fmt = av_oformat_next(fmt))) {
- score = 0;
- if (fmt->name && short_name && !av_strcasecmp(fmt->name, short_name))
- score += 100;
- if (fmt->mime_type && mime_type && !strcmp(fmt->mime_type, mime_type))
- score += 10;
- if (filename && fmt->extensions &&
- av_match_ext(filename, fmt->extensions)) {
- score += 5;
- }
- if (score > score_max) {
- score_max = score;
- fmt_found = fmt;
+ ret = avio_read(s, pkt->data + prev_size, read_size);
+ if (ret != read_size) {
+ av_shrink_packet(pkt, prev_size + FFMAX(ret, 0));
+ break;
}
- }
- return fmt_found;
-}
-enum AVCodecID av_guess_codec(AVOutputFormat *fmt, const char *short_name,
- const char *filename, const char *mime_type, enum AVMediaType type){
- if(type == AVMEDIA_TYPE_VIDEO){
- enum AVCodecID codec_id= AV_CODEC_ID_NONE;
+ size -= read_size;
+ } while (size > 0);
-#if CONFIG_IMAGE2_MUXER
- if(!strcmp(fmt->name, "image2") || !strcmp(fmt->name, "image2pipe")){
- codec_id= ff_guess_image2_codec(filename);
- }
-#endif
- if(codec_id == AV_CODEC_ID_NONE)
- codec_id= fmt->video_codec;
- return codec_id;
- }else if(type == AVMEDIA_TYPE_AUDIO)
- return fmt->audio_codec;
- else if (type == AVMEDIA_TYPE_SUBTITLE)
- return fmt->subtitle_codec;
- else
- return AV_CODEC_ID_NONE;
-}
-
-AVInputFormat *av_find_input_format(const char *short_name)
-{
- AVInputFormat *fmt = NULL;
- while ((fmt = av_iformat_next(fmt))) {
- if (match_format(short_name, fmt->name))
- return fmt;
- }
- return NULL;
+ pkt->pos = orig_pos;
+ if (!pkt->size)
+ av_free_packet(pkt);
+ return pkt->size > orig_size ? pkt->size - orig_size : ret;
}
-
int av_get_packet(AVIOContext *s, AVPacket *pkt, int size)
{
- int ret= av_new_packet(pkt, size);
-
- if(ret<0)
- return ret;
-
- pkt->pos= avio_tell(s);
-
- ret= avio_read(s, pkt->data, size);
- if(ret<=0)
- av_free_packet(pkt);
- else
- av_shrink_packet(pkt, ret);
+ av_init_packet(pkt);
+ pkt->data = NULL;
+ pkt->size = 0;
+ pkt->pos = avio_tell(s);
- return ret;
+ return append_packet_chunked(s, pkt, size);
}
int av_append_packet(AVIOContext *s, AVPacket *pkt, int size)
{
- int ret;
- int old_size;
if (!pkt->size)
return av_get_packet(s, pkt, size);
- old_size = pkt->size;
- ret = av_grow_packet(pkt, size);
- if (ret < 0)
- return ret;
- ret = avio_read(s, pkt->data + old_size, size);
- av_shrink_packet(pkt, old_size + FFMAX(ret, 0));
- return ret;
+ return append_packet_chunked(s, pkt, size);
}
score = fmt1->read_probe(&lpd);
} else if (fmt1->extensions) {
if (av_match_ext(lpd.filename, fmt1->extensions)) {
- score = 50;
+ score = AVPROBE_SCORE_EXTENSION;
}
}
if (score > *score_max) {
}
/* a hack for files with huge id3v2 tags -- try to guess by file extension. */
- if (!fmt && is_opened && *score_max < AVPROBE_SCORE_MAX/4) {
+ if (!fmt && is_opened && *score_max < AVPROBE_SCORE_EXTENSION / 2) {
while ((fmt = av_iformat_next(fmt)))
if (fmt->extensions && av_match_ext(lpd.filename, fmt->extensions)) {
- *score_max = AVPROBE_SCORE_MAX/4;
+ *score_max = AVPROBE_SCORE_EXTENSION / 2;
break;
}
}
- if (!fmt && id3 && *score_max < AVPROBE_SCORE_MAX/4-1) {
+ if (!fmt && id3 && *score_max < AVPROBE_SCORE_EXTENSION / 2 - 1) {
while ((fmt = av_iformat_next(fmt)))
if (fmt->extensions && av_match_ext("mp3", fmt->extensions)) {
- *score_max = AVPROBE_SCORE_MAX/4-1;
+ *score_max = AVPROBE_SCORE_EXTENSION / 2 - 1;
break;
}
}
}
/* read probe data */
- buf = av_realloc(buf, probe_size + AVPROBE_PADDING_SIZE);
+ if ((ret = av_reallocp(&buf, probe_size + AVPROBE_PADDING_SIZE)) < 0)
+ return ret;
if ((ret = avio_read(pb, buf + buf_offset, probe_size - buf_offset)) < 0) {
/* fail if error was not end of file, otherwise, lower score */
if (ret != AVERROR_EOF) {
/*******************************************************/
-static void probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
+static int probe_codec(AVFormatContext *s, AVStream *st, const AVPacket *pkt)
{
if(st->codec->codec_id == AV_CODEC_ID_PROBE){
AVProbeData *pd = &st->probe_data;
--st->probe_packets;
if (pkt) {
- pd->buf = av_realloc(pd->buf, pd->buf_size+pkt->size+AVPROBE_PADDING_SIZE);
+ int err;
+ if ((err = av_reallocp(&pd->buf, pd->buf_size + pkt->size +
+ AVPROBE_PADDING_SIZE)) < 0)
+ return err;
memcpy(pd->buf+pd->buf_size, pkt->data, pkt->size);
pd->buf_size += pkt->size;
memset(pd->buf+pd->buf_size, 0, AVPROBE_PADDING_SIZE);
if (!pd->buf_size) {
av_log(s, AV_LOG_ERROR, "nothing to probe for stream %d\n",
st->index);
- return;
+ return 0;
}
}
}
}
}
+ return 0;
}
int ff_read_packet(AVFormatContext *s, AVPacket *pkt)
{
- int ret, i;
+ int ret, i, err;
AVStream *st;
for(;;){
s->raw_packet_buffer_remaining_size < pkt->size) {
AVProbeData *pd;
if (st->probe_packets) {
- probe_codec(s, st, NULL);
+ if ((err = probe_codec(s, st, NULL)) < 0)
+ return err;
}
pd = &st->probe_data;
av_freep(&pd->buf);
for (i = 0; i < s->nb_streams; i++) {
st = s->streams[i];
if (st->probe_packets) {
- probe_codec(s, st, NULL);
+ if ((err = probe_codec(s, st, NULL)) < 0)
+ return err;
}
}
continue;
add_to_pktbuf(&s->raw_packet_buffer, pkt, &s->raw_packet_buffer_end);
s->raw_packet_buffer_remaining_size -= pkt->size;
- probe_codec(s, st, pkt);
+ if ((err = probe_codec(s, st, pkt)) < 0)
+ return err;
}
}
if ((frame_size = av_get_audio_frame_duration(enc, size)) > 0)
return frame_size;
- /* fallback to using frame_size if muxing */
+ /* Fall back on using frame_size if muxing. */
if (enc->frame_size > 1)
return enc->frame_size;
pc && pc->pict_type != AV_PICTURE_TYPE_B)
presentation_delayed = 1;
- if(pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE && pkt->dts > pkt->pts && st->pts_wrap_bits<63
- /*&& pkt->dts-(1LL<<st->pts_wrap_bits) < pkt->pts*/){
+ if (pkt->pts != AV_NOPTS_VALUE && pkt->dts != AV_NOPTS_VALUE &&
+ st->pts_wrap_bits < 63 &&
+ pkt->dts - (1LL << (st->pts_wrap_bits - 1)) > pkt->pts) {
pkt->dts -= 1LL<<st->pts_wrap_bits;
}
if (!out_pkt.size)
continue;
+ if (pkt->side_data) {
+ out_pkt.side_data = pkt->side_data;
+ out_pkt.side_data_elems = pkt->side_data_elems;
+ pkt->side_data = NULL;
+ pkt->side_data_elems = 0;
+ }
+
/* set the duration */
out_pkt.duration = 0;
if (st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
out_pkt.buf = pkt->buf;
pkt->buf = NULL;
#if FF_API_DESTRUCT_PACKET
+FF_DISABLE_DEPRECATION_WARNINGS
out_pkt.destruct = pkt->destruct;
pkt->destruct = NULL;
+FF_ENABLE_DEPRECATION_WARNINGS
#endif
}
if ((ret = av_dup_packet(&out_pkt)) < 0)
//try to seek via read_timestamp()
}
- //Fallback to old API if new is not implemented but old is
- //Note the old has somewat different sematics
+ // Fall back on old API if new is not implemented but old is.
+ // Note the old API has somewhat different semantics.
if(s->iformat->read_seek || 1)
return av_seek_frame(s, stream_index, ts, flags | ((uint64_t)ts - min_ts > (uint64_t)max_ts - ts ? AVSEEK_FLAG_BACKWARD : 0));
static void estimate_timings_from_bit_rate(AVFormatContext *ic)
{
int64_t filesize, duration;
- int bit_rate, i;
+ int i;
AVStream *st;
/* if bit_rate is already set, we believe it */
if (ic->bit_rate <= 0) {
- bit_rate = 0;
+ int bit_rate = 0;
for(i=0;i<ic->nb_streams;i++) {
st = ic->streams[i];
- if (st->codec->bit_rate > 0)
- bit_rate += st->codec->bit_rate;
+ if (st->codec->bit_rate > 0) {
+ if (INT_MAX - st->codec->bit_rate < bit_rate) {
+ bit_rate = 0;
+ break;
+ }
+ bit_rate += st->codec->bit_rate;
+ }
}
ic->bit_rate = bit_rate;
}
}
for (i=0; i<ic->nb_streams; i++) {
-#if FF_API_R_FRAME_RATE
- ic->streams[i]->info->last_dts = AV_NOPTS_VALUE;
-#endif
ic->streams[i]->info->fps_first_dts = AV_NOPTS_VALUE;
ic->streams[i]->info->fps_last_dts = AV_NOPTS_VALUE;
}
break;
}
}
-#if FF_API_R_FRAME_RATE
- {
- int64_t last = st->info->last_dts;
-
- if(pkt->dts != AV_NOPTS_VALUE && last != AV_NOPTS_VALUE && pkt->dts > last){
- int64_t duration= pkt->dts - last;
- double dur= duration * av_q2d(st->time_base);
-
- if (st->info->duration_count < 2)
- memset(st->info->duration_error, 0, sizeof(st->info->duration_error));
- for (i=1; i<FF_ARRAY_ELEMS(st->info->duration_error); i++) {
- int framerate= get_std_framerate(i);
- int ticks= lrintf(dur*framerate/(1001*12));
- double error = dur - (double)ticks*1001*12 / framerate;
- st->info->duration_error[i] += error*error;
- }
- st->info->duration_count++;
- // ignore the first 4 values, they might have some random jitter
- if (st->info->duration_count > 3)
- st->info->duration_gcd = av_gcd(st->info->duration_gcd, duration);
- }
- if (last == AV_NOPTS_VALUE || st->info->duration_count <= 1)
- st->info->last_dts = pkt->dts;
- }
-#endif
if(st->parser && st->parser->parser->split && !st->codec->extradata){
int i= st->parser->parser->split(st->codec, pkt->data, pkt->size);
if (i > 0 && i < FF_MAX_EXTRADATA_SIZE) {
int best_fps = 0;
double best_error = 0.01;
+ if (delta_dts >= INT64_MAX / st->time_base.num ||
+ delta_packets >= INT64_MAX / st->time_base.den ||
+ delta_dts < 0)
+ continue;
av_reduce(&st->avg_frame_rate.num, &st->avg_frame_rate.den,
delta_packets*(int64_t)st->time_base.den,
delta_dts*(int64_t)st->time_base.num, 60000);
best_fps, 12*1001, INT_MAX);
}
}
-#if FF_API_R_FRAME_RATE
- // the check for tb_unreliable() is not completely correct, since this is not about handling
- // a unreliable/inexact time base, but a time base that is finer than necessary, as e.g.
- // ipmovie.c produces.
- if (tb_unreliable(st->codec) && st->info->duration_count > 15 && st->info->duration_gcd > 1 && !st->r_frame_rate.num)
- av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, st->time_base.den, st->time_base.num * st->info->duration_gcd, INT_MAX);
- if (st->info->duration_count && !st->r_frame_rate.num
- && tb_unreliable(st->codec)) {
- int num = 0;
- double best_error= 2*av_q2d(st->time_base);
- best_error = best_error*best_error*st->info->duration_count*1000*12*30;
-
- for (j=1; j<FF_ARRAY_ELEMS(st->info->duration_error); j++) {
- double error = st->info->duration_error[j] * get_std_framerate(j);
- if(error < best_error){
- best_error= error;
- num = get_std_framerate(j);
- }
- }
- // do not increase frame rate by more than 1 % in order to match a standard rate.
- if (num && (!st->r_frame_rate.num || (double)num/(12*1001) < 1.01 * av_q2d(st->r_frame_rate)))
- av_reduce(&st->r_frame_rate.num, &st->r_frame_rate.den, num, 12*1001, INT_MAX);
- }
-#endif
}else if(st->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
if(!st->codec->bits_per_coded_sample)
st->codec->bits_per_coded_sample= av_get_bits_per_sample(st->codec->codec_id);
if (st->attached_pic.data)
av_free_packet(&st->attached_pic);
av_dict_free(&st->metadata);
+ av_freep(&st->probe_data.buf);
av_free(st->index_entries);
av_free(st->codec->extradata);
av_free(st->codec->subtitle_header);
{
AVStream *st;
int i;
- AVStream **streams;
- if (s->nb_streams >= INT_MAX/sizeof(*streams))
- return NULL;
- streams = av_realloc(s->streams, (s->nb_streams + 1) * sizeof(*streams));
- if (!streams)
+ if (av_reallocp_array(&s->streams, s->nb_streams + 1, sizeof(*s->streams)) < 0) {
+ s->nb_streams = 0;
return NULL;
- s->streams = streams;
+ }
st = av_mallocz(sizeof(AVStream));
if (!st)
st->sample_aspect_ratio = (AVRational){0,1};
-#if FF_API_R_FRAME_RATE
- st->info->last_dts = AV_NOPTS_VALUE;
-#endif
st->info->fps_first_dts = AV_NOPTS_VALUE;
st->info->fps_last_dts = AV_NOPTS_VALUE;
{
int i, j;
AVProgram *program=NULL;
- void *tmp;
if (idx >= ac->nb_streams) {
av_log(ac, AV_LOG_ERROR, "stream index %d is not valid\n", idx);
if(program->stream_index[j] == idx)
return;
- tmp = av_realloc(program->stream_index, sizeof(unsigned int)*(program->nb_stream_indexes+1));
- if(!tmp)
+ if (av_reallocp_array(&program->stream_index,
+ program->nb_stream_indexes + 1,
+ sizeof(*program->stream_index)) < 0) {
+ program->nb_stream_indexes = 0;
return;
- program->stream_index = tmp;
+ }
program->stream_index[program->nb_stream_indexes++] = idx;
return;
}
if(st->codec->codec_type == AVMEDIA_TYPE_VIDEO){
if(st->avg_frame_rate.den && st->avg_frame_rate.num)
print_fps(av_q2d(st->avg_frame_rate), "fps");
-#if FF_API_R_FRAME_RATE
- if(st->r_frame_rate.den && st->r_frame_rate.num)
- print_fps(av_q2d(st->r_frame_rate), "tbr");
-#endif
if(st->time_base.den && st->time_base.num)
print_fps(1/av_q2d(st->time_base), "tbn");
if(st->codec->time_base.den && st->codec->time_base.num)
s->pts_wrap_bits = pts_wrap_bits;
}
-int ff_url_join(char *str, int size, const char *proto,
- const char *authorization, const char *hostname,
- int port, const char *fmt, ...)
-{
-#if CONFIG_NETWORK
- struct addrinfo hints = { 0 }, *ai;
-#endif
-
- str[0] = '\0';
- if (proto)
- av_strlcatf(str, size, "%s://", proto);
- if (authorization && authorization[0])
- av_strlcatf(str, size, "%s@", authorization);
-#if CONFIG_NETWORK && defined(AF_INET6)
- /* Determine if hostname is a numerical IPv6 address,
- * properly escape it within [] in that case. */
- hints.ai_flags = AI_NUMERICHOST;
- if (!getaddrinfo(hostname, NULL, &hints, &ai)) {
- if (ai->ai_family == AF_INET6) {
- av_strlcat(str, "[", size);
- av_strlcat(str, hostname, size);
- av_strlcat(str, "]", size);
- } else {
- av_strlcat(str, hostname, size);
- }
- freeaddrinfo(ai);
- } else
-#endif
- /* Not an IPv6 address, just output the plain string. */
- av_strlcat(str, hostname, size);
-
- if (port >= 0)
- av_strlcatf(str, size, ":%d", port);
- if (fmt) {
- va_list vl;
- int len = strlen(str);
-
- va_start(vl, fmt);
- vsnprintf(str + len, size > len ? size - len : 0, fmt, vl);
- va_end(vl);
- }
- return strlen(str);
-}
-
-int ff_write_chained(AVFormatContext *dst, int dst_stream, AVPacket *pkt,
- AVFormatContext *src)
-{
- AVPacket local_pkt;
-
- local_pkt = *pkt;
- local_pkt.stream_index = dst_stream;
- if (pkt->pts != AV_NOPTS_VALUE)
- local_pkt.pts = av_rescale_q(pkt->pts,
- src->streams[pkt->stream_index]->time_base,
- dst->streams[dst_stream]->time_base);
- if (pkt->dts != AV_NOPTS_VALUE)
- local_pkt.dts = av_rescale_q(pkt->dts,
- src->streams[pkt->stream_index]->time_base,
- dst->streams[dst_stream]->time_base);
- return av_write_frame(dst, &local_pkt);
-}
-
void ff_parse_key_value(const char *str, ff_parse_key_val_cb callback_get_buf,
void *context)
{
return -1;
}
-void ff_make_absolute_url(char *buf, int size, const char *base,
- const char *rel)
-{
- char *sep, *path_query;
- /* Absolute path, relative to the current server */
- if (base && strstr(base, "://") && rel[0] == '/') {
- if (base != buf)
- av_strlcpy(buf, base, size);
- sep = strstr(buf, "://");
- if (sep) {
- /* Take scheme from base url */
- if (rel[1] == '/') {
- sep[1] = '\0';
- } else {
- /* Take scheme and host from base url */
- sep += 3;
- sep = strchr(sep, '/');
- if (sep)
- *sep = '\0';
- }
- }
- av_strlcat(buf, rel, size);
- return;
- }
- /* If rel actually is an absolute url, just copy it */
- if (!base || strstr(rel, "://") || rel[0] == '/') {
- av_strlcpy(buf, rel, size);
- return;
- }
- if (base != buf)
- av_strlcpy(buf, base, size);
-
- /* Strip off any query string from base */
- path_query = strchr(buf, '?');
- if (path_query != NULL)
- *path_query = '\0';
-
- /* Is relative path just a new query part? */
- if (rel[0] == '?') {
- av_strlcat(buf, rel, size);
- return;
- }
-
- /* Remove the file name from the base url */
- sep = strrchr(buf, '/');
- if (sep)
- sep[1] = '\0';
- else
- buf[0] = '\0';
- while (av_strstart(rel, "../", NULL) && sep) {
- /* Remove the path delimiter at the end */
- sep[0] = '\0';
- sep = strrchr(buf, '/');
- /* If the next directory name to pop off is "..", break here */
- if (!strcmp(sep ? &sep[1] : buf, "..")) {
- /* Readd the slash we just removed */
- av_strlcat(buf, "/", size);
- break;
- }
- /* Cut off the directory name */
- if (sep)
- sep[1] = '\0';
- else
- buf[0] = '\0';
- rel += 3;
- }
- av_strlcat(buf, rel, size);
-}
-
int64_t ff_iso8601_to_unix_time(const char *datestr)
{
#if HAVE_STRPTIME
}
return 0;
}
-
-const struct AVCodecTag *avformat_get_riff_video_tags(void)
-{
- return ff_codec_bmp_tags;
-}
-const struct AVCodecTag *avformat_get_riff_audio_tags(void)
-{
- return ff_codec_wav_tags;
-}
-
-static int match_host_pattern(const char *pattern, const char *hostname)
-{
- int len_p, len_h;
- if (!strcmp(pattern, "*"))
- return 1;
- // Skip a possible *. at the start of the pattern
- if (pattern[0] == '*')
- pattern++;
- if (pattern[0] == '.')
- pattern++;
- len_p = strlen(pattern);
- len_h = strlen(hostname);
- if (len_p > len_h)
- return 0;
- // Simply check if the end of hostname is equal to 'pattern'
- if (!strcmp(pattern, &hostname[len_h - len_p])) {
- if (len_h == len_p)
- return 1; // Exact match
- if (hostname[len_h - len_p - 1] == '.')
- return 1; // The matched substring is a domain and not just a substring of a domain
- }
- return 0;
-}
-
-int ff_http_match_no_proxy(const char *no_proxy, const char *hostname)
-{
- char *buf, *start;
- int ret = 0;
- if (!no_proxy)
- return 0;
- if (!hostname)
- return 0;
- buf = av_strdup(no_proxy);
- if (!buf)
- return 0;
- start = buf;
- while (start) {
- char *sep, *next = NULL;
- start += strspn(start, " ,");
- sep = start + strcspn(start, " ,");
- if (*sep) {
- next = sep + 1;
- *sep = '\0';
- }
- if (match_host_pattern(start, hostname)) {
- ret = 1;
- break;
- }
- start = next;
- }
- av_free(buf);
- return ret;
-}
projects / ffmpeg / blobdiff