Відеокамера реального часу своїми руками

#include “liveMedia.hh”#include “GroupsockHelper.hh”

#include “BasicUsageEnvironment.hh”

// To convert 16-bit samples to 8-bit u-law (“u” is the Greek letter “mu”)
// encoding, before streaming, uncomment the following line:
//#define CONVERT_TO_ULAW 1

UsageEnvironment* env;

void play(); // forward

int main(int argc, char** argv) {
// Begin by setting up our usage environment:
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
env = BasicUsageEnvironment::createNew(*scheduler);

play();

env->taskScheduler().doEventLoop(); // does not return
return 0; // only to prevent compiler warnings
}

char const* inputFileName = “stdin”;

void afterPlaying(void* clientData); // forward

// A structure to hold the state of the current session.
// It is used in the “afterPlaying()” function to clean up the session.
struct sessionState_t {
FramedSource* source;
RTPSink* sink;
RTCPInstance* rtcpInstance;
Groupsock* rtpGroupsock;
Groupsock* rtcpGroupsock;
RTSPServer* rtspServer;
} sessionState;

void play() {
// Open the file as a ‘WAV’ file:
WAVAudioFileSource* wavSource = WAVAudioFileSource::createNew(*env, inputFileName);
if (wavSource == NULL) {
*env << “Unable to open file \”” << inputFileName
<< “\” as a WAV audio file source: ”
<< env->getResultMsg() << “\n”;
exit(1);
}

// Get attributes of the audio source:
unsigned char audioFormat = wavSource->getAudioFormat();
unsigned char const bitsPerSample = wavSource->bitsPerSample();
// We handle only 4,8,16,20,24 bits-per-sample audio:
if (bitsPerSample%4 != 0 || bitsPerSample < 4 || bitsPerSample > 24 || bitsPerSample == 12) {
*env << “The input file contains ” << bitsPerSample << ” bit-per-sample audio, which we don’t handle\n”;
exit(1);
}
unsigned const samplingFrequency = wavSource->samplingFrequency();
unsigned char const numChannels = wavSource->numChannels();
unsigned bitsPerSecond = samplingFrequency*bitsPerSample*numChannels;
*env << “Audio source parameters:\n\t” << samplingFrequency << ” Hz, “;
*env << bitsPerSample << ” bits-per-sample, “;
*env << numChannels << ” channels => “;
*env << bitsPerSecond << ” bits-per-second\n”;

char const* mimeType;
unsigned char payloadFormatCode = 96; // by default, unless a static RTP payload type can be used

// Add in any filter necessary to transform the data prior to streaming.
// (This is where any audio compression would get added.)
sessionState.source = wavSource; // by default
if (audioFormat == WA_PCM) {
if (bitsPerSample == 16) {
// Note that samples in the WAV audio file are in little-endian order.
#ifdef CONVERT_TO_ULAW
// Add a filter that converts from raw 16-bit PCM audio (in little-endian order) to 8-bit u-law audio:
sessionState.source = uLawFromPCMAudioSource::createNew(*env, wavSource, 1/*little-endian*/);
if (sessionState.source == NULL) {
*env << “Unable to create a u-law filter from the PCM audio source: ” << env->getResultMsg() << “\n”;
exit(1);
}
bitsPerSecond /= 2;
*env << “Converting to 8-bit u-law audio for streaming => ” << bitsPerSecond << ” bits-per-second\n”;
mimeType = “PCMU”;
if (samplingFrequency == 8000 && numChannels == 1) {
payloadFormatCode = 0; // a static RTP payload type
}
#else
// Add a filter that converts from little-endian to network (big-endian) order:
sessionState.source = EndianSwap16::createNew(*env, wavSource);
if (sessionState.source == NULL) {
*env << “Unable to create a little->bit-endian order filter from the PCM audio source: ” << env->getResultMsg() << “\n”;
exit(1);
}
*env << “Converting to network byte order for streaming\n”;
mimeType = “L16”;
if (samplingFrequency == 44100 && numChannels == 2) {
payloadFormatCode = 10; // a static RTP payload type
} else if (samplingFrequency == 44100 && numChannels == 1) {
payloadFormatCode = 11; // a static RTP payload type
}
#endif
} else if (bitsPerSample == 20 || bitsPerSample == 24) {
// Add a filter that converts from little-endian to network (big-endian) order:
sessionState.source = EndianSwap24::createNew(*env, wavSource);
if (sessionState.source == NULL) {
*env << “Unable to create a little->bit-endian order filter from the PCM audio source: ” << env->getResultMsg() << “\n”;
exit(1);
}
*env << “Converting to network byte order for streaming\n”;
mimeType = bitsPerSample == 20 ? “L20” : “L24”;
} else { // bitsPerSample == 8 (we assume that bitsPerSample == 4 is only for WA_IMA_ADPCM)
// Don’t do any transformation; send the 8-bit PCM data ‘as is’:
mimeType = “L8”;
}
} else if (audioFormat == WA_PCMU) {
mimeType = “PCMU”;
if (samplingFrequency == 8000 && numChannels == 1) {
payloadFormatCode = 0; // a static RTP payload type
}
} else if (audioFormat == WA_PCMA) {
mimeType = “PCMA”;
if (samplingFrequency == 8000 && numChannels == 1) {
payloadFormatCode = 8; // a static RTP payload type
}
} else if (audioFormat == WA_IMA_ADPCM) {
mimeType = “DVI4”;
// Use a static payload type, if one is defined:
if (numChannels == 1) {
if (samplingFrequency == 8000) {
payloadFormatCode = 5; // a static RTP payload type
} else if (samplingFrequency == 16000) {
payloadFormatCode = 6; // a static RTP payload type
} else if (samplingFrequency == 11025) {
payloadFormatCode = 16; // a static RTP payload type
} else if (samplingFrequency == 22050) {
payloadFormatCode = 17; // a static RTP payload type
}
}
} else { //unknown format
*env << “Unknown audio format code \”” << audioFormat << “\” in WAV file header\n”;
exit(1);
}

// Create ‘groupsocks’ for RTP and RTCP:
struct in_addr destinationAddress;
destinationAddress.s_addr = chooseRandomIPv4SSMAddress(*env);
// Note: This is a multicast address. If you wish instead to stream
// using unicast, then you should use the “testOnDemandRTSPServer” demo application,
// or the “LIVE555 Media Server” – not this application – as a model.

const unsigned short rtpPortNum = 2222;
const unsigned short rtcpPortNum = rtpPortNum+1;
const unsigned char ttl = 255;

const Port rtpPort(rtpPortNum);
const Port rtcpPort(rtcpPortNum);

sessionState.rtpGroupsock
= new Groupsock(*env, destinationAddress, rtpPort, ttl);
sessionState.rtpGroupsock->multicastSendOnly(); // we’re a SSM source
sessionState.rtcpGroupsock
= new Groupsock(*env, destinationAddress, rtcpPort, ttl);
sessionState.rtcpGroupsock->multicastSendOnly(); // we’re a SSM source

// Create an appropriate audio RTP sink (using “SimpleRTPSink”) from the RTP ‘groupsock’:
sessionState.sink
= SimpleRTPSink::createNew(*env, sessionState.rtpGroupsock,
payloadFormatCode, samplingFrequency,
“audio”, mimeType, numChannels);

// Create (and start) a ‘RTCP instance’ for this RTP sink:
const unsigned estimatedSessionBandwidth = (bitsPerSecond + 500)/1000; // in kbps; for RTCP b/w share
const unsigned maxCNAMElen = 100;
unsigned char CNAME[maxCNAMElen+1];
gethostname((char*)CNAME, maxCNAMElen);
CNAME[maxCNAMElen] = ‘\0’; // just in case
sessionState.rtcpInstance
= RTCPInstance::createNew(*env, sessionState.rtcpGroupsock,
estimatedSessionBandwidth, CNAME,
sessionState.sink, NULL /* we’re a server */,
True /* we’re a SSM source*/);
// Note: This starts RTCP running automatically

// Create and start a RTSP server to serve this stream:
sessionState.rtspServer = RTSPServer::createNew(*env, 8554);
if (sessionState.rtspServer == NULL) {
*env << “Failed to create RTSP server: ” << env->getResultMsg() << “\n”;
exit(1);
}
ServerMediaSession* sms
= ServerMediaSession::createNew(*env, “testStream”, inputFileName,
“Session streamed by \”testWAVAudiotreamer\””, True/*SSM*/);
sms->addSubsession(PassiveServerMediaSubsession::createNew(*sessionState.sink, sessionState.rtcpInstance));
sessionState.rtspServer->addServerMediaSession(sms);

char* url = sessionState.rtspServer->rtspURL(sms);
*env << “Play this stream using the URL \”” << url << “\”\n”;
delete[] url;

// Finally, start the streaming:
*env << “Beginning streaming…\n”;
sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
}
void afterPlaying(void* /*clientData*/) {
*env << “…done streaming\n”;

// End by closing the media:
Medium::close(sessionState.rtspServer);
Medium::close(sessionState.rtcpInstance);
Medium::close(sessionState.sink);
delete sessionState.rtpGroupsock;
Medium::close(sessionState.source);
delete sessionState.rtcpGroupsock;

// We’re done:
exit(0);
}

#include “liveMedia.hh”#include “GroupsockHelper.hh”
#include “BasicUsageEnvironment.hh”

UsageEnvironment* env;

void play(); // forward

int main(int argc, char** argv) {
// Begin by setting up our usage environment:
TaskScheduler* scheduler = BasicTaskScheduler::createNew();
env = BasicUsageEnvironment::createNew(*scheduler);

play();

env->taskScheduler().doEventLoop(); // does not return
return 0; // only to prevent compiler warnings
}

char const* inputFileName = “stdin”;

void afterPlaying(void* clientData); // forward

// A structure to hold the state of the current session.
// It is used in the “afterPlaying()” function to clean up the session.
struct sessionState_t {
FramedSource* source;
RTPSink* sink;
RTCPInstance* rtcpInstance;
Groupsock* rtpGroupsock;
Groupsock* rtcpGroupsock;
RTSPServer* rtspServer;
} sessionState;

void play() {
// Open the file as a ‘MP3 file source’:
sessionState.source = MP3FileSource::createNew(*env, inputFileName);
if (sessionState.source == NULL) {
*env << “Unable to open file \”” << inputFileName
<< “\” as a MP3 file source\n”;
exit(1);
}

// Create ‘groupsocks’ for RTP and RTCP:
struct in_addr destinationAddress;
destinationAddress.s_addr = chooseRandomIPv4SSMAddress(*env);
// Note: This is a multicast address. If you wish instead to stream
// using unicast, then you should use the “testOnDemandRTSPServer” demo application,
// or the “LIVE555 Media Server” – not this application – as a model.

const unsigned short rtpPortNum = 2222;
const unsigned short rtcpPortNum = rtpPortNum+1;
const unsigned char ttl = 255;

const Port rtpPort(rtpPortNum);
const Port rtcpPort(rtcpPortNum);

sessionState.rtpGroupsock
= new Groupsock(*env, destinationAddress, rtpPort, ttl);
sessionState.rtpGroupsock->multicastSendOnly(); // we’re a SSM source
sessionState.rtcpGroupsock
= new Groupsock(*env, destinationAddress, rtcpPort, ttl);
sessionState.rtcpGroupsock->multicastSendOnly(); // we’re a SSM source

sessionState.sink
= MPEG1or2AudioRTPSink::createNew(*env, sessionState.rtpGroupsock);
// Create (and start) a ‘RTCP instance’ for this RTP sink:
const unsigned estimatedSessionBandwidth = 160;
const unsigned maxCNAMElen = 100;
unsigned char CNAME[maxCNAMElen+1];
gethostname((char*)CNAME, maxCNAMElen);
CNAME[maxCNAMElen] = ‘\0’; // just in case
sessionState.rtcpInstance
= RTCPInstance::createNew(*env, sessionState.rtcpGroupsock,
estimatedSessionBandwidth, CNAME,
sessionState.sink, NULL /* we’re a server */,
True /* we’re a SSM source*/);
// Note: This starts RTCP running automatically

// Create and start a RTSP server to serve this stream:
sessionState.rtspServer = RTSPServer::createNew(*env, 8554);
if (sessionState.rtspServer == NULL) {
*env << “Failed to create RTSP server: ” << env->getResultMsg() << “\n”;
exit(1);
}
ServerMediaSession* sms
= ServerMediaSession::createNew(*env, “testStream”, inputFileName,
“Session streamed by \”testWAVAudiotreamer\””, True/*SSM*/);
sms->addSubsession(PassiveServerMediaSubsession::createNew(*sessionState.sink, sessionState.rtcpInstance));
sessionState.rtspServer->addServerMediaSession(sms);

char* url = sessionState.rtspServer->rtspURL(sms);
*env << “Play this stream using the URL \”” << url << “\”\n”;
delete[] url;

// Finally, start the streaming:
*env << “Beginning streaming…\n”;
sessionState.sink->startPlaying(*sessionState.source, afterPlaying, NULL);
}

void afterPlaying(void* /*clientData*/) {
*env << “…done streaming\n”;

// End by closing the media:
Medium::close(sessionState.rtspServer);
Medium::close(sessionState.rtcpInstance);
Medium::close(sessionState.sink);
delete sessionState.rtpGroupsock;
Medium::close(sessionState.source);
delete sessionState.rtcpGroupsock;

// We’re done:
exit(0);
}

<icecast><limits>
<clients>4</clients>
<sources>1</sources>
<threadpool>5</threadpool>
<queue-size>524288</queue-size>
<client-timeout>30</client-timeout>
<header-timeout>15</header-timeout>
<source-timeout>10</source-timeout>
<burst-on-connect>0</burst-on-connect>
<burst-size>65535</burst-size>
</limits>

<authentication>
<!– Sources log in with username ‘source’ –>
<source-password>password</source-password>
<!– Relays log in username ‘relay’ –>
<relay-password>password</relay-password>

<!– Admin logs in with the username given below –>
<admin-user>admin</admin-user>
<admin-password>password</admin-password>
</authentication>

<!– This is the hostname other people will use to connect to your server.
It affects mainly the urls generated by Icecast for playlists and yp
listings. –>
<hostname>localhost</hostname>

<!– You may have multiple <listener> elements –>
<listen-socket>
<port>8000</port>
<!– <bind-address>127.0.0.1</bind-address> –>
<!– <shoutcast-mount>/stream</shoutcast-mount> –>
</listen-socket>

<paths>
<!– basedir is only used if chroot is enabled –>
<basedir>/usr/share/icecast2</basedir>

<!– Note that if <chroot> is turned on below, these paths must both
be relative to the new root, not the original root –>
<logdir>/var/log/icecast2</logdir>
<webroot>/usr/share/icecast2/web</webroot>
<adminroot>/usr/share/icecast2/admin</adminroot>

<alias source=”/” dest=”/status.xsl”/>
</paths>

<logging>
<accesslog>access.log</accesslog>
<errorlog>error.log</errorlog>
<loglevel>1</loglevel> <!– 4 Debug, 3 Info, 2 Warn, 1 Error –>
<logsize>10000</logsize> <!– Max size of a logfile –>
</logging>

<security>
<chroot>0</chroot>

</security>
</icecast>

<?xml version=”1.0″?><ices>
<!– run in background –>
<background>0</background>
<!– where logs, etc go. –>
<logpath>/var/log/ices</logpath>
<logfile>ices.log</logfile>
<!– 1=error,2=warn,3=info,4=debug –>
<loglevel>1</loglevel>
<!– set this to 1 to log to the console instead of to the file above –>
<consolelog>1</consolelog>
<stream>
<!– metadata used for stream listing (not currently used) –>
<metadata>
<name>mypi</name>
<genre>webcam audio</genre>
<description>stream</description>
<url>http://seka.org.ua</url>
</metadata>

<input>
<module>alsa</module>
<param name=”rate”>24000</param>
<param name=”channels”>1</param>
<param name=”device”>hw:1,0</param>
<param name=”metadata”>0</param>
<param name=”metadatafilename”>/home/ices/metadata</param>
</input>

<instance>
<!– Server details:
You define hostname and port for the server here, along with
the source password and mountpoint. –>
<hostname>localhost</hostname>
<port>8000</port>
<password>password</password>
<mount>/audio.ogg</mount>

<!– Reconnect parameters:
When something goes wrong (e.g. the server crashes, or the
network drops) and ices disconnects from the server, these
control how often it tries to reconnect, and how many times
it tries to reconnect. Delay is in seconds.
If you set reconnectattempts to -1, it will continue
indefinately. Suggest setting reconnectdelay to a large value
if you do this.
–>
<reconnectdelay>2</reconnectdelay>
<reconnectattempts>5</reconnectattempts>

<!– maxqueuelength:
This describes how long the internal data queues may be. This
basically lets you control how much data gets buffered before
ices decides it can’t send to the server fast enough, and
either shuts down or flushes the queue (dropping the data)
and continues.
For advanced users only.
–>
<maxqueuelength>80</maxqueuelength>

<!– Live encoding/reencoding:
Currrently, the parameters given here for encoding MUST
match the input data for channels and sample rate. That
restriction will be relaxed in the future.
–>

<encode>
<nominal-bitrate>64000</nominal-bitrate>
<samplerate>24000</samplerate>
<channels>1</channels>
</encode>

</instance>
</stream>
</ices>