wav format

Format floppy disks easy. Just run the program and you are ready to format your disks.

Switch audio file conversion software is a sound file format converter for Windows or Mac. It is able to convert and encode audio files from many different file formats into mp3, wav or wma files including wav to mp3, mp3 to wav, wma to mp3 and much more (see the supported formats list below).

Switch audio file converter is very easy to use. Just add the files you want to convert to the list, select the format you want to use, and then click the convert button.

Converts a variety of audio file formats to mp3 or wav such as:
· wav, mp3, au
· aif/aiff, gsm, vox
· raw, ogg, flac
· aac, mp2, m4a,
· .mov, .amr and many more formats.

Here are some key features of "Switch File Format Converter":

· MP3 encoder supports constant or variable bit rates from 8 to 320kbps with optional error correction and stereo modes.
· WAV encoder supports sample rates between 6000 and 196000Hz in PCM as well as a number of other audio codecs.
· Allows up to 32000 files to be converted in one batch.
· Can be run from the command line for automation with other applications.
· Optimized CPU usage and efficient code allows for fastest conversion times.
· Switch Sound File Converter integrates directly with other sound software programs including:
· Express Burn for CD Recording,
· Express Rip for Direct CD Ripping,
· WavePad for Sound File Editing,
· RecordPad for Professional Sound Recording and
· Express Scribe for Typing Voice Recordings.
· Switch audio file converter has an intuitive and easy to use interface.
· Compress wav to mp3 files to save hard drive space.
· To open or convert strange or audio file formats not supported by other audio software you use.
· Convert multiple format audio files to mp3 for your iPod, PSP or phone.
· In professional audio studios to open formats not supported by your sound editor.
· As a command line plugin for other software to convert or compress audio files.

OODoc::Format::Pod is a Perl module to produce POD pages from the doc tree.

INHERITANCE

OODoc::Format::Pod
is an OODoc::Format
is an OODoc::Object

OODoc::Format::Pod is extended by
OODoc::Format::Pod2

SYNOPSIS

my $doc = OODoc->new(...);
$doc->create
( pod
, format_options => [show_examples => NO]
, append => "extra textn"
);

Create manual pages in the POD syntax. POD is the standard document description syntax for Perl. POD can be translated to many different operating system specific manual systems, like the Unix man system.

Mork Format Parser description
An efficient C++ implementation of Mork database format reader. MorkParser was designed to be an efficient C++ implementation of Mork database format reader.

It is dependant on Trolltech Qt, but this dependency can be easily removed.

DateTime::Format::Strptime is a Perl module to parse and format strp and strf time patterns.

SYNOPSIS

use DateTime::Format::Strptime;

my $Strp = new DateTime::Format::Strptime(
pattern => %T,
locale => en_AU,
time_zone => Australia/Melbourne,
);

my $dt = $Strp->parse_datetime(23:16:42);

$Strp->format_datetime($dt);
# 23:16:42



# Croak when things go wrong:
my $Strp = new DateTime::Format::Strptime(
pattern => %T,
locale => en_AU,
time_zone => Australia/Melbourne,
on_error => croak,
);

$newpattern = $Strp->pattern(%Q);
# Unidentified token in pattern: %Q in %Q at line 34 of script.pl

# Do something else when things go wrong:
my $Strp = new DateTime::Format::Strptime(
pattern => %T,
locale => en_AU,
time_zone => Australia/Melbourne,
on_error => &phone_police,
);

This module implements most of strptime(3), the POSIX function that is the reverse of strftime(3), for DateTime. While strftime takes a DateTime and a pattern and returns a string, strptime takes a string and a pattern and returns the DateTime object associated.

Perfect Format is an HTC (HTML Component) designed to format and validate web page input, keystroke by keystroke as data is entered. Perfect Format decreases web page development time and increases web page usability.

Phone numbers fields, numeric fields, date fields and many more input types can be masked so that input is controlled as data is entered.

Perfect Format is changing the way developers think about web page design and it is changing the expectations of the web user.

Perfect Format is easy to implement for web page designers and developers, requires little or no programming and does not have to be installed on individual client browsers.

NOTE: Some HTML experience is required to implement Perfect Format. Some vbscript or jscript experience may be required, depending upon the desired results. Free upgrades and support to registered users. 30 day money back guarantee.

Here are some key features of "Perfect Format":

· Zero deployment. Perfect Format is an HTC (HTML Component), not an activeX control. Simply copy it to your web server and go.
· Works on all web server platforms because it is 100% client-side code
· Greatly decreases web page development time
· Provides impressive input and edit mask capabilities
· Eliminates 99% of web page input validation code, reducing the amount of HTML scripting required
· Error messages related to invalid input are almost totally eliminated because most validation occurs as data is entered
· Provides users with visual clues as to the format of acceptable data and restricts and formats data entry on a character by character basis
· Easily pays for itself on the first project where Perfect Format is used
· Obsoletes pattern matching validation techniques
· Free upgrades and support to registered users
· 30 day money back guarantee

The AlgoSuite Format Converter plug-ins are designed to perform high-quality format conversion between SDTV, HDTV and film images. It includes Anti-Aliasing Processor (AAP), Motion Adaptive Anti-Aliasing De-interlacer (MAADI), Inverse Telecine Restorer (CINE), Content Adaptive Scaler (CAS) and Frame Rate Converter (FRC) packaged in individual plug-in nodes that can be sequenced in the flow graph to program the desired format conversion operation in Digital Fusion or packaged into a convenient Format Converter node (FC) in After Effects and inside the FileIn node in Shake.

Here are some key features of "AlgoSuite Format Converter":

· Resolution independent images
· Supports 8-bit, 16-bit and floating-point color components
· Dual-Processor support for faster rendering
· Render-only licenses available
· Available on Windows XP and Mac OS X depending on host application.

Fortran::Format is a Perl module to read and write data according to a standard Fortran 77 FORMAT.

SYNOPSYS

use Fortran::Format;

my $f = Fortran::Format->new("2(N: ,I4,2X)");
print $f->write(1 .. 10);
# prints the following:
# N: 1 N: 2
# N: 3 N: 4
# N: 5 N: 6
# N: 7 N: 8
# N: 9 N: 10

# if you dont want to save the format object,
# just chain the calls:
Fortran::Format->new("2(N: ,I4,2X)")->write(1 .. 10);

This is a Perl implementation of the Fortran 77 formatted input/output facility. One possible use is for producing input files for old Fortran programs, making sure that their column-oriented records are rigorously correct. Fortran formats may also have some advantages over printf in some cases: it is very easy to output an array, reusing the format as needed; and the syntax for repeated columns is more concise. Unlike printf, for good or ill, Fortran-formatted fields never exceed their desired width. For example, compare

printf "%3d", 12345; # prints "12345"
print Fortran::Format->new("I3")->write(12345); # prints "***"

This implementation was written in pure Perl, with portability and correctness in mind. It implements the full ANSI standard for Fortran 77 Formats (or at least it should). It was not written with speed in mind, so if you need to process millions of records it may not be what you need.

Time::Format is a Perl module for easy-to-use date/time formatting.

SYNOPSIS

use Time::Format qw(%time %strftime %manip);

$time{$format}
$time{$format, $unixtime}

print "Today is $time{yyyy/mm/dd}n";
print "Yesterday was $time{yyyy/mm/dd, time-24*60*60}n";
print "The time is $time{hh:mm:ss}n";
print "Another time is $time{H:mm am tz, $another_time}n";
print "Timestamp: $time{yyyymmdd.hhmmss.mmm}n";
%time also accepts Date::Manip strings and DateTime objects:
$dm = Date::Manip::ParseDate(last monday);
print "Last monday was $time{Month d, yyyy, $dm}";
$dt = DateTime->new (....);
print "Heres another date: $time{m/d/yy, $dt}";
It also accepts most ISO-8601 date/time strings:
$t = 2005/10/31T17:11:09; # date separator: / or - or .
$t = 2005-10-31 17.11.09; # in-between separator: T or _ or space
$t = 20051031_171109; # time separator: : or .
$t = 20051031171109; # separators may be omitted
$t = 2005/10/31; # date-only is okay
$t = 17:11:09; # time-only is okay
# But not:
$t = 20051031; # date-only without separators
$t = 171109; # time-only without separators
# ...because those look like epoch time numbers.
%strftime works like POSIXs strftime, if you like those %-formats.
$strftime{$format}
$strftime{$format, $unixtime}
$strftime{$format, $sec,$min,$hour, $mday,$mon,$year, $wday,$yday,$isdst}

print "POSIXish: $strftime{%A, %B %d, %Y, 0,0,0,12,11,95,2}n";
print "POSIXish: $strftime{%A, %B %d, %Y, 1054866251}n";
print "POSIXish: $strftime{%A, %B %d, %Y}n"; # current time
%manip works like Date::Manips UnixDate function.
$manip{$format};
$manip{$format, $when};

print "Date::Manip: $manip{%m/%d/%Y}n"; # current time
print "Date::Manip: $manip{%m/%d/%Y,last Tuesday}n";
These can also be used as standalone functions:
use Time::Format qw(time_format time_strftime time_manip);

print "Today is ", time_format(yyyy/mm/dd, $some_time), "n";
print "POSIXish: ", time_strftime(%A %B %d, %Y,$some_time), "n";
print "Date::Manip: ", time_manip(%m/%d/%Y,$some_time), "n";

This module creates global pseudovariables which format dates and times, according to formatting codes you pass to them in strings.

The %time formatting codes are designed to be easy to remember and use, and to take up just as many characters as the output time value whenever possible. For example, the four-digit year code is "yyyy", the three-letter month abbreviation is "Mon".

The nice thing about having a variable-like interface instead of function calls is that the values can be used inside of strings (as well as outside of strings in ordinary expressions). Dates are frequently used within strings (log messages, output, data records, etc.), so having the ability to interpolate them directly is handy.

Perl allows arbitrary expressions within curly braces of a hash, even when that hash is being interpolated into a string. This allows you to do computations on the fly while formatting times and inserting them into strings. See the "yesterday" example above.

The format strings are designed with programmers in mind. What do you need most frequently? 4-digit year, month, day, 24-based hour, minute, second -- usually with leading zeroes. These six are the easiest formats to use and remember in Time::Format: yyyy, mm, dd, hh, mm, ss. Variants on these formats follow a simple and consistent formula. This module is for everyone who is weary of trying to remember strftime(3)s arcane codes, or of endlessly writing $t[4]++; $t[5]+=1900 as you manually format times or dates.

Note that mm (and related codes) are used both for months and minutes. This is a feature. %time resolves the ambiguity by examining other nearby formatting codes. If its in the context of a year or a day, "month" is assumed. If in the context of an hour or a second, "minute" is assumed.

The format strings are not meant to encompass every date/time need ever conceived. But how often do you need the day of the year (strftimes %j) or the week number (strftimes %W)?

For capabilities that %time does not provide, %strftime provides an interface to POSIXs strftime, and %manip provides an interface to the Date::Manip modules UnixDate function.

If the companion module Time::Format_XS is also installed, Time::Format will detect and use it. This will result in a significant speed increase for %time and time_format.

DateTime::Format::Excel is a Perl module that can convert between DateTime and Excel dates.

SYNOPSIS

use DateTime::Format::Excel;

# From Excel via class method:

my $datetime = DateTime::Format::Excel->parse_datetime( 37680 );
print $datetime->ymd(.); # 2003.02.28

# or via an object

my $excel = DateTime::Format::Excel->new();
print $excel->parse_datetime( 25569 )->ymd; # 1970-01-01

# Back to Excel number:

use DateTime;
my $dt = DateTime->new( year => 1979, month => 7, day => 16 );
my $daynum = DateTime::Format::Excel->format_datetime( $dt );
print $daynum; # 29052

# or via an object
my $other_daynum = $excel->format_datetime( $dt );
print $other_daynum; # 29052

Excel uses a different system for its dates than most Unix programs. This module allows you to convert between a few of the Excel raw formats and DateTime objects, which can then be further converted via any of the other DateTime::Format::* modules, or just with DateTimes methods.

If you happen to be dealing with dates between 1 Jan 1900 and 1 Mar 1900 please read the notes on epochs.

If youre wanting to handle actual spreadsheet files, you may find Spreadsheet::WriteExcel and Spreadsheet::ParseExcel of use.

DateTime::Format::Pg is a Perl module to parse and format PostgreSQL dates and times.

SYNOPSIS

use DateTime::Format::Pg;

my $dt = DateTime::Format::Pg->parse_datetime( 2003-01-16 23:12:01 );

# 2003-01-16T23:12:01+0200
DateTime::Format::Pg->format_datetime($dt);

This module understands the formats used by PostgreSQL for its DATE, TIME, TIMESTAMP, and INTERVAL data types. It can be used to parse these formats in order to create DateTime or DateTime::Duration objects, and it can take a DateTime or DateTime::Duration object and produce a string representing it in a format accepted by PostgreSQL.

CONSTRUCTORS

The following methods can be used to create DateTime::Format::Pg objects.
new( name => value, ... )

Creates a new DateTime::Format::Pg instance. This is generally not required for simple operations. If you wish to use a different parsing style from the default then it is more comfortable to create an object.

my $parser = DateTime::Format::Pg->new()
my $copy = $parser->new( european => 1 );

This method accepts the following options:

european

If european is set to non-zero, dates are assumed to be in european dd/mm/yyyy format. The default is to assume US mm/dd/yyyy format (because this is the default for PostgreSQL).

This option only has an effect if PostgreSQL is set to output dates in the PostgreSQL (DATE only) and SQL (DATE and TIMESTAMP) styles.
Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

server_tz

This option can be set to a DateTime::TimeZone object or a string that contains a time zone name.

This value must be set to the same value as the PostgreSQL servers time zone in order to parse TIMESTAMP WITH TIMEZONE values in the PostgreSQL, SQL, and German formats correctly.

Note that you dont have to set this option if the PostgreSQL server has been set to use the ISO format, which is the default.

clone()

This method is provided for those who prefer to explicitly clone via a method called clone().

my $clone = $original->clone();

If called as a class method it will die.

DateTime::Format::Builder is a Perl module to create datetime parser classes and objects.

SYNOPSIS

package DateTime::Format::Brief;
our $VERSION = 0.07;
use DateTime::Format::Builder
(
parsers => {
parse_datetime => [
{
regex => qr/^(d{4})(dd)(dd)(dd)(dd)(dd)$/,
params => [qw( year month day hour minute second )],
},
{
regex => qr/^(d{4})(dd)(dd)$/,
params => [qw( year month day )],
},
],
}
);

DateTime::Format::Builder creates DateTime parsers. Many string formats of dates and times are simple and just require a basic regular expression to extract the relevant information. Builder provides a simple way to do this without writing reams of structural code.

Builder provides a number of methods, most of which youll never need, or at least rarely need. Theyre provided more for exposing of the modules innards to any subclasses, or for when you need to do something slightly beyond what I expected.

Switch is an easy-to-use sound file converter. It can convert audio files from many different file formats into mp3 or wav files.

Switch is very easy to use. Just add the files you want to convert to the list, select the format you want to use, and then click the convert button.

A full list of the Switch Sound Format Converter features follow but a quick way to try it out is to download and install now. You dont need to purchase and it only takes a couple of minutes to complete the process (click here to install).

The Switch Sound File Converter is free.

Features:

· Converts a variety of different audio file formats including wav, mp3, ogg, flac, aac, wma, au, gsm and dss formats into mp3 or wav.
· MPEG Layer-3 encoder supports constant or variable bit rates from 8 to 320kbps with optional error correction and stero modes.
· WAV encoder support sample rates between 6000 and 196000Hz in PCM or a number of other codecs.
· Up to 32000 files can be converted in one batch.
· Optimized CPU usage and efficient code for fastest conversion times.
· Integrates directly with other sound software programs including Express Burn for CD Recording, Express Rip for Direct CD Ripping, WavePad for Sound File Editing, RecordPad for Professional Sound Recording and Express Scribe for Typing Voice Recordings.
· Intuitive and easy to use interface.

DateTime::Format::Epoch is a Perl module that can convert DateTimes to/from epoch seconds.

SYNOPSIS

use DateTime::Format::Epoch;

my $dt = DateTime->new( year => 1970, month => 1, day => 1 );
my $formatter = DateTime::Format::Epoch->new(
epoch => $dt,
unit => seconds,
type => int, # or float, bigint
skip_leap_secondss => 1,
start_at => 0,
local_epoch => undef,
);

my $dt2 = $formatter->parse_datetime( 1051488000 );
# 2003-04-28T00:00:00

$formatter->format_datetime($dt2);
# 1051488000

This module can convert a DateTime object (or any object that can be converted to a DateTime object) to the number of seconds since a given epoch. It can also do the reverse.