1 /*
2 * Copyright (C) 2024-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 permissions and
13 * limitations under the License.
14 */
15
16 #include "transcoder_server.h"
17 #include "map"
18 #include "media_log.h"
19 #include "media_errors.h"
20 #include "engine_factory_repo.h"
21 #include "param_wrapper.h"
22 #include "accesstoken_kit.h"
23 #include "ipc_skeleton.h"
24 #include "media_dfx.h"
25
26 namespace {
27 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_PLAYER, "TransCoderServer"};
28 const std::map<OHOS::Media::TransCoderServer::RecStatus, std::string> TRANSCODER_STATE_MAP = {
29 {OHOS::Media::TransCoderServer::REC_INITIALIZED, "initialized"},
30 {OHOS::Media::TransCoderServer::REC_CONFIGURED, "configured"},
31 {OHOS::Media::TransCoderServer::REC_PREPARED, "prepared"},
32 {OHOS::Media::TransCoderServer::REC_TRANSCODERING, "transcordring"},
33 {OHOS::Media::TransCoderServer::REC_PAUSED, "paused"},
34 {OHOS::Media::TransCoderServer::REC_ERROR, "error"},
35 };
36 }
37
38 namespace OHOS {
39 namespace Media {
40 const std::string START_TAG = "TransCoderCreate->Start";
41 const std::string STOP_TAG = "TransCoderStop->Destroy";
42
Create()43 std::shared_ptr<ITransCoderService> TransCoderServer::Create()
44 {
45 std::shared_ptr<TransCoderServer> server = std::make_shared<TransCoderServer>();
46 int32_t ret = server->Init();
47 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, nullptr, "failed to init TransCoderServer");
48 return server;
49 }
50
TransCoderServer()51 TransCoderServer::TransCoderServer()
52 : taskQue_("TranscoderServer")
53 {
54 taskQue_.Start();
55 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances create", FAKE_POINTER(this));
56 instanceId_ = HiviewDFX::HiTraceChain::GetId().GetChainId();
57 }
58
~TransCoderServer()59 TransCoderServer::~TransCoderServer()
60 {
61 std::lock_guard<std::mutex> lock(mutex_);
62 taskQue_.Stop();
63 MEDIA_LOGD("0x%{public}06" PRIXPTR " Instances destroy", FAKE_POINTER(this));
64 }
65
Init()66 int32_t TransCoderServer::Init()
67 {
68 MediaTrace trace("TransCoderServer::Init");
69 uint32_t tokenId = IPCSkeleton::GetCallingTokenID();
70 uint64_t fullTokenId = IPCSkeleton::GetCallingFullTokenID();
71 int32_t appUid = IPCSkeleton::GetCallingUid();
72 int32_t appPid = IPCSkeleton::GetCallingPid();
73
74 auto task = std::make_shared<TaskHandler<MediaServiceErrCode>>([&, this] {
75 auto engineFactory = EngineFactoryRepo::Instance().GetEngineFactory(
76 IEngineFactory::Scene::SCENE_TRANSCODER, appUid);
77 CHECK_AND_RETURN_RET_LOG(engineFactory != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
78 "failed to get factory");
79 transCoderEngine_ = engineFactory->CreateTransCoderEngine(appUid, appPid, tokenId, fullTokenId);
80 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_CREATE_REC_ENGINE_FAILED,
81 "failed to create transCoder engine");
82 transCoderEngine_->SetInstanceId(instanceId_);
83 return MSERR_OK;
84 });
85 int32_t ret = taskQue_.EnqueueTask(task);
86 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
87
88 auto result = task->GetResult();
89 CHECK_AND_RETURN_RET_LOG(result.Value() == MSERR_OK, result.Value(), "Result failed");
90
91 status_ = REC_INITIALIZED;
92 return MSERR_OK;
93 }
94
GetStatusDescription(OHOS::Media::TransCoderServer::RecStatus status)95 const std::string& TransCoderServer::GetStatusDescription(OHOS::Media::TransCoderServer::RecStatus status)
96 {
97 static const std::string ILLEGAL_STATE = "PLAYER_STATUS_ILLEGAL";
98 CHECK_AND_RETURN_RET(status >= OHOS::Media::TransCoderServer::REC_INITIALIZED &&
99 status <= OHOS::Media::TransCoderServer::REC_ERROR, ILLEGAL_STATE);
100
101 return TRANSCODER_STATE_MAP.find(status)->second;
102 }
103
OnError(TransCoderErrorType errorType,int32_t errorCode)104 void TransCoderServer::OnError(TransCoderErrorType errorType, int32_t errorCode)
105 {
106 (void)errorType;
107 std::lock_guard<std::mutex> lock(cbMutex_);
108 lastErrMsg_ = MSErrorToString(static_cast<MediaServiceErrCode>(errorCode));
109 CHECK_AND_RETURN(transCoderCb_ != nullptr);
110 status_ = REC_ERROR;
111 MEDIA_LOGI("receive an error event, errorCode: %{public}d, errorMsg: %{public}s", errorCode, lastErrMsg_.c_str());
112 transCoderCb_->OnError(errorCode, lastErrMsg_);
113 }
114
OnInfo(TransCoderOnInfoType type,int32_t extra)115 void TransCoderServer::OnInfo(TransCoderOnInfoType type, int32_t extra)
116 {
117 std::lock_guard<std::mutex> lock(cbMutex_);
118 CHECK_AND_RETURN(transCoderCb_ != nullptr);
119 transCoderCb_->OnInfo(type, extra);
120 }
121
SetVideoEncoder(VideoCodecFormat encoder)122 int32_t TransCoderServer::SetVideoEncoder(VideoCodecFormat encoder)
123 {
124 std::lock_guard<std::mutex> lock(mutex_);
125 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
126 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
127 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
128 config_.videoCodec = encoder;
129 VideoEnc vidEnc(encoder);
130 MEDIA_LOGD("set video encoder encoder:%{public}d", encoder);
131 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
132 return transCoderEngine_->Configure(vidEnc);
133 });
134 int32_t ret = taskQue_.EnqueueTask(task);
135 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
136
137 auto result = task->GetResult();
138 return result.Value();
139 }
140
SetVideoSize(int32_t width,int32_t height)141 int32_t TransCoderServer::SetVideoSize(int32_t width, int32_t height)
142 {
143 std::lock_guard<std::mutex> lock(mutex_);
144 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
145 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
146 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
147 config_.width = width;
148 config_.height = height;
149 VideoRectangle vidSize(width, height);
150 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
151 return transCoderEngine_->Configure(vidSize);
152 });
153 int32_t ret = taskQue_.EnqueueTask(task);
154 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
155
156 auto result = task->GetResult();
157 return result.Value();
158 }
159
SetVideoEncodingBitRate(int32_t rate)160 int32_t TransCoderServer::SetVideoEncodingBitRate(int32_t rate)
161 {
162 std::lock_guard<std::mutex> lock(mutex_);
163 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
164 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
165 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
166 config_.videoBitRate = rate;
167 VideoBitRate vidBitRate(rate);
168 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
169 return transCoderEngine_->Configure(vidBitRate);
170 });
171 int32_t ret = taskQue_.EnqueueTask(task);
172 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
173
174 auto result = task->GetResult();
175 return result.Value();
176 }
177
SetColorSpace(TranscoderColorSpace colorSpaceFormat)178 int32_t TransCoderServer::SetColorSpace(TranscoderColorSpace colorSpaceFormat)
179 {
180 std::lock_guard<std::mutex> lock(mutex_);
181 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
182 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
183 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
184 config_.colorSpaceFormat = colorSpaceFormat;
185 VideoColorSpace colorSpaceFmt(colorSpaceFormat);
186 MEDIA_LOGD("set color space, format: %{public}d", static_cast<int32_t>(colorSpaceFormat));
187 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
188 return transCoderEngine_->Configure(colorSpaceFmt);
189 });
190 int32_t ret = taskQue_.EnqueueTask(task);
191 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
192
193 auto result = task->GetResult();
194 return result.Value();
195 }
196
SetEnableBFrame(bool enableBFrame)197 int32_t TransCoderServer::SetEnableBFrame(bool enableBFrame)
198 {
199 std::lock_guard<std::mutex> lock(mutex_);
200 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
201 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
202 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
203 config_.enableBFrame = enableBFrame;
204 VideoEnableBFrameEncoding videoEnableBFrameEncoding(enableBFrame);
205 MEDIA_LOGD("SetEnableBFrame: %{public}d", static_cast<int32_t>(enableBFrame));
206 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
207 return transCoderEngine_->Configure(videoEnableBFrameEncoding);
208 });
209 int32_t ret = taskQue_.EnqueueTask(task);
210 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
211
212 auto result = task->GetResult();
213 return result.Value();
214 }
215
SetAudioEncoder(AudioCodecFormat encoder)216 int32_t TransCoderServer::SetAudioEncoder(AudioCodecFormat encoder)
217 {
218 std::lock_guard<std::mutex> lock(mutex_);
219 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
220 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
221 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
222 config_.audioCodec = encoder;
223 AudioEnc audEnc(encoder);
224 MEDIA_LOGD("set audio encoder encoder:%{public}d", encoder);
225 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
226 return transCoderEngine_->Configure(audEnc);
227 });
228 int32_t ret = taskQue_.EnqueueTask(task);
229 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
230
231 auto result = task->GetResult();
232 return result.Value();
233 }
234
SetAudioEncodingBitRate(int32_t bitRate)235 int32_t TransCoderServer::SetAudioEncodingBitRate(int32_t bitRate)
236 {
237 std::lock_guard<std::mutex> lock(mutex_);
238 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
239 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
240 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
241 config_.audioBitRate = bitRate;
242 AudioBitRate audBitRate(bitRate);
243 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
244 return transCoderEngine_->Configure(audBitRate);
245 });
246 int32_t ret = taskQue_.EnqueueTask(task);
247 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
248
249 auto result = task->GetResult();
250 return result.Value();
251 }
252
SetOutputFormat(OutputFormatType format)253 int32_t TransCoderServer::SetOutputFormat(OutputFormatType format)
254 {
255 std::lock_guard<std::mutex> lock(mutex_);
256 CHECK_AND_RETURN_RET_LOG(status_ == REC_INITIALIZED, MSERR_INVALID_OPERATION,
257 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
258 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
259 config_.format = format;
260 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
261 return transCoderEngine_->SetOutputFormat(format);
262 });
263 int32_t ret = taskQue_.EnqueueTask(task);
264 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
265
266 auto result = task->GetResult();
267 ret = result.Value();
268 ChangeStatus((ret == MSERR_OK ? REC_CONFIGURED : REC_INITIALIZED));
269 return ret;
270 }
271
SetInputFile(int32_t fd,int64_t offset,int64_t size)272 int32_t TransCoderServer::SetInputFile(int32_t fd, int64_t offset, int64_t size)
273 {
274 std::lock_guard<std::mutex> lock(mutex_);
275 CHECK_AND_RETURN_RET_LOG(status_ == REC_INITIALIZED, MSERR_INVALID_OPERATION,
276 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
277 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
278 config_.srcFd = fd;
279 config_.srcFdOffset = offset;
280 config_.srcFdSize = size;
281 uriHelper_ = std::make_unique<UriHelper>(fd, offset, size);
282 CHECK_AND_RETURN_RET_LOG(uriHelper_->AccessCheck(UriHelper::URI_READ),
283 MSERR_FILE_ACCESS_FAILED, "Failed to read the fd");
284 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
285 return transCoderEngine_->SetInputFile(uriHelper_->FormattedUri());
286 });
287 int32_t ret = taskQue_.EnqueueTask(task);
288 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
289
290 auto result = task->GetResult();
291 return result.Value();
292 }
293
SetOutputFile(int32_t fd)294 int32_t TransCoderServer::SetOutputFile(int32_t fd)
295 {
296 std::lock_guard<std::mutex> lock(mutex_);
297 CHECK_AND_RETURN_RET_LOG(status_ == REC_INITIALIZED, MSERR_INVALID_OPERATION,
298 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
299 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
300 config_.dstUrl = fd;
301 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
302 return transCoderEngine_->SetOutputFile(fd);
303 });
304 int32_t ret = taskQue_.EnqueueTask(task);
305 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
306
307 auto result = task->GetResult();
308 return result.Value();
309 }
310
SetTransCoderCallback(const std::shared_ptr<TransCoderCallback> & callback)311 int32_t TransCoderServer::SetTransCoderCallback(const std::shared_ptr<TransCoderCallback> &callback)
312 {
313 std::lock_guard<std::mutex> lock(mutex_);
314 CHECK_AND_RETURN_RET_LOG(status_ == REC_INITIALIZED || status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
315 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
316 {
317 std::lock_guard<std::mutex> cbLock(cbMutex_);
318 transCoderCb_ = callback;
319 }
320
321 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
322 std::shared_ptr<ITransCoderEngineObs> obs = shared_from_this();
323 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
324 return transCoderEngine_->SetObs(obs);
325 });
326 int32_t ret = taskQue_.EnqueueTask(task);
327 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
328
329 auto result = task->GetResult();
330 return result.Value();
331 }
332
Prepare()333 int32_t TransCoderServer::Prepare()
334 {
335 std::lock_guard<std::mutex> lock(mutex_);
336 MediaTrace trace("TransCoderServer::Prepare");
337 CHECK_AND_RETURN_RET_LOG(status_ != REC_PREPARED, MSERR_INVALID_OPERATION, "Can not repeat Prepare");
338 CHECK_AND_RETURN_RET_LOG(status_ == REC_CONFIGURED, MSERR_INVALID_OPERATION,
339 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
340 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
341 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
342 return transCoderEngine_->Prepare();
343 });
344 int32_t ret = taskQue_.EnqueueTask(task);
345 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
346
347 auto result = task->GetResult();
348 ret = result.Value();
349 ChangeStatus((ret == MSERR_OK ? REC_PREPARED : REC_ERROR));
350 return ret;
351 }
352
Start()353 int32_t TransCoderServer::Start()
354 {
355 std::lock_guard<std::mutex> lock(mutex_);
356 MediaTrace trace("TransCoderServer::Start");
357 CHECK_AND_RETURN_RET_LOG(status_ != REC_TRANSCODERING, MSERR_INVALID_OPERATION, "Can not repeat Start");
358 CHECK_AND_RETURN_RET_LOG(status_ == REC_PREPARED, MSERR_INVALID_OPERATION,
359 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
360 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
361 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
362 return transCoderEngine_->Start();
363 });
364 int32_t ret = taskQue_.EnqueueTask(task);
365 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
366
367 auto result = task->GetResult();
368 ret = result.Value();
369 ChangeStatus((ret == MSERR_OK ? REC_TRANSCODERING : REC_ERROR));
370 return ret;
371 }
372
Pause()373 int32_t TransCoderServer::Pause()
374 {
375 MediaTrace trace("TransCoderServer::Pause");
376 std::lock_guard<std::mutex> lock(mutex_);
377 CHECK_AND_RETURN_RET_LOG(status_ != REC_PAUSED, MSERR_INVALID_OPERATION, "Can not repeat Pause");
378 CHECK_AND_RETURN_RET_LOG(status_ == REC_TRANSCODERING, MSERR_INVALID_OPERATION,
379 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
380 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
381 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
382 return transCoderEngine_->Pause();
383 });
384 int32_t ret = taskQue_.EnqueueTask(task);
385 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
386
387 auto result = task->GetResult();
388 ret = result.Value();
389 ChangeStatus((ret == MSERR_OK ? REC_PAUSED : REC_ERROR));
390 return ret;
391 }
392
Resume()393 int32_t TransCoderServer::Resume()
394 {
395 MediaTrace trace("TransCoderServer::Resume");
396 std::lock_guard<std::mutex> lock(mutex_);
397 CHECK_AND_RETURN_RET_LOG(status_ != REC_TRANSCODERING, MSERR_INVALID_OPERATION, "Can not repeat Resume");
398 CHECK_AND_RETURN_RET_LOG(status_ == REC_PAUSED, MSERR_INVALID_OPERATION,
399 "invalid status, current status is %{public}s", GetStatusDescription(status_).c_str());
400 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
401 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
402 return transCoderEngine_->Resume();
403 });
404 int32_t ret = taskQue_.EnqueueTask(task);
405 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
406
407 auto result = task->GetResult();
408 ret = result.Value();
409 ChangeStatus((ret == MSERR_OK ? REC_TRANSCODERING : REC_ERROR));
410 return ret;
411 }
412
Cancel()413 int32_t TransCoderServer::Cancel()
414 {
415 std::lock_guard<std::mutex> lock(mutex_);
416 MediaTrace trace("TransCoderServer::Cancel");
417 CHECK_AND_RETURN_RET_LOG(transCoderEngine_ != nullptr, MSERR_NO_MEMORY, "engine is nullptr");
418 CHECK_AND_RETURN_RET_LOG(status_ != REC_ERROR, MSERR_INVALID_OPERATION, "current status is error");
419 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
420 return transCoderEngine_->Cancel();
421 });
422 int32_t ret = taskQue_.EnqueueTask(task);
423 CHECK_AND_RETURN_RET_LOG(ret == MSERR_OK, ret, "EnqueueTask failed");
424
425 auto result = task->GetResult();
426 ret = result.Value();
427 ChangeStatus((ret == MSERR_OK ? REC_INITIALIZED : REC_ERROR));
428 return ret;
429 }
430
Release()431 int32_t TransCoderServer::Release()
432 {
433 std::lock_guard<std::mutex> lock(mutex_);
434 CHECK_AND_RETURN_RET_LOG(!isReleased_, MSERR_OK, "server has been released");
435 ReleaseInner();
436 isReleased_ = true;
437 return MSERR_OK;
438 }
439
ReleaseInner()440 void TransCoderServer::ReleaseInner()
441 {
442 MEDIA_LOGI("ReleaseInner enter");
443 if (transCoderEngine_ == nullptr) {
444 return;
445 }
446 auto task = std::make_shared<TaskHandler<int32_t>>([&, this] {
447 int32_t ret = transCoderEngine_->Cancel();
448 transCoderEngine_ = nullptr;
449 return ret;
450 });
451 (void)taskQue_.EnqueueTask(task);
452 (void)task->GetResult();
453 }
454
ChangeStatus(RecStatus status)455 void TransCoderServer::ChangeStatus(RecStatus status)
456 {
457 CHECK_AND_RETURN_LOG(status_ != REC_ERROR, "status is error");
458 {
459 std::lock_guard<std::mutex> cbLock(cbMutex_);
460 status_ = status;
461 MEDIA_LOGI("current status is %{public}s", GetStatusDescription(status_).c_str());
462 }
463 return;
464 }
465
DumpInfo(int32_t fd)466 int32_t TransCoderServer::DumpInfo(int32_t fd)
467 {
468 std::string dumpString;
469 dumpString += "In TransCoderServer::DumpInfo\n";
470 dumpString += "TransCoderServer current state is: " + std::to_string(status_) + "\n";
471 if (lastErrMsg_.size() != 0) {
472 dumpString += "TransCoderServer last error is: " + lastErrMsg_ + "\n";
473 }
474 dumpString += "TransCoderServer videoCodec is: " + std::to_string(config_.videoCodec) + "\n";
475 dumpString += "TransCoderServer audioCodec is: " + std::to_string(config_.audioCodec) + "\n";
476 dumpString += "TransCoderServer width is: " + std::to_string(config_.width) + "\n";
477 dumpString += "TransCoderServer height is: " + std::to_string(config_.height) + "\n";
478 dumpString += "TransCoderServer bitRate is: " + std::to_string(config_.videoBitRate) + "\n";
479 dumpString += "TransCoderServer audioBitRate is: " + std::to_string(config_.audioBitRate) + "\n";
480 dumpString += "TransCoderServer format is: " + std::to_string(config_.format) + "\n";
481 write(fd, dumpString.c_str(), dumpString.size());
482
483 return MSERR_OK;
484 }
485 } // namespace Media
486 } // namespace OHOS
487