Free crc insurance software for linux

Home Insurance Inventory Wizard is an free little program you can upload to your web site to add some extra functionality.
Home Insurance Inventory Wizard makes taking a home inventory for home insurance purposes extremely simple. And installing it is super easy, too. Best of all, its free!
Main features:
- Javascript and PHP-based for maximum compatibility
- The home inventory list expands as new rooms and items are added indefinitely. Can be useful for small apartments or large houses.
- Inventories can be saved by the user and downloaded, no databases needed!
- Home inventory lists can be uploaded by a user later so that they can make adjustments and add new items
- An HTML output option allows the user to create and then print a nicely formatted HTML version of their home inventory. Also includes option to add images of items.
- No adware, spyware or viruses
- The Home Insurance Inventory Wizard is absolutely FREE!

Jacksum KDE Konqueror Integration installs features of Jacksum 1.7.0 at the KDE Konqueror (and uninstalls it again if you like).

Jacksum is a free and platform independent software for computing and verifying checksums, CRCs and message digests (known as hash values and fingerprints). "Jacksum" is a synthetic word made of JAva and ChecKSUM.

Jacksum supports 58 popular algorithms (Adler32, BSD sum, Bzip2s CRC-32, POSIX cksum, CRC-8, CRC-16, CRC-24, CRC-32 (FCS-32), CRC-64, ELF-32, eMule/eDonkey, FCS-16, GOST R 34.11-94, HAS-160, HAVAL (3/4/5 passes, 128/160/192/224/256 bits), MD2, MD4, MD5, MPEG-2s CRC-32, RIPEMD-128, RIPEMD-160, RIPEMD-256, RIPEMD-320, SHA-0, SHA-1, SHA-224, SHA-256, SHA-384, SHA-512, Tiger-128, Tiger-160, Tiger, Tiger2, Tiger Tree Hash, Tiger2 Tree Hash, Unix System V sum, sum8, sum16, sum24, sum32, Whirlpool-0, Whirlpool-1, Whirlpool and xor8).

Jacksum supports the "Rocksoft (tm) Model CRC Algorithm", it can calculate customized CRC algorithms and it supports the combination of multiple algorithms.

Jacksum has opened its source code and it is released under the terms of the GNU GPL. Jacksum is OSI Certified Open Source Software. OSI Certified is a certification mark of the Open Source Initiative.

Jacksum is platform independent, because it is written entirely in the Java programming language, the software runs on any platform having a Java Runtime Environment.

Jacksum has multiple interfaces. It can be used on the command line, in your file browser, and also in many other software projects.

AdvanceSCAN project is a commandline ROM manager for emulators.
AdvanceSCAN is a command line ROM manager for MAME, MESS, AdvanceMAME, AdvanceMESS, and Raine for Unix, DOS, and Windows.
Main features:
- Directly read, write zip archives without decompressing and recompressing them for the best performance.
- Add, copy, move and rename files in the zip archives. Any rom that you have is placed automatically in the correct zip.
- Recognize the text files added by rom sites and delete them.
- Recognize the text files added by the rom dumpers and keep or delete them.
- Its safe. On all the zip operations any file removed or overwritten is saved in the `rom_unknown `sample_unknown directories and kept for future uses. This will prevent any unwanted remove operation.
- Generate differential rom sets.
Enhancements:
- New rom zips are now created only if at least one unique rom is found. Roms shared with other games dont trigger the zip creation. For example, galaga88
- and pacmania share the rom ns1-mcu.bin. This functionality prevents the creation of the galaga88 zip from a correct copy of pacmania using only the
- ns1-mcu.bin file.
- Relaxed a consistency check for the local header in zip files. The crc and size entries are allowed to contain the real value also if a data descriptor is present.

Sarien project is a Sierra AGI interpreter for games like Kings Quest and Space Quest.
Sarien is a portable Sierra AGI resource interpreter engine that allows you to play Sierra On-Line AGI version 2 and version 3 games (such as Space Quest 1 and 2, and Leisure Suit Larry in the Land of the Lounge Lizards) natively in Linux, Solaris, Windows, and other platforms.
Enhancements:
- added QNX native sound driver (untested)
- ported to DOS 16-bit using Turbo C++
- started MacOS port using MPW (incomplete)
- changed palette to use Amiga-ish colors instead of PC EGA
- added "crc" command to the interpreter console
- sprite blitting algorithm changed to work with hidden screens
- fixed add.to.pic to erase and re-blit all sprites
- reimplemented options -C (show game CRC), -L (list games) and -P (picture viewer)
- unk_xxx command names changed to official names
- added Amiga Gold Rush! 2.05 game ID
- added support to Amiga v3 games
- added support to Amiga sound emulation
- fixed input prompt in normal input mode
- using table instead of computed values for priority bands
- implemented set.pri.base (used in KQ4)
- implemented echo.line (to repeat last input line with F3)
- implemented adj.ego.move.to.x.y (for click-to-walk interface)
- added mouse event support to the X11, SDL and Win32 drivers
- added debug info on status line (activated with key F11)
- implemented click-to-walk mouse interface
- menu system rewritten to allow mouse operation
- added experimental hi-res picture mode (switch with toggle.monitor)
- added mouse support in the picture viewer
- added SGML man page (use docbook-to-man to create the roff file)
- added AGI Mouse 1.0 protocol emulation
- merged Richard Houles MacOS X port
- merged Paul Hills Amiga port
- merged Vasyl Tsvirkunovs PocketPC port
- added experimental support to noise channel
- implemented picture offset according to configure.screen
- implemented invisible ego signaling
- fixed command get.num
- fixed controller reset (moved to the end of the cycle)
- fixed v3 game loading in big-endian machines
- sound tuning improved, added chorus and envelope release
- savegame subsystem rewritten

Los Alamos Message Passing Interface is an implementation of the Message Passing Interface (MPI) motivated by a growing need for fault tolerance at the software level in large high-performance computing (HPC) systems.
This need is caused by the vast number of components present in modern HPC systems, particularly clusters. The individual components -- processors, memory modules, network interface cards (NICs), etc. -- are typically manufactured to tolerances adequate for small or desktop systems.
When aggregated into a large HPC system, however, system-wide error rates may be too great to successfully complete a long application run. For example, a network device may have an error rate which is perfectly acceptable for a desktop system, but not in a cluster of thousands of nodes, which must run error free for many hours or even days to complete a scientific calculation.
LA-MPI has two primary goals: network fault tolerance and high performance.
Network fault tolerance is acheived by implementing a highly efficient checksum/retransmission protocol. The integrity of delivered data is (optionally) verified at the user-level using a checksum or CRC. Data that is corrupt (or never delivered) is retransmitted.
As for high performance, LA-MPIs lightweight checksum/retransmission protocol allows us to achieve low latency messaging. Furthermore, the flexible approach taken to the use of redundant data paths in a network-device-rich system leads to high network bandwidth since different messages and/or message-fragments can be sent in parallel along different paths. Also, since LA-MPI is developed for use on the the large systems at Los Alamos National Laboratory we have verified that LA-MPI is scalable to over 3,500 processes.
An alternative solution to the network fault tolerance problem is to use the TCP/IP protocol. We believe, however, that this protocol -- developed to handle unreliable, inhomogeneous and oversubscribed networks -- performs poorly and is overly complex for HPC system messaging, and that LA-MPIs lightweight checksum/retransmission protocol is a more appropriate choice.
Main features:
- Standard compliant (MPI version 1.2 integrated with ROMIO for MPI-IO)
- Highly portable
- Open source (LGPL)
- Thread safe
- Optimized for SMP systems, including NUMA architectures
- Network fault tolerant (data integrity checked at user level)
- Message-fragment striping across multiple network devices
Enhancements:
- Namespace conflicts have been fixed.
- Error detection and handling of fragments has been improved.
- Bugs in memory barriers and spinlocks for x86 and x86_64 architectures have been fixed.
- Profiling and backtracing support have been added.
- Asynchronous I/O has been disabled by default as a workaround for problems with some filesystems.
- Minor timeout bugs have been fixed.

Desperado is a library of reusable object-oriented components written in C++ and C. It was developed to capture some of the useful design patterns we encountered in embedded applications and found ourselves re-implementing from project to project, while (we hope) not falling prey to the not-invented-here syndrome.
Desperado project requires a ANSI C99 and ANSI C++ compiler to build. This version runs under Linux and Cygwin, but it is simple to port to other operating systems. Desperado includes the following components:
- FiclShell provides a FORTH-based programmable command-line shell that can access variables and functions with C bindings in the underlying application. It uses Ficl, John Sadlers embeddable, small-footprint FORTH interpreter. It can read and write C variables and call C functions with as many as ten integer arguments. The FORTH data stack can be accessed by the application.
- BandwidthThrottle, CellRateThrottle, ContractThrottle and Exponential Throttle are used for rate control. The various throttle classes implement several rate control strategies, many of which are based on the Generic Cell Rate Algorithm (GCRA).
- Dump displays memory in hexadecimal word or byte format. It sounds mundane, but we use it frequently.
- Input and Output functors offer an consistent abstraction for binary and character I/O. - BufferInput/Output, DescriptorInput/Output, FIleInput/Output, PathInput/Output, and SocketInput/Output are among the I/O functors implemented..
- Print provides formatted output through any output functor.
- Ram is a template that generates efficient hardware memory tests for memory width of any integer data type. It is based an article by Michael Barr in Embedded Systems Programming magazine.
- Crc is a template that generates parameterized sixteen or thirty-two bit cyclic redundancy check algorithms. It is based on the work of Ross Williams at Rocksoft.
CommonEra, LocalTime, AtomicSeconds, LeapSeconds, TimeZone, DaylightSavingTime and others handle the conversion of time values between seconds with nanoseconds, Coordinated Universal Time (UTC), International Atomic Time (TAI), and Local Time, relative to an arbitary time and date in the Common Era. - For example, these components can generate a time stamp in UTC or local time using a time duration relative to when a embedded device was reset. It includes support for time zones, different daylight saving time algorithms, and leap seconds.
- Chain, Link and the template LinkType are a family of classes that support a simple, efficient, data structure that implements doubly linked lists. It implements FIFO, LIFO, and circular linked lists. In O(1) time it can perform operations like insert, remove, push, pop, and getting the head of the list. The Link node an be embedded inside an object, just like a pointer, or used independently, in a manner similar to the structures in the Standard Template Library. An object can be easily managed on multiple chains of links simultaneously. This data structure is useful in real-time applications where the use of the STL might be problematic.
- Number is a template that generates a number parser for any integer type. The base of the input number string is derived from context. The parser is similar to, but more flexible than, the libc functions strtol and strtoul.
- Platform provides an abstract interface to the small number of operating system services needed by Desperado. Linux and Cygwin are derived classes.
- Heap is a malloc-like interface to the C++ heap. malloc is in turn a POSIX-compliant C-binding interface to Heap. This design simplifies introducing a common alternative heap manager into both C++ and C code in a single application.
- Transliterator provides a mechanism for implementing simple time and space efficient table-driven parsers. The examples Word and Attribute are implemented.
- Escape expands and collapses C-style escape sequences. Encode expands and collapses URL-style escape sequences.
- generics is a collection of well tested preprocessor macros that automatically generate handy values, like minimum and maximum signed numbers, for any integer data type. These simplify generic programming, for example when using C++ templates, but are very useful in C as well.
- cxxcapi is a collection of macros and other preprocessor symbols that simplify writing components that can be used with either C or C++ translation units.
- Desperado incorporates many useful architecture patterns. It contains numerous examples of how to incrementally introduce C++ into legacy C code bases, and how to effectively use C++ objects directly from C code. It shows how to abstract out operating system and input/output details to defer their implementation, allowing greater parallel development and easier application porting. It illustrates how to use templates to avoid allocating and freeing memory from the heap in real-time and embedded code. It uses templates to create efficient type-safe variable sized data structures.
- Unit tests are included which serve as coding examples and uses cases. They can be run as main programs, from the FiclShell, or called as functions, enabling them to be run on an embedded target to verify the librarys correct operation on the actual hardware.
- Desperado also contains some perhaps less than successful experiments, such as its use of the placement-new operator in the guise of a preprocessor macro used to reinitialize objects. We may revisit some of these possible mis-features in the future.
Enhancements:
- The use of templates was reconciled with the gnu option -frepo to reduce code bloat.
- No changes were made to interfaces or functionality.

3D Spatialization of Sound is a Linux/X11 port of the 3D spatializer library from the CRC.

This program creates "directional" stereo sound from mono source. CRC folks told me I shouldnt have raised the sampling frequency without adjusting other stuff.

Oh well. This was a proof-of-concept type project anyway. I think to get correct 3D effect, you need to drop sampling rate back to 11025.

To Build the X11 implementation:

1. make
2. cp audio-filter /usr/local/bin
3. mpg123 -m -s some_music.mp3 | audio-filter | aplay -S -s 44100 -f s16l -

audio-filter is implemented as a filter, it reads signed 16 bit mono input at 44100 khz from stdin, and outputs signed 16 bit stereo, 44100 khz output to stdout. You can replace mpg123 with any sound source generating signed 16 bit 44100 khz mono signal. "aplay" is a sound player utility which comes with ALSA linux sound driver. You can use "play" from the sox package, or "ampctl", or any other sound player that would read 44100 khz, signed 16 bit stereo raw data from stdin. For "sox" play script, you would replace "aplay" command line with "play -c 2 -f s -r 44100 -s w -t raw -"

If everything is good, a 640x480 window will come up, with some cryptic writing on the top, a filled circle with an arrow pointing right, and a empty circle slightly to the right of the circle with arrow.

NOTE, that just like in the original Windows implementation, the axiss are reversed. The arrow on the "head" is pointing "forward". So, in the default startup configuration, the sound is located in front of the listener. Moving the sound source "up" moves it to the left of the listener, and "down", to the right. You can visualize this well if you turn your monitor 90 degrees counter
clock wise.

The filled circle with an arrow is your "head"
The empty circle is the "sound source"

You can move the "sound source" around by clicking the mouse at any position in the window, or by clicking on the "sound source" circle, and dragging it to the desired position. Soundfield will be dynamically updated as you do this.

You can move the "head" by moving the mouse to desired position, and right-clicking. The "head" icon will move to the new position and soundfield will be updated.