sip-lab 1.10.0 → 1.11.0

package/README.md

@@ -5,6 +5,12 @@
 A nodejs module that helps to write functional tests for SIP systems (including media operations).
 It uses pjproject for SIP and media processing.
 
+It permits to:
+  - send and receive DTMF inband/RFC2833/INFO.
+  - play/record wav file on a call
+  - send/receive fax (T.30 only)
+
+
 ### Installation
 
 This will require for you to have some libraries installed. So do:
@@ -24,26 +30,34 @@ Then install sip-lab by doing:
   npm install sip-lab
 ```
 
-However, since it takes a long time to fetch and build pjproject and the node addon for it, you could install sip-lab globally:
+To test from within this repo just build and install by doing:
 ```
-  npm install -g sip-lab
+  npm install -g node-gyp
+  npm install --unsafe-perm
 ```
-
-But if you do so, you will need to set NODE_PATH for node to find it by doing:
+And run some sample script from subfolder samples:
 ```
-  export NODE_PATH=$(npm root --quiet -g)
+  node samples/simple.js
 ```
 
-To test from within this repo just run:
+The module is known to work properly in Ubuntu 18.04.4, Ubuntu 20.04.4, Debian 8 and Debian 10 (and it is expected to work in Debian 9).
+It was originally developed with node v.10 and tested with v.12 and it is expected to work with latest versions of node.
+(it is known to not work with node v.8)
+
+
+Since running
 ```
-  npm install -g node-gyp
-  npm install --unsafe-perm
+npm install sip-lab
+```
+takes some time to fetch and build pjproject and the node addon for it, you could install sip-lab globally:
 
-  node samples/simple.js
+```
+  npm install -g sip-lab
 ```
 
-The module is known to work properly in Ubuntu 18.04.4, Debian 8 and Debian 10 (and it is expected to work in Debian 9).
-It was originally developed with node v.10 and tested with v.12 and it is expected to work with latest versions of node.
-(it is known to not work with node v.8)
+But if you do so, you will need to set NODE_PATH for node to find it by doing:
+```
+  export NODE_PATH=$(npm root --quiet -g)
+```
 
 

package/binding.gyp

@@ -14,6 +14,7 @@
         'src/pjmedia/src/chainlink/chainlink_wav_player.c',
         'src/pjmedia/src/chainlink/chainlink_wav_writer.c',
         'src/pjmedia/src/chainlink/chainlink_wire_port.c',
+        'src/pjmedia/src/chainlink/chainlink_fax.c',
       ],
       'include_dirs': [
         "pjproject/pjsip/include",

package/index.js

@@ -59,6 +59,8 @@ addon.call = {
   start_playing: addon.call_start_play_wav,
   stop_recording: addon.call_stop_record_wav,
   stop_playing: addon.call_stop_play_wav,
+  start_fax: addon.call_start_fax,
+  stop_fax: addon.call_stop_fax,
   get_stream_stat: addon.call_get_stream_stat,
   refer: addon.call_refer,
   get_info: addon.call_get_info,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sip-lab",
-  "version": "1.10.0",
+  "version": "1.11.0",
   "description": "",
   "main": "index.js",
   "engines": {

package/samples/send_and_receive_fax.js

@@ -0,0 +1,143 @@
+var sip = require ('../index.js')
+var Zester = require('zester')
+var z = new Zester()
+var m = require('data-matching')
+var sip_msg = require('sip-matching')
+
+async function test() {
+    //sip.set_log_level(6)
+    sip.dtmf_aggregation_on(500)
+
+    z.trap_events(sip.event_source, 'event', (evt) => {
+        var e = evt.args[0]
+        return e
+    })
+
+    console.log(sip.start((data) => { console.log(data)} ))
+
+    t1 = sip.transport.create("127.0.0.1", 5090, 1)
+    t2 = sip.transport.create("127.0.0.1", 5092, 1)
+
+    console.log("t1", t1)
+    console.log("t2", t2)
+
+    flags = 0
+
+    oc = sip.call.create(t1.id, flags, 'sip:a@t', 'sip:b@127.0.0.1:5092')
+
+    await z.wait([
+        {
+            event: "incoming_call",
+            call_id: m.collect("call_id"),
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '100',
+                $rr: 'Trying',
+                '$(hdrcnt(via))': 1,
+                '$hdr(call-id)': m.collect('sip_call_id'),
+                $fU: 'a',
+                $fd: 't',
+                $tU: 'b',
+                '$hdr(l)': '0',
+            }),
+        },
+    ], 1000)
+
+    ic = {
+        id: z.store.call_id,
+        sip_call_id: z.store.sip_call_id,
+    }
+
+    sip.call.respond(ic.id, 200, 'OK')
+
+    await z.wait([
+        {
+            event: 'media_status',
+            call_id: oc.id,
+            status: 'setup_ok',
+            local_mode: 'sendrecv',
+            remote_mode: 'sendrecv',
+        },
+        {
+            event: 'media_status',
+            call_id: ic.id,
+            status: 'setup_ok',
+            local_mode: 'sendrecv',
+            remote_mode: 'sendrecv',
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'INVITE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+                '$(hdrcnt(VIA))': 1,
+                $fU: 'a',
+                $fd: 't',
+                $tU: 'b',
+                '$hdr(content-type)': 'application/sdp',
+                $rb: '!{_}a=sendrecv',
+            }),
+        },
+    ], 1000)
+
+    await z.sleep(1000)
+
+    var is_sender = true
+
+    sip.call.start_fax(oc.id, is_sender, 'samples/fax_doc.tiff')
+    await z.sleep(100)
+    sip.call.start_fax(ic.id, !is_sender, 'received.tiff')
+
+    await z.wait([
+        {
+            event: 'fax_result',
+            call_id: oc.id,
+            result: 0,
+        },
+        {
+            event: 'fax_result',
+            call_id: ic.id,
+            result: 0,
+        },
+    ], 60 * 1000)
+
+    sip.call.terminate(oc.id)
+
+    await z.wait([
+        {
+            event: 'call_ended',
+            call_id: oc.id,
+        },
+        {
+            event: 'call_ended',
+            call_id: ic.id,
+        },
+        {
+            event: 'response',
+            call_id: oc.id,
+            method: 'BYE',
+            msg: sip_msg({
+                $rs: '200',
+                $rr: 'OK',
+            }),
+        },
+    ], 1000)
+
+    console.log("Success")
+
+    sip.stop()
+}
+
+
+test()
+.catch(e => {
+    console.error(e)
+    process.exit(1)
+})
+

package/src/addon.cpp

@@ -669,6 +669,47 @@ Napi::Value call_start_play_wav(const Napi::CallbackInfo& info) {
   return env.Null();
 }
 
+Napi::Value call_start_fax(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 3) {
+    Napi::Error::New(env, "Wrong number of arguments. Expected: call_id, is_sender, file]").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "call_id must be number.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int call_id = info[0].As<Napi::Number>().Int32Value();
+
+  if (!info[1].IsBoolean()) {
+    Napi::TypeError::New(env, "is_sender must be boolean.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  bool is_sender = info[1].As<Napi::Boolean>().Value();
+
+  if (!info[2].IsString()) {
+    Napi::TypeError::New(env, "file must be string.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  string file = info[2].As<Napi::String>().Utf8Value();
+
+  if (file.length() == 0) {
+    Napi::Error::New(env, "input_file is invalid (blank string)").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  int res = pjw_call_start_fax(call_id, is_sender, file.c_str());
+
+  if(res != 0) {
+    Napi::Error::New(env, pjw_get_error()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return env.Null();
+}
+
 Napi::Value call_stop_record_wav(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -717,6 +758,30 @@ Napi::Value call_stop_play_wav(const Napi::CallbackInfo& info) {
   return env.Null();
 }
 
+Napi::Value call_stop_fax(const Napi::CallbackInfo& info) {
+  Napi::Env env = info.Env();
+
+  if (info.Length() != 1) {
+    Napi::Error::New(env, "Wrong number of arguments. Expected: call_id").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  if (!info[0].IsNumber()) {
+    Napi::TypeError::New(env, "call_id must be number.").ThrowAsJavaScriptException();
+    return env.Null();
+  }
+  int call_id = info[0].As<Napi::Number>().Int32Value();
+
+  int res = pjw_call_stop_fax(call_id);
+
+  if(res != 0) {
+    Napi::Error::New(env, pjw_get_error()).ThrowAsJavaScriptException();
+    return env.Null();
+  }
+
+  return env.Null();
+}
+
 Napi::Value call_get_stream_stat(const Napi::CallbackInfo& info) {
   Napi::Env env = info.Env();
 
@@ -1381,8 +1446,10 @@ Napi::Object init(Napi::Env env, Napi::Object exports) {
   exports.Set("call_send_request", Napi::Function::New(env, call_send_request));
   exports.Set("call_start_record_wav", Napi::Function::New(env, call_start_record_wav));
   exports.Set("call_start_play_wav", Napi::Function::New(env, call_start_play_wav));
+  exports.Set("call_start_fax", Napi::Function::New(env, call_start_fax));
   exports.Set("call_stop_record_wav", Napi::Function::New(env, call_stop_record_wav));
   exports.Set("call_stop_play_wav", Napi::Function::New(env, call_stop_play_wav));
+  exports.Set("call_stop_fax", Napi::Function::New(env, call_stop_fax));
   exports.Set("call_get_stream_stat", Napi::Function::New(env, call_get_stream_stat));
   exports.Set("call_refer", Napi::Function::New(env, call_refer));
   exports.Set("call_get_info", Napi::Function::New(env, call_get_info));

package/src/event_templates.cpp

@@ -53,3 +53,7 @@ int make_evt_registration_status(char *dest, int size, long account_id, int code
 	return snprintf(dest, size, "{\"event\": \"registration_status\", \"account_id\": %i, \"code\": %i, \"reason\": \"%s\", \"expires\": %i}", account_id, code, reason, expires);
 }
 
+int make_evt_fax_result(char *dest, int size, long call_id, int result) {
+   return snprintf(dest, size, "{\"event\": \"fax_result\", \"call_id\": %i, \"result\": %i}", call_id, result);
+}
+

package/src/event_templates.hpp

@@ -22,6 +22,8 @@ int make_evt_internal_error(char *dest, int size, char *msg);
 
 int make_evt_registration_status(char *dest, int size, long account_id, int code, char *reason, int expires);
 
+int make_evt_fax_result(char *dest, int size, long call_id, int result);
+
 #endif
 
 

package/src/pjmedia/Makefile

@@ -18,7 +18,7 @@ all: libchainlink.a
 
 #libchainlink.a: chainlink_wire_port.o chainlink_dtmfdet.o chainlink_tonegen.o chainlink_wav_player.o
 #libchainlink.a: chainlink_wire_port.o chainlink_dtmfdet.o chainlink_tonegen.o
-libchainlink.a: chainlink_wire_port.o chainlink_dtmfdet.o chainlink_wav_player.o chainlink_wav_writer.o chainlink_tonegen.o
+libchainlink.a: chainlink_wire_port.o chainlink_dtmfdet.o chainlink_wav_player.o chainlink_wav_writer.o chainlink_tonegen.o chainlink_fax.o
 	ar rcs $@ $^
 
 chainlink_wire_port.o: 
@@ -31,6 +31,8 @@ chainlink_wav_writer.o:
 
 chainlink_tonegen.o:
 
+chainlink_fax.o:
+
 clean:
 	rm -f *.o
 	rm -f *.a

package/src/pjmedia/include/chainlink/chainlink_fax.h

@@ -0,0 +1,25 @@
+#ifndef __CHAINLINK_FAX_H__
+#define __CHAINLINK_FAX_H__
+
+#include <pjmedia/port.h>
+
+PJ_BEGIN_DECL
+
+PJ_DECL(pj_status_t) chainlink_fax_port_create( pj_pool_t *pool,
+                unsigned clock_rate,
+                unsigned channel_count,
+                unsigned samples_per_frame,
+                unsigned bits_per_sample,
+                void (*cb)(pjmedia_port*,
+                    void *user_data,
+                    int result),
+                void *user_data,
+                int is_caller,
+                int is_sender,
+                const char *file,
+                pjmedia_port **p_port);
+
+
+PJ_END_DECL
+
+#endif	/* __CHAINLINK_FAX_H__ */

package/src/pjmedia/src/chainlink/chainlink_fax.c

@@ -0,0 +1,274 @@
+#include "chainlink.h"
+#include "chainlink_fax.h"
+
+#include <pjmedia/errno.h>
+#include <pjmedia/port.h>
+#include <pj/assert.h>
+#include <pj/lock.h>
+#include <pj/pool.h>
+#include <pj/string.h>
+
+#define SPANDSP_EXPOSE_INTERNAL_STRUCTURES
+#include <spandsp.h>
+
+#define SIGNATURE   PJMEDIA_SIGNATURE('L', 'f', 'a', 'x')
+#define THIS_FILE   "chainlink_fax.c"
+
+#if 0
+#   define TRACE_(expr)	PJ_LOG(4,expr)
+#else
+#   define TRACE_(expr)
+#endif
+
+#define FAX_DATA_CHUNK 320
+#define T38_DATA_CHUNK 160
+
+
+enum
+{
+    /*! No compression */
+    T30_SUPPORT_NO_COMPRESSION = 0x01,
+    /*! T.1 1D compression */
+    T30_SUPPORT_T4_1D_COMPRESSION = 0x02,
+    /*! T.4 2D compression */
+    T30_SUPPORT_T4_2D_COMPRESSION = 0x04,
+    /*! T.6 2D compression */
+    T30_SUPPORT_T6_COMPRESSION = 0x08,
+    /*! T.85 monochrome JBIG compression */
+    T30_SUPPORT_T85_COMPRESSION = 0x10,
+    /*! T.43 colour JBIG compression */
+    T30_SUPPORT_T43_COMPRESSION = 0x20,
+    /*! T.45 run length colour compression */
+    T30_SUPPORT_T45_COMPRESSION = 0x40,
+    /*! T.81 + T.30 Annex E colour JPEG compression */
+    T30_SUPPORT_T81_COMPRESSION = 0x80,
+    /*! T.81 + T.30 Annex K colour sYCC-JPEG compression */
+    T30_SUPPORT_SYCC_T81_COMPRESSION = 0x100,
+    /*! T.88 monochrome JBIG2 compression */
+    T30_SUPPORT_T88_COMPRESSION = 0x200
+};
+
+
+static pj_status_t fax_get_frame(pjmedia_port *this_port, 
+					pjmedia_frame *frame);
+static pj_status_t fax_put_frame(pjmedia_port *this_port, 
+				  pjmedia_frame *frame);
+static pj_status_t fax_on_destroy(pjmedia_port *this_port);
+
+struct fax_device
+{
+	struct chainlink link;
+	fax_state_t fax;
+	void (*fax_cb)(pjmedia_port*, void*, int);
+	void *fax_cb_user_data;
+	int is_caller;
+	int is_sender;
+
+    pj_lock_t	       *lock;
+};
+
+static int phase_b_handler(t30_state_t* s, void* user_data, int result)
+{
+	printf("fax phase_b_handler user_data=%p result=%i\n", user_data, result);
+    return T30_ERR_OK;
+}
+
+static int phase_d_handler(t30_state_t* s, void* user_data, int result)
+{
+	printf("fax phase_b_handler user_data=%p result=%i\n", user_data, result);
+    return T30_ERR_OK;
+}
+
+static void phase_e_handler(t30_state_t* s, void* user_data, int result)
+{
+	printf("fax phase_e_handler user_data=%p result=%i\n", user_data, result);
+
+    if (!user_data) {
+        printf("not user_data\n");    
+        return;
+    }
+
+    struct fax_device *fd = (struct fax_device*)user_data;
+	if(!fd->fax_cb) {
+        printf("not fax_cb\n");
+        return;
+    }
+
+    printf("sending result event\n");
+	fd->fax_cb((pjmedia_port*)fd, fd->fax_cb_user_data, result);
+}
+
+static int document_handler(t30_state_t* s, void* user_data, int result)
+{
+	printf("fax document_handler user_data=%p result=%i\n", user_data, result);
+
+    if (!user_data) return 0;
+
+    struct fax_device *fd = (struct fax_device*)user_data;
+	if(!fd->fax_cb) return 0;
+
+	//fd->fax_cb((pjmedia_port*)fd, fd->fax_cb_user_data, result);
+
+    return 0;
+}
+
+PJ_DEF(pj_status_t) chainlink_fax_port_create( pj_pool_t *pool,
+				unsigned clock_rate,
+				unsigned channel_count,
+				unsigned samples_per_frame,
+				unsigned bits_per_sample,
+				void (*cb)(pjmedia_port*, 
+					void *user_data, 
+					int result), 
+				void *user_data,
+				int is_caller,
+				int is_sender,
+				const char *file,
+				pjmedia_port **p_port)
+{
+    struct fax_device *fd;
+    const pj_str_t name = pj_str("fax_device");
+
+    PJ_ASSERT_RETURN(pool && clock_rate && channel_count && 
+		     samples_per_frame && bits_per_sample == 16 && 
+		     p_port != NULL, PJ_EINVAL);
+
+    PJ_ASSERT_RETURN(pool && p_port, PJ_EINVAL);
+
+    fd = PJ_POOL_ZALLOC_T(pool, struct fax_device);
+    PJ_ASSERT_RETURN(pool != NULL, PJ_ENOMEM);
+
+    pjmedia_port_info_init(&fd->link.port.info, &name, SIGNATURE, clock_rate,
+			   channel_count, bits_per_sample, samples_per_frame);
+
+    fd->link.port.get_frame = &fax_get_frame;
+    fd->link.port.put_frame = &fax_put_frame;
+    fd->link.port.on_destroy = &fax_on_destroy;
+
+	fax_init(&fd->fax, is_caller);
+	//fax_set_transmit_on_idle(&fd->fax,1);
+
+	t30_state_t *t30 = fax_get_t30_state(&fd->fax);
+
+	span_log_set_level(fax_get_logging_state(&fd->fax), SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
+	span_log_set_level(t30_get_logging_state(t30), SPAN_LOG_SHOW_SEVERITY | SPAN_LOG_SHOW_PROTOCOL | SPAN_LOG_FLOW);
+
+	char ident[] = "chainlink_fax";
+
+    t30_set_tx_ident(t30, ident);
+    t30_set_phase_b_handler(t30, &phase_b_handler, (void*)fd);
+    t30_set_phase_d_handler(t30, &phase_d_handler, (void*)fd);
+	t30_set_phase_e_handler(t30, &phase_e_handler, (void*)fd);
+    //printf("setting document_handler with user_data=%p\n", (void*)fd);
+	t30_set_document_handler(t30, &document_handler, (void*)fd);
+
+	fd->is_caller = is_caller;
+	fd->is_sender = is_sender;
+
+	pj_status_t status = pj_lock_create_simple_mutex(pool, "fax", &fd->lock);
+
+    if (status != PJ_SUCCESS) {
+		printf("failed to create lock\n");
+		return status;
+    }
+
+    if (is_sender)
+		t30_set_tx_file(t30,file,-1,-1);
+    else
+		t30_set_rx_file(t30,file,-1);
+
+    t30_set_ecm_capability(t30,1);
+    t30_set_supported_compressions(t30,T30_SUPPORT_T4_1D_COMPRESSION |
+        T30_SUPPORT_T4_2D_COMPRESSION | T30_SUPPORT_T6_COMPRESSION);
+
+	fax_set_transmit_on_idle(&fd->fax, 1);
+
+    fd->fax_cb = cb;
+    fd->fax_cb_user_data = user_data;
+
+    TRACE_((THIS_FILE, "fax_device created: %u/%u/%u/%u", clock_rate, 
+	    channel_count, samples_per_frame, bits_per_sample));
+
+    *p_port = &fd->link.port; 
+    return PJ_SUCCESS;
+}
+
+// called when pjmedia needs data to be sent out
+static pj_status_t fax_get_frame(pjmedia_port *this_port,
+					pjmedia_frame *frame) {
+
+	//printf("ENTER fax_get_frame frame_size=%i\n", frame->size);
+
+	PJ_ASSERT_RETURN(this_port && frame, PJ_EINVAL);
+	char *p = (char*)frame->buf;
+
+	struct fax_device *fd = (struct fax_device*)this_port;
+    pj_lock_acquire(fd->lock);
+
+	int tx = 0;
+
+	if ((tx = fax_tx(&fd->fax, (int16_t *)frame->buf, frame->size/2)) < 0) {
+		printf("fax_tx reported an error\n");
+		pj_lock_release(fd->lock);
+		printf("EXIT fax_get_frame\n");
+		return PJ_FALSE;
+	}
+    pj_lock_release(fd->lock);
+
+    frame->type = PJMEDIA_FRAME_TYPE_AUDIO;
+    frame->timestamp.u64 = 0;
+
+	//printf("EXIT fax_get_frame\n");
+    return PJ_SUCCESS;
+}
+
+// called when pjmedia has received data
+static pj_status_t fax_put_frame(pjmedia_port *this_port, 
+				  pjmedia_frame *frame)
+{
+    if(frame->type != PJMEDIA_FRAME_TYPE_AUDIO) return PJ_SUCCESS;
+	//printf("ENTER fax_put_frame frame->buf=%x frame->size=%i\n", frame->buf, frame->size);
+
+    struct fax_device *fd = (struct fax_device*) this_port;
+    pj_lock_acquire(fd->lock);
+
+    unsigned int pos = 0;
+
+    while (pos < frame->size)
+    {
+		// feed the decoder with small chunks of data (16 bytes/ms)
+		int len = frame->size - pos;
+		if (len > FAX_DATA_CHUNK) len = FAX_DATA_CHUNK;
+
+		/* Pass the new incoming audio frame to the fax_rx function */
+		if (fax_rx(&fd->fax, (int16_t *)(frame->buf)+pos, len/2)) {
+			printf("fax_rx reported an error\n");
+			pj_lock_release(fd->lock);
+			printf("EXIT fax_put_frame\n");
+			return 0;
+		}
+
+		pos += len;
+    }
+
+	pj_lock_release(fd->lock);
+
+	//printf("EXIT fax_put_frame\n");
+    return fd->link.next->put_frame(fd->link.next, frame);
+}
+
+/*
+ * Destroy port.
+ */
+static pj_status_t fax_on_destroy(pjmedia_port *this_port)
+{
+	printf("fax_on_destroy\n");
+
+	struct fax_device *fd = (struct fax_device*)this_port;
+
+    fax_release(&fd->fax);
+
+	if(fd->lock) pj_lock_destroy(fd->lock);
+    return PJ_SUCCESS;
+}
+

package/src/sip.cpp

@@ -26,6 +26,7 @@
 #include "chainlink_dtmfdet.h"
 #include "chainlink_tonegen.h"
 #include "chainlink_wav_port.h"
+#include "chainlink_fax.h"
 
 #include <ctime>
 
@@ -166,6 +167,7 @@ struct Call {
 	chainlink *wav_player;
 	chainlink *tonegen;
 	chainlink *dtmfdet;
+	chainlink *fax;
 
 	Transport *transport;
 
@@ -361,6 +363,8 @@ bool prepare_tonegen(Call *c);
 bool prepare_wav_player(Call *c, const char *file);
 bool prepare_wav_writer(Call *c, const char *file); 
 
+bool prepare_fax(Call *c, bool is_sender, const char *file); 
+
 void prepare_error_event(ostringstream *oss, char *scope, char *details);
 //void prepare_pjsipcall_error_event(ostringstream *oss, char *scope, char *function, pj_status_t s);
 void append_status(ostringstream *oss, pj_status_t s);
@@ -461,6 +465,21 @@ static void on_inband_dtmf(pjmedia_port *port, void *user_data, char digit){
 	}
 }
 
+static void on_fax_result(pjmedia_port *port, void *user_data, int result){
+   if(g_shutting_down) return;
+
+   long call_id;
+   if( !g_call_ids.get_id((long)user_data, call_id) ){
+       printf("on_fax_result: Failed to get call_id. Event will not be notified.\n");
+       return;
+   }
+
+   char evt[256];
+   make_evt_fax_result(evt, sizeof(evt), call_id, result);
+   dispatch_event(evt);
+}
+
+
 void dispatch_event(const char * evt)
 {
 	//addon_log(LOG_LEVEL_DEBUG, "dispach_event called\n");
@@ -2215,6 +2234,87 @@ int pjw_call_stop_record_wav(long call_id)
 	return 0;
 }
 
+int pjw_call_start_fax(long call_id, bool is_sender, const char *file)
+{
+	PJW_LOCK();
+
+	long val;
+
+	if(!g_call_ids.get(call_id, val)){
+		PJW_UNLOCK();
+		set_error("Invalid call_id");
+		return -1;
+	}
+
+	Call *call = (Call*)val;
+
+	if(!call->med_stream)
+	{
+		PJW_UNLOCK();
+		set_error("Media not ready");
+		return -1;
+	}
+
+	pj_status_t status;
+
+	pjmedia_port *stream_port;
+	status = pjmedia_stream_get_port(call->med_stream,
+					&stream_port);
+	if(status != PJ_SUCCESS)
+	{
+		PJW_UNLOCK();
+		set_error("pjmedia_stream_get_port failed");
+		return -1;
+	}
+
+	if(!prepare_fax(call, is_sender, file)){
+		PJW_UNLOCK();
+		set_error("pjmedia_wav_player_port_create failed");
+		return -1;
+	}	
+
+	PJW_UNLOCK();
+	return 0;
+}
+
+
+int pjw_call_stop_fax(long call_id)
+{
+	PJW_LOCK();
+
+	long val;
+
+	if(!g_call_ids.get(call_id, val)){
+		PJW_UNLOCK();
+		set_error("Invalid call_id");
+		return -1;
+	}
+
+	Call *call = (Call*)val;
+
+	pjmedia_port *stream_port;
+	pj_status_t status;
+	status = pjmedia_stream_get_port(call->med_stream,
+					&stream_port);
+	if(status != PJ_SUCCESS) {
+		PJW_UNLOCK();
+		set_error("pjmedia_stream_get_port failed.");
+		return -1;
+	}	
+
+	if(!prepare_wire(call->inv->pool, &call->fax, PJMEDIA_PIA_SRATE(&stream_port->info), PJMEDIA_PIA_CCNT(&stream_port->info), PJMEDIA_PIA_SPF(&stream_port->info), PJMEDIA_PIA_BITS(&stream_port->info))) {
+		PJW_UNLOCK();
+		set_error("prepare_wire failed.");
+		return -1;
+	}
+
+	connect_media_ports(call);
+
+	PJW_UNLOCK();
+	return 0;
+}
+
+
 int pjw_call_get_stream_stat(long call_id, char *out_stats){
 	PJW_LOCK();
 
@@ -3645,6 +3745,12 @@ bool init_media_ports(Call *c, unsigned sampling_rate, unsigned channel_count, u
 		if(status != PJ_SUCCESS) return false;
 	}
 
+   if(!c->fax) {
+       if(!prepare_wire(c->inv->pool, &c->fax, sampling_rate, channel_count, samples_per_frame, bits_per_sample)) {
+           return false;
+       }
+   }
+
 	connect_media_ports(c);
 	return true;
 }
@@ -3653,7 +3759,8 @@ void connect_media_ports(Call *c) {
 	((chainlink*)c->dtmfdet)->next = (pjmedia_port*)c->tonegen;
 	((chainlink*)c->tonegen)->next = (pjmedia_port*)c->wav_player;
 	((chainlink*)c->wav_player)->next = (pjmedia_port*)c->wav_writer;
-	((chainlink*)c->wav_writer)->next = c->null_port;
+    ((chainlink*)c->wav_writer)->next = (pjmedia_port*)c->fax;
+    ((chainlink*)c->fax)->next = c->null_port;
 }
 
 bool prepare_tonegen(Call *c) {
@@ -3740,6 +3847,37 @@ bool prepare_wav_writer(Call *c, const char *file) {
 	return true;
 }
 
+
+bool prepare_fax(Call *c, bool is_sender, const char *file) {
+   pj_status_t status;
+
+   chainlink *link = (chainlink*)c->fax;
+
+   pjmedia_port *stream_port;
+   status = pjmedia_stream_get_port(c->med_stream,
+                   &stream_port);
+   if(status != PJ_SUCCESS) return false;
+
+   status = pjmedia_port_destroy((pjmedia_port*)link);
+   if(status != PJ_SUCCESS) return false;
+
+   status = chainlink_fax_port_create(c->inv->pool,
+                       PJMEDIA_PIA_SRATE(&stream_port->info),
+                       PJMEDIA_PIA_CCNT(&stream_port->info),
+                       PJMEDIA_PIA_SPF(&stream_port->info),
+                       PJMEDIA_PIA_BITS(&stream_port->info),
+                       on_fax_result,
+                       c,
+                       c->outgoing,
+                       is_sender,
+                       file,
+                       (pjmedia_port**)&c->fax);
+   if(status != PJ_SUCCESS) return false;
+
+   connect_media_ports(c);
+   return true;
+}
+
 bool prepare_wire(pj_pool_t *pool, chainlink **link, unsigned sampling_rate, unsigned channel_count, unsigned samples_per_frame, unsigned bits_per_sample) {
 	pj_status_t status;
 

package/src/sip.hpp

@@ -33,6 +33,8 @@ int pjw_call_start_record_wav(long call_id, const char *file);
 int pjw_call_start_play_wav(long call_id, const char *file);
 int pjw_call_stop_play_wav(long call_id);
 int pjw_call_stop_record_wav(long call_id);
+int pjw_call_start_fax(long call_id, bool is_sender, const char *file);
+int pjw_call_stop_fax(long call_id);
 int pjw_call_get_stream_stat(long call_id, char *out_stats);
 int pjw_call_refer(long call_id, const char *dest_uri, const char *additional_headers, long *out_subscription_id);
 int pjw_call_get_info(long call_id, const char *required_info, char *out_info);