RealSystem G2 extends RealNetworks' expertise with RealAudio and RealVideo to provide a complete platform for streaming datatypes and building streaming media applications. RealSystem can stream virtually any datatype from its native file format, including audio, video, images, MIDI, animation, and VRML.
RealSystem provides transparent streaming from any data source, whether a local file system, a database, or a live broadcast. With RealSystem, multimedia content creators can easily combine any number of data formats into a multimedia presentation streamed robustly over any network. Users can receive the presentations in RealPlayer, Web browsers, or custom applications.
The RealSystem G2 Software Development Kit (SDK) provides developers with the public interfaces used to extend and customize RealSystem G2. If you have not done so already, visit the RealNetworks DevZone to download the RealSystem G2 SDK for your platform. RealNetworks designed this SDK for developers who need to do any of the following:
To stream a datatype to RealPlayer, Web browsers, or other applications, you build plug-ins that enable RealServer to stream the datatype and RealSystem clients to render it. RealNetworks will help you make your plug-ins available for download by anyone using RealPlayer or an application enabled for RealSystem.
The public interfaces for the RealSystem client let you incorporate RealSystem capabilities into your application. Then, with the appropriate plug-ins, your application can render streaming datatypes just like RealPlayer.
The RealSystem SDK lets you create logging and monitoring tools for RealServer, or implement data streaming from sources such as databases. You simply build the appropriate plug-in.
![]() |
Note |
---|
You do not need to use the RealSystem G2 SDK to extend RealPlayer's embedded Web page playback capability with JavaScript or VBScript. To do this, get the Embedded RealPlayer Extended Functionality Guide from http://service.real.com/help/library/index.html. |
RealSystem G2 includes RealServer G2 and the RealNetworks clients: RealPlayer G2 and RealPlayer Plus G2. The open RealSystem architecture lets you develop plug-ins that extend the capabilities of RealServer or a RealSystem client. RealServer and RealSystem clients also support open streaming protocols, allowing them to interoperate with other standards-based data streaming systems.
![]() |
Additional Information |
---|
Check http://www.real.com for information about the commercial versions of RealServer G2, RealPlayer G2, and RealPlayer Plus G2. |
RealServer G2, the latest generation of server technology from RealNetworks, runs on Windows NT and many UNIX platforms. It supports broadcasting by multicast or unicast, using TCP/IP, UDP/IP, UDP resend, or HTTP. The open architecture of RealServer G2 provides useful features such as these:
![]() |
Additional Information |
---|
See "Appendix E: RealServer Configuration" and "Appendix F: RealServer Property Registry". |
![]() |
Additional Information |
---|
See "Chapter 19: Authentication". |
![]() |
Additional Information |
---|
See "Chapter 14: Network Services". |
RealPlayer G2 and RealPlayer Plus G2 are the RealNetworks client applications designed to render RealSystem streaming datatypes on Macintosh, Windows, and UNIX platforms. These products ship with a Netscape Plug-in and ActiveX Control that let you play presentations back in the Web browser without launching RealPlayer as a separate application.
![]() |
Note |
---|
For information on Web page playback, see RealSystem G2 Production Guide, available as HTML or PDF at http://service.real.com/help/library/index.html. |
As with RealServer, the RealSystem client is based on an open architecture that lets you customize client features or add client functionality to an application. As explained in "Chapter 20: Top-Level Client", sample code and documentation explain how to add RealSystem client functionality to an application:
![]() |
Additional Information |
---|
See "Chapter 13: Audio Services". |
![]() |
Additional Information |
---|
See "Chapter 12: Sites (Windowing)". |
![]() |
Additional Information |
---|
See "Chapter 14: Network Services". |
When communicating with RealPlayer G2, RealServer G2 by default uses Real Time Streaming Protocol (RTSP) as its control protocol and RealNetworks RDP as its proprietary packet protocol. RealSystem also supports the open-standard RTP packet protocol, enabling RealServer and RealSystem clients to interoperate with RTP-based servers or clients. Both RealServer G2 and the RealPlayer G2 client also support RealNetworks PNA proprietary protocol for backwards compatibility with earlier versions of RealSystem.
Multimedia presentations controlled through RTSP are defined with Synchronized Multimedia Integration Language (SMIL), an open language based on SGML. A SMIL file lists the locations of the media files (video, audio, animation, text, and so on) that make up the presentation, specifying how and when each media file plays. You can use a SMIL file to stream multiple tracks simultaneously, stream tracks in a given sequence, and stream different versions of tracks based on feedback by the client.
The World Wide Web Consortium (W3C) has released the SMIL 1.0 specification as a W3C Recommendation. For information on SMIL mark-up, please see RealSystem G2 Production Guide available at http://service.real.com/help/library/index.html.
The heart of RealSystem is the plug-in architecture of RealServer and RealSystem clients. This architecture lets RealServer stream any datatype, and also lets you customize RealServer features. With this SDK, you can build these types of plug-ins:
This plug-in converts a certain datatype to packets that RealServer can stream. Although RealServer primarily uses file format plug-ins for streaming, RealSystem clients also use them to play local files.
![]() |
Note |
---|
Because RealServer and RealSystem clients share the same RealSystem architecture, plug-ins developed for RealServer work for RealSystem clients with no additional coding requirements. |
This plug-in receives streamed packets and renders them for playback on the RealSystem client. Every file format plug-in has a corresponding rendering plug-in.
RealServer and RealSystem clients use a file system plug-in to read files from a data source. Because server and clients include plug-ins for reading from local disks, you have to build a file system plug-in only to customize the server or client to read from an alternate data source such as a database.
A broadcast plug-in converts a live data source to a RealSystem packet stream. Although you can build your own broadcast plug-in, RealSystem includes remote broadcast libraries that tie an encoder application to RealServer's standard broadcast plug-in. This lets you easily broadcast live audio or video data, as well as RealText or RealPix.
![]() |
Additional Information |
---|
See "Chapter 8: Broadcast Plug-in". For more on remote broadcast features, see "Chapter 16: Remote Broadcast", "Chapter 17: RealText Broadcast", and "Chapter 18: RealPix Broadcast". |
A monitor plug-in can retrieve system information from the RealServer registry. This includes, for example, the number of clients currently connected and the URL requested by each client. You can also define new properties stored in the RealServer registry.
![]() |
Additional Information |
---|
"Chapter 9: Monitor Plug-in". |
Allowance plug-ins allow only certain requests or actions from a RealSystem G2 client.
![]() |
Additional Information |
---|
"Chapter 10: Allowance Plug-in". |
On Windows, RealSystem plug-ins are 16-bit or 32-bit DLLs. On UNIX and Macintosh they are shared libraries. Because RealSystem provides several cross-platform services, the plug-ins you develop will require little or no code specific to the operating system.
The most common example of RealSystem in action is streaming files from RealServer to RealPlayer when the user clicks a link in a Web page. The following figure explains the steps that take place to make this happen.
The flexibility of RealSystem allows many variations on this basic scenario:
Multimedia presentations streamed by RealServer typically consist of more than one datatype. Each datatype can have more than one stream. AVI, for example, uses separate streams for video and audio data. The sources for streamed data may be separate files specified within an SMIL file. Or they may be combined in a single file of a container datatype, such as ASF or RealMedia File Format (RMFF).
This figure shows three files that make up a multimedia presentation. Files A and C each contain a visual datatype rendered in a client window. File B contains audio data played on the client computer's sound system. The RealSystem client launches a separate rendering plug-in for each datatype, ensuring that the three parts stay synchronized to their single timeline during playback.
RealSystem clients can receive files from a Web server. As shown in the following figure, clients have an HTTP file system plug-in that allows them to communicate with Web servers. Clients also use the file format plug-in for the streamed datatype. Because RealServer and RealSystem clients share the same architecture, file format plug-ins work on either the server or client side.
HTTP streaming provides a reasonable method of delivering short clips from a Web server using the HTTP protocol. It is not as robust as RealServer streaming, however, and it lacks features such as searching. When the user seeks forward in the presentation timeline, for example, the client stops rendering the datatype but continues to process the data as it comes in at its normal rate. Rendering resumes once the streamed data reaches the timeline position designated by the seek.
A RealSystem client can also play back files on the local machine. It uses its standard file system plug-in to access the local disk, and uses file format and rendering plug-ins for the file datatype to play the file. As noted previously, file format plug-ins work on either the server or client side.
RealPlayer Plus G2 lets the user record a presentation streamed by RealServer. The user can then play the recorded file back locally. Other RealSystem clients can support this feature as well. A RealSystem content creator can override this feature, however, and prevent the recording of, for instance, a pay-per-view video.