US20020008703A1 - Method and system for synchronizing scripted animations - Google Patents
Method and system for synchronizing scripted animations Download PDFInfo
- Publication number
- US20020008703A1 US20020008703A1 US09/031,144 US3114498A US2002008703A1 US 20020008703 A1 US20020008703 A1 US 20020008703A1 US 3114498 A US3114498 A US 3114498A US 2002008703 A1 US2002008703 A1 US 2002008703A1
- Authority
- US
- United States
- Prior art keywords
- animation
- character
- server
- action
- request
- Prior art date
- Legal status (The legal status is an assumption and is not a legal conclusion. Google has not performed a legal analysis and makes no representation as to the accuracy of the status listed.)
- Granted
Links
- 238000000034 method Methods 0.000 title claims description 171
- 230000009471 action Effects 0.000 claims abstract description 147
- 238000013515 script Methods 0.000 claims abstract description 88
- 230000004044 response Effects 0.000 claims abstract description 20
- 230000002452 interceptive effect Effects 0.000 claims abstract description 16
- 230000003993 interaction Effects 0.000 claims abstract description 14
- 230000009850 completed effect Effects 0.000 claims abstract description 9
- 230000006870 function Effects 0.000 claims description 96
- 230000008569 process Effects 0.000 claims description 51
- 238000012545 processing Methods 0.000 claims description 16
- 230000001360 synchronised effect Effects 0.000 claims description 11
- 230000001960 triggered effect Effects 0.000 claims description 4
- 230000000903 blocking effect Effects 0.000 claims description 2
- 238000012544 monitoring process Methods 0.000 claims 1
- 239000003795 chemical substances by application Substances 0.000 description 73
- 230000000007 visual effect Effects 0.000 description 36
- 238000010586 diagram Methods 0.000 description 21
- 241000272186 Falco columbarius Species 0.000 description 15
- 230000015572 biosynthetic process Effects 0.000 description 14
- 238000003786 synthesis reaction Methods 0.000 description 14
- 230000007246 mechanism Effects 0.000 description 9
- 230000006399 behavior Effects 0.000 description 8
- 230000008901 benefit Effects 0.000 description 8
- 239000000872 buffer Substances 0.000 description 8
- 238000013459 approach Methods 0.000 description 6
- 238000004891 communication Methods 0.000 description 6
- 238000013461 design Methods 0.000 description 5
- 230000000694 effects Effects 0.000 description 5
- 238000012546 transfer Methods 0.000 description 5
- 239000002131 composite material Substances 0.000 description 4
- 238000011161 development Methods 0.000 description 4
- 241000282326 Felis catus Species 0.000 description 3
- 241000287828 Gallus gallus Species 0.000 description 3
- 230000004913 activation Effects 0.000 description 3
- 230000009286 beneficial effect Effects 0.000 description 3
- 230000008859 change Effects 0.000 description 3
- 235000012489 doughnuts Nutrition 0.000 description 3
- 238000005538 encapsulation Methods 0.000 description 3
- 238000005516 engineering process Methods 0.000 description 3
- 230000002085 persistent effect Effects 0.000 description 3
- 238000013507 mapping Methods 0.000 description 2
- 230000003287 optical effect Effects 0.000 description 2
- 239000003973 paint Substances 0.000 description 2
- 230000037361 pathway Effects 0.000 description 2
- 230000002093 peripheral effect Effects 0.000 description 2
- 238000009877 rendering Methods 0.000 description 2
- 208000012661 Dyskinesia Diseases 0.000 description 1
- 238000012369 In process control Methods 0.000 description 1
- 230000003213 activating effect Effects 0.000 description 1
- 230000005540 biological transmission Effects 0.000 description 1
- 238000004422 calculation algorithm Methods 0.000 description 1
- 230000006835 compression Effects 0.000 description 1
- 238000007906 compression Methods 0.000 description 1
- 230000006837 decompression Effects 0.000 description 1
- 230000001934 delay Effects 0.000 description 1
- 238000009795 derivation Methods 0.000 description 1
- 230000009977 dual effect Effects 0.000 description 1
- 238000010304 firing Methods 0.000 description 1
- 238000007429 general method Methods 0.000 description 1
- 238000010965 in-process control Methods 0.000 description 1
- 238000009434 installation Methods 0.000 description 1
- 230000010354 integration Effects 0.000 description 1
- 230000007774 longterm Effects 0.000 description 1
- 239000000203 mixture Substances 0.000 description 1
- 239000013307 optical fiber Substances 0.000 description 1
- 238000005457 optimization Methods 0.000 description 1
- 238000002360 preparation method Methods 0.000 description 1
- 230000009467 reduction Effects 0.000 description 1
- 230000004043 responsiveness Effects 0.000 description 1
- 238000012552 review Methods 0.000 description 1
- 239000004065 semiconductor Substances 0.000 description 1
- 239000007787 solid Substances 0.000 description 1
- 230000007704 transition Effects 0.000 description 1
- 238000012795 verification Methods 0.000 description 1
Images
Classifications
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F8/00—Arrangements for software engineering
-
- G—PHYSICS
- G06—COMPUTING; CALCULATING OR COUNTING
- G06F—ELECTRIC DIGITAL DATA PROCESSING
- G06F3/00—Input arrangements for transferring data to be processed into a form capable of being handled by the computer; Output arrangements for transferring data from processing unit to output unit, e.g. interface arrangements
- G06F3/01—Input arrangements or combined input and output arrangements for interaction between user and computer
- G06F3/048—Interaction techniques based on graphical user interfaces [GUI]
- G06F3/0481—Interaction techniques based on graphical user interfaces [GUI] based on specific properties of the displayed interaction object or a metaphor-based environment, e.g. interaction with desktop elements like windows or icons, or assisted by a cursor's changing behaviour or appearance
-
- Y—GENERAL TAGGING OF NEW TECHNOLOGICAL DEVELOPMENTS; GENERAL TAGGING OF CROSS-SECTIONAL TECHNOLOGIES SPANNING OVER SEVERAL SECTIONS OF THE IPC; TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10—TECHNICAL SUBJECTS COVERED BY FORMER USPC
- Y10S—TECHNICAL SUBJECTS COVERED BY FORMER USPC CROSS-REFERENCE ART COLLECTIONS [XRACs] AND DIGESTS
- Y10S345/00—Computer graphics processing and selective visual display systems
- Y10S345/949—Animation processing method
Definitions
- the invention relates to computer generated animation, and more specifically to synchronization of interactive animations (animations that are responsive to user input).
- So-called rapid prototyping languages use a much more accessible form of scripting. These languages use textual command scripts to run procedures based on underlying controls.
- VB in particular, represents its scripts as simple text files, which can be edited with the most basic of tools and are easy to read and write.
- VBScript a somewhat restricted form of VB, is already widely available as a scripting tool over the Web, and is naturally expressed in text.
- the invention provides a method for synchronizing animations that addresses these and other drawbacks.
- the invention may be implemented in an animation server that provides synchronization services to client programs.
- the synchronization services are particularly well suited for scripted animations, i.e., animations that are controlled via a script.
- these synchronization services are also accessible to other types of application programs written in programming languages such as C, C++, and Java via an Application Programming Interface.
- the invention provides synchronization methods used to synchronize the playback and speech of two or more interactive animations that share the display. These animations are interactive in the sense that they respond to user input such as clicks of a mouse button or speech input via a speech recognition engine.
- an animation system enables applications to request animation services and input/output services for interactive animations such as user interface characters.
- One specific form of this type of character is a non-rectangular animation that is superimposed over the windows of concurrently executing programs.
- applications can specify the input commands that a character will be responsive to, including mouse input or speech via a speech recognition engine
- Applications animate the characters by invoking commands to request actions such as playing an animation sequence or generating speech output from text.
- the system schedules the actions for playback.
- the system maintains a queue for each character and schedules the actions in first-in, first-out order.
- an application invokes a synchronization command of the animation system and specifies an action of a character that it wants to synchronize with another character.
- the way in which the system synchronizes the actions of the characters depends on the synchronization command.
- One type of command called a wait command, synchronizes actions of different characters by halting a character until the specified action of another character has completed.
- Another type of command called an interrupt, causes an interrupt to be scheduled for a character. When this interrupt is processed, the animation server halts (e.g., deletes from a queue) a specified action of another character.
- an application can program the system to notify it about the progress of an animation or about input from the user. This feature enables applications to synchronize actions of characters in response to events.
- Applications can be written in the form of text-based scripts. These scripts control animations by making animation requests via textual script commands. Scripts can animate more than one character and synchronize the character's actions via the synchronization commands summarized above. The script commands operate on character actions, rather than on a time-based scheme. This enables programmers to quickly write animation scripts involving interaction between two or more animations without requiring precise frame by frame control of the animations.
- FIG. 1 is a general block diagram of a computer that serves as an operating environment for the invention.
- FIG. 2 is a screen shot illustrating an example of animated character located on top of the user interface in a windowing environment.
- FIG. 3 is a diagram illustrating the architecture of an animation system in one implementation of the invention.
- FIG. 4 is flow diagram illustrating how the animation server in FIG. 3 plays an animation.
- FIG. 5 illustrates an example of the animation file structure.
- FIG. 6 is a flow diagram illustrating a method used to retrieve image data to construct a current frame of animation.
- FIG. 7 is a flow diagram illustrating the process for obtaining the bounding region of an arbitrary shaped animation.
- FIG. 8 is a diagram illustrating an example of a COM server and its relationship with an instance of object data.
- FIG. 9 is a conceptual diagram illustrating the relationship between a COM object and a user of the object (such as a client program).
- FIG. 10 illustrates the relationship among the different types of objects supported in the animation server.
- FIG. 11 is a diagram of a web browsing environment illustrating how interactive, animated user interface characters can be activated from Web pages.
- FIG. 12 is a block diagram illustrating the flow of information from scripts and other types of applications to the animation server and the character threads that it spawns.
- FIG. 1 is a general block diagram of a computer system that serves as an operating environment for the invention.
- the computer system 20 includes as its basic elements a computer 22 , one or more input devices 28 , including a cursor control device, and one or more output devices 30 , including a display monitor.
- the computer 22 has at least one high speed processing unit (CPU) 24 and a memory system 26 .
- the input and output device, memory system and CPU are interconnected and communicate through at least one bus structure 32 .
- the CPU 24 has a conventional design and includes an ALU 34 for performing computations, a collection of registers 36 for temporary storage of data and instructions, and a control unit 38 for controlling operation of the system 20 .
- the CPU 24 may be a processor having any of a variety of architectures including Alpha from Digital, MIPS from MIPS Technology, NEC, IDT, Siemens, and others, x86 from Intel and others, including Cyrix, AMD, and Nexgen, and the PowerPC from IBM and Motorola.
- the memory system 26 generally includes high-speed main memory 40 in the form of a medium such as random access memory (RAM) and read only memory (ROM) semiconductor devices, and secondary storage 42 in the form of long term storage mediums such as floppy disks, hard disks, tape, CD-ROM, flash memory, etc. and other devices that store data using electrical, magnetic, optical or other recording media.
- the main memory 40 also can include video display memory for displaying images through a display device.
- the memory 26 can comprise a variety of alternative components having a variety of storage capacities.
- the input and output devices 28 , 30 are conventional peripheral devices coupled to or installed within the computer.
- the input device 28 can comprise a keyboard, a cursor control device such as a mouse or trackball, a physical transducer (e.g., a microphone), etc.
- the output device 30 shown in FIG. 1 generally represents a variety of conventional output devices typically provided with a computer system such as a display monitor, a printer, a transducer (e.g., a speaker), etc.
- the computer Since the invention relates to computer generated animation and speech input and output services, the computer must have some form of display monitor for displaying this animation, a microphone and analog to digital converter circuitry for converting sound to digitized audio, and speakers and digital to audio converter circuitry for converting digitized audio output to analog sound waves.
- the input and output devices actually reside within a single peripheral.
- these devices include a network adapter card and a modem, which operate as input and output devices.
- 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 .
- CPU 28 may be comprised of a discrete ALU 34 , registers 36 and control unit 38 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.
- 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 computer industry.
- FIG. 2 is a screen shot illustrating an example of animated character located on top of the user interface in a windowing environment.
- This screen shot illustrates one example of how an implementation of the invention creates arbitrary shaped animation that is not confined to the window of a hosting application.
- the animated character 60 can move anywhere in the user interface.
- the user interface referred to as the “desktop” includes the shell 62 of the operating system as well as a couple of windows 64 , 66 associated with currently running application programs.
- this example includes an Internet browser application running in one window 64 and a word processor application 66 running in a second window on the desktop of the Windows 95 Operating System.
- the bounding region defines the area occupied by non-transparent pixels within the frame, whether they are a contiguous group of pixels or disjoint groups of contiguous pixels. For example, if the animation were in the shape of a red doughnut with a transparent center, the bounding region would define the red pixels of the doughnut as groups of contiguous pixels that comprise the doughnut, excluding the transparent center. If the animation comprised a football and goalposts, the bounding region would define the football as one or more groups of contiguous pixels and the goalposts as one or more groups of contiguous pixels.
- the bounding region is capable of defining non-rectangular shaped animation including one or more transparent holes and including more than one disjoint group of pixels.
- the bounding region can be used to set a region window, a non-rectangular window capable of clipping input and output to the non-transparent pixels defined by the bounding region.
- Region windows can be implemented as a module of the operating system or as a module outside of the operating system.
- the software module implementing region windows should have access to input events from the keyboard and cursor positioning device and to the other programs using the display screen so that it can clip input and output to the bounding region for each frame.
- the Windows Operating System supports the clipping of input and output to region windows as explained further below.
- FIG. 3 is a general block diagram illustrating the architecture of a client server animation system.
- the animation system includes an animation server 100 , which controls the playback of animation, and one or more clients 102 - 106 , which request animation services from the server.
- the server relies on graphic support software in the underlying operating system 120 to create windows, post messages for windows, and paint windows.
- the operating system creates and clips input to non-rectangular windows (“region windows”).
- region window controller part of the operating system is labeled, “region window controller” (see item 122 ). This is the part of the operating system that manages region windows.
- the region window controller 122 creates a region window having a boundary matching the boundary of the current frame of animation.
- the regionizer specifies the bounding region of the current frame to the operating system.
- the operating system monitors input and notifies the server of input events relating to the animation.
- the services related to the playback of animation are implemented in four modules 1) the sequencer 108 ; 2) the loader 110 3) the regionizer 112 ; and 4) the mouth animation module 114 .
- the sequencer module 108 is responsible for determining which bitmap to display at any given time along with its position relative to some fixed point on the display.
- the regionizer module 112 is responsible for generating the bounding region of the frame, setting it as the clipping region of the frame's hosting region window and then drawing the frame into the region. In slower computers, it is not feasible to generate the bounding region as frames are constructed and played back. Therefore, in this implementation the regionizer also supports the loading of bounding region information in cases where it is precomputed and stored along with the frame data in the animation file.
- the mouth animation module 114 is responsible for coordinating speech output with the animation representing a user interface character's mouth.
- the mouth animation module receives a message from a speech synthesis engine 116 whenever a specific phoneme is about to be spoken. When the mouth animation module receives this message, it performs a mapping of the specified phoneme to image data stored in a animation mouth data file that corresponds to the phoneme. It is responsible for loading, decompressing, and controlling the playback of the animation representing the character's mouth.
- the speech synthesis engine 116 is responsible for generating speech output from text.
- the speech synthesis engine 116 is a SAPI compliant text to speech generator from Centigram Communications Corp., San Jose, Calif.
- Other SAPI compliant text to speech generators can be used as well. For example, Lernout and Hauspie of Belgium also makes a SAPI compliant text to speech generator.
- the speech recognition engine 118 is responsible for analyzing digitized audio input to identify significant words or phrases selected by the animation server.
- the animation server defines these words or phrases by defining a grammar of acceptable phrases.
- the client specifies this grammar by specifying sequences of words that it wants the system to detect in a text string format.
- the server also supports a command language that includes boolean operators and allows alternative words. This command language enables the client to specify a word or phrase along with a number of possible alternative or option words to look for in the speech input.
- the syntax of the command language is described in more detail below.
- the speech recognition used in this implementation is a SAPI compliant speech recognition engine made by Microsoft Corporation.
- a suitable alternative speech recognition engine is available from Lernout and Hauspie of Belgium.
- the operating system in this implementation is the Windows 95 operating system from Microsoft Corporation.
- the application programming interface for the operating system includes two functions used to create and control region windows. These functions are:
- the SetWindowRgn function sets the window region of a rectangular host window.
- the window region is an arbitrary shaped region on the display screen defined by an array of rectangles. These rectangles describe the rectangular regions of pixels in the host window that the window region covers.
- bRedraw Boolean value that specifies whether the operating system redraws the window after setting the window region. If bRedraw is TRUE, the operating system does so; otherwise, it does not. Typically, the program using region windows will set bRedraw to TRUE if the window is visible. Return Values If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. Remarks If the bRedraw parameter is TRUE, the system sends the WM_WINDOWPOSCHANGING and WM_WINDOWPOSCHANGED messages to the window.
- the GetWindowRgn function obtains a copy of the window region of a window.
- the window region of a window is set by calling the SetWindowRgn function.
- hrgn Handle to a region. This region receives a copy of the window region.
- Return Values specifies the type of the region that the function obtains. It can be one of the following values: Value Meaning NULLREGION The region is empty.
- SIMPLEREGION The region is a single rectangle. COMPLEXREGION The region is more than one rectangle. ERROR An error occurred; the region is unaffected. Comments The coordinates of a window's window region are relative to the upper-left corner of the window, not the client area of the window.
- the region window controller shown in FIG. 3 corresponds to the software in the operating system that supports the creation of region windows and the handling of messages that correspond to region windows.
- the speech recognition engine and the speech synthesis engine communicate with an audio input and output device such as a sound card according to the SAPI specification from Microsoft.
- these engines interact with an audio device through software representations of the audio device referred to as multimedia audio objects, audio sources (which provide input to the speech recognition engine) and audio destinations (which mediate output from the speech synthesis engine).
- multimedia audio objects which provide input to the speech recognition engine
- audio destinations which mediate output from the speech synthesis engine
- FIG. 4 is flow diagram illustrating how the animation server plays an animation.
- the animation data file is opened via the computer's operating system as shown in step 150 .
- the animation data file includes an animation header block and a series of bitmaps that make up each of the frames in the animation.
- the loader module 108 reads the animation header block to get all of data needed to play an animation and passes it to the sequencer as shown in step 152 .
- FIG. 5 illustrates an example of the animation file structure.
- the animation header lists the number of frames ( 160 ) and includes a block of data for each frame (see items 162 - 166 in FIG. 5 for example).
- the frame data 170 consists of a frame type (image, branch or sound) 172 , frame position (x, y coordinates) 174 , duration (in 60ths or a second) 176 , a unique ID 178 , and an offset 180 into the animation data file where the compressed bitmaps 182 for the frame reside.
- Animation branch frames allow developers to specify alternate pathways through the animation sequence other than the default sequential flow.
- Sound frames allow developers to specify digitized sound data to be played at a specific time in the animation sequence.
- step 190 the process for playing animation continues at step 190 , where the sequencer initializes the current frame number. Once the loader has successfully loaded the animation header block, the sequencer can start playing the animation. It initializes the current frame number to zero and looks at the type field of the current block of frame data to determine the type for the current frame.
- the next step 192 is to get the frame data for the current frame as shown in step 192 .
- the loader loads the data for the current frame from the animation file as specified in the frame data block.
- the sequencer then constructs the frame from the data retrieved for the current frame as shown in step 194 .
- FIG. 6 is a flow diagram illustrating the method used to retrieve image data for the current frame. If the frame type is an image, the sequencer first looks in a data cache of frame bitmaps for an entry equal to the next frame's ID as shown in steps 200 and 202 .
- the image data cache is a section of the computer's main memory where a fixed number of decompressed frame bitmaps reside in a most-recently-used queue (MRU). Data caching uncompressed frame bitmaps significantly improves overall performance of the animation system.
- MRU most-recently-used queue
- the sequencer finds the frame ID in the data cache, it returns with the constructed frame that is already in the cache as shown in the flow diagram. If there is no entry in the data cache for the current frame, the sequencer passes a request on to the loader to load the required bitmaps for the specified frame.
- Each animation frame can be made up of multiple layered bitmaps.
- the loader uses the data offset for the frame from the animation header block to read all of the compressed bitmaps that make up the frame from the animation data file into the computer's memory (see step 204 , FIG. 6).
- the loader decompresses the individual bitmaps and combines them into a single decompressed bitmap as shown in steps 206 and 208 .
- the loader constructs a composite bitmap by performing bit block transfers from the decompressed bitmaps to an off-screen buffer, which holds a composite bitmap.
- This composite bitmap is first saved in the data cache and then passed back to the sequencer where it can be used in generating the current frame. If the sequencer had initially found an entry in the data cache for the specified frame ID, it could have retrieved the composited, decompressed bitmap for the frame from the data cache. This step eliminates the need to decompress and composite the animation frame when it has already been done recently.
- the sequencer can pass control to the regionizer, which computes a bounding region for the frame if the bounding region is not already available.
- the bounding region defines the non-transparent portion of the constructed frame.
- the bounding region is the boundary of the genie.
- Some objects can have transparent regions inside of them, in which case the bounding region defines the non-transparent portion and also describes any transparent portion within an object as well.
- a constructed frame of animation can have a number of disparate pieces which are not necessarily contiguous.
- the step of computing the bounding region ( 210 , in FIG. 4) can be computed in real time, which means that the bounding region does not need to be pre-computed. Instead, the regionizer can compute the bounding region as it constructs and displays each frame.
- the regionizer takes one of three actions: 1) looks in a region data cache to see if the region data is already present; 2) on faster computers, generates the bounding region in real time; and 3) on slower computers, loads and uses a pre-computed bounding region.
- FIG. 7 is a flow diagram illustrating the process for obtaining the bounding region.
- the first choice for the regionizer is to attempt to retrieve the necessary region data from a region data cache in main memory of the computer as shown in step 220 of FIG. 7.
- This cache works similarly to the image cache in that it is a most recently used queue (in other words, it is a last-used-first-out queue). If the necessary data is found in the data cache it is retrieved (see steps 222 , 224 ).
- FIG. 7 illustrates the steps performed on a fast computer where the regionizer computes the bounding region in real time.
- the animation server is able to determine whether to compute the bounding region in real time by checking the computer's registry
- the regionizer will compute the bounding region of the decompressed bitmap frame in real-time. In this implementation, the regionizer computes the bounding region as shown in FIG. 7 and described below.
- the regionizer determines which color (the color key) the bitmap is using to identify its transparent portions. The first pixel in the frame's bitmap (i.e. the pixel at location (0, 0) in rectangular coordinate space of the bitmap where (0, 0 is the upper left hand corner) is deemed special in that it defines the transparent color of the frame. The pixel value of this transparent color is sometimes referred to as the color key.
- the regionizer scans the bitmap one line at a time looking for contiguous runs of non-transparent color as shown in step 228 .
- it finds a run of non-transparent pixels it combines the bounding rectangle of the run with rectangles from previous runs 230 .
- These rectangles always have a height of one, i.e. they are a single scan line of the bitmap, and have a width less than or equal to the total width of the bitmap.
- the operating system is responsible for combining the rectangles into non-rectangular regions in an optimized way. This process continues for every line in the bitmap until the entire bitmap has been completely scanned (as reflected generally by the loop back to step 228 from decision block 232 ). Upon completion, a single region is available that describes the bounding region of the animation frame.
- the region data can be pre-processed during the animation development. The same process described above is used to generate the region data for each bitmap frame in the animation. The region data is then compressed and stored to a separate data file along with the animation data file. On slow systems, instead of generating the region data when it is needed, the data is simply read from a data file and decompressed. This method is far less CPU intensive than generating the region data in real-time which is important in low end PC systems.
- the regionizer After the regionizer has retrieved the bounding region, either by generating it in real-time or by loading and decompressing it from a data file, it saves it in the region data cache for future use.
- the animation server has all of the components in memory that are necessary to display the next frame of the animation.
- the first step is to position the region window at the appropriate location as specified by the frame's x, y coordinate in the frame data block (see step 240 in FIG. 4). Calls to the operating system, such as SetWindowPos in the Windows Operating System, make this step possible.
- the next step 242 is to set the animation frame window's region to the region generated by the regionizer.
- the operating system is responsible for sending the appropriate paint messages to any window that intersects with the previous region of the animation frame window so that this area can be redrawn.
- the application owning the window is responsible for repainting itself in the portion of its window altered by the animation.
- One way to re-draw the portion of the desktop that is modified by the animation as it moves from frame to frame is to compute a bounding rectangle that encloses the animation in two consecutive frames and to re-compute the portion of the user interface that falls within this bounding rectangle.
- This bounding rectangle captures the animation in its current and previous frame. In other words, it includes the screen area once occupied by the animation in the previous frame as well as the screen area occupied by the animation in the current frame.
- the operating system instructs applications within this rectangle to redraw themselves.
- the portion of the desktop user interface within this rectangle is copied to an off-screen buffer.
- the animation server then instructs the operating system to draw the current frame of animation, clipped by its bounding region, to this off-screen buffer.
- the operating system performs a bit block transfer of this portion to the frame buffer to display the current frame of animation along with the re-drawn portion of the Windows desktop user interface, which is the background of the animation.
- the animation server draws the decompressed, composited bitmap generated by the sequencer to the animation frame's region window.
- the operating system clips this bitmap to the bounding region of the window (which exactly matches the non-transparent pixels of the composited bitmap).
- the sequencer then sets an operating system timer to go off after an amount of time equal to the duration specified in the frame data (see step 246 ).
- the animation server employs a similar technique to animate a portion of an animated character representing the character's mouth.
- the animation server loads, decompresses, and caches bitmaps representing the character's mouth.
- the animation server draws a bitmap representing the mouth on top of the constructed frame representing the character at the (x, y) coordinates where the character's mouth is located.
- the servers maintains bitmaps representing the character's mouth in a variety of different positions in a mouth animation file. There are a number of different bitmaps, each representing the position of the mouth for a corresponding phoneme. To enhance realism, the server can maintain different sets of mouth data files and select the appropriate one based on the position of the character. Each set of mouth data files can map a set of phonemes to bitmaps representing the mouth position for a phoneme.
- the server instructs the speech synthesis engine to notify it before it generates speech output for a phoneme. Just before the speech synthesis engine is about to output a phoneme, it passes a message to the mouth animation module identifying the phoneme.
- the mouth animation module loads the animation and draws at the (x,y) location on top of the current frame of animation.
- the region data is being generated in real-time, animations can be scaled and played back at a size different from the size that the animation was originally developed at.
- the entire process as described above is essentially the same.
- the main difference is that the sequencer can scale the composited, decompressed bitmap returned by the loader using the specified scaling factor.
- the regionizer works on decompressed bitmaps stored in memory and needs no knowledge of the size of the original source of the bitmap or any scaling factor.
- the operating system can be used to perform scaling of bitmaps in an efficient manner. Once the bitmap is scaled it can be passed to the regionizer and the system works as described above. Allowing scaling of animations in real-time is important because it allows end users to have greater control over the look and feel of the system.
- Another significant feature of this implementation is the way in which the animation's moving, non-rectangular window receives cursor device input from the user. Since the animation server repetitively updates the bounding region of the animation for each frame, the active area of the animation always corresponds to the non-transparent portion of the current frame. Thus, the operating system only notifies the server of cursor input (e.g. right and left mouse clicks) when the cursor is positioned within the non-transparent portion of the current frame. This form of interactive behavior enhances the effect of the animation operating outside the focus of any rectangular windows currently displayed on the Windows desktop user interface.
- the second implementation of the animation system is similar to the first animation system in that it generates arbitrary shaped animation and can also generate a bounding region for a frame of animation in real time. From the stand-point of the user, this implementation generates arbitrary-shaped animation with similar behavior as the first implementation. Namely, it produces arbitrary shaped animation and plays a sequence of animation in the foreground of the user interface such that the animation is not limited to a window of a host application or to a window of an application that requests playback of the animation.
- the system does not load individual bitmaps and then construct each frame from separate bitmaps, but instead, loads constructed frames; 2) it does not cache region data in a MRU cache in main memory as above, but instead, caches all regions in secondary storage (e.g., on a computer's hard disk) as they are generated; and 3) it has the additional capability to pre-compute region data on a low priority thread.
- the system first gets a request to open a character file.
- the file contains character, animation and audio data and is a structured storage file (see “Inside OLE” by Kraig Brockschmidt for a description) which contains all of the data necessary to play region window animations.
- the calling module can register itself to receive event notifications that describe the current state of the animation system at various times.
- the character data stream is read into memory and the character is initialized.
- the data included in the character data stream includes the character's color table, an index into the color table that defines the transparent color (or color key), size information (i.e. width and height of the character frame), audio definition data, animation version information and any other data necessary for initialization of the character.
- a window is then created of the appropriate size but is not made visible until explicitly done so by the calling module (such as a client program to the animation server).
- a logical palette is created from color table information retrieved from the character data stream. The character is now initialized and is ready for animation requests.
- Animation data consists of a sequence of animation frame data.
- Frame data consists of all of the data necessary to render an animation frame to the display device. This consists of the actual image bits for the frame, as well as a duration, coordinate offsets, frame branching logic, and lip-synched mouth image data (described further below). If the image bits are in a compressed format they are decompressed. Note that in this implementation, the frame is already constructed in the sense that it does not have to be assembled by combining more than one bitmap. As demonstrated in the first implementation, it is possible to construct frames in real time as opposed to using pre-constructed frames.
- the animation can be played.
- the animation is played by first rendering the uncompressed frame image data for the next frame to an offscreen video memory buffer.
- the animation system then creates a window region from the buffer that defines all areas of the image that are non-transparent.
- a “hole” is a transparent region completely surrounded by a non-transparent region.
- a disjoint region is any non-transparent region completely surrounded by either transparent pixels or the boundaries of the image. “Holes” can contain any number of disjoint regions within themselves.
- the image region is defined to be the list of non-transparent regions.
- the image region is analogous to the “bounding region” described in the first implementation and the terms can be used interchangeably. In both cases, the region defines the location of non-rectangular, non-transparent image portions whether or not they comprise a contiguous group of pixels or disjoint groups of contiguous pixels.
- the operating system is called to assign the region to the window.
- the operating system is responsible for clipping all input and output to the region associated with a window.
- the image data can be copied from the offscreen memory buffer to the display device, using the operating system's bit block transfer, where it will be clipped to the bounding region assigned to the window.
- the Windows Operating System for example, has an application programming interfaces (APIs) that support bit block transfers to offscreen buffers. Input and output are clipped to the list of (possibly) disjoint regions that make up the image region.
- APIs application programming interfaces
- an operating system timer is set to go off in the amount of time specified by the frame's duration.
- the animation system must determine the next frame to render. If the frame contains no branching logic, the system determines if it is the last frame in the animation and notifies the calling module of the completion (if the module registered itself to receive event notifications). If it is not the last frame, the next frame is either the next frame in sequential order, or the frame specified in the branching logic for the current frame.
- Branching logic is defined by specifying a frame number to branch to and a percentage of time that the branch should be taken. Multiple branches can be defined as long as the total percentage does not exceed 100%. The first branch is given a branch probability between 1 and it's percentage. Subsequent branches are given a probability between the maximum probability of the previous branch plus one to that value plus their percentage. To determine which branch to take, the animation system generates a random number between 1 and 100 and starts searching sequentially through the frame branches until it finds a branch whose maximum probability is less than or equal to the random number. If no branch can be found, the next sequential frame is selected.
- the system can repeat the process of rendering, region generation, and displaying of the frame image data.
- the repetition of this process is an animation.
- the generation of the region data for an animation frame in real-time is “expensive” in terms of CPU cycles.
- a system of region caching has been implemented. It would be beneficial if the region data could be processed at character development time and saved along with the character animation data. This is possible but has serious limitations. If the region data is pre-processed, the character can not be scaled at run-time.
- the character data file also has to store all of the region data for every frame in every animation. The data can be quite large. This is not a problem when the entire character data file resides on the local machine running the animation system. However, the animation supports incremental downloading of animation data over low bandwidth communication lines such as the Internet. Downloading the region data for a character would be extremely slow.
- a hybrid approach to region generation is used in this alternative implementation. The approach minimizes the download time associated with a character data file and minimizes the CPU cycles needed to generate regions in real-time.
- the system will first look in a local storage cache of regions for a match. In contrast to the fixed sized MRU cache in the first implementation, this cache is located in secondary storage, i.e. the hard disk. If the region is found it can be loaded from disk very fast and assigned to window as described above. If the region is not found, it is generated in real-time and used as described above. However, after the region is used it is saved to the region cache on disk. The next time the region is required it can simply be read from the cache instead of being generated in real-time. Thus, the system gets the benefit of the pre-computed region without it having to have been downloaded over a possibly low bandwidth communications link. This gives the system the appearance of improved performance over time, i.e. the more frames that are displayed (which results in region generation and thus caching), the better the performance.
- the system can also pre-generate regions on a low priority background thread when the animation system is idle.
- the region generation thread is started in a suspended mode. Whenever the system is idle, it resumes the thread (in low priority) which starts generating regions for any animation frame that does not already have an entry in the cache.
- the thread runs at a very low priority so that it does not unnecessarily steal CPU cycles from other applications currently running.
- the thread is suspended when the animation system becomes active. Over time, every animation frame in the character data file will have a pre-computed region in the cache. Once this is accomplished the region generation thread can be terminated.
- Regions are directly linked to frame images at a given scale.
- the default scale of an animation frame is 100%, i.e. the frame should be displayed at its actual size.
- the animation system supports scaling of animations. This has the advantage that animations can be played at a size that is relative to the resolution of the display being used. This is necessary to overcome the problem that an animation created at a certain size looks bigger or smaller depending on both the resolution and physical size of the display device.
- Caching region does improve performance by reducing the need to re-compute region data.
- cached region data cannot be used because it is the wrong size. Therefore, when the scale of an animation changes, all pre-computed regions are deemed unusable and must be recomputed. Thus, the entire region cache must be flushed and regenerated. The region generation thread must be restarted or reset (if it is still running). This process is quite expensive but is acceptable because scaling is something that users will typically do infrequently.
- the animation system supports the incremental downloading of animations from a remote site. This is extremely beneficial for running the system over low bandwidth communication links.
- a character When a character is loaded from a remote site, only the character data stream is initially downloaded.
- the character data stream contains all of the data necessary to initialize the character. If a character data stream already exists on the local machine, the downloaded data is compared to the local data to determine if any animations currently stored locally have been superseded by a newer version on the remote site. If so, those animations are marked so that if a request for the animation is made the system knows that it must retrieve the newer version from the remote site. No animation data is downloaded.
- the character data stream is typically very small so the system can be initialized quite quickly.
- the system looks in the character data file on the local storage device. If the animation is found, it is loaded and played as described above. If the animation is not found it is downloaded from the remote site. Once the download is complete, the animation can be played as described above.
- calling modules e.g., clients
- the calling module may want to download several animations that are played in sequence. If none of the animations reside locally, the system would download the first animation, play the animation, download the next animation, play it, etc. This is obviously not the desired effect.
- the animation system allows callers to download sets of animation.
- the system first checks to see whether or not the animations reside locally. If it does, the system simply returns. If it does not the system begins the process of downloading the animations from the remote site. It can do this in a asynchronous fashion.
- the system also supports a notification API so that calling modules can download animations asynchronously and then be notified when they have been downloaded.
- the calling module could do the following:
- Asynchronous download calls are always temporarily interrupted by synchronous calls.
- the calling module asynchronously downloads an animation and a synchronous animation request is generated as a result of end user interaction, the synchronous requests gets priority. This follows the notion that the end user really is in control of setting the priority for animation downloads.
- the cache for region data in the first implementation is a better design in cases where the same animations are used repeatedly in a short period of time because the MRU cache is more fully utilized, and it is quicker to read region data from main memory rather than retrieve it from secondary storage.
- the second implementation has better performance because all region data is cached in secondary storage as it is computed, rather than being limited to a fixed size MRU cache.
- region data is computed in real time along with an animation request and is also pre-computed before a request using a background thread
- the second implementation will approach a cache hit rate of 100% over time.
- an animation system can be implemented using different combinations of the features described above to optimize performance.
- the animation system calls into the animation data provider through certain COM interfaces.
- this implementation of the client/server architecture does not depend on any particular file format. It only depends upon the animation data provider's ability to construct bitmap representations of the current frame of the animation of the character, and to pass those on to the server at a relatively high speed.
- These COM interfaces allow the animation system to obtain information about the character in general, as well as information about the specific poses of the character. Thus, they provide access to all of the character's properties, including its name, its size, the number of bit planes in each animation bitmap, as well as to the animation bitmaps themselves.
- these COM interfaces allow the animation system to pass provider-defined state information to different animation data providers.
- This state information can be encoded in a form that only those data providers understand, providing a degree of protection for the content of the character.
- these COM interfaces are optimized to reduce the costs of accessing this data. This optimization is necessary in order to handle the case of an application client with a dedicated animation data provider. It has two parts. First, animation data providers can support standard OLE COM interfaces through which their persistent state can be captured so that each instance of an animation data provider can be reconstituted inside the server process. In addition, the COM interfaces used specifically to provide animation data are optimized to store and pass that data in a format particularly well-suited to transfer across process boundaries.
- the animation services described above are implemented as a Component Object Model (COM) based OLE Automation Servers.
- COM Component Object Model
- the COM server implements a set of animation services that can be used by an unlimited number of clients, which are typically application programs. These clients can connect to the server using either a C/C++ COM Application Programming Interface (API) or via a Microsoft ActiveX Control interface.
- API Application Programming Interface
- the ActiveX control allows access to all of the functionality of the COM server while providing an interface that is easy to use and abstracts the COM server's interface to a higher level.
- an “object” is an instance of a programmer-defined type referred to as a class, which exhibits the characteristics of data encapsulation, polymorphism and inheritance.
- a class is the definition of a data structure and the functions that manipulate that structure (member functions).
- Data encapsulation refers to the combining of data (also referred to as properties of an object) with methods that operate on the data (also referred to as member functions of an object) into a unitary software component (i.e., the object), such that the object hides its internal composition, structure and operation and exposes its functionality to client programs that utilize the object only through one or more interfaces.
- Programs that wish to use an object do not access the object's data directly, but must instead call functions on the object's interfaces to operate on the data.
- An interface is explained further below, but in general, is a group of related functions that a program can invoke to access an object's data.
- Polymorphism refers to the ability to view (i.e., interact with) two similar objects through a common interface, thereby eliminating the need to differentiate between two objects.
- Inheritance refers to the derivation of different classes of objects from a base class, where the derived classes inherit the properties and characteristics of the base class (which for purposes of OLE are the interfaces of the base class).
- FIG. 8 is a diagram illustrating an example of a COM server 300 and its relationship with an instance of object data 302 .
- an instance of an object is represented in the computer system 20 (FIG. 1) by an instance data structure 304 and a virtual function table 306 .
- the instance data structure 304 contains a pointer 308 to the virtual function table 306 and data 302 (also referred to as data members, or properties of the object).
- a pointer is a data value that holds the address of an item in memory.
- the virtual function table 306 contains entries 310 - 314 for member functions 316 - 320 implemented in the server. Each of the entries 310 - 314 contains a reference to the code 316 - 320 that implements the corresponding member function.
- An interface to an object is a group of semantically related functions that are publicly accessible to software that wishes to use the object (e.g., a client program).
- the interface is implemented in the computer memory as a block of the memory containing an array of function pointers, illustrated as the function table 306 in FIG. 8.
- the interface's definition are the names for each function in the virtual function table.
- An object may support more than one interface. If an object has more than one interface, the object has a function table and corresponding set of related functions for each interface.
- Client programs interact with the object by obtaining a pointer (referred to as an interface pointer) 322 to the pointer 308 of the virtual function table 306 .
- OLE includes a type definition of an interface pointer which allows client programs to call member functions on the interface by name through the interface pointer and provides type checking on the function's arguments, as expressed in the following code (in the C++ programming language):
- Interfaces of an object are illustrated graphically as a plug-in jack. Also, Interfaces conventionally are given names beginning with a capital “I.” Objects can include multiple interfaces which are implemented with one or more virtual function tables. The member function of an interface is denoted as “IinterfaceName::FunctionName.”
- FIG. 9 is a conceptual diagram illustrating the relationship between a COM object 340 and a user 342 of the object (such as a client program).
- the user of the object has a pointer 344 to the one of the object's interfaces, which is represented by a plug-in jack 346 .
- the object includes code 348 implementing the member functions in the object's interface, and it also includes the encapsulated data 350 , accessible via the object's interface.
- An OLE server such as the animation server, can include a number of interfaces which allow clients of the server to access an instance of an object, such as an interactive character animation encapsulated within an object.
- the object conforming to the COM specification exhibits data encapsulation by exposing its interfaces to client programs.
- the client programs interact with the object by calling the member functions 348 on a particular interface of the object, but do not directly manipulate the object's data 350 .
- a COM object also exhibits polymorphism and inheritance in that it can provide interfaces in common with a base class and other similar objects, so that client programs can interact with each of the objects in the same manner by calling member functions of the interface that the objects have in common.
- the virtual function table 306 and member functions 316 - 320 of the object are provided by a server program 300 which is stored in the computer system 20 (FIG. 1) as an executable program file (with a “.exe” file name extension) or as a dynamic link library file (with a “.dll” file name extension).
- Dynamic link library files are loaded, dynamically linked, and executed by the Windows 95 operating system in a same process with a client application program.
- Executable program files are loaded by the operating system as a separately executing process.
- the server application 300 includes code for the virtual function table 306 (FIG. 8) and member functions 316 - 320 (FIG. 8) of the classes that it supports, and also includes a class factory 330 that generates the instance data structure 304 (FIG. 8) for an object of the class.
- a server program can be written by a programmer to support a particular class of object that contains any desired data.
- the animation server for example, provides objects representing an interactive animation. This allows a client program (such as the clients shown in FIG. 3) to interact with the interactive animation through interfaces of the OLE object.
- the server For the client program to interact with an instance of a COM object provided by the server 300 , the server must first create the object (i.e., instantiate an object of a class supported by the server application) and the client must gain an interface pointer to the object (pointer 322 , for example).
- the client program realizes these events using services provided by OLE and a set of standard object interfaces defined by COM based on class and interface identifiers assigned to the object's class and interfaces.
- API application programming interface
- COM library which is part of a component of the Windows7 operating system in a file named “OLE32.DLL.”
- API application programming interface
- classes of objects are uniquely associated with class identifiers (“CLSIDs”).
- Class identifiers are 128-bit globally unique identifiers (“GUID”) that the programmer creates with an OLE service named “CoCreateGUID” and assigns to the respective classes.
- GUIDs interface identifiers
- IIDs interface identifiers
- the COM library provides an API function, “CoCreateInstance,” that the client program can call to request creation of an object to encapsulate a particular animation's data using a CLSID associated with the data.
- the CoCreateInstance API function creates an instance of the object and returns a pointer of the requested interface to the client program.
- the client program obtains pointers to other desired interfaces of the object using the interface identifier associated with the desired interface.
- COM defines several standard interfaces generally supported by OLE objects including the IUnknown interface.
- This interface includes a member function named “QueryInterface.”
- the QueryInterface function can be called with an interface identifier as an argument, and returns a pointer to the interface associated with that interface identifier.
- the IUnknown interface's member functions are included as part of each interface on an object.
- any interface pointer that the client obtains to an interface of the object 80 can be used to call the QueryInterface function.
- the animation server is implemented as an “OLE Automation server.”
- automated in this context refers to how the OLE object exposes a set of commands or functions that another piece of code can invoke. OLE automation enables an application to control another application's objects programmatically. In other words, automation provides a way for a program to manipulate an application's objects from outside the application.
- a software object exposes itself as a series of methods, properties and events.
- a property is an attribute, such as a color, the zip code section or the postal code section of an address, or another object.
- a method generally refers to a request to an object to perform a specific action.
- an event is a notification from an object that something has happened. An event is similar to a method call except that it occurs from the object to its client.
- Properties have data types.
- the postal code section of an address can be a string or a long integer.
- Properties can also be parameterized, which is useful to construct an array of one type representing a collection of properties (e.g., the lines of an address).
- a parameter representing an index in the array is defined for the property. Methods can also take parameters and return results.
- OLE automation also allows for hierarchies of automation objects by allowing methods and properties to return pointers to other objects. For example a series of related attributes can be represented within an object, which represents each of the attributes as a property.
- a software object's properties and methods can be exposed to outside applications through 1) a standard OLE interface called IDispatch, and 2) through interface methods and property access functions that applications can call directly.
- IDispatch provides outside access to an object's methods and properties through one of its methods called the Invoke method.
- a program can ask an OLE object to return a property or can call one of its methods by calling the Invoke method on the IDispatch interface of the object and identifying the property or method by its ID.
- the IDispatch interface includes other methods to enable a program to get an ID of a method or property, and to get data type information.
- An OLE object can expose methods that can be called directly, rather than through the Invoke method in the IDispatch interface.
- an OLE object can expose a set of functions that is derived from IDispatch and includes method and property access functions that another program can call directly. This is sometimes called a ‘dual’ interface because other programs can invoke an object's methods through the Idispatch interface and directly through this second type of interface.
- An OLE control is a type of OLE object that uses OLE Automation to expose properties and methods and to provide support for events.
- An OLE control object is typically designed to be incorporated into a host application called a container.
- an event is a notification from the control to its container that something has happened.
- events are typically implemented as standard OLE automation methods, except that the automation interface for these methods is implemented in the container, not the control.
- a control wants to fire an event, it calls the container method associated with the event. For instance, the control can call the proper container method to fire the event through the IDispatch::Invoke method of the container.
- An OLE object can tell another object that it is the consumer of the other object's interface through a mechanism known as a connection point.
- a connection point is an interface exposed by an object that is used to hook up to an implementation of an interface with which the object wants to communicate.
- a control describes the event interface in terms of an OLE automation interface in its type library, marking the interface as “source.” This means that the control does not implement the interface.
- the control then provides a connection point through which the container can connect its implementation.
- a connection point can be defined as an implementation of the IConnectionPoint interface.
- the container gets the connection point through another interface called IConnectionPointContainer, which allows an external object to iterate list of connection points maintained by a control.
- the animation server shown in FIG. 3 is implemented as an OLE Server.
- FIG. 10 illustrates the hierarchy of the objects supported in the animation server.
- the top level object is the agent object 360 , which represents an interactive, animated user interface character called an agent.
- An example of this type of character is the genie in FIG. 2.
- the other objects include a commands object 362 , character objects 364 , a user object 366 , an input object 368 , an output object 370 and a balloon object 372 .
- the commands object can have several command objects 374 , which represent individual input commands that a client has specified for an agent.
- Clients can include code that directly invokes the objects implemented in the animation server using ActiveX (OLE) interfaces.
- OLE ActiveX
- a client can access the methods, properties and events of the objects implemented in the animation server through an OLE control representing an animated character.
- OLE control representing an animated character
- software developers can insert an OLE control representing an animated character into a Visual Basic form.
- the Visual Basic programming environment gives the developer high level access to the methods, properties and events of the animation server using conventional Visual Basic syntax.
- the OLE control acts as a high level programming interface to the animation server.
- a piece of code such as a Visual Basic application program
- invokes a method or property on the OLE control the OLE control routes the method or property request to the corresponding method or property in the animation server.
- the OLE control thus, acts as a thin software layer that enables programmatic access to the methods and properties of the software objects in the animation server.
- the Visual Basic programming environment also provides support for receiving event notification from the animation server. When the developer inserts a control representing a character into a Visual Basic form and creates a Visual Basic application, the Visual Basic programming environment adds the necessary support for receiving event notification to the application. This event notification mechanism is similar to the event notification mechanism used to communicate events from an OLE control to a container of an OLE control.
- the operating system dynamically loads the character control in the process space of the application.
- the Visual Basic application can access the methods and properties of the control, which in turn, accesses the corresponding methods and properties in the animation server running in a separate process.
- the OLE control based design also enables developers to create script code in Visual Basic Script that accesses the methods, properties and events of the animation server through the OLE control interface.
- One important use of this technology is adding an animated character to an HTML document and controlling the character through script code in the document.
- the HTML document is parsed and rendered by an application program, such as an Internet browser application.
- the browser loads the character control in its process space when it encounters an object identifier in the HTML page corresponding to the character control.
- the browser uses an interpreter, loaded in its process space, to translate the script.
- the browser control communicates requests to access methods and properties to the interface of the in-process control, which in turn, accesses the corresponding methods and properties in the out of process animation server.
- Clients of the animation server access its animation services using the methods, properties and events of the agent object's interface.
- the methods of the agent object include a number of functions to control the playback of an animation.
- Example methods include: Play, GestureAt, MoveTo, Stop, and Speak.
- Play A client invokes this method to ask the server to play a specified animation sequence.
- the client specifies the animation sequence by passing a string that specifies the name of the animation sequence.
- the server uses the animation technique described above in detail.
- GestureAt Clients use this method to cause the animation to gesture at a specified location.
- the client provides two integer values representing the screen coordinates (x,y) in pixels where the character should gesture at.
- the character author assigns animations corresponding to different coordinates to this method, and at runtime, the server determines which of these animations to play based on the current location of the character and the coordinates specified by the client.
- MoveTo This method moves the animation to a specified location in screen coordinates.
- Speak—Clients invoke this method to instruct the server to generate speech output for a specified text string.
- Clients specify a text string, which the speech output engine converts into digitized audio output.
- the animation server plays lip synched animation of the agent's mouth along with the speech output.
- the server can play the ASCII text requested by a client.
- the server processes a client request to speak, it passes the appropriate text to the speech synthesis engine.
- the speech synthesis engine then processes the text and begins sending data to the physical audio device (e.g., sound card installed in the PC).
- the speech synthesis engine (item 116 in FIG. 3) can send a notification to the mouth animation module (item 114 in FIG. 3) of the server whenever a specific phoneme is about to be spoken.
- the mouth animation module receives this notification, it performs a mapping of the specified phoneme to appropriate data stored in the animation mouth data file.
- the mouth data consists of an x,y coordinate, a width and height, and a compressed bitmap of a mouth that appropriately matches the phoneme to be spoken.
- the mouth bitmap can then be loaded from the data file into memory, decompressed, and drawn on top of the current frame that the server is currently displaying at the coordinates of the animation's mouth. This action is repeated for every phoneme that is synthesized by the speech synthesis engine. This gives the illusion that the character is actually speaking the synthesized audio.
- the server also embeds what are referred to as tags in every piece of text that is passed to the speech synthesis engine. These tags are inserted before every word in the text and tell the speech synthesis engine that the server wants to be notified whenever one of these tags is encountered. The server can then uses this data to display the word that is currently being spoken in a visual user interface. This technique can then be used effectively to close caption the text as it is being spoken. In this implementation, the server displays this text in a graphic representing a balloon.
- the client can use a special type of tag called a bookmark tag in Speak method statement to sync its operations with the output text.
- the bookmark tag is a tag supplied by the client along with the ASCII text that tells the server when to notify the client. For example, to display a window at a particular point in its spoken output, the programmer inserts a bookmark tag at the desired location in the output string. When the server encounters the bookmark tag in the output text, it generates a Bookmark event with the bookmark number you specified in the tag.
- Agent1.Speak “Generate a bookmark now ⁇ mrk 100.”
- the Speak method While generating speech output, the Speak method automatically selects the animation of the agent based on the last animation played. The Speak method uses the last action played to determine which speaking animation to play. For example, if the client precedes the Speak command with a command to play an animation called GestureRight, the server will play GestureRight animation and then the GestureRight speaking animation. However, if the preceding animation ends at the rest pose, the server will play the RestPose speaking animation.
- Playing a speaking animation also automatically disables the listening mode while the associated animation is played.
- events are notifications from the animation server that something has happened for which a client should be notified. They, for the most part, are asynchronous, but in some cases, can be synchronous.
- asynchronous event handling means that the piece of code that monitors the event spawns a separate thread to fire the event so that the code can continue processing after it fires the event.
- Synchronous event handling means that the piece of code that monitors the event does not spawn a separate thread to fire the event but instead, fires the event on the current thread of execution and waits until the event is processed before continuing.
- the server is responsible for firing events to clients, whether they are application programs or a character control within an application program (such as a Visual Basic application) or a script (such as a Visual Basic Script embedded in an HTML document).
- a character control the control acts as a gateway for communicating events.
- One form of event notification is a callback function where the client requesting notification of an event provides the name and location of a function to call when a predefined event occurs.
- this callback can be implemented as an IDispatch interface of the client that the animation server can invoke when it detects an event, has occurred.
- the callback function is made on a separate thread of execution, while for synchronous events, the callback is made on the same thread.
- agent object's events allow the client program to track the state of an agent. Examples of these types of events include: Input Activate, Input Deactivate, Command, Shutdown, Bookmark.
- Input Activate event The server generates this event when a client becomes active for input from the server.
- Input Deactivate event The server generates this event when a client has been deactivated for input from the server.
- the server uses the activate and deactivate events to arbitrate among requests from clients for input services.
- the active client is the client that receives mouse and speech input from the server.
- Bookmark event The server generates this event when it encounters a bookmark tag in a text string as it converts the text string into speech output.
- the client can insert this tag in the text string provided with a Speak method.
- the client specifies a tag ID for the bookmark when it passes the text to the server.
- Command event This event occurs then the user chooses an input command of an agent (e.g., clicks on the agent's command window).
- agent e.g., clicks on the agent's command window.
- right-clicking the mouse button while the cursor is positioned over the character displays a pop-up menu, selecting Open Commands Window from this menu displays the agent's command window.
- This command window is one way to implement a visual command interface for an agent object. It displays one or more visual input commands by displaying the text caption provided by the client. The user can select one of these input commands by positioning the cursor over the caption and clicking on the mouse button.
- cursor device input displayed by a cursor device input because the user can enter an input command using a cursor device such as a mouse or trackball.
- the command event tells the client which input command the user has provided by specifying a command object.
- the command object provides access to a number of properties of the command object as set forth in the table below.
- Value Description User Input Identifies the command object returned by the server. The following properties can be accessed from the common object.
- Name A string value identifying the name (ID) of the command. Confidence a long integer value indicating the confidence scoring for the command
- Voice A string value identifying the voice text for the command Alt 1
- Name A string value identifying the name of the next (second) best command.
- Alt 1 A long integer value indicating the confidence scoring Confidence for the best command
- Alt 2 Voice A string value identifying the voice text for the next (second) best command match
- Alt 2 Name A string value identifying the name of third best command match.
- Alt 2 A long integer identifying the confidence scoring Confidence for the third match.
- Alt 2 Voice A string value identifying the voice text for the third best command.
- Count an integer value indicating the number of alternatives returned.
- Resume event This event occurs when the animation resumes after being suspended. The end user can resume the animation by clicking on a suspend caption in the pop-up window associated with the agent.
- StopListening This event occurs when the server is no longer in the listening mode. This means that the character will not respond to speech commands.
- the character object provides access to the properties of a character. These are not the same as the properties of the control.
- the user can change the properties of a character, but the values of these properties are read-only to client applications to avoid arbitrary changes to the user-specified settings.
- the properties of a character include:
- Height This property is an integer representing the height of a character in pixels.
- Width This is an integer representing the width of the character in pixels.
- Left This property is an integer that specifies the left edge of the current character frame. The Left property is expressed in pixels, relative to screen origin (upper left).
- Top This property is an integer that specifies the top edge of the current character frame.
- the Top property is expressed in pixels, relative to screen origin (upper left).
- the character object includes the following properties relating to speech input and output: Listening, Pitch, Speed, and Volume.
- Listening This is a boolean value that indicates whether the agent is in listening mode.
- Pitch, Speed, and Volume are read only integer values representing the pitch, speed, and volume of the speech output.
- the client is not allowed to alter these values directly.
- the client can, however, alter pitch, speed, and volume by embedding speech tags in the text string provided with a Speak method request.
- the client can use a speed tag to alter the pitch and speed of speech output, and can use a volume tag to change the volume for a portion of the speech output.
- the input and output object provide read only access to an agent's input properties and output properties.
- the commands object enables clients to specify a collection of commands that an agent object will respond to when a client becomes active.
- the server maintains a list of commands that are currently available to the user. This list includes commands that the server defines for general interaction, such as Stop Listening and Go Away; the list of available (but inactive) clients; and the commands defined by the current active client.
- the first two sets of commands are global commands; that is, they are available at any time, regardless of which client is active. Client-defined commands are available only when that client is active.
- Each client application defines a collection of commands called the Commands object.
- the client uses the Add or Insert methods of the commands object.
- the client can specify whether the user accesses the command through the Commands window, the application's (including Web page's) own interface controls, or both. For example, if the programmer wants a command to appear on the Commands window, she sets the command's Caption and Visible properties.
- the client can also set the Voice property for a command, which enables its selection through speech recognition.
- the client can add separator lines to your Commands object to group sets of commands in the Commands window.
- the client can also remove commands and separators.
- Agent 1 is the name (ID) for the agent control:
- Agent 1 Commands.Add “GetTime”, “Current Time”, “what's the current time”
- Agent 1 Commands.Add “GetDate”, “Current Date”, “what's the current date”
- Agent 1 Commands.Add “GetName”, “Current Name”, “what's your name”
- the first line of code first disables the commands by setting the Enabled property to false.
- the following lines invoke the Add method to add commands to the commands window of the agent.
- the server supports the following methods for the Commands object: Add, Insert, Remove, and RemoveAll.
- the Add method adds a command to the Commands object.
- the client can also specify the caption, voice text, visual state, and enabled state for the command.
- the Insert method inserts a command in the Commands object.
- the client specifies the command ID of the command to be inserted, a name of the command object to which the new command is related to, and value indicating whether the command should be inserted before or after the related command.
- the client can optionally specify a text string that will appear in the Commands window for the inserted command when the client is active.
- the client specifies the string value corresponding to the words or phrase to be used by the speech engine to recognize this command.
- the Remove method removes a client command object (command or separator) from the Commands object.
- the client specifies a string value corresponding to the ID for the command or separator.
- the RemoveAll method removes all client command objects (commands and separators) from the Commands object. Command objects that are removed from the collection do not display when the agent control is active.
- the server supports the following properties for the Commands object: Caption, Count, Visible, and Voice.
- the Caption property is a text string describing the text displayed for the Commands object in the Commands window.
- the Count property returns an integer (read-only property) that specifies the count of commands in the Commands object.
- the Visible property is a boolean value that determines whether the option of the Commands object is visible.
- the Voice property is a text string corresponding to the words or phrase to be used by the speech engine for recognizing this command.
- the string expression can include square bracket characters ([]) to indicate optional words and lists strings enclosed in parenthesis and separated by vertical bar characters (
- the client can also use an ellipsis ( . . . ) to support word spotting, that is, telling the speech engine to ignore words spoken in this position in the phrase, sometimes called garbage words.
- ellipses the speech engine recognizes only specific words in the string regardless of adjacent words or phrases. For example, if you set this property to “. . . check mail . . . ” the speech recognition engine will match phrases like “Please check mail,” or “Check mail, please” to this command.
- Ellipses can be used anywhere within a string.
- a command is an item in a Commands collection.
- the server provides access to the commands specified by a client when the client is active.
- the client can set the words or phrases that it wishes the server to use to match speech input for a command.
- the server When the server receives input for a command object, it sends a Command event, and passes back the name of the command as an attribute of the UserInput Object. The client can then use conditional statements to match and process the command.
- Each command defined in a Commands object also has properties that affect the how the server presents the command. For example, if you supply content for the Voice property of a command, the supplied text is automatically compiled as part of the active vocabulary of the speech recognition engine, allowing speech recognition when the client activates its Commands object. Individual commands in a Commands collection also have a Visible property. When this property is set to True, the command will appear on the agent's pop-up Commands window. A client does not have to include any or all of your commands in the agent's Commands window, if it already provides its own interface for those commands. For example, a form may already display controls that enable user interaction. In this case, the client would not need to include access on the agent's Commands window, yet it can still provide speech access to those controls (by defining command objects for those fields).
- the Caption property determines the text displayed for the command in the Commands window.
- the property is a string expression displayed as the caption for the command.
- the Confidence property is the confidence threshold that the speech engine uses to match the command.
- the property is a numeric expression that evaluates to an integer that identifies confidence value for the command.
- the Enabled property indicates whether the command is currently enabled.
- the property is represented as a boolean expression specifying whether the object is visible or hidden. If True, the command is enabled. If False, the command is disabled. If the Enabled property of the command's parent Commands object is set to False, the Enabled property of the command will also be automatically disabled. However, the Enabled property setting of the command is restored when the Enabled property of the parent Commands object is set to True.
- the Visible property indicates whether the caption of the command is visible.
- the Voice property is string value corresponding to the words or phrase to be used by the speech engine for recognizing this command.
- a string expression can include square bracket characters ([]) to indicate optional words and lists of strings enclosed in parenthesis and separated by vertical bar characters (
- the word balloon object displays the “spoken” text of the agent.
- the server exposes the setting of the Enabled property as read-only. When Enabled property is set, the word balloon is automatically displayed and removed for “spoken” output. This property value is set by the user in one of the windows used to display the agent's properties.
- the client can define text in the balloon to appear differently than the spoken output by using the Map tag. For more information about this tag, see Speech Output Tags.
- the Agent services support modifying the speech output special tags inserted in the speech text string. This allows the client to add personality to the output expression of the character. Speech output tags use the following rules of syntax in this implementation:
- the backslash character is not allowed within a tag.
- Tags are case-insensitive.
- pit is the same as ⁇ PIT ⁇ .
- Tags are white-space sensitive. For example, ⁇ Rst ⁇ is not the same as ⁇ Rst ⁇ .
- the speech output retains the characteristic set by the tag within the text specified in a single Speak method, unless modified by another tag. Speech output is automatically reset to the user-defined parameters after a Speak method is completed.
- ⁇ Chr string ⁇ Part Description string a string specifying the character of the voice. If “Normal” (the default), the character speaks in a normal tone of voice. If “Monotone,” the character speaks in a monotone voice. If “Whisper” the character whispers.
- ⁇ Ctx string ⁇ Part Description string A string specifying the context of the text that follows, which determines how symbols or abbreviations are spoken. If “Address,” addresses and/or phone numbers are used. If “Email,” electronic mail is used. If “Unknown,” (default) the Context is unknown.
- This tag enables the programmer to use spoken text that is different than the text displayed in the word balloon
- the server When the server processes a bookmark, it generates a bookmark event.
- ⁇ Pau number ⁇ Part Description number The number of milliseconds to pause.
- the speech engine supplied with the Animation Server supports values from 10 (0.01 sec) to 2550 (2.55 sec).
- the speech engine supplied with this implementation of the animation server supports values from 50 to 400.
- ⁇ Spd number ⁇ Part Description number Baseline average talking speed, in words per minute.
- the speech engine supplied with Microsoft Agent supports values from 50 to 250.
- ⁇ Vol number ⁇ Part Description number Baseline speaking volume; 0 is silence and 65535 is maximum.
- the first step that a client performs is to attach to the server. This is performed using a standard OLE mechanism which starts the server if it is not already running. The server maintains a list of all connected clients and terminates when either the last client detaches or it is explicitly shut down by the end user. This functionality is consistent with the COM specification.
- the client continues with the process of attaching by registering a notification interface with the server.
- the notification interface is used by the server whenever it needs to communicate either events or state changes with its connected clients. Notifications from the server to connected clients usually occur on a separate thread of execution in the server. This is necessary in order to prevent any single client from blocking the server while it is processing a notification.
- clients can request services from the agent server. These services consist of region window animations, lip synched animation, synthesized digital audio output, and input command processing.
- the animation services allow clients to trigger animation sequences in the agent. To accomplish this, the client calls the Play methods on the agent object's interface.
- the server can also animate the agent object at any time but gives priority to the active client except in cases where it is deemed necessary to override the default behavior.
- the active state of a client can be set by either the end user (if the client allows it) or the client itself. Only one externally connected client is considered active at any time.
- the server also implements what are known as internal clients. These clients typically follow the same rules as external clients but can override the default behavior of the server if deemed necessary.
- the client receives input from the server.
- the active client will also be sent a notification (i.e. an input Deactivate event) from the server when it is about to become inactive (analogous to KillFocus).
- Clients can explicitly make themselves input active however they should always be prepared to handle the case that another client has “stolen” the activation focus from them. This model works because it is ultimately the end user that is controlling which client has the chance to become active through either direct communication with the server or one of its connected clients.
- the server enters what is referred to as its idle state.
- the server When the server is idle, it causes the agent to play one of its idle animations picked at random.
- the server Before playing an idle animation, the server will first try to play a transitional animation to smoothly move the agent from its current position to a constant position known as the rest pose. All idle animations begin at the rest pose. Transitioning the agent through a constant position reduces the amount of jerkiness associated with quickly changing the state of the agent. This gives the agent a more natural feel.
- the server's idle animations will always be interrupted by an incoming client request.
- the server implements two mechanisms for allowing clients to synchronize their own actions with the servers.
- the first allows clients to add specific notification requests to the server's request queue.
- the server will process these notification requests with the same rules that it processes animation or audio requests.
- the other mechanism allows clients to embed notification requests in text that is to be synthesized into digital audio output.
- the bookmark tags described above, are in implementation of this type of notification request. These notification requests offer a finer granularity than the previously described mechanism in that it allows clients to synchronize actions at the spoken word level.
- these input commands include: 1) commands defined by the server and 2) commands defined by clients.
- the server monitors for these client-specific commands as well as global commands and sends a notification to the appropriate client when it detects the input command.
- the server sends a notification to the appropriate client that a command was selected.
- the server provides a notification in the form of a command event of the agent object.
- the notification tells the client the name of the command that was selected along with other information from the speech recognition engine if the command was selected via a spoken command.
- One of the pieces of information that the server passes to the client though this interface is a confidence value for the command. This value represents how confident the speech recognition engine was that the command being passed to the client was actually spoken.
- Other information consists of possible alternatives to the spoken command and their confidences.
- Clients can use this information to determine whether the engine's confidence in the spoken command was sufficiently high enough for the client to actually proceed with the processing of the command, or if they should ask the user for verification of the command. It is more effective to allow clients to do this processing instead of the server because they have context information which may be useful in determining whether to accept a command or reject it.
- the client server architecture described above enables software developers to create clients that take advantage of the animation and speech services of the server.
- Clients can request services from the server using a C/C++ COM Application Programming Interface (API) or via an ActiveX control interface.
- Developers therefore, can create client application programmers written in C or C++, or written in Visual Basic from Microsoft Corp.
- C or C++ programs can access the server functionality through the server's COM API.
- Visual Basic Programming system programmers can drag and drop an agent object's ActiveX control into a Visual Basic form.
- the ActiveX control interface also enables developers to access the animation services in Web pages using scripting languages compatible with ActiveX controls like VBScript (Visual Basic Scripting Edition from Microsoft Corp.) or Java Script.
- the programmer can access the server from a web page by declaring the object on the page, providing a name for the object for easy reference.
- the programmer uses the HTML Object tag to declare the control in the Head or Body section of the page.
- agent.object.Property value
- agent.object_Event (argument as datatype)
- FIG. 11 is a diagram illustrating a Web browsing environment 450 for accessing a Web page with an embedded agent object.
- the computer 20 also shown in FIG. 1 runs software, referred to herein as a “browser,” for browsing of electronic documents and other data from local sources (e.g., the secondary storage 42 of FIG. 1) and from a remote computer network 452 .
- the browser can be integrated with the operating system software, or can be a separate application software.
- the remote computer network 452 shown in FIG. 11 is the Internet.
- the computer 20 connects to the Internet 452 over a telephone line 454 with a modem 456 .
- Other physical connections to the computer network can be used, such as an ISDN, T 1 or high speed telephone line and modem, a television cable and modem, a satellite link, an optical fiber link, an Ethernet or other local area network technology wire and adapter card, radio or optical transmission devices, etc.
- this browsing environment also applies to other public or private computer networks, such as a computer network of a commercial on-line service or an internal corporate local area network (LAN), an intranet, or similar computer network.
- LAN corporate local area network
- Web pages and other files compatible for browsing via the browser software can reside as files of a file system stored in the computer's secondary storage 42 (FIG. 1), or reside as resources at a remote computer 458 (also referred to as a “site”) connected to the computer network 452 , such as a world-wide web site on the Internet.
- the example Web page 460 residing at the site 458 conforms with HTML standards and also includes an object tag and scripting program.
- the web page may also refer to additional information content 462 , such as images, audio, video, executable programs, etc. (hereafter simply “Web content” 462 ), which also reside at the remote computer 458 .
- the document 460 and Web content 462 are stored as files in a file system of the remote computer 458 .
- the document 460 incorporates the Web content 462 using HTML tags that specify the location of files or other Internet resource containing the Web content on the Internet 452 .
- the browser When used for browsing documents, the browser displays the document in a window the computer's user interface allocated to the browser by the operating system.
- FIG. 11 depicts the screen shot of FIG. 2 as an example of the image displayed on the computer's monitor.
- One of the windows 64 acts as the user interface of the browser.
- the browser When the browser renders the Web page, it identifies the HTML Object tag of the agent object embedded in the web page. In response, it creates an instance of the agent object and displays it on the user interface of the computer.
- the agent's animation is not confined to the window of a host application, but rather, is displayed in region window having a bounding region that matches the bounding region of the animation.
- FIG. 11 shows how the genie character plays outside the window of the Internet browser's window.
- the classid parameter of this tag specifies a class identifier of the control. As the web browser renders the web page, it uses the class identifier to create the control, such as by calling the CoCreateInstance API function to cause the control's server application to be loaded and the server application's class factory to instantiate the control.
- the codebase parameter specifies a URL of a file containing the control (such as on the Internet). If the control is not installed on the end user's computer, the web browser can retrieve this file using the URL from the Internet and then install the file on the computer before instantiating the control using its class identifier.
- the data tag (if present) specifies persistent data for the control as either a text string or via a URL of a file containing the control's persistent data.
- the web browser parses the HTML object embedding tags along with the other HTML format data in the hypertext documents. On encountering the HTML object embedding tag for an agent object during the parsing, the web browser instantiates the agent object using the class identifiers specified in the tags. To accomplish this, the web browser invokes a standard OLE interface function that looks in a registry to determine which control the tag refers to and loads it in-process.
- the web browser can download it and the server using the URLs specified as the codebase attribute of the tags (if any). As it renders the HTML code in the web page, the web browser displays the content of the hypertext page in its window.
- the browser As the browser renders the Web page, it also encounters the script.
- the browser For Visual Basic Script, the browser loads a Visual Basic Script runtime interpreter locally to translate the Visual Basic script on-the-fly and run the code. If the browser supports other scripting languages, it loads the appropriate interpreter based on the script language identified in the document. When the browser encounters script code, it loads an appropriate interpreter for the script language, and this interpreter then translates the code.
- the script code executes via calls from the interpreter in response to references to the character control interface, which in this specific implementation is the OLE control interface described in detail above. In the specific case of Visual Basic Script, for example, the browser loads an interpreter in the process space of the browser.
- the browser uses the interpreter to translate the code and then accesses the OLE control interface in response to references to the control interface in the script code.
- the browser loads the OLE control representing the character into the process space of the browser when it encounters an object identifier called the object tag.
- both the control and the interpreter are loaded in the process space of the browser.
- the script code references the character control
- the browser accesses the animation server, which runs in a separate process, through the control interface.
- the control acts a gateway, routing requests for access to the animation server's methods and properties for a particular character to the animation server.
- the script in the Web page references the agent object and uses the control methods, properties and events to define the input commands and output behavior of the object.
- the script can include conditional statements that describe the behavior of the agent when the client specified input commands are detected.
- the animation system supports interaction between and among animations through the use of synchronization services.
- These synchronization services enable an application to control interaction among separate animations that are being played on the display. While these services for synchronizing animations can be used on a variety of types of animation, they are particularly well suited for interactive animations such as the user interface characters (e.g., agent objects) described above.
- the user interface characters are arbitrary shaped (e.g., non-rectangular), do not occupy the entire display screen, and superimposed on the display such that they are not confined to the rectangular window of a hosting application.
- the hosting application is an application that controls the animation, i.e., the application that has made the animation request to make the character move or speak.
- the synchronization services support at least the following functions:
- the synchronization services are implemented in the client-server animation system described above. It is not required that the synchronization services be implemented in a client-server model. However, the client-server model described above is advantageous in that it allows several applications to access its animation and input/output services at the same time. This includes applications written in a scripting language (e.g., text files processed at run-time) or executable files compiled from conventional languages such as C, C++, or Java.
- a single application can synchronize the interaction between two or more distinct characters. Different applications can control a single character, and can also concurrently control distinct animations.
- the synchronization services of the animation server can be accessed by a variety of types of application programs, including, for example, applications written in C, C++, and Java, and rapid prototyping language such as Microsoft Visual Basic. Rapid prototyping languages, also referred to as “scripting languages,” typically provide high level textual commands that run other procedures.
- Visual Basic provides high level text commands that are used to run other programs called Visual Basic Controls. Programs written in these languages, called scripts, are usually in the form of a text file, which can be edited with a simple text editor.
- the animation server provides access to the synchronization services through an Application Programming Interface (API) and high-level script commands.
- API Application Programming Interface
- the API allows applications written in languages such as C, C++ and Java to invoke the synchronization services of the animation server.
- the high-level script commands enable text-based scripts to access the synchronization services via a script engine.
- the synchronization API may be implemented as part of the COM API of the animation server.
- the script commands access the animation server via an ActiveX control, called an agent control.
- the animation server should: 1) handle an animation request expeditiously, and in particular, within a predictable and predetermined time to avoid perceptible delay on the screen; and 2) update the position or state of each animation independently, without reference to an explicit external or internal clock relative to which the events of all simultaneously displayed animations are synchronized.
- One way to implement asynchronous animation is to have the animation server spawn a separate thread from the code requesting the animation. By spawning a separate thread, the animation server enables the requesting code to continue executing without having to wait for the animation to complete. While it may be preferable to avoid scheduling the animation to run on the same thread as the requesting code, animations can be scheduled entirely within a single thread and still be considered asynchronous. This is particularly true for platforms that do not support multi-threading, such as in the case of the Windows 3.1 operating system. Animations can be scheduled within a single thread (or non-threaded process) with each animation limiting the time during which its animation services are in control of the flow of instructions in the thread.
- the specific synchronization services are provided via three primitives: “Wait”, “Interrupt”, and “Stop.” These primitives are a special type of function call, which are accessible from a script or via the animation server API. The code that implements these functions is located in the animation server.
- the animation server manages requests for animation services such as play and speak by maintaining a queue for each animation.
- the animation server queues animation requests in a first-in, first-out order.
- the code that implements the synchronization services utilizes the queues to synchronize the actions of animations that share the display at the same time.
- each animation is defined in terms of actions.
- the actions include playing a graphical animation (sequence of images depicting motion of a character), playing back audio output associated with a character such as the character's speech output or other sound effects, and lip-synched animation, which is a combination of speech output synchronized with mouth animation.
- Applications request actions by invoking the animation services of the animation server. For example, if an application invokes an animation service such as Play, GestureTo, or Speak, these animation requests correspond to actions of a character. These actions are “schedulable” in the sense that the animation server handles the scheduling of these actions for playback in response to animation requests from applications.
- the synchronization services include a command called “wait” that enables an application to synchronize two asynchronous animations.
- wait a command that enables an application to synchronize two asynchronous animations.
- an application identifies an action and the animation and invokes the wait function on that action. This causes the animation server to block playback of one animation until the specified action of the other animation is complete.
- the animation server uses a data structure called a “request object.”
- the request object is used to store an identification of the action of a particular character used to synchronize two different characters on the display.
- the synchronization services include another command named “Interrupt” to stop an ongoing animation in sync with the action of another animation.
- an application invokes the Interrupt function on the character that will interrupt another character. In making this interrupt request, the application also specifies the action of the other character that will be interrupted.
- this function also uses the result object to identify the action used to synchronize the two characters.
- the request object is a parameter to the Interrupt command on character 1 used to identify the action of character 2 that will be interrupted.
- An interrupt call is similar to an animation request because it is placed on a character's queue and triggered when it reaches the top of the queue. It is queued up until all previously scheduled actions on the queue of the specified character (the interrupting character) are completed. At that point, though, it causes the action associated with the request object to be terminated, either by stopping an on-going action or by preventing a still-scheduled action from ever starting.
- the animated character referred to as Genie finished asking the question (“Hey, Merlin . . . ”). that item is removed from the character's queue. The next item on that queue is then examined. It is an “Interrupt” call, which instructs the animation server to immediately halt the on-going animation denoted by MerlinRequest 2 .
- the Genie character will appear to speak, and the Merlin character will appear to stop dancing, as if in response to the question the Genie character just asked.
- the character named Merlin will have reached the point that it is playing the MerlinRequest 2 animation because the Genie character initially waited (via a Wait request) for the animation corresponding to the MerlinRequest 1 object to complete before it started speaking.
- Interrupt calls provide a means by which characters can behave in a specified fashion until such time as another character has completed actions that are scheduled before the interrupt.
- the synchronization services include another command named “Stop” that enables an application to stop an animation that is being played or is already scheduled to be played. More specifically, this function is called on a character to stop an action of that character. In contrast to the Interrupt function, the stop function is not triggered upon an action of a character. Rather, the stop function is immediate in the sense that it stops the specified action in response to the stop request without waiting for some other specified action to occur.
- the implementation of the stop function in the animation server stops a specified action of a character by deleting the specified action from the character's queue.
- an application specifies the character and the action of that character to be stopped. Specifically, the application first creates a request object and then calls the stop function on a character, using the request object to specify the action to be stopped.
- the animation server also provides a synchronization function called StopAll, which differs from Stop in that it stops all actions scheduled for a character.
- the animation server has an event passing mechanism that can be used to notify an application when predefined events occur. These events are part of the animation server API and the control interface used for scripts. In the case of scripts, the animation server passes the events to the script engine, which is responsible for running the script.
- the animation can send events back to the application (or script engine) to describe its progress as the application is executed.
- the events permit the application to synchronize animations with user input.
- This also applies to a script executing in the script engine. For instance, in the VB script discussed above, the Click event could be used to enable the user to stop Genie by clicking the mouse button while positioning the cursor over Genie's animation on the screen:
- This example script uses a callback routine (Agent_Click) to stop the Genie's Speak action if the user clicks the mouse button on Genie in the display.
- the callback routine invokes the stop command and specifies the action to be stopped using the request object (Req).
- This request object is set to the action., Genie.Speak (“Why did the chicken cross the road?”.
- the animation server will remove the specified action from Genie's queue.
- FIG. 12 is a block diagram illustrating how applications access services, including the animation and synchronization services of the animation system.
- An animation server 500 implements the animation and synchronization services.
- Applications written in a prototyping language (scripts 502 , 504 ) access the services via a scripting engine 506 . These scripts are typically represented as text files, which are processed at run time by the scripting engine 506 .
- Application programs written in conventional programming languages such as C, C++, and Java (e.g., APP. 1 and APP. 2 in FIG. 12) access the animation and synchronization services implemented in the server via the server's API.
- Scripts 502 , 504 written in Visual Basic or some other prototyping language, are interpreted in the scripting engine 506 .
- the scripting engine 506 interprets the script commands, such as the animation and synchronization commands described above, and invokes the animation server to execute them.
- the type of scripting engine depends on the script language.
- Some examples of script engines include an instance of the Microsoft Visual Basic run-time environment, or a web browser like Microsoft Internet Explorer.
- the script engine 506 accesses the animation server through an OLE control called the agent control 508 .
- the agent control 508 is a dynamic link library that can be loaded into the process space of programs that qualify as OLE containers.
- the script engine 506 is an OLE container and interacts with the OLE control 508 embedded in it via the standard OLE container-control interfaces. In turn, the agent control communicates with the animation server through the server's API.
- FIG. 12 shows two additional applications accessing the server through its programming interface to illustrate that the server can process requests from several concurrently executing programs including the script engine 506 , as well as other applications 510 , 512 .
- the animation server 500 manages animation and synchronization requests using a queue (e.g., 520 , 522 , 524 ) for each character.
- the queue is used to queue all animation (Play, GestureTo), utterance (Speak), and interrupt (Interrupt) calls. These queues run asynchronously.
- the animation requests in each queue are carried out on separate threads of execution ( 530 , 532 , 524 ).
- the animation server includes a program module called the request manager 540 that is responsible for managing the queues for each character.
- the request manager is part of animation server application, and it runs on a separate thread from the threads for each queue.
- the request manager maintains a queue of pending requests for each character.
- a client program e.g., script or application program
- the request manager appends a new entry to the tail of the queue of the character subject to the request.
- the entry at the head of the queue if any, is either the action (e.g., Play or Speak request) that is currently being executed or is a placeholder for an action stored in some other queue.
- Such placeholders serve as surrogates for “wait requests”, operations through which one character “waits” until a specified action is performed and completed by some other character.
- an “action” refers to a scheduable animation requested by a client such as a Play or Speak request.
- the entries in the queues either represent scheduable actions or placeholders for the actions.
- the client identifies the action that is subject to a particular request via the request object.
- the request manager takes the appropriate steps necessary to update the queues to process the request.
- the request manager 540 removes that action from the appropriate queue, and, if necessary, marks any surrogate wait requests on other queues as “satisfied”. It then activates the next item on the queue.
- the request manager activates a surrogate wait request, it halts processing on the actions of that queue until the action specified in the wait request is satisfied.
- the request manager removes that action from the queue. A wait request may be satisfied before it reaches the head of the queue.
- the wait request is not removed until it reaches the head of the queue.
- Alternative implementations could remove the wait request from the queue as soon as it is satisfied. Functionally, these alternative approaches are similar.
- Stop and StopAll requests are processed similarly. Since they are executed immediately upon being made, they are not entered into the queue. When a stop request is encountered, the request manager immediately marks the relevant item as complete. Then, when that item reaches the head of the queue, it is removed immediately from the queue. As in the case of a satisfied wait request, an alternative implementation could remove an action that is subject to a Stop request immediately, rather than marking it complete.
- a thread is a basic program unit that the scheduler in the operating system kernel uses to determine access to CPU time.
- a thread in this context is an execution path within a process, has its own private stack storage and execution context, shares memory allocated to its parent process, and can be one of many concurrent threads created by a single process. Any thread can create an “Event” object and obtain a handle to it using an operating system function called CreateEvent. Any threads belonging to any process can obtain a handle to the same event by specifying the event name. Any thread with a valid handle can then use the SetEvent to signal the occurrence of the event. Threads waiting for the event are then free to continue execution, and multiple threads may become eligible to run when the event is signaled.
- the animation server is an executable process that has multiple threads, including the request manager and any threads spawned for character queues (character threads).
- the request manager controls the execution of the character threads by setting any of four predefined events for the character queues: an Exit event, a Stop event, a New event, and a Done event.
- Each of the character queues has a unique set of these four events.
- the character threads are implemented as a loop that periodically calls the WaitForMultipleObject function in the operating system. When it makes this call, the thread specifies an array of handles to each of its four events in the order listed above. The order is important because it establishes the order in which the operating system determines whether each of these events has been signaled. After making the function call, a character thread waits for the four event objects to be signaled.
- the queue is to enter an exit state: all actions it contains should be removed and the character data cleaned up in preparation for shutdown of the animation server.
- the Stop event the currently active animation is being stopped, and should be cleaned up along with any other pending animation requests that were posted prior to the Stop.
- the New event is set, a new animation request is being added to the queue.
- the Done event is set, the current animation has just completed, and needs to be cleaned up.
- the request manager sets a New event for the character thread of the character identified in the request.
- the target character thread adds the action to the tail of its queue.
- Each of the character threads execute concurrently under the multi-threading scheduling scheme of the operating system. As actions or surrogate actions reach the top of a queue, the character thread processes the action. In the case of standard Play or Speak request, the character thread makes a call to the request manager, which in turn, takes the appropriate action to play the animation. In the reference implementation, animations are played on the main thread of the application server. If multiple animations need to be drawn to the screen at the same time, the main thread makes drawing calls to the operating system quickly so that the animations appear simultaneously on the screen from the user's perspective. As noted below, it is also possible to implement the animations on separate threads of the animation server, but there are some performance trade-offs.
- the character thread When a Wait request reaches the head of a queue, the character thread makes a call to the request manager indicating that it is in a wait state (blocked) pending the completion of a particular action. The blocked thread remains in this state until the request manager sets a Done event for this action. In response to this Done event, the character thread cleans up the surrogate action at the head of its queue and proceeds to the next action.
- the character thread When an Interrupt request reaches the head of the queue, the character thread signals a stop event for the queue of the character that is subject to the interrupt request, identifying the action or actions to be stopped. The character thread for which the Stop event is set then responds to the Stop event by marking the identified action in its queue as complete.
- Each of the character queues proceed to the next entry in their respective queues when they receive Done events.
- the character queues continue to pop entries from the top of their queues until signaled to stop or exit as described above.
- WaitForMultipleObjects by its design, allows the queue to assign the appropriate priority to the event objects: Exit before Stop before New before Done. It also has the advantage that the operating system code supports the assurance that the state of the queue is actually kept internally consistent. By using operating system primitives for implementing the synchronization of the threads that control the animations, consistency is guaranteed.
- Play and Speak requests are executed on the main thread of the application.
- Threads although computationally fairly lightweight, carry fairly significant memory costs in some systems implementing the Win32 API for the Windows Operating System. For instance, under Windows 95, approximately 64K of kernel memory is consumed by each thread just to maintain its essential data. Each character already costs one thread to support its request manager queue. Thus, a character's animation would cost yet another thread if an animation requests were executed on a separate thread. The costs of the second threads would add up very quickly.
- the main thread of the server application can be “hung”—stop processing messages—by activities driven by inter-process communication between the animation server and a client.
- the main server thread can be hung it makes a call to an external thread or process that does not return. This, in turn, will hang the animation services, causing the characters to appear to freeze and to stop responding to user input.
- the animation system does not have to be implemented as an OLE server.
- the system can be implemented according to other object oriented programming models, or alternatively, need not be based on an object model at all.
- scripts access animation services via an OLE control.
- OLE control is only one possible way to process script commands in the script engine.
- the specific syntax of the script commands and API calls used to access synchronization services can vary as well. For example, there are a variety of alternative ways to identify an action of an animation for the purpose of synchronizing the actions of different animations.
- the request object is just one possible data structure that can be used as an identification of a character's action.
- the server's API may use a request object to identify an action, or may use a pointer to an action to identify the action.
- the animation server can be implemented as a multi-threaded application with the request manager and character queues executing on separate threads.
- a similar functionality can be achieved in multi-tasking platforms that do not support multi-threading.
- each of the threads could be implemented as separate processes that employ shared memory to access shared data.
Abstract
Description
- This application is a continuation in part of U.S. application Ser. No. 08/858,648 filed with the U.S. Patent and Trademark Office on May 19, 1997.
- The invention relates to computer generated animation, and more specifically to synchronization of interactive animations (animations that are responsive to user input).
- Computer animation is more compelling when it includes realistic interaction among the components in a graphics scene. This is especially true when the animated characters in a graphics scene are supposed to simulate life-like interaction. Consider the following scenario: during a short segment of an animated display, two characters are on-screen doing a vaudeville routine. They dance together for a while, then one of them stops, puts down his cane, and turns to the other, who is still dancing. He says, “Hey, Merlin! Did you hear the one about the cat who ate the paper?” Merlin responds, “No, I haven't heard that one.”
- Scenarios like this are at the heart of animation, yet it is difficult for application programs to synchronize the actions of characters so that they appear more life-like. Most current applications use a time-based scripting system, in which the precise times at which individual actions and gestures evolve in lock step with a clock. This method is very flexible and quite powerful. Unfortunately, it requires a great deal of attention to each frame, it is very time-consuming, and the resulting script is hard to read. These limitations affect the use and availability of animation to designers in the mass market. Since it is particularly difficult to express such scripts in string format, they are particularly unsuitable to the World Wide Web (the Web), over which most control information is transmitted as text.
- So-called rapid prototyping languages (including the Microsoft Visual Basic (VB) and Borland Delphi prototyping languages) use a much more accessible form of scripting. These languages use textual command scripts to run procedures based on underlying controls. VB, in particular, represents its scripts as simple text files, which can be edited with the most basic of tools and are easy to read and write. Moreover, VBScript, a somewhat restricted form of VB, is already widely available as a scripting tool over the Web, and is naturally expressed in text.
- While these rapid prototyping languages facilitate development of software applications and are well suited for Web site development, they do not provide the precise control over timing that multimedia scripts provide. Unfortunately, multimedia scripts are more difficult to use, particularly because they require complex time-based programming to synchronize animations.
- The invention provides a method for synchronizing animations that addresses these and other drawbacks. The invention may be implemented in an animation server that provides synchronization services to client programs. The synchronization services are particularly well suited for scripted animations, i.e., animations that are controlled via a script. However, these synchronization services are also accessible to other types of application programs written in programming languages such as C, C++, and Java via an Application Programming Interface. The invention provides synchronization methods used to synchronize the playback and speech of two or more interactive animations that share the display. These animations are interactive in the sense that they respond to user input such as clicks of a mouse button or speech input via a speech recognition engine.
- In one implementation of the invention, an animation system enables applications to request animation services and input/output services for interactive animations such as user interface characters. One specific form of this type of character is a non-rectangular animation that is superimposed over the windows of concurrently executing programs. Through the animation system's input services, applications can specify the input commands that a character will be responsive to, including mouse input or speech via a speech recognition engine
- Applications animate the characters by invoking commands to request actions such as playing an animation sequence or generating speech output from text. In response to these commands, the system schedules the actions for playback. In one implementation, the system maintains a queue for each character and schedules the actions in first-in, first-out order.
- To synchronize actions of two or more characters, an application invokes a synchronization command of the animation system and specifies an action of a character that it wants to synchronize with another character. The way in which the system synchronizes the actions of the characters depends on the synchronization command. One type of command, called a wait command, synchronizes actions of different characters by halting a character until the specified action of another character has completed. Another type of command, called an interrupt, causes an interrupt to be scheduled for a character. When this interrupt is processed, the animation server halts (e.g., deletes from a queue) a specified action of another character. Using the events supported in the animation system, an application can program the system to notify it about the progress of an animation or about input from the user. This feature enables applications to synchronize actions of characters in response to events.
- Applications can be written in the form of text-based scripts. These scripts control animations by making animation requests via textual script commands. Scripts can animate more than one character and synchronize the character's actions via the synchronization commands summarized above. The script commands operate on character actions, rather than on a time-based scheme. This enables programmers to quickly write animation scripts involving interaction between two or more animations without requiring precise frame by frame control of the animations.
- 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 that serves as an operating environment for the invention.
- FIG. 2 is a screen shot illustrating an example of animated character located on top of the user interface in a windowing environment.
- FIG. 3 is a diagram illustrating the architecture of an animation system in one implementation of the invention.
- FIG. 4 is flow diagram illustrating how the animation server in FIG. 3 plays an animation.
- FIG. 5 illustrates an example of the animation file structure.
- FIG. 6 is a flow diagram illustrating a method used to retrieve image data to construct a current frame of animation.
- FIG. 7 is a flow diagram illustrating the process for obtaining the bounding region of an arbitrary shaped animation.
- FIG. 8 is a diagram illustrating an example of a COM server and its relationship with an instance of object data.
- FIG. 9 is a conceptual diagram illustrating the relationship between a COM object and a user of the object (such as a client program).
- FIG. 10 illustrates the relationship among the different types of objects supported in the animation server.
- FIG. 11 is a diagram of a web browsing environment illustrating how interactive, animated user interface characters can be activated from Web pages.
- FIG. 12 is a block diagram illustrating the flow of information from scripts and other types of applications to the animation server and the character threads that it spawns.
- Computer Overview
- FIG. 1 is a general block diagram of a computer system that serves as an operating environment for the invention. The
computer system 20 includes as its basic elements acomputer 22, one ormore input devices 28, including a cursor control device, and one ormore output devices 30, including a display monitor. Thecomputer 22 has at least one high speed processing unit (CPU) 24 and amemory system 26. The input and output device, memory system and CPU are interconnected and communicate through at least onebus structure 32. - The
CPU 24 has a conventional design and includes anALU 34 for performing computations, a collection ofregisters 36 for temporary storage of data and instructions, and acontrol unit 38 for controlling operation of thesystem 20. TheCPU 24 may be a processor having any of a variety of architectures including Alpha from Digital, MIPS from MIPS Technology, NEC, IDT, Siemens, and others, x86 from Intel and others, including Cyrix, AMD, and Nexgen, and the PowerPC from IBM and Motorola. - The
memory system 26 generally includes high-speedmain memory 40 in the form of a medium such as random access memory (RAM) and read only memory (ROM) semiconductor devices, and secondary storage 42 in the form of long term storage mediums such as floppy disks, hard disks, tape, CD-ROM, flash memory, etc. and other devices that store data using electrical, magnetic, optical or other recording media. Themain memory 40 also can include video display memory for displaying images through a display device. Thememory 26 can comprise a variety of alternative components having a variety of storage capacities. - The input and
output devices input device 28 can comprise a keyboard, a cursor control device such as a mouse or trackball, a physical transducer (e.g., a microphone), etc. Theoutput device 30 shown in FIG. 1 generally represents a variety of conventional output devices typically provided with a computer system such as a display monitor, a printer, a transducer (e.g., a speaker), etc. Since the invention relates to computer generated animation and speech input and output services, the computer must have some form of display monitor for displaying this animation, a microphone and analog to digital converter circuitry for converting sound to digitized audio, and speakers and digital to audio converter circuitry for converting digitized audio output to analog sound waves. - For some devices, the input and output devices actually reside within a single peripheral. Examples of these devices include a network adapter card and a modem, which operate as input and output devices.
- 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 adiscrete ALU 34, registers 36 andcontrol unit 38 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 computer industry. - Animation System Overview
- FIG. 2 is a screen shot illustrating an example of animated character located on top of the user interface in a windowing environment. This screen shot illustrates one example of how an implementation of the invention creates arbitrary shaped animation that is not confined to the window of a hosting application. The
animated character 60 can move anywhere in the user interface. In this windowing environment, the user interface, referred to as the “desktop” includes theshell 62 of the operating system as well as a couple ofwindows window 64 and aword processor application 66 running in a second window on the desktop of the Windows 95 Operating System. - The animated character moves on top of the desktop and each of the windows of the executing applications. As the character moves about the screen, the animation system computes the bounding region of the non-transparent portion of the animation and generates a new window with a shape to match this bounding region. This gives the appearance that the character is independent from the user interface and each of the other windows.
- To generate an animation like this, the animation system performs the following steps:
- 1) loads the bitmap(s) for the current frame of animation;
- 2) constructs a frame of animation from these bitmaps (optional depending on whether the frame is already constructed at authoring time).
- 3) computes the bounding region of the constructed frame in real time;
- 4) sets a window region to the bounding region of the frame; and
- 5) draws the frame into the region window.
- The bounding region defines the non-transparent portions of a frame of animation. A frame in an animation is represented as a rectangular area that encloses an arbitrary shaped animation. The pixels located within this rectangular area but do not form part of the arbitrary-shaped animation are transparent in the sense that they will not occlude or alter the color of the corresponding pixels in the background bitmap (such as the desktop in the Windows Operating System) when combined with it. The pixels located in the arbitrary animation are non-transparent and are drawn to the display screen so that the animation is visible in the foreground.
- The bounding region defines the area occupied by non-transparent pixels within the frame, whether they are a contiguous group of pixels or disjoint groups of contiguous pixels. For example, if the animation were in the shape of a red doughnut with a transparent center, the bounding region would define the red pixels of the doughnut as groups of contiguous pixels that comprise the doughnut, excluding the transparent center. If the animation comprised a football and goalposts, the bounding region would define the football as one or more groups of contiguous pixels and the goalposts as one or more groups of contiguous pixels. The bounding region is capable of defining non-rectangular shaped animation including one or more transparent holes and including more than one disjoint group of pixels.
- Once computed, the bounding region can be used to set a region window, a non-rectangular window capable of clipping input and output to the non-transparent pixels defined by the bounding region. Region windows can be implemented as a module of the operating system or as a module outside of the operating system. Preferably, the software module implementing region windows should have access to input events from the keyboard and cursor positioning device and to the other programs using the display screen so that it can clip input and output to the bounding region for each frame. The Windows Operating System supports the clipping of input and output to region windows as explained further below.
- The method outlined above for drawing non-rectangular animation can be implemented in a variety of different types of computer systems. Below we describe an implementation of the invention in a client-server animation system. However the basic principles of the invention can be applied to different software architectures as well.
- FIG. 3 is a general block diagram illustrating the architecture of a client server animation system. The animation system includes an
animation server 100, which controls the playback of animation, and one or more clients 102-106, which request animation services from the server. During playback of the animation, the server relies on graphic support software in theunderlying operating system 120 to create windows, post messages for windows, and paint windows. - In this specific implementation, the operating system creates and clips input to non-rectangular windows (“region windows”). To show this in FIG. 3, part of the operating system is labeled, “region window controller” (see item122). This is the part of the operating system that manages region windows. The
region window controller 122 creates a region window having a boundary matching the boundary of the current frame of animation. When the system wants to update the shape of a region window, the regionizer specifies the bounding region of the current frame to the operating system. The operating system monitors input and notifies the server of input events relating to the animation. - The services related to the playback of animation are implemented in four modules 1) the
sequencer 108; 2) theloader 110 3) theregionizer 112; and 4) the mouth animation module 114. Thesequencer module 108 is responsible for determining which bitmap to display at any given time along with its position relative to some fixed point on the display. - The
loader module 110 is responsible for reading the frame's bitmap from some input source (either a computer disk file or a computer network via a modem or network adapter) into memory. In cases where the bitmap is compressed, the loader module is also responsible for decompressing the bitmap into its native format. There are variety of known still image compression formats, and the decompression method, therefore, depends on the format of the compressed bitmap. - The
regionizer module 112 is responsible for generating the bounding region of the frame, setting it as the clipping region of the frame's hosting region window and then drawing the frame into the region. In slower computers, it is not feasible to generate the bounding region as frames are constructed and played back. Therefore, in this implementation the regionizer also supports the loading of bounding region information in cases where it is precomputed and stored along with the frame data in the animation file. - The mouth animation module114 is responsible for coordinating speech output with the animation representing a user interface character's mouth. The mouth animation module receives a message from a speech synthesis engine 116 whenever a specific phoneme is about to be spoken. When the mouth animation module receives this message, it performs a mapping of the specified phoneme to image data stored in a animation mouth data file that corresponds to the phoneme. It is responsible for loading, decompressing, and controlling the playback of the animation representing the character's mouth.
- The speech synthesis engine116 is responsible for generating speech output from text. In this implementation, the speech synthesis engine 116 is a SAPI compliant text to speech generator from Centigram Communications Corp., San Jose, Calif. Other SAPI compliant text to speech generators can be used as well. For example, Lernout and Hauspie of Belgium also makes a SAPI compliant text to speech generator.
- The speech recognition engine118 is responsible for analyzing digitized audio input to identify significant words or phrases selected by the animation server. The animation server defines these words or phrases by defining a grammar of acceptable phrases. The client specifies this grammar by specifying sequences of words that it wants the system to detect in a text string format. The server also supports a command language that includes boolean operators and allows alternative words. This command language enables the client to specify a word or phrase along with a number of possible alternative or option words to look for in the speech input. The syntax of the command language is described in more detail below.
- The speech recognition used in this implementation is a SAPI compliant speech recognition engine made by Microsoft Corporation. A suitable alternative speech recognition engine is available from Lernout and Hauspie of Belgium.
- The operating system in this implementation is the Windows 95 operating system from Microsoft Corporation. The application programming interface for the operating system includes two functions used to create and control region windows. These functions are:
- 1) SetWindowRgn; and
- 2) GetWindowRgn
- SetWindowRgn
- The SetWindowRgn function sets the window region of a rectangular host window. The window region is an arbitrary shaped region on the display screen defined by an array of rectangles. These rectangles describe the rectangular regions of pixels in the host window that the window region covers.
- The window region determines the area within the host window where the operating system permits drawing. The operating system does not display any portion of a window that lies outside of the window region. A description of an implementation of SetWindowRgn follows below:
int SetWindowRgn( HWND hWnd,// handle to window whose window region is to be set HRGN hRgn, // handle to region BOOL bRedraw // window redraw flag ); Parameters hWnd Handle to the window whose window region is to be set. hRgn Handle to a region. The function sets the window region of the window to this region. If hRgn is NULL, the function sets the window region to NULL. bRedraw Boolean value that specifies whether the operating system redraws the window after setting the window region. If bRedraw is TRUE, the operating system does so; otherwise, it does not. Typically, the program using region windows will set bRedraw to TRUE if the window is visible. Return Values If the function succeeds, the return value is nonzero. If the function fails, the return value is zero. Remarks If the bRedraw parameter is TRUE, the system sends the WM_WINDOWPOSCHANGING and WM_WINDOWPOSCHANGED messages to the window. - The coordinates of a window's window region are relative to the upper-left corner of the window, not the client area of the window. After a successful call to SetWindowRgn, the operating system owns the region specified by the region handle hRgn. The operating system does not make a copy of the region. Thus, the program using region windows should not make any further function calls with this region handle. In particular, it should not close this region handle. A description of an implementation of SetWindowRgn follows below:
- GetWindowRgn
- The GetWindowRgn function obtains a copy of the window region of a window. The window region of a window is set by calling the SetWindowRgn function.
int GetWindowRgn( HWND hWnd,// handle to window whose window region is to be obtained HRGN hRgn // handle to region that receives a copy of the window region ); Parameters hWnd Handle to the window whose window region is to be obtained. hrgn Handle to a region. This region receives a copy of the window region. Return Values The return value specifies the type of the region that the function obtains. It can be one of the following values: Value Meaning NULLREGION The region is empty. SIMPLEREGION The region is a single rectangle. COMPLEXREGION The region is more than one rectangle. ERROR An error occurred; the region is unaffected. Comments The coordinates of a window's window region are relative to the upper-left corner of the window, not the client area of the window. - The region window controller shown in FIG. 3 corresponds to the software in the operating system that supports the creation of region windows and the handling of messages that correspond to region windows.
- In this implementation, the speech recognition engine and the speech synthesis engine communicate with an audio input and output device such as a sound card according to the SAPI specification from Microsoft. In compliance with SAPI, these engines interact with an audio device through software representations of the audio device referred to as multimedia audio objects, audio sources (which provide input to the speech recognition engine) and audio destinations (which mediate output from the speech synthesis engine). The structure and operation of this software representation are described in detail in the SAPI specification available from Microsoft.
- In the next two sections, we describe two alternative implementations of the animation system shown in FIG. 3. Both implementations generate arbitrary shaped animation and can compute the arbitrary shaped region occupied by non-transparent pixels of a frame in real time. However, the manner in which each system computes and stores this region data varies. Specifically, since it is not computationally efficient to re-compute the region data for every frame, these systems use varying methods for caching region data. The advantages of each approach are summarized following the description of the second implementation.
- First Implementation of the Animation System
- FIG. 4 is flow diagram illustrating how the animation server plays an animation. First, the animation data file is opened via the computer's operating system as shown in
step 150. The animation data file includes an animation header block and a series of bitmaps that make up each of the frames in the animation. Once the operating system has opened the file, theloader module 108 reads the animation header block to get all of data needed to play an animation and passes it to the sequencer as shown instep 152. - FIG. 5 illustrates an example of the animation file structure. The animation header lists the number of frames (160) and includes a block of data for each frame (see items 162-166 in FIG. 5 for example). The
frame data 170 consists of a frame type (image, branch or sound) 172, frame position (x, y coordinates) 174, duration (in 60ths or a second) 176, aunique ID 178, and an offset 180 into the animation data file where thecompressed bitmaps 182 for the frame reside. Animation branch frames allow developers to specify alternate pathways through the animation sequence other than the default sequential flow. Sound frames allow developers to specify digitized sound data to be played at a specific time in the animation sequence. - Back at FIG. 4, the process for playing animation continues at
step 190, where the sequencer initializes the current frame number. Once the loader has successfully loaded the animation header block, the sequencer can start playing the animation. It initializes the current frame number to zero and looks at the type field of the current block of frame data to determine the type for the current frame. - The
next step 192 is to get the frame data for the current frame as shown instep 192. When necessary, the loader loads the data for the current frame from the animation file as specified in the frame data block. The sequencer then constructs the frame from the data retrieved for the current frame as shown instep 194. - FIG. 6 is a flow diagram illustrating the method used to retrieve image data for the current frame. If the frame type is an image, the sequencer first looks in a data cache of frame bitmaps for an entry equal to the next frame's ID as shown in
steps - If the sequencer finds the frame ID in the data cache, it returns with the constructed frame that is already in the cache as shown in the flow diagram. If there is no entry in the data cache for the current frame, the sequencer passes a request on to the loader to load the required bitmaps for the specified frame. Each animation frame can be made up of multiple layered bitmaps. The loader uses the data offset for the frame from the animation header block to read all of the compressed bitmaps that make up the frame from the animation data file into the computer's memory (see
step 204, FIG. 6). - Once in memory, the loader decompresses the individual bitmaps and combines them into a single decompressed bitmap as shown in
steps - Once the sequencer has generated the appropriate decompressed bitmap for the current frame, it can pass control to the regionizer, which computes a bounding region for the frame if the bounding region is not already available. The bounding region defines the non-transparent portion of the constructed frame. For a solid object like the genie in FIG. 2, the bounding region is the boundary of the genie. Some objects can have transparent regions inside of them, in which case the bounding region defines the non-transparent portion and also describes any transparent portion within an object as well. A constructed frame of animation can have a number of disparate pieces which are not necessarily contiguous. The step of computing the bounding region (210, in FIG. 4) can be computed in real time, which means that the bounding region does not need to be pre-computed. Instead, the regionizer can compute the bounding region as it constructs and displays each frame.
- In this implementation, the regionizer takes one of three actions: 1) looks in a region data cache to see if the region data is already present; 2) on faster computers, generates the bounding region in real time; and 3) on slower computers, loads and uses a pre-computed bounding region. FIG. 7 is a flow diagram illustrating the process for obtaining the bounding region.
- The first choice for the regionizer is to attempt to retrieve the necessary region data from a region data cache in main memory of the computer as shown in
step 220 of FIG. 7. This cache works similarly to the image cache in that it is a most recently used queue (in other words, it is a last-used-first-out queue). If the necessary data is found in the data cache it is retrieved (seesteps 222, 224). - If it is not in the queue, two alternate pathways are possible. FIG. 7 illustrates the steps performed on a fast computer where the regionizer computes the bounding region in real time. The animation server is able to determine whether to compute the bounding region in real time by checking the computer's registry
- If the computer executing the animation server is deemed fast enough, the regionizer will compute the bounding region of the decompressed bitmap frame in real-time. In this implementation, the regionizer computes the bounding region as shown in FIG. 7 and described below. First in step labeled226, the regionizer determines which color (the color key) the bitmap is using to identify its transparent portions. The first pixel in the frame's bitmap (i.e. the pixel at location (0, 0) in rectangular coordinate space of the bitmap where (0, 0 is the upper left hand corner) is deemed special in that it defines the transparent color of the frame. The pixel value of this transparent color is sometimes referred to as the color key. Using this color key, the regionizer scans the bitmap one line at a time looking for contiguous runs of non-transparent color as shown in
step 228. When it finds a run of non-transparent pixels, it combines the bounding rectangle of the run with rectangles from previous runs 230. These rectangles always have a height of one, i.e. they are a single scan line of the bitmap, and have a width less than or equal to the total width of the bitmap. The operating system is responsible for combining the rectangles into non-rectangular regions in an optimized way. This process continues for every line in the bitmap until the entire bitmap has been completely scanned (as reflected generally by the loop back to step 228 from decision block 232). Upon completion, a single region is available that describes the bounding region of the animation frame. - On computer systems that are too slow to perform this type of processing in the time required by the animation server, the region data can be pre-processed during the animation development. The same process described above is used to generate the region data for each bitmap frame in the animation. The region data is then compressed and stored to a separate data file along with the animation data file. On slow systems, instead of generating the region data when it is needed, the data is simply read from a data file and decompressed. This method is far less CPU intensive than generating the region data in real-time which is important in low end PC systems. The disadvantage of this technique is that the region data for an animation can be quite large when stored to a data file, cannot be scaled (which is discussed further below), and is far less flexible in that it must be computed at the same time the animation is built. When the system is enhanced to support real-time rendered animations, this technique does not work because the bounding region needs to be generated in real time after the image has been modified, i.e. scaled, rotated, translated etc.
- After the regionizer has retrieved the bounding region, either by generating it in real-time or by loading and decompressing it from a data file, it saves it in the region data cache for future use.
- We now return again to the diagram in FIG. 4. At this point, the animation server has all of the components in memory that are necessary to display the next frame of the animation. The first step is to position the region window at the appropriate location as specified by the frame's x, y coordinate in the frame data block (see
step 240 in FIG. 4). Calls to the operating system, such as SetWindowPos in the Windows Operating System, make this step possible. - The next step242 is to set the animation frame window's region to the region generated by the regionizer. The operating system is responsible for sending the appropriate paint messages to any window that intersects with the previous region of the animation frame window so that this area can be redrawn. In response to receiving these messages, the application owning the window is responsible for repainting itself in the portion of its window altered by the animation.
- One way to re-draw the portion of the desktop that is modified by the animation as it moves from frame to frame is to compute a bounding rectangle that encloses the animation in two consecutive frames and to re-compute the portion of the user interface that falls within this bounding rectangle. This bounding rectangle captures the animation in its current and previous frame. In other words, it includes the screen area once occupied by the animation in the previous frame as well as the screen area occupied by the animation in the current frame. The operating system instructs applications within this rectangle to redraw themselves. The portion of the desktop user interface within this rectangle is copied to an off-screen buffer. The animation server then instructs the operating system to draw the current frame of animation, clipped by its bounding region, to this off-screen buffer. Finally, the operating system performs a bit block transfer of this portion to the frame buffer to display the current frame of animation along with the re-drawn portion of the Windows desktop user interface, which is the background of the animation.
- As shown in
step 244 of FIG. 4, the animation server draws the decompressed, composited bitmap generated by the sequencer to the animation frame's region window. The operating system clips this bitmap to the bounding region of the window (which exactly matches the non-transparent pixels of the composited bitmap). The sequencer then sets an operating system timer to go off after an amount of time equal to the duration specified in the frame data (see step 246). - When the timer goes off, the entire process is repeated for the next frame in the animation. This is illustrated in FIG. 4 by the timer-up
message 248. - The animation server employs a similar technique to animate a portion of an animated character representing the character's mouth. The animation server loads, decompresses, and caches bitmaps representing the character's mouth. To create the illusion of speech, the animation server draws a bitmap representing the mouth on top of the constructed frame representing the character at the (x, y) coordinates where the character's mouth is located.
- In this implementation, the servers maintains bitmaps representing the character's mouth in a variety of different positions in a mouth animation file. There are a number of different bitmaps, each representing the position of the mouth for a corresponding phoneme. To enhance realism, the server can maintain different sets of mouth data files and select the appropriate one based on the position of the character. Each set of mouth data files can map a set of phonemes to bitmaps representing the mouth position for a phoneme.
- To lip-synch the mouth animation with the speech output, the server instructs the speech synthesis engine to notify it before it generates speech output for a phoneme. Just before the speech synthesis engine is about to output a phoneme, it passes a message to the mouth animation module identifying the phoneme. The mouth animation module loads the animation and draws at the (x,y) location on top of the current frame of animation.
- If the region data is being generated in real-time, animations can be scaled and played back at a size different from the size that the animation was originally developed at. The entire process as described above is essentially the same. The main difference is that the sequencer can scale the composited, decompressed bitmap returned by the loader using the specified scaling factor. The regionizer works on decompressed bitmaps stored in memory and needs no knowledge of the size of the original source of the bitmap or any scaling factor. The operating system can be used to perform scaling of bitmaps in an efficient manner. Once the bitmap is scaled it can be passed to the regionizer and the system works as described above. Allowing scaling of animations in real-time is important because it allows end users to have greater control over the look and feel of the system.
- Another significant feature of this implementation is the way in which the animation's moving, non-rectangular window receives cursor device input from the user. Since the animation server repetitively updates the bounding region of the animation for each frame, the active area of the animation always corresponds to the non-transparent portion of the current frame. Thus, the operating system only notifies the server of cursor input (e.g. right and left mouse clicks) when the cursor is positioned within the non-transparent portion of the current frame. This form of interactive behavior enhances the effect of the animation operating outside the focus of any rectangular windows currently displayed on the Windows desktop user interface.
- Second Implementation of the Animation System
- The second implementation of the animation system is similar to the first animation system in that it generates arbitrary shaped animation and can also generate a bounding region for a frame of animation in real time. From the stand-point of the user, this implementation generates arbitrary-shaped animation with similar behavior as the first implementation. Namely, it produces arbitrary shaped animation and plays a sequence of animation in the foreground of the user interface such that the animation is not limited to a window of a host application or to a window of an application that requests playback of the animation. However, it has some differences: 1) the system does not load individual bitmaps and then construct each frame from separate bitmaps, but instead, loads constructed frames; 2) it does not cache region data in a MRU cache in main memory as above, but instead, caches all regions in secondary storage (e.g., on a computer's hard disk) as they are generated; and 3) it has the additional capability to pre-compute region data on a low priority thread.
- Below we describe these and other implementation details. We describe this system using the example of an animated “character,” an animation that has life-like gestures. One example of this type of character is the genie shown in FIG. 2. Although it is described using the specific example of an animated character, this animation system can be applied to other forms of arbitrary shaped animation as well.
- The system first gets a request to open a character file. The file contains character, animation and audio data and is a structured storage file (see “Inside OLE” by Kraig Brockschmidt for a description) which contains all of the data necessary to play region window animations. At this time, the calling module can register itself to receive event notifications that describe the current state of the animation system at various times. Once the file is successfully opened, the character data stream is read into memory and the character is initialized. The data included in the character data stream includes the character's color table, an index into the color table that defines the transparent color (or color key), size information (i.e. width and height of the character frame), audio definition data, animation version information and any other data necessary for initialization of the character. A window is then created of the appropriate size but is not made visible until explicitly done so by the calling module (such as a client program to the animation server). A logical palette is created from color table information retrieved from the character data stream. The character is now initialized and is ready for animation requests.
- Each animation is stored in a separate data stream in the structured storage file. When an animation is requested to be played, the system finds the appropriate data stream and begins loading it into memory. Animation data consists of a sequence of animation frame data. Frame data consists of all of the data necessary to render an animation frame to the display device. This consists of the actual image bits for the frame, as well as a duration, coordinate offsets, frame branching logic, and lip-synched mouth image data (described further below). If the image bits are in a compressed format they are decompressed. Note that in this implementation, the frame is already constructed in the sense that it does not have to be assembled by combining more than one bitmap. As demonstrated in the first implementation, it is possible to construct frames in real time as opposed to using pre-constructed frames.
- After the animation data has been successfully loaded and decompressed, the animation can be played. The animation is played by first rendering the uncompressed frame image data for the next frame to an offscreen video memory buffer. The animation system then creates a window region from the buffer that defines all areas of the image that are non-transparent. The algorithm for creating the region is as follows:
ImageRegion = empty for each scan line in the image for each run of non-transparent pixels in the scan line create a rectangular region of height one combine the region with ImageRegion end loop - It is important to note that the above method also works for images that contain either “holes” or more than one disjoint region. A “hole” is a transparent region completely surrounded by a non-transparent region. A disjoint region is any non-transparent region completely surrounded by either transparent pixels or the boundaries of the image. “Holes” can contain any number of disjoint regions within themselves. The image region is defined to be the list of non-transparent regions. The image region is analogous to the “bounding region” described in the first implementation and the terms can be used interchangeably. In both cases, the region defines the location of non-rectangular, non-transparent image portions whether or not they comprise a contiguous group of pixels or disjoint groups of contiguous pixels.
- Once the image region is generated, the operating system is called to assign the region to the window. The operating system is responsible for clipping all input and output to the region associated with a window. After the region has been set, the image data can be copied from the offscreen memory buffer to the display device, using the operating system's bit block transfer, where it will be clipped to the bounding region assigned to the window. The Windows Operating System, for example, has an application programming interfaces (APIs) that support bit block transfers to offscreen buffers. Input and output are clipped to the list of (possibly) disjoint regions that make up the image region.
- After the frame image is rendered to the display device, an operating system timer is set to go off in the amount of time specified by the frame's duration. When the timer goes off, the animation system must determine the next frame to render. If the frame contains no branching logic, the system determines if it is the last frame in the animation and notifies the calling module of the completion (if the module registered itself to receive event notifications). If it is not the last frame, the next frame is either the next frame in sequential order, or the frame specified in the branching logic for the current frame.
- Branching logic is defined by specifying a frame number to branch to and a percentage of time that the branch should be taken. Multiple branches can be defined as long as the total percentage does not exceed 100%. The first branch is given a branch probability between 1 and it's percentage. Subsequent branches are given a probability between the maximum probability of the previous branch plus one to that value plus their percentage. To determine which branch to take, the animation system generates a random number between 1 and 100 and starts searching sequentially through the frame branches until it finds a branch whose maximum probability is less than or equal to the random number. If no branch can be found, the next sequential frame is selected.
- Once the next frame number is known, the system can repeat the process of rendering, region generation, and displaying of the frame image data. The repetition of this process is an animation.
- The generation of the region data for an animation frame in real-time is “expensive” in terms of CPU cycles. Thus a system of region caching has been implemented. It would be beneficial if the region data could be processed at character development time and saved along with the character animation data. This is possible but has serious limitations. If the region data is pre-processed, the character can not be scaled at run-time. The character data file also has to store all of the region data for every frame in every animation. The data can be quite large. This is not a problem when the entire character data file resides on the local machine running the animation system. However, the animation supports incremental downloading of animation data over low bandwidth communication lines such as the Internet. Downloading the region data for a character would be extremely slow. Thus a hybrid approach to region generation is used in this alternative implementation. The approach minimizes the download time associated with a character data file and minimizes the CPU cycles needed to generate regions in real-time.
- When a region for an animation frame needs to be rendered, the system will first look in a local storage cache of regions for a match. In contrast to the fixed sized MRU cache in the first implementation, this cache is located in secondary storage, i.e. the hard disk. If the region is found it can be loaded from disk very fast and assigned to window as described above. If the region is not found, it is generated in real-time and used as described above. However, after the region is used it is saved to the region cache on disk. The next time the region is required it can simply be read from the cache instead of being generated in real-time. Thus, the system gets the benefit of the pre-computed region without it having to have been downloaded over a possibly low bandwidth communications link. This gives the system the appearance of improved performance over time, i.e. the more frames that are displayed (which results in region generation and thus caching), the better the performance.
- The system can also pre-generate regions on a low priority background thread when the animation system is idle. When the character is loaded, the region generation thread is started in a suspended mode. Whenever the system is idle, it resumes the thread (in low priority) which starts generating regions for any animation frame that does not already have an entry in the cache. The thread runs at a very low priority so that it does not unnecessarily steal CPU cycles from other applications currently running. The thread is suspended when the animation system becomes active. Over time, every animation frame in the character data file will have a pre-computed region in the cache. Once this is accomplished the region generation thread can be terminated.
- On low-end systems that are simply not capable of ever generating regions in real-time, the computation of regions must be done before the system can be used. This can be done at character installation time when the user commonly expects a delay.
- Regions are directly linked to frame images at a given scale. The default scale of an animation frame is 100%, i.e. the frame should be displayed at its actual size. The animation system supports scaling of animations. This has the advantage that animations can be played at a size that is relative to the resolution of the display being used. This is necessary to overcome the problem that an animation created at a certain size looks bigger or smaller depending on both the resolution and physical size of the display device.
- Caching region does improve performance by reducing the need to re-compute region data. However, if the user or a client application wishes to scale an animation (enlarge or reduce its screen size), cached region data cannot be used because it is the wrong size. Therefore, when the scale of an animation changes, all pre-computed regions are deemed unusable and must be recomputed. Thus, the entire region cache must be flushed and regenerated. The region generation thread must be restarted or reset (if it is still running). This process is quite expensive but is acceptable because scaling is something that users will typically do infrequently.
- The animation system supports the incremental downloading of animations from a remote site. This is extremely beneficial for running the system over low bandwidth communication links. When a character is loaded from a remote site, only the character data stream is initially downloaded. The character data stream contains all of the data necessary to initialize the character. If a character data stream already exists on the local machine, the downloaded data is compared to the local data to determine if any animations currently stored locally have been superseded by a newer version on the remote site. If so, those animations are marked so that if a request for the animation is made the system knows that it must retrieve the newer version from the remote site. No animation data is downloaded. The character data stream is typically very small so the system can be initialized quite quickly. When a request for an animation is made, the system looks in the character data file on the local storage device. If the animation is found, it is loaded and played as described above. If the animation is not found it is downloaded from the remote site. Once the download is complete, the animation can be played as described above.
- It is desirable for calling modules (e.g., clients) to have control over when animations get downloaded. For instance, the calling module may want to download several animations that are played in sequence. If none of the animations reside locally, the system would download the first animation, play the animation, download the next animation, play it, etc. This is obviously not the desired effect. Thus, the animation system allows callers to download sets of animation. When a calling module requests an animation to be downloaded, the system first checks to see whether or not the animations reside locally. If it does, the system simply returns. If it does not the system begins the process of downloading the animations from the remote site. It can do this in a asynchronous fashion. The system also supports a notification API so that calling modules can download animations asynchronously and then be notified when they have been downloaded. Thus in the example above the calling module could do the following:
- Request=Get “
Animation 1”, Get “Animation 2”, Get “Animation 3” - On Request Complete
- Play “
Animation 1” - Play “
Animation 2” - Play “
Animation 3” - This results in a request for the three animations to be downloaded at the same time. The “Request Complete” event indicates that all of the animations reside locally can be played one after another without any delays. Animations do not have to be explicitly downloaded. If an animation is requested that is not stored locally, the system adds an implicit download call. The above scheme also works for audio data files that may be associated with an animation.
- Asynchronous download calls are always temporarily interrupted by synchronous calls. Thus, if the calling module asynchronously downloads an animation and a synchronous animation request is generated as a result of end user interaction, the synchronous requests gets priority. This follows the notion that the end user really is in control of setting the priority for animation downloads.
- As demonstrated by the alternative implementations described here, there are a number of different ways to implement the animation system, and therefore, it is not limited to these specific implementations. The cache for region data in the first implementation is a better design in cases where the same animations are used repeatedly in a short period of time because the MRU cache is more fully utilized, and it is quicker to read region data from main memory rather than retrieve it from secondary storage. However, it is often more likely that clients will make requests for different animations, rather than make repeated requests to play a small number of animations over and over. In these cases, the second implementation has better performance because all region data is cached in secondary storage as it is computed, rather than being limited to a fixed size MRU cache. Since region data is computed in real time along with an animation request and is also pre-computed before a request using a background thread, the second implementation will approach a cache hit rate of 100% over time. Depending on the desired performance and the nature of the animation requests, an animation system can be implemented using different combinations of the features described above to optimize performance.
- It is important to point out that there are other possible implementations of an animation system. For example, one can abstract the general method described in the previous sections with a client/server architecture. In this abstract form, the processes used to draw animations on the screen are divided into two separate classes of operation. The file I/O, the cache, and all other data used for generating the character animations are accessed through an OLE COM server called an “animation data provider.” The regionizer and the sequencer reside in a client. (This client can, in turn, provide services to other programs on the computer.) This abstract representation allows the animation system to use bitmaps that are represented in arbitrary formats on secondary storage. It also allows the animation system to provide smooth transitions from one posture to another for arbitrary animated characters. This frees the system from any fixed character file format, as well as reducing the dependence of the animation system on the Windows operating system.
- In one implementation of this client/server architecture, the animation system calls into the animation data provider through certain COM interfaces. Significantly, this implementation of the client/server architecture does not depend on any particular file format. It only depends upon the animation data provider's ability to construct bitmap representations of the current frame of the animation of the character, and to pass those on to the server at a relatively high speed. These COM interfaces allow the animation system to obtain information about the character in general, as well as information about the specific poses of the character. Thus, they provide access to all of the character's properties, including its name, its size, the number of bit planes in each animation bitmap, as well as to the animation bitmaps themselves. In addition, these COM interfaces allow the animation system to pass provider-defined state information to different animation data providers. This state information can be encoded in a form that only those data providers understand, providing a degree of protection for the content of the character. Finally, these COM interfaces are optimized to reduce the costs of accessing this data. This optimization is necessary in order to handle the case of an application client with a dedicated animation data provider. It has two parts. First, animation data providers can support standard OLE COM interfaces through which their persistent state can be captured so that each instance of an animation data provider can be reconstituted inside the server process. In addition, the COM interfaces used specifically to provide animation data are optimized to store and pass that data in a format particularly well-suited to transfer across process boundaries.
- Animation Server COM Object Implementation
- The animation services described above are implemented as a Component Object Model (COM) based OLE Automation Servers. For a detailed discussion of OLE see Inside OLE, Second Edition by Kraig Brockschmidt, Microsoft Press, Redmond, Washington 1995. The COM server implements a set of animation services that can be used by an unlimited number of clients, which are typically application programs. These clients can connect to the server using either a C/C++ COM Application Programming Interface (API) or via a Microsoft ActiveX Control interface. The ActiveX control allows access to all of the functionality of the COM server while providing an interface that is easy to use and abstracts the COM server's interface to a higher level.
- COM Object Overview
- In object oriented programming terminology, an “object” is an instance of a programmer-defined type referred to as a class, which exhibits the characteristics of data encapsulation, polymorphism and inheritance. A class is the definition of a data structure and the functions that manipulate that structure (member functions).
- Data encapsulation refers to the combining of data (also referred to as properties of an object) with methods that operate on the data (also referred to as member functions of an object) into a unitary software component (i.e., the object), such that the object hides its internal composition, structure and operation and exposes its functionality to client programs that utilize the object only through one or more interfaces. Programs that wish to use an object do not access the object's data directly, but must instead call functions on the object's interfaces to operate on the data. An interface is explained further below, but in general, is a group of related functions that a program can invoke to access an object's data.
- Polymorphism refers to the ability to view (i.e., interact with) two similar objects through a common interface, thereby eliminating the need to differentiate between two objects. Inheritance refers to the derivation of different classes of objects from a base class, where the derived classes inherit the properties and characteristics of the base class (which for purposes of OLE are the interfaces of the base class).
- OLE's COM specification defines binary standards for objects and their interfaces which facilitate the integration of software components. FIG. 8 is a diagram illustrating an example of a
COM server 300 and its relationship with an instance ofobject data 302. According to the COM specification, an instance of an object is represented in the computer system 20 (FIG. 1) by aninstance data structure 304 and a virtual function table 306. Theinstance data structure 304 contains apointer 308 to the virtual function table 306 and data 302 (also referred to as data members, or properties of the object). A pointer is a data value that holds the address of an item in memory. The virtual function table 306 contains entries 310-314 for member functions 316-320 implemented in the server. Each of the entries 310-314 contains a reference to the code 316-320 that implements the corresponding member function. - An interface to an object is a group of semantically related functions that are publicly accessible to software that wishes to use the object (e.g., a client program). The interface is implemented in the computer memory as a block of the memory containing an array of function pointers, illustrated as the function table306 in FIG. 8. The interface's definition are the names for each function in the virtual function table. An object may support more than one interface. If an object has more than one interface, the object has a function table and corresponding set of related functions for each interface.
- Client programs interact with the object by obtaining a pointer (referred to as an interface pointer)322 to the
pointer 308 of the virtual function table 306. OLE includes a type definition of an interface pointer which allows client programs to call member functions on the interface by name through the interface pointer and provides type checking on the function's arguments, as expressed in the following code (in the C++ programming language): - pInterface->MemberFunction( . . . )
- By convention, the interfaces of an object are illustrated graphically as a plug-in jack. Also, Interfaces conventionally are given names beginning with a capital “I.” Objects can include multiple interfaces which are implemented with one or more virtual function tables. The member function of an interface is denoted as “IinterfaceName::FunctionName.”
- FIG. 9 is a conceptual diagram illustrating the relationship between a
COM object 340 and auser 342 of the object (such as a client program). The user of the object has apointer 344 to the one of the object's interfaces, which is represented by a plug-injack 346. The object includescode 348 implementing the member functions in the object's interface, and it also includes the encapsulateddata 350, accessible via the object's interface. An OLE server, such as the animation server, can include a number of interfaces which allow clients of the server to access an instance of an object, such as an interactive character animation encapsulated within an object. - The object conforming to the COM specification exhibits data encapsulation by exposing its interfaces to client programs. The client programs interact with the object by calling the member functions348 on a particular interface of the object, but do not directly manipulate the object's
data 350. A COM object also exhibits polymorphism and inheritance in that it can provide interfaces in common with a base class and other similar objects, so that client programs can interact with each of the objects in the same manner by calling member functions of the interface that the objects have in common. - OLE Server Overview
- To describe an OLE server, we turn again to the example in FIG. 8. The virtual function table306 and member functions 316-320 of the object are provided by a
server program 300 which is stored in the computer system 20 (FIG. 1) as an executable program file (with a “.exe” file name extension) or as a dynamic link library file (with a “.dll” file name extension). Dynamic link library files are loaded, dynamically linked, and executed by the Windows 95 operating system in a same process with a client application program. Executable program files are loaded by the operating system as a separately executing process. In the OLE specification, theserver application 300 includes code for the virtual function table 306 (FIG. 8) and member functions 316-320 (FIG. 8) of the classes that it supports, and also includes a class factory 330 that generates the instance data structure 304 (FIG. 8) for an object of the class. - A server program can be written by a programmer to support a particular class of object that contains any desired data. The animation server, for example, provides objects representing an interactive animation. This allows a client program (such as the clients shown in FIG. 3) to interact with the interactive animation through interfaces of the OLE object.
- For the client program to interact with an instance of a COM object provided by the
server 300, the server must first create the object (i.e., instantiate an object of a class supported by the server application) and the client must gain an interface pointer to the object (pointer 322, for example). In OLE, the client program realizes these events using services provided by OLE and a set of standard object interfaces defined by COM based on class and interface identifiers assigned to the object's class and interfaces. More specifically, the services are available to client programs as application programming interface (API) functions provided in the COM library, which is part of a component of the Windows7 operating system in a file named “OLE32.DLL.” In OLE, classes of objects are uniquely associated with class identifiers (“CLSIDs”). Class identifiers are 128-bit globally unique identifiers (“GUID”) that the programmer creates with an OLE service named “CoCreateGUID” and assigns to the respective classes. The interfaces of an object are associated with interface identifiers (“IIDs”). - In particular, the COM library provides an API function, “CoCreateInstance,” that the client program can call to request creation of an object to encapsulate a particular animation's data using a CLSID associated with the data. The CoCreateInstance API function creates an instance of the object and returns a pointer of the requested interface to the client program.
- Once the client program has obtained a first interface pointer to the object, the client obtains pointers to other desired interfaces of the object using the interface identifier associated with the desired interface. COM defines several standard interfaces generally supported by OLE objects including the IUnknown interface. This interface includes a member function named “QueryInterface.” The QueryInterface function can be called with an interface identifier as an argument, and returns a pointer to the interface associated with that interface identifier. By convention, the IUnknown interface's member functions are included as part of each interface on an object. Thus, any interface pointer that the client obtains to an interface of the object80 can be used to call the QueryInterface function.
- As noted above, the animation server is implemented as an “OLE Automation server.” The term “automation” in this context refers to how the OLE object exposes a set of commands or functions that another piece of code can invoke. OLE automation enables an application to control another application's objects programmatically. In other words, automation provides a way for a program to manipulate an application's objects from outside the application.
- In OLE automation, a software object exposes itself as a series of methods, properties and events. A property is an attribute, such as a color, the zip code section or the postal code section of an address, or another object. A method generally refers to a request to an object to perform a specific action. Finally, an event is a notification from an object that something has happened. An event is similar to a method call except that it occurs from the object to its client.
- Properties have data types. For example, the postal code section of an address can be a string or a long integer. Properties can also be parameterized, which is useful to construct an array of one type representing a collection of properties (e.g., the lines of an address). In this type of property, a parameter representing an index in the array is defined for the property. Methods can also take parameters and return results.
- OLE automation also allows for hierarchies of automation objects by allowing methods and properties to return pointers to other objects. For example a series of related attributes can be represented within an object, which represents each of the attributes as a property.
- In OLE, a software object's properties and methods can be exposed to outside applications through 1) a standard OLE interface called IDispatch, and 2) through interface methods and property access functions that applications can call directly. IDispatch provides outside access to an object's methods and properties through one of its methods called the Invoke method. For instance, a program can ask an OLE object to return a property or can call one of its methods by calling the Invoke method on the IDispatch interface of the object and identifying the property or method by its ID. The IDispatch interface includes other methods to enable a program to get an ID of a method or property, and to get data type information. An OLE object can expose methods that can be called directly, rather than through the Invoke method in the IDispatch interface. For example, an OLE object can expose a set of functions that is derived from IDispatch and includes method and property access functions that another program can call directly. This is sometimes called a ‘dual’ interface because other programs can invoke an object's methods through the Idispatch interface and directly through this second type of interface.
- An OLE control is a type of OLE object that uses OLE Automation to expose properties and methods and to provide support for events. An OLE control object is typically designed to be incorporated into a host application called a container. In the context of OLE controls, an event is a notification from the control to its container that something has happened. In OLE controls, events are typically implemented as standard OLE automation methods, except that the automation interface for these methods is implemented in the container, not the control. When a control wants to fire an event, it calls the container method associated with the event. For instance, the control can call the proper container method to fire the event through the IDispatch::Invoke method of the container.
- An OLE object can tell another object that it is the consumer of the other object's interface through a mechanism known as a connection point. A connection point is an interface exposed by an object that is used to hook up to an implementation of an interface with which the object wants to communicate. In the case of control events, a control describes the event interface in terms of an OLE automation interface in its type library, marking the interface as “source.” This means that the control does not implement the interface. The control then provides a connection point through which the container can connect its implementation. A connection point can be defined as an implementation of the IConnectionPoint interface. The container gets the connection point through another interface called IConnectionPointContainer, which allows an external object to iterate list of connection points maintained by a control.
- The Animation Server
- The animation server shown in FIG. 3 is implemented as an OLE Server. FIG. 10 illustrates the hierarchy of the objects supported in the animation server. The top level object is the
agent object 360, which represents an interactive, animated user interface character called an agent. An example of this type of character is the genie in FIG. 2. - The other objects include a
commands object 362, character objects 364, auser object 366, aninput object 368, anoutput object 370 and aballoon object 372. The commands object can haveseveral command objects 374, which represent individual input commands that a client has specified for an agent. - Below, we describe the methods, properties and events that make up the interfaces to the objects supported in the animation server. Clients can include code that directly invokes the objects implemented in the animation server using ActiveX (OLE) interfaces. Alternatively, a client can access the methods, properties and events of the objects implemented in the animation server through an OLE control representing an animated character. For example in the Visual Basic Programming Environment from Microsoft, software developers can insert an OLE control representing an animated character into a Visual Basic form. The Visual Basic programming environment gives the developer high level access to the methods, properties and events of the animation server using conventional Visual Basic syntax. A description of examples of the methods properties and events that OLE controls expose follows below.
- The OLE control acts as a high level programming interface to the animation server. When a piece of code, such as a Visual Basic application program, invokes a method or property on the OLE control, the OLE control routes the method or property request to the corresponding method or property in the animation server. The OLE control, thus, acts as a thin software layer that enables programmatic access to the methods and properties of the software objects in the animation server. The Visual Basic programming environment also provides support for receiving event notification from the animation server. When the developer inserts a control representing a character into a Visual Basic form and creates a Visual Basic application, the Visual Basic programming environment adds the necessary support for receiving event notification to the application. This event notification mechanism is similar to the event notification mechanism used to communicate events from an OLE control to a container of an OLE control.
- In a typical implementation of a Visual Basic application that includes an animated character control, the operating system dynamically loads the character control in the process space of the application. The Visual Basic application can access the methods and properties of the control, which in turn, accesses the corresponding methods and properties in the animation server running in a separate process.
- The OLE control based design also enables developers to create script code in Visual Basic Script that accesses the methods, properties and events of the animation server through the OLE control interface. One important use of this technology is adding an animated character to an HTML document and controlling the character through script code in the document. In this particular use of the invention, the HTML document is parsed and rendered by an application program, such as an Internet browser application. In one possible implementation, the browser loads the character control in its process space when it encounters an object identifier in the HTML page corresponding to the character control. When it encounters the script code in the HTML page, the browser uses an interpreter, loaded in its process space, to translate the script. To execute the script and allow it to access the animation server, the browser control communicates requests to access methods and properties to the interface of the in-process control, which in turn, accesses the corresponding methods and properties in the out of process animation server.
- It is important to note that these uses of the animated character control are only examples. The invention does not necessarily require that the animation server be accessed through an OLE automation interface. There are alternative ways to access an out of process animation server, and the use of an OLE control is just one possible method of programmatically accessing the animation server.
- We now turn to specific examples of the methods, properties and events of the objects implemented in the animation server. Below we describe methods, properties and events of the server's ActiveX control interface in more detail.
- The Agent Object
- Clients of the animation server access its animation services using the methods, properties and events of the agent object's interface. The methods of the agent object include a number of functions to control the playback of an animation. Example methods include: Play, GestureAt, MoveTo, Stop, and Speak.
- Play—A client invokes this method to ask the server to play a specified animation sequence. The client specifies the animation sequence by passing a string that specifies the name of the animation sequence.
- To display the requested animation, the server uses the animation technique described above in detail.
- GestureAt—Clients use this method to cause the animation to gesture at a specified location. When invoking this method, the client provides two integer values representing the screen coordinates (x,y) in pixels where the character should gesture at. The character author assigns animations corresponding to different coordinates to this method, and at runtime, the server determines which of these animations to play based on the current location of the character and the coordinates specified by the client.
- MoveTo—This method moves the animation to a specified location in screen coordinates.
- Stop—Clients invoke this method to halt the current animation and play the next queued animation.
- Speak—Clients invoke this method to instruct the server to generate speech output for a specified text string.
- Clients specify a text string, which the speech output engine converts into digitized audio output.
- The animation server plays lip synched animation of the agent's mouth along with the speech output. Once the speech synthesis engine and agent mouth data is loaded on an end user's machine, the server can play the ASCII text requested by a client. When the server processes a client request to speak, it passes the appropriate text to the speech synthesis engine. The speech synthesis engine then processes the text and begins sending data to the physical audio device (e.g., sound card installed in the PC).
- The speech synthesis engine (item116 in FIG. 3) can send a notification to the mouth animation module (item 114 in FIG. 3) of the server whenever a specific phoneme is about to be spoken. When the mouth animation module receives this notification, it performs a mapping of the specified phoneme to appropriate data stored in the animation mouth data file. The mouth data consists of an x,y coordinate, a width and height, and a compressed bitmap of a mouth that appropriately matches the phoneme to be spoken. The mouth bitmap can then be loaded from the data file into memory, decompressed, and drawn on top of the current frame that the server is currently displaying at the coordinates of the animation's mouth. This action is repeated for every phoneme that is synthesized by the speech synthesis engine. This gives the illusion that the character is actually speaking the synthesized audio.
- It is important to note that the mouth bitmaps that correspond to the various phonemes that are generated are completely bounded by the region of the current animation frame. No region processing is performed during or as a result of the drawing of the mouth. In order to maintain lip synch with the above technique, the process of preparing and drawing the appropriate mouth for a specific phoneme must be done extremely fast. Performing any additional CPU intensive processing will result in the lip synching falling behind.
- The server also embeds what are referred to as tags in every piece of text that is passed to the speech synthesis engine. These tags are inserted before every word in the text and tell the speech synthesis engine that the server wants to be notified whenever one of these tags is encountered. The server can then uses this data to display the word that is currently being spoken in a visual user interface. This technique can then be used effectively to close caption the text as it is being spoken. In this implementation, the server displays this text in a graphic representing a balloon.
- The client can use a special type of tag called a bookmark tag in Speak method statement to sync its operations with the output text. The bookmark tag is a tag supplied by the client along with the ASCII text that tells the server when to notify the client. For example, to display a window at a particular point in its spoken output, the programmer inserts a bookmark tag at the desired location in the output string. When the server encounters the bookmark tag in the output text, it generates a Bookmark event with the bookmark number you specified in the tag.
- Agent1.Speak “Generate a bookmark now\mrk=100.”
- While generating speech output, the Speak method automatically selects the animation of the agent based on the last animation played. The Speak method uses the last action played to determine which speaking animation to play. For example, if the client precedes the Speak command with a command to play an animation called GestureRight, the server will play GestureRight animation and then the GestureRight speaking animation. However, if the preceding animation ends at the rest pose, the server will play the RestPose speaking animation.
- Playing a speaking animation also automatically disables the listening mode while the associated animation is played.
- Agent Object Events
- In general, events are notifications from the animation server that something has happened for which a client should be notified. They, for the most part, are asynchronous, but in some cases, can be synchronous. In the context of event notification in this implementation, asynchronous event handling means that the piece of code that monitors the event spawns a separate thread to fire the event so that the code can continue processing after it fires the event. Synchronous event handling means that the piece of code that monitors the event does not spawn a separate thread to fire the event but instead, fires the event on the current thread of execution and waits until the event is processed before continuing. In the case of the animation server, the server is responsible for firing events to clients, whether they are application programs or a character control within an application program (such as a Visual Basic application) or a script (such as a Visual Basic Script embedded in an HTML document). In the latter case of a character control, the control acts as a gateway for communicating events.
- Most of the events generated in the OLE implementation of the animation server are asynchronous, meaning that they spawn a separate thread to fire an event. This is beneficial to performance because the animation server can continue executing without waiting for the client to finish processing an event. However, some events, like QueryServerShutdown, are synchronous because it is important for the server to wait for the client to finish processing the event before continuing.
- One form of event notification is a callback function where the client requesting notification of an event provides the name and location of a function to call when a predefined event occurs. For example in OLE, this callback can be implemented as an IDispatch interface of the client that the animation server can invoke when it detects an event, has occurred. For asynchronous events, the callback function is made on a separate thread of execution, while for synchronous events, the callback is made on the same thread.
- The agent object's events allow the client program to track the state of an agent. Examples of these types of events include: Input Activate, Input Deactivate, Command, Shutdown, Bookmark.
- Input Activate event—The server generates this event when a client becomes active for input from the server.
- Input Deactivate event—The server generates this event when a client has been deactivated for input from the server.
- The server uses the activate and deactivate events to arbitrate among requests from clients for input services. The active client is the client that receives mouse and speech input from the server.
- Bookmark event—The server generates this event when it encounters a bookmark tag in a text string as it converts the text string into speech output. The client can insert this tag in the text string provided with a Speak method. To distinguish between bookmark tags, the client specifies a tag ID for the bookmark when it passes the text to the server.
- Command event—This event occurs then the user chooses an input command of an agent (e.g., clicks on the agent's command window). In one implementation of the agent, right-clicking the mouse button while the cursor is positioned over the character displays a pop-up menu, selecting Open Commands Window from this menu displays the agent's command window. This command window is one way to implement a visual command interface for an agent object. It displays one or more visual input commands by displaying the text caption provided by the client. The user can select one of these input commands by positioning the cursor over the caption and clicking on the mouse button. We sometimes refer to this form of visual input as cursor device input because the user can enter an input command using a cursor device such as a mouse or trackball.
- The command event tells the client which input command the user has provided by specifying a command object. The command object provides access to a number of properties of the command object as set forth in the table below.
Value Description User Input Identifies the command object returned by the server. The following properties can be accessed from the common object. Name A string value identifying the name (ID) of the command. Confidence a long integer value indicating the confidence scoring for the command Voice A string value identifying the voice text for the command Alt 1 Name A string value identifying the name of the next (second) best command. Alt 1 A long integer value indicating the confidence scoring Confidence for the best command Alt 1 Voice A string value identifying the voice text for the next (second) best command match Alt 2 Name A string value identifying the name of third best command match. Alt 2 A long integer identifying the confidence scoring Confidence for the third match. Alt 2 VoiceA string value identifying the voice text for the third best command. Count an integer value indicating the number of alternatives returned. - Resume event—This event occurs when the animation resumes after being suspended. The end user can resume the animation by clicking on a suspend caption in the pop-up window associated with the agent.
- Shutdown event—This occurs when the server shuts down.
- StopListening—This event occurs when the server is no longer in the listening mode. This means that the character will not respond to speech commands.
- The Character Object
- The character object provides access to the properties of a character. These are not the same as the properties of the control. The user can change the properties of a character, but the values of these properties are read-only to client applications to avoid arbitrary changes to the user-specified settings. The properties of a character include:
- Height—This property is an integer representing the height of a character in pixels.
- Width—This is an integer representing the width of the character in pixels.
- Left—This property is an integer that specifies the left edge of the current character frame. The Left property is expressed in pixels, relative to screen origin (upper left).
- Top—This property is an integer that specifies the top edge of the current character frame. The Top property is expressed in pixels, relative to screen origin (upper left).
- Even though the character appears in an irregularly shaped region window, the Height, Width, Left and Top properties of the character are based on the external dimensions of the rectangular animation frame used when it was created. Clients use the MoveTo method of the agent to change the character's position.
- The character object includes the following properties relating to speech input and output: Listening, Pitch, Speed, and Volume.
- Listening—This is a boolean value that indicates whether the agent is in listening mode.
- Pitch, Speed, and Volume—These are read only integer values representing the pitch, speed, and volume of the speech output. In this implementation, the client is not allowed to alter these values directly. The client can, however, alter pitch, speed, and volume by embedding speech tags in the text string provided with a Speak method request. For example, the client can use a speed tag to alter the pitch and speed of speech output, and can use a volume tag to change the volume for a portion of the speech output.
- The Input and Output Objects
- The input and output object provide read only access to an agent's input properties and output properties.
- The Commands Object
- The commands object enables clients to specify a collection of commands that an agent object will respond to when a client becomes active. The server maintains a list of commands that are currently available to the user. This list includes commands that the server defines for general interaction, such as Stop Listening and Go Away; the list of available (but inactive) clients; and the commands defined by the current active client. The first two sets of commands are global commands; that is, they are available at any time, regardless of which client is active. Client-defined commands are available only when that client is active.
- Each client application defines a collection of commands called the Commands object. To add a command to the Commands object, the client uses the Add or Insert methods of the commands object. For each command in the collection, the client can specify whether the user accesses the command through the Commands window, the application's (including Web page's) own interface controls, or both. For example, if the programmer wants a command to appear on the Commands window, she sets the command's Caption and Visible properties.
- The client can also set the Voice property for a command, which enables its selection through speech recognition.
- The client can add separator lines to your Commands object to group sets of commands in the Commands window. The client can also remove commands and separators.
- Here's an example using VBScript, where Agent1 is the name (ID) for the agent control:
- Agent1.Commands.Add “GetTime”, “Current Time”, “what's the current time”
- Agent1.Commands.Add “GetDate”, “Current Date”, “what's the current date”
- Agent1.Commands.Add “GetName”, “Current Name”, “what's your name”
- In this example, the first line of code first disables the commands by setting the Enabled property to false. The following lines invoke the Add method to add commands to the commands window of the agent.
- The server supports the following methods for the Commands object: Add, Insert, Remove, and RemoveAll.
- The Add method adds a command to the Commands object. The client can also specify the caption, voice text, visual state, and enabled state for the command.
- The Insert method inserts a command in the Commands object. The client specifies the command ID of the command to be inserted, a name of the command object to which the new command is related to, and value indicating whether the command should be inserted before or after the related command. The client can optionally specify a text string that will appear in the Commands window for the inserted command when the client is active.
- For speech input, the client specifies the string value corresponding to the words or phrase to be used by the speech engine to recognize this command.
- The Remove method removes a client command object (command or separator) from the Commands object. The client specifies a string value corresponding to the ID for the command or separator.
- The RemoveAll method removes all client command objects (commands and separators) from the Commands object. Command objects that are removed from the collection do not display when the agent control is active.
- The server supports the following properties for the Commands object: Caption, Count, Visible, and Voice.
- The Caption property is a text string describing the text displayed for the Commands object in the Commands window.
- The Count property returns an integer (read-only property) that specifies the count of commands in the Commands object.
- The Visible property is a boolean value that determines whether the option of the Commands object is visible.
- The Voice property is a text string corresponding to the words or phrase to be used by the speech engine for recognizing this command.
- The string expression can include square bracket characters ([]) to indicate optional words and lists strings enclosed in parenthesis and separated by vertical bar characters (|) to indicate alternative strings. Alternates must be enclosed in parentheses. For example, “(hello [there]|hi)” tells the speech engine to accept “hello.” “hello there,” or “hi” for the command.
- The client can also use an ellipsis ( . . . ) to support word spotting, that is, telling the speech engine to ignore words spoken in this position in the phrase, sometimes called garbage words. When ellipses are used, the speech engine recognizes only specific words in the string regardless of adjacent words or phrases. For example, if you set this property to “. . . check mail . . . ” the speech recognition engine will match phrases like “Please check mail,” or “Check mail, please” to this command. Ellipses can be used anywhere within a string.
- The Command Object
- A command is an item in a Commands collection. The server provides access to the commands specified by a client when the client is active.
- For each command that the client specifies, it can define whether it will be accessible in the Commands window by using the Caption, Visible, and Enabled properties.
- In addition, the client can set the words or phrases that it wishes the server to use to match speech input for a command.
- When the server receives input for a command object, it sends a Command event, and passes back the name of the command as an attribute of the UserInput Object. The client can then use conditional statements to match and process the command.
- Properties of the Command Object
- Each command defined in a Commands object also has properties that affect the how the server presents the command. For example, if you supply content for the Voice property of a command, the supplied text is automatically compiled as part of the active vocabulary of the speech recognition engine, allowing speech recognition when the client activates its Commands object. Individual commands in a Commands collection also have a Visible property. When this property is set to True, the command will appear on the agent's pop-up Commands window. A client does not have to include any or all of your commands in the agent's Commands window, if it already provides its own interface for those commands. For example, a form may already display controls that enable user interaction. In this case, the client would not need to include access on the agent's Commands window, yet it can still provide speech access to those controls (by defining command objects for those fields).
- The following Command properties are supported: Caption, Confidence, Enabled, Visible, and Voice.
- The Caption property determines the text displayed for the command in the Commands window. The property is a string expression displayed as the caption for the command.
- The Confidence property is the confidence threshold that the speech engine uses to match the command. The property is a numeric expression that evaluates to an integer that identifies confidence value for the command.
- The Enabled property indicates whether the command is currently enabled. The property is represented as a boolean expression specifying whether the object is visible or hidden. If True, the command is enabled. If False, the command is disabled. If the Enabled property of the command's parent Commands object is set to False, the Enabled property of the command will also be automatically disabled. However, the Enabled property setting of the command is restored when the Enabled property of the parent Commands object is set to True.
- The Visible property indicates whether the caption of the command is visible. The Voice property is string value corresponding to the words or phrase to be used by the speech engine for recognizing this command. A string expression can include square bracket characters ([]) to indicate optional words and lists of strings enclosed in parenthesis and separated by vertical bar characters (|) to indicate alternative strings. Alternates must be enclosed in parentheses. For example, “(hello [there]|hi)” tells the speech engine to accept “hello,” “hello there,” or “hi” for the command.
- The Balloon Object
- The word balloon object displays the “spoken” text of the agent. The server exposes the setting of the Enabled property as read-only. When Enabled property is set, the word balloon is automatically displayed and removed for “spoken” output. This property value is set by the user in one of the windows used to display the agent's properties. The client can define text in the balloon to appear differently than the spoken output by using the Map tag. For more information about this tag, see Speech Output Tags.
- Speech Output Tags
- The Agent services support modifying the speech output special tags inserted in the speech text string. This allows the client to add personality to the output expression of the character. Speech output tags use the following rules of syntax in this implementation:
- 1. All tags begin and end with a backslash character (\).
- 2. The backslash character is not allowed within a tag. To include a backslash character in tagged text, but outside of a tag, use a double backslash (\\).
- 3. Tags are case-insensitive. For example, pit is the same as \PIT\.
- 4. Tags are white-space sensitive. For example, \Rst\ is not the same as \Rst\.
- Unless otherwise specified, the speech output retains the characteristic set by the tag within the text specified in a single Speak method, unless modified by another tag. Speech output is automatically reset to the user-defined parameters after a Speak method is completed.
- The following tags are supported:
- Chr, Ctx, Emp, Map, Mrk, Pau, Pit, Rst, Spd, Vol
- Chr
- Description
- Sets the character of the voice.
- Syntax
- \Chr=string\
Part Description string a string specifying the character of the voice. If “Normal” (the default), the character speaks in a normal tone of voice. If “Monotone,” the character speaks in a monotone voice. If “Whisper” the character whispers. - Ctx
- Description
- Sets the context of the output text.
- Syntax
- \Ctx=string\
Part Description string A string specifying the context of the text that follows, which determines how symbols or abbreviations are spoken. If “Address,” addresses and/or phone numbers are used. If “Email,” electronic mail is used. If “Unknown,” (default) the Context is unknown. - Emp
- Description
- Emphasizes the next word spoken. This tag must immediately adjoin the word.
- Syntax
- \Emp\
- Map
- Description
- Maps spoken text to text displayed in the word balloon.
- Syntax
- \Map=“SpokenText”=“BalloonText”\
Part Description SpokenText A string specifying the text for spoken output. BalloonText A string specifying the text to appear in the word balloon. - Remarks
- This tag enables the programmer to use spoken text that is different than the text displayed in the word balloon
- Mrk
- Description
- Indicates a bookmark in the text. (See also the Bookmark event.) Number must be greater than zero
- Syntax
- \Mrk=number\
Part Description number The number of the bookmark. - Remarks
- When the server processes a bookmark, it generates a bookmark event.
- Pau
- Description
- Pauses speech for the specified number of milliseconds.
- Syntax
- \Pau=number\
Part Description number The number of milliseconds to pause. - Remarks
- The speech engine supplied with the Animation Server supports values from 10 (0.01 sec) to 2550 (2.55 sec).
- Pit
- Description
- Sets the baseline pitch of the output to the specified value in hertz.
- Syntax
- \Pit=number\
Part Description number The pitch in hertz. - Remarks
- The speech engine supplied with this implementation of the animation server supports values from 50 to 400.
- Rst
- Description
- Resets all tags to the default settings.
- Syntax
- \Rst\
- Spd
- Description
- Sets the baseline average talking speed of the speech output.
- Syntax
- \Spd=number\
Part Description number Baseline average talking speed, in words per minute. - Remarks
- The speech engine supplied with Microsoft Agent supports values from 50 to 250.
- Vol
- Description
- Sets the baseline speaking volume of the speech output.
- Syntax
- \Vol=number\
Part Description number Baseline speaking volume; 0 is silence and 65535 is maximum. - Having described an implementation of the animation server and its interface, we now describe how the server interacts with clients requesting animation services.
- The first step that a client performs is to attach to the server. This is performed using a standard OLE mechanism which starts the server if it is not already running. The server maintains a list of all connected clients and terminates when either the last client detaches or it is explicitly shut down by the end user. This functionality is consistent with the COM specification.
- Once the server is started, the client continues with the process of attaching by registering a notification interface with the server. The notification interface is used by the server whenever it needs to communicate either events or state changes with its connected clients. Notifications from the server to connected clients usually occur on a separate thread of execution in the server. This is necessary in order to prevent any single client from blocking the server while it is processing a notification.
- Once a connection to the server is established, clients can request services from the agent server. These services consist of region window animations, lip synched animation, synthesized digital audio output, and input command processing. The animation services allow clients to trigger animation sequences in the agent. To accomplish this, the client calls the Play methods on the agent object's interface.
- The server can also animate the agent object at any time but gives priority to the active client except in cases where it is deemed necessary to override the default behavior. The active state of a client can be set by either the end user (if the client allows it) or the client itself. Only one externally connected client is considered active at any time. The server also implements what are known as internal clients. These clients typically follow the same rules as external clients but can override the default behavior of the server if deemed necessary.
- Whenever a client becomes input active it is sent a notification from the server in the form of an input Activate event. This activation is analogous to a window gaining the input focus in the Windows Operating System. Upon activation, the client receives input from the server. The active client will also be sent a notification (i.e. an input Deactivate event) from the server when it is about to become inactive (analogous to KillFocus).
- Clients can explicitly make themselves input active however they should always be prepared to handle the case that another client has “stolen” the activation focus from them. This model works because it is ultimately the end user that is controlling which client has the chance to become active through either direct communication with the server or one of its connected clients.
- If there are no requests, the server enters what is referred to as its idle state. When the server is idle, it causes the agent to play one of its idle animations picked at random. Before playing an idle animation, the server will first try to play a transitional animation to smoothly move the agent from its current position to a constant position known as the rest pose. All idle animations begin at the rest pose. Transitioning the agent through a constant position reduces the amount of jerkiness associated with quickly changing the state of the agent. This gives the agent a more natural feel. The server's idle animations will always be interrupted by an incoming client request.
- If there are requests in the queue, the next request is popped off of the queue and the appropriate action is taken by the server. This process continues until the request queue is empty.
- Because of the asynchronous nature of the agent's playback mechanism, it is important to implement a method that allows clients to notify themselves when a particular event has been triggered in the server. This is necessary for synchronizing events in the server with events in the client.
- Consider the example where a client wants to play an animation that causes the agent to gesture at a particular location on the screen, display its own window, and then have the agent speak something to the user.
- The server implements two mechanisms for allowing clients to synchronize their own actions with the servers. The first allows clients to add specific notification requests to the server's request queue. The server will process these notification requests with the same rules that it processes animation or audio requests. When the server encounters a notification request in the request queue, it simply sends the notification to the client that posted the request. This type of notification is acceptable for many synchronizing functions.
- The other mechanism allows clients to embed notification requests in text that is to be synthesized into digital audio output. The bookmark tags, described above, are in implementation of this type of notification request. These notification requests offer a finer granularity than the previously described mechanism in that it allows clients to synchronize actions at the spoken word level.
- Visual and Speech Input Command Notification
- Above we described the methods and properties of the animation server that enable a client to specify input commands that an agent will respond to when the client is active. In the implementation of the server described above, these input commands include: 1) commands defined by the server and 2) commands defined by clients.
- The server monitors for these client-specific commands as well as global commands and sends a notification to the appropriate client when it detects the input command. When the end user selects a command, via either the visual command interface or through a spoken command, the server sends a notification to the appropriate client that a command was selected. In this implementation, the server provides a notification in the form of a command event of the agent object.
- The notification tells the client the name of the command that was selected along with other information from the speech recognition engine if the command was selected via a spoken command. One of the pieces of information that the server passes to the client though this interface is a confidence value for the command. This value represents how confident the speech recognition engine was that the command being passed to the client was actually spoken. Other information consists of possible alternatives to the spoken command and their confidences. Clients can use this information to determine whether the engine's confidence in the spoken command was sufficiently high enough for the client to actually proceed with the processing of the command, or if they should ask the user for verification of the command. It is more effective to allow clients to do this processing instead of the server because they have context information which may be useful in determining whether to accept a command or reject it.
- The client server architecture described above enables software developers to create clients that take advantage of the animation and speech services of the server. Clients can request services from the server using a C/C++ COM Application Programming Interface (API) or via an ActiveX control interface. Developers, therefore, can create client application programmers written in C or C++, or written in Visual Basic from Microsoft Corp. For example, C or C++ programs can access the server functionality through the server's COM API. Using the Visual Basic Programming system, programmers can drag and drop an agent object's ActiveX control into a Visual Basic form.
- The ActiveX control interface also enables developers to access the animation services in Web pages using scripting languages compatible with ActiveX controls like VBScript (Visual Basic Scripting Edition from Microsoft Corp.) or Java Script. The programmer can access the server from a web page by declaring the object on the page, providing a name for the object for easy reference.
- To access the services of the animation server from a Web page, the programmer uses the HTML Object tag to declare the control in the Head or Body section of the page.
- To use a method or property in VBScript (or Visual Basic®), the programmer uses the conventional syntax for methods, properties, and events. Examples of this syntax are set forth below:
- agent.object.Method argument
- agent.object.Property=value
- agent.object_Event (argument as datatype)
- Before describing how agent objects are created and accessed via Web scripts in more detail, we provide an overview of the browser software used to access web pages and process Web scripts.
- FIG. 11 is a diagram illustrating a
Web browsing environment 450 for accessing a Web page with an embedded agent object. In the Web browsing environment shown in FIG. 11, the computer 20 (also shown in FIG. 1) runs software, referred to herein as a “browser,” for browsing of electronic documents and other data from local sources (e.g., the secondary storage 42 of FIG. 1) and from aremote computer network 452. The browser can be integrated with the operating system software, or can be a separate application software. Theremote computer network 452 shown in FIG. 11 is the Internet. - The
computer 20 connects to theInternet 452 over atelephone line 454 with amodem 456. Other physical connections to the computer network can be used, such as an ISDN, T1 or high speed telephone line and modem, a television cable and modem, a satellite link, an optical fiber link, an Ethernet or other local area network technology wire and adapter card, radio or optical transmission devices, etc. Although we specifically refer to the Internet here, this browsing environment also applies to other public or private computer networks, such as a computer network of a commercial on-line service or an internal corporate local area network (LAN), an intranet, or similar computer network. - Web pages and other files compatible for browsing via the browser software can reside as files of a file system stored in the computer's secondary storage42 (FIG. 1), or reside as resources at a remote computer 458 (also referred to as a “site”) connected to the
computer network 452, such as a world-wide web site on the Internet. Theexample Web page 460 residing at thesite 458 conforms with HTML standards and also includes an object tag and scripting program. The web page may also refer toadditional information content 462, such as images, audio, video, executable programs, etc. (hereafter simply “Web content” 462), which also reside at theremote computer 458. Thedocument 460 andWeb content 462 are stored as files in a file system of theremote computer 458. Thedocument 460 incorporates theWeb content 462 using HTML tags that specify the location of files or other Internet resource containing the Web content on theInternet 452. - When used for browsing documents, the browser displays the document in a window the computer's user interface allocated to the browser by the operating system. FIG. 11 depicts the screen shot of FIG. 2 as an example of the image displayed on the computer's monitor. One of the
windows 64 acts as the user interface of the browser. - When the browser renders the Web page, it identifies the HTML Object tag of the agent object embedded in the web page. In response, it creates an instance of the agent object and displays it on the user interface of the computer.
- As explained in detail above, the agent's animation is not confined to the window of a host application, but rather, is displayed in region window having a bounding region that matches the bounding region of the animation. FIG. 11 shows how the genie character plays outside the window of the Internet browser's window.
- The format of the HTML object tag is as follows:
<OBJECT classid= codebase= data= height= width=> - The classid parameter of this tag (if present) specifies a class identifier of the control. As the web browser renders the web page, it uses the class identifier to create the control, such as by calling the CoCreateInstance API function to cause the control's server application to be loaded and the server application's class factory to instantiate the control. The codebase parameter (if present) specifies a URL of a file containing the control (such as on the Internet). If the control is not installed on the end user's computer, the web browser can retrieve this file using the URL from the Internet and then install the file on the computer before instantiating the control using its class identifier. The data tag (if present) specifies persistent data for the control as either a text string or via a URL of a file containing the control's persistent data.
- The specific format of an agent object is as follows:
<OBJECT classid=“clsid:855b244c-fc5b-11CF-91fe-00c04fd701a5” id=Agent > </OBJECT> - Before displaying the web page, the web browser parses the HTML object embedding tags along with the other HTML format data in the hypertext documents. On encountering the HTML object embedding tag for an agent object during the parsing, the web browser instantiates the agent object using the class identifiers specified in the tags. To accomplish this, the web browser invokes a standard OLE interface function that looks in a registry to determine which control the tag refers to and loads it in-process.
- If the control is not installed on the computer20 (FIG. 1), the web browser can download it and the server using the URLs specified as the codebase attribute of the tags (if any). As it renders the HTML code in the web page, the web browser displays the content of the hypertext page in its window.
- As the browser renders the Web page, it also encounters the script. For Visual Basic Script, the browser loads a Visual Basic Script runtime interpreter locally to translate the Visual Basic script on-the-fly and run the code. If the browser supports other scripting languages, it loads the appropriate interpreter based on the script language identified in the document. When the browser encounters script code, it loads an appropriate interpreter for the script language, and this interpreter then translates the code. The script code executes via calls from the interpreter in response to references to the character control interface, which in this specific implementation is the OLE control interface described in detail above. In the specific case of Visual Basic Script, for example, the browser loads an interpreter in the process space of the browser. To execute the script code, the browser uses the interpreter to translate the code and then accesses the OLE control interface in response to references to the control interface in the script code. As noted above, the browser loads the OLE control representing the character into the process space of the browser when it encounters an object identifier called the object tag. Thus, in this particular implementation, both the control and the interpreter are loaded in the process space of the browser. When the script code references the character control, the browser accesses the animation server, which runs in a separate process, through the control interface. The control acts a gateway, routing requests for access to the animation server's methods and properties for a particular character to the animation server.
- In order to describe the interactive behavior of the agent, the script in the Web page references the agent object and uses the control methods, properties and events to define the input commands and output behavior of the object. For example, the script can include conditional statements that describe the behavior of the agent when the client specified input commands are detected.
- Synchronization of Animations
- The animation system supports interaction between and among animations through the use of synchronization services. These synchronization services enable an application to control interaction among separate animations that are being played on the display. While these services for synchronizing animations can be used on a variety of types of animation, they are particularly well suited for interactive animations such as the user interface characters (e.g., agent objects) described above. The user interface characters are arbitrary shaped (e.g., non-rectangular), do not occupy the entire display screen, and superimposed on the display such that they are not confined to the rectangular window of a hosting application. The hosting application is an application that controls the animation, i.e., the application that has made the animation request to make the character move or speak.
- The synchronization services support at least the following functions:
- 1) synchronizing two or more animations on the display, and more specifically, synchronizing interactive animations such as the animated characters described above;
- 2) stopping an on-going animation in synch with another animation;
- 3) stopping an action of an on-going animation immediately; and
- 4) stopping an on-going animation in response to an event, including stopping an animation in response to detecting user input such as speech input or cursor device input.
- The synchronization services are implemented in the client-server animation system described above. It is not required that the synchronization services be implemented in a client-server model. However, the client-server model described above is advantageous in that it allows several applications to access its animation and input/output services at the same time. This includes applications written in a scripting language (e.g., text files processed at run-time) or executable files compiled from conventional languages such as C, C++, or Java. Using the synchronization services, a single application can synchronize the interaction between two or more distinct characters. Different applications can control a single character, and can also concurrently control distinct animations.
- Like the other animation services described above, the synchronization services of the animation server can be accessed by a variety of types of application programs, including, for example, applications written in C, C++, and Java, and rapid prototyping language such as Microsoft Visual Basic. Rapid prototyping languages, also referred to as “scripting languages,” typically provide high level textual commands that run other procedures. For example, Visual Basic provides high level text commands that are used to run other programs called Visual Basic Controls. Programs written in these languages, called scripts, are usually in the form of a text file, which can be edited with a simple text editor.
- The animation server provides access to the synchronization services through an Application Programming Interface (API) and high-level script commands. The API allows applications written in languages such as C, C++ and Java to invoke the synchronization services of the animation server. The high-level script commands enable text-based scripts to access the synchronization services via a script engine. The synchronization API may be implemented as part of the COM API of the animation server. The script commands access the animation server via an ActiveX control, called an agent control.
- Before describing an implementation of the animation services, it is helpful to review the distinction between asynchronous and synchronous animation services. In order to provide asynchronous animation, the animation server should: 1) handle an animation request expeditiously, and in particular, within a predictable and predetermined time to avoid perceptible delay on the screen; and 2) update the position or state of each animation independently, without reference to an explicit external or internal clock relative to which the events of all simultaneously displayed animations are synchronized.
- One way to implement asynchronous animation is to have the animation server spawn a separate thread from the code requesting the animation. By spawning a separate thread, the animation server enables the requesting code to continue executing without having to wait for the animation to complete. While it may be preferable to avoid scheduling the animation to run on the same thread as the requesting code, animations can be scheduled entirely within a single thread and still be considered asynchronous. This is particularly true for platforms that do not support multi-threading, such as in the case of the Windows 3.1 operating system. Animations can be scheduled within a single thread (or non-threaded process) with each animation limiting the time during which its animation services are in control of the flow of instructions in the thread.
- In the current implementation, the specific synchronization services are provided via three primitives: “Wait”, “Interrupt”, and “Stop.” These primitives are a special type of function call, which are accessible from a script or via the animation server API. The code that implements these functions is located in the animation server.
- As described above, the animation server manages requests for animation services such as play and speak by maintaining a queue for each animation. The animation server queues animation requests in a first-in, first-out order. The code that implements the synchronization services utilizes the queues to synchronize the actions of animations that share the display at the same time. Below, we describe how the synchronization services synchronize the actions of animations on the display.
- The behavior of each animation is defined in terms of actions. In the current implementation, the actions include playing a graphical animation (sequence of images depicting motion of a character), playing back audio output associated with a character such as the character's speech output or other sound effects, and lip-synched animation, which is a combination of speech output synchronized with mouth animation. Applications request actions by invoking the animation services of the animation server. For example, if an application invokes an animation service such as Play, GestureTo, or Speak, these animation requests correspond to actions of a character. These actions are “schedulable” in the sense that the animation server handles the scheduling of these actions for playback in response to animation requests from applications.
- Synchronizing Two Asynchronous Animations
- The synchronization services include a command called “wait” that enables an application to synchronize two asynchronous animations. In order to synchronize actions from different animations, an application identifies an action and the animation and invokes the wait function on that action. This causes the animation server to block playback of one animation until the specified action of the other animation is complete.
- To implement this function, the animation server uses a data structure called a “request object.” The request object is used to store an identification of the action of a particular character used to synchronize two different characters on the display.
- To illustrate the operation of the wait function, consider the example introduced in the background section, which includes two interactive characters, the Genie and Merlin, performing a vaudeville routine. In our examples that follow, we use the syntax of the script language of the current implementation. These examples could also be implemented using the methods in the animation server's API.
- In the example of Genie and Merlin, we would like to synchronize an action of Genie with an action of Merlin. Specifically, we would like both Genie and Merlin to dance and then halt Genie until Merlin completes his first dance routine. A script to generate the desired interaction would look like:
- Genie.Play “GenieDance”
- Set MerlinRequest=Merlin.Play (“MerlinDance”)
- Genie.Wait MerlinRequest
- Merlin. Play “MerlinDanceMore”
- Genie.Speak (“Hey, Merlin! Did you hear the one about the cat who ate the paper?”)
- In this example, it is assumed that “s GenieDance”, “MerlinDance” and “MerlinDanceMore” represent long animations. Note that in requesting an animation, the script identifies the character and the action in the form:
- Character.Action.
- The assignment of “GenieWait” to the value of Merlin. Play creates a “request object.” When such a request object is passed with the Wait command, the animation queue that schedules Genie's animations is blocked until the specified action is completed. Any schedulable action can generate a request object. In the example above, both executions of animations and utterances are used to generate request objects.
- Stopping an On-Going Animation In-Sync with Another Character
- The synchronization services include another command named “Interrupt” to stop an ongoing animation in sync with the action of another animation. In order to stop an on-going animation of one character upon an action of another character., an application invokes the Interrupt function on the character that will interrupt another character. In making this interrupt request, the application also specifies the action of the other character that will be interrupted.
- Like the Wait function, this function also uses the result object to identify the action used to synchronize the two characters. The request object is a parameter to the Interrupt command on character1 used to identify the action of character2 that will be interrupted.
- The form of the function call is:
- Character1.Interrupt RequestObject
- To illustrate the operation of the Interrupt function, let us continue with the previous example. Since “MerlinDanceMore” is a long animation, it is almost certainly not finished when Genie finishes asking his question. That means that Merlin's on-going dance must be stopped. Thus, the Interrupt function can be used to halt the animation named Merlin as follows (in an extension of the scenario discussed above):
- Genie.Play “GenieDance”
- Set MerlinRequest1=Merlin.Play (“MerlinDance”)
- Genie.Wait MerlinRequest1
- Set MerlinRequest2=Merlin.Play “MerlinDanceMore”
- Genie.Speak (“Hey, Merlin! Did you hear the one about the cat who ate the paper?”)
- Genie. Interrupt MerlinRequest2
- An interrupt call is similar to an animation request because it is placed on a character's queue and triggered when it reaches the top of the queue. It is queued up until all previously scheduled actions on the queue of the specified character (the interrupting character) are completed. At that point, though, it causes the action associated with the request object to be terminated, either by stopping an on-going action or by preventing a still-scheduled action from ever starting. When the animated character referred to as Genie finished asking the question (“Hey, Merlin . . . ”). that item is removed from the character's queue. The next item on that queue is then examined. It is an “Interrupt” call, which instructs the animation server to immediately halt the on-going animation denoted by MerlinRequest2. Thus, the Genie character will appear to speak, and the Merlin character will appear to stop dancing, as if in response to the question the Genie character just asked. In the example, the character named Merlin will have reached the point that it is playing the MerlinRequest2 animation because the Genie character initially waited (via a Wait request) for the animation corresponding to the MerlinRequest1 object to complete before it started speaking. Interrupt calls provide a means by which characters can behave in a specified fashion until such time as another character has completed actions that are scheduled before the interrupt.
- Stopping an On-Going Animation
- The synchronization services include another command named “Stop” that enables an application to stop an animation that is being played or is already scheduled to be played. More specifically, this function is called on a character to stop an action of that character. In contrast to the Interrupt function, the stop function is not triggered upon an action of a character. Rather, the stop function is immediate in the sense that it stops the specified action in response to the stop request without waiting for some other specified action to occur.
- The implementation of the stop function in the animation server stops a specified action of a character by deleting the specified action from the character's queue. To invoke the function, an application specifies the character and the action of that character to be stopped. Specifically, the application first creates a request object and then calls the stop function on a character, using the request object to specify the action to be stopped.
- The form of this call is:
- Character. Stop RequestObject
- An example will illustrate how to access this function:
- Set Interrupted Genie.Speak “Why did the chicken cross the road?”
- Genie.Stop Interrupted
- Genie.Speak “Oh, you've heard that one before?”
- It will appear that the telling of the joke will be stopped in mid-utterance, and Genie will interrupt himself, saying, “Oh, you've heard that one before?” In fact, the interruption happens so fast that the first statement never seems to happen at all. When the server receives the stop request for an action, it immediately stops the specified action.
- When a script calls “Stop” on a character, the interruption is immediate. Interrupt, by way of contrast, is queued behind other actions, so that the interruption will only happen after the actions scheduled ahead of it have already been removed from the queue. A side effect of this difference is that a character object can only invoke Stop on its own actions, and can only invoke Interrupt to interrupt the action of some other character.
- The animation server also provides a synchronization function called StopAll, which differs from Stop in that it stops all actions scheduled for a character.
- Synchronizing User Input with Animation
- As described above, the animation server has an event passing mechanism that can be used to notify an application when predefined events occur. These events are part of the animation server API and the control interface used for scripts. In the case of scripts, the animation server passes the events to the script engine, which is responsible for running the script.
- The animation can send events back to the application (or script engine) to describe its progress as the application is executed. The events permit the application to synchronize animations with user input. This also applies to a script executing in the script engine. For instance, in the VB script discussed above, the Click event could be used to enable the user to stop Genie by clicking the mouse button while positioning the cursor over Genie's animation on the screen:
- Dim Req As Object
- Dim Genie As Object
- Private Sub Agent_Click(ByVal CharacterID As String,
- ByVal Button As Integer,
- ByVal Shift As Integer,
- ByVal x As Integer,
- ByVal y As Integer)
- Genie.Stop Req
- Genie.Speak “Oh, I guess you have heard that one before.”
- End Sub
- Private Sub Form_Load()
- Agent.Characters.Load “Genie”
- Set Genie=Agent.Characters(“Genie”)
- Genie.Show
- Genie.Speak “Click me if you've heard this one before!”
- Set Req=Genie.Speak (“Why did the chicken cross the road?”)
- End Sub
- This example script uses a callback routine (Agent_Click) to stop the Genie's Speak action if the user clicks the mouse button on Genie in the display. The callback routine invokes the stop command and specifies the action to be stopped using the request object (Req). This request object is set to the action., Genie.Speak (“Why did the chicken cross the road?”. Thus, if the user clicks on the Genie after it says, “Stop me if you've heard this one before!, then the animation server will remove the specified action from Genie's queue.
- Accessing the Synchronization Services from Applications
- FIG. 12 is a block diagram illustrating how applications access services, including the animation and synchronization services of the animation system. An
animation server 500 implements the animation and synchronization services. Applications written in a prototyping language (scripts 502, 504) access the services via ascripting engine 506. These scripts are typically represented as text files, which are processed at run time by thescripting engine 506. Application programs written in conventional programming languages such as C, C++, and Java (e.g., APP. 1 and APP. 2 in FIG. 12) access the animation and synchronization services implemented in the server via the server's API. -
Scripts scripting engine 506. Thescripting engine 506 interprets the script commands, such as the animation and synchronization commands described above, and invokes the animation server to execute them. The type of scripting engine depends on the script language. Some examples of script engines include an instance of the Microsoft Visual Basic run-time environment, or a web browser like Microsoft Internet Explorer. - In the current implementation, the
script engine 506 accesses the animation server through an OLE control called theagent control 508. Theagent control 508 is a dynamic link library that can be loaded into the process space of programs that qualify as OLE containers. Thescript engine 506 is an OLE container and interacts with theOLE control 508 embedded in it via the standard OLE container-control interfaces. In turn, the agent control communicates with the animation server through the server's API. - In addition to accessing server functionality via a script engine, applications can also directly access the animation services via the server's API. FIG. 12 shows two additional applications accessing the server through its programming interface to illustrate that the server can process requests from several concurrently executing programs including the
script engine 506, as well asother applications - The
animation server 500 manages animation and synchronization requests using a queue (e.g., 520, 522, 524) for each character. The queue is used to queue all animation (Play, GestureTo), utterance (Speak), and interrupt (Interrupt) calls. These queues run asynchronously. In the current version for the Windows Operating System, the animation requests in each queue are carried out on separate threads of execution (530, 532, 524). The animation server includes a program module called therequest manager 540 that is responsible for managing the queues for each character. The request manager is part of animation server application, and it runs on a separate thread from the threads for each queue. - The Request Manager
- The request manager maintains a queue of pending requests for each character. When a client program (e.g., script or application program) makes an animation request to the animation server, the request manager appends a new entry to the tail of the queue of the character subject to the request. At any given time, the entry at the head of the queue, if any, is either the action (e.g., Play or Speak request) that is currently being executed or is a placeholder for an action stored in some other queue. Such placeholders serve as surrogates for “wait requests”, operations through which one character “waits” until a specified action is performed and completed by some other character.
- To clarify, an “action” refers to a scheduable animation requested by a client such as a Play or Speak request. The entries in the queues either represent scheduable actions or placeholders for the actions. The client identifies the action that is subject to a particular request via the request object. In response to an animation or synchronization request, the request manager takes the appropriate steps necessary to update the queues to process the request.
- When an action completes, the
request manager 540 removes that action from the appropriate queue, and, if necessary, marks any surrogate wait requests on other queues as “satisfied”. It then activates the next item on the queue. When the request manager activates a surrogate wait request, it halts processing on the actions of that queue until the action specified in the wait request is satisfied. Similarly, when a surrogate for a wait request is satisfied and at the head of the queue, the request manager removes that action from the queue. A wait request may be satisfied before it reaches the head of the queue. - In the reference implementation, the wait request is not removed until it reaches the head of the queue. Alternative implementations could remove the wait request from the queue as soon as it is satisfied. Functionally, these alternative approaches are similar.
- Stop and StopAll requests are processed similarly. Since they are executed immediately upon being made, they are not entered into the queue. When a stop request is encountered, the request manager immediately marks the relevant item as complete. Then, when that item reaches the head of the queue, it is removed immediately from the queue. As in the case of a satisfied wait request, an alternative implementation could remove an action that is subject to a Stop request immediately, rather than marking it complete.
- Synchronization of Queues on Separate Threads
- The essence of the current implementation of the scheduling threads is to make it very inexpensive to wait for the completion of an action such as a play or speak request. In the reference implementation shown in FIG. 12, this is accomplished by using several synchronization primitives, called “Events” in the Windows Operating System, and making a call to a synchronization function called “WaitForMultipleObjects” provided by the Windows Operating System.
- In the Windows Operating System, a thread is a basic program unit that the scheduler in the operating system kernel uses to determine access to CPU time. A thread, in this context is an execution path within a process, has its own private stack storage and execution context, shares memory allocated to its parent process, and can be one of many concurrent threads created by a single process. Any thread can create an “Event” object and obtain a handle to it using an operating system function called CreateEvent. Any threads belonging to any process can obtain a handle to the same event by specifying the event name. Any thread with a valid handle can then use the SetEvent to signal the occurrence of the event. Threads waiting for the event are then free to continue execution, and multiple threads may become eligible to run when the event is signaled.
- When a program (thread or process) makes a call to any of the so-called “Wait functions” in the operating system (which include not only WaitForMultipleObjects, but also “WaitMessage”, “WaitForSingleObject”, “MsgWaitForMultipleObjects”, and several others). the operating system kernel suspends the execution of the thread until a certain criterion is met. The operating system guarantees that the computation cost of a thread in this state is very low.
- In the reference implementation, the animation server is an executable process that has multiple threads, including the request manager and any threads spawned for character queues (character threads). The request manager controls the execution of the character threads by setting any of four predefined events for the character queues: an Exit event, a Stop event, a New event, and a Done event. Each of the character queues has a unique set of these four events. The character threads are implemented as a loop that periodically calls the WaitForMultipleObject function in the operating system. When it makes this call, the thread specifies an array of handles to each of its four events in the order listed above. The order is important because it establishes the order in which the operating system determines whether each of these events has been signaled. After making the function call, a character thread waits for the four event objects to be signaled.
- When the Exit event is set, the queue is to enter an exit state: all actions it contains should be removed and the character data cleaned up in preparation for shutdown of the animation server. When the Stop event is set, the currently active animation is being stopped, and should be cleaned up along with any other pending animation requests that were posted prior to the Stop. When the New event is set, a new animation request is being added to the queue. When the Done event is set, the current animation has just completed, and needs to be cleaned up.
- To add an action or surrogate action to a queue, the request manager sets a New event for the character thread of the character identified in the request. When notified of this event by the operating system, the target character thread adds the action to the tail of its queue.
- Each of the character threads execute concurrently under the multi-threading scheduling scheme of the operating system. As actions or surrogate actions reach the top of a queue, the character thread processes the action. In the case of standard Play or Speak request, the character thread makes a call to the request manager, which in turn, takes the appropriate action to play the animation. In the reference implementation, animations are played on the main thread of the application server. If multiple animations need to be drawn to the screen at the same time, the main thread makes drawing calls to the operating system quickly so that the animations appear simultaneously on the screen from the user's perspective. As noted below, it is also possible to implement the animations on separate threads of the animation server, but there are some performance trade-offs.
- When a Wait request reaches the head of a queue, the character thread makes a call to the request manager indicating that it is in a wait state (blocked) pending the completion of a particular action. The blocked thread remains in this state until the request manager sets a Done event for this action. In response to this Done event, the character thread cleans up the surrogate action at the head of its queue and proceeds to the next action.
- When an Interrupt request reaches the head of the queue, the character thread signals a stop event for the queue of the character that is subject to the interrupt request, identifying the action or actions to be stopped. The character thread for which the Stop event is set then responds to the Stop event by marking the identified action in its queue as complete.
- Each of the character queues proceed to the next entry in their respective queues when they receive Done events. The character queues continue to pop entries from the top of their queues until signaled to stop or exit as described above.
- The function, WaitForMultipleObjects, by its design, allows the queue to assign the appropriate priority to the event objects: Exit before Stop before New before Done. It also has the advantage that the operating system code supports the assurance that the state of the queue is actually kept internally consistent. By using operating system primitives for implementing the synchronization of the threads that control the animations, consistency is guaranteed.
- While using synchronization primitives of the operating system has these advantages, it is also possible to implement the same synchronization features within the code of the animation server.
- Implementing Animation Actions on Separate Threads
- In the current reference implementation, Play and Speak requests are executed on the main thread of the application. This implementation has some advantages and some disadvantages. Threads, although computationally fairly lightweight, carry fairly significant memory costs in some systems implementing the Win32 API for the Windows Operating System. For instance, under Windows 95, approximately 64K of kernel memory is consumed by each thread just to maintain its essential data. Each character already costs one thread to support its request manager queue. Thus, a character's animation would cost yet another thread if an animation requests were executed on a separate thread. The costs of the second threads would add up very quickly.
- On the other hand, there are unfortunate interactions between some of the essential operations that must take place on the animation server application's main thread and the operations necessary to drive a character's animations. Under certain circumstances, for instance, the main thread of the server application can be “hung”—stop processing messages—by activities driven by inter-process communication between the animation server and a client. For example, the main server thread can be hung it makes a call to an external thread or process that does not return. This, in turn, will hang the animation services, causing the characters to appear to freeze and to stop responding to user input. Depending on the environment in which the server is running, the costs of increased memory load, leading to a reduction of overall system responsiveness, need to be balanced against the costs of the possibility that a bug in a client program could cause all characters to freeze. Depending on the target machine configuration, one or another of these approaches might be better.
- Complementing each character's queuing thread with a separate animation thread can be thought of as an extension of the reference implementation. The operations involving activating, scheduling, or interrupting animations are already implemented through the request manager, which is, therefore, necessarily thread-safe. Scheduling animations on a separate thread is straightforward, then —one creates a thread in which the frames or sounds of those animations can be executed, and handles the timing of those displays on that secondary thread.
- Conclusion
- Though we have described the synchronization methods with respect to specific implementations and operating system platforms, it is important to emphasize that the invention is not limited to these implementations. The animation system does not have to be implemented as an OLE server. The system can be implemented according to other object oriented programming models, or alternatively, need not be based on an object model at all. In the implementation described above, scripts access animation services via an OLE control. However, the use of an OLE control is only one possible way to process script commands in the script engine.
- The specific syntax of the script commands and API calls used to access synchronization services can vary as well. For example, there are a variety of alternative ways to identify an action of an animation for the purpose of synchronizing the actions of different animations. The request object is just one possible data structure that can be used as an identification of a character's action. For example, the server's API may use a request object to identify an action, or may use a pointer to an action to identify the action.
- As explained above, the animation server can be implemented as a multi-threaded application with the request manager and character queues executing on separate threads. A similar functionality can be achieved in multi-tasking platforms that do not support multi-threading. For example, each of the threads could be implemented as separate processes that employ shared memory to access shared data.
- In view of the many possible implementations to which the principles of our invention may be applied, it should be recognized that the implementations described above are only examples of the invention and should not be taken as a limitation on the scope of the invention. Rather, the scope of the invention is defined by the following claims. We therefore claim as our invention all that comes within the scope and spirit of these claims.
Claims (26)
Priority Applications (1)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US09/031,144 US6369821B2 (en) | 1997-05-19 | 1998-02-26 | Method and system for synchronizing scripted animations |
Applications Claiming Priority (2)
Application Number | Priority Date | Filing Date | Title |
---|---|---|---|
US08/858,648 US5983190A (en) | 1997-05-19 | 1997-05-19 | Client server animation system for managing interactive user interface characters |
US09/031,144 US6369821B2 (en) | 1997-05-19 | 1998-02-26 | Method and system for synchronizing scripted animations |
Related Parent Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/858,684 Continuation-In-Part US5956857A (en) | 1997-05-19 | 1997-05-19 | Mounting device for a coordinate measuring machine |
US08/858,648 Continuation-In-Part US5983190A (en) | 1997-05-19 | 1997-05-19 | Client server animation system for managing interactive user interface characters |
Publications (2)
Publication Number | Publication Date |
---|---|
US20020008703A1 true US20020008703A1 (en) | 2002-01-24 |
US6369821B2 US6369821B2 (en) | 2002-04-09 |
Family
ID=25328814
Family Applications (2)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/858,648 Expired - Lifetime US5983190A (en) | 1997-05-19 | 1997-05-19 | Client server animation system for managing interactive user interface characters |
US09/031,144 Expired - Lifetime US6369821B2 (en) | 1997-05-19 | 1998-02-26 | Method and system for synchronizing scripted animations |
Family Applications Before (1)
Application Number | Title | Priority Date | Filing Date |
---|---|---|---|
US08/858,648 Expired - Lifetime US5983190A (en) | 1997-05-19 | 1997-05-19 | Client server animation system for managing interactive user interface characters |
Country Status (1)
Country | Link |
---|---|
US (2) | US5983190A (en) |
Cited By (85)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US20010026276A1 (en) * | 2000-03-17 | 2001-10-04 | Kiyomi Sakamoto | Map display device and navigation device |
US20020041289A1 (en) * | 2000-08-21 | 2002-04-11 | Hatch John D. | Method and apparatus for producing functionality and user interfaces for devices having an embedded operating system |
US20020049805A1 (en) * | 2000-10-24 | 2002-04-25 | Sanyo Electric Co., Ltd. | User support apparatus and system using agents |
US20020057372A1 (en) * | 1998-11-13 | 2002-05-16 | Philips Electronics North America Corporation | Method and device for detecting an event in a program of a video and/or audio signal and for providing the program to a display upon detection of the event |
US20020062386A1 (en) * | 2000-11-01 | 2002-05-23 | Christopher Piche | Method and apparatus for improving real time and/or interactive animation over a computer network |
US20020101431A1 (en) * | 2000-09-15 | 2002-08-01 | Forney Paul W. | Method and system for animating graphical user interface elements via a manufacturing/process control portal server |
US20020133635A1 (en) * | 2001-03-16 | 2002-09-19 | Microsoft Corporation | Method and system for interacting with devices having different capabilities |
US20030025728A1 (en) * | 2001-07-10 | 2003-02-06 | Ebbo David S. | User control objects for providing server-side code generation from a user-defined dynamic web page content file |
US20030145060A1 (en) * | 2001-10-18 | 2003-07-31 | Martin Anthony G. | Presentation of information to end-users |
US20030161425A1 (en) * | 2002-02-26 | 2003-08-28 | Yamaha Corporation | Multimedia information encoding apparatus, multimedia information reproducing apparatus, multimedia information encoding process program, multimedia information reproducing process program, and multimedia encoded data |
US20030233477A1 (en) * | 2002-06-17 | 2003-12-18 | Microsoft Corporation | Extensible infrastructure for manipulating messages communicated over a distributed network |
US20040017396A1 (en) * | 2002-07-29 | 2004-01-29 | Werndorfer Scott M. | System and method for managing contacts in an instant messaging environment |
US20040024822A1 (en) * | 2002-08-01 | 2004-02-05 | Werndorfer Scott M. | Apparatus and method for generating audio and graphical animations in an instant messaging environment |
US6690376B1 (en) * | 1999-09-29 | 2004-02-10 | Sega Enterprises, Ltd. | Storage medium for storing animation data, image processing method using same, and storage medium storing image processing programs |
US20040073873A1 (en) * | 2002-10-11 | 2004-04-15 | Microsoft Corporation | Adaptive image formatting control |
US6757900B1 (en) | 2000-05-18 | 2004-06-29 | Microsoft Corporation | State management of server-side control objects |
US20040148337A1 (en) * | 2002-12-02 | 2004-07-29 | Duncan Ross W. | System and method for enabling communication between a web browser and a software agent infrastructure |
US6792607B1 (en) | 2000-05-18 | 2004-09-14 | Microsoft Corporation | Databinding using server-side control objects |
US20040189644A1 (en) * | 2003-03-25 | 2004-09-30 | Frisken Sarah F. | Method for animating two-dimensional objects |
US20040205830A1 (en) * | 2003-04-10 | 2004-10-14 | Microsoft Corporation | Synchronization mechanism and the implementation for multimedia captioning and audio descriptions |
US20040230410A1 (en) * | 2003-05-13 | 2004-11-18 | Harless William G. | Method and system for simulated interactive conversation |
US20050091230A1 (en) * | 2003-10-24 | 2005-04-28 | Ebbo David S. | Software build extensibility |
US6898604B1 (en) | 2001-06-29 | 2005-05-24 | Microsoft Corporation | XML serialization and deserialization |
US20050193097A1 (en) * | 2001-06-06 | 2005-09-01 | Microsoft Corporation | Providing remote processing services over a distributed communications network |
US20050219255A1 (en) * | 2004-03-30 | 2005-10-06 | Hung-Yi Lin | User interface display apparatus using texture mapping method |
US6961750B1 (en) | 2000-05-18 | 2005-11-01 | Microsoft Corp. | Server-side control objects for processing client-side user interface elements |
US20050251380A1 (en) * | 2004-05-10 | 2005-11-10 | Simon Calvert | Designer regions and Interactive control designers |
US20050256933A1 (en) * | 2004-05-07 | 2005-11-17 | Millington Bradley D | Client-side callbacks to server events |
US20050256924A1 (en) * | 2004-05-14 | 2005-11-17 | Microsoft Corporation | Systems and methods for persisting data between web pages |
US20050256834A1 (en) * | 2004-05-17 | 2005-11-17 | Microsoft Corporation | Data controls architecture |
US20050268292A1 (en) * | 2004-05-28 | 2005-12-01 | Microsoft Corporation | Non-compile pages |
US20050278351A1 (en) * | 2004-05-28 | 2005-12-15 | Microsoft Corporation | Site navigation and site navigation data source |
US20060005149A1 (en) * | 2001-04-20 | 2006-01-05 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US20060004910A1 (en) * | 2000-05-18 | 2006-01-05 | Microsoft Corporation | Postback input handling by server-side control objects |
US6985946B1 (en) | 2000-05-12 | 2006-01-10 | Microsoft Corporation | Authentication and authorization pipeline architecture for use in a web server |
US6990653B1 (en) * | 2000-05-18 | 2006-01-24 | Microsoft Corporation | Server-side code generation from a dynamic web page content file |
US20060020883A1 (en) * | 2004-05-28 | 2006-01-26 | Microsoft Corporation | Web page personalization |
US20060041550A1 (en) * | 2004-08-19 | 2006-02-23 | Claria Corporation | Method and apparatus for responding to end-user request for information-personalization |
US20060085541A1 (en) * | 2004-10-19 | 2006-04-20 | International Business Machines Corporation | Facilitating optimization of response time in computer networks |
US20060085515A1 (en) * | 2004-10-14 | 2006-04-20 | Kevin Kurtz | Advanced text analysis and supplemental content processing in an instant messaging environment |
US20060109273A1 (en) * | 2004-11-19 | 2006-05-25 | Rams Joaquin S | Real-time multi-media information and communications system |
US20060136378A1 (en) * | 2004-12-17 | 2006-06-22 | Claria Corporation | Search engine for a computer network |
US20060233520A1 (en) * | 2005-04-18 | 2006-10-19 | Lg Electronics Inc. | Method for transmitting and receiving graphic data between an image display apparatus and an external apparatus, and information frame structure including information on the graphic data |
US20060242587A1 (en) * | 2002-05-21 | 2006-10-26 | Eagle Scott G | Method and apparatus for displaying messages in computer systems |
US20060253432A1 (en) * | 2005-03-17 | 2006-11-09 | Claria Corporation | Method for providing content to an internet user based on the user's demonstrated content preferences |
US20060274069A1 (en) * | 2005-06-07 | 2006-12-07 | Gordon Patricia L | Three dimensional animated figures |
US20060293957A1 (en) * | 2005-06-28 | 2006-12-28 | Claria Corporation | Method for providing advertising content to an internet user based on the user's demonstrated content preferences |
US20060294226A1 (en) * | 2005-06-28 | 2006-12-28 | Goulden David L | Techniques for displaying impressions in documents delivered over a computer network |
US20070229542A1 (en) * | 2006-03-30 | 2007-10-04 | Taco Van Ieperen | Method and graphical interface for embedding animated content into a computer application |
US20080016491A1 (en) * | 2006-07-13 | 2008-01-17 | Apple Computer, Inc | Multimedia scripting |
US20080059801A1 (en) * | 2006-08-31 | 2008-03-06 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Authenticatable displayed content |
US20080059802A1 (en) * | 2006-08-31 | 2008-03-06 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Screening for masquerading content |
US20080072286A1 (en) * | 2006-08-31 | 2008-03-20 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Handling masquerading elements |
US20090125813A1 (en) * | 2007-11-09 | 2009-05-14 | Zhongnan Shen | Method and system for processing multiple dialog sessions in parallel |
US20090184967A1 (en) * | 1999-05-21 | 2009-07-23 | Kulas Charles J | Script control for lip animation in a scene generated by a computer rendering engine |
US7594001B1 (en) | 2001-07-06 | 2009-09-22 | Microsoft Corporation | Partial page output caching |
US20090315896A1 (en) * | 2008-06-24 | 2009-12-24 | Microsoft Corporation | Animation platform |
US20100182331A1 (en) * | 2009-01-16 | 2010-07-22 | Samsung Electronics Co., Ltd. | Method and apparatus for drawing image |
US20100253693A1 (en) * | 2009-04-01 | 2010-10-07 | Qnx Software Systems Gmbh & Co. Kg | System for accelerating composite graphics rendering |
US7817158B1 (en) * | 1998-10-23 | 2010-10-19 | Autodesk, Inc. | Specifying operations to be applied to the attributes of a set of objects |
US20100299682A1 (en) * | 2009-05-21 | 2010-11-25 | Samsung Electronics Co., Ltd. | Method and apparatus for executing java application |
US20100306053A1 (en) * | 2004-12-20 | 2010-12-02 | Anthony Martin | Method and Device for Publishing Cross-Network User Behavioral Data |
US20110072109A1 (en) * | 2000-07-12 | 2011-03-24 | Treehouse Solutions, Inc. | Method and system for presenting data over a network based on network user choices and collecting real-time data related to said choices |
US20110096076A1 (en) * | 2009-10-27 | 2011-04-28 | Microsoft Corporation | Application program interface for animation |
US20110119582A1 (en) * | 2009-11-17 | 2011-05-19 | Samsung Electronics Co., Ltd. | Method and system for rendering multiple hospitality services to a user via a virtual platform field |
US8065600B2 (en) | 2004-05-14 | 2011-11-22 | Microsoft Corporation | Systems and methods for defining web content navigation |
US20110298787A1 (en) * | 2010-06-02 | 2011-12-08 | Daniel Feies | Layer composition, rendering, and animation using multiple execution threads |
US20120026174A1 (en) * | 2009-04-27 | 2012-02-02 | Sonoma Data Solution, Llc | Method and Apparatus for Character Animation |
US20120030612A1 (en) * | 2010-07-30 | 2012-02-02 | Sap Ag | Dynamic property attributes |
US8316003B2 (en) | 2002-11-05 | 2012-11-20 | Carhamm Ltd., Llc | Updating content of presentation vehicle in a computer network |
CN102929491A (en) * | 2011-11-14 | 2013-02-13 | 微软公司 | Cross-window animation |
CN103098098A (en) * | 2010-03-30 | 2013-05-08 | 三菱电机株式会社 | Animation display device |
US8689238B2 (en) | 2000-05-18 | 2014-04-01 | Carhamm Ltd., Llc | Techniques for displaying impressions in documents delivered over a computer network |
US20140279743A1 (en) * | 2013-03-15 | 2014-09-18 | Yahoo! Inc. | Jabba-type override for correcting or improving output of a model |
US20150046852A1 (en) * | 2013-08-12 | 2015-02-12 | Home Box Office, Inc. | Coordinating user interface elements across screen spaces |
US9128702B2 (en) * | 2012-03-23 | 2015-09-08 | Google Inc. | Asynchronous message passing |
US9747426B2 (en) | 2006-08-31 | 2017-08-29 | Invention Science Fund I, Llc | Handling masquerading elements |
USRE46758E1 (en) * | 2007-09-04 | 2018-03-20 | Apple Inc. | Animation of graphical objects |
US9934263B1 (en) * | 2012-12-04 | 2018-04-03 | Pivotal Software, Inc. | Big-fast data connector between in-memory database system and data warehouse system |
US9977661B2 (en) * | 2013-06-28 | 2018-05-22 | Tencent Technology (Shenzhen) Company Limited | Method and system for generating a user interface |
US10033747B1 (en) * | 2015-09-29 | 2018-07-24 | Fireeye, Inc. | System and method for detecting interpreter-based exploit attacks |
US10162951B2 (en) | 2006-02-23 | 2018-12-25 | Microsoft Technology Licensing, Llc | Non-intrusive background synchronization when authentication is required |
US20190268249A1 (en) * | 2016-11-04 | 2019-08-29 | Google Llc | Systems and methods for measuring media performance on end-user devices |
RU2726342C1 (en) * | 2020-01-17 | 2020-07-13 | Общество с ограниченной ответственностью «ЯЛОС МОБАЙЛ» | System for displaying the animated sound image data on the display of the computing device in accordance with notifications |
US20220210506A1 (en) * | 2020-11-23 | 2022-06-30 | The Boston Consulting Group, Inc. | Methods And Systems For Context-Sensitive Manipulation of an Object via a Presentation Software |
Families Citing this family (339)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US8352400B2 (en) | 1991-12-23 | 2013-01-08 | Hoffberg Steven M | Adaptive pattern recognition based controller apparatus and method and human-factored interface therefore |
US6678864B1 (en) * | 1992-02-25 | 2004-01-13 | Irving Tsai | Method and apparatus for linking designated portions of a received document image with an electronic address |
US6604103B1 (en) * | 1994-09-02 | 2003-08-05 | Mark A. Wolfe | System and method for information retrieval employing a preloading procedure |
US7467137B1 (en) | 1994-09-02 | 2008-12-16 | Wolfe Mark A | System and method for information retrieval employing a preloading procedure |
US7555529B2 (en) * | 1995-11-13 | 2009-06-30 | Citrix Systems, Inc. | Interacting with software applications displayed in a web page |
US6088515A (en) | 1995-11-13 | 2000-07-11 | Citrix Systems Inc | Method and apparatus for making a hypermedium interactive |
US6006252A (en) * | 1996-10-08 | 1999-12-21 | Wolfe; Mark A. | System and method for communicating information relating to a network resource |
US20050097594A1 (en) * | 1997-03-24 | 2005-05-05 | O'donnell Frank | Systems and methods for awarding affinity points based upon remote control usage |
US7737980B2 (en) * | 1997-07-10 | 2010-06-15 | Phac Le Tuan | Methods and apparatus for supporting and implementing computer based animation |
US6567779B1 (en) * | 1997-08-05 | 2003-05-20 | At&T Corp. | Method and system for aligning natural and synthetic video to speech synthesis |
US7366670B1 (en) | 1997-08-05 | 2008-04-29 | At&T Corp. | Method and system for aligning natural and synthetic video to speech synthesis |
US7027568B1 (en) * | 1997-10-10 | 2006-04-11 | Verizon Services Corp. | Personal message service with enhanced text to speech synthesis |
US7257604B1 (en) | 1997-11-17 | 2007-08-14 | Wolfe Mark A | System and method for communicating information relating to a network resource |
US7159009B2 (en) * | 1997-12-17 | 2007-01-02 | Sony Corporation | Method and apparatus for automatic sending of e-mail and automatic sending control program supplying medium |
US6282512B1 (en) * | 1998-02-05 | 2001-08-28 | Texas Instruments Incorporated | Enhancement of markup language pages to support spoken queries |
US6314439B1 (en) * | 1998-02-06 | 2001-11-06 | International Business Machines Corporation | Computer system, program product and method of creating aliases and accessing storage locations in a computer system with same |
JP4197195B2 (en) * | 1998-02-27 | 2008-12-17 | ヒューレット・パッカード・カンパニー | Providing audio information |
US6684211B1 (en) | 1998-04-01 | 2004-01-27 | Planetweb, Inc. | Multimedia communication and presentation |
US6144938A (en) * | 1998-05-01 | 2000-11-07 | Sun Microsystems, Inc. | Voice user interface with personality |
JP3125746B2 (en) * | 1998-05-27 | 2001-01-22 | 日本電気株式会社 | PERSON INTERACTIVE DEVICE AND RECORDING MEDIUM RECORDING PERSON INTERACTIVE PROGRAM |
US6167448A (en) * | 1998-06-11 | 2000-12-26 | Compaq Computer Corporation | Management event notification system using event notification messages written using a markup language |
US6175862B1 (en) * | 1998-06-17 | 2001-01-16 | International Business Machines Corporation | Hot objects with sequenced links in web browsers |
US6513160B2 (en) * | 1998-06-17 | 2003-01-28 | Opentv, Inc. | System and method for promoting viewer interaction in a television system |
US6593937B2 (en) | 1998-06-18 | 2003-07-15 | Sony Corporation | Method of and apparatus for handling high bandwidth on-screen-display graphics data over a distributed IEEE 1394 network utilizing an isochronous data transmission format |
US6501441B1 (en) | 1998-06-18 | 2002-12-31 | Sony Corporation | Method of and apparatus for partitioning, scaling and displaying video and/or graphics across several display devices |
US6377276B1 (en) * | 1998-06-18 | 2002-04-23 | Sony Corporation | Bitmap animation of on-screen-display graphics over a distributed network and a clipping region having a visible window |
US7082391B1 (en) * | 1998-07-14 | 2006-07-25 | Intel Corporation | Automatic speech recognition |
EP1116221B1 (en) * | 1998-09-30 | 2003-07-23 | Lernout & Hauspie Speech Products N.V. | Graphic user interface for navigation in speech recognition system grammars |
US6163794A (en) | 1998-10-23 | 2000-12-19 | General Magic | Network system extensible by users |
US6409602B1 (en) | 1998-11-06 | 2002-06-25 | New Millenium Gaming Limited | Slim terminal gaming system |
US6845370B2 (en) * | 1998-11-12 | 2005-01-18 | Accenture Llp | Advanced information gathering for targeted activities |
US6446076B1 (en) * | 1998-11-12 | 2002-09-03 | Accenture Llp. | Voice interactive web-based agent system responsive to a user location for prioritizing and formatting information |
IL127293A0 (en) * | 1998-11-26 | 1999-09-22 | Creator Ltd | Script development systems and methods useful therefor |
US6751606B1 (en) * | 1998-12-23 | 2004-06-15 | Microsoft Corporation | System for enhancing a query interface |
JP2000187435A (en) * | 1998-12-24 | 2000-07-04 | Sony Corp | Information processing device, portable apparatus, electronic pet device, recording medium with information processing procedure recorded thereon, and information processing method |
US6928469B1 (en) | 1998-12-29 | 2005-08-09 | Citrix Systems, Inc. | Apparatus and method for determining a program neighborhood for a client node in a client-server network using markup language techniques |
US20030040916A1 (en) * | 1999-01-27 | 2003-02-27 | Major Ronald Leslie | Voice driven mouth animation system |
US7904187B2 (en) | 1999-02-01 | 2011-03-08 | Hoffberg Steven M | Internet appliance system and method |
US6970925B1 (en) * | 1999-02-03 | 2005-11-29 | William H. Gates, III | Method and system for property notification |
US6313835B1 (en) * | 1999-04-09 | 2001-11-06 | Zapa Digital Arts Ltd. | Simplified on-line preparation of dynamic web sites |
EP1045374B1 (en) * | 1999-04-13 | 2010-08-11 | Sony Deutschland GmbH | Merging of speech interfaces for concurrent use of devices and applications |
US7283964B1 (en) * | 1999-05-21 | 2007-10-16 | Winbond Electronics Corporation | Method and apparatus for voice controlled devices with improved phrase storage, use, conversion, transfer, and recognition |
US6559845B1 (en) * | 1999-06-11 | 2003-05-06 | Pulse Entertainment | Three dimensional animation system and method |
US6493719B1 (en) * | 1999-07-26 | 2002-12-10 | Microsoft Corporation | Method and system for scripting for system management information |
US6370597B1 (en) * | 1999-08-12 | 2002-04-09 | United Internet Technologies, Inc. | System for remotely controlling an animatronic device in a chat environment utilizing control signals sent by a remote device over the internet |
US6480201B1 (en) | 1999-08-24 | 2002-11-12 | Microsoft Corporation | Alpha regions |
US6486888B1 (en) | 1999-08-24 | 2002-11-26 | Microsoft Corporation | Alpha regions |
US6578000B1 (en) * | 1999-09-03 | 2003-06-10 | Cisco Technology, Inc. | Browser-based arrangement for developing voice enabled web applications using extensible markup language documents |
US7149690B2 (en) * | 1999-09-09 | 2006-12-12 | Lucent Technologies Inc. | Method and apparatus for interactive language instruction |
US6360221B1 (en) | 1999-09-21 | 2002-03-19 | Neostar, Inc. | Method and apparatus for the production, delivery, and receipt of enhanced e-mail |
US9092535B1 (en) | 1999-09-21 | 2015-07-28 | Google Inc. | E-mail embedded textual hyperlink object |
US7330815B1 (en) * | 1999-10-04 | 2008-02-12 | Globalenglish Corporation | Method and system for network-based speech recognition |
US6823313B1 (en) * | 1999-10-12 | 2004-11-23 | Unisys Corporation | Methodology for developing interactive systems |
US7369130B2 (en) * | 1999-10-29 | 2008-05-06 | Hitachi Kokusai Electric Inc. | Method and apparatus for editing image data, and computer program product of editing image data |
US6944586B1 (en) * | 1999-11-09 | 2005-09-13 | Interactive Drama, Inc. | Interactive simulated dialogue system and method for a computer network |
JP2003514307A (en) * | 1999-11-11 | 2003-04-15 | ユナイテッド バーチャリティーズ インク. | Computer advertising method and system |
US9076448B2 (en) | 1999-11-12 | 2015-07-07 | Nuance Communications, Inc. | Distributed real time speech recognition system |
US6633846B1 (en) * | 1999-11-12 | 2003-10-14 | Phoenix Solutions, Inc. | Distributed realtime speech recognition system |
US7392185B2 (en) | 1999-11-12 | 2008-06-24 | Phoenix Solutions, Inc. | Speech based learning/training system using semantic decoding |
US6665640B1 (en) * | 1999-11-12 | 2003-12-16 | Phoenix Solutions, Inc. | Interactive speech based learning/training system formulating search queries based on natural language parsing of recognized user queries |
US7050977B1 (en) | 1999-11-12 | 2006-05-23 | Phoenix Solutions, Inc. | Speech-enabled server for internet website and method |
US7725307B2 (en) | 1999-11-12 | 2010-05-25 | Phoenix Solutions, Inc. | Query engine for processing voice based queries including semantic decoding |
US7013283B1 (en) * | 1999-11-17 | 2006-03-14 | Sarnoff Corporation | System and method for providing programming content in response to an audio signal |
US6657628B1 (en) * | 1999-11-24 | 2003-12-02 | Fuji Xerox Co., Ltd. | Method and apparatus for specification, control and modulation of social primitives in animated characters |
US6606103B1 (en) * | 1999-11-30 | 2003-08-12 | Uhc Llc | Infinite resolution scheme for graphical user interface object |
US7020843B2 (en) * | 1999-11-30 | 2006-03-28 | Uhc Llc | Method and system for implementing a browser object container |
US6807666B1 (en) * | 1999-12-15 | 2004-10-19 | Microsoft Corporation | Methods and arrangements for providing multiple concurrent desktops and workspaces in a shared computing environment |
IL133560A (en) | 1999-12-16 | 2001-09-13 | Ad4Ever Inc | Method and system for dynamically superimposing multimedia on a background object downloaded through the internet |
US6654784B1 (en) * | 2000-01-14 | 2003-11-25 | Nexaweb Technologies, Inc | Computing architecture |
US6434529B1 (en) * | 2000-02-16 | 2002-08-13 | Sun Microsystems, Inc. | System and method for referencing object instances and invoking methods on those object instances from within a speech recognition grammar |
US7509648B1 (en) * | 2000-02-28 | 2009-03-24 | At & T Corp. | Paradigm in multimedia services creation methodology, and new service creation and service execution environments |
US20010037386A1 (en) * | 2000-03-06 | 2001-11-01 | Susumu Takatsuka | Communication system, entertainment apparatus, recording medium, and program |
US7366766B2 (en) * | 2000-03-24 | 2008-04-29 | Eliza Corporation | Web-based speech recognition with scripting and semantic objects |
US6831652B1 (en) * | 2000-03-24 | 2004-12-14 | Ati International, Srl | Method and system for storing graphics data |
US7370086B2 (en) | 2000-03-24 | 2008-05-06 | Eliza Corporation | Web-based speech recognition with scripting and semantic objects |
US6539354B1 (en) | 2000-03-24 | 2003-03-25 | Fluent Speech Technologies, Inc. | Methods and devices for producing and using synthetic visual speech based on natural coarticulation |
US8626519B1 (en) | 2000-03-30 | 2014-01-07 | Inventor Holdings, Llc | Entertainment layer overlaid on online transactions |
KR100426335B1 (en) * | 2000-04-06 | 2004-04-03 | 주식회사 한스텝 | System for operating toys by an application program |
US6640299B1 (en) * | 2000-04-21 | 2003-10-28 | Ati International Srl | Method and apparatus for arbitrating access to a computational engine for use in a video graphics controller |
US6785726B1 (en) | 2000-05-08 | 2004-08-31 | Citrix Systems, Inc. | Method and apparatus for delivering local and remote server events in a similar fashion |
US6789112B1 (en) | 2000-05-08 | 2004-09-07 | Citrix Systems, Inc. | Method and apparatus for administering a server having a subsystem in communication with an event channel |
US6785713B1 (en) | 2000-05-08 | 2004-08-31 | Citrix Systems, Inc. | Method and apparatus for communicating among a network of servers utilizing a transport mechanism |
US7284232B1 (en) | 2000-05-15 | 2007-10-16 | International Business Machines Corporation | Automated generation of aliases based on embedded alias information |
JP2001325052A (en) * | 2000-05-17 | 2001-11-22 | Sharp Corp | Agent display device, agent display method, and recording medium with agent display program recorded |
EP1326405B1 (en) * | 2000-05-26 | 2005-03-23 | Citrix Systems, Inc. | Method and system for efficiently reducing graphical display data for transmission over a low bandwidth transport protocol mechanism |
US20020029285A1 (en) * | 2000-05-26 | 2002-03-07 | Henry Collins | Adapting graphical data, processing activity to changing network conditions |
AU2006202299B2 (en) * | 2000-05-26 | 2008-01-03 | Citrix Systems, Inc. | Method and system for efficiently reducing graphical display data for transmission over a low bandwidth transport protocol mechanism |
US20010049596A1 (en) * | 2000-05-30 | 2001-12-06 | Adam Lavine | Text to animation process |
US6943794B2 (en) * | 2000-06-13 | 2005-09-13 | Minolta Co., Ltd. | Communication system and communication method using animation and server as well as terminal device used therefor |
US6654722B1 (en) * | 2000-06-19 | 2003-11-25 | International Business Machines Corporation | Voice over IP protocol based speech system |
US7699699B2 (en) | 2000-06-23 | 2010-04-20 | Igt | Gaming device having multiple selectable display interfaces based on player's wagers |
US7695363B2 (en) | 2000-06-23 | 2010-04-13 | Igt | Gaming device having multiple display interfaces |
US7159008B1 (en) * | 2000-06-30 | 2007-01-02 | Immersion Corporation | Chat interface with haptic feedback functionality |
US6734873B1 (en) | 2000-07-21 | 2004-05-11 | Viewpoint Corporation | Method and system for displaying a composited image |
US7091975B1 (en) * | 2000-07-21 | 2006-08-15 | Microsoft Corporation | Shape and animation methods and systems using examples |
JP2002041276A (en) * | 2000-07-24 | 2002-02-08 | Sony Corp | Interactive operation-supporting system, interactive operation-supporting method and recording medium |
JP2002062889A (en) * | 2000-08-14 | 2002-02-28 | Pioneer Electronic Corp | Speech synthesizing method |
KR20020022504A (en) * | 2000-09-20 | 2002-03-27 | 박종만 | System and method for 3D animation authoring with motion control, facial animation, lip synchronizing and lip synchronized voice |
US6608624B1 (en) * | 2000-09-06 | 2003-08-19 | Image Tech Incorporation | Method for accelerating 3D animation production |
CN1473298A (en) * | 2000-09-08 | 2004-02-04 | ù | Computerized advertising method and system |
JP2002091971A (en) * | 2000-09-11 | 2002-03-29 | Sony Corp | Agent system, method/device for providing information and data recording medium |
US6728698B2 (en) * | 2000-09-14 | 2004-04-27 | Benq Corporation | Method and system for interaction between a browser engine and an application |
KR20020022885A (en) * | 2000-09-21 | 2002-03-28 | 이성웅 | System and method for producing virtual character of mascot and method for computer service using virtual character |
US7240006B1 (en) * | 2000-09-27 | 2007-07-03 | International Business Machines Corporation | Explicitly registering markup based on verbal commands and exploiting audio context |
FR2814570B1 (en) * | 2000-09-27 | 2003-11-21 | Cyber Act | INTERACTIVE METHOD FOR COMMUNICATING INFORMATION TO USERS OF A COMPUTER COMMUNICATION NETWORK, PARTICULARLY OF THE INTERNET TYPE |
US7024348B1 (en) * | 2000-09-28 | 2006-04-04 | Unisys Corporation | Dialogue flow interpreter development tool |
JP2002109560A (en) * | 2000-10-02 | 2002-04-12 | Sharp Corp | Animation reproducing unit, animation reproducing system, animation reproducing method, recording medium readable by computer storing program for executing animation reproducing method |
US7260536B1 (en) * | 2000-10-06 | 2007-08-21 | Hewlett-Packard Development Company, L.P. | Distributed voice and wireless interface modules for exposing messaging/collaboration data to voice and wireless devices |
US6931656B1 (en) * | 2000-10-11 | 2005-08-16 | Koninklijke Philips Electronics N.V. | Virtual creature displayed on a television |
JP3417918B2 (en) | 2000-11-02 | 2003-06-16 | コナミ株式会社 | Computer-readable recording medium recording display control program, and display control apparatus and method |
US7035803B1 (en) | 2000-11-03 | 2006-04-25 | At&T Corp. | Method for sending multi-media messages using customizable background images |
US6976082B1 (en) | 2000-11-03 | 2005-12-13 | At&T Corp. | System and method for receiving multi-media messages |
US7203648B1 (en) | 2000-11-03 | 2007-04-10 | At&T Corp. | Method for sending multi-media messages with customized audio |
US7091976B1 (en) | 2000-11-03 | 2006-08-15 | At&T Corp. | System and method of customizing animated entities for use in a multi-media communication application |
AU2002232928A1 (en) * | 2000-11-03 | 2002-05-15 | Zoesis, Inc. | Interactive character system |
US6963839B1 (en) | 2000-11-03 | 2005-11-08 | At&T Corp. | System and method of controlling sound in a multi-media communication application |
US20080040227A1 (en) | 2000-11-03 | 2008-02-14 | At&T Corp. | System and method of marketing using a multi-media communication system |
US6990452B1 (en) | 2000-11-03 | 2006-01-24 | At&T Corp. | Method for sending multi-media messages using emoticons |
JP4011327B2 (en) * | 2000-11-15 | 2007-11-21 | 株式会社レクサー・リサーチ | Display object providing apparatus, display object providing method, and display object providing program |
ES2305124T3 (en) * | 2000-11-17 | 2008-11-01 | TATE & LYLE TECHNOLOGY LIMITED | FUNDIBLE FORM OF SUCRALOSE. |
GB0029024D0 (en) * | 2000-11-29 | 2001-01-10 | Hewlett Packard Co | Communication of network address information |
US6775671B1 (en) * | 2000-12-13 | 2004-08-10 | William Marsh Rice University | Component-based adaptation system and method |
US7143044B2 (en) * | 2000-12-29 | 2006-11-28 | International Business Machines Corporation | Translator for infants and toddlers |
JP2002208022A (en) * | 2001-01-10 | 2002-07-26 | Reile:Kk | Display control method, information display device and medium |
WO2002057953A1 (en) * | 2001-01-18 | 2002-07-25 | Bug-Life Ltd. | Method and system for the implementation of virtual animated characters within a data communication network-based application |
US6661418B1 (en) * | 2001-01-22 | 2003-12-09 | Digital Animations Limited | Character animation system |
US6749510B2 (en) * | 2001-02-07 | 2004-06-15 | Wms Gaming Inc. | Centralized gaming system with modifiable remote display terminals |
US7249190B2 (en) * | 2001-02-09 | 2007-07-24 | Comlet Technologies, Llc. | Enhanced data exchange and presentation/communication system |
US7797431B2 (en) * | 2001-02-09 | 2010-09-14 | Willard Case | Enhanced data exchange and functionality control system and method |
US7305345B2 (en) * | 2001-02-15 | 2007-12-04 | Livewire Acquisition, Inc. | Methods, systems, and computer program products for providing automated customer service via an intelligent virtual agent that is trained using customer-agent conversations |
WO2002069325A1 (en) * | 2001-02-26 | 2002-09-06 | Startouch International, Ltd. | Apparatus and methods for implementing voice enabling applications in a coverged voice and data network environment |
US6801897B2 (en) * | 2001-03-28 | 2004-10-05 | International Business Machines Corporation | Method of providing concise forms of natural commands |
US20020194006A1 (en) * | 2001-03-29 | 2002-12-19 | Koninklijke Philips Electronics N.V. | Text to visual speech system and method incorporating facial emotions |
US6957389B2 (en) * | 2001-04-09 | 2005-10-18 | Microsoft Corp. | Animation on-object user interface |
FR2823585B1 (en) * | 2001-04-13 | 2003-09-12 | Cantoche Production | METHOD AND SYSTEM FOR ANIMATING A THREE-DIMENSIONAL CHARACTER |
US7203645B2 (en) * | 2001-04-27 | 2007-04-10 | Intel Corporation | Speech recognition system loading different recognition engines for different applications |
US20030046364A1 (en) * | 2001-06-12 | 2003-03-06 | Lonnie Sisco | Web interface |
US20020198716A1 (en) * | 2001-06-25 | 2002-12-26 | Kurt Zimmerman | System and method of improved communication |
EP1274046A1 (en) * | 2001-07-03 | 2003-01-08 | FunMail, Inc | Method and system for generating animations from text |
IL159895A0 (en) * | 2001-07-20 | 2004-06-20 | Technion Res & Dev Foundation | Methods of generating human cardiac cells and tissues and uses thereof |
US7444286B2 (en) * | 2001-09-05 | 2008-10-28 | Roth Daniel L | Speech recognition using re-utterance recognition |
US7505911B2 (en) * | 2001-09-05 | 2009-03-17 | Roth Daniel L | Combined speech recognition and sound recording |
US7809574B2 (en) | 2001-09-05 | 2010-10-05 | Voice Signal Technologies Inc. | Word recognition using choice lists |
US7526431B2 (en) | 2001-09-05 | 2009-04-28 | Voice Signal Technologies, Inc. | Speech recognition using ambiguous or phone key spelling and/or filtering |
US7467089B2 (en) | 2001-09-05 | 2008-12-16 | Roth Daniel L | Combined speech and handwriting recognition |
US20030055824A1 (en) * | 2001-09-19 | 2003-03-20 | Andrea Califano | Distributed personalized genetic safe |
US7324947B2 (en) | 2001-10-03 | 2008-01-29 | Promptu Systems Corporation | Global speech user interface |
US7260604B2 (en) | 2001-10-18 | 2007-08-21 | Sharp Laboratories Of America, Inc. | Graphical user interface for an appliance network |
JP3589216B2 (en) * | 2001-11-02 | 2004-11-17 | 日本電気株式会社 | Speech synthesis system and speech synthesis method |
US7671861B1 (en) | 2001-11-02 | 2010-03-02 | At&T Intellectual Property Ii, L.P. | Apparatus and method of customizing animated entities for use in a multi-media communication application |
US7663628B2 (en) * | 2002-01-22 | 2010-02-16 | Gizmoz Israel 2002 Ltd. | Apparatus and method for efficient animation of believable speaking 3D characters in real time |
KR20030066841A (en) * | 2002-02-05 | 2003-08-14 | 보람연구소(주) | Avatar agent system |
CA2477187C (en) * | 2002-02-25 | 2011-08-02 | Loma Linda University | System for building interactive calculations on web pages |
US20030167167A1 (en) * | 2002-02-26 | 2003-09-04 | Li Gong | Intelligent personal assistants |
US20030163311A1 (en) * | 2002-02-26 | 2003-08-28 | Li Gong | Intelligent social agents |
US8671213B2 (en) | 2002-03-14 | 2014-03-11 | Citrix Systems, Inc. | Methods and apparatus for generating graphical and media displays at a client |
US7376695B2 (en) | 2002-03-14 | 2008-05-20 | Citrix Systems, Inc. | Method and system for generating a graphical display for a remote terminal session |
US8135843B2 (en) | 2002-03-22 | 2012-03-13 | Citrix Systems, Inc. | Methods and systems for providing access to an application |
AU2003202442B2 (en) * | 2002-03-28 | 2005-11-03 | Canon Kabushiki Kaisha | A Client Server Approach for Interactive Updates of Graphical User Interfaces on Intranets |
AUPS145902A0 (en) * | 2002-03-28 | 2002-05-09 | Canon Kabushiki Kaisha | A client server approach for interactive updates of graphical user interfaces on intranets |
WO2003085511A1 (en) * | 2002-04-09 | 2003-10-16 | Matsushita Electric Industrial Co., Ltd. | Speech providing system, server, client machine, information providing management server, and voice providing method |
US7076430B1 (en) | 2002-05-16 | 2006-07-11 | At&T Corp. | System and method of providing conversational visual prosody for talking heads |
US7219308B2 (en) * | 2002-06-21 | 2007-05-15 | Microsoft Corporation | User interface for media player program |
EP1387302A3 (en) * | 2002-07-31 | 2006-05-24 | Hewlett-Packard Development Company, L.P. | Establishment of network connections |
WO2008156437A1 (en) | 2006-04-10 | 2008-12-24 | Avaworks Incorporated | Do-it-yourself photo realistic talking head creation system and method |
US20050222846A1 (en) * | 2002-11-12 | 2005-10-06 | Christopher Tomes | Character branding employing voice and speech recognition technology |
US7173623B2 (en) * | 2003-05-09 | 2007-02-06 | Microsoft Corporation | System supporting animation of graphical display elements through animation object instances |
US7757182B2 (en) | 2003-06-25 | 2010-07-13 | Microsoft Corporation | Taskbar media player |
US7512884B2 (en) | 2003-06-25 | 2009-03-31 | Microsoft Corporation | System and method for switching of media presentation |
US8264489B2 (en) * | 2003-07-11 | 2012-09-11 | Intel Corporation | Interface remoting |
US7274382B2 (en) * | 2003-07-16 | 2007-09-25 | Plut William J | Customizable background sizes and controls for changing background size |
US7928994B2 (en) | 2003-07-16 | 2011-04-19 | Transpacific Image, Llc | Graphics items that extend outside a background perimeter |
US20050033822A1 (en) * | 2003-08-05 | 2005-02-10 | Grayson George Dale | Method and apparatus for information distribution and retrieval |
US7529674B2 (en) * | 2003-08-18 | 2009-05-05 | Sap Aktiengesellschaft | Speech animation |
US7269794B2 (en) * | 2003-09-11 | 2007-09-11 | International Business Machines Corporation | Method and apparatus for viewpoint collaboration |
US7552450B1 (en) | 2003-09-30 | 2009-06-23 | Microsoft Corporation | Systems and methods for enabling applications via an application programming interface (API) to interface with and configure digital media components |
US8533597B2 (en) * | 2003-09-30 | 2013-09-10 | Microsoft Corporation | Strategies for configuring media processing functionality using a hierarchical ordering of control parameters |
US20050132385A1 (en) * | 2003-10-06 | 2005-06-16 | Mikael Bourges-Sevenier | System and method for creating and executing rich applications on multimedia terminals |
US7593015B2 (en) * | 2003-11-14 | 2009-09-22 | Kyocera Wireless Corp. | System and method for sequencing media objects |
US7500223B2 (en) * | 2004-01-02 | 2009-03-03 | International Business Machines Corporation | Automatically creating JavaScript objects to invoke methods on server-side Java beans |
KR100657065B1 (en) * | 2004-01-29 | 2006-12-13 | 삼성전자주식회사 | Device and method for character processing in wireless terminal |
ATE459902T1 (en) * | 2004-03-06 | 2010-03-15 | Peter Renner | SYSTEM FOR CONTROLLING AND OPERATION TECHNICAL PROCESSES |
US7689543B2 (en) * | 2004-03-11 | 2010-03-30 | International Business Machines Corporation | Search engine providing match and alternative answers using cumulative probability values |
US20050231512A1 (en) * | 2004-04-16 | 2005-10-20 | Niles Gregory E | Animation of an object using behaviors |
US7932909B2 (en) * | 2004-04-16 | 2011-04-26 | Apple Inc. | User interface for controlling three-dimensional animation of an object |
US7388580B2 (en) * | 2004-05-07 | 2008-06-17 | Valve Corporation | Generating eyes for a character in a virtual environment |
WO2005119648A2 (en) * | 2004-06-01 | 2005-12-15 | Dna Digital Media Group | Character branding employing voice and speech recognition technology |
US7672845B2 (en) * | 2004-06-22 | 2010-03-02 | International Business Machines Corporation | Method and system for keyword detection using voice-recognition |
US20060022983A1 (en) * | 2004-07-27 | 2006-02-02 | Alias Systems Corp. | Processing three-dimensional data |
US7411590B1 (en) * | 2004-08-09 | 2008-08-12 | Apple Inc. | Multimedia file format |
US7963847B2 (en) | 2004-08-19 | 2011-06-21 | Igt | Gaming system having multiple gaming machines which provide bonus awards |
US8021230B2 (en) | 2004-08-19 | 2011-09-20 | Igt | Gaming system having multiple gaming machines which provide bonus awards |
US8251791B2 (en) | 2004-08-19 | 2012-08-28 | Igt | Gaming system having multiple gaming machines which provide bonus awards |
US20060041848A1 (en) * | 2004-08-23 | 2006-02-23 | Luigi Lira | Overlaid display of messages in the user interface of instant messaging and other digital communication services |
US7599838B2 (en) | 2004-09-01 | 2009-10-06 | Sap Aktiengesellschaft | Speech animation with behavioral contexts for application scenarios |
US7748032B2 (en) | 2004-09-30 | 2010-06-29 | Citrix Systems, Inc. | Method and apparatus for associating tickets in a ticket hierarchy |
US7711835B2 (en) | 2004-09-30 | 2010-05-04 | Citrix Systems, Inc. | Method and apparatus for reducing disclosure of proprietary data in a networked environment |
US8613048B2 (en) | 2004-09-30 | 2013-12-17 | Citrix Systems, Inc. | Method and apparatus for providing authorized remote access to application sessions |
US8171479B2 (en) | 2004-09-30 | 2012-05-01 | Citrix Systems, Inc. | Method and apparatus for providing an aggregate view of enumerated system resources from various isolation layers |
US8095940B2 (en) | 2005-09-19 | 2012-01-10 | Citrix Systems, Inc. | Method and system for locating and accessing resources |
US7680758B2 (en) | 2004-09-30 | 2010-03-16 | Citrix Systems, Inc. | Method and apparatus for isolating execution of software applications |
EP2113121B1 (en) * | 2004-11-22 | 2018-11-07 | Mario Pirchio | Method to synchronize audio and graphics in a multimedia presentation |
US8340130B2 (en) | 2005-01-14 | 2012-12-25 | Citrix Systems, Inc. | Methods and systems for generating playback instructions for rendering of a recorded computer session |
US8145777B2 (en) | 2005-01-14 | 2012-03-27 | Citrix Systems, Inc. | Method and system for real-time seeking during playback of remote presentation protocols |
US8200828B2 (en) | 2005-01-14 | 2012-06-12 | Citrix Systems, Inc. | Systems and methods for single stack shadowing |
US8935316B2 (en) | 2005-01-14 | 2015-01-13 | Citrix Systems, Inc. | Methods and systems for in-session playback on a local machine of remotely-stored and real time presentation layer protocol data |
US20060159432A1 (en) | 2005-01-14 | 2006-07-20 | Citrix Systems, Inc. | System and methods for automatic time-warped playback in rendering a recorded computer session |
US7831728B2 (en) | 2005-01-14 | 2010-11-09 | Citrix Systems, Inc. | Methods and systems for real-time seeking during real-time playback of a presentation layer protocol data stream |
US8296441B2 (en) | 2005-01-14 | 2012-10-23 | Citrix Systems, Inc. | Methods and systems for joining a real-time session of presentation layer protocol data |
US8024568B2 (en) | 2005-01-28 | 2011-09-20 | Citrix Systems, Inc. | Method and system for verification of an endpoint security scan |
KR100610487B1 (en) * | 2005-02-15 | 2006-08-08 | 주식회사 팬택 | Apparatus and method for picture formation by event in the mobile communication terminal |
US20060184893A1 (en) * | 2005-02-17 | 2006-08-17 | Raymond Chow | Graphics controller providing for enhanced control of window animation |
US20060200355A1 (en) * | 2005-03-01 | 2006-09-07 | Gil Sideman | System and method for a real time client server text to speech interface |
US8171169B2 (en) | 2005-03-14 | 2012-05-01 | Citrix Systems, Inc. | Method and apparatus for updating a graphical display in a distributed processing environment |
US8423673B2 (en) | 2005-03-14 | 2013-04-16 | Citrix Systems, Inc. | Method and apparatus for updating a graphical display in a distributed processing environment using compression |
US7512537B2 (en) * | 2005-03-22 | 2009-03-31 | Microsoft Corporation | NLP tool to dynamically create movies/animated scenes |
US20060277044A1 (en) * | 2005-06-02 | 2006-12-07 | Mckay Martin | Client-based speech enabled web content |
US7973793B2 (en) * | 2005-06-10 | 2011-07-05 | Panasonic Corporation | Scenario generation device, scenario generation method, and scenario generation program |
KR101203847B1 (en) * | 2005-06-30 | 2012-11-21 | 엘지전자 주식회사 | dish washing machine having avatar image processing unit |
US7548859B2 (en) * | 2005-08-03 | 2009-06-16 | Motorola, Inc. | Method and system for assisting users in interacting with multi-modal dialog systems |
US20070035668A1 (en) * | 2005-08-11 | 2007-02-15 | Sony Corporation | Method of routing an audio/video signal from a television's internal tuner to a remote device |
US7753773B2 (en) | 2005-08-26 | 2010-07-13 | Igt | Gaming device having physical concentric symbol generators which are operable to provide a plurality of different games to a player |
US8137188B2 (en) | 2005-09-09 | 2012-03-20 | Igt | Server based gaming system having multiple progressive awards |
US8128491B2 (en) | 2005-09-09 | 2012-03-06 | Igt | Server based gaming system having multiple progressive awards |
US7841939B2 (en) | 2005-09-09 | 2010-11-30 | Igt | Server based gaming system having multiple progressive awards |
US8191008B2 (en) * | 2005-10-03 | 2012-05-29 | Citrix Systems, Inc. | Simulating multi-monitor functionality in a single monitor environment |
US7779034B2 (en) | 2005-10-07 | 2010-08-17 | Citrix Systems, Inc. | Method and system for accessing a remote file in a directory structure associated with an application program executing locally |
US8131825B2 (en) | 2005-10-07 | 2012-03-06 | Citrix Systems, Inc. | Method and a system for responding locally to requests for file metadata associated with files stored remotely |
US7464065B2 (en) * | 2005-11-21 | 2008-12-09 | International Business Machines Corporation | Object specific language extension interface for a multi-level data structure |
US7924884B2 (en) * | 2005-12-20 | 2011-04-12 | Citrix Systems, Inc. | Performance logging using relative differentials and skip recording |
JP2007172716A (en) * | 2005-12-20 | 2007-07-05 | Sony Corp | Apparatus, method and program for play-back, and recording medium and data structure, and apparatus, method and program for authoring |
US7895570B2 (en) * | 2005-12-22 | 2011-02-22 | International Business Machines Corporation | Accessible role and state information in HTML documents |
US20070174429A1 (en) | 2006-01-24 | 2007-07-26 | Citrix Systems, Inc. | Methods and servers for establishing a connection between a client system and a virtual machine hosting a requested computing environment |
US7768543B2 (en) * | 2006-03-09 | 2010-08-03 | Citrix Online, Llc | System and method for dynamically altering videoconference bit rates and layout based on participant activity |
US8769019B2 (en) * | 2006-05-04 | 2014-07-01 | Citrix Systems, Inc. | Methods and systems for managing shared state within a distributed system with varying consistency and consensus semantics |
EP1858005A1 (en) * | 2006-05-19 | 2007-11-21 | Texthelp Systems Limited | Streaming speech with synchronized highlighting generated by a server |
US8010094B2 (en) * | 2006-06-06 | 2011-08-30 | Turner Broadcasting System, Inc. | Mobile device with themed multimedia effects |
US7747445B2 (en) * | 2006-07-12 | 2010-06-29 | Nuance Communications, Inc. | Distinguishing among different types of abstractions consisting of plurality of commands specified by particular sequencing and or timing or no timing and sequencing using voice commands |
US8512130B2 (en) | 2006-07-27 | 2013-08-20 | Igt | Gaming system with linked gaming machines that are configurable to have a same probability of winning a designated award |
US20080027726A1 (en) * | 2006-07-28 | 2008-01-31 | Eric Louis Hansen | Text to audio mapping, and animation of the text |
US20100030557A1 (en) * | 2006-07-31 | 2010-02-04 | Stephen Molloy | Voice and text communication system, method and apparatus |
US20080055316A1 (en) * | 2006-08-30 | 2008-03-06 | Microsoft Corporation | Programmatically representing sentence meaning with animation |
US7791559B2 (en) * | 2006-09-14 | 2010-09-07 | Citrix Systems, Inc. | System and method for multiple display support in remote access software |
US8054241B2 (en) * | 2006-09-14 | 2011-11-08 | Citrix Systems, Inc. | Systems and methods for multiple display support in remote access software |
US8616959B2 (en) | 2006-09-27 | 2013-12-31 | Igt | Server based gaming system having system triggered loyalty award sequences |
US7862430B2 (en) | 2006-09-27 | 2011-01-04 | Igt | Server based gaming system having system triggered loyalty award sequences |
US7674180B2 (en) | 2006-09-27 | 2010-03-09 | Igt | Server based gaming system having system triggered loyalty award sequences |
JP4858059B2 (en) * | 2006-10-02 | 2012-01-18 | ソニー株式会社 | Playback device, display control method, and display control program |
JP5034424B2 (en) * | 2006-10-11 | 2012-09-26 | ソニー株式会社 | Playback apparatus and playback method |
US8073681B2 (en) | 2006-10-16 | 2011-12-06 | Voicebox Technologies, Inc. | System and method for a cooperative conversational voice user interface |
US20080126095A1 (en) * | 2006-10-27 | 2008-05-29 | Gil Sideman | System and method for adding functionality to a user interface playback environment |
US8533846B2 (en) | 2006-11-08 | 2013-09-10 | Citrix Systems, Inc. | Method and system for dynamically associating access rights with a resource |
US20080183678A1 (en) * | 2006-12-29 | 2008-07-31 | Denise Chapman Weston | Systems and methods for personalizing responses to user requests |
US20080159274A1 (en) * | 2006-12-29 | 2008-07-03 | Brugman David L | Method and apparatus for improved routing necessitated by network element replacement |
US8656311B1 (en) | 2007-01-07 | 2014-02-18 | Apple Inc. | Method and apparatus for compositing various types of content |
US7872652B2 (en) * | 2007-01-07 | 2011-01-18 | Apple Inc. | Application programming interfaces for synchronization |
US20080168478A1 (en) | 2007-01-07 | 2008-07-10 | Andrew Platzer | Application Programming Interfaces for Scrolling |
US20080168402A1 (en) | 2007-01-07 | 2008-07-10 | Christopher Blumenberg | Application Programming Interfaces for Gesture Operations |
US7903115B2 (en) | 2007-01-07 | 2011-03-08 | Apple Inc. | Animations |
US7844915B2 (en) | 2007-01-07 | 2010-11-30 | Apple Inc. | Application programming interfaces for scrolling operations |
US8813100B1 (en) | 2007-01-07 | 2014-08-19 | Apple Inc. | Memory management |
US7818176B2 (en) | 2007-02-06 | 2010-10-19 | Voicebox Technologies, Inc. | System and method for selecting and presenting advertisements based on natural language processing of voice-based input |
US8315652B2 (en) | 2007-05-18 | 2012-11-20 | Immersion Corporation | Haptically enabled messaging |
US7962344B2 (en) * | 2007-06-29 | 2011-06-14 | Microsoft Corporation | Depicting a speech user interface via graphical elements |
US8346206B1 (en) | 2007-07-23 | 2013-01-01 | At&T Mobility Ii Llc | Customizable media feedback software package and methods of generating and installing the package |
US7985133B2 (en) | 2007-07-30 | 2011-07-26 | Igt | Gaming system and method for providing an additional gaming currency |
US8900053B2 (en) | 2007-08-10 | 2014-12-02 | Igt | Gaming system and method for providing different bonus awards based on different types of triggered events |
US8171483B2 (en) | 2007-10-20 | 2012-05-01 | Citrix Systems, Inc. | Method and system for communicating between isolation environments |
US9142097B2 (en) | 2007-10-26 | 2015-09-22 | Igt | Gaming system and method for providing play of local first game and remote second game |
CA2708344A1 (en) * | 2007-12-10 | 2009-06-18 | 4419341 Canada Inc. | Method and system for the creation of a personalized video |
US8140335B2 (en) | 2007-12-11 | 2012-03-20 | Voicebox Technologies, Inc. | System and method for providing a natural language voice user interface in an integrated voice navigation services environment |
EP2293192B1 (en) | 2008-01-27 | 2021-03-31 | Citrix Systems, Inc. | Methods and systems for remoting three dimensional graphics |
JP2011512582A (en) * | 2008-02-12 | 2011-04-21 | フーモジョ,インク. | Network distribution of interactive 3D animated characters |
US8645827B2 (en) | 2008-03-04 | 2014-02-04 | Apple Inc. | Touch event model |
US8174502B2 (en) | 2008-03-04 | 2012-05-08 | Apple Inc. | Touch event processing for web pages |
US8717305B2 (en) * | 2008-03-04 | 2014-05-06 | Apple Inc. | Touch event model for web pages |
US8416196B2 (en) * | 2008-03-04 | 2013-04-09 | Apple Inc. | Touch event model programming interface |
US9305548B2 (en) | 2008-05-27 | 2016-04-05 | Voicebox Technologies Corporation | System and method for an integrated, multi-modal, multi-device natural language voice services environment |
US8812809B2 (en) | 2008-06-10 | 2014-08-19 | Oracle America, Inc. | Method and apparatus for allocating memory for immutable data on a computing device |
US20100073379A1 (en) * | 2008-09-24 | 2010-03-25 | Sadan Eray Berger | Method and system for rendering real-time sprites |
US8823793B2 (en) * | 2008-11-10 | 2014-09-02 | At&T Intellectual Property I, L.P. | System and method for performing security tasks |
KR101515859B1 (en) * | 2008-12-05 | 2015-05-06 | 삼성전자 주식회사 | Display apparatus and display method of contents list thereof |
US8654134B2 (en) | 2008-12-08 | 2014-02-18 | Microsoft Corporation | Command remoting |
US8326637B2 (en) | 2009-02-20 | 2012-12-04 | Voicebox Technologies, Inc. | System and method for processing multi-modal device interactions in a natural language voice services environment |
US20100231582A1 (en) * | 2009-03-10 | 2010-09-16 | Yogurt Bilgi Teknolojileri A.S. | Method and system for distributing animation sequences of 3d objects |
US8285499B2 (en) | 2009-03-16 | 2012-10-09 | Apple Inc. | Event recognition |
US8566045B2 (en) | 2009-03-16 | 2013-10-22 | Apple Inc. | Event recognition |
US9684521B2 (en) | 2010-01-26 | 2017-06-20 | Apple Inc. | Systems having discrete and continuous gesture recognizers |
US8566044B2 (en) * | 2009-03-16 | 2013-10-22 | Apple Inc. | Event recognition |
US9311112B2 (en) | 2009-03-16 | 2016-04-12 | Apple Inc. | Event recognition |
US8090797B2 (en) | 2009-05-02 | 2012-01-03 | Citrix Systems, Inc. | Methods and systems for launching applications into existing isolation environments |
US9190110B2 (en) | 2009-05-12 | 2015-11-17 | JBF Interlude 2009 LTD | System and method for assembling a recorded composition |
US9039516B2 (en) | 2009-07-30 | 2015-05-26 | Igt | Concurrent play on multiple gaming machines |
CA2686995A1 (en) * | 2009-12-03 | 2011-06-03 | Ibm Canada Limited - Ibm Canada Limitee | Handling user-interface gestures in non-rectangular regions |
US8558913B2 (en) * | 2010-02-08 | 2013-10-15 | Apple Inc. | Capture condition selection from brightness and motion |
US11232458B2 (en) | 2010-02-17 | 2022-01-25 | JBF Interlude 2009 LTD | System and method for data mining within interactive multimedia |
EP2363055A1 (en) | 2010-03-01 | 2011-09-07 | Electrolux Home Products Corporation N.V. | Projector and household appliance comprising such a projector |
US8552999B2 (en) | 2010-06-14 | 2013-10-08 | Apple Inc. | Control selection approximation |
CA2711874C (en) | 2010-08-26 | 2011-05-31 | Microsoft Corporation | Aligning animation state update and frame composition |
US8751228B2 (en) * | 2010-11-04 | 2014-06-10 | Microsoft Corporation | Minimum converted trajectory error (MCTE) audio-to-video engine |
US9298363B2 (en) | 2011-04-11 | 2016-03-29 | Apple Inc. | Region activation for touch sensitive surface |
US8615159B2 (en) | 2011-09-20 | 2013-12-24 | Citrix Systems, Inc. | Methods and systems for cataloging text in a recorded session |
US9240180B2 (en) * | 2011-12-01 | 2016-01-19 | At&T Intellectual Property I, L.P. | System and method for low-latency web-based text-to-speech without plugins |
US20140067399A1 (en) * | 2012-06-22 | 2014-03-06 | Matopy Limited | Method and system for reproduction of digital content |
US9384736B2 (en) * | 2012-08-21 | 2016-07-05 | Nuance Communications, Inc. | Method to provide incremental UI response based on multiple asynchronous evidence about user input |
US9733716B2 (en) | 2013-06-09 | 2017-08-15 | Apple Inc. | Proxy gesture recognizer |
GB2517212B (en) | 2013-08-16 | 2018-04-25 | Toshiba Res Europe Limited | A Computer Generated Emulation of a subject |
US9653115B2 (en) * | 2014-04-10 | 2017-05-16 | JBF Interlude 2009 LTD | Systems and methods for creating linear video from branched video |
US9569062B2 (en) * | 2014-05-21 | 2017-02-14 | Facebook, Inc. | Asynchronous execution of animation tasks for a GUI |
US9875080B2 (en) | 2014-07-17 | 2018-01-23 | Nokia Technologies Oy | Method and apparatus for an interactive user interface |
US9875618B2 (en) | 2014-07-24 | 2018-01-23 | Igt | Gaming system and method employing multi-directional interaction between multiple concurrently played games |
US9953646B2 (en) | 2014-09-02 | 2018-04-24 | Belleau Technologies | Method and system for dynamic speech recognition and tracking of prewritten script |
US9898459B2 (en) | 2014-09-16 | 2018-02-20 | Voicebox Technologies Corporation | Integration of domain information into state transitions of a finite state transducer for natural language processing |
WO2016044290A1 (en) | 2014-09-16 | 2016-03-24 | Kennewick Michael R | Voice commerce |
US9792957B2 (en) | 2014-10-08 | 2017-10-17 | JBF Interlude 2009 LTD | Systems and methods for dynamic video bookmarking |
EP3207467A4 (en) | 2014-10-15 | 2018-05-23 | VoiceBox Technologies Corporation | System and method for providing follow-up responses to prior natural language inputs of a user |
US9659564B2 (en) * | 2014-10-24 | 2017-05-23 | Sestek Ses Ve Iletisim Bilgisayar Teknolojileri Sanayi Ticaret Anonim Sirketi | Speaker verification based on acoustic behavioral characteristics of the speaker |
US10431214B2 (en) | 2014-11-26 | 2019-10-01 | Voicebox Technologies Corporation | System and method of determining a domain and/or an action related to a natural language input |
US10614799B2 (en) | 2014-11-26 | 2020-04-07 | Voicebox Technologies Corporation | System and method of providing intent predictions for an utterance prior to a system detection of an end of the utterance |
US10460765B2 (en) | 2015-08-26 | 2019-10-29 | JBF Interlude 2009 LTD | Systems and methods for adaptive and responsive video |
US9972171B2 (en) | 2015-09-24 | 2018-05-15 | Igt | Gaming system and method for providing a triggering event based on a collection of units from different games |
WO2017075452A1 (en) * | 2015-10-29 | 2017-05-04 | True Image Interactive, Inc | Systems and methods for machine-generated avatars |
US11856271B2 (en) | 2016-04-12 | 2023-12-26 | JBF Interlude 2009 LTD | Symbiotic interactive video |
US10331784B2 (en) | 2016-07-29 | 2019-06-25 | Voicebox Technologies Corporation | System and method of disambiguating natural language processing requests |
US20180089879A1 (en) | 2016-09-23 | 2018-03-29 | Apple Inc. | Synchronizing Display of Multiple Animations |
US11050809B2 (en) | 2016-12-30 | 2021-06-29 | JBF Interlude 2009 LTD | Systems and methods for dynamic weighting of branched video paths |
US10217260B1 (en) * | 2017-08-16 | 2019-02-26 | Td Ameritrade Ip Company, Inc. | Real-time lip synchronization animation |
US10770092B1 (en) * | 2017-09-22 | 2020-09-08 | Amazon Technologies, Inc. | Viseme data generation |
US10257578B1 (en) | 2018-01-05 | 2019-04-09 | JBF Interlude 2009 LTD | Dynamic library display for interactive videos |
US20190213269A1 (en) * | 2018-01-10 | 2019-07-11 | Amojee, Inc. | Interactive animated gifs and other interactive images |
US11601721B2 (en) | 2018-06-04 | 2023-03-07 | JBF Interlude 2009 LTD | Interactive video dynamic adaptation and user profiling |
KR102116315B1 (en) * | 2018-12-17 | 2020-05-28 | 주식회사 인공지능연구원 | System for synchronizing voice and motion of character |
US11490047B2 (en) | 2019-10-02 | 2022-11-01 | JBF Interlude 2009 LTD | Systems and methods for dynamically adjusting video aspect ratios |
US10805665B1 (en) | 2019-12-13 | 2020-10-13 | Bank Of America Corporation | Synchronizing text-to-audio with interactive videos in the video framework |
US11350185B2 (en) * | 2019-12-13 | 2022-05-31 | Bank Of America Corporation | Text-to-audio for interactive videos using a markup language |
US11245961B2 (en) | 2020-02-18 | 2022-02-08 | JBF Interlude 2009 LTD | System and methods for detecting anomalous activities for interactive videos |
US11882337B2 (en) | 2021-05-28 | 2024-01-23 | JBF Interlude 2009 LTD | Automated platform for generating interactive videos |
US11934477B2 (en) | 2021-09-24 | 2024-03-19 | JBF Interlude 2009 LTD | Video player integration within websites |
CN115035218B (en) * | 2022-08-11 | 2022-11-01 | 湖南湘生网络信息有限公司 | Interactive animation production method and device, computer equipment and storage medium |
Family Cites Families (12)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US4884972A (en) * | 1986-11-26 | 1989-12-05 | Bright Star Technology, Inc. | Speech synchronized animation |
US5111409A (en) * | 1989-07-21 | 1992-05-05 | Elon Gasper | Authoring and use systems for sound synchronized animation |
US5278943A (en) * | 1990-03-23 | 1994-01-11 | Bright Star Technology, Inc. | Speech animation and inflection system |
US5287446A (en) * | 1990-10-15 | 1994-02-15 | Sierra On-Line, Inc. | System and methods for intelligent movement on computer displays |
US5430835A (en) * | 1991-02-15 | 1995-07-04 | Sierra On-Line, Inc. | Method and means for computer sychronization of actions and sounds |
US5689618A (en) * | 1991-02-19 | 1997-11-18 | Bright Star Technology, Inc. | Advanced tools for speech synchronized animation |
US5377997A (en) * | 1992-09-22 | 1995-01-03 | Sierra On-Line, Inc. | Method and apparatus for relating messages and actions in interactive computer games |
US5465362A (en) * | 1993-12-30 | 1995-11-07 | Taligent, Inc. | Object-oriented view-system for displaying information in a windowing environment |
US5715416A (en) * | 1994-09-30 | 1998-02-03 | Baker; Michelle | User definable pictorial interface for a accessing information in an electronic file system |
CA2202614A1 (en) * | 1994-10-25 | 1996-05-02 | Taligent, Inc. | Object-oriented system for servicing windows |
US5764241A (en) * | 1995-11-30 | 1998-06-09 | Microsoft Corporation | Method and system for modeling and presenting integrated media with a declarative modeling language for representing reactive behavior |
US5867175A (en) * | 1996-05-24 | 1999-02-02 | Microsoft Corporation | Method and apparatus for scriping animation |
-
1997
- 1997-05-19 US US08/858,648 patent/US5983190A/en not_active Expired - Lifetime
-
1998
- 1998-02-26 US US09/031,144 patent/US6369821B2/en not_active Expired - Lifetime
Cited By (146)
Publication number | Priority date | Publication date | Assignee | Title |
---|---|---|---|---|
US7817158B1 (en) * | 1998-10-23 | 2010-10-19 | Autodesk, Inc. | Specifying operations to be applied to the attributes of a set of objects |
US20020057372A1 (en) * | 1998-11-13 | 2002-05-16 | Philips Electronics North America Corporation | Method and device for detecting an event in a program of a video and/or audio signal and for providing the program to a display upon detection of the event |
US7124365B2 (en) * | 1998-11-13 | 2006-10-17 | Koninklijke Philips Electronics N.V. | Method and device for detecting an event in a program of a video and/or audio signal and for providing the program to a display upon detection of the event |
US20090184967A1 (en) * | 1999-05-21 | 2009-07-23 | Kulas Charles J | Script control for lip animation in a scene generated by a computer rendering engine |
US8717359B2 (en) | 1999-05-21 | 2014-05-06 | Quonsil Pl. 3, Llc | Script control for camera positioning in a scene generated by a computer rendering engine |
US8674996B2 (en) * | 1999-05-21 | 2014-03-18 | Quonsil Pl. 3, Llc | Script control for lip animation in a scene generated by a computer rendering engine |
US20090189989A1 (en) * | 1999-05-21 | 2009-07-30 | Kulas Charles J | Script control for camera positioning in a scene generated by a computer rendering engine |
US6690376B1 (en) * | 1999-09-29 | 2004-02-10 | Sega Enterprises, Ltd. | Storage medium for storing animation data, image processing method using same, and storage medium storing image processing programs |
US20050052462A1 (en) * | 2000-03-17 | 2005-03-10 | Kiyomi Sakamoto | Map display device and navigation device |
US20010026276A1 (en) * | 2000-03-17 | 2001-10-04 | Kiyomi Sakamoto | Map display device and navigation device |
US20060080440A1 (en) * | 2000-05-12 | 2006-04-13 | Microsoft Corporation | Authentication and authorization pipeline architecture for use in a server |
US7266605B2 (en) | 2000-05-12 | 2007-09-04 | Microsoft Corporation | Authentication and authorization pipeline architecture for use in a server |
US6985946B1 (en) | 2000-05-12 | 2006-01-10 | Microsoft Corporation | Authentication and authorization pipeline architecture for use in a web server |
US8689238B2 (en) | 2000-05-18 | 2014-04-01 | Carhamm Ltd., Llc | Techniques for displaying impressions in documents delivered over a computer network |
US6961750B1 (en) | 2000-05-18 | 2005-11-01 | Microsoft Corp. | Server-side control objects for processing client-side user interface elements |
US6757900B1 (en) | 2000-05-18 | 2004-06-29 | Microsoft Corporation | State management of server-side control objects |
US20060004910A1 (en) * | 2000-05-18 | 2006-01-05 | Microsoft Corporation | Postback input handling by server-side control objects |
US6792607B1 (en) | 2000-05-18 | 2004-09-14 | Microsoft Corporation | Databinding using server-side control objects |
US6990653B1 (en) * | 2000-05-18 | 2006-01-24 | Microsoft Corporation | Server-side code generation from a dynamic web page content file |
US20110072109A1 (en) * | 2000-07-12 | 2011-03-24 | Treehouse Solutions, Inc. | Method and system for presenting data over a network based on network user choices and collecting real-time data related to said choices |
US8180858B2 (en) * | 2000-07-12 | 2012-05-15 | Treehouse Avatar Technologies Inc. | Method and system for presenting data over a network based on network user choices and collecting real-time data related to said choices |
US20020041289A1 (en) * | 2000-08-21 | 2002-04-11 | Hatch John D. | Method and apparatus for producing functionality and user interfaces for devices having an embedded operating system |
US20020101431A1 (en) * | 2000-09-15 | 2002-08-01 | Forney Paul W. | Method and system for animating graphical user interface elements via a manufacturing/process control portal server |
US20100238181A1 (en) * | 2000-09-15 | 2010-09-23 | Invensys Systems, Inc. | Method And System For Animating Graphical User Interface Elements Via A Manufacturing/Process Control Portal Server |
US7728838B2 (en) * | 2000-09-15 | 2010-06-01 | Invensys Systems, Inc. | Method and system for animating graphical user interface elements via a manufacturing/process control portal server |
US7973794B2 (en) * | 2000-09-15 | 2011-07-05 | Invensys Systems, Inc. | Method and system for animating graphical user interface elements via a manufacturing/process control portal server |
US20020049805A1 (en) * | 2000-10-24 | 2002-04-25 | Sanyo Electric Co., Ltd. | User support apparatus and system using agents |
US6922670B2 (en) * | 2000-10-24 | 2005-07-26 | Sanyo Electric Co., Ltd. | User support apparatus and system using agents |
US20020062386A1 (en) * | 2000-11-01 | 2002-05-23 | Christopher Piche | Method and apparatus for improving real time and/or interactive animation over a computer network |
US20040038737A1 (en) * | 2000-11-01 | 2004-02-26 | Christopher Piche | Method and apparatus for improving real time and/or interactive animation over a computer network |
US20020133635A1 (en) * | 2001-03-16 | 2002-09-19 | Microsoft Corporation | Method and system for interacting with devices having different capabilities |
US20060005149A1 (en) * | 2001-04-20 | 2006-01-05 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US7689937B2 (en) * | 2001-04-20 | 2010-03-30 | Microsoft Corporation | Method and system for displaying categorized information on a user interface |
US20050193097A1 (en) * | 2001-06-06 | 2005-09-01 | Microsoft Corporation | Providing remote processing services over a distributed communications network |
US7640495B2 (en) | 2001-06-29 | 2009-12-29 | Microsoft Corporation | XML serialization and deserialization |
US20050144622A1 (en) * | 2001-06-29 | 2005-06-30 | Microsoft Corporation | XML serialization and deserialization |
US6898604B1 (en) | 2001-06-29 | 2005-05-24 | Microsoft Corporation | XML serialization and deserialization |
US7594001B1 (en) | 2001-07-06 | 2009-09-22 | Microsoft Corporation | Partial page output caching |
US20030025728A1 (en) * | 2001-07-10 | 2003-02-06 | Ebbo David S. | User control objects for providing server-side code generation from a user-defined dynamic web page content file |
US7120897B2 (en) | 2001-07-10 | 2006-10-10 | Microsoft Corporation | User control objects for providing server-side code generation from a user-defined dynamic web page content file |
US8521827B2 (en) | 2001-10-18 | 2013-08-27 | Carhamm Ltd., Llc | Presentation of information to end-users |
US20030145060A1 (en) * | 2001-10-18 | 2003-07-31 | Martin Anthony G. | Presentation of information to end-users |
US7447986B2 (en) * | 2002-02-26 | 2008-11-04 | Yamaha Corporation | Multimedia information encoding apparatus, multimedia information reproducing apparatus, multimedia information encoding process program, multimedia information reproducing process program, and multimedia encoded data |
US20030161425A1 (en) * | 2002-02-26 | 2003-08-28 | Yamaha Corporation | Multimedia information encoding apparatus, multimedia information reproducing apparatus, multimedia information encoding process program, multimedia information reproducing process program, and multimedia encoded data |
US20060242587A1 (en) * | 2002-05-21 | 2006-10-26 | Eagle Scott G | Method and apparatus for displaying messages in computer systems |
US20030233477A1 (en) * | 2002-06-17 | 2003-12-18 | Microsoft Corporation | Extensible infrastructure for manipulating messages communicated over a distributed network |
US20080120387A1 (en) * | 2002-07-29 | 2008-05-22 | Werndorfer Scott M | System and method for managing contacts in an instant messaging environment |
US7275215B2 (en) | 2002-07-29 | 2007-09-25 | Cerulean Studios, Llc | System and method for managing contacts in an instant messaging environment |
US20040017396A1 (en) * | 2002-07-29 | 2004-01-29 | Werndorfer Scott M. | System and method for managing contacts in an instant messaging environment |
US20080021970A1 (en) * | 2002-07-29 | 2008-01-24 | Werndorfer Scott M | System and method for managing contacts in an instant messaging environment |
US7631266B2 (en) | 2002-07-29 | 2009-12-08 | Cerulean Studios, Llc | System and method for managing contacts in an instant messaging environment |
US20040024822A1 (en) * | 2002-08-01 | 2004-02-05 | Werndorfer Scott M. | Apparatus and method for generating audio and graphical animations in an instant messaging environment |
US20040073873A1 (en) * | 2002-10-11 | 2004-04-15 | Microsoft Corporation | Adaptive image formatting control |
US8316003B2 (en) | 2002-11-05 | 2012-11-20 | Carhamm Ltd., Llc | Updating content of presentation vehicle in a computer network |
US20040148337A1 (en) * | 2002-12-02 | 2004-07-29 | Duncan Ross W. | System and method for enabling communication between a web browser and a software agent infrastructure |
EP1426883A3 (en) * | 2002-12-02 | 2005-09-28 | Ncr International Inc. | A system and method for enabling communication between a web browser and a software agent infrastructure |
US20040189644A1 (en) * | 2003-03-25 | 2004-09-30 | Frisken Sarah F. | Method for animating two-dimensional objects |
US7176926B2 (en) * | 2003-03-25 | 2007-02-13 | Mitsubishi Electric Research Laboratories, Inc. | Method for animating two-dimensional objects |
US20040205830A1 (en) * | 2003-04-10 | 2004-10-14 | Microsoft Corporation | Synchronization mechanism and the implementation for multimedia captioning and audio descriptions |
US7676737B2 (en) * | 2003-04-10 | 2010-03-09 | Microsoft Corporation | Synchronization mechanism and the implementation for multimedia captioning and audio descriptions |
US20040230410A1 (en) * | 2003-05-13 | 2004-11-18 | Harless William G. | Method and system for simulated interactive conversation |
US7797146B2 (en) * | 2003-05-13 | 2010-09-14 | Interactive Drama, Inc. | Method and system for simulated interactive conversation |
US20050091230A1 (en) * | 2003-10-24 | 2005-04-28 | Ebbo David S. | Software build extensibility |
US20050219255A1 (en) * | 2004-03-30 | 2005-10-06 | Hung-Yi Lin | User interface display apparatus using texture mapping method |
US7038695B2 (en) * | 2004-03-30 | 2006-05-02 | Mstar Semiconductor, Inc. | User interface display apparatus using texture mapping method |
US7890604B2 (en) | 2004-05-07 | 2011-02-15 | Microsoft Corproation | Client-side callbacks to server events |
US20050256933A1 (en) * | 2004-05-07 | 2005-11-17 | Millington Bradley D | Client-side callbacks to server events |
US20050251380A1 (en) * | 2004-05-10 | 2005-11-10 | Simon Calvert | Designer regions and Interactive control designers |
US9026578B2 (en) | 2004-05-14 | 2015-05-05 | Microsoft Corporation | Systems and methods for persisting data between web pages |
US8065600B2 (en) | 2004-05-14 | 2011-11-22 | Microsoft Corporation | Systems and methods for defining web content navigation |
US20050256924A1 (en) * | 2004-05-14 | 2005-11-17 | Microsoft Corporation | Systems and methods for persisting data between web pages |
US20050256834A1 (en) * | 2004-05-17 | 2005-11-17 | Microsoft Corporation | Data controls architecture |
US20050268292A1 (en) * | 2004-05-28 | 2005-12-01 | Microsoft Corporation | Non-compile pages |
US8156448B2 (en) | 2004-05-28 | 2012-04-10 | Microsoft Corporation | Site navigation and site navigation data source |
US20060020883A1 (en) * | 2004-05-28 | 2006-01-26 | Microsoft Corporation | Web page personalization |
US20050278351A1 (en) * | 2004-05-28 | 2005-12-15 | Microsoft Corporation | Site navigation and site navigation data source |
US8255413B2 (en) | 2004-08-19 | 2012-08-28 | Carhamm Ltd., Llc | Method and apparatus for responding to request for information-personalization |
US20060041550A1 (en) * | 2004-08-19 | 2006-02-23 | Claria Corporation | Method and apparatus for responding to end-user request for information-personalization |
US20060085515A1 (en) * | 2004-10-14 | 2006-04-20 | Kevin Kurtz | Advanced text analysis and supplemental content processing in an instant messaging environment |
US20060085541A1 (en) * | 2004-10-19 | 2006-04-20 | International Business Machines Corporation | Facilitating optimization of response time in computer networks |
US20060109273A1 (en) * | 2004-11-19 | 2006-05-25 | Rams Joaquin S | Real-time multi-media information and communications system |
US20060136378A1 (en) * | 2004-12-17 | 2006-06-22 | Claria Corporation | Search engine for a computer network |
US8078602B2 (en) | 2004-12-17 | 2011-12-13 | Claria Innovations, Llc | Search engine for a computer network |
US20100306053A1 (en) * | 2004-12-20 | 2010-12-02 | Anthony Martin | Method and Device for Publishing Cross-Network User Behavioral Data |
US9495446B2 (en) | 2004-12-20 | 2016-11-15 | Gula Consulting Limited Liability Company | Method and device for publishing cross-network user behavioral data |
US20060253432A1 (en) * | 2005-03-17 | 2006-11-09 | Claria Corporation | Method for providing content to an internet user based on the user's demonstrated content preferences |
US8073866B2 (en) | 2005-03-17 | 2011-12-06 | Claria Innovations, Llc | Method for providing content to an internet user based on the user's demonstrated content preferences |
US20060233520A1 (en) * | 2005-04-18 | 2006-10-19 | Lg Electronics Inc. | Method for transmitting and receiving graphic data between an image display apparatus and an external apparatus, and information frame structure including information on the graphic data |
US20060274069A1 (en) * | 2005-06-07 | 2006-12-07 | Gordon Patricia L | Three dimensional animated figures |
US7508393B2 (en) * | 2005-06-07 | 2009-03-24 | Gordon Patricia L | Three dimensional animated figures |
US20060293957A1 (en) * | 2005-06-28 | 2006-12-28 | Claria Corporation | Method for providing advertising content to an internet user based on the user's demonstrated content preferences |
US20060294226A1 (en) * | 2005-06-28 | 2006-12-28 | Goulden David L | Techniques for displaying impressions in documents delivered over a computer network |
US20070005791A1 (en) * | 2005-06-28 | 2007-01-04 | Claria Corporation | Method and system for controlling and adapting media stream |
US20070005425A1 (en) * | 2005-06-28 | 2007-01-04 | Claria Corporation | Method and system for predicting consumer behavior |
US8086697B2 (en) | 2005-06-28 | 2011-12-27 | Claria Innovations, Llc | Techniques for displaying impressions in documents delivered over a computer network |
US10162951B2 (en) | 2006-02-23 | 2018-12-25 | Microsoft Technology Licensing, Llc | Non-intrusive background synchronization when authentication is required |
US7876333B2 (en) * | 2006-03-30 | 2011-01-25 | Smart Technologies Ulc | Method and graphical interface for embedding animated content into a computer application |
US20070229542A1 (en) * | 2006-03-30 | 2007-10-04 | Taco Van Ieperen | Method and graphical interface for embedding animated content into a computer application |
US8860752B2 (en) * | 2006-07-13 | 2014-10-14 | Apple Inc. | Multimedia scripting |
US20080016491A1 (en) * | 2006-07-13 | 2008-01-17 | Apple Computer, Inc | Multimedia scripting |
US8640248B2 (en) | 2006-08-31 | 2014-01-28 | The Invention Science Fund I, Llc | Handling masquerading elements |
US8555396B2 (en) * | 2006-08-31 | 2013-10-08 | The Invention Science Fund I, Llc | Authenticatable displayed content |
US9747426B2 (en) | 2006-08-31 | 2017-08-29 | Invention Science Fund I, Llc | Handling masquerading elements |
US20080059801A1 (en) * | 2006-08-31 | 2008-03-06 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Authenticatable displayed content |
US20080059802A1 (en) * | 2006-08-31 | 2008-03-06 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Screening for masquerading content |
US20080072286A1 (en) * | 2006-08-31 | 2008-03-20 | Searete Llc, A Limited Liability Corporation Of The State Of Delaware | Handling masquerading elements |
US8327155B2 (en) | 2006-08-31 | 2012-12-04 | The Invention Science Fund I, Llc | Screening for masquerading content |
USRE46758E1 (en) * | 2007-09-04 | 2018-03-20 | Apple Inc. | Animation of graphical objects |
US20090125813A1 (en) * | 2007-11-09 | 2009-05-14 | Zhongnan Shen | Method and system for processing multiple dialog sessions in parallel |
US20090315896A1 (en) * | 2008-06-24 | 2009-12-24 | Microsoft Corporation | Animation platform |
US20100182331A1 (en) * | 2009-01-16 | 2010-07-22 | Samsung Electronics Co., Ltd. | Method and apparatus for drawing image |
US8976187B2 (en) * | 2009-04-01 | 2015-03-10 | 2236008 Ontario, Inc. | System for accelerating composite graphics rendering |
US20100253693A1 (en) * | 2009-04-01 | 2010-10-07 | Qnx Software Systems Gmbh & Co. Kg | System for accelerating composite graphics rendering |
US20120026174A1 (en) * | 2009-04-27 | 2012-02-02 | Sonoma Data Solution, Llc | Method and Apparatus for Character Animation |
US20100299682A1 (en) * | 2009-05-21 | 2010-11-25 | Samsung Electronics Co., Ltd. | Method and apparatus for executing java application |
KR101698484B1 (en) | 2009-05-21 | 2017-01-20 | 삼성전자 주식회사 | Method and apparatus for performing JAVA application |
KR20100125672A (en) * | 2009-05-21 | 2010-12-01 | 삼성전자주식회사 | Method and apparatus for performing java application |
US20110096076A1 (en) * | 2009-10-27 | 2011-04-28 | Microsoft Corporation | Application program interface for animation |
US20110119582A1 (en) * | 2009-11-17 | 2011-05-19 | Samsung Electronics Co., Ltd. | Method and system for rendering multiple hospitality services to a user via a virtual platform field |
CN103098098A (en) * | 2010-03-30 | 2013-05-08 | 三菱电机株式会社 | Animation display device |
US20110298787A1 (en) * | 2010-06-02 | 2011-12-08 | Daniel Feies | Layer composition, rendering, and animation using multiple execution threads |
CN102339474A (en) * | 2010-06-02 | 2012-02-01 | 微软公司 | Layer composition, rendering, and animation using multiple execution threads |
US20120030612A1 (en) * | 2010-07-30 | 2012-02-02 | Sap Ag | Dynamic property attributes |
CN102929491A (en) * | 2011-11-14 | 2013-02-13 | 微软公司 | Cross-window animation |
US20130120444A1 (en) * | 2011-11-14 | 2013-05-16 | Microsoft Corporation | Cross window animation |
US9135022B2 (en) * | 2011-11-14 | 2015-09-15 | Microsoft Technology Licensing, Llc | Cross window animation |
KR102118223B1 (en) | 2011-11-14 | 2020-06-02 | 마이크로소프트 테크놀로지 라이센싱, 엘엘씨 | Cross window animation |
KR20140094540A (en) * | 2011-11-14 | 2014-07-30 | 마이크로소프트 코포레이션 | Cross window animation |
EP2780786A4 (en) * | 2011-11-14 | 2015-09-09 | Microsoft Technology Licensing Llc | Cross window animation |
US20160050253A1 (en) * | 2012-03-23 | 2016-02-18 | Google Inc. | Asynchronous Message Passing |
US9128702B2 (en) * | 2012-03-23 | 2015-09-08 | Google Inc. | Asynchronous message passing |
US10425463B2 (en) * | 2012-03-23 | 2019-09-24 | Google Llc | Asynchronous message passing |
US9934263B1 (en) * | 2012-12-04 | 2018-04-03 | Pivotal Software, Inc. | Big-fast data connector between in-memory database system and data warehouse system |
US9195940B2 (en) * | 2013-03-15 | 2015-11-24 | Yahoo! Inc. | Jabba-type override for correcting or improving output of a model |
US20140279743A1 (en) * | 2013-03-15 | 2014-09-18 | Yahoo! Inc. | Jabba-type override for correcting or improving output of a model |
US9977661B2 (en) * | 2013-06-28 | 2018-05-22 | Tencent Technology (Shenzhen) Company Limited | Method and system for generating a user interface |
US10228828B2 (en) | 2013-08-12 | 2019-03-12 | Home Box Office, Inc. | Coordinating user interface elements across screen spaces |
US9864490B2 (en) * | 2013-08-12 | 2018-01-09 | Home Box Office, Inc. | Coordinating user interface elements across screen spaces |
US20150046852A1 (en) * | 2013-08-12 | 2015-02-12 | Home Box Office, Inc. | Coordinating user interface elements across screen spaces |
US10033747B1 (en) * | 2015-09-29 | 2018-07-24 | Fireeye, Inc. | System and method for detecting interpreter-based exploit attacks |
US10887328B1 (en) | 2015-09-29 | 2021-01-05 | Fireeye, Inc. | System and method for detecting interpreter-based exploit attacks |
US20190268249A1 (en) * | 2016-11-04 | 2019-08-29 | Google Llc | Systems and methods for measuring media performance on end-user devices |
US10673720B2 (en) * | 2016-11-04 | 2020-06-02 | Google Llc | Systems and methods for measuring media performance on end-user devices |
RU2726342C1 (en) * | 2020-01-17 | 2020-07-13 | Общество с ограниченной ответственностью «ЯЛОС МОБАЙЛ» | System for displaying the animated sound image data on the display of the computing device in accordance with notifications |
US20220210506A1 (en) * | 2020-11-23 | 2022-06-30 | The Boston Consulting Group, Inc. | Methods And Systems For Context-Sensitive Manipulation of an Object via a Presentation Software |
US11470389B2 (en) * | 2020-11-23 | 2022-10-11 | The Boston Consulting Group, Inc. | Methods and systems for context-sensitive manipulation of an object via a presentation software |
Also Published As
Publication number | Publication date |
---|---|
US6369821B2 (en) | 2002-04-09 |
US5983190A (en) | 1999-11-09 |
Similar Documents
Publication | Publication Date | Title |
---|---|---|
US6369821B2 (en) | Method and system for synchronizing scripted animations | |
US6121981A (en) | Method and system for generating arbitrary-shaped animation in the user interface of a computer | |
US6802055B2 (en) | Capturing graphics primitives associated with any display object rendered to a graphical user interface | |
US6377928B1 (en) | Voice recognition for animated agent-based navigation | |
US7020841B2 (en) | System and method for generating and presenting multi-modal applications from intent-based markup scripts | |
US6101510A (en) | Web browser control for incorporating web browser functionality into application programs | |
Myers | User interface software tools | |
US7177813B2 (en) | Middleware layer between speech related applications and engines | |
US5664061A (en) | Interactive computer system recognizing spoken commands | |
US5801692A (en) | Audio-visual user interface controls | |
US5764241A (en) | Method and system for modeling and presenting integrated media with a declarative modeling language for representing reactive behavior | |
US5650941A (en) | Computer architecture for creating and manipulating displayable objects | |
US5546583A (en) | Method and system for providing a client/server interface in a programming language | |
US20050091672A1 (en) | Facilitating presentation functionality through a programming interface media namespace | |
JP2003162733A (en) | Generic parameterization for scene graph | |
US5748196A (en) | Implementing branching operations at processing intersections in interactive applications | |
US20150222730A1 (en) | Client server interaction for graphical/audio applications | |
JP2002517817A (en) | Generating persistent representations of complex data structures | |
JP2005135384A (en) | Programming interface for computer platform | |
JPH08510344A (en) | Multimedia synchronization system | |
JPH10177467A (en) | Multitask data processing system and its method | |
US7599838B2 (en) | Speech animation with behavioral contexts for application scenarios | |
WO1999049394A1 (en) | Application program interfaces in an operating system | |
US8032825B2 (en) | Dynamically creating multimodal markup documents | |
US7162425B2 (en) | Speech-related event notification system |
Legal Events
Date | Code | Title | Description |
---|---|---|---|
AS | Assignment |
Owner name: MICROSOFT CORPORATION, WASHINGTON Free format text: ASSIGNMENT OF ASSIGNORS INTEREST;ASSIGNORS:MERRILL, JOHN WICKENS LAMB;TROWER, TANDY W., II;WEINBERG, MARK JEFFREY;REEL/FRAME:009004/0807 Effective date: 19980225 |
|
STCF | Information on status: patent grant |
Free format text: PATENTED CASE |
|
CC | Certificate of correction | ||
FPAY | Fee payment |
Year of fee payment: 4 |
|
FEPP | Fee payment procedure |
Free format text: PAYOR NUMBER ASSIGNED (ORIGINAL EVENT CODE: ASPN); ENTITY STATUS OF PATENT OWNER: LARGE ENTITY |
|
FPAY | Fee payment |
Year of fee payment: 8 |
|
FPAY | Fee payment |
Year of fee payment: 12 |
|
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 |