Commit b04dbad

#include "H264LiveVideoSource.h"

H264LiveVideoSource* H264LiveVideoSource::createNew(UsageEnvironment& env, Boolean deleteBufferOnClose, unsigned preferredFrameSize, unsigned playTimePerFrame, int fd_pipe[2])

{

H264LiveVideoSource* videosource = new H264LiveVideoSource(env, deleteBufferOnClose, preferredFrameSize, playTimePerFrame, fd_pipe);

return videosource;

}

H264LiveVideoSource::H264LiveVideoSource(UsageEnvironment& env, Boolean deleteBufferOnClose, unsigned preferredFrameSize, unsigned playTimePerFrame, int fd_pipe[2]) :

FramedSource(env), fDeleteBufferOnClose(deleteBufferOnClose), fPreferredFrameSize(preferredFrameSize), fPlayTimePerFrame(playTimePerFrame), fLastPlayTime(0)

{

}

H264LiveVideoSource::~H264LiveVideoSource()

{

}

void H264LiveVideoSource::doGetNextFrame()

{

}

#ifndef H264_LIVEVIDEOSOURCE_H

#define H264_LIVEVIDEOSOURCE_H

#include "../live555/UsageEnvironment/UsageEnvironment.hh"

#include "../live555/liveMedia/FramedSource.hh"

class H264LiveVideoSource: public FramedSource

{

static H264LiveVideoSource* createNew(UsageEnvironment& env, Boolean deleteBufferOnClose = True, unsigned preferredFrameSize = 0, unsigned playTimePerFrame = 0,

int fd_pipe[2] = NULL);

void seekToByteAbsolute(u_int64_t byteNumber, u_int64_t numBytesToStream = 0);

// if "numBytesToStream" is >0, then we limit the stream to that number of bytes, before treating it as EOF

void seekToByteRelative(int64_t offset);

H264LiveVideoSource(UsageEnvironment& env, Boolean deleteBufferOnClose, unsigned preferredFrameSize, unsigned playTimePerFrame, int fd_pipe[2]);

~H264LiveVideoSource();

// redefined virtual functions:

virtual void doGetNextFrame();

int fd[2];

Boolean fDeleteBufferOnClose;

unsigned fPreferredFrameSize;

unsigned fPlayTimePerFrame;

unsigned fLastPlayTime;

Boolean fLimitNumBytesToStream;

u_int64_t fNumBytesToStream; // used iff "fLimitNumBytesToStream" is True

};

#include "../live555/liveMedia/H264VideoFileServerMediaSubsession.hh"

class H264LiveVideoServerMediaSubsession: public OnDemandServerMediaSubsession

{

static H264LiveVideoServerMediaSubsession*

createNew(UsageEnvironment& env, Boolean reuseFirstSource, int fifo[2]);

void checkForAuxSDPLine1();

void afterPlayingDummy1();

H264LiveVideoServerMediaSubsession(UsageEnvironment& env, Boolean reuseFirstSource, int fifo[2]);

virtual ~H264LiveVideoServerMediaSubsession();

void setDoneFlag()

{

fDoneFlag = ~0;

}

// redefined virtual functions

virtual FramedSource* createNewStreamSource(unsigned clientSessionId, unsigned& estBitrate);

virtual RTPSink* createNewRTPSink(Groupsock* rtpGroupsock, unsigned char rtpPayloadTypeIfDynamic, FramedSource* inputSource);

virtual char const* getAuxSDPLine(RTPSink* rtpSink, FramedSource* inputSource);

int m_fifo[2];

char* fAuxSDPLine;

char fDoneFlag; // used when setting up "fAuxSDPLine"

RTPSink* fDummyRTPSink; // ditto

};

#endif /* H264LIVEVIDEOSOURCE_H */

SOURCES +=src/live/RTMPLiveVideo.cpp src/live/H264MemReader.cpp src/live/H264LiveVideoSource.cpp

OBJS +=src/live/RTMPLiveVideo.o src/live/H264MemReader.o src/live/H264LiveVideoSource.o

#ifndef _BASIC_HASH_TABLE_HH

#define _BASIC_HASH_TABLE_HH

#ifndef _HASH_TABLE_HH

#include "HashTable.hh"

#endif

#ifndef _NET_COMMON_H

#include <NetCommon.h> // to ensure that "uintptr_t" is defined

#endif

#define SMALL_HASH_TABLE_SIZE 4

class BasicHashTable: public HashTable {

class TableEntry; // forward

BasicHashTable(int keyType);

virtual ~BasicHashTable();

// Used to iterate through the members of the table:

class Iterator; friend class Iterator; // to make Sun's C++ compiler happy

class Iterator: public HashTable::Iterator {

public:

Iterator(BasicHashTable const& table);

private: // implementation of inherited pure virtual functions

void* next(char const*& key); // returns 0 if none

private:

BasicHashTable const& fTable;

unsigned fNextIndex; // index of next bucket to be enumerated after this

TableEntry* fNextEntry; // next entry in the current bucket

};

private: // implementation of inherited pure virtual functions

virtual void* Add(char const* key, void* value);

// Returns the old value if different, otherwise 0

virtual Boolean Remove(char const* key);

virtual void* Lookup(char const* key) const;

// Returns 0 if not found

virtual unsigned numEntries() const;

class TableEntry {

public:

TableEntry* fNext;

char const* key;

void* value;

};

TableEntry* lookupKey(char const* key, unsigned& index) const;

// returns entry matching "key", or NULL if none

Boolean keyMatches(char const* key1, char const* key2) const;

// used to implement "lookupKey()"

TableEntry* insertNewEntry(unsigned index, char const* key);

// creates a new entry, and inserts it in the table

void assignKey(TableEntry* entry, char const* key);

// used to implement "insertNewEntry()"

void deleteEntry(unsigned index, TableEntry* entry);

void deleteKey(TableEntry* entry);

// used to implement "deleteEntry()"

void rebuild(); // rebuilds the table as its size increases

unsigned hashIndexFromKey(char const* key) const;

// used to implement many of the routines above

unsigned randomIndex(uintptr_t i) const {

return (unsigned)(((i*1103515245) >> fDownShift) & fMask);

}

TableEntry** fBuckets; // pointer to bucket array

TableEntry* fStaticBuckets[SMALL_HASH_TABLE_SIZE];// used for small tables

unsigned fNumBuckets, fNumEntries, fRebuildSize, fDownShift, fMask;

int fKeyType;

};

#endif

#ifndef _BASIC_USAGE_ENVIRONMENT_HH

#define _BASIC_USAGE_ENVIRONMENT_HH

#ifndef _BASIC_USAGE_ENVIRONMENT0_HH

#include "BasicUsageEnvironment0.hh"

#endif

class BasicUsageEnvironment: public BasicUsageEnvironment0 {

static BasicUsageEnvironment* createNew(TaskScheduler& taskScheduler);

// redefined virtual functions:

virtual int getErrno() const;

virtual UsageEnvironment& operator<<(char const* str);

virtual UsageEnvironment& operator<<(int i);

virtual UsageEnvironment& operator<<(unsigned u);

virtual UsageEnvironment& operator<<(double d);

virtual UsageEnvironment& operator<<(void* p);

BasicUsageEnvironment(TaskScheduler& taskScheduler);

// called only by "createNew()" (or subclass constructors)

virtual ~BasicUsageEnvironment();

};

class BasicTaskScheduler: public BasicTaskScheduler0 {

static BasicTaskScheduler* createNew(unsigned maxSchedulerGranularity = 10000/*microseconds*/);

// "maxSchedulerGranularity" (default value: 10 ms) specifies the maximum time that we wait (in "select()") before

// returning to the event loop to handle non-socket or non-timer-based events, such as 'triggered events'.

// You can change this is you wish (but only if you know what you're doing!), or set it to 0, to specify no such maximum time.

// (You should set it to 0 only if you know that you will not be using 'event triggers'.)

virtual ~BasicTaskScheduler();

BasicTaskScheduler(unsigned maxSchedulerGranularity);

// called only by "createNew()"

static void schedulerTickTask(void* clientData);

void schedulerTickTask();

// Redefined virtual functions:

virtual void SingleStep(unsigned maxDelayTime);

virtual void setBackgroundHandling(int socketNum, int conditionSet, BackgroundHandlerProc* handlerProc, void* clientData);

virtual void moveSocketHandling(int oldSocketNum, int newSocketNum);

unsigned fMaxSchedulerGranularity;

// To implement background operations:

int fMaxNumSockets;

fd_set fReadSet;

fd_set fWriteSet;

fd_set fExceptionSet;

#if defined(__WIN32__) || defined(_WIN32)

// Hack to work around a bug in Windows' "select()" implementation:

int fDummySocketNum;

#endif

};

#endif