1 /*
2  * Copyright (C) 2022 Huawei Device Co., Ltd.
3  * Licensed under the Apache License, Version 2.0 (the "License");
4  * you may not use this file except in compliance with the License.
5  * You may obtain a copy of the License at
6  *
7  *     http://www.apache.org/licenses/LICENSE-2.0
8  *
9  * Unless required by applicable law or agreed to in writing, software
10  * distributed under the License is distributed on an "AS IS" BASIS,
11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12  * See the License for the specific language governing permissions and
13  * limitations under the License.
14  */
15 
16 #ifndef AV_PLAYER_NAPI_H
17 #define AV_PLAYER_NAPI_H
18 
19 #include <shared_mutex>
20 #include "player.h"
21 #include "media_errors.h"
22 #include "napi/native_api.h"
23 #include "napi/native_node_api.h"
24 #include "avplayer_callback.h"
25 #include "media_data_source_callback.h"
26 #include "common_napi.h"
27 #include "audio_info.h"
28 #include "audio_effect.h"
29 #include "task_queue.h"
30 
31 namespace OHOS {
32 namespace Media {
33 namespace AVPlayerState {
34 const std::string STATE_IDLE = "idle";
35 const std::string STATE_INITIALIZED = "initialized";
36 const std::string STATE_PREPARED = "prepared";
37 const std::string STATE_PLAYING = "playing";
38 const std::string STATE_PAUSED = "paused";
39 const std::string STATE_STOPPED = "stopped";
40 const std::string STATE_RELEASED = "released";
41 const std::string STATE_ERROR = "error";
42 const std::string STATE_COMPLETED = "completed";
43 }
44 
45 namespace AVPlayerEvent {
46 const std::string EVENT_STATE_CHANGE = "stateChange";
47 const std::string EVENT_VOLUME_CHANGE = "volumeChange";
48 const std::string EVENT_END_OF_STREAM = "endOfStream";
49 const std::string EVENT_SEEK_DONE = "seekDone";
50 const std::string EVENT_SPEED_DONE = "speedDone";
51 const std::string EVENT_BITRATE_DONE = "bitrateDone";
52 const std::string EVENT_TIME_UPDATE = "timeUpdate";
53 const std::string EVENT_DURATION_UPDATE = "durationUpdate";
54 const std::string EVENT_SUBTITLE_TEXT_UPDATE = "subtitleTextUpdate";
55 const std::string EVENT_BUFFERING_UPDATE = "bufferingUpdate";
56 const std::string EVENT_START_RENDER_FRAME = "startRenderFrame";
57 const std::string EVENT_VIDEO_SIZE_CHANGE = "videoSizeChange";
58 const std::string EVENT_AUDIO_INTERRUPT = "audioInterrupt";
59 const std::string EVENT_AVAILABLE_BITRATES = "availableBitrates";
60 const std::string EVENT_TRACKCHANGE = "trackChange";
61 const std::string EVENT_TRACK_INFO_UPDATE = "trackInfoUpdate";
62 const std::string EVENT_DRM_INFO_UPDATE = "mediaKeySystemInfoUpdate";
63 const std::string EVENT_SET_DECRYPT_CONFIG_DONE = "setDecryptConfigDone";
64 const std::string EVENT_AUDIO_DEVICE_CHANGE = "audioOutputDeviceChangeWithInfo";
65 const std::string EVENT_SUBTITLE_UPDATE = "subtitleUpdate";
66 const std::string EVENT_ERROR = "error";
67 const std::string EVENT_AMPLITUDE_UPDATE = "amplitudeUpdate";
68 }
69 
70 using TaskRet = std::pair<int32_t, std::string>;
71 
72 class AVPlayerNapi : public AVPlayerNotify {
73 public:
74     __attribute__((visibility("default"))) static napi_value Init(napi_env env, napi_value exports);
75 
76 private:
77     static napi_value Constructor(napi_env env, napi_callback_info info);
78     static void Destructor(napi_env env, void *nativeObject, void *finalize);
79     /**
80      * createAVPlayer(callback: AsyncCallback<VideoPlayer>): void
81      * createAVPlayer(): Promise<VideoPlayer>
82      */
83     static napi_value JsCreateAVPlayer(napi_env env, napi_callback_info info);
84     /**
85      * prepare(callback: AsyncCallback<void>): void
86      * prepare(): Promise<void>
87      */
88     static napi_value JsPrepare(napi_env env, napi_callback_info info);
89     /**
90      * play(callback: AsyncCallback<void>): void
91      * play(): Promise<void>
92      */
93     static napi_value JsPlay(napi_env env, napi_callback_info info);
94     /**
95      * pause(callback: AsyncCallback<void>): void
96      * pause(): Promise<void>
97      */
98     static napi_value JsPause(napi_env env, napi_callback_info info);
99     /**
100      * stop(callback: AsyncCallback<void>): void
101      * stop(): Promise<void>
102      */
103     static napi_value JsStop(napi_env env, napi_callback_info info);
104     /**
105      * reset(callback: AsyncCallback<void>): void
106      * reset(): Promise<void>
107      */
108     static napi_value JsReset(napi_env env, napi_callback_info info);
109     /**
110      * release(callback: AsyncCallback<void>): void
111      * release(): Promise<void>
112      */
113     static napi_value JsRelease(napi_env env, napi_callback_info info);
114     /**
115      * seek(timeMs: number, mode?:SeekMode): void
116      */
117     static napi_value JsSeek(napi_env env, napi_callback_info info);
118     /**
119      * setPlayRange(startTimeMs: number, endTimeMs: number, mode?: SeekMode): void
120      */
121     static napi_value JsSetPlaybackRange(napi_env env, napi_callback_info info);
122     /**
123      * setSpeed(speed: number): void
124      */
125     static napi_value JsSetSpeed(napi_env env, napi_callback_info info);
126     /**
127      * setVolume(vol: number): void
128      */
129     static napi_value JsSetVolume(napi_env env, napi_callback_info info);
130     /**
131      * selectBitrate(bitRate: number): void
132      */
133     static napi_value JsSelectBitrate(napi_env env, napi_callback_info info);
134     /**
135      * addSubtitleUrl: string
136      */
137     static napi_value JsAddSubtitleUrl(napi_env env, napi_callback_info info);
138     /**
139      * addSubtitleFdSrc: AVFileDescriptor
140      */
141     static napi_value JsAddSubtitleAVFileDescriptor(napi_env env, napi_callback_info info);
142     /**
143      * url: string
144      */
145     static napi_value JsSetUrl(napi_env env, napi_callback_info info);
146     static napi_value JsGetUrl(napi_env env, napi_callback_info info);
147     /**
148      * fdSrc: AVFileDescriptor
149      */
150     static napi_value JsGetAVFileDescriptor(napi_env env, napi_callback_info info);
151     static napi_value JsSetAVFileDescriptor(napi_env env, napi_callback_info info);
152     /**
153      * dataSrc: DataSrcDescriptor
154      */
155     static napi_value JsSetDataSrc(napi_env env, napi_callback_info info);
156     static napi_value JsGetDataSrc(napi_env env, napi_callback_info info);
157     /**
158      * surfaceId?: string
159      */
160     static napi_value JsSetSurfaceID(napi_env env, napi_callback_info info);
161     static napi_value JsGetSurfaceID(napi_env env, napi_callback_info info);
162     /**
163      * loop: boolenan
164      */
165     static napi_value JsSetLoop(napi_env env, napi_callback_info info);
166     static napi_value JsGetLoop(napi_env env, napi_callback_info info);
167     /**
168      * videoScaleType?: VideoScaleType
169      */
170     static napi_value JsSetVideoScaleType(napi_env env, napi_callback_info info);
171     static napi_value JsGetVideoScaleType(napi_env env, napi_callback_info info);
172     /**
173      * audioInterruptMode?: audio.AudioInterruptMode
174      */
175     static napi_value JsGetAudioInterruptMode(napi_env env, napi_callback_info info);
176     static napi_value JsSetAudioInterruptMode(napi_env env, napi_callback_info info);
177 
178     /**
179      * audioRendererInfo?: audio.AudioRendererInfo
180      */
181     static napi_value JsGetAudioRendererInfo(napi_env env, napi_callback_info info);
182     static napi_value JsSetAudioRendererInfo(napi_env env, napi_callback_info info);
183 
184     /**
185      * audioEffectMode ?: audio.AudioEffectMode;
186      */
187     static napi_value JsGetAudioEffectMode(napi_env env, napi_callback_info info);
188     static napi_value JsSetAudioEffectMode(napi_env env, napi_callback_info info);
189     /**
190      * readonly currentTime: number
191      */
192     static napi_value JsGetCurrentTime(napi_env env, napi_callback_info info);
193     /**
194      * readonly duration: number
195      */
196     static napi_value JsGetDuration(napi_env env, napi_callback_info info);
197     /**
198      * readonly state: AVPlayState
199      */
200     static napi_value JsGetState(napi_env env, napi_callback_info info);
201     /**
202      * readonly width: number
203      */
204     static napi_value JsGetWidth(napi_env env, napi_callback_info info);
205     /**
206      * readonly height: number
207      */
208     static napi_value JsGetHeight(napi_env env, napi_callback_info info);
209     /**
210      * getTrackDescription(callback:AsyncCallback<Array<MediaDescription>>): void
211      * getTrackDescription(): Promise<Array<MediaDescription>>
212      */
213     static napi_value JsGetTrackDescription(napi_env env, napi_callback_info info);
214     /**
215      * JsGetSelectedTracks(callback:AsyncCallback<Array<number>>): void
216      * JsGetSelectedTracks(): Promise<Array<number>>
217      */
218     static napi_value JsGetSelectedTracks(napi_env env, napi_callback_info info);
219     /**
220      * selectTrack(index: number, mode?: SwitchMode): void;
221      */
222     static napi_value JsSelectTrack(napi_env env, napi_callback_info info);
223     /**
224      * deselectTrack(index: number): void;
225      */
226     static napi_value JsDeselectTrack(napi_env env, napi_callback_info info);
227     /**
228      * GetCurrentTrack(trackType: MediaType, callback: AsyncCallback<number>): void;
229      * GetCurrentTrack(trackType: MediaType): Promise<number>;
230      */
231     static napi_value JsGetCurrentTrack(napi_env env, napi_callback_info info);
232     /**
233      * setDecryptionConfig(mediaKeySession: drm.MediaKeySession, secureVideoPath: boolean): void;
234      */
235     static napi_value JsSetDecryptConfig(napi_env env, napi_callback_info info);
236 
237     static napi_value JsSetMediaSource(napi_env env, napi_callback_info info);
238     /**
239      * getMediaKeySystemInfos(): Array<MediaKeySystemInfo>;
240      */
241     static napi_value JsGetMediaKeySystemInfos(napi_env env, napi_callback_info info);
242 
243     /**
244      * getPlaybackInfo(): playbackInfo;
245      */
246     static napi_value JsGetPlaybackInfo(napi_env env, napi_callback_info info);
247 
248     static napi_value JsSetPlaybackStrategy(napi_env env, napi_callback_info info);
249 
250     static napi_value JsSetMediaMuted(napi_env env, napi_callback_info info);
251     /**
252      * on(type: 'stateChange', callback: (state: AVPlayerState, reason: StateChangeReason) => void): void;
253      * off(type: 'stateChange'): void;
254      * on(type: 'volumeChange', callback: Callback<number>): void;
255      * off(type: 'volumeChange'): void;
256      * on(type: 'endOfStream', callback: Callback<void>): void;
257      * off(type: 'endOfStream'): void;
258      * on(type: 'seekDone', callback: Callback<number>): void;
259      * off(type: 'seekDone'): void;
260      * on(type: 'speedDone', callback: Callback<number>): void;
261      * off(type: 'speedDone'): void;
262      * on(type: 'bitrateDone', callback: Callback<number>): void;
263      * off(type: 'bitrateDone'): void;
264      * on(type: 'timeUpdate', callback: Callback<number>): void;
265      * off(type: 'timeUpdate'): void;
266      * on(type: 'durationUpdate', callback: Callback<number>): void;
267      * off(type: 'durationUpdate'): void;
268      * on(type: 'bufferingUpdate', callback: (infoType: BufferingInfoType, value: number) => void): void;
269      * off(type: 'bufferingUpdate'): void;
270      * on(type: 'startRenderFrame', callback: Callback<void>): void;
271      * off(type: 'startRenderFrame'): void;
272      * on(type: 'videoSizeChange', callback: (width: number, height: number) => void): void;
273      * off(type: 'videoSizeChange'): void;
274      * on(type: 'audioInterrupt', callback: (info: audio.InterruptEvent) => void): void;
275      * off(type: 'audioInterrupt'): void;
276      * on(type: 'availableBitrates', callback: (bitrates: Array<number>) => void): void;
277      * off(type: 'availableBitrates'): void;
278      * on(type: 'error', callback: ErrorCallback): void;
279      * off(type: 'error'): void;
280      * on(type: 'mediaKeySystemInfoUpdate', callback: (mediaKeySystemInfo: Array<MediaKeySystemInfo>) => void): void;
281      * off(type: 'mediaKeySystemInfoUpdate'): void;
282      */
283     static napi_value JsSetOnCallback(napi_env env, napi_callback_info info);
284     static napi_value JsClearOnCallback(napi_env env, napi_callback_info info);
285 
286     static AVPlayerNapi* GetJsInstance(napi_env env, napi_callback_info info);
287     static AVPlayerNapi* GetJsInstanceWithParameter(napi_env env, napi_callback_info info,
288         size_t &argc, napi_value *argv);
289     static bool JsHandleParameter(napi_env env, napi_value args, AVPlayerNapi *jsPlayer);
290     static void SeekEnqueueTask(AVPlayerNapi *jsPlayer, int32_t time, int32_t mode);
291     AVPlayerNapi();
292     ~AVPlayerNapi() override;
293     void SaveCallbackReference(const std::string &callbackName, std::shared_ptr<AutoRef> ref);
294     void ClearCallbackReference();
295     void ClearCallbackReference(const std::string &callbackName);
296     void StartListenCurrentResource();
297     void PauseListenCurrentResource();
298     void QueueOnErrorCb(MediaServiceExtErrCodeAPI9 errorCode, const std::string &errorMsg);
299     void OnErrorCb(MediaServiceExtErrCodeAPI9 errorCode, const std::string &errorMsg);
300     void SetSource(std::string url);
301     void AddSubSource(std::string url);
302     void SetSurface(const std::string &surfaceStr);
303     void ResetUserParameters();
304 
305     std::shared_ptr<TaskHandler<TaskRet>> PrepareTask();
306     std::shared_ptr<TaskHandler<TaskRet>> PlayTask();
307     std::shared_ptr<TaskHandler<TaskRet>> PauseTask();
308     std::shared_ptr<TaskHandler<TaskRet>> StopTask();
309     std::shared_ptr<TaskHandler<TaskRet>> ResetTask();
310     std::shared_ptr<TaskHandler<TaskRet>> ReleaseTask();
311     std::shared_ptr<TaskHandler<TaskRet>> SetPlaybackStrategyTask(AVPlayStrategy playStrategy);
312     std::shared_ptr<TaskHandler<TaskRet>> SetMediaMutedTask(MediaType type, bool isMuted);
313     std::shared_ptr<TaskHandler<TaskRet>> EqueueSetPlayRangeTask(int32_t start, int32_t end, int32_t mode);
314 
315     std::string GetCurrentState();
316     bool IsControllable();
317     bool CanSetPlayRange();
318     bool IsLiveSource() const;
319     void EnqueueNetworkTask(const std::string url);
320     void EnqueueFdTask(const int32_t fd);
321 
322     PlayerSeekMode TransferSeekMode(int32_t mode);
323     PlayerSwitchMode TransferSwitchMode(int32_t mode);
324 
325     void NotifyDuration(int32_t duration) override;
326     void NotifyPosition(int32_t position) override;
327     void NotifyState(PlayerStates state) override;
328     void NotifyVideoSize(int32_t width, int32_t height) override;
329     void NotifyIsLiveStream() override;
330     void NotifyDrmInfoUpdated(const std::multimap<std::string, std::vector<uint8_t>> &infos) override;
331     void StopTaskQue();
332     void WaitTaskQueStop();
333     void MaxAmplitudeCallbackOn(AVPlayerNapi *jsPlayer, std::string callbackName);
334     void MaxAmplitudeCallbackOff(AVPlayerNapi *jsPlayer, std::string callbackName);
335     void DeviceChangeCallbackOn(AVPlayerNapi *jsPlayer, std::string callbackName);
336     void DeviceChangeCallbackOff(AVPlayerNapi *jsPlayer, std::string callbackName);
337 
338     std::condition_variable stopTaskQueCond_;
339     bool taskQueStoped_ = false;
340     bool calMaxAmplitude_ = false;
341     bool deviceChangeCallbackflag_ = false;
342 
343     struct AVPlayerContext : public MediaAsyncContext {
AVPlayerContextOHOS::Media::AVPlayerNapi::AVPlayerContext344         explicit AVPlayerContext(napi_env env) : MediaAsyncContext(env) {}
345         ~AVPlayerContext() = default;
CheckTaskResultOHOS::Media::AVPlayerNapi::AVPlayerContext346         void CheckTaskResult(bool isTimeLimited = false, uint32_t milliseconds = 0)
347         {
348             if (asyncTask != nullptr) {
349                 auto result = isTimeLimited ? asyncTask->GetResultWithTimeLimit(milliseconds) : asyncTask->GetResult();
350                 if (result.HasResult() && result.Value().first != MSERR_EXT_API9_OK) {
351                     SignError(result.Value().first, result.Value().second);
352                 }
353             }
354         }
355         std::shared_ptr<TaskHandler<TaskRet>> asyncTask = nullptr;
356         AVPlayerNapi *napi = nullptr;
357     };
358     void GetCurrentTrackTask(std::unique_ptr<AVPlayerContext> &promiseCtx, napi_env env, napi_value args);
359     void HandleSelectTrack(std::unique_ptr<AVPlayerContext> &promiseCtx, napi_env env, napi_value args[],
360         size_t argCount);
361     static thread_local napi_ref constructor_;
362     napi_env env_ = nullptr;
363     std::shared_ptr<Player> player_ = nullptr;
364     std::shared_ptr<AVPlayerCallback> playerCb_ = nullptr;
365     std::shared_ptr<MediaDataSourceCallback> dataSrcCb_ = nullptr;
366     std::atomic<bool> isReleased_ = false;
367     std::atomic<bool> isInterrupted_ = false;
368     std::string url_ = "";
369     struct AVFileDescriptor fileDescriptor_;
370     struct AVDataSrcDescriptor dataSrcDescriptor_;
371     std::string surface_ = "";
372     bool loop_ = false;
373     int32_t videoScaleType_ = 0;
374     std::vector<Format> trackInfoVec_;
375     OHOS::AudioStandard::InterruptMode interruptMode_ = AudioStandard::InterruptMode::SHARE_MODE;
376     OHOS::AudioStandard::AudioRendererInfo audioRendererInfo_ = OHOS::AudioStandard::AudioRendererInfo {
377         OHOS::AudioStandard::ContentType::CONTENT_TYPE_MUSIC,
378         OHOS::AudioStandard::StreamUsage::STREAM_USAGE_MEDIA,
379         0
380     };
381     int32_t audioEffectMode_ = OHOS::AudioStandard::AudioEffectMode::EFFECT_DEFAULT;
382     std::unique_ptr<TaskQueue> taskQue_;
383     std::mutex mutex_;
384     std::mutex taskMutex_;
385     std::map<std::string, std::shared_ptr<AutoRef>> refMap_;
386     PlayerStates state_ = PLAYER_IDLE;
387     std::condition_variable stateChangeCond_;
388     std::atomic<bool> stopWait_;
389     bool avplayerExit_ = false;
390     int32_t width_ = 0;
391     int32_t height_ = 0;
392     int32_t position_ = -1;
393     int32_t duration_ = -1;
394     bool isLiveStream_ = false;
395     std::shared_mutex drmMutex_{};
396     std::multimap<std::string, std::vector<uint8_t>> localDrmInfos_;
397     Format playbackInfo_;
398     int32_t index_ = -1;
399     int32_t mode_ = SWITCH_SMOOTH;
400 };
401 } // namespace Media
402 } // namespace OHOS
403 #endif // AV_PLAYER_NAPI_H