Purpose: | Provides miscellaneous information needed to transmit a live stream. |
Implemented by: | File format plug-in |
Used by: | Information not yet available at publication. |
Header file: | rmalvpix.h |
The IRMALiveFileFormatInfo
interface contains the following methods:
IRMALiveFileFormatInfo::FormResendPacket
IRMALiveFileFormatInfo::GetResendBitrate
IRMALiveFileFormatInfo::GetResendDuration
IRMALiveFileFormatInfo::IsLiveResendRequired
IRMALiveFileFormatInfo::VerifyFileCompatibility
IRMALiveFileFormatInfo::VerifyStreamCompatibility
As with all COM interfaces, the IRMALiveFileFormatInfo
interface inherits the following IUnknown
methods:
Forms a live resend packet based on the original packet passed as the first parameter. This allows the file format plug-in to make resend packets distinguishable from original packets.
STDMETHOD(FormResendPacket) (
THIS_
IRMAPacket* pOriginalPacket,
REF(IRMAPacket*) pResendPacket
) PURE;
IRMAPacket
interface that manages the original packet.
IRMAPacket
interface that manages the live resend packet.
Gets the rate at which packets should be resent if periodic live resends are required for this stream.
STDMETHOD(GetResendBitrate) (
THIS_
UINT16 unStreamNumber,
REF(UINT32) ulBitrate
) PURE;
Gets the duration between the time a packet is sent and is then resent if periodic live resends are required for this stream.
STDMETHOD(GetResendDuration) (
THIS_
IRMAPacket* pPacket,
REF(UINT32) ulDuration
) PURE;
IRMAPacket
interface that manages the packet.
Returns TRUE
if the indicated stream requires the latest packet to be resent periodically in a live presentation.
STDMETHOD_(BOOL,IsLiveResendRequired) (
THIS_
UINT16 unStreamNumber
) PURE;
Compares two file headers and returns PNR_OK
if these two files can be transmitted sequentially in a single live presentation.
STDMETHOD(VerifyFileCompatibility) (
THIS_
IRMAValues* pFileHeader1,
IRMAValues* pFileHeader2
) PURE;
IRMAValues
interface that manages the header for the first file.
IRMAValues
interface that manages the header for the second file.
Compares two stream headers and returns PNR_OK
if these two streams can be transmitted sequentially in a single live presentation.
STDMETHOD(VerifyStreamCompatibility) (
THIS_
IRMAValues* pStreamHeader1,
IRMAValues* pStreamHeader2
) PURE;
IRMAValues
interface that manages the header for the first stream.
IRMAValues
interface that manages the header for the second stream.
Purpose: | Sends LiveRealPix data and mark-up to the LiveRealPix Broadcast Library |
Implemented by: | LiveRealPix Broadcast Library |
Used by: | LiveRealPix broadcast application |
Header file: | rmalvpix.h |
This interface is used for live broadcasting of RealPix, as with successive jpeg images from a camera. A LiveRealPix broadcast application uses this interface to send LiveRealPix data and mark-up to the LiveRealPix Broadcast Library, which then broadcasts the images through RealServer.The response interface is IRMALiveRealPixResponse
.
![]() |
Additional Information |
---|
See "Chapter 18: RealPix Broadcast". |
The IRMALiveRealPix
interface contains the following methods:
IRMALiveRealPix::GetTime
IRMALiveRealPix::InitImage
IRMALiveRealPix::Process
IRMALiveRealPix::SendEffect
IRMALiveRealPix::SendImage
IRMALiveRealPix::StartEncoder
IRMALiveRealPix::StopEncoder
As with all COM interfaces, the IRMALiveRealPix
interface inherits the following IUnknown
methods:
Returns the current time, in milliseconds, from the encoder.
STDMETHOD_(UINT32, GetTime) (
THIS
) PURE;
Prepares an image for being sent. This method simply breaks the image up into packets; nothing has yet been sent to the server. This is not an asynchronous call; all processing has finished by the time this call returns.
STDMETHOD(InitImage) (
THIS_
PixImageInfo *pImageInfo
) PURE;
PixImageInfo
structure that contains all the information for images that should be sent down the stream.
Gives the library time to send packets to the server. This method should be called very often in between IRMALiveRealPix::SendImage
and IRMALiveRealPixResponse::ImageSent
, as well as between IRMALiveRealPix::SendEffect
and IRMALiveRealPixResponse::EffectSent
. Other than these times, it should be called every three to five seconds.
STDMETHOD(Process) (
THIS
) PURE;
Creates an effect packet and immediately adds this packet to the packet send queue. Further calls to IRMALiveRealPix::Process
result in this packet being sent to the server. A handle is returned in the PixEffectInfo
structure by which this effect can later be identified. When the effect has been sent to the server, the encoder responds with IRMALiveRealPixResponse::EffectSent
.
STDMETHOD(SendEffect) (
THIS_
PixEffectInfo *pEffectInfo
) PURE;
PixEffectInfo
structure that contains all the information about the effect that the RealPix renderer should perform.
Tranfers all the packets for the image into the packet send queue. Further calls to IRMALiveRealPix::Process
result in these packets being sent to the server. When all the packets for this image have been sent, the encoder responds with IRMALiveRealPixResponse::ImageSent
.
STDMETHOD(SendImage) (
THIS_
UINT32 ulImageHandle
) PURE;
Starts the encoder. The encoder responds to this call asynchronously with IRMALiveRealPixResponse::EncoderStarted
.
STDMETHOD(StartEncoder) (
THIS_
PixInitInfo *pInitInfo,
IRMALiveRealPixResponse *pResponse
) PURE;
PixInitInfo
structure that contains the initialization information.
IRMALiveRealPixResponse
interface that manages the response to various methods in this interface.
Informs the encoder that no more images of effects are going to be sent to the encoder. The encoder shuts down the connection to the server and responds with IRMALiveRealPixResponse::EncoderStopped
. This method can be called at any time after calling IRMALiveRealPix::StartEncoder
. Also, since the encoder can call back with IRMALiveRealPixResponse::EncoderStopped
at any time, your application should be prepared to handle that situation.
STDMETHOD(StopEncoder) (
THIS
) PURE;
Purpose: | Provides responses from IRMALiveRealPix |
Implemented by: | LiveRealPix Broadcast Library |
Used by: | LiveRealPix broadcast application |
Header file: | rmalvpix.h |
This interface provides responses to many of the methods implemented by the IRMALiveRealPix
interface.
![]() |
Additional Information |
---|
See "Chapter 18: RealPix Broadcast". |
The IRMALiveRealPixResponse
interface contains the following methods:
IRMALiveRealPixResponse::EffectSent
IRMALiveRealPixResponse::EncoderStarted
IRMALiveRealPixResponse::EncoderStopped
IRMALiveRealPixResponse::ErrorOccurred
IRMALiveRealPixResponse::ImageSent
As with all COM interfaces, the IRMALiveRealPixResponse
interface inherits the following IUnknown
methods:
Indicates whether the effect was sent successfully.
STDMETHOD(EffectSent) (
THIS_
PN_RESULT status,
UINT32 ulEffectHandle
) PURE;
IRMALiveRealPix::SendEffect
operation. If this parameter is PNR_OK
, the call completed successfully.
m_ulHandle
member of the PixEffectInfo
structure by IRMALiveRealPix::SendEffect
.
Indicates whether the encoder started successfully.
STDMETHOD(EncoderStarted) (
THIS_
PN_RESULT status,
const char *pszHeaderString
) PURE;
IRMALiveRealPix::StartEncoder
operation. If this parameter is PNR_OK
, the call completed successfully.
Indicates whether the encoder stopped successfully.
STDMETHOD(EncoderStopped) (
THIS_
PN_RESULT status
) PURE;
IRMALiveRealPix::StopEncoder
operation. If this parameter is PNR_OK
, the call completed successfully. At this point, the application can then shut down or call IRMALiveRealPix::StartEncoder
again.
Indicates the encoder has received an error from the server. Depending upon the severity of the error, the server might shut down the encoder and an IRMALiveRealPixResponse::EncoderStopped
call would be made. Therefore, the application should be ready to handle an IRMALiveRealPixResponse::EncoderStopped
call at any time. If an error occurs, you should call IRMALiveRealPix::StopEncoder
and shut down the encoder from the application side.
STDMETHOD(ErrorOccurred) (
THIS_
const UINT8 unSeverity,
const ULONG32 ulRMACode,
const ULONG32 ulUserCode,
const char *pszUserString,
const char *pszMoreInfoURL
) PURE;
Indicates whether the send image operation completed successfully.
STDMETHOD(ImageSent) (
THIS_
PN_RESULT status,
UINT32 ulImageHandle
) PURE;
IRMALiveRealPix::SendImage
operation. If this parameter is PNR_OK
, the call completed successfully.
Purpose: | Sends RealText data and mark-up to the RealText Broadcast Library |
Implemented by: | RealText Broadcast Library |
Used by: | RealText broadcast application |
Header file: | rmalvtxt.h |
This interface is used for live broadcasting of RealText, as with a live stock ticker feed. A RealText broadcast application uses this interface to send RealText data and mark-up to the RealText Broadcast Library, which then broadcasts the text through RealServer. There is no response interface.
![]() |
Additional Information |
---|
See "Chapter 17: RealText Broadcast". |
The IRMALiveText
interface contains the following methods:
IRMALiveText::AddData
IRMALiveText::AddTickerItem
IRMALiveText::EncoderIsDone
IRMALiveText::EncoderIsInitialized
IRMALiveText::flush
IRMALiveText::GetTime
IRMALiveText::InitLiveText
IRMALiveText::PacketsHaveStarted
IRMALiveText::Process
IRMALiveText::SetBackgroundColor
IRMALiveText::SetDoLooping
IRMALiveText::SetEncoderDone
IRMALiveText::SetHyperlinkInfo
IRMALiveText::SetTextMotion
IRMALiveText::SetType
IRMALiveText::SetWindowDimensions
IRMALiveText::UseWordwrap
As with all COM interfaces, the IRMALiveText
interface inherits the following IUnknown
methods:
STDMETHOD(AddData) (
THIS_
char* szMoreData,
BOOL bSendImmediately
) PURE;
TRUE
, forces the encoder to send all text that has been added (and not yet sent) immediately. If FALSE
, the encoder decides when to send the text it has buffered based on the length of the text in the buffer and the time since the last packet was sent.
Adds "tickertape" text to the stream. This method prepends "<TU>" to the characters in the szTickerUpperData
parameter, and "<TL>" to the characters in the szTickerLowerData
parameter. Therefore, calling AddTickerItem("ABCD", "5 1/2", TRUE)
is the same as calling AddData("<TU>ABCD", FALSE)
followed by AddData("<TL>5 1/2", TRUE)
, except that the former guarantees that the "upper" and "lower" items are sent in the same packet.
STDMETHOD(AddTickerItem) (
THIS_
char* szTickerUpperData,
char* szTickerLowerData,
BOOL bSendImmediately
) PURE;
TRUE
, forces the encoder to send all text that has been added (and not yet sent) immediately. If FALSE
, the encoder decides when to send the text it has buffered based on the length of the text in the buffer and the time since the last packet was sent.
Indicates whether the library has broadcast all the text it has received. A return value of TRUE
indicates it has finished broadcasing all the text.
STDMETHOD_(BOOL,EncoderIsDone) (
THIS
) PURE;
Indicates whether the library has received the initialization parameters that enable it to connect to the RealServer broadcast plug-in. After initialization, the library is ready to receive text. A return value of TRUE
indicates the library has received the initialization parameters.
STDMETHOD_(BOOL,EncoderIsInitialized) (
THIS
) PURE;
Tells the encoder to send everything that is in the buffer, then clear the buffer.
STDMETHOD(flush) (
THIS
) PURE;
Returns the current system time in milliseconds.
STDMETHOD_(UINT32,GetTime) (
THIS
) PURE;
Sets up the encoder so it can stream data through the server. The user name, password, and port are all values set up on the server (located at pAddress
). This method must be called before any of the other IRMALiveText
methods.
STDMETHOD(InitLiveText) (
THIS_
char* pAddress,
UINT16 port,
char* pUsername,
char* pPassword,
char* pFilename
) PURE;
{ /encoder/, pn-encoder, Port=#### }
pUsername
. This is the same password used by RealAudio encoders.
rtsp://srv1:8080/encoder/foo.rtx
".
Indicates whether packets have started. A return value of TRUE
indicates the packets have started.
STDMETHOD_(BOOL,PacketsHaveStarted) (
THIS
) PURE;
Allows the library to perform necessary processing. This method should be called after calling IRMALiveText::AddData
, IRMALiveText::AddTickerItem
, or IRMALiveText::flush
. When not sending text, the application should also call this method approximately every five seconds. This method is required due to the asynchronous nature of RealSystem.
STDMETHOD(Process) (
THIS
) PURE;
Controls the window's background color. If the application does not use this method, the property's default value is used.
STDMETHOD(SetBackgroundColor) (
THIS_
char* szBackgroundColor
) PURE;
Determines whether looping occurs. This method for "TickerTape"-type windows only; it is ignored by all other types. If the application does not use this method, the property's default value is used.
STDMETHOD(SetDoLooping) (
THIS_
BOOL bDoLooping
) PURE;
TRUE
, looping will occur.
Notifies the library that the application has finished sending text.
STDMETHOD(SetEncoderDone) (
THIS
) PURE;
Specifies whether hyperlinks are underlined and sets the hyperlink color. If the application does not use this method, the property's default value is used.
STDMETHOD(SetHyperlinkInfo) (
THIS_
BOOL underlineHyperlinks,
char* szLinkColor
) PURE;
TRUE
, the hyperlinks are underlined.
Sets the window's scroll rate and crawl rate. If the application does not use this method, the property's default value is used.
STDMETHOD(SetTextMotion) (
THIS_
LONG32 scrollrate,
LONG32 crawlrate
) PURE;
Determines the window type (generic, tickertape, and so on). If the application does not use this method, the property's default value is used.
STDMETHOD(SetType) (
THIS_
char* szType
) PURE;
A scrollingnews window is preset to have text scroll from the bottom of the window to the top at a set rate for the entire presentation.
Text in a tickertape window crawls from the right side of the window to the left. It can also loop back around to the right. Text displays next to the window's top or bottom edge.
The marquee window is like the TickerTape in that text crawls from right to left and can loop. It is different in that text is centered vertically within the window.
A teleprompter window behaves like a generic window except that text arriving at the bottom edge of the window causes the text above it to move up just enough to display the new line.
Controls the window's width and height. If the application does not use this method, the property's default value is used.
STDMETHOD(SetWindowDimensions) (
THIS_
ULONG32 width,
ULONG32 height
) PURE;
Sets word wrap on or off. If the application does not use this method, the property's default value is used.
STDMETHOD(UseWordwrap) (
THIS_
BOOL useWordwrap
) PURE;
TRUE
, sets word wrap on.
Purpose: | Sends RealText data and mark-up to the RealText Broadcast Library |
Implemented by: | RealText Broadcast Library |
Used by: | RealText broadcast application |
Header file: | rmalvtxt.h |
This interface is an addition to the IRMALiveText
interface, which is used for live broadcasting of RealText, as with a live stock ticker feed. A RealText broadcast application uses this interface to send RealText data and mark-up to the RealText Broadcast Library, which then broadcasts the text through RealServer. There is no response interface.
The IRMALiveText2
interface contains the following methods:
IRMALiveText2::DeclareAverageBitrate
IRMALiveText2::DeclareMaximumBitrate
IRMALiveText2::GetLastSentTextEndTime
IRMALiveText2::IgnoreExtraSpaces
IRMALiveText2::SetFlags
IRMALiveText2::SetTimeBetweenDryStreamResends
As with all COM interfaces, the IRMALiveText2
interface inherits the following IUnknown
methods:
Gives an estimate of the bit rate needed by a live text stream so the server can determine whether or not a player can view the stream based on its available bandwidth. This method should be called before sending any data.
STDMETHOD(DeclareAverageBitrate) (
THIS_
ULONG32 ulAvgBitsPerSecond
) PURE;
Gives the maximum bit rate needed by a live text stream so that the server can determine whether or not a player can view the stream based on its available bandwidth. This method should be called before sending any data.
STDMETHOD(DeclareMaximumBitrate) (
THIS_
ULONG32 ulMaxBitsPerSecond
) PURE;
Tells when the last-sent text will end. This allows you to determine when it is all right to send more text. For example, if you are streaming a presentation that is scrolling at a rate of 20 pixels per second in a window that is 200 pixels high, and you call IRMALiveText::AddData
with 100 lines of 20-point text, it will take 100 seconds for all that text to scroll up and out of the window. This method would return the current time plus 100 if you called it right after calling IRMALiveText::AddData
.
This method can be called at any time while the encoder is running.
STDMETHOD(GetLastSentTextEndTime) (
THIS_
ULONG32& ulLastEndTime
) PURE;
![]() |
Note |
---|
If looping (see IRMALiveText::SetDoLooping ) is set to TRUE in tickertape and
marquee (and other windows with horizontal motion), then this method
returns a value that is the start time of the last-added text. This is
necessary because looping text has no defined end time.
|
Determines how multiple, contiguous space characters are presented. This method should be called before sending any data.
STDMETHOD(IgnoreExtraSpaces) (
THIS_
BOOL bIgnoreExtraSpaces
) PURE;
FALSE
(default), multiple spaces in non-tag text are rendered. If TRUE
, multiple, contiguous spaces are treated as a single space.
This method is for internal testing use only and does not affect the presentation of a live text stream.
Adjusts the time, since the last data was sent, that the encoder waits before resending "heartbeat" packets. These "heartbeat" packes let the server know the encoder still alive and to let newly-connected players know what is currently visible in the window, in case they connected during a "dry" period in the stream, after the last new text was sent.
This method can be called at any time while the encoder is running.
STDMETHOD(SetTimeBetweenDryStreamResends) (
THIS_
ULONG32 ulMillisecBetweenResends
) PURE;
Purpose: | Requests a server to load balance multiple instances of the plug-in |
Implemented by: | Plug-ins |
Used by: | Information not yet available at publication. |
Header file: | rmaengin.h |
The IRMALoadBalancedListen
interface is queried off of IRMAListenSocket
. This interface allows a plug-in to specify that it wants the server to load balance multiple instances of itself. The server will instantiate multiple instances of the plug-in as needed based on socket and descriptor limits. Each plug-in instance should attempt to listen on the same port as other instances (because they will share the port).
The IRMALoadBalancedListen
interface contains the following methods:
As with all COM interfaces, the IRMALoadBalancedListen
interface inherits the following IUnknown
methods:
Sets the unique ID for this listen socket. This ID determines whether or not different instances of a plug-in trying to listen on a single port are actually the same plug-in. Without this method, it would be possible for two completely different plug-ins to listen on the same port using the load balanced listener.
STDMETHOD(SetID) (
THIS_
REFIID ID
) PURE;
Sets the reserve limit for descriptors and sockets. If less than the reserve limit of descriptors and sockets are left, then a new instance of the plugin is created.
STDMETHOD(SetReserveLimit) (
THIS_
UINT32 ulDescriptors,
UINT32 ulSockets
) PURE;
Purpose: | Attaches a Multi-Instance Site User Supplier (MISUS) object to a site |
Implemented by: | MISUS object (Client core) |
Used by: | Display rendering plug-in |
Header file: | rmawin.h |
This is the interface to a MISUS object instantiated by the RealSystem client core. In normal RealSystem windowing, a display rendering plug-in that supports multiple sites renders data to this object, which in turn renders data to the multiple sites. The preferred implementation is to use IRMACommonClassFactory
to create this interface.
![]() |
Additional Information |
---|
See "Chapter 12: Sites (Windowing)". See also IRMASiteUserSupplier .
|
The IRMAMultiInstanceSiteUserSupplier
interface contains the following methods:
IRMAMultiInstanceSiteUserSupplier::ReleaseSingleSiteUser
IRMAMultiInstanceSiteUserSupplier::SetSingleSiteUser
As with all COM interfaces, the IRMAMultiInstanceSiteUserSupplier
interface inherits the following IUnknown
methods:
Releases the renderer from the site.
STDMETHOD(ReleaseSingleSiteUser) (
THIS
) PURE;
Sets a single renderer that could be used for multiple sites.
STDMETHOD(SetSingleSiteUser) (
THIS_
IUnknown* pUnknown
) PURE;
IUnknown
interface that identifies the instance of the MISUS object (IRMASiteUser
).
Purpose: | Creates networking objects |
Implemented by: | Network Services |
Used by: | Any component |
Header file: | rmaengin.h |
RealSystem architecture's Network Services implements this interface, which any RealSystem component can use to generate network socket objects. Depending on the object type, the component can then use IRMAListenSocket
, IRMAResolver
, IRMATCPSocket
, or IRMAUDPSocket
. Broadcast and monitor plug-ins typically use this interface. For example, a broadcast plug-in uses Network Services to get a TCP socket to connect to its live source over a TCP/IP network.
![]() |
Additional Information |
---|
See "Chapter 8: Broadcast Plug-in" or "Chapter 9: Monitor Plug-in". |
The IRMANetworkServices
interface contains the following methods:
IRMANetworkServices::CreateListenSocket
IRMANetworkServices::CreateResolver
IRMANetworkServices::CreateTCPSocket
IRMANetworkServices::CreateUDPSocket
As with all COM interfaces, the IRMANetworkServices
interface inherits the following IUnknown
methods:
Creates a new TCP socket that listens for connections on a particular port.
STDMETHOD(CreateListenSocket) (
THIS_
IRMAListenSocket** ppListenSocket
) PURE;
IRMAListenSocket
interface that manages the new TCP socket.
Creates a new resolver that can look up host names.
STDMETHOD(CreateResolver) (
THIS_
IRMAResolver** ppResolver
) PURE;
IRMAResolver
interface that resolves a DNS host name into an IP address.
STDMETHOD(CreateTCPSocket) (
THIS_
IRMATCPSocket** ppTCPSocket
) PURE;
IRMATCPSocket
interface that manages the new TCP socket.
STDMETHOD(CreateUDPSocket) (
THIS_
IRMAUDPSocket** ppUDPSocket
) PURE;
IRMAUDPSocket
interface that manages the new UDP socket.
Purpose: | Initializing and configuring plug-ins |
Implemented by: | Plug-ins |
Used by: | Server core |
Header file: | rmaplgns.h |
This interface contains alternate methods for initializing and configuring plug-ins. The IRMAObjectConfiguration::SetContext
method can be use instead of IRMAPlugin::InitPlugin
for setting the context of the plug-in. This is especially useful if you only need to set the configuration of the plug-in after the plug-in has been intialized, which can be accomplished using the IRMAObjectConfiguration::SetConfiguration
method.
The IRMAObjectConfiguration
interface contains the following methods:
As with all COM interfaces, the IRMAObjectConfiguration
interface inherits the following IUnknown
methods:
Supplies configuration information from the plug-in. This configuration information is often a set of CString properties extracted from a list in the configuration file. This allows each plug-in within a specific class (that is, an authorization plug-in, a database plug-in, and so on) to require a different set of parameters. Typical configuration information handled by this method are realm, database ID, and so on. For example, this method might be used to configure an authentication object. The server core reads the server configuration file to determine the realm and database ID for authenticating a particular audio clip. If the clip's realm uses basic authentication, the server core will create an object that supports basic authentication. It will then call this method on that object os the object knows which realm and database ID to user for that clip.
STDMETHOD(SetConfiguration) (
THIS_
IRMAValues* pIRMAValuesConfiguration
) PURE;
IRMAValues
interface that that manages the configuration information.
Passes in an object to a plug-in so the plug-in can use services from the server core. Both IRMAPlugin::InitPlugin
and this method must be called before calling any other method on the plug-in. The server can use this method instead of IRMAPlugin::InitPlugin
if the server does not need to assume that the object being dealt with is a plug-in.
STDMETHOD(SetContext) (
THIS_
IUnknown* pIUnknownContext
) PURE;
IUnknown
interface that identifies the instance of this object.
Purpose: | Provides optimized scheduling of callbacks |
Implemented by: | RealSystem client |
Used by: | Rendering plug-in components |
Header file: | rmaengin.h |
The IRMAOptimizedScheduler
interface provides the user with a way of scheduling callbacks that will be executed at some time in the future. This interface should only be used if you need accurately-timed callbacks. These callbacks should be efficient and should not consume much time/CPU. This is not a thread-safe interface. The user must take care of synchronization in their callbacks.
The IRMAOptimizedScheduler
interface contains the following methods:
IRMAOptimizedScheduler::AbsoluteEnter
IRMAOptimizedScheduler::GetCurrentSchedulerTime
IRMAOptimizedScheduler::RelativeEnter
IRMAOptimizedScheduler::Remove
As with all COM interfaces, the IRMAOptimizedScheduler
interface inherits the following IUnknown
methods:
Schedules a callback to be executed at a specified time. Returns a handle to the callback.
STDMETHOD_(CallbackHandle,AbsoluteEnter) (
THIS_
IRMACallback* pCallback,
RMATimeval tVal
) PURE;
IRMACallback
interface that manages the scheduled callback.
RMATimeval
structure that specifies the time for the callback to be executed.
Returns a pointer to an RMATimeval
structure that contains the current time in the timeline of the scheduler.
STDMETHOD_(RMATimeval,GetCurrentSchedulerTime) (
THIS
) PURE;
Schedules a callback to be executed a specified number of milliseconds from now. This method is less percise then IRMAOptimizedScheduler::AbsoluteEnter
and should only be used when accurate timing is not critical. Returns the handle to the callback.
STDMETHOD_(CallbackHandle,RelativeEnter) (
THIS_
IRMACallback* pCallback,
UINT32 ms
) PURE;
IRMACallback
interface that manages the scheduled callback.
Removes a callback from the scheduler.
STDMETHOD(Remove) (
THIS_
CallbackHandle Handle
) PURE;
Purpose: | Sets options on any component. |
Implemented by: | Any component |
Used by: | Any other component |
Header file: | rmavalue.h |
If a component implements this interface, the caller can find out all of the options (and their types and current settings) by calling the IRMAOptions::GetOptions
method. Then the caller can set any individual option by calling the appropriate IRMAOptions
method, depending on the option type.
The IRMAOptions
interface contains the following methods:
IRMAOptions::GetOptions
IRMAOptions::SetOptionBuffer
IRMAOptions::SetOptionCString
IRMAOptions::SetOptionULONG32
As with all COM interfaces, the IRMAOptions
interface inherits the following IUnknown
methods:
Returns a list of the options supported by this particular object, along with the value currently set for each option. Enumerate the members of the returned IRMAValues
object to discover what options a component supports and the type of each of those options. The value for each name-value pair is the current setting for that option.
STDMETHOD(GetOptions) (
THIS_
REF(IRMAValues*) pOptions
) PURE;
IRMAValues
interface that manages the list of options.
Sets the value of a buffer option.
STDMETHOD(SetOptionBuffer) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the buffer value of the option being set.
Sets the value of a CString option.
STDMETHOD(SetOptionCString) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the CString value of the option being set.
Sets the value of a ULONG32 option.
STDMETHOD(SetOptionULONG32) (
THIS_
const char* pName,
ULONG32 ulValue
) PURE;
Purpose: | Overrides any default services provided by the G2 system. |
Implemented by: | RealSystem client |
Used by: | Plug-ins |
Header file: | rmaengin.h |
This interface is queried off of the context. Currently, this interface is supported only on the client side. You can currently override IRMANetworkServices
using this interface. You can use the same interface to later restore the overriden services by calling the IRMAOverrideDefaultServices::OverrideServices
method with the original service that was queried (IUnknown::QueryInterface
) before the initial override.
The IRMAOverrideDefaultServices
interface contains the IRMAOverrideDefaultServices::OverrideServices
method.
As with all COM interfaces, the IRMAOverrideDefaultServices
interface inherits the following IUnknown
methods:
Overrides the default services provided by the G2 system.
STDMETHOD(OverrideServices) (
THIS_
IUnknown* pContext
) PURE;
IUnknown
interface that identifies the instance of the object for which services are being overridden.
Purpose: | Provides access to the RealServer registry |
Implemented by: | RealServer and RealSystem client |
Used by: | Monitor plug-ins |
Header file: | rmamon.h |
The RealServer registry stores information about RealSystem events, such as how many clients are currently connected. A monitor plug-in can use the IRMAPNRegistry
interface to gain access to this registry. This interface creates a registry object that the plug-in can then use to set watches on registry properties through IRMAPropWatch
.
![]() |
Additional Information |
---|
See "RealServer Property Registry". |
The IRMAPNRegistry
interface contains the following methods:
IRMAPNRegistry::AddBuf
IRMAPNRegistry::AddComp
IRMAPNRegistry::AddInt
IRMAPNRegistry::AddIntRef
IRMAPNRegistry::AddStr
IRMAPNRegistry::CreatePropWatch
IRMAPNRegistry::DeleteById
IRMAPNRegistry::DeleteByName
IRMAPNRegistry::FindParentIdById
IRMAPNRegistry::FindParentIdByName
IRMAPNRegistry::GetBufById
IRMAPNRegistry::GetBufByName
IRMAPNRegistry::GetId
IRMAPNRegistry::GetIntById
IRMAPNRegistry::GetIntByName
IRMAPNRegistry::GetNumPropsAtRoot
IRMAPNRegistry::GetNumPropsById
IRMAPNRegistry::GetNumPropsByName
IRMAPNRegistry::GetPropListById
IRMAPNRegistry::GetPropListByName
IRMAPNRegistry::GetPropListOfRoot
IRMAPNRegistry::GetPropName
IRMAPNRegistry::GetStrById
IRMAPNRegistry::GetStrByName
IRMAPNRegistry::GetTypeById
IRMAPNRegistry::GetTypeByName
IRMAPNRegistry::SetBufById
IRMAPNRegistry::SetBufByName
IRMAPNRegistry::SetIntById
IRMAPNRegistry::SetIntByName
IRMAPNRegistry::SetStrById
IRMAPNRegistry::SetStrByName
As with all COM interfaces, the IRMAPNRegistry
interface inherits the following IUnknown
methods:
Adds a BUFFER property to the registry. This method returns the ID of the newly added property if successful or returns ZERO (0) if an error occurred during the operation.
STDMETHOD_(UINT32, AddBuf) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the BUFFER value.
Adds a COMPOSITE property to the registry. This method returns the ID of the newly added property if successful or returns ZERO (0) if an error occurred during the operation.
STDMETHOD_(UINT32, AddComp) (
THIS_
const char* pName
) PURE;
Adds an INTEGER property to the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.
STDMETHOD_(UINT32, AddInt) (
THIS_
const char* pName,
const INT32 iValue
) PURE;
Adds an INTEGER REFERENCE property to the registry. This property lets the user modify its contents directly without having to go through the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.
STDMETHOD_(UINT32, AddIntRef) (
THIS_
const char* pName,
INT32* pValue
) PURE;
Adds a STRING property to the registry. This method returns the ID of the newly-added property if successful or returns ZERO (0) if an error occurred during the operation.
STDMETHOD_(UINT32, AddStr) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the STRING value.
Creates a new IRMAPropWatch
interface that can then be used to set watches on specific RealServer registry properties.
STDMETHOD(CreatePropWatch) (
THIS_
REF(IRMAPropWatch*) pPropWatch
) PURE;
IRMAPropWatch
interface that manages the watches on RealServer registry properties.
Deletes a property from the registry using its ID.
STDMETHOD_(UINT32, DeleteById) (
THIS_
const UINT32 ulID
) PURE;
Deletes a property from the registry using its name.
STDMETHOD_(UINT32, DeleteByName) (
THIS_
const char* pcPropName
) PURE;
Returns the ID value of the parent node of the property whose ID has been specified. If this method fails, a ZERO value is returned.
STDMETHOD_(UINT32, FindParentIdById) (
THIS_
const UINT32 id
) const PURE;
Returns the ID value of the parent node of the property whose name has been specified. If this method fails, a ZERO value is returned.
STDMETHOD_(UINT32, FindParentIdByName) (
THIS_
const char* pName
) const PURE;
Retreives a BUFFER value from the registry given its property ID. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetBufById) (
THIS_
const UINT32 id,
REF(IRMABuffer*) ppValue
) const PURE;
IRMABuffer
interface that manages the BUFFER value.
Retreives a BUFFER value from the registry given its property name. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetBufByName) (
THIS_
const char* pName,
REF(IRMABuffer*) ppValue
) const PURE;
IRMABuffer
interface that manages the BUFFER value.
Returns the property's ID given the property name.
STDMETHOD_(UINT32, GetId) (
THIS_
const char* pName
) const PURE;
Retreives an INTEGER value from the registry given its property ID. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetIntById) (
THIS_
const UINT32 ulId,
REF(INT32) nValue
) const PURE;
Retreives an INTEGER value from the registry given its property name. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetIntByName) (
THIS_
const char* pName,
REF(INT32) nValue
) const PURE;
Returns the number of properties at the root of the registry.
STDMETHOD_(INT32, GetNumPropsAtRoot) (
THIS
) const PURE;
Returns the count of the number of properties in the registry. If a property's ID is specified, then it returns the number of properties under that ID.
STDMETHOD_(INT32, GetNumPropsById) (
THIS_
const UINT32 id
) const PURE;
Returns the count of the number of properties in the registry. If a property name is specified, then it returns the number of properties under that name.
STDMETHOD_(INT32, GetNumPropsByName) (
THIS_
const char* pName
) const PURE;
Returns an array of properties immediately under the one with the specified ID.
STDMETHOD(GetPropListById) (
THIS_
const UINT32 id,
REF(IRMAValues*) pValues
) const PURE;
IRMAValues
interface that manages the array of properties.
Returns an array of properties immediately under the one with the specified name.
STDMETHOD(GetPropListByName) (
THIS_
const char* pName,
REF(IRMAValues*) pValues
) const PURE;
IRMAValues
interface that manages the array of properties.
Returns an array of properties under the root level of the registry's hierarchy.
STDMETHOD(GetPropListOfRoot) (
THIS_
REF(IRMAValues*) pValues
) const PURE;
IRMAValues
interface that manages the array of properties.
Returns the property name given the property's ID.
STDMETHOD(GetPropName) (
THIS_
const UINT32 ulId,
REF(IRMABuffer*) pName
) const PURE;
IRMABuffer
interface that manages the property name.
Retreives a STRING value from the registry given its property ID. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetStrById) (
THIS_
const UINT32 id,
REF(IRMABuffer*) pValue
) const PURE;
IRMABuffer
interface that manages the STRING value.
Retreives a STRING value from the registry given its property name. If the property is found, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(GetStrByName) (
THIS_
const char* pName,
REF(IRMABuffer*) pValue
) const PURE;
IRMABuffer
interface that manages the STRING value.
Returns the datatype of the property given its ID.
STDMETHOD_(RMAPropType, GetTypeById) (
THIS_
const UINT32 id
) const PURE;
Returns the datatype of the property given its name.
STDMETHOD_(RMAPropType, GetTypeByName) (
THIS_
const char* pName
) const PURE;
Modifies a property's BUFFER value in the registry given its property ID. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetBufById) (
THIS_
const UINT32 id,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the new BUFFER value to be set.
Modifies a property's BUFFER value in the registry given its property name. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetBufByName) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the new BUFFER value to be set.
Modifies a property's INTEGER value in the registry given its property ID. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetIntById) (
THIS_
const UINT32 id,
const INT32 iValue
) PURE;
Modifies a property's INTEGER value in the registry given its property name. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetIntByName) (
THIS_
const char* pName,
const INT32 iValue
) PURE;
Modifies a property's STRING value in the registry given its property ID. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetStrById) (
THIS_
const UINT32 id,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the new INTEGER value to be set.
Modifies a property's STRING value in the registry given its property name. If the value was set, this method returns PNR_OK
, otherwise it returns PNR_FAIL
.
STDMETHOD(SetStrByName) (
THIS_
const char* pName,
IRMABuffer* pValue
) PURE;
IRMABuffer
interface that manages the new INTEGER value to be set.
Purpose: | Provides access to a pay-per-view database |
Implemented by: | Pay-per-view database plug-in |
Used by: | File system and pay-per-view allowance plug-ins |
Header file: | rmappv.h |
This interface can be used to create a database plug-in to store pay-per-view data.
The IRMAPPVDatabase
interface contains the following methods:
IRMAPPVDatabase::DeductTime
IRMAPPVDatabase::GetPasswordFromUserid
IRMAPPVDatabase::GetPPVDBInfo
IRMAPPVDatabase::GetRedirect
IRMAPPVDatabase::GetUseridFromGUID
IRMAPPVDatabase::GrantPermission
IRMAPPVDatabase::GrantTime
IRMAPPVDatabase::InitPPVDB
IRMAPPVDatabase::InsertUser
IRMAPPVDatabase::LogAccess
IRMAPPVDatabase::LogReg
IRMAPPVDatabase::PutRedirect
IRMAPPVDatabase::RegisterGUID
IRMAPPVDatabase::RemoveUser
IRMAPPVDatabase::RevokeAllPermissions
IRMAPPVDatabase::RevokePermission
IRMAPPVDatabase::SetPassword
IRMAPPVDatabase::ValidateUser
As with all COM interfaces, the IRMAPPVDatabase
interface inherits the following IUnknown
methods:
Deducts a user time to view. This method is obsolete and should not be used in any new applications.
STDMETHOD(DeductTime) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission,
UINT32 ulDeduct
) PURE;
PPVPermission
structure that contains the permission information and URL.
STDMETHOD(GetPasswordFromUserid) (
THIS_
const char* pUserid,
char* pCipherPassword,
UINT32 ulCipherPasswordLen
) PURE;
pCipherPassword
.
Gets this database's short name. This unique identifier identifies this database plug-in, and should be unique enough that no other plug-in will ever have the same plug-in name.
STDMETHOD(GetPPVDBInfo) (
THIS_
REF(const char*) pShortName
) PURE;
Gets the redirection URL corresponding to the requested URL from the database.
STDMETHOD(GetRedirect) (
THIS_
const char* pURL,
char* pURLRedirect,
UINT32 ulURLRedirectLen
) PURE;
pURLRedirect
.
Gets a user's ID. For this method to return a valid user ID, GUID logging must be enabled (that is, the GUID cannot be all zeroes).
STDMETHOD(GetUseridFromGUID) (
THIS_
const char* pGUID,
char* pUserid,
UINT32 ulUseridLen
) PURE;
pUserid
.
STDMETHOD(GrantPermission) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission
) PURE;
PPVPermission
structure that contains the permission information and URL.
Grants a user time to view. This method is obsolete and should not be used by any new applications.
STDMETHOD(GrantTime) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission,
UINT32 ulGrant
) PURE;
PPVPermission
structure that contains the permission information and URL.
Opens and initializes the pay-per-view database. This method is called once per instance before any other methods in this interface are called.
STDMETHOD(InitPPVDB) (
THIS_
const char* pDBName,
const char* pUserID,
const char* pPassword
) PURE;
Inserts a user in the database (the user should not already exist).
STDMETHOD(InsertUser) (
THIS_
const char* pUserid,
const char* pPasswordCipher
) PURE;
Inserts a new record into the user authentication database.
STDMETHOD(LogAccess) (
THIS_
PPVAccessLog* pPPVAccessLog
) PURE;
PPVAccessLog
structure that contains the logging information.
![]() |
Additional Information |
---|
See the chapters on authenticating RealServer visitors and storing authentication data in the RealServer G2 Administration Guide for information on user authentication. |
Inserts a new record into the database. This method uses information supplied by the IRMAPPVDatabase::RegisterGUID
method.
STDMETHOD(LogReg) (
THIS_
PPVRegLog* pPPVRegLog
) PURE;
PPVRegLog
structure that contains the logging information.
![]() |
Additional Information |
---|
See the chapters on authenticating RealServer visitors and storing authentication data in the RealServer G2 Administration Guide for information on player validation. |
Adds a redirection URL to the database that corresponds with the URL key.
STDMETHOD(PutRedirect) (
THIS_
const char* pURL,
const char* pURLRedirect
) PURE;
Registers a GUID to be associated with the given user ID. For the GUID to be properly associated with the user ID, GUID logging must be enabled (that is, the GUID cannot be all zeroes).
STDMETHOD(RegisterGUID) (
THIS_
const char* pUserid,
const char* pGUID,
BOOL bForce
) PURE;
TRUE
, forces the registration of the GUID, even if the uuid_writeable
flag in the server's authentication database is set to read only. See the chapter on storing authentication data in the RealServer Administration Guide for more information on uuid_writeable
.
Removes a user from the database.
STDMETHOD(RemoveUser) (
THIS_
const char* pUserid
) PURE;
Removes all permission records for a user.
STDMETHOD(RevokeAllPermissions) (
THIS_
const char* pUserid
) PURE;
STDMETHOD(RevokePermission) (
THIS_
const char* pUserid,
const PPVPermission* pPPVPermission
) PURE;
PPVPermission
structure that contains the permission information and URL.
Sets the password for the user associated with the given user ID.
STDMETHOD(SetPassword) (
THIS_
const char* pUserid,
const char* pCipherPassword
) PURE;
Validates whether the user associated with the given user ID should be given permission to view a specific piece of content. If the user is granted permission to view the file, the database should fill in the other members of the PPVPermission
structure with information about what kind of permission the user should be granted (that is, should the user be granted a number of seconds of viewing time, or should they be able to watch until a specific expiration date, and so on).
STDMETHOD(ValidateUser) (
THIS_
const char* pUserid,
PPVPermission* pPPVPermission
) PURE;
PPVPermission
structure that contains the URL of the content that requires validation.
Purpose: | Provides storage of pay-per-view permission data |
Implemented by: | Database plug-in |
Used by: | File system and pay-per-view allowance plug-ins |
Header file: | rmadb.h |
This interface administers and enforces permissions for pay-per-view content. The response interface is IRMAPPVDBManagerResponse
.
The IRMAPPVDBManager
interface contains the following methods:
IRMAPPVDBManager::GetPermissions
IRMAPPVDBManager::LogAccessAttempt
IRMAPPVDBManager::RevokeAllPermissions
IRMAPPVDBManager::RevokePermissions
IRMAPPVDBManager::SetPermissions
As with all COM interfaces, the IRMAPPVDBManager
interface inherits the following IUnknown
methods:
Retrieves the pay-per-view permissions for the specified URL and user.
STDMETHOD(GetPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL
) PURE;
IRMAPPVDBManagerResponse
interface that manages the response to this method.
IRMABuffer
interface that manages the specified user's identification.
IRMABuffer
interface that manages the specified URL.
Records the results of an attempt to access protected content.
STDMETHOD(LogAccessAttempt) (
THIS_
IRMAValues* pValuesAccess
) PURE;
IRMAValues
interface that manages the result of an attempt to access protected content. The following keys are used:
Removes the pay-per-view permissions for all URLs to which this user has access.
STDMETHOD(RevokeAllPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID
) PURE;
IRMAPPVDBManagerResponse
interface that manages the response to this method.
IRMABuffer
interface that manages the specified user's identification.
Removes the pay-per-view permissions for the specified URL and user.
STDMETHOD(RevokePermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL
) PURE;
IRMAPPVDBManagerResponse
interface that manages the reponse to this method.
IRMABuffer
interface that manages the specified user's identification.
IRMABuffer
interface that manages the specified URL.
Sets the pay-per-view permissions for the specified URL and user.
STDMETHOD(SetPermissions) (
THIS_
IRMAPPVDBManagerResponse* pPPVDBManagerResponseNew,
IRMABuffer* pBufferPrincipalID,
IRMABuffer* pBufferURL,
IRMAValues* pValuesPermissions
) PURE;
IRMAPPVDBManagerResponse
interface that manages the response to this method.
IRMABuffer
interface that manages the specified user's identification.
IRMABuffer
interface that manages the specified URL.
IRMAValues
interface that manages the pay-per-view permissions. The following keys are used:
Purpose: | Manages pay-per-view permission data |
Implemented by: | Database user |
Used by: | Database plug-in |
Header file: | rmadb.h |
This interface provide an asynchronous response to IRMAPPVDBManager
.
The IRMAPPVDBManagerResponse
interface contains the following methods:
IRMAPPVDBManagerResponse::GetPermissionsDone
IRMAPPVDBManagerResponse::RevokeAllPermissionsDone
IRMAPPVDBManagerResponse::RevokePermissionsDone
IRMAPPVDBManagerResponse::SetPermissionsDone
As with all COM interfaces, the IRMAPPVDBManagerResponse
interface inherits the following IUnknown
methods:
Reports the status of the call to get the pay-per-view permissions, and returns the permissions for the specifed user.
STDMETHOD(GetPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID,
IRMAValues* pValuesPermissions
) PURE;
IRMAPPVDBManager::GetPermissions
operation. A value of PNR_OK
indicates the operation has completed successfully.
IRMABuffer
interface that manages the user's identification.
IRMAValues
interface that manages the pay-per-view permissions. The following keys are used:
Reports the status of the call to revoke all the pay-per-view permissions for the specified user.
STDMETHOD(RevokeAllPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
IRMAPPVDBManager::RevokeAllPermissions
operation. A value of PNR_OK
indicates the operation has completed successfully.
IRMABuffer
interface that manages the user's identification.
Reports the status of the call to revoke the pay-per-view permissions for the specified user.
STDMETHOD(RevokePermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
IRMAPPVDBManager::RevokePermissions
operation. A value of PNR_OK
indicates the operation has completed successfully.
IRMABuffer
interface that manages the user's identification.
Reports the status of the call to set the pay-per-view permissions for the specified user.
STDMETHOD(SetPermissionsDone) (
THIS_
PN_RESULT ResultStatus,
IRMABuffer* pBufferPrincipalID
) PURE;
IRMAPPVDBManager::SetPermissions
operation. A value of PNR_OK
indicates the operation has completed successfully.
IRMABuffer
interface that manages the user's identification.