woobi

stream media across a lan

Showing:

Popularity

Downloads/wk

7

GitHub Stars

3

Maintenance

Last Commit

7mos ago

Contributors

4

Package

Dependencies

23

Size (min+gzip)

552.4KB

License

MIT

Type Definitions

Tree-Shakeable

No?

Categories

Readme

Woobi Media Streams

EPG ui, LAN media server, IPTV broadcaster, and media converter.

  • Stream the same media to multiple locations at once using multicast or unicast/http.
  • Stream your desktop to gaming/live servers.
  • Use a tv tuner to stream tv to all connected devices.
  • EPG with DVR controls via adapter.

Contents

Pre-Requisites
Installation
Usage
Woobi UI
Configuration

Woobi.Channel

Woobi.Sources

Woobi.Streams

Screen Shots
Contributing
License

Pre-Requisites

You need ffmpeg and node >= v4.

Installation

yarn install woobi

Usage

var Woobi = require('woobi');
Woobi.init( {
    channelPort: 13000,
    host: 'studio',
    loadSaved: false,
    proxy: {
        port: 2777,
        nodeadmin: false,
        host: '0.0.0.0',
    },
    adapters:  [
        /* the included media adapter is for a mysql database setup */
        {
            name: 'media',
            adapter: 'media',
            config: {
                user: 'MYSQLUSER',
                pass: 'MYSQLPASS',
                host: 'MYSQLHOST',
                database: 'MYSQLDB'
            },
        },
        /* custom adapters can be added. use the included adapters as a template */
        {
            name: 'livetv',
            adapter: function ( Woobi ) {
            
                var MyAdapter = function ( opts, callback ) {
        
                    if ( !( this instanceof MyAdapter ) ) return new MyAdapter( opts, callback );
                    
                }
                
                /* Add any function available in /lib/core/apapters.js */
                MyAdapter.prototype.getGuideData = function ( channels, start, end ) {
                
                }
                return MyAdapter;
            
            },
            config: {
                
            }
        },
        /* The included live tv adapter uses a mix of mysql databases and direct tcp connections */
        {
            name: 'livetv',
            adapter: 'livetv',
            config: {
                epg: {
                    user: 'MYSQLUSER',
                    pass: 'MYSQLPASS',
                    host: 'MYSQLHOST',
                    database: 'MYSQLDB'
                },
                tv: {
                    user: 'MYSQLUSER',
                    pass: 'MYSQLPASS',
                    host: 'MYSQLHOST',
                    database: 'MYSQLDB'
                },
                socket: {
                    host: 'anna',
                    port: '9080',
                    hostname: 'studio',
                    agent: 'Woobi'
                },
            }
        },
    ]
});

Woobi UI

http://localhost:7001
If you set the proxy option you can use the Woobi UI.

  • Live Tv EPG and DVR Manager (ui only)
  • Create Channels
  • View Channels
  • Save / Manage Channels
  • View local library

Configuration

Woobi.init(options, callback)

@param - options - Object
@param - callback - Function
return Promise

optiontypeinfo
hostStringHost to use to access Woobi UI and api routes.
proxyfalse|ObjectOptional server for api routes and Woobi UI.
adaptersObject|ArrayAdapters can convert your info to the correct format.
loadSavedBooleanLoad saved channels on boot that are set to autostart.
channelPortNumberIf you do not supply a port when streaming a channel, the port will be assigned starting at this number.
mediaPathStringFull path to store saved HLS files. Defaults to /module_path/media
media passthrough routeStringApi route to direct access media.
media passthrough pathStringReplace the path above with the actual server path.
video passthrough routeStringApi route to direct access videos.
video passthrough pathStringReplace the path above with the actual server path.
proxy object
optiontypeinfo
hostStringHost to start on. default 0.0.0.0
portObjectPort for api routes and Woobi UI access.
keystoneBooleanUse keystone if you want to save channel configs from the UI.
nodeadminBooleanLoad the nodeadmin app.
authBooleanUsed with keystone. Set to false at first to create a new user @ http://localhost/keystone

You can add any keystone option to the proxy configuration.
If you want to use channel saving and do not want to use keystone, then attach a mongoose model to Woobi.libs._mongo.ChannelConfig.model

adapters Array of Objects

Adapters are used to convert your information into the required format for the UI.
You can also uses adapters for non-ui use cases.
For local media a media adapter is needed. An example using mysql databases is included.
For live tv a livetv adapter is needed. An example using a mix of mysql databses and tcp connections is supplied.

Adapters are available at Woobi.libs['USER_SUPPLIED_NAME']

optiontypeinfo
nameStringUnique name for the adapter. Can be accessed at Woobi.libs[name]
adapterString|FunctionString for included adapter or a function to provide your own.
configObject
config.userStringusername
config.passStringpassword
config.hostStringhost
config.databaseStringdatabase

View /lib/core/adapter.js for all available functions to use.

note - A media and livetv adapters are used by the UI if supplied.
note - config will be passed to custom adapters and can include additional key/value pairs

The media adapter needs the following functions
tvShow( idShow ) tvShows( obj ) tvShowByName( name ) tvShowByIMDB( imdb_id )
tvShowEpisodes( idShow ) recentEpisodes( obj )
movie( idShow ) movies( obj ) movieByName( name )
movieByIMDB( imdb_id ) recentMovies( obj ) grabMedia( obj ) mediaFiles( obj ) mediaFile( obj )

The livetv adapter needs the following functions
connect( obj ) getGuideData( channels, start, end ) getSeriesTimers( obj ) getTimers( obj ) getTVChannels( obj ) getChannelGroups( obj )

Woobi.Channel

Use Woobi.addChannel( name, opts ).then() to add channels instead of directly with new Woobi.Channel( name, opts, callback ).

/**
 * This gives iptv by grabbing a 
 * tv tuner card source and sending it over udp
 * For wired networks a multicast can be used
 **/
Woobi.addChannel( 'TV', {
    loop: true,
    assets: [
        {
            type: 'program',
            name: 'Air',
            arg: 'gnutv -channels /home/woobi/dvb/channels.conf -out udp 10.10.10.82 13333 WAGA5',
            redo: 'gnutv -channels /home/woobi/dvb/channels.conf -out udp 10.10.10.82 13333 ##CMD##',
        },
        {
            type: 'udpSink',
            port: 13333,
            host: '10.10.10.82',
            name: 'AirTV',
        },
        {
            type: 'udpStream',
            port: 13333,
            host: '10.10.10.87',
            name: 'streamAir'
        },
        
    ],
}, ( err ) => {
    if ( err ) console.log( '##ERROR##', err );
});

/**
 * using the library adapter
 **/
Woobi.libs.media.movies()
.then( ( movies ) => {
    movies = movies.map( r => {
        return { name: r.name, file: r.file, progress: true, metadata: r, encode: false }
    });
    return Woobi.addChannel( 'recentMovies', {
        files: movies,
        loop: true,
        noTransition: true,
        hls: {
            type: 'hls',
            name: 'movieChannel',
            passthrough: true, // uses the stream as is / no transcoding
        }
    });
})
.catch( ( err ) => {
    if ( err ) debug( '##ERROR##', err );
});

// channel is now available at Woobi.channels.recentMovies

Options

Adding Assets

Properties

API Routes

Watch / Listen

Woobi.Sources

.File(options, callback)

@param - options - Object
@param - callback - Function

let file = new Woobi.Sources.File({
    name: 'Test',
    file: '/home/woobi/Pitures/woobi.mp3'
});
optiontypeinfo
nameStringUnique name for asset
fileObjectFull path to file.

.Fluent(options, callback)

@param - options - Object
@param - callback - Function

let fluent = new Woobi.Sources.Fluent({
    name: 'Test',
    file: '/home/woobi/Videos/woobi.mp4',
    streamable: true
});
optiontypeinfo
nameStringUnique name for asset
fileObjectoptional Full path to file.
streamObjectoptional Source stream.
progressBooleanEmit progress info.
metadataObjectObject of information about file. Should be flat with exception of the art key(an Array).
seekNumber
inputFormatString
inputOptionsArray|String
outputOptionsArray|String
videoFiltersObject
onlyOptionsArray|String
encodeBoolean
streamableBoolean
formatString

.Program(options, callback)

@param - options - Object
@param - callback - Function

let program = new Woobi.Sources.Program({
    name: 'TV',
    program: 'gnutv',
    arg: '-channels /home/woobi/dvb/channels.conf -out udp 10.10.10.82 13333 WAGA5',
    redo: '-channels /home/woobi/dvb/channels.conf -out udp 10.10.10.82 13333 ##CMD##',
});
optiontypeinfo
nameStringUnique name for asset
programStringProgram name.
argsStringArgument String.
redoStringString used to restart program.

.UDP(options, callback)

@param - options - Object
@param - callback - Function

let updSource = new Woobi.Sources.UDP({
    name: 'UDPSource',
    host: '10.10.10.10',
    port: 7005
});
optiontypeinfo
nameStringUnique name for asset
hostString
portNumber

Woobi.Streams

.bridge()

let bridge = new Woobi.Streams.bridge();

normal passthrough stream

.HLS(options, callback)

@param - options - Object
@param - callback - Function

let hls = new Woobi.Streams.HLS({
    name: 'Test',
    file: '/home/woobi/Videos/woobi.mp4',
    streamable: true
});
optiontypeinfo
nameStringUnique name for asset
fileObjectoptional Full path to file.
streamObjectoptional Source stream.
progressBooleanEmit progress info.
metadataObjectObject of information about file. Should be flat with exception of the art key(an Array).
seekNumber
inputFormatString
inputOptionsArray|String
outputOptionsArray|String
onlyOptionsArray|String
hlsOptionsArray|String
passthroughBoolean
streamableBoolean
formatString

.MpegTS(options, callback)

@param - options - Object
@param - callback - Function

let mpegts = new Woobi.Streams.MpegTS({
    name: 'Test',
    file: '/home/woobi/Videos/woobi.mp4',
    streamable: true
});
optiontypeinfo
nameStringUnique name for asset
programString
pathString
urlPathString
sourceObjectinput source.
videoString
audioString
otherString
segmentString

.throttle(source, rate, onEnd)

@param - source - Stream
@param - rate - Number @param - onEnd - Function

let throttle = new Woobi.Streams.throttle(stream, 1000);
// throttle.stream.pipe(somewhere)

.transform()

let transformer = new Woobi.Streams.transform();

transform stream

.UDP(options, callback)

@param - options - Object
@param - callback - Function

let updStream = new Woobi.Streams.UDP({
    name: 'UDPStream',
    host: '10.10.10.11',
    port: 7006
});
optiontypeinfo
nameStringUnique name for asset
hostString
portNumber

Screen Shots

Contributing

License

Rate & Review

Great Documentation0
Easy to Use0
Performant0
Highly Customizable0
Bleeding Edge0
Responsive Maintainers0
Poor Documentation0
Hard to Use0
Slow0
Buggy0
Abandoned0
Unwelcoming Community0
100