extern "C" size_t __cdecl _fwrite_nolock(
void const* const buffer,
size_t const element_size,
size_t const element_count,
FILE* const public_stream
)
{
if (element_size == 0 || element_count == 0)
{
return 0;
}
__crt_stdio_stream const stream(public_stream);
_VALIDATE_RETURN(stream.valid(), EINVAL, 0);
_VALIDATE_RETURN(buffer != nullptr, EINVAL, 0);
_VALIDATE_RETURN(element_count <= (SIZE_MAX / element_size), EINVAL, 0);
// Figure out how big the buffer is; if the stream doesn't currently have a
// buffer, we assume that we'll get one with the usual internal buffer size:
unsigned stream_buffer_size = stream.has_any_buffer()
? stream->_bufsiz
: _INTERNAL_BUFSIZ;
// The total number of bytes to be written to the stream:
size_t const total_bytes = element_size * element_count;
char const* data = static_cast<char const*>(buffer);
// Write blocks of data from the buffer until there is no more data left:
size_t remaining_bytes = total_bytes;
while (remaining_bytes != 0)
{
// If the buffer is big and is not full, copy data into the buffer:
if (stream.has_big_buffer() && stream->_cnt != 0)
{
if (stream->_cnt < 0)
{
_ASSERTE(("Inconsistent Stream Count. Flush between consecutive read and write", stream->_cnt >= 0));
stream.set_flags(_IOERROR);
return (total_bytes - remaining_bytes) / element_size;
}
size_t const bytes_to_write = __min(remaining_bytes, static_cast<size_t>(stream->_cnt));
memcpy(stream->_ptr, data, bytes_to_write);
remaining_bytes -= bytes_to_write;
stream->_cnt -= static_cast<int>(bytes_to_write);
stream->_ptr += bytes_to_write;
data += bytes_to_write;
}
// If we have more than stream_buffer_size bytes to write, write data by
// calling _write() with an integral number of stream_buffer_size blocks.
else if (remaining_bytes >= stream_buffer_size)
{
// If we reach here and we have a big buffer, it must be full, so
// flush it. If the flush fails, there's nothing we can do to
// recover:
if (stream.has_big_buffer() && __acrt_stdio_flush_nolock(stream.public_stream()))
{
return (total_bytes - remaining_bytes) / element_size;
}
// Calculate the number of bytes to write. The _write API takes a
// 32-bit unsigned byte count, so clamp the value to UINT_MAX:
size_t const max_bytes_to_write = stream_buffer_size > 0
? remaining_bytes - remaining_bytes % stream_buffer_size
: remaining_bytes;
unsigned const bytes_to_write = static_cast<unsigned>(__min(max_bytes_to_write, UINT_MAX));
unsigned const bytes_actually_written = _write(_fileno(stream.public_stream()), data, bytes_to_write);
if (bytes_actually_written == static_cast<unsigned>(-1))
{
stream.set_flags(_IOERROR);
return (total_bytes - remaining_bytes) / element_size;
}
// VSWhidbey #326224: _write can return more bytes than we requested
// due to Unicode conversions in text files. We do not care how many
// bytes were written as long as the number is as least as large as we
// requested:
unsigned const bytes_written = bytes_actually_written > bytes_to_write
? bytes_to_write
: bytes_actually_written;
// Update the remaining bytes and data to reflect the write:
remaining_bytes -= bytes_written;
data += bytes_written;
if (bytes_actually_written < bytes_to_write)
{
stream.set_flags(_IOERROR);
return (total_bytes - remaining_bytes) / element_size;
}
}
// Otherwise, the stream does not have a buffer, or the buffer is full
// and there are not enough characters to do a direct write, so use
// __acrt_stdio_flush_and_write_narrow_nolock:
else
{
// Write the first character. If this fails, there is nothing we can
// do. (Note that if this fails, it will update the stream error state.)
if (__acrt_stdio_flush_and_write_narrow_nolock(*data, stream.public_stream()) == EOF)
{
return (total_bytes - remaining_bytes) / element_size;
}
// Update the remaining bytes to account for the byte we just wrote:
++data;
--remaining_bytes;
stream_buffer_size = stream->_bufsiz > 0
? stream->_bufsiz
: 1;
}
}
return element_count; // Success!
}
ERRORCODE TextFlow::adjust_words(DB_RECORD_NUMBER p_record,
DB_RECORD_NUMBER f_record,
CHARACTER_DELTA cdelta, WORD_DELTA_PTR wdelta)
{
ParagraphPtr paragraph;
W_INDEX w_index;
TEXT_WORD_PTR wp;
ERRORCODE error;
/* Redisplay vars */
LINE_PTR lp;
FramePtr frame;
PCOORD erase_xmin, erase_xmax;
W_INDEX old_windex;
L_INDEX l_index;
BOOL deleted_something;
/*
// Initialize the word delta structure first.
*/
wdelta->w_start = -1;
wdelta->count = 0;
/* Make sure we avoid busy work. */
if (cdelta.count == 0)
{
return ERRORCODE_None;
}
/* Lock the paragraph so we can access it. */
if ((paragraph = (ParagraphPtr)database->get_record(p_record, &error, RECORD_TYPE_Paragraph)) == NULL)
{
return error;
}
/* Get the frame object. */
if ((frame = (FramePtr)database->get_record(f_record, &error, RECORD_TYPE_Frame)) == NULL)
{
paragraph->release();
return error;
}
/*
// Run through the word array and update all words which need it.
// We must be careful using a pointer into the word array data since any
// deletions can cause the array data to change locations.
*/
/* Initialize redisplay variables */
deleted_something = FALSE;
lp = NULL;
old_windex = 0;
l_index = frame->line_of_word(0, NULL);
lp = (LINE_PTR)frame->line.get_element(l_index);
for (wp = (TEXT_WORD_PTR)paragraph->word.get_element(0), w_index = 0;
w_index < paragraph->word.count();
old_windex++,
w_index++, wp++)
{
C_INDEX this_start;
if ((this_start = wp->c_start) >= cdelta.c_start)
{
/* This has moved. Move it now. */
/* If deleting, see if the array is still valid. */
if ((this_start += cdelta.count) <= cdelta.c_start)
{
this_start = cdelta.c_start;
if (!deleted_something)
{
deleted_something = TRUE;
erase_xmin = wp->x_offset + wp->draw_left;
erase_xmax = wp->x_offset + wp->draw_width;
}
/*
// Update the word delta.
// This makes the (valid) assumption that words which get
// deleted are all contiguous.
*/
if (wdelta->w_start == -1)
{
wdelta->w_start = w_index;
/* Start updating w1 (last word to erase) */
l_index = frame->line_of_word(w_index, NULL);
lp = (LINE_PTR)frame->line.get_element(l_index);
erase_xmax = __max(erase_xmax, wp->x_offset + wp->draw_width);
erase_xmin = __min(erase_xmin, wp->x_offset + wp->draw_left);
}
else
{
/* The previous word has vanished. Delete it now. */
if (old_windex > lp->w_end)
{
/* That's all the words for this line. Erase the words */
add_width_refresh_extent(frame, lp,
erase_xmin, erase_xmax, REFRESH_ERASE);
/* Start a new line */
erase_xmin = wp->x_offset + wp->draw_left;
erase_xmax = wp->x_offset + wp->draw_width;
lp++;
}
else
{
erase_xmax = __max(erase_xmax, wp->x_offset + wp->draw_width);
}
wdelta->count--;
/* Do the actual delete. */
paragraph->delete_word(--w_index);
paragraph->modified();
#ifdef DEBUG_AW
printf("Delete previous word (%d)\n", w_index);
#endif
/* Recompute 'wp' in case 'word.data' changed. */
wp = (TEXT_WORD_PTR)paragraph->word.get_element(w_index);
}
}
#ifdef DEBUG_AW
printf("Bumped WORD %d from index %d to %d (", w_index, wp->c_start, this_start);
#endif
/* Set the new start. */
wp->c_start = this_start;
#ifdef DEBUG_AW
dump_word(paragraph, wp);
printf(")\n");
#endif
}
else
{
/* Advance the erase anchor point */
erase_xmin = __min(erase_xmin, wp->x_offset + wp->draw_left);
}
}
if (deleted_something)
{
/* Found at least one line to delete. Delete the last line we found */
add_width_refresh_extent(frame, lp,
erase_xmin, erase_xmax, REFRESH_ERASE);
}
/* Release the objects we got. */
frame->release();
paragraph->release();
return ERRORCODE_None;
}
VOID TextFlow::position_lines(FramePtr frame, VERT_ALIGN_TYPE align_type)
{
PCOORD y_offset;
L_INDEX l_index;
LINE_PTR lp;
PBOX refresh_offsets;
PBOX bound = frame->get_bound();
PCOORD baseline;
/*
// Compute the height of all the lines so we can know how to align them.
*/
y_offset = 0;
baseline = 0;
SHORT line_count = frame->number_of_lines();
if (line_count == 0)
{
refresh_offsets.x0 = 0;
refresh_offsets.x1 = 0;
}
else
{
PCOORD xmin, xmax;
xmin = 0x7fffffff;
xmax = -xmin;
for (lp = frame->get_line(0), l_index = 0; l_index < line_count; lp++, l_index++)
{
xmin = __min(xmin, lp->refresh_xmin);
xmax = __max(xmax, lp->refresh_xmax);
if (l_index == 0)
{
baseline = y_offset + lp->ascend;
}
else
{
baseline = y_offset + lp->line_spacing - lp->descend;
}
y_offset = baseline + lp->descend;
}
refresh_offsets.x0 = xmin;
refresh_offsets.x1 = xmax;
}
/*
// Compute the offset value from the height of the text and the frame height.
*/
if ((y_offset = bound.y1 - bound.y0 - y_offset) > 0)
{
switch (align_type)
{
case ALIGN_top:
{
y_offset = 0;
break;
}
case ALIGN_middle:
{
y_offset /= 2;
break;
}
case ALIGN_bottom:
default:
{
break;
}
}
}
else
{
/* Text too big for frame. Top align it. */
y_offset = 0;
}
refresh_offsets.y0 = y_offset;
/*
// We have the amount to offset. Do the offset now.
*/
for (lp = frame->get_line(0), l_index = 0; l_index < line_count; lp++, l_index++)
{
if (l_index == 0)
{
y_offset += lp->ascend;
}
else
{
y_offset += lp->line_spacing - lp->descend;
}
if (y_offset != lp->baseline)
{
if (lp->baseline != -1)
{
add_line_refresh_extent(frame, lp);
}
lp->baseline = y_offset;
add_line_refresh_extent(frame, lp);
}
y_offset += lp->descend;
}
refresh_offsets.y1 = __min(y_offset, bound.y1 - bound.y0);
frame->set_refresh_offsets(refresh_offsets);
}
void gml_hdref( const gmltag * entry )
{
char * p;
char * pa;
char * pe;
char * idp;
char quote;
char c;
bool idseen;
bool pageseen;
bool withpage;
size_t len;
char buf64[64];
ref_entry * re;
static char undefid[] = "\"Undefined Heading\" on page XXX";
idseen = false;
pageseen = false;
withpage = false;
p = scan_start;
re = NULL;
/***********************************************************************/
/* Scan attributes for :HDREF */
/* id= */
/* page= */
/***********************************************************************/
for( ;; ) {
while( *p == ' ' ) {
p++;
}
if( *p == '\0' || *p == '.' ) {
break; // tag end found
}
if( !strnicmp( "page=", p, 5 ) ) {
p += 5;
while( *p == ' ' ) {
p++;
}
pa = p;
if( !strnicmp( "yes", p, 3 ) ) {
pageseen = true;
withpage = true;
p += 3;
} else {
if( !strnicmp( "no", p, 2 ) ) {
pageseen = true;
withpage = false;
p += 2;
} else {
g_err( err_inv_att_val );
file_mac_info();
err_count++;
while( *p && (*p != '.') && (*p != ' ') ) p++;
}
}
scan_start = p;
continue;
}
if( !strnicmp( "refid=", p, 6 ) ) {
p += 6;
while( *p == ' ' ) {
p++;
}
if( is_quote_char( *p ) ) {
quote = *p;
p++;
} else {
quote = '\0';
}
pa = p;
while( *p && is_id_char( *p ) ) {
p++;
}
len = __min( ID_LEN, p - pa );// restrict length as in ghx.c
if( len > 0 ) {
idseen = true; // valid id attribute found
pe = pa + len;
c = *pe;
*pe = '\0';
re = find_refid( ref_dict, strlwr( pa ) );
if( re != NULL ) { // id found in ref dict
idp = mem_alloc( 4 + strlen( re->text_cap ) );
*idp = '"'; // decorate with quotes
strcpy( idp + 1, re->text_cap );
strcat( idp, "\"" );
} else {
if( GlobalFlags.lastpass ) {
g_warn( wng_id_xxx, pa );
g_info( inf_id_unknown );
file_mac_info();
wng_count++;
}
}
*pe = c;
}
if( *p && (quote == *p) ) {
p++;
}
scan_start = p;
continue;
}
/*******************************************************************/
/* no more valid attributes */
/*******************************************************************/
break;
}
if( *p == '.' ) { // tag end ?
p++;
}
if( idseen ) { // id attribute was specified
bool concatsave = ProcFlags.concat;
ProcFlags.concat = true; // make process_text add to line
if( re == NULL ) { // undefined refid
process_text( undefid, g_curr_font_num );
} else {
process_text( idp, g_curr_font_num );
if( withpage || (!pageseen && (page != re->pageno)) ) {
sprintf_s( buf64, sizeof( buf64 ), "on page %d", re->pageno );
process_text( buf64, g_curr_font_num );
}
mem_free( idp );
}
ProcFlags.concat = concatsave;
} else {
g_err( err_att_missing ); // id attribute missing
file_mac_info();
err_count++;
}
scan_start = p;
return;
}
ERRORCODE TextFlow::rebuild_lines(FrameObjectPtr object, WORD_RANGE wrange)
{
ERRORCODE error;
DB_RECORD_NUMBER f_record = object->get_frame_record();
FramePtr frame;
DB_RECORD_NUMBER p_record;
ParagraphPtr paragraph;
W_INDEX w_index;
TEXT_WORD_PTR wp;
PCOORD line_top;
LINE_PTR lp;
L_INDEX l_index;
PCOORD frame_extent, frame_left, tab_size;
PCOORD baseline;
BOOL use_white_space;
FLAGS frame_flags;
frame_object = object;
/*
// Text is flowed by placing text words into lines within a frame.
// Words are flowed until the end is reached and then until words stop moving.
*/
if ((frame = (FramePtr)database->get_record(f_record, &error, RECORD_TYPE_Frame)) == NULL)
{
return error;
}
frame_flags = frame->get_flags();
/*
// See if we need to do any stretching.
*/
if (frame_flags & (FRAME_FLAG_stretch_frame | FRAME_FLAG_stretch_text))
{
if (frame_flags & FRAME_FLAG_stretch_frame)
{
SHORT error;
/* Stretch the frame before flowing. */
if ((error = object->stretch_frame()) != 0)
{
frame->release();
if (error > 0)
{
error = ERRORCODE_None;
}
return (ERRORCODE)error;
}
/* Frame did not change size. Flow normally. */
}
#if 0
else
#else
/* Always check (or check, too). */
if (frame_flags & FRAME_FLAG_stretch_text)
#endif
{
/* Stretch the text before flowing. */
if ((error = frame->stretch_text()) != ERRORCODE_None)
{
frame->release();
return error;
}
/* Flow all the text. */
wrange.w_start = wrange.w_end = -1;
}
}
p_record = frame->get_paragraph();
if ((paragraph = (ParagraphPtr)database->get_record(p_record, &error, RECORD_TYPE_Paragraph)) == NULL)
{
frame->release();
return error;
}
/*
// Ascertain the true start and end of the text flow request.
*/
SHORT word_count = paragraph->number_of_words();
if (wrange.w_start < 0)
{
wrange.w_start = 0;
}
if (wrange.w_end < 0)
{
wrange.w_end = word_count-1;
}
if (wrange.w_start > wrange.w_end || wrange.w_end >= word_count)
{
/* Error of a parameter nature. */
paragraph->release();
frame->release();
return ERRORCODE_BadParameter;
}
/*
// Find the line where the desired word starts.
// If the word hasn't been flowed yet, it may be "between" existing lines.
// If a word is not in a line, we'll shove it into the line just following it.
// This should always be possible, because the EOP word should always be
// flowed and in a line (and no word should come after it).
//
// We can do this really easily by just checking the last word in the line.
// If we are before that line, we have our line.
*/
SHORT line_count = frame->number_of_lines();
for (lp = frame->get_line(0), l_index = 0;
l_index < line_count;
l_index++, lp++)
{
/* MH 4/25/93 this was "if (lp->w_end >= wrange.w_start)" */
if (lp->w_end + 1 >= wrange.w_start)
{
break;
}
}
/*
// Adjust w_start to the start of the line or our word, whichever is first.
*/
if (wrange.w_start > lp->w_start)
{
wrange.w_start = lp->w_start;
}
#ifdef DEBUG_RL
printf("Flow words from %d to %d @ line %d\n", wrange.w_start, wrange.w_end, l_index);
#endif
/*
// Now, we have the line (l_index) and the first word to flow (w_start) into
// it. Let's do some flowin'!
*/
/* Compute the flowable extent and the size of a tab. */
TextStyleRef style = paragraph->get_style();
PBOX bound = frame->get_bound();
frame_left = style.get_left_margin();
frame_extent = bound.x1 - bound.x0
- (style.get_left_margin() + style.get_right_margin());
use_white_space = frame_flags & FRAME_FLAG_use_white_space;
if ((tab_size = frame_extent / 16) == 0)
{
tab_size = 1;
}
/* Compute the current top of line. */
baseline = lp->baseline;
line_top = baseline - lp->ascend;
#ifdef DEBUG_RL
printf("current baseline: %ld, ascend: %ld, line_top:%ld\n",
baseline, lp->ascend, line_top);
#endif
for (w_index = wrange.w_start, wp = paragraph->get_word(w_index);; )
{
PCOORD extent; /* Horizontal extent. */
PCOORD x_offset; /* Horizontal position. */
PCOORD solid_x_offset;
LINE old_line;
BOOL line_changed;
#ifdef DEBUG_RL
printf("(flow next line)\n");
#endif
/* Remember the old line so we can tell if it moved. */
old_line = *lp;
/* Start a new line. */
lp->w_start = w_index;
/* Initialize the horizontal extent. */
extent = frame_extent;
/* Plug in parameters for this line and update line_top. */
lp->ascend = lp->descend = lp->line_spacing = 0;
baseline = line_top;
/* Start us at the left margin. */
x_offset = 0;
solid_x_offset = 0;
/* Flow words into this line until done (possibly passing w_end). */
while (w_index < word_count)
{
FLAGS flags = wp->flags;
/* Calculate tab width if necessary. */
if (wp->type == WORD_TYPE_tab)
{
wp->width = ((x_offset + tab_size)/tab_size)*tab_size - x_offset;
}
/* See if this word will fit in the row. */
#ifdef DEBUG_RL
printf("flow word ");
dump_word(paragraph, wp);
printf("...");
#endif
if (flags & WORD_FLAG_override)
{
/* Something is overridden. */
wp->flags &= ~WORD_FLAG_override;
if (flags & WORD_FLAG_override_flow)
{
/*
// A flow word!
// Note that the flags have been cleared, so we won't keep
// hitting this.
*/
break;
}
}
else if (x_offset + wp->width > extent /* doesn't fit */
&& w_index != lp->w_start /* not first word */
&& !(wp->type == WORD_TYPE_space
&& ((wp-1)->type == WORD_TYPE_solid
|| (wp-1)->type == WORD_TYPE_macro))
&& wp->width != 0) /* real word */
{
#ifdef DEBUG_RL
printf(" Move word to next line\n");
#endif
break;
}
/* Update the horizontal offsets. */
x_offset += wp->width;
if (use_white_space
|| wp->type == WORD_TYPE_solid
|| wp->type == WORD_TYPE_macro)
{
solid_x_offset = x_offset;
}
if (wp->ascend > lp->ascend)
{
#ifdef DEBUG_RL
printf("Expand ascend from %ld to %ld\n", lp->ascend, wp->ascend);
#endif
baseline -= lp->ascend;
baseline += (lp->ascend = wp->ascend);
#ifdef DEBUG_RL
printf("Baseline moves to %ld\n", baseline);
#endif
}
if (wp->descend > lp->descend)
{
#ifdef DEBUG_RL
printf("Expand descend from %ld to %ld\n", lp->descend, wp->descend);
#endif
lp->descend = wp->descend;
}
if (wp->line_spacing > lp->line_spacing)
{
lp->line_spacing = wp->line_spacing;
}
/* Add this word to the line. */
lp->w_end = w_index++;
#ifdef DEBUG_RL
printf(" Add word to line (x:%ld, w:%ld).\n", x_offset-wp->width, wp->width);
#endif
/* If we just placed a break word, this line is done. */
if (wp++->type == WORD_TYPE_break)
{
/*
// If the previous word:
// (a) was a "macro" word,
// (b) started at the beginning of the line, and
// (c) had zero width,
// don't flow the break to the next line.
*/
BOOL fBreak = TRUE;
if (w_index >= 2 && x_offset == 0)
{
TEXT_WORD_PTR wprev = wp-2;
/* I make an assumption - x_offset == 0 --> width == 0. */
// if (wprev->width == 0)
{
if (*(paragraph->get_character(wprev->c_start)) >= MACRO_CHARACTER)
{
fBreak = FALSE;
}
}
}
if (fBreak)
{
#ifdef DEBUG_RL
printf("(Breaking on BREAK word)\n");
#endif
/* We need to break for this line. */
break;
}
}
}
#ifdef DEBUG_RL
printf("[ line %d base:%ld, asc:%ld, dsc:%ld, w: %d to %d ]\n",
l_index,
baseline, lp->ascend, lp->descend,
lp->w_start, lp->w_end);
#endif
/*
// We now know all the words in this line. Handle the placement.
*/
/* First calculate the alignment offset. */
if ((x_offset = extent - solid_x_offset) > 0)
{
/* Some space to distribute. */
switch (style.get_line_alignment())
{
case ALIGN_center:
{
x_offset /= 2;
break;
}
case ALIGN_left:
{
x_offset = 0;
break;
}
default:
{
break;
}
}
}
else
{
x_offset = 0;
}
/* Now set the positions of the words in this line. */
line_changed = FALSE; /* Cross your fingers. */
x_offset += style.get_left_margin();
{
W_INDEX w_index = lp->w_start, w_end = lp->w_end;
TEXT_WORD_PTR wp = paragraph->get_word(w_index);
/* Redisplay variables */
TEXT_WORD_PTR first_word_change = NULL;
TEXT_WORD_PTR last_word_change = NULL;
PCOORD erase_xmin, erase_xmax;
BOOL found_erase = FALSE;
lp->refresh_xmin = 0x7fffffff;
lp->refresh_xmax = -lp->refresh_xmin;
while (w_index <= w_end)
{
if (x_offset != wp->x_offset || (wp->flags & WORD_FLAG_changed_size))
{
/* A word moved. */
#ifdef DEBUG_RL
printf("word %d changed from %ld to %ld\n",
w_index, wp->x_offset, x_offset);
#endif
if (first_word_change == NULL)
{
first_word_change = wp;
}
if (!found_erase && wp->x_offset != -1 &&
w_index >= old_line.w_start && w_index <= old_line.w_end)
{
erase_xmin = wp->x_offset + wp->draw_left;
erase_xmax = wp->x_offset + wp->draw_width;
found_erase = TRUE;
}
last_word_change = wp;
if (wp->x_offset != -1 &&
w_index >= old_line.w_start && w_index <= old_line.w_end)
{
erase_xmin = __min(erase_xmin, wp->x_offset + wp->draw_left);
erase_xmax = __max(erase_xmax, wp->x_offset + wp->draw_width);
}
wp->x_offset = x_offset;
//remove this to do word-wise refresh; restore it to do full line refresh
// line_changed = TRUE;
}
wp->flags &= ~WORD_FLAG_changed_size;
lp->refresh_xmin = __min(lp->refresh_xmin, wp->x_offset + wp->draw_left);
lp->refresh_xmax = __max(lp->refresh_xmax, wp->x_offset + wp->draw_width);
x_offset += wp++->width;
w_index++;
}
if (first_word_change != NULL && old_line.baseline != -1)
{
/* Add a DRAW for every word that moved; erase moved words from
their old positions. */
add_words_refresh_extent(frame, &old_line,
first_word_change, last_word_change, REFRESH_DRAW);
if (found_erase)
{
add_width_refresh_extent(frame, &old_line,
erase_xmin, erase_xmax, REFRESH_ERASE);
}
}
}
/* See if the line changed. */
if (!line_changed)
{
/* Words stayed the same. See if the line is different somehow. */
/* Compare using the OLD_LINE structure. This allows us to ignore
the changes in refresh_xmin, refresh_xmax. */
line_changed = (memcmp(&old_line, lp, sizeof(OLD_LINE)) != 0);
if (line_changed)
{
lp->baseline = -1;
}
}
if (line_changed)
{
#ifdef DEBUG_RL
printf("Line %d changed\n", l_index);
printf("old [%d to %d] vs. new [%d to %d]\n",
old_line.w_start, old_line.w_end,
lp->w_start, lp->w_end);
#endif
if (old_line.baseline != -1)
{
add_line_refresh_extent(frame, &old_line);
}
}
else
{
#ifdef DEBUG_RL
printf("Line %d stayed the same\n", l_index);
#endif
/* We can end now! */
if (w_index > wrange.w_end)
{
break;
}
}
/* See if we're done. */
if (w_index >= word_count)
{
/* Run out of words. Finished. */
break;
}
/*
// Move to a new line.
// Add one if there are no more left.
*/
line_top = baseline + lp->descend;
if (++l_index == frame->number_of_lines())
{
/* Create a new dummy line. */
LINE line;
#ifdef DEBUG_RL
printf("(Create a new line)\n");
#endif
line.w_start = line.w_end = 0; /* In case. */
line.baseline = -1;
frame->insert_line(l_index, &line);
lp = frame->get_line(l_index);
}
else
{
/* Add a refresh extent for the old line in case it's changing. */
#ifdef DEBUG_RL
printf("(Move onto existing line)\n");
#endif
lp++;
}
}
#ifdef DEBUG_RL
printf("Done (final l_index:%d, w_index:%d)...\n", l_index, w_index);
#endif
/* If we flowed all words, delete any trailing lines. */
if (w_index == word_count)
{
if (++l_index < frame->number_of_lines())
{
while (l_index < frame->number_of_lines())
{
#ifdef DEBUG_RL
printf("{Delete line}");
#endif
add_line_refresh_extent(frame, frame->get_line(l_index));
frame->delete_line(l_index);
}
#ifdef DEBUG_RL
printf("\n");
#endif
}
}
if (frame_flags & FRAME_FLAG_ystretch_frame)
{
position_lines(frame, style.get_vertical_alignment());
object->ystretch_frame();
}
position_lines(frame, style.get_vertical_alignment());
/*
// Release our objects.
*/
paragraph->release(TRUE);
frame->release(TRUE);
return ERRORCODE_None;
}
//初始化函数
BOOL CGameFrameDlg::OnInitDialog()
{
__super::OnInitDialog();
//设置属性
ModifyStyle(WS_CAPTION|WS_BORDER,0,0);
//读取配置
m_bAllowSound=AfxGetApp()->GetProfileInt(TEXT("GameOption"),TEXT("EnableSound"),TRUE)?true:false;
//创建控制
m_pGameFrameControl=new CGameFrameControl(this);
if (m_pGameFrameControl==NULL) throw TEXT("游戏框架创建失败");
//创建组件
if (m_MessageProxyHelper.CreateInstance()==false) throw TEXT("信息组件创建失败");
m_MessageProxyHelper->SetRichEditHwnd(&m_pGameFrameControl->m_ChatMessage);
//设置界面
m_VorSplitter.SetSplitterSink(this);
//创建组件
if (m_UserFaceResHelper.CreateInstance()==false) throw TEXT("头像组件加载失败");
if (m_ClientKernelHelper.CreateInstance()==false) throw TEXT("游戏框架内核模块加载失败");
//创建游戏视图
CRect rcGameView(0,0,0,0);
m_pGameFrameControl->Create(IDD_FRAME_CONTROL,this);
if (m_pGameFrameControl->SetUserFaceRes(m_UserFaceResHelper.GetInterface())==false) throw TEXT("头像资源接口设置失败");
m_pGameFrameView->Create(NULL,NULL,WS_VISIBLE|WS_CHILD|WS_CLIPSIBLINGS|WS_CLIPCHILDREN,rcGameView,this,10);
if (m_pGameFrameView->SetUserFaceRes(m_UserFaceResHelper.GetInterface())==false) throw TEXT("头像资源接口设置失败");
CVideoServiceManager * pVideoServiceManager=CVideoServiceManager::GetInstance();
if (pVideoServiceManager!=NULL && pVideoServiceManager->SetUserFaceRes(m_UserFaceResHelper.GetInterface())==false) throw TEXT("头像资源接口设置失败");
//初始化内核
LPCTSTR lpszCmdLine=AfxGetApp()->m_lpCmdLine;
bool bSuccess=m_ClientKernelHelper->InitClientKernel(lpszCmdLine,m_pKernelSink);
if (bSuccess==false) throw TEXT("游戏框架逻辑模块初始化失败");
bSuccess=m_ClientKernelHelper->SetMessageProxy(m_MessageProxyHelper.GetInterface());
if (bSuccess==false) throw TEXT("获取消息输出模块失败");
//初始化游戏
m_pGameFrameControl->SetClientKernel(m_ClientKernelHelper.GetInterface());
if (InitGameFrame()==false) throw TEXT("游戏框架初始化失败");
//加载资源
UpdateSkinResource();
//移动窗口
INT nXScreen=GetSystemMetrics(SM_CXSCREEN);
INT nYScreen=GetSystemMetrics(SM_CYSCREEN);
SetWindowPos(NULL,0,0,__min(nXScreen,1024),__min(nYScreen,730),SWP_NOZORDER|SWP_NOMOVE);
//显示窗口
m_bInitDialog=true;
m_pGameFrameView->ShowWindow(SW_SHOW);
m_pGameFrameControl->ShowWindow(SW_SHOW);
//显示窗口
CenterWindow();
MaxSizeWindow();
ShowWindow(SW_SHOW);
return TRUE;
}
LoadStatus_t GdbLoader::Load(void)
{
m_cOrdinal = 0;
SetProgress(g_hExp, "Loading...", 0);
size_t cOffset = sizeof(g_pGdbSignature);
size_t cFileSize = (size_t)GetFileSize();
do {
const size_t cEndOffset_tmp = __min(cOffset + sizeof(CGdbRecordHdr), cFileSize);
const char * const pRecord_tmp = GetFilePart(cOffset, cEndOffset_tmp);
if (pRecord_tmp == NULL)
return lsFailed;
const CGdbRecordHdr * const pHdr_tmp = reinterpret_cast<const CGdbRecordHdr *>(pRecord_tmp);
size_t cNextOffset = __min(cOffset + sizeof(CGdbRecordHdr) + pHdr_tmp->dwLen, cFileSize);
const char * const pRecord = GetFilePart (cOffset, cNextOffset);
if (pRecord == NULL)
return lsFailed;
const CGdbRecordHdr * const pHdr = reinterpret_cast<const CGdbRecordHdr *>(pRecord);
switch (pHdr->btType) {
case 'D': { // GDB format version.
const CGdbFormatVersion * const pVer = static_cast<const CGdbFormatVersion *>(pHdr);
switch (pVer->wdVersion) {
case 0x6B:
case 0x6C:
case 0x6D:
// AddLog(g_hExp, "GDB Format version %d.", pVer->wdVersion - 0x6B + 1);
break;
default:
// ReportText ("Format version: 0x%02X.", pVer->wdVersion);
break;
}
m_b2ndVersion = pVer->wdVersion == 0x6C;
m_b3rdVersion = pVer->wdVersion == 0x6D;
if (pVer->wdVersion > 0x6D)
AddLog(g_hExp, "File was created with an untested version of MapSource.", NULL);
break;
}
case 'A': { // MapSource version.
const CGdbMSVersion * const pVer = static_cast<const CGdbMSVersion *> (pHdr);
const char * const pRecord = GetFilePart (cOffset, cNextOffset + 10);
if (pRecord == NULL)
return lsFailed;
if (::_strnicmp (pRecord + (cNextOffset - cOffset), "MapSource", 10) == 0)
cNextOffset += 10;
break;
}
case 'W': { // Waypoint.
const CGdbWaypointHdr * const pWP = static_cast<const CGdbWaypointHdr *> (pHdr);
ParseWaypoint (pWP, cOffset, cNextOffset);
break;
}
case 'T': { // Track.
const CGdbTrackHdr * const pTrack = static_cast<const CGdbTrackHdr *> (pHdr);
ParseTrack (pTrack, cOffset, cNextOffset, cFileSize, false);
break;
}
case 'R': { // Route.
const CGdbRouteHdr * const pRoute = static_cast<const CGdbRouteHdr *> (pHdr);
ParseRoute (pRoute, cOffset, cNextOffset);
break;
}
case 'L': { // Map reference.
const CGdbMapHdr * const pMap = static_cast<const CGdbMapHdr *> (pHdr);
break;
}
case 'V': { // Tail mark and map set info.
break;
}
}
cOffset = cNextOffset;
SetProgress(g_hExp, NULL, ::MulDiv(100, cOffset, cFileSize));
} while (cOffset < cFileSize);
return lsOK;
}
/**
* @brief This function learns the topics of words in a document and is the
* main step of a Gibbs sampling iteration. The word topic counts and
* corpus topic counts are passed to this function in the first call and
* then transfered to the rest calls through args.mSysInfo->user_fctx for
* efficiency.
* @param args[0] The unique words in the documents
* @param args[1] The counts of each unique words
* @param args[2] The topic counts and topic assignments in the document
* @param args[3] The model (word topic counts and corpus topic
* counts)
* @param args[4] The Dirichlet parameter for per-document topic
* multinomial, i.e. alpha
* @param args[5] The Dirichlet parameter for per-topic word
* multinomial, i.e. beta
* @param args[6] The size of vocabulary
* @param args[7] The number of topics
* @param args[8] The number of iterations (=1:training, >1:prediction)
* @return The updated topic counts and topic assignments for
* the document
**/
AnyType lda_gibbs_sample::run(AnyType & args)
{
ArrayHandle<int32_t> words = args[0].getAs<ArrayHandle<int32_t> >();
ArrayHandle<int32_t> counts = args[1].getAs<ArrayHandle<int32_t> >();
MutableArrayHandle<int32_t> doc_topic = args[2].getAs<MutableArrayHandle<int32_t> >();
double alpha = args[4].getAs<double>();
double beta = args[5].getAs<double>();
int32_t voc_size = args[6].getAs<int32_t>();
int32_t topic_num = args[7].getAs<int32_t>();
int32_t iter_num = args[8].getAs<int32_t>();
if(alpha <= 0)
throw std::invalid_argument("invalid argument - alpha");
if(beta <= 0)
throw std::invalid_argument("invalid argument - beta");
if(voc_size <= 0)
throw std::invalid_argument(
"invalid argument - voc_size");
if(topic_num <= 0)
throw std::invalid_argument(
"invalid argument - topic_num");
if(iter_num <= 0)
throw std::invalid_argument(
"invalid argument - iter_num");
if(words.size() != counts.size())
throw std::invalid_argument(
"dimensions mismatch: words.size() != counts.size()");
if(__min(words) < 0 || __max(words) >= voc_size)
throw std::invalid_argument(
"invalid values in words");
if(__min(counts) <= 0)
throw std::invalid_argument(
"invalid values in counts");
int32_t word_count = __sum(counts);
if(doc_topic.size() != (size_t)(word_count + topic_num))
throw std::invalid_argument(
"invalid dimension - doc_topic.size() != word_count + topic_num");
if(__min(doc_topic, 0, topic_num) < 0)
throw std::invalid_argument("invalid values in topic_count");
if(
__min(doc_topic, topic_num, word_count) < 0 ||
__max(doc_topic, topic_num, word_count) >= topic_num)
throw std::invalid_argument( "invalid values in topic_assignment");
if (!args.getUserFuncContext())
{
if(args[3].isNull())
throw std::invalid_argument("invalid argument - the model \
parameter should not be null for the first call");
ArrayHandle<int64_t> model = args[3].getAs<ArrayHandle<int64_t> >();
if(model.size() != (size_t)((voc_size + 1) * topic_num))
throw std::invalid_argument(
"invalid dimension - model.size() != (voc_size + 1) * topic_num");
if(__min(model) < 0)
throw std::invalid_argument("invalid topic counts in model");
int64_t * state =
static_cast<int64_t *>(
MemoryContextAllocZero(
args.getCacheMemoryContext(),
model.size() * sizeof(int64_t)));
memcpy(state, model.ptr(), model.size() * sizeof(int64_t));
args.setUserFuncContext(state);
}
int64_t * state = static_cast<int64_t *>(args.getUserFuncContext());
if(NULL == state){
throw std::runtime_error("args.mSysInfo->user_fctx is null");
}
int32_t unique_word_count = static_cast<int32_t>(words.size());
for(int32_t it = 0; it < iter_num; it++){
int32_t word_index = topic_num;
for(int32_t i = 0; i < unique_word_count; i++) {
int32_t wordid = words[i];
for(int32_t j = 0; j < counts[i]; j++){
int32_t topic = doc_topic[word_index];
int32_t retopic = __lda_gibbs_sample(
topic_num, topic, doc_topic.ptr(),
state + wordid * topic_num,
state + voc_size * topic_num, alpha, beta);
doc_topic[word_index] = retopic;
doc_topic[topic]--;
doc_topic[retopic]++;
if(iter_num == 1){
state[voc_size * topic_num + topic]--;
state[voc_size * topic_num + retopic]++;
state[wordid * topic_num + topic]--;
state[wordid * topic_num + retopic]++;
}
word_index++;
}
}
}
return doc_topic;
}
/**
* @brief This function is the sfunc for the aggregator computing the topic
* counts. It scans the topic assignments in a document and updates the word
* topic counts.
* @param args[0] The state variable, current topic counts
* @param args[1] The unique words in the document
* @param args[2] The counts of each unique word in the document
* @param args[3] The topic assignments in the document
* @param args[4] The size of vocabulary
* @param args[5] The number of topics
* @return The updated state
**/
AnyType lda_count_topic_sfunc::run(AnyType & args)
{
if(args[4].isNull() || args[5].isNull())
throw std::invalid_argument("null parameter - voc_size and/or \
topic_num is null");
if(args[1].isNull() || args[2].isNull() || args[3].isNull())
return args[0];
int32_t voc_size = args[4].getAs<int32_t>();
int32_t topic_num = args[5].getAs<int32_t>();
if(voc_size <= 0)
throw std::invalid_argument(
"invalid argument - voc_size");
if(topic_num <= 0)
throw std::invalid_argument(
"invalid argument - topic_num");
ArrayHandle<int32_t> words = args[1].getAs<ArrayHandle<int32_t> >();
ArrayHandle<int32_t> counts = args[2].getAs<ArrayHandle<int32_t> >();
ArrayHandle<int32_t> topic_assignment = args[3].getAs<ArrayHandle<int32_t> >();
if(words.size() != counts.size())
throw std::invalid_argument(
"dimensions mismatch - words.size() != counts.size()");
if(__min(words) < 0 || __max(words) >= voc_size)
throw std::invalid_argument(
"invalid values in words");
if(__min(counts) <= 0)
throw std::invalid_argument(
"invalid values in counts");
if(__min(topic_assignment) < 0 || __max(topic_assignment) >= topic_num)
throw std::invalid_argument("invalid values in topics");
if((size_t)__sum(counts) != topic_assignment.size())
throw std::invalid_argument(
"dimension mismatch - sum(counts) != topic_assignment.size()");
MutableArrayHandle<int64_t> state(NULL);
if(args[0].isNull()){
int dims[2] = {voc_size + 1, topic_num};
int lbs[2] = {1, 1};
state = madlib_construct_md_array(
NULL, NULL, 2, dims, lbs, INT8TI.oid, INT8TI.len, INT8TI.byval,
INT8TI.align);
} else {
state = args[0].getAs<MutableArrayHandle<int64_t> >();
}
int32_t unique_word_count = static_cast<int32_t>(words.size());
int32_t word_index = 0;
for(int32_t i = 0; i < unique_word_count; i++){
int32_t wordid = words[i];
for(int32_t j = 0; j < counts[i]; j++){
int32_t topic = topic_assignment[word_index];
state[wordid * topic_num + topic]++;
state[voc_size * topic_num + topic]++;
word_index++;
}
}
return state;
}
void PreprocessTransferFreenect(libusb_transfer* transfer, const int read)
{
fnusb_isoc_stream* xferstrm = (fnusb_isoc_stream*)transfer->user_data;
freenect_device* dev = xferstrm->parent->parent;
packet_stream* pktstrm = (transfer->endpoint == 0x81) ? &dev->video : &dev->depth;
// Kinect Camera Frame Packed Header:
struct pkt_hdr
{
uint8_t magic[2];
uint8_t pad;
uint8_t flag;
uint8_t unk1;
uint8_t seq;
uint8_t unk2;
uint8_t unk3;
uint32_t timestamp;
}; // 12 bytes
//packet sizes:
// first middle last
// Bayer 1920 1920 24
// IR 1920 1920 1180
// YUV422 1920 1920 36
// Depth 1760 1760 1144
const unsigned int pktlen = sizeof(pkt_hdr) + pktstrm->pkt_size;
const unsigned int pktend = sizeof(pkt_hdr) + pktstrm->last_pkt_size;
unsigned int remaining (read);
unsigned int leftover (transfer->length);
unsigned char* pktbuffer (transfer->buffer);
const int pkts (transfer->num_iso_packets);
for (int i=0; i<pkts; ++i)
{
const pkt_hdr& header (*(pkt_hdr*)pktbuffer);
libusb_iso_packet_descriptor& desc (transfer->iso_packet_desc[i]);
if ((header.magic[0] == 'R') && (header.magic[1] == 'B'))
{
switch(header.flag & 0x0F)
{
case 0x01 : // begin
case 0x02 : // middle
desc.actual_length = __min(remaining, pktlen);
break;
case 0x05 : // final
desc.actual_length = __min(remaining, pktend);
break;
default :
fprintf(stdout, "0x%02X\n", header.flag);
break;
}
}
else
{
desc.actual_length = 0;
}
remaining -= desc.actual_length;
pktbuffer += desc.length; // a.k.a: += 1920
leftover -= desc.length; // a.k.a: -= 1920
}
if (remaining > 0)
{
fprintf(stdout, "%d remaining out of %d\n", remaining, read);
if (remaining == read)
{
}
}
}
/*
* lock - handle lock requests return errno to reply to client w/
*/
static int _iofunc_lock_scoid(iofunc_lock_list_t **plist, int scoid, int type, off64_t start, off64_t end) {
iofunc_lock_list_t *cl, /* current list item */
*pl, /* previous list item */
*ol;
int ret;
ol = cl = pl = NULL;
/*
* Simple case, no existing locks, simply add new lock.
*/
if((cl = *plist) == NULL) {
return _iofunc_lock_add(plist, scoid, type, start, end);
}
/*
* Simple case, lock is before existing locks.
* Just insert at head of list (no possible overlap).
*/
if(end < cl->start) {
pl = *plist, *plist= NULL;
if ((ret = _iofunc_lock_add(plist, scoid, type, start, end)) != EOK) {
*plist = pl;
}
else {
(*plist)->next = pl;
}
return ret;
}
/*
* Scan thru remaining locklist to find location for new request.
*/
for(pl = NULL;cl != NULL; pl = cl, cl = cl->next) {
/*
* If lock is owned by same process and overlaps, stop scan.
* If more locks in range, skip to next.
* Otherwise stop scan.
*/
if(cl->scoid == scoid &&
OVERLAP(start, end, cl->start, cl->end)) {
break;
}
else if(cl->start > start) {
cl = pl;
break;
}
}
/*
* Request is at end of list, so we can add the lock here.
*/
if(cl == NULL){
return _iofunc_lock_add(&pl,scoid,type,start,end);
}
/*
* If we overlap & id's match
* -And the types match, create a superblock
* -And the types differ, split the block
* Otherwise add new entry
*/
if(cl->scoid == scoid && OVERLAP(start, end, cl->start, cl->end)) {
if(cl->type == type) {
cl->end = __max(cl->end, end);
cl->start = __min(cl->start, start);
return EOK;
}
else if (!(cl = locksplit(plist, cl, scoid, type, start, end))) {
return EINVAL;
}
//Otherwise go on an compact w/ cl
}
else {
if((ret = _iofunc_lock_add(&cl, scoid, type, start, end))) {
return ret;
}
cl = cl->next;
}
/*
This compaction is not required, though it might optimize things
slightly if we were to join blocks together. (Check boundary
conditions as well as overlap)
*/
#if 0
/*
* Remember the new lock region for later
*/
ol = cl;
/*
* End point set above may overlap later entries.
* If so delete or modify them to perform the compaction.
*/
while(nl = cl->next; cl && nl; cl = nl, nl = cl->next) {
/*
* If the new range overlaps the first part of the next lock,
* if its the same type,
* take its end point and delete the next lock
* else
* move the start point (unlocking anyone waiting).
* We should be done.
*/
if(cl->scoid == scoid) {
if(end <= nl->end) {
if(nl->type == type) {
ol->end = nl->end;
cl->next = nl->next;
_iofunc_lock_free(nl);
}
else {
nl->start = start;
if(nl->blocked) {
printf("TODO: Wakup people! \n");
//wakeup(nl);
}
}
return EOK;
}
else {
/*
* the next lock is fully included in the new range
* so it may be deleted
*/
cl->next = nl->next;
_iofunc_lock_free(nl);
}
}
else {
cl = nl;
}
}
#endif
return EOK;
}
void UPD765A::cmd_write_data()
{
switch(phase) {
case PHASE_IDLE:
shift_to_cmd(8);
break;
case PHASE_CMD:
get_sector_params();
REGISTER_PHASE_EVENT_NEW(PHASE_EXEC, get_usec_to_exec_phase());
break;
case PHASE_EXEC:
#ifdef SDL
if (force_ready && !disk[hdu & DRIVE_MASK]->inserted) {
REGISTER_PHASE_EVENT(PHASE_EXEC, 1000000);
break;
}
#endif // SDL
result = check_cond(true);
if(result & ST1_MA) {
REGISTER_PHASE_EVENT(PHASE_EXEC, 1000000); // retry
break;
}
if(!result) {
result = find_id();
}
if(result) {
shift_to_result7();
} else {
int length = 0x80 << (id[3] & 7);
if(!(id[3] & 7)) {
length = __min(dtl, 0x80);
memset(buffer + length, 0, 0x80 - length);
}
shift_to_write(length);
}
break;
case PHASE_WRITE:
write_data((command & 0x1f) == 9);
if(result) {
shift_to_result7();
break;
}
phase = PHASE_EXEC;
if(!id_incr()) {
REGISTER_PHASE_EVENT(PHASE_TIMER, 2000);
break;
}
REGISTER_PHASE_EVENT_NEW(PHASE_EXEC, get_usec_to_exec_phase());
break;
case PHASE_TIMER:
// result = ST0_AT | ST1_EN;
result = ST1_EN;
shift_to_result7();
break;
case PHASE_TC:
CANCEL_EVENT();
if(prevphase == PHASE_WRITE && bufptr != buffer) {
// terminate while transfer ?
memset(bufptr, 0, count);
write_data((command & 0x1f) == 9);
}
shift_to_result7();
break;
}
}
uint32 UPD765A::read_sector()
{
int drv = hdu & DRIVE_MASK;
int trk = fdc[drv].track;
int side = (hdu >> 2) & 1;
// get sector counts in the current track
if(!disk[drv]->make_track(trk, side)) {
#ifdef _FDC_DEBUG_LOG
emu->out_debug_log("FDC: TRACK NOT FOUND (TRK=%d SIDE=%d)\n", trk, side);
#endif
return ST0_AT | ST1_MA;
}
int secnum = disk[drv]->sector_num.sd;
if(!secnum) {
#ifdef _FDC_DEBUG_LOG
emu->out_debug_log("FDC: NO SECTORS IN TRACK (TRK=%d SIDE=%d)\n", trk, side);
#endif
return ST0_AT | ST1_MA;
}
int cy = -1;
for(int i = 0; i < secnum; i++) {
if(!disk[drv]->get_sector(trk, side, i)) {
continue;
}
cy = disk[drv]->id[0];
#if 0
if(disk[drv]->id[0] != id[0] || disk[drv]->id[1] != id[1] || disk[drv]->id[2] != id[2] /*|| disk[drv]->id[3] != id[3]*/) {
#else
if(disk[drv]->id[0] != id[0] || disk[drv]->id[1] != id[1] || disk[drv]->id[2] != id[2] || disk[drv]->id[3] != id[3]) {
#endif
continue;
}
// sector number is matched
if(disk[drv]->invalid_format) {
memset(buffer, disk[drv]->drive_mfm ? 0x4e : 0xff, sizeof(buffer));
memcpy(buffer, disk[drv]->sector, disk[drv]->sector_size.sd);
} else {
memcpy(buffer, disk[drv]->track + disk[drv]->data_position[i], disk[drv]->get_track_size() - disk[drv]->data_position[i]);
memcpy(buffer + disk[drv]->get_track_size() - disk[drv]->data_position[i], disk[drv]->track, disk[drv]->data_position[i]);
}
fdc[drv].next_trans_position = disk[drv]->data_position[i];
if(disk[drv]->crc_error) {
return ST0_AT | ST1_DE | ST2_DD;
}
if(disk[drv]->deleted) {
return ST2_CM;
}
return 0;
}
#ifdef _FDC_DEBUG_LOG
emu->out_debug_log("FDC: SECTOR NOT FOUND (TRK=%d SIDE=%d ID=%2x,%2x,%2x,%2x)\n", trk, side, id[0], id[1], id[2], id[3]);
#endif
if(cy != id[0] && cy != -1) {
if(cy == 0xff) {
return ST0_AT | ST1_ND | ST2_BC;
} else {
return ST0_AT | ST1_ND | ST2_NC;
}
}
return ST0_AT | ST1_ND;
}
uint32 UPD765A::write_sector(bool deleted)
{
int drv = hdu & DRIVE_MASK;
int trk = fdc[drv].track;
int side = (hdu >> 2) & 1;
if(disk[drv]->write_protected) {
return ST0_AT | ST1_NW;
}
// get sector counts in the current track
if(!disk[drv]->get_track(trk, side)) {
return ST0_AT | ST1_MA;
}
int secnum = disk[drv]->sector_num.sd;
if(!secnum) {
return ST0_AT | ST1_MA;
}
int cy = -1;
for(int i = 0; i < secnum; i++) {
if(!disk[drv]->get_sector(trk, side, i)) {
continue;
}
cy = disk[drv]->id[0];
if(disk[drv]->id[0] != id[0] || disk[drv]->id[1] != id[1] || disk[drv]->id[2] != id[2] /*|| disk[drv]->id[3] != id[3]*/) {
continue;
}
// sector number is matched
int size = 0x80 << (id[3] & 7);
memcpy(disk[drv]->sector, buffer, __min(size, disk[drv]->sector_size.sd));
disk[drv]->set_deleted(deleted);
return 0;
}
if(cy != id[0] && cy != -1) {
if(cy == 0xff) {
return ST0_AT | ST1_ND | ST2_BC;
} else {
return ST0_AT | ST1_ND | ST2_NC;
}
}
return ST0_AT | ST1_ND;
}
inline void operator()(T val) const
{
static const int precision = 6;
int zeroes = (val == 0.0f) ? 1 : -(int)floor(__min(0, log10(fabs(val))));
std::cout << std::showpoint << std::setprecision(precision - zeroes) << (val < 0.0f ? "" : " ") << val << ", ";
}
BOOL CommonCmdHandler (
IN void *pvCmdBuf, // Address of buffer contaiing command packet
IN size_t tCmdSize, // Size of command packet
OUT void *pvRspBuf, // Address of buffer for response packet
IN size_t tRspSize // Expected size of response packet
)
{
BOOL bSucceeded = FALSE; // Success indicator
DWORD dwCount; // Count returned by WriteFile()/ReadFile()
DWORD dwStatus; // Buffer for status codes
int iRetries; // Retry counter
// Obtain (thread) exclusive access to resources
switch( WaitForSingleObject( hMutex, INFINITE ) )
{
case WAIT_ABANDONED:
case WAIT_OBJECT_0:
break;
default:
return( FALSE );
}
// Attach to HECI driver if we aren't already
if( !bAttached && !AttachDriver() )
{
// Couldn't attach the driver...
dwStatus = GetLastError();
}
else
{
// Attached; now have info to verify max command/response size...
if( (tCmdSize > stProperties.minRxBufferSize) || (tRspSize > stProperties.minRxBufferSize) )
dwStatus = ERROR_BAD_LENGTH;
// Length ok, attempt communication...
else
{
// Support retries during communication...
for( iRetries = 0; iRetries < RETRY_COUNT; iRetries++ )
{
bReceivePosted = FALSE;
// Post Receive Buffer if a response expected
if( (tRspSize == 0) || PostReceive( pvBuffer, stProperties.minRxBufferSize ) )
{
// Send Command Packet
if( DoSend( pvCmdBuf, tCmdSize ) )
{
// If no response is desired, we're done!
if( tRspSize == 0 )
{
bSucceeded = TRUE;
break;
}
// Receive and process Response Packet
dwCount = CompleteReceive( TRUE );
if( dwCount )
{
// Have a response; verify it
if( (dwCount != tRspSize) && (CheckRspSuccess(pvBuffer)) )
{
// Data received is larger/smaller than expected
dwStatus = ERROR_BAD_LENGTH;
}
else
{
// Data received is right length (or QST rejected command)
// Place info available into caller's buffer
memcpy( pvRspBuf, pvBuffer, __min(dwCount, tRspSize) );
bSucceeded = TRUE;
}
// We're done!
break;
}
}
// Remember ccode from first failed operation...
if( iRetries == 0 )
dwStatus = GetLastError();
// Won't need the buffer we posted...
if( tRspSize != 0 )
CancelReceive();
}
// A retry is necessary; recreate attachment to driver in case lost due to PM transition, etc.
DetachDriver();
if( !AttachDriver() )
break; // Can't reattach, time to give up
if( !AsyncDelay( RETRY_DELAY ) ) // Delay retry to give driver a break
break;
}
}
}
ReleaseMutex( hMutex );
if( !bSucceeded )
SetLastError( dwStatus ); // Indicate why we're failing
return (bSucceeded);
}
//------------------------------------------------------------------------------------------------
// update the message from (x0,y0,plane) to the neighbors on the same plane
// the encoding of the direction
// 2 |
// v
// 0 ------> <------- 1
// ^
// 3 |
//------------------------------------------------------------------------------------------------
void BPFlow::UpdateSpatialMessage(int x, int y, int plane, int direction)
{
// eliminate impossible messages
if (direction==0 && x==Width-1)
return;
if (direction==1 && x==0)
return;
if (direction==2 && y==Height-1)
return;
if (direction==3 && y==0)
return;
int offset=y*Width+x;
int nStates=pWinSize[plane][offset]*2+1;
T_message* message_org;
message_org=new T_message[nStates];
int x1=x,y1=y; // get the destination
switch(direction){
case 0:
x1++;
s=Im_s.data()[offset*2+plane];
d=Im_d.data()[offset*2+plane];
break;
case 1:
x1--;
s=Im_s.data()[(offset-1)*2+plane];
d=Im_d.data()[(offset-1)*2+plane];
break;
case 2:
y1++;
s=Im_s.data()[offset*2+plane];
d=Im_d.data()[offset*2+plane];
break;
case 3:
y1--;
s=Im_s.data()[(offset-Width)*2+plane];
d=Im_d.data()[(offset-Width)*2+plane];
break;
}
//s=m_s;
//d=m_d;
int offset1=y1*Width+x1;
int nStates1=pWinSize[plane][offset1]*2+1; // get the number of states for the destination node
int wsize=pWinSize[plane][offset];
int wsize1=pWinSize[plane][offset1];
T_message*& message=pSpatialMessage[plane][offset1*nNeighbors+direction].data();
// initialize the message from the dual plane
if(!IsTRW)
memcpy(message_org,pDualMessage[plane][offset].data(),sizeof(T_message)*nStates);
else
{
memset(message_org,0,sizeof(T_message)*nStates);
Add2Message(message_org,pDualMessage[plane][offset].data(),nStates,CTRW);
}
// add the range term
if(!IsTRW)
Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates);
else
Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates,CTRW);
// add spatial messages
if(!IsTRW)
{
if(x>0 && direction!=1) // add left to right
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates);
if(x<Width-1 && direction!=0) // add right to left
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
if(y>0 && direction!=3) // add top down
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates);
if(y<Height-1 && direction!=2) // add bottom up
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
}
else
{
if(x>0) // add left to right
if(direction==1)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW-1);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW);
if(x<Width-1) // add right to left
if(direction==0)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW-1);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW);
if(y>0) // add top down
if(direction==3)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW-1);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
if(y<Height-1) // add bottom up
if(direction==2)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates,CTRW-1);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates,CTRW);
}
// use distance transform function to impose smoothness compatibility
T_message Min=CStochastic::Min(nStates,message_org)+d;
for(ptrdiff_t l=1;l<nStates;l++)
message_org[l]=__min(message_org[l],message_org[l-1]+s);
for(ptrdiff_t l=nStates-2;l>=0;l--)
message_org[l]=__min(message_org[l],message_org[l+1]+s);
// transform the compatibility
int shift=pOffset[plane][offset1]-pOffset[plane][offset];
if(abs(shift)>wsize+wsize1) // the shift is too big that there is no overlap
{
if(offset>0)
for(ptrdiff_t l=0;l<nStates1;l++)
message[l]=l*s;
else
for(ptrdiff_t l=0;l<nStates1;l++)
message[l]=-l*s;
}
else
{
int start=__max(-wsize,shift-wsize1);
int end=__min(wsize,shift+wsize1);
for(ptrdiff_t i=start;i<=end;i++)
message[i-shift+wsize1]=message_org[i+wsize];
if(start-shift+wsize1>0)
for(ptrdiff_t i=start-shift+wsize1-1;i>=0;i--)
message[i]=message[i+1]+s;
if(end-shift+wsize1<nStates1)
for(ptrdiff_t i=end-shift+wsize1+1;i<nStates1;i++)
message[i]=message[i-1]+s;
}
// put back the threshold
for(ptrdiff_t l=0;l<nStates1;l++)
message[l]=__min(message[l],Min);
// normalize the message by subtracting the minimum value
Min=CStochastic::Min(nStates1,message);
for(ptrdiff_t l=0;l<nStates1;l++)
message[l]-=Min;
delete message_org;
}
int main() {
TCAS_pFile pFile;
TCAS_pHeader pHeader;
TCAS_pRawChunk pRawChunk;
pFile = (TCAS_pFile)malloc(sizeof(TCAS_File));
memset(pFile, 0, sizeof(TCAS_File));
pFile->minTime = TCAS_INIT_MIN_TIME;
pHeader = (TCAS_pHeader)malloc(sizeof(TCAS_Header));
pRawChunk = (TCAS_pRawChunk)malloc(4 * sizeof(TCAS_RawChunk));
pRawChunk[0].startTime = 0;
pRawChunk[0].endTime = 100;
pRawChunk[0].frameType = 0;
pRawChunk[0].layer = 5;
pRawChunk[0].posX = 100;
pRawChunk[0].posY = 100;
pRawChunk[0].r = (tcas_byte)1;
pRawChunk[0].g = (tcas_byte)2;
pRawChunk[0].b = (tcas_byte)3;
pRawChunk[0].a = (tcas_byte)4;
pFile->minTime = __min(pFile->minTime, pRawChunk[0].startTime);
pFile->maxTime = __max(pFile->maxTime, pRawChunk[0].endTime);
pFile->chunks ++;
pRawChunk[1].startTime = 200;
pRawChunk[1].endTime = 300;
pRawChunk[1].frameType = 0;
pRawChunk[1].layer = 1;
pRawChunk[1].posX = 200;
pRawChunk[1].posY = 100;
pRawChunk[1].r = (tcas_byte)5;
pRawChunk[1].g = (tcas_byte)6;
pRawChunk[1].b = (tcas_byte)7;
pRawChunk[1].a = (tcas_byte)8;
pFile->minTime = __min(pFile->minTime, pRawChunk[1].startTime);
pFile->maxTime = __max(pFile->maxTime, pRawChunk[1].endTime);
pFile->chunks ++;
pRawChunk[2].startTime = 400;
pRawChunk[2].endTime = 500;
pRawChunk[2].frameType = 0;
pRawChunk[2].layer = 3;
pRawChunk[2].posX = 100;
pRawChunk[2].posY = 200;
pRawChunk[2].r = (tcas_byte)1;
pRawChunk[2].g = (tcas_byte)2;
pRawChunk[2].b = (tcas_byte)3;
pRawChunk[2].a = (tcas_byte)4;
pFile->minTime = __min(pFile->minTime, pRawChunk[2].startTime);
pFile->maxTime = __max(pFile->maxTime, pRawChunk[2].endTime);
pFile->chunks ++;
pRawChunk[3].startTime = 400;
pRawChunk[3].endTime = 500;
pRawChunk[3].frameType = 0;
pRawChunk[3].layer = 3;
pRawChunk[3].posX = 200;
pRawChunk[3].posY = 200;
pRawChunk[3].r = (tcas_byte)1;
pRawChunk[3].g = (tcas_byte)2;
pRawChunk[3].b = (tcas_byte)3;
pRawChunk[3].a = (tcas_byte)4;
pFile->minTime = __min(pFile->minTime, pRawChunk[3].startTime);
pFile->maxTime = __max(pFile->maxTime, pRawChunk[3].endTime);
pFile->chunks ++;
libtcas_open_file(pFile, "test_raw.tcas", tcas_file_create_new);
libtcas_set_file_position_indicator(pFile, tcas_fpi_header);
libtcas_write_raw_chunks(pFile, pRawChunk, 4);
libtcas_set_header(pHeader, TCAS_FILE_TYPE_RAW, 0, 640, 480, pFile->minTime, pFile->maxTime, pFile->chunks, 1, 1);
libtcas_write_header(pFile, pHeader, tcas_false);
libtcas_close_file(pFile);
free(pRawChunk);
free(pHeader);
free(pFile);
return 0;
}
//------------------------------------------------------------------------------------------------
// update dual message passing from one plane to the other
//------------------------------------------------------------------------------------------------
void BPFlow::UpdateDualMessage(int x, int y, int plane)
{
int offset=y*Width+x;
int offset1=offset;
int wsize=pWinSize[plane][offset];
int nStates=wsize*2+1;
int wsize1=pWinSize[1-plane][offset];
int nStates1=wsize1*2+1;
s=Im_s.data()[offset*2+plane];
d=Im_d.data()[offset*2+plane];
//s=m_s;
//d=m_d;
T_message* message_org;
message_org=new T_message[nStates];
memset(message_org,0,sizeof(T_message)*nStates);
// add the range term
if(!IsTRW)
Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates);
else
Add2Message(message_org,pRangeTerm[plane][offset].data(),nStates,CTRW);
// add spatial messages
if(x>0) //add left to right
{
if(!IsTRW)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors].data(),nStates,CTRW);
}
if(x<Width-1) // add right to left
{
if(!IsTRW)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+1].data(),nStates,CTRW);
}
if(y>0) // add top down
{
if(!IsTRW)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
}
if(y<Height-1) // add bottom up
{
if(!IsTRW)
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+3].data(),nStates);
else
Add2Message(message_org,pSpatialMessage[plane][offset*nNeighbors+2].data(),nStates,CTRW);
}
if(IsTRW)
Add2Message(message_org,pDualMessage[plane][offset1].data(),nStates,CTRW-1);
T_message*& message=pDualMessage[1-plane][offset1].data();
T_message Min;
// use the data term
if(plane==0) // from vx plane to vy plane
for(size_t l=0;l<nStates1;l++)
message[l]=CStochastic::Min(nStates,pDataTerm[offset].data()+l*nStates,message_org);
else // from vy plane to vx plane
for(size_t l=0;l<nStates1;l++)
{
Min=message_org[0]+pDataTerm[offset].data()[l];
for(size_t h=0;h<nStates;h++)
Min=__min(Min,message_org[h]+pDataTerm[offset].data()[h*nStates1+l]);
message[l]=Min;
}
// normalize the message
Min=CStochastic::Min(nStates1,message);
for(size_t l=0;l<nStates;l++)
message[l]-=Min;
delete message_org;
}
//游戏结束
bool __cdecl CTableFrameSink::OnEventGameEnd( WORD wChairID, IServerUserItem * pIServerUserItem, BYTE cbReason )
{
switch ( cbReason )
{
case GER_DISMISS: //游戏解散
{
//效验参数
ASSERT( pIServerUserItem != NULL );
ASSERT( wChairID < m_wPlayerCount );
//构造数据
CMD_S_GameEnd GameEnd;
memset( &GameEnd, 0, sizeof( GameEnd ) );
//剩余扑克
BYTE bCardPos = 0;
for ( WORD i = 0; i < m_wPlayerCount; i++ )
{
GameEnd.bCardCount[ i ] = m_bCardCount[ i ];
CopyMemory( &GameEnd.bCardData[ bCardPos ], m_bHandCardData[ i ], m_bCardCount[ i ] * sizeof( BYTE ) );
bCardPos += m_bCardCount[ i ];
}
//发送信息
m_pITableFrame->SendTableData( INVALID_CHAIR, SUB_S_GAME_END, &GameEnd, sizeof( GameEnd ) );
m_pITableFrame->SendLookonData( INVALID_CHAIR, SUB_S_GAME_END, &GameEnd, sizeof( GameEnd ) );
//结束游戏
m_pITableFrame->ConcludeGame();
return true;
}
case GER_NORMAL: //常规结束
{
//定义变量
CMD_S_GameEnd GameEnd;
ZeroMemory( &GameEnd, sizeof( GameEnd ) );
//剩余扑克
BYTE bCardPos = 0;
for ( WORD i = 0; i < m_wPlayerCount; i++ )
{
GameEnd.bCardCount[ i ] = m_bCardCount[ i ];
CopyMemory( &GameEnd.bCardData[ bCardPos ], m_bHandCardData[ i ], m_bCardCount[ i ] * sizeof( BYTE ) );
bCardPos += m_bCardCount[ i ];
}
//变量定义
LONG lCellScore = m_pGameServiceOption->lCellScore;
bool bLandWin = ( m_bCardCount[ m_wBankerUser ] == 0 ) ? true : false;
//春天判断
if ( wChairID == m_wBankerUser )
{
WORD wUser1 = ( m_wBankerUser + 1 ) % GAME_PLAYER;
WORD wUser2 = ( m_wBankerUser + 2 ) % GAME_PLAYER;
if ( ( m_bOutCardCount[ wUser1 ] == 0 ) && ( m_bOutCardCount[ wUser2 ] == 0 ) ) m_wBombTime *= 2;
}
else
{
if ( m_bOutCardCount[ m_wBankerUser ] == 1 ) m_wBombTime *= 2;
}
//炸弹限制
m_wBombTime = __min( m_wBombTime, 16 );
//游戏积分
LONG lScore=0;
LONG lRevenue=0;
enScoreKind ScoreKind;
//统计积分
for ( WORD i = 0; i < m_wPlayerCount; i++ )
{
lScore=0;
lRevenue=0;
//统计积分
if ( i == m_wBankerUser )
{
lScore = m_wBombTime * m_bLandScore * lCellScore * ( ( bLandWin == true ) ? 2 : -2 );
GameEnd.lGameScore[ i ] = m_wBombTime * m_bLandScore * lCellScore * ( ( bLandWin == true ) ? 2 : -2 );
}
else
{
lScore = m_wBombTime * m_bLandScore * lCellScore * ( ( bLandWin == true ) ? -1 : 1 );
GameEnd.lGameScore[ i ] = m_wBombTime * m_bLandScore * lCellScore * ( ( bLandWin == true ) ? -1 : 1 );
}
//胜利类型
ScoreKind=(GameEnd.lGameScore[i]>0L)?enScoreKind_Win:enScoreKind_Lost;
//计算税收
if (m_pGameServiceOption->wServerType==GAME_GENRE_GOLD)
{
if (GameEnd.lGameScore[i]>=100L)
{
//计算税收
GameEnd.lGameTax+= (GameEnd.lGameScore[i]*m_pGameServiceOption->wRevenue/1000L);
lRevenue = (GameEnd.lGameScore[i]*m_pGameServiceOption->wRevenue/1000L);
//积分调整
lScore=lScore-lRevenue;
GameEnd.lGameScore[i]=GameEnd.lGameScore[i]-lRevenue;
}
}
//修改分数
m_pITableFrame->WriteUserScore(i,lScore,lRevenue,ScoreKind);
//历史积分
m_HistoryScore.OnEventUserScore(i,GameEnd.lGameScore[i]);
}
//发送信息
m_pITableFrame->SendTableData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
//切换用户
m_wFirstUser=wChairID;
//结束游戏
m_pITableFrame->ConcludeGame();
return true;
}
case GER_USER_LEFT: //用户强退
{
//效验参数
ASSERT(pIServerUserItem!=NULL);
ASSERT(wChairID<m_wPlayerCount);
//构造数据
CMD_S_GameEnd GameEnd;
ZeroMemory(&GameEnd,sizeof(GameEnd));
//剩余扑克
BYTE bCardPos=0;
for (WORD i=0;i<m_wPlayerCount;i++)
{
GameEnd.bCardCount[i]=m_bCardCount[i];
CopyMemory(&GameEnd.bCardData[bCardPos],m_bHandCardData[i],m_bCardCount[i]*sizeof(BYTE));
bCardPos+=m_bCardCount[i];
}
//炸弹限制
m_wBombTime=__min(m_wBombTime,16);
m_bLandScore=__max(m_bLandScore,1);
//修改积分
for (WORD i=0;i<m_wPlayerCount;i++)
{
//游戏积分
LONG lScore=0;
LONG lRevenue=0;
enScoreKind ScoreKind=enScoreKind_Draw;
//构造变量
if (i==wChairID)
{
ScoreKind=enScoreKind_Flee;
lScore =-m_wBombTime*m_bLandScore*m_pGameServiceOption->lCellScore*2;
GameEnd.lGameScore[i]=-m_wBombTime*m_bLandScore*m_pGameServiceOption->lCellScore*2;
}
else if (m_pGameServiceOption->wServerType==GAME_GENRE_GOLD)
{
//统计积分
//ScoreKind=enScoreKind_Win;
//lScore=(m_wBombTime*m_bLandScore*m_pGameServiceOption->lCellScore*4)/2;
//GameEnd.lGameScore[i]=(m_wBombTime*m_bLandScore*m_pGameServiceOption->lCellScore*4)/2;
////计算税收
//if (lScore>=100L)
//{
// //计算税收
// GameEnd.lGameTax+=GameEnd.lGameScore[i]*m_pGameServiceOption->cbRevenue/100L;
// lRevenue = GameEnd.lGameScore[i]*m_pGameServiceOption->cbRevenue/100L;
// //积分调整
// lScore=lScore-lRevenue ;
// GameEnd.lGameScore[i]=GameEnd.lGameScore[i]-lRevenue ;
//}
}
//写入积分
m_pITableFrame->WriteUserScore(i,lScore,lRevenue,ScoreKind);
//历史积分
m_HistoryScore.OnEventUserScore(i,GameEnd.lGameScore[i]);
}
//发送信息
m_pITableFrame->SendTableData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
m_pITableFrame->SendLookonData(INVALID_CHAIR,SUB_S_GAME_END,&GameEnd,sizeof(GameEnd));
//结束游戏
m_pITableFrame->ConcludeGame();
return true;
}
}
ASSERT(FALSE);
return false;
}
//------------------------------------------------------------------------------------------------
// function to compute data term
//------------------------------------------------------------------------------------------------
void BPFlow::ComputeDataTerm()
{
// allocate the buffer for data term
nTotalMatches = AllocateBuffer<PixelBuffer2D<T_message>, T_message>(pDataTerm, ptrDataTerm, WinSize);
int XWinLength = WinSize * 2 + 1;
T_message HistMin,HistMax;
double HistInterval;
double* pHistogramBuffer;
int nBins=20000;
int total=0; // total is the total number of plausible matches, used to normalize the histogram
pHistogramBuffer=new double[nBins];
memset(pHistogramBuffer,0,sizeof(double)*nBins);
HistMin= 32767;
HistMax=0;
//--------------------------------------------------------------------------------------------------
// step 1. the first sweep to compute the data term for the visible matches
//--------------------------------------------------------------------------------------------------
// accelerate here!
for(ptrdiff_t i = 0; i < Height; i++) // index over y
for(ptrdiff_t j = 0; j < Width; j++) // index over x
{
size_t index = i * Width + j;
// loop over a local window
for(ptrdiff_t k = -WinSize; k <= WinSize; k++) // index over y
for(ptrdiff_t l = -WinSize; l <= WinSize; l++) // index over x
{
ptrdiff_t x = j + pOffset[0][index] + l;
ptrdiff_t y = i + pOffset[1][index] + k;
ptrdiff_t index2 = y * Width2 + x;
T_message foo = 0;
// if the point is outside the image boundary then continue
if(!InsideImage(x, y)) continue;
// |S1(p) - S2(p + f(p))|
for(int n = 0; n < nChannels; n++)
foo += abs(pIm1[index * nChannels + n] - pIm2[index2 * nChannels + n]); // L1 norm
pDataTerm[index][(k + WinSize) * XWinLength + l + WinSize] = foo;
HistMin=__min(HistMin,foo);
HistMax=__max(HistMax,foo);
total++;
}
}
// compute the histogram info
HistInterval=(double)(HistMax-HistMin)/nBins;
//--------------------------------------------------------------------------------------------------
// step 2. get the histogram of the matching
//--------------------------------------------------------------------------------------------------
// accelerate here!
for(ptrdiff_t i=0;i<Height;i++) // index over y
for(ptrdiff_t j=0;j<Width;j++) // index over x
{
size_t index=i*Width+j;
// loop over a local window
for(ptrdiff_t k = -WinSize; k <= WinSize; k++) // index over y
for(ptrdiff_t l = -WinSize; l <= WinSize; l++) // index over x
{
ptrdiff_t x = j + pOffset[0][index] + l;
ptrdiff_t y = i + pOffset[1][index] + k;
// if the point is outside the image boundary then continue
if(!InsideImage(x,y)) continue;
int foo = __min(pDataTerm[index][(k + WinSize) * XWinLength + l + WinSize] / HistInterval, nBins-1);
pHistogramBuffer[foo]++;
}
}
for(int i=0;i<nBins;i++) // normalize the histogram
pHistogramBuffer[i] /= total;
T_message DefaultMatchingScore;
double Prob=0;
for(int i=0;i<nBins;i++)
{
Prob+=pHistogramBuffer[i];
if(Prob>=0.5)//(double)Area/nTotalMatches) // find the matching score
{
DefaultMatchingScore=__max(i,1)*HistInterval+HistMin;
break;
}
}
if(IsDisplay)
#ifdef INTMESSAGE
printf("Min: %d, Default: %d, Max: %d\n",HistMin,DefaultMatchingScore,HistMax);
#else
printf("Min: %f, Default: %f, Max: %f\n",HistMin,DefaultMatchingScore,HistMax);
#endif
//--------------------------------------------------------------------------------------------------
// step 3. assigning the default matching score to the outside matches
//--------------------------------------------------------------------------------------------------
// accelerate here!
for(ptrdiff_t i=0;i<Height;i++) // index over y
for(ptrdiff_t j=0;j<Width;j++) // index over x
{
size_t index=i*Width+j;
// loop over a local window
for(ptrdiff_t k = -WinSize; k <= WinSize; k++) // index over y
for(ptrdiff_t l = -WinSize; l <= WinSize; l++) // index over x
{
ptrdiff_t x = j + pOffset[0][index] + l;
ptrdiff_t y = i + pOffset[1][index] + k;
int _ptr = (k + WinSize) * XWinLength + l + WinSize;
// if the point is outside the image boundary then continue
if(!InsideImage(x,y))
pDataTerm[index][_ptr]=DefaultMatchingScore;
else if (IsDataTermTruncated) // put truncaitons to the data term
pDataTerm[index][_ptr]=__min(pDataTerm[index][_ptr],DefaultMatchingScore);
}
}
delete pHistogramBuffer;
}
void CameraController::Update()
{
if ( m_ZoomDirection == ZOOM_DIRECTION_NONE )
{
return;
}
float targetY = 0;
float targetViewY = 0;
switch ( m_ZoomStatus )
{
case ZOOM_STATUS_NEAREST:
targetY = NEAREST_Y;
targetViewY = NEAREST_VIEW_Y;
break;
case ZOOM_STATUS_DEGREE_1:
targetY = DEGREE_1_Y;
targetViewY = DEGREE_1_VIEW_Y;
break;
case ZOOM_STATUS_DEGREE_2:
targetY = DEGREE_2_Y;
targetViewY = DEGREE_2_VIEW_Y;
break;
case ZOOM_STATUS_DEGREE_3:
targetY = DEGREE_3_Y;
targetViewY = DEGREE_3_VIEW_Y;
break;
case ZOOM_STATUS_FARTHEST:
default:
targetY = FARTHEST_Y;
targetViewY = FARTHEST_VIEW_Y;
break;
}
float time = static_cast<float>( Timer::GetInstance()->GetElapsedTime() ) / 1000;
float delta = time * 10.0f;
D3DXVECTOR3 view = m_LookAtPoint - m_EyePoint;
D3DXVec3Normalize( &view, &view );
float dotView = D3DXVec3Dot( &view, &( -m_UpVector ) );
// Log( "%-8f도!!! %-8f \n", dotView, targetViewY );
// Log( "목표 = %f, 현위치 = %f \n", targetY, m_EyePoint.y );
// 카메라 업
if ( m_ZoomDirection == ZOOM_DIRECTION_BACK )
{
if ( dotView < targetViewY )
{
RotateUp( delta * dotView / ( m_EyePoint.y / 10 ) );
}
MoveElevate( delta * 10 );
MoveForward( -delta * 10, true );
if ( targetY < m_EyePoint.y )
{
m_ZoomDirection = ZOOM_DIRECTION_NONE;
return;
}
}
// 카메라 다운
else if ( m_ZoomDirection == ZOOM_DIRECTION_FOWARD )
{
if ( dotView > targetViewY )
{
RotateUp( -delta * dotView / ( m_EyePoint.y / 10 ) );
}
MoveElevate( -delta * 10 );
MoveForward( delta * 10, true );
if ( targetY > m_EyePoint.y )
{
m_ZoomDirection = ZOOM_DIRECTION_NONE;
return;
}
}
if ( m_ZoomPointX > 0 )
{
m_ZoomPointX = __min( m_ZoomPointX, 50 );
m_ZoomPointX -= delta;
MoveSide( delta );
}
else if ( m_ZoomPointX < 0 )
{
m_ZoomPointX = __max( m_ZoomPointX, -50 );
m_ZoomPointX += delta;
MoveSide( -delta );
}
if ( m_ZoomPointY > 0 )
{
m_ZoomPointY = __min( m_ZoomPointY, 50 );
m_ZoomPointY -= delta;
MoveForward( -delta );
}
else if ( m_ZoomPointY < 0 )
{
m_ZoomPointY = __max( m_ZoomPointY, -50 );
m_ZoomPointY += delta;
MoveForward( delta );
}
}
//------------------------------------------------------------------------------------------------
// update the message from (x0,y0) to the neighbors
// the encoding of the direction
// 2 |
// v
// 0 ------> <------- 1
// ^
// 3 |
//------------------------------------------------------------------------------------------------
void BPFlow::UpdateSpatialMessage(int x, int y, int direction)
{
// eliminate impossible messages
if (direction==0 && x==Width-1) return;
if (direction==1 && x==0) return;
if (direction==2 && y==Height-1) return;
if (direction==3 && y==0) return;
int p = y * Width + x;
int WinLen = 2 * WinSize + 1;
int nStates = WinLen * WinLen + 1;
int x1 = x, y1 = y; // get the destination
switch(direction)
{
case 0:
x1++;
break;
case 1:
x1--;
break;
case 2:
y1++;
break;
case 3:
y1--;
break;
}
int q = y1 * Width + x1;
if (!pMask1[q]) return;
// init message
T_message*& message = pSpatialMessage[q * nNeighbors + direction].data();
T_message* message_org;
message_org = new T_message[nStates];
// msg_org = dataTerm
memset(message_org, 0, sizeof(T_message) * nStates);
memcpy(message_org, pDataTerm[p].data(), sizeof(T_message) * (nStates - 1));
// add the range term
Add2Message(message_org, pRangeTerm[p].data(), nStates - 1);
// add spatial messages
// add m s->p where s != q
if(x > 0 && direction != 1 && pMask1[x - 1 + y * Width]) // add left to right
Add2Message(message_org, pSpatialMessage[p * nNeighbors].data(), nStates);
if(x < Width - 1 && direction != 0 && pMask1[x + 1 + y * Width]) // add right to left
Add2Message(message_org, pSpatialMessage[p * nNeighbors + 1].data(), nStates);
if(y > 0 && direction != 3 && pMask1[x + (y - 1) * Width]) // add top to down
Add2Message(message_org, pSpatialMessage[p * nNeighbors + 2].data(), nStates);
if(y < Height - 1 && direction != 2 && pMask1[x + (y + 1) * Width]) // add bottom to up
Add2Message(message_org, pSpatialMessage[p * nNeighbors + 3].data(), nStates);
// msg_org = h(fp)
// calculate min h(fp), fp is not empty
T_message Min = CStochastic::Min(nStates - 1, message_org);
// mahatton distance transformation
// suitable for no predict flow
int i, j, pInWin;
///* // forward pass
for (i = -WinSize; i <= WinSize; i++)
{
for (j = -WinSize; j <= WinSize; j++)
{
pInWin = i + WinSize + WinLen * (j + WinSize);
if (i - 1 >= -WinSize)
{
message_org[pInWin] = __min(message_org[pInWin - 1] + s, message_org[pInWin]);
}
if (j - 1 >= -WinSize)
{
message_org[pInWin] = __min(message_org[pInWin - WinLen] + s, message_org[pInWin]);
}
}
}
// backward pass
for (i = WinSize; i >= -WinSize; i--)
{
for (j = WinSize; j >= -WinSize; j--)
{
pInWin = i + WinSize + WinLen * (j + WinSize);
if (i + 1 <= WinSize)
{
message_org[pInWin] = __min(message_org[pInWin + 1] + s, message_org[pInWin]);
}
if (j + 1 <= WinSize)
{
message_org[pInWin] = __min(message_org[pInWin + WinLen] + s, message_org[pInWin]);
}
}
}
for (i = 0; i < nStates - 1; i++)
{
message_org[i] = __min(message_org[i], Min + d);
}
memcpy(message, message_org, sizeof(T_message) * nStates);
//*/
/*
// brute force method for calculating min(s * |f(p) - f(q)|, d)
T_message tmp;
int k, l, qInWin;
for (i = 0; i < nStates; i++)
message[i] = -1;
for (i = -WinSize; i <= WinSize; i++)
{
for (j = -WinSize; j <= WinSize; j++)
{
pInWin = i + WinSize + WinLen * (j + WinSize);
for (k = -WinSize; k <= WinSize; k++)
{
for (l = -WinSize; l <= WinSize; l++)
{
qInWin = k + WinSize + WinLen * (l + WinSize);
// use manhatton distance to metric distance between fp, fq
// min(s * (|u(p) - u(q)| + |v(p) - v(q)|), d)
tmp = __min((fabs(pOffset[0][p] + i - (k + pOffset[0][q])) + fabs(pOffset[1][p] + j - (l + pOffset[1][q]))) * s, d);
if (message[qInWin] == -1)
message[qInWin] = message_org[pInWin] + tmp;
else
message[qInWin] = __min(message[qInWin], message_org[pInWin] + tmp);
}
}
}
}
*/
T_message Max = 0;
T_message pEmpty = message_org[nStates - 1] + alphaD + alphaV;
message[nStates - 1] = __min(Min + alphaV, pEmpty);
for (i = 0; i < nStates - 1; i++)
if (Max < message[i]) Max = message[i];
// set all pixels out of mask message as maximum value
for (int w = -WinSize; w <= WinSize; w++)
{
for (int h = -WinSize; h <= WinSize; h++)
{
int nx = x1 + w;
int ny = y1 + h;
int l = w + WinSize + (h + WinSize) * WinLen;
message[l] = __min(message[l], pEmpty + pRangeTerm[p].data()[l]);
if (!InsideImage(nx, ny)) continue;
if (!pMask2[nx + ny * Width]) message[l] = Max + s * WinLen;
}
}
// normalize the message by subtracting the minimum value
Min = CStochastic::Min(nStates, message);
for(int l = 0; l < nStates; l++)
message[l] -= Min;
delete message_org;
}
BOOL bConvertOEMDevmode(
PCOEMDEV pOEMDevIn,
POEMDEV pOEMDevOut
)
/*++
Routine Description:
Converts private DEVMODE members to the
current version.
Arguments:
pOEMDevIn - pointer to OEM private devmode
pOEMDevOut - pointer to OEM private devmode
Return Value:
TRUE if successful, FALSE if there is an error
--*/
{
VERBOSE("bConvertOEMDevmode entry.");
if( (NULL == pOEMDevIn)
||
(NULL == pOEMDevOut)
)
{
ERR("ConvertOEMDevmode() invalid parameters.\r\n");
return FALSE;
}
// Check OEM Signature, if it doesn't match ours,
// then just assume DMIn is bad and use defaults.
if(pOEMDevIn->dmOEMExtra.dwSignature == pOEMDevOut->dmOEMExtra.dwSignature)
{
VERBOSE("Converting private OEM Devmode.\r\n");
// Set the devmode defaults so that anything the isn't copied over will
// be set to the default value.
pOEMDevOut->dwDriverData = 0;
// Copy the old structure in to the new using which ever size is the smaller.
// Devmode maybe from newer Devmode (not likely since there is only one), or
// Devmode maybe a newer Devmode, in which case it maybe larger,
// but the first part of the structure should be the same.
// DESIGN ASSUMPTION: the private DEVMODE structure only gets added to;
// the fields that are in the DEVMODE never change only new fields get added to the end.
memcpy(pOEMDevOut, pOEMDevIn, __min(pOEMDevOut->dmOEMExtra.dwSize, pOEMDevIn->dmOEMExtra.dwSize));
// Re-fill in the size and version fields to indicated
// that the DEVMODE is the current private DEVMODE version.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
}
else
{
VERBOSE("Unknown DEVMODE signature, pOEMDMIn ignored.\r\n");
// Don't know what the input DEVMODE is, so just use defaults.
pOEMDevOut->dmOEMExtra.dwSize = sizeof(OEMDEV);
pOEMDevOut->dmOEMExtra.dwSignature = OEM_SIGNATURE;
pOEMDevOut->dmOEMExtra.dwVersion = OEM_VERSION;
pOEMDevOut->dwDriverData = 0;
}
return TRUE;
}
//------------------------------------------------------------------------------------------------
// function to get energy
//------------------------------------------------------------------------------------------------
double BPFlow::GetEnergy()
{
double energy = 0;
int p, q, emptyState, WinLen;
int pXWinOffset, pYWinOffset, qXWinOffset, qYWinOffset;
// min (a * |f(p) - f(q)|, d)
WinLen = WinSize * 2 + 1;
emptyState = WinLen * WinLen;
for(int i = 0; i < Height; i++)
{
for(int j = 0; j < Width; j++)
{
p = i * Width + j;
if (!pMask1[p]) continue;
// calculate Vp,q
if(j < Width-1)
{
q = p + 1;
if (pMask1[q])
{
// f(p) or f(q) is empty
if (pX[p] == emptyState || pX[q] == emptyState)
energy += alphaV;
else
{
pXWinOffset = pX[p] % WinLen + pOffset[0][p] - WinSize;
pYWinOffset = pX[p] / WinLen + pOffset[1][p] - WinSize;
qXWinOffset = pX[q] % WinLen + pOffset[0][q] - WinSize;
qYWinOffset = pX[q] / WinLen + pOffset[1][q] - WinSize;
energy = energy + __min((fabs(pXWinOffset - qXWinOffset) + fabs(pYWinOffset - qYWinOffset)) * s, d);
}
}
}
if(i<Height-1)
{
q = p + Width;
if (pMask1[q])
{
if (pX[p] == emptyState || pX[q] == emptyState)
energy += alphaV;
else
{
pXWinOffset = pX[p] % WinLen + pOffset[0][p] - WinSize;
pYWinOffset = pX[p] / WinLen + pOffset[1][p] - WinSize;
qXWinOffset = pX[q] % WinLen + pOffset[0][q] - WinSize;
qYWinOffset = pX[q] / WinLen + pOffset[1][q] - WinSize;
energy = energy + __min((fabs(pXWinOffset - qXWinOffset) + fabs(pYWinOffset - qYWinOffset)) * s, d);
}
}
}
if (pX[p] == emptyState) energy += alphaD;
else
{
energy += pDataTerm[p].data()[pX[p]];
energy += pRangeTerm[p].data()[pX[p]];
}
}
}
return energy;
}
VOID near TextFlow::add_width_refresh_extent(
FramePtr frame, LINE_PTR lp,
PCOORD xmin, PCOORD xmax,
REFRESH_TYPE refresh_type)
{
if (want_refresh && database->can_refresh())
{
PBOX pbox, bound = frame->get_bound();
PCOORD baseline;
FLAGS object_flags = frame_object->get_flags();
if (object_flags & OBJECT_FLAG_xflipped)
{
pbox.x0 = bound.x1 - xmax;
pbox.x1 = bound.x1 - xmin;
}
else
{
pbox.x0 = bound.x0 + xmin;
pbox.x1 = bound.x0 + xmax;
}
if (pbox.x0 >= pbox.x1)
{
/* Null box */
return;
}
#if 0
printf("WR: %c%ld %ld%c\n",
refresh_type == REFRESH_ERASE ? '(' : '[',
pbox.x0,
pbox.x1,
refresh_type == REFRESH_ERASE ? ')' : ']');
#endif
#if 0
/* Allow for pixels added by hinting and by clear-out */
pbox.x0 -= 2*redisplay_x_pixel;
pbox.x1 += 2*redisplay_x_pixel;
#endif
baseline = lp->baseline;
pbox.y0 = baseline - lp->ascend /*- 2*redisplay_y_pixel*/;
pbox.y1 = baseline + lp->descend /*+ 2*redisplay_y_pixel*/;
pbox.y0 = __max(pbox.y0, 0);
pbox.y1 = __min(pbox.y1, bound.y1-bound.y0);
if (object_flags & OBJECT_FLAG_yflipped)
{
PCOORD y0 = pbox.y0;
pbox.y0 = bound.y1 - pbox.y1;
pbox.y1 = bound.y1 - y0;
}
else
{
pbox.y0 += bound.y0;
pbox.y1 += bound.y0;
}
RECT rExtraPixels;
SetRect(&rExtraPixels, 2, 2, 2, 2);
database->do_refresh_notify(&pbox, refresh_type, frame_object, &rExtraPixels);
}
}
void ARX_GLOBALMODS_Apply()
{
if (EDITMODE) return;
float baseinc = _framedelay;
float incdiv1000 = _framedelay * DIV1000;
if (desired.flags & GMOD_ZCLIP)
{
current.zclip = Approach(current.zclip, desired.zclip, baseinc * 2);
}
else // return to default...
{
desired.zclip = current.zclip = Approach(current.zclip, DEFAULT_ZCLIP, baseinc * 2);
}
// Now goes for RGB mods
if (desired.flags & GMOD_DCOLOR)
{
current.depthcolor.r = Approach(current.depthcolor.r, desired.depthcolor.r, incdiv1000);
current.depthcolor.g = Approach(current.depthcolor.g, desired.depthcolor.g, incdiv1000);
current.depthcolor.b = Approach(current.depthcolor.b, desired.depthcolor.b, incdiv1000);
}
else
{
current.depthcolor.r = Approach(current.depthcolor.r, 0, incdiv1000);
current.depthcolor.g = Approach(current.depthcolor.g, 0, incdiv1000);
current.depthcolor.b = Approach(current.depthcolor.b, 0, incdiv1000);
}
ModeLight &= ~MODE_DEPTHCUEING;
if (pMenuConfig)
{
float fZclipp = ((((float)pMenuConfig->iFogDistance) * 1.2f) * (DEFAULT_ZCLIP - DEFAULT_MINZCLIP) / 10.f) + DEFAULT_MINZCLIP;
fZclipp += (ACTIVECAM->focal - 310.f) * 5.f;
SetCameraDepth(__min(current.zclip, fZclipp));
}
else
{
SetCameraDepth(current.zclip);
}
if (USE_D3DFOG)
{
D3DDEVICEDESC7 d3dDeviceDesc;
GDevice->GetCaps(&d3dDeviceDesc);
#define PERCENT_FOG (.6f)
ulBKGColor = D3DRGB(current.depthcolor.r, current.depthcolor.g, current.depthcolor.b);
//pour compatibilité ATI, etc...
GDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, ulBKGColor);
float zval;
zval = fZFogEnd;
float zvalstart = fZFogStart;
if ((!pMenuConfig->bATI) &&
(d3dDeviceDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_FOGTABLE))
{
GDevice->SetRenderState(D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_NONE);
GDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_LINEAR);
bUSE_D3DFOG_INTER = true;
//WORLD COORDINATE
if (d3dDeviceDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_WFOG)
{
zval *= ACTIVECAM->cdepth;
zvalstart *= ACTIVECAM->cdepth;
}
}
else
{
zval *= ACTIVECAM->cdepth;
zvalstart *= ACTIVECAM->cdepth;
fZFogStartWorld = zvalstart;
fZFogEndWorld = zval;
GDevice->SetRenderState(D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_LINEAR);
GDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_NONE);
bUSE_D3DFOG_INTER = false;
}
GDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEEND, *((LPDWORD)(&zval)));
GDevice->SetRenderState(D3DRENDERSTATE_FOGTABLESTART, *((LPDWORD)(&zvalstart)));
}
else
{
GDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, D3DRGB(current.depthcolor.r, current.depthcolor.g, current.depthcolor.b));
GDevice->SetRenderState(D3DRENDERSTATE_FOGVERTEXMODE, D3DFOG_NONE);
GDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, D3DFOG_NONE);
}
}
ERRORCODE TextFlow::rebuild_words(DB_RECORD_NUMBER p_record,
DB_RECORD_NUMBER f_record,
CHARACTER_RANGE crange,
WORD_DELTA_PTR wdelta, WORD_RANGE_PTR wrange)
{
ParagraphPtr paragraph;
FramePtr frame;
W_INDEX w_index, w_start, w_end;
TEXT_WORD_PTR wp;
C_INDEX c_index;
CHARACTER_PTR cp;
ERRORCODE error;
/*
// Initialize the word delta structure first.
*/
wrange->w_start =
wrange->w_end =
wdelta->w_start = -1;
wdelta->count = 0;
/* Get the paragraph so we can operate on it. */
if ((paragraph = (ParagraphPtr)database->get_record(p_record, &error, RECORD_TYPE_Paragraph)) == NULL)
{
/* Error! */
return error;
}
/* See if there is any text. */
SHORT text_count = paragraph->number_of_characters();
if (text_count == 0)
{
/* No text! No words to form. */
paragraph->release();
return ERRORCODE_None;
}
/* Figure out where to begin forming words. */
if (crange.c_start < 0)
{
crange.c_start = 0;
}
if (crange.c_start >= text_count)
{
crange.c_start = text_count-1;
}
if (crange.c_end < 0 || crange.c_end >= text_count)
{
crange.c_end = text_count-1;
}
if (crange.c_start > crange.c_end)
{
/*
// Huh? Bad parameters!
// We could adjust the parameters to full extent and continue, but then
// we might not catch a bad programming case.
// Let's just return an error for now.
*/
od("rebuild_words: bad parameters\r\n");
paragraph->release();
return ERRORCODE_BadParameter;
}
/*
// The first thing we need to do is go through and figure out which words
// are going to be rebuilt. The first word to be rebuilt is the word containing
// the start change (or the previous one if it's the first character of that
// word). The c_index where word forming starts is the first character of
// this word. The last word to be rebuilt is the word containing the end
// change. The c_index where word forming stops is the last character of this
// word. These words will be deleted and rebuilt from the c_index range
// generated.
*/
/*
// A paragraph should always have at least one word (the eop word).
// OK. Here's the first problem: what happens if c_start > word(eop).c_start?
// This means that the character indicies are inconsistent. This shouldn't
// happen, so let's see if we can detect it and flag an error.
*/
/*
// Look for the word containing the start offset.
*/
SHORT word_count = paragraph->number_of_words();
w_start = w_end = word_count;
for (w_index = 0, wp = (TEXT_WORD_PTR)paragraph->word.get_element(0);
w_index < word_count;
wp++, w_index++)
{
if (wp->c_start >= crange.c_start)
{
w_start = w_index-1;
break;
}
}
if (w_start == word_count)
{
/* Couldn't find the c_index in our word array. Inconsistent. */
paragraph->release();
od("rebuild_words: start index inconsistent\r\n");
return ERRORCODE_BadParameter;
}
else if (w_start < 0)
{
/* Means c_start is in first word. */
w_start = 0;
}
#ifdef DEBUG_RW
printf("Found start offset %d in word %d (", crange.c_start, w_start);
dump_word(paragraph, (TEXT_WORD_PTR)paragraph->word.data + w_start);
printf(")\n");
#endif
/* Get the first index in this word. */
wrange->w_start =
wrange->w_end =
wdelta->w_start = w_start;
if ((c_index = paragraph->get_word(w_start)->c_start) < crange.c_start)
{
/* Move back to start of word. */
crange.c_start = c_index;
wdelta->w_start++; /* First word stays put. */
}
#ifdef DEBUG_RW
printf("Start offset moves to %d\n", crange.c_start);
#endif
/*
// Look for the word containing the end offset.
*/
for (; w_index < word_count; wp++, w_index++)
{
if (wp->c_start >= crange.c_end)
{
w_end = w_index;
break;
}
}
if (w_end == word_count)
{
/* Couldn't find the c_index in our word array. Inconsistent. */
paragraph->release();
od("rebuild_words: end index inconsistent\r\n");
return ERRORCODE_IntError;
}
else if (w_end == word_count-1)
{
/* We ended up on the eop word. Move off of it. */
w_end--;
}
#ifdef DEBUG_RW
printf("Found end offset %d in word %d (", crange.c_end, w_end);
dump_word(paragraph, (TEXT_WORD_PTR)paragraph->word.data + w_end);
printf(")\n");
#endif
/* Get the first index of the next word. */
if ((c_index = paragraph->get_word(w_end+1)->c_start-1) > crange.c_end)
{
/* Move forward to end of word. */
crange.c_end = c_index;
}
#ifdef DEBUG_RW
printf("End offset moves to %d\n", crange.c_end);
#endif
/*
// Delete the existing range if we have one.
// Perhaps this should be optimized someday to do all at once!
*/
if (w_end >= w_start)
{
/* Redisplay variables */
BOOL new_line = TRUE;
L_INDEX l_index;
LINE_PTR lp;
TEXT_WORD_PTR wp0;
PCOORD erase_xmin, erase_xmax;
if ((frame = (FramePtr)database->get_record(f_record, &error, RECORD_TYPE_Frame)) == NULL)
{
paragraph->release();
return error;
}
/* Get line pointer for redisplay purposes */
l_index = frame->line_of_word(w_end, NULL);
lp = frame->get_line(l_index);
erase_xmin = 0x7fffffff;
erase_xmax = -erase_xmin;
wdelta->count = -(w_end - w_start + 1);
while (w_end >= w_start)
{
#ifdef DEBUG_RW
printf("Delete word %d\n", w_end);
#endif
wp0 = paragraph->get_word(w_end);
if (!new_line && w_end < lp->w_start)
{
new_line = TRUE;
add_width_refresh_extent(frame, lp,
erase_xmin, erase_xmax, REFRESH_ERASE);
lp--;
}
if (new_line)
{
new_line = FALSE;
erase_xmin = wp0->x_offset + wp0->draw_left;
erase_xmax = wp0->x_offset + wp0->draw_width;
}
else
{
erase_xmin = __min(erase_xmin, wp0->x_offset + wp0->draw_left);
erase_xmax = __max(erase_xmax, wp0->x_offset + wp0->draw_width);
}
paragraph->delete_word(w_end--);
}
add_width_refresh_extent(frame, lp,
erase_xmin, erase_xmax, REFRESH_ERASE);
frame->release();
}
/*
// Start forming new words.
*/
for (w_index = w_start, c_index = crange.c_start,
cp = paragraph->get_character(c_index);
c_index <= crange.c_end; )
{
TEXT_WORD word;
/* Start this word. */
#ifdef DEBUG_RW
printf(*cp < ' ' ? "[%d]" : "[%c]", *cp);
#endif
word.type = character_type(*cp++);
word.flags = WORD_FLAG_needs_sizing;
word.c_start = c_index++;
word.x_offset = -1;
word.width = 0;
/* Accumulate the rest of the word. */
if (word.type == WORD_TYPE_solid)
{
/* Search for the next word start. */
while (c_index <= crange.c_end && character_type(*cp) == word.type)
{
#ifdef DEBUG_RW
printf(*cp < ' ' ? "(%d)" : "(%c)", *cp);
#endif
cp++;
c_index++;
}
}
/* This is a whole new word. */
#ifdef DEBUG_RW
printf(" ADD word %d, type %d, c (%d to %d) \n", w_index, word.type, word.c_start, c_index-1);
#endif
paragraph->insert_word(w_index++, &word);
/* Another delta in the word array. */
wdelta->count++;
wrange->w_end++;
}
/* Release the paragraph. */
paragraph->release(TRUE);
return ERRORCODE_None;
}
const Genome *
Genome::loadFromFile(const char *fileName, unsigned i_minOffset, unsigned length)
{
FILE *loadFile;
unsigned nBases,nPieces;
if (!openFileAndGetSizes(fileName,&loadFile,&nBases,&nPieces)) {
//
// It already printed an error. Just fail.
//
return NULL;
}
if (0 == length) {
length = nBases - i_minOffset;
} else {
//
// Don't let length go beyond nBases.
//
length = __min(length,nBases - i_minOffset);
}
Genome *genome = new Genome(nBases,length);
genome->nBases = nBases;
genome->nPieces = genome->maxPieces = nPieces;
genome->pieces = new Piece[nPieces];
genome->minOffset = i_minOffset;
if (i_minOffset >= nBases) {
fprintf(stderr,"Genome::loadFromFile: specified minOffset %u >= nBases %u\n",i_minOffset,nBases);
}
genome->maxOffset = i_minOffset + length;
static const unsigned pieceNameBufferSize = 512;
char pieceNameBuffer[pieceNameBufferSize];
unsigned n;
size_t pieceSize;
char *curName;
for (unsigned i = 0; i < nPieces; i++) {
if (NULL == fgets(pieceNameBuffer, pieceNameBufferSize, loadFile)){
fprintf(stderr,"Unable to read piece description\n");
delete genome;
return NULL;
}
for (n = 0; n < pieceNameBufferSize; n++){
if (pieceNameBuffer[n] == ' ') {
pieceNameBuffer[n] = '\0';
break;
}
}
genome->pieces[i].beginningOffset = atoi(pieceNameBuffer);
pieceNameBuffer[n] = ' ';
n++; // increment n so we start copying at the position after the space
pieceSize = strlen(pieceNameBuffer + n) - 1; //don't include the final \n
genome->pieces[i].name = new char[pieceSize + 1];
curName = genome->pieces[i].name;
for (unsigned pos = 0; pos < pieceSize; pos++) {
curName[pos] = pieceNameBuffer[pos + n];
}
curName[pieceSize] = '\0';
}
//
// Skip over the miserable \n that gets left in the file.
//
/* char newline;
if (1 != fread(&newline,1,1,loadFile)) {
fprintf(stderr,"Genome::loadFromFile: Unable to read expected newline\n");
delete genome;
return NULL;
}
if (newline != 10) {
fprintf(stderr,"Genome::loadFromFile: Expected newline to be 0x0a, got 0x%02x\n",newline);
delete genome;
return NULL;
}
*/
if (0 != _fseek64bit(loadFile,i_minOffset,SEEK_CUR)) {
fprintf(stderr,"Genome::loadFromFile: _fseek64bit failed\n");
exit(1);
}
if (length != fread(genome->bases,1,length,loadFile)) {
fprintf(stderr,"Genome::loadFromFile: fread of bases failed\n");
fclose(loadFile);
delete genome;
return NULL;
}
fclose(loadFile);
return genome;
}
template<class T> static T __min(ArrayHandle<T> ah){
return __min(ah, 0, ah.size());
}
int
ipmi_tsol_main(struct ipmi_intf * intf, int argc, char ** argv)
{
struct pollfd fds_wait[3], fds_data_wait[3], *fds;
struct sockaddr_in sin, myaddr, *sa_in;
socklen_t mylen;
char *recvip = NULL;
char out_buff[IPMI_BUF_SIZE * 8], in_buff[IPMI_BUF_SIZE];
char buff[IPMI_BUF_SIZE + 4];
int fd_socket, result, i;
int out_buff_fill, in_buff_fill;
int ip1, ip2, ip3, ip4;
int read_only = 0, rows = 0, cols = 0;
int port = IPMI_TSOL_DEF_PORT;
if (strlen(intf->name) < 3 || strncmp(intf->name, "lan", 3) != 0) {
lprintf(LOG_ERR, "Error: Tyan SOL is only available over lan interface");
return -1;
}
for (i = 0; i<argc; i++) {
if (sscanf(argv[i], "%d.%d.%d.%d", &ip1, &ip2, &ip3, &ip4) == 4) {
/* not free'd ...*/
/* recvip = strdup(argv[i]); */
recvip = argv[i];
}
else if (sscanf(argv[i], "port=%d", &ip1) == 1)
port = ip1;
else if (sscanf(argv[i], "rows=%d", &ip1) == 1)
rows = ip1;
else if (sscanf(argv[i], "cols=%d", &ip1) == 1)
cols = ip1;
else if (strlen(argv[i]) == 2 && strncmp(argv[i], "ro", 2) == 0)
read_only = 1;
else if (strlen(argv[i]) == 2 && strncmp(argv[i], "rw", 2) == 0)
read_only = 0;
else if (strlen(argv[i]) == 7 && strncmp(argv[i], "altterm", 7) == 0)
_altterm = 1;
else if (strlen(argv[i]) == 4 && strncmp(argv[i], "help", 4) == 0) {
print_tsol_usage();
return 0;
}
else {
print_tsol_usage();
return 0;
}
}
/* create udp socket to receive the packet */
memset(&sin, 0, sizeof(sin));
sin.sin_family = AF_INET;
sin.sin_port = htons(port);
sa_in = (struct sockaddr_in *)&intf->session->addr;
result = inet_pton(AF_INET, (const char *)intf->session->hostname,
&sa_in->sin_addr);
if (result <= 0) {
struct hostent *host = gethostbyname((const char *)intf->session->hostname);
if (host == NULL ) {
lprintf(LOG_ERR, "Address lookup for %s failed",
intf->session->hostname);
return -1;
}
if (host->h_addrtype != AF_INET) {
lprintf(LOG_ERR,
"Address lookup for %s failed. Got %s, expected IPv4 address.",
intf->session->hostname,
(host->h_addrtype == AF_INET6) ? "IPv6" : "Unknown");
return (-1);
}
sa_in->sin_family = host->h_addrtype;
memcpy(&sa_in->sin_addr, host->h_addr, host->h_length);
}
fd_socket = socket(PF_INET, SOCK_DGRAM, IPPROTO_UDP);
if (fd_socket < 0) {
lprintf(LOG_ERR, "Can't open port %d", port);
return -1;
}
if (-1 == bind(fd_socket, (struct sockaddr *)&sin, sizeof(sin))) {
lprintf(LOG_ERR, "Failed to bind socket.");
close(fd_socket);
return -1;
}
/*
* retrieve local IP address if not supplied on command line
*/
if (recvip == NULL) {
result = intf->open(intf); /* must connect first */
if (result < 0) {
close(fd_socket);
return -1;
}
mylen = sizeof(myaddr);
if (getsockname(intf->fd, (struct sockaddr *)&myaddr, &mylen) < 0) {
lperror(LOG_ERR, "getsockname failed");
close(fd_socket);
return -1;
}
recvip = inet_ntoa(myaddr.sin_addr);
if (recvip == NULL) {
lprintf(LOG_ERR, "Unable to find local IP address");
close(fd_socket);
return -1;
}
}
printf("[Starting %sSOL with receiving address %s:%d]\n",
read_only ? "Read-only " : "", recvip, port);
set_terminal_size(rows, cols);
enter_raw_mode();
/*
* talk to smdc to start Console redirect - IP address and port as parameter
* ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x06 0xC0 0xA8 0xA8 0x78 0x1A 0x0A
*/
result = ipmi_tsol_start(intf, recvip, port);
if (result < 0) {
lprintf(LOG_ERR, "Error starting SOL");
close(fd_socket);
return -1;
}
printf("[SOL Session operational. Use %c? for help]\n",
intf->session->sol_escape_char);
gettimeofday(&_start_keepalive, 0);
fds_wait[0].fd = fd_socket;
fds_wait[0].events = POLLIN;
fds_wait[0].revents = 0;
fds_wait[1].fd = fileno(stdin);
fds_wait[1].events = POLLIN;
fds_wait[1].revents = 0;
fds_wait[2].fd = -1;
fds_wait[2].events = 0;
fds_wait[2].revents = 0;
fds_data_wait[0].fd = fd_socket;
fds_data_wait[0].events = POLLIN | POLLOUT;
fds_data_wait[0].revents = 0;
fds_data_wait[1].fd = fileno(stdin);
fds_data_wait[1].events = POLLIN;
fds_data_wait[1].revents = 0;
fds_data_wait[2].fd = fileno(stdout);
fds_data_wait[2].events = POLLOUT;
fds_data_wait[2].revents = 0;
out_buff_fill = 0;
in_buff_fill = 0;
fds = fds_wait;
for (;;) {
result = poll(fds, 3, 15*1000);
if (result < 0)
break;
/* send keepalive packet */
tsol_keepalive(intf);
if ((fds[0].revents & POLLIN) && (sizeof(out_buff) > out_buff_fill)){
socklen_t sin_len = sizeof(sin);
result = recvfrom(fd_socket, buff, sizeof(out_buff) - out_buff_fill + 4, 0,
(struct sockaddr *)&sin, &sin_len);
/* read the data from udp socket, skip some bytes in the head */
if((result - 4) > 0 ){
int length = result - 4;
#if 1
length = (unsigned char)buff[2] & 0xff;
length *= 256;
length += ((unsigned char)buff[3] & 0xff);
if ((length <= 0) || (length > (result - 4)))
length = result - 4;
#endif
memcpy(out_buff + out_buff_fill, buff + 4, length);
out_buff_fill += length;
}
}
if ((fds[1].revents & POLLIN) && (sizeof(in_buff) > in_buff_fill)) {
result = read(fileno(stdin), in_buff + in_buff_fill,
sizeof(in_buff) - in_buff_fill); // read from keyboard
if (result > 0) {
int bytes;
bytes = do_inbuf_actions(intf, in_buff + in_buff_fill, result);
if(bytes < 0) {
result = ipmi_tsol_stop(intf, recvip, port);
do_terminal_cleanup();
return result;
}
if (read_only)
bytes = 0;
in_buff_fill += bytes;
}
}
if ((fds[2].revents & POLLOUT) && out_buff_fill) {
result = write(fileno(stdout), out_buff, out_buff_fill); // to screen
if (result > 0) {
out_buff_fill -= result;
if (out_buff_fill) {
memmove(out_buff, out_buff + result, out_buff_fill);
}
}
}
if ((fds[0].revents & POLLOUT) && in_buff_fill) {
/*
* translate key and send that to SMDC using IPMI
* ipmitool -I lan -H 192.168.168.227 -U Administrator raw 0x30 0x03 0x04 0x1B 0x5B 0x43
*/
result = ipmi_tsol_send_keystroke(intf, in_buff, __min(in_buff_fill,14));
if (result > 0) {
gettimeofday(&_start_keepalive, 0);
in_buff_fill -= result;
if (in_buff_fill) {
memmove(in_buff, in_buff + result, in_buff_fill);
}
}
}
fds = (in_buff_fill || out_buff_fill )?
fds_data_wait : fds_wait;
}
return 0;
}
