player.dart

// Copyright 2022-2024 Wang Bin. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
import 'dart:async';
import 'dart:ffi';
import 'dart:isolate';
import 'dart:ui' as ui;

import 'package:ffi/ffi.dart';
import 'package:flutter/foundation.dart';

import 'fvp_platform_interface.dart';
import 'generated_bindings.dart';
import 'global.dart';
import 'media_info.dart';
import 'lib.dart';
import 'extensions.dart';

class Player {
  int get nativeHandle => _player.address;

  /// for builder
  final ValueNotifier<int?> textureId = ValueNotifier<int?>(null);

  Player() {
    _pp.value = _player;
    _receivePort.listen((message) async {
      final type = message[0] as int;
      final rep = calloc<_CallbackReply>();
      switch (type) {
        case 0:
          {
            // event
            final error = message[1] as int;
            final category = message[2] as String;
            final detail = message[3] as String;
            final ev = MediaEvent(error, category, detail);
            for (final cb in _eventCb) {
              cb(ev);
            }
          }
        case 1:
          {
            // state
            final oldValue = message[1] as int;
            final newValue = message[2] as int;
            for (final cb in _stateCb) {
              cb(PlaybackState.from(oldValue), PlaybackState.from(newValue));
            }
            Libfvp.replyType(nativeHandle, type, nullptr);
          }
        case 2:
          {
            // media status
            final oldValue = message[1] as int;
            final newValue = message[2] as int;
            bool ret = true;
            for (var cb in _statusCb) {
              ret = cb(MediaStatus(oldValue), MediaStatus(newValue)) && ret;
            }
            rep.ref.mediaStatus.ret = ret;
            Libfvp.replyType(nativeHandle, type, rep.cast());
          }
        case 3:
          {
            // prepared
            final pos = message[1] as int;
            if (!_prepared.isCompleted) {
              _prepared.complete(pos);
            }
            rep.ref.prepared.ret = true;
            rep.ref.prepared.boost = true;
            if (!_videoSize.isCompleted) {
              if (pos < 0) {
                _videoSize.complete(null);
              } else {
                _setVideoSize();
              }
            }
            if (_prepareCb != null) {
              rep.ref.prepared.ret = await _prepareCb!();
              _prepareCb = null;
            }
            Libfvp.replyType(nativeHandle, type, rep.cast());
          }
        case 6:
          {
            // seek
            final pos = message[1] as int;
            if (!(_seeked?.isCompleted ?? true)) {
              _seeked?.complete(pos);
            }
            _seeked = null;
          }
      }
      calloc.free(rep);
    });
    Libfvp.registerPort(nativeHandle, NativeApi.postCObject.cast(),
        _receivePort.sendPort.nativePort);

    onMediaStatus((oldValue, newValue) {
      if (_videoSize.isCompleted) {
        return true;
      }
      if (!oldValue.test(MediaStatus.loaded) &&
          newValue.test(MediaStatus.loaded)) {
        _setVideoSize();
      }
      if (oldValue.test(MediaStatus.loading) &&
          newValue.test(MediaStatus.invalid | MediaStatus.stalled)) {
        _videoSize.complete(null);
      }
      return true;
    });
    onEvent((e) {
      if (_videoSize.isCompleted) {
        return;
      }
      if (e.category == 'decoder.video') {
        _setVideoSize();
      }
    });
  }

  /// Release resources
  void dispose() async {
    if (_pp == nullptr) {
      return;
    }
    // await: ensure no player ref in fvp plugin before mdkPlayerAPI_delete() in dart
    await updateTexture(width: -1);
    state = PlaybackState.stopped;
    Libfvp.unregisterPort(nativeHandle);
    onEvent(null);
    onStateChanged(null);
    onMediaStatus(null);

    _receivePort.close();

    Libmdk.instance.mdkPlayerAPI_delete(_pp);
    calloc.free(_pp);
    _pp = nullptr;
  }

  /// Release current texture then create a new one for current [media], and update [textureId].
  ///
  /// Texture will be created when media is loaded and [mediaInfo.video] is not empty.
  /// If both [width] and [height] are null, texture size is video frame size, otherwise is requested size.
  Future<int> updateTexture(
      {int? width, int? height, bool? tunnel, bool? fit}) async {
    if (_texId >= 0) {
      textureId.value = null;
      await FvpPlatform.instance.releaseTexture(nativeHandle, _texId);
      _texId = -1;
    }
    if (width == null && height == null) {
      // original size
      final size = await _videoSize.future;
      if (size == null) {
        return -1;
      }
      _texId = await FvpPlatform.instance.createTexture(nativeHandle,
          size.width.toInt(), size.height.toInt(), tunnel ?? false);
      textureId.value = _texId;
      return _texId;
    }
    if (width != null && height != null && width > 0 && height > 0) {
      _texId = await FvpPlatform.instance
          .createTexture(nativeHandle, width, height, tunnel ?? false);
      textureId.value = _texId;
      return _texId;
    }
    // release texture if width or height <= 0
    return _texId;
  }

  /// Mute the audio or not
  set mute(bool value) {
    _mute = value;
    _player.ref.setMute.asFunction<void Function(Pointer<mdkPlayer>, bool)>(
        isLeaf: true)(_player.ref.object, value);
  }

  /// Mute value.
  bool get mute => _mute;

  /// Set audio volume value. 1.0 is source value
  set volume(double value) {
    _volume = value;
    _player.ref.setVolume
            .asFunction<void Function(Pointer<mdkPlayer>, double)>()(
        _player.ref.object, value);
  }

  /// Audio volume value
  double get volume => _volume;

  /// Set the audio renderer. Can be 'AudioTrack', 'OpenSL' on android.
  set audioBackends(List<String> value) {
    final u8p = value.toCZ();
    _player.ref.setAudioBackends.asFunction<
            void Function(Pointer<mdkPlayer>, Pointer<Pointer<Char>>)>()(
        _player.ref.object, u8p.cast());
    u8p.free();
  }

  /// Set media, can be url, file path, assets://path etc.
  set media(String value) {
    _media = value;
    final cs = value.toNativeUtf8();
    _player.ref.setMedia
            .asFunction<void Function(Pointer<mdkPlayer>, Pointer<Char>)>()(
        _player.ref.object, cs.cast());
    malloc.free(cs);
  }

  /// Current media.
  String get media => _media;

  /// Set audio decoder priority. Usually not required.
  set audioDecoders(List<String> value) => setDecoders(MediaType.audio, value);

  List<String> get audioDecoders => _adec;

  /// Set video decoder priority. Default is 'auto' decoder, which is usually 'FFmpeg'.
  /// Detail: https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setdecodersmediatype-type-const-stdvectorstdstring-names
  set videoDecoders(List<String> value) => setDecoders(MediaType.video, value);

  /// Decoder list set by user
  List<String> get videoDecoders => _vdec;

  /// Set active audio tracks. Other tracks will be disabled.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setactivetracksmediatype-type-const-stdsetint-tracks
  set activeAudioTracks(List<int> value) =>
      setActiveTracks(MediaType.audio, value);

  /// Active audio tracks set by user
  List<int> get activeAudioTracks => _activeAT;

  /// Set active video tracks. Other tracks will be disabled.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setactivetracksmediatype-type-const-stdsetint-tracks
  set activeVideoTracks(List<int> value) =>
      setActiveTracks(MediaType.video, value);

  /// Active video tracks set by user
  List<int> get activeVideoTracks => _activeVT;

  /// Set active subtitle tracks. Other tracks will be disabled.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setactivetracksmediatype-type-const-stdsetint-tracks
  set activeSubtitleTracks(List<int> value) =>
      setActiveTracks(MediaType.subtitle, value);

  /// Active subtitle tracks set by user
  List<int> get activeSubtitleTracks => _activeST;

  /// Set playback state to start, pause and stop the media.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setstateplaybackstate-value
  set state(PlaybackState value) {
    _state = value;
    _player.ref.setState.asFunction<void Function(Pointer<mdkPlayer>, int)>()(
        _player.ref.object, value.rawValue);
    if (_state == PlaybackState.stopped) {
      _videoSize = Completer<ui.Size?>();
    }
  }

  /// Current playback state.
  PlaybackState get state => _state;

  /// Current [MediaStatus] value
  MediaStatus get mediaStatus => MediaStatus(_player.ref.mediaStatus
      .asFunction<int Function(Pointer<mdkPlayer>)>()(_player.ref.object));

  /// Set loop count. -1 is infinite loop. 0 is no loop.
  set loop(int value) {
    _loop = value;
    _player.ref.setLoop.asFunction<void Function(Pointer<mdkPlayer>, int)>()(
        _player.ref.object, value);
  }

  /// Loop count set by user.
  int get loop => _loop;

  /// Preload the next media set by [setNext] immediately or when current playback is finished.
  set preloadImmediately(bool value) {
    _preloadImmediately = value;
    _player.ref.setPreloadImmediately
            .asFunction<void Function(Pointer<mdkPlayer>, bool)>()(
        _player.ref.object, value);
  }

  bool get preloadImmediately => _preloadImmediately;

  /// Get current playback position in milliseconds relative to media's first timestamp.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#int64_t-position-const
  int get position => _player.ref.position
      .asFunction<int Function(Pointer<mdkPlayer>)>()(_player.ref.object);

  /// Playback speed. 1.0 is original speed.
  set playbackRate(double value) {
    _playbackRate = value;
    _player.ref.setPlaybackRate
            .asFunction<void Function(Pointer<mdkPlayer>, double)>()(
        _player.ref.object, value);
  }

  /// Playback speed set by user.
  double get playbackRate => _playbackRate;

  /// Media information.
  MediaInfo get mediaInfo {
    _mediaInfoC = _player.ref.mediaInfo
            .asFunction<Pointer<mdkMediaInfo> Function(Pointer<mdkPlayer>)>()(
        _player.ref.object);
    return MediaInfo.from(_mediaInfoC);
  }

  /// Load the [media] from [position] in milliseconds and decode the first frame, then [state] will be [PlaybackState.paused].
  /// If error occurs, will be [PlaybackState.stopped].
  /// Return the result position, or a negative value if failed.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-prepareint64_t-startposition--0-functionboolint64_t-position-bool-boost-cb--nullptr-seekflag-flags--seekflagfromstart
  Future<int> prepare(
      {int position = 0,
      SeekFlag flags = const SeekFlag(SeekFlag.defaultFlags),
      Future<bool> Function()? callback}) async {
    _prepared = Completer<int>();
    Libfvp.registerType(nativeHandle, 3, true);
    _prepareCb = callback;
    if (!Libfvp.prepare(nativeHandle, position, flags.rawValue,
        NativeApi.postCObject.cast(), _receivePort.sendPort.nativePort)) {
      _prepared.complete(-1);
    }
    return _prepared.future;
  }

  /// Set decoder priority.
  /// Detail: https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setdecodersmediatype-type-const-stdvectorstdstring-names
  void setDecoders(MediaType type, List<String> value) {
    switch (type) {
      case MediaType.audio:
        _adec = value;
      case MediaType.video:
        _vdec = value;
      default:
    }

    final u8p = value.toCZ();
    _player.ref.setDecoders.asFunction<
            void Function(Pointer<mdkPlayer>, int, Pointer<Pointer<Char>>)>()(
        _player.ref.object, type.rawValue, u8p.cast());
    u8p.free();
  }

  /// Set active tracks of [type]. Other tracks of [type] will be disabled.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setactivetracksmediatype-type-const-stdsetint-tracks
  void setActiveTracks(MediaType type, List<int> value) {
    switch (type) {
      case MediaType.audio:
        _activeAT = value;
      case MediaType.video:
        _activeVT = value;
      case MediaType.subtitle:
        _activeST = value;
      default:
    }
    final ca = calloc<Int>(value.length);
    for (int i = 0; i < value.length; ++i) {
      ca[i] = value[i];
    }
    _player.ref.setActiveTracks.asFunction<
            void Function(Pointer<mdkPlayer>, int, Pointer<Int>, int)>()(
        _player.ref.object, type.rawValue, ca.cast(), value.length);
    calloc.free(ca);
  }

  /// Set media of [type]. Can be used to load external audio track and subtitle file.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setmediaconst-char-url-mediatype-type
  void setMedia(String uri, MediaType type) {
    final cs = uri.toNativeUtf8();
    _player.ref.setMediaForType.asFunction<
            void Function(Pointer<mdkPlayer>, Pointer<Char>, int)>()(
        _player.ref.object, cs.cast(), type.rawValue);
    malloc.free(cs);
  }

  /// Set the next media to play when current media playback is finished.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setnextmediaconst-char-url-int64_t-startposition--0-seekflag-flags--seekflagfromstart
  void setNext(String uri,
      {int from = 0,
      SeekFlag seekFlag = const SeekFlag(SeekFlag.defaultFlags)}) {
    final cs = uri.toNativeUtf8();
    _player.ref.setNextMedia.asFunction<
            void Function(Pointer<mdkPlayer>, Pointer<Char>, int, int)>()(
        _player.ref.object, cs.cast(), from, seekFlag.rawValue);
    malloc.free(cs);
  }

  /// Wait for [state] in current thread
  bool waitFor(PlaybackState state, {int timeout = -1}) => _player.ref.waitFor
          .asFunction<bool Function(Pointer<mdkPlayer>, int, int)>()(
      _player.ref.object, state.rawValue, timeout);

  /// Seek to [position] in milliseconds
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#bool-seekint64_t-pos-seekflag-flags-stdfunctionvoidint64_t-ret-cb--nullptr
  Future<int> seek(
      {required int position,
      SeekFlag flags = const SeekFlag(SeekFlag.defaultFlags)}) async {
    if (!(_seeked?.isCompleted ?? true)) {
      _seeked?.complete(-2);
    }
    _seeked = Completer<int>();
    if (!Libfvp.seek(nativeHandle, position, flags.rawValue,
        NativeApi.postCObject.cast(), _receivePort.sendPort.nativePort)) {
      _seeked!.complete(-10);
    }
    return _seeked!.future;
  }

  /// Return buffered duration in milliseconds.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#int64_t-bufferedint64_t-bytes--nullptr-const
  int buffered() {
    //var cbytes = calloc<Int64>();
    final ret = _player.ref.buffered
            .asFunction<int Function(Pointer<mdkPlayer>, Pointer<Int64>)>()(
        _player.ref.object, nullptr);
    //cbytes.value
    //calloc.free(cbytes);
    return ret;
  }

  /// Set duration range of buffered data.
  ///
  /// [minMs] default 1000. wait for buffered duration >= [minMs]
  ///   If [minMs] < 0, then [minMs], [maxMs] and [drop] will be reset to the default value
  /// [maxMs] default 4000. max buffered duration.
  ///   If [maxMs] < 0, then [maxMs] and drop will be reset to the default value
  ///   If [maxMs] == 0, same as INT64_MAX
  /// [drop] = true: drop old non-key frame packets to reduce buffered duration until < [maxMs].
  /// [drop] = false: wait for buffered duration < maxMs before pushing packets
  ///
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setbufferrangeint64_t-minms-int64_t-maxms-bool-drop--false
  void setBufferRange({int min = -1, int max = -1, bool drop = false}) =>
      _player.ref.setBufferRange
              .asFunction<void Function(Pointer<mdkPlayer>, int, int, bool)>()(
          _player.ref.object, min, max, drop);

  /// Start to record if [to] is not null. Stop recording if [to] is null.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-recordconst-char-url--nullptr-const-char-format--nullptr
  void record({String? to, String? format}) {
    final cto = to?.toNativeUtf8();
    final cfmt = format?.toNativeUtf8();
    _player.ref.record.asFunction<
            void Function(Pointer<mdkPlayer>, Pointer<Char>, Pointer<Char>)>()(
        _player.ref.object, cto?.cast() ?? nullptr, cfmt?.cast() ?? nullptr);
    if (cto != null) {
      malloc.free(cto);
    }
    if (cfmt != null) {
      malloc.free(cfmt);
    }
  }

  /// Set position range in milliseconds. Can be used by A-B loop.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setrangeint64_t-a-int64_t-b--int64_max
  void setRange({required int from, int to = -1}) => _player.ref.setRange
          .asFunction<void Function(Pointer<mdkPlayer>, int, int)>()(
      _player.ref.object, from, to);

  /// Set additional properties.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setpropertyconst-stdstring-key-const-stdstring-value
  void setProperty(String name, String value) {
    final ck = name.toNativeUtf8();
    final cv = value.toNativeUtf8();
    _player.ref.setProperty.asFunction<
            void Function(Pointer<mdkPlayer>, Pointer<Char>, Pointer<Char>)>()(
        _player.ref.object, ck.cast(), cv.cast());
    malloc.free(ck);
    malloc.free(cv);
  }

  /// Get property value for [name]
  String? getProperty(String name) {
    final ck = name.toNativeUtf8();
    final cv = _player.ref.getProperty.asFunction<
            Pointer<Char> Function(Pointer<mdkPlayer>, Pointer<Char>)>()(
        _player.ref.object, ck.cast());
    malloc.free(ck);
    if (cv.address == 0) {
      return null;
    }
    return cv.cast<Utf8>().toDartString();
  }

  // video renderer apis

  /// Set video renderer size or destroy renderer.
  /// Usually NOT used in dart.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setvideosurfacesizeint-width-int-height-void-vo_opaque--nullptr
  void setVideoSurfaceSize(int width, int height, {Object? vid}) =>
      _player.ref.setVideoSurfaceSize.asFunction<
              void Function(Pointer<mdkPlayer>, int, int, Pointer<Void>)>()(
          _player.ref.object, width, height, Pointer.fromAddress(vid.hashCode));

  void setVideoViewport(double x, double y, double width, double height,
          {Object? vid}) =>
      _player.ref.setVideoViewport.asFunction<
              void Function(Pointer<mdkPlayer>, double, double, double, double,
                  Pointer<Void>)>()(_player.ref.object, x, y, width, height,
          Pointer.fromAddress(vid.hashCode));

  /// Set video content aspect ratio. No effect if texture width/height == original video frame width/height.
  /// [value] can be [ignoreAspectRatio], [keepAspectRatio], [keepAspectRatioCrop] and other desired ratio = width/height
  ///
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setaspectratiofloat-value-void-vo_opaque--nullptr
  void setAspectRatio(double value, {Object? vid}) =>
      _player.ref.setAspectRatio.asFunction<
              void Function(Pointer<mdkPlayer>, double, Pointer<Void>)>()(
          _player.ref.object, value, Pointer.fromAddress(vid.hashCode));

  // TODO: mapPoint( List<double>)

  /// rotate video content around the center. [degree] can be 0, 90, 180, 270 in counterclockwise.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-rotateint-degree-void-vo_opaque--nullptr
  void rotate(int degree, {Object? vid}) => _player.ref.rotate
          .asFunction<void Function(Pointer<mdkPlayer>, int, Pointer<Void>)>()(
      _player.ref.object, degree, Pointer.fromAddress(vid.hashCode));

  /// scale video content. 1.0 is no scale.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-scalefloat-x-float-y-void-vo_opaque--nullptr
  void scale(double x, double y, {Object? vid}) => _player.ref.scale.asFunction<
          void Function(Pointer<mdkPlayer>, double, double, Pointer<Void>)>()(
      _player.ref.object, x, y, Pointer.fromAddress(vid.hashCode));

  /// Set background color.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setbackgroundcolorfloat-r-float-g-float-b-float-a-void-vo_opaque--nullptr
  void setBackgroundColor(double r, double g, double b, double a,
          {Object? vid}) =>
      _player.ref.setBackgroundColor.asFunction<
              void Function(Pointer<mdkPlayer>, double, double, double, double,
                  Pointer<Void>)>()(
          _player.ref.object, r, g, b, a, Pointer.fromAddress(vid.hashCode));

  /// Set background color.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#void-setbackgroundcolorfloat-r-float-g-float-b-float-a-void-vo_opaque--nullptr
  void setBackground(ui.Color c, {Object? vid}) =>
      _player.ref.setBackgroundColor.asFunction<
              void Function(Pointer<mdkPlayer>, double, double, double, double,
                  Pointer<Void>)>()(
          _player.ref.object,
          c.red / 255,
          c.green / 255,
          c.blue / 255,
          c.alpha / 255,
          Pointer.fromAddress(vid.hashCode));

  /// Set a built-in video effect.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#player-setvideoeffect-effect-const-float-values-void-vo_opaque--nullptr
  void setVideoEffect(VideoEffect effect, List<double> value, {Object? vid}) {
    final cv = calloc<Float>(value.length);
    for (int i = 0; i < value.length; ++i) {
      cv[i] = value[i];
    }
    _player.ref.setVideoEffect.asFunction<
            void Function(
                Pointer<mdkPlayer>, int, Pointer<Float>, Pointer<Void>)>()(
        _player.ref.object,
        effect.rawValue,
        cv.cast(),
        Pointer.fromAddress(vid.hashCode));
    calloc.free(cv);
  }

  /// Set target color space.
  /// Usually NOT used by dart because flutter only supports SDR output.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#player-setcolorspace-value-void-vo_opaque--nullptr
  void setColorSpace(ColorSpace value, {Object? vid}) => _player
          .ref.setColorSpace
          .asFunction<void Function(Pointer<mdkPlayer>, int, Pointer<Void>)>()(
      _player.ref.object, value.rawValue, Pointer.fromAddress(vid.hashCode));

  /// Draw the current video frame and return frame timestamp in seconds.
  /// Usually NOT used in dart.
  double renderVideo({Object? vid}) => _player.ref.renderVideo
          .asFunction<double Function(Pointer<mdkPlayer>, Pointer<Void>)>()(
      _player.ref.object, Pointer.fromAddress(vid.hashCode));

  // callbacks

  /// Set [MediaEvent] callback.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#player-oneventstdfunctionboolconst-mediaevent-cb-callbacktoken-token--nullptr
  void onEvent(void Function(MediaEvent)? callback) {
    if (callback == null) {
      _eventCb.clear();
      Libfvp.unregisterType(nativeHandle, 0);
    } else {
      _eventCb.add(callback);
      Libfvp.registerType(nativeHandle, 0, false);
    }
  }

  /// Set a [PlaybackState] change callback.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#player-onstatechangedstdfunctionvoidstate-cb
// reply: true to let native code wait for dart callback result
  void onStateChanged(
      void Function(PlaybackState oldValue, PlaybackState newValue)? callback,
      {bool reply = false}) {
    if (callback == null) {
      _stateCb.clear();
      Libfvp.unregisterType(nativeHandle, 1);
    } else {
      _stateCb.add(callback);
      Libfvp.registerType(nativeHandle, 1, reply);
    }
  }

  /// Add a [MediaStatus] callback or remove all callbacks.
  /// https://github.com/wang-bin/mdk-sdk/wiki/Player-APIs#player-onmediastatusstdfunctionboolmediastatus-oldvalue-mediastatus-newvalue-cb-callbacktoken-token--nullptr
// reply: true to let native code wait for dart callback result, may result in dead lock because when native waiting main isolate reply, main isolate may execute another task(e.g. frequent seekTo) which also acquire the same lock in native
// only the last callback reply parameter works
  void onMediaStatus(
      bool Function(MediaStatus oldValue, MediaStatus newValue)? callback,
      {bool reply = false}) {
    if (callback == null) {
      _statusCb.clear();
      Libfvp.unregisterType(nativeHandle, 2);
    } else {
      _statusCb.add(callback);
      Libfvp.registerType(nativeHandle, 2, reply);
    }
  }

  void _setVideoSize() {
    final vc = mediaInfo.video?[0].codec;
    // if no video stream, create a dummy texture of size 16x16
    double w = 16;
    double h = 16;
    if (vc != null) {
      if (vc.width <= 0 || vc.height <= 0) {
        // failed to parse video size, e.g. small probesize
        return;
      }
      w = vc.width.toDouble();
      h = (vc.height.toDouble() / vc.par).roundToDouble();
      if (mediaInfo.video![0].rotation % 180 == 90) {
        (w, h) = (h, w);
      }
    }
    final size = ui.Size(w, h);
    _videoSize.complete(size);
  }

  final _player = Libmdk.instance.mdkPlayerAPI_new();
  var _pp = calloc<Pointer<mdkPlayerAPI>>();

  int _texId = -1;
  var _videoSize = Completer<ui.Size?>();
  var _prepared = Completer<int>();
  Completer<int>? _seeked;
  final _receivePort = ReceivePort();

  final _eventCb = <Function(MediaEvent)>[];
  final _stateCb = <Function(PlaybackState oldValue, PlaybackState newValue)>[];
  final _statusCb =
      <bool Function(MediaStatus oldValue, MediaStatus newValue)>[];
  Future<bool> Function()? _prepareCb;

  bool _mute = false;
  double _volume = 1.0;
  String _media = "";
  List<String> _adec = ["auto"];
  List<String> _vdec = ["auto"];
  List<int> _activeAT = [0];
  List<int> _activeVT = [0];
  List<int> _activeST = [0];
  PlaybackState _state = PlaybackState.stopped;
  int _loop = 0;
  bool _preloadImmediately = true;
  double _playbackRate = 1.0;
  Pointer<mdkMediaInfo> _mediaInfoC =
      nullptr; // MediaInfo has views on mdkMediaInfo
}

final class _CallbackReply extends Union {
  external _UnnamedStruct5 mediaStatus;
  external _UnnamedStruct6 sync1;
  external _UnnamedStruct7 prepared;
}

final class _UnnamedStruct5 extends Struct {
  @Bool()
  external bool ret;
}

final class _UnnamedStruct6 extends Struct {
  @Double()
  external double ret;
}

final class _UnnamedStruct7 extends Struct {
  @Bool()
  external bool ret;
  @Bool()
  external bool boost;
}