コード例 #1
0
ファイル: httpauth.c プロジェクト: AVLeo/libav
void ff_http_auth_handle_header(HTTPAuthState *state, const char *key,
                                const char *value)
{
    if (!strcmp(key, "WWW-Authenticate") || !strcmp(key, "Proxy-Authenticate")) {
        const char *p;
        if (av_stristart(value, "Basic ", &p) &&
            state->auth_type <= HTTP_AUTH_BASIC) {
            state->auth_type = HTTP_AUTH_BASIC;
            state->realm[0] = 0;
            state->stale = 0;
            ff_parse_key_value(p, (ff_parse_key_val_cb) handle_basic_params,
                               state);
        } else if (av_stristart(value, "Digest ", &p) &&
                   state->auth_type <= HTTP_AUTH_DIGEST) {
            state->auth_type = HTTP_AUTH_DIGEST;
            memset(&state->digest_params, 0, sizeof(DigestParams));
            state->realm[0] = 0;
            state->stale = 0;
            ff_parse_key_value(p, (ff_parse_key_val_cb) handle_digest_params,
                               state);
            choose_qop(state->digest_params.qop,
                       sizeof(state->digest_params.qop));
            if (!av_strcasecmp(state->digest_params.stale, "true"))
                state->stale = 1;
        }
    } else if (!strcmp(key, "Authentication-Info")) {
        ff_parse_key_value(value, (ff_parse_key_val_cb) handle_digest_update,
                           state);
    }
}
コード例 #2
0
ファイル: http.c プロジェクト: 309746069/FFmpeg
static inline int has_header(const char *str, const char *header)
{
    /* header + 2 to skip over CRLF prefix. (make sure you have one!) */
    if (!str)
        return 0;
    return av_stristart(str, header + 2, NULL) || av_stristr(str, header);
}
コード例 #3
0
ファイル: mpjpegdec.c プロジェクト: JacyG/FFmpeg
static char* mpjpeg_get_boundary(AVIOContext* pb)
{
    uint8_t *mime_type = NULL;
    const char *start;
    const char *end;
    uint8_t *res = NULL;
    int     len;

    /* get MIME type, and skip to the first parameter */
    av_opt_get(pb, "mime_type", AV_OPT_SEARCH_CHILDREN, &mime_type);
    start = mime_type;
    while (start != NULL && *start != '\0') {
        start = strchr(start, ';');
        if (!start)
            break;

        start = start+1;

        while (av_isspace(*start))
            start++;

        if (!av_stristart(start, "boundary=", &start)) {
            end = strchr(start, ';');
            if (end)
                len = end - start - 1;
            else
                len = strlen(start);
            res = av_strndup(start, len);
            break;
        }
    }

    av_freep(&mime_type);
    return res;
}
コード例 #4
0
void rtsp_parse_line(RTSPHeader *reply, const char *buf)
{
    const char *p;

    /* NOTE: we do case independent match for broken servers */
    p = buf;
    if (av_stristart(p, "Session:", &p)) {
        get_word_sep(reply->session_id, sizeof(reply->session_id), ";", &p);
    } else if (av_stristart(p, "Content-Length:", &p)) {
        reply->content_length = strtol(p, NULL, 10);
    } else if (av_stristart(p, "Transport:", &p)) {
        rtsp_parse_transport(reply, p);
    } else if (av_stristart(p, "CSeq:", &p)) {
        reply->seq = strtol(p, NULL, 10);
    } else if (av_stristart(p, "Range:", &p)) {
        rtsp_parse_range_npt(p, &reply->range_start, &reply->range_end);
    }
}
コード例 #5
0
ファイル: avstring.c プロジェクト: antoinemartin/FFmpeg
char *av_stristr(const char *s1, const char *s2)
{
    if (!*s2)
        return (char*)(intptr_t)s1;

    do {
        if (av_stristart(s1, s2, NULL))
            return (char*)(intptr_t)s1;
    } while (*s1++);

    return NULL;
}
コード例 #6
0
ファイル: avstring.c プロジェクト: hyunhojo/vsOpenHEVC
char *av_stristr(const char *s1, const char *s2)
{
    if (!*s2)
        return s1;

    do
        if (av_stristart(s1, s2, NULL))
            return s1;
    while (*s1++);

    return NULL;
}
コード例 #7
0
/** Parse a string \p in the form of Range:npt=xx-xx, and determine the start
 *  and end time.
 *  Used for seeking in the rtp stream.
 */
static void rtsp_parse_range_npt(const char *p, int64_t *start, int64_t *end)
{
    char buf[256];

    skip_spaces(&p);
    if (!av_stristart(p, "npt=", &p))
        return;

    *start = AV_NOPTS_VALUE;
    *end = AV_NOPTS_VALUE;

    get_word_sep(buf, sizeof(buf), "-", &p);
    *start = parse_date(buf, 1);
    if (*p == '-') {
        p++;
        get_word_sep(buf, sizeof(buf), "-", &p);
        *end = parse_date(buf, 1);
    }
//    av_log(NULL, AV_LOG_DEBUG, "Range Start: %lld\n", *start);
//    av_log(NULL, AV_LOG_DEBUG, "Range End: %lld\n", *end);
}
コード例 #8
0
/**
 * Identify if the stream as an AD binary stream
 */
static int adbinary_probe(AVProbeData *p)
{
    int score = 0;
    unsigned char *dataPtr;
    uint32_t dataSize;
    int bufferSize = p->buf_size;
    uint8_t *bufPtr = p->buf;

    // Netvu protocol can only send adbinary or admime
    if ( (p->filename) && (av_stristart(p->filename, "netvu://", NULL) == 1))
        score += AVPROBE_SCORE_MAX / 4;

    while ((bufferSize >= PKT_SEPARATOR_SIZE) && (score < AVPROBE_SCORE_MAX))  {
        dataSize =  (bufPtr[PKT_SIZE_BYTE_0] << 24) +
                    (bufPtr[PKT_SIZE_BYTE_1] << 16) +
                    (bufPtr[PKT_SIZE_BYTE_2] << 8 ) +
                    (bufPtr[PKT_SIZE_BYTE_3]);

        // Sanity check on dataSize
        if ((dataSize < 6) || (dataSize > 0x1000000))
            return 0;
        
        // Maximum of 32 cameras can be connected to a system
        if (bufPtr[PKT_DATACHANNEL] > 32)
            return 0;

        dataPtr = &bufPtr[PKT_SEPARATOR_SIZE];
        bufferSize -= PKT_SEPARATOR_SIZE;

        switch (bufPtr[PKT_DATATYPE])  {
            case AD_DATATYPE_JPEG:
            case AD_DATATYPE_MPEG4I:
            case AD_DATATYPE_MPEG4P:
            case AD_DATATYPE_H264I:
            case AD_DATATYPE_H264P:
                if (bufferSize >= NetVuImageDataHeaderSize) {
                    struct NetVuImageData test;
                    ad_network2host(&test, dataPtr);
                    if (pic_version_valid(test.version))  {
                        av_log(NULL, AV_LOG_DEBUG, "%s: Detected video packet\n", __func__);
                        score += AVPROBE_SCORE_MAX;
                    }
                }
                break;
            case AD_DATATYPE_JFIF:
                if (bufferSize >= 2)  {
                    if ( (*dataPtr == 0xFF) && (*(dataPtr + 1) == 0xD8) )  {
                        av_log(NULL, AV_LOG_DEBUG, "%s: Detected JFIF packet\n", __func__);
                        score += AVPROBE_SCORE_MAX;
                    }
                }
                break;
            case AD_DATATYPE_AUDIO_ADPCM:
                if (bufferSize >= NetVuAudioDataHeaderSize)  {
                    struct NetVuAudioData test;
                    audioheader_network2host(&test, dataPtr);
                    if (test.version == AUD_VERSION)  {
                        av_log(NULL, AV_LOG_DEBUG, "%s: Detected audio packet\n", __func__);
                        score += AVPROBE_SCORE_MAX;
                    }
                }
                break;
            case AD_DATATYPE_AUDIO_RAW:
                // We don't handle this format
                av_log(NULL, AV_LOG_DEBUG, "%s: Detected raw audio packet (unsupported)\n", __func__);
                break;
            case AD_DATATYPE_MINIMAL_MPEG4:
                if (bufferSize >= 10)  {
                    uint32_t sec  = AV_RB32(dataPtr);
                    uint32_t vos  = AV_RB32(dataPtr + 6);
                    
                    if (mpegOrH264(vos) == PIC_MODE_MPEG4_411)  {
                        // Check for MPEG4 start code in data along with a timestamp
                        // of 1980 or later.  Crappy test, but there isn't much data
                        // to go on.  Should be able to use milliseconds <= 1000 but
                        // servers often send larger values than this,
                        // nonsensical as that is
                        if (sec > 315532800)  {
                            if ((vos >= 0x1B0) && (vos <= 0x1B6)) {
                                av_log(NULL, AV_LOG_DEBUG, "%s: Detected minimal MPEG4 packet %u\n", __func__, dataSize);
                                score += AVPROBE_SCORE_MAX / 4;
                            }
                        }
                        break;
                    }
                }
                // Servers can send h264 identified as MPEG4, so fall through
                // to next case
            //case(AD_DATATYPE_MINIMAL_H264):
                if (bufferSize >= 10)  {
                    uint32_t sec  = AV_RB32(dataPtr);
                    uint32_t vos  = AV_RB32(dataPtr + 6);
                    // Check for h264 start code in data along with a timestamp
                    // of 1980 or later.  Crappy test, but there isn't much data
                    // to go on.  Should be able to use milliseconds <= 1000 but
                    // servers often send larger values than this,
                    // nonsensical as that is
                    if (sec > 315532800)  {
                        if (vos == 0x01) {
                            av_log(NULL, AV_LOG_DEBUG, "%s: Detected minimal h264 packet %u\n", __func__, dataSize);
                            score += AVPROBE_SCORE_MAX / 4;
                        }
                    }
                }
                break;
            case AD_DATATYPE_MINIMAL_AUDIO_ADPCM:
                if (bufferSize >= 8)  {
                    MinimalAudioHeader test;
                    test.t     = AV_RB32(dataPtr);
                    test.ms    = AV_RB16(dataPtr + 4);
                    test.mode  = AV_RB16(dataPtr + 6);

                    switch(test.mode)  {
                        case RTP_PAYLOAD_TYPE_8000HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_11025HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_16000HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_22050HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_32000HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_44100HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_48000HZ_ADPCM:
                        case RTP_PAYLOAD_TYPE_8000HZ_PCM:
                        case RTP_PAYLOAD_TYPE_11025HZ_PCM:
                        case RTP_PAYLOAD_TYPE_16000HZ_PCM:
                        case RTP_PAYLOAD_TYPE_22050HZ_PCM:
                        case RTP_PAYLOAD_TYPE_32000HZ_PCM: 
                        case RTP_PAYLOAD_TYPE_44100HZ_PCM:
                        case RTP_PAYLOAD_TYPE_48000HZ_PCM:
                            av_log(NULL, AV_LOG_DEBUG, "%s: Detected minimal audio packet\n", __func__);
                            score += AVPROBE_SCORE_MAX / 4;
                    }
                }
                break;
            case AD_DATATYPE_LAYOUT:
                av_log(NULL, AV_LOG_DEBUG, "%s: Detected layout packet\n", __func__);
                break;
            case AD_DATATYPE_INFO:
                if ( (bufferSize >= 1) && (dataPtr[0] == 0) || (dataPtr[0] == 1) )  {
                    av_log(NULL, AV_LOG_DEBUG, "%s: Detected info packet (%d)\n", __func__, dataPtr[0]);
                    if ((bufferSize >= 5) && (strncmp(&dataPtr[1], "SITE", 4) == 0))
                        score += AVPROBE_SCORE_MAX;
                    else if ((bufferSize >= 15) && (strncmp(&dataPtr[1], "(JPEG)TARGSIZE", 14) == 0))
                        score += AVPROBE_SCORE_MAX;
                    else
                        score += 5;
                }
                break;
            case AD_DATATYPE_XML_INFO:
                if (bufferSize >= dataSize)  {
                    const char *infoString = "<infoList>";
                    int infoStringLen = strlen(infoString);
                    if ( (infoStringLen <= dataSize) && (av_strncasecmp(dataPtr, infoString, infoStringLen) == 0) )  {
                        av_log(NULL, AV_LOG_DEBUG, "%s: Detected xml info packet\n", __func__);
                        score += AVPROBE_SCORE_MAX;
                    }
                }
                break;
            case AD_DATATYPE_BMP:
                av_log(NULL, AV_LOG_DEBUG, "%s: Detected bmp packet\n", __func__);
                break;
            case AD_DATATYPE_PBM:
                if (bufferSize >= 3)  {
                    if ((dataPtr[0] == 'P') && (dataPtr[1] >= '1') && (dataPtr[1] <= '6'))  {
                        if (dataPtr[2] == 0x0A)  {
                            score += AVPROBE_SCORE_MAX;
                            av_log(NULL, AV_LOG_DEBUG, "%s: Detected pbm packet\n", __func__);
                        }
                    }
                }
                break;
            case AD_DATATYPE_SVARS_INFO:
                if ( (bufferSize >= 1) && (dataPtr[0] == 0) || (dataPtr[0] == 1) )  {
                    av_log(NULL, AV_LOG_DEBUG, "%s: Detected svars info packet (%d)\n", __func__, dataPtr[0]);
                    score += 5;
                }
                break;
            default:
                av_log(NULL, AV_LOG_DEBUG, "%s: Detected unknown packet type\n", __func__);
                break;
        }

        if (dataSize <= bufferSize)  {
            bufferSize -= dataSize;
            bufPtr = dataPtr + dataSize;
        }
        else  {
            bufferSize = 0;
            bufPtr = p->buf;
        }
    }

    if (score > AVPROBE_SCORE_MAX)
        score = AVPROBE_SCORE_MAX;

    av_log(NULL, AV_LOG_DEBUG, "%s: Score %d\n", __func__, score);

    return score;
}