static void read_subtitles(agi::ProgressSink *ps, MatroskaFile *file, MkvStdIO *input, bool srt, double totalTime, AssParser *parser) {
std::vector<std::pair<int, std::string>> subList;
// Load blocks
uint64_t startTime, endTime, filePos;
unsigned int rt, frameSize, frameFlags;
while (mkv_ReadFrame(file, 0, &rt, &startTime, &endTime, &filePos, &frameSize, &frameFlags) == 0) {
if (ps->IsCancelled()) return;
if (frameSize == 0) continue;
const auto readBuf = input->file.read(filePos, frameSize);
const auto readBufEnd = readBuf + frameSize;
// Get start and end times
int64_t timecodeScaleLow = 1000000;
agi::Time subStart = startTime / timecodeScaleLow;
agi::Time subEnd = endTime / timecodeScaleLow;
using str_range = boost::iterator_range<const char *>;
// Process SSA/ASS
if (!srt) {
auto first = std::find(readBuf, readBufEnd, ',');
if (first == readBufEnd) continue;
auto second = std::find(first + 1, readBufEnd, ',');
if (second == readBufEnd) continue;
subList.emplace_back(
boost::lexical_cast<int>(str_range(readBuf, first)),
agi::format("Dialogue: %d,%s,%s,%s"
, boost::lexical_cast<int>(str_range(first + 1, second))
, subStart.GetAssFormatted()
, subEnd.GetAssFormatted()
, str_range(second + 1, readBufEnd)));
}
// Process SRT
else {
auto line = agi::format("Dialogue: 0,%s,%s,Default,,0,0,0,,%s"
, subStart.GetAssFormatted()
, subEnd.GetAssFormatted()
, str_range(readBuf, readBufEnd));
boost::replace_all(line, "\r\n", "\\N");
boost::replace_all(line, "\r", "\\N");
boost::replace_all(line, "\n", "\\N");
subList.emplace_back(subList.size(), std::move(line));
}
ps->SetProgress(startTime / timecodeScaleLow, totalTime);
}
// Insert into file
sort(begin(subList), end(subList));
for (auto order_value_pair : subList)
parser->AddLine(order_value_pair.second);
}
void mp_perfdata_float2(const char *label, float value, const char *unit,
thresholds *threshold, int have_min, float min,
int have_max, float max) {
char *buf;
int precision = 3;
mp_perfdata_percent_resolv(threshold, have_max?max:0);
if (!mp_showperfdata)
return;
if (value >= 9999)
precision = 0;
else if (value == 0)
precision = 0;
if (strpbrk (label, "'= +")) {
mp_asprintf(&buf, "'%s'=%.*f%s;", label, precision, value, unit);
} else {
mp_asprintf(&buf, "%s=%.*f%s;", label, precision, value, unit);
}
mp_strcat_space(&mp_perfdata, buf);
free(buf);
if (threshold && threshold->warning) {
buf = str_range(threshold->warning);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if (threshold && threshold->critical) {
buf = str_range(threshold->critical);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if(have_min) {
mp_asprintf(&buf, "%.*f", precision, min);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if(have_max) {
mp_asprintf(&buf, "%.*f;", precision, max);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
for( buf = mp_perfdata + strlen(mp_perfdata) - 1; *(buf-1) == ';'; buf--) {
*buf = '\0';
}
}
void mp_perfdata_int2(const char *label, long int value, const char *unit,
thresholds *threshold, int have_min, long int min,
int have_max, long int max) {
char *buf;
mp_perfdata_percent_resolv(threshold, have_max?max:0);
if (!mp_showperfdata)
return;
if (strpbrk (label, "'= +")) {
mp_asprintf(&buf, "'%s'=%ld%s;", label, value, unit);
} else {
mp_asprintf(&buf, "%s=%ld%s;", label, value, unit);
}
mp_strcat_space(&mp_perfdata, buf);
free(buf);
if (threshold && threshold->warning) {
buf = str_range(threshold->warning);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if (threshold && threshold->critical) {
buf = str_range(threshold->critical);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if(have_min) {
mp_asprintf(&buf, "%ld", min);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
mp_strcat(&mp_perfdata, ";");
if(have_max) {
mp_asprintf(&buf, "%ld;", max);
mp_strcat(&mp_perfdata, buf);
free(buf);
}
for( buf = mp_perfdata + strlen(mp_perfdata) - 1; *(buf-1) == ';'; buf--) {
*buf = '\0';
}
}
/*
* NAME: optimize->expr()
* DESCRIPTION: optimize an expression
*/
static Uint opt_expr(node **m, bool pop)
{
Uint d1, d2, i;
node *n;
node **oldside, *side;
Uint olddepth;
n = *m;
switch (n->type) {
case N_FLOAT:
case N_GLOBAL:
case N_INT:
case N_LOCAL:
case N_STR:
case N_NIL:
return !pop;
case N_TOINT:
case N_CAST:
return opt_expr(&n->l.left, FALSE);
case N_NEG:
case N_UMIN:
return max2(opt_expr(&n->l.left, FALSE), 2);
case N_CATCH:
oldside = side_start(&side, &olddepth);
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
n->l.left = (node *) NULL;
}
d1 = max2(d1, side_end(&n->l.left, side, oldside, olddepth));
if (d1 == 0) {
*m = node_nil();
(*m)->line = n->line;
return !pop;
}
return d1;
case N_TOFLOAT:
if (n->l.left->mod != T_INT) {
return opt_expr(&n->l.left, FALSE);
}
/* fall through */
case N_NOT:
case N_TST:
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
return opt_expr(&n->l.left, FALSE);
case N_TOSTRING:
if (pop && (n->l.left->mod == T_INT || n->l.left->mod == T_FLOAT)) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
return opt_expr(&n->l.left, FALSE);
case N_LVALUE:
return opt_lvalue(n->l.left);
case N_ADD_EQ_1:
case N_ADD_EQ_1_INT:
case N_ADD_EQ_1_FLOAT:
case N_SUB_EQ_1:
case N_SUB_EQ_1_INT:
case N_SUB_EQ_1_FLOAT:
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN:
if (pop) {
n->type = N_SUB_EQ_1;
}
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN_INT:
if (pop) {
n->type = N_SUB_EQ_1_INT;
}
return opt_lvalue(n->l.left) + 1;
case N_MIN_MIN_FLOAT:
if (pop) {
n->type = N_SUB_EQ_1_FLOAT;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS:
if (pop) {
n->type = N_ADD_EQ_1;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS_INT:
if (pop) {
n->type = N_ADD_EQ_1_INT;
}
return opt_lvalue(n->l.left) + 1;
case N_PLUS_PLUS_FLOAT:
if (pop) {
n->type = N_ADD_EQ_1_FLOAT;
}
return opt_lvalue(n->l.left) + 1;
case N_FUNC:
m = &n->l.left->r.right;
n = *m;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; ) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
m = &n->r.right;
n = n->l.left;
i += (n->type == N_LVALUE ||
(n->type == N_COMMA && n->r.right->type == N_LVALUE)) ? 6 : 1;
n = *m;
}
if (n->type == N_SPREAD) {
m = &n->l.left;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(m, FALSE);
d1 = max3(d1, i + d2, i + side_end(m, side, oldside, olddepth));
n = *m;
if (n->type == N_LVALUE ||
(n->type == N_COMMA && n->r.right->type == N_LVALUE)) {
d1 += 2;
}
return d1;
case N_INSTANCEOF:
return opt_expr(&n->l.left, FALSE) + 1;
case N_GE:
case N_GT:
case N_LE:
case N_LT:
if (n->l.left->mod != n->r.right->mod) {
return max2(opt_expr(&n->l.left, FALSE),
opt_expr(&n->r.right, FALSE) + 1);
}
/* fall through */
case N_EQ:
case N_NE:
if (pop) {
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
*m = n->r.right;
return opt_expr(m, TRUE);
}
d2 = opt_expr(&n->r.right, TRUE);
if (d2 == 0) {
*m = n->l.left;
return d1;
}
n->type = N_COMMA;
side_add(m, d1);
return d2;
}
return opt_binop(m);
case N_DIV_INT:
case N_MOD_INT:
if (n->r.right->type == N_INT && n->r.right->l.number == 0) {
d1 = opt_binop(m);
return (d1 == 1) ? !pop : d1;
}
/* fall through */
case N_ADD_INT:
case N_ADD_FLOAT:
case N_AND_INT:
case N_DIV_FLOAT:
case N_EQ_INT:
case N_EQ_FLOAT:
case N_GE_INT:
case N_GE_FLOAT:
case N_GT_INT:
case N_GT_FLOAT:
case N_LE_INT:
case N_LE_FLOAT:
case N_LSHIFT_INT:
case N_LT_INT:
case N_LT_FLOAT:
case N_MULT_INT:
case N_MULT_FLOAT:
case N_NE_INT:
case N_NE_FLOAT:
case N_OR_INT:
case N_RSHIFT_INT:
case N_SUB_INT:
case N_SUB_FLOAT:
case N_XOR_INT:
if (pop) {
d1 = opt_expr(&n->l.left, TRUE);
if (d1 == 0) {
*m = n->r.right;
return opt_expr(m, TRUE);
}
d2 = opt_expr(&n->r.right, TRUE);
if (d2 == 0) {
*m = n->l.left;
return d1;
}
n->type = N_COMMA;
side_add(m, d1);
return d2;
}
/* fall through */
case N_ADD:
case N_AND:
case N_DIV:
case N_LSHIFT:
case N_MOD:
case N_MULT:
case N_OR:
case N_RSHIFT:
case N_SUB:
case N_SUM:
case N_XOR:
d1 = opt_binop(m);
return (d1 == 1) ? !pop : d1;
case N_INDEX:
if (n->l.left->type == N_STR && n->r.right->type == N_INT) {
if (n->r.right->l.number < 0 ||
n->r.right->l.number >= (long) n->l.left->l.string->len) {
return 2;
}
node_toint(n, (Int) str_index(n->l.left->l.string,
(long) n->r.right->l.number));
return !pop;
}
if (n->l.left->type == N_FUNC && n->r.right->mod == T_INT) {
if (n->l.left->r.number == kd_status) {
n->type = N_FUNC;
if (n->l.left->l.left->r.right != (node *) NULL) {
/* status(obj)[i] */
n = n->l.left;
n->type = N_STR;
n->r.right = n->l.left;
n->l.string = n->l.left->l.string;
n = n->r.right;
n->type = N_PAIR;
n->l.left = n->r.right;
n->r.right = (*m)->r.right;
(*m)->r.number = ((long) KFCALL << 24) | KF_STATUSO_IDX;
} else {
/* status()[i] */
n->l.left = n->l.left->l.left;
n->l.left->r.right = n->r.right;
n->r.number = ((long) KFCALL << 24) | KF_STATUS_IDX;
}
return opt_expr(m, pop);
}
if (n->l.left->r.number == kd_call_trace) {
/* call_trace()[i] */
n->type = N_FUNC;
n->l.left = n->l.left->l.left;
n->l.left->r.right = n->r.right;
n->r.number = ((long) KFCALL << 24) | KF_CALLTR_IDX;
return opt_expr(m, pop);
}
}
return max3(opt_expr(&n->l.left, FALSE),
opt_expr(&n->r.right, FALSE) + 1, 3);
case N_ADD_EQ:
case N_ADD_EQ_INT:
case N_ADD_EQ_FLOAT:
case N_AND_EQ:
case N_AND_EQ_INT:
case N_DIV_EQ:
case N_DIV_EQ_INT:
case N_DIV_EQ_FLOAT:
case N_LSHIFT_EQ:
case N_LSHIFT_EQ_INT:
case N_MOD_EQ:
case N_MOD_EQ_INT:
case N_MULT_EQ:
case N_MULT_EQ_INT:
case N_MULT_EQ_FLOAT:
case N_OR_EQ:
case N_OR_EQ_INT:
case N_RSHIFT_EQ:
case N_RSHIFT_EQ_INT:
case N_SUB_EQ:
case N_SUB_EQ_INT:
case N_SUB_EQ_FLOAT:
case N_SUM_EQ:
case N_XOR_EQ:
case N_XOR_EQ_INT:
return opt_asgnexp(m, pop);
case N_ASSIGN:
if (n->l.left->type == N_AGGR) {
d2 = 0;
for (n = n->l.left->l.left; n->type == N_PAIR; n = n->r.right) {
d1 = opt_lvalue(n->l.left);
d2 += 2 + ((d1 < 4) ? d1 : 4);
}
d1 = opt_lvalue(n);
d2 += 2 + ((d1 < 4) ? d1 : 4);
return d2 + max2(2, opt_expr(&(*m)->r.right, FALSE));
} else {
d1 = opt_lvalue(n->l.left);
return max2(d1, ((d1 < 4) ? d1 : 4) + opt_expr(&n->r.right, FALSE));
}
case N_COMMA:
side_add(m, opt_expr(&n->l.left, TRUE));
return opt_expr(m, pop);
case N_LAND:
d1 = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (!opt_ctest(n->l.left)) {
/* false && x */
*m = n->l.left;
return !pop;
}
/* true && x */
n->type = N_TST;
n->l.left = n->r.right;
return opt_expr(m, pop);
}
oldside = side_start(&side, &olddepth);
d2 = opt_cond(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (n->r.right->flags & F_CONST) {
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (!opt_ctest(n->r.right)) {
/* x && false */
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* x && true */
n->type = N_TST;
return d1;
}
if (n->r.right->type == N_COMMA) {
n = n->r.right;
if ((n->r.right->flags & F_CONST) && !opt_ctest(n->r.right)) {
/* x && (y, false) --> (x && y, false) */
(*m)->r.right = n->l.left;
n->l.left = *m;
*m = n;
return opt_expr(m, pop);
}
}
return max2(d1, d2);
case N_LOR:
d1 = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (opt_ctest(n->l.left)) {
/* true || x */
*m = n->l.left;
return !pop;
}
/* false || x */
n->type = N_TST;
n->l.left = n->r.right;
return opt_expr(m, pop);
}
oldside = side_start(&side, &olddepth);
d2 = opt_cond(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (n->r.right->flags & F_CONST) {
if (pop) {
*m = n->l.left;
return opt_expr(m, TRUE);
}
if (opt_ctest(n->r.right)) {
/* x || true */
n->type = N_COMMA;
return opt_expr(m, FALSE);
}
/* x || false */
n->type = N_TST;
return d1;
}
if (n->r.right->type == N_COMMA) {
n = n->r.right;
if ((n->r.right->flags & F_CONST) && opt_ctest(n->r.right)) {
/* x || (y, true) --> (x || y, true) */
(*m)->r.right = n->l.left;
n->l.left = *m;
*m = n;
return opt_expr(m, pop);
}
}
return max2(d1, d2);
case N_QUEST:
i = opt_cond(&n->l.left, FALSE);
if (n->l.left->flags & F_CONST) {
if (opt_ctest(n->l.left)) {
*m = n->r.right->l.left;
} else {
*m = n->r.right->r.right;
}
return opt_expr(m, pop);
}
if (n->l.left->type == N_COMMA && (n->l.left->r.right->flags & F_CONST))
{
side_add(&n->l.left, i);
if (opt_ctest(n->l.left)) {
*m = n->r.right->l.left;
} else {
*m = n->r.right->r.right;
}
return opt_expr(m, pop);
}
n = n->r.right;
oldside = side_start(&side, &olddepth);
d1 = opt_expr(&n->l.left, pop);
if (d1 == 0) {
n->l.left = (node *) NULL;
}
d1 = max2(d1, side_end(&n->l.left, side, oldside, olddepth));
if (d1 == 0) {
n->l.left = (node *) NULL;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->r.right, pop);
if (d2 == 0) {
n->r.right = (node *) NULL;
}
d2 = max2(d2, side_end(&n->r.right, side, oldside, olddepth));
if (d2 == 0) {
n->r.right = (node *) NULL;
}
return max3(i, d1, d2);
case N_RANGE:
d1 = opt_expr(&n->l.left, FALSE);
d2 = 1;
if (n->r.right->l.left != (node *) NULL) {
d2 = opt_expr(&n->r.right->l.left, FALSE);
if ((n->l.left->mod == T_STRING || (n->l.left->mod & T_REF) != 0) &&
n->r.right->l.left->type == N_INT &&
n->r.right->l.left->l.number == 0) {
/*
* str[0 .. x] or arr[0 .. x]
*/
n->r.right->l.left = (node *) NULL;
d2 = 1;
} else {
d1 = max2(d1, d2 + 1);
d2 = 2;
}
}
if (n->r.right->r.right != (node *) NULL) {
d1 = max2(d1, d2 + opt_expr(&n->r.right->r.right, FALSE));
}
if (n->l.left->type == N_STR) {
long from, to;
if (n->r.right->l.left == (node *) NULL) {
from = 0;
} else {
if (n->r.right->l.left->type != N_INT) {
return d1;
}
from = n->r.right->l.left->l.number;
}
if (n->r.right->r.right == (node *) NULL) {
to = n->l.left->l.string->len - 1;
} else {
if (n->r.right->r.right->type != N_INT) {
return d1;
}
to = n->r.right->r.right->l.number;
}
if (from >= 0 && from <= to + 1 &&
to < (long) n->l.left->l.string->len) {
node_tostr(n, str_range(n->l.left->l.string, from, to));
return !pop;
}
return d1;
}
return max2(d1, 3);
case N_AGGR:
if (n->mod == T_MAPPING) {
n = n->l.left;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; i += 2) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left->l.left, FALSE);
d1 = max3(d1, i + d2, i + side_end(&n->l.left->l.left,
side, oldside, olddepth));
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left->r.right, FALSE);
d1 = max3(d1, i + 1 + d2,
i + 1 + side_end(&n->l.left->r.right, side, oldside,
olddepth));
n = n->r.right;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->r.right, FALSE);
return max3(d1, i + 1 + d2,
i + 1 + side_end(&n->r.right, side, oldside, olddepth));
} else {
m = &n->l.left;
n = *m;
if (n == (node *) NULL) {
return 1;
}
d1 = 0;
for (i = 0; n->type == N_PAIR; i++) {
oldside = side_start(&side, &olddepth);
d2 = opt_expr(&n->l.left, FALSE);
d1 = max3(d1, i + d2,
i + side_end(&n->l.left, side, oldside, olddepth));
m = &n->r.right;
n = *m;
}
oldside = side_start(&side, &olddepth);
d2 = opt_expr(m, FALSE);
return max3(d1, i + d2, i + side_end(m, side, oldside, olddepth));
}
}
# ifdef DEBUG
fatal("unknown expression type %d", n->type);
# endif
return 0;
}
