@alessmicrosystems/mpegts.js 1.8.1

package/src/player/player-engine-worker.ts

@@ -0,0 +1,370 @@
+/*
+ * Copyright (C) 2023 zheng qian. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Log from '../utils/logger';
+import LoggingControl from '../utils/logging-control';
+import { IllegalStateException } from '../utils/exception';
+import MediaInfo from '../core/media-info';
+import MSEEvents from '../core/mse-events';
+import MSEController from '../core/mse-controller';
+import Transmuxer from "../core/transmuxer";
+import TransmuxingEvents from '../core/transmuxing-events';
+import PlayerEvents from './player-events';
+import { ErrorTypes } from './player-errors';
+import {
+    WorkerCommandPacket,
+    WorkerCommandPacketInit,
+    WorkerCommandPacketLoggingConfig,
+    WorkerCommandPacketUnbufferedSeek,
+    WorkerCommandPacketTimeUpdate,
+    WorkerCommandPacketReadyStateChange,
+} from './player-engine-worker-cmd-def.js';
+import {
+    WorkerMessagePacket,
+    WorkerMessagePacketMSEInit,
+    WorkerMessagePacketMSEEvent,
+    WorkerMessagePacketPlayerEvent,
+    WorkerMessagePacketPlayerEventError,
+    WorkerMessagePacketPlayerEventExtraData,
+    WorkerMessagePacketTransmuxingEventInfo,
+    WorkerMessagePacketTransmuxingEventRecommendSeekpoint,
+    WorkerMessagePacketBufferedPositionChanged,
+    WorkerMessagePacketLogcatCallback,
+} from './player-engine-worker-msg-def.js';
+
+const PlayerEngineWorker = (self: DedicatedWorkerGlobalScope) => {
+    const TAG: string = 'PlayerEngineWorker';
+
+    const logcat_callback: (type: string, str: string) => void = onLogcatCallback.bind(this);
+
+    let media_data_source: any = null;
+    let config: any = null;
+
+    let mse_controller: MSEController = null;
+    let transmuxer: Transmuxer = null;
+
+    let mse_source_opened: boolean = false;
+    let has_pending_load: boolean = false;
+
+    let media_element_current_time: number = 0;
+    let media_element_ready_state: number = 0;
+
+    let destroyed = false;
+
+    self.addEventListener('message', (e: MessageEvent) => {
+        if (destroyed) {
+            return;
+        }
+
+        const command_packet = e.data as WorkerCommandPacket;
+        const cmd = command_packet.cmd;
+
+        switch (cmd) {
+            case 'logging_config': {
+                const packet = command_packet as WorkerCommandPacketLoggingConfig;
+                LoggingControl.applyConfig(packet.logging_config);
+
+                if (packet.logging_config.enableCallback === true) {
+                    LoggingControl.addLogListener(logcat_callback);
+                } else {
+                    LoggingControl.removeLogListener(logcat_callback);
+                }
+                break;
+            }
+            case 'init': {
+                const packet = command_packet as WorkerCommandPacketInit;
+                media_data_source = packet.media_data_source;
+                config = packet.config;
+                break;
+            }
+            case 'destroy':
+                destroy();
+                break;
+            case 'initialize_mse':
+                initializeMSE();
+                break;
+            case 'shutdown_mse':
+                shutdownMSE();
+                break;
+            case 'load':
+                load();
+                break;
+            case 'unload':
+                unload();
+                break;
+            case 'unbuffered_seek': {
+                const packet = command_packet as WorkerCommandPacketUnbufferedSeek;
+                mse_controller.flush();
+                transmuxer.seek(packet.milliseconds);
+                break;
+            }
+            case 'switch_audio_pid': {
+                if (transmuxer) {
+                    (transmuxer as any).switchAudioPid((command_packet as any).pid);
+                }
+                break;
+            }
+            case 'timeupdate': {
+                const packet = command_packet as WorkerCommandPacketTimeUpdate;
+                media_element_current_time = packet.current_time;
+                break;
+            }
+            case 'readystatechange': {
+                const packet = command_packet as WorkerCommandPacketReadyStateChange;
+                media_element_ready_state = packet.ready_state;
+                break;
+            }
+            case 'pause_transmuxer':
+                transmuxer.pause();
+                break;
+            case 'resume_transmuxer':
+                transmuxer.resume();
+                break;
+        }
+    });
+
+    function destroy(): void {
+        if (transmuxer) {
+            unload();
+        }
+        if (mse_controller) {
+            shutdownMSE();
+        }
+        destroyed = true;
+
+        self.postMessage({
+            msg: 'destroyed',
+        } as WorkerMessagePacket);
+    }
+
+    function initializeMSE(): void {
+        Log.v(TAG, 'Initializing MediaSource in DedicatedWorker');
+        mse_controller = new MSEController(config);
+        mse_controller.on(MSEEvents.SOURCE_OPEN, onMSESourceOpen.bind(this));
+        mse_controller.on(MSEEvents.UPDATE_END, onMSEUpdateEnd.bind(this));
+        mse_controller.on(MSEEvents.BUFFER_FULL, onMSEBufferFull.bind(this));
+        mse_controller.on(MSEEvents.ERROR, onMSEError.bind(this));
+        mse_controller.initialize({
+            getCurrentTime: () => media_element_current_time,
+            getReadyState: () => media_element_ready_state,
+        });
+
+        let handle = mse_controller.getHandle();
+        self.postMessage({
+            msg: 'mse_init',
+            handle: handle,
+        } as WorkerMessagePacketMSEInit, [handle]);
+    }
+
+    function shutdownMSE(): void {
+        if (mse_controller) {
+            mse_controller.shutdown();
+            mse_controller.destroy();
+            mse_controller = null;
+        }
+    }
+
+    function load(): void {
+        if (media_data_source == null || config == null) {
+            throw new IllegalStateException('Worker not initialized');
+        }
+        if (transmuxer) {
+            throw new IllegalStateException('Transmuxer has been initialized');
+        }
+        if (has_pending_load) {
+            return;
+        }
+        if (config.deferLoadAfterSourceOpen && !mse_source_opened) {
+            has_pending_load = true;
+            return;
+        }
+
+        transmuxer = new Transmuxer(media_data_source, config);
+
+        transmuxer.on(TransmuxingEvents.INIT_SEGMENT, (type: string, is: any) => {
+            mse_controller.appendInitSegment(is);
+        });
+        transmuxer.on(TransmuxingEvents.MEDIA_SEGMENT, (type: string, ms: any) => {
+            mse_controller.appendMediaSegment(ms);
+            self.postMessage({
+                msg: 'buffered_position_changed',
+                buffered_position_milliseconds: ms.info.endDts,
+            } as WorkerMessagePacketBufferedPositionChanged);
+        });
+        transmuxer.on(TransmuxingEvents.LOADING_COMPLETE, () => {
+            mse_controller.endOfStream();
+            self.postMessage({
+                msg: 'player_event',
+                event: PlayerEvents.LOADING_COMPLETE,
+            } as WorkerMessagePacketPlayerEvent);
+        });
+        transmuxer.on(TransmuxingEvents.RECOVERED_EARLY_EOF, () => {
+            self.postMessage({
+                msg: 'player_event',
+                event: PlayerEvents.RECOVERED_EARLY_EOF,
+            } as WorkerMessagePacketPlayerEvent);
+        });
+        transmuxer.on(TransmuxingEvents.IO_ERROR, (detail: any, info: any) => {
+            self.postMessage({
+                msg: 'player_event',
+                event: PlayerEvents.ERROR,
+                error_type: ErrorTypes.NETWORK_ERROR,
+                error_detail: detail,
+                info: info,
+            } as WorkerMessagePacketPlayerEventError);
+        });
+        transmuxer.on(TransmuxingEvents.DEMUX_ERROR, (detail: any, info: any) => {
+            self.postMessage({
+                msg: 'player_event',
+                event: PlayerEvents.ERROR,
+                error_type: ErrorTypes.MEDIA_ERROR,
+                error_detail: detail,
+                info: info,
+            } as WorkerMessagePacketPlayerEventError);
+        });
+
+        transmuxer.on(TransmuxingEvents.MEDIA_INFO, (mediaInfo: MediaInfo) => {
+            emitTransmuxingEventsInfo(TransmuxingEvents.MEDIA_INFO, mediaInfo);
+        });
+        transmuxer.on(TransmuxingEvents.STATISTICS_INFO, (statInfo: any) => {
+            emitTransmuxingEventsInfo(TransmuxingEvents.STATISTICS_INFO, statInfo);
+        });
+
+        transmuxer.on(TransmuxingEvents.RECOMMEND_SEEKPOINT, (milliseconds: number) => {
+            emitTransmuxingEventsRecommendSeekpoint(milliseconds);
+        });
+
+        transmuxer.on(TransmuxingEvents.METADATA_ARRIVED, (metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.METADATA_ARRIVED, metadata);
+        });
+        transmuxer.on(TransmuxingEvents.SCRIPTDATA_ARRIVED, (data: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.SCRIPTDATA_ARRIVED, data);
+        });
+        transmuxer.on((TransmuxingEvents as any).TRACKS_UPDATED, (data: any) => {
+            emitPlayerEventsExtraData((PlayerEvents as any).TRACKS_UPDATED, data);
+        });
+        transmuxer.on(TransmuxingEvents.TIMED_ID3_METADATA_ARRIVED, (timed_id3_metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.TIMED_ID3_METADATA_ARRIVED, timed_id3_metadata);
+        });
+        transmuxer.on(TransmuxingEvents.PGS_SUBTITLE_ARRIVED, (pgs_data: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.PGS_SUBTITLE_ARRIVED, pgs_data);
+        });
+        transmuxer.on(TransmuxingEvents.SYNCHRONOUS_KLV_METADATA_ARRIVED, (synchronous_klv_metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.SYNCHRONOUS_KLV_METADATA_ARRIVED, synchronous_klv_metadata);
+        });
+        transmuxer.on(TransmuxingEvents.ASYNCHRONOUS_KLV_METADATA_ARRIVED, (asynchronous_klv_metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.ASYNCHRONOUS_KLV_METADATA_ARRIVED, asynchronous_klv_metadata);
+        });
+        transmuxer.on(TransmuxingEvents.SMPTE2038_METADATA_ARRIVED, (smpte2038_metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.SMPTE2038_METADATA_ARRIVED, smpte2038_metadata);
+        });
+        transmuxer.on(TransmuxingEvents.SEI_ARRIVED, (sei_data: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.SEI_ARRIVED, sei_data);
+        });
+        transmuxer.on(TransmuxingEvents.SCTE35_METADATA_ARRIVED, (scte35_metadata: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.SCTE35_METADATA_ARRIVED, scte35_metadata);
+        });
+        transmuxer.on(TransmuxingEvents.PES_PRIVATE_DATA_DESCRIPTOR, (descriptor: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.PES_PRIVATE_DATA_DESCRIPTOR, descriptor);
+        });
+        transmuxer.on(TransmuxingEvents.PES_PRIVATE_DATA_ARRIVED, (private_data: any) => {
+            emitPlayerEventsExtraData(PlayerEvents.PES_PRIVATE_DATA_ARRIVED, private_data);
+        });
+
+        transmuxer.open();
+    }
+
+    function unload(): void {
+        if (mse_controller) {
+            mse_controller.flush();
+        }
+        if (transmuxer) {
+            transmuxer.close();
+            transmuxer.destroy();
+            transmuxer = null;
+        }
+    }
+
+    function onMSESourceOpen(): void {
+        mse_source_opened = true;
+        if (has_pending_load) {
+            has_pending_load = false;
+            load();
+        }
+    }
+
+    function onMSEUpdateEnd(): void {
+        self.postMessage({
+            msg: 'mse_event',
+            event: MSEEvents.UPDATE_END,
+        } as WorkerMessagePacketMSEEvent);
+    }
+
+    function onMSEBufferFull(): void {
+        Log.v(TAG, 'MSE SourceBuffer is full, report to main thread');
+        self.postMessage({
+            msg: 'mse_event',
+            event: MSEEvents.BUFFER_FULL,
+        } as WorkerMessagePacketMSEEvent);
+    }
+
+    function onMSEError(info: any): void {
+        self.postMessage({
+            msg: 'player_event',
+            event: PlayerEvents.ERROR,
+            error_type: ErrorTypes.MEDIA_ERROR,
+            error_detail: ErrorTypes.MEDIA_MSE_ERROR,
+            info: info,
+        } as WorkerMessagePacketPlayerEventError);
+    }
+
+    function emitTransmuxingEventsRecommendSeekpoint(milliseconds: number) {
+        self.postMessage({
+            msg: 'transmuxing_event',
+            event: TransmuxingEvents.RECOMMEND_SEEKPOINT,
+            milliseconds: milliseconds,
+        } as WorkerMessagePacketTransmuxingEventRecommendSeekpoint);
+    }
+
+    function emitTransmuxingEventsInfo(event: TransmuxingEvents, info: any) {
+        self.postMessage({
+            msg: 'transmuxing_event',
+            event: event,
+            info: info,
+        } as WorkerMessagePacketTransmuxingEventInfo);
+    }
+
+    function emitPlayerEventsExtraData(event: PlayerEvents, extraData: any) {
+        self.postMessage({
+            msg: 'player_event',
+            event: event,
+            extraData: extraData,
+        } as WorkerMessagePacketPlayerEventExtraData);
+    }
+
+    function onLogcatCallback(type: string, str: string): void {
+        self.postMessage({
+            msg: 'logcat_callback',
+            type: type,
+            logcat: str,
+        } as WorkerMessagePacketLogcatCallback);
+    }
+
+};
+
+export default PlayerEngineWorker;

package/src/player/player-engine.ts

@@ -0,0 +1,35 @@
+/*
+ * Copyright (C) 2023 zheng qian. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import type MediaInfo from "../core/media-info";
+
+export default interface PlayerEngine {
+    destroy(): void;
+    on(event: string, listener: (...args: any[]) => void): void;
+    off(event: string, listener: (...args: any[]) => void): void;
+    attachMediaElement(mediaElement: HTMLMediaElement): void;
+    detachMediaElement(): void;
+    load(): void;
+    unload(): void;
+    play(): Promise<void>;
+    pause(): void;
+    seek(seconds: number): void;
+    readonly mediaInfo: MediaInfo | undefined;
+    readonly statisticsInfo: any | undefined;
+    switchAudioPid(pid: number): void;
+}

package/src/player/player-errors.js

@@ -0,0 +1,39 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {LoaderErrors} from '../io/loader.js';
+import DemuxErrors from '../demux/demux-errors.js';
+
+export const ErrorTypes = {
+    NETWORK_ERROR: 'NetworkError',
+    MEDIA_ERROR: 'MediaError',
+    OTHER_ERROR: 'OtherError'
+};
+
+export const ErrorDetails = {
+    NETWORK_EXCEPTION: LoaderErrors.EXCEPTION,
+    NETWORK_STATUS_CODE_INVALID: LoaderErrors.HTTP_STATUS_CODE_INVALID,
+    NETWORK_TIMEOUT: LoaderErrors.CONNECTING_TIMEOUT,
+    NETWORK_UNRECOVERABLE_EARLY_EOF: LoaderErrors.UNRECOVERABLE_EARLY_EOF,
+
+    MEDIA_MSE_ERROR: 'MediaMSEError',
+
+    MEDIA_FORMAT_ERROR: DemuxErrors.FORMAT_ERROR,
+    MEDIA_FORMAT_UNSUPPORTED: DemuxErrors.FORMAT_UNSUPPORTED,
+    MEDIA_CODEC_UNSUPPORTED: DemuxErrors.CODEC_UNSUPPORTED
+};

package/src/player/player-events.ts

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2016 Bilibili. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+enum PlayerEvents {
+    ERROR = 'error',
+    LOADING_COMPLETE = 'loading_complete',
+    RECOVERED_EARLY_EOF = 'recovered_early_eof',
+    MEDIA_INFO = 'media_info',
+    METADATA_ARRIVED = 'metadata_arrived',
+    SCRIPTDATA_ARRIVED = 'scriptdata_arrived',
+    TRACKS_UPDATED = 'tracks_updated',
+    TIMED_ID3_METADATA_ARRIVED = 'timed_id3_metadata_arrived',
+    PGS_SUBTITLE_ARRIVED = 'pgs_subtitle_arrived',
+    SYNCHRONOUS_KLV_METADATA_ARRIVED = 'synchronous_klv_metadata_arrived',
+    ASYNCHRONOUS_KLV_METADATA_ARRIVED = 'asynchronous_klv_metadata_arrived',
+    SMPTE2038_METADATA_ARRIVED = 'smpte2038_metadata_arrived',
+    SEI_ARRIVED = 'sei_arrived',
+    SCTE35_METADATA_ARRIVED = 'scte35_metadata_arrived',
+    PES_PRIVATE_DATA_DESCRIPTOR = 'pes_private_data_descriptor',
+    PES_PRIVATE_DATA_ARRIVED = 'pes_private_data_arrived',
+    STATISTICS_INFO = 'statistics_info',
+    DESTROYING = 'destroying'
+};
+
+export default PlayerEvents;

package/src/player/seeking-handler.ts

@@ -0,0 +1,205 @@
+/*
+ * Copyright (C) 2023 zheng qian. All Rights Reserved.
+ *
+ * @author zheng qian <xqq@xqq.im>
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Browser from '../utils/browser';
+import { IDRSampleList } from '../core/media-segment-info';
+
+class SeekingHandler {
+
+    private readonly TAG: string = 'SeekingHandler';
+
+    private _config: any = null;
+    private _media_element: HTMLMediaElement = null;
+    private _always_seek_keyframe: boolean = false;
+    private _on_unbuffered_seek: (milliseconds: number) => void = null;
+
+    private _request_set_current_time: boolean = false;
+    private _seek_request_record_clocktime?: number = null;
+    private _idr_sample_list: IDRSampleList = new IDRSampleList();
+
+    private e?: any = null;
+
+    public constructor(
+        config: any,
+        media_element: HTMLMediaElement,
+        on_unbuffered_seek: (milliseconds: number) => void
+    ) {
+        this._config = config;
+        this._media_element = media_element;
+        this._on_unbuffered_seek = on_unbuffered_seek;
+
+        this.e = {
+            onMediaSeeking: this._onMediaSeeking.bind(this),
+        };
+
+        let chrome_need_idr_fix = (Browser.chrome &&
+                                  (Browser.version.major < 50 ||
+                                  (Browser.version.major === 50 && Browser.version.build < 2661)));
+        this._always_seek_keyframe = (chrome_need_idr_fix || Browser.msedge || Browser.msie) ? true : false;
+        if (this._always_seek_keyframe) {
+            this._config.accurateSeek = false;
+        }
+
+        this._media_element.addEventListener('seeking', this.e.onMediaSeeking);
+    }
+
+    public destroy(): void {
+        this._idr_sample_list.clear();
+        this._idr_sample_list = null;
+        this._media_element.removeEventListener('seeking', this.e.onMediaSeeking);
+        this._media_element = null;
+        this._on_unbuffered_seek = null;
+    }
+
+    public seek(seconds: number): void {
+        const direct_seek: boolean = this._isPositionBuffered(seconds);
+        let direct_seek_to_video_begin: boolean = false;
+
+        if (seconds < 1.0 && this._media_element.buffered.length > 0) {
+            const video_begin_time = this._media_element.buffered.start(0);
+            if ((video_begin_time < 1.0 && seconds < video_begin_time) || Browser.safari) {
+                direct_seek_to_video_begin = true;
+                // Workaround for Safari: Seek to 0 may cause video stuck, use 0.1 to avoid
+                seconds = Browser.safari ? 0.1 : video_begin_time;
+            }
+        }
+
+        if (direct_seek_to_video_begin) {
+            this.directSeek(seconds);
+        } else if (direct_seek) {
+            if (!this._always_seek_keyframe) {
+                this.directSeek(seconds);
+            } else {
+                // For some old browsers we have to seek to keyframe
+                // Seek to nearest keyframe if possible
+                const idr = this._getNearestKeyframe(Math.floor(seconds * 1000));
+                if (idr != null) {
+                    seconds = idr.dts / 1000;
+                }
+                this.directSeek(seconds);
+            }
+        } else {
+            this._idr_sample_list.clear();
+            this._on_unbuffered_seek(Math.floor(seconds * 1000));  // In milliseconds
+            if (this._config.accurateSeek) {
+                this.directSeek(seconds);
+            }
+            // else: Wait for recommend_seekpoint callback
+        }
+    }
+
+    public directSeek(seconds: number): void {
+        this._request_set_current_time = true;
+        this._media_element.currentTime = seconds;
+    }
+
+    public appendSyncPoints(syncpoints: any[]): void {
+        this._idr_sample_list.appendArray(syncpoints);
+    }
+
+    // Handle seeking request from browser's progress bar or HTMLMediaElement.currentTime setter
+    private _onMediaSeeking(e: Event): void {
+        if (this._request_set_current_time) {
+            this._request_set_current_time = false;
+            return;
+        }
+
+        let target: number = this._media_element.currentTime;
+        const buffered: TimeRanges = this._media_element.buffered;
+
+        // Handle seeking to video begin (near 0.0s)
+        if (target < 1.0 && buffered.length > 0) {
+            let video_begin_time = buffered.start(0);
+            if ((video_begin_time < 1.0 && target < video_begin_time) || Browser.safari) {
+                // Safari may get stuck if currentTime set to 0, use 0.1 to avoid
+                let target: number = Browser.safari ? 0.1 : video_begin_time;
+                this.directSeek(target);
+                return;
+            }
+        }
+
+        // Handle in-buffer seeking (usually nothing to do)
+        if (this._isPositionBuffered(target)) {
+            if (this._always_seek_keyframe) {
+                const idr = this._getNearestKeyframe(Math.floor(target * 1000));
+                if (idr != null) {
+                    target = idr.dts / 1000;
+                    this.directSeek(target);
+                }
+            }
+            return;
+        }
+
+        // else: Prepare for unbuffered seeking
+        // Defer the unbuffered seeking since the seeking bar maybe still being draged
+        this._seek_request_record_clocktime = SeekingHandler._getClockTime();
+        window.setTimeout(this._pollAndApplyUnbufferedSeek.bind(this), 50);
+
+    }
+
+    private _pollAndApplyUnbufferedSeek(): void {
+        if (this._seek_request_record_clocktime == null) {
+            return;
+        }
+
+        const record_time: number = this._seek_request_record_clocktime;
+        if (record_time <= SeekingHandler._getClockTime() - 100) {
+            const target = this._media_element.currentTime;
+            this._seek_request_record_clocktime = null;
+            if (!this._isPositionBuffered(target)) {
+                this._idr_sample_list.clear();
+                this._on_unbuffered_seek(Math.floor(target * 1000));  // In milliseconds
+                // Update currentTime if using accurateSeek, or wait for recommend_seekpoint callback
+                if (this._config.accurateSeek) {
+                    this.directSeek(target);
+                }
+            }
+        } else {
+            window.setTimeout(this._pollAndApplyUnbufferedSeek.bind(this), 50);
+        }
+    }
+
+    private _isPositionBuffered(seconds: number): boolean {
+        const buffered = this._media_element.buffered;
+
+        for (let i = 0; i < buffered.length; i++) {
+            const from = buffered.start(i);
+            const to = buffered.end(i);
+            if (seconds >= from && seconds < to) {
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    private _getNearestKeyframe(dts: number): any {
+        return this._idr_sample_list.getLastSyncPointBeforeDts(dts);
+    }
+
+    private static _getClockTime(): number {
+        if (self.performance && self.performance.now) {
+            return self.performance.now();
+        } else {
+            return Date.now();
+        }
+    }
+
+}
+
+export default SeekingHandler;