#include <Swiften/ScreenSharing/Image.h>

namespace Swift {

: width(width), height(height)

{

int len = width * height * 3;

if (rgb24data) {

class Image {

public:

typedef boost::shared_ptr<Image> ref;

int width;

int height;

std::vector<uint8_t> data;

#include <Swiften/ScreenSharing/IncomingScreenSharing.h>

#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);

}

void IncomingScreenSharing::accept()

{

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();

clientSocket->connect(initialTransport->getCandidates().front().hostAddressPort);

// Send a empty packet to let the server know about us

SafeByteArray data(1, 0);

clientSocket->send(data);

onStateChange(ScreenSharing::Connecting);

}

JingleContentID IncomingScreenSharing::getContentID() const

{

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

}

}

#pragma once

#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();

virtual void cancel();

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/Jingle/JingleSession.h>

#include <Swiften/Network/UDPSocket.h>

#include <Swiften/Network/TimerFactory.h>

#include <Swiften/Network/Timer.h>

#include <Swiften/ScreenSharing/RTPSessionImpl.h>

#include <boost/bind.hpp>

namespace Swift {

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)

return;

void OutgoingScreenSharing::handleConnectionFailed()

{

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

canceled = true;

onStateChange(ScreenSharing::Failed);

}

SWIFT_LOG(debug) << "Screen sharing: accepted and connected, start sharing" << std::endl;

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

rtpSession = new RTPSessionImpl(serverSocket, payloadTypeUsed);

}

}

#include <Swiften/ScreenSharing/ScreenSharing.h>

#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;

};

}

#include <rtpsessionparams.h>

namespace Swift {

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

send(data, len);

return true;

}

return RTPSessionImpl::nativeAddressToJRTPAddress(udpSocket->getLocalAddress()).IsSameAddress(address);

}

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

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

}

RTPSessionImpl::RTPSessionImpl(boost::shared_ptr<UDPSocket> udpSocket, const RTPPayloadType &payloadType)

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);

virtual bool ComesFromThisSender (const jrtplib::RTPAddress* address);

*/

#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;

}

}

#pragma once

#include <Swiften/Base/boost_bsignals.h>

#include <Swiften/Base/IDGenerator.h>

#include <boost/shared_ptr.hpp>

namespace Swift {

class JingleSession;

class JingleRawUDPTransportPayload;

class UDPSocketFactory;

class UDPSocket;

class ScreenSharing {

public:

typedef boost::shared_ptr<ScreenSharing> ref;

WaitingForAccept,

};

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

}

// Update the default configuration with our settings

vpx_img_free(imageBuffer);

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];

yPlane[i] = ((66 * p[0] + 129 * p[1] + 25 * p[2] + 128) >> 8) + 16;

#include <Swiften/ScreenSharing/VP8Decoder.h>

namespace Swift {

: decoder(decoder), firstPacket(true)

{

}

#include <stdint.h>

#include <stddef.h>

namespace Swift {

class VP8RTPParser {

public:

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

private:

static const uint8_t SBit = 1 << 4;

static const uint8_t HBit = 1 << 4;

static const uint8_t Size0BitShift = 5;

std::vector<uint8_t> buffer;

bool firstPacket;

size_t frameSize;