int rfx_rlgr_encode(RLGR_MODE mode, const INT16* data, int data_size, BYTE* buffer, int buffer_size) { int k; int kp; int krp; RFX_BITSTREAM* bs; int processed_size; bs = (RFX_BITSTREAM*) malloc(sizeof(RFX_BITSTREAM)); ZeroMemory(bs, sizeof(RFX_BITSTREAM)); rfx_bitstream_attach(bs, buffer, buffer_size); /* initialize the parameters */ k = 1; kp = 1 << LSGR; krp = 1 << LSGR; /* process all the input coefficients */ while (data_size > 0) { int input; if (k) { int numZeros; int runmax; int mag; int sign; /* RUN-LENGTH MODE */ /* collect the run of zeros in the input stream */ numZeros = 0; GetNextInput(input); while (input == 0 && data_size > 0) { numZeros++; GetNextInput(input); } // emit output zeros runmax = 1 << k; while (numZeros >= runmax) { OutputBit(1, 0); /* output a zero bit */ numZeros -= runmax; UpdateParam(kp, UP_GR, k); /* update kp, k */ runmax = 1 << k; } /* output a 1 to terminate runs */ OutputBit(1, 1); /* output the remaining run length using k bits */ OutputBits(k, numZeros); /* note: when we reach here and the last byte being encoded is 0, we still need to output the last two bits, otherwise mstsc will crash */ /* encode the nonzero value using GR coding */ mag = (input < 0 ? -input : input); /* absolute value of input coefficient */ sign = (input < 0 ? 1 : 0); /* sign of input coefficient */ OutputBit(1, sign); /* output the sign bit */ CodeGR(&krp, mag ? mag - 1 : 0); /* output GR code for (mag - 1) */ UpdateParam(kp, -DN_GR, k); } else { /* GOLOMB-RICE MODE */ if (mode == RLGR1) { UINT32 twoMs; /* RLGR1 variant */ /* convert input to (2*magnitude - sign), encode using GR code */ GetNextInput(input); twoMs = Get2MagSign(input); CodeGR(&krp, twoMs); /* update k, kp */ /* NOTE: as of Aug 2011, the algorithm is still wrongly documented and the update direction is reversed */ if (twoMs) { UpdateParam(kp, -DQ_GR, k); } else { UpdateParam(kp, UQ_GR, k); } } else /* mode == RLGR3 */ { UINT32 twoMs1; UINT32 twoMs2; UINT32 sum2Ms; UINT32 nIdx; /* RLGR3 variant */ /* convert the next two input values to (2*magnitude - sign) and */ /* encode their sum using GR code */ GetNextInput(input); twoMs1 = Get2MagSign(input); GetNextInput(input); twoMs2 = Get2MagSign(input); sum2Ms = twoMs1 + twoMs2; CodeGR(&krp, sum2Ms); /* encode binary representation of the first input (twoMs1). */ GetMinBits(sum2Ms, nIdx); OutputBits(nIdx, twoMs1); /* update k,kp for the two input values */ if (twoMs1 && twoMs2) { UpdateParam(kp, -2 * DQ_GR, k); } else if (!twoMs1 && !twoMs2) { UpdateParam(kp, 2 * UQ_GR, k); } } } } processed_size = rfx_bitstream_get_processed_bytes(bs); free(bs); return processed_size; }
extern void ParseMicrosoft( void ) /********************************/ // read in Microsoft linker commands { char cmd[LINE_BUF_SIZE]; char *end; size_t len; bool first; bool more_objs; bool more_libs; /* Start with object files. */ mask_spc_chr = 0x1f; /* Replace spaces with another character. */ more_cmdline = !!*CmdFile->current; first = more_cmdline; is_new_line = true; do { more_objs = false; /* No more unless we discover otherwise. */ if( first ) len = GetLine( cmd, sizeof( cmd ), OPTION_SLOT ); else len = GetLine( cmd, sizeof( cmd ), OBJECT_SLOT ); if( !len ) break; end = LastStringChar( cmd ); if( *end == mask_spc_chr ) { more_objs = true; *end = '\0'; } TokenizeLine( cmd, mask_spc_chr, DoOneObject ); first = false; } while( more_objs ); /* Check for possible error conditions. */ if( OverlayLevel ) Error( "unmatched left parenthesis" ); FindObjectName(); /* This will report an error if no objects. */ mask_spc_chr = 0; /* Remove spaces in input. */ /* Get executable and map file name. */ GetNextInput( cmd, sizeof( cmd ), RUN_SLOT ); GetNextInput( cmd, sizeof( cmd ), MAP_SLOT ); mask_spc_chr = 0x1f; /* Replace spaces with another character. */ /* Get library file names. */ if( !is_term ) { do { GetLine( cmd, sizeof( cmd ), LIBRARY_SLOT ); more_libs = false; if( is_term || *cmd == '\0' ) break; end = LastStringChar( cmd ); if( *end == mask_spc_chr ) { more_libs = true; *end = '\0'; } TokenizeLine( cmd, mask_spc_chr, DoOneLib ); } while( more_libs ); } mask_spc_chr = 0; /* Remove spaces in input again. */ /* Get def file name and process it. */ GetNextInput( cmd, sizeof( cmd ), DEF_SLOT ); ProcessDefFile(); }
int rfx_rlgr1_encode(const sint16* data, int data_size, uint8* buffer, int buffer_size) { int k; int kp; int krp; int input; int numZeros; int runmax; int mag; int sign; int processed_size; int lmag; RFX_BITSTREAM bs; uint32 twoMs; rfx_bitstream_attach(bs, buffer, buffer_size); /* initialize the parameters */ k = 1; kp = 1 << LSGR; krp = 1 << LSGR; /* process all the input coefficients */ while (data_size > 0) { if (k) { /* RUN-LENGTH MODE */ /* collect the run of zeros in the input stream */ numZeros = 0; GetNextInput(input); while (input == 0 && data_size > 0) { numZeros++; GetNextInput(input); } /* emit output zeros */ runmax = 1 << k; while (numZeros >= runmax) { OutputBit(1, 0); /* output a zero bit */ numZeros -= runmax; UpdateParam(kp, UP_GR, k); /* update kp, k */ runmax = 1 << k; } /* output a 1 to terminate runs */ OutputBit(1, 1); /* output the remaining run length using k bits */ OutputBits(k, numZeros); /* note: when we reach here and the last byte being encoded is 0, we still need to output the last two bits, otherwise mstsc will crash */ /* encode the nonzero value using GR coding */ mag = (input < 0 ? -input : input); /* absolute value of input coefficient */ sign = (input < 0 ? 1 : 0); /* sign of input coefficient */ OutputBit(1, sign); /* output the sign bit */ lmag = mag ? mag - 1 : 0; CodeGR(krp, lmag); /* output GR code for (mag - 1) */ UpdateParam(kp, -DN_GR, k); } else { /* GOLOMB-RICE MODE */ /* RLGR1 variant */ /* convert input to (2*magnitude - sign), encode using GR code */ GetNextInput(input); twoMs = Get2MagSign(input); CodeGR(krp, twoMs); /* update k, kp */ /* NOTE: as of Aug 2011, the algorithm is still wrongly documented and the update direction is reversed */ if (twoMs) { UpdateParam(kp, -DQ_GR, k); } else { UpdateParam(kp, UQ_GR, k); } } } processed_size = rfx_bitstream_get_processed_bytes(bs); return processed_size; }
status_t BBufferConsumer::HandleMessage(int32 message, const void* data, size_t size) { PRINT(4, "BBufferConsumer::HandleMessage %#lx, node %ld\n", message, ID()); status_t rv; switch (message) { case CONSUMER_ACCEPT_FORMAT: { const consumer_accept_format_request* request = static_cast<const consumer_accept_format_request*>(data); consumer_accept_format_reply reply; reply.format = request->format; status_t status = AcceptFormat(request->dest, &reply.format); request->SendReply(status, &reply, sizeof(reply)); return B_OK; } case CONSUMER_GET_NEXT_INPUT: { const consumer_get_next_input_request *request = static_cast<const consumer_get_next_input_request *>(data); consumer_get_next_input_reply reply; reply.cookie = request->cookie; rv = GetNextInput(&reply.cookie, &reply.input); request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case CONSUMER_DISPOSE_INPUT_COOKIE: { const consumer_dispose_input_cookie_request *request = static_cast<const consumer_dispose_input_cookie_request *>(data); consumer_dispose_input_cookie_reply reply; DisposeInputCookie(request->cookie); request->SendReply(B_OK, &reply, sizeof(reply)); return B_OK; } case CONSUMER_BUFFER_RECEIVED: { const consumer_buffer_received_command* command = static_cast<const consumer_buffer_received_command*>(data); BBuffer* buffer = fBufferCache->GetBuffer(command->buffer); if (buffer == NULL) { ERROR("BBufferConsumer::CONSUMER_BUFFER_RECEIVED can't" "find the buffer\n"); } else { buffer->SetHeader(&command->header); PRINT(4, "calling BBufferConsumer::BufferReceived buffer %ld " "at perf %Ld and TimeSource()->Now() is %Ld\n", buffer->Header()->buffer, buffer->Header()->start_time, TimeSource()->Now()); BufferReceived(buffer); } return B_OK; } case CONSUMER_PRODUCER_DATA_STATUS: { const consumer_producer_data_status_command *command = static_cast<const consumer_producer_data_status_command *>(data); ProducerDataStatus(command->for_whom, command->status, command->at_performance_time); return B_OK; } case CONSUMER_GET_LATENCY_FOR: { const consumer_get_latency_for_request *request = static_cast<const consumer_get_latency_for_request *>(data); consumer_get_latency_for_reply reply; rv = GetLatencyFor(request->for_whom, &reply.latency, &reply.timesource); request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case CONSUMER_CONNECTED: { const consumer_connected_request *request = static_cast<const consumer_connected_request *>(data); consumer_connected_reply reply; reply.input = request->input; rv = Connected(request->input.source, request->input.destination, request->input.format, &reply.input); request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } case CONSUMER_DISCONNECTED: { const consumer_disconnected_request *request = static_cast<const consumer_disconnected_request *>(data); consumer_disconnected_reply reply; Disconnected(request->source, request->destination); request->SendReply(B_OK, &reply, sizeof(reply)); return B_OK; } case CONSUMER_FORMAT_CHANGED: { const consumer_format_changed_request *request = static_cast<const consumer_format_changed_request *>(data); consumer_format_changed_reply reply; rv = FormatChanged(request->producer, request->consumer, request->change_tag, request->format); request->SendReply(rv, &reply, sizeof(reply)); // XXX is this RequestCompleted() correct? node_request_completed_command completedcommand; completedcommand.info.what = media_request_info::B_FORMAT_CHANGED; completedcommand.info.change_tag = request->change_tag; completedcommand.info.status = reply.result; //completedcommand.info.cookie completedcommand.info.user_data = 0; completedcommand.info.source = request->producer; completedcommand.info.destination = request->consumer; completedcommand.info.format = request->format; SendToPort(request->consumer.port, NODE_REQUEST_COMPLETED, &completedcommand, sizeof(completedcommand)); return B_OK; } case CONSUMER_SEEK_TAG_REQUESTED: { const consumer_seek_tag_requested_request *request = static_cast<const consumer_seek_tag_requested_request *>(data); consumer_seek_tag_requested_reply reply; rv = SeekTagRequested(request->destination, request->target_time, request->flags, &reply.seek_tag, &reply.tagged_time, &reply.flags); request->SendReply(rv, &reply, sizeof(reply)); return B_OK; } } return B_ERROR; }