1 (function(global, document) {

     2 

     3   // Popcorn.js does not support archaic browsers

     4   if ( !document.addEventListener ) {

     5     global.Popcorn = {

     6       isSupported: false

     7     };

     8 

     9     var methods = ( "forEach extend effects error guid sizeOf isArray nop position disable enable destroy " +

    10           "addTrackEvent removeTrackEvent getTrackEvents getTrackEvent getLastTrackEventId " +

    11           "timeUpdate plugin removePlugin compose effect parser xhr getJSONP getScript" ).split(/\s+/);

    12 

    13     while ( methods.length ) {

    14       global.Popcorn[ methods.shift() ] = function() {};

    15     }

    16     return;

    17   }

    18 

    19   var

    20 

    21   AP = Array.prototype,

    22   OP = Object.prototype,

    23 

    24   forEach = AP.forEach,

    25   slice = AP.slice,

    26   hasOwn = OP.hasOwnProperty,

    27   toString = OP.toString,

    28 

    29   // Copy global Popcorn (may not exist)

    30   _Popcorn = global.Popcorn,

    31 

    32   //  ID string matching

    33   rIdExp  = /^(#([\w\-\_\.]+))$/,

    34 

    35   //  Ready fn cache

    36   readyStack = [],

    37   readyBound = false,

    38   readyFired = false,

    39 

    40   //  Non-public internal data object

    41   internal = {

    42     events: {

    43       hash: {},

    44       apis: {}

    45     }

    46   },

    47 

    48   //  Non-public `requestAnimFrame`

    49   //  http://paulirish.com/2011/requestanimationframe-for-smart-animating/

    50   requestAnimFrame = (function(){

    51     return global.requestAnimationFrame ||

    52       global.webkitRequestAnimationFrame ||

    53       global.mozRequestAnimationFrame ||

    54       global.oRequestAnimationFrame ||

    55       global.msRequestAnimationFrame ||

    56       function( callback, element ) {

    57         global.setTimeout( callback, 16 );

    58       };

    59   }()),

    60 

    61   refresh = function( obj ) {

    62     var currentTime = obj.media.currentTime,

    63       animation = obj.options.frameAnimation,

    64       disabled = obj.data.disabled,

    65       tracks = obj.data.trackEvents,

    66       animating = tracks.animating,

    67       start = tracks.startIndex,

    68       registryByName = Popcorn.registryByName,

    69       animIndex = 0,

    70       byStart, natives, type;

    71 

    72     start = Math.min( start + 1, tracks.byStart.length - 2 );

    73 

    74     while ( start > 0 && tracks.byStart[ start ] ) {

    75 

    76       byStart = tracks.byStart[ start ];

    77       natives = byStart._natives;

    78       type = natives && natives.type;

    79 

    80       if ( !natives ||

    81           ( !!registryByName[ type ] || !!obj[ type ] ) ) {

    82 

    83         if ( ( byStart.start <= currentTime && byStart.end > currentTime ) &&

    84                 disabled.indexOf( type ) === -1 ) {

    85 

    86           if ( !byStart._running ) {

    87             byStart._running = true;

    88             natives.start.call( obj, null, byStart );

    89 

    90             // if the 'frameAnimation' option is used,

    91             // push the current byStart object into the `animating` cue

    92             if ( animation &&

    93                 ( byStart && byStart._running && byStart.natives.frame ) ) {

    94 

    95               natives.frame.call( obj, null, byStart, currentTime );

    96             }

    97           }

    98         } else if ( byStart._running === true ) {

    99 

   100           byStart._running = false;

   101           natives.end.call( obj, null, byStart );

   102 

   103           if ( animation && byStart._natives.frame ) {

   104             animIndex = animating.indexOf( byStart );

   105             if ( animIndex >= 0 ) {

   106               animating.splice( animIndex, 1 );

   107             }

   108           }

   109         }

   110       }

   111 

   112       start--;

   113     }

   114   },

   115 

   116   //  Declare constructor

   117   //  Returns an instance object.

   118   Popcorn = function( entity, options ) {

   119     //  Return new Popcorn object

   120     return new Popcorn.p.init( entity, options || null );

   121   };

   122 

   123   //  Popcorn API version, automatically inserted via build system.

   124   Popcorn.version = "@VERSION";

   125 

   126   //  Boolean flag allowing a client to determine if Popcorn can be supported

   127   Popcorn.isSupported = true;

   128 

   129   //  Instance caching

   130   Popcorn.instances = [];

   131 

   132   //  Declare a shortcut (Popcorn.p) to and a definition of

   133   //  the new prototype for our Popcorn constructor

   134   Popcorn.p = Popcorn.prototype = {

   135 

   136     init: function( entity, options ) {

   137 

   138       var matches;

   139 

   140       //  Supports Popcorn(function () { /../ })

   141       //  Originally proposed by Daniel Brooks

   142 

   143       if ( typeof entity === "function" ) {

   144 

   145         //  If document ready has already fired

   146         if ( document.readyState === "interactive" || document.readyState === "complete" ) {

   147 

   148           entity( document, Popcorn );

   149 

   150           return;

   151         }

   152         //  Add `entity` fn to ready stack

   153         readyStack.push( entity );

   154 

   155         //  This process should happen once per page load

   156         if ( !readyBound ) {

   157 

   158           //  set readyBound flag

   159           readyBound = true;

   160 

   161           var DOMContentLoaded  = function() {

   162 

   163             readyFired = true;

   164 

   165             //  Remove global DOM ready listener

   166             document.removeEventListener( "DOMContentLoaded", DOMContentLoaded, false );

   167 

   168             //  Execute all ready function in the stack

   169             for ( var i = 0, readyStackLength = readyStack.length; i < readyStackLength; i++ ) {

   170 

   171               readyStack[ i ].call( document, Popcorn );

   172 

   173             }

   174             //  GC readyStack

   175             readyStack = null;

   176           };

   177 

   178           //  Register global DOM ready listener

   179           document.addEventListener( "DOMContentLoaded", DOMContentLoaded, false );

   180         }

   181 

   182         return;

   183       }

   184 

   185       //  Check if entity is a valid string id

   186       matches = rIdExp.exec( entity );

   187 

   188       //  Get media element by id or object reference

   189       this.media = matches && matches.length && matches[ 2 ] ?

   190                      document.getElementById( matches[ 2 ] ) :

   191                      entity;

   192 

   193       //  Create an audio or video element property reference

   194       this[ ( this.media.nodeName && this.media.nodeName.toLowerCase() ) || "video" ] = this.media;

   195 

   196       //  Register new instance

   197       Popcorn.instances.push( this );

   198 

   199       this.options = options || {};

   200 

   201       this.isDestroyed = false;

   202 

   203       this.data = {

   204 

   205         // Executed by either timeupdate event or in rAF loop

   206         timeUpdate: Popcorn.nop,

   207 

   208         // Allows disabling a plugin per instance

   209         disabled: [],

   210 

   211         // Stores DOM event queues by type

   212         events: {},

   213 

   214         // Stores Special event hooks data

   215         hooks: {},

   216 

   217         // Store track event history data

   218         history: [],

   219 

   220         // Stores ad-hoc state related data]

   221         state: {

   222           volume: this.media.volume

   223         },

   224 

   225         // Store track event object references by trackId

   226         trackRefs: {},

   227 

   228         // Playback track event queues

   229         trackEvents: {

   230           byStart: [{

   231 

   232             start: -1,

   233             end: -1

   234           }],

   235           byEnd: [{

   236             start: -1,

   237             end: -1

   238           }],

   239           animating: [],

   240           startIndex: 0,

   241           endIndex: 0,

   242           previousUpdateTime: -1

   243         }

   244       };

   245 

   246       //  Wrap true ready check

   247       var isReady = function( that ) {

   248 

   249         var duration, videoDurationPlus;

   250 

   251         if ( that.media.readyState >= 2 ) {

   252           //  Adding padding to the front and end of the arrays

   253           //  this is so we do not fall off either end

   254 

   255           duration = that.media.duration;

   256           //  Check for no duration info (NaN)

   257           videoDurationPlus = duration != duration ? Number.MAX_VALUE : duration + 1;

   258 

   259           Popcorn.addTrackEvent( that, {

   260             start: videoDurationPlus,

   261             end: videoDurationPlus

   262           });

   263 

   264           if ( that.options.frameAnimation ) {

   265             //  if Popcorn is created with frameAnimation option set to true,

   266             //  requestAnimFrame is used instead of "timeupdate" media event.

   267             //  This is for greater frame time accuracy, theoretically up to

   268             //  60 frames per second as opposed to ~4 ( ~every 15-250ms)

   269             that.data.timeUpdate = function () {

   270 

   271               Popcorn.timeUpdate( that, {} );

   272 

   273               that.trigger( "timeupdate" );

   274 

   275               !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

   276             };

   277 

   278             !that.isDestroyed && requestAnimFrame( that.data.timeUpdate );

   279 

   280           } else {

   281 

   282             that.data.timeUpdate = function( event ) {

   283               Popcorn.timeUpdate( that, event );

   284             };

   285 

   286             if ( !that.isDestroyed ) {

   287               that.media.addEventListener( "timeupdate", that.data.timeUpdate, false );

   288             }

   289           }

   290         } else {

   291           global.setTimeout(function() {

   292             isReady( that );

   293           }, 1 );

   294         }

   295       };

   296 

   297       isReady( this );

   298 

   299       return this;

   300     }

   301   };

   302 

   303   //  Extend constructor prototype to instance prototype

   304   //  Allows chaining methods to instances

   305   Popcorn.p.init.prototype = Popcorn.p;

   306 

   307   Popcorn.forEach = function( obj, fn, context ) {

   308 

   309     if ( !obj || !fn ) {

   310       return {};

   311     }

   312 

   313     context = context || this;

   314 

   315     var key, len;

   316 

   317     // Use native whenever possible

   318     if ( forEach && obj.forEach === forEach ) {

   319       return obj.forEach( fn, context );

   320     }

   321 

   322     if ( toString.call( obj ) === "[object NodeList]" ) {

   323       for ( key = 0, len = obj.length; key < len; key++ ) {

   324         fn.call( context, obj[ key ], key, obj );

   325       }

   326       return obj;

   327     }

   328 

   329     for ( key in obj ) {

   330       if ( hasOwn.call( obj, key ) ) {

   331         fn.call( context, obj[ key ], key, obj );

   332       }

   333     }

   334     return obj;

   335   };

   336 

   337   Popcorn.extend = function( obj ) {

   338     var dest = obj, src = slice.call( arguments, 1 );

   339 

   340     Popcorn.forEach( src, function( copy ) {

   341       for ( var prop in copy ) {

   342         dest[ prop ] = copy[ prop ];

   343       }

   344     });

   345 

   346     return dest;

   347   };

   348 

   349 

   350   // A Few reusable utils, memoized onto Popcorn

   351   Popcorn.extend( Popcorn, {

   352     noConflict: function( deep ) {

   353 

   354       if ( deep ) {

   355         global.Popcorn = _Popcorn;

   356       }

   357 

   358       return Popcorn;

   359     },

   360     error: function( msg ) {

   361       throw new Error( msg );

   362     },

   363     guid: function( prefix ) {

   364       Popcorn.guid.counter++;

   365       return  ( prefix ? prefix : "" ) + ( +new Date() + Popcorn.guid.counter );

   366     },

   367     sizeOf: function( obj ) {

   368       var size = 0;

   369 

   370       for ( var prop in obj ) {

   371         size++;

   372       }

   373 

   374       return size;

   375     },

   376     isArray: Array.isArray || function( array ) {

   377       return toString.call( array ) === "[object Array]";

   378     },

   379 

   380     nop: function() {},

   381 

   382     position: function( elem ) {

   383 

   384       var clientRect = elem.getBoundingClientRect(),

   385           bounds = {},

   386           doc = elem.ownerDocument,

   387           docElem = document.documentElement,

   388           body = document.body,

   389           clientTop, clientLeft, scrollTop, scrollLeft, top, left;

   390 

   391       //  Determine correct clientTop/Left

   392       clientTop = docElem.clientTop || body.clientTop || 0;

   393       clientLeft = docElem.clientLeft || body.clientLeft || 0;

   394 

   395       //  Determine correct scrollTop/Left

   396       scrollTop = ( global.pageYOffset && docElem.scrollTop || body.scrollTop );

   397       scrollLeft = ( global.pageXOffset && docElem.scrollLeft || body.scrollLeft );

   398 

   399       //  Temp top/left

   400       top = Math.ceil( clientRect.top + scrollTop - clientTop );

   401       left = Math.ceil( clientRect.left + scrollLeft - clientLeft );

   402 

   403       for ( var p in clientRect ) {

   404         bounds[ p ] = Math.round( clientRect[ p ] );

   405       }

   406 

   407       return Popcorn.extend({}, bounds, { top: top, left: left });

   408     },

   409 

   410     disable: function( instance, plugin ) {

   411 

   412       var disabled = instance.data.disabled;

   413 

   414       if ( disabled.indexOf( plugin ) === -1 ) {

   415         disabled.push( plugin );

   416       }

   417 

   418       refresh( instance );

   419 

   420       return instance;

   421     },

   422     enable: function( instance, plugin ) {

   423 

   424       var disabled = instance.data.disabled,

   425           index = disabled.indexOf( plugin );

   426 

   427       if ( index > -1 ) {

   428         disabled.splice( index, 1 );

   429       }

   430 

   431       refresh( instance );

   432 

   433       return instance;

   434     },

   435     destroy: function( instance ) {

   436       var events = instance.data.events,

   437           singleEvent, item, fn;

   438 

   439       //  Iterate through all events and remove them

   440       for ( item in events ) {

   441         singleEvent = events[ item ];

   442         for ( fn in singleEvent ) {

   443           delete singleEvent[ fn ];

   444         }

   445         events[ item ] = null;

   446       }

   447 

   448       if ( !instance.isDestroyed ) {

   449         instance.data.timeUpdate && instance.media.removeEventListener( "timeupdate", instance.data.timeUpdate, false );

   450         instance.isDestroyed = true;

   451       }

   452     }

   453   });

   454 

   455   //  Memoized GUID Counter

   456   Popcorn.guid.counter = 1;

   457 

   458   //  Factory to implement getters, setters and controllers

   459   //  as Popcorn instance methods. The IIFE will create and return

   460   //  an object with defined methods

   461   Popcorn.extend(Popcorn.p, (function() {

   462 

   463       var methods = "load play pause currentTime playbackRate volume duration preload playbackRate " +

   464                     "autoplay loop controls muted buffered readyState seeking paused played seekable ended",

   465           ret = {};

   466 

   467 

   468       //  Build methods, store in object that is returned and passed to extend

   469       Popcorn.forEach( methods.split( /\s+/g ), function( name ) {

   470 

   471         ret[ name ] = function( arg ) {

   472 

   473           if ( typeof this.media[ name ] === "function" ) {

   474 

   475             // Support for shorthanded play(n)/pause(n) jump to currentTime

   476             // If arg is not null or undefined and called by one of the

   477             // allowed shorthandable methods, then set the currentTime

   478             // Supports time as seconds or SMPTE

   479             if ( arg != null && /play|pause/.test( name ) ) {

   480               this.media.currentTime = Popcorn.util.toSeconds( arg );

   481             }

   482 

   483             this.media[ name ]();

   484 

   485             return this;

   486           }

   487 

   488 

   489           if ( arg != null ) {

   490 

   491             this.media[ name ] = arg;

   492 

   493             return this;

   494           }

   495 

   496           return this.media[ name ];

   497         };

   498       });

   499 

   500       return ret;

   501 

   502     })()

   503   );

   504 

   505   Popcorn.forEach( "enable disable".split(" "), function( method ) {

   506     Popcorn.p[ method ] = function( plugin ) {

   507       return Popcorn[ method ]( this, plugin );

   508     };

   509   });

   510 

   511   Popcorn.extend(Popcorn.p, {

   512 

   513     //  Rounded currentTime

   514     roundTime: function() {

   515       return -~this.media.currentTime;

   516     },

   517 

   518     //  Attach an event to a single point in time

   519     exec: function( time, fn ) {

   520 

   521       //  Creating a one second track event with an empty end

   522       Popcorn.addTrackEvent( this, {

   523         start: time,

   524         end: time + 1,

   525         _running: false,

   526         _natives: {

   527           start: fn || Popcorn.nop,

   528           end: Popcorn.nop,

   529           type: "exec"

   530         }

   531       });

   532 

   533       return this;

   534     },

   535 

   536     // Mute the calling media, optionally toggle

   537     mute: function( toggle ) {

   538 

   539       var event = toggle == null || toggle === true ? "muted" : "unmuted";

   540 

   541       // If `toggle` is explicitly `false`,

   542       // unmute the media and restore the volume level

   543       if ( event === "unmuted" ) {

   544         this.media.muted = false;

   545         this.media.volume = this.data.state.volume;

   546       }

   547 

   548       // If `toggle` is either null or undefined,

   549       // save the current volume and mute the media element

   550       if ( event === "muted" ) {

   551         this.data.state.volume = this.media.volume;

   552         this.media.muted = true;

   553       }

   554 

   555       // Trigger either muted|unmuted event

   556       this.trigger( event );

   557 

   558       return this;

   559     },

   560 

   561     // Convenience method, unmute the calling media

   562     unmute: function( toggle ) {

   563 

   564       return this.mute( toggle == null ? false : !toggle );

   565     },

   566 

   567     // Get the client bounding box of an instance element

   568     position: function() {

   569       return Popcorn.position( this.media );

   570     },

   571 

   572     // Toggle a plugin's playback behaviour (on or off) per instance

   573     toggle: function( plugin ) {

   574       return Popcorn[ this.data.disabled.indexOf( plugin ) > -1 ? "enable" : "disable" ]( this, plugin );

   575     },

   576 

   577     // Set default values for plugin options objects per instance

   578     defaults: function( plugin, defaults ) {

   579 

   580       // If an array of default configurations is provided,

   581       // iterate and apply each to this instance

   582       if ( Popcorn.isArray( plugin ) ) {

   583 

   584         Popcorn.forEach( plugin, function( obj ) {

   585           for ( var name in obj ) {

   586             this.defaults( name, obj[ name ] );

   587           }

   588         }, this );

   589 

   590         return this;

   591       }

   592 

   593       if ( !this.options.defaults ) {

   594         this.options.defaults = {};

   595       }

   596 

   597       if ( !this.options.defaults[ plugin ] ) {

   598         this.options.defaults[ plugin ] = {};

   599       }

   600 

   601       Popcorn.extend( this.options.defaults[ plugin ], defaults );

   602 

   603       return this;

   604     }

   605   });

   606 

   607   Popcorn.Events  = {

   608     UIEvents: "blur focus focusin focusout load resize scroll unload",

   609     MouseEvents: "mousedown mouseup mousemove mouseover mouseout mouseenter mouseleave click dblclick",

   610     Events: "loadstart progress suspend emptied stalled play pause " +

   611             "loadedmetadata loadeddata waiting playing canplay canplaythrough " +

   612             "seeking seeked timeupdate ended ratechange durationchange volumechange"

   613   };

   614 

   615   Popcorn.Events.Natives = Popcorn.Events.UIEvents + " " +

   616                            Popcorn.Events.MouseEvents + " " +

   617                            Popcorn.Events.Events;

   618 

   619   internal.events.apiTypes = [ "UIEvents", "MouseEvents", "Events" ];

   620 

   621   // Privately compile events table at load time

   622   (function( events, data ) {

   623 

   624     var apis = internal.events.apiTypes,

   625     eventsList = events.Natives.split( /\s+/g ),

   626     idx = 0, len = eventsList.length, prop;

   627 

   628     for( ; idx < len; idx++ ) {

   629       data.hash[ eventsList[idx] ] = true;

   630     }

   631 

   632     apis.forEach(function( val, idx ) {

   633 

   634       data.apis[ val ] = {};

   635 

   636       var apiEvents = events[ val ].split( /\s+/g ),

   637       len = apiEvents.length,

   638       k = 0;

   639 

   640       for ( ; k < len; k++ ) {

   641         data.apis[ val ][ apiEvents[ k ] ] = true;

   642       }

   643     });

   644   })( Popcorn.Events, internal.events );

   645 

   646   Popcorn.events = {

   647 

   648     isNative: function( type ) {

   649       return !!internal.events.hash[ type ];

   650     },

   651     getInterface: function( type ) {

   652 

   653       if ( !Popcorn.events.isNative( type ) ) {

   654         return false;

   655       }

   656 

   657       var eventApi = internal.events,

   658         apis = eventApi.apiTypes,

   659         apihash = eventApi.apis,

   660         idx = 0, len = apis.length, api, tmp;

   661 

   662       for ( ; idx < len; idx++ ) {

   663         tmp = apis[ idx ];

   664 

   665         if ( apihash[ tmp ][ type ] ) {

   666           api = tmp;

   667           break;

   668         }

   669       }

   670       return api;

   671     },

   672     //  Compile all native events to single array

   673     all: Popcorn.Events.Natives.split( /\s+/g ),

   674     //  Defines all Event handling static functions

   675     fn: {

   676       trigger: function( type, data ) {

   677 

   678         var eventInterface, evt;

   679         //  setup checks for custom event system

   680         if ( this.data.events[ type ] && Popcorn.sizeOf( this.data.events[ type ] ) ) {

   681 

   682           eventInterface  = Popcorn.events.getInterface( type );

   683 

   684           if ( eventInterface ) {

   685 

   686             evt = document.createEvent( eventInterface );

   687             evt.initEvent( type, true, true, global, 1 );

   688 

   689             this.media.dispatchEvent( evt );

   690 

   691             return this;

   692           }

   693 

   694           //  Custom events

   695           Popcorn.forEach( this.data.events[ type ], function( obj, key ) {

   696 

   697             obj.call( this, data );

   698 

   699           }, this );

   700 

   701         }

   702 

   703         return this;

   704       },

   705       listen: function( type, fn ) {

   706 

   707         var self = this,

   708             hasEvents = true,

   709             eventHook = Popcorn.events.hooks[ type ],

   710             origType = type,

   711             tmp;

   712 

   713         if ( !this.data.events[ type ] ) {

   714           this.data.events[ type ] = {};

   715           hasEvents = false;

   716         }

   717 

   718         // Check and setup event hooks

   719         if ( eventHook ) {

   720 

   721           // Execute hook add method if defined

   722           if ( eventHook.add ) {

   723             eventHook.add.call( this, {}, fn );

   724           }

   725 

   726           // Reassign event type to our piggyback event type if defined

   727           if ( eventHook.bind ) {

   728             type = eventHook.bind;

   729           }

   730 

   731           // Reassign handler if defined

   732           if ( eventHook.handler ) {

   733             tmp = fn;

   734 

   735             fn = function wrapper( event ) {

   736               eventHook.handler.call( self, event, tmp );

   737             };

   738           }

   739 

   740           // assume the piggy back event is registered

   741           hasEvents = true;

   742 

   743           // Setup event registry entry

   744           if ( !this.data.events[ type ] ) {

   745             this.data.events[ type ] = {};

   746             // Toggle if the previous assumption was untrue

   747             hasEvents = false;

   748           }

   749         }

   750 

   751         //  Register event and handler

   752         this.data.events[ type ][ fn.name || ( fn.toString() + Popcorn.guid() ) ] = fn;

   753 

   754         // only attach one event of any type

   755         if ( !hasEvents && Popcorn.events.all.indexOf( type ) > -1 ) {

   756 

   757           this.media.addEventListener( type, function( event ) {

   758 

   759             Popcorn.forEach( self.data.events[ type ], function( obj, key ) {

   760               if ( typeof obj === "function" ) {

   761                 obj.call( self, event );

   762               }

   763             });

   764 

   765           }, false);

   766         }

   767         return this;

   768       },

   769       unlisten: function( type, fn ) {

   770 

   771         if ( this.data.events[ type ] && this.data.events[ type ][ fn ] ) {

   772 

   773           delete this.data.events[ type ][ fn ];

   774 

   775           return this;

   776         }

   777 

   778         this.data.events[ type ] = null;

   779 

   780         return this;

   781       }

   782     },

   783     hooks: {

   784       canplayall: {

   785         bind: "canplaythrough",

   786         add: function( event, callback ) {

   787 

   788           var state = false;

   789 

   790           if ( this.media.readyState ) {

   791 

   792             callback.call( this, event );

   793 

   794             state = true;

   795           }

   796 

   797           this.data.hooks.canplayall = {

   798             fired: state

   799           };

   800         },

   801         // declare special handling instructions

   802         handler: function canplayall( event, callback ) {

   803 

   804           if ( !this.data.hooks.canplayall.fired ) {

   805             // trigger original user callback once

   806             callback.call( this, event );

   807 

   808             this.data.hooks.canplayall.fired = true;

   809           }

   810         }

   811       }

   812     }

   813   };

   814 

   815   //  Extend Popcorn.events.fns (listen, unlisten, trigger) to all Popcorn instances

   816   Popcorn.forEach( [ "trigger", "listen", "unlisten" ], function( key ) {

   817     Popcorn.p[ key ] = Popcorn.events.fn[ key ];

   818   });

   819 

   820   // Internal Only - Adds track events to the instance object

   821   Popcorn.addTrackEvent = function( obj, track ) {

   822 

   823     // Determine if this track has default options set for it

   824     // If so, apply them to the track object

   825     if ( track && track._natives && track._natives.type &&

   826         ( obj.options.defaults && obj.options.defaults[ track._natives.type ] ) ) {

   827 

   828       track = Popcorn.extend( {}, obj.options.defaults[ track._natives.type ], track );

   829     }

   830 

   831     if ( track._natives ) {

   832       //  Supports user defined track event id

   833       track._id = !track.id ? Popcorn.guid( track._natives.type ) : track.id;

   834 

   835       //  Push track event ids into the history

   836       obj.data.history.push( track._id );

   837     }

   838 

   839     track.start = Popcorn.util.toSeconds( track.start, obj.options.framerate );

   840     track.end   = Popcorn.util.toSeconds( track.end, obj.options.framerate );

   841 

   842     //  Store this definition in an array sorted by times

   843     var byStart = obj.data.trackEvents.byStart,

   844         byEnd = obj.data.trackEvents.byEnd,

   845         startIndex, endIndex,

   846         currentTime;

   847 

   848     for ( startIndex = byStart.length - 1; startIndex >= 0; startIndex-- ) {

   849 

   850       if ( track.start >= byStart[ startIndex ].start ) {

   851         byStart.splice( startIndex + 1, 0, track );

   852         break;

   853       }

   854     }

   855 

   856     for ( endIndex = byEnd.length - 1; endIndex >= 0; endIndex-- ) {

   857 

   858       if ( track.end > byEnd[ endIndex ].end ) {

   859         byEnd.splice( endIndex + 1, 0, track );

   860         break;

   861       }

   862     }

   863 

   864     // Display track event immediately if it's enabled and current

   865     if ( track._natives &&

   866         ( !!Popcorn.registryByName[ track._natives.type ] || !!obj[ track._natives.type ] ) ) {

   867 

   868       currentTime = obj.media.currentTime;

   869       if ( track.end > currentTime &&

   870         track.start <= currentTime &&

   871         obj.data.disabled.indexOf( track._natives.type ) === -1 ) {

   872 

   873         track._running = true;

   874         track._natives.start.call( obj, null, track );

   875 

   876         if ( obj.options.frameAnimation &&

   877           track._natives.frame ) {

   878 

   879           obj.data.trackEvents.animating.push( track );

   880           track._natives.frame.call( obj, null, track, currentTime );

   881         }

   882       }

   883     }

   884 

   885     // update startIndex and endIndex

   886     if ( startIndex <= obj.data.trackEvents.startIndex &&

   887       track.start <= obj.data.trackEvents.previousUpdateTime ) {

   888 

   889       obj.data.trackEvents.startIndex++;

   890     }

   891 

   892     if ( endIndex <= obj.data.trackEvents.endIndex &&

   893       track.end < obj.data.trackEvents.previousUpdateTime ) {

   894 

   895       obj.data.trackEvents.endIndex++;

   896     }

   897 

   898     this.timeUpdate( obj, null, true );

   899 

   900     // Store references to user added trackevents in ref table

   901     if ( track._id ) {

   902       Popcorn.addTrackEvent.ref( obj, track );

   903     }

   904   };

   905 

   906   // Internal Only - Adds track event references to the instance object's trackRefs hash table

   907   Popcorn.addTrackEvent.ref = function( obj, track ) {

   908     obj.data.trackRefs[ track._id ] = track;

   909 

   910     return obj;

   911   };

   912 

   913   Popcorn.removeTrackEvent  = function( obj, trackId ) {

   914 

   915     var historyLen = obj.data.history.length,

   916         indexWasAt = 0,

   917         byStart = [],

   918         byEnd = [],

   919         animating = [],

   920         history = [];

   921 

   922     Popcorn.forEach( obj.data.trackEvents.byStart, function( o, i, context ) {

   923       // Preserve the original start/end trackEvents

   924       if ( !o._id ) {

   925         byStart.push( obj.data.trackEvents.byStart[i] );

   926         byEnd.push( obj.data.trackEvents.byEnd[i] );

   927       }

   928 

   929       // Filter for user track events (vs system track events)

   930       if ( o._id ) {

   931 

   932         // Filter for the trackevent to remove

   933         if ( o._id !== trackId ) {

   934           byStart.push( obj.data.trackEvents.byStart[i] );

   935           byEnd.push( obj.data.trackEvents.byEnd[i] );

   936         }

   937 

   938         //  Capture the position of the track being removed.

   939         if ( o._id === trackId ) {

   940           indexWasAt = i;

   941           o._natives._teardown && o._natives._teardown.call( obj, o );

   942         }

   943       }

   944 

   945     });

   946 

   947     if ( obj.data.trackEvents.animating.length ) {

   948       Popcorn.forEach( obj.data.trackEvents.animating, function( o, i, context ) {

   949         // Preserve the original start/end trackEvents

   950         if ( !o._id ) {

   951           animating.push( obj.data.trackEvents.animating[i] );

   952         }

   953 

   954         // Filter for user track events (vs system track events)

   955         if ( o._id ) {

   956           // Filter for the trackevent to remove

   957           if ( o._id !== trackId ) {

   958             animating.push( obj.data.trackEvents.animating[i] );

   959           }

   960         }

   961       });

   962     }

   963 

   964     //  Update

   965     if ( indexWasAt <= obj.data.trackEvents.startIndex ) {

   966       obj.data.trackEvents.startIndex--;

   967     }

   968 

   969     if ( indexWasAt <= obj.data.trackEvents.endIndex ) {

   970       obj.data.trackEvents.endIndex--;

   971     }

   972 

   973     obj.data.trackEvents.byStart = byStart;

   974     obj.data.trackEvents.byEnd = byEnd;

   975     obj.data.trackEvents.animating = animating;

   976 

   977     for ( var i = 0; i < historyLen; i++ ) {

   978       if ( obj.data.history[ i ] !== trackId ) {

   979         history.push( obj.data.history[ i ] );

   980       }

   981     }

   982 

   983     // Update ordered history array

   984     obj.data.history = history;

   985 

   986     // Update track event references

   987     Popcorn.removeTrackEvent.ref( obj, trackId );

   988   };

   989 

   990   // Internal Only - Removes track event references from instance object's trackRefs hash table

   991   Popcorn.removeTrackEvent.ref = function( obj, trackId ) {

   992     delete obj.data.trackRefs[ trackId ];

   993 

   994     return obj;

   995   };

   996 

   997   // Return an array of track events bound to this instance object

   998   Popcorn.getTrackEvents = function( obj ) {

   999 

  1000     var trackevents = [],

  1001       refs = obj.data.trackEvents.byStart,

  1002       length = refs.length,

  1003       idx = 0,

  1004       ref;

  1005 

  1006     for ( ; idx < length; idx++ ) {

  1007       ref = refs[ idx ];

  1008       // Return only user attributed track event references

  1009       if ( ref._id ) {

  1010         trackevents.push( ref );

  1011       }

  1012     }

  1013 

  1014     return trackevents;

  1015   };

  1016 

  1017   // Internal Only - Returns an instance object's trackRefs hash table

  1018   Popcorn.getTrackEvents.ref = function( obj ) {

  1019     return obj.data.trackRefs;

  1020   };

  1021 

  1022   // Return a single track event bound to this instance object

  1023   Popcorn.getTrackEvent = function( obj, trackId ) {

  1024     return obj.data.trackRefs[ trackId ];

  1025   };

  1026 

  1027   // Internal Only - Returns an instance object's track reference by track id

  1028   Popcorn.getTrackEvent.ref = function( obj, trackId ) {

  1029     return obj.data.trackRefs[ trackId ];

  1030   };

  1031 

  1032   Popcorn.getLastTrackEventId = function( obj ) {

  1033     return obj.data.history[ obj.data.history.length - 1 ];

  1034   };

  1035 

  1036   Popcorn.timeUpdate = function( obj, event ) {

  1037 

  1038     var currentTime = obj.media.currentTime,

  1039         previousTime = obj.data.trackEvents.previousUpdateTime,

  1040         tracks = obj.data.trackEvents,

  1041         animating = tracks.animating,

  1042         end = tracks.endIndex,

  1043         start = tracks.startIndex,

  1044         animIndex = 0,

  1045 

  1046         registryByName = Popcorn.registryByName,

  1047 

  1048         byEnd, byStart, byAnimate, natives, type;

  1049 

  1050     //  Playbar advancing

  1051     if ( previousTime <= currentTime ) {

  1052 

  1053       while ( tracks.byEnd[ end ] && tracks.byEnd[ end ].end <= currentTime ) {

  1054 

  1055         byEnd = tracks.byEnd[ end ];

  1056         natives = byEnd._natives;

  1057         type = natives && natives.type;

  1058 

  1059         //  If plugin does not exist on this instance, remove it

  1060         if ( !natives ||

  1061             ( !!registryByName[ type ] ||

  1062               !!obj[ type ] ) ) {

  1063 

  1064           if ( byEnd._running === true ) {

  1065             byEnd._running = false;

  1066             natives.end.call( obj, event, byEnd );

  1067           }

  1068 

  1069           end++;

  1070         } else {

  1071           // remove track event

  1072           Popcorn.removeTrackEvent( obj, byEnd._id );

  1073           return;

  1074         }

  1075       }

  1076 

  1077       while ( tracks.byStart[ start ] && tracks.byStart[ start ].start <= currentTime ) {

  1078 

  1079         byStart = tracks.byStart[ start ];

  1080         natives = byStart._natives;

  1081         type = natives && natives.type;

  1082 

  1083         //  If plugin does not exist on this instance, remove it

  1084         if ( !natives ||

  1085             ( !!registryByName[ type ] ||

  1086               !!obj[ type ] ) ) {

  1087 

  1088           if ( byStart.end > currentTime &&

  1089                 byStart._running === false &&

  1090                   obj.data.disabled.indexOf( type ) === -1 ) {

  1091 

  1092             byStart._running = true;

  1093             natives.start.call( obj, event, byStart );

  1094 

  1095             // If the `frameAnimation` option is used,

  1096             // push the current byStart object into the `animating` cue

  1097             if ( obj.options.frameAnimation &&

  1098                 ( byStart && byStart._running && byStart._natives.frame ) ) {

  1099 

  1100               animating.push( byStart );

  1101             }

  1102           }

  1103           start++;

  1104         } else {

  1105           // remove track event

  1106           Popcorn.removeTrackEvent( obj, byStart._id );

  1107           return;

  1108         }

  1109       }

  1110 

  1111       // If the `frameAnimation` option is used, iterate the animating track

  1112       // and execute the `frame` callback

  1113       if ( obj.options.frameAnimation ) {

  1114         while ( animIndex < animating.length ) {

  1115 

  1116           byAnimate = animating[ animIndex ];

  1117 

  1118           if ( !byAnimate._running ) {

  1119             animating.splice( animIndex, 1 );

  1120           } else {

  1121             byAnimate._natives.frame.call( obj, event, byAnimate, currentTime );

  1122             animIndex++;

  1123           }

  1124         }

  1125       }

  1126 

  1127     // Playbar receding

  1128     } else if ( previousTime > currentTime ) {

  1129 

  1130       while ( tracks.byStart[ start ] && tracks.byStart[ start ].start > currentTime ) {

  1131 

  1132         byStart = tracks.byStart[ start ];

  1133         natives = byStart._natives;

  1134         type = natives && natives.type;