Result:
found more than 953 distributions - search limited to the first 2001 files matching your query
( run in 1.762 )
Audio-LibSampleRate
view release on metacpan or search on metacpan
libsamplerate/doc/api_full.html view on Meta::CPAN
output frames.
</P>
<P>
The <B>src_process</B> function returns non-zero if an error occurs.
The non-zero error return value can be decoded into a text string using the function
documented <A HREF="api_misc.html#ErrorReporting">here</A>.
</P>
<A NAME="Reset"></A>
<H3><BR>Reset</H3>
libsamplerate/doc/api_full.html view on Meta::CPAN
<B>src_callback_process</B>.
<p/>
<P>
This function returns non-zero on error and the error return value can be
decoded into a text string using the function documented
<A HREF="api_misc.html#ErrorReporting">here</A>.</P>
<!-- <A HREF="mailto:aldel@mega-nerd.com">For the spam bots</A> -->
</DIV>
Audio-M4P
view release on metacpan or search on metacpan
lib/Audio/M4P.pm view on Meta::CPAN
print "Artist is $tags->{ARTIST}\n" if $tags->{ARTIST};
use Audio::M4P::Decrypt;
my $outfile = 'mydecodedfile';
my $deDRMS = new Audio::M4P::Decrypt;
$deDRMS->DeDRMS($mp4file, $outfile);
See also the individual pod documentation for Audio::M4P::QuickTime
and Audio::M4P::Decrypt.
Audio-MPC
view release on metacpan or search on metacpan
lib/Audio/MPC.pm view on Meta::CPAN
Returns the newly created object or C<undef> in case of an error. In this case,
check C<< Audio::MPC->errstr >>.
=item B<decode> (buffer, [ MPC_LITTLE_ENDIAN || MPC_BIG_ENDIAN ])
Reads data from the audio-stream and puts the decoded PCM-samples into
I<buffer> which must not be readonly. The PCM data will be stereo (that is, two
channels) and 44.1 kHZ with each sample 16 bit wide.
The optional second argument specifies the byte-order of each sample. If not
specified, I<MPC_LITTLE_ENDIAN> is assumed.
Returns the length of I<buffer>, "0 but true" if the stream was succesfully
decoded with no more samples left and false in case of an error.
=item B<errstr>
This class method returns a string telling you what kind of error occured.
Currently, only use this method after the constructor C<new> failed to return a
lib/Audio/MPC.pm view on Meta::CPAN
=item * canseek (reader)
The function is expected to return a true value if the underlying filehandle
is seekable. However, experiments showed that non-seekable streams cannot be
decoded and are therefore not handled at all:
sub canseek {
my $reader = shift;
return seek $reader->fh, 0, SEEK_CUR; # test if seek succeeded
}
Audio-MPEG
view release on metacpan or search on metacpan
=item B<new>()
This creates a new object. Each object has it's own private context, so
it is possible to have more than one object created at a time.
Once a stream has started to be decoded, the object may only be used for
that stream (due to state information kept in the object).
=item B<$len> = B<buffer>(I<$data>)
This method adds an arbitrary "chunk" of input MP3 data to the internal
buffering pool. Typically, this is at least 4KB of data. A good length
of data to pass is 40KB (approximately 1 second of audio encoded at 320kbps
or 2.5 seconds of audio encoded at 128KBs).
Method returns the length of data, in bytes, that has not be decoded yet.
=item B<decode_frame>()
This method will process the next MP3 frame of the data that has been
buffered with B<buffer>(), prepares it for PCM synthesis. The prepared
data is stored in the object. Do not use both this function and
B<decode_frame_header>() on the same object.
Method returns 1 if a frame was decoded (successfully or not), and 0
if it ran out of data before finishing decoding.
Upon return, program should interrogate I<$obj->err>. If it is > 0, then
a decoding error has occurred, and no PCM synthesis is possible (i.e. frame
should be skipped). See the EXAMPLES section later in this document.
Returns an English string describing the error condition.
=item B<current_frame>()
Returns the current MP3 frame that was decoded.
=item B<total_frames>()
Returns the total number of MP3 frames decoded. Used after decoding has
been completed.
=item B<frame_duration>()
Returns the length of the frame, in seconds, that was decoded.
=item B<total_duration>()
Returns the total duration, in seconds, that was decoded. Used after decoding
has been completed.
=item B<bit_rate>()
Returns the bitrate, in kbs, of the frame that was decoded.
=item B<average_bit_rate>()
Returns the average bitrate of the decoded frames. Used after decoding has
been completed.
=item B<sample_rate>()
Returns the samplerate, in Hertz, of the decoded frame.
=item B<layer>()
Returns the MPEG audio layer number of the decoded frame.
=item B<channels>()
Returns the number of PCM channels that were decoded (1 or 2) of the
decoded frame.
=item B<pcm>()
Returns the synthesized PCM structure of the decoded/synthesized frame.
This format is in a 24bit fixed-point format, and is only intended for
passing to an B<Audio::MPEG::Output> object. It is also intended to be
used by a planned future filtering object.
=back
=item B<header>($I<datasize>)
This method will return a header (first few bytes of data) that is valid
for the output type. $I<datasize> refers to the length of audio data in bytes.
If not passed the length, B<header>() will output a valid header, except that
the embedded length will be zero. After the sample is decoded, header is
typically called again, and re-written to the beginning of the file (see
the EXAMPLE section of the document). If called with an object type that
does not have a header, this returns an empty scalar.
Currently, only Sun mulaw and WAV formats have headers.
Audio-Mad
view release on metacpan or search on metacpan
lib/Audio/Mad/Frame.pm view on Meta::CPAN
=item * bitrate
=item * samplerate
These functions retrieve the information from the currently
decoded frame header. layer, mode, and flags correspond
to the MAD_LAYER_, MAD_MODE_, and MAD_FLAG_ constants.
bitrate and samplerate are represented as integers.
=item * duration
Returns the duration of the currently decoded frame as an
Audio::Mad::Timer object. See Audio::Mad::Timer's manpage
for details on what this means.
=item * NCHANNELS
Audio-Opusfile
view release on metacpan or search on metacpan
lib/Audio/Opusfile.pm view on Meta::CPAN
in the first logical Opus stream.
=item $of->B<bitrate_instant>
Compute the instantaneous bitrate, measured as the ratio of bits to
playable samples decoded since a) the last call to B<bitrate_instant>,
b) the last seek, or c) the start of playback, whichever was most
recent.
This will spike somewhat after a seek or at the start/end of a chain
boundary, as pre-skip, pre-roll, and end-trimming causes samples to be
decoded but not played.
=item $of->B<raw_tell>
Obtain the current value of the position indicator of I<$of>. This is
the byte position that is currently being read from.
lib/Audio/Opusfile.pm view on Meta::CPAN
exactly the requested position. The PCM offset is in samples at 48 kHz
relative to the start of the stream.
=item $of->B<set_gain_offset>(I<$gain_type>, I<$gain_offset>)
Sets the gain to be used for decoded output.
By default, the gain in the header is applied with no additional
offset. The total gain (including header gain and/or track gain, if
applicable, and this offset), will be clamped to [-32768,32767]/256
dB. This is more than enough to saturate or underflow 16-bit PCM.
B<Note:> The new gain will not be applied to any already buffered,
decoded output. This means you cannot change it sample-by-sample, as
at best it will be updated packet-by-packet. It is meant for setting a
target volume level, rather than applying smooth fades, etc.
I<$gain_type> is one of OP_HEADER_GAIN, OP_TRACK_GAIN, or
OP_ABSOLUTE_GAIN. I<$gain_offset> is in 1/256ths of a dB.
lib/Audio/Opusfile.pm view on Meta::CPAN
It is recommended to use B<read_float> instead of this method if the
rest of your audio processing chain can handle floating point.
Reads more samples from the stream. I<$bufsize> is the maximum number
of samples read, and it defaults to 1048576. Returns a list whose
first element is the link index this data was decoded from, and the
rest of the elements are PCM samples, as signed 16-bit values at 48
kHz with a nominal range of [-32768,32767). Multiple channels are
interleaved using the L<Vorbis channel ordering|https://www.xiph.org/vorbis/doc/Vorbis_I_spec.html#x1-810004.3.9>.
You can use C<< $of->head($li)->channel_count >> to find out the
Audio-Play-MPG123
view release on metacpan or search on metacpan
mpg123/INSTALL view on Meta::CPAN
Some additional remarks:
- There is currently no direct audio hardware support for some
hardware and (of course) "generic" targets. That means that you
have to use the "-s" commandline option to write the decoded audio
data to stdout.
- On Solaris, use Sun's SparcWorks compiler ("make solaris")
if at all possible. It generates faster code than gcc, so
use gcc only if there's no other way.
Audio-RaveMP
view release on metacpan or search on metacpan
j = sscanf(p,"%u",&arg);
if (j < 1)
break;
/* Get argument pointer (if any) and return decoded value */
if ((ip=va_arg(ap,unsigned int *)) != NULL)
*ip = arg;
/* Skip field just processed and white space following it */
while (isblank(*p))
p++;
}
return i; /* Return number of fields decoded */
}
/********************** XPV *****************************/
static void XPV(int level,char *fmt,...)
{
/* To be implemented... */
Audio-Scan
view release on metacpan or search on metacpan
the file metadata which may or may not be correct.
- Bundled a win32 build of zlib to make compiling on Windows a bit easier.
0.62 2010-03-02 12:00:00
- INCOMPATIBLE CHANGE: Ogg Vorbis COVERART tags are now translated to an
ALLPICTURES block and are base64-decoded.
- Added support for new Ogg Vorbis cover art tag, METADATA_BLOCK_PICTURE. Data
is returned in the same ALLPICTURES array as for FLAC.
0.61 2010-02-23 22:50:00
- RT 53118: Fixed crash under Perl 5.11.
Audio-TinySoundFont
view release on metacpan or search on metacpan
TinySoundFont/tsf.h view on Meta::CPAN
if (pSmpl >= pSmplEnd) break;
{ int use = stb_vorbis_decode_frame_pushdata(v, pSmpl, (int)(pSmplEnd - pSmpl), TSF_NULL, &outputs, &n_samples); pSmpl += use; }
if (!n_samples) continue;
#endif
// Expand our output buffer if necessary then copy over the decoded frame samples
resNum += n_samples;
if (resNum > resMax)
{
do { resMax += (resMax ? (resMax < 1048576 ? resMax : 1048576) : resInitial); } while (resNum > resMax);
res = (float*)TSF_REALLOC((oldres = res), resMax * sizeof(float));
Audio-WMA
view release on metacpan or search on metacpan
# Error Correction Data BYTESTREAM variable error-correction-specific format data, depending on
# value of Error Correct Type
#
# There is one ASF_Stream_Properties_Object for each stream (audio, video) but the
# stream number isn't known until halfway through decoding the structure, hence it
# it is decoded to a temporary variable and then stuck in the appropriate index later
my $method = $inline ? '_readAndIncrementInlineOffset' : '_readAndIncrementOffset';
$stream{'stream_type'} = $self->$method($GUID);
$stream{'stream_type_guid'} = _byteStringToGUID($stream{'stream_type'});
$stream{'error_correct_type'} = $self->$method($GUID);
Audio-XMMSClient
view release on metacpan or search on metacpan
XMMSClientResult.xs view on Meta::CPAN
=over 4
=item Arguments: $string
=item Return Value: $decoded_url
=back
my $decoded_url = $result->decode_url($url);
my $decoded_url = Audio::XMMSClient::Result->decode_url($url);
Decode an URL-encoded C<$string>.
Some strings (currently only the url of media) has no known encoding, and must
be encoded in an UTF-8 clean way. This is done similar to the url encoding web
browsers do. This functions decodes a string encoded in that way. OBSERVE that
the decoded string HAS NO KNOWN ENCODING and you cannot display it on screen in
a 100% guaranteed correct way (a good heuristic is to try to validate the
decoded string as UTF-8, and if it validates assume that it is an UTF-8 encoded
string, and otherwise fall back to some other encoding).
Do not use this function if you don't understand the implications. The best
thing is not to try to display the url at all.
Audio-aKodePlayer
view release on metacpan or search on metacpan
lib/Audio/aKodePlayer.pm view on Meta::CPAN
Closes the player and releases the output sink.
=item load(filename)
Loads the file from a given filename and prepares it for
playing. Returns false if the file cannot be loaded or decoded.
=item setDecoderPlugin(plugin_name)
Sets the decoder plugin to use. Default is auto-detect.
Aut
view release on metacpan or search on metacpan
Aut/Ticket.pm view on Meta::CPAN
=head3 C<decrypt(ciphertext) --E<gt> string>
=over 1
Decrypts text using L<Aut::Crypt>, after it has been decoded
with L<Aut::Base64>. If the decryption is valid, it returns
the decrypted string, otherwise C<undef> is returned.
=head1 SEE ALSO
Auth-Yubikey_Decrypter
view release on metacpan or search on metacpan
lib/Auth/Yubikey_Decrypter.pm view on Meta::CPAN
my $token_bin = &yubikey_modhex_decode($token);
# Decrypt the token using it's key
my $cipher = Crypt::Rijndael->new( $aeskey_bin );
my $token_decoded_bin = $cipher->decrypt($token_bin);
my $token_decoded_hex = unpack "H*", $token_decoded_bin;
# get all the values from the decoded token
my $secretid_hex = substr($token_decoded_hex,0,12);
my $counter_dec = ord(substr($token_decoded_bin,7,1))*256+ord(substr($token_decoded_bin,6,1));
my $timestamp_dec = ord(substr($token_decoded_bin,10,1))*65536+ord(substr($token_decoded_bin,9,1))*256+ord(substr($token_decoded_bin,8,1));
my $session_use_dec = ord(substr($token_decoded_bin,11,1));
my $random_dec = ord(substr($token_decoded_bin,13,1))*256+ord(substr($token_decoded_bin,12,1));
my $crc_dec = ord(substr($token_decoded_bin,15,1))*256+ord(substr($token_decoded_bin,14,1));
my $crc_ok = &yubikey_crc_check($token_decoded_bin);
return ($publicID,$secretid_hex,$counter_dec,$timestamp_dec,$session_use_dec,$random_dec,$crc_dec,$crc_ok);
}
=head2 yubikey_modhex_decode
Input : the modhex code
Output : decoded modhex code in hex
=cut
sub yubikey_modhex_decode
{
my $mstring = $_[0];
my $cset="cbdefghijklnrtuv";
my $decoded="";
my $hbyte=0;
my $pos;
for (my $i=0; $i<length($mstring);$i++)
{
$pos=index($cset,substr($mstring,$i,1));
if ($i/2 != int($i/2))
{
$decoded .= chr($hbyte+$pos);
$hbyte=0;
}
else
{
$hbyte=$pos*16;
}
}
return $decoded;
}
=head2 yubikey_crc_check
Performs a crc check on the decoded data
=cut
sub yubikey_crc_check
{
Authen-CAS-External
view release on metacpan or search on metacpan
lib/Authen/CAS/External/UserAgent.pm view on Meta::CPAN
# The previous response can determine what occurred
return;
}
# Parse the forms on the page
my @forms = HTML::Form->parse($response->decoded_content, $response->base);
# Find the login form
my $login_form;
FORM: foreach my $form (@forms) {
if (defined $form->find_input('lt')
Authen-CAS-UserAgent
view release on metacpan or search on metacpan
lib/Authen/CAS/UserAgent.pm view on Meta::CPAN
# default heuristic for finding login parameters
my $defaultLoginParamsHeuristic = sub {
my ($service, $response, $ua, $h, @params) = @_;
# find all input controls on the submit form
my $content = $response->decoded_content;
while($content =~ /(\<input.*?\>)/igs) {
my $input = $1;
my $name = $input =~ /name=\"(.*?)\"/si ? $1 : undef;
my $value = $input =~ /value=\"(.*?)\"/si ? $1 : undef;
lib/Authen/CAS/UserAgent.pm view on Meta::CPAN
return $1;
}
}
#check for a javascript window.location.href redirect
if($response->decoded_content =~ /window\.location\.href="[^"]*ticket=([^&"]*?)"/sg) {
return $1;
}
return;
};
lib/Authen/CAS/UserAgent.pm view on Meta::CPAN
'targetService' => $service,
);
# fetch proxy ticket and parse response xml
my $response = $ua->simple_request(HTTP::Request::Common::GET($ptUri));
my $doc = eval {XML::LibXML->new()->parse_string($response->decoded_content('charset' => 'none'))};
if($@ || !$doc) {
$h->{'error'} = ERROR_PROXY_INVALIDRESPONSE;
push @{$h->{'errors'}}, $h->{'error'};
return;
}
lib/Authen/CAS/UserAgent.pm view on Meta::CPAN
#retrieve a ticket for the requested service
my $ticketResponse = $ua->simple_request(HTTP::Request::Common::POST($tgtUri, [
'service' => $service,
]));
return if($ticketResponse->code != 200);
return $ticketResponse->decoded_content;
};
##Static Methods
#return the default user agent for this class
Authen-Passphrase-Argon2
view release on metacpan or search on metacpan
lib/Authen/Passphrase/Argon2.pm view on Meta::CPAN
params
# Only one of these must be defined for the salt value. An error will be thrown if none or more than one is defined.
salt - plain text salt value
salt_hex - salt in hex value that gets decoded.
salt_base64 - salt value encoded in base64 that gets decoded.
salt_random - a random salt will be generated using Data::GUID.
# Only one of these must be defined for the crypt value. An error will be thrown if none or more than one is defined.
passphrase - plain text passpord that will be converted to argon2
hash - plain text argon2 value
Authen-Radius
view release on metacpan or search on metacpan
sub _decode_value {
my ( $self, $vendor, $id, $type, $name, $value, $has_tag ) = @_;
if ( defined $type ) {
if ( exists $decoder{$type} ) {
my ($decoded, $tag) = $decoder{$type}->( $self, $vendor, $id, $name, $value, $has_tag );
return wantarray ? ($decoded, $tag) : $decoded;
}
else {
if ($debug) {
print {*STDERR} "Unsupported type '$type' for attribute with id: '$id'.\n";
}
Authen-SASL-Perl-NTLM
view release on metacpan or search on metacpan
lib/Authen/SASL/Perl/NTLM.pm view on Meta::CPAN
#
sub client_step {
my ( $self, $challenge ) = @_;
if ( defined $challenge ) {
# The challenge has been decoded but Authen::NTLM expects it encoded
$challenge = MIME::Base64::encode_base64($challenge);
# Empty challenge string needs to be undef if we want
# Authen::NTLM::challenge() to generate a type 1 message
$challenge = undef if $challenge eq q{};
Authen-Simple-WebForm
view release on metacpan or search on metacpan
lib/Authen/Simple/WebForm.pm view on Meta::CPAN
if ($self->trace)
{
print STDERR ("-"x80)."\n";
print STDERR "TRACE: initial response, response code [".$res->code."]\n";
print STDERR "TRACE: initial response, cookies [".$ua->cookie_jar->as_string()."]\n";
print STDERR $res->decoded_content;
print STDERR "\n\n\n";
print STDERR ("-"x80)."\n";
}
# make sure status code is ok?
if ($self->check_initial_status_code)
lib/Authen/Simple/WebForm.pm view on Meta::CPAN
{
my $expect = $self->initial_expect;
unless (ref($expect) eq 'Regexp') {
$expect = qr/\Q$expect\E/;
}
unless ($res->decoded_content =~ /$expect/)
{
$self->log->error("Initial url didn't return expected results.") if $self->log;
return 0;
}
}
lib/Authen/Simple/WebForm.pm view on Meta::CPAN
if ($self->trace)
{
print STDERR ("-"x80)."\n";
print STDERR "TRACE: initial response, response code [".$res->code."]\n";
print STDERR "TRACE: initial response, cookies [".$ua->cookie_jar->as_string()."]\n";
print STDERR $res->decoded_content;
print STDERR "\n\n\n";
print STDERR ("-"x80)."\n";
}
# make sure status code is ok?
lib/Authen/Simple/WebForm.pm view on Meta::CPAN
{
my $expect = $self->login_expect;
unless (ref($expect) eq 'Regexp') {
$expect = qr/\Q$expect\E/;
}
unless ($res->decoded_content =~ /$expect/)
{
$self->log->debug("Failed to authenticate user '$full_username'. Reason: Login page response did not match expected value.")
if $self->log;
return 0;
}
Authen-Ticket
view release on metacpan or search on metacpan
lib/Authen/Ticket/Client.pm view on Meta::CPAN
=over 4
=item decode_cookie($class, $ticket)
This subroutine returns the decoded version of the ticket. This is the
place to put decryption of the cookie or other checks that do not
depend on understanding the information within the ticket. The default
version decodes from base 64. The return value is the decoded
string representation of the ticket.
=item deconstruct_cookie($class, $ticket)
This subroutine breaks the ticket apart into field values. The return
Authen-WebAuthn
view release on metacpan or search on metacpan
lib/Authen/WebAuthn.pm view on Meta::CPAN
};
}
sub getAttestationObject {
my ($dat) = @_;
my $decoded = decode_base64url($dat);
my $res = {};
my $h = decode_cbor($decoded);
$res->{authData} = getAuthData( $h->{authData} );
$res->{authDataRaw} = $h->{authData};
$res->{attStmt} = $h->{attStmt};
$res->{fmt} = $h->{fmt};
return $res;
Avro
view release on metacpan or search on metacpan
t/03_bin_decode.t view on Meta::CPAN
my $dec = Avro::BinaryDecoder->decode(
writer_schema => $w_enum,
reader_schema => $r_enum,
reader => $reader,
);
is $dec, $data, "decoded!";
}
for my $data (qw/a z/) {
Avro::BinaryEncoder->encode(
schema => $w_enum,
t/03_bin_decode.t view on Meta::CPAN
writer_schema => $w_schema,
reader_schema => $r_schema,
reader => $reader,
);
is_deeply $dec, $data, "decoded!";
}
## map resolution
{
my $w_schema = Avro::Schema->parse(<<EOP);
t/03_bin_decode.t view on Meta::CPAN
my $dec = Avro::BinaryDecoder->decode(
writer_schema => $w_schema,
reader_schema => $w_schema,
reader => $reader,
);
is_deeply $dec, $data, "decoded succeeded!";
}
## schema upgrade
{
my $w_schema = Avro::Schema->parse(<<EOP);
t/03_bin_decode.t view on Meta::CPAN
my $dec = Avro::BinaryDecoder->decode(
writer_schema => $w_schema,
reader_schema => $w_schema,
reader => $reader,
);
is_deeply $dec, $data, "decoded succeeded! +upgrade";
is $dec->{one}[0], 1.0, "kind of dumb test";
}
done_testing;
AxKit-XSP-WebUtils
view release on metacpan or search on metacpan
WebUtils.pm view on Meta::CPAN
Returns the name of the authenticated user.
=head2 C<<web:password/>>
If the current request is protected by Basic authentication, this tag
will return the decoded password sent by the client.
=head2 C<<web:request_parsed_uri>>
This tag allows you to get the fully parsed URI for the current request.
In contrast to <web:request_uri/> the parsed URI will always include things like
AxKit2
view release on metacpan or search on metacpan
demo/webmail/xmlmail-display.xsl view on Meta::CPAN
<xsl:apply-templates/>
</div>
</xsl:template>
<xsl:template match="htmlpart[@pre='1']">
<!-- <div class="marker">HTML Part (decoded to text):</div> -->
<pre>
<xsl:apply-templates/>
</pre>
</xsl:template>
<xsl:template match="htmlpart">
<!-- <div class="marker">HTML Part (decoded to text):</div> -->
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="textpart">
<!-- <div class="marker">Plain Text Part:</div> -->
BBCode-Parser
view release on metacpan or search on metacpan
lib/BBCode/Util.pm view on Meta::CPAN
} elsif(/^ (\d+) $/x) {
$ch = 0+$1;
}
return sprintf "#x%X", $ch if defined $ch;
my $decoded = HTML::Entities::decode("&$_;");
return undef if $decoded eq "&$_;";
return $_;
}
BEGIN { _export qw(parseListType parse) }
my %listtype = (
BBDB
view release on metacpan or search on metacpan
(birthday "6/15")
)
nil The cache vector - always nil
]
After this is decoded it will be returned as a reference to a BBDB
object. The internal structure of the BBDB object mimics the lisp
structure of the BBDB string. It consists of a reference to an array
with 9 elements The Data::Dumper output of the above BBDB string would
just replaces all of the ()s with []s. It can be accessed by using
the C<$bbdb->part('all')> method. For completeness, here is the output
In version 2.32 of BBDB, despite what the documentation says, it seems
that zip codes are always stored quoted strings, even though it seems
to be impossible to enter anything other than an integer.
Phone numbers may be converted from strings to integers if they are
decoded and encoded. This should not affect the operation of BBDB.
Also a null last name is converted from "" to nil, which also doesn't
hurt anything.
You might ask why I use arrays instead of hashes to encode the data in
the BBDB file. The answer is that order matters in the bbdb file, and
BBS-DiscuzX2
view release on metacpan or search on metacpan
lib/BBS/DiscuzX2.pm view on Meta::CPAN
$self->{site} = $opt{site};
$res = $self->{browser}->get($opt{site}.'forum.php');
return unless($res->is_success);
($self->{formhash}) = $res->decoded_content =~ m/formhash=(\w+)">/s;
return 1;
}
sub post_thread {
my ($self, $data) = @_;
BBS-Perm
view release on metacpan or search on metacpan
lib/BBS/Perm/Plugin/Feed.pm view on Meta::CPAN
=item text
Get the contents of user's input, it's either a command's output or a file's
contents.
Caveat: command output and file contents are decoded by your system LANG or
LC_ALL setting. So, you'd better update the encoding of your file in
accordance with your system settings.
=item widget
( run in 1.762 second using v1.01-cache-2.11-cpan-26ccb49234f )