使用OpenH323开发
必备软件包可以从http://www.openh323.org下载. pwlib是一套跨平台的C++的开发库,使基于pwlib上开发的应用能够很少量的移植就可以跑在windows和unix的平台上. Open323是澳洲的一家公司驱动的open source的h323协议族实现, 还不够十分的完整, 但是已经是非常的难得了. 在windows上和linux下都能编译使用, 我已经试过了. Windows上编译他们比较麻烦, 注意的是一定要用batch building. 在VC7上编译openh323的动态连接库的时候, VS.net会崩溃, 注意避开, 不过也可以试试看看现象, 如果能够解决, 请告诉我一下. 在linux上编译就没有什么好说的了, 设好两个环境变量(PWLIBDIR, OPENH323DIR), 就可以在展开的目录下编译了, 先编译PWLIB, 再编译OPENH323, 别忘了将相应xx/lib写到/etc/ld.so.conf下. 我这里可能对安装讲的不够详细, openh323讲的非常详细, 大家可以去看.
以linux平台为例: 使用pwlib, 在成功编译之后, 到$(PWLIBDIR)/SAMPLES/ 这里是一些例子, hello_world 是个非常简单的工程, 从这里我们可以看到如何写使用pwlib的Makefile: # Simple makefile for the hello world program PROG = hello SOURCES = hello.cxx ifndef PWLIBDIR PWLIBDIR=$(HOME)/pwlib endif include $(PWLIBDIR)/make/ptlib.mak 关键是包含了一个ptlib.mak
hello.cxx #include class Hello : public PProcess { PCLASSINFO(Hello, PProcess) public: void Main(); };
PCREATE_PROCESS(Hello) void Hello::Main() { cout << "Hello world!/n"; } 非常有代表性. Include $(PWLIBDIR)/make/ptlib.mak 这样就可以make all, make debug的之类的进行编译, 需要的头文件库都会替你安排好. 编译的结果就会放在obj_linux_x86_xx, xx 表示你用的是debug编译还是其他, 如果是debug, xx就是d.
使用pwlib的程序, 必然要有一个PProcess的子类, 作为整个进程, 这是指在console模式下, gui模式的用PApplication这个我没有用过. Pwlib里面的类大多都是P开头, (可能是取其兼容的意思, 跨平台的特性, 我瞎猜的), 在进程中如果想创建新的线程就创建PThread子类的对象, 对于这种关于过程的类,都有Main函数等待子类去实现. 在使用所有的P类的时候, 注意使用两个宏, 声明类的时候PCLASSINFO(Hello, PProcess); 分号可以加, 也可不加. PProcess的子类的实现的时候要用PCREATE_PROCESS(Hello);, 这个东西把main()之类的系统入口封装了, 由他来调用Main()成员函数. 在使用线程的时候, 如果想让线程从线程的对象一创建就运行, 就应该在PThread子类中的构造函数中调用父类的Resume(). 关于pwlib先说这些, 在使用Openh323的时候到处都会用到pwlib的东西和概念.
Openh323: 终于进入正题了, 先粗略的讲点概念(多余了), H323是指协议族了, 包含了很多规范, 它来自ITU, 应会议的需要而产生, 信令相关的东西用H225 H245,类似Q931,用ASN1编码后在tcp之上传输, 数据相关的就是编码解码的东西了(包括音频视频), 音频g711(alaw, ulaw)了等等多了, 视频h261, 好像h263还没实现. 在H323的系统里进行通讯的角色实体就是Endpoint, 每个Endpoint可以有很多的Connection, 每个Endpoint也可以拥有很多的逻辑角色, 这个不讨论. Endpoint 在Openh323中就是类H323Endpoint的实例 Connection 在Openh323中就是 H323Connection的实例 当Endpoint接收了一个远程的连接请求, Endpoint就会创建一个H323Connection; 当Endpoint发出一个连接的请求, Endpoint也会创建一个H323Connection Connection 就会进入一个状态机, 在各个状态中, Connetcion会相应的执行相应的方法, 这些方法, 大多都是Onxxxxx(), 是虚函数, 我们可以自己通过继承H323Connection创建其子类, 并且在我们想做事的时机去重载相应的虚函数. 这是使用Openh323的一个基本的思路. 现在我们可以看看如何写一个自己H323的Endpoint, 让它能够和netmeeting互操作.成功编译Openh323后在它的samples的目录下面有几个例子, mfc是指在windows下如何使用MFC和Openh323一起开发, 还有simple, 这是个简单的H323的Endpoint的实现, 作为理解OpenH323的库如何使用和开发的技巧方法已经足够了. 程序运行主线: PWLIB(PCREATE_PROCESS(SimpleH323Process))--SimpleH323Process:: SimpleH323Process()--SimpleH323Process::Main(); Main()如果结束, 这个程序就结束了, 可是Main()里面有个死循环, 写过图形程序的朋友们都知道, 这就是在等消息来呀. 在VC中称之为Interface thread. 程序注解: main.h 这个文件包含了程序用到的所有类的声明, 一般应该至少有三个类: 来自PProcess的一个主进程的, 或者说作为界面线程的;(只有一个对象) 来自H323Endpoint的, 标识这个H323端点的;(只有一个对象) 来自H323Connection的, 标识所有和这个H323端点相关的连接;(可以有多个)
#ifndef _SimpleH323_MAIN_H #define _SimpleH323_MAIN_H //避免头文件重复包含
#include
class SimpleH323EndPoint : public H323EndPoint { //使用Pwlib的要求, 就像使用MFC, 有n多的宏, 可以看看pwlib的源码, //宏展开都干了什么 PCLASSINFO(SimpleH323EndPoint, H323EndPoint);
public: SimpleH323EndPoint(); ~SimpleH323EndPoint();
// overrides from H323EndPoint // 重载H323EndPoint的函数
// 当收到一个远程的呼入和发出呼出的请求的时候 virtual H323Connection * CreateConnection(unsigned callReference); // 有远程的请求来到, 这是在CreateConnection之后的 virtual BOOL OnIncomingCall(H323Connection &, const H323SignalPDU &, H323SignalPDU &); //应答远程的呼入 virtual H323Connection::AnswerCallResponse OnAnswerCall(H323Connection &, const PString &, const H323SignalPDU &, H323SignalPDU &); //当连接被Forward virtual BOOL OnConnectionForwarded(H323Connection &, const PString &, const H323SignalPDU &); //当连接建立 virtual void OnConnectionEstablished(H323Connection & connection, const PString & token); //当连接撤销 virtual void OnConnectionCleared(H323Connection & connection, const PString & clearedCallToken); //当连接需要打开声音的通道 virtual BOOL OpenAudioChannel(H323Connection &, BOOL, unsigned, H323AudioCodec &);
// New functions // 自己添加的新函数, 父类中不存在 BOOL Initialise(PArgList &); BOOL SetSoundDevice(PArgList &, const char *, PSoundChannel::Directions); // 每个连接会有一个Token来唯一标识 PString currentCallToken;
protected: BOOL autoAnswer; PString busyForwardParty; };
class SimpleH323Connection : public H323Connection { PCLASSINFO(SimpleH323Connection, H323Connection);
public: //创建连接对象的时候将Endpoint的对象以引用传进来 //引用的概念就是将整个对象暴露给你的意思, 不是复制了一份的意思, //对象还是原来的对象, 所以在Connection中修改了EndPoint的某些属性后 //就是在操作着传进来的对象, 这是C++的基本概念, OpenH323大量的使用 //引用传递对象, 对引用的概念要理解 SimpleH323Connection(SimpleH323EndPoint &, unsigned);
//重载了两个父类的函数
// 当打开逻辑通道的时候(等于没说) virtual BOOL OnStartLogicalChannel(H323Channel &); // 处理用户输入, 这个不是之运行这个程序的用户,而是这个连接上的用户输入 // 一般应该是拨号了之类的, virtual void OnUserInputString(const PString &);
protected: // 快速连接?? BOOL noFastStart; }; class SimpleH323Process : public PProcess { //主进程, 类似VC的用户界面线程, //他是整个程序的入口点, 和结束点 //创建了EndPoint对象后会有好几个线程启动 //这个就是主线程 PCLASSINFO(SimpleH323Process, PProcess)
public: SimpleH323Process(); ~SimpleH323Process(); //这个函数会被自动调用, 是我们程序的入口了 void Main(); protected:
//这个H323端点对象 SimpleH323EndPoint * endpoint; };
#endif // _SimpleH323_MAIN_H
下面是main.cpp 所有的类的实现了
#include
#ifdef __GNUC__ #define H323_STATIC_LIB #endif
#include "main.h" #include "../../version.h"
#define new PNEW
// 这个东西里边可能封装了标准的main函数 PCREATE_PROCESS(SimpleH323Process);
///
//几个宏都在version.h里面定义 SimpleH323Process::SimpleH323Process() : PProcess("OpenH323 Project", "SimpleH323", MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER) { endpoint = NULL; }
SimpleH323Process::~SimpleH323Process() { delete endpoint; } void SimpleH323Process::Main() { cout << GetName() << " Version " << GetVersion(TRUE) << " by " << GetManufacturer() << " on " << GetOSClass() << << GetOSName() << " (" << GetOSVersion() << - << GetOSHardware() << ")/n/n";
// Get and parse all of the command line arguments. // 分析命令行参数, 略去数行 PArgList & args = GetArguments(); args.Parse( "a-auto-answer." "b-bandwidth:" "B-forward-busy:" "D-disable:” FALSE); if (args.HasOption(h) || (!args.HasOption(l) && args.GetCount() == 0)) { //如果没有参数或者参数是h, 就输出如何使用, 此处略去数行 } //这个东西暂时不管 #if PTRACING #endif
// Create the H.323 endpoint and initialise it // H323 EndPoint 创建了, 并且把命令参数传过去初始化, 初始化的时候做了一些事
endpoint = new SimpleH323EndPoint; if (!endpoint->Initialise(args)) return; //看看命令行里是不是想直接呼叫另一个H323的endpoint.有没有l(listen)的option //如果是就MakeCall, // See if making a call or just listening. if (args.HasOption(l)) cout << "Waiting for incoming calls for /"" << endpoint->GetLocalUserName() << "/"/n"; else { cout << "Initiating call to /"" << args[0] << "/"/n"; endpoint->MakeCall(args[0], endpoint->currentCallToken); } cout << "Press X to exit." << endl;
// Simplest possible user interface // 简单的用户界面, 会有一个提示> // 取pid是我加的 for (;;) { pid_t thispid; char prom[20];
thispid = getpid(); sprintf(prom, "H323 %d >", thispid);
cout << prom << flush; PCaselessString cmd; cin >> cmd; if (cmd == "X") break;
if (cmd.FindOneOf("HYN") != P_MAX_INDEX) { H323Connection*connection; //使用lock就是怕别的线程把它给删了 //因为这里正用着呢 connection=endpoint->FindConnectionWithLock(endpoint->currentCallToken); if (connection != NULL) { if (cmd == "H") connection->ClearCall(); else if (cmd == "Y") connection->AnsweringCall(H323Connection::AnswerCallNow); else if (cmd == "N") connection->AnsweringCall(H323Connection::AnswerCallDenied); connection->Unlock(); } } }
cout << "Exiting " << GetName() << endl; } // Main 函数结束
// 自己的Init函数 BOOL SimpleH323EndPoint::Initialise(PArgList & args) { // Get local username, multiple uses of -u indicates additional aliases if (args.HasOption(u)) { PStringArray aliases = args.GetOptionString(u).Lines(); // 设定改Endpoint的username SetLocalUserName(aliases[0]); // 设定Aliases 就是每个Endpoint可以有好多名字的意思 for (PINDEX i = 1; i < aliases.GetSize(); i++) AddAliasName(aliases[i]); }
// Set the various options //设置静音检测否
SetSilenceDetectionMode(args.HasOption(e) ? H323AudioCodec::NoSilenceDetection : H323AudioCodec::AdaptiveSilenceDetection); //快速连接? DisableFastStart(args.HasOption(f)); //H245通道 DisableH245Tunneling(args.HasOption(T));
autoAnswer = args.HasOption(a); busyForwardParty = args.GetOptionString(B);
if (args.HasOption()) { initialBandwidth = args.GetOptionString().AsUnsigned()*100; if (initialBandwidth == 0) { cerr << "Illegal bandwidth specified." << endl; return FALSE; } }
if (args.HasOption(j)) { unsigned jitter = args.GetOptionString(j).AsUnsigned(); //设定音频抖动的, 应该影响到接收的缓存 if (jitter >= 20 && jitter <= 10000) SetMaxAudioDelayJitter(jitter); else { cerr << "Jitter should be between 20 milliseconds and 10 seconds." << endl;
return FALSE; } }
//设定声音设备 //也可以不用声音设备, 比如Openh323工程的子项目 OpenAM和OpenMCU //都使演示了如何不使用声音物理设备的方法, 我想那里边的东西会对某些朋友们 //的需求比较合适 if (!SetSoundDevice(args, "sound", PSoundChannel::Recorder)) return FALSE; if (!SetSoundDevice(args, "sound", PSoundChannel::Player)) return FALSE; if (!SetSoundDevice(args, "sound-in", PSoundChannel::Recorder)) return FALSE; if (!SetSoundDevice(args, "sound-out", PSoundChannel::Player)) return FALSE;
// 设定decode encode的能力 // H323 EndPoint在真正进行数据通讯之前要进行能力的交换, 说明自己能够接收和发送什么标准的数据, g.711是必须支持的. // Set the default codecs available on sound cards. AddAllCapabilities(0, 0, "GSM*{sw}"); AddAllCapabilities(0, 0, "G.711*{sw}"); AddAllCapabilities(0, 0, "LPC*{sw}"); AddAllUserInputCapabilities(0, 1);
RemoveCapabilities(args.GetOptionString(D).Lines()); ReorderCapabilities(args.GetOptionString(P).Lines());
cout << "Local username: " << GetLocalUserName() << "/n" << "Silence compression is " << (GetSilenceDetectionMode() == H323AudioCodec::NoSilenceDetection ? "Dis" : "En") << "abled/n" << "Auto answer is " << autoAnswer << "/n" << "FastConnect is " << (IsFastStartDisabled() ? "Dis" : "En") << "abled/n"
<< "H245Tunnelling is " << (IsH245TunnelingDisabled() ? "Dis" : "En") << "abled/n" << "Jitter buffer: " << GetMaxAudioDelayJitter() << " ms/n" << "Sound output device: /"" << GetSoundChannelPlayDevice() << "/"/n" "Sound input device: /"" << GetSoundChannelRecordDevice() << "/"/n" << "Codecs (in preference order):/n" << setprecision(2) << GetCapabilities() << endl;
//启动一个来电的监听 //可以使用配置的端口, 也可以使用default的端口 // Start the listener thread for incoming calls. H323ListenerTCP * listener; if (args.GetOptionString(i).IsEmpty()) listener = new H323ListenerTCP(*this); else { PIPSocket::Address interfaceAddress(args.GetOptionString(i)); listener = new H323ListenerTCP(*this, interfaceAddress); } if (!StartListener(listener)) { cerr << "Could not open H.323 listener port on " << listener->GetListenerPort() << endl; delete listener; return FALSE; }
//这是连接GateKeeper相关的东西, 先不讨论了 // Initialise the security info if (args.HasOption(p)) { SetGatekeeperPassword(args.GetOptionString(p)); cout << "Enabling H.235 security access to gatekeeper." << endl; }
// Establish link with gatekeeper if required. if (args.HasOption(g) || !args.HasOption( )) { H323TransportUDP * rasChannel; if (args.GetOptionString(i).IsEmpty()) rasChannel = new H323TransportUDP(*this); else { PIPSocket::Address interfaceAddress(args.GetOptionString(i)); rasChannel = new H323TransportUDP(*this, interfaceAddress); }
if (args.HasOption(g)) { PString gkName = args.GetOptionString(g); if (SetGatekeeper(gkName, rasChannel)) cout << "Gatekeeper set: " << *gatekeeper << endl; else { cerr << "Error registering with gatekeeper at /"" << gkName << /" << endl; return FALSE; } } else { cout << "Searching for gatekeeper..." << flush; if (DiscoverGatekeeper(rasChannel)) cout << "/nGatekeeper found: " << *gatekeeper << endl; else { cerr << "/nNo gatekeeper found." << endl; if (args.HasOption( )) return FALSE; } } }
return TRUE; }
//设定音频设备, 没什么可讲的 BOOL SimpleH323EndPoint::SetSoundDevice(PArgList & args, const char * optionName, PSoundChannel::Directions dir) { if (!args.HasOption(optionName)) return TRUE;
PString dev = args.GetOptionString(optionName);
if (dir == PSoundChannel::Player) { if (SetSoundChannelPlayDevice(dev)) return TRUE; } else { if (SetSoundChannelRecordDevice(dev)) return TRUE; }
cerr << "Device for " << optionName << " (/"" << dev << "/") must be one of:/n";
PStringArray names = PSoundChannel::GetDeviceNames(dir); for (PINDEX i = 0; i < names.GetSize(); i++) cerr << " /"" << names[i] << "/"/n";
return FALSE; }
//这个函数很简单但是非常关键, 是从EndPoint中重载过来的. //本来是return new H323Connection()的, 现在改成Simplexxx //自己实现的一个Connection, 这样当Endpoint里面调用 //Connection的一些东西的时候, 实际上运行的是Simplexxx //的实现, 看到C++的好处了吧, C里用函数指针也可以实现, 没有 //C++这么native. H323Connection * SimpleH323EndPoint::CreateConnection(unsigned callReference)
{ return new SimpleH323Connection(*this, callReference); } //没什么东西, 关键是看看这个东西的调用的时机 BOOL SimpleH323EndPoint::OnIncomingCall(H323Connection & connection, const H323SignalPDU &, H323SignalPDU &) { if (currentCallToken.IsEmpty()) return TRUE;
if (busyForwardParty.IsEmpty()) { cout << "Incoming call from /"" << connection.GetRemotePartyName() << "/" rejected, line busy!" << endl; return FALSE; }
cout << "Forwarding call to /"" << busyForwardParty << "/"." << endl; return !connection.ForwardCall(busyForwardParty); }
//这个东西, 很有用, H323Connection的类里也有这个虚函数 //返回的值决定告诉远程的连接者是否接收这份连接请求 H323Connection::AnswerCallResponse SimpleH323EndPoint::OnAnswerCall(H323Connection & connection, const PString & caller, const H323SignalPDU &, H323SignalPDU &) { currentCallToken = connection.GetCallToken();
if (autoAnswer) { cout << "Automatically accepting call." << endl; return H323Connection::AnswerCallNow; }
cout << "Incoming call from /"" << caller << "/", answer call (Y/n)? " << flush;
return H323Connection::AnswerCallPending; }
BOOL SimpleH323EndPoint::OnConnectionForwarded(H323Connection & /*connection*/, const PString & forwardParty, const H323SignalPDU & /*pdu*/) { if (MakeCall(forwardParty, currentCallToken)) { cout << "Call is being forwarded to host " << forwardParty << endl; return TRUE; }
cout << "Error forwarding call to /"" << forwardParty << /" << endl; return FALSE; }
//连接建立时候 void SimpleH323EndPoint::OnConnectionEstablished(H323Connection & connection,
const PString & token) { currentCallToken = token; cout << "In call with " << connection.GetRemotePartyName() << endl; }
//连接断开时候 void SimpleH323EndPoint::OnConnectionCleared(H323Connection & connection, const PString & clearedCallToken) { if (currentCallToken == clearedCallToken) currentCallToken = PString();
PString remoteName = /" + connection.GetRemotePartyName() + /"; switch (connection.GetCallEndReason()) { case H323Connection::EndedByRemoteUser : cout << remoteName << " has cleared the call"; break; case H323Connection::EndedByCallerAbort : cout << remoteName << " has stopped calling"; break; case H323Connection::EndedByRefusal : cout << remoteName << " did not accept your call"; break; case H323Connection::EndedByNoAnswer : cout << remoteName << " did not answer your call"; break; case H323Connection::EndedByTransportFail : cout << "Call with " << remoteName << " ended abnormally"; break; case H323Connection::EndedByCapabilityExchange : cout << "Could not find common codec with " << remoteName; break; case H323Connection::EndedByNoAccept : cout << "Did not accept incoming call from " << remoteName; break; case H323Connection::EndedByAnswerDenied : cout << "Refused incoming call from " << remoteName; break; case H323Connection::EndedByNoUser : cout << "Gatekeeper could find user " << remoteName; break; case H323Connection::EndedByNoBandwidth : cout << "Call to " << remoteName << " aborted, insufficient bandwidth."; break; case H323Connection::EndedByUnreachable : cout << remoteName << " could not be reached."; break; case H323Connection::EndedByHostOffline : cout << remoteName << " is not online."; break; case H323Connection::EndedByNoEndPoint : cout << "No phone running for " << remoteName; break; case H323Connection::EndedByConnectFail : cout << "Transport error calling " << remoteName; break; default : cout << "Call with " << remoteName << " completed"; } cout << ", duration " << setprecision(0) << setw(5) << (PTime() - connection.GetConnectionStartTime()) << endl; }
//打开声音设备时候 //isEncoding 表示编码吗 //编码表示向外发送数据, 从声音设备读 //解码表示从网络读出数据, 写到声音设备上 //不同的方向的codec是不同的, 所以在这里有好多文章可以做 //可以给codec attach上不同的channel根据isEncoding的值 BOOL SimpleH323EndPoint::OpenAudioChannel(H323Connection & connection, BOOL isEncoding, unsigned bufferSize, H323AudioCodec & codec) { if (H323EndPoint::OpenAudioChannel(connection, isEncoding, bufferSize, codec)) return TRUE;
cerr << "Could not open sound device "; if (isEncoding) cerr << GetSoundChannelRecordDevice(); else cerr << GetSoundChannelPlayDevice(); cerr << " - Check permissions or full duplex capability." << endl;
return FALSE; } // EndPoint的实现分析完毕.
H323Connection的实现, 这个Connection的实现太简单了.可能不足以说明问题 我也没什么好说的了 ///
SimpleH323Connection::SimpleH323Connection(SimpleH323EndPoint & ep, unsigned ref) : H323Connection(ep, ref) { }
BOOL SimpleH323Connection::OnStartLogicalChannel(H323Channel & channel) { if (!H323Connection::OnStartLogicalChannel(channel)) return FALSE;
cout << "Started logical channel: ";
switch (channel.GetDirection()) { case H323Channel::IsTransmitter : cout << "sending "; break;
case H323Channel::IsReceiver : cout << "receiving "; break;
default : break; }
cout << channel.GetCapability() << endl;
return TRUE; }
void SimpleH323Connection::OnUserInputString(const PString & value) { cout << "User input received: /"" << value << /" << endl; } // End of File ///
总结一下基本的过程就是创建一个H323Endpoint的对象endpoint, 创建对象后这个程序就有好多个小的线程被创建了.然后EndPoint开始监听来电, 之后判断是否直接呼叫另一个h323的Endpoint. 然后就是一个for循环, 判断标准的输入, 并通过当前的token来lock一个Connection, 每个连接会有唯一的一个token, lock的意思是说, 在被lock的期间是不能被释放的. 根据输入的字符决定对得到的连接做什么.
OpenAM: 是个answer machine, 自动应答机, 或者是留言机. 实现的很简单, 里面对OpenH323使用的思路很有价值. ./openam –n –-g711message sample_message.wav 这样运行, 用netmeeting 连接一下这个IP, netmeeting就会放一段简单的英语, 测测你的英语听力, 他在讲什么? 这个程序是一个支持多连接和并发连接的Endpoint, 但是他没有使用真正的声音设备, 放出的音从一个已有的wav文件中读出来, 远程用户的留言被录到一个文件里, 文件的名字表示了是什么时间录制的. 主要的思路是给在连接打开声音通道的时候, 根据isEncoding的值区别是录音还是放音,如果是录音, 将读文件的Channel附加在codec上, 相反写文件的Channel附件在codec上,注意这是两个codec. 这个东西给了我们一个方法, 如何使用文件IO来代替声音设备的IO来使用OpenH323.
这是main.h
#ifndef _Voxilla_MAIN_H #define _Voxilla_MAIN_H
#include #include #include #include #include
#include #include
//主进程 class OpenAm : public PProcess { PCLASSINFO(OpenAm, PProcess)
public: OpenAm(); ~OpenAm();
void Main(); void RecordFile(PArgList & args); void PlayFile(PArgList & args);
protected: long GetCodec(const PString & codecname); OpalLineInterfaceDevice * GetDevice(const PString & device); };
//H323 端点 class MyH323EndPoint : public H323EndPoint { PCLASSINFO(MyH323EndPoint, H323EndPoint);
public: MyH323EndPoint(unsigned callLimit, const PString & runCmd, const PDirectory & dir, int flags);
// overrides from H323EndPoint virtual H323Connection * CreateConnection(unsigned callReference); BOOL OnIncomingCall(H323Connection &, const H323SignalPDU &, H323SignalPDU &);
// new functions BOOL Initialise(PConfigArgs & args);
PString GetGSMOGM() const { return gsmOgm; } void SetGSMOGM(const PString & s) { gsmOgm = s; }
PString GetG711OGM() const { return g711Ogm; } void SetG711OGM(const PString & s) { g711Ogm = s; }
PString GetLPC10OGM() const { return lpc10Ogm; } void SetLPC10OGM(const PString & s) { lpc10Ogm = s; }
#ifdef SPEEX_CODEC PString GetSPEEXOGM() const { return speexOgm; } void SetSPEEXOGM(const PString & s) { speexOgm = s; } #endif
PString GetG7231OGM() const { return g7231Ogm; } void SetG7231OGM(const PString & s) { g7231Ogm = s; }
unsigned GetCallLimit() const { return callLimit; } PString GetRunCmd() const { return runCmd; } PDirectory GetDirectory() const { return dir; }
void SetRecordWav(const BOOL rec){ recordWav = rec; } BOOL GetRecordWav() const { return recordWav; }
enum { DeleteAfterRecord = 0x01, NoRecordG7231 = 0x02, HangupAfterPlay = 0x04 };
BOOL GetDeleteAfterRecord() const { return flags & DeleteAfterRecord; } BOOL GetNoRecordG7231() const { return flags & NoRecordG7231; } BOOL GetHangupAfterPlay() const { return flags & HangupAfterPlay; }
protected: unsigned callLimit; PString pcmOgm, g711Ogm, gsmOgm, lpc10Ogm, g7231Ogm, runCmd; #ifdef SPEEX_CODEC PString speexOgm; #endif PDirectory dir; int flags; BOOL recordWav; };
class PCM_RecordFile; class MyH323Connection; PQUEUE(PStringQueue, PString); // Out Going Channel OGM //就是发送语音的通道 //即是读文件的通道 class PCM_OGMChannel : public PIndirectChannel { PCLASSINFO(PCM_OGMChannel, PIndirectChannel);
public: PCM_OGMChannel(MyH323Connection & conn);
BOOL Read(void * buffer, PINDEX amount); void PlayFile(PFile * chan);
BOOL Close();
void QueueFile(const PString & cmd); void FlushQueue();
void SetRecordTrigger(); void SetHangupTrigger();
void SetPlayOnce() { playOnce = TRUE; }
protected: virtual BOOL ReadFrame(PINDEX amount); virtual void CreateSilenceFrame(PINDEX amount); virtual void Synchronise(PINDEX amount); virtual BOOL IsWAVFileValid(PWAVFile *chan);
BOOL AdjustFrame(void * buffer, PINDEX amount);
PStringQueue playQueue;
MyH323Connection & conn; PMutex chanMutex; int silentCount; int totalData; BOOL recordTrigger, hangupTrigger; BOOL closed; BOOL playOnce;
PAdaptiveDelay ogm_delay;
PBYTEArray frameBuffer; PINDEX frameLen, frameOffs; }; //这个是之读的文件是个g723编码的文件, 暂时不研究这个类相关的一切 class G7231_OGMChannel : public PCM_OGMChannel { PCLASSINFO(G7231_OGMChannel, PCM_OGMChannel); public: G7231_OGMChannel(MyH323Connection & conn);
protected: BOOL ReadFrame(PINDEX amount); void CreateSilenceFrame(PINDEX amount); void Synchronise(PINDEX amount); BOOL IsWAVFileValid(PWAVFile *chan); };
//连接,都是从这个类实例出来的 class MyH323Connection : public H323Connection { PCLASSINFO(MyH323Connection, H323Connection);
public: MyH323Connection(MyH323EndPoint &, unsigned); ~MyH323Connection();
// overrides from H323Connection BOOL OpenAudioChannel(BOOL, unsigned, H323AudioCodec & codec); AnswerCallResponse OnAnswerCall(const PString &, const H323SignalPDU &, H323SignalPDU &); BOOL OnStartLogicalChannel(H323Channel & channel); void OnUserInputString(const PString & value);
// new functions void StartRecording(); void Hangup();
void SetE164Number(const PString & _num) { e164Number = _num; }
PString GetE164Number() const { return e164Number; }
protected: void OnUserInputChar(char ch); BOOL StartMenu(int menuNumber); BOOL ProcessMenuCmd(const PString & cmdStr);
const MyH323EndPoint & ep; PString product; PTime callStartTime; PTime recordStartTime; PString basename; PFilePath recordFn; PString transmitCodecName, receiveCodecName; BOOL recordTrigger; PMutex connMutex;
PCM_RecordFile * recordFile; PCM_OGMChannel * ogmChannel;
PString digits, lastDigits; int currentMenu; PStringList menuNames;
PString securityToken, e164Number; };
//是录音 class PCM_RecordFile : public PIndirectChannel { PCLASSINFO(PCM_RecordFile, PIndirectChannel)
public: PCM_RecordFile(MyH323Connection & conn, const PFilePath & fn, unsigned callLimit); ~PCM_RecordFile();
BOOL Write(const void * buf, PINDEX len); BOOL Close(); void StartRecording();
virtual void DelayFrame(PINDEX len); virtual BOOL WriteFrame(const void * buf, PINDEX len);
BOOL WasRecordStarted() const { return recordStarted; }
protected: MyH323Connection & conn; PTime finishTime; PFilePath fn; unsigned callLimit; BOOL recordStarted; BOOL timeLimitExceeded; BOOL closed; BOOL isPCM; BOOL dataWritten; PAdaptiveDelay delay; PMutex pcmrecordMutex; PFile *fileclass; // will point to a PWAVFile or PFile class }; //录的结果是个g723文件, 我们暂时不考虑这个类相关的一切 class G7231_RecordFile : public PCM_RecordFile { PCLASSINFO(G7231_RecordFile, PCM_RecordFile);
public: G7231_RecordFile(MyH323Connection & conn, const PFilePath & fn, unsigned callLimit); void DelayFrame(PINDEX len); BOOL WriteFrame(const void * buf, PINDEX len); };
#endif // _Voxilla_MAIN_H
// End of File ///
这是main.cxx #include #include
#include "version.h" #include "lpc10codec.h"
#ifdef SPEEX_CODEC #include "speexcodec.h" #endif
#include "mscodecs.h" #include "opalvxml.h" #include "main.h"
PCREATE_PROCESS(OpenAm);
#define new PNEW
//default 录音时间 #define DEFAULT_MSG_LIMIT 30 #define DEFAULT_CALL_LOG "call_log.txt"
#define G7231_SAMPLES_PER_BLOCK 240
#define CHECK_PCM 1 #define CHECK_G7231 2
#define MENU_PREFIX "UserMenu-"
static PMutex logMutex; static PTextFile logFile; static PFilePath logFilename = DEFAULT_CALL_LOG;
PString G7231Ext = ".g723"; PString WAVExt = ".wav"; PString PCMExt = ".sw";
//关于log的一切先不用看 static void LogMessage(const PString & str) { PTime now; PString msg = now.AsString("hh:mm:ss dd/MM/yyyy") & str; logMutex.Wait();
if (!logFile.IsOpen()) { logFile.Open(logFilename, PFile::ReadWrite); logFile.SetPosition(0, PFile::End); }
logFile.WriteLine(msg);
logFile.Close();
logMutex.Signal(); }
static void LogCall(const PFilePath & fn, const PString & from, const PString & user, unsigned len, const PString & codec, const PString & product) { PString addr = from; LogMessage(addr & "/"" + user + "/"" & PString(PString::Unsigned, len) & codec & "/"" + product + "/"" & "/"" + fn + "/""); }
///
OpenAm::OpenAm() : PProcess("OpenH323 Project", "OpenAM", MAJOR_VERSION, MINOR_VERSION, BUILD_TYPE, BUILD_NUMBER) { }
OpenAm::~OpenAm() { }
void OpenAm::Main() { cout << GetName() << " Version " << GetVersion(TRUE) << " by " << GetManufacturer() << " on " << GetOSClass() << << GetOSName() << " (" << GetOSVersion() << - << GetOSHardware() << ")/n/n";
// 分析命令行了 PConfigArgs args(GetArguments());
args.Parse( "D-disable:" "d-directory:" "g-gatekeeper:" "n-no-gatekeeper." "-g711-ulaw." "-no-g711-ulaw." "-g711-alaw." "-no-g711-alaw." "-g711message:" "-no-g711message." "-g7231." "-no-g7231." "-g7231message:" "-no-g7231message." "-gsm." "-no-gsm." "-gsmmessage:" "-no-gsmmessage." "h-help." "H-hangup." "-no-hangup." "i-interface:" "-no-interface." "k-kill." "-no-kill." "l-limit:" "-no-limit." "-listenport:" "-no-listenport." "-lpc10message:" "-no-lpc10message." "-speexmessage:" "-no-speexmessage." "m-message:" "-no-message." "-no-recordg7231." #if PTRACING "o-output:" #endif "P-prefer:" "-pcm." "-no-pcm." "-pcmmessage:" "-no-pcmmessage." "-port:" "q-quicknet:" "-no-quicknet:" "r-run:" "-no-run." "-recordraw." "-require-gatekeeper." "-no-require-gatekeeper." "-save." #if PMEMORY_CHECK "-setallocationbreakpoint:" #endif #if PTRACING "t-trace." #endif "u-username:" "-no-username." , FALSE);
#if PMEMORY_CHECK if (args.HasOption("setallocationbreakpoint")) PMemoryHeap::SetAllocationBreakpoint(args.GetOptionString("setallocationbreakpoint").AsInteger()); #endif
#if PTRACING PTrace::Initialise(args.GetOptionCount( ), args.HasOption(o) ? (const char *)args.GetOptionString(o) : NULL); #endif
if (args.HasOption(h)) { cout << "Usage : " << GetName() << " [options]/n" "Options:/n" " -d --directory dir : Put recorded mesages into dir/n" " -l --limit secs : Limit recorded messages to secs duration (default " << DEFAULT_MSG_LIMIT << ")/n" " -m --pcmmessage fn : Set outgoing message for PCM derived codecs (G.711/GSM) to fn/n" " --g7231message fn : Set outgoing message for G723.1 codec to fn/n" " --g711message fn : Set outgoing message for G711 codec to fn/n" " --gsmmessage fn : Set outgoing message for GSM codec to fn/n" " --lpc10message fn : Set outgoing message for LPC10 codec to fn/n" #ifdef SPEEX_CODEC " --speexmessage fn : Set outgoing message for Speex codec to fn/n" #endif
" --recordraw : Record PCM audo in raw files (.sw) instead of .wav/n" " -r --run cmd : Run this command after each recorded message/n" " -k --kill : Kill recorded files after user command/n" " -H --hangup : hangup after playing message/n" " -u --username str : Set the local endpoint name to str/n" " -i --interface ip : Bind to a specific interface/n" " --listenport port : Listen on a specific port/n" " -g --gatekeeper host: Specify gatekeeper host./n" " -n --no-gatekeeper : Disable gatekeeper discovery./n" " --require-gatekeeper: Exit if gatekeeper discovery fails./n" " -D --disable codec : Disable the specified codec (may be used multiple times)/n" " -P --prefer codec : Prefer the specified codec (may be used multiple times)/n" #if PTRACING " -t --trace : Enable trace, use multiple times for more detail/n" " -o --output : File for trace output, default is stderr/n" #endif " --save : Save arguments in configuration file/n" " -h --help : Display this help message/n"; return; }
args.Save("save");
//是指有IXJ卡吗? 我想你肯定没有, 那是电话卡 不用管他 #if HAS_IXJ if (args.GetCount() > 0) { if (args[0] *= "record") RecordFile(args); else if (args[0] *= "play") PlayFile(args); else cerr << "unknown command /"" << args[0] << "/"" << endl; return; } #endif
unsigned callLimit = DEFAULT_MSG_LIMIT; if (args.HasOption(l)) { callLimit = args.GetOptionString(l).AsInteger(); if (callLimit > 3600) { cout << "warning: maximum call length " << callLimit << " is out of range. Using " << DEFAULT_MSG_LIMIT << " instead/n"; callLimit = DEFAULT_MSG_LIMIT; } else if (callLimit == 0) cout << "warning: recorded message call limit disabled/n"; } cout << "Recorded messages limited to " << callLimit << " seconds/n";
PString runCmd; if (args.HasOption( )) { runCmd = args.GetOptionString( ); cout << "Executing /"" << runCmd << "/" after each message" << endl; }
PDirectory dir; if (args.HasOption(d)) dir = args.GetOptionString(d);
int flags = 0;
if (args.HasOption("no-recordg7231")) { cout << "Supressing recording of G723.1 messages" << endl; flags |= MyH323EndPoint::NoRecordG7231; } if (args.HasOption(k)) { cout << "Deleting recorded files after processing" << endl; if (runCmd.IsEmpty()) cout << "WARNING: recorded files will be deleted even though no run command is present" << endl; flags |= MyH323EndPoint::DeleteAfterRecord; }
if (args.HasOption(H)) flags |= MyH323EndPoint::HangupAfterPlay;
//创建H323 EndPoint MyH323EndPoint endpoint(callLimit, runCmd, dir, flags);
PString userName = "OpenH323 Answering Machine v" + GetVersion(); if (args.HasOption(u)) userName = args.GetOptionString(u); endpoint.SetLocalUserName(userName);
if (!endpoint.Initialise(args)) return;
// start the H.323 listener // 开始监听 H323有个默认的端口应该是1572 之类的 DefaultSignalPort, 我忘了 H323ListenerTCP * listener; PIPSocket::Address interfaceAddress(INADDR_ANY); WORD listenPort = H323ListenerTCP::DefaultSignalPort;
if (args.HasOption("listenport")) listenPort = (WORD)args.GetOptionString("listenport").AsInteger();
if (args.HasOption(i)) interfaceAddress = PIPSocket::Address(args.GetOptionString(i));
listener = new H323ListenerTCP(endpoint, interfaceAddress, listenPort);
if (!endpoint.StartListener(listener)) { cout << "Could not open H.323 listener port on " << listener->GetListenerPort() << endl; delete listener; return; }
//gatekeeper 相关的东西我们也不必考虑 用-n这个参数这个端点就不会 //去找gatekeeper
if (args.HasOption(g)) { PString gkName = args.GetOptionString(g); if (endpoint.SetGatekeeper(gkName, new H323TransportUDP(endpoint))) cout << "Gatekeeper set: " << *endpoint.GetGatekeeper() << endl; else { cout << "Error registering with gatekeeper at /"" << gkName << /" << endl; return; } } else if (!args.HasOption( )) { cout << "Searching for gatekeeper..." << flush; if (endpoint.DiscoverGatekeeper(new H323TransportUDP(endpoint))) cout << "/nGatekeeper found: " << *endpoint.GetGatekeeper() << endl; else { cout << "/nNo gatekeeper found." << endl; if (args.HasOption("require-gatekeeper")) return; } }
cout << "Waiting for incoming calls for /"" << endpoint.GetLocalUserName() << /" << endl;
//瞧瞧, 这就是主进程干的这点事, Sleep的是毫秒 for (;;) PThread::Current()->Sleep(5000); }
///
MyH323EndPoint::MyH323EndPoint(unsigned _callLimit, const PString & _runCmd, const PDirectory & _dir, int _flags) : callLimit(_callLimit), runCmd(_runCmd), dir(_dir), flags(_flags) { }
BOOL MyH323EndPoint::OnIncomingCall(H323Connection & _conn, const H323SignalPDU & setupPDU, H323SignalPDU &) { //传过来的是引用, 引用这个东西必须马上赋值 MyH323Connection & conn = (MyH323Connection &)_conn;
// see if incoming call is to a getway address PString number; if (setupPDU.GetDestinationE164(number)) conn.SetE164Number(number);
return TRUE; } //这个没什么异常, 都这样做 H323Connection * MyH323EndPoint::CreateConnection(unsigned callReference) { return new MyH323Connection(*this, callReference); }
//分析命令, 看看应该使用什么样的能力去交换, // 我们在使用的时候指定—g711message //就是说只是用g711 的alaw或者mulaw //很多废话就不用看了 //除了和g711相关的其他都没有用处了
BOOL MyH323EndPoint::Initialise(PConfigArgs & args) { // format for record files, raw or wav if (args.HasOption("recordraw")) SetRecordWav(FALSE); else SetRecordWav(TRUE);
// get G723.1 OGM if (args.HasOption("g7231message")) g7231Ogm = args.GetOptionString("g7231message"); else if (args.HasOption(m)) { if (PFile::Exists(args.GetOptionString(m) + "_g7231" + WAVExt)) { g7231Ogm = args.GetOptionString(m) + "_g7231" + WAVExt; } else if (PFile::Exists(args.GetOptionString(m) + PCMExt)) { g7231Ogm = args.GetOptionString(m) + G7231Ext; } }
if (!g7231Ogm.IsEmpty()) { if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g7231Ogm)) { cout << "warning: cannot open G723.1 OGM file /"" << g7231Ogm << "/"" << endl; g7231Ogm = ""; } }
if (g7231Ogm.IsEmpty()) cout << "No G.723.1 outgoing message set/n"; else { cout << "Using /"" << g7231Ogm << "/" as G.723.1 outgoing message/n"; }
// Get the OGM message for the PCM codecs // Check if the file specified exists. If it does, use it. // If it does not exist, try with .wav and .sw extensions. if (args.HasOption("pcmmessage")) { pcmOgm = args.GetOptionString("pcmmessage"); } else if (args.HasOption(m)) { if (g7231Ogm.Find("%s") == P_MAX_INDEX) { pcmOgm = args.GetOptionString(m); } else { if (PFile::Exists(args.GetOptionString(m))) { pcmOgm = args.GetOptionString(m); } else if (PFile::Exists(args.GetOptionString(m) + WAVExt)) { pcmOgm = args.GetOptionString(m) + WAVExt; } else if (PFile::Exists(args.GetOptionString(m) + PCMExt)) { pcmOgm = args.GetOptionString(m) + PCMExt; } } }
// By default, use the pcmOgm for all the PCM codecs, but allow the user // to override them. gsmOgm = pcmOgm; g711Ogm = pcmOgm; lpc10Ogm = pcmOgm; #ifdef SPEEX_CODEC speexOgm = pcmOgm; #endif
// We can set the filename for specific codecs. if (args.HasOption("gsmmessage")) gsmOgm = args.GetOptionString("gsmmessage");
//这句话用的着 if (args.HasOption("g711message")) g711Ogm = args.GetOptionString("g711message");
if (args.HasOption("lpc10message")) lpc10Ogm = args.GetOptionString("lpc10message"); //这是一个codec设备, 你没有! #ifdef SPEEX_CODEC if (args.HasOption("speexmessage")) speexOgm = args.GetOptionString("speexmessage"); #endif
// Check GSM OGM message if (!gsmOgm.IsEmpty()) { if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(gsmOgm)) { cout << "warning: cannot open GSM OGM file /"" << gsmOgm << "/"" << endl; gsmOgm = ""; } } if (gsmOgm.IsEmpty()) cout << "No GSM outgoing message set/n"; else { cout << "Using /"" << gsmOgm << "/" as GSM outgoing message/n"; }
// Check G.711 OGM message if (!g711Ogm.IsEmpty()) { if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(g711Ogm)) { cout << "warning: cannot open G711 OGM file /"" << g711Ogm << "/"" << endl;
g711Ogm = ""; } } if (g711Ogm.IsEmpty()) cout << "No G711 outgoing message set/n"; else { cout << "Using /"" << g711Ogm << "/" as G.711 outgoing message/n"; }
// Check LPC10 OGM message if (!lpc10Ogm.IsEmpty()) { if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(lpc10Ogm)) { cout << "warning: cannot open LPC10 OGM file /"" << lpc10Ogm << "/"" << endl;
lpc10Ogm = ""; } } if (lpc10Ogm.IsEmpty()) cout << "No LPC10 outgoing message set/n"; else { cout << "Using /"" << lpc10Ogm << "/" as LPC10 outgoing message/n"; }
#ifdef SPEEX_CODEC // Check Speex OGM message if (!speexOgm.IsEmpty()) { if ((g7231Ogm.Find("%s") == P_MAX_INDEX) && !PFile::Exists(speexOgm)) { cout << "warning: cannot open Speex OGM file /"" << speexOgm << "/"" << endl;
speexOgm = ""; } } if (speexOgm.IsEmpty()) cout << "No Speex outgoing message set/n"; else { cout << "Using /"" << speexOgm << "/" as Speex outgoing message/n"; } #endif
if (g7231Ogm.IsEmpty() && gsmOgm.IsEmpty() && g711Ogm.IsEmpty() && lpc10Ogm.IsEmpty() #ifdef SPEEX_CODEC && speexOgm.IsEmpty() #endif ) { cerr << "Must specify at least one outgoing message" << endl; return FALSE; }
if (!g7231Ogm.IsEmpty()) SetCapability(0, 0, new G7231_File_Capability);
if (!gsmOgm.IsEmpty()) SetCapability(0, 0, new H323_GSM0610Capability);
if (!gsmOgm.IsEmpty()) SetCapability(0, 0, new MicrosoftGSMAudioCapability);
//这是 AM Endpoint的能力 支持g711的alaw和ulaw if (!g711Ogm.IsEmpty()) SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::muLaw, H323_G711Capability::At64k));
if (!g711Ogm.IsEmpty()) SetCapability(0, 0, new H323_G711Capability(H323_G711Capability::ALaw, H323_G711Capability::At64k));
//没有用了 if (!lpc10Ogm.IsEmpty()) SetCapability(0, 0, new H323_LPC10Capability(*this));
#ifdef SPEEX_CODEC if (!speexOgm.IsEmpty()) SetCapability(0, 0, new SpeexNarrow3AudioCapability()); #endif
capabilities.Remove(args.GetOptionString(D).Lines()); capabilities.Reorder(args.GetOptionString(P).Lines());
cout << "Codecs (in preference order):/n" << setprecision(2) << capabilities << endl;
return TRUE; }
///
//录音通道, 解码对象所附着的通道 //写文件 PCM_RecordFile::PCM_RecordFile(MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit) : conn(_conn), fn(_fn), callLimit(_callLimit) { recordStarted = FALSE; timeLimitExceeded = FALSE; closed = FALSE; dataWritten = FALSE;
// If the file name ends in .wav then open the output as a WAV file. // Otherwise open it as a raw file. if ((_fn.Right(4)).ToLower() == ".wav") fileclass = new PWAVFile(_fn, PFile::WriteOnly, PFile::ModeDefault,PWAVFile::PCM_WavFile); else fileclass = new PFile(_fn, PFile::WriteOnly); }
void PCM_RecordFile::StartRecording() { PWaitAndSignal mutex(pcmrecordMutex);
if (recordStarted) return;
PTRACE(1, "Starting recording to " << fn);
PTime now; recordStarted = TRUE; finishTime = now + (callLimit * 1000); }
BOOL PCM_RecordFile::Close() { PWaitAndSignal mutex(pcmrecordMutex);
closed = TRUE; return fileclass->Close(); }
BOOL PCM_RecordFile::Write(const void * buf, PINDEX len) { // Wait for the mutex, and Signal it at the end of this function PWaitAndSignal mutex(pcmrecordMutex);
// If the record file has been closed, or if the time limit has // been exceeded, then return immediatly. if (closed || timeLimitExceeded) return FALSE;
if (!recordStarted) { DelayFrame(len); return TRUE; }
PTime now; if ((callLimit != 0) && (now >= finishTime)) { PTRACE(1, "Terminating call due to timeout"); conn.ClearCall(); timeLimitExceeded = TRUE; return TRUE; }
DelayFrame(len);
dataWritten = TRUE;
return WriteFrame(buf, len); }
BOOL PCM_RecordFile::WriteFrame(const void * buf, PINDEX len) { //cerr << "Writing PCM " << len << endl; return fileclass->Write(buf, len); }
void PCM_RecordFile::DelayFrame(PINDEX len) { delay.Delay(len/16); }
PCM_RecordFile::~PCM_RecordFile() { PWaitAndSignal mutex(pcmrecordMutex);
if (!dataWritten) { PTRACE(1, "Deleting " << fn << " as no data recorded"); fileclass->Remove(fn); }
delete fileclass; }
/// // Override some of the PCM_RecordFile functions to write // G723.1 data instead of PCM data.
G7231_RecordFile::G7231_RecordFile(MyH323Connection & _conn, const PFilePath & _fn, unsigned _callLimit) : PCM_RecordFile(_conn, _fn, _callLimit) { // If the record file is a .wav file, we need to close the file // that PCM_RecordFile will have opened, and reopen it as a G.723.1 Wav file.
if ((_fn.Right(4)).ToLower() == ".wav") { fileclass->Remove(_fn); delete fileclass; fileclass = new PWAVFile(_fn, PFile::WriteOnly, PFile::ModeDefault,PWAVFile::G7231_WavFile); } }
BOOL G7231_RecordFile::WriteFrame(const void * buf, PINDEX /*len*/) { int frameLen = G7231_File_Codec::GetFrameLen(*(BYTE *)buf); // cerr << "Writing G7231 " << frameLen << endl; return fileclass->Write(buf, frameLen); }
void G7231_RecordFile::DelayFrame(PINDEX /*len*/) { // Ignore the len parameter as that is the compressed size. // We must delay by the actual sample time. delay.Delay((G7231_SAMPLES_PER_BLOCK*2)/16); }
///
static BOOL MatchString(const PString & str1, const PString str2) { if (str1.GetLength() != str2.GetLength()) return FALSE;
PINDEX len = str1.GetLength();
PINDEX i; for (i = 0; i < len; i++) if ((str1[i] != ?) && (str2[i] != ?) && (str1[i] != str2[i])) return FALSE;
return TRUE; }
static PINDEX FindMatch(const PStringList & list, const PString & key) { PINDEX maxKeyLen = 0; PINDEX i;
PINDEX keyLen = key.GetLength(); PINDEX listLen = list.GetSize();
for (i = 0; i < listLen; i++) maxKeyLen = PMAX(maxKeyLen, list[i].GetLength());
if (keyLen == 0 || maxKeyLen == 0) return P_MAX_INDEX;
if (keyLen > maxKeyLen) return P_MAX_INDEX;
PINDEX len = 1; while (len <= keyLen) { PString subStr = key.Left(len);
PINDEX matches = 0; PINDEX lastMatch = P_MAX_INDEX; PINDEX i;
// look for a match to the substring for (i = 0; i < list.GetSize(); i++) { if ((list[i].GetLength() >= keyLen) && MatchString(list[i].Left(len), subStr)) { matches++; lastMatch = i; } }
// if we got ONE match, we have a winner if (matches == 1) return lastMatch+1;
// if we have no matches, then there is no point continuing if (matches == 0) return P_MAX_INDEX;
// if we have more than one match, try the next char len++; }
// too many matches return 0; }
MyH323Connection::MyH323Connection(MyH323EndPoint & _ep, unsigned callReference) : H323Connection(_ep, callReference), ep(_ep) { basename = psprintf("iii_iii", callStartTime.GetYear(), callStartTime.GetMonth(), callStartTime.GetDay(), callStartTime.GetHour(), callStartTime.GetMinute(), callStartTime.GetSecond()); recordFile = NULL; ogmChannel = NULL;
receiveCodecName = transmitCodecName = "none";
cout << "Opening connection" << endl;
currentMenu = 0; digits = "";
PConfig config; PStringList sections = config.GetSections(); PINDEX i; for (i = 0; i < sections.GetSize(); i++) { if (sections[i].Find(MENU_PREFIX) == 0) menuNames.AppendString(sections[i]); }
}
MyH323Connection::~MyH323Connection() { cout << "Closing connection" << endl;
PTime now; PTimeInterval interval = now - recordStartTime; PString addr = GetControlChannel().GetRemoteAddress();
PString codecStr = receiveCodecName + "/" + transmitCodecName; unsigned duration = (unsigned)((interval.GetMilliSeconds()+999)/1000);
LogCall(recordFn, addr, GetRemotePartyName(), duration, codecStr, product);
if ((recordFile!= NULL) && (recordFile->WasRecordStarted()) && !ep.GetRunCmd().IsEmpty()) { PString cmdStr = ep.GetRunCmd() & recordFn & "/" + addr + "/" & "/"" + GetRemotePartyName() + "/"" & PString(PString::Unsigned, duration) & "/"" + codecStr + "/"" & "/"" + product + "/""; PTRACE(1, "Executing : " << cmdStr); system((const char *)cmdStr); } else { PTRACE(1, "No action to perform at end of record"); }
if (ogmChannel != NULL) delete ogmChannel;
if (recordFile != NULL) delete recordFile;
if (ep.GetDeleteAfterRecord()) { PTRACE(1, "Removing " << recordFn << " as requested by option"); PFile::Remove(recordFn); } }
H323Connection::AnswerCallResponse MyH323Connection::OnAnswerCall(const PString & caller, const H323SignalPDU & setupPDU, H323SignalPDU & /*connectPDU*/) { product = "Unknown";
const H225_Setup_UUIE & setup = setupPDU.m_h323_uu_pdu.m_h323_message_body;
const H225_EndpointType & epInfo = setup.m_sourceInfo;
if (epInfo.HasOptionalField(H225_EndpointType::e_vendor)) { const H225_VendorIdentifier & vendorInfo = epInfo.m_vendor; if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_productId)) product = vendorInfo.m_productId.AsString(); if (vendorInfo.HasOptionalField(H225_VendorIdentifier::e_versionId)) product = product + "/" + vendorInfo.m_versionId.AsString(); }
cout << "Accepting call from " << caller << " using " << product << endl;
return AnswerCallNow; } // //关键的东西都在这里 // 从传入的codec的的类别来判断H323 Endpoint正在使用什么样的codec进行数据的编码解码 //显然我们一开始的设定影响了现在的codec, 我们设定H323 Endpoint 的能力是G711,
// 所以这里应该是IsDescendant from H323_muLawCodec::Class() 或者H323_ALawCodec::Class(). // BOOL MyH323Connection::OpenAudioChannel(BOOL isEncoding, unsigned /* bufferSize */, H323AudioCodec & codec) { codec.SetSilenceDetectionMode(H323AudioCodec::NoSilenceDetection); PStringStream codecName; codecName << codec;
PString ogm; BOOL isPCM = FALSE;
if (codec.IsDescendant(G7231_File_Codec::Class())) { ogm = ep.GetG7231OGM(); isPCM = FALSE; } else if (codec.IsDescendant(H323_GSM0610Codec::Class())) { ogm = ep.GetGSMOGM(); isPCM = TRUE; } else if (codec.IsDescendant(MicrosoftGSMCodec::Class())) { ogm = ep.GetGSMOGM(); isPCM = TRUE; } else if (codec.IsDescendant(H323_muLawCodec::Class())) { ogm = ep.GetG711OGM(); isPCM = TRUE; } else if (codec.IsDescendant(H323_ALawCodec::Class())) { ogm = ep.GetG711OGM(); isPCM = TRUE; } else if (codec.IsDescendant(H323_LPC10Codec::Class())) { ogm = ep.GetLPC10OGM(); isPCM = TRUE; #ifdef SPEEX_CODEC } else if (codec.IsDescendant(SpeexCodec::Class())) { ogm = ep.GetSPEEXOGM(); isPCM = TRUE; #endif } else { cerr << "Unknown codec /"" << codecName << endl; return FALSE; }
PWaitAndSignal mutex(connMutex);
if ((recordFile == NULL) && (isEncoding == FALSE)) { if (isPCM) { if (ep.GetRecordWav() == TRUE) recordFn = ep.GetDirectory() + (basename + ".wav"); else recordFn = ep.GetDirectory() + (basename + ".sw"); recordFile = new PCM_RecordFile (*this, recordFn, ep.GetCallLimit()); } else { if (ep.GetRecordWav() == TRUE) recordFn = ep.GetDirectory() + (basename + ".wav"); else recordFn = ep.GetDirectory() + (basename + ".g723"); recordFile = new G7231_RecordFile(*this, recordFn, ep.GetCallLimit()); } }
// 这里创建了我们想用的通道 if ((ogmChannel == NULL) && (isEncoding == TRUE)) { if (isPCM) ogmChannel = new PCM_OGMChannel(*this); else ogmChannel = new G7231_OGMChannel(*this); }
if (isEncoding) {
if (ep.GetHangupAfterPlay()) ogmChannel->SetPlayOnce();
if (ogm.Find("%s")) ogm.Replace("%s", e164Number);
transmitCodecName = codecName; if (!StartMenu(0)) { if (!PFile::Exists(ogm)) cerr << "error: cannot find OGM /"" << ogm << "/"" << endl; else ogmChannel->QueueFile(ogm); if (!ep.GetNoRecordG7231()) ogmChannel->SetRecordTrigger(); }
//这里讲通道附着在codec上, 放音 codec.AttachChannel(ogmChannel, FALSE); } else { receiveCodecName = codecName; //这里讲通道附着在codec上. 录音 codec.AttachChannel(recordFile, FALSE); } return TRUE; }
BOOL MyH323Connection::OnStartLogicalChannel(H323Channel & channel) { if (!H323Connection::OnStartLogicalChannel(channel)) return FALSE;
cout << "Started logical channel: ";
switch (channel.GetDirection()) { case H323Channel::IsT
