Free poe component enc flac software for linux

POE::Component::Enc::Flac is a POE component to wrap FLAC encoder flac.

SYNOPSIS

use POE qw(Component::Enc::Flac);

$encoder1 = POE::Component::Enc::Flac->new();
$encoder1->enc(input => "/tmp/track03.wav");

$encoder2 = POE::Component::Enc::Flac->new(
parent => mainSession,
priority => 10,
compression => best,
status => flacStatus,
error => flacEerror,
warning => flacWarning,
done => flacDone,
);
$encoder2->enc(
input => "/tmp/track02.wav",
output => "/tmp/02.flac",
tracknumber => Track 2,
comment => [
title=Birdhouse in your Soul,
artist=They Might be Giants,
date=1990,
origin=CD,
]
);

POE::Kernel->run();

ABSTRACT

POE is a multitasking framework for Perl. FLAC stands for Free Lossless Audio Codec and flac is an encoder for this standard. This module wraps flac into the POE framework, simplifying its use in, for example, a CD music ripper and encoder application. It provides an object oriented interface.

PoJoe Component Libraries project is a set of Java POJO components, originally developed for OSMQ. Developers have found these components useful in building robust enterprise applications.
Of note are: a FIFO queue that utilizes memory until a size threshold is reached, paging overflow elements to a disk cache; a dynamic discovery mechanism for locating remote processes by name over an IP network, eliminating the need to identify a remote service with a specific host computer; and a set of peer-to-peer async message components that support n concurrent message publishers for each named subscriber.
Enhancements:
- Minor enhancements and bugfixes, and changing the license from GNU Lesser to Apache 2.0.

POE::Component::IRC is a fully event-driven IRC client module.

SYNOPSIS

# A simple Rot13 encryption bot

use strict;
use warnings;
use POE qw(Component::IRC);

my $nickname = Flibble . $$;
my $ircname = Flibble the Sailor Bot;
my $ircserver = irc.blahblahblah.irc;
my $port = 6667;

my @channels = ( #Blah, #Foo, #Bar );

# We create a new PoCo-IRC object and component.
my $irc = POE::Component::IRC->spawn(
nick => $nickname,
server => $ircserver,
port => $port,
ircname => $ircname,
) or die "Oh noooo! $!";

POE::Session->create(
package_states => [
main => [ qw(_default _start irc_001 irc_public) ],
],
heap => { irc => $irc },
);

$poe_kernel->run();
exit 0;

sub _start {
my ($kernel,$heap) = @_[KERNEL,HEAP];

# We get the session ID of the component from the object
# and register and connect to the specified server.
my $irc_session = $heap->{irc}->session_id();
$kernel->post( $irc_session => register => all );
$kernel->post( $irc_session => connect => { } );
undef;
}

sub irc_001 {
my ($kernel,$sender) = @_[KERNEL,SENDER];

# Get the components object at any time by accessing the heap of
# the SENDER
my $poco_object = $sender->get_heap();
print "Connected to ", $poco_object->server_name(), "n";

# In any irc_* events SENDER will be the PoCo-IRC session
$kernel->post( $sender => join => $_ ) for @channels;
undef;
}

sub irc_public {
my ($kernel,$sender,$who,$where,$what) = @_[KERNEL,SENDER,ARG0,ARG1,ARG2];
my $nick = ( split /!/, $who )[0];
my $channel = $where->[0];

if ( my ($rot13) = $what =~ /^rot13 (.+)/ ) {
$rot13 =~ tr[a-zA-Z][n-za-mN-ZA-M];
$kernel->post( $sender => privmsg => $channel => "$nick: $rot13" );
}
undef;
}

# We registered for all events, this will produce some debug info.
sub _default {
my ($event, $args) = @_[ARG0 .. $#_];
my @output = ( "$event: " );

foreach my $arg ( @$args ) {
if ( ref($arg) eq ARRAY ) {
push( @output, "[" . join(" ,", @$arg ) . "]" );
} else {
push ( @output, "$arg" );
}
}
print STDOUT join , @output, "n";
return 0;
}

POE::Component::IRC is a POE component (whod have guessed?) which acts as an easily controllable IRC client for your other POE components and sessions. You create an IRC component and tell it what events your session cares about and where to connect to, and it sends back interesting IRC events when they happen. You make the client do things by sending it events. Thats all there is to it. Cool, no?

[Note that using this module requires some familiarity with the details of the IRC protocol. Id advise you to read up on the gory details of RFC 1459 before you get started. Keep the list of server numeric codes handy while you program. Needless to say, youll also need a good working knowledge of POE, or this document will be of very little use to you.]
The POE::Component::IRC distribution has a docs/ folder with a collection of salient documentation including the pertinent RFCs.

POE::Component::IRC consists of a POE::Session that manages the IRC connection and dispatches irc_ prefixed events to interested sessions and an object that can be used to access additional information using methods.

Sessions register their interest in receiving irc_ events by sending register to the component. One would usually do this in your _start handler. Your session will continue to receive events until you unregister. The component will continue to stay around until you tell it not to with shutdown.

The SYNOPSIS demonstrates a fairly basic bot.

POE::Component::OSCAR is a POE component for the Net::OSCAR module.

SYNOPSIS

use POE qw(Component::OSCAR);

[ ... POE set up ... ]

sub _start { # start an OSCAR session $oscar = POE::Component::OSCAR->new();
# start an OSCAR session with automatic throttling of new connections
# to prevent being banned by the server
$oscar = POE::Component::OSCAR->new( throttle => 4 );

# set up the "im_in" callback to call your state, "im_in_state"
$oscar->set_callback( im_in => im_in_state);

# its good to detect errors if you dont want to get banned
$oscar->set_callback( error => error_state );
$oscar->set_callback( admin_error => admin_erro_stater );
$oscar->set_callback( rate_alert => rate_alert_state );

# sign on
$oscar->signon( screenname => $MY_SCREENNAME, password => $MY_PASSWORD );
}
sub im_in_state { my ($nothing, $args) = @_[ARG0..$#_]; my ($object, $who, $what, $away) = @$args;
print "Got $what from $whon";
}

Simple components for Ada library 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 of the License, or (at your option) any later version.
This library 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.
As a special exception, if other files instantiate generics from this unit, or you link this unit with other files to produce an executable, this unit does not by itself cause the resulting executable to be covered by the GNU General Public License.
This exception does not however invalidate any other reasons why the executable file might be covered by the GNU Public License.
Enhancements:
- Functions Is_In were added for doubly-linked webs and lists. GPS project files were added for GNAT users.

POE::Component::Client::Halo is an implementation of the Halo query protocol.

SYNOPSIS

use Data::Dumper; # for the sample below
use POE qw(Component::Client::Halo);

my $halo = new POE::Component::Client::Halo(
Alias => halo,
Timeout => 15,
Retry => 2,
);

$kernel->post(halo, info, 127.0.0.1, 2302, pbhandler, ident);

$kernel->post(halo, detail, 127.0.0.1, 2302, pbhandler, ident);

sub postback_handler {
my ($ip, $port, $command, $identifier, $response) = @_;
print "Halo query $command_executed on ";
print " at $ip:$port";
print " had a identifier of $identifier" if defined $identifier;
print " returned from the server with:";
print Dumper($response), "nn";
}

POE::Component::Client::Halo is an implementation of the Halo query protocol. It was reverse engineered with a sniffer and two cups of coffee. This is a preliminary release, based version 1.00.01.0580 of the dedicated server (the first public release). It is capable of handling multiple requests of different types in parallel.

POE::Component::Client::SMTP is a Perl module for asynchronous mail sending with POE. Thus your program isnt blocking while busy talking with an (E)SMTP server.

SYNOPSIS

Warning! The following examples are not complete programs, and arent designed to be run as full blown applications. Their purpose is to quickly introduce you to the module.

For complete examples, check the eg directory that can be found in the distributions kit.

A simple example:

# load PoCoClient::SMTP
use POE::Component::Client::SMTP;
# spawn a session
POE::Component::Client::SMTP->send(
From => foo@baz.com,
To => john@doe.net,
Server => relay.mailer.net,
SMTP_Success => callback_event_for_success,
SMTP_Failure => callback_event_for_failure,
);
# and you are all set ;-)
A more complex example:
# load PoCoClient::SMTP
use POE::Component::Client::SMTP;
# spawn a session
POE::Component::Client::SMTP->send(
# Email related parameters
From => foo@baz.com,
To => [
john@doe.net,
andy@zzz.org,
peter@z.net,
george@g.com,
],
Body => $email_body, # heres where your message is stored
Server => relay.mailer.net,
Timeout => 100, # 100 seconds before timeouting
# POE related parameters
Alias => pococlsmtpX,
SMTP_Success => callback_event_for_success,
SMTP_Failure => callback_event_for_failure,
);
# and you are all set

POE::Component::Client::HTTP is a HTTP user-agent component.

SYNOPSIS

use POE qw(Component::Client::HTTP);

POE::Component::Client::HTTP->spawn(
Agent => SpiffCrawler/0.90, # defaults to something long
Alias => ua, # defaults to weeble
From => spiffster@perl.org, # defaults to undef (no header)
Protocol => HTTP/0.9, # defaults to HTTP/1.1
Timeout => 60, # defaults to 180 seconds
MaxSize => 16384, # defaults to entire response
Streaming => 4096, # defaults to 0 (off)
FollowRedirects => 2 # defaults to 0 (off)
Proxy => "http://localhost:80", # defaults to HTTP_PROXY env. variable
NoProxy => [ "localhost", "127.0.0.1" ], # defs to NO_PROXY env. variable
);

$kernel->post(
ua, # posts to the ua alias
request, # posts to uas request state
response, # which of our states will receive the response
$request, # an HTTP::Request object
);

# This is the sub which is called when the session receives a
# response event.
sub response_handler {
my ($request_packet, $response_packet) = @_[ARG0, ARG1];

# HTTP::Request
my $request_object = $request_packet->[0];

# HTTP::Response
my $response_object = $response_packet->[0];

my $stream_chunk;
if (! defined($response_object->content)) {
$stream_chunk = $response_packet->[1];
}

print(
"*" x 78, "n",
"*** my request:n",
"-" x 78, "n",
$request_object->as_string(),
"*" x 78, "n",
"*** their response:n",
"-" x 78, "n",
$response_object->as_string(),
);

if (defined $stream_chunk) {
print "-" x 40, "n", $stream_chunk, "n";
}

print "*" x 78, "n";
}

POE::Component::Client::HTTP is an HTTP user-agent for POE. It lets other sessions run while HTTP transactions are being processed, and it lets several HTTP transactions be processed in parallel.

If POE::Component::Client::DNS is also installed, Client::HTTP will use it to resolve hosts without blocking. Otherwise it will use gethostbyname(), which may have performance problems.

HTTP client components are not proper objects. Instead of being created, as most objects are, they are "spawned" as separate sessions. To avoid confusion (and hopefully not cause other confusion), they must be spawned with a spawn method, not created anew with a new one.