664 if (
avio_seek(pb, last_pos + 1, SEEK_SET) < 0)
713 int max_size, uint64_t *number)
726 "Read error at pos. %"PRIu64
" (0x%"PRIx64
")\n",
735 if (read > max_size) {
738 "Invalid EBML number size tag 0x%02x at pos %"PRIu64
" (0x%"PRIx64
")\n",
746 total = (total << 8) |
avio_r8(pb);
762 if (res > 0 && *number + 1 == 1ULL << (7 * res))
763 *number = 0xffffffffffffffULL;
781 *num = (*num << 8) |
avio_r8(pb);
804 *num = (*num << 8) |
avio_r8(pb);
921 *num = unum - ((1LL << (7 * res - 1)) - 1);
930 uint32_t
id,
void *
data)
933 for (i = 0; syntax[i].
id; i++)
934 if (
id == syntax[i].
id)
964 for (i = 0; syntax[i].
id; i++)
965 switch (syntax[i].
type) {
967 *(uint64_t *) ((
char *) data + syntax[i].
data_offset) = syntax[i].def.
u;
970 *(
double *) ((
char *) data + syntax[i].data_offset) = syntax[i].
def.
f;
975 if (syntax[i].def.
s) {
1040 uint32_t
id = syntax->
id;
1052 list->
elem = newelem;
1062 if (max_lengths[syntax->
type] && length > max_lengths[syntax->
type]) {
1064 "Invalid length 0x%"PRIx64
" > 0x%"PRIx64
" for syntax element %i\n",
1065 length, max_lengths[syntax->
type], syntax->
type);
1070 switch (syntax->
type) {
1121 for (i = 0; syntax[i].
id; i++) {
1122 void *data_off = (
char *) data + syntax[i].data_offset;
1123 switch (syntax[i].
type) {
1133 if (syntax[i].list_elem_size) {
1135 char *ptr = list->
elem;
1136 for (j = 0; j < list->
nb_elem;
1154 int len_mask = 0x80,
size = 1,
n = 1, i;
1162 while (
size <= 8 && !(total & len_mask)) {
1168 total &= (len_mask - 1);
1170 total = (total << 8) | p->
buf[4 +
n++];
1182 if (total < probelen)
1184 for (
n = 4 +
size;
n <= 4 +
size + total - probelen;
n++)
1200 if (tracks[i].num == num)
1212 int isize = *buf_size;
1215 int pkt_size = isize;
1219 if (pkt_size >= 10000000
U)
1222 switch (encodings[0].compression.algo) {
1228 if (header_size && !header) {
1236 pkt_size = isize + header_size;
1241 memcpy(pkt_data, header, header_size);
1242 memcpy(pkt_data + header_size, data, isize);
1248 olen = pkt_size *= 3;
1254 pkt_data = newpktdata;
1267 z_stream zstream = { 0 };
1268 if (inflateInit(&zstream) != Z_OK)
1270 zstream.next_in =
data;
1271 zstream.avail_in = isize;
1276 inflateEnd(&zstream);
1279 pkt_data = newpktdata;
1280 zstream.avail_out = pkt_size - zstream.total_out;
1281 zstream.next_out = pkt_data + zstream.total_out;
1283 result = inflate(&zstream, Z_NO_FLUSH);
1285 result = Z_MEM_ERROR;
1286 }
while (result == Z_OK && pkt_size < 10000000);
1287 pkt_size = zstream.total_out;
1288 inflateEnd(&zstream);
1289 if (result != Z_STREAM_END) {
1290 if (result == Z_MEM_ERROR)
1302 bz_stream bzstream = { 0 };
1303 if (BZ2_bzDecompressInit(&bzstream, 0, 0) != BZ_OK)
1305 bzstream.next_in =
data;
1306 bzstream.avail_in = isize;
1311 BZ2_bzDecompressEnd(&bzstream);
1314 pkt_data = newpktdata;
1315 bzstream.avail_out = pkt_size - bzstream.total_out_lo32;
1316 bzstream.next_out = pkt_data + bzstream.total_out_lo32;
1318 result = BZ2_bzDecompress(&bzstream);
1320 result = BZ_MEM_ERROR;
1321 }
while (result == BZ_OK && pkt_size < 10000000);
1322 pkt_size = bzstream.total_out_lo32;
1323 BZ2_bzDecompressEnd(&bzstream);
1324 if (result != BZ_STREAM_END) {
1325 if (result == BZ_MEM_ERROR)
1339 *buf_size = pkt_size;
1354 for (i = 0; i < list->
nb_elem; i++) {
1355 const char *lang = tags[i].
lang &&
1356 strcmp(tags[i].lang,
"und") ? tags[i].
lang :
NULL;
1358 if (!tags[i].
name) {
1363 snprintf(key,
sizeof(key),
"%s/%s", prefix, tags[i].name);
1366 if (tags[i].def || !lang) {
1368 if (tags[i].sub.nb_elem)
1375 if (tags[i].sub.nb_elem)
1389 if (tags[i].target.attachuid) {
1392 if (attachment[j].
uid == tags[i].target.attachuid &&
1395 &attachment[j].stream->metadata,
NULL);
1396 }
else if (tags[i].target.chapteruid) {
1399 if (chapter[j].
uid == tags[i].target.chapteruid &&
1402 &chapter[j].chapter->metadata,
NULL);
1403 }
else if (tags[i].target.trackuid) {
1406 if (track[j].
uid == tags[i].target.trackuid && track[j].
stream)
1408 &track[j].stream->metadata,
NULL);
1419 uint32_t level_up = matroska->
level_up;
1433 "Max EBML element depth (%d) reached, "
1438 level.
length = (uint64_t) -1;
1443 ret =
ebml_parse(matroska, matroska_segment, matroska);
1448 if (length == (uint64_t) -1)
1470 for (i = 0; i < seekhead_list->
nb_elem; i++) {
1472 uint32_t
id = seekheads[i].
id;
1473 uint64_t pos = seekheads[i].
pos;
1476 if (!elem || elem->
parsed)
1499 int index_scale = 1;
1505 index_list = &matroska->
index;
1506 index = index_list->
elem;
1512 for (i = 0; i < index_list->
nb_elem; i++) {
1515 for (j = 0; j < pos_list->
nb_elem; j++) {
1518 if (track && track->stream)
1521 index[i].
time / index_scale, 0, 0,
1548 static const char *
const aac_profiles[] = {
"MAIN",
"LC",
"SSR" };
1551 for (profile = 0; profile <
FF_ARRAY_ELEMS(aac_profiles); profile++)
1552 if (strstr(codec_id, aac_profiles[profile]))
1571 time_t creation_time = date_utc / 1000000000 + 978307200;
1572 struct tm tmpbuf, *ptm =
gmtime_r(&creation_time, &tmpbuf);
1574 if (strftime(buffer,
sizeof(buffer),
"%Y-%m-%d %H:%M:%S", ptm))
1575 av_dict_set(metadata,
"creation_time", buffer, 0);
1599 int block_last, block_type, block_size;
1605 if (block_size > size)
1614 chmask =
av_dict_get(dict,
"WAVEFORMATEXTENSIBLE_CHANNEL_MASK",
NULL, 0);
1617 if (!mask || mask & ~0x3ffffULL) {
1619 "Invalid value of WAVEFORMATEXTENSIBLE_CHANNEL_MASK\n");
1647 int extradata_size = 0;
1648 int extradata_offset = 0;
1649 uint32_t fourcc = 0;
1651 char* key_id_base64 =
NULL;
1660 "Unknown or unsupported track type %"PRIu64
"\n",
1680 if (encodings_list->
nb_elem > 1) {
1682 "Multiple combined encodings not supported");
1683 }
else if (encodings_list->
nb_elem == 1) {
1684 if (encodings[0].
type) {
1685 if (encodings[0].encryption.key_id.size > 0) {
1688 const int b64_size =
AV_BASE64_SIZE(encodings[0].encryption.key_id.size);
1690 if (key_id_base64 ==
NULL)
1694 encodings[0].encryption.key_id.data,
1697 encodings[0].
scope = 0;
1699 "Unsupported encoding type");
1712 encodings[0].
scope = 0;
1714 "Unsupported encoding type");
1724 "Failed to decode codec private data\n");
1746 if (key_id_base64) {
1752 if (!strcmp(track->
codec_id,
"V_MS/VFW/FOURCC") &&
1763 extradata_offset = 40;
1764 }
else if (!strcmp(track->
codec_id,
"A_MS/ACM") &&
1776 }
else if (!strcmp(track->
codec_id,
"A_QUICKTIME")
1785 }
else if (!strcmp(track->
codec_id,
"V_QUICKTIME") &&
1829 extradata[0] = (profile << 3) | ((sri & 0x0E) >> 1);
1830 extradata[1] = ((sri & 0x01) << 7) | (track->
audio.
channels << 3);
1831 if (strstr(track->
codec_id,
"SBR")) {
1833 extradata[2] = 0x56;
1834 extradata[3] = 0xE5;
1835 extradata[4] = 0x80 | (sri << 3);
1848 AV_WB32(extradata, extradata_size);
1849 memcpy(&extradata[4],
"alac", 4);
1854 extradata_size = 30;
1874 extradata_offset = 26;
1910 static const int sipr_bit_rate[4] = { 6504, 8496, 5000, 16000 };
1915 extradata_offset = 78;
1928 "Unknown/unsupported AVCodecID %s.\n", track->
codec_id);
1933 1000 * 1000 * 1000);
1942 if (strcmp(track->language,
"und"))
1946 if (track->flag_default)
1948 if (track->flag_forced)
1955 }
else if (track->codec_priv.data && track->codec_priv.size > 0) {
1959 track->codec_priv.data + extradata_offset,
1960 track->codec_priv.size);
1976 st->
codec->
width * track->video.display_height,
1981 if (track->default_duration) {
1983 1000000000, track->default_duration, 30000);
1984 #if FF_API_R_FRAME_RATE
1996 if (track->video.alpha_mode)
2000 for (j=0; j < track->operation.combine_planes.nb_elem; j++) {
2004 snprintf(buf,
sizeof(buf),
"%s_%d",
2007 if (planes[j].
uid == tracks[k].
uid) {
2009 "stereo_mode", buf, 0);
2015 track->video.stereo_mode != 10 && track->video.stereo_mode != 12) {
2028 if (track->codec_delay > 0) {
2033 if (track->seek_preroll > 0) {
2042 if (!strcmp(track->codec_id,
"D_WEBVTT/CAPTIONS")) {
2044 }
else if (!strcmp(track->codec_id,
"D_WEBVTT/DESCRIPTIONS")) {
2046 }
else if (!strcmp(track->codec_id,
"D_WEBVTT/METADATA")) {
2052 matroska->contains_ssa = 1;
2066 uint64_t max_start = 0;
2075 if (
ebml_parse(matroska, ebml_syntax, &ebml) ||
2077 ebml.
max_size >
sizeof(uint64_t) ||
2082 "EBML header using unsupported features\n"
2083 "(EBML version %"PRIu64
", doctype %s, doc version %"PRIu64
")\n",
2089 "EBML header using unsupported features\n"
2090 "(EBML version %"PRIu64
", doctype %s, doc version %"PRIu64
")\n",
2107 res =
ebml_parse(matroska, matroska_segments, matroska);
2114 res =
ebml_parse(matroska, matroska_segment, matroska);
2133 attachments = attachments_list->
elem;
2134 for (j = 0; j < attachments_list->
nb_elem; j++) {
2135 if (!(attachments[j].filename && attachments[j].mime &&
2136 attachments[j].bin.data && attachments[j].
bin.
size > 0)) {
2158 attachments[j].
stream = st;
2162 chapters = chapters_list->
elem;
2163 for (i = 0; i < chapters_list->
nb_elem; i++)
2165 (max_start == 0 || chapters[i].
start > max_start)) {
2169 chapters[i].
start, chapters[i].
end,
2171 if (chapters[i].chapter) {
2173 "title", chapters[i].
title, 0);
2175 max_start = chapters[i].
start;
2203 matroska->
packets = newpackets;
2233 int *buf_size,
int type,
2234 uint32_t **lace_buf,
int *laces)
2236 int res = 0,
n,
size = *buf_size;
2238 uint32_t *lace_size;
2246 *lace_buf[0] =
size;
2254 lace_size =
av_mallocz(*laces *
sizeof(
int));
2263 for (
n = 0; res == 0 &&
n < *laces - 1;
n++) {
2265 if (size <= total) {
2271 lace_size[
n] +=
temp;
2278 if (size <= total) {
2283 lace_size[
n] = size - total;
2288 if (size % (*laces)) {
2292 for (
n = 0;
n < *laces;
n++)
2293 lace_size[
n] = size / *laces;
2301 if (n < 0 || num > INT_MAX) {
2303 "EBML block data error\n");
2309 total = lace_size[0] = num;
2310 for (
n = 1; res == 0 &&
n < *laces - 1;
n++) {
2314 if (r < 0 || lace_size[
n - 1] + snum > (uint64_t)INT_MAX) {
2316 "EBML block data error\n");
2322 lace_size[
n] = lace_size[
n - 1] + snum;
2323 total += lace_size[
n];
2325 if (size <= total) {
2329 lace_size[*laces - 1] = size - total;
2335 *lace_buf = lace_size;
2358 if (size < cfs * h / 2) {
2360 "Corrupt int4 RM-style audio packet size\n");
2363 for (x = 0; x < h / 2; x++)
2364 memcpy(track->
audio.
buf + x * 2 * w + y * cfs,
2365 data + x * cfs, cfs);
2369 "Corrupt sipr RM-style audio packet size\n");
2372 memcpy(track->
audio.
buf + y * w, data, w);
2374 if (size < sps * w / sps || h<=0 || w%sps) {
2376 "Corrupt generic RM-style audio packet size\n");
2379 for (x = 0; x < w / sps; x++)
2381 sps * (h * x + ((h + 1) / 2) * (y & 1) + (y >> 1)),
2382 data + x * sps, sps);
2428 if (srclen < 12 || track->stream->codec->extradata_size < 2)
2437 while (srclen >= 8) {
2443 uint32_t crc =
AV_RL32(src + 4);
2447 multiblock = (flags & 0x1800) != 0x1800;
2459 if (blocksize > srclen) {
2464 tmp =
av_realloc(dst, dstlen + blocksize + 32);
2470 dstlen += blocksize + 32;
2473 AV_WL32(dst + offset + 4, blocksize + 24);
2474 AV_WL16(dst + offset + 8, ver);
2475 AV_WL16(dst + offset + 10, 0);
2476 AV_WL32(dst + offset + 12, 0);
2477 AV_WL32(dst + offset + 16, 0);
2478 AV_WL32(dst + offset + 20, samples);
2479 AV_WL32(dst + offset + 24, flags);
2480 AV_WL32(dst + offset + 28, crc);
2481 memcpy(dst + offset + 32, src, blocksize);
2484 srclen -= blocksize;
2485 offset += blocksize + 32;
2508 int id_len, settings_len, text_len;
2516 q = data + data_len;
2521 if (*p ==
'\r' || *p ==
'\n') {
2530 if (p >= q || *p !=
'\n')
2537 if (*p ==
'\r' || *p ==
'\n') {
2538 settings_len = p - settings;
2546 if (p >= q || *p !=
'\n')
2552 while (text_len > 0) {
2553 const int len = text_len - 1;
2555 if (c !=
'\r' && c !=
'\n')
2572 memcpy(pkt->
data, text, text_len);
2582 memcpy(buf,
id, id_len);
2585 if (settings_len > 0) {
2593 memcpy(buf, settings, settings_len);
2600 pkt->
pts = timecode;
2617 uint64_t timecode, uint64_t lace_duration,
2619 uint8_t *additional, uint64_t additional_id,
int additional_size,
2620 int64_t discard_padding)
2627 if (encodings && !encodings->
type && encodings->
scope & 1) {
2638 "Error parsing a wavpack block.\n");
2641 if (pkt_data != data)
2662 bytestream_put_be32(&buf, pkt_size);
2663 bytestream_put_be32(&buf,
MKBETAG(
'i',
'c',
'p',
'f'));
2666 memcpy(pkt->
data + offset, pkt_data, pkt_size);
2668 if (pkt_data != data)
2674 if (additional_size > 0) {
2677 additional_size + 8);
2683 AV_WB64(side_data, additional_id);
2684 memcpy(side_data + 8, additional, additional_size);
2687 if (discard_padding) {
2703 pkt->
dts = timecode;
2705 pkt->
pts = timecode;
2720 lace_duration <= INT_MAX) {
2737 if (pkt_data != data)
2743 int size, int64_t pos, uint64_t cluster_time,
2745 uint8_t *additional, uint64_t additional_id,
int additional_size,
2746 int64_t cluster_pos, int64_t discard_padding)
2753 uint32_t *lace_size =
NULL;
2756 int trust_default_duration = 1;
2766 if (!track || !track->
stream) {
2768 "Invalid stream %"PRIu64
" or size %u\n", num, size);
2770 }
else if (size <= 3)
2781 if (is_keyframe == -1)
2784 if (cluster_time != (uint64_t) -1 &&
2785 (block_time >= 0 || cluster_time >= -block_time)) {
2786 timecode = cluster_time + block_time - track->
codec_delay;
2788 timecode < track->end_timecode)
2797 if (timecode < matroska->skip_to_timecode)
2808 &lace_size, &laces);
2817 trust_default_duration = 0;
2821 if (!block_duration && trust_default_duration)
2824 if (cluster_time != (uint64_t)-1 && (block_time >= 0 || cluster_time >= -block_time))
2828 for (n = 0; n < laces; n++) {
2829 int64_t lace_duration = block_duration*(n+1) / laces - block_duration*n / laces;
2831 if (lace_size[n] > size) {
2850 timecode, lace_duration,
2856 timecode, lace_duration, pos,
2857 !n ? is_keyframe : 0,
2858 additional, additional_id, additional_size,
2865 timecode = lace_duration ? timecode + lace_duration :
AV_NOPTS_VALUE;
2866 data += lace_size[
n];
2867 size -= lace_size[
n];
2881 matroska_cluster_incremental_parsing,
2896 matroska_clusters_incremental,
2901 matroska_cluster_incremental_parsing,
2909 blocks = blocks_list->
elem;
2913 if (blocks[i].bin.size > 0 && blocks[i].
bin.
data) {
2917 if (!blocks[i].non_simple)
2947 res =
ebml_parse(matroska, matroska_clusters, &cluster);
2948 blocks_list = &cluster.
blocks;
2949 blocks = blocks_list->
elem;
2950 for (i = 0; i < blocks_list->
nb_elem; i++)
2951 if (blocks[i].bin.size > 0 && blocks[i].
bin.
data) {
2956 is_keyframe,
NULL, 0, 0, pos,
2979 int64_t timestamp,
int flags)
2984 int i,
index, index_sub, index_min;
3023 while (index_sub >= 0 &&
3025 tracks[i].stream->index_entries[index_sub].pos < st->
index_entries[index_min].
pos &&
3092 for (i = 1; i < nb_index_entries; i++) {
3093 if (index_entries[i - 1].timestamp * matroska->
time_scale <= ts &&
3101 if (i != nb_index_entries - 1) {
3117 int64_t cluster_pos, before_pos;
3122 if (index < 0)
return 0;
3126 int64_t cluster_id = 0, cluster_length = 0;
3132 if (cluster_id != 0xF43B675) {
3143 cluster_pos += cluster_length + 12;
3154 double min_buffer,
double*
buffer,
3158 double nano_seconds_per_second = 1000000000.0;
3159 double time_sec = time_ns / nano_seconds_per_second;
3161 int64_t time_to_search_ns = (int64_t)(search_sec * nano_seconds_per_second);
3162 int64_t end_time_ns = time_ns + time_to_search_ns;
3163 double sec_downloaded = 0.0;
3167 *sec_to_download = 0.0;
3171 int64_t cue_nano = desc_curr.
end_time_ns - time_ns;
3174 double timeToDownload = (cueBytes * 8.0) /
bps;
3176 sec_downloaded += (cue_nano / nano_seconds_per_second) - timeToDownload;
3177 *sec_to_download += timeToDownload;
3181 double desc_end_time_sec = desc_curr.
end_time_ns / nano_seconds_per_second;
3182 double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
3183 sec_downloaded = percent_to_sub * sec_downloaded;
3184 *sec_to_download = percent_to_sub * *sec_to_download;
3187 if ((sec_downloaded + *buffer) <= min_buffer) {
3198 double desc_sec = desc_ns / nano_seconds_per_second;
3199 double bits = (desc_bytes * 8.0);
3200 double time_to_download = bits /
bps;
3202 sec_downloaded += desc_sec - time_to_download;
3203 *sec_to_download += time_to_download;
3206 double desc_end_time_sec = desc_curr.
end_time_ns / nano_seconds_per_second;
3207 double percent_to_sub = search_sec / (desc_end_time_sec - time_sec);
3208 sec_downloaded = percent_to_sub * sec_downloaded;
3209 *sec_to_download = percent_to_sub * *sec_to_download;
3211 if ((sec_downloaded + *buffer) <= min_buffer)
3216 if ((sec_downloaded + *buffer) <= min_buffer) {
3223 *buffer = *buffer + sec_downloaded;
3238 double bandwidth = 0.0;
3242 int64_t prebuffer_ns = 1000000000;
3244 double nano_seconds_per_second = 1000000000.0;
3245 int64_t prebuffered_ns = time_ns + prebuffer_ns;
3246 double prebuffer_bytes = 0.0;
3247 int64_t temp_prebuffer_ns = prebuffer_ns;
3248 int64_t pre_bytes, pre_ns;
3249 double pre_sec, prebuffer, bits_per_second;
3267 bits_per_second = 0.0;
3273 pre_sec = pre_ns / nano_seconds_per_second;
3275 pre_bytes * ((temp_prebuffer_ns / nano_seconds_per_second) / pre_sec);
3277 prebuffer = prebuffer_ns / nano_seconds_per_second;
3280 bits_per_second = 0.0;
3284 double desc_sec = desc_ns / nano_seconds_per_second;
3285 double calc_bits_per_second = (desc_bytes * 8) / desc_sec;
3288 double percent = (desc_bytes - prebuffer_bytes) / desc_bytes;
3289 double mod_bits_per_second = calc_bits_per_second * percent;
3291 if (prebuffer < desc_sec) {
3297 int64_t
bps = (int64_t)(mod_bits_per_second) + 1;
3298 const double min_buffer = 0.0;
3299 double buffer = prebuffer;
3300 double sec_to_download = 0.0;
3303 min_buffer, &buffer, &sec_to_download,
3307 }
else if (rv == 0) {
3308 bits_per_second = (double)(bps);
3316 if (bandwidth < bits_per_second) bandwidth = bits_per_second;
3318 return (int64_t)bandwidth;
3327 int64_t cues_start = -1, cues_end = -1, before_pos, bandwidth;
3331 for (i = 0; i < seekhead_list->
nb_elem; i++)
3335 if (i >= seekhead_list->
nb_elem)
return -1;
3339 if (
avio_seek(matroska->
ctx->
pb, cues_start, SEEK_SET) == cues_start) {
3343 uint64_t cues_length = 0, cues_id = 0, bytes_read = 0;
3346 cues_end = cues_start + cues_length + bytes_read - 1;
3349 if (cues_start == -1 || cues_end == -1)
return -1;
3362 if (bandwidth < 0)
return -1;
3371 if (!buf)
return -1;
3374 snprintf(buf, (i + 1) * 20 *
sizeof(
char),
3377 strncat(buf,
",",
sizeof(
char));
3406 if (!buf)
return AVERROR(ENOMEM);
3424 .
name =
"matroska,webm",
3426 .extensions =
"mkv,mk3d,mka,mks",
3433 .mime_type =
"audio/webm,audio/x-matroska,video/webm,video/x-matroska"
3437 .
name =
"webm_dash_manifest",