static int rt_event_to_ass(AVBPrint *buf, const char *p)
{
int prev_chr_is_space = 1;
while (*p) {
if (*p != '<') {
if (!isspace(*p))
av_bprint_chars(buf, *p, 1);
else if (!prev_chr_is_space)
av_bprint_chars(buf, ' ', 1);
prev_chr_is_space = isspace(*p);
} else {
const char *end = strchr(p, '>');
if (!end)
break;
if (!av_strncasecmp(p, "<br/>", 5) ||
!av_strncasecmp(p, "<br>", 4)) {
av_bprintf(buf, "\\N");
}
p = end;
}
p++;
}
av_bprintf(buf, "\r\n");
return 0;
}
static int parse_content_encoding(URLContext *h, const char *p)
{
if (!av_strncasecmp(p, "gzip", 4) ||
!av_strncasecmp(p, "deflate", 7)) {
#if CONFIG_ZLIB
HTTPContext *s = h->priv_data;
s->compressed = 1;
inflateEnd(&s->inflate_stream);
if (inflateInit2(&s->inflate_stream, 32 + 15) != Z_OK) {
av_log(h, AV_LOG_WARNING, "Error during zlib initialisation: %s\n",
s->inflate_stream.msg);
return AVERROR(ENOSYS);
}
if (zlibCompileFlags() & (1 << 17)) {
av_log(h, AV_LOG_WARNING,
"Your zlib was compiled without gzip support.\n");
return AVERROR(ENOSYS);
}
#else
av_log(h, AV_LOG_WARNING,
"Compressed (%s) content, need zlib with gzip support\n", p);
return AVERROR(ENOSYS);
#endif /* CONFIG_ZLIB */
} else if (!av_strncasecmp(p, "identity", 8)) {
// The normal, no-encoding case (although servers shouldn't include
// the header at all if this is the case).
} else {
av_log(h, AV_LOG_WARNING, "Unknown content coding: %s\n", p);
}
return 0;
}
static int sami_read_header(AVFormatContext *s)
{
SAMIContext *sami = s->priv_data;
AVStream *st = avformat_new_stream(s, NULL);
AVBPrint buf, hdr_buf;
char c = 0;
int res = 0, got_first_sync_point = 0;
FFTextReader tr;
ff_text_init_avio(&tr, s->pb);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 1000);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_SAMI;
av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
av_bprint_init(&hdr_buf, 0, AV_BPRINT_SIZE_UNLIMITED);
while (!ff_text_eof(&tr)) {
AVPacket *sub;
const int64_t pos = ff_text_pos(&tr) - (c != 0);
int is_sync, n = ff_smil_extract_next_text_chunk(&tr, &buf, &c);
if (n == 0)
break;
is_sync = !av_strncasecmp(buf.str, "<SYNC", 5);
if (is_sync)
got_first_sync_point = 1;
if (!got_first_sync_point) {
av_bprintf(&hdr_buf, "%s", buf.str);
} else {
sub = ff_subtitles_queue_insert(&sami->q, buf.str, buf.len, !is_sync);
if (!sub) {
res = AVERROR(ENOMEM);
goto end;
}
if (is_sync) {
const char *p = ff_smil_get_attr_ptr(buf.str, "Start");
sub->pos = pos;
sub->pts = p ? strtol(p, NULL, 10) : 0;
sub->duration = -1;
}
}
av_bprint_clear(&buf);
}
res = avpriv_bprint_to_extradata(st->codec, &hdr_buf);
if (res < 0)
goto end;
ff_subtitles_queue_finalize(&sami->q);
end:
av_bprint_finalize(&buf, NULL);
return res;
}
static int realtext_probe(AVProbeData *p)
{
const unsigned char *ptr = p->buf;
if (AV_RB24(ptr) == 0xEFBBBF)
ptr += 3; /* skip UTF-8 BOM */
return !av_strncasecmp(ptr, "<window", 7) ? AVPROBE_SCORE_MAX/2 : 0;
}
static av_cold int data_open(URLContext *h, const char *uri, int flags)
{
DataContext *dc = h->priv_data;
const char *data, *opt, *next;
char *ddata;
int ret, base64 = 0;
size_t in_size;
/* data:content/type[;base64],payload */
av_strstart(uri, "data:", &uri);
data = strchr(uri, ',');
if (!data) {
av_log(h, AV_LOG_ERROR, "No ',' delimiter in URI\n");
return AVERROR(EINVAL);
}
opt = uri;
while (opt < data) {
next = av_x_if_null(memchr(opt, ';', data - opt), data);
if (opt == uri) {
if (!memchr(opt, '/', next - opt)) { /* basic validity check */
av_log(h, AV_LOG_ERROR, "Invalid content-type '%.*s'\n",
(int)(next - opt), opt);
return AVERROR(EINVAL);
}
av_log(h, AV_LOG_VERBOSE, "Content-type: %.*s\n",
(int)(next - opt), opt);
} else {
if (!av_strncasecmp(opt, "base64", next - opt)) {
base64 = 1;
} else {
av_log(h, AV_LOG_VERBOSE, "Ignoring option '%.*s'\n",
(int)(next - opt), opt);
}
}
opt = next + 1;
}
data++;
in_size = strlen(data);
if (base64) {
size_t out_size = 3 * (in_size / 4) + 1;
if (out_size > INT_MAX || !(ddata = av_malloc(out_size)))
return AVERROR(ENOMEM);
if ((ret = av_base64_decode(ddata, data, out_size)) < 0) {
av_free(ddata);
av_log(h, AV_LOG_ERROR, "Invalid base64 in URI\n");
return ret;
}
dc->data = dc->tofree = ddata;
dc->size = ret;
} else {
dc->data = data;
dc->size = in_size;
}
return 0;
}
static int realtext_probe(AVProbeData *p)
{
char buf[7];
FFTextReader tr;
ff_text_init_buf(&tr, p->buf, p->buf_size);
ff_text_read(&tr, buf, sizeof(buf));
return !av_strncasecmp(buf, "<window", 7) ? AVPROBE_SCORE_EXTENSION : 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);
}
const char *ff_smil_get_attr_ptr(const char *s, const char *attr)
{
int in_quotes = 0;
const int len = strlen(attr);
while (*s) {
while (*s) {
if (!in_quotes && av_isspace(*s))
break;
in_quotes ^= *s == '"'; // XXX: support escaping?
s++;
}
while (av_isspace(*s))
s++;
if (!av_strncasecmp(s, attr, len) && s[len] == '=')
return s + len + 1 + (s[len + 1] == '"');
}
return NULL;
}
static int realtext_read_header(AVFormatContext *s)
{
RealTextContext *rt = s->priv_data;
AVStream *st = avformat_new_stream(s, NULL);
AVBPrint buf;
char c = 0;
int res = 0, duration = read_ts("60"); // default duration is 60 seconds
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_REALTEXT;
av_bprint_init(&buf, 0, AV_BPRINT_SIZE_UNLIMITED);
while (!url_feof(s->pb)) {
AVPacket *sub;
const int64_t pos = avio_tell(s->pb) - (c != 0);
int n = ff_smil_extract_next_chunk(s->pb, &buf, &c);
if (n == 0)
break;
if (!av_strncasecmp(buf.str, "<window", 7)) {
/* save header to extradata */
const char *p = ff_smil_get_attr_ptr(buf.str, "duration");
if (p)
duration = read_ts(p);
st->codec->extradata = av_strdup(buf.str);
if (!st->codec->extradata) {
res = AVERROR(ENOMEM);
goto end;
}
st->codec->extradata_size = buf.len + 1;
} else {
/* if we just read a <time> tag, introduce a new event, otherwise merge
* with the previous one */
int merge = !av_strncasecmp(buf.str, "<time", 5) ? 0 : 1;
sub = ff_subtitles_queue_insert(&rt->q, buf.str, buf.len, merge);
if (!sub) {
res = AVERROR(ENOMEM);
goto end;
}
if (!merge) {
const char *begin = ff_smil_get_attr_ptr(buf.str, "begin");
const char *end = ff_smil_get_attr_ptr(buf.str, "end");
sub->pos = pos;
sub->pts = begin ? read_ts(begin) : 0;
sub->duration = end ? (read_ts(end) - sub->pts) : duration;
}
}
av_bprint_clear(&buf);
}
ff_subtitles_queue_finalize(&rt->q);
end:
av_bprint_finalize(&buf, NULL);
return res;
}
static double avpriv_strtod(const char *nptr, char **endptr)
{
char *end;
double res;
/* Skip leading spaces */
while (av_isspace(*nptr))
nptr++;
if (!av_strncasecmp(nptr, "infinity", 8)) {
end = nptr + 8;
res = INFINITY;
} else if (!av_strncasecmp(nptr, "inf", 3)) {
end = nptr + 3;
res = INFINITY;
} else if (!av_strncasecmp(nptr, "+infinity", 9)) {
end = nptr + 9;
res = INFINITY;
} else if (!av_strncasecmp(nptr, "+inf", 4)) {
end = nptr + 4;
res = INFINITY;
} else if (!av_strncasecmp(nptr, "-infinity", 9)) {
end = nptr + 9;
res = -INFINITY;
} else if (!av_strncasecmp(nptr, "-inf", 4)) {
end = nptr + 4;
res = -INFINITY;
} else if (!av_strncasecmp(nptr, "nan", 3)) {
end = check_nan_suffix(nptr + 3);
res = NAN;
} else if (!av_strncasecmp(nptr, "+nan", 4) ||
!av_strncasecmp(nptr, "-nan", 4)) {
end = check_nan_suffix(nptr + 4);
res = NAN;
} else if (!av_strncasecmp(nptr, "0x", 2) ||
!av_strncasecmp(nptr, "-0x", 3) ||
!av_strncasecmp(nptr, "+0x", 3)) {
/* FIXME this doesn't handle exponents, non-integers (float/double)
* and numbers too large for long long */
res = strtoll(nptr, &end, 16);
} else {
res = strtod(nptr, &end);
}
if (endptr)
*endptr = end;
return res;
}
static int process_line(URLContext *h, char *line, int line_count,
int *new_location)
{
HTTPContext *s = h->priv_data;
char *tag, *p, *end;
int ret;
/* end of header */
if (line[0] == '\0') {
s->end_header = 1;
return 0;
}
p = line;
if (line_count == 0) {
while (!av_isspace(*p) && *p != '\0')
p++;
while (av_isspace(*p))
p++;
s->http_code = strtol(p, &end, 10);
av_log(NULL, AV_LOG_TRACE, "http_code=%d\n", s->http_code);
if ((ret = check_http_code(h, s->http_code, end)) < 0)
return ret;
} else {
while (*p != '\0' && *p != ':')
p++;
if (*p != ':')
return 1;
*p = '\0';
tag = line;
p++;
while (av_isspace(*p))
p++;
if (!av_strcasecmp(tag, "Location")) {
if ((ret = parse_location(s, p)) < 0)
return ret;
*new_location = 1;
} else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
s->filesize = strtoll(p, NULL, 10);
} else if (!av_strcasecmp(tag, "Content-Range")) {
parse_content_range(h, p);
} else if (!av_strcasecmp(tag, "Accept-Ranges") &&
!strncmp(p, "bytes", 5)) {
h->is_streamed = 0;
} else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
!av_strncasecmp(p, "chunked", 7)) {
s->filesize = -1;
s->chunksize = 0;
} else if (!av_strcasecmp(tag, "WWW-Authenticate")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Authentication-Info")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Proxy-Authenticate")) {
ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Connection")) {
if (!strcmp(p, "close"))
s->willclose = 1;
} else if (!av_strcasecmp(tag, "Content-Type")) {
av_free(s->mime_type);
s->mime_type = av_strdup(p);
} else if (!av_strcasecmp(tag, "Icy-MetaInt")) {
s->icy_metaint = strtoll(p, NULL, 10);
} else if (!av_strncasecmp(tag, "Icy-", 4)) {
if ((ret = parse_icy(s, tag, p)) < 0)
return ret;
} else if (!av_strcasecmp(tag, "Content-Encoding")) {
if ((ret = parse_content_encoding(h, p)) < 0)
return ret;
}
}
return 1;
}
/**
* Create a string containing cookie values for use as a HTTP cookie header
* field value for a particular path and domain from the cookie values stored in
* the HTTP protocol context. The cookie string is stored in *cookies.
*
* @return a negative value if an error condition occurred, 0 otherwise
*/
static int get_cookies(HTTPContext *s, char **cookies, const char *path,
const char *domain)
{
// cookie strings will look like Set-Cookie header field values. Multiple
// Set-Cookie fields will result in multiple values delimited by a newline
int ret = 0;
char *next, *cookie, *set_cookies = av_strdup(s->cookies), *cset_cookies = set_cookies;
if (!set_cookies) return AVERROR(EINVAL);
// destroy any cookies in the dictionary.
av_dict_free(&s->cookie_dict);
*cookies = NULL;
while ((cookie = av_strtok(set_cookies, "\n", &next))) {
int domain_offset = 0;
char *param, *next_param, *cdomain = NULL, *cpath = NULL, *cvalue = NULL;
set_cookies = NULL;
// store the cookie in a dict in case it is updated in the response
if (parse_cookie(s, cookie, &s->cookie_dict))
av_log(s, AV_LOG_WARNING, "Unable to parse '%s'\n", cookie);
while ((param = av_strtok(cookie, "; ", &next_param))) {
if (cookie) {
// first key-value pair is the actual cookie value
cvalue = av_strdup(param);
cookie = NULL;
} else if (!av_strncasecmp("path=", param, 5)) {
av_free(cpath);
cpath = av_strdup(¶m[5]);
} else if (!av_strncasecmp("domain=", param, 7)) {
// if the cookie specifies a sub-domain, skip the leading dot thereby
// supporting URLs that point to sub-domains and the master domain
int leading_dot = (param[7] == '.');
av_free(cdomain);
cdomain = av_strdup(¶m[7+leading_dot]);
} else {
// ignore unknown attributes
}
}
if (!cdomain)
cdomain = av_strdup(domain);
// ensure all of the necessary values are valid
if (!cdomain || !cpath || !cvalue) {
av_log(s, AV_LOG_WARNING,
"Invalid cookie found, no value, path or domain specified\n");
goto done_cookie;
}
// check if the request path matches the cookie path
if (av_strncasecmp(path, cpath, strlen(cpath)))
goto done_cookie;
// the domain should be at least the size of our cookie domain
domain_offset = strlen(domain) - strlen(cdomain);
if (domain_offset < 0)
goto done_cookie;
// match the cookie domain
if (av_strcasecmp(&domain[domain_offset], cdomain))
goto done_cookie;
// cookie parameters match, so copy the value
if (!*cookies) {
if (!(*cookies = av_strdup(cvalue))) {
ret = AVERROR(ENOMEM);
goto done_cookie;
}
} else {
char *tmp = *cookies;
size_t str_size = strlen(cvalue) + strlen(*cookies) + 3;
if (!(*cookies = av_malloc(str_size))) {
ret = AVERROR(ENOMEM);
goto done_cookie;
}
snprintf(*cookies, str_size, "%s; %s", tmp, cvalue);
av_free(tmp);
}
done_cookie:
av_freep(&cdomain);
av_freep(&cpath);
av_freep(&cvalue);
if (ret < 0) {
if (*cookies) av_freep(cookies);
av_free(cset_cookies);
return ret;
}
}
av_free(cset_cookies);
return 0;
}
static int jacosub_read_header(AVFormatContext *s)
{
AVBPrint header;
AVIOContext *pb = s->pb;
char line[JSS_MAX_LINESIZE];
JACOsubContext *jacosub = s->priv_data;
int shift_set = 0; // only the first shift matters
int merge_line = 0;
int i;
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = CODEC_ID_JACOSUB;
jacosub->timeres = 30;
av_bprint_init(&header, 1024+FF_INPUT_BUFFER_PADDING_SIZE, 4096);
while (!url_feof(pb)) {
int cmd_len;
const char *p = line;
int64_t pos = avio_tell(pb);
ff_get_line(pb, line, sizeof(line));
p = jss_skip_whitespace(p);
/* queue timed line */
if (merge_line || timed_line(p)) {
SubEntry *subs, *sub;
const int len = strlen(line);
if (merge_line) {
char *tmp;
const int old_len = strlen(sub->line);
sub = &subs[jacosub->nsub];
tmp = av_realloc(sub->line, old_len + len + 1);
if (!tmp)
return AVERROR(ENOMEM);
sub->line = tmp;
strcpy(sub->line + old_len, line);
} else {
subs = av_realloc(jacosub->subs,
sizeof(*jacosub->subs) * (jacosub->nsub+1));
if (!subs)
return AVERROR(ENOMEM);
jacosub->subs = subs;
sub = &subs[jacosub->nsub];
sub->pos = pos;
sub->line = av_strdup(line);
if (!sub->line)
return AVERROR(ENOMEM);
}
merge_line = len > 1 && !strcmp(&line[len - 2], "\\\n");
if (!merge_line)
jacosub->nsub++;
continue;
}
/* skip all non-compiler commands and focus on the command */
if (*p != '#')
continue;
p++;
i = get_jss_cmd(p[0]);
if (i == -1)
continue;
/* trim command + spaces */
cmd_len = strlen(cmds[i]);
if (av_strncasecmp(p, cmds[i], cmd_len) == 0)
p += cmd_len;
else
p++;
p = jss_skip_whitespace(p);
/* handle commands which affect the whole script */
switch (cmds[i][0]) {
case 'S': // SHIFT command affect the whole script...
if (!shift_set) {
jacosub->shift = get_shift(jacosub->timeres, p);
shift_set = 1;
}
av_bprintf(&header, "#S %s", p);
break;
case 'T': // ...but must be placed after TIMERES
jacosub->timeres = strtol(p, NULL, 10);
av_bprintf(&header, "#T %s", p);
break;
}
}
/* general/essential directives in the extradata */
av_bprint_finalize(&header, (char **)&st->codec->extradata);
st->codec->extradata_size = header.len + 1;
/* SHIFT and TIMERES affect the whole script so packet timing can only be
* done in a second pass */
for (i = 0; i < jacosub->nsub; i++) {
SubEntry *sub = &jacosub->subs[i];
read_ts(jacosub, sub->line, &sub->start, &sub->end);
}
qsort(jacosub->subs, jacosub->nsub, sizeof(*jacosub->subs), cmp_timed_sub);
return 0;
}
static int nist_read_header(AVFormatContext *s)
{
char buffer[256], coding[32] = "pcm", format[32] = "01";
int bps = 0, be = 0;
int32_t header_size = -1;
AVStream *st;
st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
st->codecpar->codec_type = AVMEDIA_TYPE_AUDIO;
ff_get_line(s->pb, buffer, sizeof(buffer));
ff_get_line(s->pb, buffer, sizeof(buffer));
sscanf(buffer, "%"SCNd32, &header_size);
if (header_size <= 0)
return AVERROR_INVALIDDATA;
while (!avio_feof(s->pb)) {
ff_get_line(s->pb, buffer, sizeof(buffer));
if (avio_tell(s->pb) >= header_size)
return AVERROR_INVALIDDATA;
if (!memcmp(buffer, "end_head", 8)) {
if (!st->codecpar->bits_per_coded_sample)
st->codecpar->bits_per_coded_sample = bps << 3;
if (!av_strcasecmp(coding, "pcm")) {
if (st->codecpar->codec_id == AV_CODEC_ID_NONE)
st->codecpar->codec_id = ff_get_pcm_codec_id(st->codecpar->bits_per_coded_sample,
0, be, 0xFFFF);
} else if (!av_strcasecmp(coding, "alaw")) {
st->codecpar->codec_id = AV_CODEC_ID_PCM_ALAW;
} else if (!av_strcasecmp(coding, "ulaw") ||
!av_strcasecmp(coding, "mu-law")) {
st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW;
} else if (!av_strncasecmp(coding, "pcm,embedded-shorten", 20)) {
st->codecpar->codec_id = AV_CODEC_ID_SHORTEN;
if (ff_alloc_extradata(st->codecpar, 1))
st->codecpar->extradata[0] = 1;
} else {
avpriv_request_sample(s, "coding %s", coding);
}
avpriv_set_pts_info(st, 64, 1, st->codecpar->sample_rate);
st->codecpar->block_align = st->codecpar->bits_per_coded_sample * st->codecpar->channels / 8;
if (avio_tell(s->pb) > header_size)
return AVERROR_INVALIDDATA;
avio_skip(s->pb, header_size - avio_tell(s->pb));
return 0;
} else if (!memcmp(buffer, "channel_count", 13)) {
sscanf(buffer, "%*s %*s %u", &st->codecpar->channels);
} else if (!memcmp(buffer, "sample_byte_format", 18)) {
sscanf(buffer, "%*s %*s %31s", format);
if (!av_strcasecmp(format, "01")) {
be = 0;
} else if (!av_strcasecmp(format, "10")) {
be = 1;
} else if (!av_strcasecmp(format, "mu-law")) {
st->codecpar->codec_id = AV_CODEC_ID_PCM_MULAW;
} else if (av_strcasecmp(format, "1")) {
avpriv_request_sample(s, "sample byte format %s", format);
return AVERROR_PATCHWELCOME;
}
} else if (!memcmp(buffer, "sample_coding", 13)) {
sscanf(buffer, "%*s %*s %31s", coding);
} else if (!memcmp(buffer, "sample_count", 12)) {
sscanf(buffer, "%*s %*s %"SCNd64, &st->duration);
} else if (!memcmp(buffer, "sample_n_bytes", 14)) {
sscanf(buffer, "%*s %*s %d", &bps);
} else if (!memcmp(buffer, "sample_rate", 11)) {
sscanf(buffer, "%*s %*s %d", &st->codecpar->sample_rate);
} else if (!memcmp(buffer, "sample_sig_bits", 15)) {
sscanf(buffer, "%*s %*s %d", &st->codecpar->bits_per_coded_sample);
} else {
char key[32], value[32];
if (sscanf(buffer, "%31s %*s %31s", key, value) == 2) {
av_dict_set(&s->metadata, key, value, AV_DICT_APPEND);
} else {
av_log(s, AV_LOG_ERROR, "Failed to parse '%s' as metadata\n", buffer);
}
}
}
return AVERROR_EOF;
}
/**
* 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;
}
static int sami_paragraph_to_ass(AVCodecContext *avctx, const char *src)
{
SAMIContext *sami = avctx->priv_data;
int ret = 0;
char *tag = NULL;
char *dupsrc = av_strdup(src);
char *p = dupsrc;
av_bprint_clear(&sami->content);
for (;;) {
char *saveptr = NULL;
int prev_chr_is_space = 0;
AVBPrint *dst = &sami->content;
/* parse & extract paragraph tag */
p = av_stristr(p, "<P");
if (!p)
break;
if (p[2] != '>' && !av_isspace(p[2])) { // avoid confusion with tags such as <PRE>
p++;
continue;
}
if (dst->len) // add a separator with the previous paragraph if there was one
av_bprintf(dst, "\\N");
tag = av_strtok(p, ">", &saveptr);
if (!tag || !saveptr)
break;
p = saveptr;
/* check if the current paragraph is the "source" (speaker name) */
if (av_stristr(tag, "ID=Source") || av_stristr(tag, "ID=\"Source\"")) {
dst = &sami->source;
av_bprint_clear(dst);
}
/* if empty event -> skip subtitle */
while (av_isspace(*p))
p++;
if (!strncmp(p, " ", 6)) {
ret = -1;
goto end;
}
/* extract the text, stripping most of the tags */
while (*p) {
if (*p == '<') {
if (!av_strncasecmp(p, "<P", 2) && (p[2] == '>' || av_isspace(p[2])))
break;
if (!av_strncasecmp(p, "<BR", 3))
av_bprintf(dst, "\\N");
p++;
while (*p && *p != '>')
p++;
if (!*p)
break;
if (*p == '>')
p++;
}
if (!av_isspace(*p))
av_bprint_chars(dst, *p, 1);
else if (!prev_chr_is_space)
av_bprint_chars(dst, ' ', 1);
prev_chr_is_space = av_isspace(*p);
p++;
}
}
av_bprint_clear(&sami->full);
if (sami->source.len)
av_bprintf(&sami->full, "{\\i1}%s{\\i0}\\N", sami->source.str);
av_bprintf(&sami->full, "%s", sami->content.str);
end:
av_free(dupsrc);
return ret;
}
int internel_decoder::get_attached_images(char* url,stream_context *streamcontext){
stream_context *sc = streamcontext;
AVInputFormat *format = sc->pFormatCtx->iformat;
if(strcmp(format->name,"mp3") == 0){
sc->is_mp3 = 1;
}
/// If attached image of mp3 is not detected by ffmpeg then we use taglib to extract the attached image
if(strcmp(format->name,"mp3") == 0 && sc->videostream == -1){
TagLib::MPEG::File mp3File(url);
Tag * mp3Tag;
FrameList listOfMp3Frames;
AttachedPictureFrame * pictureFrame;
AVPacket packet;
//av_init_packet(&packet);
mp3Tag= mp3File.ID3v2Tag();
if(mp3Tag)
{
listOfMp3Frames = mp3Tag->frameListMap()["APIC"];
if(!listOfMp3Frames.isEmpty())
{
FrameList::ConstIterator it= listOfMp3Frames.begin();
// for(; it != listOfMp3Frames.end() ; it++)
// {
pictureFrame = static_cast<AttachedPictureFrame *> (*it);
//cout <<"mime-type:"<<pictureFrame->mimeType()<<endl;
AVCodec *codec;
const char *mime_attached = pictureFrame->mimeType().toCString(false);
const CodecMime *mime = ff_id3v2_mime_tags;
while (mime->id != AV_CODEC_ID_NONE) {
if (!av_strncasecmp(mime->str, mime_attached, sizeof(mime_attached))) {
codec = avcodec_find_decoder(mime->id);
cout <<"mime-type:"<<mime->str<<endl;
break;
}
mime++;
}
if(mime->id != AV_CODEC_ID_NONE){
av_new_packet (&packet, pictureFrame->picture().size());
memcpy(packet.data,pictureFrame->picture().data(),pictureFrame->picture().size());
// packet.data = (uint8_t*)pictureFrame->picture().data();
packet.size = pictureFrame->picture().size();
packet.flags = AV_PKT_FLAG_KEY;
pthread_mutex_lock(&sc->videolock);
sc->videobuffer.push(packet);
pthread_mutex_unlock(&sc->videolock);
sc->videoctx = avcodec_alloc_context3(NULL);
avcodec_open2(sc->videoctx,codec, NULL);
sc->attachedimage = 1;
AVFrame *frame = avcodec_alloc_frame();
int decode_ok;
int len;
while(true){
len = avcodec_decode_video2(sc->videoctx, frame, &decode_ok, &packet);
if(decode_ok || len < 0){
break;
}
}
if(len < 0){
sc->videoctx->width = 0;
sc->videoctx->height = 0;
sc->height = 0;
sc->width = 0;
av_free(frame);
return -1;
}else{
cout <<frame->height<<" - "<<frame->width<<endl;
sc->videoctx->width = frame->width;
sc->videoctx->height = frame->height;
sc->height = frame->height;
sc->width = frame->width;
av_free(frame);
}
}else{
return -1;
}
//break;
// }
} else{
return -1;
}
} else {
return -1;
}
}
return 0;
}
static int jacosub_read_header(AVFormatContext *s)
{
AVBPrint header;
AVIOContext *pb = s->pb;
char line[JSS_MAX_LINESIZE];
JACOsubContext *jacosub = s->priv_data;
int shift_set = 0; // only the first shift matters
int merge_line = 0;
int i, ret;
AVStream *st = avformat_new_stream(s, NULL);
if (!st)
return AVERROR(ENOMEM);
avpriv_set_pts_info(st, 64, 1, 100);
st->codec->codec_type = AVMEDIA_TYPE_SUBTITLE;
st->codec->codec_id = AV_CODEC_ID_JACOSUB;
jacosub->timeres = 30;
av_bprint_init(&header, 1024+FF_INPUT_BUFFER_PADDING_SIZE, 4096);
while (!avio_feof(pb)) {
int cmd_len;
const char *p = line;
int64_t pos = avio_tell(pb);
int len = ff_get_line(pb, line, sizeof(line));
p = jss_skip_whitespace(p);
/* queue timed line */
if (merge_line || timed_line(p)) {
AVPacket *sub;
sub = ff_subtitles_queue_insert(&jacosub->q, line, len, merge_line);
if (!sub)
return AVERROR(ENOMEM);
sub->pos = pos;
merge_line = len > 1 && !strcmp(&line[len - 2], "\\\n");
continue;
}
/* skip all non-compiler commands and focus on the command */
if (*p != '#')
continue;
p++;
i = get_jss_cmd(p[0]);
if (i == -1)
continue;
/* trim command + spaces */
cmd_len = strlen(cmds[i]);
if (av_strncasecmp(p, cmds[i], cmd_len) == 0)
p += cmd_len;
else
p++;
p = jss_skip_whitespace(p);
/* handle commands which affect the whole script */
switch (cmds[i][0]) {
case 'S': // SHIFT command affect the whole script...
if (!shift_set) {
jacosub->shift = get_shift(jacosub->timeres, p);
shift_set = 1;
}
av_bprintf(&header, "#S %s", p);
break;
case 'T': // ...but must be placed after TIMERES
jacosub->timeres = strtol(p, NULL, 10);
if (!jacosub->timeres)
jacosub->timeres = 30;
else
av_bprintf(&header, "#T %s", p);
break;
}
}
/* general/essential directives in the extradata */
ret = avpriv_bprint_to_extradata(st->codec, &header);
if (ret < 0)
return ret;
/* SHIFT and TIMERES affect the whole script so packet timing can only be
* done in a second pass */
for (i = 0; i < jacosub->q.nb_subs; i++) {
AVPacket *sub = &jacosub->q.subs[i];
read_ts(jacosub, sub->data, &sub->pts, &sub->duration);
}
ff_subtitles_queue_finalize(&jacosub->q);
return 0;
}
static int process_line(URLContext *h, char *line, int line_count,
int *new_location)
{
HTTPContext *s = h->priv_data;
const char *auto_method = h->flags & AVIO_FLAG_READ ? "POST" : "GET";
char *tag, *p, *end, *method, *resource, *version;
int ret;
/* end of header */
if (line[0] == '\0') {
s->end_header = 1;
return 0;
}
p = line;
if (line_count == 0) {
if (s->listen) {
// HTTP method
method = p;
while (!av_isspace(*p))
p++;
*(p++) = '\0';
av_log(h, AV_LOG_TRACE, "Received method: %s\n", method);
if (s->method) {
if (av_strcasecmp(s->method, method)) {
av_log(h, AV_LOG_ERROR, "Received and expected HTTP method do not match. (%s expected, %s received)\n",
s->method, method);
return ff_http_averror(400, AVERROR(EIO));
}
} else {
// use autodetected HTTP method to expect
av_log(h, AV_LOG_TRACE, "Autodetected %s HTTP method\n", auto_method);
if (av_strcasecmp(auto_method, method)) {
av_log(h, AV_LOG_ERROR, "Received and autodetected HTTP method did not match "
"(%s autodetected %s received)\n", auto_method, method);
return ff_http_averror(400, AVERROR(EIO));
}
}
// HTTP resource
while (av_isspace(*p))
p++;
resource = p;
while (!av_isspace(*p))
p++;
*(p++) = '\0';
av_log(h, AV_LOG_TRACE, "Requested resource: %s\n", resource);
// HTTP version
while (av_isspace(*p))
p++;
version = p;
while (!av_isspace(*p))
p++;
*p = '\0';
if (av_strncasecmp(version, "HTTP/", 5)) {
av_log(h, AV_LOG_ERROR, "Malformed HTTP version string.\n");
return ff_http_averror(400, AVERROR(EIO));
}
av_log(h, AV_LOG_TRACE, "HTTP version string: %s\n", version);
} else {
while (!av_isspace(*p) && *p != '\0')
p++;
while (av_isspace(*p))
p++;
s->http_code = strtol(p, &end, 10);
av_log(h, AV_LOG_TRACE, "http_code=%d\n", s->http_code);
if ((ret = check_http_code(h, s->http_code, end)) < 0)
return ret;
}
} else {
while (*p != '\0' && *p != ':')
p++;
if (*p != ':')
return 1;
*p = '\0';
tag = line;
p++;
while (av_isspace(*p))
p++;
if (!av_strcasecmp(tag, "Location")) {
if ((ret = parse_location(s, p)) < 0)
return ret;
*new_location = 1;
} else if (!av_strcasecmp(tag, "Content-Length") && s->filesize == -1) {
s->filesize = strtoll(p, NULL, 10);
} else if (!av_strcasecmp(tag, "Content-Range")) {
parse_content_range(h, p);
} else if (!av_strcasecmp(tag, "Accept-Ranges") &&
!strncmp(p, "bytes", 5) &&
s->seekable == -1) {
h->is_streamed = 0;
} else if (!av_strcasecmp(tag, "Transfer-Encoding") &&
!av_strncasecmp(p, "chunked", 7)) {
s->filesize = -1;
s->chunksize = 0;
} else if (!av_strcasecmp(tag, "WWW-Authenticate")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Authentication-Info")) {
ff_http_auth_handle_header(&s->auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Proxy-Authenticate")) {
ff_http_auth_handle_header(&s->proxy_auth_state, tag, p);
} else if (!av_strcasecmp(tag, "Connection")) {
if (!strcmp(p, "close"))
s->willclose = 1;
} else if (!av_strcasecmp(tag, "Server")) {
if (!av_strcasecmp(p, "AkamaiGHost")) {
s->is_akamai = 1;
} else if (!av_strncasecmp(p, "MediaGateway", 12)) {
s->is_mediagateway = 1;
}
} else if (!av_strcasecmp(tag, "Content-Type")) {
av_free(s->mime_type);
s->mime_type = av_strdup(p);
} else if (!av_strcasecmp(tag, "Set-Cookie")) {
if (parse_cookie(s, p, &s->cookie_dict))
av_log(h, AV_LOG_WARNING, "Unable to parse '%s'\n", p);
} else if (!av_strcasecmp(tag, "Icy-MetaInt")) {
s->icy_metaint = strtoll(p, NULL, 10);
} else if (!av_strncasecmp(tag, "Icy-", 4)) {
if ((ret = parse_icy(s, tag, p)) < 0)
return ret;
} else if (!av_strcasecmp(tag, "Content-Encoding")) {
if ((ret = parse_content_encoding(h, p)) < 0)
return ret;
}
}
return 1;
}
