static void add_service(obs_property_t list, json_t *service)
{
json_t *servers;
const char *name;
if (!json_is_object(service)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"is not an object");
return;
}
name = get_string_val(service, "name");
if (!name) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"has no name");
return;
}
servers = json_object_get(service, "servers");
if (!servers || !json_is_array(servers)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"'%s' has no servers", name);
return;
}
obs_property_list_add_string(list, name, name);
}
static void add_service(obs_property_t *list, json_t *service, bool show_all,
const char *cur_service)
{
json_t *servers;
const char *name;
bool common;
if (!json_is_object(service)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"is not an object");
return;
}
name = get_string_val(service, "name");
if (!name) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"has no name");
return;
}
common = get_bool_val(service, "common");
if (!show_all && !common && strcmp(cur_service, name) != 0) {
return;
}
servers = json_object_get(service, "servers");
if (!servers || !json_is_array(servers)) {
blog(LOG_WARNING, "rtmp-common.c: [add_service] service "
"'%s' has no servers", name);
return;
}
obs_property_list_add_string(list, name, name);
}
static HRESULT String_toUpperCase(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
jsstr_t *str;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
if(r) {
jsstr_t *ret;
WCHAR *buf;
buf = jsstr_alloc_buf(jsstr_length(str), &ret);
if(!buf) {
jsstr_release(str);
return E_OUTOFMEMORY;
}
jsstr_flush(str, buf);
struprW(buf);
*r = jsval_string(ret);
}
jsstr_release(str);
return S_OK;
}
static HRESULT do_attribute_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, unsigned argc, jsval_t *argv, jsval_t *r,
const WCHAR *tagname, const WCHAR *attrname)
{
jsstr_t *str, *attr_value = NULL;
HRESULT hres;
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
if(argc) {
hres = to_string(ctx, argv[0], &attr_value);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
} else {
attr_value = jsstr_undefined();
}
if(r) {
unsigned attrname_len = strlenW(attrname);
unsigned tagname_len = strlenW(tagname);
jsstr_t *ret;
WCHAR *ptr;
ptr = jsstr_alloc_buf(2*tagname_len + attrname_len + jsstr_length(attr_value) + jsstr_length(str) + 9, &ret);
if(ptr) {
*ptr++ = '<';
memcpy(ptr, tagname, tagname_len*sizeof(WCHAR));
ptr += tagname_len;
*ptr++ = ' ';
memcpy(ptr, attrname, attrname_len*sizeof(WCHAR));
ptr += attrname_len;
*ptr++ = '=';
*ptr++ = '"';
ptr += jsstr_flush(attr_value, ptr);
*ptr++ = '"';
*ptr++ = '>';
ptr += jsstr_flush(str, ptr);
*ptr++ = '<';
*ptr++ = '/';
memcpy(ptr, tagname, tagname_len*sizeof(WCHAR));
ptr += tagname_len;
*ptr = '>';
*r = jsval_string(ret);
} else {
hres = E_OUTOFMEMORY;
}
}
jsstr_release(attr_value);
jsstr_release(str);
return hres;
}
/* ECMA-262 3rd Edition 15.5.4.15 */
static HRESULT String_substring(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
INT start=0, end, length;
jsstr_t *str;
double d;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
length = jsstr_length(str);
if(argc >= 1) {
hres = to_integer(ctx, argv[0], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(d >= 0)
start = is_int32(d) ? min(length, d) : length;
}
if(argc >= 2) {
hres = to_integer(ctx, argv[1], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(d >= 0)
end = is_int32(d) ? min(length, d) : length;
else
end = 0;
} else {
end = length;
}
if(start > end) {
INT tmp = start;
start = end;
end = tmp;
}
if(r) {
jsstr_t *ret = jsstr_substr(str, start, end-start);
if(ret)
*r = jsval_string(ret);
else
hres = E_OUTOFMEMORY;
}
jsstr_release(str);
return hres;
}
/* ECMA-262 3rd Edition B.2.3 */
static HRESULT String_substr(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
int start=0, len, length;
jsstr_t *str;
double d;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
length = jsstr_length(str);
if(argc >= 1) {
hres = to_integer(ctx, argv[0], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(d >= 0)
start = is_int32(d) ? min(length, d) : length;
}
if(argc >= 2) {
hres = to_integer(ctx, argv[1], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(d >= 0.0)
len = is_int32(d) ? min(length-start, d) : length-start;
else
len = 0;
} else {
len = length-start;
}
hres = S_OK;
if(r) {
jsstr_t *ret = jsstr_substr(str, start, len);
if(ret)
*r = jsval_string(ret);
else
hres = E_OUTOFMEMORY;
}
jsstr_release(str);
return hres;
}
static HRESULT get_string_flat_val(script_ctx_t *ctx, vdisp_t *jsthis, jsstr_t **jsval, const WCHAR **val)
{
HRESULT hres;
hres = get_string_val(ctx, jsthis, jsval);
if(FAILED(hres))
return hres;
*val = jsstr_flatten(*jsval);
if(*val)
return S_OK;
jsstr_release(*jsval);
return E_OUTOFMEMORY;
}
static void update_content_length(char **ut_buf, u32 *pack_len)
{
int nlen;
char olen[20];
char *pcrlfcrlf;
get_string_val(*ut_buf, (char*)"Content-Length: ", (char*)"\r\n", olen);
pcrlfcrlf = strnstr(*ut_buf, "\r\n\r\n", *pack_len, true);
if (pcrlfcrlf != NULL) {
char len1[256];
char len2[256];
nlen = strlen(*ut_buf) - (pcrlfcrlf - *ut_buf) - 4;
sprintf(len1, "Content-Length: %s\r\n", olen);
sprintf(len2, "Content-Length: %d\r\n", nlen);
strreplace(ut_buf, len1, len2, REPLACE_ALL, pack_len);
}
}
/* ECMA-262 3rd Edition 15.5.4.10 */
static HRESULT String_match(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
jsdisp_t *regexp = NULL;
jsstr_t *str;
HRESULT hres;
TRACE("\n");
if(!argc) {
if(r)
*r = jsval_null();
return S_OK;
}
if(is_object_instance(argv[0])) {
regexp = iface_to_jsdisp(get_object(argv[0]));
if(regexp && !is_class(regexp, JSCLASS_REGEXP)) {
jsdisp_release(regexp);
regexp = NULL;
}
}
if(!regexp) {
jsstr_t *match_str;
hres = to_string(ctx, argv[0], &match_str);
if(FAILED(hres))
return hres;
hres = create_regexp(ctx, match_str, 0, ®exp);
jsstr_release(match_str);
if(FAILED(hres))
return hres;
}
hres = get_string_val(ctx, jsthis, &str);
if(SUCCEEDED(hres))
hres = regexp_string_match(ctx, regexp, str, r);
jsdisp_release(regexp);
jsstr_release(str);
return hres;
}
/* ECMA-262 3rd Edition 15.5.4.5 */
static HRESULT String_charCodeAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
jsstr_t *str;
DWORD idx = 0;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
if(argc > 0) {
double d;
hres = to_integer(ctx, argv[0], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(!is_int32(d) || d < 0 || d >= jsstr_length(str)) {
jsstr_release(str);
if(r)
*r = jsval_number(NAN);
return S_OK;
}
idx = d;
}
if(r) {
WCHAR c;
jsstr_extract(str, idx, 1, &c);
*r = jsval_number(c);
}
jsstr_release(str);
return S_OK;
}
static HRESULT do_attributeless_tag_format(script_ctx_t *ctx, vdisp_t *jsthis, jsval_t *r, const WCHAR *tagname)
{
unsigned tagname_len;
jsstr_t *str, *ret;
WCHAR *ptr;
HRESULT hres;
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
if(!r) {
jsstr_release(str);
return S_OK;
}
tagname_len = strlenW(tagname);
ptr = jsstr_alloc_buf(jsstr_length(str) + 2*tagname_len + 5, &ret);
if(!ret) {
jsstr_release(str);
return E_OUTOFMEMORY;
}
*ptr++ = '<';
memcpy(ptr, tagname, tagname_len*sizeof(WCHAR));
ptr += tagname_len;
*ptr++ = '>';
ptr += jsstr_flush(str, ptr);
jsstr_release(str);
*ptr++ = '<';
*ptr++ = '/';
memcpy(ptr, tagname, tagname_len*sizeof(WCHAR));
ptr += tagname_len;
*ptr = '>';
*r = jsval_string(ret);
return S_OK;
}
/* ECMA-262 3rd Edition 15.5.4.5 */
static HRESULT String_charAt(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
jsstr_t *str, *ret;
INT pos = 0;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
if(argc) {
double d;
hres = to_integer(ctx, argv[0], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
pos = is_int32(d) ? d : -1;
}
if(!r) {
jsstr_release(str);
return S_OK;
}
if(0 <= pos && pos < jsstr_length(str)) {
ret = jsstr_substr(str, pos, 1);
if(!ret)
return E_OUTOFMEMORY;
} else {
ret = jsstr_empty();
}
*r = jsval_string(ret);
return S_OK;
}
int read_roi_infile(char *infile)
{
FILE *fp = fopen(infile,"r");
if (fp==NULL) {printf("ERROR: can't open %s ROI input file\n",infile); return(1); }
char ctmp[256];
int itmp;
double dtmp;
int i;
// DESCRIPTION VALUE
// ---------------------------------------------------------- -----------------------------------------------
get_string_val(fp,datfilename); // First input data file <infile>.dat
get_string_val(fp,ctmp); // Second input data file /dev/null
get_string_val(fp,ctmp); // Output data file <infile>.slc
get_string_val(fp,ctmp); // Output amplitudes file /dev/null
get_string_val(fp,ctmp); // 8lk output file 8lk
get_int_val(fp,&itmp); // debug flag 0
get_int_val(fp,&itmp); // How many input bytes per line files 1 and 2 13680 13680
get_int_val(fp,&itmp); // How many good bytes per line, including header 13680 13680
get_int_val(fp,&start_line); // First line to read (start at 0) 1
get_int_val(fp,&npatches); // Enter # of range input patches {Get nl from hdr values; patches = nl/11600}
get_int_val(fp,&itmp); // First sample pair to use (start at zero) 0
get_int_val(fp,&itmp); // Azimuth Patch Size (Power of 2) 16384
get_int_val(fp,&patch_size); // Number of valid points in azimuth 11600
get_string_val(fp,ctmp); // Deskew the image n
get_int_val(fp,&ncaltones);
printf("Reading %i caltone values\n",ncaltones);
for (i=0;i<ncaltones;i++)
get_double_val(fp,&dtmp); // Caltone % of sample rate 0.25 0.25701904296875
get_2int_vals(fp,&itmp,&ns); // Start range bin, number of range bins to process 1 6840
get_int_val(fp,&itmp); // Delta azimuth, range pixels for second file 0 0
get_3double_vals(fp,&dop1,&dop2,&dop3); // Image 1 Doppler centroid quad coefs (Hz/prf) {calculated from dop_est - 3 parameters}
get_double_val(fp,&dtmp); // Image 2 Doppler centroid quad coefs (Hz/prf) {copy above 3 values}
get_int_val(fp,&itmp); // 1 = use file 1 doppler, 2 = file 2, 3 = avg 1
get_double_val(fp,&earth_rad); // Earth Radius (m) {calculated from get_peg_info}
get_double_val(fp,&sc_vel); // Body Fixed S/C velocities 1,2 (m/s) {calculate from EBEF state vector - 2 parameters}
get_double_val(fp,&sc_height); // Spacecraft height 1,2 (m) {calculated from get_peg_info - 2 parameters}
get_double_val(fp,&dtmp); // Planet GM 0
get_double_val(fp,&dtmp); // Left, Right or Unknown Pointing Right
get_double_val(fp,&dtmp); // SCH Velocity Vector 1 {calculated from get_peg_info - 3 parameters}
get_double_val(fp,&dtmp); // SCH Velocity Vector 2 {copy above 3 values}
get_double_val(fp,&dtmp); // SCH Acceleration Vector 1 {calculated from get_pef_info - 3 parameters}
get_double_val(fp,&dtmp); // SCH Acceleration Vector 2 {copy above 3 values}
get_double_val(fp,&srf); // Range of first sample in raw data file 1,2 (m) {calculate from the hdr infomation - 2 values}
get_double_val(fp,&prf); // PRF 1,2 (pps) {calculate from the hdr information - 2 values}
get_double_val(fp,&dtmp); // i/q means, i1,q1, i2,q2 15.5 15.5 15.5 15.5
get_string_val(fp,ctmp); // Flip i/q (y/n) s
get_double_val(fp,&dtmp); // Desired azimuth resolution (m) 5 (what should this be???)
get_double_val(fp,&dtmp); // Number of azimuth looks 4 (what should this be???)
get_double_val(fp,&fs); // Range sampling rate (Hz) 22765000
get_double_val(fp,&chirp_slope); // Chirp Slope (Hz/s) 5.62130178e11
get_double_val(fp,&pulse_duration); // Pulse Duration (s) 33.8e-6
get_int_val(fp,&itmp); // Chirp extension points 0
get_string_val(fp,ctmp); // Secondary range migration correction (y/n) n
get_double_val(fp,&wavelength); // Radar Wavelength (m) 0.235
get_int_val(fp,&itmp); // Range Spectral Weighting (1.=none, 0.54=Hamming) 1.0
get_double_val(fp,&dtmp); // Fraction of range bandwidth to remove 0 0
get_double_val(fp,&dtmp); // linear resampling coefs: sloper, intr, slopea, inta 0 0 0 0
get_double_val(fp,&dtmp); // linear resampling deltas: dsloper, dintr, dslopea, dinta 0 0 0 0
get_string_val(fp,ctmp); // AGC file /dev/null
get_string_val(fp,dwpfilename); // DWP file /dev/null or DWP file
printf("start_line %i\n",start_line);
printf("npatches %i\n",npatches);
printf("patch_size %i\n",patch_size);
printf("num samples %i\n",ns);
return(0);
}
/* ECMA-262 3rd Edition 15.5.4.6 */
static HRESULT String_concat(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
jsstr_t *ret, *str;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
switch(argc) {
case 0:
ret = str;
break;
case 1: {
jsstr_t *arg_str;
hres = to_string(ctx, argv[0], &arg_str);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
ret = jsstr_concat(str, arg_str);
jsstr_release(str);
if(!ret)
return E_OUTOFMEMORY;
break;
}
default: {
const unsigned str_cnt = argc+1;
unsigned len = 0, i;
jsstr_t **strs;
WCHAR *ptr;
strs = heap_alloc_zero(str_cnt * sizeof(*strs));
if(!strs) {
jsstr_release(str);
return E_OUTOFMEMORY;
}
strs[0] = str;
for(i=0; i < argc; i++) {
hres = to_string(ctx, argv[i], strs+i+1);
if(FAILED(hres))
break;
}
if(SUCCEEDED(hres)) {
for(i=0; i < str_cnt; i++) {
len += jsstr_length(strs[i]);
if(len > JSSTR_MAX_LENGTH) {
hres = E_OUTOFMEMORY;
break;
}
}
if(SUCCEEDED(hres)) {
ptr = jsstr_alloc_buf(len, &ret);
if(ptr) {
for(i=0; i < str_cnt; i++)
ptr += jsstr_flush(strs[i], ptr);
} else {
hres = E_OUTOFMEMORY;
}
}
}
while(i--)
jsstr_release(strs[i]);
heap_free(strs);
if(FAILED(hres))
return hres;
}
}
if(r)
*r = jsval_string(ret);
else
jsstr_release(ret);
return S_OK;
}
/* ECMA-262 3rd Edition 15.5.4.13 */
static HRESULT String_slice(script_ctx_t *ctx, vdisp_t *jsthis, WORD flags, unsigned argc, jsval_t *argv,
jsval_t *r)
{
int start=0, end, length;
jsstr_t *str;
double d;
HRESULT hres;
TRACE("\n");
hres = get_string_val(ctx, jsthis, &str);
if(FAILED(hres))
return hres;
length = jsstr_length(str);
if(argc) {
hres = to_integer(ctx, argv[0], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(is_int32(d)) {
start = d;
if(start < 0) {
start = length + start;
if(start < 0)
start = 0;
} else if(start > length) {
start = length;
}
} else if(d > 0) {
start = length;
}
}
if(argc >= 2) {
hres = to_integer(ctx, argv[1], &d);
if(FAILED(hres)) {
jsstr_release(str);
return hres;
}
if(is_int32(d)) {
end = d;
if(end < 0) {
end = length + end;
if(end < 0)
end = 0;
} else if(end > length) {
end = length;
}
} else {
end = d < 0.0 ? 0 : length;
}
} else {
end = length;
}
if(end < start)
end = start;
if(r) {
jsstr_t *retstr = jsstr_substr(str, start, end-start);
if(!retstr) {
jsstr_release(str);
return E_OUTOFMEMORY;
}
*r = jsval_string(retstr);
}
jsstr_release(str);
return S_OK;
}
