view release on metacpan or  search on metacpan

bin/query.pl  view on Meta::CPAN

my $iter	= $query->execute( $model );

# print the results as a string to standard output
print $iter->as_string;

### this will allow the results to be printed in a streaming fashion:
### or, if you want to iterate over each result row:
# while (my $s = $iter->next) {
# 	print $s . "\n";
# }

 view release on metacpan or  search on metacpan

lib/RDF/Sesame/Repository.pm  view on Meta::CPAN

resulting RDF.  The minimal method invocation looks like

    my $rdf = $repo->extract( format => 'turtle' )

where C<$rdf> is a reference to a scalar containing the serialization of all
the triples in the repository.  The streaming results returned by Sesame are
handled appropriately so that memory usage in minimized.  If the output is
sent to a file (see L</output>), only one "chunk" is held in memory at a time
(subject to caching by your OS).  The serialization may also be compressed (or
otherwise processed) as it's being streamed from the server (see
L</compress>).

 view release on metacpan or  search on metacpan

Changes.ttl  view on Meta::CPAN

                        asc:update      "Throw exception in RDF::Trine::Node::Resource->new when IRI contains bad characters." ;
                        asc:update      "Fix RDF::Trine::Parser::RDFXML to UTF-8 encode strings before calling into the SAX parser (related to github pull request #82)." ;
                        asc:update      "Fixed typo in exception throwing in RDF::Trine::Parser::TriG." ;
                        asc:update      "Fixed mistaken use of 'otherwise' exception handler in turtle_tokenize.pl." ;
                        asc:update      "Improved error handling in RDF::Trine::Parser->parse_url_into_model." ;
                        asc:update      "Implemented streaming version of RDF::Trine::Parser::RDFXML->parse_file using parse_file from XML::SAX." ;
                        asc:update      "Removed use of given/when statements to make perl 5.18 happy." ;
                        asc:update      "Silence tracing code in RDF::Trine::Store::Hexastore." ;
                        asc:update      "Added TryCatch to list of required modules." ;
                        asc:update      "Changed key names and layout of nodemap data in Redis store." ;
                        ] .

Changes.ttl  view on Meta::CPAN

        doap:Version    [
                        doap:revision     "1.001" ;
                        doap:created      "2012-10-05" ;
                        ];
        asc:changes     [
                        asc:update      "Replaced old Turtle and TriG parsers with new streaming implementations." ;
                        asc:update      "Added RDF::Trine::Node::Literal->canonicalize method." ;
                        asc:update      "Updated RDF::Trine::Parser::Redland to construct a new parser object on each parse (avoiding a bug in redland)." ;
                        asc:update      "Applied partial patch to 'fix interaction with HTML::Data::Parser' (from Dorian Taylor; commit 9b713b23b6)." ;
                        asc:update      "Added Moose and MooseX::ArrayRef to prerequisites list." ;
                        asc:update      "Updated code style to work with Perl::Critic core policies." ;

Changes.ttl  view on Meta::CPAN

        asc:changes     [
                        asc:addition    "Added RDF::Trine::Iterator->count method." ;
                        asc:addition    "Added ability to access the number of rows returned from RDF::Trine::Iterator::Bindings::as_string." ;
                        asc:addition    "Added RDF::Trine::Model::Dataset for constructing views over a model, and RDF::Trine::Model->dataset_model constructor method." ;
                        asc:addition    "Added missing use of Encode to RDF::Trine::Store::Redland." ;
                        asc:addition    "Added bin/rdf_transcode.pl for (streaming) conversion between RDF serialization formats." ;
                        asc:addition    "Added ability for RDF::Trine::Store::Memory to load RDF files by URI in _new_with_string." ;
                        asc:update      "Updated quality value heuristics in RDF::Trine::Serializer::negotiate to prefer turtle if no accept headers are supplied." ;
                        asc:update      "Fixed RDF::Trine::Iterator::Bindings::as_string to respect $max_result_size argument." ;
                        asc:update      "RDF::Trine::Iterator::Bindings::as_string now returns unescaped strings." ;
                        asc:update      "Updated RDF::Trine::Parser::parse_url_into_model to fall back on file extension heuristics if the media-type based parse fails." ;

Changes.ttl  view on Meta::CPAN

                        asc:addition    "Added Text::CSV and HTTP::Negotiate to RDF::Trine prereq list." ;
                        asc:update      "Fixed exception thrown on unrecognized parser name." ;
                        asc:update      "Removed dependency list and added perlrdf link to POD in RDF::Trine and RDF::Query." ;
                        asc:update      "Updated RDF::Trine::Serializer::Turtle->new API to take %args instead of \\%namespaces." ;
                        asc:update      "Updated RDF::Trine::Serializer::RDFXML to take %args and properly accept and serialize xmlns namespaces." ;
                        asc:update      "Updated RDF::Trine::Parser::RDFa to use streaming parsing (instead of materializing the graph first)." ;
                        asc:update      "Updated RDF::Trine::Model::_debug to use quad semantics when getting statement iterator." ;
                        asc:update      "Updated t/parser-turtle.t to use File::Glob::bsd_glob for cases where the test directory's path contains whitespace." ;
                        asc:update      "Removed redundant parse_into_model methods from RDF::Trine::Parser subclasses." ;
                        asc:update      "Renamed examples/create_store.pl to examples/foaf_labels.pl." ;
                        asc:update      "Fixed bug in turtle serializer that improperly serialized bnode objects 'belonging' to a parent bnode." ;

Changes.ttl  view on Meta::CPAN

                        asc:update      "Moved the nested hash join from ::Iterator to ::Iterator::Bindings." ;
                        asc:update      "Pipelined the code for nested loop joins on binding iterators." ;
                        asc:update      "Fixed bug in ::Model::StatementFilter to call join_steams in ::Iterator::Bindings." ;
                        asc:update      "Fixed bug in ::Iterator::Graph::as_bindings where not all arguments are ::Node::Variable objects." ;
                        asc:update      "Updated SPARQL XML Results namespace for boolean iterators." ;
                        asc:update      "Replaced XML::Twig code with new XML::SAX parser (allowing streaming parsing)." ;
                        asc:update      "Moved as_sparql methods from RDF::Trine:: to RDF::Query:: classes." ;
                        asc:update      "RDF::Trine::Iterator::smap now allows overriding default construct_args (e.g. binding names)." ;
                        asc:update      "Fixed RDF::Trine::Model::StatementFilter::get_pattern to project away unused variables (fixing a bug that caused joining to always fail)." ;
                        asc:update      "Updated example turtle parser to accept URLs as command line arguments." ;
                        asc:update      "Turtle parser now removes dashes from the UUIDs used for blank node IDs." ;

 view release on metacpan or  search on metacpan

lib/DBD/RDFStore.pm  view on Meta::CPAN

	if($DBD::RDFStore::st::debug>1) {
		print STDERR (" " x $tpi);
		print STDERR "$tpi BEGIN\n";	
		};

	# if we have a previous state try to recover it (this is needed for streaming results)
	my $bind_state = pop @{ $sth->{'binds'} };

	if(	( $bind_state ) && ($DBD::RDFStore::st::debug>1) ) {
		print STDERR (" " x $tpi);
		print STDERR "RECOVER previous state for $tpi\n";

lib/DBD/RDFStore.pm  view on Meta::CPAN

		};

	return _fetchrow_RDF_or_XML( $sth );
	};

# fetch the whole matching graph in one call (not streaming then)
# return RDFStore::Model of matching statements
sub fetchallgraph {
        my($sth) = @_;

	my $whole_graph;

lib/DBD/RDFStore.pm  view on Meta::CPAN

		};

	return $whole_graph;
	};

# should be streaming
sub _fetchrow_RDF_or_XML {
        my($sth, $syntax) = @_;

	return
		if($sth->{'RDF_or_XML_stream_finished'});

lib/DBD/RDFStore.pm  view on Meta::CPAN

		unless(	(!$syntax) ||
			($syntax =~ m#(RDF/XML|N-Triples|dawg-results|rdf-for-xml|dawg-xml)#i) );

	my $result = '';

	my $mm = new RDFStore::Model; # we want streaming - that's why this...

	# DESCRIBE <URI> are done once in one single subgraph / match
	if(	( $sth->{'Statement'}->getQueryType eq 'DESCRIBE' ) &&
		( grep m/^<([^>]+)>/, @{ $sth->{'Statement'}->{'describes'} }) ) {
		foreach my $d ( @{ $sth->{'Statement'}->{'describes'} } ) {

 view release on metacpan or  search on metacpan

lib/REST/Neo4p/Agent.pm  view on Meta::CPAN

incrementally and (with the L<Mojo::UserAgent> backend) in a
non-blocking way. New Neo4j server versions may break the incremental
parsing. If this happens,  L<make a
ticket|https://rt.cpan.org/Public/Bug/Report.html?Queue=REST-Neo4p>. In
the meantime, you should be able to keep things going (albeit more
slowly) by turning off streaming at the agent:

 REST::Neo4p->agent->no_stream;

Streaming responses can be requested again by issuing

 view release on metacpan or  search on metacpan

ChangeLog  view on Meta::CPAN

	* lib/RPC/XML/Client.pm
	* lib/RPC/XML/Parser.pm
	* lib/RPC/XML/Server.pm
	The parsing of incoming data in the client and both server
	classes is now done to a streaming XML parser, eliminating the
	need for the full message to ever be in memory at once.
	Likewise, the client and server classes have new attributes and
	accessor methods to allow them to spool outgoing messages to
	files if the messages threaten to be too large to keep in
	memory (this is best used when dealing with a lot of Base64

 view release on metacpan or  search on metacpan

lib/RTSP/Client.pm  view on Meta::CPAN

  
  
=head1 DESCRIPTION

This module provides a high-level interface for communicating with an RTSP server.
RTSP is a protocol for controlling streaming applications, it is not a media transport or a codec. 
It supports describing media streams and controlling playback, and that's about it.

In typical usage, you will open a connection to an RTSP server and send it the PLAY method. The server
will then stream the media at you on the client port range using the specified transport protocol.
You are responsible for listening on the client port range and handling the actual media data yourself,

 view release on metacpan or  search on metacpan

Lite.pm  view on Meta::CPAN

RTSP::Lite is a stand-alone lightweight RTSP/1.0 module for Perl. It
is based on Roy Hooper's HTTP::Lite (RTSP protocol is very similar to
HTTP protocol. I simply modified it to support RTSP).

The main focus of the module is to help you write simple RTSP clients
for monitoring and debugging streaming server. So far, full streaming
clients that need RTP handling are out of my scope.

The main modifications from the HTTP::Lite 2.1.4 are: 
 + Supports continuous requests. Therefore explicit open operation is
 now required.

 view release on metacpan or  search on metacpan

lib/RTSP/Server.pm  view on Meta::CPAN

information.

=head1 USAGE

After starting the server, stream sources may send an ANNOUNCE for a
desired mountpoint, followed by a RECORD request to begin streaming.
Clients can then connect on the client port at the same mountpoint and
send a PLAY request to receive the RTP data streamed from the source.

=head1 BUNDLED APPLICATIONS

 view release on metacpan or  search on metacpan

lib/RapidApp/Module/Grid/Role/ExcelExport.pm  view on Meta::CPAN

	# override the columns that DataStore is fetching
	#$self->c->req->params->{columns}= $self->json->encode($columns);
	my $data = $self->DataStore->read({%$params, columns => $columns, ignore_page_size => 1});

	# TODO: We just read all rows into memory, and now we're building the file in memory as well.
	# We would do well to replace this with a db-cursor-to-tempfile streaming design
	
	my $dlData = '';
	open my $fd, '>', \$dlData;
	
	my $method= $export_format->{renderer};

 view release on metacpan or  search on metacpan

lib/Raylib/FFI.pm  view on Meta::CPAN

Check if music is playing

=head2 UpdateMusicStream( $music )

Update buffers for music streaming

=head2 StopMusicStream( $music )

Stop music playing

 view release on metacpan or  search on metacpan

redland/ChangeLog.1  view on Meta::CPAN

2000-11-02  Dave Beckett  <Dave.Beckett@bristol.ac.uk>

	* rdf_parser_sirpac.c:
	Updated for changed parser API
	Split for 2 SiRPAC implementations - W3C and Stanford
	Support for streaming/static support via Java --streaming/--static
	depending on whether the parser features aboutEach/prefix are set.

	* rdf_parser_repat.c:
	Updated for changed parser API
	Start to gather parseType literal content - unfinished.

redland/ChangeLog.1  view on Meta::CPAN

	* acconfig.h:
	Updated Java parser defines for SiRPAC, SAX

	* PrintParser.java:
	Updated to have --streaming/--static flags to pick parser modes.
	Tidied messages and error reporting.

	* example4.c:
	Update for new parser constructor
	Set rdf:aboutEach/prefix parser features depending on the type of

redland/ChangeLog.1  view on Meta::CPAN

	Add the sources and classes to the release

2000-08-28  Dave Beckett  <Dave.Beckett@bristol.ac.uk>

	* PrintParser.java:
	Use streaming SiRPAC to parse RDF/XML content to triples

	* PrintConsumer.java:
	SiRPAC RDF consumer that prints out triple as they are added

	* rdf_parser_sirpac.c:
	Use SiRPAC in streaming mode via local PrintParser class

	* configure.in:
	Don't check for HTRDFParseFile yet

	* rdf_stream.h:

 view release on metacpan or  search on metacpan

lib/Reflex.pm  view on Meta::CPAN

=head3 Reflex::Role::Accepting - Add non-blocking connection accepting to a role.

=head3 Reflex::Role::Connecting - Add non-blocking client connecting to a class.

=head3 Reflex::Role::InStreaming - Add non-blocking streaming input behavior to a class.

=head3 Reflex::Role::OutStreaming - Add non-blocking streaming output behavior to a class.

=head3 Reflex::Role::Readable - Add non-blocking readable-watching behavior to a class.

=head3 Reflex::Role::Reading - Add standard non-blocking sysread() behavior to a class.

=head3 Reflex::Role::Recving - Add standard non-blocking send/recv behavior to a class.

=head3 Reflex::Role::Streaming - Add non-blocking streaming I/O behavior to a class.

=head3 Reflex::Role::Writable - Add non-blocking writable-watching behavior to a class.

=head3 Reflex::Role::Writing - Add standard non-blocking syswrite() behavior to a class.

 view release on metacpan or  search on metacpan

lib/Reflexive/Role/DataMover.pm  view on Meta::CPAN

    with 'Reflexive::Role::DataMover';

=head1 DESCRIPTION

Reflexive::Role::DataMover is a composable behavior that provides functionality
for streaming data between two Reflex::Streams. It is a parameterized role, so
there is tons of configurability available, but the defaults should be sane
enough to avoid using most of it. See L</ROLE_PARAMTERS> for details.

Essentially what this role does is upon BUILD it watches the events out of each
of the handles. This kickstarts reading from the "input" handle. on_input_data

 view release on metacpan or  search on metacpan

eg/notmatch.pl  view on Meta::CPAN

#
# The following log lines did not match:
EOT

while (<>) {
    # ignore streaming media for now
    next if /^(?:Windows_Media|<RealMedia>)/;
    my %data;
    @data{@fields} = (m/$re/og) or print;
}

 view release on metacpan or  search on metacpan

lib/Religion/Islam/Quran/QuranEnglish.txt  view on Meta::CPAN

9|87|They prefer to be with (the women), who remain behind (at home): their hearts are sealed and so they understand not. 
9|88|But the Messenger, and those who believe with him, strive and fight with their wealth and their persons: for them are (all) good things: and it is they who will prosper. 
9|89|Allah hath prepared for them gardens under which rivers flow, to dwell therein: that is the supreme felicity. 
9|90|And there were, among the desert Arabs (also), men who made excuses and came to claim exemption; and those who were false to Allah and His Messenger (merely) sat inactive. Soon will a grievous penalty seize the Unbelievers among them. 
9|91|There is no blame on those who are infirm, or ill, or who find no resources to spend (on the cause), if they are sincere (in duty) to Allah and His Messenger. no ground (of complaint) can there be against such as do right: and Allah is Oft-forgi...
9|92|Nor (is there blame) on those who came to thee to be provided with mounts, and when thou saidst, "I can find no mounts for you," they turned back, their eyes streaming with tears of grief that they had no resources wherewith to provide the expen...
9|93|The ground (of complaint) is against such as claim exemption while they are rich. They prefer to stay with the (women) who remain behind: Allah hath sealed their hearts; so they know not (What they miss). 
9|94|They will present their excuses to you when ye return to them. Say thou: "Present no excuses: we shall not believe you: Allah hath already informed us of the true state of matters concerning you: It is your actions that Allah and His Messenger w...
9|95|They will swear to you by Allah, when ye return to them, that ye may leave them alone. So leave them alone: For they are an abomination, and Hell is their dwelling-place,-a fitting recompense for the (evil) that they did. 
9|96|They will swear unto you, that ye may be pleased with them but if ye are pleased with them, Allah is not pleased with those who disobey. 
9|97|The Arabs of the desert are the worst in Unbelief and hypocrisy, and most fitted to be in ignorance of the command which Allah hath sent down to His Messenger. But Allah is All-knowing, All-Wise. 

 view release on metacpan or  search on metacpan

lib/Rex/Repositorio/Server/Helper/RenderFile.pm  view on Meta::CPAN

        'cleanup'  => 1,                     # delete file after completed
    );

=head1 DESCRIPTION

L<Mojolicious::Plugin::RenderFile> is a L<Mojolicious> plugin that adds "render_file" helper. It does not read file in memory and just streaming it to a client.

=head1 HELPERS

=head2 C<render_file>

 view release on metacpan or  search on metacpan

lib/Riap.pod  view on Meta::CPAN

=item * B<stream_arg> => bool

Optional. If set to true, then will provide a filehandle or an iterable object
as argument value for the function, where the function can read data from. And
will also send special argument C<< -arg_stream => 1 >> to function. Note that
the function must have exactly a single argument that has its C<streaming>
property set to true. Otherwise, server MUST send 501 (unimplemented) response.

=back

=head2 Action: B<complete_arg_val>

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

	  to depend on others.


1.1.71  2015-01-17  Released-By: PERLANCAR

	- Specify that streaming input and output now uses coderef instead of
	  filehandle/etc. This is simpler and has the side-effects of easier to
	  do wrapping for (see Perinci::Sub::Wrapper) where one can just wrap
	  the coderef to do per-record validation of streaming input/output.


1.1.70  2014-11-19  Released-By: PERLANCAR

	- Add 'links' property to arg spec.

 view release on metacpan or  search on metacpan

lib/Robotics/IRobot.pm  view on Meta::CPAN

=item $robot->playABCNotation($file, $callback)

Loads song in ABC format (see abcnotation.com) from $file and begins playing on Create.
If passed, calls &$callback($robot) when done.

I<NOTE:  You must either poll sensor values frequently or use the sensor data streaming methods
for this method to work properly.  Calling this method will overwrite any data contained in song banks 14 and 15>

=cut

sub playABCNotation($$$) {

lib/Robotics/IRobot.pm  view on Meta::CPAN

=item $robot->playLongSongRaw($callback, @songBytes)

Plays song contained in @songBytes (may be longer than 16 notes).  If passed, calls &$callback($robot) when done.

I<NOTE:  You must either poll sensor values frequently or use the sensor data streaming methods
for this method to work properly.  Calling this method will overwrite any data contained in song banks 14 and 15>

=cut

sub playLongSongRaw($$@) {

lib/Robotics/IRobot.pm  view on Meta::CPAN

Robot will make the turn at $speed.  Robot will stop once complete and call
&$callback($robot) if $callback is passed.

See section DEAD RECKONING for more information.

I<NOTE:  You must either poll sensor values frequently or use the sensor data streaming methods
for this method to work properly.>

=cut

sub turnTo($$$) {

lib/Robotics/IRobot.pm  view on Meta::CPAN

Robot will make the proceed at $speed.  Robot will stop once complete
and call &$callback($robot) if $callback is passed.

See section DEAD RECKONING for more information.

I<NOTE:  You must either poll sensor values frequently or use the sensor data streaming methods
for this method to work properly.>

=cut

sub goTo($$$$$) {

lib/Robotics/IRobot.pm  view on Meta::CPAN

you can use the $robot->getSensor($id) method.  This will only retrieve data for
one sensor (or sensor set) but, it is not recommended.

Consult the OI Interface document for more details on sensor ids.

Another method is to use the iRobot's sensor streaming functionality.  When the
robot is put in streaming mode it will send back sensor data once every 15ms.  Use the
$robot->startSteam, $robot->pauseStream. $robot->resumeStream method to start and
stop the stream.  The $robot->getStreamFrame method should be called at least every
15ms to read in the sensor data and update the sensor state hash.  As with the polling
method, you can pass a sensor ids to $robot->startStream to have the robot stream data
for only particular sensors, but again, this is not recommeded.

The third method is to use the event-driven approach.  Your program can register sensor listeners
or events to listen for using the $robot->addSensorListener, $robot->addSensorEvent,
$robot->runEvery, $robot->waitTime, $robot->waitDistance, and $robot->waitAngle methods.  Once these
have been registered the $robot->runSensorLoop and $robot->exitSensorLoop methods will put the robot in
streaming mode then read sensor data as it comes in while updating the sensor state hash and calling any
sensor listeners or events.

=over 4

=item $robot->getSensorState()

lib/Robotics/IRobot.pm  view on Meta::CPAN

	return @retArr;
}

=item $robot->runSensorLoop()

Begins streaming sensor data from the robot.  Updates sensor state hash every 15ms and triggers any
sensor listeners or events.  This method will block until $robot->exitSensorLoop() is called.

=cut

sub runSensorLoop($) {

lib/Robotics/IRobot.pm  view on Meta::CPAN

	$self->pauseStream();
}

=item $robot->exitSensorLoop()

Stops streaming data from robot.  Causes any previous call to runSensorLoop to return.

=cut

sub exitSensorLoop($) {
	my $self=shift;

lib/Robotics/IRobot.pm  view on Meta::CPAN

=item $robot->startStream()

=item $robot->startStream($sensorId)

Puts robot into streaming mode.  If a $sensorId is passed only streams that sensor (not recommended).  Otherwises streams data from
all sensors.

See OI Documentation for more details

=cut

lib/Robotics/IRobot.pm  view on Meta::CPAN

=over 4

=item $robot->close()

Stops the robot motion and sensor streaming and closes communication port.

=back

=cut

 view release on metacpan or  search on metacpan

vendor/rocksdb/third-party/fbson/FbsonDocument.h  view on Meta::CPAN

 *
 * Note: iterators are forward direction only.
 *
 * ** Query **
 * Querying into containers is through the member functions find (for key/value
 * pairs) and get (for array elements), and is in streaming style. We don't
 * need to read/scan the whole FBSON packed bytes in order to return results.
 * Once the key/index is found, we will stop search.  You can use text to query
 * both objects and array (for array, text will be converted to integer index),
 * and use index to retrieve from array. Array index is 0-based.
 *

 view release on metacpan or  search on metacpan

Changes  view on Meta::CPAN

2.007     2021-01-25 02:01:08+08:00 Asia/Kuala_Lumpur
    New features:

    - the `->source` provided by a Ryu::Sink is now a child of the sink itself,
    to facilitate backpressure algorithms and help with common streaming configurations

    Bugs fixed:

    - ->ordered_futures would call ->pause or ->resume more often than required,
    these are now only triggered when they would change state

 view release on metacpan or  search on metacpan

lib/SDL2/hints.pm  view on Meta::CPAN

By default SDL tries to make a best guess whether to use acceleration or not on
each platform.

SDL can try to accelerate the screen surface returned by
L<SDL_GetWindowSurface( ... )|SDL2/SDL_GetWindowSurface( ... )> by using
streaming textures with a 3D rendering engine. This variable controls whether
and how this is done.

=item C<SDL_HINT_GAMECONTROLLERCONFIG>

A variable that lets you provide a file with extra gamecontroller db entries.

 view release on metacpan or  search on metacpan

benchmark/README  view on Meta::CPAN

No web server required.

This benchmark sheds light on how much performance is - in theory - reachable
by each approach: The XML::LibXML (Hash) benchmark converts the DOM into
a nested hash using a recursive function. This is - basically - how
XML::Compile works. XML::Simple uses XML::Parser's streaming
API. SOAP::WSDL uses XML::Parser::Expat, XML::Parser's low-level backend,
to create objects or - in the (Hash) variant - nested hashes similar to
those created by XML::Simple.
SOAP::WSDL_XS uses a libexpat-based XS parser to create perl objects, and
XML::LibXML (DOM) creates a C level libxml2 DOM accessible from perl.

 view release on metacpan or  search on metacpan

.tmp/libpng/contrib/gregbook/README  view on Meta::CPAN

Chapters 13, 14 and 15 of "PNG: The Definitive Guide" discuss three free,
cross-platform demo programs that show how to use the libpng reference
library:  rpng, rpng2 and wpng.  rpng and rpng2 are viewers; the first is
a very simple example that that shows how a standard file-viewer might use
libpng, while the second is designed to process streaming data and shows
how a web browser might be written.  wpng is a simple command-line program
that reads binary PGM and PPM files (the ``raw'' grayscale and RGB subsets
of PBMPLUS/NetPBM) and converts them to PNG.

The source code for all three demo programs currently compiles under

 view release on metacpan or  search on metacpan

lib/SPVM/Resource/Zlib/V1_2_11.native/src/contrib/dotzlib/readme.txt  view on Meta::CPAN

This directory contains a .Net wrapper class library for the ZLib1.dll

The wrapper includes support for inflating/deflating memory buffers,
.Net streaming wrappers for the gz streams part of zlib, and wrappers
for the checksum parts of zlib. See DotZLib/UnitTests.cs for examples.

Directory structure:
--------------------

 view release on metacpan or  search on metacpan

lib/SPVM/Resource/Zlib.native/src/contrib/dotzlib/readme.txt  view on Meta::CPAN

This directory contains a .Net wrapper class library for the ZLib1.dll

The wrapper includes support for inflating/deflating memory buffers,
.Net streaming wrappers for the gz streams part of zlib, and wrappers
for the checksum parts of zlib. See DotZLib/UnitTests.cs for examples.

Directory structure:
--------------------

 view release on metacpan or  search on metacpan

lib/SWF/Builder/Character/Sound.pm  view on Meta::CPAN

#stub

}

sub start_streaming {
    my ($self, %param) = @_;

    my $parent = $param{MovieClip} || $param{MC} || $self->{_parent} or croak "Can't get the movieclip to play on";
    if ($parent eq '_root') {
	$parent = $self->{_root};
    } elsif (ref($parent) eq 'SWF::Builder') {
	$parent = $parent->{_root};
    }

    croak "A streaming sound has already set in the movie clip" if $parent->{_streamsoundf};
    $parent->{_streamsoundf} = 1;
    my $frame = $param{Frame} || 1;

    my $ss = $self->_init_streaming($self->{_root}{_file}->FrameRate);
    push @{$parent->{_frame_list}[0]}, $ss->header_tag;

#    $ss->__dump;

    while (defined(my $btag = $ss->next_block_tag)) {

lib/SWF/Builder/Character/Sound.pm  view on Meta::CPAN

=item $sound->stop( [ MovieClip => $mc, Frame => $frame ] )

stops playing the sound. 
It can take 'MovieClip' and 'Frame' options as same as the 'play' method.

=item $sound->start_streaming( [ MovieClip => $mc, Frame => $frame ] )

starts the streaming sound, which synchronizes with the movie timeline.
It can take 'MovieClip' and 'Frame' options as same as the 'play' method.

=item $sound->Latency( $msec )

sets the sound latency in milliseconds.

 view release on metacpan or  search on metacpan

lib/SWF/Element.pod  view on Meta::CPAN

 LeftLevel   $
 RightLevel  $

=item Tag::SoundStreamHead / Tag::SoundStreamHead2

defines the format of streaming sound.

 Type: ValidInSprite

 field                    class   lookahead
 Flags                    $           *

 view release on metacpan or  search on metacpan

SWF/Movie.pm  view on Meta::CPAN

	$m->protect();

=item setSoundStream(SWF::Sound)

Puts an SWF::Sound object as streaming sound into the main timeline.

	$m->setSoundStream($sound);

=item streamMp3(filename)

SWF/Movie.pm  view on Meta::CPAN

	$m->setFrames(10); # ming fills it automatic with frames
	
	$m->nextFrame()
	$m->save("empty.swf");

=item streaming example

	#!/usr/bin/perl -w
	
	use SWF("Shape");
	SWF::setVersion(6);