Free subscribe to podcast software for linux

importOpmlAsPodcast script imports OPML lists with urls to podcasts, which are exported by many podcast portals and podcatchers, easily into amaroK (Vers. 1.3.3 up).

The script first opens a "file open dialog" with which you can choose a OPML (XML) file locally from your computer or from a remote location.

The script parses the file and looks for RSS-feeds. There has to be a parameter called xmlUrl in a tag called outline for the script to be able to do that.

MP3::Podcast is a Perl extension for podcasting directories full of MP3 files.

SYNOPSIS

use MP3::Podcast;
my $dirbase = shift;
my $urlbase = shift;
my $dir = shift;
my $pod = MP3::Podcast->new($dirbase,$urlbase);
my $rss = $pod->podcast( $dir, "This is a test" );
print $rss->as_string;

ABSTRACT

Create podcast easily from directories, using MP3s own info.

Creates a podcast, basically a RSS feed for a directory full of MP3 files. Takes information from the MP3 files themselves; it needs MP3 files with their ID tags completed.

The bundle includes two programs in the C< examples > dir: C< gen-podcast.pl >, used this way:

bash% ./gen-podcast.pl < dirbase > < urlbase > < dir to scan > that generates a static RSS from a dir, and C< podcast.cgi >, to use from a webserver. To use it, copy podcast.cgi and podcast.conf to a cgi-serviceable dir; edit podcast.conf to your liking and copy it to the directory you want. Copy also .podcast to the directory you want served as a podcast (this is done mainly to avoid dir-creeping), and also drop edit also the path to fetch the MP3::Podcast lib, and call it with C< http://my.host.com/cgi-bin/podcast.cgi/< dirname >.rss

The name of the directory to scan will be taken from the URI.

Amarok is a wonderful media player and audio library management tool for Linux. Podcast Cleanup allows for extensions by third parties via a nice script system.

Amarok has some in-built support for subscribing to podcasts, however, at time of writing, there is no convenient way to manage deletion of downloaded podcast episodes en-masse.

Presently, the only way to delete downloaded podcast files from amarok is to traverse the podcast list, right clicking on each downloaded podcast episode, and selecting delete from the contect menu. This is quite cumbersome, particularly considering the fact that ever deletion provokes a confirmation dialog.

I listen to a lot of podcasts, and I wanted a better way to manage my downloaded podcast files, so I wrote a small script to delete downloaded podcast files.

The script can delete downloaded podcasts, either unconditionally, or just the listened podcasts, or listend-to podcasts which are older than some age (expressed in hours, days, weeks or months.

Its possible to specify cleanup criteria for startup, and at some regular time interval (after the initial check).

Its possible to request confirmation before deletion is done, and to request a notification when files have been cleaned up.

Armangils vodcatcher is a video podcast (or vodcast) client for the command line. Armangils vodcatcher project provides several download strategies (new shows only, allowed, back-catalog, etc), supports BitTorrent, offers cache management, and generates playlists for video player applications. It is written in Ruby, and runs on Linux (tested), Windows, MacOS and many other operating systems.

To watch video podcasts, simply type something like vodcatcher subscriptions.opml > latest.m3u. This will download the subscribed shows into the current directory and generate an M3U playlist named latest.m3u.

This application accepts one or more feeds (RSS or Atom) or subscription lists (OPML or iTunes PCAST) as argument, in the form of URLs or filenames. Alternatively, it tries to read one such document from the standard input.

For help, use vodcatcher -h.

Options:

-F, --Function FUNCTION used function (download search );
when using the search function (which
generates an OPML document), the only
relevant options are -v, -r and -f
(default value: download)

-d, --dir DIR Query for caching files
and storing application state
(default value: current directory)

-s, --size SIZE Size of media file cache in MB;
0 means infinite; default value is 500

-m, --memsize N Remember last N downloaded media files,
and do not download them again;
0 means infinite; default value is 1000

-t, --type TYPE Playlist type (m3u smil pls asx tox xspf )
(default value: m3u)

-S, --strategy S Strategy to use for downloading vodcasts
(new one back_catalog all cache ):
* back_catalog: download any show that
has not been downloaded before; prefer
the most recent shows of top-most feeds
in the OPML/PCAST documents.
* new: ignore vodcast back-catalogs; this
is like back_catalog, except that only the
most recent show of each feed is
considered.
* one: download one unlistened show of
each feed, with a preference for recent
shows
* all: download all show; even already
downloaded shows are downloaded once
again.
* cache: play shows that are already in
cache (default value: new)

-f, --feeds N Do not download more than N feeds
(when using the download function);
or return the first N relevant feeds
(when using the search function);
0 means no limits (default value: 1000)

-r, --retries N Try downloading files (media, RSS/Atom or
or OPML/PCAST) at most N times before
giving up (default value: 1)

-T, --Torrentdir DIR Copy torrent files to directory DIR;
handling torrents through an external
BitTorrent client is left to the user;
if this option is not used, torrents are
handled internally (if RubyTorrent is
installed), or else ignored

-U, --Uploadrate N Maximum upload rate (kilobytes per second)
for the internal BitTorrent client
(default: no limit)

-i, --itemsize N If a downloaded show is less than N MB in
size (where N is an integer), fetch other
shows of that same feed until this size is
reached (default: 0)

-p, --[no-]perfeed Create one subfolder per feed in cache

-c, --[no-]cache Play already cached files,
DEPRECATED (use -S cache)

-e, --[no-]empty Delete all previously downloaded
files

-a, --[no-]asif Do not download media files
(useful for testing)

-v, --[no-]verbose Run verbosely

--version Display current version

-h, --help Show this message

Usage examples:

vodcatcher -d ~/vodcasts feeds.opml http://host/second.opml > latest.m3u

vodcatcher -d ~/vodcasts -S cache > cache.m3u

cat feeds.opml | vodcatcher -d ~/vodcasts > latest.m3u

vodcatcher -vd ~/vodcasts -s 500 -m 10_000 -t asx feeds.opml > latest.asx

vodcatcher -vF search -f 44 video vlog http://www.podfeed.net/opml/directory.opml > results.opml

MP3::PodcastFetch is a Perl module to fetch and manage a podcast subscription.

SYNOPSIS

use MP3::PodcastFetch;
my $feed = MP3::PodcastFetch->new(-base => /tmp/podcasts,
-rss => http://www.npr.org/rss/podcast.php?id=500001
-rewrite_filename => 1,
-upgrade_tag => auto);
$feed->fetch_pods;
print "fetched ",$feed->fetched," new podcastsn";
for my $file ($feed->fetched_files) {
print $file,"n";
}

This package provides a convenient and simple way of mirroring the podcasts described by an RSS feed into a local directory. It was written as the backend for the fetch_pods.pl script.

To use it, create an MP3::PodcastFetch object with the required -base and -rss arguments. The podcasts listed in the RSS subscription file located at the -rss URL will be mirrored into one or more subdirectories located beneath the path at -base. One subdirectory will be created for each channel specified by the RSS. Additional new() arguments control optional features of this module.

Once the object is created, call its fetch_pods() method to download the RSS file, parse it, and mirror the subscribed podcasts locally.

RSS Ripper project is a set of Python scripts that rewrites RSS feeds as required for better ease of use. After the rip and rewrite, the new RSS feed is uploaded to your FTP server for your own private re-subscription.

Example Usage:

Rename digg_ripper.py-dist

mv digg_ripper.py-dist digg_ripper.py

Edit the FTP values at the top of the script to point to your own FTP.

FTP_HOST = example.com
FTP_USER = username
FTP_PASS = password
FTP_DIR = ~/path/to/public_html

Run it:

python digg_ripper.py

or

./digg_ripper.py

You may want to add a cron job:

0 * * * * /path/to/rss_ripper/digg_ripper.py >/dev/null 2>&1

And finally you can subscribe to your own custom rss feed.

Piddlepodder is a podcatching client. It imitates the simplicity of bashpodder with a few added features.

PiddlePodder downloads podcasts from a list of XML feeds and puts them into a download directory by date.

No effort is made to copy the resulting files to an iPod, nor will this application interface with a directory, since its just a simple podcatcher.

Piddlepodder offers the ability to mark the set of podcasts as current (catch up). This is handy for first-time users who would otherwise be stuck downloading every show (sometimes since the beginning of the podcast) which can lead to hefty download times and large amounts of disk space.

PiddlePodder owes a debt of gratitude to PerlPodder, the code of which drives the XML parsing in PiddlePodder. Thanks to Sam Versluys et. al for creating PerlPodder.

Channel is a generic/simple facility with the purpose of making event dispatching and message passing as straightforward to use as data structures:
Channel is a template library, with its major components configurable as template parameters:
template
<
class Id_Type,
class Id_Trait = IdTrait ,
class SynchPolicy = ACE_MT_SYNCH,
class AllocPolicy,
class Router = MapRouter
>
class Channel
By replacing Id_Type, Id_Trait and Router with various concrete classes, Channel can support table/linear message routing, hierarchical routing and associative routing (Linda style) at the demand of user. The same way, we can use integer, string, POD structs or any class as message ids (provided that proper operations are defined with Id_Trait)
Channel provides complete publish/subscribe interface for channel members (peer threads in message passing and objects in event dispatching) to pub/sub message/event ids/types and send/receive messages/events
Channels are process local entities which can be "connected" to allow transparent distributed communication between members in different channels (Connectors based on tcp socket and unix domain socket are provided as samples)
Namespace control:
The ids published/subscribed by channel members constitute channels namespace.
Channel provides publish/subscribe scope control; When ids are published/subscribed, peers can specify desired scope (LOCAL, REMOTE, GLOBAL)
When 2 channels are connected, their namespaces are automatically "merged", which is transparent to both channel members and programmers. Members can communicate with members in remote channels the same way as with local members (by pub/sub ids).
Namespace merge/integration is controlled by:
Id scope specification
filters and translators defined at channel connections
Channel communication are peer-2-peer; there are no central daemons required for message passing.
Channel support both asynchronous message passing and synchronous event dispatching models.
Channel is built on top of
ACE (Adaptive Communication Environment) to gain platform independence.
Enhancements:
- The framework was ported to Windows XP with VC8.
- Dispatching policy was added as a Channel template parameter to support various dispatching algorithms.
- Broadcast and simple RoundRobin dispatching policies were implemented for testing.
- Callback was changed to functor style so that normal functions and functors can be directly used as callbacks.