namespace Swift {

: width(width), height(height)

{

int len = width * height * 3;

public:

typedef boost::shared_ptr<Image> ref;

int width;

int height;

#include <Swiften/Jingle/JingleSession.h>

#include <Swiften/Elements/JingleRawUDPTransportPayload.h>

#include <Swiften/Network/UDPSocketFactory.h>

#include <Swiften/Network/UDPSocket.h>

namespace Swift {

IncomingScreenSharing::IncomingScreenSharing(boost::shared_ptr<JingleSession> session, UDPSocketFactory* udpSocketFactory,

boost::shared_ptr<JingleContentPayload> content)

: ScreenSharing(session, udpSocketFactory),

{

onStateChange(ScreenSharing::WaitingForAccept);

}

IncomingScreenSharing::~IncomingScreenSharing()

{

}

void IncomingScreenSharing::cancel()

{

onStateChange(ScreenSharing::Canceled);

}

{

JingleRawUDPTransportPayload::ref transport = boost::make_shared<JingleRawUDPTransportPayload>();

addBestCandidate(transport);

// TODO: create a valid description instead of copying the initator's one

JingleRawUDPTransportPayload::ref initialTransport = initialContent->getTransport<JingleRawUDPTransportPayload>();

clientSocket = udpSocketFactory->createUDPSocket();

SafeByteArray data(1, 0);

clientSocket->send(data);

onStateChange(ScreenSharing::Connecting);

}

return JingleContentID(initialContent->getName(), initialContent->getCreator());

}

}

#include <Swiften/ScreenSharing/ScreenSharing.h>

#include <Swiften/Jingle/JingleContentID.h>

namespace Swift {

class JingleContentPayload;

public:

typedef boost::shared_ptr<IncomingScreenSharing> ref;

public:

boost::shared_ptr<JingleContentPayload> content);

virtual ~IncomingScreenSharing();

void accept();

private:

JingleContentID getContentID() const;

private:

boost::shared_ptr<JingleContentPayload> initialContent;

};

}

#include <Swiften/ScreenSharing/OutgoingScreenSharing.h>

#include <Swiften/Elements/JinglePayload.h>

#include <Swiften/Elements/JingleRawUDPTransportPayload.h>

#include <Swiften/Elements/JingleRTPDescription.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/ScreenSharing/RTPSessionImpl.h>

#include <boost/bind.hpp>

OutgoingScreenSharing::OutgoingScreenSharing(boost::shared_ptr<JingleSession> session, UDPSocketFactory* udpSocketFactory, TimerFactory* timerFactory)

: ScreenSharing(session, udpSocketFactory),

{

session->onSessionAcceptReceived.connect(boost::bind(&OutgoingScreenSharing::handleSessionAcceptReceived, this, _1, _2, _3));

}

OutgoingScreenSharing::~OutgoingScreenSharing()

{

}

void OutgoingScreenSharing::cancel()

{

canceled = true;

onStateChange(ScreenSharing::Canceled);

}

{

//onStateChange(ScreenSharing::WaitingForStart);

SWIFT_LOG(debug) << "Screen sharing: start" << std::endl;

JingleRTPDescription::ref desc = boost::make_shared<JingleRTPDescription>(JingleRTPDescription::Video);

payloadTypeUsed = RTPPayloadType(98, "VP8", 90000);

desc->addPayloadType(payloadTypeUsed);

JingleRawUDPTransportPayload::ref transport = boost::make_shared<JingleRawUDPTransportPayload>();

addBestCandidate(transport);

onStateChange(ScreenSharing::WaitingForAccept);

serverSocket->onConnected.connect(boost::bind(&OutgoingScreenSharing::handleSocketConnected, this));

serverSocket->connectToFirstIncoming();

}

void OutgoingScreenSharing::handleSocketConnected()

{

if (canceled)

{

SWIFT_LOG(debug) << "Screen sharing: unable to connect" << std::endl;

canceled = true;

onStateChange(ScreenSharing::Failed);

// Session accepted and socket connected, we can start the rtp session

rtpSession = new RTPSessionImpl(serverSocket, payloadTypeUsed);

}

}

#include <Swiften/Jingle/JingleContentID.h>

#include <Swiften/Elements/RTPPayloadType.h>

namespace Swift {

class ConnectivityManager;

class JingleDescription;

class JingleTransportPayload;

class TimerFactory;

class Timer;

class OutgoingScreenSharing : public ScreenSharing {

public:

typedef boost::shared_ptr<OutgoingScreenSharing> ref;

public:

virtual ~OutgoingScreenSharing();

virtual void cancel();

private:

void handleSocketConnected();

void handleSessionAcceptReceived(const JingleContentID& /*id*/, boost::shared_ptr<JingleDescription> /*desc*/, boost::shared_ptr<JingleTransportPayload> /*transport*/);

void handleConnectionFailed();

void startRTPSession();

private:

JingleContentID contentID;

bool canceled;

bool sessionAccepted;

bool socketConnected;

RTPPayloadType payloadTypeUsed;

boost::shared_ptr<Timer> connectionTimer;

};

}

namespace Swift {

bool Sender::SendRTP(const void *data, size_t len) {

send(data, len);

return true;

}

void Sender::send(const void* data, size_t len) {

udpSocket->send(SafeByteArray(uint8Data, uint8Data + len));

}

packetInjecter = static_cast<jrtplib::RTPExternalTransmissionInfo*>(session.GetTransmissionInfo())->GetPacketInjector();

udpSocket->onDataRead.connect(boost::bind(&RTPSessionImpl::handleDataRead, this, _1));

}

RTPSessionImpl::~RTPSessionImpl()

void RTPSessionImpl::stop(int maxWaitMs)

{

session.BYEDestroy(jrtplib::RTPTime(0, maxWaitMs * 1000), "", 0);

}

void RTPSessionImpl::checkError(int rtperr) const

namespace Swift {

class Sender : public jrtplib::RTPExternalSender {

public:

virtual bool SendRTP(const void* data, size_t len);

virtual bool SendRTCP(const void* data, size_t len);

#include <Swiften/ScreenSharing/ScreenSharing.h>

#include <Swiften/Base/foreach.h>

#include <Swiften/Network/UDPSocket.h>

namespace Swift {

ScreenSharing::ScreenSharing(boost::shared_ptr<JingleSession> session, UDPSocketFactory* udpSocketFactory)

{

}

ScreenSharing::~ScreenSharing()

{

}

bool ScreenSharing::addBestCandidate(boost::shared_ptr<JingleRawUDPTransportPayload> transport)

{

// TODO: NAT traversal

return false;

}

}

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/IDGenerator.h>

#include <boost/shared_ptr.hpp>

class JingleRawUDPTransportPayload;

class UDPSocketFactory;

class UDPSocket;

class ScreenSharing {

public:

};

public:

virtual ~ScreenSharing();

virtual void cancel() = 0;

public:

boost::signal<void (SCState)> onStateChange;

protected:

bool addBestCandidate(boost::shared_ptr<JingleRawUDPTransportPayload> transport);

protected:

IDGenerator idGenerator;

boost::shared_ptr<UDPSocket> serverSocket;

boost::shared_ptr<UDPSocket> clientSocket;

UDPSocketFactory* udpSocketFactory;

};

}

// Populate encoder configuration

vpx_codec_err_t err = vpx_codec_enc_config_default(codecInterface, &codecConfig, 0);

if (err) {

// TODO: exception

}

vpx_codec_err_t err = vpx_codec_enc_init(&codecContext, codecInterface, &codecConfig, codecFlags);

if (err) {

// TODO: exception

return;

}

imageBuffer = vpx_img_alloc(0, VPX_IMG_FMT_YV12, codecConfig.g_w, codecConfig.g_h, 1);

if (!imageBuffer) {

// TODO: exception

}

}

{

if (!convertRGB24toYV12inBuffer(frame)) {

// TODO: exception ?

return;

}

vpx_codec_err_t err = vpx_codec_encode(&codecContext, imageBuffer, frameNumber, 1, frameFlags, VPX_DL_REALTIME);

if (err) {

// TODO: exception ?

return;

}

++frameNumber;

}

{

if (!imageBuffer)

return false;

unsigned int width = frame.width;

unsigned int height = frame.height;

unsigned int len = width * height;

for (unsigned int i = 0; i < len; ++i) {

const uint8_t* p = &data[3 * i];

namespace Swift {

: decoder(decoder), firstPacket(true)

{

}

#include <stddef.h>

namespace Swift {

class VP8RTPParser {

public:

void newPayloadReceived(const uint8_t* data, size_t len, bool hasMarker);

static const uint8_t HBit = 1 << 4;

static const uint8_t Size0BitShift = 5;

std::vector<uint8_t> buffer;

bool firstPacket;