Free 1024 software for linux

JACE is a Convolution Engine for JACK and ALSA, using FFT-based partitioned convolution with uniform partition sizes.
This is a prealpha release of the Jace project.
Main features:
- Any matrix of convolutions between up to 16 input and 16 outputs.
- Maximum length for each convolution is one megasample (nearly 22 seconds at 48 kHz).
- Allows the use of a period size down to 1/16 of the partition size.
- Its fast.
When used with a period size smaller than the partition size, JACE will try to spread the CPU load evenly over all process cycles that make up a partition. This works quite well if there is enough work to be distributed, and less well otherwise.
As an extreme example, if there is only one input and one output, and the convolution size is just one partition, its clearly not possible to spread the three elementary operations over 16 cycles. But in those cases the load will be small anyway, and you can use a smaller partition size.
Code to use SSE (tested) and 3DNOW (untested !) for the MAC steps is present, but disabled by default since it seems to make little difference.
Performance on 2 GHz Pentium IV with 4 convolutions of 5.5 seconds each at Fs = 48 kHz. Load is as displayed by qjackctl. Delay is input + process + output.
period partition load delay
-----------------------------------
1024 8k 12% 340ms
1024 4K 17% 170ms
512 4K 18% 170ms
256 4K 19% 170ms
128 2k 32% 85ms
64 1k 59% 43ms

pyao is a wrapper for the ao library.

pyao is a set of Python bindings for Xiph.orgs libao, a cross-platform audio output library.

Installation:

python config_unix.py
python setup.py build
[as root] python setup.py install

The config script is new and still pretty weak. If you have any problems let me know. Access the module by using "import ao" in your Python code.

Heres an interactive session of just playing with the module, until I create better documentation (there should be docstrings for everything). Watch as I read some random data and "play" it to a wave file.

>>> import ao

>>> myoptions = {file: myoutput.wav}

>>> dev = ao.AudioDevice(wav, options = myoptions)

>>> f = open(/dev/urandom, r) #thats some good stuff

>>> print dev
< AudioDevice object at 0x812ac28 >

>>> print dev.get_driver_info()
{author: Aaron Holtzman,
short_name: wav,
name: WAV file output,
comment: Sends output to a .wav file}

>>> print ao.get_driver_info(oss)
{author: Aaron Holtzman,
short_name: oss,
name: OSS audio driver output ,
comment: Outputs audio to the Open Sound System driver.}

>>> data = f.read(1024*8)

>>> dev.play(data)

>>> < control-d >

And now I have a file myoutput.wav with random noise in it.

smalloc short from Static memory buffer malloc, is an ideal memory manager for Realtime Linux Kernel modules that cant use dynamic memory offered by kmalloc because of the non-realtime nature of kmalloc.

Like malloc(), smalloc() doles out memory to client code. Unlike malloc, however, smalloc takes a static memory buffer (as an initialization parameter). It is this buffer that smalloc manages when doling out memory to client code.

This design makes smalloc ideal for use inside a Realtime Linux kernel module. It also makes it much easire to port userspace code that relies on malloc() in C or operator new() in C++ for memory management to a realtime kernel module.

For example:

(the below is linux kernel code)

< code >

#include "smalloc.h"
#include < linux/slab.h >

#define MEMPOOLSZ (1024*1024*1024)
char *buf;

...

buf = kmalloc(MEMPOOLSZ, GFP_KERNEL); /* 1 megabyte buffer in kernel
module.. */
smalloc_set_memory_pool(buf, sizeof(buf));

...

MyStruct *s;

s = smalloc(sizeof(MyStruct)); /* example of code that uses this
static memory buffer */

< /code >

The above example is a typical usage pattern of smalloc.

herodot is a tool that parses the timeline of filesystem activity created by mactime and adds human readable descriptions to it (e.g.: this file has been created). It also understands that later changes of some MAC tags hide earlier changes.

Usage:

Use this tool like that:

$ ./herodot < timeline.txt > interpreted_timeline.txt

Examples:

When the output of mactime says:

Wed Jun 15 2005 17:21:24 1024 m.c d/drwxr-xr-x root root 293340 /lib/tls/i686
herodot will say:

Wed Jun 15 2005 17:21:24 1024 m.c d/drwxr-xr-x root root 293340 /lib/tls/i686 (m.c) (subdirectory or file created in this directory)

It is because herodot knows that changing of m and c time tags of some directory without changing its a time means that some subdirectory or file has been created in this directory.

When the output of mactime says:

Mon Nov 07 2005 21:11:18 5 m.c -/-rw-r--r-- 0 0 15 katalog/dir_1/dir_1_1/fil_2.txt
Mon Nov 07 2005 21:11:20 5 .a. -/-rw-r--r-- 0 0 15 katalog/dir_1/dir_1_1/fil_2.txt
herodot will say:

Mon Nov 07 2005 21:11:20 5 .a. -/-rw-r--r-- 0 0 15 katalog/dir_1/dir_1_1/fil_2.txt (.a.) (reading from this file)
Mon Nov 07 2005 21:11:18 5 m.c -/-rw-r--r-- 0 0 15 katalog/dir_1/dir_1_1/fil_2.txt (m?c) (this file created) (writing to this file)

As you can see, the lines in herodots output are in oposite order the newest events come the first. Ok, thats not so much important side effect. Th important thing is that if the a tag was changed in some moment, we can not be sure if it was changed or not before that moment so in every older event of that file the tag a will be marked as ? (quotation mark).

tthsum generates and checks TTH checksums (root of the THEX hash tree). The Merkle Hash Tree is a hash construct that exhibits desirable properties for verifying the integrity of files and file subranges in an incremental or out-of-order fashion.
The tool uses the Tiger hash algorithm for both the internal and the leaf nodes, and has an interface identical to md5sum.
Enhancements:
- Converted tthsum to C (it was C++).
- Updated makefiles, added NMakefile for Windows, run nmake /f NMakefile on windows.
- Added BIG_ENDIAN support (tested on a SPARC).
- Removed -b functionality. The asterisk that did nothing didnt make sense.
- Made this Changelog a bit more readable.
- Fixed a bug where incorrect hashes were generated when using the console as input file. (The reads did not generate a multiple of 1024 bytes.)
- Added mmap(2) support (-m) (mapping 1.6MB at a time), default is read(2). YMMV.
- Added -p, -w, -V options (show progress, warn about improper digest lines, show version).
- Writing escaped and utf8-ified filenames to digest.

Fortify provides full strength, 128-bit encryption facilities to the export editions of Netscape Navigator and Communicator. If you routinely use Netscapes export-grade web browsers, (i.e. the ones you can download from the Internet), then you need Fortify. It is easy to illustrate why you need Fortify. Take a look at this diagram. Follow the links on the navigation bar below to find out more about Fortify or to download a copy for yourself.
Fortify is free for all forms of non-commercial use, including individual, educational, research, or charitable use. Please refer to the Copyright for full details.
Commercial use, or commercial re-distribution, of Fortify is controlled under the terms of the software Copyright, and requires a formal licence. However, the terms are deliberately simple, and, more often than not, they are purely a formality.
Organisations should, in the first instance, register their interest in using Fortify, via the contact enquiry form .
When comparing Fortify to alternative strong encryption solutions, such as SSL relays, SSL proxies, or Java-based applet solutions, there are a number of advantages which has to be considered:
1. It is more secure. A Fortified browser performs strong encryption internally. When connecting to a full strength web server, you have a true, end-to-end, strongly encrypted channel. With SSL proxies, at least one segment of the channel remains weakly encrypted.
2. It is faster. When using a Fortified browser, the data in the communications channel is not re-encrypted as it travels between the browser and the web server. It also has fewer network "hops" to traverse. And, unlike some alternative solutions, no supplementary Java applets are involved. All these factors result in better network performance, and less load on your PC or workstation.
3. It is simpler. A Fortified browser requires no additional certificates for its correct operation. Indeed, no other browser reconfigurations are needed at all. It is easy to install.
4. It is intranet friendly. A Fortified browser can be readily installed on a LAN file server and shared to a group of users. No further installation effort is required on each individual workstation or PC. In medium or large scale networks, this can lead to substantial savings in administrative time and effort.
Main features:
- In the Netscape 2.x and 3.x browsers, Fortify provides full strength, 128-bit encryption facilities. These are used when connecting to an encrypting web server (with the SSL protocol). Without Fortify, the export-grade web browsers are limited to 40-bit encryption facilities, which are substantially weaker, and have been demonstrated to be "crackable".
-
- In the Netscape 4.x browsers, Fortify provides these same 128-bit encryption features, plus the ability to generate 1024-bit RSA keys internally (these are typically used for client certificates), plus the ability to send and receive e-mail messages using strong 128-bit encryption (with the S/MIME protocol).
-
- Further details are provided in the following sections of this document.

froofyJIT is a C++ syntactic sugar front-end for Paolo Bonzinis GNU lightning library for dynamic native code generation. froofyJIT program uses C++s powerful language facilities to allow GNU lightning instructions to be expressed in a more concise way that approximates a real assembly language.
Below is a program which uses froofyJIT to compute a Fibonacci number (directly translated from tests/fib.c in GNU lightning):
#include < cstdlib >
#include < iostream >
#include "froofy/jit.h"
static jit_insn codeBuffer[1024];
typedef int (*pifi)(int);
int main()
{
pifi nfibs;
int in;
{
using namespace froofy::jit;
label< > basis;
nfibs/ !org, codeBuffer;
prolog, 1;
!arg< ui > in;
getarg< ui > v0, in;
blti< ui > basis, v0, 2;
subi< ui > v1, v0, 1;
subi< ui > v2, v0, 2;
prepare< i > 1;
pusharg< ui > v1;
finish, nfibs;
retval< i > v1;
prepare< i > 1;
pusharg< ui > v2;
finish, nfibs;
retval< i > v2;
addi< ui > v1, v1, 1;
addr< ui > rr, v1, v2;
ret --;
basis/ movi< i > rr, 1;
ret --;
!end, codeBuffer;
}
std::cout<<less