Color quality and packet shaping features for displaying an application on a variety of client devices

Claim 2

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine; initializing a protocol engine with parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; executing on the server the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting a new pending request from the application service; executing the new pending display request to create an image to be displayed on the client device, saving the resulting image to memory and determining for the image its relative cost and its corresponding request time based the local performance factor; converting the new pending display request from the application service into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request in the sequence its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each added request; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue, incrementing the total network time by the request time for the newly added request, and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a color quality data transformation including: selecting a quality level to apply to a set of image data having a number of significant color bits defining an initial number of possible colors; applying a pixel mask to the set of image data, the initial number of possible colors reduced to a smaller number of possible colors as a function of the quality level; loading the set of image data into an output buffer; and sending the set of image data from the output buffer to the display engine.

Claim 3

The method of claim 1 , further comprising applying another pixel mask to the set of image data, the another pixel mask calculating a way point for each of the reduced number of possible colors as a function of the quality level and the initial number of possible colors.

Claim 4

The method of claim 2 , wherein the way point is a mid-way point.

Claim 5

The method of claim 2 , wherein the way point is not a mid-way point.

Claim 6

The method of claim 1 , further comprising applying a level of image compression to the set of image data.

Claim 7

The method of claim 5 , wherein the level of image compression is defined by the use of at least one technique selected from the group consisting of RLE, Basic HexTile and Advanced HexTile.

Claim 8

The method of claim 1 , further comprising applying a general packet compressor to the set of image data.

Claim 9

The method of claim 7 , wherein the general packet compressor includes at least one member selected from the group consisting of fixed level Zlib and variable level Zlib.

Claim 10

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 1 .

Claim 11

An electronic media, comprising a program for performing the method of claim 1 .

Claim 12

An apparatus for performing the method of claim 1 .

Claim 13

The method of claim 1 wherein the relative cost for a request comprises a predetermined fixed basic operation cost and a localized cost per pixel calculated for the client device.

Claim 14

The method of claim 1 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the merge optimization.

Claim 15

The method of claim 13 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 16

The method of claim 1 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 17

The method of claim 1 wherein the encoding further comprises the steps of performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encoded compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 18

The method of claim 16 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the ZLib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the ZLib compression to a midrange compression level between its highest and lowest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the ZLib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 19

The method of claim 1 further comprising: periodically updating the of bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 20

The method of claim 1 further comprising: periodically updating the bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 21

The method of claim 1 further comprising: periodically updating the client device local performance factor and using the updated performance factor to determine the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then one minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 22

The method of claim 1 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 23

The method of claim 1 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.

Claim 24

In a client server network providing at least one application service for selection by a user via a client device having a display engine operating thereon, a method for converting, transmitting, and displaying requests of the requested application service that are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; using the display engine to determine parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having identifiers that are prior to such second sequence unique identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a color quality data transformation including: selecting a quality level to apply to a set of image data having a number of significant color bits defining an initial number of possible colors; applying a pixel mask to the set of image data, the initial number of possible colors reduced to a smaller number of possible colors as a function of the quality level; loading the set of image data into an output buffer; and sending the set of image data from the output buffer to the display engine.

Claim 25

In a client server network providing at least one application service for selection by a user via a client device having a display engine operating thereon, a method for converting, transmitting, and displaying requests of the requested application service that are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; using the display engine to determine parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having identifiers that are prior to such second sequence unique identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a color quality data transformation including: selecting a quality level to apply to a set of image data having a number of significant color bits defining an initial number of possible colors; applying a pixel mask to the set of image data, the initial number of possible colors reduced to a smaller number of possible colors as a function of the quality level; loading the set of image data into an output buffer; and sending the set of image data from the output buffer to the display engine.

Claim 26

The method of claim 23 , further comprising applying another pixel mask to the set of image data, the another pixel mask calculating a way point for each of the reduced number of possible colors as a function of the quality level and the initial number of possible colors.

Claim 27

The method of claim 24 , wherein the way point is a mid-way point.

Claim 28

The method of claim 24 , wherein the way point is not a mid-way point.

Claim 29

The method of claim 23 , further comprising applying a level of image compression to the set of image data.

Claim 30

The method of claim 27 , wherein the level of image compression is defined by the use of at least one technique selected from the group consisting of RLE, Basic HexTile and Advanced HexTile.

Claim 31

The method of claim 23 , further comprising applying a general packet compressor to the set of image data.

Claim 32

The method of claim 29 , wherein the general packet compressor includes at least one member selected from the group consisting of fixed level Zlib and variable level Zlib.

Claim 33

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 23 .

Claim 34

An electronic media, comprising a program for performing the method of claim 23 .

Claim 35

An apparatus for performing the method of claim 23 .

Claim 36

The method of claim 23 wherein the relative cost comprises a predetermined fixed basic operation cost and a localized cost per pixel calculated for the client device.

Claim 37

The method of claim 23 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the merge optimization.

Claim 38

The method of claim 35 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 39

The method of claim 23 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 40

The method of claim 23 wherein the encoding further comprises the steps of: performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encode compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 41

The method of claim 38 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the ZLib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the ZLib compression to a midrange compression level between its highest and lowest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the ZLib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 42

The method of claim 39 further comprising: periodically updating the bandwidth and latency parameters; and using the updated connection parameters to determine the level of encoding used.

Claim 43

The method of claim 39 further comprising: periodically updating the client device local performance factor parameter and using the updated performance factor to update the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then 1 minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 44

The method of claim 39 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 45

The method of claim 23 further comprising: periodically updating the bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 46

The method of claim 23 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.

Claim 47

The method of claim 44 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 48

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; providing to the display a table of display operations expected to be supported by the client device on which the display engine is executing; using the display engine to determine parameters of the client device comprising: testing the operation of each of the expected display operations on the client device and modifying the table to indicate which of the expected display operations was successfully tested; determining a local performance factor for the client device; and determining parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters as determined by the display engine; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue when the request times of the pending requests in the first queue exceed a predetermined third value by comparing the relative cost of the image to the sum of the relative costs of pending converted display requests in the first queue intended for display on the same portion of the display device of the client device as the image, and, if the relative cost of the image is less than the sum of the relative costs of the compared pending display requests: converting the image into a converted image request and determining its relative cost and its request time based on the local performance factor; replacing in the first queue the compared pending converted display requests with the converted image display request; and adjusting the total request time to reflect the addition of the converted image request and removal of the compared pending requests in the first queue; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine based on the bandwidth of the connection; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; using the display engine to process the received encoded display requests comprising the steps of: unencoding the converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is equal to the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time value and from the total network time value the time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a color quality data transformation including: selecting a quality level to apply to a set of image data having a number of significant color bits defining an initial number of possible colors; applying a pixel mask to the set of image data, the initial number of possible colors reduced to a smaller number of possible colors as a function of the quality level; loading the set of image data into an output buffer; and sending the set of image data from the output buffer to the display engine.

Claim 49

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; providing to the display a table of display operations expected to be supported by the client device on which the display engine is executing; using the display engine to determine parameters of the client device comprising: testing the operation of each of the expected display operations on the client device and modifying the table to indicate which of the expected display operations was successfully tested; determining a local performance factor for the client device; and determining parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters as determined by the display engine; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue when the request times of the pending requests in the first queue exceed a predetermined third value by comparing the relative cost of the image to the sum of the relative costs of pending converted display requests in the first queue intended for display on the same portion of the display device of the client device as the image, and, if the relative cost of the image is less than the sum of the relative costs of the compared pending display requests: converting the image into a converted image request and determining its relative cost and its request time based on the local performance factor; replacing in the first queue the compared pending converted display requests with the converted image display request; and adjusting the total request time to reflect the addition of the converted image request and removal of the compared pending requests in the first queue; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine based on the bandwidth of the connection; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; using the display engine to process the received encoded display requests comprising the steps of: unencoding the converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is equal to the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time value and from the total network time value the time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a color quality data transformation including: selecting a quality level to apply to a set of image data having a number of significant color bits defining an initial number of possible colors; applying a pixel mask to the set of image data, the initial number of possible colors reduced to a smaller number of possible colors as a function of the quality level; loading the set of image data into an output buffer; and sending the set of image data from the output buffer to the display engine.

Claim 50

The method of claim 46 , further comprising applying another pixel mask to the set of image data, the another pixel mask calculating a way point for each of the reduced number of possible colors as a function of the quality level and the initial number of possible colors.

Claim 51

The method of claim 17 , wherein the way point is a mid-way point.

Claim 52

The method of claim 47 , wherein the way point is not a mid-way point.

Claim 53

The method of claim 46 , further comprising applying a level of image compression to the set of image data.

Claim 54

The method of claim 50 , wherein the level of image compression is defined by the use of at least one technique selected from the group consisting of RLE, Basic HexTile and Advanced HexTile.

Claim 55

The method of claim 46 , further comprising applying a general packet compressor to the set of image data.

Claim 56

The method of claim 52 , wherein the general packet compressor includes at least one member selected from the group consisting of fixed level Zlib and variable level Zlib.

Claim 57

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 46 .

Claim 58

An electronic media, comprising a program for performing the method of claim 46 .

Claim 59

An apparatus for performing the method of claim 46 .

Claim 60

The method of claim 46 wherein the relative cost comprises a predetermined fixed basic operation cost and a localized per pixel cost based on a performance factor calculated for the client device.

Claim 61

The method of claim 46 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the step of optimization.

Claim 62

The method of claim 58 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 63

The method of claim 46 wherein the encoding further comprises the steps of performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encode compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 64

The method of claim 46 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the Zlib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the Zlib compression to a midrange compression level between the lowest and highest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the Zlib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 65

The method of claim 46 further comprising: periodically updating the client device local performance factor parameter and using the updated performance factor to update the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then 1 minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 66

The method of claim 46 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 67

The method of claim 46 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.

Claim 68

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine; initializing a protocol engine with parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; executing on the server the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting a new pending request from the application service; executing the new pending display request to create an image to be displayed on the client device, saving the resulting image to memory and determining for the image its relative cost and its corresponding request time based the local performance factor; converting the new pending display request from the application service into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request in the sequence its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each added request; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue, incrementing the total network time by the request time for the newly added request, and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 69

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine; initializing a protocol engine with parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; executing on the server the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting a new pending request from the application service; executing the new pending display request to create an image to be displayed on the client device, saving the resulting image to memory and determining for the image its relative cost and its corresponding request time based the local performance factor; converting the new pending display request from the application service into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request in the sequence its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each added request; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue, incrementing the total network time by the request time for the newly added request, and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 70

The method of claim 65 , further comprising routing the shaped packet to a client device via the transmitted request queue.

Claim 71

The method of claim 65 , further comprising storing the shaped packet in a shaped packet buffer.

Claim 72

The method of claim 67 , further comprising routing the shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 73

The method of claim 67 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 74

The method of claim 67 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 75

The method of claim 65 , further comprising forming another shaped packet by associating a third data portion with a fourth data portion and another header.

Claim 76

The method of claim 71 , further comprising routing the shaped packet and the another shaped packet to a client device via the transmitted request queue.

Claim 77

The method of claim 71 , further comprising storing the shaped packet and the another shaped packet in a shaped packet buffer.

Claim 78

The method of claim 73 , further comprising routing the shaped packet and the another shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 79

The method of claim 73 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 80

The method of claim 73 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 81

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 65 .

Claim 82

An electronic media, comprising a program for performing the method of claim 65 .

Claim 83

An apparatus for performing the method of claim 65 .

Claim 84

The method of claim 65 wherein the relative cost for a request comprises a predetermined fixed basic operation cost and a localized cost per pixel calculated for the client device.

Claim 85

The method of claim 65 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the merge optimization.

Claim 86

The method of claim 81 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 87

The method of claim 65 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 88

The method of claim 65 wherein the encoding further comprises the steps of performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encoded compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 89

The method of claim 84 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the ZLib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the ZLib compression to a midrange compression level between its highest and lowest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the ZLib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 90

The method of claim 65 further comprising: periodically updating the of bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 91

The method of claim 65 further comprising: periodically updating the bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 92

The method of claim 65 further comprising: periodically updating the client device local performance factor and using the updated performance factor to determine the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then one minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 93

The method of claim 69 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 94

The method of claim 65 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.

Claim 95

In a client server network providing at least one application service for selection by a user via a client device having a display engine operating thereon, a method for converting, transmitting, and displaying requests of the requested application service that are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; using the display engine to determine parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having identifiers that are prior to such second sequence unique identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 96

In a client server network providing at least one application service for selection by a user via a client device having a display engine operating thereon, a method for converting, transmitting, and displaying requests of the requested application service that are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; using the display engine to determine parameters of the client device comprising display operations supported by the client device, the relative cost of each supported operation and a local performance factor and parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue using a merge optimization when the request times of the pending requests in the first queue exceed a predetermined third value and updating the total request time based on the results of the merge optimization; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; executing the display engine comprising the steps of: unencoding the received converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last received display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is the same as the second sequence identifier and all pending displayed requests in the second queue having identifiers that are prior to such second sequence unique identifier; and decrementing from the total request time and from the total network time the request time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 97

The method of claim 91 , further comprising routing the shaped packet to a client device via the transmitted request queue.

Claim 98

The method of claim 91 , further comprising storing the shaped packet in a shaped packet buffer.

Claim 99

The method of claim 93 , further comprising routing the shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 100

The method of claim 93 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 101

The method of claim 93 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 102

The method of claim 91 , further comprising forming another shaped packet by associating a third data portion with a fourth data portion and another header.

Claim 103

The method of claim 97 , further comprising routing the shaped packet and the another shaped packet to a client device via the transmitted request queue.

Claim 104

The method of claim 97 , further comprising storing the shaped packet and the another shaped packet in a shaped packet buffer.

Claim 105

The method of claim 99 , further comprising routing the shaped packet and the another shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 106

The method of claim 99 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 107

The method of claim 99 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 108

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 91 .

Claim 109

An electronic media, comprising a program for performing the method of claim 91 .

Claim 110

An apparatus for performing the method of claim 91 .

Claim 111

The method of claim 91 wherein the relative cost comprises a predetermined fixed basic operation cost and a localized cost per pixel calculated for the client device.

Claim 112

The method of claim 91 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the merge optimization.

Claim 113

The method of claim 107 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 114

The method of claim 91 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 115

The method of claim 91 wherein the encoding further comprises the steps of: performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encode compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 116

The method of claim 110 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the ZLib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the ZLib compression to a midrange compression level between its highest and lowest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the ZLib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 117

The method of claim 111 further comprising: periodically updating the bandwidth and latency parameters; and using the updated connection parameters to determine the level of encoding used.

Claim 118

The method of claim 111 further comprising: periodically updating the client device local performance factor parameter and using the updated performance factor to update the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then 1 minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 119

The method of claim 111 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 120

The method of claim 91 further comprising: periodically updating the bandwidth and latency parameters; and using the updated parameters to determine the level of encoding used.

Claim 121

The method of claim 91 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.

Claim 122

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; providing to the display a table of display operations expected to be supported by the client device on which the display engine is executing; using the display engine to determine parameters of the client device comprising: testing the operation of each of the expected display operations on the client device and modifying the table to indicate which of the expected display operations was successfully tested; determining a local performance factor for the client device; and determining parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters as determined by the display engine; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue when the request times of the pending requests in the first queue exceed a predetermined third value by comparing the relative cost of the image to the sum of the relative costs of pending converted display requests in the first queue intended for display on the same portion of the display device of the client device as the image, and, if the relative cost of the image is less than the sum of the relative costs of the compared pending display requests: converting the image into a converted image request and determining its relative cost and its request time based on the local performance factor; replacing in the first queue the compared pending converted display requests with the converted image display request; and adjusting the total request time to reflect the addition of the converted image request and removal of the compared pending requests in the first queue; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine based on the bandwidth of the connection; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; using the display engine to process the received encoded display requests comprising the steps of: unencoding the converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is equal to the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time value and from the total network time value the time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 123

In a client server network providing at least one application service for selection by a user via a client device, a method for transmitting to and displaying on the display device of the client device display requests of the requested application service which are not supported by the client device, comprising: downloading from the server and executing on the client device a display engine associated with the application service requested by the user; loading on a server in the network a protocol engine in communication with the display engine and the requested application service; providing to the display a table of display operations expected to be supported by the client device on which the display engine is executing; using the display engine to determine parameters of the client device comprising: testing the operation of each of the expected display operations on the client device and modifying the table to indicate which of the expected display operations was successfully tested; determining a local performance factor for the client device; and determining parameters of the connection from the server to the display engine comprising bandwidth and latency; transmitting to and initializing the protocol engine with the client device parameters and the connection parameters as determined by the display engine; executing the protocol engine comprising the steps of: maintaining a first queue for retaining pending display requests and a second queue for retaining transmitted display requests of the requested application service for display on the client device; each request having a corresponding relative cost and request time determined by the relative cost and the local performance factor; maintaining a total request time for all requests in both queues and maintaining a total network time for all requests in the second queue; while the total request time is less than a predetermined first value: accepting from the application service a new pending display request to be displayed on the client device; executing the new pending display request to create an image to be displayed on a portion of a display screen of a client device, saving the resulting image to memory, and determining for the image its relative cost and its corresponding request time based the local performance factor; converting, based on the support display operations of the client device, the new pending display request into a sequence of converted requests that are supported by the client device, placing the sequence of converted requests in the first queue, determining for each converted display request its relative cost and its corresponding request time based on the local performance factor, and incrementing the total request time by the request time of each converted request added to the first queue; while the total network time is less than a predetermined second value: optimizing the first queue when the request times of the pending requests in the first queue exceed a predetermined third value by comparing the relative cost of the image to the sum of the relative costs of pending converted display requests in the first queue intended for display on the same portion of the display device of the client device as the image, and, if the relative cost of the image is less than the sum of the relative costs of the compared pending display requests: converting the image into a converted image request and determining its relative cost and its request time based on the local performance factor; replacing in the first queue the compared pending converted display requests with the converted image display request; and adjusting the total request time to reflect the addition of the converted image request and removal of the compared pending requests in the first queue; reading a pending request from the first queue and labeling each read request with a first sequence identifier; encoding each read display request for transmission to the display engine based on the bandwidth of the connection; placing a copy of the optimized request into the second queue and incrementing the total network time value for the newly added request; and transmitting the encoded display request to the display engine; using the display engine to process the received encoded display requests comprising the steps of: unencoding the converted display request and displaying it on the client device; generating a second sequence identifier corresponding to first sequence identifier of the displayed request; and periodically transmitting to the protocol engine the second sequence identifier of the last display request displayed on the client device; and upon receipt of the second sequence identifier of the last displayed display request, the protocol engine further comprising the steps of: deleting from the second queue the display request whose first sequence identifier is equal to the second sequence identifier and all pending displayed requests in the second queue having first sequence identifiers that are prior to such second sequence identifier; and decrementing from the total request time value and from the total network time value the time values of each of the deleted display requests, wherein transmitting the encoded display request to the display engine includes a packet shaping data structure transformation including: if i) the total network time is equal to or greater than a current round trip time, defined by twice a current latency, and ii) the total request time minus the total network time is equal to or less than half a preset limit, then forming a shaped packet by associating a first data portion with a second data portion and a header.

Claim 124

The method of claim 117 , further comprising routing the shaped packet to a client device via the transmitted request queue.

Claim 125

The method of claim 117 , further comprising storing the shaped packet in a shaped packet buffer.

Claim 126

The method of claim 119 , further comprising routing the shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 127

The method of claim 119 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 128

The method of claim 119 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 129

The method of claim 117 , further comprising forming another shaped packet by associating a third data portion with a fourth data portion and another header.

Claim 130

The method of claim 123 , further comprising routing the shaped packet and the another shaped packet to a client device via the transmitted request queue.

Claim 131

The method of claim 123 , further comprising storing the shaped packet and the another shaped packet in a shaped packet buffer.

Claim 132

The method of claim 125 , further comprising routing the shaped packet and the another shaped packet from the shaped packet buffer to a client device when a capacity of the shaped packet buffer is reached.

Claim 133

The method of claim 125 , further comprising routing the shaped packet from the shaped packet buffer to a client device when i) the total network time is less than the current round trip time or ii) the total request time minus the total network time is greater than half the preset limit.

Claim 134

The method of claim 125 , further comprising routing the shaped packet from the shaped packet buffer to a client device after a period of time has passed.

Claim 135

A computer program, comprising computer or machine readable program elements translatable for implementing the method of claim 117 .

Claim 136

An electronic media, comprising a program for performing the method of claim 117 .

Claim 137

An apparatus for performing the method of claim 117 .

Claim 138

The method of claim 117 wherein the relative cost comprises a predetermined fixed basic operation cost and a localized per pixel cost based on a performance factor calculated for the client device.

Claim 139

The method of claim 117 wherein the optimization of the first queue further comprises the step of performing a pruning optimization prior to performing the step of optimization.

Claim 140

The method of claim 133 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 141

The method of claim 116 wherein the optimization of the first queue further comprises performing an update scheduling optimization and an attribute scheduling optimization.

Claim 142

The method of claim 117 wherein the encoding further comprises the steps of performing coordinate compression; performing run length encoding compression; serializing the coordinate compressed and run length encode compressed request into fixed byte ordered strings; performing delta compression; and performing Zlib compression.

Claim 143

The method of claim 117 wherein the encoding further comprises the steps of: omitting the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine greater than about 300 Kbytes per second; applying the steps of run length encoding and delta compression if the bandwidth of the connection to the display engine is less than about 300 Kbytes per second; omitting Zlib compression if the bandwidth of the connection to the display engine is greater than about 300 Kbytes per second; setting the Zlib compression to its lowest and quickest compression level if the bandwidth of the connection to the display engine is between about 100 Kbytes to about 300 Kbytes per second; setting the Zlib compression to a midrange compression level between the lowest and highest compression levels if the bandwidth of the connection to the display engine is between about 3 Kbytes to about 100 Kbytes per second; and setting the Zlib compression to its highest compression level if the bandwidth of the connection to the display engine is less than about 3 Kbytes per second.

Claim 144

The method of claim 117 further comprising: periodically updating the client device local performance factor parameter and using the updated performance factor to update the request times of pending requests received after the updating has occurred; on moving a pending request from the first queue to the second queue adding to the request an time estimate of the time when that request should be removed from the second queue based on the updated local performance factor; on removing the request from the second queue, maintaining a running average and variance for the percentage error for the estimated time as compared to the actual time that the request was removed, and, if the total of the average error minus half of the variance exceeds a pre-set limit and the time since the last update is more then 1 minute then immediately repeating the steps of updating the connection parameters and the client device local performance factor parameter.

Claim 145

The method of claim 117 wherein the updated local performance is used to update the request times of the requests in the first and second queues.

Claim 146

The method of claim 117 wherein the predetermined first value is about five seconds, the predetermined second value is about two seconds, and the predetermined third value is about 1/20 of the predetermined first value.