/* returns error */ int APP_CC xrdp_iso_incoming(struct xrdp_iso* self) { int code; struct stream* s; make_stream(s); init_stream(s, 8192); DEBUG((" in xrdp_iso_incoming")); if (xrdp_iso_recv_msg(self, s, &code) != 0) { free_stream(s); return 1; } if (! xrdp_iso_parse_connection_request(self, s, code)) { free_stream(s); return 1; } if (code != ISO_PDU_CR) { free_stream(s); return 1; } if (xrdp_iso_send_connection_confirm(self, s) != 0) { free_stream(s); return 1; } DEBUG((" out xrdp_iso_incoming")); free_stream(s); return 0; }
void bg_ogg_encoder_destroy(void * data) { int i; bg_ogg_encoder_t * e = data; if(e->write_callback_data) bg_ogg_encoder_close(e, 1); if(e->audio_streams) { for(i = 0; i < e->num_audio_streams; i++) free_stream(&e->audio_streams[i]); free(e->audio_streams); } if(e->video_streams) { for(i = 0; i < e->num_video_streams; i++) free_stream(&e->video_streams[i]); free(e->video_streams); } if(e->filename) free(e->filename); if(e->audio_parameters) bg_parameter_info_destroy_array(e->audio_parameters); if(e->video_parameters) bg_parameter_info_destroy_array(e->video_parameters); free(e); }
xmlDocPtr DEFAULT_CC xml_receive_message(int client) { struct stream* s; int data_length; int res = 0; make_stream(s); init_stream(s, 1024); xmlDocPtr doc; res= g_tcp_recv(client, s->data, sizeof(int), 0); if (res != sizeof(int)) { log_message(&(g_cfg->log), LOG_LEVEL_DEBUG, "sesman[xml_received_message]: " "Unable to read size header with error %s", strerror(g_get_errno())); return NULL; } in_uint32_be(s,data_length); log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_received_message]: " "data_length : %i", data_length); free_stream(s); make_stream(s); init_stream(s, data_length + 1); g_tcp_recv(client, s->data, data_length, 0); s->data[data_length] = 0; log_message(&(g_cfg->log), LOG_LEVEL_DEBUG_PLUS, "sesman[xml_received_message]: " "data : %s",s->data); doc = xmlReadMemory(s->data, data_length, "noname.xml", NULL, 0); free_stream(s); return doc; }
int APP_CC dev_redir_process_close_io_request(int completion_id) { struct stream* s; log_message(&log_conf, LOG_LEVEL_DEBUG, "chansrv[dev_redir_process_close_io_request]:" "close file : %s",actions[completion_id].path); make_stream(s); init_stream(s,1100); actions[completion_id].last_req = IRP_MJ_CLOSE; out_uint16_le(s, RDPDR_CTYP_CORE); out_uint16_le(s, PAKID_CORE_DEVICE_IOREQUEST); out_uint32_le(s, actions[completion_id].device); out_uint32_le(s, actions[completion_id].file_id); out_uint32_le(s, completion_id); out_uint32_le(s, IRP_MJ_CLOSE); /* major version */ out_uint32_le(s, 0); /* minor version */ out_uint8s(s,32); s_mark_end(s); dev_redir_send(s); actions[completion_id].message_id++; free_stream(s); return 0; free_stream(s); }
static int enable_cache(struct MPContext *mpctx, struct stream **stream, struct demuxer **demuxer, struct demuxer_params *params) { struct MPOpts *opts = mpctx->opts; if (opts->stream_cache_size <= 0) return 0; char *filename = talloc_strdup(NULL, (*demuxer)->filename); free_demuxer(*demuxer); free_stream(*stream); *stream = stream_open(filename, opts); if (!*stream) { talloc_free(filename); return -1; } stream_enable_cache_percent(stream, opts->stream_cache_size, opts->stream_cache_def_size, opts->stream_cache_min_percent, opts->stream_cache_seek_min_percent); *demuxer = demux_open(*stream, "mkv", params, opts); if (!*demuxer) { talloc_free(filename); free_stream(*stream); return -1; } talloc_free(filename); return 1; }
int EXPORT_CC libxrdp_send_bell(struct xrdp_session *session) { struct stream *s = (struct stream *)NULL; DEBUG(("libxrdp_send_bell sending bell signal")); /* see MS documentation: Server play sound PDU, TS_PLAY_SOUND_PDU_DATA */ make_stream(s); init_stream(s, 8192); if (xrdp_rdp_init_data((struct xrdp_rdp *)session->rdp, s) != 0) { free_stream(s); return 1; } out_uint32_le(s, 440); /* frequency */ out_uint32_le(s, 100); /* duration (ms) */ s_mark_end(s); if (xrdp_rdp_send_data((struct xrdp_rdp *)session->rdp, s, RDP_DATA_PDU_PLAY_SOUND) != 0) { free_stream(s); return 1; } free_stream(s); return 0; }
void APP_CC trans_delete(struct trans *self) { if (self == 0) { return; } free_stream(self->in_s); free_stream(self->out_s); if (self->sck > 0) { g_tcp_close(self->sck); } self->sck = 0; if (self->listen_filename != 0) { g_file_delete(self->listen_filename); g_free(self->listen_filename); } if (self->tls != 0) { ssl_tls_delete(self->tls); } g_free(self); }
int APP_CC xrdp_image_compress_rle(int width, int height, int bpp, unsigned char* data, char* dest) { struct stream *s; struct stream *tmp_s; int e; int i; int bufsize; make_stream(s); init_stream(s, IMAGE_TILE_MAX_BUFFER_SIZE); make_stream(tmp_s); init_stream(tmp_s, IMAGE_TILE_MAX_BUFFER_SIZE); e = width % 4; if (e != 0) e = 4 - e; i = height; xrdp_bitmap_compress(data, width, height, s, bpp, IMAGE_TILE_MAX_BUFFER_SIZE, i - 1, tmp_s, e); bufsize = (int) (s->p - s->data); g_memcpy(dest, s->data, bufsize); free_stream(tmp_s); free_stream(s); return bufsize; }
/* send a chunk of the file from server to client */ static int clipboard_send_file_data(int streamId, int lindex, int nPositionLow, int cbRequested) { struct stream *s; int size; int rv; int fd; char full_fn[256]; struct cb_file_info *cfi; if (g_files_list == 0) { LLOGLN(10, ("clipboard_send_file_data: error g_files_list is nil")); return 1; } cfi = (struct cb_file_info *)list_get_item(g_files_list, lindex); if (cfi == 0) { LLOGLN(10, ("clipboard_send_file_data: error cfi is nil")); return 1; } LLOGLN(10, ("clipboard_send_file_data: streamId %d lindex %d " "nPositionLow %d cbRequested %d", streamId, lindex, nPositionLow, cbRequested)); g_snprintf(full_fn, 255, "%s/%s", cfi->pathname, cfi->filename); fd = g_file_open_ex(full_fn, 1, 0, 0, 0); if (fd == -1) { LLOGLN(0, ("clipboard_send_file_data: file open [%s] failed", full_fn)); return 1; } g_file_seek(fd, nPositionLow); make_stream(s); init_stream(s, cbRequested + 64); size = g_file_read(fd, s->data + 12, cbRequested); if (size < 1) { LLOGLN(0, ("clipboard_send_file_data: read error, want %d got %d", cbRequested, size)); free_stream(s); g_file_close(fd); return 1; } out_uint16_le(s, CB_FILECONTENTS_RESPONSE); /* 9 */ out_uint16_le(s, CB_RESPONSE_OK); /* 1 status */ out_uint32_le(s, size + 4); out_uint32_le(s, streamId); s->p += size; out_uint32_le(s, 0); s_mark_end(s); size = (int)(s->end - s->data); rv = send_channel_data(g_cliprdr_chan_id, s->data, size); free_stream(s); g_file_close(fd); return rv; }
void APP_CC trans_delete(struct trans* self) { if (self == 0) { return; } free_stream(self->in_s); free_stream(self->out_s); g_tcp_close(self->sck); g_free(self); }
static int sound_send_training(void) { struct stream *s; int bytes; int time; char *size_ptr; print_got_here(); make_stream(s); init_stream(s, 8182); out_uint16_le(s, SNDC_TRAINING); size_ptr = s->p; out_uint16_le(s, 0); /* size, set later */ time = g_time2(); g_training_sent_time = time; out_uint16_le(s, time); out_uint16_le(s, 1024); out_uint8s(s, (1024 - 4)); s_mark_end(s); bytes = (int)((s->end - s->data) - 4); size_ptr[0] = bytes; size_ptr[1] = bytes >> 8; bytes = (int)(s->end - s->data); send_channel_data(g_rdpsnd_chan_id, s->data, bytes); free_stream(s); return 0; }
/* return error */ int DEFAULT_CC lib_mod_event(struct mod* mod, int msg, tbus param1, tbus param2, tbus param3, tbus param4) { struct stream* s; int len; int rv; LIB_DEBUG(mod, "in lib_mod_event"); make_stream(s); init_stream(s, 8192); s_push_layer(s, iso_hdr, 4); out_uint16_le(s, 103); out_uint32_le(s, msg); out_uint32_le(s, param1); out_uint32_le(s, param2); out_uint32_le(s, param3); out_uint32_le(s, param4); s_mark_end(s); len = (int)(s->end - s->data); s_pop_layer(s, iso_hdr); out_uint32_le(s, len); rv = lib_send(mod, s->data, len); free_stream(s); LIB_DEBUG(mod, "out lib_mod_event"); return rv; }
static void deferred_free_viewer_stream(struct rcu_head *head) { struct relay_viewer_stream *stream = caa_container_of(head, struct relay_viewer_stream, rcu_node); free_stream(stream); }
static void asx_parse_entryref(ASX_Parser_t* parser,char* buffer,char** _attribs) { char *href; stream_t* stream; if(parser->deep > 0) return; href = asx_get_attrib("HREF",_attribs); if(href == NULL) { asx_warning_attrib_required(parser,"ENTRYREF" ,"HREF" ); return; } stream=stream_open(href, NULL); if(!stream) { mp_msg(MSGT_PLAYTREE,MSGL_WARN,"Can't open playlist %s\n",href); free(href); return; } mp_msg(MSGT_PLAYTREE,MSGL_ERR,"Not recursively loading playlist %s\n",href); free_stream(stream); free(href); //mp_msg(MSGT_PLAYTREE,MSGL_INFO,"Need to implement entryref\n"); }
void cliprdr_send_data(int request_type) { struct stream* s; int clipboard_size = clipboard_get_current_clipboard_data_size(&clipboard, format_utf8_string_atom); char* clipboard_data = (char*)clipboard_get_current_clipboard_data(&clipboard, format_utf8_string_atom); int uni_clipboard_len = (clipboard_size+1)*2; int packet_len = uni_clipboard_len + 12; char* temp; make_stream(s); init_stream(s,packet_len); log_message(l_config, LOG_LEVEL_DEBUG, "vchannel_cliprdr[cliprdr_send_data]:"); /* clip header */ out_uint16_le(s, CB_FORMAT_DATA_RESPONSE); /* msg type */ out_uint16_le(s, 0); /* msg flag */ out_uint32_le(s, uni_clipboard_len); /* msg size */ temp = s->p; uni_rdp_out_str(s, clipboard_data, uni_clipboard_len); s_mark_end(s); cliprdr_send(s); free_stream(s); }
void cliprdr_send_capability() { /* this message is ignored by rdp applet */ struct stream* s; make_stream(s); init_stream(s,1024); log_message(l_config, LOG_LEVEL_DEBUG, "vchannel_cliprdr[cliprdr_send_capability]:"); /* clip header */ out_uint16_le(s, CB_CLIP_CAPS); /* msg type */ out_uint16_le(s, 0x00); /* msg flag */ out_uint32_le(s, 0); /* msg size */ /* we only support one capability for now */ out_uint16_le(s, 1); /* cCapabilitiesSets */ out_uint8s(s, 16); /* pad */ /* CLIPRDR_CAPS_SET */ out_uint16_le(s, CB_CAPSTYPE_GENERAL); /* capabilitySetType */ out_uint16_le(s, 92); /* lengthCapability */ out_uint32_le(s, CB_CAPS_VERSION_1); /* version */ out_uint32_le(s, 0); /* general flags */ s_mark_end(s); cliprdr_send(s); free_stream(s); }
// return value: // 0 = EOF or no stream found // 1 = successfully read a packet static int demux_mf_fill_buffer(demuxer_t *demuxer) { mf_t *mf = demuxer->priv; if (mf->curr_frame >= mf->nr_of_files) return 0; struct stream *entry_stream = NULL; if (mf->streams) entry_stream = mf->streams[mf->curr_frame]; struct stream *stream = entry_stream; if (!stream) { char *filename = mf->names[mf->curr_frame]; if (filename) stream = stream_open(filename, demuxer->opts); } if (stream) { stream_seek(stream, 0); bstr data = stream_read_complete(stream, NULL, MF_MAX_FILE_SIZE); if (data.len) { demux_packet_t *dp = new_demux_packet(data.len); memcpy(dp->buffer, data.start, data.len); dp->pts = mf->curr_frame / mf->sh->fps; dp->keyframe = true; demuxer_add_packet(demuxer, demuxer->streams[0], dp); } talloc_free(data.start); } if (stream && stream != entry_stream) free_stream(stream); mf->curr_frame++; return 1; }
bool APP_CC xrdp_emt_send_result(struct xrdp_rdp* self, struct xrdp_emt* emt) { struct stream* s; if (emt == NULL) { printf("emt is null\n"); return false; } make_stream(s); init_stream(s, 40); xrdp_sec_init(self->sec_layer, s); out_uint8(s, SEC_AUTODETECT_REQ_LENGTH); // headerLength out_uint8(s, TYPE_ID_AUTODETECT_REQUEST); // headerTypeId out_uint16_le(s, emt->seq_number++); // sequenceNumber out_uint16_le(s, field_all); // responseType out_uint32_le(s, self->session->base_RTT); out_uint32_le(s, self->session->bandwidth); out_uint32_le(s, self->session->average_RTT); s_mark_end(s); xrdp_emt_send_packet(self, emt, s); free_stream(s); return true; }
static bool try_open(struct MPContext *mpctx, char *filename) { struct bstr bfilename = bstr0(filename); // Avoid trying to open itself or another .cue file. Best would be // to check the result of demuxer auto-detection, but the demuxer // API doesn't allow this without opening a full demuxer. if (bstr_case_endswith(bfilename, bstr0(".cue")) || bstrcasecmp(bstr0(mpctx->demuxer->filename), bfilename) == 0) return false; struct stream *s = stream_open(filename, mpctx->opts); if (!s) return false; struct demuxer *d = demux_open(s, NULL, NULL, mpctx->opts); // Since .bin files are raw PCM data with no headers, we have to explicitly // open them. Also, try to avoid to open files that are most likely not .bin // files, as that would only play noise. Checking the file extension is // fragile, but it's about the only way we have. // TODO: maybe also could check if the .bin file is a multiple of the Audio // CD sector size (2352 bytes) if (!d && bstr_case_endswith(bfilename, bstr0(".bin"))) { mp_msg(MSGT_CPLAYER, MSGL_WARN, "CUE: Opening as BIN file!\n"); d = demux_open(s, "rawaudio", NULL, mpctx->opts); } if (d) { add_source(mpctx, d); return true; } mp_msg(MSGT_CPLAYER, MSGL_ERR, "Could not open source '%s'!\n", filename); free_stream(s); return false; }
int RarSeek(rar_file_t *file, uint64_t position) { if (position > file->real_size) position = file->real_size; /* Search the chunk */ const rar_file_chunk_t *old_chunk = file->current_chunk; for (int i = 0; i < file->chunk_count; i++) { file->current_chunk = file->chunk[i]; if (position < file->current_chunk->cummulated_size + file->current_chunk->size) break; } file->i_pos = position; const uint64_t offset = file->current_chunk->offset + (position - file->current_chunk->cummulated_size); if (strcmp(old_chunk->mrl, file->current_chunk->mrl)) { if (file->s) free_stream(file->s); file->s = stream_create(file->current_chunk->mrl, STREAM_READ | STREAM_NO_FILTERS, file->cancel, file->global); } return file->s ? stream_seek(file->s, offset) : 0; }
static int open_file(struct demuxer *demuxer, enum demux_check check) { bool force = check < DEMUX_CHECK_UNSAFE || check == DEMUX_CHECK_REQUEST; struct pl_parser *p = talloc_zero(NULL, struct pl_parser); p->pl = talloc_zero(p, struct playlist); bstr probe_buf = stream_peek(demuxer->stream, PROBE_SIZE); p->s = open_memory_stream(probe_buf.start, probe_buf.len); p->utf16 = stream_skip_bom(p->s); p->probing = true; const struct pl_format *fmt = probe_pl(p, force); free_stream(p->s); playlist_clear(p->pl); if (!fmt) { talloc_free(p); return -1; } p->probing = false; p->s = demuxer->stream; p->utf16 = stream_skip_bom(p->s); bool ok = fmt->parse(p) >= 0; if (ok) playlist_add_base_path(p->pl, mp_dirname(demuxer->filename)); demuxer->playlist = talloc_steal(demuxer, p->pl); demuxer->filetype = fmt->name; talloc_free(p); return ok ? 0 : -1; }
ASS_Track *mp_ass_read_stream(ASS_Library *library, const char *fname, char *charset) { ASS_Track *track; struct stream *s = open_stream(fname, NULL, NULL); if (!s) // Stream code should have printed an error already return NULL; struct bstr content = stream_read_complete(s, NULL, 100000000, 1); if (content.start == NULL) mp_tmsg(MSGT_ASS, MSGL_ERR, "Refusing to load subtitle file " "larger than 100 MB: %s\n", fname); free_stream(s); if (content.len == 0) { talloc_free(content.start); return NULL; } content.start[content.len] = 0; track = ass_read_memory(library, content.start, content.len, charset); if (track) { free(track->name); track->name = strdup(fname); } talloc_free(content.start); return track; }
int free_stream(struct Stream_t **Stream) { if(!*Stream) return -1; int ret = 0; if(! --(*Stream)->refs) { if((*Stream)->Class->flush) ret |= (*Stream)->Class->flush(*Stream); if((*Stream)->Class->freeFunc) ret |= (*Stream)->Class->freeFunc(*Stream); if((*Stream)->Next) ret |= free_stream(&(*Stream)->Next); free(*Stream); } else if ((*Stream)->Next) ret |= flush_stream((*Stream)->Next); *Stream = NULL; return ret; }
/* ask the client to send the file size */ int clipboard_request_file_size(int stream_id, int lindex) { struct stream *s; int size; int rv; log_debug("clipboard_request_file_size:"); if (g_file_request_sent_type != 0) { log_error("clipboard_request_file_size: warning, still waiting " "for CB_FILECONTENTS_RESPONSE"); } make_stream(s); init_stream(s, 8192); out_uint16_le(s, CB_FILECONTENTS_REQUEST); /* 8 */ out_uint16_le(s, 0); out_uint32_le(s, 28); out_uint32_le(s, stream_id); out_uint32_le(s, lindex); out_uint32_le(s, CB_FILECONTENTS_SIZE); out_uint32_le(s, 0); /* nPositionLow */ out_uint32_le(s, 0); /* nPositionHigh */ out_uint32_le(s, 0); /* cbRequested */ out_uint32_le(s, 0); /* clipDataId */ out_uint32_le(s, 0); s_mark_end(s); size = (int)(s->end - s->data); rv = send_channel_data(g_cliprdr_chan_id, s->data, size); free_stream(s); g_file_request_sent_type = CB_FILECONTENTS_SIZE; return rv; }
/* return error */ static int APP_CC send_paint_rect_ack(struct mod *mod, int flags, int x, int y, int cx, int cy, int frame_id) { int len; struct stream *s; make_stream(s); init_stream(s, 8192); s_push_layer(s, iso_hdr, 4); out_uint16_le(s, 105); out_uint32_le(s, flags); out_uint32_le(s, frame_id); out_uint32_le(s, x); out_uint32_le(s, y); out_uint32_le(s, cx); out_uint32_le(s, cy); s_mark_end(s); len = (int)(s->end - s->data); s_pop_layer(s, iso_hdr); out_uint32_le(s, len); lib_send(mod, s->data, len); free_stream(s); return 0; }
static demuxer_t* demux_open_hack_avi(demuxer_t *demuxer) { sh_audio_t* sh_a; demuxer = demux_open_avi(demuxer); if(!demuxer) return NULL; // failed to open sh_a = demuxer->audio->sh; /*demux_avi no do parsing in for audio, then here will tell decodec to do paring before decodeced data*/ if(sh_a) sh_a->need_parsing = 1; //add by gysun if(demuxer->audio->id != -2 && sh_a) { #ifdef CONFIG_OGGVORBIS // support for Ogg-in-AVI: if(sh_a->format == 0xFFFE) demuxer = init_avi_with_ogg(demuxer); else if(sh_a->format == 0x674F) { stream_t* s; demuxer_t *od; s = new_ds_stream(demuxer->audio); od = new_demuxer(s,DEMUXER_TYPE_OGG,-1,-2,-2,NULL); if(!demux_ogg_open(od)) { mp_msg( MSGT_DEMUXER,MSGL_ERR,MSGTR_ErrorOpeningOGGDemuxer); free_stream(s); demuxer->audio->id = -2; } else demuxer = new_demuxers_demuxer(demuxer,od,demuxer); } #endif } return demuxer; }
bool APP_CC xrdp_emt_send_request(struct xrdp_rdp* self, struct xrdp_emt* emt, int type) { struct stream* s; if (emt == NULL) { printf("emt is null\n"); return false; } make_stream(s); init_stream(s, 40); xrdp_sec_init(self->sec_layer, s); out_uint8(s, SEC_AUTODETECT_REQ_LENGTH); // headerLength out_uint8(s, TYPE_ID_AUTODETECT_REQUEST); // headerTypeId out_uint16_le(s, emt->seq_number++); // sequenceNumber out_uint16_le(s, type); // responseType s_mark_end(s); xrdp_emt_send_packet(self, emt, s); free_stream(s); return true; }
static demuxer_t* demux_open_hack_avi(demuxer_t *demuxer) { struct MPOpts *opts = demuxer->opts; sh_audio_t* sh_a; demuxer = demux_open_avi(demuxer); if(!demuxer) return NULL; // failed to open sh_a = demuxer->audio->sh; if(demuxer->audio->id != -2 && sh_a) { #ifdef CONFIG_OGGVORBIS // support for Ogg-in-AVI: if(sh_a->format == 0xFFFE) demuxer = init_avi_with_ogg(demuxer); else if(sh_a->format == 0x674F) { stream_t* s; demuxer_t *od; s = new_ds_stream(demuxer->audio); od = new_demuxer(opts, s,DEMUXER_TYPE_OGG,-1,-2,-2,NULL); if(!demux_ogg_open(od)) { mp_tmsg( MSGT_DEMUXER,MSGL_ERR,"Unable to open the Ogg demuxer.\n"); free_stream(s); demuxer->audio->id = -2; } else demuxer = new_demuxers_demuxer(demuxer,od,demuxer); } #endif } return demuxer; }
/* returns error */ int APP_CC rdp_iso_connect(struct rdp_iso *self, char *ip, char *port) { int code; struct stream *s; DEBUG((" in rdp_iso_connect")); make_stream(s); init_stream(s, 8192); if (rdp_tcp_connect(self->tcp_layer, ip, port) != 0) { free_stream(s); DEBUG((" out rdp_iso_connect error rdp_tcp_connect failed")); return 1; } if (rdp_iso_send_msg(self, s, ISO_PDU_CR) != 0) { free_stream(s); rdp_tcp_disconnect(self->tcp_layer); DEBUG((" out rdp_iso_connect error rdp_iso_send_msg failed")); return 1; } init_stream(s, 8192); if (rdp_iso_recv_msg(self, s, &code) != 0) { free_stream(s); rdp_tcp_disconnect(self->tcp_layer); DEBUG((" out rdp_iso_connect error rdp_iso_recv_msg failed")); return 1; } if (code != ISO_PDU_CC) { free_stream(s); rdp_tcp_disconnect(self->tcp_layer); DEBUG((" out rdp_iso_connect error code != ISO_PDU_CC")); return 1; } free_stream(s); DEBUG((" out rdp_iso_connect")); return 0; }
static int APP_CC sound_send_server_formats(void) { struct stream *s; int bytes; char *size_ptr; print_got_here(); make_stream(s); init_stream(s, 8182); out_uint16_le(s, SNDC_FORMATS); size_ptr = s->p; out_uint16_le(s, 0); /* size, set later */ out_uint32_le(s, 0); /* dwFlags */ out_uint32_le(s, 0); /* dwVolume */ out_uint32_le(s, 0); /* dwPitch */ out_uint16_le(s, 0); /* wDGramPort */ out_uint16_le(s, 1); /* wNumberOfFormats */ out_uint8(s, g_cBlockNo); /* cLastBlockConfirmed */ out_uint16_le(s, 2); /* wVersion */ out_uint8(s, 0); /* bPad */ /* sndFormats */ /* wFormatTag 2 byte offset 0 nChannels 2 byte offset 2 nSamplesPerSec 4 byte offset 4 nAvgBytesPerSec 4 byte offset 8 nBlockAlign 2 byte offset 12 wBitsPerSample 2 byte offset 14 cbSize 2 byte offset 16 data variable offset 18 */ /* examples 01 00 02 00 44 ac 00 00 10 b1 02 00 04 00 10 00 ....D........... 00 00 01 00 02 00 22 56 00 00 88 58 01 00 04 00 10 00 ...."V...X...... 00 00 */ out_uint16_le(s, 1); // wFormatTag - WAVE_FORMAT_PCM out_uint16_le(s, 2); // num of channels out_uint32_le(s, 44100); // samples per sec out_uint32_le(s, 176400); // avg bytes per sec out_uint16_le(s, 4); // block align out_uint16_le(s, 16); // bits per sample out_uint16_le(s, 0); // size s_mark_end(s); bytes = (int)((s->end - s->data) - 4); size_ptr[0] = bytes; size_ptr[1] = bytes >> 8; bytes = (int)(s->end - s->data); send_channel_data(g_rdpsnd_chan_id, s->data, bytes); free_stream(s); return 0; }