int ff_ass_add_rect(AVSubtitle *sub, const char *dialog,
int ts_start, int duration, int raw)
{
int len = 0, dlen;
char s_start[16], s_end[16], header[48] = {0};
AVSubtitleRect **rects;
if (!raw) {
ts_to_string(s_start, sizeof(s_start), ts_start);
if (duration == -1)
snprintf(s_end, sizeof(s_end), "9:59:59.99");
else
ts_to_string(s_end, sizeof(s_end), ts_start + duration);
len = snprintf(header, sizeof(header), "Dialogue: 0,%s,%s,Default,",
s_start, s_end);
}
dlen = strcspn(dialog, "\n");
dlen += dialog[dlen] == '\n';
rects = av_realloc(sub->rects, (sub->num_rects+1) * sizeof(*sub->rects));
if (!rects)
return AVERROR(ENOMEM);
sub->rects = rects;
sub->end_display_time = FFMAX(sub->end_display_time, 10 * duration);
rects[sub->num_rects] = av_mallocz(sizeof(*rects[0]));
rects[sub->num_rects]->type = SUBTITLE_ASS;
rects[sub->num_rects]->ass = av_malloc(len + dlen + 1);
strcpy (rects[sub->num_rects]->ass , header);
av_strlcpy(rects[sub->num_rects]->ass + len, dialog, dlen + 1);
sub->num_rects++;
return dlen;
}
uint8_t* sinsp_filter_check_event::extract(sinsp_evt *evt, OUT uint32_t* len)
{
switch(m_field_id)
{
case TYPE_TIME:
ts_to_string(evt->get_ts(), &m_strstorage, false, true);
return (uint8_t*)m_strstorage.c_str();
case TYPE_TIME_S:
ts_to_string(evt->get_ts(), &m_strstorage, false, false);
return (uint8_t*)m_strstorage.c_str();
case TYPE_DATETIME:
ts_to_string(evt->get_ts(), &m_strstorage, true, true);
return (uint8_t*)m_strstorage.c_str();
case TYPE_RAWTS:
return (uint8_t*)&evt->m_pevt->ts;
case TYPE_RAWTS_S:
m_u64val = evt->get_ts() / ONE_SECOND_IN_NS;
return (uint8_t*)&m_u64val;
case TYPE_RAWTS_NS:
m_u64val = evt->get_ts() % ONE_SECOND_IN_NS;
return (uint8_t*)&m_u64val;
case TYPE_RELTS:
if(m_first_ts == 0)
{
m_first_ts = evt->get_ts();
}
m_u64val = evt->get_ts() - m_first_ts;
return (uint8_t*)&m_u64val;
case TYPE_RELTS_S:
if(m_first_ts == 0)
{
m_first_ts = evt->get_ts();
}
m_u64val = (evt->get_ts() - m_first_ts) / ONE_SECOND_IN_NS;
return (uint8_t*)&m_u64val;
case TYPE_RELTS_NS:
if(m_first_ts == 0)
{
m_first_ts = evt->get_ts();
}
m_u64val = (evt->get_ts() - m_first_ts) % ONE_SECOND_IN_NS;
return (uint8_t*)&m_u64val;
case TYPE_LATENCY:
{
m_u64val = 0;
if(evt->get_direction() == SCAP_ED_IN)
{
if(evt->m_tinfo != NULL)
{
uint16_t* pt = (uint16_t*)evt->m_tinfo->get_private_state(m_th_state_id);
*pt = evt->get_type();
}
return (uint8_t*)&m_u64val;
}
if(evt->m_tinfo != NULL)
{
uint16_t* pt = (uint16_t*)evt->m_tinfo->get_private_state(m_th_state_id);
if(evt->m_tinfo->m_prevevent_ts && evt->get_type() == *pt + 1)
{
m_u64val = (evt->get_ts() - evt->m_tinfo->m_prevevent_ts);
}
}
return (uint8_t*)&m_u64val;
}
case TYPE_LATENCY_S:
case TYPE_LATENCY_NS:
{
m_u64val = 0;
if(evt->get_direction() == SCAP_ED_IN)
{
if(evt->m_tinfo != NULL)
{
uint16_t* pt = (uint16_t*)evt->m_tinfo->get_private_state(m_th_state_id);
*pt = evt->get_type();
}
return (uint8_t*)&m_u64val;
}
if(evt->m_tinfo != NULL)
{
uint16_t* pt = (uint16_t*)evt->m_tinfo->get_private_state(m_th_state_id);
if(evt->m_tinfo->m_prevevent_ts && evt->get_type() == *pt + 1)
{
if(m_field_id == TYPE_LATENCY_S)
{
m_u64val = (evt->get_ts() - evt->m_tinfo->m_prevevent_ts) / 1000000000;
}
else
{
m_u64val = (evt->get_ts() - evt->m_tinfo->m_prevevent_ts) % 1000000000;
}
}
}
return (uint8_t*)&m_u64val;
}
case TYPE_DIR:
if(PPME_IS_ENTER(evt->get_type()))
{
return (uint8_t*)">";
}
else
{
return (uint8_t*)"<";
}
case TYPE_TYPE:
{
uint8_t* evname;
if(evt->m_pevt->type == PPME_GENERIC_E || evt->m_pevt->type == PPME_GENERIC_X)
{
sinsp_evt_param *parinfo = evt->get_param(0);
ASSERT(parinfo->m_len == sizeof(uint16_t));
uint16_t evid = *(uint16_t *)parinfo->m_val;
evname = (uint8_t*)g_infotables.m_syscall_info_table[evid].name;
}
else
{
evname = (uint8_t*)evt->get_name();
}
return evname;
}
break;
case TYPE_NUMBER:
return (uint8_t*)&evt->m_evtnum;
case TYPE_CPU:
return (uint8_t*)&evt->m_cpuid;
case TYPE_ARGRAW:
return extract_argraw(evt, len, m_arginfo->name);
break;
case TYPE_ARGSTR:
{
const char* resolved_argstr;
const char* argstr;
ASSERT(m_inspector != NULL);
if(m_argid != -1)
{
if(m_argid >= (int32_t)evt->m_info->nparams)
{
return NULL;
}
argstr = evt->get_param_as_str(m_argid, &resolved_argstr, m_inspector->get_buffer_format());
}
else
{
argstr = evt->get_param_value_str(m_argname.c_str(), &resolved_argstr, m_inspector->get_buffer_format());
}
if(resolved_argstr != NULL && resolved_argstr[0] != 0)
{
return (uint8_t*)resolved_argstr;
}
else
{
return (uint8_t*)argstr;
}
}
break;
case TYPE_ARGS:
{
if(evt->get_type() == PPME_GENERIC_E || evt->get_type() == PPME_GENERIC_X)
{
//
// Don't print the arguments for generic events: they have only internal use
//
return (uint8_t*)"";
}
const char* resolved_argstr = NULL;
const char* argstr = NULL;
uint32_t nargs = evt->get_num_params();
m_strstorage.clear();
for(uint32_t j = 0; j < nargs; j++)
{
ASSERT(m_inspector != NULL);
argstr = evt->get_param_as_str(j, &resolved_argstr, m_inspector->get_buffer_format());
if(resolved_argstr[0] == 0)
{
m_strstorage += evt->get_param_name(j);
m_strstorage += '=';
m_strstorage += argstr;
m_strstorage += " ";
}
else
{
m_strstorage += evt->get_param_name(j);
m_strstorage += '=';
m_strstorage += argstr;
m_strstorage += string("(") + resolved_argstr + ") ";
}
}
return (uint8_t*)m_strstorage.c_str();
}
break;
case TYPE_BUFFER:
{
if(m_is_compare)
{
return extract_argraw(evt, len, "data");
}
const char* resolved_argstr;
const char* argstr;
argstr = evt->get_param_value_str("data", &resolved_argstr, m_inspector->get_buffer_format());
return (uint8_t*)argstr;
break;
}
case TYPE_RESRAW:
{
const sinsp_evt_param* pi = evt->get_param_value_raw("res");
if(pi != NULL)
{
*len = pi->m_len;
return (uint8_t*)pi->m_val;
}
if((evt->get_flags() & EF_CREATES_FD) && PPME_IS_EXIT(evt->get_type()))
{
pi = evt->get_param_value_raw("fd");
if(pi != NULL)
{
*len = pi->m_len;
return (uint8_t*)pi->m_val;
}
}
return NULL;
}
break;
case TYPE_RESSTR:
{
const char* resolved_argstr;
const char* argstr;
argstr = evt->get_param_value_str("res", &resolved_argstr);
if(resolved_argstr != NULL && resolved_argstr[0] != 0)
{
return (uint8_t*)resolved_argstr;
}
else
{
if(argstr == NULL)
{
if((evt->get_flags() & EF_CREATES_FD) && PPME_IS_EXIT(evt->get_type()))
{
argstr = evt->get_param_value_str("fd", &resolved_argstr);
if(resolved_argstr != NULL && resolved_argstr[0] != 0)
{
return (uint8_t*)resolved_argstr;
}
else
{
return (uint8_t*)argstr;
}
}
else
{
return NULL;
}
}
else
{
return (uint8_t*)argstr;
}
}
}
break;
case TYPE_FAILED:
{
m_u32val = 0;
const sinsp_evt_param* pi = evt->get_param_value_raw("res");
if(pi != NULL)
{
ASSERT(pi->m_len == sizeof(int64_t));
if(*(int64_t*)pi->m_val < 0)
{
m_u32val = 1;
}
}
else if((evt->get_flags() & EF_CREATES_FD) && PPME_IS_EXIT(evt->get_type()))
{
pi = evt->get_param_value_raw("fd");
if(pi != NULL)
{
ASSERT(pi->m_len == sizeof(int64_t));
if(*(int64_t*)pi->m_val < 0)
{
m_u32val = 1;
}
}
}
return (uint8_t*)&m_u32val;
}
break;
case TYPE_ISIO:
{
ppm_event_flags eflags = evt->get_flags();
if(eflags & (EF_READS_FROM_FD | EF_WRITES_TO_FD))
{
m_u32val = 1;
}
else
{
m_u32val = 0;
}
}
return (uint8_t*)&m_u32val;
case TYPE_ISIO_READ:
{
ppm_event_flags eflags = evt->get_flags();
if(eflags & EF_READS_FROM_FD)
{
m_u32val = 1;
}
else
{
m_u32val = 0;
}
return (uint8_t*)&m_u32val;
}
case TYPE_ISIO_WRITE:
{
ppm_event_flags eflags = evt->get_flags();
if(eflags & EF_WRITES_TO_FD)
{
m_u32val = 1;
}
else
{
m_u32val = 0;
}
return (uint8_t*)&m_u32val;
}
case TYPE_ISWAIT:
{
ppm_event_flags eflags = evt->get_flags();
if(eflags & (EF_WAITS))
{
m_u32val = 1;
}
else
{
m_u32val = 0;
}
}
return (uint8_t*)&m_u32val;
case TYPE_COUNT:
m_u32val = 1;
return (uint8_t*)&m_u32val;
default:
ASSERT(false);
return NULL;
}
return NULL;
}
