/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <e32math.h>
#include <RtpHeader.h>
#include "CXPSPacketSink.h"
#include "CXPSPacket.h"
//
// Creates packet sink
//
// Returns NULL on memory error
//
CXPSPacketSink* CXPSPacketSink::New()
{
return NULL ;
}
//
// Constructor
//
CXPSPacketSink::CXPSPacketSink()
{
//do nothing
}
//
// Destructor
//
CXPSPacketSink::~CXPSPacketSink()
{
// do nothing
}
//
// Creates the symbian server with the specified name and
// waits for client connection.
//
// Parameters:
// ServerName : Name of the server to be created.
// pObserver : Observer for packet sink callbacks
//
// Returns KErrNone on success or system wide error otherwise
//
//
TInt CXPSPacketSink::Init(const TDesC& /*ServerName*/, MXPSPktSinkObserver* /*pObserver*/)
{
return KErrNotSupported;
}
//
// Sets the SDP info into the server.
//
// Note:
// SetSessionDescription SHALL be invoked before the application
// issues a open URL on the MMF controller. OpenURL on controller
// will result in a connect and query for SDP by the client
//
// Init SHALL be called prior to this API invocation
//
// Parameters:
// aSDPDesc : Session description protocol message
// unNumStreams: Number of streams
//
// Returns KErrNone on success or system wide error otherwise
//
//
//
TInt CXPSPacketSink::SetSessionDescription(TDesC8& /*aSDPDesc*/, TUint /* uNumStreams*/)
{
return KErrNotSupported;
}
//
// Sets the session's output device mode.
// Audio, Video or other streams will use the bit mask to make a decision
// on routing to external devices (eg., Bluetooth, TV-Out,etc)
//
// Note:
// SetSecureOutputMode is an optional API and SHALL be invoked while
// playing protected content. Default behaviour is allow all ie.,
// no restrictions applied in routing streams to output devices.
//
// SetSecureOutputMode SHALL be invoked before the application
// issues a OpenURL on the MMF controller.
//
// Init SHALL be called prior to this API invocation
//
// Parameters:
// ulSecureOutBitMask : 32-Bit mask representing the secure output mode
// All bits zero will result in BLOCKING of unsecure
// output devices. (0x0) (eg. TV-Out will be blocked)
// All bits one will result in allowing streams to
// render to both secure and unsecure output devices.
// (0xFFFFFFFF) Rest of the bit mask combinations
// are reserved for future use.
//
// Returns KErrNone on success or system wide error otherwise
//
//
//
TInt CXPSPacketSink::SetSecureOutputMode(TUint32 /* ulSecureOutBitMask */)
{
return KErrNotSupported;
}
//
// AuthenticateClient sets the minimum capability that a client SHALL
// possess for connecting to the server.
//
// Note:
// AuthenticateClient SHALL be invoked before the application
// issues a open URL on the MMF controller. OpenURL on controller
// will result in a connect.
//
// Init SHALL be called prior to this API invocation
//
// Parameters:
// aSDPDesc : Session description protocol message
//
// Returns KErrNone on success or system wide error otherwise
//
//
//
TInt CXPSPacketSink::AuthenticateClient(TSecurityPolicy& /* aSecurityPolicy*/)
{
return KErrNotSupported;
}
//
// Enqueues the packet on the packet sink.
//
// Parameters:
// unStreamId : Stream identifier
// CXPSPacket : transferred packet, XPS takes over ownership
//
// Returns KErrNone on success or system wide error otherwise.
// Packet overflow scenario will result in KErrOverflow.
// Application SHALL stop supplying more packets on receiving KErrOverflow.
// Packet supply can be resumed after the callback from the packet sink.
// MXPSPacketSinkObserver::ResumePacketSupply API will be used to notify.
//
// NOTE:
// KErrOverflow return indicates that the slots are filled out. Current packet
// has been enqueued and there are no slots for more packets. Packet supply
// SHALL be resumed after observer callback (MXPSPktSinkObserver::RestorePacketSupply).
// KErrNotReady will be returned if packets are enqueued after overflow and before
// resume callback
//
//
TInt CXPSPacketSink::Enqueue(TUint /* unStreamNumber*/, CXPSPacket* /*pPacket*/)
{
return KErrNotSupported;
}
//
// Enqueues the packet on the packet sink.
//
// Parameters:
// unStreamId : Stream identifier
// aHeaderInfo : RTP header of the packet
// aPayloadData: RTP payload
//
// Returns KErrNone on success or system wide error otherwise.
// Packet overflow scenario will result in KErrOverflow.
// Application SHALL stop supplying more packets on receiving KErrOverflow.
// Packet supply can be resumed after the callback from the packet sink.
// MXPSPacketSinkObserver::ResumePacketSupply API will be used to notify.
//
//
TInt CXPSPacketSink::Enqueue(TUint /*unStreamId*/, const TRtpRecvHeader& /*aHeaderInfo*/,
const TDesC8& /*aPayloadData*/)
{
return KErrNotSupported;
}
//
// StreamEnd indicates the end of given stream
//
// Paramaters:
// unStreamId : Stream identifier
//
// Returns KErrNone on success or system wide error otherwise
//
//
TInt CXPSPacketSink::StreamEnd(TUint /*unStreamNumber*/)
{
return KErrNotSupported;
}
//
// Configures the stream's buffering capability. Sets the
// queue to the size specified.
//
// Note:
// This API is optional. Packet sink will start with default values
//
// Paramaters:
// unStreamId : Stream identifier
// unNumSlots : Maximum number of packets that may be bufferred in
// packet sink for the given stream
//
// Returns KErrNone on success or system wide error otherwise
//
TInt CXPSPacketSink::ConfigStream(TUint /*unStreamId*/, TUint /*unNumSlots*/)
{
return KErrNotSupported;
}
//
// Configures the stream's buffering capability. Sets the
// queue to the heap size specified.
//
// Note:
// This API is optional. Packet sink will start with default values
// This API could be called during runtime to re-adjust the queue size
//
// Paramaters:
// unStreamId : Stream identifier
// unQueueSiezInBytes : Maximum number of heap size that may be
// bufferred in packet sink for the given stream
//
// Returns KErrNone on success or system wide error otherwise
//
TInt CXPSPacketSink::ConfigStreamBySize(TUint /*unStreamId*/, TUint32 /*unQueueSiezInBytes*/)
{
return KErrNotSupported;
}
//
// Resets the packet sink. Releases all the packets stored in packet sink
// Does not affect the SDP or intialization attributes. It only cleans up the
// bufferred packets on the packet sink
//
// Returns KErrNone on success or system wide error otherwise
//
//
TInt CXPSPacketSink::Reset()
{
return KErrNotSupported;
}
//
// SetOverflowAutoManage instructs XPS whether to do buffer overflow control or not
//
// Paramaters:
// bIsOverflowAutoManaged:
// ETrue: if XPS has no packet for one stream, and Helix is demanding
// for it, XPS will drop 1 packet from any stream whose queue
// is full. It allows XPS client to push further packets into XPS
// in the hope that required stream packet could come to XPS
// eventually. This process repeats till XPS receives deired packet.
// EFalse:XPS dose not do buffer management described above
//
// Note: If XPS client has single queue implementation, it is better to
// let XPS handle the overflow situation.
//
// Default: ETrue
//
// Returns: the previous status of Overflow Management
//
//
TBool CXPSPacketSink::SetOverflowAutoManage(TBool /*bIsOverflowAutoManaged*/)
{
return ETrue;
}