int
xrdpvr_send_init(void *channel)
{
STREAM *s;
char *cptr;
int rv;
int len;
printf("xrdpvr_send_init:\n");
stream_new(s, MAX_BUFSIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_INIT_XRDPVR);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
result_t load_file(editor_t *ed, handle_t stream)
{
uint16_t length;
int f;
result_t result;
if(failed(result = stream_length(stream, &length)))
return result;
ed->stream = stream;
ed->start = (char *) neutron_malloc(length + MINEXTEND);
if (!ed->start)
return e_no_space;
if(succeeded(result = stream_setpos(stream, 0)) &&
succeeded(result = stream_read(stream, ed->start, length, 0)))
{
ed->gap = ed->start + length;
ed->rest = ed->end = ed->gap + MINEXTEND;
ed->anchor = -1;
}
if (failed(result) && ed->start)
{
neutron_free(ed->start);
ed->start = 0;
}
return result;
}
/**
* send video data to client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
* @param data_len number of bytes to send
* @param data video data to send
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_send_video_data(void *channel, uint32_t stream_id, uint32_t data_len, uint8_t *data)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_PDU_SIZE + data_len);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SEND_VIDEO_DATA);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, data_len);
stream_ins_byte_array(s, data, data_len);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
#ifdef DEBUG_FRAGMENTS
printf("### sent %d + 4 bytes video data to client\n", len);
#endif
return rv;
}
int
xrdpvr_set_geometry(void *channel, int stream_id, int xpos, int ypos, int width, int height)
{
STREAM *s;
char *cptr;
int rv;
int len;
printf("xrdpvr_set_geometry: entered; x=%d y=%d\n", xpos, ypos);
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_GEOMETRY);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, xpos);
stream_ins_u32_le(s, ypos);
stream_ins_u32_le(s, width);
stream_ins_u32_le(s, height);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* send audio data to client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
* @param data_len number of bytes to send
* @param data audio data to send
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_send_audio_data(void *channel, uint32_t stream_id, uint32_t data_len, uint8_t *data)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_PDU_SIZE + data_len);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SEND_AUDIO_DATA);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, data_len);
stream_ins_byte_array(s, data, data_len);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* write set volume to a xrdpvr client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param volume volume 0x0000 to 0xffff
*
* @return 0 on success, -1 on failure
******************************************************************************/
int
xrdpvr_set_volume(void *channel, int volume)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_BUFSIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_VOLUME);
stream_ins_u32_le(s, volume);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* set video format
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_set_video_format(void *channel, uint32_t stream_id, int format,
int width, int height)
{
STREAM *s;
char *cptr;
int rv;
int len;
width = (width + 15) & ~15;
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_VIDEO_FORMAT);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, format);
stream_ins_u32_le(s, width);
stream_ins_u32_le(s, height);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
/**
* write data to a xrdpvr client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param s structure containing data to write
*
* @return 0 on success, -1 on failure
******************************************************************************/
static int
xrdpvr_write_to_client(void *channel, STREAM *s)
{
int bytes_to_send;
int bytes_written;
int index = 0;
int rv;
if ((channel == NULL) || (s == NULL))
{
return -1;
}
bytes_to_send = stream_length(s);
while (1)
{
rv = WTSVirtualChannelWrite(channel, &s->data[index], bytes_to_send, &bytes_written);
if (rv < 0)
{
return -1;
}
index += bytes_written;
bytes_to_send -= bytes_written;
if ((rv == 0) && (bytes_to_send == 0))
{
return 0;
}
usleep(1000 * 3);
}
}
/**
* set audio format
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_set_audio_format(void *channel, uint32_t stream_id)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_AUDIO_FORMAT);
stream_ins_u32_le(s, stream_id);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
void test_stream_filter_dup(void) {
stream_t *st;
st = stream_filter_dup(stream_range(1, 100, 1), stream_generic_filter_even, NULL);
CU_ASSERT(stream_length(st) == 50);
return;
}
void test_stream_range(void) {
stream_t *st;
st = stream_range(1, 1000, 1);
CU_ASSERT(stream_length(st) == 1000);
stream_reset(st);
st = stream_range(2, 1000, 2);
CU_ASSERT(stream_length(st) == 500);
stream_reset(st);
st = stream_range(1000, 1, 1);
CU_ASSERT(stream_length(st) == 1000);
stream_reset(st);
return;
}
/**
* de-initialize the media player
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_deinit_player(void *channel, int stream_id)
{
STREAM *s;
char *cptr;
int rv;
int len;
if ((channel == NULL) || (stream_id <= 0))
{
return -1;
}
/* do local clean up */
if (g_psi.frame != 0)
{
av_free(g_psi.frame);
g_psi.frame = 0;
}
if (g_psi.p_audio_codec_ctx != 0)
{
avcodec_close(g_psi.p_audio_codec_ctx);
g_psi.p_audio_codec_ctx = 0;
}
if (g_psi.p_video_codec_ctx != 0)
{
avcodec_close(g_psi.p_video_codec_ctx);
g_psi.p_video_codec_ctx = 0;
}
//avformat_close_input(&g_psi.p_format_ctx);
if (g_psi.p_format_ctx != 0)
{
av_close_input_file(g_psi.p_format_ctx);
g_psi.p_format_ctx = 0;
}
/* do remote cleanup */
stream_new(s, MAX_PDU_SIZE);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_DEINIT_XRDPVR);
stream_ins_u32_le(s, stream_id);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return 0;
}
void test_stream_drop(void) {
stream_t *st;
st = stream_range(1, 1000, 1);
st = stream_drop(st, 10);
CU_ASSERT(stream_length(st) == 990);
return;
}
void test_stream_length(void) {
stream_t *st;
st = stream_new((void *)"HELLO", NULL, NULL, NULL);
CU_ASSERT(stream_length(st) == 1);
st = stream_new((void *)1, stream_generic_adder, (void *)1000, NULL);
CU_ASSERT(stream_length(st) == 1001);
st = stream_new((void *)"HELLO", NULL, NULL,
stream_new((void *)1, stream_generic_adder, (void *)1000, NULL));
CU_ASSERT(stream_length(st) == 1002);
st = stream_new((void *)"HELLO", NULL, NULL,
stream_new((void *)1, stream_generic_adder, (void *)1000,
stream_new((void *)"GET TO THE CHOPPA", NULL, NULL,
stream_new((void *)1, stream_generic_adder, (void *)10, NULL))));
CU_ASSERT(stream_length(st) == 1013);
stream_reset(st);
CU_ASSERT(stream_length(st) == 1013);
}
/**
* set audio format
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param stream_id unique identification number for this stream
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_set_audio_format(void *channel, uint32_t stream_id, int format,
char *extradata, int extradata_size, int sample_rate,
int bit_rate, int channels, int block_align)
{
STREAM *s;
char *cptr;
int rv;
int len;
stream_new(s, MAX_PDU_SIZE);
printf("extradata_size %d sample_rate %d bit_rate %d channels %d "
"block_align %d\n", extradata_size, sample_rate, bit_rate,
channels, block_align);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_SET_AUDIO_FORMAT);
stream_ins_u32_le(s, stream_id);
stream_ins_u32_le(s, format);
stream_ins_u32_le(s, extradata_size);
memcpy(s->p, extradata, extradata_size);
s->p += extradata_size;
stream_ins_u32_le(s, sample_rate);
stream_ins_u32_le(s, bit_rate);
stream_ins_u32_le(s, channels);
stream_ins_u32_le(s, block_align);
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len);
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
stream_free(s);
return rv;
}
static void Z72_lambda(CL_FORM *base)
{
COPY(INDIRECT(GET_FORM(ARG(0)) + 3), ARG(1));
if(CL_SYMBOLP(ARG(1)))
{
COPY(SYM_VALUE(ARG(1)), ARG(1));
}
else
{
if(CL_TRUEP(ARG(1)))
{
COPY(SYMVAL(Slisp, 676), ARG(2)); /* SYM_EXPECTED */
COPY(ARG(1), ARG(3));
Ferror(ARG(2), 2);
}
else
{
LOAD_NIL(ARG(1));
}
}
stream_length(ARG(1));
Ffuncall(ARG(1), 1);
COPY(ARG(1), ARG(0));
}
static const char *
translate_pattern(const char *pattern, int *tpatlen)
{
/* Translate a MOO pattern into a more standard syntax. Effectively, this
* just involves converting from `%' escapes into `\' escapes.
*/
static Stream *s = 0;
const char *p = pattern;
char c;
if (!s)
s = new_stream(100);
while (*p) {
switch (c = *p++) {
case '%':
c = *p++;
if (!c)
goto fail;
else if (strchr(".*+?[^$|()123456789bB<>wW", c))
stream_add_char(s, '\\');
stream_add_char(s, c);
break;
case '\\':
stream_add_string(s, "\\\\");
break;
case '[':
/* Any '%' or '\' characters inside a charset should be copied
* over without translation. */
stream_add_char(s, c);
c = *p++;
if (c == '^') {
stream_add_char(s, c);
c = *p++;
}
/* This is the only place a ']' can appear and not be the end of
* the charset. */
if (c == ']') {
stream_add_char(s, c);
c = *p++;
}
while (c && c != ']') {
stream_add_char(s, c);
c = *p++;
}
if (!c)
goto fail;
else
stream_add_char(s, c);
break;
default:
stream_add_char(s, c);
break;
}
}
*tpatlen = stream_length(s);
return reset_stream(s);
fail:
reset_stream(s);
return 0;
}
/**
* send media meta-data to client
*
* @param channel opaque handle returned by WTSVirtualChannelOpenEx
* @param filename media file
*
* @return 0 on success, -1 on error
*****************************************************************************/
int
xrdpvr_create_metadata_file(void *channel, char *filename)
{
STREAM *s;
char *cptr;
int rv;
int len;
int fd;
if ((fd = open(filename , O_RDONLY)) < 0)
{
return -1;
}
stream_new(s, MAX_PDU_SIZE + 1048576);
/* send CMD_CREATE_META_DATA_FILE */
stream_ins_u32_le(s, 4); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_CREATE_META_DATA_FILE);
if (xrdpvr_write_to_client(channel, s))
{
close(fd);
return -1;
}
/* read first 1MB of file and send to client */
s->p = s->data;
stream_ins_u32_le(s, 0); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_WRITE_META_DATA);
stream_ins_u32_le(s, 0); /* number of bytes to follow */
if ((rv = read(fd, s->p, 1048576)) <= 0)
{
close(fd);
return -1;
}
s->p += rv;
/* insert number of bytes in stream */
len = stream_length(s) - 4;
cptr = s->p;
s->p = s->data;
stream_ins_u32_le(s, len); /* number of bytes in this cmd */
s->p += 4;
stream_ins_u32_le(s, rv); /* number of metadata bytes */
s->p = cptr;
/* write data to virtual channel */
rv = xrdpvr_write_to_client(channel, s);
/* send CMD_CLOSE_META_DATA_FILE */
s->p = s->data;
stream_ins_u32_le(s, 4); /* number of bytes to follow */
stream_ins_u32_le(s, CMD_CLOSE_META_DATA_FILE);
if (xrdpvr_write_to_client(channel, s))
{
close(fd);
return -1;
}
stream_free(s);
return rv;
}
static void
disassemble(Program * prog, Printer p, void *data)
{
Stream *s = new_stream(100);
Stream *insn = new_stream(50);
int i, l;
unsigned pc;
Bytecodes bc;
const char *ptr;
const char **names = prog->var_names;
unsigned tmp, num_names = prog->num_var_names;
# define NAMES(i) (tmp = i, \
tmp < num_names ? names[tmp] \
: "*** Unknown variable ***")
Var *literals = prog->literals;
initialize_tables();
print = p;
print_data = data;
stream_printf(s, "Language version number: %d", (int) prog->version);
output(s);
stream_printf(s, "First line number: %d", prog->first_lineno);
output(s);
for (i = -1; i < 0 || i < prog->fork_vectors_size; i++) {
output(s);
if (i == -1) {
stream_printf(s, "Main code vector:");
output(s);
stream_printf(s, "=================");
output(s);
bc = prog->main_vector;
} else {
stream_printf(s, "Forked code vector %d:", i);
l = stream_length(s);
output(s);
while (l--)
stream_add_char(s, '=');
output(s);
bc = prog->fork_vectors[i];
}
stream_printf(s, "[Bytes for labels = %d, literals = %d, ",
bc.numbytes_label, bc.numbytes_literal);
stream_printf(s, "forks = %d, variables = %d, stack refs = %d]",
bc.numbytes_fork, bc.numbytes_var_name,
bc.numbytes_stack);
output(s);
stream_printf(s, "[Maximum stack size = %d]", bc.max_stack);
output(s);
max_bytes_width = 5;
for (pc = 0; pc < bc.size;) {
Byte b;
unsigned arg;
# define ADD_BYTES(n) (arg = add_bytes(s, bc.vector, pc, n), \
pc += n, \
arg)
unsigned a1, a2;
new_insn(s, pc);
b = add_bytes(s, bc.vector, pc++, 1);
if (b != OP_EXTENDED)
stream_add_string(insn, COUNT_TICK(b) ? " * " : " ");
if (IS_OPTIM_NUM_OPCODE(b))
stream_printf(insn, "NUM %d", OPCODE_TO_OPTIM_NUM(b));
#ifdef BYTECODE_REDUCE_REF
else if (IS_PUSH_CLEAR_n(b))
stream_printf(insn, "PUSH_CLEAR %s", NAMES(PUSH_CLEAR_n_INDEX(b)));
#endif /* BYTECODE_REDUCE_REF */
else if (IS_PUSH_n(b))
stream_printf(insn, "PUSH %s", NAMES(PUSH_n_INDEX(b)));
else if (IS_PUT_n(b))
stream_printf(insn, "PUT %s", NAMES(PUT_n_INDEX(b)));
else if (b == OP_EXTENDED) {
b = ADD_BYTES(1);
stream_add_string(insn, COUNT_EOP_TICK(b) ? " * " : " ");
stream_add_string(insn, ext_mnemonics[b]);
switch ((Extended_Opcode) b) {
case EOP_WHILE_ID:
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s %d", NAMES(a1), a2);
break;
case EOP_EXIT_ID:
stream_printf(insn, " %s",
NAMES(ADD_BYTES(bc.numbytes_var_name)));
/* fall thru */
case EOP_EXIT:
a1 = ADD_BYTES(bc.numbytes_stack);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %d %d", a1, a2);
break;
case EOP_PUSH_LABEL:
case EOP_END_CATCH:
case EOP_END_EXCEPT:
case EOP_TRY_FINALLY:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_label));
break;
case EOP_TRY_EXCEPT:
stream_printf(insn, " %d", ADD_BYTES(1));
break;
case EOP_LENGTH:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_stack));
break;
case EOP_SCATTER:
{
int i, nargs = ADD_BYTES(1);
a1 = ADD_BYTES(1);
a2 = ADD_BYTES(1);
stream_printf(insn, " %d/%d/%d:", nargs, a1, a2);
for (i = 0; i < nargs; i++) {
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s/%d", NAMES(a1), a2);
}
stream_printf(insn, " %d",
ADD_BYTES(bc.numbytes_label));
}
break;
default:
break;
}
} else {
stream_add_string(insn, mnemonics[b]);
switch ((Opcode) b) {
case OP_IF:
case OP_IF_QUES:
case OP_EIF:
case OP_AND:
case OP_OR:
case OP_JUMP:
case OP_WHILE:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_label));
break;
case OP_FORK:
stream_printf(insn, " %d", ADD_BYTES(bc.numbytes_fork));
break;
case OP_FORK_WITH_ID:
a1 = ADD_BYTES(bc.numbytes_fork);
a2 = ADD_BYTES(bc.numbytes_var_name);
stream_printf(insn, " %d %s", a1, NAMES(a2));
break;
case OP_FOR_LIST:
case OP_FOR_RANGE:
a1 = ADD_BYTES(bc.numbytes_var_name);
a2 = ADD_BYTES(bc.numbytes_label);
stream_printf(insn, " %s %d", NAMES(a1), a2);
break;
case OP_G_PUSH:
#ifdef BYTECODE_REDUCE_REF
case OP_G_PUSH_CLEAR:
#endif /* BYTECODE_REDUCE_REF */
case OP_G_PUT:
stream_printf(insn, " %s",
NAMES(ADD_BYTES(bc.numbytes_var_name)));
break;
case OP_IMM:
{
Var v;
v = literals[ADD_BYTES(bc.numbytes_literal)];
switch (v.type) {
case TYPE_OBJ:
stream_printf(insn, " #%d", v.v.obj);
break;
case TYPE_INT:
stream_printf(insn, " %d", v.v.num);
break;
case TYPE_STR:
stream_add_string(insn, " \"");
for (ptr = v.v.str; *ptr; ptr++) {
if (*ptr == '"' || *ptr == '\\')
stream_add_char(insn, '\\');
stream_add_char(insn, *ptr);
}
stream_add_char(insn, '"');
break;
case TYPE_ERR:
stream_printf(insn, " %s", error_name(v.v.err));
break;
default:
stream_printf(insn, " <literal type = %d>",
v.type);
break;
}
}
break;
case OP_BI_FUNC_CALL:
stream_printf(insn, " %s", name_func_by_num(ADD_BYTES(1)));
default:
break;
}
}
finish_insn(s, insn);
}
}
free_stream(s);
free_stream(insn);
}
