Refactoring. Make Session._media private

src/core/session.ts

 import { Tracker } from '../trackers/tracker';
 import { Time } from './time';
 import { Source } from '../sources/source';
+import { VideoSource } from '../sources/video-source';
+import { CanvasSource } from '../sources/canvas-source';
 import { asap } from '../utils/asap';
 
 /** Session mode */
     /** Rendering viewport */
     private readonly _viewport: Viewport;
 
+    /** Primary source of data */
+    private readonly _primarySource: VideoSource | CanvasSource;
+
     /** Time Manager */
     private _time: Time;
 
         if(mode != 'immersive' && mode != 'inline')
             throw new IllegalArgumentError(`Invalid session mode "${mode}"`);
 
+        // find the primary source of data
+        this._primarySource = this._findPrimarySource(sources);
+
         // setup the viewport
         this._viewport = viewport;
-        this._viewport._init(() => this.media.size, mode);
+        this._viewport._init(() => this._media.size, mode);
 
         // setup the main loop
         this._setupUpdateLoop();
         }).then(() => {
 
             // validate sources of data
-            const videoSources = sources.filter(source => source._type == 'video');
-            if(videoSources.length != 1)
-                throw new IllegalArgumentError(`One video source of data must be provided`);
-
             for(let i = sources.length - 1; i >= 0; i--) {
                 if(sources.indexOf(sources[i]) < i)
                     throw new IllegalArgumentError(`Found repeated sources of data`);
     }
 
     /**
-     * The underlying media (generally a camera stream)
-     * @internal
-     */
-    get media(): SpeedyMedia
-    {
-        for(let i = this._sources.length - 1; i >= 0; i--) {
-            if(this._sources[i]._type == 'video')
-                return this._sources[i]._data as SpeedyMedia;
-        }
-
-        // this shouldn't happen
-        throw new IllegalOperationError(`Invalid input source`);
-    }
-
-    /**
      * Session mode
      */
     get mode(): SessionMode
     }
 
     /**
+     * Find the primary source of data (generally a camera stream)
+     * @param sources
+     * @returns the primary source
+     */
+    private _findPrimarySource(sources: Source[]): VideoSource | CanvasSource
+    {
+        // prefer video sources
+        for(let i = 0; i < sources.length; i++) {
+            if(sources[i]._type == 'video')
+                return sources[i] as VideoSource;
+        }
+        for(let i = 0; i < sources.length; i++) {
+            if(sources[i]._type == 'canvas')
+                return sources[i] as CanvasSource;
+        }
+
+        // this shouldn't happen
+        throw new IllegalOperationError(`No primary source of data was found!`);
+    }
+
+    /**
+     * The media of the primary source of data
+     */
+    private get _media(): SpeedyMedia
+    {
+        return this._primarySource._data;
+    }
+
+    /**
      * Attach a tracker to the session
      * @param tracker
      */
         const canvas = this._viewport._backgroundCanvas;
         const ctx = canvas.getContext('2d', { alpha: false });
         
-        if(ctx && this.media.type != 'data') {
+        if(ctx && this._media.type != 'data') {
             ctx.imageSmoothingEnabled = false;
 
             // draw user media
-            const image = this.media.source as CanvasImageSource;
+            const image = this._media.source as CanvasImageSource;
             ctx.drawImage(image, 0, 0, canvas.width, canvas.height);
 
             // render output image(s)

src/trackers/image-tracker/image-tracker.ts

 import { SpeedyPipelineNodeResize } from 'speedy-vision/types/core/pipeline/nodes/transforms/resize';
 import { SpeedyPipelineNodeFASTKeypointDetector } from 'speedy-vision/types/core/pipeline/nodes/keypoints/detectors/fast';
 import { SpeedyKeypoint } from 'speedy-vision/types/core/speedy-keypoint';
+import { VideoSource } from '../../sources/video-source';
+import { CanvasSource } from '../../sources/canvas-source';
 import { Tracker, TrackerOutput, TrackerResult, Trackable } from '../tracker';
 import { Session } from '../../core/session';
 import { IllegalOperationError, IllegalArgumentError } from '../../utils/errors';
     /** session */
     private _session: Nullable<Session>;
 
+    /** source of data */
+    private _source: Nullable<VideoSource | CanvasSource>;
+
     /** all states */
     private readonly _state: Record<ImageTrackerStateName, ImageTrackerState>;
 
 
         // initial setup
         this._session = null;
+        this._source = null;
         this._activeStateName = 'initial';
         this._lastOutput = { };
         this._database = new ReferenceImageDatabase();
         // store the session
         this._session = session;
 
+        // find a suitable source of data
+        // XXX also let the user specify a source manually?
+        for(const source of session.sources) {
+            // prefer video sources
+            if(source._type == 'video') {
+                this._source = source as VideoSource;
+                break;
+            }
+            else if(source._type == 'canvas')
+                this._source = source as CanvasSource;
+        }
+        if(this._source === null)
+            throw new IllegalOperationError('The image tracker requires a suitable source of data');
+
         // initialize states
         for(const state of Object.values(this._state))
             state.init();
 
         // compute the screen size for image processing purposes
         // note: this may change over time...!
-        const media = this._session.media;
+        const media = this._source!._data;
         const aspectRatio = media.width / media.height;
         const screenSize = Utils.resolution(this._resolution, aspectRatio);