Fresh Technology Try

Emacs 24 on Lion - mention the top right corner - full screen support

2011-12-05T12:07:00.001+08:00

Build Emacs on (Mac OS X 7) Lion, need get the latest code of emacs from the code repository.
(The latest stable release 23.3 can not be built on Lion, but 24.0.x is OK,
to build emacs 23.3 on Lion, check this.)
Using git to checkout the code, "git clone --depth 1 git://git.savannah.gnu.org/emacs.git"
"--depth 1" gets the latest code but not the whole history of repository.

The newer m4, autoconf, automake, libtool are needed to build emacs code.
Lion has got these tools preinstalled but too old to build emacs code.
I download them from mirror.kernel.org. Download, build and install with the classic steps (configure, make, sudo make install).
Do not forget add /usr/local/bin to your bash PATH, otherwise the tools still are the older version of the system.

Patch emacs code with the Lion full screen features.
Get the patch file from git://gist.github.com/1355895.git.
It is really cool and straightforward.

Full screen support is a big favor to developer. Amazing feature, love Lion.

The HDA sound driver for my T61p

2009-04-24T22:14:00.002+08:00

Eventually, I found the driver from google code. Thanks god. otherwise I need write this one.

Please goto http://code.google.com/p/voodoohda/ get the latest code.

It works fine on my lenovo T61p.

Guijin Ding
2009/4/24

Source code has been put on google code

2009-02-11T21:24:00.002+08:00

Sorry for so many days no updates. That should be a good news for some ones, I have put the code on google code.

svn checkout http://82566mm-osx-driver.googlecode.com/svn/trunk/ 82566mm-osx-driver-read-only

Welcome any comments or any improvements. You can email to me to say what you want to change and attach the change result source code file. I will merge and check in the code and share in google code.

If anyone who want contribute on this driver, it is welcomed and I will update the google code project to make sure you get the check-in permission.

Guijin Ding

Intel 82566MM -- Link is broken

2008-11-06T19:15:00.002+08:00

try this, Intel82566MM.kext.tar.gz

video converter for Mac OS X

2008-10-29T22:05:00.004+08:00

The video converter for Mac OS X has been almost done. In a few weeks I will public it. And this software wrapper ffmpeg to do media content encode/decode.

This software use Cocoa and Apple undocumented API -- cover flow.

Check out the screenshot:

Sender video converter for Mac OS X

Updated Intel82566MM driver - Oct. 15th 2008

2008-10-15T07:57:00.000+08:00

To support netstats in the driver.

Download the latest kext package.

Update Intel82566MM driver - Oct. 14 2008

2008-10-14T20:01:00.002+08:00

Update the Intel82566MM driver for Leopard (at lease 10.5.2).
To avoid some potential catch the sharing interrupt that does not belong to itself.

Maybe it is the root cause that sb who has the Intel HDA audio does not work well after installing the Intel82566MM driver. :-)

Download the latest kext package.

For nVidia Quadro 570m support in Mac OS X

2008-10-09T17:34:00.002+08:00

I have tried, tried. It is too hard and no clue so far.
The same as your feeling, I want to enable the QE/CI in my Leopard on T61p all the way. It is too hard and no clue.
I can share the research information on the hacking procgress. Maybe it is a never win fight.

A site focused on nVidia card reverse engineering.
http://nouveau.freedesktop.org/wiki/

Apple resouces but not very clearly to say how to write a Graphics driver to support QE/CI. But IOGraphics is open source. (unfortunately it can not be compiled by my xcode, need change somthing?)
http://developer.apple.com/documentation/Darwin/Reference/IOKit/IOGraphicsLib/CompositePage.html
http://developer.apple.com/documentation/Darwin/Conceptual/KEXTConcept/KEXTConcept.pdf

Updated Intel8255MM Mac OSX driver - 10/6/2008

2008-10-06T10:44:00.004+08:00

Please download from here http://www.tootoosoft.com/intel82566mm/Intel82566MM.kext.tar.gz.

Update to set the unknown ethernet device to ich8 serial by default.

Update Intel82566MM intend to support all kinds of e1000e ethernet card

2008-10-03T19:25:00.002+08:00

Update the code and wish to support all kinds of Ehternet chips of Intel E1000E. Hope it can work.

As usual, the package include the source code and precompiled kext.

Thanks for your inspiration

2008-10-03T07:39:00.002+08:00

I have added a donation button ... to keep the working going on. To support more intel e1000 PCIe ethernet cards on Leopard those e1000e (a project of sourceforge) supported.

Intel 82566MM Mac OS X (Leopard) driver works today

2008-10-01T20:56:00.003+08:00

Eventually, it works. This message coming from my Safari. And source code and kext binary still in there -- http://www.tootoosoft.com/intel82566mm/Intel82566MM.tar.gz

There are still some features need to be added (Power manager, VLAN support, checksum offloading, TCP segments support). But those are not critical.

Intel 82566MM -- Mac OS X driver that can ping another host.

2008-09-27T10:09:00.003+08:00

Ping crash fix. new issue present -> many incoming packets without EOP (End of Packet) flag.

Fixing... Sorry for the progress :-)

The latest source code and kext binary has been updated.

Intel 82566MM -- Mac OS X driver that can ping another host.

2008-09-24T23:35:00.002+08:00

Oh, that is great. But there is still possible crash.

Try this version and feel my progress.^_^ source code under GPL

Intel 82566MM -- Mac OS X driver with source code (cable plugin-> active, caple unplug-> inactive)

2008-09-21T14:40:00.005+08:00

Now watchdog can work. and you can plugin/unplugin the cable and see the "ifconfig" simultaneously.

Try this version and feel my progress. kext download and source code under GPL.

Now the driver still can not work for sending/receiving. Any comments is welcome. ^_^

su to root user and excute

cd /tmp

tar zxvf xxxx/Intel82566MM.tar.gz

ls -l (check Intel82566MM.kext has correct user:group that should be root:wheel)

kextload Intel82566MM.kext

...... (ifconfig or other Mac OS X network config tools)

kextunload Intel82566MM.kext

WARNING and DISCLAIM: The driver is only suit for Lenovo T61p. Using or Testing the driver may crash your system. You should make sure you have backup and made your data safty. And you take the total risk if you install/running this driver.

Intel 82566MM -- Mac OS X driver init and start done.

2008-09-20T22:19:00.004+08:00

After a couple of days and many reboots. the init and start of the driver for Intel82566MM on Mac OS X almost done.

Now I am working on the enable and disable interface of the driver.
So far the driver can get the mac address of the Intel82566MM ethernet card and could be configured by ifconfig or Mac OS X setup tool.

A watchdog timer is running and check the link down and up. (Actually it works not very well. I am fixing it.)

Try this version and feel my progress. download

su to root user and excute

cd /tmp

tar zxvf xxxx/Intel82566MM.tar.gz

ls -l (check Intel82566MM.kext has correct user:group that should be root:wheel)

kextload Intel82566MM.kext

...... (ifconfig or other Mac OS X network config tools)

kextunload Intel82566MM.kext

WARNING and DISCLAIM: The driver is only suit for Lenovo T61p. Using or Testing the driver may crash your system. You should make sure you have backup and made your data safty. And you take the total risk if you install/running this driver.

How to write Mac OS X device driver without Xcode -- Makefile to create Mac OS X device driver

2008-09-03T23:57:00.002+08:00

I got a Makefile to write my ethernet device driver.

CC = /Developer/usr/bin/gcc-4.0
CXX = /Developer/usr/bin/g++-4.0
SYSROOT = /Developer/SDKs/MacOSX10.5.sdk
ARCHFLAGS = -arch i386 -isysroot ${SYSROOT} -mmacosx-version-min=10.5

CXXFLAGS = -x c++ ${ARCHFLAGS} -fmessage-length=0 -pipe -nostdinc -fno-builtin \
-Wno-trigraphs -fno-exceptions -fno-rtti -fcheck-new -fasm-blocks \
-force_cpusubtype_ALL -static -msoft-float -Os -fno-common \
-mkernel -finline -fno-keep-inline-functions -Wreturn-type \
-Wunused-variable -DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE \
-DNeXT -fapple-kext -gdwarf-2 \
-I/System/Library/Frameworks/Kernel.framework/PrivateHeaders \
-I/Developer/SDKs/MacOSX10.5.sdk/System/Library/Frameworks/Kernel.framework/Headers \
-I.

CFLAGS = -x c ${ARCHFLAGS} -fmessage-length=0 -pipe -nostdinc -std=c99 -fno-builtin \
-Wno-trigraphs -fasm-blocks -force_cpusubtype_ALL -static -msoft-float -Os -fno-common \
-mkernel -finline -fno-keep-inline-functions -Wreturn-type -Wunused-variable \
-DKERNEL -DKERNEL_PRIVATE -DDRIVER_PRIVATE -DAPPLE -DNeXT -gdwarf-2 \
-I/System/Library/Frameworks/Kernel.framework/PrivateHeaders \
-I/Developer/SDKs/MacOSX10.5.sdk/System/Library/Frameworks/Kernel.framework/Headers \
-I.

CXXLDFLAGS = -lcpp_kext -static -nostdlib -r -lkmodc++
CLDFLAGS = -lkmod -lcc_kext

COBJS = Intel82566MM_info.o
CXXOBJS = Intel82566MM.o hw.o nvm.o fc.o mac.o dhcp.o

DRIVER_IMAGE = Intel82566MM
all: ${DRIVER_IMAGE}

%.o: %.cpp
${CC} -c ${CXXFLAGS} $< -o $@
%.o: %.c
${CC} -c ${CFLAGS} $< -o $@

${DRIVER_IMAGE}: ${COBJS} ${CXXOBJS}
${CXX} ${ARCHFLAGS} ${CXXOBJS} ${CXXLDFLAGS} ${COBJS} ${CLDFLAGS} -o ${DRIVER_IMAGE}

clean:
rm -f *.o ${DRIVER_IMAGE}

Note: the xxx_info.c is the driver entry fot IOkit device driver. For my driver it is:

#include

extern kern_return_t _start(kmod_info_t *ki, void *data);
extern kern_return_t _stop(kmod_info_t *ki, void *data);

KMOD_EXPLICIT_DECL(com.tootoosoft.driver.Intel82566MM, "1.0.0d1", _start, _stop)
__private_extern__ kmod_start_func_t *_realmain = 0;
__private_extern__ kmod_stop_func_t *_antimain = 0;
__private_extern__ int _kext_apple_cc = __APPLE_CC__ ;

So you choose what you like to create the device driver.
Emacs or VIM.

Oh kextunload ......

2008-09-03T06:58:00.002+08:00

If you over write free() of IOEthernentController, you must call IOEthernetController::free() in your free() method. Otherwise you never unload this kext unless reboot your Mac ...

Intel 82566MM -- How to access EEPROM/NVM?

2008-09-02T14:58:00.001+08:00

The Ethernet controller provides two different methods for software access to the EEPROM. It can either use the built-in controller to read the EEPROM or access the EEPROM directly using the EEPROM’s 4-wire interface.

Software can use the EEPROM Read register (EERD) to cause the Ethernet controller to read a word from the EEPROM that the software can then use. To do this, software writes the address to read into the Read Address field (EERD.ADDR; bits 15:2) and simultaneously writes a 1b to the Start Read bit (EERD.START; bit 0). The Ethernet controller then reads the word from the EEPROM, sets the Read Done bit (EERD.DONE; bit 1), and puts the data in the Read Data field (EERD.DATA; bits 31:16). Software can poll the EEPROM Read register until it sees the Read Done bit set, then use the data from the Read Data field. Any words read this way are not written to the Ethernet controller’s internal registers.

Software can also directly access the EEPROM’s 4-wire interface through the EEPROM/Flash Control register (EEC). It can use this for reads, writes, or other EEPROM operations.

To directly access the EEPROM, software should follow these steps:
1. Write a 1b to the EEPROM Request bit (EEC.EE_REQ; bit 6).
2. Read the EEPROM Grant bit (EEC.EE_GNT; bit 7) until it becomes 1b. It remains 0b as long as the hardware is accessing the EEPROM. Write or read the EEPROM using the direct access to the 4-wire interface as defined in the EEPROM/Flash Control & Data register (EEC). The exact protocol used depends on the EEPROM placed on the board and can be found in the appropriate datasheet.
4. Write a 0b to the EEPROM Request bit (EEC.EE_REQ; bit 6).
Finally, software can cause the Ethernet controller to re-read part of the hardware accessed fields of the EEPROM (setting the Ethernet controller’s internal registers appropriately) by writing a 1b to the EEPROM Reset bit of the Extended Device Control Register (CTRL_EXT.EE_RST; bit 13).

In Linux e1000e driver, it used the second method.

Mac OS X Device Driver -- what is work loop?

2008-09-02T11:16:00.001+08:00

Tired to understanding the Linux Intel e1000e driver. Change my mind to Mac OS X and have a break.

Interrupt service threads are the standard way of handling interrupts in Mac OS X device drivers, though they often go by another name, the work loop. A work loop is a thread whose sole purpose is to wait for an event such as an interrupt to occur, then call an appropriate handler function to do the actual work of processing the interrupt—checking the result, copying data, and so on. This activity occurs in a kernel thread. The kernel thread does not receive the actual interrupt, however. A low-level interrupt handler receives the primary interrupt. It then generates a software interrupt known as a secondary interrupt. The interrupt service thread receives that secondary software interrupt. Thus, routines running in an interrupt service thread do not have to obey the same rules as an actual interrupt handler; they can block, call IOLog, and so on.

PCI Matching Policy in Mac OS X

2008-09-02T10:29:00.001+08:00

PCI Matching

PCI device drivers can base their property matching on the PCI configuration space registers for vendor and device ID (offsets 0x00 and 0x02), subsystem vendor and device ID (offsets 0x2C and 0x2E), and class code (offset 0x09). Other registers, such as revision ID and header type, are not available in property matching and must be examined by the probe method.

The PCI matching dictionary keys are:

IOPCIMatch: Matches against the primary vendor/device ID registers or the subsystem
vendor/device ID registers. The primary IDs are checked first; if either of
these doesn’t match then the subsystem IDs are checked.
IOPCIPrimaryMatch: Matches only against the primary vendor/device ID registers.
IOPCISecondaryMatch: Matches only against the subsystem vendor/device ID registers.
IOPCIClassMatch: Matches against the class code register.

Oh PBA is another PBA.

2008-09-02T10:12:00.002+08:00

PBA for OEM number.
PBA (Packet Buffer Allocation).

Two PBA in the chip, a little confusing.

PBA (01000h; R/W)
This register sets the on-chip receive and transmit storage allocation ratio. The receive allocation value is read/write for the lower six bits. The transmit allocation is read-only and is calculated based on PBA.RXA. The partitioning size is 1 KB.

What is NAPI?

2008-09-02T09:46:00.002+08:00

To make thing as simple as possible. I try to disable the NAPI mode. It may cause some performance lost.

But how NAPI. The folling two links are very good start points.

http://lwn.net/Articles/30107/
http://www.linuxfoundation.org/en/Net:NAPI

Intel 82566MM -- what type of interrupt shold be masked?

2008-09-02T07:11:00.001+08:00

That comes the definition of e1000e source of Linux kerenel.

/*
* This defines the bits that are set in the Interrupt Mask
* Set/Read Register. Each bit is documented below:
* o RXT0 = Receiver Timer Interrupt (ring 0)
* o TXDW = Transmit Descriptor Written Back
* o RXDMT0 = Receive Descriptor Minimum Threshold hit (ring 0)
* o RXSEQ = Receive Sequence Error
* o LSC = Link Status Change
*/

Intel 82566MM -- What is PBA?

2008-09-01T21:50:00.001+08:00

The nine-digit Printed Board Assembly (PBA) number, used for Intel manufactured adapter cards, is stored in a four-byte field. The dash itself is not stored, neither is the first digit of the 3-digit suffix, as it will always be 0b for the affected products. Note that through the course of
hardware ECOs, the suffix field (byte 4) is incremented. The purpose of this information is to allow Customer Support (or any user) to identify the exact revision level of a product. Network driver software should not rely on this field to identify the product or its capabilities.

Only Intel engineer to surstaining ...

What is Intel AMT in 82566MM?

2008-09-01T12:55:00.002+08:00

The Gigabite Ethernet Controller is integrated in ICH8.
AMT is provided as well.

But what is AMT?

Intel® Active Management Technology (Intel®
AMT) (Intel® ICH8DO and ICH8M-E Only))
Intel Active Management Technology is a set of advanced manageability features
developed as a direct result of IT customer feedback gained through Intel market
research. Reducing the Total Cost of Ownership (TCO) through improved asset tracking,
remote manageability, and fewer desk-side visits were identified as key IT priorities.
Intel AMT extends the capabilities of existing management solutions by making the
asset information, remote diagnostics, recovery and contain capabilities always
available, or Out of Band (OOB), even when the system is in a low-power “off” state or
the OS is hung.
Another technology feature of Intel Active Technology is System Defense. System
Defense is a Intel AMT feature that is used to stop the propagation of worms and
viruses. Programmable packet filters in the integrated LAN Controller are used to
accomplish this. These filters inspect all incoming and all outgoing packets and decide
whether to block or pass the packets as configured. There is no indication to the host
that a packet has been blocked or accepted.
The logic can be used to accept or block reception to host or transmission to network
paths. Additionally, counter logic can be used to count the number or filter matches for
a given filter. This feature allows for statistical sampling of connections as well as rate
limiting of connections.

What features does it provided?
• E-Asset Tag
• OOB HW and SW Inventory Logs
• OOB Alerts
• IDE Redirect
• Serial over LAN for Remote Control
• Remote Diagnostics Execution
• OS Lock-Up Alert
• OS Repair
• Remote BIOS Recovery and Update

I would like to disable the feature in my driver for Mac OS X.

Understanding Intel 82566MM driver source on Linux

2008-08-31T22:31:00.002+08:00

Understanding Intel 82566MM driver source on Linux. That is the first step to port it to Mac OS X.

It is really not a one-day-project.

Today after a few hours, I got the basic infrustucture of the e1000e source and delete many code those are irrelvant with the 82566MM... (ethtool, param parser, 82571, msi interrupt, NAPI support, kcompat and so on totally been removed).

And the left code still can work on my T61p.

The understanding work still need go on ...

Leopard 82566MM driver - Apple Intel 82557 Driver sample

2008-08-31T09:33:00.001+08:00

I got the Apple Intel 82557 driver source from Darwin Open Source project.

So far, I believe everything is ready to develop my 82566MM driver on Mac OS X.

Leopard 82566MM driver - Mac resource

2008-08-31T09:30:00.002+08:00

How to write a KEXT on Mac OS X.
How to write a Device Driver (IOKit) on Mac OS X.
How to write a Network device driver on Mac OS X.

These document could be download from Apple Developer Connection.

Leopard 82566MM driver - Linux resource

2008-08-31T09:28:00.002+08:00

Linux resource

The sourceforge project e1000 is a good place for Linux e1000 driver.

Linux 2.6.22.3 has integrated the PCIe e1000 driver in its net driver (e1000 and e1000e).

Leopard 82566MM driver - I decided port e1000/e1000e network card driver to my hackintosh

2008-08-31T09:20:00.003+08:00

I decided port e1000/e1000e network card driver to my hackintosh

I have installed Leopard on my laptop (Lenovo T61p). But the Intel 82566MM is not drived by the hackintosh.

It is 2 months that I have been waiting the open community people to resolve this problem. But it really frustrate me.

So I decided work on it.

The day is the start point. It is August 31 2008.

100阶台阶的走法

2007-05-31T15:31:00.000+08:00

100阶台阶，每次走1或者2阶，共有多少种走法？

考虑在99处走一个1到达终点，也可以考虑是在98处选择两个走。那么100阶台阶上来的可能只有两类，一类是从99过来的1，一类是从98过来的2。所以100阶台阶的走法就很明显了是 99阶于 98阶的和。

那么如果可能走 1， 2， 3个台阶呢，应该也可以推算出来了。

写个Xlib的BMP文件显示程序

2007-05-16T12:17:00.000+08:00

项目中有这个需要四处找可用的信息。终于从一个叫IV的程序源码得到了最后的解决方法。

整个遇到的问题主要有
1 bmp的数据结构在GCC下被缺省4字节对齐，需要在bmp file info 和 bmp info header struct定义最后加上 __attribute__((packed)),值得注意的是不要放到typedef 一行中，这个问题困扰了我一下.

2 Xlib中显示有颜色的图像需要根据当前链接的DISPLAY的colormap有关系，这是可以理解的，就是比较麻烦，对于不同的Xserver你的显示程序可能要写成不一样 .

3 如果要想动态获得当前DISPLAY提供的像素颜色，那么制作一个XImage的时间会不可接受（对于超过 256彩色的图像）

这是我在做的过程中发现的问题。

第一个问题解决的数据结构定义：

typedef unsigned short int WORD;
typedef unsigned int DWORD;
typedef int LONG;

struct tagRGBQUAD {
unsigned char rgbBlue;
unsigned char rgbGreen;
unsigned char rgbRed;
unsigned char rgbReserved;
}__attribute__((packed));

typedef struct tagRGBQUAD RGBQUAD;

struct tagBITMAPFILEHEADER {
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits;
}__attribute__((packed));
typedef struct tagBITMAPFILEHEADER BITMAPFILEHEADER;

struct tagBITMAPINFOHEADER{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
}__attribute__((packed));

typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;

//这些数据结构直接从MSDN从COPY，然后调整。

//普通的显示图像的过程是这样的
//打开DISPLAY，创建WINDOW，创建GC，打开 BMP 文件读出结构信息和 BMP数据，创建XIMAGE通过 BMP数据，标注关心的WINDOW事件映射窗口 flush消息

//开始窗口循环
//在EXPOSE的事件上显示XIMAGE数据
//可以选择在KeyPress上把程序EXIT，我没有加，如果想得到KeyCode，需要根据键盘字符找到 KeySym再在映射到keycode

//程序如下
#include
#include
#include

#include

typedef unsigned short int WORD;
typedef unsigned int DWORD;
typedef int LONG;

struct tagRGBQUAD {
unsigned char rgbBlue;
unsigned char rgbGreen;
unsigned char rgbRed;
unsigned char rgbReserved;
}__attribute__((packed));

typedef struct tagRGBQUAD RGBQUAD;

struct tagBITMAPFILEHEADER {
WORD bfType;
DWORD bfSize;
WORD bfReserved1;
WORD bfReserved2;
DWORD bfOffBits;
}__attribute__((packed));
typedef struct tagBITMAPFILEHEADER BITMAPFILEHEADER;

struct tagBITMAPINFOHEADER{
DWORD biSize;
LONG biWidth;
LONG biHeight;
WORD biPlanes;
WORD biBitCount;
DWORD biCompression;
DWORD biSizeImage;
LONG biXPelsPerMeter;
LONG biYPelsPerMeter;
DWORD biClrUsed;
DWORD biClrImportant;
}__attribute__((packed));

typedef struct tagBITMAPINFOHEADER BITMAPINFOHEADER;

int read_bmp_file(char* filename, unsigned char * const buffer,
unsigned char** data, int* width, int* height, int* depth)
{
FILE* fd;
int rt;
int channel;
unsigned char* bits;

BITMAPFILEHEADER bmfh;
BITMAPINFOHEADER bmih;

fd = fopen(filename, "rb");
if(fd == NULL) {
printf("NO such file %s.\n", filename);
return -1;
}

rt = fread(buffer, 1, 2*1024*1024, fd);
printf("read image ->%d.\n", rt);
fclose(fd);

printf("sizeof(bmfh)->%d.\n", sizeof(bmfh));
printf("sizeof(bmih)->%d.\n", sizeof(bmih));

memcpy(&bmfh, buffer, sizeof(bmfh));
memcpy(&bmih, buffer + sizeof(bmfh), sizeof(bmih));
if(bmfh.bfType != 19778) {
return -1;
}

bits = (unsigned char*) (buffer+bmfh.bfOffBits);

channel = bmih.biBitCount/8;
*depth = bmih.biBitCount;
*width = bmih.biWidth;
*height = bmih.biHeight;

*data = bits;
printf("\tsize(%dx%d) channel:%d ---\n", *width, *height, channel);
return 0;
}

static int highbit(unsigned long ul)

{
int i; unsigned long hb;
hb = 0x8000; hb = (hb<<16); /* hb = 0x80000000UL */
for (i=31; ((ul & hb) == 0) && i>=0; i--, ul<<=1);
return i;
}

XImage* create_ximage(Display* dpy, unsigned char* data,
int width, int height, int bdepth)
{
Visual *visual = DefaultVisual(dpy, DefaultScreen(dpy));
int depth = DefaultDepth(dpy, DefaultScreen(dpy));
XImage* res;
int i, j;
unsigned char* idata;

res = XCreateImage(dpy, visual, depth, ZPixmap, 0 /*offset*/,
NULL, width, height, 32, 0);
if (res == NULL) {
return NULL;
}

idata = (unsigned char*)malloc(res->bytes_per_line*height);
res->data = idata;

{
unsigned long r, g, b, rmask, gmask, bmask, xcol;
int rshift, gshift, bshift, bperpix, bperline, border;
unsigned char *ip, *pp;
rmask = visual->red_mask;
gmask = visual->green_mask;
bmask = visual->blue_mask;

rshift = 7 - highbit(rmask);
gshift = 7 - highbit(gmask);
bshift = 7 - highbit(bmask);

bperline = res->bytes_per_line;
bperpix = res->bits_per_pixel;
border = res->byte_order;

pp = data;

for (i=0; i for (j=0; j b = *pp++; g = *pp++; r = *pp++;
pp++;

if (rshift<0) r = r << (-rshift);
else r = r >> rshift;

if (gshift<0) g = g << (-gshift);
else g = g >> gshift;

if (bshift<0) b = b << (-bshift);
else b = b >> bshift;

r = r & rmask;
g = g & gmask;
b = b & bmask;

xcol = r | g | b;

ip = (idata+(height-1-i)*bperline+j*bperpix/8);
if (bperpix == 32) {
if (border == MSBFirst) {
*ip++ = (xcol>>24) & 0xff;
*ip++ = (xcol>>16) & 0xff;
*ip++ = (xcol>>8) & 0xff;
*ip++ = xcol & 0xff;
}
else { /* LSBFirst */
*ip++ = xcol & 0xff;
*ip++ = (xcol>>8) & 0xff;
*ip++ = (xcol>>16) & 0xff;
*ip++ = (xcol>>24) & 0xff;
}
}

else if (bperpix == 24) {
if (border == MSBFirst) {
*ip++ = (xcol>>16) & 0xff;
*ip++ = (xcol>>8) & 0xff;
*ip++ = xcol & 0xff;
}
else { /* LSBFirst */
*ip++ = xcol & 0xff;
*ip++ = (xcol>>8) & 0xff;
*ip++ = (xcol>>16) & 0xff;
}
}

else if (bperpix == 16) {
if (border == MSBFirst) {
*ip++ = (xcol>>8) & 0xff;
*ip++ = xcol & 0xff;
}
else { /* LSBFirst */
*ip++ = xcol & 0xff;
*ip++ = (xcol>>8) & 0xff;
}
}

else if (bperpix == 8) {
*ip++ = xcol & 0xff;
}
}
}
}

return res;
}

Window create_simple_window(Display* display, int width, int height, int x, int y)
{
int screen_num = DefaultScreen(display);
int win_border_width = 2;
Window win;

win = XCreateSimpleWindow(display, RootWindow(display, screen_num),
x, y, width, height, win_border_width,
BlackPixel(display, screen_num),
WhitePixel(display, screen_num));

return win;
}

GC create_gc(Display* display, Window win, int reverse_video)
{
GC gc; /* handle of newly created GC. */
unsigned long valuemask = 0; /* which values in 'values' to */
/* check when creating the GC. */
XGCValues values; /* initial values for the GC. */
unsigned int line_width = 2; /* line width for the GC. */
int line_style = LineSolid; /* style for lines drawing and */
int cap_style = CapButt; /* style of the line's edje and */
int join_style = JoinBevel; /* joined lines. */
int screen_num = DefaultScreen(display);

gc = XCreateGC(display, win, valuemask, &values);
if (gc < 0) {
printf("XCreateGC: \n");
}

/* allocate foreground and background colors for this GC. */
if (reverse_video) {
XSetForeground(display, gc, WhitePixel(display, screen_num));
XSetBackground(display, gc, BlackPixel(display, screen_num));
}
else {
XSetForeground(display, gc, BlackPixel(display, screen_num));
XSetBackground(display, gc, WhitePixel(display, screen_num));
}

/* define the style of lines that will be drawn using this GC. */
XSetLineAttributes(display, gc,
line_width, line_style, cap_style, join_style);

/* define the fill style for the GC. to be 'solid filling'. */
XSetFillStyle(display, gc, FillSolid);

return gc;
}

int place_graphics(Display* display,
Window win, GC gc,
XImage* img,
unsigned int width,
unsigned int height)
{
XPutImage(display, win, gc, img, 0, 0, 0, 0, width, height);
return 0;

}

int show_bmp_data(unsigned char* bmpdata, int bwidth, int bheight, int bdepth)
{
Display* display;
int screen_num;
Window win;
unsigned int display_width, display_height;
unsigned int width, height;
char *display_name = (char*)getenv("DISPLAY");
GC gc;
XImage* img;
/* open connection with the X server. */
display = XOpenDisplay(display_name);
if (display == NULL) {
return -1;
}

screen_num = DefaultScreen(display);
display_width = DisplayWidth(display, screen_num);
display_height = DisplayHeight(display, screen_num);

width = 720;
height = 576;

printf("window width - '%d'; height - '%d'\n", width, height);

win = create_simple_window(display, width, height, 0, 0);
gc = create_gc(display, win, 0);
XSelectInput(display, win, ExposureMask | KeyPressMask |
ButtonPressMask | StructureNotifyMask);

img = create_ximage(display, bmpdata, bwidth, bheight, bdepth);

XMapWindow(display, win);
XFlush(display);
{
XEvent report;
while (1) {
XNextEvent(display, &report);
switch (report.type) {
case Expose:

if (report.xexpose.count != 0)
break;

place_graphics(display, win, gc, img, width, height);
break;
case ConfigureNotify:

break;
case ButtonPress:

case KeyPress:

break;

default:

break;
} /* End switch */
} /* End while */
}
return 0;
}

int main(int argc, char** argv)
{
char filename[256];
unsigned char* data;
unsigned char* buffer;
int width, height, depth;

strcpy(filename, "/root/a.bmp");
if(argc == 2) {
strcpy(filename, argv[1]);
}
buffer = (unsigned char*) malloc(2*1024*1024);
if(buffer == NULL) {
return -1;
}

data = NULL;
read_bmp_file(filename, buffer, &data, &width, &height, &depth);
if(data == NULL) {
free(buffer);
return -1;
}
show_bmp_data(data, width, height, depth);
free(buffer);
return 0;
}

//这里面只是支持32位BMP文件将BMP数据到IMAGE转换中的最后pp++去掉就可以支持24位BMP
//我现在使用XAllocColor的方法实现256色BMP的显示，这个演示的程序不包含。

文章选项：

字符识别之卷积神经网络

2007-05-05T23:06:00.000+08:00

卷积神经网络可以共享权,可以提取图像特征,可以通过设计卷积核和采样方法来实现图像的旋转不变.
我使用了一个卷积神经网络的模型,参考了一个LeCun的文献.
首先将字符图象变成28x28 为什么呢,28能被4整除比较合适.因为我真正在神经网络中识别的是29x29,但是为了从车牌中提取图像方便,把所有图像都归一成28 28.
整个网络设计分为5层. 第一层是输入层,就是原始的29x29的图像.
第二层分成6个Feature Map. 每个Feature Map包含了一个13x13的图像.每个13x13的图像是从第一层与一个5x5的卷积核卷积而来,这个卷积核在第一层输入的图像X方向和Y方向每隔两个像素移动一次,可以动手画一下,看看是不是能把29x29映射成13x13,我画过了,可以.6个Feature Map就是用 6个不同的卷积核.
第三层分成50个Feature Map,每个Feature Map是5x5像素的图像. 和第一层到第二层的映射方法一样,是一个5x5的卷积核,在第二层的某个Feature Map上移动,移动的方法也是X Y 方向每隔两个像素.再次动手画画,看看是不是13x13能够映射成5x5.
第四层和第五层是全连接层. 第四层100个神经元,第五层是输出层.你想输出多少种变化?

二值图像区域标示算法

2007-05-05T22:43:00.000+08:00

对二值图像的连通区域搜索标明.在OpenCV中可以使用cvFindContours来实现,然后再用mini area确定一个Box2D的对象,就可以操作连通区域了,我使用了一下,标示的挺准确(我还没有发现错误),并且速度也很快.
但是我不想因为就使用这一个函数来增加一个库引用的负担,或者我想自己发现连通区域怎么办.当然我就是基于这两个原因,试用了很多算法来标示连通区域.
常见的标号法,就是四连通或者八连通搜索,对一个像素的4个邻域(左,上)或者8个邻域搜索(左,上,左上,右上)来标号,建立一个和原图像像素一样多的整数空间,然后在这个整数空间标号(可以解决区域超过255的情况).标号算法的最大问题就是要重新计算统一区域重复标注的问题.这个问题很是不好弄,所以我最后放弃了标号法.
图的深度优先搜索方法,就是遇到一个关注像素(如白色,黑色是背景),就在这个像素的8邻域内查看如果有关注像素,就把这个像素放到一个栈里面,并且把当前的关注像素标号,然后再把栈里面的像素弹出,同样找这个像素的8邻域,如果有关注像素并且未被标号,那么放入栈,然后标号这个像素.如此反复知道栈见底.这是图的深度优先搜索,如果真的是这样搜索区域的话,真的很慢. 加了些处理后,速度基本可以接受了.首先将整个图像的关注像素全部放入一个链表,因为一般讲背景像素是整个图像中的大多数,这样就避开每次对关注像素搜索的时候要不断地碰到背景像素这样的浪费.再有就是将栈变成静态数组,再加一个索引跟着.这样搜索每个区域的第一个关注点的时候都到链表中去寻找,而不是遍历图像.但是8邻域搜索是必须以图像像素索引的,不能到链表中找.注意链表不能存在像素的拷贝而只是引用,不然在标示的时候不能影响到链表的数据,那么也就不能正确的找到下一个区域的起始关注点.

OpenCV使用注意之伪内存泄露

2007-04-16T15:34:00.000+08:00

在测试和验证各种各样的算法的时候,我使用了Intel的OpenCV.这是个开源的项目,很不错.使用这里面的函数在初期帮我节省了很多时间,虽然现在我已经全部用自己实现的替换掉了,自己写的好控制些,并且速度的确快了一些.不过我也积累了一些小的OpenCV的使用经验,这些经验也是用时间换来的,在此记录下,如果可以节省一点资源就是价值.
在使用cvGetSubRect的时候,我的内存是刷刷的漏掉,当然最开始我怎么也不知道是这个函数漏,一万次的试验才发现,是它在泄露. 我想知道是它在泄露,如何避免就是一件简单的事情了. 最简单的办法就是不用了哈哈,我就是自己写了一个类似的函数,把它暂时替换掉了.实际上是我用错了这个函数,我在使用它的时候为Matric申请了内存,实际上是不需要申请它会把源数据中的内存值直接付给这个Matric的数据指针,这样的结果就是把我实际申请的数据空间指针给覆盖了,我的程序就丢失了这个已经申请的内存区域的地址,我如果去释放这个Matric,那么实际上是释放的Matric的Header和源数据的相应空间,把源给干了,不仅仅是泄露,而且还干了很龌龊的事情.这是后来我查看cvGetSubRect的code时候发现的(cxarray.c 1496).
知道了这些,就知道怎么正确使用这个函数了. cvGetSubRect(). 如果使用它那么请记住我说的.

图像处理之卷积概念

2007-04-16T10:57:00.000+08:00

如果你刚刚接触图像处理,或者离开大学很长时间,一看到卷积这个东西,肯定和我一样感到晕菜.那么就复习一下,并且实际的写个程序验证一下,我保证你这辈子不会再忘记卷积的概念了.我们来看一下一维卷积的概念.
连续空间的卷积定义是 f(x)与g(x)的卷积是 f(t-x)g(x) 在t从负无穷到正无穷的积分值.t-x要在f(x)定义域内,所以看上去很大的积分实际上还是在一定范围的.
实际的过程就是f(x) 先做一个Y轴的反转,然后再沿X轴平移t就是f(t-x),然后再把g(x)拿来,两者乘积的值再积分.想象一下如果g(x)或者f(x)是个单位的阶越函数. 那么就是f(t-x)与g(x)相交部分的面积.这就是卷积了.
把积分符号换成求和就是离散空间的卷积定义了.那么在图像中卷积卷积地是什么意思呢,就是图像就是图像f(x),模板是g(x),然后将模版g(x)在模版中移动,每到一个位置,就把f(x)与g(x)的定义域相交的元素进行乘积并且求和,得出新的图像一点,就是被卷积后的图像. 模版又称为卷积核.卷积核做一个矩阵的形状.
卷积定义上是线性系统分析经常用到的.线性系统就是一个系统的输入和输出的关系是线性关系.就是说整个系统可以分解成N多的无关独立变化,整个系统就是这些变化的累加.
如 x1->y1, x2->y2; 那么A*x1 + B*x2 -> A*y1 + B*y2 这就是线性系统. 表示一个线性系统可以用积分的形式如 Y = Sf(t,x)g(x)dt S表示积分符号,就是f(t,x)表示的是A B之类的线性系数.
看上去很像卷积呀,,对如果f(t,x) = F(t-x) 不就是了吗.从f(t,x)变成F(t-x)实际上是说明f(t,x)是个线性移不变,就是说变量的差不变化的时候,那么函数的值不变化. 实际上说明一个事情就是说线性移不变系统的输出可以通过输入和表示系统线性特征的函数卷积得到.

哈哈,我也有点晕了.

车牌识别-水平微分之递增算法

2007-04-16T10:52:00.000+08:00

将原始彩色图像转换成灰度图象之后,对灰度图象进行水平微分

,微分的方法是先做水平均值然后再微分,具体方法参考了一个文献的描述:使用一个水平模板算子，即[1,1,1…，1，1，1，1]。该算子与图像进行卷积然后再与原图像作差分运算，当差分值大于某一门限值就认为它是边缘目标，否则是背景。

水平模板即[1,1,1…，1，1，1，1]，它与图像进行卷积相当于图像水平方向进行低通滤波，再与原图像差分，其目的是突出图像的垂直方向的高频信息（相当于对图像进行高通滤波）。由于该算子可以做增量运算，也就是在计算局部平均值时，先计算水平方向窗口内各点之和，将前次运算的结果减去窗口最左边点的值再加上右边新一点的值。这样可以减少求和运算次数.

算子的长度多少的选择要看一个车牌字符的宽度大致应该是多少,比如9,说明比较适合9个像素宽度的字符.

下面是我的实现:
里面有最大值统计,可以根据最大值来动态调节二值化的域值,也可以是固定的比如10,影响不是很大.

typedef struct {
int width;
int height;
int width_step;
int channel;
unsigned char* image_data;
} t_image;

int pre_delta(t_image* src, t_image* dst)
{
int height=src->height;
int width=src->width;
int x, y;

unsigned int v;
unsigned char *p, *q;
int i, u;

int max_u = 0;

for(y=0; y p = src->image_data + src->width_step*y;
q = dst->image_data + dst->width_step*y;
v = 0;
for(i = 0; i < 9; i++) {
v += *(p++);
}
for(x=5; x v -= *(p - 9);
v += *(p++);
u = (v/9 - *(p-5));
if(u > 0) {
if(u > max_u)
max_u = u;
*(q+x) = (unsigned char)u;
}
}
}
return 0;
}

参考文献:
一种边缘检测与扫描线相结合的车牌定位算法

车牌识别实现--字符识别

2007-04-15T22:46:00.000+08:00

别看车牌只是几个字符,但是识别出来还是有点难度的,因为字符提取出来的效果差距很大.提取的字符可能模糊可能倾斜,可能粗可能细,也可能断裂,我四处寻找可以参考的细化的算法,很遗憾没有好的,细化出来的效果很差,不是算法太差,就是原始图像太差,怎么办呢. 终于我找到了解决之道,就是不细化直接识别.这需要卷积神经网络,这个东西太爽了,在教科书上提及很少的共享权重的神经网络,有人在98年就用它来设计识别手写英文字符,这个文献我仔细研读了,并且作者实现的识别率惊人得高,99%多,给我很大信心,我设计了一个卷积神经网络,初步训练和测试效果很好,训练收敛很好,识别也很准确.我没有时间制作大量样本,如果有大量样本数据训练,这个网络表现会更好.
今天写道这里,基本的原理我都写了.真正有价值的就这些了.

车牌识别实现--字符分割

2007-04-15T22:26:00.000+08:00

以前我想定位了,分割很容易了, 垂直做个投影不就OK了.事实上远远不是这样,因为定位的结果可能错的也可能是好的,也可能含有严重干扰.简单处理是不行的. 首先拿到定位出来的车牌,要分析出来这个车牌的字符和背景的颜色,哪个更黑或者更白,如果这个没有其他都是费.
分析颜色对比,我没有找到合适的文献说明,我自己设计了一个,也许有人已经用过这样的方法,我又在发明相同的轮子了,呵呵不管了,有轮子也好哇. 还是将灰度车牌图像做微分,不过是全微分,这样出来的车牌图像是个灰度微分图,在灰度微分图的最中间的1/4区域内做垂直投影,找到一系列的大的求和点和一系列小值和点,这样基本可以想象这些大值点应该是字符边缘,而小值点是背景,也可能是字符内部.在原有车牌灰度上找这些大值点的像素值, 再找到这些小值点的像素值,小值点像素值要做处理,如果变化很大,说明真的有字符里面的像素也有背景像素,要参考一下刚才发现的字符平均像素,把这些像素去掉.这样就清静了,肯定都是背景了.再比较背景和字符像素的灰度值发现字符黑还是背景黑.

然后将图像二值化,二值化的方法很多,都不是很有效果,原因是定位的结果可能很不同,我用了一个文献的算法将车牌字符占用比例考虑进去再这个小的邻域内进行最大类间方差和最小类内方差判别,来得到二值化车牌.

提取字符过程又要区域分割,这里面涉及很多奇妙的东西,参考很多文献,先找到几个相似的区域,如果没有相似区域说明这个车牌图像质量太差,从相似区域里面找最大区域,以这个区域作为样板. 分割之,经常有断裂和连接的情况,通过样板的方法很容易搞定.也许你没有看到倾斜矫正这个过程,因为字符是通过区域提取得到的,所以车牌的倾斜是不需要矫正的,(倒是字符识别的时候会遇到倾斜的字符).

车牌识别实现--粗定位算法

2007-04-15T21:58:00.000+08:00

首先,我想说明的是很多的想法不是我原创的,但是程序都是我写的.我在这里把我几个月来对车牌定位和识别的设计实现以及试验的过程记录下来,为了自己不断忘却的记忆,也许能帮上你的忙,那我就会感谢没有浪费你的时间.我为我没有做到不利于别人的事情而感到安慰,呵呵.
我选择的定位方式是基于纹理的分析,通过微分图像,将车牌的字符变化突出出来,然后选择一个值进行微分图像二值化,这个值的选择看上去很重要,其实不是很重要,我试验了固定的数10,或者微分图像的最大值推算一个接近10的数,得到的图像虽然不同,但是字符的水平纹理基本不受太大影响.然后要对二值化微分图像进行处理,在很多文献上提到颗粒滤波和长程曲线滤波,我借鉴了颗粒滤波和长程曲线滤波的想法,但是重新简化了算法,颗粒滤波不是针对颗粒的周围只是针对其上下边界进行计算,因为我要寻找纹理的水平方向上的变化,颗粒滤波的效果很好,并且能够实现快速匹配运算,提高效率,长程滤波困扰了我很长时间,最后还是用了一个笨方法但是实际速度还是可以接受,我专门写了一个帖子以示纪念.
核心的过程实际上是对二值图像的水平纹理变化扫描统计,扫描到车牌特征区域,并且把这个区域记下.车牌特征区域实际上不是一下能够定位出来的,扫描只是一个准备过程,就是相当于把这个问题分解,那么扫描的过程也就不会非常难实现.扫描到在X方向上一段距离内像素值变化在9-50范围就可能是车牌,把这个扫描线放到一个新的图像中,这是很关关键,这样在一个临时存储的图像中就会用很多很多扫描线,这些线是通过对二值图像的变化扫描出来的,需要使用简单的状态机,不然程序就太乱了.临时图像的有很多扫描线,这些扫描线都像发现了车牌一样. 这时候我把精力转移到处理这个有扫描线的临时图像上,其中我自己设计了腐蚀和膨胀算法,因为传统腐蚀与膨胀算法是针对所有目标区域的,但是我不想这样,因为我在腐蚀的时候,我只希望专门沿着X方向或者专门沿着Y方向把不合适大小的连续扫描线去掉,而不对那些看上去真的很合适的扫描线进行形态操作,不影响它,根本就不动它. 通过这样的处理后再将区域进行标识,区域标识我用的两条直线同在一个区域的判别方法,这个方法很快,但是会有很明显的共区域现象.需要重新处理,好在在这个时候区域已经很少,选择什么算法,对速度影响不大.
到这里定位基本结束,90%以上的车牌就是最底下的候选区域.清晰的车牌很容易定位,不清晰的车牌即使勉强定位成功,识别也是很难.因为下面的字符分割也是个麻烦.

一种长程曲线的滤波方法

2007-04-15T20:29:00.000+08:00

一种长程曲线的滤波方法
很久没有来这里了,最近一直在忙于实现一个自动车牌定位和识别的算法,感谢互联网为我提供了很多素材,最终我采用了基于纹理分析的方法.但是在微分图像中有很长的边缘干扰,类似汽车的边界,这些长程曲线干扰如何去掉,困扰了我很久,有文献上略略提到,但是没有明确和实现的方法.我设计了一个方法,也许不是最好的,但是还比较好用.
具体的算法是,在微分图像中进行8连通的区域搜索,用标记法搜索,不用二次修正,因为是竖长曲线搜索,如果是标记错误,那么影响很小.对于搜索出来的区域寻找Y轴的最大小值,如果最大值和最小值之间距大于你的想象了(一般是整幅图像的1/10)那么这是一个干扰长线区域,应该去掉.

Using doxygen with CJK-latex

2007-01-21T14:21:00.000+08:00

Make sure you have installed the latast doxygen CJK-latex and related fonts. Create doxygen config file support Chinese language and make sure output format including latex.

After generate document you will get the latex directory. Change directory to latex and edit the main tex file maybe "refmain.tex". Add the line "\usepackage{CJK}" after "\usepackage{doxygen}".
Add the line "\begin{CJK*}{GB}{song}" after "\begin{document}"
Add the line "\end{CJK*} before \end{document}

and run latex refman.tex you will the refman.dvi that supports chinese.

Using Apache2 SSL in Debian

2007-01-19T17:34:00.000+08:00

If you have virtualhost define.
first add a listen port to port.conf
Listen 80
Listen 443 --- new line
second add a virtualhost name in apache2.conf
VirtualHost *:80
VirtualHost *:433 --- new line
third add a virtual host to your virtual host define for example a tootoosoft_com file in sites-available directory.
copy original virtualhost definition and modify the name from *:80 to *:443
add
SSLEngine on
SSLCertificateFile /etc/apache2/ssl/apache.pem

restart apache. test any page just replace url http to https

this link has some detail info.
http://www.debian-administration.org/articles/349

Install Apache2 with mod_ssl

2007-01-17T14:50:00.000+08:00

在apache2中SSL的支持已经内置，不需要再单独现在MOD SSL这个软件了。那么只需要编译这个DSO就可以了，apache中支持DSO的方法就是调用动态库没有什么奇招。那么编译的时候 --enable-so --enable-ssl=static 用static可以将openssl的函数编译到mod_ssl中这样一旦openssl的动态库不在也可以使用。并且openssl有的安装默认是不编译动态库的，比较谨慎。
当然还需要创建服务器端的SSL证书和私钥。可以通过一个工具在http://www.openssl.org/contrib/ssl.ca-0.1.tar.gz
解压缩然后首先生成 ROOT CA的自签发证书和ROOT CA的私钥，然后再生成服务器证书请求和服务器私钥，通过ROOT CA进行服务器证书的签发。然后将服务器证书和私钥复制到合适路径这些文件的路径要在http.conf中明确表示。
http conf一般通过打开 http-ssl conf注释来引用ssl的配置信息。那么检查该配置文件，确认你的证书都能被他找到。

Reinstall Apache2

2007-01-17T14:42:00.000+08:00

当你已经安装一个apache2 ，比如目录/usr/local/apache2.你是不能够再从源码编译Apache2的.为什么呢，因为Apache2的configure中做了判断,它会search $lookdir 其中就包含了 /usr/local/apache2 你只需要把它放到一个不是$lookdir覆盖的目录就可以了.lookdir是configure里面指定的一组目录.现在包含 /usr /usr/local /usr/local/apr /opt/apr /usr/local/apache2

Install Apache2 Mysql PHP XOOPS from scrible

2007-01-17T10:51:00.000+08:00

1) install mysql
configure --prefix=/usr/lcoal/mysql/
make
make install
mysql_install_db

mysqld_safe
(check the mysql user add, adduser mysql)

change root password for mysql, default root password is nothing
mysqladmin -u root password "newpassword"

login test
mysqladming -uroot -pxxx mysql

2) install apache2
configure --prefix=/usr/local/apache2/ --enable-so --enable-mods-shared=most
make
make install

3) install php
configure --prefix=/usr/local/php/ --with-mysql=/usr/local/mysql --with-apxs2=/usr/local/apache2/bin/apxs --with-gd --enable-gd-native-ttf --with-ttf --with-gettext --with-iconv --with-png --with-zlib --with-xml --enable-calendar
make
make install
it will modify the httpd.conf ucomment line

LoadModule php4_module modules/libphp4.so

4) apache2 config
edit http.conf add the following two lines in the section mime_module

...
AddType application/x-httpd-php .php
AddType application/x-httpd-php-source .phps
...

5) XOOPS
copy xoops/html/* to htdocs (apache DocumentRoot)
chmod 777 cache
chmod 777 template_c
chmod 777 mainfile.php
chmod 777 uploads
create database xoops in mysql
firefox browse the root http://localhost/
than in the wizard you will get next->next->next ...

Remove "wintems.exe" trojan manually - 2

2007-01-14T10:18:00.000+08:00

删除了wintems之后，但是还是不行，经常能看到iexplore经常自己启动，我正在操作得软件也经常失去焦点。这是怎么回事肯定是什么软件，启动iexplorer。待我慢慢寻之。

Remove "wintems.exe" trojan manually

2007-01-14T08:13:00.000+08:00

很久以来，我都没有使用杀毒软件，一旦发现系统变慢，我就观察是否有中毒。这几天在写一些VC的程序的时候，经常失去自己键盘的焦点，很是恼火，原来是系统中了一个 wintems.exe 的Trojan。这个东西会导致iexplore干一些事情，我在系统刚刚启动的时候执行了 ethereal抓到了无数的自动访问 xxxx N多的网站。简直是疯狂。决定手动干掉它，因为各种杀毒软件实在是太笨，并且特别耗资源，我这个机器只有300多M的内存， PIII的CPU，我一直让他保持20个以内的进程运行，所以一旦有什么异样，我能立刻发现，并且干掉它。

检查你的进程列表如果有 wintem.exe 那么很荣幸，你中着了。然后再检查注册表 regedit.exe，看HKCU\SOFTWARE\DateTimeN，N可能是1，2，3，4之类的数字，那么说明你正在中招。干掉它。每个机器的感染现象不一样，所以杀毒软件是不一定能解决问题的，得通过你的观察。

我得iexplore一定是被注入东西了，经常无缘无故得自己运行，所以需要换一个干净得。然后wintems这个进程一定要停止调。

下次再写详细得手动杀毒步骤，但是这未必适合你，因为我们中得毒和系统得环境都不同，处于病毒得变化状态也不相同，所以不变得使用我得方法未必有效，但是这个杀毒得方法还是可以得，需要点时间，但是我觉得比杀毒软件在自己得机器上漫无目的瞎搞要好得多。

Using apache2 VirtualHost in Debian

2007-01-11T10:17:00.000+08:00

In Debian apache2's config file is /etc/apache/apache2.conf

The botom line in the config file "Include /etc/apache2/sites-enabled/". That means apache2 will use the file in the directory as virtualhost.
Goto the directory you will find nothing or a symbolic file "000-default". It is OK. Actually the virtualhost config in the directory "/etc/apache2/sites-available".

For example you want add a virtual host named tootoosoft.com to the existing apache. Now create a file in the /etc/apache2/sites-available/ named tootoosoft_com (anything is ok). edit it just like following:

NameVirtualHost *

ServerName www.tootoosoft.com

DocumentRoot /var/www/tootoosoft_com

Options FollowSymLinks
AllowOverride None

Options Indexes FollowSymLinks MultiViews
AllowOverride None
Order allow,deny
allow from all

LogLevel warn

CustomLog /var/log/apache2/access.log combined
ServerSignature On

NameHost *, the * means any IP interface in the host.
then create a symbolic "/etc/apache2/sites-enabled"
# ln -sf /etc/apache2/sites-available/tootoosoft_com /etc/apache2/sites-enabled/tootoosoft_com

Restart apache2
#/etc/init.d/apache restart

If you want add more just create file in sites-available and create symbolic file in sites-enabled and restart apache you will get it.

Using Libjingle

2007-01-06T23:27:00.000+08:00

Libjingle give us a selection to develop a p2p voice tools. You certainly can select a commercial Voice Engine (GIPS) but the ICE and the framework is still very important. It token me three days to develop a Linux p2p ip phone based libjingle and GTK2. It is very interesting but if you want to build a solution. Libjingle is not enough. More is your business.

Asterisk release 1.4.0

2007-01-06T23:19:00.000+08:00

Asterisk the open source PBX but hardware not :). It is really a good idea to sale the compatible interface card. But the LIBPRI, chan-ss7 and some related open source project is very interesting .

http://www.asterisk.org

If you want to get a open source ss7 implementation the chan-ss7 is a good begining better than openss7 (it is not really open because I can not see it is valid code).

http://www.sifira.dk/chan-ss7/

the latest version 0.8.4.

OpenH323 status

2007-01-06T23:12:00.000+08:00

It is long time I had not take time on researching the project. It's major site has not updated since 2004. SF has the latest.

http://sourceforge.net/projects/openh323

My DOT EMACS .emacs support chinese fontset emacs23

2007-01-06T20:15:00.000+08:00

(set-language-environment 'Chinese-GB)
(set-keyboard-coding-system 'euc-cn)
(set-clipboard-coding-system 'euc-cn)
(set-terminal-coding-system 'euc-cn)
(set-buffer-file-coding-system 'euc-cn)
(set-selection-coding-system 'euc-cn)
(modify-coding-system-alist 'process "*" 'euc-cn)
(setq default-process-coding-system
'(euc-cn . euc-cn))
(setq-default pathname-coding-system 'euc-cn)
(tool-bar-mode nil)
(menu-bar-mode nil)
(scroll-bar-mode nil)
(global-font-lock-mode t)
(transient-mark-mode t)
(display-time)
(column-number-mode t)
(show-paren-mode t)
(fset 'yes-or-no-p 'y-or-n-p)
(setq visible-bell t)
;(setq lazy-lock-defer-on-scrolling t)
;(setq font-lock-support-mode 'lazy-lock-mode)
;(setq font-lock-maximum-decoration t)
(setq-default indent-tabs-mode nil)
;(highlight-current-line-on t)
;(highlight-current-line-set-bg-color "sea green")
;(highlight-current-line-set-bg-color "light green")

(add-hook 'c-mode-hook 'linux-c-mode)
(add-hook 'c++-mode-hook 'linux-cpp-mode)
;; imenu
(setq imenu-sort-function 'imenu--sort-by-name)
(defun linux-c-mode()
(define-key c-mode-map [return] 'newline-and-indent)
(interactive)
(c-set-style "K&R")
(c-toggle-auto-state)
(c-toggle-hungry-state)
(setq c-basic-offset 8)
(imenu-add-menubar-index)
(which-function-mode)
)
(defun linux-cpp-mode()
(define-key c++-mode-map [return] 'newline-and-indent)
(define-key c++-mode-map [(control c) (c)] 'compile)
(interactive)
(c-set-style "K&R")
(c-toggle-auto-state)
(c-toggle-hungry-state)
(setq c-basic-offset 8)
(imenu-add-menubar-index)
(which-function-mode)
)

(setq inhibit-startup-message t)

(setq font-encoding-alist
(cons '("gb2312.1980" . chinese-gbk) font-encoding-alist))

(create-fontset-from-fontset-spec
"-*-fixed-medium-r-*-*-20-*-*-*-*-*-fontset-chinese,
chinese-gb2312:-default-song-medium-r-*--*-*-*-*-*-*-gb2312.1980-0" t)

(setq default-frame-alist
(append
'((font . "fontset-chinese"))
default-frame-alist))

Install Emacs23 with antialias

2007-01-06T17:58:00.000+08:00

Check out the latest EMACS23

#cvs -d :pserver:anonymous@cvs.savannah.gnu.org:/sources/emacs co emacs
#cd emacs
#./configure --with-xft=yes --with-x-toolkit=gtk --with-gtk=yes
#make bootstrap
In the step you will get many errors. just edit your emacs/src/Makefile add the cairo and glib include directory. Using pkg-config to find. Run pkg-config --cflags gtk+-2.0 you will find "-I/usr/include/gtk-2.0 -I/usr/lib/gtk-2.0/include -I/usr/include/atk-1.0 -I/usr//include/cairo -I/usr/include/pango-1.0 -I/usr/include/glib-2.0 -I/usr/lib/glib-2.0/include". Check the line in Makefile add the miss cairo and glib include directory. save the file(if using vi you will get the read only file just type :x!).

#make; make install

Compile GTK+ with Cairo

2007-01-06T17:45:00.000+08:00

Get latest cairo distribution from http://cairographics.org/. Get latest gtk lib from http://www.gtk.org including glib pango and gtk. You also need the latest libpng atk and latest pkg-config.

First compile pkg-config and install it. you can set pkg-config search path using PKG_CONFIG_PATH. pkg-config use this enviroment variable to search the directory find the installed package. Every pacage want to be managed by pkg-config has a .pc file that indicate what details information related the package.

Then compile libpng and install it.

Then compile glib and isntall it.

Then compile cario and install it.

Then pango make sure pango prompt you it using XFT and Cairo to render.

Then gtk+. If you have any trouble, please let me known I will try it and modify this notes.

使用graphviz

2007-01-03T17:43:00.000+08:00

一直有个任务，没有去完成，每次惭愧的时候都挤出一点时间来考虑一下，但是东东西西的零散开去，没有积累。看到这个东西，或者可以用用。

http://www.graphviz.org/
http://www-128.ibm.com/developerworks/cn/linux/l-graphvis/?ca=dwcn-newsletter-linux
http://www-128.ibm.com/developerworks/linux/library/l-graphvis/
http://www.blogjava.net/cap/archive/2005/07/17/7895.aspx

使用 GSM LIB 发送中文短信

2007-01-03T16:35:00.001+08:00

这也是我早些年写的一个文章,这里面用的email地址因为每年都需要收费,不交费就停,这点钱到算不了什么关键是交起来太麻烦,忘了交就给我停了,后来就干脆不用了,有了gmail就更不需要了,但是地震一下感到还得使用本土的服务比较可靠. 呵呵.

使用GSMlib发送中文短信
dingguijin@21cn.com
GSMlib是访问GSM modem的库, 因此能访问相应的mobile phone. 它的主站点:
http://www.pxh.de/fs/gsmlib/
如果你有如下之一的设备, 那么你就可以通过串口或者红外基于GSMlib来控制你的设备.
• Nokia 6150/Xircom REM56G.100
• Nokia 6150/Options "GSM-Ready(R) Cellular-Only" modem from Option International
• Nokia 8810/- (Linux IrDA serial device)
• Siemens S10D/Dr Neuhaus Gipsy Card GSM
• Siemens S25/- (Linux IrDA serial device)
• Siemens S35i/- (Linux IrDA serial device)
• Ericcson SH888/- (Linux IrDA serial device)
• Ericsson 6050102/GM 12 GSM module
• Siemens M20T/- (stand-alone GSM module)
• Wavecom WM02 GSM/- (stand-alone GSM module)
• Nokia 7110 (firware rev 4.80)/- (Linux IrDA serial device)
• Nokia 8290 (USA GSM 1900MHz)/- (Linux IrDA serial device)
• Falcom A2-1/- (stand-alone GSM module)
• Ericsson R320s/- (Linux IrDA serial device)
• Motorola Timeport 260/- (Serial cable and Linux IrDA serial device)
• Motorola Timeport 250/- (Linux IrDA serial device)
在这里面我用过Wavecom WM02 的GSM modem, 成功发送中文短信.
由于在短信息中对于多字节字符采用的是Unicode 编码(编码的意思就是文字的数据形式, 文字是人可以阅读的; 而计算机, 网络传输使用的是数据, 进行通讯的设备达成一个统一, 说0xbb 0xcc 表示某某一个文字, 其中有一种统一叫做Unicode, 叫这个名字的原因是它自认为懂得全世界的语言, 简体中文和繁体中文的文字的相当一部分被包含进来了, 所以手机上的文字是简体繁体可以同在一起显示, 不象桌面计算机了), 而在一般的桌面机器上的简体汉字都是GB2312的编码, 所以我们把它转成Unicode, 在linux中叫做multi char to wide char
多字节字转成宽字节字, 然后再将宽字转成网络顺序, 发送OK. 简单的过程也有几个陷阱.这是我的发送程序, 使用串口连接的wavecom 的 GSM modem.
try {
// handle command line options
// 你的设备连接到了什么上
string device = "/dev/ttyS0";
//速率是多少
string baudrate = "19200";
string initString = DEFAULT_INIT_STRING;
//你想发给谁?
string phoneNumber = “13910180xxx”;
bool swHandshake = false;
bool requestStatusReport = false;
//这是断消息中心
string serviceCentreAddress = "+8613800100500";

//发送的内容
char gbc[200] = “我们都是神枪手”;
wchar_t utf8c[100];
int wcsize;
int i;

//下面的这个函数是依赖你的locale的设定的, 这样它就知道原始的编码是什么了
//当然也可以在程序中显示的设置locale为zh_CN.GB2312
mbstowcs(utf8c, gbc, strlen(gbc));
wcsize = wcslen(utf8c);
string text;
for(i = 0; i < wcsize; i++) {
utf8c[i] = htons(utf8c[i]);
//只用插入才能是wchar_t的东西放到string类的对象中, 因为直接赋值, 会有零, 你于是只能发送一个汉字. 在C++中也有wstring 不过gsmlib没有用它呀
text.insert(2*i, (char*)&utf8c[i], 2);
}

Ref at;
// open the port and ME/TA
Ref port = new UnixSerialPort (device, baudRateStrToSpeed(baudrate), initString, swHandshake);
// switch message service level to 1
// this enables acknowledgement PDUs
MeTa m(port);

m.setMessageService(1);
at = new GsmAt(m);
// send SMS
Ref submitSMS = new SMSSubmitMessage(text, phoneNumber);
// set service centre address in new submit PDU if requested by user
submitSMS->setDataCodingScheme(DataCodingScheme(DCS_SIXTEEN_BIT_ALPHABET));
//submitSMS->setUserData(text);
Address sca(serviceCentreAddress);
submitSMS->setServiceCentreAddress(sca);
submitSMS->setStatusReportRequest(requestStatusReport);
submitSMS->setAt(at);

Ref ackPDU;
submitSMS->send(ackPDU);
// print acknowledgement if available
if (! ackPDU.isnull())
cout <<>toString();
} catch (GsmException &ge) {
cerr << argv[0] << _("[ERROR]: ") << ge.what() << endl;
exit(1);
}

Makefile 里面要连接正确的库, 我没有把gsmlib安装, 只编译了一下.
all: smsd smssend

gsmlibdir = /root/gsmlib-1.9
gsmliblibsdir = $(gsmlibdir)/gsmlib/.libs

cflags = -c -g -Wall -I $(gsmlibdir)
ldflags = --static -L $(gsmliblibsdir) -lgsmme

smsd_objs = smsd.o
smssend_objs = smssend.o

smsd : $(smsd_objs)
g++ $(ldfalgs) -o $@ $^ $(ldflags)
smssend : $(smssend_objs)
g++ $(ldfalgs) -o $@ $^ $(ldflags)
%.o:%.cc
g++ $(cflags) $<

.PHONY:clean
clean:
rm -f *~ *.o smsd smssend core

使用OpenH323开发VOIP程序

2007-01-03T16:30:00.000+08:00

这是我早些年写的一片文章,当时花了挺多的时间,写了很多可是当时的LinuxByte不能一次上传那么多内容导致现在网上流传的都是少了一部份的版本,那么现在我把它找回来,我这两天有时间把它补全,再看看OpenH323的工程有什么新的动向了,以前看OPAL说统一了H323和SIP的接口应该是个好事情,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 \"" <<>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 "
<<>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 "
<<>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("%04i%02i%02i_%02i%02i%02i", 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

It is google blog system?

2007-01-03T16:05:00.000+08:00

我发现这里面有我多年以前申请的BLOG，就是访问速度太慢了，浪费时间于是就在申请后，再也没有关注过。但是今天不一样了，它属于GOOGLE了，也许会快一些吧，由于我接触的技术范围很广，但是不是很泛泛的意思，可能就是跳跃性比较强的意思吧，最初就是打算收集一些我自己在当时的一些理解，所以申请了那个BLOG。现在的考虑也是包括这个意思，只不过自从10月份辞职以来时间就从容了许多，也许在GOOGLE的大树下我能乘凉一下----把我经历的一些技术问题和所有人分享，节省大家的时间我想也是在创造价值吧。