Add layer1 over IP support
Implement a ISDN over IP tunnel to use mISDN hardware on remote locations. Signed-off-by: Karsten Keil <kkeil@suse.de>
This commit is contained in:
Karsten Keil
parent
af69fb3a8f
commit
3712b42d4b
|
|
@ -23,5 +23,22 @@ config MISDN_DSP
|
|||
and get more informations about this module and it's usage.
|
||||
If unsure, say 'N'.
|
||||
|
||||
source "drivers/isdn/hardware/mISDN/Kconfig"
|
||||
config MISDN_L1OIP
|
||||
tristate "ISDN over IP tunnel"
|
||||
depends on MISDN
|
||||
help
|
||||
Enable support for ISDN over IP tunnel.
|
||||
|
||||
It features:
|
||||
- dynamic IP exchange, if one or both peers have dynamic IPs
|
||||
- BRI (S0) and PRI (S2M) interface
|
||||
- layer 1 control via network keepalive frames
|
||||
- direct tunneling of physical interface via IP
|
||||
|
||||
NOTE: This protocol is called 'Layer 1 over IP' and is not
|
||||
compatible with ISDNoIP (Agfeo) or TDMoIP. Protocol description is
|
||||
provided in the source code.
|
||||
|
||||
source "drivers/isdn/hardware/mISDN/Kconfig"
|
||||
|
||||
endif #MISDN
|
||||
|
|
|
|||
|
|
@ -4,8 +4,10 @@
|
|||
|
||||
obj-$(CONFIG_MISDN) += mISDN_core.o
|
||||
obj-$(CONFIG_MISDN_DSP) += mISDN_dsp.o
|
||||
obj-$(CONFIG_MISDN_L1OIP) += l1oip.o
|
||||
|
||||
# multi objects
|
||||
|
||||
mISDN_core-objs := core.o fsm.o socket.o hwchannel.o stack.o layer1.o layer2.o tei.o timerdev.o
|
||||
mISDN_dsp-objs := dsp_core.o dsp_cmx.o dsp_tones.o dsp_dtmf.o dsp_audio.o dsp_blowfish.o dsp_pipeline.o dsp_hwec.o
|
||||
l1oip-objs := l1oip_core.o l1oip_codec.o
|
||||
|
|
|
|||
|
|
@ -0,0 +1,91 @@
|
|||
/*
|
||||
* see notice in l1oip.c
|
||||
*/
|
||||
|
||||
/* debugging */
|
||||
#define DEBUG_L1OIP_INIT 0x00010000
|
||||
#define DEBUG_L1OIP_SOCKET 0x00020000
|
||||
#define DEBUG_L1OIP_MGR 0x00040000
|
||||
#define DEBUG_L1OIP_MSG 0x00080000
|
||||
|
||||
/* enable to disorder received bchannels by sequence 2143658798... */
|
||||
/*
|
||||
#define REORDER_DEBUG
|
||||
*/
|
||||
|
||||
/* frames */
|
||||
#define L1OIP_MAX_LEN 2048 /* max packet size form l2 */
|
||||
#define L1OIP_MAX_PERFRAME 1400 /* max data size in one frame */
|
||||
|
||||
|
||||
/* timers */
|
||||
#define L1OIP_KEEPALIVE 15
|
||||
#define L1OIP_TIMEOUT 65
|
||||
|
||||
|
||||
/* socket */
|
||||
#define L1OIP_DEFAULTPORT 931
|
||||
|
||||
|
||||
/* channel structure */
|
||||
struct l1oip_chan {
|
||||
struct dchannel *dch;
|
||||
struct bchannel *bch;
|
||||
u32 tx_counter; /* counts xmit bytes/packets */
|
||||
u32 rx_counter; /* counts recv bytes/packets */
|
||||
u32 codecstate; /* used by codec to save data */
|
||||
#ifdef REORDER_DEBUG
|
||||
int disorder_flag;
|
||||
struct sk_buff *disorder_skb;
|
||||
u32 disorder_cnt;
|
||||
#endif
|
||||
};
|
||||
|
||||
|
||||
/* card structure */
|
||||
struct l1oip {
|
||||
struct list_head list;
|
||||
|
||||
/* card */
|
||||
int registered; /* if registered with mISDN */
|
||||
char name[MISDN_MAX_IDLEN];
|
||||
int idx; /* card index */
|
||||
int pri; /* 1=pri, 0=bri */
|
||||
int d_idx; /* current dchannel number */
|
||||
int b_num; /* number of bchannels */
|
||||
u32 id; /* id of connection */
|
||||
int ondemand; /* if transmis. is on demand */
|
||||
int bundle; /* bundle channels in one frm */
|
||||
int codec; /* codec to use for transmis. */
|
||||
int limit; /* limit number of bchannels */
|
||||
|
||||
/* timer */
|
||||
struct timer_list keep_tl;
|
||||
struct timer_list timeout_tl;
|
||||
int timeout_on;
|
||||
struct work_struct workq;
|
||||
|
||||
/* socket */
|
||||
struct socket *socket; /* if set, socket is created */
|
||||
struct completion socket_complete;/* completion of sock thread */
|
||||
struct task_struct *socket_thread;
|
||||
spinlock_t socket_lock; /* access sock outside thread */
|
||||
u32 remoteip; /* if all set, ip is assigned */
|
||||
u16 localport; /* must always be set */
|
||||
u16 remoteport; /* must always be set */
|
||||
struct sockaddr_in sin_local; /* local socket name */
|
||||
struct sockaddr_in sin_remote; /* remote socket name */
|
||||
struct msghdr sendmsg; /* ip message to send */
|
||||
struct iovec sendiov; /* iov for message */
|
||||
|
||||
/* frame */
|
||||
struct l1oip_chan chan[128]; /* channel instances */
|
||||
};
|
||||
|
||||
extern int l1oip_law_to_4bit(u8 *data, int len, u8 *result, u32 *state);
|
||||
extern int l1oip_4bit_to_law(u8 *data, int len, u8 *result);
|
||||
extern int l1oip_alaw_to_ulaw(u8 *data, int len, u8 *result);
|
||||
extern int l1oip_ulaw_to_alaw(u8 *data, int len, u8 *result);
|
||||
extern void l1oip_4bit_free(void);
|
||||
extern int l1oip_4bit_alloc(int ulaw);
|
||||
|
||||
|
|
@ -0,0 +1,374 @@
|
|||
/*
|
||||
|
||||
* l1oip_codec.c generic codec using lookup table
|
||||
* -> conversion from a-Law to u-Law
|
||||
* -> conversion from u-Law to a-Law
|
||||
* -> compression by reducing the number of sample resolution to 4
|
||||
*
|
||||
* NOTE: It is not compatible with any standard codec like ADPCM.
|
||||
*
|
||||
* Author Andreas Eversberg (jolly@eversberg.eu)
|
||||
*
|
||||
* This program is free software; you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation; either version 2, or (at your option)
|
||||
* any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program; if not, write to the Free Software
|
||||
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
|
||||
|
||||
*/
|
||||
|
||||
/*
|
||||
|
||||
How the codec works:
|
||||
--------------------
|
||||
|
||||
The volume is increased to increase the dynamic range of the audio signal.
|
||||
Each sample is converted to a-LAW with only 16 steps of level resolution.
|
||||
A pair of two samples are stored in one byte.
|
||||
|
||||
The first byte is stored in the upper bits, the second byte is stored in the
|
||||
lower bits.
|
||||
|
||||
To speed up compression and decompression, two lookup tables are formed:
|
||||
|
||||
- 16 bits index for two samples (law encoded) with 8 bit compressed result.
|
||||
- 8 bits index for one compressed data with 16 bits decompressed result.
|
||||
|
||||
NOTE: The bytes are handled as they are law-encoded.
|
||||
|
||||
*/
|
||||
|
||||
#include <linux/vmalloc.h>
|
||||
#include <linux/mISDNif.h>
|
||||
#include "core.h"
|
||||
|
||||
/* definitions of codec. don't use calculations, code may run slower. */
|
||||
|
||||
static u8 *table_com;
|
||||
static u16 *table_dec;
|
||||
|
||||
|
||||
/* alaw -> ulaw */
|
||||
static u8 alaw_to_ulaw[256] =
|
||||
{
|
||||
0xab, 0x2b, 0xe3, 0x63, 0x8b, 0x0b, 0xc9, 0x49,
|
||||
0xba, 0x3a, 0xf6, 0x76, 0x9b, 0x1b, 0xd7, 0x57,
|
||||
0xa3, 0x23, 0xdd, 0x5d, 0x83, 0x03, 0xc1, 0x41,
|
||||
0xb2, 0x32, 0xeb, 0x6b, 0x93, 0x13, 0xcf, 0x4f,
|
||||
0xaf, 0x2f, 0xe7, 0x67, 0x8f, 0x0f, 0xcd, 0x4d,
|
||||
0xbe, 0x3e, 0xfe, 0x7e, 0x9f, 0x1f, 0xdb, 0x5b,
|
||||
0xa7, 0x27, 0xdf, 0x5f, 0x87, 0x07, 0xc5, 0x45,
|
||||
0xb6, 0x36, 0xef, 0x6f, 0x97, 0x17, 0xd3, 0x53,
|
||||
0xa9, 0x29, 0xe1, 0x61, 0x89, 0x09, 0xc7, 0x47,
|
||||
0xb8, 0x38, 0xf2, 0x72, 0x99, 0x19, 0xd5, 0x55,
|
||||
0xa1, 0x21, 0xdc, 0x5c, 0x81, 0x01, 0xbf, 0x3f,
|
||||
0xb0, 0x30, 0xe9, 0x69, 0x91, 0x11, 0xce, 0x4e,
|
||||
0xad, 0x2d, 0xe5, 0x65, 0x8d, 0x0d, 0xcb, 0x4b,
|
||||
0xbc, 0x3c, 0xfa, 0x7a, 0x9d, 0x1d, 0xd9, 0x59,
|
||||
0xa5, 0x25, 0xde, 0x5e, 0x85, 0x05, 0xc3, 0x43,
|
||||
0xb4, 0x34, 0xed, 0x6d, 0x95, 0x15, 0xd1, 0x51,
|
||||
0xac, 0x2c, 0xe4, 0x64, 0x8c, 0x0c, 0xca, 0x4a,
|
||||
0xbb, 0x3b, 0xf8, 0x78, 0x9c, 0x1c, 0xd8, 0x58,
|
||||
0xa4, 0x24, 0xde, 0x5e, 0x84, 0x04, 0xc2, 0x42,
|
||||
0xb3, 0x33, 0xec, 0x6c, 0x94, 0x14, 0xd0, 0x50,
|
||||
0xb0, 0x30, 0xe8, 0x68, 0x90, 0x10, 0xce, 0x4e,
|
||||
0xbf, 0x3f, 0xfe, 0x7e, 0xa0, 0x20, 0xdc, 0x5c,
|
||||
0xa8, 0x28, 0xe0, 0x60, 0x88, 0x08, 0xc6, 0x46,
|
||||
0xb7, 0x37, 0xf0, 0x70, 0x98, 0x18, 0xd4, 0x54,
|
||||
0xaa, 0x2a, 0xe2, 0x62, 0x8a, 0x0a, 0xc8, 0x48,
|
||||
0xb9, 0x39, 0xf4, 0x74, 0x9a, 0x1a, 0xd6, 0x56,
|
||||
0xa2, 0x22, 0xdd, 0x5d, 0x82, 0x02, 0xc0, 0x40,
|
||||
0xb1, 0x31, 0xea, 0x6a, 0x92, 0x12, 0xcf, 0x4f,
|
||||
0xae, 0x2e, 0xe6, 0x66, 0x8e, 0x0e, 0xcc, 0x4c,
|
||||
0xbd, 0x3d, 0xfc, 0x7c, 0x9e, 0x1e, 0xda, 0x5a,
|
||||
0xa6, 0x26, 0xdf, 0x5f, 0x86, 0x06, 0xc4, 0x44,
|
||||
0xb5, 0x35, 0xee, 0x6e, 0x96, 0x16, 0xd2, 0x52
|
||||
};
|
||||
|
||||
/* ulaw -> alaw */
|
||||
static u8 ulaw_to_alaw[256] =
|
||||
{
|
||||
0xab, 0x55, 0xd5, 0x15, 0x95, 0x75, 0xf5, 0x35,
|
||||
0xb5, 0x45, 0xc5, 0x05, 0x85, 0x65, 0xe5, 0x25,
|
||||
0xa5, 0x5d, 0xdd, 0x1d, 0x9d, 0x7d, 0xfd, 0x3d,
|
||||
0xbd, 0x4d, 0xcd, 0x0d, 0x8d, 0x6d, 0xed, 0x2d,
|
||||
0xad, 0x51, 0xd1, 0x11, 0x91, 0x71, 0xf1, 0x31,
|
||||
0xb1, 0x41, 0xc1, 0x01, 0x81, 0x61, 0xe1, 0x21,
|
||||
0x59, 0xd9, 0x19, 0x99, 0x79, 0xf9, 0x39, 0xb9,
|
||||
0x49, 0xc9, 0x09, 0x89, 0x69, 0xe9, 0x29, 0xa9,
|
||||
0xd7, 0x17, 0x97, 0x77, 0xf7, 0x37, 0xb7, 0x47,
|
||||
0xc7, 0x07, 0x87, 0x67, 0xe7, 0x27, 0xa7, 0xdf,
|
||||
0x9f, 0x7f, 0xff, 0x3f, 0xbf, 0x4f, 0xcf, 0x0f,
|
||||
0x8f, 0x6f, 0xef, 0x2f, 0x53, 0x13, 0x73, 0x33,
|
||||
0xb3, 0x43, 0xc3, 0x03, 0x83, 0x63, 0xe3, 0x23,
|
||||
0xa3, 0x5b, 0xdb, 0x1b, 0x9b, 0x7b, 0xfb, 0x3b,
|
||||
0xbb, 0xbb, 0x4b, 0x4b, 0xcb, 0xcb, 0x0b, 0x0b,
|
||||
0x8b, 0x8b, 0x6b, 0x6b, 0xeb, 0xeb, 0x2b, 0x2b,
|
||||
0xab, 0x54, 0xd4, 0x14, 0x94, 0x74, 0xf4, 0x34,
|
||||
0xb4, 0x44, 0xc4, 0x04, 0x84, 0x64, 0xe4, 0x24,
|
||||
0xa4, 0x5c, 0xdc, 0x1c, 0x9c, 0x7c, 0xfc, 0x3c,
|
||||
0xbc, 0x4c, 0xcc, 0x0c, 0x8c, 0x6c, 0xec, 0x2c,
|
||||
0xac, 0x50, 0xd0, 0x10, 0x90, 0x70, 0xf0, 0x30,
|
||||
0xb0, 0x40, 0xc0, 0x00, 0x80, 0x60, 0xe0, 0x20,
|
||||
0x58, 0xd8, 0x18, 0x98, 0x78, 0xf8, 0x38, 0xb8,
|
||||
0x48, 0xc8, 0x08, 0x88, 0x68, 0xe8, 0x28, 0xa8,
|
||||
0xd6, 0x16, 0x96, 0x76, 0xf6, 0x36, 0xb6, 0x46,
|
||||
0xc6, 0x06, 0x86, 0x66, 0xe6, 0x26, 0xa6, 0xde,
|
||||
0x9e, 0x7e, 0xfe, 0x3e, 0xbe, 0x4e, 0xce, 0x0e,
|
||||
0x8e, 0x6e, 0xee, 0x2e, 0x52, 0x12, 0x72, 0x32,
|
||||
0xb2, 0x42, 0xc2, 0x02, 0x82, 0x62, 0xe2, 0x22,
|
||||
0xa2, 0x5a, 0xda, 0x1a, 0x9a, 0x7a, 0xfa, 0x3a,
|
||||
0xba, 0xba, 0x4a, 0x4a, 0xca, 0xca, 0x0a, 0x0a,
|
||||
0x8a, 0x8a, 0x6a, 0x6a, 0xea, 0xea, 0x2a, 0x2a
|
||||
};
|
||||
|
||||
/* alaw -> 4bit compression */
|
||||
static u8 alaw_to_4bit[256] = {
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0d, 0x02,
|
||||
0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x01, 0x0a, 0x05,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x08, 0x07, 0x0f, 0x00, 0x0b, 0x04,
|
||||
0x0e, 0x01, 0x0a, 0x05, 0x0f, 0x00, 0x0c, 0x03,
|
||||
0x0d, 0x02, 0x09, 0x06, 0x0f, 0x00, 0x0b, 0x04,
|
||||
};
|
||||
|
||||
/* 4bit -> alaw decompression */
|
||||
static u8 _4bit_to_alaw[16] = {
|
||||
0x5d, 0x51, 0xd9, 0xd7, 0x5f, 0x53, 0xa3, 0x4b,
|
||||
0x2a, 0x3a, 0x22, 0x2e, 0x26, 0x56, 0x20, 0x2c,
|
||||
};
|
||||
|
||||
/* ulaw -> 4bit compression */
|
||||
static u8 ulaw_to_4bit[256] = {
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
|
||||
0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01, 0x01,
|
||||
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
|
||||
0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02, 0x02,
|
||||
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x03,
|
||||
0x03, 0x03, 0x03, 0x03, 0x03, 0x03, 0x04, 0x04,
|
||||
0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04,
|
||||
0x04, 0x04, 0x04, 0x04, 0x05, 0x05, 0x05, 0x05,
|
||||
0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
|
||||
0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
|
||||
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07,
|
||||
0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x07, 0x08,
|
||||
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
|
||||
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
|
||||
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
|
||||
0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f, 0x0f,
|
||||
0x0f, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
|
||||
0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e, 0x0e,
|
||||
0x0e, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
|
||||
0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d, 0x0d,
|
||||
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c,
|
||||
0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0c, 0x0b, 0x0b,
|
||||
0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b, 0x0b,
|
||||
0x0b, 0x0b, 0x0b, 0x0b, 0x0a, 0x0a, 0x0a, 0x0a,
|
||||
0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a, 0x0a,
|
||||
0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09, 0x09,
|
||||
0x09, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
|
||||
0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08, 0x08,
|
||||
};
|
||||
|
||||
/* 4bit -> ulaw decompression */
|
||||
static u8 _4bit_to_ulaw[16] = {
|
||||
0x11, 0x21, 0x31, 0x40, 0x4e, 0x5c, 0x68, 0x71,
|
||||
0xfe, 0xef, 0xe7, 0xdb, 0xcd, 0xbf, 0xaf, 0x9f,
|
||||
};
|
||||
|
||||
|
||||
/*
|
||||
* Compresses data to the result buffer
|
||||
* The result size must be at least half of the input buffer.
|
||||
* The number of samples also must be even!
|
||||
*/
|
||||
int
|
||||
l1oip_law_to_4bit(u8 *data, int len, u8 *result, u32 *state)
|
||||
{
|
||||
int ii, i = 0, o = 0;
|
||||
|
||||
if (!len)
|
||||
return 0;
|
||||
|
||||
/* send saved byte and first input byte */
|
||||
if (*state) {
|
||||
*result++ = table_com[(((*state)<<8)&0xff00) | (*data++)];
|
||||
len--;
|
||||
o++;
|
||||
}
|
||||
|
||||
ii = len >> 1;
|
||||
|
||||
while (i < ii) {
|
||||
*result++ = table_com[(data[0]<<8) | (data[1])];
|
||||
data += 2;
|
||||
i++;
|
||||
o++;
|
||||
}
|
||||
|
||||
/* if len has an odd number, we save byte for next call */
|
||||
if (len & 1)
|
||||
*state = 0x100 + *data;
|
||||
else
|
||||
*state = 0;
|
||||
|
||||
return o;
|
||||
}
|
||||
|
||||
/* Decompress data to the result buffer
|
||||
* The result size must be the number of sample in packet. (2 * input data)
|
||||
* The number of samples in the result are even!
|
||||
*/
|
||||
int
|
||||
l1oip_4bit_to_law(u8 *data, int len, u8 *result)
|
||||
{
|
||||
int i = 0;
|
||||
u16 r;
|
||||
|
||||
while (i < len) {
|
||||
r = table_dec[*data++];
|
||||
*result++ = r>>8;
|
||||
*result++ = r;
|
||||
i++;
|
||||
}
|
||||
|
||||
return len << 1;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* law conversion
|
||||
*/
|
||||
int
|
||||
l1oip_alaw_to_ulaw(u8 *data, int len, u8 *result)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
while (i < len) {
|
||||
*result++ = alaw_to_ulaw[*data++];
|
||||
i++;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
int
|
||||
l1oip_ulaw_to_alaw(u8 *data, int len, u8 *result)
|
||||
{
|
||||
int i = 0;
|
||||
|
||||
while (i < len) {
|
||||
*result++ = ulaw_to_alaw[*data++];
|
||||
i++;
|
||||
}
|
||||
|
||||
return len;
|
||||
}
|
||||
|
||||
|
||||
/*
|
||||
* generate/free compression and decompression table
|
||||
*/
|
||||
void
|
||||
l1oip_4bit_free(void)
|
||||
{
|
||||
if (table_dec)
|
||||
vfree(table_dec);
|
||||
if (table_com)
|
||||
vfree(table_com);
|
||||
table_com = NULL;
|
||||
table_dec = NULL;
|
||||
}
|
||||
|
||||
int
|
||||
l1oip_4bit_alloc(int ulaw)
|
||||
{
|
||||
int i1, i2, c, sample;
|
||||
|
||||
/* in case, it is called again */
|
||||
if (table_dec)
|
||||
return 0;
|
||||
|
||||
/* alloc conversion tables */
|
||||
table_com = vmalloc(65536);
|
||||
table_dec = vmalloc(512);
|
||||
if (!table_com | !table_dec) {
|
||||
l1oip_4bit_free();
|
||||
return -ENOMEM;
|
||||
}
|
||||
memset(table_com, 0, 65536);
|
||||
memset(table_dec, 0, 512);
|
||||
/* generate compression table */
|
||||
i1 = 0;
|
||||
while (i1 < 256) {
|
||||
if (ulaw)
|
||||
c = ulaw_to_4bit[i1];
|
||||
else
|
||||
c = alaw_to_4bit[i1];
|
||||
i2 = 0;
|
||||
while (i2 < 256) {
|
||||
table_com[(i1<<8) | i2] |= (c<<4);
|
||||
table_com[(i2<<8) | i1] |= c;
|
||||
i2++;
|
||||
}
|
||||
i1++;
|
||||
}
|
||||
|
||||
/* generate decompression table */
|
||||
i1 = 0;
|
||||
while (i1 < 16) {
|
||||
if (ulaw)
|
||||
sample = _4bit_to_ulaw[i1];
|
||||
else
|
||||
sample = _4bit_to_alaw[i1];
|
||||
i2 = 0;
|
||||
while (i2 < 16) {
|
||||
table_dec[(i1<<4) | i2] |= (sample<<8);
|
||||
table_dec[(i2<<4) | i1] |= sample;
|
||||
i2++;
|
||||
}
|
||||
i1++;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue