int main(void)
{
int status,i;
RTPSession s;
RTPSessionParams sessparams;
RTPUDPv4TransmissionParams transparams;
char blaai[100];
transparams.SetPortbase(10000);
sessparams.SetOwnTimestampUnit(1.0/8000.0);
sessparams.SetUsePollThread(true);
sessparams.SetMaximumPacketSize(10000);
status = s.Create(sessparams,&transparams);
s.SetLocalName((const uint8_t *)"Jori Liesenborgs",16);
s.SetLocalEMail((const uint8_t *)"*****@*****.**",20);
s.SetLocalNote((const uint8_t *)"Blaai",5);
s.SetNameInterval(3);
s.SetEMailInterval(5);
s.SetNoteInterval(2);
status = s.AddDestination(RTPIPv4Address(ntohl(inet_addr("192.168.2.115")),5000));
//status = s.AddDestination(RTPIPv4Address(ntohl(inet_addr("127.0.0.1")),7000));
int snd = open("/dev/dsp",O_RDWR);
int val;
val = 0;
status = ioctl(snd,SNDCTL_DSP_STEREO,&val);
val = 8;
status = ioctl(snd,SNDCTL_DSP_SAMPLESIZE,&val);
val = 8000;
status = ioctl(snd,SNDCTL_DSP_SPEED,&val);
val = 7 | (128<<16);
ioctl(snd,SNDCTL_DSP_SETFRAGMENT,&val);
i = 0;
while (i++ < 40000)
{
if (i == 1000)
{
//std::cout <<"Disabling note" << std::endl;
s.SetNoteInterval(0);
}
uint8_t data[PACKSIZE];
RTPTime t1 = RTPTime::CurrentTime();
status = read(snd,data,PACKSIZE);
RTPTime t2 = RTPTime::CurrentTime();
t2 -= t1;
printf("%d.%06d\n",t2.GetSeconds(),t2.GetMicroSeconds());
status = s.SendPacket(data,PACKSIZE,1,false,PACKSIZE);
}
close(snd);
printf("Destroying...\n");
s.BYEDestroy(RTPTime(10,0),(const uint8_t *)"Leaving session",16);
return 0;
}
/***********************************************************************************************************
**函数:Rtp_Lock
**功能:
**输入参数:
**返回值:
***********************************************************************************************************/
static int RtpSetup( uint16_t portbase)
{
int status;
RTPUDPv4TransmissionParams transparams;
RTPSessionParams sessparams;
sessparams.SetOwnTimestampUnit(1.0/90000.0);
sessparams.SetMaximumPacketSize(1200);
transparams.SetPortbase(portbase);
sess.SetDefaultPayloadType(PLOAD_TYPE);
sess.SetDefaultMark(false);
sess.SetDefaultTimestampIncrement(DefaultTimestampIncrement);
status = sess.Create(sessparams,&transparams);
checkerror(status);
return status;
}
// Create a new RTP session. If multicast is not being used then multicastIP
// should be set to an empty string.
static RTPSession createRtpSession(const std::string& multicastIP,
unsigned int port)
{
RTPSession session;
//if (setenv("LOGNAME", "video", 0) != 0) {
// throw std::runtime_error("Error setting LOGNAME environment variable");
//}
// Set up session params
RTPSessionParams sessionparams;
sessionparams.SetUsePollThread(false);
sessionparams.SetMaximumPacketSize(1400);
sessionparams.SetAcceptOwnPackets(true);
sessionparams.SetOwnTimestampUnit(1.0f/900000.0f);
sessionparams.SetResolveLocalHostname(false);
sessionparams.SetSessionBandwidth(9000000);
sessionparams.SetReceiveMode(RTPTransmitter::AcceptAll);
RTPUDPv4TransmissionParams transparams;
transparams.SetPortbase(port);
int status = session.Create(sessionparams, &transparams);
if (status < 0) {
throw std::runtime_error("Error creating RTP session");
}
// Join multicast groups if they are specified
if (multicastIP.size() > 0) {
if (!session.SupportsMulticasting()) {
throw std::runtime_error("Multicast not supported!");
} else {
int joinip = ntohl(inet_addr(multicastIP.c_str()));
RTPIPv4Address joinaddr(joinip, port);
int jstatus = session.JoinMulticastGroup(joinaddr);
if (jstatus < 0) {
throw std::runtime_error("Unable to join multicast group");
}
}
}
return session;
}
}
int MP3MediaSubSession::InitRTPSession()
{
//setup session parameters
RTPSessionParams sessParams;
sessParams.SetOwnTimestampUnit(1.0 / 8000.0); //30 video frames per second
sessParams.SetUsePollThread(1); // background thread to call virtual callbacks - set by default, but just to be sure
sessParams.SetMaximumPacketSize(MAX_PACKET_SIZE);
//setup transmission parameters
RTPUDPv4TransmissionParams transParams;
transParams.SetPortbase(portNum_);
//CREATE THE SESSION
int errcode = theRTPSession_.Create(sessParams, &transParams);
if ( errcode < 0 )
{
string stdErrStr = RTPGetErrorString(errcode);
RTSPDEBUG("[Error] : %s", stdErrStr.c_str());
return ERR_RTSP_CRAETE_RTP_SESSION; //unable to create the session
}
int main(void)
{
#ifdef NEED_PA_INIT
std::string errStr;
if (!MIPPAInputOutput::initializePortAudio(errStr))
{
std::cerr << "Can't initialize PortAudio: " << errStr << std::endl;
return -1;
}
#endif // NEED_PA_INIT
#ifdef WIN32
WSADATA dat;
WSAStartup(MAKEWORD(2,2),&dat);
#endif // WIN32
MIPTime interval(0.020); // We'll use 20 millisecond intervals.
MIPAverageTimer timer(interval);
MIPWAVInput sndFileInput;
MIPSamplingRateConverter sampConv, sampConv2;
MIPSampleEncoder sampEnc, sampEnc2, sampEnc3;
MIPULawEncoder uLawEnc;
MIPRTPULawEncoder rtpEnc;
MIPRTPComponent rtpComp;
MIPRTPDecoder rtpDec;
MIPRTPULawDecoder rtpULawDec;
MIPULawDecoder uLawDec;
MIPAudioMixer mixer;
MIPComponentAlias rtpCompAlias(&rtpComp);
ToggleOutputComponent sndToggleComponent(&sndFileInput);
#ifdef MIPCONFIG_SUPPORT_WINMM
MIPWinMMOutput sndCardOutput;
#else
#ifdef MIPCONFIG_SUPPORT_OSS
MIPOSSInputOutput sndCardOutput;
#else
MIPPAInputOutput sndCardOutput;
#endif
#endif
MyChain chain("Sound file player");
RTPSession rtpSession;
bool returnValue;
// We'll open the file 'soundfile.wav'.
returnValue = sndFileInput.open("soundfile.wav", interval);
checkError(returnValue, sndFileInput);
// We'll convert to a sampling rate of 8000Hz and mono sound.
int samplingRate = 8000;
int numChannels = 1;
returnValue = sampConv.init(samplingRate, numChannels);
checkError(returnValue, sampConv);
// Initialize the sample encoder: the RTP U-law audio encoder
// expects native endian signed 16 bit samples.
returnValue = sampEnc.init(MIPRAWAUDIOMESSAGE_TYPE_S16);
checkError(returnValue, sampEnc);
// Convert samples to U-law encoding
returnValue = uLawEnc.init();
checkError(returnValue, uLawEnc);
// Initialize the RTP audio encoder: this component will create
// RTP messages which can be sent to the RTP component.
returnValue = rtpEnc.init();
checkError(returnValue, rtpEnc);
// We'll initialize the RTPSession object which is needed by the
// RTP component.
RTPUDPv4TransmissionParams transmissionParams;
RTPSessionParams sessionParams;
int portBase = 60000;
int status;
transmissionParams.SetPortbase(portBase);
sessionParams.SetOwnTimestampUnit(1.0/((double)samplingRate));
sessionParams.SetMaximumPacketSize(64000);
sessionParams.SetAcceptOwnPackets(true);
status = rtpSession.Create(sessionParams,&transmissionParams);
checkError(status);
// Instruct the RTP session to send data to ourselves.
status = rtpSession.AddDestination(RTPIPv4Address(ntohl(inet_addr("127.0.0.1")),portBase));
checkError(status);
// Tell the RTP component to use this RTPSession object.
returnValue = rtpComp.init(&rtpSession, 160); // 20ms at 8000Hz = 160 samples per RTP packet
checkError(returnValue, rtpComp);
// Initialize the RTP audio decoder.
returnValue = rtpDec.init(true, 0, &rtpSession);
checkError(returnValue, rtpDec);
// Register the U-law decoder for payload type 0
returnValue = rtpDec.setPacketDecoder(0,&rtpULawDec);
checkError(returnValue, rtpDec);
// Convert U-law encoded samples to linear encoded samples
returnValue = uLawDec.init();
checkError(returnValue, uLawDec);
// Transform the received audio data to floating point format.
returnValue = sampEnc2.init(MIPRAWAUDIOMESSAGE_TYPE_FLOAT);
checkError(returnValue, sampEnc2);
// We'll make sure that received audio frames are converted to the right
// sampling rate.
returnValue = sampConv2.init(samplingRate, numChannels);
checkError(returnValue, sampConv2);
// Initialize the mixer.
returnValue = mixer.init(samplingRate, numChannels, interval);
checkError(returnValue, mixer);
// Initialize the soundcard output.
returnValue = sndCardOutput.open(samplingRate, numChannels, interval);
checkError(returnValue, sndCardOutput);
#ifdef MIPCONFIG_SUPPORT_WINMM
// The WinMM output component uses signed little endian 16 bit samples.
returnValue = sampEnc3.init(MIPRAWAUDIOMESSAGE_TYPE_S16LE);
#else
#ifdef MIPCONFIG_SUPPORT_OSS
// The OSS component can use several encoding types. We'll ask
// the component to which format samples should be converted.
returnValue = sampEnc3.init(sndCardOutput.getRawAudioSubtype());
#else
// The PortAudio output component uses signed 16 bit samples
returnValue = sampEnc3.init(MIPRAWAUDIOMESSAGE_TYPE_S16);
#endif
#endif
checkError(returnValue, sampEnc3);
// Next, we'll create the chain
returnValue = chain.setChainStart(&timer);
checkError(returnValue, chain);
returnValue = chain.addConnection(&timer, &sndToggleComponent);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sndToggleComponent, &sampConv);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sampConv, &sampEnc);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sampEnc, &uLawEnc);
checkError(returnValue, chain);
returnValue = chain.addConnection(&uLawEnc, &rtpEnc);
checkError(returnValue, chain);
returnValue = chain.addConnection(&rtpEnc, &rtpComp);
checkError(returnValue, chain);
returnValue = chain.addConnection(&timer, &rtpCompAlias);
checkError(returnValue, chain);
returnValue = chain.addConnection(&rtpCompAlias, &rtpDec);
checkError(returnValue, chain);
// This is where the feedback chain is specified: we want
// feedback from the mixer to reach the RTP audio decoder,
// so we'll specify that over the links in between, feedback
// should be transferred.
returnValue = chain.addConnection(&rtpDec, &uLawDec, true);
checkError(returnValue, chain);
returnValue = chain.addConnection(&uLawDec, &sampEnc2, true);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sampEnc2, &sampConv2, true);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sampConv2, &mixer, true);
checkError(returnValue, chain);
returnValue = chain.addConnection(&mixer, &sampEnc3);
checkError(returnValue, chain);
returnValue = chain.addConnection(&sampEnc3, &sndCardOutput);
checkError(returnValue, chain);
// Start the chain
returnValue = chain.start();
checkError(returnValue, chain);
// We'll wait until enter is pressed
int num = 10;
for (int i = 0 ; i < num ; i++)
{
std::cout << "iteration " << (i+1) << "/" << num << std::endl;
std::cout << "Press enter for silence" << std::endl;
getc(stdin);
sndToggleComponent.lock();
sndToggleComponent.setEnabled(false);
sndToggleComponent.unlock();
std::cout << "Press enter for sound" << std::endl;
getc(stdin);
sndToggleComponent.lock();
sndToggleComponent.setEnabled(true);
sndToggleComponent.unlock();
}
returnValue = chain.stop();
checkError(returnValue, chain);
rtpSession.Destroy();
// We'll let the destructors of the other components take care
// of their de-initialization.
sndCardOutput.close(); // In case we're using PortAudio
#ifdef NEED_PA_INIT
MIPPAInputOutput::terminatePortAudio();
#endif // NEED_PA_INIT
#ifdef WIN32
WSACleanup();
#endif
return 0;
}
int main(void)
{
int packetsPerSecond = 100;
MIPTime interval(1.0/(double)packetsPerSecond); // We'll use 10 millisecond intervals.
MIPAverageTimer timer(interval);
MIPOSCInput oscInput;
MIPOSCEncoder oscEnc;
MIPRTPOSCEncoder rtpEnc;
MIPRTPComponent rtpComp;
MIPRTPDecoder rtpDec;
MIPRTPOSCDecoder rtpOSCDec;
MIPOSCDecoder oscDec;
MIPOSCOutput oscOutput;
MyChain chain("OSC Sender");
RTPSession rtpSession;
bool returnValue;
// Convert Messages to MIPOSCMessages
returnValue = oscEnc.init();
checkError(returnValue, oscEnc);
// Initialize the RTP OSC encoder: this component will create
// RTP messages which can be sent to the RTP component.
returnValue = rtpEnc.init();
checkError(returnValue, rtpEnc);
// We'll initialize the RTPSession object which is needed by the
// RTP component.
RTPUDPv4TransmissionParams transmissionParams;
RTPSessionParams sessionParams;
int portBase = 60000;
int status;
transmissionParams.SetPortbase(portBase);
sessionParams.SetOwnTimestampUnit(1.0/((double)packetsPerSecond));
sessionParams.SetMaximumPacketSize(64000);
sessionParams.SetAcceptOwnPackets(true);
status = rtpSession.Create(sessionParams,&transmissionParams);
checkError(status);
// Instruct the RTP session to send data to ourselves.
status = rtpSession.AddDestination(RTPIPv4Address(ntohl(inet_addr("127.0.0.1")),portBase));
checkError(status);
// Tell the RTP component to use this RTPSession object.
returnValue = rtpComp.init(&rtpSession);
checkError(returnValue, rtpComp);
returnValue = rtpDec.init(false, 0, &rtpSession);
checkError(returnValue, rtpDec);
returnValue = rtpDec.setPacketDecoder(0, &rtpOSCDec);
checkError(returnValue, rtpDec);
returnValue = oscDec.init();
checkError(returnValue, oscDec);
// Next, we'll create the chain
returnValue = chain.setChainStart(&timer);
checkError(returnValue, chain);
returnValue = chain.addConnection(&timer, &oscInput);
checkError(returnValue, chain);
returnValue = chain.addConnection(&oscInput, &oscEnc);
checkError(returnValue, chain);
returnValue = chain.addConnection(&oscEnc, &rtpEnc);
checkError(returnValue, chain);
returnValue = chain.addConnection(&rtpEnc, &rtpComp);
checkError(returnValue, chain);
returnValue = chain.addConnection(&rtpComp, &rtpDec);
checkError(returnValue, chain);
returnValue = chain.addConnection(&rtpDec, &oscDec, true);
checkError(returnValue, chain);
returnValue = chain.addConnection(&oscDec, &oscOutput);
checkError(returnValue, chain);
// Start the chain
returnValue = chain.start();
checkError(returnValue, chain);
// We'll wait until enter is pressed
int counter = 0;
sleep(1);
for(int i=0; i<4; i++) {
lo_message m = lo_message_new();
lo_message_add_int32(m,counter++);
oscInput.push(m, "/testpfad");
sleep(1);
}
getc(stdin);
returnValue = chain.stop();
checkError(returnValue, chain);
rtpSession.Destroy();
return 0;
}