U.S. patent application number 11/205727 was filed with the patent office on 2005-12-15 for audio visual architecture.
This patent application is currently assigned to Microsoft Corporation. Invention is credited to Hasha, Richard.
Application Number | 20050276124 11/205727 |
Document ID | / |
Family ID | 35460371 |
Filed Date | 2005-12-15 |
United States Patent
Application |
20050276124 |
Kind Code |
A1 |
Hasha, Richard |
December 15, 2005 |
Audio visual architecture
Abstract
An architecture is provided that is capable of supporting
interconnections between components. These devices include output
components, such as laserdiscs players and input components, such
as speakers. Each of the output components has a source port
associated with each type of output signal it can output, and each
input component has a sink port associated with each type of input
signal that it can input. A multitude of aspects follow from this
architecture. For example, each source port can be connected to one
or more input ports. The path between a source port and a sink port
can be either static or dynamic. Furthermore, the dynamic path can
be established through a switching mechanism. Any connection
between a source port and a sink port can be either a virtual
circuit or a transport medium.
Inventors: |
Hasha, Richard; (Seattle,
WA) |
Correspondence
Address: |
WOODCOCK WASHBURN LLP
ONE LIBERTY PLACE - 46TH FLOOR
PHILADELPHIA
PA
19103
US
|
Assignee: |
Microsoft Corporation
Redmond
WA
|
Family ID: |
35460371 |
Appl. No.: |
11/205727 |
Filed: |
August 15, 2005 |
Related U.S. Patent Documents
|
|
|
|
|
|
Application
Number |
Filing Date |
Patent Number |
|
|
11205727 |
Aug 15, 2005 |
|
|
|
09322643 |
May 28, 1999 |
|
|
|
60118668 |
Feb 3, 1999 |
|
|
|
Current U.S.
Class: |
365/189.04 |
Current CPC
Class: |
H04L 2012/2849 20130101;
H04L 12/2803 20130101; H04L 12/2838 20130101; H04L 67/36
20130101 |
Class at
Publication: |
365/189.04 |
International
Class: |
G11C 016/04 |
Claims
What is claimed:
1. An audio/visual system, comprising: at least one output
component having at least one source port for each type of output
signal output from the at least one output component and at least
one source port object for each of said at least one source port;
and at least one input component having at least one sink port for
each type of input signal input to the at least one input component
and at least one sink port object for each at least one sink port,
wherein each at least one source port of said at least one output
component is connectable to said at least one sink port of said at
least one input component via at least one primitive circuit
path.
2. An audio/visual system according to claim 1, further including
at least one primitive circuit object for each at least one
primitive circuit path with a signal at least one of (A)
originating from a source port and (B) terminating at a sink
port.
3. An audio/visual system according to claim 1, wherein the at
least one primitive circuit path between the at least one source
port and the at least one sink port is at least one of a static
path and a dynamic path.
4. An audio/visual system according to claim 1, further including
at least one switching mechanism having at least one input
switching port and at least one output switching port, wherein a
switching mechanism of the at least one switching mechanism enables
the at least one input switching port associated with the switching
mechanism to be connected to the at least one output switching port
associated with the switching mechanism, thereby establishing at
least one dynamic path between the at least one input switching
port and the at least one output switching port.
5. An audio/visual system according to claim 1, wherein a wire
protocol-based approach is utilized that supports the semantics of
said at least one output component and said at least one input
component.
6. An audio/visual system according to claim 1, further comprising:
at least one entertainment session; and at least one
player/recorder component associated with each entertainment
session including at least one output component, wherein a
player/recorder component is a type of source object.
7. An audio/visual system according to claim 1, wherein said at
least one output component includes at least one of (A) a display
component and (B) a speaker system component, wherein a display
object represents a display component and a speaker system object
represents a speaker system component.
8. An audio/visual system according to claim 1, further comprising:
at least one media manager object for managing media at its
location and for providing at least one appropriate object, as
determined by the at least one media manager object, for the media
managed by the at least one media manager object.
9. A method for establishing a path between a source component and
an input component in an audio/visual system comprising at least
one source component having at least one source port capable of
supporting each type of output signal output from the at least one
source component and at least one primitive source port object for
each of said at least one source port; and at least one input
component having at least one sink port capable of supporting each
type of input signal input to the at least one input component and
a primitive sink port object for each sink port, wherein each at
least one source port of said at least one source component is
connectable to said at least one sink port of said at least one
input component via at least one primitive circuit path, including:
instantiating a virtual circuit object that establishes a path
between the source port corresponding to the complete source port
object and the sink port corresponding to the complete sink port
object.
10. A method according to claim 9, further including: establishing
a primitive circuit path using an output object that represents the
source component and an input object that represents the input
component.
11. A method according to claim 9, wherein the sink port and the
source port are included in the same port.
12. A method according to claim 9, wherein said instantiating
includes hosting the virtual circuit object by the source port.
13. A method for use in connection with an audio/visual system,
comprising: connecting at least one source port of at least one
output component to at least one sink port of at least one input
component via at least one primitive circuit path; wherein each of
said at least one output component includes at least one source
port for each type of output signal output from the at least one
output component and at least one source port object for each of
said at least one source port, and wherein each of said at least
one input component includes at least one sink port for each type
of input signal input to the at least one input component and at
least one sink port object for each at least one sink port.
14. A method according to claim 13, wherein at least one primitive
circuit object is generated for each at least one primitive circuit
path with a signal at least one of (A) originating from a source
port and (B) terminating at a sink port.
15. A method according to claim 13, wherein the at least one
primitive circuit path between the at least one source port and the
at least one sink port is at least one of a static path and a
dynamic path.
16. A method according to claim 13, wherein a switching mechanism
having at least one input switching port and at least one output
switching port connects at least one input switching port
associated with the switching mechanism to the at least one output
switching port associated with the switching mechanism, thereby
establishing at least one dynamic path between the at least one
input switching port and the at least one output switching
port.
17. A method according to claim 13, wherein a wire protocol-based
approach is utilized that supports the semantics of said at least
one output component and said at least one input component.
18. A method according to claim 13, further comprising: generating
at least one entertainment session; and associating at least one
player/recorder component with each entertainment session including
at least one output component, wherein a player/recorder component
is a type of source object.
19. A method according to claim 13, wherein said at least one
output component includes at least one of (A) a display component
and (B) a speaker system component, wherein a display object
represents a display component and a speaker system object
represents a speaker system component.
20. A method according to claim 13, further comprising: generating
at least one media manager object for managing media at its
location and for providing at least one appropriate object, as
determined by the at least one media manager object, for the media
managed by the at least one media manager object.
Description
CROSS REFERENCE TO RELATED APPLICATIONS
[0001] This application is a continuation application of U.S.
application Ser. No. 09/322,643, filed May 28, 1999, which claims
the benefit of Provisional Application No. 60/118,668, filed Feb.
3, 1999.
[0002] This application is also related to co-pending application
entitled "Audio Visual Architecture," Attorney Docket Number
MSFT-4488/183206.05, U.S. application Ser. No. filed on ______.
TECHNICAL FIELD
[0003] The described technology is related to audio/visual
systems.
BACKGROUND
[0004] A large environment, such as a large building or a large
house, may have many audio/video devices located throughout the
environment. These AV devices may include CD players, speaker
systems, computer systems, television receivers, satellite
receivers, displays, and so on. In addition, many sources of media
may be available. One such media is a jukebox containing a variety
of compact discs. The AV devices typically provide a control panel
through which the device can be controlled. For example, a CD
player provides a control panel that allows a CD to be started,
paused, or stopped. Typically, the interconnections between the AV
devices are static. That is, when the AV devices are installed,
cabling is routed between devices. For example, speaker wire may be
routed between an amplifier and speakers.
[0005] A problem with such static interconnections it is very
expensive and difficult to provide all the desired interconnections
and to change connections. Another problem is that it is cumbersome
to use only the control panels to control the devices. It would be
desirable to have an architecture that would support the dynamic
interconnection between devices.
SUMMARY
[0006] An architecture is provided that is capable of supporting
interconnections between components. In one aspect, an audio/visual
system is disclosed, where the system comprises of at least one
output component having at least one source port for each type of
output signal output from the output component, and at least one
source port object for each source port. Furthermore, the system
comprises of at least one input component having at least one sink
port for each type of input signal input to the input component,
and at least one sink port object for each one sink port. In this
arrangement, the source ports of the output component are
connectable to the sink ports of the input component via primitive
circuit paths. These primitive circuit paths between the source
ports and the sink ports can be static or dynamic.
[0007] In another aspect, the system may further including at least
one switching mechanism having at least one input switching port
and at least one output switching port, where a switching mechanism
of the at least one switching mechanism enables the input switching
port associated with the switching mechanism to be connected to the
output switching port associated with the switching mechanism,
thereby establishing at least one dynamic path between the input
switching port and the output switching port.
[0008] In still a further aspect, the system may further comprise
of at least one entertainment session and at least one
player/recorder component associated with each entertainment
session, including at least one output component, where a
player/recorder component is a type of source object. The output
component may include a display component or a speaker system
component, where a display object represents a display component
and a speaker system object represents a speaker system component.
Alternatively, the system may further comprise of at least one
media manager object for managing media at its location and for
providing at least one appropriate object, as determined by the at
least one media manager object, for the media managed by the at
least one media manager object.
[0009] This summary is provided to introduce a selection of
concepts in a simplified form that are further described below in
the Detailed Description. This Summary is not intended to identify
key features or essential features of the claimed subject matter,
nor is it intended to be used as an aid in determining the scope of
the claimed subject matter.
BRIEF DESCRIPTION OF THE DRAWINGS
[0010] FIG. 1 is a block diagram illustrating network layer objects
that model the path between output components, switching
mechanisms, and input components.
[0011] FIG. 2 is a block diagram illustrating the session layer
objects that represent virtual circuits.
[0012] FIG. 3 is a block diagram illustrating management laser
objects.
[0013] FIG. 4 is a diagram illustrating the establishment of a path
between an output component and an input component.
[0014] FIG. 5 is a flow diagram representing a function of a
complete source port object for creating a virtual circuit
object.
[0015] FIG. 6 is a flow diagram of example implementation of the
constructor for a virtual circuit object.
[0016] FIG. 7 is a flow diagram illustrating an example
implementation of process-not-direct-connection function.
[0017] FIG. 9 is a flow diagram illustrating an example
implementation of an activation of an AV source port function.
[0018] FIG. 10 is a block diagram illustrating the components of an
entertainment center.
[0019] FIG. 11 illustrates a block diagram illustrating various
components of the AV system.
[0020] FIG. 12 is a flow diagram illustrating the assigning of a
program to an entertainment center.
[0021] FIG. 13 is a flow diagram of function to select a
program.
[0022] FIG. 14 is a flow diagram representing an example
implementation of a set current program function of an
entertainment center object.
[0023] FIG. 15 is a flow diagram of an example implementation of a
function to get a loaded player/recorder object.
[0024] FIG. 16 is a flow diagram of example implementation of the
load yourself function 20 of the player/recorder object.
[0025] FIG. 17 is a flow diagram of an example implementation of
the load program function of a player/recorder object.
[0026] FIG. 18 is a flow diagram of an example load program
function of a media manager object.
[0027] FIG. 19 is a flow diagram of another example load program
function of the media manager object.
DETAILED DESCRIPTION OF ILLUSTRATIVE EMBODIMENTS
[0028] Each output component (e.g., laserdisc player or output
software component) has a source port associated with each type of
the output signal that it can output. For example, an output
component may output a video signal in RGB format through one
source port and may output audio signal in AES format through
another source port. Each input component (e.g., speaker system or
input software component) has a sink port associated with each type
of input signal that it can input. For example, an input component
may input a signal in RGB format through one sink port. The AV
system models each port with a corresponding port object. The AV
system has a corresponding primitive source port object for each
source port and a corresponding primitive sink port object for each
sink port.
[0029] Each source port can be connected to one or more input
ports. For example, a source port that outputs a video signal can
be connected to the input ports of several monitor devices. The
path between a source port and a sink port can be static or
dynamic. A static path may correspond to a direct connection
between a source port and a sink port of the output component. A
dynamic path can be established through a switching mechanism. A
switching mechanism allows for its sink ports to be connected to
its source ports so that a path can be established. The connection
can be a virtual circuit or a transport medium. For example, a
certain bandwidth of the transport medium may be allocated for the
connection. The path between a source port and a sink port is
referred to as a primitive circuit. A primitive circuit may be a
direct path between a source port of an output component and a sink
port of an input component. A primitive circuit may also be a path
between a source port of an output component with an input
switching port (a type of sink port) of a switching mechanism.
Similarly, a primitive circuit may be a path between an output
switching port (a type of source port) of a switching mechanism to
a sink port of an input component. The AV system has a
corresponding primitive circuit object for each path with a signal
origination from a source port and/or terminating at a sink port,
corresponding input switching port object for each input switching
port, and an output switching port object for each output port.
[0030] FIG. 1 is a block diagram illustrating network layer objects
that model the path between output components, switching
mechanisms, and input components. In this example, a laserdisc
player is connected to a speaker system and a display. The
laserdisc player includes three physical source ports: one for
digital video, one for left audio, and one for right audio. The
source ports have a direct path to input switching ports of the
switching mechanism. The speaker system has two sink ports: one for
left audio and one right audio. The display has a sink port for
digital video. The sink ports of the output devices have direct
paths to the output switching ports of the switching mechanism. The
AV system represents each of these components with a corresponding
object in memory. The player recorder object 101 corresponds to the
laserdisc player. The speaker system object 102 corresponds to the
speaker system, and the display object 103 corresponds to the
display. The AV system represents multiple ports of a component by
a single aggregating port object. The source port object 104
corresponds to the source ports of the laserdisc player, the sink
port object 105 corresponds to the sink ports of the speaker
system, and the sink port object 106 corresponds to the sink port
of the display. Each port object may contain nested port objects to
organize the ports of a component in a hierarchy. In this example,
the source ports of the laserdisc player are represented by an
aggregate source port object 104 that contains two child source
port objects. A one child source port object 107 represents the
audio source ports, and the other child source port object 108
represents the video source port. The source port object
representing the audio source port contains two source port
objects. One source object 109 represents the left audio source
port, and the other source port object 110 represents at the right
audio source port. Similarly, the sink port object 105 represents
the sink ports of the speaker system and contains two child sink
ports. One sink port object 111 represents the left audio sink
port, and the other child sink port object 112 represents the right
audio sink port. Since the display has only one sink port, its
corresponding sink port object 106 has no child sink ports. A
source port object or a sink port object that has no child port is
referred to as a primitive port object. For example, source port
objects 109 and 110 are primitive source ports. A port object that
is not a child of any other port object is referred to as a
complete port object. For example, source port object 104 is a
complete source port object. Sink port object 106 is both a
primitive sink port object and a complete sink port object.
[0031] The AV system may represent each path by a primitive circuit
object. In this example, primitive circuit object 113 corresponds
to a direct path between the left audio source port of the
laserdisc player and an input switch port of the switching
mechanism. The AV system represents the switching mechanism by a
switch object 114. A switch object contains an input source port
object 115 for each of its input switch ports and an output switch
port object 116 for each of its output switch ports.
[0032] The AV system represents a path for a signal between a
complete source port and a complete sink port by a virtual circuit.
A signal models actual informational context that is on a path. A
virtual circuit may represent static and dynamic connections. FIG.
2 is a block diagram illustrating the session layer objects that
represent virtual circuits. The AV system represents a virtual
circuit by a virtual circuit object. The virtual circuit object 201
corresponds to the path between the complete source port of the
laserdisc player and the complete sink port of the speaker system.
The virtual circuit object 202 corresponds to the path between the
source port of the laserdisc player and the complete sink port of
the display. The virtual circuit object 201 corresponds only to the
audio source ports of the laserdisc player, and the virtual circuit
object 202 corresponds only to the video source ports of the
laserdisc player. Each virtual circuit object contains a primitive
binding information corresponding to each of the paths within that
virtual circuit. For example, the virtual circuit object 201
contains a primitive binding information 203 and 204. The AV system
allows each source port to be connected to multiple sink ports.
[0033] FIG. 3 is a block diagram illustrating management layer
objects. The AV system represents the signals that are output by
the source ports of an output component as a stream. That is, each
output outputs a stream of signals. The signals within the stream
are hierarchically organized in a manner that is similar to how
source ports are organized within a complete source port. The AV
system represents the stream of an output component by a stream
object that may contain other stream objects. In this example, the
output signals of the laserdisc player are represented by stream
object 301. The audio signals of the laserdisc player are
represented by child stream object 302, and the video signal of the
laserdisc player is represented by child stream object 303. The
audio stream object contains a child stream object 304 representing
the left audio signal and a child stream object 305 representing
the right audio signal. A stream object that does not contain other
stream objects is referred to as a primitive stream object. A
stream object that is not contained within other stream objects is
referred to as a complete stream object. For example, stream object
301 is a complete stream object, and stream object 304 is a
primitive stream object. Each primitive stream object contains a
signal object that corresponds to the signal that is output by the
corresponding source port. Signal object 306 corresponds to the
signal that is transmitted between the left audio source port of
the laserdisc player and the left sink port of the speaker system.
Signal object 307 corresponds to the signal that is transmitted
between the right audio source of the laserdisc player and the
right sink port of the speaker system. Signal object 308
corresponds to the signal that is transmitted from the video source
port of the laserdisc player to the sink port of the display.
[0034] FIG. 4 is a diagram illustrating the establishment of a path
between an output component and an input component. A path is
established using an object that represents the output component
and an object that represents the input component. In step 401, the
process requests the output object to provide a pointer to a
complete source port object. In step 402, the process requests the
source port object for a pointer to its complete stream object. In
step 403, the process requests the input object to provide a
pointer to its complete sink port object. In step 404, the process
asks the source port object to create a virtual circuit object that
establishes a path between the source port to the sink port. The
process is then complete.
[0035] FIG. 5 is a flow diagram representing a function of a
complete source port object for creating a virtual circuit object.
This function performs the processing necessary to establish a path
for a signal between a primitive source port and a primitive sink
port. The create virtual circuit function is passed a pointer to
the sink port object. In step 501, the function creates a new
virtual circuit object passing a pointer to the source port object
and a pointer to the sink port object. In step 502, the function
adds the virtual circuit object to a list of virtual circuits for
the source port object. The function then returns.
[0036] FIG. 6 is a flow diagram of example implementation of the
constructor for a virtual circuit object. The constructor is passed
a pointer to a source port object and a pointer to a sink port
object. In the step 601, the constructor retrieves a pointer to the
stream associated with the source port object. In step 602, the
constructor assigns the stream to the sink port object by invoking
the assign stream function of the sink port object passing a
pointer to the stream object. The assign stream function returns
the number of signal objects within the stream object that are
assigned to the complete sink port object. In steps 603-610, the
constructor loops creating a primitive binding object for each
signal object that is assigned to the sink port object. In step
603, the constructor selects the next signal number starting with
1. In step 604, if the selected number is greater than the number
of assigned signals, then the constructor returns, else the
constructor continues at step 605. In step 605, the constructor
retrieves a pointer to the primitive sink port object corresponding
to the numbered signal object and retrieves a pointer to the signal
object itself. The constructor retrieves these pointers by invoking
the get assignment pointer function of the sink port object. In
step 606, the constructor retrieves a pointer to the primitive
source port object for the corresponding signal port object. In
step 607, the constructor retrieves a pointer to the sink port
object of the primitive source port object. In step 608, if the
primitive sink port object of the primitive circuit of the
primitive sink port object is the same as the primitive sink port
object of the primitive circuit of the primitive source port
object, then a direct connection exists between the source port and
the sink port. Otherwise, the connection is through a switching
mechanism. If the connection is through a switching mechanism, then
the constructor continues at step 609, else the constructor
continues at step 610. In step 609, the constructor invokes a
process-not-direct-connection function. In step 610, the
constructor adds an identification of the binding from the
primitive source port to the primitive sink port to the binding
table of the virtual circuit object. A binding represents the
identity of the primitive source port object and the primitive sink
port object. If the connection is not direct, the binding also
includes the identity of the input switch port object and the
output switch port object of the switching mechanism. The function
then loops to step 603 to process the next signal object.
[0037] FIG. 7 is a flow diagram illustrating an example
implementation of process-not-direct-connection function. In step
701, the function retrieves a pointer to switch input port object
for the primitive circuit of the primitive source port object. In
step 702, the function retrieves a pointer to the primitive source
port object. In step 703, the function retrieves a pointer to the
output switch port object of the retrieved primitive circuit. In
step 704, the function creates a connection between the input
switch port object and the output switch port object. The function
then returns.
1 class AvPort { getOwnerObjectPtr (resultPtr); isCompletePort( );
isPrimitivePort( ); getParentPortPtr(portPtr);
getNumberOfChildPorts(number); getChildPortPtr(number, portPtr);
setProperty(resetIn); setProperty(resetOut); } getOwnerObjectPtr
(resultPtr);
[0038] This function returns a pointer to the owner object of the
port. The owner of the port is the object that directly contains a
complete port. Each port within the port hierarchy as the same
owner object.
[0039] This function returns an indication as to whether this port
is a complete port. isPrimitivePort( );
[0040] This function returns an indication as to whether this port
is a primitive port. getParentPortPtr(portPtr);
[0041] This function returns a pointer to the parent port of this
port. The parent port is that port which is the next higher port in
the port hierarchy. getNumberOfChildPorts(number);
[0042] This function returns the number of child ports of this
port. getChildPortPtr(number, portPtr);
[0043] This function returns a pointer to the child port designated
by the passed port.
2 class AvSinkPort : AvPort { isConnectedToStream( );
getAvStreamPtr(streamPtr); assignStream(streamPtr, number);
unassignStream( ); getNumberOfAssignments(number);
getAssignmentsPtrs(number, assignedSignalPtr, toPrimitivePortPtr)
connectToAssignedStream( ); } isConnectedToStream( );
[0044] This function retains an indication whether this sink port
is connected to a stream. getAvStreamPtr(streamPtr);
[0045] This function returns a pointer to the stream to which this
sink port is connected. assignStream(streamPtr);
[0046] This function informs a sink port that it is to consider the
signals within a stream for the purpose of assigning them to a
primitive sink port. unassignStream( );
[0047] This function undoes the assigning.
getNumberOfAssignments(number);
[0048] This function returns the number of assignments between a
signal and a primitive sink port that was made during the
assignment. getAssignmentsPtrs(number, assignedSignalPtr,
toPrimitivePortPtr);
[0049] This function is passed an assignment number and returns an
indication of the signal that is assigned to the primitive port.
connectToAssignedStream( );
[0050] This function is used to inform a complete sink port and its
container of the assigned stream so that any action appropriate to
the connection can be taken, such as powering on the output
component.
3 class AvSignal { getSignalUsage(usage); getSignalFormat(format);
getParentStreamPtr(streamPtr); getSourcePortPtr(sourcePortPtr); }
getSignalUsage(usage);
[0051] This function returns the usage of the signal. The usage may
be, for example, left audio or the red of an RGBsignal.
getSignalFormat(format);
[0052] This function returns the format of the signal. The format
may be, for example, 601 video or AES audio.
getParentStreamPtr(streamPtr);
[0053] This function returns a pointer to the stream which is the
parent of this signal. That is, the primitive stream that is
carrying the signal. getSourcePortPtr(sourcePortPtr);
[0054] This function returns a pointer to the primitive source port
that is outputting this signal.
4 class AvStream { isCompleteStream( ); isPrimitiveStream( );
getParentStreamPtr(streamPtr); getNumberOfChildStreams(number);
getChildStreamPtr(number, streamPtr);
getSourcePortPtr(sourcePortPtr);
getSourceProgramPtr(sourceProgramPbr); getSignalPtr(signalPtr); }
IsCompleteStream( );
[0055] This function returns an indication as to whether this
stream is a complete stream. IsPrimitiveStream( );
[0056] This function returns an indication as to whether this
stream is a primitive stream. getParentStreamPtr(streamPtr);
[0057] This function returns a pointer to the stream that is the
parent of this stream. getNumberOfChildStreams(number);
[0058] This function returns the number of child streams of this
stream. getChildStreamPtr(number, streamPtr);
[0059] This function returns a pointer to the numbered child stream
of this stream. getSourcePortPtr(sourcePortPtr);
[0060] This function returns a pointer to the source port that is
producing this stream. The source port is at the same level in its
hierarchy as this stream is in its hierarchy.
getSourceProgramPtr(sourceP- rogramPtr);
[0061] This function returns a pointer to the source program that
is producing this stream. getSignalPtr(signalPtr);
[0062] This function returns a pointer to the signal in this stream
is a primitive stream.
5 class AvPrimitiveCircuit { getSourcePortPtr(sourcePortPtr);
getSinkPortPtr(sinkPortPtr); } getSourcePortPtr(sourcePortPtr);
[0063] This function returns a pointer to the primitive source port
of this primitive circuit. getSinkPortPtr(sinkPortPtr);
[0064] This function returns a pointer to the primitive sink port
of this primitive circuit.
6 class AvInputSwitchPort : AvSinkPort {
getNumberOfConnections(number); getConnectionPtr(number,
outputSwitchPortPtr); createConnection(outputSwitchPortPtr);
removeConnection(outputSwitch.PortPtr); }
getNumberOfConnections(number);
[0065] This function returns the number connections from this input
switch port to output switch ports. getConnectionPtr(number,
outputSwitchPortPtr);
[0066] This function returns a pointer to the numbered output
switch port that is connected to this input switch port.
createConnection(outputSwitc- hPortPtr);
[0067] This function creates a connection from this input switch
port to the passed output switch port.
removeConnection(outputSwitchPortPtr);
[0068] This function removes a connection from this input switch
port to the passed output switch port.
7 class AvOutputSwitchPort : AvSourcePort {
getInputConnectionPtr(inputSwitchPortPtr); }
getInputConnectionPtr(inputSwitchPortPtr);
[0069] This function gets the input switch port to which this
output switch port is connected.
8 class AvVirtualCircuit { getCompleteSourcePort(sourcePortPtr);
getCompleteSinkPort(sinkPor- tPtr);
getNumberOfPrimitiveBindings(number);
getPrimitiveBindingPtrs(number, sourcePortPtr, sinkPortPtr); }
getCompleteSourcePort(sourcePortPtr);
[0070] This function returns a pointer to the complete source port
that is producing the signals being routed by this virtual circuit.
getCompleteSinkPort(sinkPortPtr);
[0071] This function returns a pointer to the complete source port
that is receiving the signals being routed by this virtual circuit.
getNumberOfPrimitiveBindings(number);
[0072] This function returns the number of bindings between
primitive source ports and primitive sink ports this virtual
connection. getPrimitiveBindingPtrs(number, sourcePortPtt,
sinkPortPtr);
[0073] This function returns the numbered binding as a pointer to
the primitive source port and a pointer to the primitive sink
port.
9 AvSourcePort class AvSourcePort : AvPort { isActiveSourcePort( );
getAvStreamPtr(streamPtr);
getPrimitiveCircuitPtr(primitiveCircuitPtr);
getNumberOfVirtualCircuits(number); getVirtualCircuitPtr(number,
virtualCircuitPtr); createVirtualCircuit(toSinkPortPtr);
removeVirtualCircuit(toSinkPortPtr); } isActiveSourcePort( );
[0074] This function returns in indication of whether this source
is active. A source port is active when it is capable producing a
signal. getAvStreamPtr(streamPtr);
[0075] This function returns a pointer to the stream associated
with this source port.
getPrimitiveCircuitPtr(primitiveCircuitPtr);
[0076] This function returns a pointer to the primitive circuit
associated with this source port if this primitive source port.
getNumberOfVirtualCircuits(number);
[0077] This function returns the number of virtual circuits that
are associated with this source port. getViriualCircuitPtr(number,
virtualCircuitPtr);
[0078] This function returns a pointer to the numbered virtual
circuit. createVirtualCircuit(toSinkPortPtr);
[0079] This function creates a virtual circuit that connects this
source port to the passed sink port.
removeVirtualCircuit(toSinkPortPtr);
[0080] This function removes the virtual circuit that connects the
source port to the passed sink port.
[0081] FIG. 10 is a block diagram illustrating the components of an
entertainment center. An entertainment center component provides a
behavior that allows an AV program to be assigned to a
player/recorder component. When a program is assigned to an
entertainment center, the entertainment center performs the
processing that is needed to load that program into a
player/recorder, cause the program to be played, and route the
output signals of the player/recorder component to output
components. An entertainment center may be associated with a space
(e.g, a room within a house). The entertainment center may also be
associated with multiple player/recorders and multiple output
components such as a display component and a speaker subsystem
component. The AV system represents the associated space by a space
object 1001, represents the player/recorder components by
player/recorder objects 1002, and represents the output components
by a display object 1003 and a speaker subsystem object 1004. An
entertainment center may have a default set of the output
components. When a program is assigned to the entertainment center,
the output signals for the player/recorder component are routed to
these default output components. The entertainment center controls
the creating of virtual circuits that are needed to effect this
routing. The entertainment center may also allow the output signals
of a player/recorder component to be dynamically routed to
different output components. For example, the entertainment center
may allow the output of the player/recorder component to be
dynamically routed to a speaker system component associated with
another space. To effect this dynamic routing, the AV system
creates and destroys virtual circuits dynamically. In one
embodiment, the entertainment center may determine for each of its
output components whether the routing should be allowed, whether to
be notified when an output signal is routed due to an action
external to the entertainment center, and whether to provide a user
interface for controlling the output component to which the signal
is routed. These determinations may be different for each output
component associated with the entertainment center. When an
entertainment center is notified that one of its output components
has been routed due to an external action (e.g. a different
entertainment center routing to the output component causing the
notification), the entertainment center can become an additional
controller of the player/recorder. An entertainment center may also
provide property notifications when the properties of its
associated player/recorder components or output components change.
For example, the entertainment center may notify a corresponding
user interface component that the pause button on a player/recorder
component has been depressed. An entertainment center object may
provide a user interface component that is appropriate for
controlling the user interface of the input components and output
components associated with the entertainment center.
[0082] FIG. 11 illustrates a block diagram illustrating various
components of the AV system. The AV system includes player/recorder
objects 1101, display objects 1102, speaker system objects 1103,
media manager objects 1104, and program objects 1105. A
player/recorder object has one or more complete source port objects
associated with it and may have one or more complete sink port
objects associated with it. Each output object has one or more
complete sink ports associated with it. A player/recorder object
typically corresponds to a physical player/recorder component, such
as laserdisc player. The player/recorder object provides a behavior
to load an AV program into the player/recorder component. A
player/recorder object also provides a behavior that allows
commands to be sent to the player/recorder component. For example,
after a laserdisc has been loaded, a start, pause, or stop command
can be sent via the player/recorder object to the player/recorder
component. The player/recorder object also provides the behavior to
determine whether a particular AV program can be loaded into the
player/recorder component. A player/recorder object may also
provide additional behavior that is customize to the
characteristics of the corresponding player/recorder component.
[0083] The output objects that correspond to the output components
provide a behavior that returns the identification of a sink port
object that is appropriate for assigning the signals associated
with a specified stream object. For example, a speaker system
object that is passed a stream that includes both video and audio
signals would return an indication that only audio sink ports are
to be assigned. The output objects may also provide additional
behavior that is specific to the type of output component. For
example, a display object may provide behavior for turning the
display on and off and for controlling the contrast of the display.
A speaker system object may provide behavior for controlling the
volume, equalizer functions, and surround sound system controls.
This additional behavior may be part of the base object class or
may be provided through a derivation of that base object class.
[0084] A program pool object represents a collection of AV
programs. Each AV program has a corresponding program object. An AV
program conceptually corresponds to a media that can be played by a
player/recorder component. For example, an AV program may represent
the feed provided through a certain television channel, a musical
score stored on a CD, a movie stored on a laserdisc, and so on.
These AV programs can be hierarchically organized to represent more
complex AV programs. For example, an AV program may include a
sub-AV program corresponding to the feed from a television channel
and a sub-AV program corresponding to the output of a computer
program. Thus, AV programs can represent arbitrarily complex
multimedia programs. The AV system represents an AV program by a
program object. A program object provides the behavior to browse
through the hierarchy of the AV programs represented by that
program object, allows a player/recorder component to be assigned
to the AV program, and provides a behavior corresponding to the
loading of the AV program into the player/recorder component. A
program object also has a program ID, which provides descriptive
information about the AV program. For example, descriptive
information may include the name of the movie that the AV program
represents. A program object stores the location of the media that
corresponds to the AV program. For example, if the AV program
corresponds to a laserdisc in a certain laserdisc stack, then the
location would indicate the stack and slot of the laserdisc within
the stack. In one embodiment, the location is represented as a path
within a hierarchy of locations. A program object stores the
identifier of an owner, which may be the program pool object that
the program object is within. A program object allows for the
retrieving of its child program objects and may allow for certain
criteria to be established so that only children that match the
criteria are returned. A program object may also allow for
retrieving of its parent program object. In one embodiment, the
parent program object may be retrieved through the containing
program pool by providing the location of the program object to the
program pool. A program object has a program type associated with
it. The program type specifies a path through a hierarchy of
program types. The hierarchy of program types is described below in
detail.
[0085] In one embodiment, the AV system provides a capability for
resolving a program ID into many different types of references. For
example, the AV system may provide a get program object function
that inputs a program ID and returns a reference to a corresponding
program object. The AV system may also provide a get program genre
function that inputs a program ID and returns a set of program
objects in the same genre. For example, a program ID for a country
music song when provided to the get program genre function would
return references to program objects corresponding to other country
music songs. To implement such multi-resolution references, the
functions may access the program object associated with the program
ID to retrieve information on its genre.
[0086] A program object may provide alternate interfaces for
maintenance of state. For example, a program object may provide an
interface for adding and deleting properties of the program object
and setting properties of the program object. An alternate
interface may also provide for the adding and deleting of child
program objects or for the deleting of the program object itself.
These interfaces may be specific to the type of AV program
represented by the program object.
[0087] A program pool has a corresponding program pool object. A
program pool object provides an access port for each client that is
accessing the program pool. The program pool object provides a
function that receives a program ID and returns a reference to a
program object corresponding to that program ID. A program pool
object also allows for database cursor-like access to the program
objects. For example, a query can be submitted which specifies the
criteria for program objects. The program objects that match that
criteria are provided in a result set. The client can access that
result set using techniques such as advance to the next program
object, get reference for the current program object, and return a
set of references for the program objects in the result set. In one
embodiment, the result set of a query may be cached at a client to
reduce communications between the clients in the program pool. The
program pool may also automatically update the client's cache as
the set of programs that match the criteria changes. In one
embodiment, the program pool provides an access control mechanism
to restrict access by certain clients. The program pool may use the
phantom object mechanism as described in U.S. application Ser. No.
09/322,455, entitled "Method and System for Tracking Clients."
[0088] The media manager provides a mechanism for managing media at
its location and for providing a player/recorder object for the
media itself. For example, a media manager object may correspond to
a multi-laserdisc stack. The media manager object provides a load
program function that is passed a program object and that returns a
player/recorder object with that program loaded. A media manager
may be hierarchically organized. That is, a media manager object
may have child media manager objects to an arbitrary level of
nesting. Each parent media manager object may have an associated
location table. The location table maps the location of a program
to the media manager object that is responsible for returning the
player/recorder object for that program object. A media manager
object that has no child object may process the location of the
program object to identify which player/recorder to associate with
the program object. For example, if a media manager object
represents a multi-laserdisc stack, then the media manager object
may use the location associated with that program object to
determine which slot within the stack contains the media for that
program.
[0089] FIG. 12 is a flow diagram illustrating the assigning of a
program to an entertainment center. In step 1201, the function
invokes a function to select a certain program object. The invoked
function returns a pointer to the program object. In step 1202, the
function invokes the set current program function of the
entertainment center object passing the pointer to the program
object. The processing is then complete.
[0090] FIG. 13 is a flow diagram of a function to select a program.
This function may display a user interface that allows a user to
browse through the programs in a program pool. The user interface
may allow the user to specify various search criteria. For example,
the user interface may allow the user to specify the type of music
that is of interest. In step 1301, the function allows the user to
select a program from the program pool. In step 1302, the function
sets the return pointer to a pointer to a program object
representing the program. The function then returns.
[0091] FIG. 14 is a flow diagram representing an example
implementation of a set of current program function of an
entertainment center object. This function is passed a pointer to a
program object and effects the loading of that program within the
entertainment center. In step 1401, the function invokes a function
to retrieve a loaded player/recorder object. The function passes a
pointer to the program object and is returned a pointer to a
player/recorder object that is loaded with the program. In step
1402, the function invokes the get current source function of the
player/recorder object. That invoked function returns a pointer to
the complete source port for the player/recorder object. In step
1403, the function invokes the get stream pointer function of the
source port object to retrieve a pointer to the complete stream for
that source port object. In steps 1404-1407, the function loops
selecting the output components associated with the entertainment
center and creating a virtual circuit from the player/recorder
component to the output components. As described above, a
entertainment center may have a default set of output components.
In step 1404, the function selects the next output component. In
step 1405, if all the output components have already been selected,
then the function returns, else the function continues at step
1406. In step 1406, the function requests the selected output
component to return a sink port object that is appropriate to the
stream. The function invokes a get sink port function of the output
object corresponding to the selected output component. In step
1407, the function invokes the create virtual circuit function of
the source port object passing a pointer to the sink port object.
That invoked function creates a virtual circuit from the source
port to the sink port. The function then loops to step 1404 to
select the next output component.
[0092] FIG. 15 is a flow diagram of an example implementation of a
function to get a loaded player/recorder object. This function is
passed a pointer to a program object and returns a pointer to a
player/recorder object. In step 1501, the function retrieves the
location of the program object. In step 1502, if the location
indicates that a player/recorder component is already associated
with this program object, then the function continues at step 1503,
else the function continues at step 1504. In step 1503, the
function invokes the load yourself function of the program object
and receives a pointer to a loaded player/recorder object in
return. In step 1504, the function gets a player/recorder object
that is appropriate to the entertainment center. In step 1505, the
function invokes a load program function of the player/recorder
object passing the pointer to the program object. The function then
returns.
[0093] FIG. 16 is a flow diagram of example implementation of the
load yourself function of the player/recorder object. This function
is passed a pointer to a program object that is to be loaded into
the player/recorder component. In step 1601, the function invokes a
load program function of the media manager object passing a pointer
to the program object and receiving a pointer to a player/recorder
in return. In step 1602, the function invokes the load program
function of the player/recorder object passing the program pointer
and then returns.
[0094] FIG. 17 is a flow diagram of an example implementation of
the load program function of a player/recorder object. This
function is passed a pointer to a program object and effects the
loading of the program into that player/recorder component. In step
1701, the function identifies a complete source port that is
appropriate for the passed program. A player/recorder component may
have more than one complete source port. For example, a
player/recorder object may have a complete source for corresponding
to an RGB signal and another complete source port corresponding to
a digital video signal. In step 1702, the function assigns the
program object to the player/recorder object. In step 1703, the
function determines the usage, format, and port type for the
primitive ports of the selected source port. In step 1704, the
function invokes the set signal function of the complete source
port passing the usage, format, and port type. The invoked function
sets the usage, format, and port type for each primitive source
port. In step 1705, the function notifies the program object that
it has now been loaded. The function then returns.
[0095] FIG. 18 is a flow diagram of an example load program
function of a media manager object. This example function describes
the processing that may be performed when the media manager has
child media manager objects. This function is passed a pointer to a
program object and returns a pointer to a player/recorder object.
In step 1802, the function invokes the get location function of the
program object to retrieve the location of the media as indicated
by the program object. In step 1801, the function searches the
location table for a media manager object that manages the media
corresponding to the program object. In step 1803, the function
invokes the load program function of the located media manager
object and then returns.
[0096] FIG. 19 is a flow diagram of an another example load program
function of the media manager object. This example function
describes the processing that may be performed when the media
manager object has no child media manager object. In step 1901, the
function retrieves the location from the program object and finds
the media associated with that location. In step 1902, the function
initializes a player/recorder object for that media. In step 1903,
the function sets a return pointer to point to player/recorder
object. The function then returns.
10 class Program { getProgramId(Id); getProgramType(type);
getProgramLocation(location); getDescPropteryValueByName(name,
value); getOwnerObjectPtr(ownerP- tr); getPlayerRecorderPtr(prPtr);
loadYourself( ); unloadYourself( ); getParent(parentPtr);
getChild(childPtr); } class ProgramPool { getPort(progPoolPortPtr);
} class ProgPoolPort { getReference(id, progPtr);
getCursor(progPoolCursorPtr); } class ProgramPoolCursor {
getMatchingSetOfReferences(set); submitQuery(query); advance( );
getReference(progPtr); clone(ProgPoolPtr); } class PlayerRecorder {
canLoadProgram(progPtr); loadProgram(progPtr);
sendControlCommand(command); } class EntertainmentCenter {
setCurrentActiveSourceProgram(progPtr); }
[0097] One skilled in the art would appreciate that various
modifications can be made to the present invention. Accordingly,
the invention is not limited to the specific embodiments, but
instead the scope of an invention is specified by the following
claims.
* * * * *