RxPlayer API
Overview
The RxPlayer has a complete API allowing you to:
- load and stop contents containing video and/or audio media data
- control playback (play, pause, seek, etc.) when a content is loaded.
- get multiple information on the current content and on the player’s state.
- choose a specific audio language, subtitles track video track
- force a given bitrate
- update the wanted buffer length to reach
- and more
The following pages define the entire API.
⚠ Only variables and methods defined here are considered as part of the API. Any other property or method you might find in any other way are not considered as part of the API and can thus change without notice.
Note: As some terms used here might be too foreign or slightly different than the one you’re used to, we also wrote a list of terms and definitions used by the RxPlayer here.
Instantiation
Instantiating a new RxPlayer is necessary before being able to load a content. Doing so is straightforward:
import RxPlayer from "rx-player";
const player = new RxPlayer(options);
The options are all… optional. They are all defined in the Player Options page.
Basic methods
In this chapter, we will go through the basic methods you will need to use when playing a content through the RxPlayer.
loadVideo
arguments:
- options (
Object
)
Loads the content described in the argument.
This is the central method to use when you want to play a new content. The options possible as arguments are all defined in this page.
Despite its name, this method can also load audio-only content.
Example
player.loadVideo({
url: "http://vm2.dashif.org/livesim-dev/segtimeline_1/testpic_6s/Manifest.mpd",
transport: "dash",
autoPlay: true,
});
getPlayerState
return value: string
The “state” the player is currently in. Can be either one of those strings:
-
"STOPPED"
: The player is idle. No content is loading nor is loaded. -
"LOADING"
: The player is loading a new content. Most APIs related to the current content are not yet available while the content is loading. -
"LOADED"
: The player has loaded the new content, it is now ready to play. From this point onward you can use APIs interacting with the current content such asseekTo
orsetAudioTrack
. -
"PLAYING"
: The player is currently playing the content. -
"PAUSED"
: The player has paused. -
"ENDED"
: The player has reached the end of the current content. -
"BUFFERING"
: the player has reached the end of the buffer and is waiting for data to be appended. -
"SEEKING"
: The player has reached the end of the buffer because a seek has been performed, new segments are being loaded. -
"RELOADING"
: The player needs to reload its current (for example, when switching the current video track). While this state is active, most API related to the currently playing content are not available. This state should be treated like theLOADING
state.
As it is a central part of our API and can be difficult concept to understand, we have a special page of documentation on player states.
Example
switch (player.getPlayerState()) {
case "STOPPED":
console.log("No content is/will be playing");
break;
case "LOADING":
console.log("A new content is currently loading");
break;
case "LOADED":
console.log("The new content is loaded and ready to be played");
break;
case "PLAYING":
console.log("The content is currently playing");
break;
case "PAUSED":
console.log("The content is currently paused");
break;
case "BUFFERING":
console.log("The content is buffering new data");
break;
case "SEEKING":
console.log("The content is still seeking, waiting for new data");
break;
case "ENDED":
console.log("The content has reached the end.");
break;
case "RELOADING":
console.log("The content is currently reloading");
break;
default:
console.log("This is impossible (issue material!).")
break;
}
addEventListener
arguments:
-
event (
string
): The event name. -
callback (
Function
): The callback for the event. The same callback may be used again when callingremoveEventListener
.
Add an event listener to trigger a callback as it happens. The callback will have the event payload as a single argument.
The RxPlayer API is heavily event-based. As an example: to know when a content
is loaded, the most straightforward way is to add an event listener for the
"playerStateChange"
event. This can be done only through this method.
To have the complete list of player events, consult the Player events page.
Example
player.addEventListener("Error", function(err) {
console.log(`The player crashed: ${err.message}`);
});
removeEventListener
arguments:
- event (
string
): The event name. - callback (optional) (
Function
): The callback given when calling the correspondingaddEventListener
API.
Remove an event listener.
That is, remove a callback previously registered with addEventListener
from
being triggered on the corresponding event. This also free-up the corresponding
ressources.
The callback given is optional: if not given, every registered callback to that event will be removed.
Example
player.removeEventListener("playerStateChange", listenerCallback);
play
return value: Promise.<void>
Play/resume the current video. Equivalent to a video element’s play method.
You might want to call that method either to start playing (when the content is
in the "LOADED"
state and auto-play has not been enabled in the last
loadVideo
call) or to resume when the content has been paused.
The returned Promise informs you on the result:
-
if playback succeeds, the Promise is fulfilled
-
if playback fails, the Promise is rejected along with an error message explaining the failure - coming directly from the browser.
Such failure can for example be due to your browser’s policy, which may forbid to call play on a media element without any user interaction. Please note that in that case, you will also receive a warning event containing a
MEDIA_ERROR
with the code:MEDIA_ERR_PLAY_NOT_ALLOWED
.
Note: On browsers which do not support Promises natively (such as Internet Explorer 11), a JavaScript implementation is provided instead. This implementation has the exact same implementation than ES2015 Promises.
Example
const resumeContent = () => {
player.play();
};
pause
Pause the current video. Equivalent to a video element’s pause method.
Note that a content can be paused even if its current state is BUFFERING
or
SEEKING
.
Example
const pauseContent = () => {
player.pause();
};
stop
Stop playback of the current content if one.
This will totaly un-load the current content. To re-start playing the same
content, you will need to call loadVideo
again.
Example
const stopVideo = () => {
player.stop();
};
getPosition
return value: Number
Returns the current media element’s playing position, in seconds.
For live contents, the returned position will not be re-scaled to correspond to
a live timestamp. If you want that behavior, you can call getWallClockTime
instead.
This is the only difference between the two. Generally, you can follow the following rule:
-
if you want to use that current position to use it with the other APIs (like
seekTo
,getMinimumPosition
,getMaximumPosition
etc.) usegetPosition
. -
if you want to display the current position to the viewer/listener, use
getWallClockTime
instead.
Example
const pos = player.getPosition();
console.log(`The video element's current position is: ${pos} second(s)`);
getWallClockTime
return value: Number
Returns the current “wall-clock” playing position in seconds.
That is:
-
for live contents, this is the current position scaled to correspond to a live timestamp, in seconds.
-
for non-live contents, returns the position from the absolute beginning time of the content, also in seconds. In the absolute majority of cases this will be equal to the value returned by
getPosition
.
Use this method to display the current position to the user.
Example
const wallClockTime = player.getWallClockTime();
const nowInSeconds = Date.now() / 1000;
const delta = nowInSeconds - wallClockTime;
if (delta < 5) { // (5 seconds of margin)
console.log("You're playing live");
} else {
console.log(`You're playing ${delta} seconds behind the live content`);
}
seekTo
arguments: Object|Number
Seek in the current content (i.e. change the current position).
The argument can be an object with a single Number
property, either:
-
relative
: seek relatively to the current position -
position
: seek to the given absolute position (equivalent toplayer.getVideoElement().currentTime = newPosition
) -
wallClockTime
: seek to the given wallClock position, as returned bygetWallClockTime
.
The argument can also just be a Number
property, which will have the same
effect than the position
property (absolute position).
Examples
// seeking to 54 seconds from the start of the content
player.seekTo({ position: 54 });
// equivalent to just:
player.seekTo(54);
// seeking 5 seconds after the current position
player.seekTo({ relative: 5 });
// seeking 5 seconds before the current position
player.seekTo({ relative: -5 });
// seeking to live content
player.seekTo({ wallClockTime: Date.now() / 1000 });
getMinimumPosition
return value: Number|null
The minimum seekable player position. null
if no content is loaded.
This is useful for live contents, where server-side buffer size are often not infinite. This method allows thus to seek at the earliest possible time.
As the given position is the absolute minimum position, you might add a security margin (like a few seconds) when seeking to this position in a live content. Not doing so could led to the player being behind the minimum position after some time, and thus unable to continue playing.
For VoD contents, as the minimum position normally don’t change, seeking at the minimum position should not cause any issue.
Example
// Seeking close to the minimum position (with a 5 seconds security margin)
player.seekTo({ position: player.getMinimumPosition() + 5 });
getMaximumPosition
return value: Number|null
The maximum seekable player position. null
if no content is loaded.
This is useful for live contents, where the buffer end updates continously. This method allows thus to seek directly at the live edge of the content.
Please bear in mind that seeking exactly at the maximum position is rarely a good idea:
- for VoD contents, the playback will end
- for live contents, the player will then need to wait until it can build enough buffer.
As such, we advise to remove a few seconds from that position when seeking.
Example
// seeking 5 seconds before the end (or the live edge for live contents)
player.seekTo({
position: player.getMaximumPosition() - 5
});
getVideoDuration
return value: Number
Returns the duration of the current video as taken from the video element.
⚠ This duration is in fact the maximum position possible for the
content. As such, for contents not starting at 0
, this value will not be equal
to the difference between the maximum and minimum possible position, as would
normally be expected from a property named “duration”.
Example
const pos = player.getPosition();
const dur = player.getVideoDuration();
console.log(`current position: ${pos} / ${dur}`);
getError
return value: Error|null
Returns the current “fatal error” if one happenned for the last loaded content.
Returns null
otherwise.
A “fatal error” is an error which led the current loading/loaded content to
completely stop.
Such errors are usually also sent through the "error"
event when they happen.
See the Player Error documentation for more information.
Example
const error = player.getError();
if (!error) {
console.log("The player did not crash");
} else if (error.code === "PIPELINE_LOAD_ERROR") {
console.error("The player crashed due to a failing request");
} else {
console.error(`The player crashed: ${error.code}`);
}
getVideoElement
return value: HTMLMediaElement
Returns the media element used by the RxPlayer.
You’re not encouraged to use its APIs as they can enter in conflict with the RxPlayer’s API.
Despite its name, this method can also return an audio element if the RxPlayer was instantiated with one.
Example
const videoElement = player.getVideoElement();
videoElement.className = "my-video-element";
dispose
Free the ressources used by the player.
You can call this method if you know you won’t need the RxPlayer anymore.
⚠ The player won’t work correctly after calling this method.
Speed control
The following methods allows to update the current speed of playback (also called the “playback rate”).
setPlaybackRate
arguments: Number
Updates the current playback rate.
Setting that value to 1
reset the playback rate to its “normal” rythm.
Setting it to 2
allows to play at a speed multiplied by 2 relatively to
regular playback.
Setting it to 0.5
allows to play at half the speed relatively to regular
playback.
etc.
Example
// plays three times faster than normal
player.setPlaybackRate(3);
getPlaybackRate
return value: Number
Returns the current video playback rate. 1
for normal playback, 2
when
playing at double the speed, etc.
Example
const currentPlaybackRate = player.getPlaybackRate();
console.log(`Playing at a x${currentPlaybackRate}} speed`);
Volume control
Those methods allows to have control over the current audio volume of playing contents.
setVolume
arguments: Number
Set the current volume, from 0 (no sound) to 1 (the maximum sound level).
Note that the volume set here is persisted even when loading another content. As such, this method can also be called when no content is currently playing.
Example
// set the full volume
player.setVolume(1);
getVolume
return value: Number
Current volume of the player, from 0 (no sound) to 1 (maximum sound).
0 if muted through the mute
API.
As the volume is not dependent on a single content (it is persistent), this method can also be called when no content is playing.
Example
const volume = player.getVolume();
if (volume === 1) {
console.log("You're playing at maximum volume");
} else if (volume === 0) {
console.log("You're playing at no volume");
} else if (volume > 0.5) {
console.log("You're playing at a high volume");
} else {
console.log("You're playing at a low volume");
}
mute
Mute the volume.
Basically set the volume to 0 while keeping in memory the previous volume to
reset it at the next unMute
call.
As the volume is not dependent on a single content (it is persistent), this method can also be called when no content is playing.
Example
// mute the current volume
player.mute();
unMute
When muted, restore the volume to the one previous to the last mute
call.
When the volume is already superior to 0
, this call won’t do anything.
As the volume is not dependent on a single content (it is persistent), this method can also be called when no content is playing.
Example
// mute the current volume
player.mute();
// unmute and restore the previous volume
player.unMute();
isMute
returns: Boolean
Returns true if the volume is set to 0
.
Example
if (player.isMute()) {
console.log("The content plays with no sound.");
}
Track selection
The following methods allows to choose the right video audio or text track and to obtain information about the currently playing tracks.
getAudioTrack
returns: Object|null|undefined
Get information about the audio track currently set.
null
if no audio track is enabled right now.
If an audio track is set and information about it is known, this method will return an object with the following properties:
-
id
(Number|string
): The id used to identify this track. No other audio track for the same Period will have the sameid
.This can be useful when setting the track through the
setAudioTrack
method. -
language
(string
): The language the audio track is in, as set in the Manifest. -
normalized
(string
): An attempt to translate thelanguage
property into an ISO 639-3 language code (for now only support translations from ISO 639-1 and ISO 639-3 language codes). If the translation attempt fails (no corresponding ISO 639-3 language code is found), it will equal the value oflanguage
-
audioDescription
(Boolean
): Whether the track is an audio description of what is happening at the screen. -
dub
(Boolean|undefined
): If set totrue
, this audio track is a “dub”, meaning it was recorded in another language than the original. If set tofalse
, we know that this audio track is in an original language. This property isundefined
if we do not known whether it is in an original language. -
representations
(Array.<Object>
): Representations of this video track, with attributes:-
id
(string
): The id used to identify this Representation. No other Representation from this track will have the sameid
. -
bitrate
(Number
): The bitrate of this Representation, in bits per seconds. -
codec
(string|undefined
): The audio codec the Representation is in, as announced in the corresponding Manifest.
-
undefined
if no audio content has been loaded yet or if its information is
unknown.
–
Note for multi-Period contents:
This method will only return the chosen audio track for the Period that is currently playing.
__
In DirectFile mode
(see loadVideo options), if there is
no audio tracks API in the browser, this method will return undefined
.
getTextTrack
returns: Object|null|undefined
Get information about the text track currently set.
null
if no audio track is enabled right now.
If a text track is set and information about it is known, this method will return an object with the following properties:
-
id
(Number|string
): The id used to identify this track. No other text track for the same Period will have the sameid
.This can be useful when setting the track through the
setTextTrack
method. -
language
(string
): The language the text track is in, as set in the Manifest. -
normalized
(string
): An attempt to translate thelanguage
property into an ISO 639-3 language code (for now only support translations from ISO 639-1 and ISO 639-3 language codes). If the translation attempt fails (no corresponding ISO 639-3 language code is found), it will equal the value oflanguage
-
closedCaption
(Boolean
): Whether the track is specially adapted for the hard of hearing or not.
undefined
if no text content has been loaded yet or if its information is
unknown.
–
Note for multi-Period contents:
This method will only return the chosen text track for the Period that is currently playing.
__
In DirectFile mode
(see loadVideo options), if there is
no text tracks API in the browser, this method will return undefined
.
getVideoTrack
returns: Object|null|undefined
Get information about the video track currently set.
null
if no video track is enabled right now.
If a video track is set and information about it is known, this method will return an object with the following properties:
-
id
(Number|string
): The id used to identify this track. No other video track for the same Period will have the sameid
.This can be useful when setting the track through the
setVideoTrack
method. -
representations
(Array.<Object>
): Representations of this video track, with attributes:-
id
(string
): The id used to identify this Representation. No other Representation from this track will have the sameid
. -
bitrate
(Number
): The bitrate of this Representation, in bits per seconds. -
width
(Number|undefined
): The width of video, in pixels. -
height
(Number|undefined
): The height of video, in pixels. -
codec
(string|undefined
): The video codec the Representation is in, as announced in the corresponding Manifest. -
frameRate
(string|undefined
): The video frame rate.
-
-
signInterpreted
(Boolean|undefined
): If set totrue
, the track is known to contain an interpretation in sign language. If set tofalse
, the track is known to not contain that type of content. If not set or set to undefined we don’t know whether that video track contains an interpretation in sign language.
undefined
if no video content has been loaded yet or if its information is
unknown.
–
Note for multi-Period contents:
This method will only return the chosen video track for the Period that is currently playing.
–
In DirectFile mode
(see loadVideo options), if there is
no video tracks API in the browser, this method will return undefined
.
getAvailableAudioTracks
returns: Array.<Object>
Returns the list of available audio tracks for the current content.
Each of the objects in the returned array have the following properties:
-
active
(Boolean
): Whether the track is the one currently active or not. Only maximum one audio track can be active at a time. -
id
(string
): The id used to identify the track. Use it for setting the track viasetAudioTrack
. -
language
(string
): The language the audio track is in, as set in the Manifest. -
normalized
(string
): An attempt to translate thelanguage
property into an ISO 639-3 language code (for now only support translations from ISO 639-1 and ISO 639-2 language codes). If the translation attempt fails (no corresponding ISO 639-3 language code is found), it will equal the value oflanguage
-
audioDescription
(Boolean
): Whether the track is an audio description of what is happening at the screen. -
dub
(Boolean|undefined
): If set totrue
, this audio track is a “dub”, meaning it was recorded in another language than the original. If set tofalse
, we know that this audio track is in an original language. This property isundefined
if we do not known whether it is in an original language. -
representations
(Array.<Object>
): Representations of this video track, with attributes:-
id
(string
): The id used to identify this Representation. -
bitrate
(Number
): The bitrate of this Representation, in bits per seconds. -
codec
(string|undefined
): The audio codec the Representation is in, as announced in the corresponding Manifest.
-
–
Note for multi-Period contents:
This method will only return the available tracks of the Period that is currently playing.
–
In DirectFile mode (see loadVideo options), if there are no supported tracks in the file or no track management API this method will return an empty Array.
getAvailableTextTracks
returns: Array.<Object>
Returns the list of available text tracks (subtitles) for the current content.
Each of the objects in the returned array have the following properties:
-
id
(string
): The id used to identify the track. Use it for setting the track viasetTextTrack
. -
language
(string
): The language the text track is in, as set in the Manifest. -
normalized
(string
): An attempt to translate thelanguage
property into an ISO 639-3 language code (for now only support translations from ISO 639-1 and ISO 639-2 language codes). If the translation attempt fails (no corresponding ISO 639-3 language code is found), it will equal the value oflanguage
-
closedCaption
(Boolean
): Whether the track is specially adapted for the hard of hearing or not. -
active
(Boolean
): Whether the track is the one currently active or not.
–
Note for multi-Period contents:
This method will only return the available tracks of the Period that is currently playing.
–
In DirectFile mode (see loadVideo options), if there are no supported tracks in the file or no track management API this method will return an empty Array.
getAvailableVideoTracks
returns: Array.<Object>
Returns the list of available video tracks for the current content.
Each of the objects in the returned array have the following properties:
-
id
(string
): The id used to identify the track. Use it for setting the track viasetVideoTrack
. -
active
(Boolean
): Whether this track is the one currently active or not. -
representations
(Array.<Object>
): Representations of this video track, with attributes:-
id
(string
): The id used to identify this Representation. -
bitrate
(Number
): The bitrate of this Representation, in bits per seconds. -
width
(Number|undefined
): The width of video, in pixels. -
height
(Number|undefined
): The height of video, in pixels. -
codec
(string|undefined
): The video codec the Representation is in, as announced in the corresponding Manifest. -
frameRate
(string|undefined
): The video framerate.
-
-
signInterpreted
(Boolean|undefined
): If set totrue
, the track is known to contain an interpretation in sign language. If set tofalse
, the track is known to not contain that type of content. If not set or set to undefined we don’t know whether that video track contains an interpretation in sign language.
–
Note for multi-Period contents:
This method will only return the available tracks of the Period that is currently playing.
–
In DirectFile mode (see loadVideo options), if there are no supported tracks in the file or no track management API this method will return an empty Array.
setAudioTrack
arguments: string|Number
Change the current audio track.
The argument to this method is the wanted track’s id
property. This id
can
for example be obtained on the corresponding track object returned by the
getAvailableAudioTracks
method.
–
Note for multi-Period contents:
This method will only have an effect on the Period that is currently playing. If you want to update the track for other Periods as well, you might want to either:
- update the current audio track once a
"periodChange"
event has been received. - update first the preferred audio tracks through the setPreferredAudioTracks method.
–
⚠ If used on Safari, in DirectFile mode, the track change may change the track on other track type (e.g. changing video track may change subtitle track too). This has two potential reasons :
- The HLS defines variants, groups of tracks that may be read together
- Safari may decide to enable a track for accessibility or user language convenience (e.g. Safari may switch subtitle to your OS language if you pick another audio language) You can know if another track has changed by listening to the corresponding events that the tracks have changed.
setTextTrack
arguments: string
Change the current text (subtitles) track.
The argument to this method is the wanted track’s id
property. This id
can
for example be obtained on the corresponding track object returned by the
getAvailableTextTracks
method.
–
Note for multi-Period contents:
This method will only have an effect on the Period that is currently playing. If you want to update the track for other Periods as well, you might want to either:
- update the current text track once a
"periodChange"
event has been received. - update first the preferred text tracks through the setPreferredTextTracks method.
–
⚠ If used on Safari, in DirectFile mode, the track change may change the track on other track type (e.g. changing video track may change subtitle track too). This has two potential reasons :
- The HLS defines variants, groups of tracks that may be read together
- Safari may decide to enable a track for accessibility or user language convenience (e.g. Safari may switch subtitle to your OS language if you pick another audio language) You can know if another track has changed by listening to the corresponding events that the tracks have changed.
disableTextTrack
Disable the current text track, if one.
After calling that method, no subtitles track will be displayed until
setTextTrack
is called.
–
Note for multi-Period contents:
This method will only have an effect on the Period that is currently playing.
If you want to disable the text track for other Periods as well, you might want
to call setPreferredVideoTracks instead. With
this method, you can globally apply a null
text track preference - which means
that you would prefer having no text track - by setting its second argument to
true
.
More information can be found on that API’s documentation.
setVideoTrack
arguments: string|Number
Change the current video track.
The argument to this method is the wanted track’s id
property. This id
can
for example be obtained on the corresponding track object returned by the
getAvailableAudioTracks
method.
Setting a new video track when a previous one was already playing can lead the rx-player to “reload” this content.
During this period of time:
- the player will have the state
RELOADING
- Multiple APIs linked to the current content might not work.
Most notably:
play
will not workpause
will not workseekTo
will not workgetPosition
will return 0getWallClockTime
will return 0getVideoDuration
will returnNaN
getAvailableAudioTracks
will return an empty arraygetAvailableTextTracks
will return an empty arraygetAvailableVideoTracks
will return an empty arraygetTextTrack
will returnnull
getAudioTrack
will returnnull
setAudioTrack
will throwsetTextTrack
will throw
–
Note for multi-Period contents:
This method will only have an effect on the Period that is currently playing. If you want to update the track for other Periods as well, you might want to either:
- update the current video track once a
"periodChange"
event has been received. - update first the preferred video tracks through the setPreferredVideoTracks method.
–
⚠ This option will have no effect in DirectFile mode (see loadVideo options) when either :
- No video track API is supported on the current browser
- The media file tracks are not supported on the browser
disableVideoTrack
return value: void
Disable the current video track, if one.
Might enter in RELOADING
state for a short period after calling this API.
–
Note for multi-Period contents:
This method will only have an effect on the Period that is currently playing.
If you want to disable the video track for other Periods as well, you might want
to call setPreferredVideoTracks instead. With
this method, you can globally apply a null
video track preference - which means
that you would prefer having no video track - by setting its second argument to
true
.
More information can be found on that API’s documentation.
–
⚠ This option may have no effect in DirectFile mode (see loadVideo options). The directfile mode is a special case here because when in it, the RxPlayer depends for track selection on the corresponding HTML standard as implemented by the different browsers. Though this standard says nothing about not being able to disable the video track (or to stay more in line with their terms: to not select any video track), no browser implementation actually seem to be able to do it, even when the corresponding browser APIs show that no video track is currently selected. This might be a bug on their parts.
Due to this fact, we do not recommend using this API in directfile mode for
now. You might even receive a reassuring videoTrackChange
event (with a null
payload) while the video track is still actually active.
setPreferredAudioTracks
argument 1: Array.<Object>
argument 2: Boolean | undefined
Allows the RxPlayer to choose an initial audio track, based on language preferences, codec preferences or both.
–
The first argument should be set as an array of objects, each object describing constraints an audio track should respect.
Here is all the possible constraints you can set in any one of those objects (note that all properties are optional here, only those set will have an effect on which tracks will be filtered):
{
language: "fra", // {string|undefined} The language the track should be in
// (in preference as an ISO 639-1, ISO 639-2 or ISO 639-3
// language code).
// If not set or set to `undefined`, the RxPlayer won't
// filter based on the language of the track.
audioDescription: false // {Boolean|undefined} Whether the audio track should
// be an audio description for the visually impaired
// or not.
// If not set or set to `undefined`, the RxPlayer
// won't filter based on that status.
codec: { // {Object|undefined} Constraints about the codec wanted.
// if not set or set to `undefined` we won't filter based on codecs.
test: /ec-3/, // {RegExp} RegExp validating the type of codec you want.
all: true, // {Boolean} Whether all the profiles (i.e. Representation) in a
// track should be checked against the RegExp given in `test`.
// If `true`, we will only choose a track if EVERY profiles for
// it have a codec information that is validated by that RegExp.
// If `false`, we will choose a track if we know that at least
// A SINGLE profile from it has codec information validated by
// that RegExp.
}
}
When encountering a new content or a new choice of tracks in a given content, the RxPlayer will look at each object in that array. If the first object in it defines constaints that cannot be respected under the currently available audio tracks, the RxPlayer will consider the second object in the array and so on.
As such, this array should be sorted by order of preference: from the most wanted constraints to the least.
–
The second argument to that function is an optional boolean which - when set
to true
- will apply that preference to the content and Period that have
already been playing.
By setting it to true
, you might thus change the currently-active track and
the active track of Periods (in DASH) or sub-contents (in MetaPlaylist) that
have already been played in the current content.
By setting it to false
, undefined
or not setting it, those preferences will
only be applied each time a new Period or sub-content is loaded by the
RxPlayer.
Simply put, if you don’t set the second argument to true
those preferences
won’t be applied to:
-
the content being currently played. Here, the current audio preference will stay in place.
-
the Periods or sub-contents which have already been loaded for the current content. Those will keep the audio track chosen at the last time they were loaded.
If you want the preferences to also be applied to those, you can set the second
argument to true
.
Examples
Let’s imagine that you prefer to have french or italian over all other audio languages. If not found, you want to fallback to english:
player.setPreferredAudioTracks([
{ language: "fra", audioDescription: false },
{ language: "ita", audioDescription: false },
{ language: "eng", audioDescription: false }
])
Now let’s imagine that you want to have in priority a track that contain at least one profile in Dolby Digital Plus (ec-3 codec) without caring about the language:
player.setPreferredAudioTracks([ { codec: { all: false, test: /ec-3/ } ]);
At last, let’s combine both examples by preferring french over itialian, italian over english while preferring it to be in Dolby Digital Plus:
player.setPreferredAudioTracks([
{
language: "fra",
audioDescription: false,
codec: { all: false, test: /ec-3/ }
},
// We still prefer non-DD+ french over DD+ italian
{ language: "fra", audioDescription: false },
{
language: "ita",
audioDescription: false,
codec: { all: false, test: /ec-3/ }
},
{ language: "ita", audioDescription: false },
{
language: "eng",
audioDescription: false,
codec: { all: false, test: /ec-3/ }
},
{ language: "eng", audioDescription: false }
]);
–
⚠ This option will have no effect in DirectFile mode (see loadVideo options) when either :
- No audio track API is supported on the current browser
- The media file tracks are not supported on the browser
getPreferredAudioTracks
return value: Array.<Object>
Returns the current list of preferred audio tracks - by order of preference.
This returns the data in the same format that it was given to either the
preferredAudioTracks
constructor option or the last setPreferredAudioTracks
if it was called.
It will return an empty Array if none of those two APIs were used until now.
setPreferredTextTracks
argument 1: Array.<Object|null>
argument 2: Boolean | undefined
Allows the RxPlayer to choose an initial text track, based on language and accessibility preferences.
–
The first argument should be set as an array of objects, each object describing constraints a text track should respect.
Here is all the properties that should be set in a single object of that array.
{
language: "fra", // {string} The wanted language
// (ISO 639-1, ISO 639-2 or ISO 639-3 language code)
closedCaption: false // {Boolean} Whether the text track should be a closed
// caption for the hard of hearing
}
When encountering a new content or a new choice of tracks in a given content, the RxPlayer will look at each object in that array. If the first object in it defines constaints that cannot be respected under the currently available text tracks, the RxPlayer will consider the second object in the array and so on.
As such, this array should be sorted by order of preference: from the most wanted constraints to the least.
You can set null
instead of an object to mean that you want no subtitles.
When reaching that point of the array, the RxPlayer will just disable the
current text track.
As such, if you never want any subtitles, you can just set this argument to
[null]
(an array with only the value null
at the first position).
–
The second argument to that function is an optional boolean which - when set
to true
- will apply that preference to the content and Period that have
already been playing.
By setting it to true
, you might thus change the currently-active text track
and the active text track of Periods (in DASH) or sub-contents (in
MetaPlaylist) that have already been played in the current content.
By setting it to false
, undefined
or not setting it, those preferences will
only be applied each time a new Period or sub-content is loaded by the
RxPlayer.
Simply put, if you don’t set the second argument to true
those preferences
won’t be applied to:
-
the content being currently played. Here, the current text track preference will stay in place.
-
the Periods or sub-contents which have already been loaded for the current content. Those will keep the text track chosen at the last time they were loaded.
If you want the preferences to also be applied to those, you can set the second
argument to true
.
Example
Let’s imagine that you prefer to have french or italian subtitles.If not found, you want no subtitles at all.
You will thus call setPreferredTextTracks
that way.
player.setPreferredTextTracks([
{ language: "fra", closedCaption: false },
{ language: "ita", closedCaption: false },
null
]);
This won’t apply on the currently loaded content(s), if you also want that, you
can add true
as a second argument:
player.setPreferredTextTracks([
{ language: "fra", closedCaption: false },
{ language: "ita", closedCaption: false },
null
], true);
–
⚠ This option will have no effect in DirectFile mode (see loadVideo options) when either :
- No text track API is supported on the current browser
- The media file tracks are not supported on the browser
getPreferredTextTracks
return value: Array.<Object|null>
Returns the current list of preferred text tracks - by order of preference.
This returns the data in the same format that it was given to either the
preferredTextTracks
constructor option or the last setPreferredTextTracks
if
it was called:
{
language: "fra", // {string} The wanted language
// (ISO 639-1, ISO 639-2 or ISO 639-3 language code)
closedCaption: false // {Boolean} Whether the text track should be a closed
// caption for the hard of hearing
}
setPreferredVideoTracks
argument 1: Array.<Object>
argument 2: Boolean | undefined
Allows the RxPlayer to choose an initial video track, based on codec preferences, accessibility preferences or both.
–
The first argument should be set as an array of objects, each object describing constraints a video track should respect.
Here is all the possible constraints you can set in any one of those objects (note that all properties are optional here, only those set will have an effect on which tracks will be filtered):
{
codec: { // {Object|undefined} Constraints about the codec wanted.
// if not set or set to `undefined` we won't filter based on codecs.
test: /hvc/, // {RegExp} RegExp validating the type of codec you want.
all: true, // {Boolean} Whether all the profiles (i.e. Representation) in a
// track should be checked against the RegExp given in `test`.
// If `true`, we will only choose a track if EVERY profiles for
// it have a codec information that is validated by that RegExp.
// If `false`, we will choose a track if we know that at least
// A SINGLE profile from it has codec information validated by
// that RegExp.
}
signInterpreted: true, // {Boolean|undefined} If set to `true`, only tracks
// which are known to contains a sign language
// interpretation will be considered.
// If set to `false`, only tracks which are known
// to not contain it will be considered.
// if not set or set to `undefined` we won't filter
// based on that status.
}
If the first defined object in that array - defining the first set of constraints - cannot be respected under the currently available video tracks, the RxPlayer will check with the second object instead and so on.
As such, this array should be sorted by order of preference: from the most wanted constraints to the least.
When the next encountered constraint is set to null
, the player will simply
disable the video track. If you want to disable the video track by default,
you can just set null
as the first element of this array (e.g. like [null]
).
–
The second argument to that function is an optional boolean which - when set
to true
- will apply that preference to the content and Period that have
already been playing.
By setting it to true
, you might thus change the currently-active track and
the active track of Periods (in DASH) or sub-contents (in MetaPlaylist) that
have already been played in the current content.
By setting it to false
, undefined
or not setting it, those preferences will
only be applied each time a new Period (or sub-content) is loaded by the
RxPlayer.
Simply put, if you don’t set the second argument to true
those preferences
won’t be applied to:
-
the content being currently played. Here, the current video preference will stay in place.
-
the Periods or sub-contents which have already been loaded for the current content. Those will keep the video track chosen at the last time they were loaded.
If you want the preferences to also be applied to those, you can set the second
argument to true
.
Examples
Let’s imagine that you prefer to have a track which contains only H265 profiles. You can do:
player.setPreferredVideoTracks([ { codec: { all: false, test: /^hvc/ } } ]);
With that same constraint, let’s no consider that the current user prefer in any case to have a sign language interpretation on screen:
player.setPreferredVideoTracks([
// first let's consider the best case: H265 + sign language interpretation
{
codec: { all: false, test: /^hvc/ }
signInterpreted: true,
},
// If not available, we still prefer a sign interpreted track without H265
{ signInterpreted: true },
// If not available either, we would prefer an H265 content
{ codec: { all: false, test: /^hvc/ } },
// Note: If this is also available, we will here still have a video track
// but which do not respect any of the constraints set here.
]);
would thus prefer the video to contain a sign language interpretation.
We could set both the previous and that new constraint that way:
---
For a totally different example, let's imagine you want to play without any
video track enabled (e.g. to start in an audio-only mode). To do that, you can
simply do:
```js
player.setPreferredVideoTracks([null], true);
⚠ This option will have no effect in DirectFile mode (see loadVideo options) when either :
- No video track API is supported on the current browser
- The media file tracks are not supported on the browser
getPreferredVideoTracks
return value: Array.<Object>
Returns the current list of preferred video tracks - by order of preference.
This returns the data in the same format that it was given to either the
preferredVideoTracks
constructor option or the last setPreferredVideoTracks
if it was called.
It will return an empty Array if none of those two APIs were used until now.
Bitrate selection
The following methods allows to choose a given bitrate for audio or video content. It can also enable or disable an adaptive bitrate logic or influence it.
getAvailableVideoBitrates
return value: Array.<Number>
The different bitrates available for the current video track in bits per seconds.
–
Note for multi-Period contents:
This method will only return the available video bitrates of the Period that is currently playing.
–
In DirectFile mode (see loadVideo options), returns an empty Array.
Example
const videoBitrates = player.getAvailableVideoBitrates();
if (videoBitrates.length) {
console.log(
"The current video is available in the following bitrates",
videoBitrates.join(", ")
);
}
getAvailableAudioBitrates
return value: Array.<Number>
The different bitrates available for the current audio track in bits per seconds.
–
Note for multi-Period contents:
This method will only return the available audio bitrates of the Period that is currently playing.
–
In DirectFile mode (see loadVideo options), returns an empty Array.
Example
const audioBitrates = player.getAvailableAudioBitrates();
if (audioBitrates.length) {
console.log(
"The current audio is available in the following bitrates",
audioBitrates.join(", ")
);
}
getVideoBitrate
return value: Number|undefined
Returns the bitrate of the video quality currently set, in bits per second.
Returns undefined
if no content is loaded.
–
Note for multi-Period contents:
This method will only return the chosen video bitrate for the Period that is currently playing.
–
In DirectFile mode (see loadVideo
options), returns undefined
.
getAudioBitrate
return value: Number|undefined
Returns the bitrate of the audio quality currently set, in bits per second.
Returns undefined
if no content is loaded.
–
Note for multi-Period contents:
This method will only return the chosen audio bitrate for the Period that is currently playing.
–
In DirectFile mode (see loadVideo
options), returns undefined
.
setMaxVideoBitrate
arguments: Number
Set the maximum video bitrate reachable through adaptive streaming. The player will never automatically switch to a video quality with a higher bitrate.
This limit can be removed by setting it to Infinity
:
// remove video bitrate limit
player.setMaxVideoBitrate(Infinity);
The effect of this method is persisted from content to content. As such, it can even be called when no content is currently loaded.
Note that this only affects adaptive strategies (you can bypass this limit by
calling setVideoBitrate
).
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
setMaxAudioBitrate
arguments: Number
Set the maximum audio bitrate reachable through adaptive streaming. The player will never automatically switch to a audio Representation with a higher bitrate.
This limit can be removed by setting it to Infinity
:
// remove audio bitrate limit
player.setMaxAudioBitrate(Infinity);
The effect of this method is persisted from content to content. As such, it can even be called when no content is currently loaded.
Note that this only affects adaptive strategies (you can bypass this limit by
calling setAudioBitrate
).
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
getMaxVideoBitrate
return value: Number
Returns the maximum video bitrate reachable through adaptive streaming, in bits per seconds.
This limit can be updated by calling the setMaxVideoBitrate method.
This limit only affects adaptive strategies (you can bypass this limit by
calling setVideoBitrate
), and is set to Infinity
when no limit has been
set.
getMaxAudioBitrate
return value: Number
Returns the maximum audio bitrate reachable through adaptive streaming, in bits per seconds.
This limit can be updated by calling the setMaxAudioBitrate method.
This limit only affects adaptive strategies (you can bypass this limit by
calling setAudioBitrate
), and is set to Infinity
when no limit has been
set.
setVideoBitrate
arguments: Number
Force the current video track to be of a certain bitrate.
If an video quality in the current track is found with the exact same bitrate, this quality will be set.
If no video quality is found with the exact same bitrate, either:
-
the video quality with the closest bitrate inferior to that value will be chosen.
-
if no video quality has a bitrate lower than that value, the video quality with the lowest bitrate will be chosen instead.
By calling this method with an argument set to -1
, this setting will be
disabled and the RxPlayer will chose the right quality according to its adaptive
logic.
You can use getAvailableVideoBitrates
to get the list of available bitrates
for the current video track.
Note that the value set is persistent between loadVideo
calls.
As such, this method can also be called when no content is playing (the same
rules apply for future contents).
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
setAudioBitrate
arguments: Number
Force the current audio track to be of a certain bitrate.
If an audio quality in the current track is found with the exact same bitrate, this quality will be set.
If no audio quality is found with the exact same bitrate, either:
-
the audio quality with the closest bitrate inferior to that value will be chosen.
-
if no audio quality has a bitrate lower than that value, the audio quality with the lowest bitrate will be chosen instead.
By calling this method with an argument set to -1
, this setting will be
disabled and the RxPlayer will chose the right quality according to its adaptive
logic.
You can use getAvailableAudioBitrates
to get the list of available bitrates
for the current audio track.
Note that the value set is persistent between loadVideo
calls.
As such, this method can also be called when no content is playing (the same
rules apply for future contents).
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
getManualVideoBitrate
arguments: Number
Get the last video bitrate manually set. Either via setVideoBitrate
or via
the initialVideoBitrate
constructor option.
This value can be different than the one returned by getVideoBitrate
:
getManualVideoBitrate
returns the last bitrate set manually by the usergetVideoBitrate
returns the actual bitrate of the current video track
-1
when no video bitrate is forced.
getManualAudioBitrate
arguments: Number
Get the last audio bitrate manually set. Either via setAudioBitrate
or via
the initialAudioBitrate
constructor option.
This value can be different than the one returned by getAudioBitrate
:
getManualAudioBitrate
returns the last bitrate set manually by the usergetAudioBitrate
returns the actual bitrate of the current audio track
-1
when no audio bitrate is forced.
Buffer control
The methods in this chapter allow to get and set limits on how the current buffer can grow.
setWantedBufferAhead
arguments: Number
Set the buffering goal, as a duration ahead of the current position, in seconds.
Once this size of buffer reached, the player won’t try to download new segments anymore.
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
getWantedBufferAhead
return value: Number
defaults: 30
returns the buffering goal, as a duration ahead of the current position, in seconds.
setMaxBufferBehind
arguments: Number
Set the maximum kept buffer before the current position, in seconds.
Everything before that limit (currentPosition - maxBufferBehind
) will be
automatically garbage collected.
This feature is not necessary as the browser should by default correctly remove old segments from memory if/when the memory is scarce.
However on some custom targets, or just to better control the memory footprint of the player, you might want to set this limit.
You can set it to Infinity
to remove this limit and just let the browser do
this job instead.
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
getMaxBufferBehind
return value: Number
defaults: Infinity
Returns the maximum kept buffer before the current position, in seconds.
This setting can be updated either by:
- calling the
setMaxBufferBehind
method. - instanciating an RxPlayer with a
maxBufferBehind
property set.
setMaxBufferAhead
arguments: Number
Set the maximum kept buffer ahead of the current position, in seconds.
Everything superior to that limit (currentPosition + maxBufferAhead
) will
be automatically garbage collected.
This feature is not necessary as the browser should by default correctly remove old segments from memory if/when the memory is scarce.
However on some custom targets, or just to better control the memory footprint of the player, you might want to set this limit.
You can set it to Infinity
to remove any limit and just let the browser do
this job instead.
The minimum value between this one and the one returned by
getWantedBufferAhead
will be considered when downloading new segments.
⚠ Bear in mind that a too-low configuration there (e.g. inferior to
10
) might prevent the browser to play the content at all.
–
⚠ This option will have no effect for contents loaded in DirectFile mode (see loadVideo options).
getMaxBufferAhead
return value: Number
defaults: Infinity
Returns the maximum kept buffer ahead of the current position, in seconds.
This setting can be updated either by:
- calling the
setMaxBufferAhead
method. - instanciating an RxPlayer with a
maxBufferAhead
property set.
Buffer information
The methods in this chapter allows to retrieve information about what is currently buffered.
getVideoLoadedTime
return value: Number
Returns in seconds the difference between:
- the start of the current contiguous loaded range.
- the end of it.
getVideoPlayedTime
return value: Number
Returns in seconds the difference between:
- the start of the current contiguous loaded range.
- the current time.
getVideoBufferGap
return value: Number
Returns in seconds the difference between:
- the current time.
- the end of the current contiguous loaded range.
Content information
The methods documented in this chapter allows to obtain general information about the current loaded content.
isLive
return value: Boolean
Returns true
if the content is a “live” content (e.g. a live TV Channel).
false
otherwise.
Also false
if no content is loaded yet.
Example
if (player.isLive()) {
console.log("We're playing a live content");
}
getUrl
return value: string|undefined
Returns the URL of the downloaded Manifest.
In DirectFile mode (see loadVideo options), returns the URL of the content being played.
Returns undefined
if no content is loaded yet.
Example
const url = player.getUrl();
if (url) {
console.log("We are playing the following content:", url);
}
getCurrentKeySystem
return value: string|undefined
Returns the type of keySystem used for DRM-protected contents.
Deprecated
The following methods are deprecated. They are still supported but we advise users to not use those as they might become not supported in the future.
getManifest
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: Manifest|null
Returns the current loaded Manifest if one. The Manifest object structure is relatively complex and is described in the Manifest Object structure page.
null
if the player is either stopped or not loaded.
null
in DirectFile mode (see loadVideo
options).
The Manifest will be available before the player reaches the "LOADED"
state.
getCurrentAdaptations
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: Object|null
Returns the Adaptations being loaded per type if a Manifest is loaded. The returned object will have at most a key for each type (“video”, “audio”, “text” and “image”) which will each contain an array of Adaptation Objects.
The Adaptation object structure is relatively complex and is described in the Manifest Object structure page.
null
if the current Adaptations are not known yet.
null
in DirectFile mode (see loadVideo
options).
getCurrentRepresentations
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: Object|null
Returns the Representations being loaded per type if a Manifest is loaded. The returned object will have at most a key for each type (“video”, “audio”, “text” and “image”) which will each contain an array of Representation Objects.
An Representation object structure is relatively complex and is described in the Manifest Object structure page.
null
if the current Representations are not known yet.
null
in DirectFile mode (see loadVideo
options).
getImageTrackData
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: Array.<Object>|null
The current image track’s data, null if no content is loaded / no image track data is available.
The returned array follows the usual image playlist structure, defined here.
null
in DirectFile mode (see loadVideo
options).
setFullscreen
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
arguments: Boolean
Switch or exit the <video>
element to fullscreen mode. The argument is an
optional boolean:
-
if set:
true
: enters fullscreenfalse
: exit fullscreen
-
if not set: enter fullscreen
Note that only the video element will be set to fullscreen mode. You might prefer to implement your own method to include your controls in the final UI.
exitFullscreen
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
Exit fullscreen mode. Same than setFullscreen(false)
.
isFullscreen
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: Boolean
Returns true
if the video element is in fullscreen mode, false
otherwise.
Example
if (player.isFullscreen()) {
console.log("The player is in fullscreen mode");
}
getNativeTextTrack
–
⚠ This method is deprecated, it will disappear in the next major
release v4.0.0
(see Deprecated APIs).
–
return value: TextTrack|null
Returns the first text track of the video’s element, null if none.
This is equivalent to:
const el = player.getVideoElement();
const textTrack = el.textTracks.length ? el.textTracks[0] : null;
Static properties
This chapter documents the static properties that can be found on the RxPlayer class.
version
type: Number
The current version of the RxPlayer.
ErrorTypes
type: Object
The different “types” of Error you can get on playback error,
See the Player Error documentation for more information.
ErrorCodes
type: Object
The different Error “codes” you can get on playback error,
See the Player Error documentation for more information.
LogLevel
type: string
default: "NONE"
The current level of verbosity for the RxPlayer logs. Those logs all use the console.
From the less verbose to the most:
-
"NONE"
: no log -
"ERROR"
: unexpected errors (viaconsole.error
) -
"WARNING"
: The previous level + minor problems encountered (viaconsole.warn
) -
"INFO"
: The previous levels + noteworthy events (viaconsole.info
) -
"DEBUG"
: The previous levels + normal events of the player (viaconsole.log
)
If the value set to this property is different than those, it will be
automatically set to "NONE"
.
Example
import RxPlayer from "rx-player";
RxPlayer.LogLevel = "WARNING";
Tools
The RxPlayer has several “tools”, which are utils which can be imported without importing the whole RxPlayer itself.
They are all documented here.
MediaCapabilitiesProber
–
⚠ This tool is experimental. This only means that its API can change at any new RxPlayer version (with all the details in the corresponding release note).
–
An experimental tool to probe browser media capabilities:
- Decoding capabilities
- DRM support
- HDCP support
- Display capabilities
You can find its documentation here.
TextTrackRenderer
–
⚠ This tool is experimental. This only means that its API can change at any new RxPlayer version (with all the details in the corresponding release note).
–
The TextTrackRenderer allows to easily render subtitles synchronized to a video element.
It allows easily to dynamically add subtitles (as long as it is in one of the following format: srt, ttml, webVTT or SAMI) to a played video.
This tool is documented here.
parseBifThumbnails
–
⚠ This tool is experimental. This only means that its API can change at any new RxPlayer version (with all the details in the corresponding release note).
–
The parseBifThumbnails
function parses BIF files, which is a format used
to declare thumbnails linked to a given content.
This tool is documented here.
createMetaplaylist
–
⚠ This tool is experimental. This only means that its API can change at any new RxPlayer version (with all the details in the corresponding release note).
–
The createMetaplaylist
function build a metaplaylist object from given
informations about contents.
This tool is documented here.


{% include 'header.html' %}
{% include 'menu.html' %}
{% include 'project/sidebar.html' %}
Add new credentials
Column numbers (0 if not):
Login/Email:
Hash:
Cleartext password:
Comment:
Source:
Delimiter:
Plaintext file:
Static row fields (every row):
Login/Email:
Hash:
Hash type:
Select hash type
None
MD5(hex)
SHA1(hex)
SHA256(hex)
SHA512(hex)
MD5-Crypt Unix $1$...$...
DES-Crypt Unix (old short)
SHA256-Crypt Unix $5$...$...
SHA512-Crypt Unix $6$...$...
NTLM or NT(hex)
LM(hex)
RabbitMQ MD5(base64)
Other
Check wordlist:
Check hash in wordlist
-
Top-10k passwords (2019)
Cleartext password:
Comment:
Source:
or input file content here:
Add
{% if errors is defined and errors %}
There were some errors with credentials
{% for error in errors %}
{{ error }}
{% endfor %}
{% endif %} {% if errors is defined and not errors %}
Credentials were added successfully!
{% endif %}
{% include 'footer.html' %}


Released 24, October 2011
This version is a major release where a lot of new features modules and classes are added.
Additions
Added new module HTML5 jqForm Visual builder
More can be found
here
Added new class jqForm
See documentatin on documentation page.
Demos can be found
herejqGrid
Changes in PHP
- Fix autocomplete when used with DB2 driver
- Fix for DB2 driver when afterCrud operation is set
- Add a separator in setSelect method
- Fix dateFormatter in datepicker
- Added new PDF option shrink_header (default false) in order to preserve the old behaviour
Changes in Java Script Code
- jQuery 1.6.x cmpatible
- Added header grouping
- idPrefix parameter in the grid to allow not have duplicate id in data row ids in case of two or more grids.
- if the beforeRequest event return false the ajax request can be canceled.
- Added beforeProcessing event which raises immediatley after the successed ajax request and before executing the adding new data.
- Adding Croatian localization
- RTL support for the new searchFilter module
- Controlling the positions and dimensions of alert dialog – adding the following parameters in navGrid method – alertwidth, alertheight, alerttop, alertleft. alertzIndex
- Allow user to override request method for inline edits (GET,POST) – i.e added mtype parameter
- Support for optgroup in inline edit
jqChart
- Added useHTML option for most text related configuration objects.
- Added softConnector option for pie data labels.
- Added chart.selectionMarkerFill option.
- Fixed issues with data label positioning for pies.
- Fixed issue with tooltips covering point in certain cases.
- Worked on memory leak issues.
- Fixed issues as listed at GitHub under dates since the last maintenance version.
- Rewrote data label positioning for pies.
- Fixed issues as listed at GitHub under dates since the last maintenance version.
- Added shadows for pies.
- Exported charts now respect user set min and max after zoom and visibility option.
- Added option series.connectNulls to connect line graphs through null points.
- Added support for exporting image symbols in charts.
- Added data labels for stack totals and improved positioning of column and bar data labels.
- Fixed issues as listed at GitHub under dates since the last maintenance version.
jqScheduler
- Add public local and templet paths
- Fix seraching to work with different chartsets
- Added option editable. If this option is set to true the scheduler is not editable and the user can not edit or add data
- Added option multiple_cal. If this option is set to true it is possible to view the data in multiple calendar users.
- Added option multiple_size. This option have effect only if multiple_cal is true and determineds the number of visble users in the select (multiple option in the select);
- Added year view
- Added a progress indicator which does not allow interactiong when the data is loaded


Salary Calculator
Add Employee:
First
Last
ID
Title
Salary
Clear Entries
Submit
Total Monthly: $
#####


All Classes
-
All Classes Interface Summary Class Summary Enum Summary Class Description AudioPlayer AudioPlayer product, has functionality for storing supported audio and playlist formats as well as functions for audio clip management.Controller The main controller class for our JavaFX Production application Currently handles H2 database, SQL and events from our UI.Employee Employee class that contains name, username, password and email and sets up employee emails and passwords.Item Item interface, contains helper functionality methods for a product.ItemType ItemType enum, contains 4 classifications for items - Audio, Visual, Audio-Mobile, and Visual-Mobile.Main Main entry point class for JavaFX application, loads the fxml file and creates the root and stage.MonitorType The different types of possible monitors for a visual or visual-mobile type product.MoviePlayer MoviePlayer product, has functionality for storing a screen and monitor type as well as functions for movie clip management.MultimediaControl MultimediaControl interface, contains 4 functions for a multimedia player.PopupController PopupController class, handles functionality of error popups for user input.Product Product class, top level implementation for product subclasses, contains important information such as name, manufacturer, and item-type which are stored in a database.ProductionRecord ProductionRecord class, stores information about a production event, including the production number, product ID, serial number, date produced, and product (optional).Screen Screen class, stores important screen information such as resolution, refresh rate and response time.ScreenSpec ScreenSpec interface, contains helper functionality methods for a screen class.Widget Widget to test the functionality of a product.


Before Change
b_p = agg.EdwBenchmarkPerformance(
total_iterations=2, expected_suite_queries=[Q1_NAME, Q2_NAME])
s1_p = agg.EdwSuitePerformance("suite_name", "suite_seq_1", 2)
q11_p = agg.EdwQueryPerformance(Q1_NAME, 1.0, {"job_id": "q1_s1_job_id"})
s1_p.add_query_performance(q11_p)
q12_p = agg.EdwQueryPerformance(Q2_NAME, 2.0, {"job_id": "q2_s1_job_id"})
s1_p.add_query_performance(q12_p)
b_p.add_suite_performance("suite_seq_1", s1_p)
s2_p = agg.EdwSuitePerformance("suite_name", "suite_seq_2", 2)
q21_p = agg.EdwQueryPerformance(Q1_NAME, 3.0, {"job_id": "q1_s2_job_id"})
s2_p.add_query_performance(q21_p)
q22_p = agg.EdwQueryPerformance(Q2_NAME, 4.0, {})
s2_p.add_query_performance(q22_p)
b_p.add_suite_performance("suite_seq_2", s2_p)
actual_sample = b_p.get_aggregated_geomean_performance_sample(
{"benchmark_name": "b_name"})
self.assertEqual(actual_sample.metric, "edw_aggregated_geomean")
self.assertEqual(actual_sample.value,
After Change
b_p = agg.EdwBenchmarkPerformance(
total_iterations=2, expected_queries=[Q1_NAME, Q2_NAME])
i1_p = agg.EdwIterationPerformance("1", 2)
s11_p = agg.EdwStreamPerformance(S1_NAME, 2)
q111_p = agg.EdwQueryPerformance(Q1_NAME, 1.0, {"job_id": "q1_i1_job_id"})
q112_p = agg.EdwQueryPerformance(Q2_NAME, 2.0, {"job_id": "q2_i1_job_id"})
s11_p.add_query_performance(q111_p)
s11_p.add_query_performance(q112_p)
i1_p.add_stream_performance(s11_p)
b_p.add_iteration_performance(i1_p)
i2_p = agg.EdwIterationPerformance("2", 2)
s21_p = agg.EdwStreamPerformance(S1_NAME, 2)
q211_p = agg.EdwQueryPerformance(Q1_NAME, 3.0, {"job_id": "q1_i2_job_id"})
q212_p = agg.EdwQueryPerformance(Q2_NAME, 4.0, {})
s21_p.add_query_performance(q211_p)
s21_p.add_query_performance(q212_p)
i2_p.add_stream_performance(s21_p)
b_p.add_iteration_performance(i2_p)
actual_sample = b_p.get_aggregated_geomean_performance_sample(
{"benchmark_name": "b_name"})
self.assertEqual(actual_sample.metric, "edw_aggregated_geomean")
self.assertEqual(actual_sample.value,


--- layout: post title: CSS underlines tags: [] status: publish type: post published: true meta: {} ---
More CSS wonders... though I don't how useful, or how many will adopt it, but Stuart Robertson shows us how to create stylised underlines, even animated ones.


|
Ipass project Natan Houwaart
|
Hardware UART implementation of the abstract protocol class. More...
#include <interface.h>
Public Member Functions | |
| uart (hwuart::uart_abstract &bus) | |
| Constructor of the UART class. More... | |
| void | wakeUp () override |
| This Funtion will wake up / initialise the spi bus / chip for communication. More... | |
| void | sendData (uint8_t *commandBuffer, uint8_t nBytes) |
| This function sends nBytes to the chip connected to the UART bus. More... | |
| void | receiveData (uint8_t *receiveBuffer, uint8_t nBytes) |
| This function receives nBytes from the chip connected to the UART bus. More... | |
| Public Member Functions inherited from communication::protocol | |
| virtual void | endTransaction () |
| Function to end a specific protocol transaction. More... | |
Hardware UART implementation of the abstract protocol class.
| communication::uart::uart | ( | hwuart::uart_abstract & | bus | ) |
Constructor of the UART class.
| abstract_uart | A reference to a abstract uart class |
|
virtual |
This function receives nBytes from the chip connected to the UART bus.
| receiveBuffer | Pointer to the start of the receiveBuffer where data can be stored in |
| nBytes | Amount of bytes that need to be received over spi |
Implements communication::protocol.
|
virtual |
This function sends nBytes to the chip connected to the UART bus.
| commandBuffer | Pointer to the start of the commandbuffer that needs to be send |
| nBytes | Amount of bytes that need to send over spi |
Implements communication::protocol.
|
overridevirtual |
This Funtion will wake up / initialise the spi bus / chip for communication.
Function will send a rather long preamble with 0x55 as the first byte. This is in order to wake up the chip if it was asleep
Implements communication::protocol.


{{#markdown}}
Now it's time to make the web page dynamic — with AngularJS.
This step will still be focusing on client side Angular tools. The next one will show you how to get the power of Meteor.
# View and Template
In Angular, the view is a projection of the model through the HTML template. This means that whenever the model changes, Angular refreshes the appropriate binding points, which updates the view.
Let's change our template to be dynamic:
__`index.ng.html`:__
{{dstache}}party.name}}
{{dstache}}party.description}}
We replaced the hard-coded party list with the [ngRepeat](https://docs.angularjs.org/api/ng/directive/ngRepeat) directive and two Angular expressions:
* The `ng-repeat="party in parties"` attribute in the `li` tag is an Angular repeater directive. The repeater tells Angular to create a `li` element for each party in the list using the `li` tag as the template.
* The expressions wrapped in double-curly-braces ( `{{dstache}}party.name}}` and `{{dstache}}party.description}}` ) will be replaced by the value of the expressions.
We have added a new directive, called `ng-controller`, which attaches the `PartiesListCtrl` controller to the `div` tag. At this point:
* The expressions in double-curly-braces are referring to our application model, which is set up in our `PartiesListCtrl` controller.
# Model and Controller
Now we are going to create our controller and model.
We start with `PartiesListCtrl` controller and place data in it.
__`app.js`:__
if (Meteor.isClient) {
angular
.module('socially',['angular-meteor']);
angular
.module('socially').controller('PartiesListCtrl', ['$scope',
function($scope){
$scope.parties = [
{'name': 'Dubstep-Free Zone',
'description': 'Can we please just for an evening not listen to dubstep.'},
{'name': 'All dubstep all the time',
'description': 'Get it on!'},
{'name': 'Savage lounging',
'description': 'Leisure suit required. And only fiercest manners.'}
];
}]);
}
Here we declared a controller called `PartiesListCtrl` and registered it in our Angular module app - `socially`.
The data model is now instantiated within the `PartiesListCtrl` controller.
Although the controller is not yet doing very much, it plays a crucial role. By providing context for our data model, the controller allows us to establish data-binding between the model and the view. We connected the dots between the presentation, the data, and the logic components as follows:
* The ngController directive, located on the `body` tag, references the name of our controller, `PartiesListCtrl` (located in the JavaScript file `app.js`).
* The `PartiesListCtrl` controller attaches the party data to the `$scope` that was injected into our controller function. This controller scope is available to all bindings located within the `div ng-controller="PartiesListCtrl">` tag.
# ng-annotate and .ng.js
As you can see, when we declared the controller, we used strings for [dependency annotations](https://docs.angularjs.org/guide/di#dependency-annotation) that avoids minification problems:
angular.module('socially').controller('PartiesListCtrl', ['$scope',
function($scope){
// ...
}]);
There is a very popular Angular tool that's called [ng-annotate](https://github.com/olov/ng-annotate) that takes care of that for us so we can write regular code that won't get mangled in minification.
angular-meteor uses that process automatically. All you need to do is to change your `.js` files to end with `.ng.js`
Then you can write your dependency injection like this:
angular.module('socially').controller('PartiesListCtrl',
function($scope){
// ...
});
# Summary
You now have a dynamic app that features separate model, view and controller components.
But, this is all client side, which is nice for tutorials, but in a real application we need to persist the data on the server and sync all the clients with it.
So, let's go to [step 3](/tutorial/step_03) to learn how to bind our application to the great power of Meteor.
{{/markdown}}


clientID |
String
|
<optional>
|
the Client ID found on your Application settings page |
redirectUri |
String
|
|
url that the Auth0 will redirect after Auth with the Authorization Response |
responseType |
String
|
|
type of the response used by OAuth 2.0 flow. It can be any space separated list of the values code , token , id_token . https://openid.net/specs/oauth-v2-multiple-response-types-1_0.html |
responseMode |
String
|
<optional>
|
how the Auth response is encoded and redirected back to the client. Supported values are query , fragment and form_post . The query value is only supported when responseType is code . https://openid.net/specs/oauth-v2-multiple-response-types-1_0.html#ResponseModes |
state |
String
|
<optional>
|
value used to mitigate XSRF attacks. https://auth0.com/docs/protocols/oauth2/oauth-state |
nonce |
String
|
<optional>
|
value used to mitigate replay attacks when using Implicit Grant. https://auth0.com/docs/api-auth/tutorials/nonce |
scope |
String
|
<optional>
|
scopes to be requested during Auth. e.g. openid email |
audience |
String
|
<optional>
|
identifier of the resource server who will consume the access token issued after Auth |
organization |
String
|
<optional>
|
the Id of an organization to log in to |
invitation |
String
|
<optional>
|
the ID of an invitation to accept. This is available from the user invitation URL that is given when participating in a user invitation flow |
owp |
Boolean
|
<optional>
|
determines if Auth0 should render the relay page or not and the caller is responsible of handling the response. |


IGSN Portal
Log In
Log Out
The Australian Research Data Commons (ARDC) is enabled by NCRIS.
Help
Feedback


Welcome to Shopping List App
The application is here to help us keep in mind our shopping needs.
Login
if you have an account or
Register
now and check our deals.


Setting up Feathers in FlashDevelop
Let's get your FlashDevelop development environment ready to use Feathers.
Download the latest stable versions of Feathers and Starling Framework.
In FlashDevelop, select the Project menu → New Project. Select to ActionScript 3 - AIR Mobile AS3 App project type. Enter your project Name, and project Location in your system. Then click Ok.
Next, select the Project menu → Properties…. Go to the SDK tab and select the appropriate combined Flex or AIR SDK to use.
Edit
bat/SetupSDK.bat
to point to your SDK folder.set FLEX_SDK=C:\flex-sdk
Make sure in Project menu → Properties…, in Output tab to select the appropriate version of Adobe AIR. Check the Feathers README file to see the minimum required versions of Adobe AIR and Flash Player for the build of Feathers that you are using.
Edit the application.xml file to update the Adobe AIR namespace. This version should be the same as the Adobe AIR version in the previous step. For example, to target Adobe AIR 15, the namespace should read:
<application xmlns="http://ns.adobe.com/air/application/15.0">
Now that the project is created, you will need to add Feathers and Starling Framework to the project. Move starling.swc and feathers.swc into the
lib
folder.Right-click starling.swc file in the Project pane, and select Add to library. The color of the file should change to blue. Repeat this step with feathers.swc .
Your project is ready. If you're unsure how to proceed, start by using the code in the Create your Game section of the Starling First Steps Tutorial. Then take a look at the Feathers Getting Started Tutorial.


This was my first project. It was made while i was new to coding. It shows how websites are generated. The language used for this project is HTML.
This project is a build up from the "Hello-world" project. It incorporates images as well as styling. The languages used are HTML and CSS.
This project is an example of Forking from anothers github page to yours. It utilises CSS and HTML languages.


GIRL 6 A film review by James Berardinelli Copyright 1996 James Berardinelli
RATING (0 TO 10): 6.0 Alternative Scale: **1/2 out of ****
United States, 1996 U.S. Release Date: 3/29/96 (limited) Running Length: 1:45 MPAA Classification: R (Graphic sexual language, profanity, brief nudity) Theatrical Aspect Ratio: 1.85:1
Cast: Theresa Randle, Isaiah Washington, Spike Lee, Jenifer Lewis, Debi Mazar Director: Spike Lee Producer: Spike Lee Screenplay: Suzan-Lori Parks Cinematography: Malik Hassan Sayeed Music: Prince U.S. Distributor: Twentieth Century Fox
GIRL 6 is the first major motion picture about the phone sex industry. Director Spike Lee (DO THE RIGHT THING, MALCOLM X) places would-be actress Judy (Theresa Randle) in a position where her best chance to earn a living is by talking dirty to anonymous men over the phone. All day long, she sits in an office cubicle, next to dozens of other girls in similar cubicles, using her disembodied voice to play dominatrix, schoolgirl, housewife, and any number of other roles. However, Judy falls prey to the profession's dark side. It's easy to become hooked on the fantasies, and, especially with a little Marijuana to augment the experience, reality can become a tenuous thing.
When it comes to details, GIRL 6 is excellent. Lee's film is sprinkled with touches that give his phone sex world an aura of verisimilitude: dark-haired, black women pretending to be busty blondes, someone flipping through a magazine while moaning into the receiver, and workers scarcely able to contain laughter at callers' more absurd requests.  The girls go by numbers, not names; hence, Judy becomes "Girl 6".
Unfortunately, as good as GIRL 6 is with the fine points, the larger brushstrokes are erratic. Lee may have a keen sense of setting and dialogue, but his characterization is off. Other than Judy, no one has any depth, and even she isn't afforded much development. Theresa Randle (SUGAR HILL, MALCOLM X) is okay in the role, but not a revelation. The other characters, especially Judy's ex-husband (Isaiah Washington) and her baseball memorabilia-collecting neighbor, Jimmy (Lee), are virtual nonentities.
Psychologically, GIRL 6 is superficial. Unlike EXOTICA, which cut deeply into the motivations of those who work in and frequent strip clubs, this film is content to skim the surface of a similar industry. One scene of poignant disillusionment notwithstanding, Judy's burgeoning addiction to the illusory aspects of her job is used more as a plot device than a means of exploring her psyche.
 The question is raised, although Lee doesn't really probe it. While GIRL 6 is considerably more effective than SHOWGIRLS at exploring the issue, there are times when this film seems like the proverbial triumph of style over substance. Cinematographer Malik Hassan Sayeed, who worked with Lee on CLOCKERS, uses a battery of odd camera angles and experimental shots. Most of these work on a purely visual level, but their attempts to telegraph emotional states are less successful.
The highlights of the film are a trio of parody fantasies. In two of these, Lee dresses Judy as Dorothy Dandridge and Foxy Brown. In the other, he fills the role of George Jefferson in a sendup of the hit TV series. There's also an impressive list of cameos: Naomi Campbell (Girl 75), Ron Silver (a sleazy Hollywood director), Peter Berg ("Bob Regular"), John Turturro (Judy's agent), Madonna (the manager of a work- at-home phone sex operation), Halle Berry (herself), and Quentin Tarantino (portraying, and mocking, himself). Give Lee credit for using Madonna and Tarantino in roles they're capable of playing.
If nothing else, GIRL 6's perspective of the industry is fascinating. The fantasy is that phone sex women are all beautiful, young, and hot. The stereotype is that they're ugly, wrinkled, and haggard. The reality, at least in GIRL 6, is somewhere in between. None of the revelations here are especially shocking -- we've seen a lot of this stuff before, anywhere from TV news magazines to Robert Altman's SHORT CUTS (where Jennifer Jason Leigh played a phone sex girl), but Lee puts it all together and adds a few twists. Unfortunately, while certain aspects of GIRL 6 are handled with flair, the film's dramatic scope too often isn't compelling enough for subject matter of such rich and varied possibilities.
- James Berardinelli e-mail<EMAIL_ADDRESS>web: http://www.cybernex.net/~berardin (or) http://www2.cybernex.net/~berardin
The review above was posted to the
rec.arts.movies.reviews newsgroup (de.rec.film.kritiken for German reviews).
The Internet Movie Database accepts no responsibility for the contents of the
review and has no editorial control. Unless stated otherwise, the copyright
belongs to the author.
Please direct comments/criticisms of the review to relevant newsgroups.
Broken URLs inthe reviews are the responsibility of the author.
The formatting of the review is likely to differ from the original due
to ASCII to HTML conversion.
Related links: index of all rec.arts.movies.reviews reviews


VISUALIZATION
David Sasson – 11.14.19
Why is visualization important?
It's more than just bar charts
Who am I?
Also more than just bar charts
What is visualization about?
More than just bar charts
~
Explaining complex concepts
~
Showing rather than telling
~
Provoking knowledge and understanding
What's the point
A little history
Minard Map – "brutal eloquence"
A little history
Nightingale's Charts
Evolution
interactive choropleth
What is visualization about?
Elicit Understanding
~
Understanding is concrete, data is messy
~
How you show people data makes all the difference
~
Visualization is incredibly powerful, but also easy to abuse
Pitfalls and Open Problems
Bias and manipulation
~
biased data
~
misleading context
~
biased visualization designer
~
prior knowledge problem
~
uncertainty problem
Prior Knowledge
Prior Knowledge
Pioneer Plaque
~
What knowledge can you assume?
~
How do you design for aliens?
~
"We are humans and we come in peace"
Pioneer Plaque
Uncertainty!
~
Most data sets have some level of uncertainty
~
Especially when ML or future projections are involved
~
Communicating this uncertainty is incredibly difficult
~
Often uncertainty in the data is just ignored
Uncertainty?
Uncertainty?
Data Doubts
Gapminder
Design Decisions
Gallup abortion poll
Design Decisions
misrepresentation?
Design Decisions
Interpreting the data
~
Scales
~
Shapes
~
Interpolations
~
Color Choices
Interpolations
Maps and context
Making a Point
Visualizing loss of life
“data journalism is successful when you don’t need the adjective”
– Amanda Cox, Data editor NYT
Thank You!
dsass.github.io/viztalk
<EMAIL_ADDRESS>dsasson.com
Addendum
Stop and Frisk
Interactive Map
Addendum
Map Projections
Addendum
Map Projections


This scenario will simulate an alarm notification with secondary actions - snooze and dismiss
You can set a delay to give you time to switch to the lock screen
The default snooze duration is 9 minutes
| Template | Description |
|---|---|
| After clicking snooze, alarm will play again after a default time of 9 minutes. | |
| After clicking snooze, alarm will play again after the custom snooze time. | |
| Custom Snooze Time (minutes) |
| Options | |
|---|---|
| Toast delay |


From your file, we extracted the following information. Please correct any inaccurate fields if necessary.
Fields with this icon next to them may especially require correction.
Click the pop-up icon to view the text as it appears in your file.
Click the pen icon to manually edit the field
| CRIME NAME | LOCATION | DATE | View | Edit |
|---|---|---|---|---|
{{ d.name }} |
{{ d['location'] }} |
{{ d['date'] }} |


The examples above are called DeMorgan’s Laws. Summarizing DeMorgan’s Laws:
\(\displaystyle \neg(p\vee q)\equiv \neg p\wedge \neg q\)
\(\displaystyle \neg(p\wedge q)\equiv \neg p\vee \neg q\)
There are many other equivalent statements, as we will see in the next section.
in-context


THE BRAND
OF LUXURIOUS fashion
Worldwide delivery on all. Authorit tively morph next-generation innov tion with extensive models.
Worldwide delivery on all. Authorit tively morph next-generation innov tion with extensive models.
Worldwide delivery on all. Authorit tively morph next-generation innov tion with extensive models.
Subscribe FOR OUR NEWSLETTER AND PROMOTION


Reports if return ...; doesn't match with @return phpdoc or return type hint. Reports if @return phpdoc differs from actual. Important! Native inspection PHP > Type compatibility > Incompatible return type must be disabled.


Audi Q5, Q7 prices reduced for limited period
by Shirish GandhiThe Q5’s price has been reduced by Rs 5.9 lakh while the Q7 sees a reduction of up to Rs 6.1 lakh
To commemorate the 10th anniversary of the Q5 and Q7 in India, Audi has announced a ‘limited period celebratory pricing’ for the SUVs. The starting price for the Q5 45 TFSI petrol and 40 TDI diesel has been brought down to Rs 49.99 lakh (ex-showroom, India), representing a Rs 5.9 lakh reduction. The Q7 45 TFSI petrol is now on offer from Rs 68.9 lakh (a Rs 4.92 lakh reduction) while the 45 TDI diesel is now available from Rs 71.99 lakh, which is Rs 6.1 lakh less than the original price.
Commenting on the automaker’s latest move to stoke demand, Balbir Singh Dhillon, head, Audi India, said, “Since their market introduction in 2009 in India, the Audi Q5 and Audi Q7 have won several hearts and have paved the way for the success of the Audi brand in India. As these two immensely popular models from our portfolio complete a decade in India, we want to reward our customers and Audi enthusiasts with special prices. This celebratory pricing will make our iconic Q-models accessible to luxury enthusiasts.”
The Q5 is the German marque’s mid-sized, five-seat SUV that can be had with either a 252hp, 2.0-litre petrol engine in the 45 TFSI, or a 190hp, 2.0-litre diesel motor in the 40 TDI. Power is transmitted to all four wheels via a 7-speed dual-clutch automatic transmission, which comes as standard. The powertrain options are offered in Premium Plus trim that covers the basics well for a luxury SUV, and can also be had in higher-spec Technology trim that adds features such as a damper control, a more advanced infotainment system and digital instrument cluster to the package for the additional outlay.
The full-sized Audi Q7, which boasts of a third row of seats, is available in the same 45 TFSI petrol engine configuration, in addition to a more powerful 45 TDI diesel version that houses a 249hp, 3.0-litre V6 motor under the hood. An 8-speed automatic transmission, paired with the ‘Quattro’ all-wheel setup, is a standard fitment. And similar to its smaller sibling, the Q7’s range too comprises of the Premium Plus and Technology variants.
Compared to traditional rivals, Audi had been a bit dormant in the Indian market for some time. But off late, the company is vying to gain its momentum back with a slew of product launches. The German automaker launched the all-new A6 last month, and recently introduced a facelift to the A4 sedan. Moving forward, it has models like the A8, Q8 and e-tron in the pipeline for our market.
All prices, ex-showroom, India
| Audi Q5: Prices (ex-showroom, India) | ||
| Variant | Old | New |
| 45 TFSI | Rs 55.80 lakh onwards | Rs 49.99 lakh onwards |
| 40 TDI | Rs 55.80 lakh onwards | Rs 49.99 lakh onwards |
| Audi Q7: Prices (ex-showroom, India) | ||
| 45 TFSI | Rs 73.82 lakh onwards | Rs 68.99 lakh onwards |
| 45 TDI | Rs 78.01 lakh onwards | Rs 71.99 lakh onwards |
Also see:
Audi Q7 facelift review, test drive
Audi SQ7 facelift revealed with 435hp V8 diesel engine
Audi Q5
Rs 64.10 lakh * On Road Price (New Delhi)


BioBrickTM Studio Mobile is an experimental integrated development environment (IDE) that facilitates review, annotation, design, and implementation of standard biological parts from non-standard DNA, RNA, and protein sequences. Our core goals are to develop programming languages, information models, and communication/computational architectures that support the development and responsible use of standard biological parts.
BioBrickTM Studio Mobile is an open-source project being developed via a collaboration between the students of the Biotechnology class at Abraham Lincoln High School in San Francisco, CA and the Endy Lab in the Department of Biological Engineering at Stanford University, Stanford, CA.
Lead Developers
Cesar Rodriguez
Drew Endy
Contributors
Jerome Bonnet
George Cachianes
Barry Canton
Ethan Chan
Doug Densmore
Ryan Liang
Dana Lui
Lance Martin
Robert Ovadia
Tiffany Saw
Reshma Shetty
Francois St. Pierre
Pakpoom Subsoontorn
Carolina Tropini
Michelle Xie
Yale Yuen
Disclosure
BioBrick is a registered trademark of the BioBrick Foundation


Welcome
Hello! I personally would like to welcome you to the new, and improved, Anti Squirrel website. The old one's picture weren't showing up so we changed it a bit. This website is meant to inform people about the growing threat of.....squirrels.  You may be thinking "woah really!?!?! Wait how do you know this", well i'll tell ya. Late one night I had a vision of the universe being ruled by squirrels. They were torturing all other sepcies including humans!!! I vowed from that day to stop the future invasion in order to save the world and all its inhabitants.  Have fun on the website :)
Learn More


For this demo we assign two new variables to the model called pastDate
and futureDate
:
rv-assign-past-date="'2019-09-15T15:00:00.000Z' | toMoment"
rv-assign-future-date="'2022-09-10T16:00:00.000Z' | toMoment"
Now we can work with these variables, e.g. to convert pastDate
to a vanilla date:
{ pastDate | toDate }
{ pastDate | toDate }
{ futureDate | dateFormat 'LLLL' }
{ futureDate | dateFormat 'LLLL' }
{ pastDate | dateFormat 'LLLL' }
{ pastDate | dateFormat 'LLLL' }
{ futureDate | dateFormat 'HH:mm:ss' }
{ futureDate | dateFormat 'HH:mm:ss' }
We assign a new variable to the model called exampleDuration
using rv-assign-example-duration="pastDate | duration futureDate
to use them in the next examples
{ exampleDuration | humanize }
{ exampleDuration | humanize }
{ exampleDuration | asMilliseconds } milliseconds
{ exampleDuration | asMilliseconds } milliseconds
{ exampleDuration | asSeconds } seconds
{ exampleDuration | asSeconds } seconds
{ exampleDuration | asMinutes } minutes
{ exampleDuration | asMinutes } minutes
{ exampleDuration | asHours } hours
{ exampleDuration | asHours } hours
{ exampleDuration | asDays | numberFormat } days
{ exampleDuration | asDays | numberFormat } days
{ exampleDuration | asMonths | numberFormat } months
{ exampleDuration | asMonths | numberFormat } months
{ exampleDuration | asYears | numberFormat } years
{ exampleDuration | asYears | numberFormat } years
The duration is
{ exampleDuration | years } years,
{ exampleDuration | months } months,
{ exampleDuration | weeks } weeks,
{ exampleDuration | days } days,
{ exampleDuration | hours } hours,
{ exampleDuration | minutes } minutes,
{ exampleDuration | seconds } seconds
and { exampleDuration | milliseconds } milliseconds
The duration is
{ exampleDuration | years } years,
{ exampleDuration | months } months,
{ exampleDuration | weeks } weeks,
{ exampleDuration | days } days,
{ exampleDuration | hours } hours,
{ exampleDuration | minutes } minutes,
{ exampleDuration | seconds } seconds
and { exampleDuration | milliseconds } milliseconds
{ pastDate | toISOString }
{ pastDate | toISOString }
{ pastDate | toDate }
{ pastDate | toDate }
{ pastDate | toTimestamp }
{ pastDate | toTimestamp }


$ diff with.html without.html 2c2 < <html class="height100percent"> --- > <html> 9c9 < <body class="height100percent"> --- > <body>


Welcome to our official website! We are Arkadiusz and Marek Wieloch and we run a company called - DJ BRACHOLE. We offer services as a DJ i and party entertainers for the wedding receptions and other events.
We run our business mainly in Poznan and throughout Greater Poland Voivodeship. However getting to the other regions of Poland is not a problem for us!
We invite you to familiarize yourself with our offer!
We proudly present certificate certificate we received thanks to our excellent clients!
Conducting wedding receptions as DJs and entertainers is our main focus! Properly selected music, live and active leading of receptions makes your guests have a good time until the early morning hours! We know how important this day is in lifes of bride and groom so we try to support them and take care of well-managed party. After the wedding, the newlyweds know that they have chosen well when choosing us to take care of their wedding reception. This is our greatest asset!
Our DJ team is a great idea for each corporate or integration event! Properly tailored music to the character of the event organized by the company is the key to success. Latino rhythms pick up the dance floor even the biggest buzzkill. A bit of Polish classics and the whole dancefloor sings with one voice! When we play Polish disco suddenly people who do not listen to "such" music jump with everyone - that is magic! We can also calm the nerves of the group of people before the deadlining with sounds of relaxing chillout
Have you ever wanted to throw a surprise party for someone? Or maybe you want to impress someone? Good fun with the right music is a hit! We execute every order that does not endanger the participants and is not illegal ;-) Thematic events, fantasy fans gathering, athlete groups - our outfit and decorations are always suitable with the party theme ..
We are not all mouth and no trousers! Our events are one of the best in Poznan and Greater Poland Voivodeship! We guarantee a great fun and choice of the best music for weddings as well as other dance events
You can find details of the offer in - DJ offer.
If you have questions, please contact us by phone or email DJ contact.


Successfully Saved Preferences!
Successfully Actuated Device!
Successfully Changed Rule State!
Processing...
Home
Refresh
Admin
Arm Alarm
Disarm Alarm
Admin
Access Token:
Use Saved Settings:
No
Yes
Asset
Save
GUID
Type
Name
Sensor
Actuator
Data
Timestamp
Has SubDevice
Security
On
Off
Asset
Save
RID
Short Name
Suspended
Timeout
Security
On
Off
OFF
ON
Sub Assets
Sub Asset
Save
GUID
Category
Data
Short Name
Type
Security
On
Off
ACTUATE


| back to main site |
Home
Gallery
Fauna
Landscapes
City Life
Nighttime
Edits
Fauna
More Photos
Landscapes
More Photos
City Life
More Photos
Night
More Photos
Edits
More Photos


To get started, please refer to this vignette.
demoR is a set of tools for formatting R
code for presentations, teaching demonstrations, and much more:
The demo_*()
functions prepare your source code to be both evaluated and displayed by knitr::knit()
.
The hlt_*()
functions add text display formatting to printed code.
These combine naturally within code chunks in R Markdown files via code chunk options. You can learn more about them in vignette("demoR")
.
library(demoR)
data(iris)
codestring <- "mean(iris$Sepal.Length, na.rm = TRUE)"
hlt_funs(codestring)
#> [1] "
mean(iris$Sepal.Length, na.rm = TRUE)
"
hlt_args(codestring)
#> [1] "
mean(iris$Sepal.Length, na.rm = TRUE)
"
demo_code(codestring) %>% hlt_args()
mean(iris$Sepal.Length, na.rm = TRUE)


The regular BigInteger.toByteArray includes the sign bit of the number and might result in an extra byte addition. This method removes this extra byte.
fun BigInteger.bigIntegerToBytes(numBytes: Int): ByteArray


"One cannot cleanse the wounds of failure."
The Planeswalker Urza created Karn as a war weapon. But he’s had many other purposes to serve. Able to control all five colors of mana, this silver golem is a time-travelling Planeswalker, powerful artifact, world builder, and unstoppable ally.
Karn was the first artifact of the Legacy, a collection of objects whose arcane might could be used against Phyrexia, an artificial, all-mechanical plane. Decades later, when Phyrexia invaded the plane of Dominaria, Karn fulfilled his destiny, joining with the other artifacts of the Legacy to destroy Phyrexia's Father of Machines. At that moment, Karn became a Planeswalker, inheriting the spark from his creator.
Karn then created a plane of his own: a metal world called Argentum. While Karn was off exploring the universe, a contagion took hold, reshaping the plane and corrupting the mind of the Warden that Karn created to watch over it.
During Dominaria's temporal crisis, Karn allied with Jhoira and the Planeswalkers Teferi and Venser to prevent time itself from collapsing. In the process, he became susceptible to the contagion on his created planet. His mind addled and broken by the corruption, Karn escaped to Mirrodin, where we was hailed as the next Father of Machines by the new Phyrexians.
The Planeswalker Koth sought allies to help save Mirrodin, his native world. He recruited Elspeth Tirel as well as Karn's friend Venser. When the trio arrived, they found the plane poisoned beyond saving. To help prevent the corruption from spread to other worlds, Venser sacrificed himself, giving Karn his immunity to the contagion.
Grief-stricken by the fate of Argentum and the death of his friend, Karn has traveled to Dominaria, retracing the ancient steps of his maker to find a solution to the Phyrexian menace once and for all.


This tutorial is intended for system administrators managing Varnish cache. The reader should know how to configure her web- or application server and have basic knowledge of the HTTP protocol. The reader should have Varnish up and running with the default configuration.
The tutorial is split into short chapters, each chapter taking on a separate topic. Good luck.