/*
 * H264DeviceSource.hh
 *
 *  Created on: 2014年7月19日
 *      Author: zjzhang
 */

#ifndef H264DEVICESOURCE_HH_
#define H264DEVICESOURCE_HH_
#include<DeviceSource.hh>

class H264DeviceSource: public DeviceSource {
public:
	static DeviceSource* createNew(UsageEnvironment& env,u_int8_t index=1,u_int width=352,u_int height=288,u_int fps=15,u_int kbps=100);
protected:
	H264DeviceSource(UsageEnvironment& env,u_int8_t index,u_int width,u_int height,u_int fps,u_int kbps);
	virtual ~H264DeviceSource();
private:
	virtual void doGetNextFrame();
	virtual unsigned maxFrameSize() const;
	int fHeight;
	int fWidth;
	void *fH264Encoder;
	u_int8_t * fBuffer;
	u_int fBufferSize;
};

#endif /* H264DEVICESOURCE_HH_ */

/*
 * H264DeviceSource.cpp
 *
 *  Created on: 2014年7月19日
 *      Author: zjzhang
 */

#include "H264DeviceSource.hh"
#ifdef __cplusplus
extern "C" {
#endif
#include "H264Stream.h"
#ifdef __cplusplus
}
#endif
DeviceSource*
H264DeviceSource::createNew(UsageEnvironment& env, u_int8_t index, u_int width,
		u_int height, u_int fps, u_int kbps) {
	return new H264DeviceSource(env, index, width, height, fps, kbps);
}

H264DeviceSource::H264DeviceSource(UsageEnvironment& env, u_int8_t index,
		u_int width, u_int height, u_int fps, u_int kbps) :
		DeviceSource(env, DeviceParameters()) {
	openCamera(1);
	getFrame(1);
	fHeight = getHeight(1);
	fWidth = getWidth(1);
	openH264Encoder(fWidth, fHeight, fps, kbps, &fH264Encoder);
	fBufferSize = fHeight * fWidth * 3 / 2;
	fBuffer = new uint8_t[fBufferSize];

}

H264DeviceSource::~H264DeviceSource() {
	// TODO Auto-generated destructor stub

	delete[] fBuffer;
	closeH264Encoder(fH264Encoder);
	closeCamera(1);
}
unsigned H264DeviceSource::maxFrameSize() const {
  // By default, this source has no maximum frame size.
  return 4096;
}
void H264DeviceSource::doGetNextFrame() {
	if (!isCurrentlyAwaitingData())
		return; // we're not ready for the data yet

	unsigned char * rgbBuffer = getFrame(1);
	ConvertRGB2YUV(fWidth, fHeight, rgbBuffer, fBuffer);
	int newFrameSize = encodeFrame(fH264Encoder, fBuffer, fBufferSize);

	// Deliver the data here:
	if (newFrameSize < 0) {
		handleClosure();
		return;
	}
	if (newFrameSize > fMaxSize) {
		fFrameSize = fMaxSize;
		fNumTruncatedBytes = newFrameSize - fMaxSize;
	} else {
		fFrameSize = newFrameSize;
	}
	if (fFrameSize > 0) {
		int result = 0;
		int p = 0;
		do {
			unsigned long len = 0;
			result = getNextPacket(fH264Encoder, fBuffer + p, &len);
			p += len;
		} while (result > 0);
	}

	gettimeofday(&fPresentationTime, NULL); // If you have a more accurate time - e.g., from an encoder - then use that instead.
	// If the device is *not* a 'live source' (e.g., it comes instead from a file or buffer), then set "fDurationInMicroseconds" here.
	memmove(fTo, fBuffer, fFrameSize);

	FramedSource::afterGetting(this);
}

#ifndef _DEVIC_SERVER_MEDIA_SUBSESSION_HH
#define _DEVICE_SERVER_MEDIA_SUBSESSION_HH

#ifndef _ON_DEMAND_SERVER_MEDIA_SUBSESSION_HH
#include "OnDemandServerMediaSubsession.hh"
#endif
class  DeviceSource;
class DeviceServerMediaSubsession: public OnDemandServerMediaSubsession {
public:
  static DeviceServerMediaSubsession*
  createNew(UsageEnvironment& env,
		    Boolean reuseFirstSource);

  // Used to implement "getAuxSDPLine()":
  void checkForAuxSDPLine1();
  void afterPlayingDummy1();
protected: // we're a virtual base class
  DeviceServerMediaSubsession(UsageEnvironment& env,
			    Boolean reuseFirstSource);
  virtual ~DeviceServerMediaSubsession();

  void setDoneFlag() { fDoneFlag = ~0; }

protected: // redefined virtual functions
  virtual char const* getAuxSDPLine(RTPSink* rtpSink,
				    FramedSource* inputSource);
  virtual FramedSource* createNewStreamSource(unsigned clientSessionId,
					      unsigned& estBitrate);
  virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock,
                                    unsigned char rtpPayloadTypeIfDynamic,
				    FramedSource* inputSource);

private:
  char* fAuxSDPLine;
  char fDoneFlag; // used when setting up "fAuxSDPLine"
  RTPSink* fDummyRTPSink; // ditto
};

#endif

#include "DeviceServerMediaSubsession.hh"
#include "H264VideoRTPSink.hh"
#include "DeviceSource.hh"
#include "H264VideoStreamFramer.hh"
#include "H264DeviceSource.hh"

DeviceServerMediaSubsession*
DeviceServerMediaSubsession::createNew(UsageEnvironment& env,
		Boolean reuseFirstSource) {
	return new DeviceServerMediaSubsession(env, reuseFirstSource);
}
DeviceServerMediaSubsession::DeviceServerMediaSubsession(UsageEnvironment& env,
		Boolean reuseFirstSource) :
		OnDemandServerMediaSubsession(env, reuseFirstSource) {
}

DeviceServerMediaSubsession::~DeviceServerMediaSubsession() {
}

FramedSource* DeviceServerMediaSubsession::createNewStreamSource(
		unsigned /*clientSessionId*/, unsigned& estBitrate) {
	DeviceSource* source = H264DeviceSource::createNew(envir());
	return H264VideoStreamFramer::createNew(envir(), source);
}

RTPSink* DeviceServerMediaSubsession::createNewRTPSink(Groupsock* rtpGroupsock,
		unsigned char rtpPayloadTypeIfDynamic, FramedSource* /*inputSource*/) {
	return H264VideoRTPSink::createNew(envir(), rtpGroupsock,
			rtpPayloadTypeIfDynamic);
}

static void afterPlayingDummy(void* clientData) {
	DeviceServerMediaSubsession* subsess =
			(DeviceServerMediaSubsession*) clientData;
	subsess->afterPlayingDummy1();
}

void DeviceServerMediaSubsession::afterPlayingDummy1() {
	// Unschedule any pending 'checking' task:
	envir().taskScheduler().unscheduleDelayedTask(nextTask());
	// Signal the event loop that we're done:
	setDoneFlag();
}

static void checkForAuxSDPLine(void* clientData) {
	DeviceServerMediaSubsession* subsess =
			(DeviceServerMediaSubsession*) clientData;
	subsess->checkForAuxSDPLine1();
}

void DeviceServerMediaSubsession::checkForAuxSDPLine1() {
	char const* dasl;

	if (fAuxSDPLine != NULL) {
		// Signal the event loop that we're done:
		setDoneFlag();
	} else if (fDummyRTPSink != NULL
			&& (dasl = fDummyRTPSink->auxSDPLine()) != NULL) {
		fAuxSDPLine = strDup(dasl);
		fDummyRTPSink = NULL;

		// Signal the event loop that we're done:
		setDoneFlag();
	} else if (!fDoneFlag) {
		// try again after a brief delay:
		int uSecsToDelay = 100000; // 100 ms
		nextTask() = envir().taskScheduler().scheduleDelayedTask(uSecsToDelay,
				(TaskFunc*) checkForAuxSDPLine, this);
	}
}
char const* DeviceServerMediaSubsession::getAuxSDPLine(RTPSink* rtpSink,
		FramedSource* inputSource) {

	if (fAuxSDPLine != NULL)
		return fAuxSDPLine; // it's already been set up (for a previous client)

	if (fDummyRTPSink == NULL) { // we're not already setting it up for another, concurrent stream
		// Note: For H264 video files, the 'config' information ("profile-level-id" and "sprop-parameter-sets") isn't known
		// until we start reading the file.  This means that "rtpSink"s "auxSDPLine()" will be NULL initially,
		// and we need to start reading data from our file until this changes.
		fDummyRTPSink = rtpSink;

		// Start reading the file:
		fDummyRTPSink->startPlaying(*inputSource, afterPlayingDummy, this);

		// Check whether the sink's 'auxSDPLine()' is ready:
		checkForAuxSDPLine(this);
	}

	envir().taskScheduler().doEventLoop(&fDoneFlag);

	return fAuxSDPLine;
}