BeCommÔ Corporation
`
`Using BeComm’s RADkit to develop Distributed
`Network Applications
` A Case Study – The Distributed Media Player
`
`BeCommÔ Corporation
`4160 – 148th Avenue, N.E.
`Redmond, WA 98052
` USA
`
`http://www.becomm.com
`
`Page 1 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`
`
`
`Contents
`
`
`
`Objective (per Motorola specification) ............................................................................... 3
`Overview ............................................................................................................................. 4
`Tools: .............................................................................................................................. 4
`Setup ............................................................................................................................... 4
`Building the DMP Applications.......................................................................................... 5
`The Distributed Namespace ............................................................................................ 5
`Populating the Namespace .......................................................................................... 6
`Querying the Namespace ............................................................................................ 6
`DataFlows ....................................................................................................................... 6
`Creating a DataFlow ................................................................................................... 6
`Synchronizing a DataFlow .......................................................................................... 7
`Managing a DataFlow ................................................................................................. 7
`Beyond the DMP Application ............................................................................................. 7
`Under the covers: how Strings works ................................................................................. 8
`Summary ............................................................................................................................. 9
`
`
`
`Page 2 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`
`Objective (per Motorola specification)
`To build a Distributed Audio Player application that meets the following requirements.
`• The audio player must play out audio files of multiple formats including MP3,
`Microsoft Media, and Real Media.
`• The audio player must play out audio from either downloaded files or "live"
`streams from the Internet.
`• The audio player must support play lists.
`• The audio player must be distributed between a central location and a lightweight
`end-point where the connection to a stereo occurs.
`• The user must be able to control the player to:
`o Select a play list
`o Select content form the Internet
`o Start and stop play-out, skip a selection
`
`Features that are not included in this example of the DMP app but could be easily added
`are:
`• Edit playlist (i.e.: add, remove, reorder songs in list)
`• Auto-generate playlists (i.e.: make me a playlist of 15 random songs that are Rock
`and less than 5 minutes long)
`• Edit attributes of a song (i.e.: set the Title, Author, Genre, etc)
`• Other stream controls (i.e.: Pause, FF, REW)
`Controls to add/remove endpoints to a playout session.
`
`
`
`Page 3 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`
`Overview
`
`Tools:
`• RADkit Level I consisting of:
`o RADapi for MFC and RADapi for Java
`o Strings runtime
`• Windows development environment (such as MSDEV)
`• Java development environment
`
`Setup
`For clarity this case study’s example will use three ‘media playing’ devices: (see Fig.1)
`• PC-A and PC-B
`o Running Windows 2000
`o Strings Runtime with MP3, RealAudio, and Windows packages installed
`o Distributed Media Player (DMP) Application have been installed
`o Access to the Internet.
`o LAN network connectivity
`• Home Stereo Companion
`o Running Linux
`o A lightweight endpoint with PCM play out capabilities only and no
`storage device
`o Strings Runtime with PCM play-out package installed
`o Java DMP client app installed
`o LAN network connectivity
`
`
`
`
`Home Stereo
`Companion
`• Strings Runtime with
`PCM play-out support
`
`PCs
`• Strings Runtime with
`Windows Media, Real
`Media, and MP3
`support
`• DMP App
`• Internet access
`
`Fig. 1 Example layout for Distributed Media Player Application example (described above)
`
`
`Page 4 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`
`
`Building the DMP Applications
`The application design that will run on both PCs is a standard form-based MFC
`application. The dialog box has two list boxes, one for ‘Songs’ and one for end point
`‘Destinations’; in this case the endpoints are speakers on the local network. Fig. 2 is a
`representation of the user interface that an application developer might build for this
`application.
`
`
`
` File View Play Favorites Go Upgrade Help
`
`Artist
`
`
`
`Media Type
`
` MP3
`
`Genre
`
` Rock n Roll
`
`Search
`
`
`Songs
`
`1. AC/DC – Razor’s Edge
`2. Guns-n-Roses – Welcome to the
`Jungle
`3. Def Leppard - Pyromania
`
`Destinations
`
`1. PC – A Speaker
`2. PC – B Speaker
`3. Home Stereo
`Companion
`
`Fig. 2 Example Distributed Media Player GUI
`
`
`In this example, the MFC application designed to run on the PCs presents a rich GUI to
`the user since PCs have abundantly large display devices such as a monitor. This example
`assumes that the Home Stereo Companion has a small and limited, LED display and
`hardware control buttons for “Play”, “Pause”, “Skip” and “Stop” operations. The
`RADapi supports application development in Java, which allows for applications to be
`built for a variety of platforms including Linux. The Home Stereo Companion’s Java app
`will be refereed to as the DMP Client app.
`
`The Distributed Namespace
`The Distributed Namespace is a browsable data structure that can be populated with
`objects. An object is defined by the class that implements it and the state that instantiates
`it.
`
`
`Page 5 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`The Application can browse the namespace and interact with objects through a variety of
`classes provided by the RADkit. For more information on available classes please see the
`enclosed help file.
`
`Populating the Namespace
`The configuration on each media playing device, in this example PC-A and PC-B,
`specifies a directory in its file system as a storage location for audio files of varying
`formats. These locations are then be scanned at startup by Strings, which populates the
`namespace with the objects found in the file system’s directory. Additionally, the
`configuration allows for registration of the device’s speaker objects in the namespace so
`that other Strings enabled devices may utilize them. The configurations on PC-A, PC-B
`and the Home Stereo Companion register their respective speaker devices in the
`namespace. The result is that each Strings device can utilize objects that are registered in
`the Distributed Namespace regardless of their physical location or the class of the object.
`
`Querying the Namespace
`When the DMP application wishes to obtain the list of media sources and sinks in the
`namespace, it constructs two network queries using the NetworkBrowser class. First it
`submits a query for MP3s, optionally constrained by a user-supplied input of "genre" and
`"artist". For example, if the user typed "Def Leppard" into the "artist" field, the
`application would construct a query to the RADapi for “ext='mp3' AND artist='Def
`Leppard’". The response is a list of MP3 network objects, which the DMP application
`uses to populate the "Songs" list box. Notice that the application (and user) does not
`need to know where the music file objects are physically located - since they are
`populated within the namespace they could be on either PC-A, PC-B or any other
`provider of music file objects.
`
`Next, the application submits a query to the RADapi for all network speakers. It uses
`“Class=='Speaker'” which asks for all network objects that support the "Speaker"
`interface. The DMP application uses these values returned to it by the RADapi to
`populate the “Destinations” list box. Again, the DMP application doesn’t require
`knowledge of where the speakers are on the network, just that they support the speaker
`interface.
`
`DataFlows
`A DataFlow is also an object that can be created and manipulated using the RADapi. A
`DataFlow requires that at least one object is a data ‘source’ and that zero or more objects
`that make up the flow are a data ‘sink’. A DataFlow is assigned a unique identifier by the
`RADapi, and can be managed by the DMP application through the DataFlow class. See
`the included RADapi documentation for more details on the DataFlow class. Objects can
`also be controlled for non- DataFlow specific functions such as volume control on a
`speaker object.
`
`Creating a DataFlow
`The user of the DMP application selects a music file and one or more endpoints. When
`the user presses the "Play" button, the DMP application creates a "session" on the
`selected music file object and a session on each of the selected speaker objects. It then
`creates a DataFlow from the music file session to the speaker sessions. At this point, the
`audio will begin playing on the selected speaker objects. The developer writing the DMP
`application doesn’t require any explicit knowledge of the data transformation that needs
`
`Page 6 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`to take place in order to deliver the content from its source to the sink. Strings
`determines the transformations (or route) that the data needs to make before it can reach
`the endpoint in the correct format. For example, if a Windows Media file is selected on
`PC-A and is to be sent to the Home Stereo Companion, Strings determines that it must
`pass through the Windows Media decoder Feature on PC-A before the PCM can be
`shipped across the network to the Home Stereo Companion. Additionally, The DMP
`application doesn’t need to be aware of whether the audio is from a file or ‘live’ content
`from the Internet. Strings manages the buffering, transformation, and routing of the live
`stream at the source, before sending the PCM data stream across the network to the Home
`Stereo Companion. This is a good example of the flexibility of Strings as the Home
`Stereo Companion can access both Real and Windows Media through one of the Strings
`enabled PCs even though it cannot process those formats by itself.
`
`Synchronizing a DataFlow
`The RADapi also makes it possible to synchronize multiple DataFlow objects with each
`other regardless of content type. This makes it possible to synchronize audio playout on
`multiple endpoints or to synchronize audio with other content such as video or text. In
`this example, the DMP application can use the RADapi to synchronize audio to more than
`one target speaker creating a rich, user audio experience regardless of the actual physical
`nature (i.e. one flow might be compressed whereas another might not) of the content or
`the networks the speakers exist on (i.e. one device might be over a wireless network and
`the other over a HomePNA). Multiple DataFlows can be synchronized with each other in
`a DataFlowGroup or a single DataFlow with multiple end points can specify
`synchronized playout. The DataFlow class allows the DMP application to specify which
`speaker object is the synchronization master, and which is the slave. DataFlow
`synchronization is available for any media type. For example a video file could have the
`video synchronized on one device where the audio is being played out from another
`device on the network.
`
`Managing a DataFlow
`When the user invokes a DataFlow control such as “Start” “Stop”, or “Pause” the DMP
`application passes in the DataFlow identifier and the command name, and Strings
`determines the appropriate network objects that need to be associated with the control
`commands and then propagates them to the appropriate network objects. Since the
`DataFlow is global and unique to the network, the DMP applications on either PC-A, PC-
`B or the Home Stereo Companion can learn about and control a DataFlow. The actual
`application code to manage control of the DataFlow remains very simple because Strings
`does all the work of distributing the control inputs to the appropriate devices.
`
`Beyond the DMP Application
`The DMP application is a basic example of how a distributed network application could
`be built using the RADkit. In addition to audio, application developers using the RADkit
`have extensive flexibility in developing applications which support rich media, disparate
`network technologies and varied devices. Strings provides the flexibility to transform,
`route, and deliver any content to any device in virtually any format.
`
`As next generation wireless mobile devices such as blue tooth enabled phones,
`handhelds, digital Set-Top-Boxes and web tablets become widely available, the RADkit
`can be utilized to rapidly build applications to run on these devices and platforms to take
`full advantage of Strings. Furthermore, applications built using the RADkit, are scalable
`
`Page 7 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`as the consumer adds other Strings enabled processing devices, or content types such as
`videos, pictures, TV content, etc, to their local network.
`
`For example, the RADkit could be used to build an application for a Set-Top-Box and a
`companion web tablet so that the user could experience ‘TV out of TV’. This would
`enable images from the Set-Top-Box to be displayed on both the TV and the companion
`tablet while audio is played in sync to the TV’s stereo speakers. Adding features such as
`channel preview, instant replay and other television related content would be relatively
`simple since the application developer would require minimal knowledge of transport,
`translation and delivery issues related to television content over a network.
`
`Since Strings provides full support for peer-to-peer networking and multimedia
`interaction, developers could easily add support for other application features such photo,
`movie, music and PVR peer sharing; home control; telephony; video conferencing;
`instant messaging and more.
`
`Under the covers: how Strings works
`The Strings application logic is separated into discrete software services called Beads,
`which encapsulate everything from platform services to hardware resources and the
`protocols used to communicate data between these resources. Beads completely hide both
`the interface and the implementation of logic they encapsulate. Strings dynamically
`assembles the optimal set of Beads to facilitate the transformation and transportation of
`data throughout the system. The set of Beads is determined on the fly based on the needs
`of the network, the system, the media types being handled and user preferences. This
`allows Strings to efficiently and optimally manage communication related data as it flows
`through the system. Since Beads separate interfaces and implementation, Strings devices
`can reuse Beads in multiple contexts without requiring additional application code. This
`provides an unprecedented degree of software reuse. In addition, Beads can exist across
`machine boundaries as network services allowing Strings to leverage network services on
`the fly to extend application functionality. Such is the case of the Home Stereo
`Companion’s ability to leverage the PCs to access Windows Media or Real Audio
`Content from the Internet without having the ability to handle this type of content alone.
`
`Incorporated into Strings is a powerful Rules Engine. The Rules Engine makes it
`possible to specify configuration information that is used at runtime by Strings in
`managing dataflow through the system. The Rules Engine allows administrators to
`specify arbitrarily rich conditions that are evaluated in the process of assembling a
`sequence of Beads. Examples might include building rules to force the routing of audio
`or video content to specific locations in the network or ensuring that content of a specific
`type is always encrypted before leaving a device. The Rules Engine makes it possible to
`dynamically change system behavior without having to modify complex application
`code. Since rules can be global in nature, administrators can effectively control system
`behavior across multiple applications.
`
`Strings is platform independent and requires a thin Operating System Portability Layer to
`run on any given Operating System. Strings can be quickly and easily ported to run on
`most modern operating systems. Strings is currently supported on Windows 98, NT4, XP,
`CE, Linux, FreeBSD, VxWorks, and will soon support Symbian OS. Additionally, the
`RADkit is available for development in C++, Java, and ActiveX allowing developers to
`rapidly build applications for a wide variety of platforms.
`
`Page 8 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`

`

`
`The RADkit makes it possible for developers to build applications that leverage the
`advance multimedia, networking and distributed capabilities within Strings without
`having to be consumed with inherent complexities of such systems. This enables
`applications to be built in far less time than would otherwise be possible while still
`enabling the development feature-rich solutions.
`
`Summary
`Whether the project is a distributed media player or a more complete media gateway
`solution, the RADkit allows application developers to rapidly build distributed network
`applications by taking advantage of Strings, to dynamically share, transform, route, and
`deliver rich content such as
`• Audio
`• Video
`• TV (cable) and embedded information such as show information and Closed
`Captioning
`• Web content
`• Email
`• Chat
`to connected devices of varying capabilities such as:
`• PCs
`• Set top boxes
`• Residential Gateways
`• Web Tablets
`• PDAs
`• Mobile phones
`• Home Stereo Companions
`All while minimizing expensive development efforts to create one off custom solutions
`for each unique device.
`
`The RADapi, which ships with the RADkit Level 1 edition, has been included as a
`reference to this document.
`
`Page 9 of 9
`
`Implicit Exhibit 2029
`Sonos v. Implicit, IPR2018-0766, -0767
`
`