Merge commit 'ec7c51c7868d3ccc66b5cc38bf126258b94f086c'
authorMichael Niedermayer <michaelni@gmx.at>
Sun, 16 Jun 2013 21:45:42 +0000 (23:45 +0200)
committerMichael Niedermayer <michaelni@gmx.at>
Sun, 16 Jun 2013 21:45:42 +0000 (23:45 +0200)
* commit 'ec7c51c7868d3ccc66b5cc38bf126258b94f086c':
  avf: move ff_http_match_no_proxy to network

Conflicts:
libavformat/internal.h
libavformat/utils.c

Merged-by: Michael Niedermayer <michaelni@gmx.at>
1  2 
libavformat/internal.h
libavformat/network.c
libavformat/network.h
libavformat/noproxy-test.c
libavformat/utils.c

@@@ -376,20 -375,4 +376,18 @@@ enum AVCodecID ff_codec_get_id(const AV
   */
  enum AVCodecID ff_get_pcm_codec_id(int bps, int flt, int be, int sflags);
  
- int ff_http_match_no_proxy(const char *no_proxy, const char *hostname);
 +/**
 + * Chooses a timebase for muxing the specified stream.
 + *
 + * The choosen timebase allows sample accurate timestamps based
 + * on the framerate or sample rate for audio streams. It also is
 + * at least as precisse as 1/min_precission would be.
 + */
 +AVRational ff_choose_timebase(AVFormatContext *s, AVStream *st, int min_precission);
 +
 +/**
 + * Generate standard extradata for AVC-Intra based on width/height and field order.
 + */
 +void ff_generate_avci_extradata(AVStream *st);
 +
  #endif /* AVFORMAT_INTERNAL_H */
Simple merge
Simple merge
Simple merge
@@@ -4136,252 -3407,3 +4136,198 @@@ const struct AVCodecTag *avformat_get_r
  {
      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;
- }
 +
 +AVRational av_guess_sample_aspect_ratio(AVFormatContext *format, AVStream *stream, AVFrame *frame)
 +{
 +    AVRational undef = {0, 1};
 +    AVRational stream_sample_aspect_ratio = stream ? stream->sample_aspect_ratio : undef;
 +    AVRational codec_sample_aspect_ratio  = stream && stream->codec ? stream->codec->sample_aspect_ratio : undef;
 +    AVRational frame_sample_aspect_ratio  = frame  ? frame->sample_aspect_ratio  : codec_sample_aspect_ratio;
 +
 +    av_reduce(&stream_sample_aspect_ratio.num, &stream_sample_aspect_ratio.den,
 +               stream_sample_aspect_ratio.num,  stream_sample_aspect_ratio.den, INT_MAX);
 +    if (stream_sample_aspect_ratio.num <= 0 || stream_sample_aspect_ratio.den <= 0)
 +        stream_sample_aspect_ratio = undef;
 +
 +    av_reduce(&frame_sample_aspect_ratio.num, &frame_sample_aspect_ratio.den,
 +               frame_sample_aspect_ratio.num,  frame_sample_aspect_ratio.den, INT_MAX);
 +    if (frame_sample_aspect_ratio.num <= 0 || frame_sample_aspect_ratio.den <= 0)
 +        frame_sample_aspect_ratio = undef;
 +
 +    if (stream_sample_aspect_ratio.num)
 +        return stream_sample_aspect_ratio;
 +    else
 +        return frame_sample_aspect_ratio;
 +}
 +
 +AVRational av_guess_frame_rate(AVFormatContext *format, AVStream *st, AVFrame *frame)
 +{
 +    AVRational fr = st->r_frame_rate;
 +
 +    if (st->codec->ticks_per_frame > 1) {
 +        AVRational codec_fr = av_inv_q(st->codec->time_base);
 +        AVRational   avg_fr = st->avg_frame_rate;
 +        codec_fr.den *= st->codec->ticks_per_frame;
 +        if (   codec_fr.num > 0 && codec_fr.den > 0 && av_q2d(codec_fr) < av_q2d(fr)*0.7
 +            && fabs(1.0 - av_q2d(av_div_q(avg_fr, fr))) > 0.1)
 +            fr = codec_fr;
 +    }
 +
 +    return fr;
 +}
 +
 +int avformat_match_stream_specifier(AVFormatContext *s, AVStream *st,
 +                                    const char *spec)
 +{
 +    if (*spec <= '9' && *spec >= '0') /* opt:index */
 +        return strtol(spec, NULL, 0) == st->index;
 +    else if (*spec == 'v' || *spec == 'a' || *spec == 's' || *spec == 'd' ||
 +             *spec == 't') { /* opt:[vasdt] */
 +        enum AVMediaType type;
 +
 +        switch (*spec++) {
 +        case 'v': type = AVMEDIA_TYPE_VIDEO;      break;
 +        case 'a': type = AVMEDIA_TYPE_AUDIO;      break;
 +        case 's': type = AVMEDIA_TYPE_SUBTITLE;   break;
 +        case 'd': type = AVMEDIA_TYPE_DATA;       break;
 +        case 't': type = AVMEDIA_TYPE_ATTACHMENT; break;
 +        default:  av_assert0(0);
 +        }
 +        if (type != st->codec->codec_type)
 +            return 0;
 +        if (*spec++ == ':') { /* possibly followed by :index */
 +            int i, index = strtol(spec, NULL, 0);
 +            for (i = 0; i < s->nb_streams; i++)
 +                if (s->streams[i]->codec->codec_type == type && index-- == 0)
 +                   return i == st->index;
 +            return 0;
 +        }
 +        return 1;
 +    } else if (*spec == 'p' && *(spec + 1) == ':') {
 +        int prog_id, i, j;
 +        char *endptr;
 +        spec += 2;
 +        prog_id = strtol(spec, &endptr, 0);
 +        for (i = 0; i < s->nb_programs; i++) {
 +            if (s->programs[i]->id != prog_id)
 +                continue;
 +
 +            if (*endptr++ == ':') {
 +                int stream_idx = strtol(endptr, NULL, 0);
 +                return stream_idx >= 0 &&
 +                    stream_idx < s->programs[i]->nb_stream_indexes &&
 +                    st->index == s->programs[i]->stream_index[stream_idx];
 +            }
 +
 +            for (j = 0; j < s->programs[i]->nb_stream_indexes; j++)
 +                if (st->index == s->programs[i]->stream_index[j])
 +                    return 1;
 +        }
 +        return 0;
 +    } else if (*spec == '#') {
 +        int sid;
 +        char *endptr;
 +        sid = strtol(spec + 1, &endptr, 0);
 +        if (!*endptr)
 +            return st->id == sid;
 +    } else if (!*spec) /* empty specifier, matches everything */
 +        return 1;
 +
 +    av_log(s, AV_LOG_ERROR, "Invalid stream specifier: %s.\n", spec);
 +    return AVERROR(EINVAL);
 +}
 +
 +void ff_generate_avci_extradata(AVStream *st)
 +{
 +    static const uint8_t avci100_1080p_extradata[] = {
 +        // SPS
 +        0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
 +        0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
 +        0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
 +        0x18, 0x21, 0x02, 0x56, 0xb9, 0x3d, 0x7d, 0x7e,
 +        0x4f, 0xe3, 0x3f, 0x11, 0xf1, 0x9e, 0x08, 0xb8,
 +        0x8c, 0x54, 0x43, 0xc0, 0x78, 0x02, 0x27, 0xe2,
 +        0x70, 0x1e, 0x30, 0x10, 0x10, 0x14, 0x00, 0x00,
 +        0x03, 0x00, 0x04, 0x00, 0x00, 0x03, 0x00, 0xca,
 +        0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
 +        // PPS
 +        0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
 +        0xd0
 +    };
 +    static const uint8_t avci100_1080i_extradata[] = {
 +        // SPS
 +        0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
 +        0xb6, 0xd4, 0x20, 0x22, 0x33, 0x19, 0xc6, 0x63,
 +        0x23, 0x21, 0x01, 0x11, 0x98, 0xce, 0x33, 0x19,
 +        0x18, 0x21, 0x03, 0x3a, 0x46, 0x65, 0x6a, 0x65,
 +        0x24, 0xad, 0xe9, 0x12, 0x32, 0x14, 0x1a, 0x26,
 +        0x34, 0xad, 0xa4, 0x41, 0x82, 0x23, 0x01, 0x50,
 +        0x2b, 0x1a, 0x24, 0x69, 0x48, 0x30, 0x40, 0x2e,
 +        0x11, 0x12, 0x08, 0xc6, 0x8c, 0x04, 0x41, 0x28,
 +        0x4c, 0x34, 0xf0, 0x1e, 0x01, 0x13, 0xf2, 0xe0,
 +        0x3c, 0x60, 0x20, 0x20, 0x28, 0x00, 0x00, 0x03,
 +        0x00, 0x08, 0x00, 0x00, 0x03, 0x01, 0x94, 0x00,
 +        // PPS
 +        0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x33, 0x48,
 +        0xd0
 +    };
 +    static const uint8_t avci50_1080i_extradata[] = {
 +        // SPS
 +        0x00, 0x00, 0x00, 0x01, 0x67, 0x6e, 0x10, 0x28,
 +        0xa6, 0xd4, 0x20, 0x32, 0x33, 0x0c, 0x71, 0x18,
 +        0x88, 0x62, 0x10, 0x19, 0x19, 0x86, 0x38, 0x8c,
 +        0x44, 0x30, 0x21, 0x02, 0x56, 0x4e, 0x6e, 0x61,
 +        0x87, 0x3e, 0x73, 0x4d, 0x98, 0x0c, 0x03, 0x06,
 +        0x9c, 0x0b, 0x73, 0xe6, 0xc0, 0xb5, 0x18, 0x63,
 +        0x0d, 0x39, 0xe0, 0x5b, 0x02, 0xd4, 0xc6, 0x19,
 +        0x1a, 0x79, 0x8c, 0x32, 0x34, 0x24, 0xf0, 0x16,
 +        0x81, 0x13, 0xf7, 0xff, 0x80, 0x02, 0x00, 0x01,
 +        0xf1, 0x80, 0x80, 0x80, 0xa0, 0x00, 0x00, 0x03,
 +        0x00, 0x20, 0x00, 0x00, 0x06, 0x50, 0x80, 0x00,
 +        // PPS
 +        0x00, 0x00, 0x00, 0x01, 0x68, 0xee, 0x31, 0x12,
 +        0x11
 +    };
 +    static const uint8_t avci100_720p_extradata[] = {
 +        // SPS
 +        0x00, 0x00, 0x00, 0x01, 0x67, 0x7a, 0x10, 0x29,
 +        0xb6, 0xd4, 0x20, 0x2a, 0x33, 0x1d, 0xc7, 0x62,
 +        0xa1, 0x08, 0x40, 0x54, 0x66, 0x3b, 0x8e, 0xc5,
 +        0x42, 0x02, 0x10, 0x25, 0x64, 0x2c, 0x89, 0xe8,
 +        0x85, 0xe4, 0x21, 0x4b, 0x90, 0x83, 0x06, 0x95,
 +        0xd1, 0x06, 0x46, 0x97, 0x20, 0xc8, 0xd7, 0x43,
 +        0x08, 0x11, 0xc2, 0x1e, 0x4c, 0x91, 0x0f, 0x01,
 +        0x40, 0x16, 0xec, 0x07, 0x8c, 0x04, 0x04, 0x05,
 +        0x00, 0x00, 0x03, 0x00, 0x01, 0x00, 0x00, 0x03,
 +        0x00, 0x64, 0x84, 0x00, 0x00, 0x00, 0x00, 0x00,
 +        // PPS
 +        0x00, 0x00, 0x00, 0x01, 0x68, 0xce, 0x31, 0x12,
 +        0x11
 +    };
 +    int size = 0;
 +    const uint8_t *data = 0;
 +    if (st->codec->width == 1920) {
 +        if (st->codec->field_order == AV_FIELD_PROGRESSIVE) {
 +            data = avci100_1080p_extradata;
 +            size = sizeof(avci100_1080p_extradata);
 +        } else {
 +            data = avci100_1080i_extradata;
 +            size = sizeof(avci100_1080i_extradata);
 +        }
 +    } else if (st->codec->width == 1440) {
 +        data = avci50_1080i_extradata;
 +        size = sizeof(avci50_1080i_extradata);
 +    } else if (st->codec->width == 1280) {
 +        data = avci100_720p_extradata;
 +        size = sizeof(avci100_720p_extradata);
 +    }
 +    if (!size)
 +        return;
 +    av_freep(&st->codec->extradata);
 +    st->codec->extradata_size = 0;
 +    st->codec->extradata = av_mallocz(size + FF_INPUT_BUFFER_PADDING_SIZE);
 +    if (!st->codec->extradata)
 +        return;
 +    memcpy(st->codec->extradata, data, size);
 +    st->codec->extradata_size = size;
 +}