|Publication number||US6008816 A|
|Application number||US 08/641,016|
|Publication date||Dec 28, 1999|
|Filing date||Apr 25, 1996|
|Priority date||Apr 25, 1996|
|Publication number||08641016, 641016, US 6008816 A, US 6008816A, US-A-6008816, US6008816 A, US6008816A|
|Inventors||Craig G. Eisler, G. Eric Engstrom|
|Original Assignee||Microsoft Corporation|
|Export Citation||BiBTeX, EndNote, RefMan|
|Patent Citations (16), Non-Patent Citations (2), Referenced by (75), Classifications (5), Legal Events (6)|
|External Links: USPTO, USPTO Assignment, Espacenet|
This application is related to the following co-pending U.S. patent applications, which are commonly assigned:
Resource Management For Multimedia Devices In A Computer by Craig G. Eisler and G. Eric Engstrom, filed on Apr. 25, 1996 as application Ser. No. 08/396,522;
Method And System For Flipping Images In A Window Using Overlays by G. Eric Engstrom and Craig G. Eisler, filed on Apr. 25, 1996 as application Ser. No. 08/639,333;
Method And System In Display Device Interface For Managing Surface Memory by G. Eric Engstrom and Craig G. Eisler, filed on Apr. 25, 1996 as application Ser. No. 08/641,015;
Multimedia Device Interface For Retrieving And Exploiting Software And Hardware Capabilities by G. Eric Engstrom and Craig G. Eisler, filed on Apr. 25, 1996 as application Ser. No. 08/641,017;
Display Device Interface Including Support For Generalized Flipping Of Surfaces by Craig G. Eisler and G. Eric Engstrom, filed on Apr. 25, 1996 as application Ser. No. 08/641,014; and
System For Enhancing Device Drivers by Craig G. Eisler and G. Eric Engstrom, filed on Apr. 25, 1996 as application Ser. No. 08/637,530.
These applications are hereby incorporated by reference.
The invention relates to the process of color specification in computer graphics applications, and more specifically relates to color tables or palettes.
In computer graphics, a color image typically comprises a two dimensional array of binary color values, called a pixmap. The elements in the array are sometimes referred to as pixel values or "pixels," which represent the individual picture elements of an image. To display these pixels, a display controller typically reads the elements in an array, converts them into values compatible with the display monitor and controls the monitor's display of the image. For example, a display screen on a raster display device is comprised of an array of pixels. In the process of displaying an image on the monitor, the raster scans across the display screen energizing the individual picture elements with an electron beam based on the color values for each pixel.
A color table or "palette" is often used to compress a color image. Rather than store color values for each pixel, the pixmap can store indices into a color table instead. The entries in the color table store color values, which represent the available color choices for the pixmap or pixmaps that refer to the table. While the available color choices do not represent every conceivable color choice, they are generally deemed sufficient for the their particular application.
A color table is a form of image compression because the indices to a color table occupy fewer bits than the corresponding entries in the table. The trade off is that the color table represents a limited range of color choices. Consider the following example. One of the ways to represent the color of a pixel is to store a binary value for the Red, Green, and Blue (RGB) color components. For example, a color image can be represented with 8 bit R, G, B values. The total length of a pixel would then be 24 bits. Now, if the image is represented with only 256 colors for example, each of the 8 bit RGB values for these 256 colors can be stored in a color table having 256 entries. This color table is sometimes called an 8 bit color table because the entries to the table can be represented by an 8 bit number. Instead of storing 24 bits for each pixel in an image, each pixel can be represented by a single 8 bit index to the color table. By using the color table, the image is compressed by about a factor of 3.
While color tables provide an effective form of compression, they can also lead to difficult bookkeeping problems for application programmers. The images used in a typical game application, for example, may refer to different and inconsistent color tables. Ultimately, the display controller must have the accurate color information in order to generate the display image properly.
The invention provides an improved method of managing color palettes that is particularly adapted for a software interface to a display device, but can also be adapted for use in a variety of computer generated graphics applications. The display device interface supports a variety of palette types including palettes whose entries include indices to other palettes.
The display device interface includes a number of services that enable applications to control palettes. These services include functions to create palette structures representing palettes, to associate palettes with on or off screen pixmaps, and to manipulate the entries in palettes.
In addition to palettes with entries that store RGB or YUV color values, the display device interface can be used to create and manipulate palettes with entries that refer to another palette. For example, a palette having n entries can store indices to a second palette having m entries, where n is less than m. The second palette has entries that store color values. A specific example of this type of palette is a 4 bit on 8 bit palette. The 4 bit palette entries store indices to entries in another palette rather than color triplets.
The support for this type of palette in the display device includes a method for decoding the palette. When first pixmap associated with this type of palette is copied to a second pixmap associated with a palette that stores color values, the pixels in the first pixmap are decoded. The display device interface performs this decoding or instructs the display controller to do so. After the pixel values are copied, they are no longer indices to indices in the second palette, but instead are indices to the second palette. Another aspect of the invention is the manner in which palettes are associated with pixmaps. When an application asks the display device interface to create a palette, the display device interface creates the palette and also creates a palette structure to represent the palette. Palettes are associated with pixmaps by attaching a palette structure, representing a palette, to a surface structure representing the pixmap. To manipulate the color table of the display controller, an application can attach a palette structure to a surface structure representing the primary surface. The display device interface sets the entries in the color table of the palette to the entries of the palette attached to the primary surface.
Further features and advantages of the invention will become apparent with reference to the following detailed description and accompanying drawings.
FIG. 1 is a general block diagram of a computer system in which an embodiment of the invention can be implemented.
FIG. 2 is a block diagram illustrating the architecture of a display device interface 50 in which an embodiment of the invention is implemented.
FIGS. 3A, 3B, 3C, and 3D are block diagrams showing four examples of display device architectures.
FIG. 4A is a diagram illustrating a palette with entries that store indices into a larger palette.
FIG. 4B is a diagram illustrating the relationship between the palettes in FIG. 4A and associated palette structures.
FIGS. 5A and 5B are diagrams illustrating an example of a palette with entries that store indices to another palette.
FIGS. 6A and 6B diagrams illustrating how a palette structure can be associated with a surface structure or surfaces structures representing surface memory.
FIG. 7 is a diagram illustrating an example of surfaces associated with palettes whose entries refer to entries in the palette of a destination surface.
FIG. 8 is a block diagram illustrating the object architecture in one embodiment.
FIG. 9 is a flow diagram illustrating an implementation of creating a 4-bit on 8-bit palette.
FIG. 10 is a flow diagram illustrating an implementation of creating a 4-bit palletized surface.
FIG. 11 is a flow diagram illustrating an implementation of copying a 4-bit on 8-bit palletized surface to an 8-bit palletized surface.
FIG. 12 is a flow diagram illustrating an implementation of copying an 8-bit palletized surface to another 8-bit palletized surface.
FIG. 1 is a general block diagram of a computer system 20 in which an embodiment of the invention can be implemented. The computer system 20 includes as its basic elements a computer 22, one or more input devices 24 and one or more outputs device 26. The computer system can also include a communication device 25 and an auxiliary processing device 27.
Computer 22 generally includes a central processing unit (CPU) 28 and a memory system 30 that communicate through a bus structure 32. CPU 28 includes an arithmetic logic unit (ALU) 33 for performing computations, registers 34 for temporary storage of data and instructions and a control unit 36 for controlling the operation of computer system 20 in response to instructions from a computer program such as an application or an operating system.
Memory system 30 generally includes high-speed main memory 38 in the form of a medium such as random access memory (RAM) and read only memory (ROM) semiconductor devices, and secondary storage 40 in the form of a medium such as floppy disks, hard disks, tape, CD-ROM, etc. or other devices that use optical, magnetic or other recording material. Main memory 38 stores programs such as a computer's operating system and currently running application programs.
In some implementations, portions of main memory 38 may also be used for displaying images through a display device.
Input device 24 and output device 26 are typically peripheral devices connected by bus structure 32 to computer 22. Input device 24 may be a keyboard, pointing device, pen, joystick, head tracking device or other device for providing input data to the computer.
Output device 26 may be a display device, printer, sound device or other device for providing output data from the computer.
The communication device 25 can include any of a variety of peripheral devices that enable computers to communicate. For example, the communication device can include a modem or a network adapter.
The auxiliary processing device 27 refers generally to a peripheral with a processor for enhancing the performance of the computer. One example of an auxiliary processing device is a graphics accelerator card.
It should be understood that FIG. 1 is a block diagram illustrating the basic elements of a computer system; the figure is not intended to illustrate a specific architecture for a computer system 20. For example, no particular bus structure is shown because various bus structures known in the field of computer design may be used to interconnect the elements of the computer system in a number of ways, as desired. CPU 28 may be comprised of a discrete ALU 33, registers 34 and control unit 36 or may be a single device in which one or more of these parts of the CPU are integrated together, such as in a microprocessor. Moreover, the number and arrangement of the elements of the computer system may be varied from what is shown and described in ways known in the art.
The invention may be implemented in any of a number of well-known computer systems. For instance, the invention may be implemented in a personal computer (PC), such as IBM-AT compatible computers or computer systems based on the 80386, 80486, or Pentium processors from Intel Corporation. Alternatively, the invention may be implemented on any number of computer workstations, such as machines based on a RISC (reduced instruction set computing) architecture. The above systems serve as examples only and should not be construed as limiting the type of computer system in which the invention may be implemented.
FIG. 2 is a block diagram illustrating the architecture of a display device interface 50 in which an embodiment of the invention is implemented. This diagram illustrates relationships between application programs ("applications") 52, the display device interface 50, the hardware abstraction layer 54, and the display hardware 56. Applications 52 access the display hardware 56 through the display device interface 50, which serves as a device independent interface to the display hardware 56. The display device interface 50 performs parameter validation, memory management of the video memory, and bookkeeping for the interface. We describe specific features of the interface in further detail below.
The HAL (hardware abstraction layer) 54 is a hardware dependent interface to the display hardware 56. In this embodiment, the HAL includes only hardware specific code. It can be an integral part of the display hardware 56, or in the alternative, can be implemented in software on the host computer (22 in FIG. 1, for example). In the latter case, the HAL is typically implemented as a dynamic linked library (DLL). The HAL is implemented by and available from the manufacturer of the display card or chip.
The display device 50 interface can optionally include a hardware emulation layer (HEL) 58 to emulate display hardware features if they are not available in the display hardware.
The display hardware 56 includes the hardware devices within and/or coupled to the host computer that are responsible for displaying visual data including 2D and 3D rendered graphics and animation, video, text and still images.
FIGS. 3A, 3B, 3C, and 3D are block diagrams showing four examples of display device architectures. FIG. 3A illustrates the architecture of a video card 70 which includes video memory implemented with DRAM (dynamic random access memory) 72. FIG. 3B illustrates the architecture of a display card 74 which includes video memory implemented with VRAM (video random access memory) 76. The video cards shown in FIGS. 3A and 3B represent only two examples of video cards with significant on board memory in common use today. For example, there are numerous types of RAM (random access memory) used on video cards. VRAM and DRAM are just two common examples. The display device interface 50, shown generally in FIG. 2, is designed to be compatible with a wide variety of display controllers whether implemented in a video card, in a video chip in the computer, or some other configuration. FIG. 3C illustrates the architecture of a multimedia card where the memory used by the display card is shared with other accelerators. FIG. 3D illustrates the architecture of a display card where the memory used by the display card is shared with the host processor. The display device interface is intended to work across any of these architectures, combinations of them, or other architectures for storing and composing pixmaps onto a display device.
The video card in FIG. 3A includes as its basic elements a graphics controller 78, video memory 72 implemented with DRAM, and a digital-to-analog converter 80. In this type of video card, each of these elements share a common bus 82. On one side, the video card is connected to a bus 84 on the host computer via a bus interface 86. On the other side, the video card is connected to a physical display device such as a display monitor 88. To generate the video display, the video card 70 receives image data and display commands from the host computer (22, for example) and controls the transfer of image data to a display monitor 88. The graphics controller 78 is responsible for acceleration and other graphics operations. When the digital-to-analog converter 80 needs to take the digitally represented image data from the DRAM and send it to the monitor, the graphics controller 78 is placed on hold until the DAC 80 finishes its task.
The video card 74 in FIG. 3B includes a graphics controller 90, video memory 76 implemented with VRAM, and a DAC 92. One significant difference between the design of this card and the card in FIG. 3B is that the graphics controller 90 and DAC 92 access the VRAM 76 through separate ports (94, 96). Coupled to a peripheral bus 98 of the host computer via a bus interface 100, the video card 74 receives image data and commands from its host and controls the display of image data stored in the video memory 76. Since the VRAM is dual ported, the DAC 92 can transfer image data to the monitor 1020 as the graphics controller 90 performs operations on other image data in the video memory.
The video card 1006 in FIG. 3C includes a graphics controller 1014, "video" memory 1008 (which is not specific to any particular technology used to implement the memory), and a DAC 1016. One significant difference between the design of this card and the card in FIG. 3B is that the graphics controller 1014 shares the "video" memory with other controllers 1010/1012 and the DAC 1016. The other controllers 1012 are sometimes used to control other peripherals, including I/O devices 1018 such as a mouse, track ball, joy stick, or sound card. There are many memory architectures for these types of cards and the device display interface supports all of them. Coupled to a peripheral bus 1000 of the host computer via a bus interface 1002, the video card 1006 receives image data and commands from its host and controls the display of image data stored in the "video" memory 1008. Arbitration between other controllers can be handled either in the HAL or by the hardware.
The video card 1056 in FIG. 3D includes a graphics controller 1064, "video" memory 1058 (which is not specific to any particular technology used to implement the memory), and a DAC 1066. One significant difference between the design of this card and the card in FIG. 3B is that the graphics controller 1064 shares the "video" memory with the host processor and the DAC 1066. There are many memory architectures for these types of cards and the device display interface supports all of them. Coupled to a peripheral bus 1050 of the host computer via a bus interface 1052, the video card 1056 receives image data and commands from its host and controls the display of the image data on the display monitor 1070. Arbitration between other peripherals on the bus can be handled either in the HAL, by the video card 1056, by the operating system, or the bus.
The display device interface 50 shown in FIG. 2 acts as an interface to display hardware such as the video cards (70, 74, 1006, 1056) illustrated in FIGS. 3A, 3B, 3C and 3D. The display device interface 50 enables applications to access video memory (72, 76, 1008, 1058, for example), including both off screen and on screen memory. It also gives the applications access to special purpose graphics hardware (78, 90, 1014, and 1064, for example), where available, to enhance performance. In cases where the underlying graphics hardware does not support a requested service, the interface can potentially emulate the service through the software in the HEL 58.
The display device interface enables applications to access and manipulate color palettes. A palette, in the context of the display device interface, can include a series of entries that hold color values such as RGB or YUV, or alternatively, can hold indices into another palette. The latter type of palette is particularly helpful in applications where a number of pixmaps, each with associated color palettes, are used to compose display images. Instead of storing color values in each color palette, some color palettes can store indices into another color palette. This feature improves color specification because it increases the chances that an application's intended color specification will match the color that the display controller actually uses to generate the display image.
For example, a four bit palette of this type can have entries that store indices into an 8 bit palette. Through the display device interface, applications can manage several 4 bit palettes of this type with entries that refer to a single 8 bit palette with 256 entries for storing the color values. Since the color values are stored in one place for several pixmaps, the application is more likely to produce consistent and accurate colors in the display image.
While we use the example of a 4 bit on 8 bit palette here, it is also possible to apply this concept more broadly. In general, a palette having n entries can hold indices into a palette having m entries, where n and m are integers and n is less than m. FIG. 4A is a diagram illustrating a palette 120 with entries (122-126) that store indices to entries (128-132, for example) of a larger palette 134. The indices stored in the smaller palette are graphically represented by the arrows 136-140 from entries in the first palette to entries in the second palette. The smaller palette has an integer number of entries n, and the larger palette has an integer number of entries, m, where n is less than m.
In the typical case, the value of n and m are powers of 2, and the color indices in an associated pixmap are binary numbers. For example, a 4 bit palette refers to a palette where the indices are represented using a 4 bit binary number. A 4 bit palette typically has 16 entries (24). However, the number of entries in a palette does not have to be a power of 2.
This type of palette provides a layer of indirection for the pixmaps associated with it. This means that the palette entry refers to an entry in another palette, rather than storing a color value or values.
The display device interface enables applications to manipulate the palettes of the type shown in FIG. 4A through a palette structure. FIG. 4B is a diagram illustrating the relationship between palette structures 150, 152 and their associated palettes 154, 156. The palette structure includes a reference pointer 158, 160 to the underlying palette, which can be stored in system memory or video memory. The palette structure 150, 152 can also store other information about the palette such as its type, whether the entries have indices or actual color values, the number of entries, etc.
The display device interface, illustrated in FIG. 2, creates a palette structure and associated palette in response to a request from an application. The display device interface also includes services to get and set entries in the palette. To create a palette, an application or other process using the display device interface invokes a create palette service and specifies the type of the palette. The display device allocates memory for the palette and gives the application a reference to the palette structure. The application can then manipulate the palette through the palette structure. For example, it can set and get entries from the palette by using the get and set entry services and specifying the palette structure that it wants to manipulate.
FIGS. 5A and 5B are diagrams illustrating an example of a palette 170 with entries that store indices to another palette 172. FIG. 5A illustrates the relationship between a small, precomputed pixmap 174 and a palette 170 with entries (176-180) that contain indices into a 8 bit palette 172 shown in FIG. 5B. FIG. 5B illustrates the relationship between a larger, composited image 182 and the 8 bit palette 172 with entries (184-186) that store RGB color values. In this example, the precomputed pixmap 174 is comprised of 4 bit values, which are indices into a 4 bit palette 170. In turn, the entries in the 4 bit palette 170 store indices into an 8 bit palette, which serves as the palette for the large, composited image.
For the purpose of this example, assume that there is a lime green pixel 190 in the precomputed pixmap 174, and that the RGB values for the color lime green are stored as the entry number 17 (184) in the 8 bit palette 172 as shown in FIG. 5B. The palette associated with the small pixmap does not have an entry with the RGB values of the lime green color, but instead it has an entry (3, in this example) 192 that stores the entry number (17) of the 8 bit palette. To represent a lime green pixel in the small image, the pixmap stores an index to entry number 3, which corresponds to the entry storing the number 17. For this type of palette, each of the entries of the smaller palette store indices to a color value stored in a larger palette.
In one implementation of the display device interface, a palette is associated with a pixmap by "attaching" the palette structure to another structure representing a region in memory that holds the pixmap. This region in memory is generally referred as surface memory. A surface refers an array of image data. In the typical case, a surface is a pixmap, but it can also be an array of alpha or z values.
Pixmap surfaces can be classified as either "on" or "off" screen and can represent a variety of types of images. For instance, pixmap surfaces in this implementation of the display device interface include a primary surface, or surfaces representing overlays, sprites or texture maps. The "primary surface" represents the pixmap that is currently visible on a display monitor. The primary surface resides at a region in video memory that the display controller is reading and converting to generate a display screen. An overlay refers to a pixmap that is superimposed or combined with another pixmap, such as the primary surface. A sprite typically refers to an image smaller than the size of the display screen that is composited with another pixmap, usually the primary surface. A texture map is a pixmap that is mapped to the surface of a three dimensional (3D) graphical model. Texture maps or "textures" are used in 3D graphics rendering operations to represent fine surface detail on a graphical object. While we have listed a variety of types of pixmaps, this list is not intended to be exhaustive, but merely exemplary of the types of pixmaps which a palette can be associated with.
FIG. 6A illustrates an example of how a palette structure 200 can be associated with or "attached" to a surface structure 202. As shown in this example, the palette structure 200 includes a reference pointer 204 to the palette 206 that it represents. The palette 200 is associated with a surface 208 by the attachment link 210 between the palette structure 200 and a surface structure 202 representing the surface. The surface structure 202 manages a surface by maintaining a reference pointer 212 to the surface memory 214 holding the surface and by maintaining the attachment link 210 to the associated palette structure 200.
FIG. 6B is a diagram illustrating how a palette 220 can be attached to different surfaces. In this example, two surface structures 222, 224, representing different regions in surface memory 226, 228, refer to the same palette structure 230. The palette structure 230 is attached to both surface structures 222, 224 via attachment links 232, 234.
One embodiment of the display device interface includes a function to associate a palette with a specified surface. This function enables an application to associate a palette with a number of different surfaces. Conversely, surfaces can each have separate palettes.
The palette associated with the primary surface represents the color table of the display controller. To specify the proper color values in this color table, an application can create a palette structure, attach it to the primary surface, and then set the entries in the palette.
Another possible use of attachable palettes to attach different palettes to several surfaces that are combined into a destination surface. The entries of each of these palettes can either store color values or indices to the palette attached to the destination surface.
FIG. 7 is a diagram illustrating an example where several surfaces 240-248 have palettes 250-254 whose entries refer to entries in the palette 256 of the destination surface 258. To differentiate between surfaces, we refer to the smaller surfaces 240-248 shown in FIG. 7 as source surfaces because they will be combined with the destination surface 258 to create a new image in this example. Each of the source surfaces 240-248 is represented by a surface structure 260-268, which refers to a corresponding region in surface memory 270-278. The surface structures 260-268 of the source surfaces have attached palettes 250-254 as represented by the attachment links 280-286 in FIG. 7. Two of the surface structures 264, 266 in this example refer to the same palette 254.
The palettes 250-254 of the source surfaces have entries (288, 290, 292, for example) that store indices into the palette of the destination image. This is represented by the arrows linking the entries 288, 290, 292 of the palettes for the source surfaces to the entries 294, 296, 298 in the palette for the destination image.
One of the source surface structures (268) does not have an attached palette. In one implementation, this condition is addressed by using the palette of the primary surface as a default in cases where a surface does not have an associated palette.
For the purposes of this example, assume that the source surfaces 240-248 shown in the FIG. 7 are copied into the destination image 258 using a bit block transfer. During this operation, the pixel values in the source surfaces are decoded so that they are no longer an index to an index to the palette of the destination surface, but instead, are each an index to an entry of the palette of the destination surface. If it has the capability, the display controller can decode the pixel values. Otherwise, this decoding can be emulated in software. To decode the palette entries, the display controller (or host processor in emulation mode) looks up the palette entry in the palette for the source pixmap, finds the index into the palette of the destination pixmap, and then replaces the pixel value with an index into the palette of the destination pixmap. The display controller repeats this for each of the pixel values copied to the destination image.
The functions in the display device interface described above can be implemented in a variety of different ways. Either procedural or object oriented programming approaches can be used. In one specific embodiment, palette structures and functions relating to them and are implemented using an object oriented approach.
In this embodiment, the display device interface shown in FIG. 2 is implemented as an object that represents the underlying display device hardware. There can be one instance of a display device object for every logical display device in operation. For example, a software development environment may have two monitors, one running a game using the display device interface shown in FIG. 2, and another running the development environment using an alternative display device interface such as GDI (the graphics device interface), which is part of the Windows® 95 operating system from Microsoft Corporation.
The display device object in this particular architecture owns all of the global attributes of the display device (e.g. video card) that it represents. It controls default values for the global attributes such as the color key values, color depth, resolution and the hardware's display mode. As explained further below, it also can control a default color table or palette for the primary surface.
In this implementation of the display device interface, the display device object includes a number of member functions to create additional objects, which provide services through their respective member functions. These objects include a surface object, a palette object, and a clipper object.
A surface object is a specific way to implement the surface structures described above. A surface object, therefore, represents a region in memory that holds a pixmap, an alpha buffer, or a Z buffer, for example. The member functions of the surface object provides services for managing and manipulating surfaces. As explained in further detail below, these services include functions to flip surfaces, attach or detach a surface, perform a bit block transfer, list surfaces attached to a given surface, return capabilities of the surface, return the clipper object attached to the surface, attach a palette to a surface, get an attached palette attached to a surface, etc.
A palette object is an object that represents a palette. In this implementation, a palette object becomes associated with a surface object when attached to it. Palette objects can be attached to the pixmap surfaces described above such as the primary surface, an off screen surface, a texture map, a sprite and an overlay. Each of the palette objects attached to these surfaces can represent different palettes. Alternatively, several surface objects can be attached to the same palette object.
One embodiment of the display device interface simplifies color specification for surfaces by supporting default palettes. If a surface object does not have an attached palette, it automatically defaults to the palette of the primary surface. In this architecture, the display device object controls the default palette. This feature simplifies color specification because the application does not have to specify a color palette for every pixmap used to construct the display image. The application can control color specification by setting the color palette of the primary surface. All the application needs to do is 1) create a palette object by invoking the create palette member function of the display device object; 2) set the entries of the palette using the member functions of the palette object, and 3) attach the palette object to the primary surface. When the application requests the display device interface to attach the palette object to the primary surface, the display device interface automatically sets the color table of the display controller to correspond to the palette entries of the attached palette object.
The clipper objects represent clip lists. A clipper object can be attached to any surface. In one implementation of the display device interface for a windowing environment, a window handle can be attached to a clipper object. Using the information provided by the window handle, the display device interface can update the clip list of the clipper object with the clip list of the window as the clip list for the window changes.
In order to create a surface, palette or clipper object, the application first creates an instance of a display device object. The application can then create one of these objects by invoking one of the display device object's member functions to create the object.
FIG. 8 is a block diagram illustrating the object architecture in one embodiment. The display device object 300 for a display device is the creator and owner of the surface objects 302-308 and palette objects 310-312 for that display device. It is responsible for managing all of the objects that it creates. This ownership relationship is represented by the solid arrows 314, 316, 318 from the 30 display device object 300 to its surface objects 302-308 and palette objects 310-312. The palette objects 310-312 are attached to associated surface objects via attachment links 320, 322.
To create a surface object in this architecture, the application calls the display device object's "create surface" member function. In response, the CreateSurface member function creates a surface object that represents a surface and the underlying surface memory that holds it. The member function creates a surface object with the attributes and capabilities specified by the application. If the application requests a complex surface (a surface structure including more than one surface), then the member function in this implementation creates instances of surface objects for each surface.
The application can specify the attributes of the surface object by setting fields in a surface description structure that it passes to the create surface member function.
To create a palette object in this implementation, an application invokes the CreatePalette member function of the display device object. The application specifies the type of palette that it wants by setting one or more flags and passing these flags to the display device interface. For example, these flags can specify that the palette is a 4 bit palette with color entries, an 8 bit palette with color entries, or a 4 bit palette with entries that are indices to another palette.
FIG. 9 illustrates the process of creating a palette. An application requests a 4-bit on 8-bit palette be created at 900. If the hardware natively supports the creation of a 4-bit on 8-bit palette (902), the Hardware Abstraction Layer (HAL) entry in the display device driver is called to create the palette (903).
Otherwise, a software palette is created (904). Once this is done, the display device interface creates a palette object (905). Finally, the initial entries specified to the CreatePalette member function are copied to the palette 906.
The surface object includes member functions to attach a palette object to an instance of a surface object (SetPalette) and to get a palette object attached to a specified surface object (GetPalette). The SetPalette member function attaches a specified palette object to a surface object. After a palette is attached to a surface object, the surface object uses this palette for subsequent operations. When the SetPalette function is invoked, the palette change takes place immediately, without regard to refresh timing. The GetPalette function is used to get the palette structure associated with a specified surface object. If no palette has been explicitly associated with the surface object referred to in the function call, then the GetPalette function returns NULL, unless the surface object represents a primary surface or the back buffer of the primary surface. In this case, the GetPalette function returns a pointer to the system palette.
A surface object is created (FIG. 10) for a 4-bit palletized surface. An application calls the CreateSurface member function of the display device interface (910). The CreateSurface member function would allocate the pixel memory (911), and associate this pixel memory with the a surface object that is created (912).
Once the surface object is created and has the palette object associated with it, this surface object can have its pixel modified. An implementation of the surface object has a Lock function which provides a pointer to the pixel memory. An Unlock member function is also provided; it is called when an application is done updating the pixel memory.
To copy the pixel memory of the 4-bit on 8-bit palletized surface to an 8-bit palletized surface, the surface object provides a Blt member function. FIG. 11 illustrates the use of the of the Blt function to do this. An application calls the source surface object's Blt member function with the source surface object and the destination surface object as parameters (1020). The source surface object represents a 4-bit on 8-bit palletized pixmap and the destination surface object represents an 8-bit palletized pixmap (1020). The Blt member function checks if the hardware supports the operation (1021); if it does, the HAL function in the display device driver is called to perform the pixel copy (1022). If the hardware does not support the operation, then a software implementation can be used (1023)
One possible implementation of software pixel copy would loop through each of the pixels in the 4-bit on 8-bit palletized surface (1024). The pixel is a 4-bit value that is used to look up the corresponding 8-bit value (1025). This 8-bit value is then stored in the 8-bit palletized surface (1026).
FIG. 12 illustrates how a copy of pixels between two palletized surfaces may be processed. FIG. 12 shows both the case where the source surface object has a palette, and the case where the source surface object has no palette. The processing begins when an application calls the Blt member function of the source surface object (1030). The Blt member function is responsible for the block copy of pixels between two pixmaps. Both the source and destination surface objects are specified to the Blt member function.
The Blt member function verifies that the destination surface object has an attached palette (1031). If it does not have an attached palette (1038), an error is returned. The Bit member function then checks if the source surface object has an attached palette (1032). If it does not have an attached palette, then the Blt member function will have the pixels copied directly from the source pixmap to the destination pixmap (1033).
If there is an attached palette, the following method may be used. First, the Blt function checks if the palettes attached to each surface are an exact match (1034). If they are an exact match, then the Blt member function will have the pixels copied directly from the source pixmap to the destination pixmap (1033). When the palettes are not an exact match, then a palette matching procedure is required. For each pixel in the source pixmap (1035), the Bit member function must look at the RGB value corresponding to the palette index and find the closest matching RGB value in the destination palette (1036). Once this match is found, the corresponding palette index is written into the destination pixmap (1037).
Palette objects have member functions to allow a consumer such as an application or other process to manipulate the underlying palette. These member functions include GetCaps, GetEntries, and SetEntries,
The GetCaps function is used to get the capabilities of the palette object. To get the capabilities of a palette, an application calls this function and specifies the palette object by passing a pointer to the structure representing the palette.
Examples of the capabilities of a palette object include the type of palette such as a 4 bit, 8 bit, or a palette having entries that index another palette. Other examples of a capabilities are whether the associated palette is attached to the primary surface, and whether changes can be made to the palette that are synced with the vertical refresh rate.
The GetEntries function is used to query palette entries from a palette. To retrieve palette entries, an application can call this function and specify the desired entries by providing the starting entry and the number of entries to be retrieved from the palette.
The SetEntries function is used to change the entries in a palette. To invoke this function for specific palette entries, the application calls the function and passes the starting point of the entry to be changed, the number of entries to be changed, and the new values for the entries. In response to this call, the SetEntries function changes the specified entries immediately.
In one specific implementation, the objects in the display device architecture described above are implemented as COM interfaces. The member functions of the object types include the standard member function of a COM interface in addition to the specific functions described above. Specific examples of the member functions relating to palettes are provided in more detail in Appendix A, which is incorporated by reference.
Having described and illustrated the principles of our invention with reference to a preferred embodiment and several alternative embodiments, it should be apparent that the invention can be modified in arrangement and detail without departing from its principles. Accordingly, we claim all modifications as may come within the scope and spirit of the following claims.
Forming a part of the present specification is the following:
APPENDIX A__________________________________________________________________________ Copyright in the following material is retained by Microsoft Corporation ofRedmond, Washington. The following is an example of a member function of a display deviceobject used to create a palette object.HRESULT CreatePalette(LPDIRECTDRAW lpDD,DWORD dwFlags,LPPALETTEENTRY lpColorTable,LPDIRECTDRAWPALETTE FAR* lplpDDPalette,IUnknown FAR *pUnkOuter) The CreatePalette member function returns DD-- OK if successful,otherwise it returns one of a number of error values. The arguments to the CreatePalette member function are as follows,lpDDPoints to the structure representing the display device object.dwFlagsThe flags for the implementation of the CreatePalette member function aresetforth below.DDPCAPS-- 4BITIndex is 4 bits. There are sixteen color entries in the palette table.DDPCAPS-- 8BITENTRIESIndex is onto an 8-bit color index. This field is only valid with theDDPCAPS-- 4BITINDEX capability and the target surface is in 8bpp.Eachcolor entry is one byte long and is an index into destination surface's8bpppalette.DDPCAPS-- 8BITIndex is 8 bits. There are 256 color entries in the palette table.DDPCAPS-- ALLOW256This palette can have all 256 entries defined.DDCAPS-- INITIALIZEIndicates that this palette object should use the palette color arraypassed intothe lpDDColorArray parameter to initialize the palette object.lpColorTablePoints to an array of 16 or 256 PALETTEENTRY structures that will beused to initialize this palette object.lplpDDPalletePoints to a pointer that will be filled in with the address of the newpaletteobject if the create palette member function is successful.HRESULT SetPalette(LPDIRECTDRAWSURFACE lpDDSurface,LPDIRECTDRAWPALETTE lpDDPalette) This function attaches the specified palette object to a surface object.The surface object will use this palette for all subsequent operations. The SetPalette member function returns DD-- OK if successful,otherwise it returns one of the following error values:DDERR-- INVALIDOBJECT DDERR-- INVALIDPARAMSDDERR-- NOEXCLUSIVEMODE DDERR-- NOT8BITCOLORDDERR-- UNSUPPORTED DDERR-- GENERICDDERR-- NOPALETTEATTACHED DDERR-- NOPALETTEHWDDERR-- SURFACELOSTlpDDSurfacePoints to the surface structure representing the surface.lpDDPalettePointer to the palette structure that this surface object should use forfutureoperations.HRESULT GetPalette(LPDIRECTDRAWSURFACE lpDDSurface,LPLPDIRECTDRAWPALETTE lplpDDPalette) The GetPalette function is used to get the palette structure associatedwith this surface. If no palette has been explicitly associated with thissurface then itreturns NULL for the associated palette, unless this is the primarysurface or a backbuffer to the primary surface, in which case it returns a pointer to thesystem paletteif the primary surface is in 8bpp mode. This function returns DD-- OK if successful, otherwise it returns one ofthe following error values:DDERR-- INVALIDOBJECT DDERR-- INVALIDPARAMSDDERR-- SURFACELOST DDERR-- UNSUPPORTEDDDERR-- GENERIC DDERR-- NOEXCLUSIVEMODEDDERR-- NOPALETTEATTACHEDlpDDSurfacePoints to the surface structure representing the surface.lplpDDPalettePoints to a pointer to a palette structure. This pointer will be filledin with theaddress of the palette structure associated with this surface. This willbe set toNULL if there is no DirectDrawPalette associated with this surface. The palette object can include a number of member functions to allow aconsumer of a palette object to manipulate the underlying palette. Someofthese member functions are described in further detail below.HRESULT GetCaps(LPDIRECTDRAWPALETTE lpDDPalette,LPDWORD lpdwCaps) This function is used to get the capabilities of the palette objectspecified in an argument to the call with a pointer to the palettestructurerepresenting the palette. The GetCaps function returns DD-- OK if successful, otherwise itreturns one of the following error values:DDERR-- INVALIDOBJECT DDERR-- INVALID PARAMSlpDDPalettePoints to the DirectDrawPalette structure returned to the applicationwhenthe DirectDrawPalette was created.lpdwCapsFlags for lpdwCaps.DDPCAPS-- 4BIT DDPCAPS-- 8BITENTRIESDDPCAPS-- 8BIT DDPCAPS-- ALLOW256DDPCAPS-- PRIMARYSURFACE DDPCAPS-- PRIMARYSURFACELEFTDDPCAPS-- VSYNC The meaning of these flags is set forth below.DDPCAPS-- 4BITThis flag indicates that the index is 4 bits, and that there are sixteencolorentries in the palette table.DDPCAPS-- 8BITENTRIESThis flag indicates that the index is onto an 8 bit color index. Thisfield isonly valid with the DDPCAPS-- 4BIT capability and the target surfaceis in8bpp. Each color entry is one byte long and is an index into destinationsurface's 8bpp palette.DDPCAPS-- 8BITThis flag indicates that the index is 8 bits, and that there are 256color entriesin the palette table.DDPCAPS-- ALLOW256This flag indicates that the palette can have all 256 entries defined.DDPCAPS-- INITIALIZEThis flag indicates that this palette should use the palette color arraypassedinto the lpDDColorArray parameter to initialize the palette object.DDPCAPS-- PRIMARYSURFACEThis palette is the one attached to the primary surface. Changing thistablehas immediate effect on the display unless DDPAL-- VSYNC isspecified andsupported.DDPCAPS-- PRIMARYSURFACELEFTThis palette is the one attached to the primary surface left. Changingthistable has immediate effect on the display unless DDPAL-- VSYNC isspecifiedand supported.DDPCAPS-- VSYNCThis palette can have modifications to it synced with the monitorsrefreshrate.HRESULT GenEntries(LPDIRECTDRAWPALETTE lpDDPalette,DWORD dwFlags,DWORD dwBase,DWORD dwNumEntries,LPPALETTEENTRY lpEntries ) The GetEntries function is used to query palette values from a paletteobject. It returns DD-- OK if successful, otherwise it returns one of thefollowing error values:DDERR-- INVALIDOBJECT DDERR-- INVALIDPARAMSDDERR-- NOTPALETTIZEDlpDDPalettePoints to the palette structure returned to the application when theCreatePalette member was called.dwFlagsNot used at this time. Must be zero.dwBaseThis is the start of the entries that should be retrieved sequentially.dwNumEntriesThis flag indicates how many palette entries that an Entries structure(referredto by lpEntries) can hold. The colors of each palette entry will bereturned insequence starting from dwStartingEntry and proceeding through dwCount-lpEntriesA pointer to the palette entries. The palette entries are one byte eachif theDDPCAPS-- 8BITENTRIES field is set and four bytes otherwise. Eachfieldis a color description.DWORD Release(LPDIRECTDRAWPALETTE lpDDPalette) This function reduces the interface reference count on the palette objectcreated by and returned from the CreatePalette member. When the referencecountreaches zero, the object will be freed. This function returns the reference count of the object if successful, orzero if an error occurs.lpDDPalettePoints to the Palette structure returned to the client when theCreatePalettemember was called to create the palette object.HRESULT SetEntries(LPDIRECTDRAWPALETTE lpDDPalette,DWORD dwFlags,DWORD dwStarting Entry,DWORD dwCount,LPPALETTEENTRY lpEntries) This function is used to change entries in a palette. The changes will beperformed immediately. The palette must be attached to a surface usingtheSetPalette member before SetEntries can be used in this implementation. The SetEntries function returns DD-- OK if successful, otherwise itreturns one of the following error values:DDERR-- INVALIDOBJECT DDERR-- INVALIDPARAMSDDERR-- UNSUPPORTED DDERR-- NOTPALETTIZEDDDERR-- NOPALETTEATTACHEDlpDDPaletteThe pointer to the palette structure returned to the client when theCreatePalette member was called to create the target palette.dwFlagsNot currently used.dwStartingEntryThe first entry to be set.dwCountThe number of palette entries to be changed.lpEntriesThe palette entries are one byte each if the DDPCAPS-- 8BITENTRIESfieldis set and four bytes otherwise. Each field is a color description__________________________________________________________________________
|Cited Patent||Filing date||Publication date||Applicant||Title|
|US4979032 *||Dec 27, 1988||Dec 18, 1990||Eastman Kodak Company||Color imaging apparatus producing on various image receptive materials a visually matched hard copy reproduction of a video image displayed|
|US5065234 *||Jun 6, 1990||Nov 12, 1991||Konica Corporation||Method and apparatus for correcting the color of a printed image|
|US5233684 *||Jun 26, 1990||Aug 3, 1993||Digital Equipment Corporation||Method and apparatus for mapping a digital color image from a first color space to a second color space|
|US5235677 *||Jun 2, 1989||Aug 10, 1993||Atari Corporation||Raster graphics color palette architecture for multiple display objects|
|US5384902 *||Dec 24, 1991||Jan 24, 1995||Aldus Corporation||Method for generating a fast inverse table|
|US5394518 *||May 27, 1993||Feb 28, 1995||Microsoft Corporation||Luminance sensitive palette|
|US5394523 *||Jan 22, 1993||Feb 28, 1995||Taligent, Inc.||Polymorphic graphic device|
|US5412766 *||Oct 21, 1992||May 2, 1995||International Business Machines Corporation||Data processing method and apparatus for converting color image data to non-linear palette|
|US5428722 *||Nov 5, 1993||Jun 27, 1995||Taligent, Inc.||Object-oriented painter maker|
|US5455599 *||Apr 4, 1995||Oct 3, 1995||Taligent Inc.||Object-oriented graphic system|
|US5459486 *||Apr 18, 1994||Oct 17, 1995||University Of Washington||Method and apparatus for combining palettes of color quantized images|
|US5537579 *||Feb 18, 1994||Jul 16, 1996||Fujitsu Limited||Method and apparatus for managing color data|
|US5572235 *||Nov 2, 1992||Nov 5, 1996||The 3Do Company||Method and apparatus for processing image data|
|US5642137 *||Dec 11, 1991||Jun 24, 1997||Sony Corporation||Color selecting method|
|US5664080 *||Oct 20, 1992||Sep 2, 1997||International Business Machines Corporation||System and method for generating a universal palette and mapping an original color space to the universal palette|
|US5734368 *||Aug 18, 1994||Mar 31, 1998||U.S. Philips Corporation||System and method for rendering a color image|
|1||*||Implementing Games for Windows Using the WinG API and the WaveMix DLL, James Finnegan, Microsoft Systems Journal, pp. 61 81, Jan., 1995.|
|2||Implementing Games for Windows Using the WinG API and the WaveMix DLL, James Finnegan, Microsoft Systems Journal, pp. 61-81, Jan., 1995.|
|Citing Patent||Filing date||Publication date||Applicant||Title|
|US6275000 *||Nov 7, 2000||Aug 14, 2001||Mitsubishi Denki Kabushiki Kaisha||Method of controlling an induction motor and apparatus for carrying out the same|
|US6774908||Aug 31, 2001||Aug 10, 2004||Creative Frontier Inc.||System and method for tracking an object in a video and linking information thereto|
|US6812923||Mar 1, 2001||Nov 2, 2004||Microsoft Corporation||Method and system for efficiently transferring data objects within a graphics display system|
|US6819325||Mar 6, 2001||Nov 16, 2004||Microsoft Corporation||API communications for vertex and pixel shaders|
|US6828975||Mar 1, 2001||Dec 7, 2004||Microsoft Corporation||Method and system for managing graphics objects in a graphics display system|
|US6831635||Mar 1, 2001||Dec 14, 2004||Microsoft Corporation||Method and system for providing a unified API for both 2D and 3D graphics objects|
|US6874150||Mar 1, 2001||Mar 29, 2005||Microsoft Corporation||Method and system for maintaining connections between surfaces and objects in a graphics display system|
|US6900813 *||Oct 4, 2000||May 31, 2005||Ati International Srl||Method and apparatus for improved graphics rendering performance|
|US7023431||Mar 1, 2001||Apr 4, 2006||Microsoft Corporation||Method and system for providing data to a graphics chip in a graphics display system|
|US7091985 *||May 16, 2000||Aug 15, 2006||International Business Machines Corporation||System and method for compressing color data using expandable color palette|
|US7142216||Sep 9, 2004||Nov 28, 2006||Microsoft Corporation||API communications for vertex and pixel shaders|
|US7159041||Mar 1, 2001||Jan 2, 2007||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US7187384||Oct 25, 2004||Mar 6, 2007||Microsoft Corporation||Systems and methods for downloading custom or prefabricated processing routines to programmable graphics chips|
|US7200807||Aug 27, 2003||Apr 3, 2007||Enreach Technology, Inc.||System and process for object rendering on thin client platforms|
|US7336264 *||Nov 20, 2003||Feb 26, 2008||Avid Technology, Inc.||Method and system for editing or modifying 3D animations in a non-linear editing environment|
|US7466317||Jul 26, 2004||Dec 16, 2008||Microsoft Corporation||Method and system for managing graphics objects in a graphics display system|
|US7528829||Feb 3, 2006||May 5, 2009||Microsoft Corporation||Method and system for providing data to a graphics chip in a graphics display system|
|US7570268||Oct 25, 2004||Aug 4, 2009||Microsoft Corporation||Systems and methods for providing graphics data in parallel to graphics processing hardware|
|US7593017||Aug 15, 2006||Sep 22, 2009||3M Innovative Properties Company||Display simulator|
|US7629980 *||Oct 25, 2006||Dec 8, 2009||Via Technologies, Inc.||Color-revealing method, color-changing method and color-processing device|
|US7646388||Oct 25, 2004||Jan 12, 2010||Microsoft Corporation||Systems and methods for reducing redundant checks on graphics memory|
|US7659902||Jun 26, 2006||Feb 9, 2010||Microsoft Corporation||API communications for vertex and pixel shaders|
|US7761884||Oct 7, 2004||Jul 20, 2010||Microsoft Corporation||Method and system for maintaining connections between surfaces and objects in a graphics display system|
|US7773093||Aug 15, 2002||Aug 10, 2010||Creatier Interactive, Llc||Method and apparatus for associating the color of an object with an event|
|US7782316||Oct 22, 2004||Aug 24, 2010||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US7800606||Oct 22, 2004||Sep 21, 2010||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US7800607||Oct 22, 2004||Sep 21, 2010||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US7804506||Feb 25, 2004||Sep 28, 2010||Creatier Interactive, Llc||System and method for tracking an object in a video and linking information thereto|
|US7884817||Sep 2, 2004||Feb 8, 2011||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US7965288 *||Oct 22, 2009||Jun 21, 2011||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US8086275||Dec 27, 2011||Microsoft Corporation||Alternative inputs of a mobile communications device|
|US8175653||Mar 30, 2009||May 8, 2012||Microsoft Corporation||Chromeless user interface|
|US8238876||Mar 30, 2009||Aug 7, 2012||Microsoft Corporation||Notifications|
|US8250494||Aug 21, 2012||Microsoft Corporation||User interface with parallax animation|
|US8269736||May 22, 2009||Sep 18, 2012||Microsoft Corporation||Drop target gestures|
|US8355698||Mar 30, 2009||Jan 15, 2013||Microsoft Corporation||Unlock screen|
|US8385952||Jun 15, 2009||Feb 26, 2013||Microsoft Corporation||Mobile communications device user interface|
|US8411046||May 20, 2009||Apr 2, 2013||Microsoft Corporation||Column organization of content|
|US8432407||Jul 30, 2009||Apr 30, 2013||Microsoft Corporation||Method and system for managing graphics objects in a graphics display system|
|US8548431||Jun 8, 2012||Oct 1, 2013||Microsoft Corporation||Notifications|
|US8560959||Oct 18, 2012||Oct 15, 2013||Microsoft Corporation||Presenting an application change through a tile|
|US8612874||Dec 23, 2010||Dec 17, 2013||Microsoft Corporation||Presenting an application change through a tile|
|US8634876||Apr 30, 2009||Jan 21, 2014||Microsoft Corporation||Location based display characteristics in a user interface|
|US8687023||Aug 2, 2011||Apr 1, 2014||Microsoft Corporation||Cross-slide gesture to select and rearrange|
|US8689123||Dec 23, 2010||Apr 1, 2014||Microsoft Corporation||Application reporting in an application-selectable user interface|
|US8781533||Oct 10, 2011||Jul 15, 2014||Microsoft Corporation||Alternative inputs of a mobile communications device|
|US8825699||Apr 30, 2009||Sep 2, 2014||Rovi Corporation||Contextual search by a mobile communications device|
|US8830270||Oct 18, 2012||Sep 9, 2014||Microsoft Corporation||Progressively indicating new content in an application-selectable user interface|
|US8836648||May 27, 2009||Sep 16, 2014||Microsoft Corporation||Touch pull-in gesture|
|US8892170||Dec 12, 2012||Nov 18, 2014||Microsoft Corporation||Unlock screen|
|US8893033||May 27, 2011||Nov 18, 2014||Microsoft Corporation||Application notifications|
|US8914072||Mar 13, 2012||Dec 16, 2014||Microsoft Corporation||Chromeless user interface|
|US8922575||Sep 9, 2011||Dec 30, 2014||Microsoft Corporation||Tile cache|
|US8933952||Sep 10, 2011||Jan 13, 2015||Microsoft Corporation||Pre-rendering new content for an application-selectable user interface|
|US8935631||Oct 22, 2012||Jan 13, 2015||Microsoft Corporation||Arranging tiles|
|US8970499||Jul 14, 2014||Mar 3, 2015||Microsoft Technology Licensing, Llc||Alternative inputs of a mobile communications device|
|US8990733||Oct 19, 2012||Mar 24, 2015||Microsoft Technology Licensing, Llc||Application-launching interface for multiple modes|
|US9015606||Nov 25, 2013||Apr 21, 2015||Microsoft Technology Licensing, Llc||Presenting an application change through a tile|
|US9052820||Oct 22, 2012||Jun 9, 2015||Microsoft Technology Licensing, Llc||Multi-application environment|
|US9104307||May 27, 2011||Aug 11, 2015||Microsoft Technology Licensing, Llc||Multi-application environment|
|US9104440||May 27, 2011||Aug 11, 2015||Microsoft Technology Licensing, Llc||Multi-application environment|
|US20040100482 *||Nov 20, 2003||May 27, 2004||Claude Cajolet||Method and system for editing or modifying 3D animations in a non-linear editing environment|
|US20050001845 *||Jul 26, 2004||Jan 6, 2005||Microsoft Corporation||Method and system for managing graphics objects in a graphics display system|
|US20050027682 *||Sep 2, 2004||Feb 3, 2005||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US20050030312 *||Sep 9, 2004||Feb 10, 2005||Microsoft Corporation||API communications for vertex and pixel shaders|
|US20050046627 *||Oct 7, 2004||Mar 3, 2005||Microsoft Corporation||Method and system for maintaining connections between surfaces and objects in a graphics display system|
|US20050052456 *||Oct 22, 2004||Mar 10, 2005||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US20050083327 *||Oct 25, 2004||Apr 21, 2005||Microsoft Corporation||Method and system for managing graphics objects in a graphics display system|
|US20050083334 *||Oct 25, 2004||Apr 21, 2005||Microsoft Corporation||Systems and methods for providing graphics data in parallel to graphics processing hardware|
|US20050083335 *||Oct 25, 2004||Apr 21, 2005||Microsoft Corporation||Systems and methods for reducing redundant checks on graphics memory|
|US20050086317 *||Oct 22, 2004||Apr 21, 2005||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US20050086669 *||Oct 22, 2004||Apr 21, 2005||Microsoft Corporation||Method and system for defining and controlling algorithmic elements in a graphics display system|
|US20050162439 *||Aug 15, 2002||Jul 28, 2005||Creative Frontier, Inc.||Method and apparatus for associating the color of an object with an event|
|US20050193372 *||Aug 27, 2003||Sep 1, 2005||Bo Wu||System and process for object rendering on thin client platforms|
|WO2015006724A2 *||Jul 11, 2014||Jan 15, 2015||Qualcomm Incorporated||Palette prediction in palette-based video coding|
|U.S. Classification||345/589, 345/537|
|Sep 27, 1996||AS||Assignment|
Owner name: MICROSOFT CORPORATON, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:EISLER, CRAIG G.;ENGSTROM, ERIC;REEL/FRAME:008243/0628
Effective date: 19960731
|May 1, 2001||CC||Certificate of correction|
|Jun 3, 2003||FPAY||Fee payment|
Year of fee payment: 4
|Jun 4, 2007||FPAY||Fee payment|
Year of fee payment: 8
|Jun 1, 2011||FPAY||Fee payment|
Year of fee payment: 12
|Dec 9, 2014||AS||Assignment|
Owner name: MICROSOFT TECHNOLOGY LICENSING, LLC, WASHINGTON
Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNOR:MICROSOFT CORPORATION;REEL/FRAME:034541/0001
Effective date: 20141014