• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (c) 2025 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 fpermissions and
13  * limitations under the License.
14  */
15 
16 #include "napi/native_api.h"
17 #include <arpa/nameser.h>
18 #include <fcntl.h>
19 #include <map>
20 #include <js_native_api.h>
21 #include "multimedia/player_framework/avplayer.h"
22 #include "multimedia/player_framework/avplayer_base.h"
23 #include "multimedia/player_framework/avtranscoder.h"
24 #include "multimedia/player_framework/avtranscoder_base.h"
25 #include "multimedia/player_framework/native_averrors.h"
26 #include "multimedia/player_framework/native_avcodec_base.h"
27 #include "native_window/external_window.h"
28 #include "native_image/native_image.h"
29 #include "GLES3/gl32.h"
30 #include "EGL/egl.h"
31 #include <sys/stat.h>
32 #include <fstream>
33 #include <unistd.h>
34 #include <hilog/log.h>
35 #include <thread>
36 #include <vector>
37 #include <string>
38 #include <future>
39 #include <chrono>
40 
41 #define FAIL (-1)
42 #define SUCCESS 0
43 #define PARAM_0 0
44 #define PARAM_1 1
45 #define PARAM_2 2
46 #define PARAM_3 3
47 #define PARAM_4 4
48 #define PARAM_5 5
49 #define PARAM_6 6
50 #define PARAM_0666 0666
51 #define LOG_MSG_TAG "AVTransCoderNdk"
52 #define LOG(format, ...) ((void)OH_LOG_Print(LOG_APP, LOG_INFO, 0xFF00, LOG_MSG_TAG, format, ##__VA_ARGS__))
53 #define LOGE(format, ...) ((void)OH_LOG_Print(LOG_APP, LOG_ERROR, 0xFF00, LOG_MSG_TAG, format, ##__VA_ARGS__))
54 #define LOGD(format, ...) ((void)OH_LOG_Print(LOG_APP, LOG_DEBUG, 0xFF00, LOG_MSG_TAG, format, ##__VA_ARGS__))
55 
56 #define DST_ERROR_PATH "/data/storage/el2/base/files/dst_error.mp4"
57 
58 static int32_t g_gDelytime100 = 100;
59 static int32_t g_gDelytime200 = 200;
60 
61 const int32_t DEFAULT_AUDIOBITRATE = 200000;
62 const int32_t DEFAULT_VIDEOBITRATE = 3000000;
63 const int32_t DEFAULT_WIDTH = 720;
64 const int32_t DEFAULT_HEIGTH = 480;
65 const int32_t MAX_PROGRESS = 100;
66 
67 typedef struct NdkAVTransCoderUser {
68     using StateChangeFunc = std::function<void()>;
69 
70     NdkAVTransCoderUser();
71     NdkAVTransCoderUser(const NdkAVTransCoderUser &other) = delete;
72     NdkAVTransCoderUser& operator=(const NdkAVTransCoderUser &other) = delete;
73     ~NdkAVTransCoderUser();
74 
75     void OnStateChangeCb(OH_AVTranscoder *transcoder, OH_AVTranscoder_State state);
76     void OnErrorCb(OH_AVTranscoder *transcoder, int32_t errorCode, const char *errorMsg);
77     void OnProgressUpdateCb(OH_AVTranscoder *transcoder, int curProgress);
78     void InitTransCoder(int32_t srcFd, int64_t offset, int64_t length, int32_t dstFd);
79     std::map<uint32_t, StateChangeFunc> stateChangeFuncs_;
80 
81     OH_AVTranscoder *transcoder = nullptr;
82     OH_AVTranscoder_Config *config = nullptr;
83     int32_t errorCode = AV_ERR_UNKNOWN;
84     int32_t callbackError = AV_ERR_UNKNOWN;
85     int32_t returnError = AV_ERR_UNKNOWN;
86     OH_AVTranscoder_State transCoderState = AVTRANSCODER_PREPARED;
87     int progress = 0;
88     int inStartStateCount = 0;
89 } NdkAVTransCoderUser;
NdkAVTransCoderUser()90 NdkAVTransCoderUser::NdkAVTransCoderUser()
91 {
92 }
~NdkAVTransCoderUser()93 NdkAVTransCoderUser::~NdkAVTransCoderUser()
94 {
95     if (this->transcoder != nullptr) {
96         OH_AVTranscoder_Release(this->transcoder);
97         this->transcoder = nullptr;
98     }
99     if (this->config != nullptr) {
100         OH_AVTranscoderConfig_Release(this->config);
101         this->config = nullptr;
102     }
103 }
AvTransCoderStateChangeCbImpl(OH_AVTranscoder * transcoder,OH_AVTranscoder_State state,void * userData)104 static void AvTransCoderStateChangeCbImpl(OH_AVTranscoder *transcoder, OH_AVTranscoder_State state, void *userData)
105 {
106     LOG("AvTransCoderStateChangeCbImpl state: %{public}d", state);
107     NdkAVTransCoderUser *ndkAVTransCoderUser = reinterpret_cast<NdkAVTransCoderUser *>(userData);
108     if (ndkAVTransCoderUser == nullptr || transcoder == nullptr) {
109         LOGE("AvTransCoderStateChangeCbImpl ndkAVTransCoderUser or transcoder is nullptr");
110         return;
111     }
112     ndkAVTransCoderUser->OnStateChangeCb(transcoder, state);
113 }
114 
AvTransCoderErrorCbImpl(OH_AVTranscoder * transcoder,int32_t errorCode,const char * errorMsg,void * userData)115 static void AvTransCoderErrorCbImpl(OH_AVTranscoder *transcoder, int32_t errorCode, const char *errorMsg,
116     void *userData)
117 {
118     LOG("AvTransCoderErrorCbImpl errorCode: %{public}d, errorMsg: %{public}s", errorCode,
119         errorMsg == nullptr ? "unknown" : errorMsg);
120     NdkAVTransCoderUser *ndkAVTransCoderUser = reinterpret_cast<NdkAVTransCoderUser *>(userData);
121     if (ndkAVTransCoderUser == nullptr || transcoder == nullptr) {
122         LOGE("AvTransCoderErrorCbImpl ndkAVTransCoderUser or transcoder is nullptr");
123         return;
124     }
125     ndkAVTransCoderUser->OnErrorCb(transcoder, errorCode, errorMsg);
126 }
AvTransCoderProgressUpdateCbImpl(OH_AVTranscoder * transcoder,int progress,void * userData)127 static void AvTransCoderProgressUpdateCbImpl(OH_AVTranscoder *transcoder, int progress, void *userData)
128 {
129     LOG("AvTransCoderProgressUpdateCbImpl progress: %{public}d", progress);
130     NdkAVTransCoderUser *ndkAVTransCoderUser = reinterpret_cast<NdkAVTransCoderUser *>(userData);
131     if (ndkAVTransCoderUser == nullptr || transcoder == nullptr) {
132         LOGE("AvTransCoderProgressUpdateCbImpl ndkAVTransCoderUser or transcoder is nullptr");
133         return;
134     }
135     ndkAVTransCoderUser->OnProgressUpdateCb(transcoder, progress);
136 }
InitTransCoder(int32_t srcFd,int64_t offset,int64_t length,int32_t dstFd)137 void NdkAVTransCoderUser::InitTransCoder(int32_t srcFd, int64_t offset, int64_t length, int32_t dstFd)
138 {
139     this->transcoder = OH_AVTranscoder_Create();
140     if (transcoder == nullptr) {
141         LOGE("NdkAVTransCoderUser InitTransCoder transcoder is nullptr");
142         return;
143     }
144     OH_AVTranscoder_SetStateCallback(transcoder, AvTransCoderStateChangeCbImpl, this);
145     OH_AVTranscoder_SetErrorCallback(transcoder, AvTransCoderErrorCbImpl, this);
146     OH_AVTranscoder_SetProgressUpdateCallback(transcoder, AvTransCoderProgressUpdateCbImpl, this);
147 
148     this->config = OH_AVTranscoderConfig_Create();
149     if (this->config == nullptr) {
150         LOGE("NdkAVTransCoderUser InitTransCoder OH_AVTranscoderConfig_Create failed");
151         return;
152     }
153     OH_AVTranscoderConfig_SetSrcFD(config, srcFd, offset, length);
154     OH_AVTranscoderConfig_SetDstFD(this->config, dstFd);
155     OH_AVTranscoderConfig_SetDstFileType(this->config, AV_OUTPUT_FORMAT_MPEG_4);
156 }
157 
OnProgressUpdateCb(OH_AVTranscoder * transcoder,int curProgress)158 void NdkAVTransCoderUser::OnProgressUpdateCb(OH_AVTranscoder *transcoder, int curProgress)
159 {
160     LOG("NdkAVTransCoderUser OnProgressUpdateCb progress: %{public}d", curProgress);
161     this->progress = curProgress;
162 }
163 
OnErrorCb(OH_AVTranscoder * transcoder,int32_t errorCode,const char * errorMsg)164 void NdkAVTransCoderUser::OnErrorCb(OH_AVTranscoder *transcoder, int32_t errorCode, const char *errorMsg)
165 {
166     LOG("NdkAVTransCoderUser OnErrorCb errorCode: %{public}d ,errorMsg: %{public}s",
167         errorCode, errorMsg == nullptr ? "unknown" : errorMsg);
168     this->errorCode = errorCode;
169     this->callbackError = errorCode;
170 }
171 
OnStateChangeCb(OH_AVTranscoder * transcoder,OH_AVTranscoder_State state)172 void NdkAVTransCoderUser::OnStateChangeCb(OH_AVTranscoder *transcoder, OH_AVTranscoder_State state)
173 {
174     this->transCoderState = state;
175     if (transcoder == nullptr) {
176         return;
177     }
178     int32_t ret = -1;
179     switch (state) {
180     case AVTRANSCODER_PREPARED: {
181         this->transCoderState = AVTRANSCODER_PREPARED;
182         LOG("OnStateChangeCb OH_AVTranscoder_State AVTRANSCODER_STARTED");
183         if (this->stateChangeFuncs_.count(AVTRANSCODER_PREPARED) > 0) {
184             this->stateChangeFuncs_[AVTRANSCODER_PREPARED]();
185         }
186         break;
187     }
188     case AVTRANSCODER_STARTED: {
189         this->transCoderState = AVTRANSCODER_STARTED;
190         LOG("OnStateChangeCb OH_AVTranscoder_State AVTRANSCODER_STARTED");
191         if (this->stateChangeFuncs_.count(AVTRANSCODER_STARTED) > 0) {
192             this->stateChangeFuncs_[AVTRANSCODER_STARTED]();
193         }
194         break;
195     }
196     case AVTRANSCODER_PAUSED: {
197         this->transCoderState = AVTRANSCODER_PAUSED;
198         if (this->stateChangeFuncs_.count(AVTRANSCODER_PAUSED) > 0) {
199             this->stateChangeFuncs_[AVTRANSCODER_PAUSED]();
200         }
201         LOG("OnStateChangeCb OH_AVTranscoder_State AVTRANSCODER_PAUSED");
202         break;
203     }
204     case AVTRANSCODER_CANCELLED: {
205         this->transCoderState = AVTRANSCODER_CANCELLED;
206         if (this->stateChangeFuncs_.count(AVTRANSCODER_CANCELLED) > 0) {
207             this->stateChangeFuncs_[AVTRANSCODER_CANCELLED]();
208         }
209         LOG("OnStateChangeCb OH_AVTranscoder_State AVTRANSCODER_CANCELLED");
210         break;
211     }
212     case AVTRANSCODER_COMPLETED: {
213         this->transCoderState = AVTRANSCODER_COMPLETED;
214         if (this->stateChangeFuncs_.count(AVTRANSCODER_COMPLETED) > 0) {
215             this->stateChangeFuncs_[AVTRANSCODER_COMPLETED]();
216         }
217         LOG("OnStateChangeCb OH_AVTranscoder_State AVTRANSCODER_COMPLETED");
218         break;
219     }
220     default:
221         break;
222     }
223 }
224 
225 
GetFileSize(const char * fileName)226 static int64_t GetFileSize(const char *fileName)
227 {
228     int64_t fileSize = PARAM_0;
229     if (fileName != nullptr) {
230         struct stat fileStatus;
231         fileSize = static_cast<size_t>(fileStatus.st_size);
232     }
233     return fileSize;
234 }
235 
parseBasicArgs(napi_env env,napi_callback_info info,int32_t * srcFd,int64_t * srcOffset,int64_t * length,int32_t * dstFd)236 void parseBasicArgs(napi_env env, napi_callback_info info,
237     int32_t *srcFd, int64_t *srcOffset, int64_t *length, int32_t *dstFd)
238 {
239     size_t argc = PARAM_4;
240     napi_value args[PARAM_4] = {nullptr};
241     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
242     napi_get_value_int32(env, args[PARAM_0], srcFd);
243     napi_get_value_int64(env, args[PARAM_1], srcOffset);
244     napi_get_value_int64(env, args[PARAM_2], length);
245     napi_get_value_int32(env, args[PARAM_3], dstFd);
246 }
waitAvTransCoderStateChange(NdkAVTransCoderUser * transcoderUser,OH_AVTranscoder_State state)247 int32_t waitAvTransCoderStateChange(NdkAVTransCoderUser *transcoderUser, OH_AVTranscoder_State state)
248 {
249     while (state != transcoderUser->transCoderState) {
250         std::this_thread::sleep_for(std::chrono::milliseconds(g_gDelytime100));
251         LOG("waitAvTransCoderStateChange currentState:%{public}d", transcoderUser->transCoderState);
252         if (transcoderUser->callbackError != AV_ERR_UNKNOWN && transcoderUser->callbackError != AV_ERR_OK) {
253             LOGE("waitAvTransCoderStateChange errorCode:%{public}d", transcoderUser->callbackError);
254             return transcoderUser->callbackError;
255         }
256     }
257     return SUCCESS;
258 }
259 
SetInt32NamedProperty(napi_env env,napi_value object,const char * key,int32_t value)260 static void SetInt32NamedProperty(napi_env env, napi_value object, const char* key, int32_t value)
261 {
262     napi_value temp = nullptr;
263     napi_create_int32(env, value, &temp);
264     napi_set_named_property(env, object, key, temp);
265     return;
266 }
267 
SetUserNamedProperty(napi_env env,napi_value object,const char * key,NdkAVTransCoderUser ** transcoderUser)268 static void SetUserNamedProperty(napi_env env, napi_value object, const char* key, NdkAVTransCoderUser **transcoderUser)
269 {
270     napi_value temp = nullptr;
271     napi_create_external(env, reinterpret_cast<void *>(*transcoderUser), nullptr, nullptr, &temp);
272     napi_set_named_property(env, object, "userData", temp);
273     return;
274 }
275 
OhAvTransCoderNdkTest(napi_env env,napi_callback_info info)276 static napi_value OhAvTransCoderNdkTest(napi_env env, napi_callback_info info)
277 {
278     napi_value result = nullptr;
279     int32_t srcFd = PARAM_0;
280     int64_t srcOffset = PARAM_0;
281     int64_t length = PARAM_0;
282     int32_t dstFd = PARAM_0;
283     parseBasicArgs(env, info, &srcFd, &srcOffset, &length, &dstFd);
284 
285     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
286     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
287     OH_AVErrCode errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
288     if (errCode != AV_ERR_OK) {
289         napi_get_undefined(env, &result);
290         delete transcoderUser;
291         return result;
292     }
293     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
294     if (errCode != AV_ERR_OK) {
295         napi_get_undefined(env, &result);
296         delete transcoderUser;
297         return result;
298     }
299     napi_create_external(env, reinterpret_cast<void *>(transcoderUser), nullptr, nullptr, &result);
300     return result;
301 }
302 
OhCheckAvTransCoderComplete(napi_env env,napi_callback_info info)303 static napi_value OhCheckAvTransCoderComplete(napi_env env, napi_callback_info info)
304 {
305     napi_value result = nullptr;
306     int backParam = FAIL;
307     size_t argc = 1;
308     napi_value args[1] = {nullptr};
309     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
310     void *ptr = nullptr;
311     napi_get_value_external(env, args[0], &ptr);
312     NdkAVTransCoderUser *transcoderUser = reinterpret_cast<NdkAVTransCoderUser *>(ptr);
313     if (AVTRANSCODER_COMPLETED == transcoderUser->transCoderState) {
314         LOGE("OhCheckAvTransCoderComplete transCoderState is AVTRANSCODER_COMPLETED");
315         backParam = SUCCESS;
316         delete transcoderUser;
317         transcoderUser = nullptr;
318     }
319     napi_create_int32(env, backParam, &result);
320     return result;
321 }
322 
OhAvTransCoderNdkSetResolutionError(napi_env env,napi_callback_info info)323 static napi_value OhAvTransCoderNdkSetResolutionError(napi_env env, napi_callback_info info)
324 {
325     napi_value result = nullptr;
326     int backParam = FAIL;
327 
328     size_t argc = PARAM_5;
329     napi_value args[PARAM_5] = {nullptr};
330     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
331     int32_t srcFd = PARAM_0;
332     napi_get_value_int32(env, args[PARAM_0], &srcFd);
333     int64_t srcOffset = PARAM_0;
334     napi_get_value_int64(env, args[PARAM_1], &srcOffset);
335     int64_t length = PARAM_0;
336     napi_get_value_int64(env, args[PARAM_2], &length);
337     int32_t width = PARAM_0;
338     napi_get_value_int32(env, args[PARAM_3], &width);
339     int32_t height = PARAM_0;
340     napi_get_value_int32(env, args[PARAM_4], &height);
341     int fileDescribe = open(DST_ERROR_PATH, O_CREAT | O_RDWR, PARAM_0666);
342     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
343     transcoderUser->InitTransCoder(srcFd, srcOffset, length, fileDescribe);
344     OH_AVTranscoderConfig_SetDstVideoResolution(transcoderUser->config, width, height);
345     backParam = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
346     LOG("Transcoder OhAvTransCoderNdkSetResolutionError ret %{public}d", backParam);
347     napi_create_int32(env, backParam, &result);
348     close(fileDescribe);
349     delete transcoderUser;
350     return result;
351 }
352 
OhAvTransCoderPrepareParamError1(napi_env env,napi_callback_info info)353 static napi_value OhAvTransCoderPrepareParamError1(napi_env env, napi_callback_info info)
354 {
355     napi_value result = nullptr;
356     int backParam = FAIL;
357     OH_AVTranscoder *transcoder = OH_AVTranscoder_Create();
358     OH_AVErrCode err = OH_AVTranscoder_Prepare(transcoder, nullptr);
359     backParam = err;
360     LOG("Transcoder OhAvTransCoderPrepareParamError1 ret %{public}d", backParam);
361     napi_create_int32(env, backParam, &result);
362     OH_AVTranscoder_Release(transcoder);
363     return result;
364 }
365 
OhAvTransCoderPrepareParamError2(napi_env env,napi_callback_info info)366 static napi_value OhAvTransCoderPrepareParamError2(napi_env env, napi_callback_info info)
367 {
368     napi_value result = nullptr;
369     int backParam = FAIL;
370     size_t argc = PARAM_3;
371     napi_value args[PARAM_3] = {nullptr};
372     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
373     int32_t srcFd = PARAM_0;
374     napi_get_value_int32(env, args[PARAM_0], &srcFd);
375     int64_t srcOffset = PARAM_0;
376     napi_get_value_int64(env, args[PARAM_1], &srcOffset);
377     int64_t length = PARAM_0;
378     napi_get_value_int64(env, args[PARAM_2], &length);
379 
380     OH_AVTranscoder_Config *config = OH_AVTranscoderConfig_Create();
381     OH_AVTranscoderConfig_SetSrcFD(config, srcFd, srcOffset, length);
382     int fileDescribe = open(DST_ERROR_PATH, O_CREAT | O_RDWR, PARAM_0666);
383     OH_AVTranscoderConfig_SetDstFD(config, fileDescribe);
384     OH_AVTranscoderConfig_SetDstFileType(config, AV_OUTPUT_FORMAT_MPEG_4);
385     OH_AVErrCode err = OH_AVTranscoder_Prepare(nullptr, config);
386     backParam = err;
387     LOG("Transcoder OhAvTransCoderPrepareParamError2 ret %{public}d", backParam);
388     napi_create_int32(env, backParam, &result);
389     close(fileDescribe);
390     return result;
391 }
392 
OhAvTransCoderParamError(napi_env env,napi_callback_info info)393 static napi_value OhAvTransCoderParamError(napi_env env, napi_callback_info info)
394 {
395     napi_value result = nullptr;
396     int backParam = FAIL;
397     size_t argc = PARAM_1;
398     napi_value args[PARAM_1] = {nullptr};
399     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
400     size_t bufsize = 0;
401     napi_get_value_string_utf8(env, args[PARAM_0], nullptr, 0, &bufsize);
402     if (bufsize > 0) {
403         char *buffer = new char[bufsize + 1];
404         napi_get_value_string_utf8(env, args[PARAM_0], buffer, bufsize + 1, nullptr);
405         if (std::strcmp(buffer, "Start") == 0) {
406             backParam = OH_AVTranscoder_Start(nullptr);
407         } else if (std::strcmp(buffer, "Pause") == 0) {
408             backParam = OH_AVTranscoder_Pause(nullptr);
409         } else if (std::strcmp(buffer, "Resume") == 0) {
410             backParam = OH_AVTranscoder_Resume(nullptr);
411         } else if (std::strcmp(buffer, "Cancel") == 0) {
412             backParam = OH_AVTranscoder_Cancel(nullptr);
413         } else if (std::strcmp(buffer, "Release") == 0) {
414             backParam = OH_AVTranscoder_Release(nullptr);
415         }
416         delete[] buffer;
417     }
418     LOG("Transcoder OhAvTransCoderParamError ret %{public}d", backParam);
419     napi_create_int32(env, backParam, &result);
420     return result;
421 }
422 
OhAvTransCoderOperateError(napi_env env,napi_callback_info info)423 static napi_value OhAvTransCoderOperateError(napi_env env, napi_callback_info info)
424 {
425     napi_value result = nullptr;
426     int backParam = FAIL;
427 
428     size_t argc = PARAM_1;
429     napi_value args[PARAM_1] = {nullptr};
430     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
431     OH_AVTranscoder *transcoder = OH_AVTranscoder_Create();
432 
433     size_t bufsize = 0;
434     napi_get_value_string_utf8(env, args[PARAM_0], nullptr, 0, &bufsize);
435     if (bufsize > 0) {
436         char *buffer = new char[bufsize + 1];
437         napi_get_value_string_utf8(env, args[PARAM_0], buffer, bufsize + 1, nullptr);
438         if (std::strcmp(buffer, "Start") == 0) {
439             backParam = OH_AVTranscoder_Start(transcoder);
440         } else if (std::strcmp(buffer, "Pause") == 0) {
441             backParam = OH_AVTranscoder_Pause(transcoder);
442         } else if (std::strcmp(buffer, "Resume") == 0) {
443             backParam = OH_AVTranscoder_Resume(transcoder);
444         } else if (std::strcmp(buffer, "Cancel") == 0) {
445             backParam = OH_AVTranscoder_Cancel(transcoder);
446         }
447         delete[] buffer;
448     }
449 
450     LOG("Transcoder OhAvTransCoderOperateError ret %{public}d", backParam);
451     napi_create_int32(env, backParam, &result);
452     OH_AVTranscoder_Release(transcoder);
453     return result;
454 }
455 
OhAvTransCoderNdkPrepareNotPermit(napi_env env,napi_callback_info info)456 static napi_value OhAvTransCoderNdkPrepareNotPermit(napi_env env, napi_callback_info info)
457 {
458     napi_value result = nullptr;
459     int32_t srcFd = PARAM_0;
460     int64_t srcOffset = PARAM_0;
461     int64_t length = PARAM_0;
462     int32_t dstFd = PARAM_0;
463     parseBasicArgs(env, info, &srcFd, &srcOffset, &length, &dstFd);
464 
465     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
466     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
467     OH_AVErrCode errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
468     if (errCode != AV_ERR_OK) {
469         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
470         napi_create_int32(env, errCode, &result);
471         delete transcoderUser;
472         return result;
473     }
474     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
475     if (errCode != AV_ERR_OK) {
476         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
477         napi_create_int32(env, errCode, &result);
478         delete transcoderUser;
479         return result;
480     }
481     int32_t ret = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_STARTED);
482     if (ret != AV_ERR_OK) {
483         LOGE("waitAvTransCoderStateChange failed, error code: %{public}d", ret);
484         napi_create_int32(env, ret, &result);
485         delete transcoderUser;
486         return result;
487     }
488     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
489     LOG("Transcoder OhAvTransCoderNdkPrepareNotPermit ret %{public}d", errCode);
490     napi_create_int32(env, errCode, &result);
491     delete transcoderUser;
492     return result;
493 }
494 
OhAvTransCoderNdkCancelled(napi_env env,napi_callback_info info)495 static napi_value OhAvTransCoderNdkCancelled(napi_env env, napi_callback_info info)
496 {
497     napi_value result = nullptr;
498     int backParam = FAIL;
499     int32_t srcFd = PARAM_0;
500     int64_t srcOffset = PARAM_0;
501     int64_t length = PARAM_0;
502     int32_t dstFd = PARAM_0;
503     parseBasicArgs(env, info, &srcFd, &srcOffset, &length, &dstFd);
504     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
505     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
506     transcoderUser->stateChangeFuncs_ = {
507         { AVTRANSCODER_PREPARED,
508             [transcoderUser]() {
509                 OH_AVErrCode errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
510                 transcoderUser->errorCode = errCode;
511                 LOG("OH_AVTranscoder_Start errCode:%{public}d", errCode);
512             }
513         },
514         { AVTRANSCODER_STARTED,
515             [transcoderUser]() {
516                 OH_AVErrCode errCode = OH_AVTranscoder_Pause(transcoderUser->transcoder);
517                 transcoderUser->errorCode = errCode;
518                 LOG("OH_AVTranscoder_Pause errCode:%{public}d", errCode);
519             }
520         },
521         { AVTRANSCODER_PAUSED,
522             [transcoderUser]() {
523                 OH_AVErrCode errCode = OH_AVTranscoder_Cancel(transcoderUser->transcoder);
524                 transcoderUser->errorCode = errCode;
525                 LOG("OH_AVTranscoder_Cancel errCode:%{public}d", errCode);
526             }
527         }
528     };
529     OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
530     while (transcoderUser->transCoderState != AVTRANSCODER_CANCELLED) {
531         LOG("Transcoder OhAvTransCoderNdkCancelled current state: %{public}d", transcoderUser->transCoderState);
532         std::this_thread::sleep_for(std::chrono::milliseconds(g_gDelytime200));
533     }
534     backParam = SUCCESS;
535     LOG("Transcoder OhAvTransCoderNdkCancelled ret %{public}d", backParam);
536     napi_create_int32(env, backParam, &result);
537     delete transcoderUser;
538     return result;
539 }
540 
OhAvTransCoderSetStateCbError(napi_env env,napi_callback_info info)541 static napi_value OhAvTransCoderSetStateCbError(napi_env env, napi_callback_info info)
542 {
543     napi_value result = nullptr;
544     int backParam = FAIL;
545     OH_AVErrCode err = OH_AVTranscoder_SetStateCallback(nullptr, AvTransCoderStateChangeCbImpl, nullptr);
546     backParam = err;
547     LOG("Transcoder OhAvTransCoderSetStateCbError ret %{public}d", backParam);
548     napi_create_int32(env, backParam, &result);
549     return result;
550 }
551 
OhAvTransCoderSetErrorCbError(napi_env env,napi_callback_info info)552 static napi_value OhAvTransCoderSetErrorCbError(napi_env env, napi_callback_info info)
553 {
554     napi_value result = nullptr;
555     int backParam = FAIL;
556     OH_AVErrCode err = OH_AVTranscoder_SetErrorCallback(nullptr, AvTransCoderErrorCbImpl, nullptr);
557     backParam = err;
558     LOG("Transcoder OhAvTransCoderSetErrorCbError ret %{public}d", backParam);
559     napi_create_int32(env, backParam, &result);
560     return result;
561 }
562 
OhAvTransCoderSetProgressUpdateCbError(napi_env env,napi_callback_info info)563 static napi_value OhAvTransCoderSetProgressUpdateCbError(napi_env env, napi_callback_info info)
564 {
565     napi_value result = nullptr;
566     int backParam = FAIL;
567     OH_AVErrCode err = OH_AVTranscoder_SetProgressUpdateCallback(nullptr, AvTransCoderProgressUpdateCbImpl, nullptr);
568     backParam = err;
569     LOG("Transcoder OhAvTransCoderSetProgressUpdateCbError ret %{public}d", backParam);
570     napi_create_int32(env, backParam, &result);
571     return result;
572 }
573 
OhAvTransCoderNdkProgressUpdateCb(napi_env env,napi_callback_info info)574 static napi_value OhAvTransCoderNdkProgressUpdateCb(napi_env env, napi_callback_info info)
575 {
576     napi_value result = nullptr;
577     int backParam = FAIL;
578     int32_t srcFd = PARAM_0;
579     int64_t srcOffset = PARAM_0;
580     int64_t length = PARAM_0;
581     int32_t dstFd = PARAM_0;
582     parseBasicArgs(env, info, &srcFd, &srcOffset, &length, &dstFd);
583 
584     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
585     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
586     transcoderUser->stateChangeFuncs_ = {
587         { AVTRANSCODER_PREPARED,
588             [transcoderUser]() {
589                 OH_AVErrCode errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
590                 transcoderUser->errorCode = errCode;
591                 LOG("OH_AVTranscoder_Start errCode:%{public}d", errCode);
592             }
593         },
594     };
595     OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
596     while (transcoderUser->progress != MAX_PROGRESS) {
597         LOG("Transcoder OhAvTransCoderNdkProgressUpdateCb current progress: %{public}d", transcoderUser->progress);
598         std::this_thread::sleep_for(std::chrono::milliseconds(g_gDelytime200));
599     }
600     backParam = SUCCESS;
601     LOG("Transcoder OhAvTransCoderNdkProgressUpdateCb ret %{public}d", backParam);
602     napi_create_int32(env, backParam, &result);
603     delete transcoderUser;
604     return result;
605 }
606 
OhAvTransCoderConfigSetSrcFDError(napi_env env,napi_callback_info info)607 static napi_value OhAvTransCoderConfigSetSrcFDError(napi_env env, napi_callback_info info)
608 {
609     napi_value result = nullptr;
610     int backParam = FAIL;
611 
612     size_t argc = PARAM_3;
613     napi_value args[PARAM_3] = {nullptr};
614     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
615     int32_t srcFd = PARAM_0;
616     napi_get_value_int32(env, args[PARAM_0], &srcFd);
617     int64_t srcOffset = PARAM_0;
618     napi_get_value_int64(env, args[PARAM_1], &srcOffset);
619     int64_t length = PARAM_0;
620     napi_get_value_int64(env, args[PARAM_2], &length);
621 
622     OH_AVTranscoder *transcoder = OH_AVTranscoder_Create();
623 
624     OH_AVTranscoder_Config *config = OH_AVTranscoderConfig_Create();
625     OH_AVErrCode errCode = OH_AVTranscoderConfig_SetSrcFD(config, srcFd, srcOffset, length);
626     int fileDescribe = open(DST_ERROR_PATH, O_CREAT | O_RDWR, PARAM_0666);
627     OH_AVTranscoderConfig_SetDstFD(config, fileDescribe);
628     OH_AVTranscoderConfig_SetDstFileType(config, AV_OUTPUT_FORMAT_MPEG_4);
629     LOG("TranscoderConfig OH_AVTranscoderConfig_SetSrcFD ret %{public}d", errCode);
630     if (errCode == AV_ERR_OK) {
631         backParam = OH_AVTranscoder_Prepare(transcoder, config);
632     } else {
633         backParam = errCode;
634     }
635     LOG("TranscoderConfig OhAvTransCoderConfigSetSrcFDError ret %{public}d", backParam);
636     napi_create_int32(env, backParam, &result);
637     OH_AVTranscoderConfig_Release(config);
638     OH_AVTranscoder_Release(transcoder);
639     close(fileDescribe);
640     return result;
641 }
642 
OhAvTransCoderConfigSetDstFDError(napi_env env,napi_callback_info info)643 static napi_value OhAvTransCoderConfigSetDstFDError(napi_env env, napi_callback_info info)
644 {
645     napi_value result = nullptr;
646     int backParam = FAIL;
647 
648     size_t argc = PARAM_1;
649     napi_value args[PARAM_1] = {nullptr};
650     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
651     int32_t dstFd = PARAM_0;
652     napi_get_value_int32(env, args[PARAM_0], &dstFd);
653     OH_AVTranscoder_Config *config = OH_AVTranscoderConfig_Create();
654     backParam = OH_AVTranscoderConfig_SetDstFD(config, dstFd);
655     LOG("TranscoderConfig OH_AVTranscoderConfig_SetSrcFD ret %{public}d", backParam);
656     napi_create_int32(env, backParam, &result);
657     OH_AVTranscoderConfig_Release(config);
658     return result;
659 }
660 
OhAvTransCoderConfigParamError(napi_env env,napi_callback_info info)661 static napi_value OhAvTransCoderConfigParamError(napi_env env, napi_callback_info info)
662 {
663     napi_value result = nullptr;
664     int backParam = FAIL;
665     size_t argc = PARAM_2;
666     napi_value args[PARAM_2] = {nullptr};
667     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
668     int32_t paramNum = PARAM_0;
669     napi_get_value_int32(env, args[PARAM_1], &paramNum);
670 
671     size_t bufsize = 0;
672     napi_get_value_string_utf8(env, args[PARAM_0], nullptr, 0, &bufsize);
673     OH_AVTranscoder_Config *config = OH_AVTranscoderConfig_Create();
674     if (bufsize > 0) {
675         char *buffer = new char[bufsize + 1];
676         napi_get_value_string_utf8(env, args[PARAM_0], buffer, bufsize + 1, nullptr);
677         if (std::strcmp(buffer, "SetSrcFD") == 0) {
678             backParam = OH_AVTranscoderConfig_SetSrcFD(nullptr, PARAM_1, PARAM_1, PARAM_1);
679         } else if (std::strcmp(buffer, "SetDstFD") == 0) {
680             backParam = OH_AVTranscoderConfig_SetDstFD(nullptr, PARAM_1);
681         } else if (std::strcmp(buffer, "SetDstVideoType") == 0) {
682             if (paramNum == 0) {
683                 backParam = OH_AVTranscoderConfig_SetDstVideoType(nullptr, "video/avc");
684             } else {
685                 backParam = OH_AVTranscoderConfig_SetDstVideoType(config, nullptr);
686             }
687         } else if (std::strcmp(buffer, "SetDstAudioType") == 0) {
688             if (paramNum == 0) {
689                 backParam = OH_AVTranscoderConfig_SetDstAudioType(nullptr, "audio/mp4a-latm");
690             } else {
691                 backParam = OH_AVTranscoderConfig_SetDstAudioType(config, nullptr);
692             }
693         } else if (std::strcmp(buffer, "SetDstFileType") == 0) {
694             backParam = OH_AVTranscoderConfig_SetDstFileType(nullptr, AV_OUTPUT_FORMAT_MPEG_4);
695         } else if (std::strcmp(buffer, "SetDstAudioBitrate") == 0) {
696             backParam = OH_AVTranscoderConfig_SetDstAudioBitrate(nullptr, DEFAULT_AUDIOBITRATE);
697         } else if (std::strcmp(buffer, "SetDstVideoBitrate") == 0) {
698             backParam = OH_AVTranscoderConfig_SetDstVideoBitrate(nullptr, DEFAULT_VIDEOBITRATE);
699         } else if (std::strcmp(buffer, "SetDstVideoResolution") == 0) {
700             backParam = OH_AVTranscoderConfig_SetDstVideoResolution(nullptr, DEFAULT_WIDTH, DEFAULT_HEIGTH);
701         } else if (std::strcmp(buffer, "Release") == 0) {
702             backParam = OH_AVTranscoderConfig_Release(nullptr);
703         }
704         delete[] buffer;
705     }
706     LOG("Transcoder OhAvTransCoderParamError ret %{public}d", backParam);
707     napi_create_int32(env, backParam, &result);
708     OH_AVTranscoderConfig_Release(config);
709     return result;
710 }
711 
parseBasicArgsWithInt(napi_env env,napi_callback_info info,int32_t * srcFd,int64_t * srcOffset,int64_t * length,int32_t * dstFd,int32_t * number)712 void parseBasicArgsWithInt(napi_env env, napi_callback_info info,
713     int32_t *srcFd, int64_t *srcOffset, int64_t *length, int32_t *dstFd, int32_t *number)
714 {
715     size_t argc = PARAM_5;
716     napi_value args[PARAM_5] = {nullptr};
717     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
718     napi_get_value_int32(env, args[PARAM_0], srcFd);
719     napi_get_value_int64(env, args[PARAM_1], srcOffset);
720     napi_get_value_int64(env, args[PARAM_2], length);
721     napi_get_value_int32(env, args[PARAM_3], dstFd);
722     napi_get_value_int32(env, args[PARAM_4], number);
723 }
724 
parseBasicArgsWithString(napi_env env,napi_callback_info info,int32_t * srcFd,int64_t * srcOffset,int64_t * length,int32_t * dstFd,size_t * bufsize,char ** buffer)725 void parseBasicArgsWithString(napi_env env, napi_callback_info info,
726     int32_t *srcFd, int64_t *srcOffset, int64_t *length, int32_t *dstFd, size_t *bufsize, char **buffer)
727 {
728     size_t argc = PARAM_5;
729     napi_value args[PARAM_5] = {nullptr};
730     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
731     napi_get_value_int32(env, args[PARAM_0], srcFd);
732     napi_get_value_int64(env, args[PARAM_1], srcOffset);
733     napi_get_value_int64(env, args[PARAM_2], length);
734     napi_get_value_int32(env, args[PARAM_3], dstFd);
735     napi_get_value_string_utf8(env, args[PARAM_4], nullptr, 0, bufsize);
736     *buffer = new char[*bufsize + 1];
737     napi_status status = napi_get_value_string_utf8(env, args[PARAM_4], *buffer, *bufsize + 1, nullptr);
738     if (status != napi_ok) {
739         delete[] *buffer;
740         *buffer = nullptr;
741         return;
742     }
743 }
OhAvTransCodeConfigSetDstVideoType(napi_env env,napi_callback_info info)744 static napi_value OhAvTransCodeConfigSetDstVideoType(napi_env env, napi_callback_info info)
745 {
746     napi_value result = nullptr;
747     OH_AVErrCode errCode = AV_ERR_OK;
748     int32_t srcFd = PARAM_0;
749     int64_t srcOffset = PARAM_0;
750     int64_t length = PARAM_0;
751     int32_t dstFd = PARAM_0;
752     char *buffer = nullptr;
753     size_t bufsize = PARAM_0;
754     parseBasicArgsWithString(env, info, &srcFd, &srcOffset, &length, &dstFd, &bufsize, &buffer);
755 
756     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
757     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
758     LOG("Transcoder OhAvTransCodeConfigSetDstVideoType video type size: %{public}d, type: %{public}s", bufsize, buffer);
759     if (bufsize > 0) {
760         errCode = OH_AVTranscoderConfig_SetDstVideoType(transcoderUser->config, buffer);
761     } else {
762         errCode = OH_AVTranscoderConfig_SetDstVideoType(transcoderUser->config, "");
763     }
764     if (errCode != AV_ERR_OK) {
765         LOGE("OH_AVTranscoderConfig_SetDstVideoType failed, error code: %{public}d", errCode);
766         napi_create_int32(env, errCode, &result);
767         delete[] buffer;
768         delete transcoderUser;
769         return result;
770     }
771     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
772     if (errCode != AV_ERR_OK) {
773         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
774         napi_create_int32(env, errCode, &result);
775         delete[] buffer;
776         delete transcoderUser;
777         return result;
778     }
779     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
780     if (errCode != AV_ERR_OK) {
781         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
782         napi_create_int32(env, errCode, &result);
783         delete[] buffer;
784         delete transcoderUser;
785         return result;
786     }
787     int32_t backParam = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_COMPLETED);
788     LOG("Transcoder OhAvTransCodeConfigSetDstVideoType ret %{public}d", backParam);
789     napi_create_int32(env, backParam, &result);
790     delete[] buffer;
791     delete transcoderUser;
792     return result;
793 }
794 
OhAvTransCodeConfigSetDstAudioType(napi_env env,napi_callback_info info)795 static napi_value OhAvTransCodeConfigSetDstAudioType(napi_env env, napi_callback_info info)
796 {
797     napi_value result = nullptr;
798     int32_t srcFd = PARAM_0;
799     int64_t srcOffset = PARAM_0;
800     int64_t length = PARAM_0;
801     int32_t dstFd = PARAM_0;
802     char *buffer = nullptr;
803     size_t bufsize = PARAM_0;
804     parseBasicArgsWithString(env, info, &srcFd, &srcOffset, &length, &dstFd, &bufsize, &buffer);
805     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
806     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
807     OH_AVErrCode errCode = AV_ERR_OK;
808     if (bufsize > 0) {
809         errCode = OH_AVTranscoderConfig_SetDstAudioType(transcoderUser->config, buffer);
810     } else {
811         errCode = OH_AVTranscoderConfig_SetDstAudioType(transcoderUser->config, "");
812     }
813     if (errCode != AV_ERR_OK) {
814         LOGE("OH_AVTranscoderConfig_SetDstAudioType failed, error code: %{public}d", errCode);
815         napi_create_int32(env, errCode, &result);
816         delete[] buffer;
817         delete transcoderUser;
818         return result;
819     }
820     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
821     if (errCode != AV_ERR_OK) {
822         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
823         napi_create_int32(env, errCode, &result);
824         delete[] buffer;
825         delete transcoderUser;
826         return result;
827     }
828     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
829     if (errCode != AV_ERR_OK) {
830         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
831         napi_create_int32(env, errCode, &result);
832         delete[] buffer;
833         delete transcoderUser;
834         return result;
835     }
836     int32_t ret = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_COMPLETED);
837     LOG("Transcoder OhAvTransCodeConfigSetDstAudioType ret %{public}d", ret);
838     napi_create_int32(env, ret, &result);
839     delete[] buffer;
840     delete transcoderUser;
841     return result;
842 }
843 
OhAvTransCodeConfigSetDstFileType(napi_env env,napi_callback_info info)844 static napi_value OhAvTransCodeConfigSetDstFileType(napi_env env, napi_callback_info info)
845 {
846     napi_value result = nullptr;
847     int32_t srcFd = PARAM_0;
848     int64_t srcOffset = PARAM_0;
849     int64_t length = PARAM_0;
850     int32_t dstFd = PARAM_0;
851     int32_t format = PARAM_0;
852     parseBasicArgsWithInt(env, info, &srcFd, &srcOffset, &length, &dstFd, &format);
853 
854     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
855     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
856     OH_AVErrCode errCode = AV_ERR_OK;
857     LOG("Transcoder OhAvTransCodeConfigSetDstFileType format: %{public}d", format);
858     OH_AVOutputFormat mimeType = static_cast<OH_AVOutputFormat>(format);
859     errCode = OH_AVTranscoderConfig_SetDstFileType(transcoderUser->config, mimeType);
860     if (errCode != AV_ERR_OK) {
861         LOGE("OH_AVTranscoderConfig_SetDstFileType failed, error code: %{public}d", errCode);
862         napi_create_int32(env, errCode, &result);
863         delete transcoderUser;
864         return result;
865     }
866     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
867     if (errCode != AV_ERR_OK) {
868         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
869         napi_create_int32(env, errCode, &result);
870         delete transcoderUser;
871         return result;
872     }
873     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
874     if (errCode != AV_ERR_OK) {
875         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
876         napi_create_int32(env, errCode, &result);
877         delete transcoderUser;
878         return result;
879     }
880     int32_t backParam = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_COMPLETED);
881     LOG("Transcoder OhAvTransCodeConfigSetDstFileType ret %{public}d", backParam);
882     napi_create_int32(env, backParam, &result);
883     delete transcoderUser;
884     return result;
885 }
886 
OhAvTransCodeConfigEnableBFrame(napi_env env,napi_callback_info info)887 static napi_value OhAvTransCodeConfigEnableBFrame(napi_env env, napi_callback_info info)
888 {
889     napi_value result = nullptr;
890     int32_t srcFd = PARAM_0;
891     int64_t srcOffset = PARAM_0;
892     int64_t length = PARAM_0;
893     int32_t dstFd = PARAM_0;
894     bool enableBFrame = false;
895     size_t argc = PARAM_5;
896     napi_value args[PARAM_5] = {nullptr};
897     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
898     napi_get_value_int32(env, args[PARAM_0], &srcFd);
899     napi_get_value_int64(env, args[PARAM_1], &srcOffset);
900     napi_get_value_int64(env, args[PARAM_2], &length);
901     napi_get_value_int32(env, args[PARAM_3], &dstFd);
902     napi_get_value_bool(env, args[PARAM_4], &enableBFrame);
903     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
904     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
905     OH_AVErrCode errCode = OH_AVTranscoderConfig_EnableBFrame(transcoderUser->config, enableBFrame);
906     if (errCode != AV_ERR_OK) {
907         LOGE("OH_AVTranscoderConfig_EnableBFrame failed, error code: %{public}d", errCode);
908         napi_create_int32(env, errCode, &result);
909         delete transcoderUser;
910         return result;
911     }
912     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
913     if (errCode != AV_ERR_OK) {
914         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
915         napi_create_int32(env, errCode, &result);
916         delete transcoderUser;
917         return result;
918     }
919     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
920     if (errCode != AV_ERR_OK) {
921         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
922         napi_create_int32(env, errCode, &result);
923         delete transcoderUser;
924         return result;
925     }
926     int32_t backParam = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_COMPLETED);
927     LOG("Transcoder OhAvTransCodeConfigEnableBFrame ret %{public}d", backParam);
928     napi_create_int32(env, backParam, &result);
929     delete transcoderUser;
930     return result;
931 }
932 
OhAvTransCodeConfigSetDstFileTypeError(napi_env env,napi_callback_info info)933 static napi_value OhAvTransCodeConfigSetDstFileTypeError(napi_env env, napi_callback_info info)
934 {
935     napi_value result = nullptr;
936     napi_create_object(env, &result);
937     int32_t srcFd = PARAM_0;
938     int64_t srcOffset = PARAM_0;
939     int64_t length = PARAM_0;
940     int32_t dstFd = PARAM_0;
941     int32_t format = PARAM_0;
942     parseBasicArgsWithInt(env, info, &srcFd, &srcOffset, &length, &dstFd, &format);
943 
944     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
945     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
946     OH_AVErrCode errCode = AV_ERR_OK;
947     LOG("Transcoder OhAvTransCodeConfigSetDstFileType format: %{public}d", format);
948     OH_AVOutputFormat mimeType = static_cast<OH_AVOutputFormat>(format);
949     errCode = OH_AVTranscoderConfig_SetDstFileType(transcoderUser->config, mimeType);
950     if (errCode != AV_ERR_OK) {
951         LOGE("OH_AVTranscoderConfig_SetDstFileType failed, error code: %{public}d", errCode);
952         SetInt32NamedProperty(env, result, "result", errCode);
953         delete transcoderUser;
954         transcoderUser = nullptr;
955         return result;
956     }
957     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
958     if (errCode != AV_ERR_OK) {
959         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
960         SetInt32NamedProperty(env, result, "result", errCode);
961         delete transcoderUser;
962         transcoderUser = nullptr;
963         return result;
964     }
965     SetInt32NamedProperty(env, result, "result", errCode);
966     SetUserNamedProperty(env, result, "userData", &transcoderUser);
967     return result;
968 }
969 
OhCheckAvTransCoderCallBackError(napi_env env,napi_callback_info info)970 static napi_value OhCheckAvTransCoderCallBackError(napi_env env, napi_callback_info info)
971 {
972     napi_value result = nullptr;
973     int backParam = FAIL;
974     size_t argc = 1;
975     napi_value args[1] = {nullptr};
976     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
977     void *ptr = nullptr;
978     napi_get_value_external(env, args[0], &ptr);
979     NdkAVTransCoderUser *transcoderUser = reinterpret_cast<NdkAVTransCoderUser *>(ptr);
980     if (transcoderUser->callbackError != AV_ERR_UNKNOWN && transcoderUser->callbackError != AV_ERR_OK) {
981         LOGE("OhCheckAvTransCoderCallBackError, error code: %{public}d", transcoderUser->callbackError);
982         backParam = transcoderUser->callbackError;
983         delete transcoderUser;
984         transcoderUser = nullptr;
985     }
986     napi_create_int32(env, backParam, &result);
987     return result;
988 }
989 
OhAvTransCodeConfigSetDstVideoBitrate(napi_env env,napi_callback_info info)990 static napi_value OhAvTransCodeConfigSetDstVideoBitrate(napi_env env, napi_callback_info info)
991 {
992     napi_value result = nullptr;
993     int32_t srcFd = PARAM_0;
994     int64_t srcOffset = PARAM_0;
995     int64_t length = PARAM_0;
996     int32_t dstFd = PARAM_0;
997     int32_t videoBitrate = PARAM_0;
998     parseBasicArgsWithInt(env, info, &srcFd, &srcOffset, &length, &dstFd, &videoBitrate);
999 
1000     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
1001     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
1002     LOG("TranscoderConfig OhAvTransCodeConfigSetDstVideoBitrate audioBitrate: %{public}d", videoBitrate);
1003     OH_AVErrCode errCode = OH_AVTranscoderConfig_SetDstVideoBitrate(transcoderUser->config, videoBitrate);
1004     if (errCode != AV_ERR_OK) {
1005         LOGE("OH_AVTranscoderConfig_SetDstVideoBitrate failed, error code: %{public}d", errCode);
1006         napi_create_int32(env, errCode, &result);
1007         delete transcoderUser;
1008         return result;
1009     }
1010     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
1011     if (errCode != AV_ERR_OK) {
1012         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
1013         napi_create_int32(env, errCode, &result);
1014         delete transcoderUser;
1015         return result;
1016     }
1017     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
1018     if (errCode != AV_ERR_OK) {
1019         LOGE("OH_AVTranscoder_Start failed, error code: %{public}d", errCode);
1020         napi_create_int32(env, errCode, &result);
1021         delete transcoderUser;
1022         return result;
1023     }
1024     int32_t backParam = waitAvTransCoderStateChange(transcoderUser, AVTRANSCODER_COMPLETED);
1025     LOG("Transcoder OhAvTransCodeConfigSetDstVideoBitrate ret %{public}d", backParam);
1026     napi_create_int32(env, backParam, &result);
1027     delete transcoderUser;
1028     return result;
1029 }
1030 
OhAvTransCodeConfigSetDstAudioBitrate(napi_env env,napi_callback_info info)1031 static napi_value OhAvTransCodeConfigSetDstAudioBitrate(napi_env env, napi_callback_info info)
1032 {
1033     napi_value result = nullptr;
1034     napi_create_object(env, &result);
1035     int32_t srcFd = PARAM_0;
1036     int64_t srcOffset = PARAM_0;
1037     int64_t length = PARAM_0;
1038     int32_t dstFd = PARAM_0;
1039     int32_t audioBitrate = PARAM_0;
1040     parseBasicArgsWithInt(env, info, &srcFd, &srcOffset, &length, &dstFd, &audioBitrate);
1041 
1042     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
1043     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
1044     LOG("TranscoderConfig OhAvTransCodeConfigSetDstAudioBitrate audioBitrate: %{public}d", audioBitrate);
1045     OH_AVErrCode errCode = OH_AVTranscoderConfig_SetDstAudioBitrate(transcoderUser->config, audioBitrate);
1046     if (errCode != AV_ERR_OK) {
1047         LOGE("OH_AVTranscoderConfig_SetDstAudioBitrate failed, error code: %{public}d", errCode);
1048         SetInt32NamedProperty(env, result, "result", errCode);
1049         delete transcoderUser;
1050         transcoderUser = nullptr;
1051         return result;
1052     }
1053     errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
1054     if (errCode != AV_ERR_OK) {
1055         LOGE("OH_AVTranscoder_Prepare failed, error code: %{public}d", errCode);
1056         SetInt32NamedProperty(env, result, "result", errCode);
1057         delete transcoderUser;
1058         transcoderUser = nullptr;
1059         return result;
1060     }
1061     errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
1062     LOG("Transcoder OhAvTransCodeConfigSetDstAudioBitrate OH_AVTranscoder_Start ret %{public}d", errCode);
1063     SetInt32NamedProperty(env, result, "result", errCode);
1064     SetUserNamedProperty(env, result, "userData", &transcoderUser);
1065     return result;
1066 }
1067 
OhAvTransCodeConfigSetDstVideoResolution(napi_env env,napi_callback_info info)1068 static napi_value OhAvTransCodeConfigSetDstVideoResolution(napi_env env, napi_callback_info info)
1069 {
1070     napi_value result = nullptr;
1071     int backParam = FAIL;
1072     size_t argc = PARAM_6;
1073     napi_value args[PARAM_6] = {nullptr};
1074     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1075     int32_t srcFd = PARAM_0;
1076     napi_get_value_int32(env, args[PARAM_0], &srcFd);
1077     int64_t srcOffset = PARAM_0;
1078     napi_get_value_int64(env, args[PARAM_1], &srcOffset);
1079     int64_t length = PARAM_0;
1080     napi_get_value_int64(env, args[PARAM_2], &length);
1081     int32_t dstFd = PARAM_0;
1082     napi_get_value_int32(env, args[PARAM_3], &dstFd);
1083     int32_t width = PARAM_0;
1084     napi_get_value_int32(env, args[PARAM_4], &width);
1085     int32_t height = PARAM_0;
1086     napi_get_value_int32(env, args[PARAM_5], &height);
1087 
1088     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
1089     transcoderUser->InitTransCoder(srcFd, srcOffset, length, dstFd);
1090     transcoderUser->stateChangeFuncs_ = {
1091         { AVTRANSCODER_PREPARED,
1092             [transcoderUser]() {
1093                 OH_AVErrCode errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
1094                 transcoderUser->errorCode = errCode;
1095                 LOG("OH_AVTranscoder_Start errCode:%{public}d", errCode);
1096             }
1097         },
1098     };
1099     OH_AVErrCode errCode = AV_ERR_OK;
1100     errCode = OH_AVTranscoderConfig_SetDstVideoResolution(transcoderUser->config, width, height);
1101     if (errCode == AV_ERR_OK) {
1102         errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
1103         if (errCode == AV_ERR_OK) {
1104             while (transcoderUser->transCoderState != AVTRANSCODER_COMPLETED) {
1105                 LOG("Transcoder OhAvTransCodeConfigSetDstVideoResolution current state: %{public}d",
1106                     transcoderUser->transCoderState);
1107                 std::this_thread::sleep_for(std::chrono::milliseconds(g_gDelytime200));
1108             }
1109             backParam = SUCCESS;
1110         } else {
1111             backParam = errCode;
1112         }
1113     } else {
1114         backParam = errCode;
1115     }
1116     LOG("Transcoder OhAvTransCodeConfigSetDstVideoResolution ret %{public}d", backParam);
1117     napi_create_int32(env, backParam, &result);
1118     delete transcoderUser;
1119     return result;
1120 }
parseSrcArgs(napi_env env,napi_callback_info info,int32_t * srcFd,int64_t * srcOffset,int64_t * length)1121 void parseSrcArgs(napi_env env, napi_callback_info info, int32_t *srcFd, int64_t *srcOffset, int64_t *length)
1122 {
1123     size_t argc = PARAM_3;
1124     napi_value args[PARAM_3] = {nullptr};
1125     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1126     napi_get_value_int32(env, args[PARAM_0], srcFd);
1127     napi_get_value_int64(env, args[PARAM_1], srcOffset);
1128     napi_get_value_int64(env, args[PARAM_2], length);
1129 }
OhAvTransCoderErrorCode(napi_env env,napi_callback_info info)1130 static napi_value OhAvTransCoderErrorCode(napi_env env, napi_callback_info info)
1131 {
1132     napi_value result = nullptr;
1133     int32_t srcFd = PARAM_0;
1134     int64_t srcOffset = PARAM_0;
1135     int64_t length = PARAM_0;
1136     parseSrcArgs(env, info, &srcFd, &srcOffset, &length);
1137     int fileDescribe = open(DST_ERROR_PATH, O_CREAT | O_RDWR, PARAM_0666);
1138     NdkAVTransCoderUser *transcoderUser = new NdkAVTransCoderUser();
1139     transcoderUser->InitTransCoder(srcFd, srcOffset, length, fileDescribe);
1140     OH_AVErrCode errCode = OH_AVTranscoder_Prepare(transcoderUser->transcoder, transcoderUser->config);
1141     if (errCode == AV_ERR_OK) {
1142         LOGE("OH_AVTranscoder_Prepare Success");
1143         if (transcoderUser->callbackError == AV_ERR_UNKNOWN || transcoderUser->callbackError == AV_ERR_OK) {
1144             errCode = OH_AVTranscoder_Start(transcoderUser->transcoder);
1145         } else {
1146             errCode = static_cast<OH_AVErrCode>(transcoderUser->callbackError);
1147         }
1148     }
1149     napi_create_int32(env, errCode, &result);
1150     delete transcoderUser;
1151     close(fileDescribe);
1152     return result;
1153 }
1154 
OhAvPlayerNdkPlayVideo(napi_env env,napi_callback_info info)1155 static napi_value OhAvPlayerNdkPlayVideo(napi_env env, napi_callback_info info)
1156 {
1157     napi_value result = nullptr;
1158     size_t argc = PARAM_2;
1159     napi_value args[PARAM_2] = {nullptr};
1160     napi_get_cb_info(env, info, &argc, args, nullptr, nullptr);
1161     int32_t srcFd = PARAM_0;
1162     napi_get_value_int32(env, args[PARAM_0], &srcFd);
1163     int64_t length = PARAM_0;
1164     napi_get_value_int64(env, args[PARAM_1], &length);
1165 
1166     OH_AVPlayer *player = OH_AVPlayer_Create();
1167     OH_AVPlayer_SetFDSource(player, srcFd, PARAM_0, length);
1168     OH_AVErrCode errCode = OH_AVPlayer_Prepare(player);
1169     napi_create_int32(env, errCode, &result);
1170     OH_AVPlayer_ReleaseSync(player);
1171     return result;
1172 }
1173 
1174 EXTERN_C_START
Init(napi_env env,napi_value exports)1175 static napi_value Init(napi_env env, napi_value exports)
1176 {
1177     napi_property_descriptor desc[] = {
1178     {"AvTransCoderNdkSetResolutionError", nullptr, OhAvTransCoderNdkSetResolutionError, nullptr,
1179         nullptr, nullptr, napi_default, nullptr},
1180     {"AvTransCoderPrepareParamError1", nullptr, OhAvTransCoderPrepareParamError1, nullptr,
1181         nullptr, nullptr, napi_default, nullptr},
1182     {"AvTransCoderPrepareParamError2", nullptr, OhAvTransCoderPrepareParamError2, nullptr,
1183         nullptr, nullptr, napi_default, nullptr},
1184     {"AvTransCoderParamError", nullptr, OhAvTransCoderParamError, nullptr,
1185         nullptr, nullptr, napi_default, nullptr},
1186     {"AvTransCoderOperateError", nullptr, OhAvTransCoderOperateError, nullptr,
1187         nullptr, nullptr, napi_default, nullptr},
1188     {"AvTransCoderNdkCancelled", nullptr, OhAvTransCoderNdkCancelled, nullptr,
1189         nullptr, nullptr, napi_default, nullptr},
1190     {"AvTransCoderSetStateCbError", nullptr, OhAvTransCoderSetStateCbError, nullptr,
1191         nullptr, nullptr, napi_default, nullptr},
1192     {"AvTransCoderSetErrorCbError", nullptr, OhAvTransCoderSetErrorCbError, nullptr,
1193         nullptr, nullptr, napi_default, nullptr},
1194     {"AvTransCoderSetProgressUpdateCbError", nullptr, OhAvTransCoderSetProgressUpdateCbError, nullptr,
1195         nullptr, nullptr, napi_default, nullptr},
1196     {"AvTransCoderNdkProgressUpdateCb", nullptr, OhAvTransCoderNdkProgressUpdateCb, nullptr,
1197         nullptr, nullptr, napi_default, nullptr},
1198     {"AvTransCoderConfigSetSrcFDError", nullptr, OhAvTransCoderConfigSetSrcFDError, nullptr,
1199         nullptr, nullptr, napi_default, nullptr},
1200     {"AvTransCoderConfigParamError", nullptr, OhAvTransCoderConfigParamError, nullptr,
1201         nullptr, nullptr, napi_default, nullptr},
1202     {"AvTransCoderConfigSetDstFDError", nullptr, OhAvTransCoderConfigSetDstFDError, nullptr,
1203         nullptr, nullptr, napi_default, nullptr},
1204     {"AvTransCodeConfigSetDstVideoType", nullptr, OhAvTransCodeConfigSetDstVideoType, nullptr,
1205         nullptr, nullptr, napi_default, nullptr},
1206     {"AvTransCodeConfigSetDstAudioType", nullptr, OhAvTransCodeConfigSetDstAudioType, nullptr,
1207         nullptr, nullptr, napi_default, nullptr},
1208     {"AvTransCodeConfigSetDstFileType", nullptr, OhAvTransCodeConfigSetDstFileType, nullptr,
1209         nullptr, nullptr, napi_default, nullptr},
1210     {"AvTransCodeConfigSetDstAudioBitrate", nullptr, OhAvTransCodeConfigSetDstAudioBitrate, nullptr,
1211         nullptr, nullptr, napi_default, nullptr},
1212     {"AvTransCodeConfigSetDstVideoBitrate", nullptr, OhAvTransCodeConfigSetDstVideoBitrate, nullptr,
1213         nullptr, nullptr, napi_default, nullptr},
1214     {"AvTransCodeConfigEnableBFrame", nullptr, OhAvTransCodeConfigEnableBFrame, nullptr,
1215         nullptr, nullptr, napi_default, nullptr},
1216     {"AvTransCodeConfigSetDstVideoResolution", nullptr, OhAvTransCodeConfigSetDstVideoResolution, nullptr,
1217         nullptr, nullptr, napi_default, nullptr},
1218     {"AvTransCoderErrorCode", nullptr, OhAvTransCoderErrorCode, nullptr,
1219         nullptr, nullptr, napi_default, nullptr},
1220     {"AvTransCoderNdkPrepareNotPermit", nullptr, OhAvTransCoderNdkPrepareNotPermit, nullptr,
1221         nullptr, nullptr, napi_default, nullptr},
1222     {"AvPlayerNdkPlayVideo", nullptr, OhAvPlayerNdkPlayVideo, nullptr,
1223         nullptr, nullptr, napi_default, nullptr},
1224     {"AvTransCoderNdkTest", nullptr, OhAvTransCoderNdkTest, nullptr,
1225         nullptr, nullptr, napi_default, nullptr},
1226     {"CheckAvTransCoderComplete", nullptr, OhCheckAvTransCoderComplete, nullptr,
1227         nullptr, nullptr, napi_default, nullptr},
1228     {"AvTransCodeConfigSetDstFileTypeError", nullptr, OhAvTransCodeConfigSetDstFileTypeError, nullptr,
1229         nullptr, nullptr, napi_default, nullptr},
1230     {"CheckAvTransCoderCallBackError", nullptr, OhCheckAvTransCoderCallBackError, nullptr,
1231         nullptr, nullptr, napi_default, nullptr}
1232     };
1233     napi_define_properties(env, exports, sizeof(desc) / sizeof(desc[0]), desc);
1234     return exports;
1235 }
1236 EXTERN_C_END
1237 
1238 static napi_module demoModule = {
1239     .nm_version = 1,
1240     .nm_flags = 0,
1241     .nm_filename = nullptr,
1242     .nm_register_func = Init,
1243     .nm_modname = "avTransCoderNdk",
1244     .nm_priv = ((void *)0),
1245     .reserved = { 0 },
1246 };
1247 
RegisterEntryModule(void)1248 extern "C" __attribute__((constructor)) void RegisterEntryModule(void)
1249 {
1250     napi_module_register(&demoModule);
1251 }
1252