PCT
`
`WORLD INTELLECTUAL PROPERTY ORGANIZATION
`International Bureau
`
`
`
`INTERNATIONAL APPLICATION PUBLISHED UNDER THE PATENT COOPERATION TREATY (PCT)
`(51) International Patent Classification 6 :
`(11) International Publication Number:
`WO 99/26130
`GO06F 3/14
`.
`(43) International Publication Date:
`
`27 May 1999 (27.05.99)
`
`
`
`(21) International Application Number: PCT/US98/24342|(81) Designated States: AU, CA, CN, IL, JP, KR, NO, NZ, SG,
`European patent (AT, BE, CH, CY, DE, DK,ES, FI, FR,
`GB, GR, IE, IT, LU, MC, NL, PT, SE).
`
`(22) International Filing Date:
`
`13 November 1998 (13.11.98)
`
`into the quickest screen refresh time for the remote control operation.
`
`Published
`(30) Priority Data:
`
`
`08/970,709 14 November 1997 (14.11.97)|US With international search report.
`Before the expiration of the time limit for amending the
`claims and to be republished in the event of the receipt of
`amendments.
`
`(71) Applicant: E-PARCEL, LLC [US/US]; Suite 300, 29 Crafts
`Street, Newton, MA 02158 (US).
`
`(72) Inventors: KOBATA, Hiroshi; Apartment 201, 50 Watertown
`Street, Watertown, MA 02172 (US). GAGNE, Robert, A.;
`995 Southern Artery, Quincy, MA 02169 (US). TONCHEV,
`Theodore, C.; 162 Sth Street, Cambridge, MA 02141 (US).
`
`(74) Agent: TURANO, Thomas, A.; Testa, Hurwitz & Thibeault,
`LLP, High Street Tower, 125 High Street, Boston, MA
`02110 (US).
`
`(54) Title) REMOTE CONTROL SYSTEM WHICH MINIMIZES SCREEN REFRESH TIME BY SELECTING COMPRESSION
`ALGORITHM
`
`GUARANTEES
`SUCCESSFUL
`TRANSFER
`
`DECOMPRESSION/
`COMPRESSION
`ALGORITHM
`
`(57) Abstract
`
`A system is provided for the remote control of one computer from another in which selectable compression speeds are utilized to
`minimize overall screen refresh time. In one embodiment, an algorithm selection module at one computer chooses the highest compression
`available corresponding to a worst case scenario, followed by measurementof the compression time and the transmission time, with the ratio
`of compression time to transmission time being used to select a decreased compression, thereby to lower compression time and consequently
`lowerthe overall screen refresh time. By adjusting both the send time and the compression time on the transmit side, the above ratio can be
`made to equal one, which correspondsto the most efficient utilization of the available bandwidth and CPU power, which in turn translates
`
`1 of 196
`
`GOOGLEEXHIBIT 1010
`
`

`

`FOR THE PURPOSES OF INFORMATION ONLY
`
`Codes used toidentify States party to the PCT on the front pages of pamphlets publishing international applications under the PCT.
`
`Zimbabwe
`
`Albania
`Armenia
`Austria
`Australia
`Azerbaijan
`Bosnia and Herzegovina
`Barbados
`Belgium
`Burkina Faso
`Bulgaria
`Benin
`Brazil
`Belarus
`Canada
`Central African Republic
`Congo
`Switzerland
`Céte d'Ivoire
`Cameroon
`China
`Cuba
`Czech Republic
`Germany
`Denmark
`Estonia
`
`SI
`SK
`SN
`SZ
`TD
`TG
`
`Slovenia
`Slovakia
`Senegal
`Swaziland
`Chad
`Togo
`Tajikistan
`Turkmenistan
`Turkey
`Trinidad and Tobago
`Ukraine
`Uganda
`United States of America
`Uzbekistan
`Viet Nam
`Yugoslavia
`
`Spain
`Finland
`France
`Gabon
`United Kingdom
`Georgia
`Ghana
`Guinea
`Greece
`Hungary
`Treland
`Israel
`Iceland
`Italy
`Japan
`Kenya
`Kyrgyzstan
`Democratic People’s
`Republic of Korea
`Republic of Korea
`Kazakstan
`Saint Lucia
`Liechtenstein
`Sri Lanka
`Liberia
`
`LS
`
`LU
`
`Lesotho
`Lithuania
`Luxembourg
`Latvia
`Monaco
`Republic of Moldova
`Madagascar
`The former Yugoslav
`Republic of Macedonia
`Mali
`Mongolia
`Mauritania
`Malawi
`Mexico
`Niger
`Netherlands
`Norway
`New Zealand
`Poland
`Portugal
`Romania
`Russian Federation
`Sudan
`Sweden
`Singapore
`
`2 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`REMOTE CONTROL SYSTEM WHICH MINIMIZES SCREEN REFRESH TIME BY SELECTING COMPRESSION
`ALGORITHM
`
`FIELD OF INVENTION
`
`This invention relates to the remote control of computers and moreparticularly to an
`
`emulation system in which screen refresh times associated with one computercontrolling another
`
`computer are minimized taking into account the demographics of the network and the sending
`
`machine.
`
`BACKGROUNDOF THE INVENTION
`
`Oneof the main problems for a consumeris oftentimes incompatibility of his equipment
`
`and the programs sought to be run. Forinstance, an individual may havea printer thatis
`
`incompatible with the driver loaded to operate it. Typically, the user calls an administrator who
`
`10
`
`telephonically instructs the individual as to how to program his computerin order to make the
`
`printer work. This may involve downloadingprinter drivers or other software in a time
`
`consuming process in which the administrator must ask the user questions. The user, on the other
`
`hand, may beinsufficiently knowledgeable to answer the administrator’s questions, resulting in
`
`frustration on both the user’s part and that of the administrator.
`
`In an effort to minimize such frustrations, systems, referred to herein as emulation
`
`systems, have been developed so that the administrator can “see” what is happening at the user’s
`
`terminal.
`
`In order to do this in the past remote control programs have been developed which
`
`capture the low level graphic calls and send them to the administrator’s computerfor display. At
`
`the administrator’s side these low level graphiccalls are utilized to provide the screen at the
`administrator’s side with an exact duplicate ofthe user’s screen. Such a system is commercially
`
`20
`
`available as model ppANYWHERE from Symantec of Cupertino, California.
`
`In this system the
`
`3 of 196
`
`SUBSTITUTE SHEET (RULE 26)
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`administrator can understand what is happeningat the user’s side and verbally instruct the user
`
`-2-
`
`whatto do.
`
`Oneof the problems with prior emulation systemsis that the screen refresh at the
`
`administrator’s side is slow, or in general not optimized to the demographics of the network and
`
`the users machine. Forinstance, if the user hasa relatively slow modem connected to the
`
`network, butis utilizing a compression algorithm that emphasizes compression speed over
`
`efficiency, this would have a negative impact on the screen refresh rate. The result for the
`
`administratoris that the administrator would select or click on an icon and have to wait an
`
`inordinate amountof time for a response. The reason for such delays has to do with the
`
`10
`
`demographics of the network and the two machinesin that inappropriate compression algorithms
`
`are chosen.
`
`In an effort to speed up the response of such systems, various techniques have been
`
`utilized. One of these techniques involves the use of low level drivers to capture graphicscalls.
`
`However, these drivers can make the system unstable and require much disk and RAM memory
`
`15
`
`space. As a result, oftentimes the screen refresh is often corrupted when moving graphics are
`
`encountered and hasa stilted appearance.
`
`Theartifacts are in general caused by the order in which the graphiccalls are trapped, and
`
`the different levels of graphics calls which are available. These systemsare also inferior in
`
`displaying bitmapped graphics and moving images. The largest problem with the above systemsis
`
`20
`
`that they can take as much as 10 megabytesof disk space on both sides, and require a rebootafter
`
`installation before using.
`
`In the prior systems there is another problem in that by relying on the graphicscalls the
`
`images are takenin parts and are displayed on the administrator's side in unnatural fashion due to
`
`the arbitrary order in which the graphicscalls are trapped. These systems have to wait for other
`
`4 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-3-
`
`applications to make graphiccalls in order to know what to update and rely on the applications to
`
`make graphics calls known to the systems. If an application performs a graphics operation not
`
`knownto the system, that informationis not transferred over to the administrator.
`
`Asa result, the image the administrator sees is incorrect, since the entire system is
`
`dependent on other applications to perform knownoperations with the operating system. For
`
`applications that perform operations that are unknown, the system ignores what could potentially
`
`be the problematic area.
`
`Thus, for the newer peripherals coupled to the user's computer, in the past the problem
`
`could be ignored since the administrators system could notseeit.
`
`SUMMARYOF THE INVENTION
`
`In order to speed up the screen refresh potion of the system, low level drivers trapping
`
`graphicscalls are eliminated in favor of increasing speed throughthealteration of the compression
`
`and decompression algorithms used at the user and administrator sides to choose the appropriate
`
`ratio of transmission time and compression time which matches the demographics of the network
`
`and that of the user's computer.
`
`In one embodiment, the speed of the refresh at the
`
`administrator's side is increased to the maximum extent possible to eliminate delays in presenting
`
`the results of an operation on the user's computer.
`
`For instance, assuming that the user's computer has a CPU speed of 200 mhz and further
`
`assuming a local area network with a mean transmission rate of ~800 kilobytes per second, best
`
`20
`
`compression algorithm would providea full screen refresh in less than 0.7 seconds including
`
`compression and transmission. If an incorrect algorithm for modem speed were chosenat the
`
`user's side, such as 28 kilobytes per second, then the refresh time at the administrator's side would
`
`be 2.5 seconds, clearly 300% longer than that achievable if the appropriate compression rate were
`
`chosen.
`
`5 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-4-
`
`In the above case it would be desirable to choose the lowest compression rate, eq. one
`
`that emphasizes compression speed overresulting size. In this case, e.g., for a local area network,
`
`a compression rate of 13% would yield the above 0.7 second refresh time, given a transmission
`
`speed of ~800kb.
`
`In the subject invention there are four different compression algorithms from which to
`
`choose. Thefirst is the lowest compression rate algorithm comprising a run length encoding
`
`algorithm. This algorithm converts a run of the same byte with a count of that byte. A second
`
`algorithm selectable by the subject system for the next higher compressionrate is a Huffman
`
`compression algorithm preceded by run length encoding, or RLE. A third algorithm selectable by
`
`the subject system for the next higher compressionrate is a modified adaptive Huffman
`
`compression algorithm using a 9 bit tree entry size, again preceded by RLE. Finally, a fourth
`
`compression algorithm is identical to the above but with 13 bit tree entry sixes, for the highest
`
`compressionrate.
`
`Thefirst algorithm is characterized byit's speed. Typically, this algorithm will compress a
`
`15
`
`megabyte in less than 0.2 seconds. This algorithm is to be selected when network bandwidthis
`
`not a problem.
`
`The second algorithm is also characterized by it's speed, but with moreresulting data size
`
`efficiency, and is to be used in high speed networks with heavy traffic.
`
`The third algorithm is characterized by its data size efficiency, in which a megabyteis
`
`20
`
`compressed down to 4 kilobytes. This algorithm is useful for internet applications because of the
`
`internet's heavy traffic and latency.
`
`The fourth algorithm is characterized by its extreme datasize efficiency in that it can
`
`compress a megabyte of screen data down to approximately 2 kilobytes or less. However,the last
`
`twoalgorithmsare relatively slow, eg. 3 secondsvs. 0.2 seconds.
`
`6 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`While the above describes four different compression algorithms, other
`
`-5-
`
`compression/decompression algorithms are within the scope ofthis invention. Regardless, the
`
`compression algorithm selected is based on the rate of send time to compression time, with the
`
`selection seeking to causethis ratio to equal one. In order to select the decompression algorithm
`
`at the user's side, the transmission from the user to the administrator is monitored and the
`
`transmission time is measured for every single refresh.
`
`In one embodiment, this involves
`
`measuring the start of the send and end of the send for a TCP network transmission. Likewise,
`
`the actual compression is measured for every single refresh in which the CPUtick countis taken
`
`at the start of the compression and at the end of the compression; and the end of the compression;
`
`10
`
`and the difference is used to calculate the compression speed in milliseconds.
`
`In one embodiment, the screen is divided into grids and a checksum recorded for each
`
`grid. This check sum is compared to the previous check sum, and whenit differs, the grid is
`
`marked as "dirty". Once the entire screen has been checked,all the dirty grids are collected and
`
`compressed. This is one refresh. This processis done ona grid bygrid basis until the whole
`
`screen has been checked.
`
`The selection process operates as follows. After an initial measurement has been made of
`
`compression time and transmission time, the ratio is calculated, and if less than one, the algorithm
`
`having a lower compressionrate is selected, thereby decreasing compression time.
`
`In one embodiment,the first algorithm selectedis the one having the highest compression
`
`20
`
`rate, assuming the worst case scenario. Thereafter, through an iterative processthe selection
`
`settles on the optimal algorithm given the demographicsof the network and the user's computer.
`
`The compression time and the transmission time is averaged out from refresh to refresh so
`
`that the ratio reflects the overall demographics. The algorithm chosenis that for which the-ratio
`
`is as Close to one as possible.
`
`7 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-6-
`
`A system is provided for the remote control of one computer from another in which
`
`selectable compression speedsare utilized to minimize overall screen refresh time.
`
`In one
`
`embodiment, an algorithm selection module at one computer chooses the highest compression
`
`available, corresponding to a worst case scenario followed by measurement of the compression
`
`time and the transmission time, with the ratio of compression time to transmission time being used
`
`to decrease compression, thereby to lower compression time and consequently lowerthe overall
`
`screen refresh time. By adjusting both the send time and the compression time on the transmit
`
`side, the above ratio can be made to be equal to one, which correspondsto the most efficient
`
`utilization of the available bandwidth and CPU power, whichin turn translates into the quickest
`
`10
`
`screen refresh time for the remote control operation.
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`These and other features of the Subject Invention will be better understood with reference
`
`to the Detailed Description taken in conjunction with the Drawings, of which:
`
`Figure 1| is block diagram of two networked computers, with one computer
`
`15
`
`correspondingto that of the user, and the other computer correspondingto that of the
`
`administrator;
`
`Figure 2 is a block diagram of the computersof Figure | illustrating the
`
`transmission of the information on the screen of the user’s computer to the screen of the
`
`administrator’s computer,
`
`20
`
`Figure 3 is a block diagram of the transmission of modifications specified at the
`
`administrator’s screen to that of the user’s screen indicating the control of the user’s computer by
`
`the administrator’s computer;
`
`Figure 4 is a block diagram of the subject system in which the compression ~-
`
`algorithm to be used by the user’s computeris automatically selected based on the demographics
`
`8 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-7-
`
`of the network and the user’s computer, whichselection is transmitted to the administrator’s
`
`computerfor use in the corresponding compression algorithmstherein;
`
`Figure 5 is a tableillustrating the header portion for the data transmitted for a
`
`single screen cycle indicating identification of the compression algorithm used;
`
`Figure 6 is a flowchart illustrating the derivation of a ratio of send time to
`
`compression time usedin the algorithm selection module offigure 4; and,
`
`Figure 7 is a graphillustrating a comparison of compression algorithmsin terms of
`
`transfer speed vs. compression speed.
`
`DETAILED DESCRIPTION
`
`10
`
`Referring now to Figure 1 in a typical networked situation a network 10 is used to
`
`connect a terminal A, herein referred to as terminal 12, to terminal B, herein referred to as
`
`terminal 14.
`
`Each of these terminals has a CPU coupled, thereto referred to as 16 and 18, with
`
`keyboards 20 and 22 coupled to respective CPUs. Mice 24 and 26 are coupled to respective
`
`CPUs 16 and 18 asillustrated.
`
`Referring now to Figure 2, in an emulation system, termina! 14 transmits its screen
`
`30 over network 10 to terminal 12, such that its screen is duplicated as 30’ at terminal 12.
`
`It is
`
`the purposeofthis transfer to alert the administrator to exactly whatis displayed at the user’s
`
`terminal so that corrective action can be taken by the user either through verbal instructions given
`
`20
`
`to the user by the administratoror, as illustrated in Figure 3, by the transmission of modifications
`
`34 from terminal 12 to terminal 14 over network 10.
`
`As mentioned hereinbefore,it is important that there be minimal delay between
`
`actions taken by the administrator via keyboard 20 or mouse 24 anda resulting operation on-
`
`terminal 14 which changeis immediately displayed on terminal 12. The ability to quickly display
`
`9 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-8-
`
`operations and results on the administrator’s terminal significantly reduces administrator
`
`frustration and fatigue, while at the same time providing more efficient transfer of information to
`
`the user or moreparticularly to the user’s terminal. Regardless of whether or not information is
`
`verbally communicatedto the user or is automatically downloaded to the users terminalit is
`
`5
`
`important that the administrator’s screen be refreshed in the shortest possible time.
`
`Factors which affect the screen refresh are the characteristics of the network, herein
`
`referred to as demographics, which includes bandwidth, transmission speed, traffic and other
`
`factors. Likewise, the screen refresh rate at the administrator’s side is intimately connected with
`
`the demographics of the user’s computer, namely CPU speed, modem speed, available memory,
`
`10
`
`and otherfactors.
`
`Referring to Figure 4, as can be seen, each of the CPUs 16 and 18 is provided with a
`
`selectable number of compression and decompression algorithms, with the compression
`
`algorithmsat the user’s side bearing reference characters 40, 42, 44 and 46. These algorithms,in
`
`one embodiment, are ordered from the highest to the lowest compression, the purpose of which
`
`15__will be hereinafter. The algorithm selected at the user’s side is accomplished through the
`
`utilization of an algorithm selection module, 50, which is coupled not only to CPU 18, but also to
`
`each of the algorithms 40-46.
`
`Likewise, at the administrator’s side corresponding decompression algorithms 52, 54, 56
`
`and 58, are coupled with CPU 16 in accordance with algorithm selection module 60, upon
`
`20
`
`detection at 62 of the compression algorithm carried by the transmitted data over network 10.
`
`In operation, each screen refresh cycle is provided with a header containing the type of
`
`compression algorithm selected at the users side by module 50. The data format of the
`
`transmitted datais illustrated in Figure 5 to indicate that as part of the header information the
`
`10 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`algorithm selectedis identified, with the remainder of the data being that associated with a screen
`
`-9.
`
`refresh cycle.
`
`This header is detected at 62 and the appropriate algorithm is introduced to CPU 16 for
`
`appropriate decompression.
`
`5
`
`Referring to Figure 6, in one embodiment, algorithm selection module 50 initially chooses
`
`for transmission that algorithm which possesses the highest compression. The reasonthis is done
`
`is to be able to accommodate the worst case scenario in which the transmission speed is limited to
`
`that of the slowest modem reasonably calculated to be included at the receiver's CPU. Algorithm
`
`select module 50 then computes how longit takes to compress a refresh cycle and how longit
`
`10
`
`takes to send this refresh cycle. It does this each and every refresh cycle to permit a ratio of send
`
`time to compression time to be calculated for each refresh cycle.
`
`If the ration is equal to 1, then this highest compression algorithm is permitted to
`
`continue. Ifthe ratio R of send time to compression timeis less than 1 then the algorithm having
`
`the next lower compressionis selected, which lowers the compression time while at the same time
`
`15
`
`increasing the send time. Measurementsare again taken for the next cycle and theratio
`
`recomputed. This iterative process finally settles upon an algorithm which optimally minimizes
`
`screen refresh time at the administrator’s side.
`
`It will be noted that, as mentioned above, the compression algorithms are ordered
`
`according to compressionso that the iterative process can settle upon the optimal algorithm.
`
`20
`
`Referring now to Figure 7, what is shown is a comparison oftradeoffs in compression
`
`speed and transfer speed for four different compression algorithms having a descending value of
`
`compression from the highest to the lowest. As can be seen the highest transfer speed is for a
`
`local area network at about 800 kilobytes per second, followed by a wide area network at about
`
`11 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`-10-
`
`500 kilobytes per second, followed by the internet at about 80 kilobytes per second, and finally
`
`followed by modemswhich operate at about 10 kilobytes per second.
`
`As can be seen, given the lowest compression algorithm, the transfer time is off the chart
`
`for a modem and barely usable for the internet, while being satisfactory both for wide area
`
`5
`
`networks and for local area networks, since the transfer time is under 1.0 seconds. On the other
`
`hand, for the highest compression algorithm, it can be seen that the overall transfer time varies
`
`little such that few improvements can be made in terms of the type of network over which the
`
`data is transmitted. For algorithms having intermediate compression rates, while the chart
`
`indicates modest improvementin certain instances, significant improvement in refresh times can
`
`10
`
`nonetheless be effectuated in certain circumstances,
`
`It will be appreciated that the graph shows
`
`averages, and that certain screen data compressesbetter with one or the other middle algorithms.
`
`The dynamic algorithm switching ensures that the most appropriate algorithm is always chosen.
`
`Whatis presented below is a program listing in C++ which describes the operation not
`
`only of the automatic selection module but also of the operation of the entire system in the
`
`15
`
`selection of optimal compression and decompression algorithms based on system demographics.
`
`12 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`11
`
`APPENDIX
`
`// Handshake information
`#define REJECT
`0x0000
`#define VERSION
`0x0106
`
`#define WAIT_TIME 15000
`
`// Input codes
`#define INPUT_MOUSE
`#define INPUTKEYBOARD
`#define INPUTDOUBLECLICKMOUSE
`#define INPUTREFRESH
`#define INPUT_CLOSE_CONNECTION
`#define INPUT_HOTKEY
`#define INPUTPAINTINGPAUSE
`#define INPUTPAINTINGRESUME
`
`0x01
`0x02
`
`0x04
`0x05
`0x06
`
`0x03
`
`0x07
`0x08
`
`// hot keys
`#define HOTKEY_ALTTAB
`#define HOTKEY_CTRLESC
`#define HOTKEYCTRLALTDEL
`
`// video codes
`#define VIDEO_PAINT
`#define VIDEONOPAINT
`#define VIDEOCLOSE_CONNECTION
`#define VIDEOPAUSE
`
`#define CONNECTIONTRANSFER
`#define CONNECTIONPAUSE
`
`0x01
`
`0x0010
`0x0011
`0x0012
`
`0x01
`0x02
`0x03
`0x04
`
`0x00
`
`0
`
`#define MONITOR_EXIT_SUCCESS
`#define VIDEOEXITSUCCESS
`#define INPUTEXITSUCCESS
`#define VIDEOEXITHANDSHAKEERROR
`#define VIDEO_EXIT_HARDWARE_ERROR
`#define VIDEOEXITDIRECTDRAWERROR
`6
`#define INPUT_EXIT_HANDSHAKE_ERROR
`#define VIDEOEXITCLIENTDOESNTSUPPORT 7
`#define VIDEOEXITHANG
`
`3
`4
`5
`
`1
`2
`
`8
`
`// Max mouse movement for mouse_event
`#define MOUSE_X Oxffff
`#define MOUSE_Y Oxffff
`
`13 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`12
`
`#define PADDINGDIVISOR 401
`
`// Misc Defines
`#define DIBHEADERMARKER
`#define BITSBYTE
`8
`
`((WORD)
`
`('M' << 8)
`
`|
`
`'B')
`
`// these are for changing the cursors to
`// windows defaults
`// these are not
`in any headers
`#define OCR_NORMAL
`32512
`#define OCR_IBEAM
`32513
`#define OCR_WAIT
`32514
`#define OCR_CROSS
`32515
`#define OCR_UP
`32516
`#define OCR_SIZENWSE
`32642
`#define OCR_SIZENESW
`32643
`#define OCR_SIZEWE
`32644
`#define OCR_SIZENS
`32645
`#define OCR_SIZEALL
`32646
`#define OCR_NO
`32648
`#define OCR_APPSTARTING
`32650
`
`#define AGENTUI WAITING
`to connect.")
`#define AGENTUI CONNECTING
`reugesting connect...")
`#define AGENT_UI_CONNECTED
`connected.")
`
`_T("Waiting for Administrator
`
`_T ("Administrator
`
`_T("Administrator
`
`VLLLLTLLTAELL ATTA ETALAAA
`// Custom windows messages
`
`#define USER_EXITLOOP
`#define USERPAUSE
`#define USER_RESUME
`
`WM_USER+1
`WM_USER+2
`WM_USER+3
`
`LILTILTSTLELET STILTS TELAT AAA
`// Grid defines
`
`12 //12 //6
`#define GRIDHEIGHT
`16 //16 //8
`#define GRIDWIDTH
`#define GRIDCOUNT (GRIDWIDTH*GRIDHEIGHT)
`#define OFFSCREENWIDTH 8 //8 //1
`
`14 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`#define PADDING 8
`
`//8 //4
`
`13
`
`LILTLSTLITTTTTTATA ATTA LAT TATTLE
`// Error codes
`
`#define CONNECTSUCCESS
`#define CONNECTINCORRECT_VERSION
`#define CONNECT_NOT_AVAILABLE
`#define CONNECTAGENTREJECT
`#define CONNECT_HARDWARE_INCOMPATIBLE
`#define CONNECTCLIENT INCOMPATIBLE
`fdefine CONNECT VIDEOHANG
`
`0x02
`0x03
`0x04
`0x05
`
`0x01
`
`0x06
`0x07
`
`cenet
`
`int STATIC BUFFER = 256;
`
`// structures for sending a keyboard or mouse event over
`the connection
`// implementation notes:
`needed for
`inplementation
`// a minimal
`// they are the parameters from keydbevent and mouseevent
`
`these contain for information then
`
`// Description of the protocol
`// Video Loos
`// Input Loop
`
`Struct KeyboardEvent
`{
`
`BYTE Vk;
`// ** fields that are part of the func **//
`BYTE Scan;
`DWORD dwFlags;
`DWORD dwExtraInfo;
`DWORD dwRepeat;
`
`be
`
`Struct OtherEvent
`
`{
`
`be
`
`int HotKeyld;
`
`Struct MouseEvent
`
`--
`
`SUBSTITUTE SHEET (RULE 26)
`
`15 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`14
`
`part of the func
`
`ae ff
`
`dwFlags;
`dx;
`dy;
`fields that are
`dwData;
`dwExtraiInfo;
`dwRepeat;
`
`struct InfoBlock
`
`{
`
`cbCompressedSize;
`long
`long cbFullSize;
`long nDirtyCount;
`DWORD fCompression;
`DWORD fStatus;
`DWORD f£fCommands;
`
`// utilities
`InfoBlock (
`{
`
`)
`
`Clear
`
`void Clear
`
`(
`
`{
`
`);
`
`)
`
`cbCompressedSize
`cbFullSize
`=
`
`nDirtyCount
`fStatus
`
`=
`=
`
`0;
`0;
`0;
`
`0;
`
`fCommands = 0;
`
`} e
`
`)e
`
`num {
`
`PALETTEAVAIL =
`
`Ox0l };
`
`Struct Status
`
`|
`
`Status (
`
`)
`
`fStatus = 0;
`
`bois SetPause (
`|
`fStatus |=
`
`)
`
`PAUSE;
`
`SUBSTITUTE SHEET (RULE 26)
`
`16 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`15
`
`void SetRefresh (
`
`)
`
`fStatus |= REFRESH;
`
`bool Refresh (
`
`)
`
`if ( fStatus & REFRESH )
`return true;
`
`else return false;
`
`boo] Pause ({
`
`)
`
`if (
`
`f£Status & PAUSE )
`return true;
`else return false;
`
`} v
`
`oid Clear
`
`{
`
`}
`
`};
`
`{ ) D
`
`WORD fStatus;
`enum { PAUSE = 0x02, REFRESH = Ox04
`
`}e
`
`Struct DirtyBlock
`{
`
`short xPos;
`shert yPos;
`
`// utilities
`void Mark (
`{
`
`int x,
`
`int y )
`
`xPos =
`yPos =
`
`(short) x;
`(short) y;
`
`};
`
`Struct HardwarelInfo
`{
`
`long ScreenWidth;
`long ScreenHeight;
`long MaxGridCount;
`long ByteCount;
`bool bFail;
`
`HardwareiInfo (
`
`)
`
`SUBSTITUTE SHEET (RULE 26)
`
`17 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`16
`
`{
`
`} v
`
`{
`
`bFail = false;
`
`oid SetFail
`
`(
`
`)
`
`bFail = true;
`
`} b
`
`)e
`
`ool GetFail
`
`(
`
`)
`
`{ return bFail;
`
`}
`
`// Global Utilities
`
`//void ResourceMessageBox (UINT, UINT=IDS_CAPTION,
`DWORD=MB_OK) ;
`
`// clientvideo.h
`
`// July 30, 1997
`// Rob Gagne
`
`// Purpose: Does the job of working with the display in the
`form of
`// a Video object, calcs the checksum, builds the dirty
`buffer and
`// compresses it.
`
`class ClientVideo
`
`{ p
`
`ublic:
`ClientVideo (
`~ClientVideo (
`
`);
`);
`
`bool OpenSession ( HWND });
`void CloseSession ( );
`bool ProcessFrame (
`InfoBlock&, DirtyBlock*, const
`LPBYTE, DWORD );
`
`long TotalBufferSize (
`
`)
`
`{ return m_cbTotalBufferSize;
`
`void QueryHardware ( HardwareInfoé );
`long GridCount
`(
`)
`{ return GRIDWIDTH * GRIDHEIGHT;
`
`int MaxPalSize (
`
`)
`
`{ return m_display.MaxPalSize (
`
`);
`
`bool GetPalette (
`
`InfoBlock&, LPPALETTEENTRY };
`
`// Process iteration commands
`
`_
`
`SUBSTITUTE SHEET (RULE 26)
`
`18 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`17
`
`enum { FORCEPAINT = 0x01 };
`private:
`bool ProcessIiteration (
`
`InfoBlock&, DirtyBlock*, DWORD
`
`i
`
`InfoBlock&, DirtyBlock*,
`
`bool ProcessIterationNoLock (
`DWORD );
`(
`bool CompressBuffer
`bool CollectiInfo ( );
`
`InfoBlock&é, const LPBYTE );
`
`// hardware information
`bool m_bSupportLocking;
`
`// screen & buffer dimensions
`long m_ScreenHeight;
`long m_ScreenWidth;
`long m_OffscreenHeight;
`long m_OffscreenWidth;
`Rect m_rctScreen;
`Rect m_rctOffscreen;
`long m_padding;
`long m_ByteCount;
`
`// hardware interface
`Video mdisplay;
`
`// buffer size info
`DWORD m_cbTotalBufferSize;
`WORD m_cbRowBufferSize;
`int m_BitsPerPel;
`HWND m_hWnd;
`
`// checksum class
`CheckSum m_checksum;
`
`// compression
`CompressionEngine m_compressionEngine;
`
`adminvideo.h
`
`August 4, 1997
`Rob Gagne
`
`manages the admin side of the video transaction
`
`\;
`//
`
`//
`//
`
`//
`
`~.
`
`class AdminVideo
`
`{ p
`
`ublic:
`
`SUBSTITUTE SHEET (RULE 26)
`
`19 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`18
`
`);
`AdminVideo (
`~AdminVideo ( );
`
`bool OpenSession (
`LPPALETTEENTRY );
`void CloseSession ( );
`bool ProcessFrame (
`InfoBlock&, DirtyBlock*, LPBYTE,
`DWORD );
`
`const HardwareInfo&, HWND,
`
`long TotalBufferSize (
`
`)
`
`{ return m_cbTotalBufferSize;
`
`long GridCount
`
`(
`
`)
`
`{ return GRIDWIDTH * GRID_HEIGHT;
`
`int MaxPalSize (
`
`)
`
`{ return m_display.MaxPalSize ( );
`
`bool SetPalette ( LPPALETTEENTRY );
`bool RestoreLostSurface ( );
`
`bool Pause ()
`bool Refresh (
`
`{
`)3
`
`return m_blLost;
`
`}
`
`private:
`bool ProcessIiteration (
`
`)3
`
`InfoBlock&, DirtyBlock*, DWORD
`
`InfoBlock&, LPBYTE );
`(
`bool ExpandBuffer
`void ProcessInfo ( const HardwareInfo& );
`
`// screen & buffer dimensions
`long m_ScreenHeight;
`long m_ScreenWidth;
`long m_OffscreenHeight;
`long m_OffscreenWidth;
`Rect m_rctScreen;
`Rect m_rctOffscreen;
`long m_padding;
`int m_ByteCount;
`
`// hardware interface
`Video m_display;
`HWND m_hWnd;
`
`// buffer size info
`DWORD m_cbTotalBufferSize;
`DWORD m_cbRowBufferSize;
`int m_BitsPerPel;
`
`// surface lost
`
`—
`
`20 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`19
`
`bool m_bLost;
`bool m_bRefresh;
`
`// compression
`CompressionEngine m_compressionEngine;
`
`};
`
`inline bool AdminVideo::Refresh (
`{
`
`)
`
`if (m_bRefresh)
`{
`
`m_bRefresh = false;
`return true;
`
`} r
`
`eturn false;
`
`// ahuff.h
`// header for adaptive huffman class
`
`#define ENDOFSTREAM
`#define ESCAPE
`#define SYMBOL_COUNT
`#define NODE_TABLE_COUNT
`#define ROOTNODE
`#define MAXWEIGHT
`#define TRUE
`#define FALSE
`
`256
`257
`258
`{
`( SYMBOLCOUNT * 2)-+1)
`0
`0x8000
`1
`0
`
`class AdaptHuffComp
`
`{ p
`
`ublic:
`AdaptHuffComp ( );
`~AdaptHuffComp ( );
`
`(LPBYTE, LPBYTE,
`
`long,
`
`long CompressBuffer
`bool=false);
`bool ExpandBuffer
`bool=false);
`
`(LPBYTE, LPBYTE,
`
`long,
`
`long,
`
`private:
`// internal structures
`struct Tree
`
`{
`
`int leaf{ SYMBOLCOUNT ]j;
`
`-_
`
`21 of 196
`
`

`

`WO 99/26130
`
`PCT/US98/24342
`
`20
`
`int next_free_node;
`struct Node
`
`{
`
`unsigned int weight;
`int parent;
`int child_is_leaf;
`int child;
`} nodes[ NODETABLECOUNT J;
`
`};
`Tree m_tree;
`
`);
`void InitializeTree(
`void EncodeSymbol( unsigned int c, BIT_MANIP *output
`
`int DecodeSymbol( BIT_MANIP *input );
`void UpdateModel(
`int c );
`void RebuildTree(
`);
`int j
`void swap_nodes( int i,
`void add_new_node(
`int c );
`
`);
`
`de
`
`//** winsock2 defines **//
`
`#define SDRECEIVE
`#define SDSEND
`#define SDBOTH
`
`0x00
`0x01
`0x02
`
`class Except
`
`{ p
`
`ublic:
`( LPCTSTR );
`Except
`void Trace ( );
`private:
`m_LastError;
`DWORD
`LPCTSTR m_pError;
`
`be
`
`class BaseSocket
`
`{ p
`
`ublic:
`// interface
`BaseSocket
`( );
`~BaseSocket
`(
`);
`
`22 of 196
`
`

`

`WO 99/26130
`
`:
`
`PCT/US98/24342
`
`21
`
`int ) const;
`( LPBYTE,
`int Send
`int ) const;
`( LPBYTE,
`int Recv
`int SendFully
`( LPBYTE,
`int
`) const;
`int RecvFully
`{ LPBYTE,
`int
`) const;
`void EmptyRecvBuffer
`(
`) const;
`bool CanRead
`(
`int = 30 ) const;
`bool CanWrite ( int
`30 ) const;
`
`void Shutdown (
`void Close (
`);
`protected:
`// data
`SOCKET
`sockaddr_in
`int
`bool
`bool
`
`int=SD_SEND );
`
`m_socket;
`m_addr;
`m_nPort;
`m_bCreated;
`m_bConnected;
`
`// protected methods
`void InitClass ( };
`void ResolveName ( int, LPCTSTR );
`void Bind ( int, LPCTSTR=NULL );
`void Create (
`);
`int&);
`( sockaddr_in*, LPTSTR,
`bool
`IPFromAddr
`bool NameFromAddr
`( sockaddr_in*, LPTSTR,
`inté&);
`bool IsIpAddr
`( LPCTSTR, unsigned char*);
`
`};
`
`class ServerSocket
`
`: public BaseSocket
`
`{ p
`
`ublic:
`// methods
`);
`(
`ServerSocket
`void Create ( int nPort );
`void Accept
`( ServerSocketé );
`void Listen ( );
`inté& );
`bool ClientName ( LPTSTR,
`bool ClientIP ( LPTSTR,
`inté );
`bool ServerName ( LPTSTR,
`int& );
`bool ServerIP ( LPTSTR,
`inté );
`private:
`// data
`sockaddr_in
`sockaddr_in
`
`m_client_addr;
`m_resolved_name;
`
`bool ResolveLocalName ( sockaddr_in* );
`
`23 of 196
`
`

`

`WO 9