(12)
`
`United States Patent
`Willard
`
`(10) Patent No.:
`(45) Date of Patent:
`
`US 7,065,752 B2
`Jun. 20, 2006
`
`US007065752B2
`
`(54) METHOD AND APPARATUS COMPILATION
`OF AN INTERPRETATIVE LANGUAGE FOR
`INTERACTIVE TELEVISION
`
`75
`(75) Inventor: Pierre Willard, Palo Alto, CA (US)
`
`(65)
`
`(73) Assignee: OpenTV, Inc., San Francisco, CA (US)
`(*) Notice:
`Subject to any disclaimer, the term of this
`patent is extended or adjusted under 35
`U.S.C. 154(b) by 706 days.
`(21) Appl. No.: 10/061,902
`(22) Filed:
`Feb. 1, 2002
`9
`Prior Publication Data
`US 2002/012094.0 A1
`Aug. 29, 2002
`O
`O
`Related U.S. Application Dat
`pplication Uata
`e
`(60) Provisional application No. 60/328.963, filed on Oct.
`12, 2001, provisional application No. 60/279.543,
`filed on Mar. 28, 2001, provisional application No.
`60/269,261, filed on Feb. 15, 2001, provisional appli-
`cation No. 60/267,876, filed on Feb. 9, 2001, provi-
`sional application No s 60/266.210 filed on Feb 2
`2001, provisional application No. 60/265,986, filed
`On Feb. 2, 2001.
`s
`
`(2006.01)
`
`(51) Int. Cl.
`G06F 9/45
`717/140
`(52) U.S. Cl
`58 Fi id f Cl- - - - - - ficati - - - - - -s - - - - - - - h- - - - - - - - - - - - - - - - - - - 717/140
`(58)
`O
`t g cars te search hi t
`ee appl1cauon Ille Ior complete searcn n1story.
`(56)
`References Cited
`
`U.S. PATENT DOCUMENTS
`5,286,088 A * 2/1994 Taylor et al. ............... 297/.353
`5.432,937 A
`7, 1995 Tevanian et al. ............ 717/162
`
`4002
`
`4004
`
`4006
`
`5,892,941. A * 4/1999 Khan et al. ................... 703/22
`5,963,934. A * 10/1999 Cochrane et al. .............. 707/2
`6,141,793 A 10/2000 Bryant et al. .....
`... T17,115
`6,188.401 B1
`2/2001 Peyer ........
`... T79,328
`6,327,608 B1* 12/2001 Dillingham ...
`... TO9,203
`6.405,367 B1
`6/2002 Bryant et al. .....
`... T17,115
`6,732,330 B1* 5/2004 Claussen et al. ..
`... 715,513
`2001/004.7394 A1* 11/2001 Kloba et al. ................ 709/217
`FOREIGN PATENT DOCUMENTS
`woofi
`28
`OTHER PUBLICATIONS
`International Search Report: PCT/US 02/02663; Mailed Apr.
`22, 2003.
`* cited by examiner
`Primary Examiner John Chavis
`74) Attorney, Agent, or Firm Meyertons Hood Kivlin
`(
`y, Agent,
`y
`Kowert & Goetzel, P.C.; Rory D. Rankin
`
`wo
`
`(57)
`
`ABSTRACT
`
`-
`A method and apparatus for extracting and compiling an
`interpretative language to implement functions such as those
`written as a script embedded in a HTML page in an
`interactive television environment. HTML pages are
`received from both broadcast and online. The compiler runs
`on a server. The compiled Scripts run faster and require less
`processing power to execute. The scripts are extracted from
`HTML representing content stored at the server. The com
`piled script code is then transmitted from the server to a
`client device, through broadcast or online, for execution
`during content display at the client device. The compiled
`Scripts run faster, require less processing power to execute,
`and run on client devices that do not have the interpreter for
`that language.
`
`53 Claims, 11 Drawing Sheets
`
`4008
`
`4010
`
`JS Compiler
`Front End
`(parser,
`binder, etc)
`
`
`
`JS Compiler
`Back End
`(ocode
`generation)
`
`
`
`L Ocode Binary
`Assembler
`
`Code Module
`Generator
`
`
`
`
`
`
`
`JS2O Page
`Elements
`Compiler
`
`JS2O Compiler
`
`4000
`
`4012
`
`Roku EX1023
`U.S. Patent No. 10,334,311
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 1 of 11
`
`US 7,065,752 B2
`
`50
`
`
`
`206
`
`transactional Control/Business functions
`
`
`
`
`
`202 -1-
`
`Communication
`link
`
`200
`
`214
`
`Figure 1
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 2 of 11
`
`US 7,065,752 B2
`
`216
`
`218
`
`220
`
`222
`
`
`
`
`
`50
`
`S-2
`See
`Rules
`
`Business Functions
`
`
`
`Point-to-Point
`Transport Convers
`Transport & Communia? N
`
`22
`
`
`
`214
`
`207
`
`2O
`232
`
`Figure 2
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 3 of 11
`
`US 7,065,752 B2
`
`50
`N
`
`216
`
`218
`
`220
`
`222
`
`
`
`
`
`206
`
`202
`
`Communication
`link
`
`204
`
`Advertising
`Manager
`
`Point-to-Point r
`
`Transport & Communication
`
`214
`
`232
`
`210
`
`Figure 3
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 4 of 11
`
`US 7,065,752 B2
`
`50
`
`267
`
`248
`
`251
`
`254
`
`253
`
`256
`
`241
`
`261
`
`terrestina
`
`O. Cable
`
`(T Messagings Manager ki
`272
`
`
`
`33
`
`266
`
`245
`
`Figure 4
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 5 of 11
`
`US 7,065,752 B2
`
`2000
`2002
`200 2026
`
`H2Otiscoder
`Dataand processing flowdiagram
`
`arehon
`
`V \|
`
`HOTiaisode,
`
`2010
`2006
`2012
`2008
`
`2004
`
`2003
`
`2024
`
`| |
`
`| |
`
`|
`
`2070-4
`classes
`2068 4Ge, SHander
`2O66
`Stated -
`2072-SF,
`2064
`posa-5,
`
`EM
`
`HMA
`
`
`
`text
`
`-
`
`Sblocks
`f
`----e. (E
`
`Documet
`Tanscodes
`
`014
`
`H
`
`Resource.cf. 1.
`
`30
`
`2018
`
`3. 2030
`833
`2028
`
`2016
`
`2388
`040
`
`O42
`
`2044
`
`se
`
`(i.e.
`
`tree
`
`Figure 5
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 6 of 11
`
`US 7,065,752 B2
`
`
`
`
`
`
`
`9 eun61-I
`
`0242
`
`1791,2
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 7 of 11
`
`US 7,065,752 B2
`
`
`
`JS Source
`
`Figure 7
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 8 of 11
`
`US 7,065,752 B2
`
`4002
`
`4004
`
`4006
`
`4008
`
`4010
`
`
`
`
`
`JS Compiler
`Front End
`(parser,
`binder, etc)
`
`
`
`
`
`s
`Compiler
`p
`
`S2O
`Cache
`
`
`
`
`
`JS2O Compiler
`
`JS Compiler c Ocode Binary
`Assembler
`Back End
`(oCode
`generation)
`
`Code Module
`Generator
`
`
`
`4000
`
`4012
`
`Figure 8
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 9 of 11
`
`US 7,065,752 B2
`
`4102
`
`4010
`
`4112
`
`Class Modules
`--> JS2O
`(otv
`Command SE
`JS Source file
`line
`Compiler
`( js) A) interface
`
`
`
`
`
`
`
`JS Compiler
`Front End
`(parser,
`binder, etc)
`
`JS Compiler
`Back End
`(ocode
`generation)
`
`deasm file
`(.asm)
`
`
`
`JS2O Command Line Compiler
`
`4114
`
`16
`
`Figure 9
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 10 of 11
`
`US 7,065,752 B2
`
`Predefined
`Class module
`
`4206
`
`
`
`
`
`External
`Class module
`
`
`
`JS External
`Code module
`
`4210
`
`4208
`
`Figure 10
`
`

`

`U.S. Patent
`
`Jun. 20, 2006
`
`Sheet 11 of 11
`
`US 7,065,752 B2
`
`4300
`
`DS-D-Tlobal war
`Global War 2
`
`global war X
`static obj
`
`.
`
`predefined ob 1
`redefined ob2
`. .
`external mod 1 war 1
`external mod 1 wa? 2
`.
`.
`.
`external mod 2 war 1
`external mod 2 war 2
`
`
`
`
`
`
`
`size
`
`call to JS2O C lib
`
`last JS2O SP
`temp values
`-
`
`as S2O FP
`
`this
`arg O
`arg 1
`---
`arg M
`
`:
`
`local war 1
`previous FP
`previous PC
`this
`number of args
`arg O
`arc. 1
`
`temp values
`
`4302
`
`first JS2O FP
`
`local war N
`-
`oca waf
`ocal war O
`
`previous PC
`
`Figure 11
`
`Figure 12
`
`

`

`US 7,065,752 B2
`
`1.
`METHOD AND APPARATUS COMPLATION
`OF AN INTERPRETATIVE LANGUAGE FOR
`INTERACTIVE TELEVISION
`
`CROSS REFERENCED TO RELATED
`APPLICATIONS
`
`10
`
`15
`
`This application claims priority from the USPTO provi
`sional patent application entitled: “A Method and Apparatus
`Compilation of an Interpretative Language for Interactive
`Television filed on Oct. 12, 2001, Ser. No. 60/328,963
`which is hereby incorporated by reference; USPTO provi
`sional patent application entitled “A System for Adaptive
`Control of Access, Content and Scheduling For Interactive
`Television filed on Feb. 2, 2001, Ser. No. 60/265,986 which
`is hereby incorporated herein by reference; USPTO provi
`sional patent application entitled “A System for Adaptive
`Control of Access, Content and Scheduling For Interactive
`Television filed on Feb. 2, 2001, Ser. No. 60/266,210 which
`is hereby incorporated herein by reference; USPTO provi
`sional patent application entitled “A System for Adaptive
`Control of Access, Content and Scheduling For Interactive
`Television filed on Feb. 9, 2001, Ser. No. 60/267,876 which
`is hereby incorporated herein by reference; and USPTO
`provisional patent application entitled “A System for Adap
`25
`tive Control of Access, Content and Scheduling For Inter
`active Television filed on Feb. 15, 2001, Ser. No. 60/269,
`261 which is hereby incorporated herein by reference:
`USPTO provisional patent application entitled “A System
`for Adaptive Control of Access, Content and Scheduling For
`Interactive Television' filed on Mar. 28, 2001, Ser. No.
`60/279.543 which is hereby incorporated herein by refer
`CCC.
`
`30
`
`COPYRIGHT NOTICE
`
`A portion of the disclosure of this patent document
`contains material (code listings and message listings) to
`which the claim of copyright protection is made. The
`copyright owner has no objection to the facsimile reproduc
`tion by any person of the patent document or the patent
`disclosure, as it appears in the U.S. Patent and Trademark
`Office file or records, but reserves all other rights whatso
`ever. Copyright 2001 OpenTV. Inc.
`
`BACKGROUND OF THE INVENTION
`
`35
`
`40
`
`45
`
`1. Field of the Invention
`The present invention relates to the field of interactive
`television content display and specifically to the extraction
`of an interpretative language, e.g., JavaScripts from text
`mark up language, e.g., HTML pages and the compilation of
`the JavaScript at a server for downloading and to a client
`device for execution on display of content provided by a
`broadcast, the Internet or cache in an interactive television
`display space.
`2. Summary of the Related Art
`Interactive television systems can be used to provide a
`wide variety of services to viewers. Interactive television
`systems are capable of delivering typical video program
`streams, interactive television applications, text and graphic
`images, web pages and other types of information. Interac
`tive television systems are also capable of registering viewer
`actions or responses and can be used for Such purposes as
`marketing, entertainment and education. Users or viewers
`may interact with the systems by ordering advertised prod
`ucts or services, competing against contestants in a game
`
`50
`
`55
`
`60
`
`65
`
`2
`show, requesting specialized information regarding particu
`lar programs, or navigating through pages of information.
`Typically, a broadcast service provider or network opera
`tor generates an interactive television signal for transmission
`to a viewer's television. The interactive television signal
`may include an interactive portion consisting of application
`code or control information, as well as an audio/video
`portion consisting of a television program or other informa
`tional displays. The broadcast service provider combines the
`audio/video and interactive portions into a single signal for
`transmission to a receiver connected to the user's television.
`The signal is generally compressed prior to transmission and
`transmitted through typical broadcast channels, such as
`cable television (CATV) lines or direct satellite transmission
`systems.
`Typically, a set-top box connected to the television con
`trols the interactive functionality of the television. The
`set-top box receives a broadcast signal transmitted by the
`broadcast service provider, separates the interactive portion
`from the audio-video portion and decompresses the respec
`tive portions of the signal. The set-top box uses the inter
`active information, for example, to execute an application
`while the audio/video information is transmitted to the
`television. The set-top box may combine the audio/video
`information with interactive graphics or audio generated by
`the interactive application prior to transmitting the informa
`tion to the television. The interactive graphics and audio
`may present additional information to the viewer or may
`prompt the viewer for input. The set-top box may provide
`viewer input or other information to the broadcast service
`provider via a modem connection or cable.
`In accordance with their aggregate nature, interactive
`television systems provide content in various different com
`munication protocols that preferably can be understood by
`the client or viewer who receives the information from the
`broadcast service provider/network operator. Typically the
`client is a set top box with a processor possessing limited
`processing power and communication bandwidth. Transla
`tion of the various protocols is beyond the limited process
`ing capability available in the typical set top box processor.
`Moreover, there exist multiple sources using a multitude of
`web authoring tools to create content. These sources tend to
`utilize the hypertext mark up language (HTML) as a stan
`dard with embedded JavaScript in the HTML pages. Java
`Script are typically interpreted. Client devices typically
`possess limited processing power and bandwidth, incapable
`of interpreting and executing an interpretative language in a
`fast and efficient manner. Thus, there is a need for a robust
`client and server architecture, which eliminates the need for
`interpretation of JavaScript embedded in HTML code so that
`HTML encoded content can be displayed by the client or set
`top box processor without requiring an inordinate amount of
`processing power or communication bandwidth.
`
`SUMMARY OF THE INVENTION
`
`The present invention addresses the needs of the interac
`tive television environment discussed above. The present
`invention provides a method and apparatus comprising
`Software and hardware for accepting and extracting an
`interpretative language. Such as JavaScript from an input
`language, such as HTML and compiling the interpretative
`language for display at a client device. A compiled JavaS
`cript page common to a plurality of pages is sent only once
`and referenced as an external page by compiled pages, thus
`reducing the amount of data to be sent and associated
`bandwidth. The viewer or client can be a viewer at a (STB),
`
`

`

`US 7,065,752 B2
`
`3
`a cellular telephone user, a digital assistant, a pocket PC or
`any other electronic reception device.
`The present invention provide distinct advantage over
`known systems. The present invention provides for extract
`ing scripts from an HTML page and compiling the Scripts on
`a server, for execution on a client device, which is an
`improvement over known systems where a browser to
`interprets and executes the Scripts on the same machine.
`The present invention also gathers Scripts for each language,
`for example JavaScript or any other Script language, from an
`HTML document into a single package, for passing to the
`compiler, so that Some of or all the Scripts are compiled
`together. Scripts are embedded in HMTL documents in
`many ways. For example, between a pair of <SCRIPTs and
`</SCRIPTs tags, or as attribute value for event handlers.
`The present invention parses the HTML document, aggre
`gates the script (for a specified language, e.g., JavaScript)
`into one package, and then calls the compiler. Some pieces
`of scripts (e.g., included Scripts) may be compiled separately
`into different modules. All modules are sent to the client
`device for execution. This allows, for example, compiled
`scripts to be shared across different HTML pages. This
`means the compiler has an interface to compile included
`script that maybe different from the one to compile the main
`document Scripts. Thus, it is easier and simpler to create a
`single compiled module.
`The client device knows how to link and execute pieces
`of compiled Scripts, as if it was a single script. Compiled
`Scripts may be cached, so that compiling does not occur if
`the Script is already in the cache. The present invention also
`provides a compile time marker in the scripts for code to be
`executed only on usual HTML browsers (ie, never executed
`in the client device). In prior systems enable the script to test
`at execution time which browser is running (Internet
`Explorer, Netscape, etc). In the present invention, the pre
`ferred compiler recognizes a keyword, e.g., “JS2O’. Thus,
`in a piece of code like: “if (JS2O) DO A; else DO B” the
`compiler will not compile “DO B as it knows that “if
`(JS2O) is always true. Thus, the entire piece of code is
`actually compiled as “DO A: The script compiler does not
`compile code that is never executed on client device, thus
`reducing the compiled code size, and improving code execu
`tion time. The compiler replaces some late binding refer
`ences by compile time bindings for faster execution on client
`device. Prior systems resolve references at execution time.
`For example, in JavaScript, when accessing an identifier
`“foo', the script engine will look for the name “foo' in a
`scope chain. This takes time of course. Here the compiler
`binds (in some cases) the identifier 'foo' to a specific
`address for fast access at runtime. For example, in JS2O,
`(Some) properties are allocated memory space as regular
`global variables in C language, and (some) other properties
`are allocated slots in the Stack as regular local variables in
`C. The compiler replaces some late binding references by
`absolute values for faster execution on client device. In this
`embodiment instead of binding to an address, the compiler
`replaces the identifier directly by a value. For example, in
`JavaScript, the identifier "NaN” is a property of an object.
`Here the compiler directly replaces references to "NaN' by
`its value.
`The preferred compiler supports an interface to define
`new classes of objects. This enables the compiler to access
`and/or optimize creation and manipulation of those objects,
`and allows the runtime to link with the code for that class.
`The class code can be implemented as an Open TV module.
`In a preferred embodiment, H2O defines an HTML syntax to
`
`4
`declare new classes of objects. The compiler Supports an
`interface to define predefined/external instance of objects
`which enables the compiler to access and/or optimize
`manipulation of those objects, and allows the runtime to
`access those objects. Those objects are created outside of the
`script execution. In a preferred embodiment, H2O defines an
`HTML syntax to declare predefined/external instance of
`objects.
`
`10
`
`BRIEF DESCRIPTION OF THE DRAWINGS
`
`Other objects and advantages of the invention will
`become apparent upon reading the following detailed
`description and upon reference to the accompanying draw
`ings in which:
`FIG. 1 is an illustration of a head-end providing content
`to a client device;
`FIG. 2 is an illustration of a head-end providing content
`to a client device;
`FIG. 3 is an illustration of a head-end providing content
`to a client device;
`FIG. 4 is an illustration of a head-end providing content
`to a client device;
`FIG. 5 is a H2O HTML Transcoder architecture diagram;
`FIG. 6 is H2O Browser processing and data flow diagram;
`FIG. 7 illustrates an interface between H2O and JS2O:
`FIG. 8 illustrates the components of JS2O compiler;
`FIG. 9 illustrates the compiler as a JS2O command line
`compiler,
`FIG. 10 illustrates execution of the compiled JS main
`code module at the client;
`FIG. 11 illustrates a preferred data segment; and
`FIG. 12 illustrates a preferred stack segment.
`While the invention is susceptible to various modifica
`tions and alternative forms, specific embodiments thereof
`are shown by way of example in the drawings and will
`herein be described in detail. It should be understood,
`however, that the drawings and detailed description thereto
`are not intended to limit the invention to the particular form
`disclosed, but on the contrary, the invention is to cover all
`modifications, equivalents and alternatives falling within the
`spirit and scope of the present invention as defined by the
`appended claims.
`
`DETAILED DESCRIPTION OF A PREFERRED
`EMBODIMENT
`
`Turning now to FIG. 1, the Service Platform 50 comprises
`a group of applications roughly divided into three catego
`ries, Content Conversion 204, Transaction Control/Business
`Functions 206 and Transport Conversion 207. The Service
`Platform enables services 200 to interact with a client 212.
`The services 200 communicate through a communication
`link 202 to the Service Platform 50. The Service Platform 50
`in turn communicates with a client 212. The client 212 may
`be a STB, a digital assistant, a cellular phone, or any other
`communication device capable of communicating with the
`Service Platform through communication link 230. The
`Content Conversion 204 and Transport Conversion 207
`services provide the transport and communication function,
`and the Business Function services provide the Business
`Control functions.
`As shown in FIG. 2, transaction Control/Business Func
`tions 206 are distributed between the Service Platform and
`the client 212. For example, a client can perform some
`business functions (e.g. implement advertising campaign
`rules and advertising/business filters to select advertise
`
`15
`
`25
`
`30
`
`35
`
`40
`
`45
`
`50
`
`55
`
`60
`
`65
`
`

`

`US 7,065,752 B2
`
`5
`
`5
`ments viewed) and select contents, which are more Suitable
`to the client 212 (e.g., select an advertisement or program
`which fits the user profile). The functions of FIG. 2 are
`expanded in FIG. 3. As shown in FIG. 3, the Business
`Functions 206 comprise four major functional components:
`Service Manager 238, Viewer Manager 240, Transaction
`Manager 242, and Advertisement (Ad) Manager 244. One
`example of a high-level operation flow for a preferred
`embodiment follows.
`Referring now to FIG. 3, a Service 200 negotiates with a
`network operator to offer a service to subscribers via the
`Head-End operator's Service Platform. The network or
`Head End operator uses the Service Manger 238 to register
`the services and the negotiated business rules 222 (e.g.
`schedule, bandwidth requirements, service access to viewer
`15
`information) associated with the service. The Service Man
`ager 238 stores Service data 216 (e.g. URL address, con
`tent). Based on the business rules 222 and Service Data 216,
`Service Manager 238 communicates with the Broadcast
`Communication 234 function to retrieve the content from
`the content provider.
`When the content is retrieved from the Service 200, it may
`be processed by the Content Conversion 204 and Content
`Filters 224 to convert the content into a form suitable for the
`client device 212. The Broadcast 234 function converts the
`content into a form suitable for the broadcast 234 network.
`The client 212 receives the converted content over broadcast
`link 211. Client 212 and Service 200 interact via Point-to
`Point link 210 and Point-to-Point function 232, which are
`part of Transport Conversion 207. The service 200 may
`comprise shopping, audio/video, gaming, voting, advertise
`ment, messaging, or any other service.
`Client 212 communicates through Point-to-Point 232
`communication link to the Service Platform 50 and Service
`200. Load Balancer 236 interacts with the Business Func
`tions 206 to determine the optimal load distribution between
`the Broadcast 234 Communication link 211 and the Point
`to-Point 232 Communication link 210. The Platform Busi
`ness Agents 226 use business rules 222 to control the
`interaction and exchange of information between the Service
`200 and the client 212. For example, the network operator
`may choose to prevent Service 200 access to user informa
`tion. Service 200 preferably pay a fee based on the Business
`Rules 222 and Service data 216 to access the user informa
`tion.
`Viewer Manager 240 stores client/user information in
`User Data 220. Platform Business Agents 226 control the
`flow of viewer information to the Service 200. Transaction
`Manager 242 records transactional information exchanged
`between the service 200 and Client 212. Based on the
`Business Rules 222 and the User Data 220, Advertising
`Manager 244 determines which advertisements and which
`type of advertisements will be presented to the client via
`Broadcast link 211 and Point-to-Point link 210.
`FIG. 4 illustrates another example of a preferred imple
`mentation of Service Platform 50. Services 200 provide
`shopping, chat, and other services either over the Internet or
`over another network or communication channel accessible
`to the network operator. Using the Service Platform, the
`network operator accesses those services. Business Func
`tions 206, comprising Service Manager 238, interact with
`Carousel Manager 254 to retrieve content from a Service
`200. The carousel comprises a repeating stream of audio/
`video/interactive data broadcast to clients from the Service
`Platform 50. Carousel manager 254, transaction manager
`242 and Service Manager 238 control the content insertion
`and deletion from the broadcast carousel. Service content is
`
`25
`
`30
`
`35
`
`40
`
`45
`
`6
`retrieved, converted into a client suitable format by H2O
`248. H2O 248 is a possible implementation of Content
`Conversion 204 and Content Filter 224. H2O converts
`HTML Content into Service Platform/Client readable con
`tent. The converted content is formatted into a data carousel
`and multiplexed by the Open Streamer 256 for broadcast to
`the client 212. Client 212 interacts with the services and if
`necessary communicates with the Service Platform and the
`Services 200. Point-to-Point communication goes through
`Service Gateway 246. Service gateway 246 performs trans
`port conversion to convert the STB protocol into a form
`Platform Business Agents 226 and H2O 248 expect and
`understand. Load Balancer 236 interacts with Business
`Functions 206, Carousel Manager 254, and Service Gateway
`246 to determine the optimal load between the Broadcast
`link 241 and the Point-to-Point Communication link 210.
`Business Functions 206 interact with the Platform Business
`Agents 226 to control access and information exchange
`between the Services 200 and client 212.
`In a preferred embodiment of the present invention, H2O
`is a client/server solution, which enables Internet content
`developers to build interactive TV applications and services
`for network operators running the Service Platform. The
`Service Platform enables viewer access to the larger pool of
`Internet talent and content made available to the vast grow
`ing worldwide market of interactive TV applications. The
`H2O server process converts Internet content (HTML pages,
`ECMAScripts, and HTML page formatting) into Service
`Platform assets. The H2O client process renders the assets
`and interacts with the client 212. In a T-Commerce/E-
`Commerce case scenario, H2O enables E-Commerce shops
`to utilize existing Web tools to create shopping services and
`to interface with the preferred Service Platform (operator),
`using standard Web protocol.
`H2O acts as a proxy to the Service Gateway and the
`broadcasting tools to convert Web content. H2O receives
`HTML from both broadcast and online sources. The present
`invention enables web sites use their current HTTP servers
`and application servers to generate interactive TV content.
`In a preferred embodiment, H2O converts HTML, JavaS
`cript, and Internet graphics to client compatible code, pref
`erable Ocode, a C-based OpenTV code running on a virtual
`machine on the set top box. Any other known or developed
`protocol can also be added to the functionality of H2O. H2O
`enables the Service Platform to communicate with clients
`STBs that are not full browser capable and to create original
`user interfaces. H2O enables Service Platform connection to
`any commerce engine that uses only HTML. H2O is respon
`sible for converting Web content such as HTML pages, JPG
`pictures, wave audio files, etc. into client-friendly resources
`that can be easily utilized with minimal processing capabil
`ity and bandwidth at the client.
`The server side of H2O is an HTTP proxy, H2OS. For
`other purposes, it can be packaged as a DLL or batch tool.
`The client side of H2O, an STB OCOD application, is
`H2OC, H2OC is built on top of other Service Platform client
`components, such as the Service Gateway library or the
`Carousel Load library. H2O enables URLs to be used to
`address documents and services. H2O enables tracking in
`the broadcast and online environments. H2OS provides
`HTTP proxy functionality. Service Platform applications
`request a document through H2O. H2O retrieves the docu
`ment, parses it, compiles it, and returns the document to the
`requester. This H2O functionality enables use of the same
`engine for different uses, online and broadcast, facilitates
`scalability, and enables flexible use of H2O. The parsing
`depends on the type of document, e.g., H2O parsing can be
`
`10
`
`50
`
`55
`
`60
`
`65
`
`

`

`US 7,065,752 B2
`
`10
`
`15
`
`25
`
`30
`
`7
`HTML parsing, a GIF picture, or JPEG images, etc. To make
`it expandable, H2O provides function to “plug-in” and run
`new third party filters.
`H2O Supports special tags comprising: A/V control, chan
`nel control; on Screen display (OSD) control; and Triggers.
`H2O Supported W3C tags comprise: controlled positioning
`of graphical elements (x, y, z). JavaScript libraries comprise
`Math, DOM, and Date. The client side of H2O, H2OC
`composes graphics assets in the client or STB. H2O enables
`updated display of a user viewed page upon reception.
`H2OC utilizes libraries (communication, carousel, et al.)
`provided by other Service Platform components. H2O
`enables refreshing a page in a single update, but also
`provides an option to choose between partial updates as
`assets are loaded, versus waiting for all or some assets to
`load. H2O enables dynamic linking/unlinking of third party
`classes.
`In broadcast mode, preferably, a global permanent object
`is provided, that is not cleared when starting a new page. The
`permanent object maintains context between pages. Other
`base objects provided by the Service Platform are also made
`permanent on transition (e.g., station control. OSD). Gad
`gets are client-defined methods. Gadgets are defined through
`an interface definition language to enable creation of new
`gadgets, modification of gadgets and to enable adding meth
`ods without modifying the JS2O compiler 4000 of the
`present invention.
`Now turning to FIGS. 5 and 6, a discussion of the main
`H2O components follows. H2O transcoder 2001 converts
`HTML inputs 2062 into H2O transcodes that can be effi
`ciently and interactively displayed by an H2O Browser in a
`client device, e.g., an OpenTV STB. The H2O Browser
`views H2O transcodes in limited Dynamic HTML4 fashion.
`The host, such as HTTP proxy 2003, invokes H2O
`Transcoder 2001. H2O Transcoder 2001 interfaces with
`35
`MIME handler 2036 and MIME info 2028 for content
`information in non-HTML MIME type. The JS2O compiler
`4000 is multi-thread safe. H2O Transcoder invokes H2O
`JavaScript Handler 2000 to take scripts as input, fetch
`external scripts or class URI, and invokes JS2O compiler
`and pre-link JavaScript. The JS handler 2000 processes JS
`custom classes 2070 and JS shared scripts 2066.
`Turning now to FIG. 6, the H2O Browser 2100 interfaces
`with JS2O JavaScript runtime 2129 for JavaScript support.
`The H2O Transcoder runs as a task, fetches MIME content
`through host HTTP proxy, and processes MIME content as
`requested. Preferably an interface is provided with the proxy
`host to handle caching mechanism for better efficiency. The
`H2O transcoder executes synchronously.
`The H2O transcoder supports a selected subset of the
`HTML4.01 W3 standard. H2O transcoder supports a subset
`of text: paragraphs, lines, phrases; Subset of list; Subset of
`table and subset of links. The H2O transcoder supports a
`subset of Object and Image elements. The H2O transcoder
`also Supports a filter authoring-side object (e.g., IE (Internet
`Explorer) custom object) and Supports runtime custom
`objects for the STB; both authoring-side (PC) and STB
`custom object class development; a Subset of image map
`(client-side, server-side); a subset of form and form controls;
`Script element; and a subset of JavaScript.
`In H2O transcoder, the HTML nodes contain once-com
`puted CSS information in element nodes. Very limited, if
`any, additional CSS is preserved. This is fundamentally
`different from the dynamic cascading rules of CSS. Dynamic
`style is limited as a style change preferably is applied to only
`65
`one node. This means that in order to query through DOM
`a property of the style of a particular element and expect it
`
`55
`
`8
`to return a valid value, the style property (e.g. style color:
`red) is explicitly specified for the element inside an inline
`style, or explicitly created in a JavaScript code in order for
`PC emulation to behave similarly.
`The present invention invokes a H2O JavaScript handler
`task to process Script element data. The JavaScript handler
`task fetches the script URI, and invokes the JS2O JavaScript
`compiler. JS2O returns a data package containing the com
`piled JavaScript code module. JS2O may cache compiled
`JavaScript scripts and matches repeated similar and identical
`JavaScript scripts.
`The present invention generates H2O Transcodes using
`client compatible resources from parser engine internal data
`models with layout and limited Style information, and Java
`Script co