fis_lib_measure/lib/view/player/controller.dart

// ignore_for_file: constant_identifier_names

import 'dart:async';

import 'package:fis_common/event/event_type.dart';
import 'package:fis_measure/interfaces/process/player/play_controller.dart';
import 'package:fis_ui/index.dart';
import 'package:fis_vid/data_channel/channel.dart';
import 'package:flutter/foundation.dart';
import 'package:vid/us/vid_us_image.dart';
import 'package:vid/us/vid_us_image_data.dart';

import 'enums.dart';
import 'events.dart';

/// Vid播放器控制器
class VidPlayerController extends ChangeNotifier implements IPlayerController {
  /// Vid播放器控制器
  ///
  /// [url] Vid文件链接
  VidPlayerController(String url) {
    _url = url;
    _dataChannel = VidDataChannel.create(url);
    _isFirstFrame = true;
    eventHandler = FEventHandler<VidPlayerEvent>();
    frameUpdated = FEventHandler<VidUsImage>();
    firstFrameLoaded = FEventHandler<VidUsImage>();
    frameLoadStateChanged = FEventHandler<bool>();
    errorOccured = FEventHandler<String?>();
  }

  static const _CAN_PLAY_STATUS_ARR = [
    VidPlayStatus.ready,
    VidPlayStatus.pause
  ];

  static const _HAS_VIEW_STATUS_ARR = [VidPlayStatus.play, VidPlayStatus.pause];

  static const _FRAME_LOAD_RETRY_LIMIT = 120; // 500ms一次，等一分钟

  @override
  late final FEventHandler<VidPlayerEvent> eventHandler;

  @override
  late final FEventHandler<VidUsImage> frameUpdated;

  @override
  late final FEventHandler<VidUsImage> firstFrameLoaded;

  @override
  late final FEventHandler<bool> frameLoadStateChanged;

  @override
  late final FEventHandler<String?> errorOccured;

  late final String _url;
  late final VidDataChannel _dataChannel;

  _PlayAssistant? _playAssistant;
  double _speed = 1.0;
  VidPlayStatus _status = VidPlayStatus.init;
  int _frameIndex = -1;
  VidUsImage? _frame;
  bool _disposed = false;
  bool _isFirstFrame = false;
  bool _loading = false;
  int _frameLoadRetryCount = 0;
  Timer? _bufferWaitingTimer;

  @override
  String get url => _url;

  @override
  VidDataChannel get dataChannel => _dataChannel;

  @override
  bool get disposed => _disposed;

  /// Current play speed
  double get currentSpeed => _speed;

  @override
  VidPlayStatus get status => _status;

  @override
  VidUsImage? get currentFrame => _frame;

  /// Whether the player is playing
  bool get playing => status == VidPlayStatus.play;

  /// Whether the player can play
  bool get canPlay => _CAN_PLAY_STATUS_ARR.contains(status);

  /// Whether the player should has view
  bool get hasView => _HAS_VIEW_STATUS_ARR.contains(status);

  /// Current viewed frame index
  int get currentFrameIndex => _frameIndex;

  /// Total frames count of current vid
  int get totalFramesCount => _dataChannel.imageCount;

  bool get isSingleFrame => totalFramesCount == 1;

  /// 是否播放结束
  bool get isEndOfPlay => currentFrameIndex == totalFramesCount - 1;

  /// 当前播放器亮度 初始值为 0
  double get brightness => _brightness;
  double _brightness = 0.0;

  /// 当前播放器对比度 初始值为 1
  double get contrast => _contrast;
  double _contrast = 1.0;

  /// Set play speed [0.5~2]
  ///
  /// [speed] speed value [0.5~2]
  void setSpeed(double speed) {
    if (speed < 0.5 || speed > 2) return;

    _speed = speed;
    eventHandler.emit(this, VidPlayerSpeedChangeEvent(currentSpeed));
  }

  @override
  Future<bool> load() async {
    final loaded = await _dataChannel.load(10 * 1000);
    if (loaded) {
      _setStatus(VidPlayStatus.ready);
    } else {
      _setStatus(VidPlayStatus.loadFail);
    }
    return loaded;
  }

  @override
  void play() {
    if (playing) return;
    if (!canPlay) return;

    if (isEndOfPlay) {
      _frameIndex = -1;
    }
    if (isSingleFrame) {
      locateTo(0);
      _setStatus(VidPlayStatus.pause);
    } else {
      _playAssistant ??= _PlayAssistant(this);
      _playAssistant!.play();

      _setStatus(VidPlayStatus.play);
    }
  }

  @override
  void pause() {
    if (!playing) return;

    _playAssistant?.pause();
    _setStatus(VidPlayStatus.pause);
  }

  /// Pause and view next frame
  Future<bool> gotoNextFrame() {
    return locateTo(currentFrameIndex + 1);
  }

  /// Pause and view prev frame
  Future<bool> gotoPrevFrame() {
    return locateTo(currentFrameIndex - 1);
  }

  @override
  Future<bool> locateTo(int index) async {
    if (index < 0 || index >= totalFramesCount) return false;

    pause();
    _loading = false;
    gotoFrame(index);
    return true;
  }

  /// View target indexed frame
  ///
  /// [index] frame index
  Future<bool> gotoFrame(int index) async {
    if (index < 0 || index >= totalFramesCount) return false;

    if (_loading) return false;

    _frameIndex = index;
    _loading = true;
    _updateFrameLoadState(true);
    final result = await _waitUpdateFrame();
    if (result) {
      _updateFrameLoadState(false);
    }
    return result;
  }

  /// Set frame brightness
  ///
  /// [value] brightness value
  void setBrightness(int value) {
    final brightnessCount = value / 100;
    if (brightnessCount < -1 || brightnessCount > 1) {
      return;
    }
    if (kIsMobile) {
      _brightness = brightnessCount * 255;
    } else {
      _brightness = brightnessCount;
    }
    final fliterMatrix = <double>[
      contrast, 0, 0, 0, brightness, // red
      0, contrast, 0, 0, brightness, // green
      0, 0, contrast, 0, brightness, // blue
      0, 0, 0, 1, 0, // alpha // alpha
    ];
    eventHandler.emit(this, VidPlayerFilterChangeEvent(fliterMatrix));
    _reloadFrame();
  }

  /// Set frame contrast
  ///
  /// [value] contrast value
  void setContrast(int value) {
    double contrastCount = 1;
    if (value < 0) {
      contrastCount = (value + 100) / 100;
    } else if (value >= 0) {
      contrastCount = value / 100 * 9 + 1;
    }
    if (contrastCount < 0 || contrastCount > 10) {
      return;
    }
    _contrast = contrastCount;
    final fliterMatrix = <double>[
      contrast, 0, 0, 0, brightness, // red
      0, contrast, 0, 0, brightness, // green
      0, 0, contrast, 0, brightness, // blue
      0, 0, 0, 1, 0, // alpha
    ];
    eventHandler.emit(this, VidPlayerFilterChangeEvent(fliterMatrix));
    _reloadFrame();
  }

  void setFilterMatrix(List<double> matrix) {
    eventHandler.emit(this, VidPlayerFilterChangeEvent(matrix));
  }

  /// 重置图像增益
  void resetTone() {
    setBrightness(0);
    setContrast(0);
    eventHandler.emit(this, VidPlayResetToneEvent());
  }

  void _reloadFrame() {
    gotoFrame(currentFrameIndex);
  }

  void _updateFrameLoadState(bool val) {
    _loading = val;
    frameLoadStateChanged.emit(this, _loading);
  }

  void _emitErrorOccured([String? msg]) {
    errorOccured.emit(this, msg);
  }

  /// 等待更新帧
  Future<bool> _waitUpdateFrame([int? timeout]) async {
    if (_disposed) return false;

    try {
      final t = timeout ?? _playAssistant?._playIntervalMillSeconds ?? 500;
      _frame = await _dataChannel.getImage(currentFrameIndex, t);
      emitFrameUpdate();
      _frameLoadRetryCount = 0;
      return true;
    } catch (e) {
      if (e is ReadTimeoutException) {
        try {
          await _waitFrameBufferFluently();
          return await _waitUpdateFrame(500);
        } catch (e) {
          _emitErrorOccured("FrameLoadTimeout");
        }
      } else {
        _emitErrorOccured("FrameLoadError");
      }
    }
    return false;
  }

  Future<void> _waitFrameBufferFluently() async {
    const duration = Duration(milliseconds: 500);
    if (isSingleFrame) {
      await _waitSingleFrameBuffer(duration);
    } else {
      await _waitVideoBuffer(duration);
    }
    _frameLoadRetryCount = 0;
  }

  Future<void> _waitSingleFrameBuffer(Duration duration) async {
    final completer = Completer();
    Timer.periodic(
      duration,
      (timer) {
        if (_dataChannel.isBufferedDone) {
          timer.cancel();
          completer.complete();
          return;
        }

        _frameLoadRetryCount++;
        if (_frameLoadRetryCount >= _FRAME_LOAD_RETRY_LIMIT) {
          completer.completeError(Exception());
        }
      },
    );
    return completer.future;
  }

  Future<void> _waitVideoBuffer(Duration duration) async {
    final singleSize = currentFrame?.imageData.length ?? 2048;
    int fluntFrameCount = (_playAssistant!._frameRate * 1).toInt(); //1s缓冲
    final leftCount = totalFramesCount - (currentFrameIndex + 1);
    if (fluntFrameCount > leftCount) {
      fluntFrameCount = leftCount;
    }
    final bufferedSize = _dataChannel.getBufferSize();
    int fluentSize = bufferedSize + fluntFrameCount * singleSize;
    final totalSize = _dataChannel.getFileSize();
    if (fluentSize > totalSize) {
      fluentSize = totalSize;
    }
    final completer = Completer();
    Timer.periodic(
      duration,
      (timer) {
        final bufferedSize = _dataChannel.getBufferSize();
        if (bufferedSize >= fluentSize) {
          timer.cancel();
          completer.complete();
          return;
        }

        _frameLoadRetryCount++;
        if (_frameLoadRetryCount >= _FRAME_LOAD_RETRY_LIMIT) {
          completer.completeError(Exception());
        }
      },
    );
    return completer.future;
  }

  /// [Carotid] ✅用于设置颈动脉单帧展示
  void set2DMeasureFrame(VidUsImage frame) {
    _emitFrameUpdated(frame);
  }

  /// [Carotid] ✅用于重置播放器
  void resetCurrentFrame() {
    _frameIndex = -1;
    play();
  }

  void emitFrameUpdate() {
    if (_isFirstFrame) {
      firstFrameLoaded.emit(this, _frame!);
      _isFirstFrame = false;
    }

    _emitFrameUpdated();
  }

  void _emitFrameUpdated([VidUsImage? frame]) {
    // frameUpdated.emit(this, frame ?? _frame!);
    final f = frame ?? _frame!;
    eventHandler.emit(
      this,
      VidPlayerFrameIndexChangeEvent(f.index, f.imageData, f.width, f.height),
    );
  }

  void _setStatus(VidPlayStatus value) {
    _status = value;
    _notifyStatus();
  }

  void _notifyStatus() {
    eventHandler.emit(this, VidPlayerStatusChangeEvent(status));
  }

  void _stop({bool needNotify = true}) {
    _playAssistant?.pause();
    if (needNotify) {
      _setStatus(VidPlayStatus.stop);
    }
  }

  @override
  void dispose() {
    _disposed = true;
    _bufferWaitingTimer?.cancel();
    _stop(needNotify: false);
    eventHandler.dispose();
    _dataChannel.close();
    super.dispose();
  }

  /// 已禁用，请通过eventHandler监听事件
  @override
  void addListener(VoidCallback listener) {
    throw UnsupportedError(
        "method `addListener` has been limited.Pls use `eventHandler.addListener`.");
  }

  /// 已禁用，请通过eventHandler监听事件
  @override
  void removeListener(VoidCallback listener) {
    throw UnsupportedError(
        "method `removeListener` has been limited.Pls use `eventHandler.removeListener`.");
  }
}

class _PlayAssistant {
  _PlayAssistant(this.owner);

  final VidPlayerController owner;

  bool _ready = false;

  late double _frameRate;

  int get _playInterval => 1000 * 1000 ~/ _frameRate;

  int get _playIntervalMillSeconds => _playInterval ~/ 1000.0;

  Timer? _timer;

  void play() {
    if (!_ready) {
      _prepare();
    }
    if (_timer != null) {
      pause();
    }
    final duration = Duration(microseconds: _playInterval);
    // final duration = const Duration(milliseconds: 1000 ~/ 10);
    _timer = Timer.periodic(duration, (timer) async {
      // print('play at  ${DateTime.now()}');
      final result = await owner.gotoFrame(owner.currentFrameIndex + 1);
      if (result) {
        if (owner.currentFrameIndex == owner.totalFramesCount - 1) {
          owner.pause();
        }
      }
    });
  }

  void pause() {
    _timer?.cancel();
    _timer = null;
  }

  void _prepare() {
    _frameRate = owner._dataChannel.probe.frameRate;
    _ready = true;
  }
}