1 /*
2 * Copyright (C) 2024 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 <iostream>
17 #include <set>
18 #include <thread>
19 #include <dlfcn.h>
20 #include <malloc.h>
21 #include "syspara/parameters.h"
22 #include "securec.h"
23 #include "avcodec_trace.h"
24 #include "avcodec_log.h"
25 #include "utils.h"
26 #include "avcodec_codec_name.h"
27 #include "hevc_decoder.h"
28 #include <fstream>
29 #include <cstdarg>
30
31 namespace OHOS {
32 namespace MediaAVCodec {
33 namespace Codec {
34 namespace {
35 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN_FRAMEWORK, "HevcDecoderLoader"};
36 const char *HEVC_DEC_LIB_PATH = "libhevcdec_ohos.z.so";
37 const char *HEVC_DEC_CREATE_FUNC_NAME = "HEVC_CreateDecoder";
38 const char *HEVC_DEC_DECODE_FRAME_FUNC_NAME = "HEVC_DecodeFrame";
39 const char *HEVC_DEC_FLUSH_FRAME_FUNC_NAME = "HEVC_FlushFrame";
40 const char *HEVC_DEC_DELETE_FUNC_NAME = "HEVC_DeleteDecoder";
41
42 constexpr uint32_t INDEX_INPUT = 0;
43 constexpr uint32_t INDEX_OUTPUT = 1;
44 constexpr int32_t DEFAULT_IN_BUFFER_CNT = 4;
45 constexpr int32_t DEFAULT_OUT_SURFACE_CNT = 4;
46 constexpr int32_t DEFAULT_OUT_BUFFER_CNT = 3;
47 constexpr int32_t DEFAULT_MIN_BUFFER_CNT = 2;
48 constexpr int32_t DEFAULT_MAX_BUFFER_CNT = 10;
49 constexpr uint32_t VIDEO_PIX_DEPTH_YUV = 3;
50 constexpr int32_t VIDEO_MIN_BUFFER_SIZE = 1474560; // 1280*768
51 constexpr int32_t VIDEO_MAX_BUFFER_SIZE = 3110400; // 1080p
52 constexpr int32_t VIDEO_MIN_SIZE = 2;
53 constexpr int32_t VIDEO_ALIGNMENT_SIZE = 2;
54 constexpr int32_t VIDEO_MAX_WIDTH_SIZE = 1920;
55 constexpr int32_t VIDEO_MAX_HEIGHT_SIZE = 1920;
56 constexpr int32_t DEFAULT_VIDEO_WIDTH = 1920;
57 constexpr int32_t DEFAULT_VIDEO_HEIGHT = 1080;
58 constexpr uint32_t DEFAULT_TRY_DECODE_TIME = 1;
59 constexpr int32_t VIDEO_INSTANCE_SIZE = 64;
60 constexpr int32_t VIDEO_BLOCKPERFRAME_SIZE = 36864;
61 constexpr int32_t VIDEO_BLOCKPERSEC_SIZE = 983040;
62 #ifdef BUILD_ENG_VERSION
63 constexpr uint32_t PATH_MAX_LEN = 128;
64 constexpr char DUMP_PATH[] = "/data/misc/hevcdecoderdump";
65 #endif
66 constexpr struct {
67 const std::string_view codecName;
68 const std::string_view mimeType;
69 } SUPPORT_HEVC_DECODER[] = {
70 {AVCodecCodecName::VIDEO_DECODER_HEVC_NAME, CodecMimeType::VIDEO_HEVC},
71 };
72 constexpr uint32_t SUPPORT_HEVC_DECODER_NUM = sizeof(SUPPORT_HEVC_DECODER) / sizeof(SUPPORT_HEVC_DECODER[0]);
73 static std::map<uint64_t, int32_t> g_surfaceCntMap;
74 static std::mutex g_surfaceMapMutex;
75 } // namespace
76 using namespace OHOS::Media;
HevcDecoder(const std::string & name)77 HevcDecoder::HevcDecoder(const std::string &name) : codecName_(name), state_(State::UNINITIALIZED)
78 {
79 AVCODEC_SYNC_TRACE;
80 std::unique_lock<std::mutex> lock(decoderCountMutex_);
81 if (!freeIDSet_.empty()) {
82 decInstanceID_ = freeIDSet_[0];
83 freeIDSet_.erase(freeIDSet_.begin());
84 decInstanceIDSet_.push_back(decInstanceID_);
85 } else if (freeIDSet_.size() + decInstanceIDSet_.size() < VIDEO_INSTANCE_SIZE) {
86 decInstanceID_ = freeIDSet_.size() + decInstanceIDSet_.size();
87 decInstanceIDSet_.push_back(decInstanceID_);
88 } else {
89 decInstanceID_ = VIDEO_INSTANCE_SIZE + 1;
90 }
91 lock.unlock();
92
93 if (decInstanceID_ < VIDEO_INSTANCE_SIZE) {
94 handle_ = dlopen(HEVC_DEC_LIB_PATH, RTLD_LAZY);
95 if (handle_ == nullptr) {
96 AVCODEC_LOGE("Load codec failed: %{public}s", HEVC_DEC_LIB_PATH);
97 }
98 HevcFuncMatch();
99 AVCODEC_LOGI("Num %{public}u HevcDecoder entered, state: Uninitialized", decInstanceID_);
100 } else {
101 AVCODEC_LOGE("HevcDecoder already has %{public}d instances, cannot has more instances", VIDEO_INSTANCE_SIZE);
102 state_ = State::ERROR;
103 }
104
105 initParams_.logFxn = nullptr;
106 initParams_.uiChannelID = 0;
107 InitHevcParams();
108 }
109
HevcFuncMatch()110 void HevcDecoder::HevcFuncMatch()
111 {
112 if (handle_ != nullptr) {
113 hevcDecoderCreateFunc_ = reinterpret_cast<CreateHevcDecoderFuncType>(dlsym(handle_,
114 HEVC_DEC_CREATE_FUNC_NAME));
115 hevcDecoderDecodecFrameFunc_ = reinterpret_cast<DecodeFuncType>(dlsym(handle_,
116 HEVC_DEC_DECODE_FRAME_FUNC_NAME));
117 hevcDecoderFlushFrameFunc_ = reinterpret_cast<FlushFuncType>(dlsym(handle_, HEVC_DEC_FLUSH_FRAME_FUNC_NAME));
118 hevcDecoderDeleteFunc_ = reinterpret_cast<DeleteFuncType>(dlsym(handle_, HEVC_DEC_DELETE_FUNC_NAME));
119 if (hevcDecoderCreateFunc_ == nullptr || hevcDecoderDecodecFrameFunc_ == nullptr ||
120 hevcDecoderDeleteFunc_ == nullptr || hevcDecoderFlushFrameFunc_ == nullptr) {
121 AVCODEC_LOGE("HevcDecoder hevcFuncMatch_ failed!");
122 ReleaseHandle();
123 }
124 }
125 }
126
ReleaseHandle()127 void HevcDecoder::ReleaseHandle()
128 {
129 std::unique_lock<std::mutex> runLock(decRunMutex_);
130 hevcDecoderCreateFunc_ = nullptr;
131 hevcDecoderDecodecFrameFunc_ = nullptr;
132 hevcDecoderFlushFrameFunc_ = nullptr;
133 hevcDecoderDeleteFunc_ = nullptr;
134 if (handle_ != nullptr) {
135 dlclose(handle_);
136 handle_ = nullptr;
137 }
138 runLock.unlock();
139 }
140
~HevcDecoder()141 HevcDecoder::~HevcDecoder()
142 {
143 ReleaseResource();
144 callback_ = nullptr;
145 ReleaseHandle();
146 if (decInstanceID_ < VIDEO_INSTANCE_SIZE) {
147 std::lock_guard<std::mutex> lock(decoderCountMutex_);
148 freeIDSet_.push_back(decInstanceID_);
149 auto it = std::find(decInstanceIDSet_.begin(), decInstanceIDSet_.end(), decInstanceID_);
150 if (it != decInstanceIDSet_.end()) {
151 decInstanceIDSet_.erase(it);
152 }
153 }
154 #ifdef BUILD_ENG_VERSION
155 if (dumpInFile_ != nullptr) {
156 dumpInFile_->close();
157 }
158 if (dumpOutFile_ != nullptr) {
159 dumpOutFile_->close();
160 }
161 if (dumpConvertFile_ != nullptr) {
162 dumpConvertFile_->close();
163 }
164 #endif
165 mallopt(M_FLUSH_THREAD_CACHE, 0);
166 }
167
Initialize()168 int32_t HevcDecoder::Initialize()
169 {
170 AVCODEC_SYNC_TRACE;
171 CHECK_AND_RETURN_RET_LOG(!codecName_.empty(), AVCS_ERR_INVALID_VAL, "Init codec failed: empty name");
172 std::string_view mime;
173 for (uint32_t i = 0; i < SUPPORT_HEVC_DECODER_NUM; ++i) {
174 if (SUPPORT_HEVC_DECODER[i].codecName == codecName_) {
175 mime = SUPPORT_HEVC_DECODER[i].mimeType;
176 break;
177 }
178 }
179 format_.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_MIME, mime);
180 format_.PutStringValue(MediaDescriptionKey::MD_KEY_CODEC_NAME, codecName_);
181 sendTask_ = std::make_shared<TaskThread>("SendFrame");
182 sendTask_->RegisterHandler([this] { SendFrame(); });
183
184 #ifdef BUILD_ENG_VERSION
185 OpenDumpFile();
186 #endif
187 state_ = State::INITIALIZED;
188 AVCODEC_LOGI("Init codec successful, state: Uninitialized -> Initialized");
189 return AVCS_ERR_OK;
190 }
191
192 #ifdef BUILD_ENG_VERSION
OpenDumpFile()193 void HevcDecoder::OpenDumpFile()
194 {
195 std::string dumpModeStr = OHOS::system::GetParameter("hevcdecoder.dump", "0");
196 AVCODEC_LOGI("dumpModeStr %{public}s", dumpModeStr.c_str());
197
198 char fileName[PATH_MAX_LEN] = {0};
199 if (dumpModeStr == "10" || dumpModeStr == "11") {
200 int ret = sprintf_s(fileName, sizeof(fileName), "%s/input_%p.h265", DUMP_PATH, this);
201 if (ret > 0) {
202 dumpInFile_ = std::make_shared<std::ofstream>();
203 dumpInFile_->open(fileName, std::ios::out | std::ios::binary);
204 if (!dumpInFile_->is_open()) {
205 AVCODEC_LOGW("fail open file %{public}s", fileName);
206 dumpInFile_ = nullptr;
207 }
208 }
209 }
210 if (dumpModeStr == "1" || dumpModeStr == "01" || dumpModeStr == "11") {
211 int ret = sprintf_s(fileName, sizeof(fileName), "%s/output_%p.yuv", DUMP_PATH, this);
212 if (ret > 0) {
213 dumpOutFile_ = std::make_shared<std::ofstream>();
214 dumpOutFile_->open(fileName, std::ios::out | std::ios::binary);
215 if (!dumpOutFile_->is_open()) {
216 AVCODEC_LOGW("fail open file %{public}s", fileName);
217 dumpOutFile_ = nullptr;
218 }
219 }
220 ret = sprintf_s(fileName, sizeof(fileName), "%s/outConvert_%p.data", DUMP_PATH, this);
221 if (ret > 0) {
222 dumpConvertFile_ = std::make_shared<std::ofstream>();
223 dumpConvertFile_->open(fileName, std::ios::out | std::ios::binary);
224 if (!dumpConvertFile_->is_open()) {
225 AVCODEC_LOGW("fail open file %{public}s", fileName);
226 dumpConvertFile_ = nullptr;
227 }
228 }
229 }
230 }
231 #endif
232
ConfigureDefaultVal(const Format & format,const std::string_view & formatKey,int32_t minVal,int32_t maxVal)233 void HevcDecoder::ConfigureDefaultVal(const Format &format, const std::string_view &formatKey, int32_t minVal,
234 int32_t maxVal)
235 {
236 int32_t val32 = 0;
237 if (format.GetIntValue(formatKey, val32) && val32 >= minVal && val32 <= maxVal) {
238 format_.PutIntValue(formatKey, val32);
239 } else {
240 AVCODEC_LOGW("Set parameter failed: %{public}s, which minimum threshold=%{public}d, "
241 "maximum threshold=%{public}d",
242 formatKey.data(), minVal, maxVal);
243 }
244 }
245
ConfigureSurface(const Format & format,const std::string_view & formatKey,FormatDataType formatType)246 void HevcDecoder::ConfigureSurface(const Format &format, const std::string_view &formatKey, FormatDataType formatType)
247 {
248 CHECK_AND_RETURN_LOG(formatType == FORMAT_TYPE_INT32, "Set parameter failed: type should be int32");
249
250 int32_t val = 0;
251 CHECK_AND_RETURN_LOG(format.GetIntValue(formatKey, val), "Set parameter failed: get value fail");
252
253 if (formatKey == MediaDescriptionKey::MD_KEY_PIXEL_FORMAT) {
254 VideoPixelFormat vpf = static_cast<VideoPixelFormat>(val);
255 CHECK_AND_RETURN_LOG(vpf == VideoPixelFormat::NV12 || vpf == VideoPixelFormat::NV21,
256 "Set parameter failed: pixel format value %{public}d invalid", val);
257 outputPixelFmt_ = vpf;
258 format_.PutIntValue(formatKey, val);
259 } else if (formatKey == MediaDescriptionKey::MD_KEY_ROTATION_ANGLE) {
260 VideoRotation sr = static_cast<VideoRotation>(val);
261 CHECK_AND_RETURN_LOG(sr == VideoRotation::VIDEO_ROTATION_0 || sr == VideoRotation::VIDEO_ROTATION_90 ||
262 sr == VideoRotation::VIDEO_ROTATION_180 || sr == VideoRotation::VIDEO_ROTATION_270,
263 "Set parameter failed: rotation angle value %{public}d invalid", val);
264 format_.PutIntValue(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE, val);
265 } else if (formatKey == MediaDescriptionKey::MD_KEY_SCALE_TYPE) {
266 ScalingMode scaleMode = static_cast<ScalingMode>(val);
267 CHECK_AND_RETURN_LOG(scaleMode == ScalingMode::SCALING_MODE_SCALE_TO_WINDOW ||
268 scaleMode == ScalingMode::SCALING_MODE_SCALE_CROP,
269 "Set parameter failed: scale type value %{public}d invalid", val);
270 format_.PutIntValue(formatKey, val);
271 } else {
272 AVCODEC_LOGW("Set parameter failed: %{public}s, please check your parameter key", formatKey.data());
273 return;
274 }
275 AVCODEC_LOGI("Set parameter %{public}s success, val %{public}d", formatKey.data(), val);
276 }
277
Configure(const Format & format)278 int32_t HevcDecoder::Configure(const Format &format)
279 {
280 AVCODEC_SYNC_TRACE;
281 if (state_ == State::UNINITIALIZED) {
282 int32_t ret = Initialize();
283 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Init codec failed");
284 }
285 CHECK_AND_RETURN_RET_LOG((state_ == State::INITIALIZED), AVCS_ERR_INVALID_STATE,
286 "Configure codec failed: not in Initialized state");
287 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, DEFAULT_VIDEO_WIDTH);
288 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, DEFAULT_VIDEO_HEIGHT);
289 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, DEFAULT_OUT_BUFFER_CNT);
290 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_INPUT_BUFFER_COUNT, DEFAULT_IN_BUFFER_CNT);
291 for (auto &it : format.GetFormatMap()) {
292 if (it.first == MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT) {
293 isOutBufSetted_ = true;
294 ConfigureDefaultVal(format, it.first, DEFAULT_MIN_BUFFER_CNT, DEFAULT_MAX_BUFFER_CNT);
295 } else if (it.first == MediaDescriptionKey::MD_KEY_MAX_INPUT_BUFFER_COUNT) {
296 ConfigureDefaultVal(format, it.first, DEFAULT_MIN_BUFFER_CNT, DEFAULT_MAX_BUFFER_CNT);
297 } else if (it.first == MediaDescriptionKey::MD_KEY_WIDTH) {
298 ConfigureDefaultVal(format, it.first, VIDEO_MIN_SIZE, VIDEO_MAX_WIDTH_SIZE);
299 } else if (it.first == MediaDescriptionKey::MD_KEY_HEIGHT) {
300 ConfigureDefaultVal(format, it.first, VIDEO_MIN_SIZE, VIDEO_MAX_HEIGHT_SIZE);
301 } else if (it.first == MediaDescriptionKey::MD_KEY_PIXEL_FORMAT ||
302 it.first == MediaDescriptionKey::MD_KEY_ROTATION_ANGLE ||
303 it.first == MediaDescriptionKey::MD_KEY_SCALE_TYPE) {
304 ConfigureSurface(format, it.first, it.second.type);
305 } else {
306 AVCODEC_LOGW("Set parameter failed: size:%{public}s, unsupport key", it.first.data());
307 }
308 }
309 format_.GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, width_);
310 format_.GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height_);
311
312 initParams_.uiChannelID = decInstanceID_;
313 initParams_.logFxn = HevcDecLog;
314
315 state_ = State::CONFIGURED;
316
317 return AVCS_ERR_OK;
318 }
319
IsActive() const320 bool HevcDecoder::IsActive() const
321 {
322 return state_ == State::RUNNING || state_ == State::FLUSHED || state_ == State::EOS;
323 }
324
Start()325 int32_t HevcDecoder::Start()
326 {
327 AVCODEC_SYNC_TRACE;
328 CHECK_AND_RETURN_RET_LOG(callback_ != nullptr, AVCS_ERR_INVALID_OPERATION, "Start codec failed: callback is null");
329 CHECK_AND_RETURN_RET_LOG((state_ == State::CONFIGURED || state_ == State::FLUSHED), AVCS_ERR_INVALID_STATE,
330 "Start codec failed: not in Configured or Flushed state");
331
332 std::unique_lock<std::mutex> runLock(decRunMutex_);
333 int32_t createRet = 0;
334 if (hevcSDecoder_ == nullptr && hevcDecoderCreateFunc_ != nullptr) {
335 createRet = hevcDecoderCreateFunc_(&hevcSDecoder_, &initParams_);
336 }
337 runLock.unlock();
338 CHECK_AND_RETURN_RET_LOG(createRet == 0 && hevcSDecoder_ != nullptr, AVCS_ERR_INVALID_OPERATION,
339 "hevc deocder create failed");
340
341 if (!isBufferAllocated_) {
342 for (int32_t i = 0; i < AV_NUM_DATA_POINTERS; i++) {
343 scaleData_[i] = nullptr;
344 scaleLineSize_[i] = 0;
345 }
346 isConverted_ = false;
347 int32_t ret = AllocateBuffers();
348 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Start codec failed: cannot allocate buffers");
349 isBufferAllocated_ = true;
350 }
351 state_ = State::RUNNING;
352 InitBuffers();
353 isSendEos_ = false;
354 sendTask_->Start();
355 AVCODEC_LOGI("Start codec successful, state: Running");
356 return AVCS_ERR_OK;
357 }
358
InitBuffers()359 void HevcDecoder::InitBuffers()
360 {
361 inputAvailQue_->SetActive(true);
362 codecAvailQue_->SetActive(true);
363 if (sInfo_.surface != nullptr) {
364 renderAvailQue_->SetActive(true);
365 requestSurfaceBufferQue_->SetActive(true);
366 }
367 if (buffers_[INDEX_INPUT].size() > 0) {
368 for (uint32_t i = 0; i < buffers_[INDEX_INPUT].size(); i++) {
369 buffers_[INDEX_INPUT][i]->owner_ = Owner::OWNED_BY_USER;
370 callback_->OnInputBufferAvailable(i, buffers_[INDEX_INPUT][i]->avBuffer);
371 AVCODEC_LOGI("OnInputBufferAvailable frame index = %{public}d, owner = %{public}d", i,
372 buffers_[INDEX_INPUT][i]->owner_.load());
373 }
374 }
375 if (buffers_[INDEX_OUTPUT].size() <= 0) {
376 return;
377 }
378 InitHevcParams();
379 if (sInfo_.surface == nullptr) {
380 for (uint32_t i = 0; i < buffers_[INDEX_OUTPUT].size(); i++) {
381 buffers_[INDEX_OUTPUT][i]->owner_ = Owner::OWNED_BY_CODEC;
382 codecAvailQue_->Push(i);
383 }
384 return;
385 }
386 for (uint32_t i = 0u; i < buffers_[INDEX_OUTPUT].size(); i++) {
387 std::shared_ptr<FSurfaceMemory> surfaceMemory = buffers_[INDEX_OUTPUT][i]->sMemory;
388 if (surfaceMemory->isAttached && surfaceMemory->owner == Owner::OWNED_BY_SURFACE) {
389 buffers_[INDEX_OUTPUT][i]->owner_ = Owner::OWNED_BY_SURFACE;
390 renderAvailQue_->Push(i);
391 } else {
392 buffers_[INDEX_OUTPUT][i]->owner_ = Owner::OWNED_BY_CODEC;
393 codecAvailQue_->Push(i);
394 }
395 }
396 }
397
InitHevcParams()398 void HevcDecoder::InitHevcParams()
399 {
400 hevcDecoderInputArgs_.pStream = nullptr;
401 hevcDecoderInputArgs_.uiStreamLen = 0;
402 hevcDecoderInputArgs_.uiTimeStamp = 0;
403 hevcDecoderOutpusArgs_.pucOutYUV[0] = nullptr;
404 hevcDecoderOutpusArgs_.pucOutYUV[1] = nullptr; // 1 u channel
405 hevcDecoderOutpusArgs_.pucOutYUV[2] = nullptr; // 2 v channel
406 hevcDecoderOutpusArgs_.uiDecBitDepth = 0;
407 hevcDecoderOutpusArgs_.uiDecHeight = 0;
408 hevcDecoderOutpusArgs_.uiDecStride = 0;
409 hevcDecoderOutpusArgs_.uiDecWidth = 0;
410 hevcDecoderOutpusArgs_.uiTimeStamp = 0;
411 }
412
ResetData()413 void HevcDecoder::ResetData()
414 {
415 if (scaleData_[0] != nullptr) {
416 if (isConverted_) {
417 av_free(scaleData_[0]);
418 isConverted_ = false;
419 scale_.reset();
420 }
421 for (int32_t i = 0; i < AV_NUM_DATA_POINTERS; i++) {
422 scaleData_[i] = nullptr;
423 scaleLineSize_[i] = 0;
424 }
425 }
426 }
427
ResetBuffers()428 void HevcDecoder::ResetBuffers()
429 {
430 inputAvailQue_->Clear();
431 codecAvailQue_->Clear();
432 if (sInfo_.surface != nullptr) {
433 renderAvailQue_->Clear();
434 requestSurfaceBufferQue_->Clear();
435 renderSurfaceBufferMap_.clear();
436 }
437 ResetData();
438 }
439
StopThread()440 void HevcDecoder::StopThread()
441 {
442 if (inputAvailQue_ != nullptr) {
443 inputAvailQue_->SetActive(false, false);
444 }
445 if (codecAvailQue_ != nullptr) {
446 codecAvailQue_->SetActive(false, false);
447 }
448 if (sendTask_ != nullptr) {
449 sendTask_->Stop();
450 }
451 if (sInfo_.surface != nullptr) {
452 if (renderAvailQue_ != nullptr) {
453 renderAvailQue_->SetActive(false, false);
454 }
455 if (requestSurfaceBufferQue_ != nullptr) {
456 requestSurfaceBufferQue_->SetActive(false, false);
457 }
458 }
459 }
460
Stop()461 int32_t HevcDecoder::Stop()
462 {
463 AVCODEC_SYNC_TRACE;
464 CHECK_AND_RETURN_RET_LOG((IsActive()), AVCS_ERR_INVALID_STATE, "Stop codec failed: not in executing state");
465 state_ = State::STOPPING;
466 inputAvailQue_->SetActive(false, false);
467 codecAvailQue_->SetActive(false, false);
468 sendTask_->Stop();
469
470 if (sInfo_.surface != nullptr) {
471 renderAvailQue_->SetActive(false, false);
472 requestSurfaceBufferQue_->SetActive(false, false);
473 }
474
475 std::unique_lock<std::mutex> runLock(decRunMutex_);
476 if (hevcSDecoder_ != nullptr && hevcDecoderDeleteFunc_ != nullptr) {
477 int ret = hevcDecoderDeleteFunc_(hevcSDecoder_);
478 if (ret != 0) {
479 AVCODEC_LOGE("Error: hevcDecoder delete error: %{public}d", ret);
480 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN);
481 state_ = State::ERROR;
482 }
483 hevcSDecoder_ = nullptr;
484 }
485 runLock.unlock();
486
487 ReleaseBuffers();
488 state_ = State::CONFIGURED;
489 AVCODEC_LOGI("Stop codec successful, state: Configured");
490 return AVCS_ERR_OK;
491 }
492
Flush()493 int32_t HevcDecoder::Flush()
494 {
495 AVCODEC_SYNC_TRACE;
496 CHECK_AND_RETURN_RET_LOG((state_ == State::RUNNING || state_ == State::EOS), AVCS_ERR_INVALID_STATE,
497 "Flush codec failed: not in running or Eos state");
498 state_ = State::FLUSHING;
499 inputAvailQue_->SetActive(false, false);
500 codecAvailQue_->SetActive(false, false);
501 sendTask_->Pause();
502
503 if (sInfo_.surface != nullptr) {
504 renderAvailQue_->SetActive(false, false);
505 requestSurfaceBufferQue_->SetActive(false, false);
506 }
507
508 ResetBuffers();
509 int32_t ret = 0;
510 while (ret == 0 && hevcDecoderFlushFrameFunc_ != nullptr) {
511 ret = hevcDecoderFlushFrameFunc_(hevcSDecoder_, &hevcDecoderOutpusArgs_);
512 }
513 state_ = State::FLUSHED;
514 AVCODEC_LOGI("Flush codec successful, state: Flushed");
515 return AVCS_ERR_OK;
516 }
517
Reset()518 int32_t HevcDecoder::Reset()
519 {
520 AVCODEC_SYNC_TRACE;
521 AVCODEC_LOGI("Reset codec called");
522 int32_t ret = Release();
523 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Reset codec failed: cannot release codec");
524 ret = Initialize();
525 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Reset codec failed: cannot init codec");
526 AVCODEC_LOGI("Reset codec successful, state: Initialized");
527 return AVCS_ERR_OK;
528 }
529
ReleaseResource()530 void HevcDecoder::ReleaseResource()
531 {
532 StopThread();
533 ReleaseBuffers();
534 format_ = Format();
535 if (sInfo_.surface != nullptr) {
536 int ret = UnRegisterListenerToSurface(sInfo_.surface);
537 if (ret != 0) {
538 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN);
539 state_ = State::ERROR;
540 }
541 StopRequestSurfaceBufferThread();
542 }
543 sInfo_.surface = nullptr;
544 std::unique_lock<std::mutex> runLock(decRunMutex_);
545 if (hevcSDecoder_ != nullptr && hevcDecoderDeleteFunc_ != nullptr) {
546 int ret = hevcDecoderDeleteFunc_(hevcSDecoder_);
547 if (ret != 0) {
548 AVCODEC_LOGE("Error: hevcDecoder delete error: %{public}d", ret);
549 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN);
550 state_ = State::ERROR;
551 }
552 hevcSDecoder_ = nullptr;
553 }
554 runLock.unlock();
555 }
556
Release()557 int32_t HevcDecoder::Release()
558 {
559 AVCODEC_SYNC_TRACE;
560 state_ = State::STOPPING;
561 ReleaseResource();
562 state_ = State::UNINITIALIZED;
563 AVCODEC_LOGI("Release codec successful, state: Uninitialized");
564 return AVCS_ERR_OK;
565 }
566
SetSurfaceParameter(const Format & format,const std::string_view & formatKey,FormatDataType formatType)567 void HevcDecoder::SetSurfaceParameter(const Format &format, const std::string_view &formatKey,
568 FormatDataType formatType)
569 {
570 CHECK_AND_RETURN_LOG(formatType == FORMAT_TYPE_INT32, "Set parameter failed: type should be int32");
571 int32_t val = 0;
572 CHECK_AND_RETURN_LOG(format.GetIntValue(formatKey, val), "Set parameter failed: get value fail");
573 if (formatKey == MediaDescriptionKey::MD_KEY_PIXEL_FORMAT) {
574 VideoPixelFormat vpf = static_cast<VideoPixelFormat>(val);
575 CHECK_AND_RETURN_LOG(vpf == VideoPixelFormat::NV12 || vpf == VideoPixelFormat::NV21,
576 "Set parameter failed: pixel format value %{public}d invalid", val);
577 outputPixelFmt_ = vpf;
578 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, val);
579 GraphicPixelFormat surfacePixelFmt;
580 if (bitDepth_ == BIT_DEPTH10BIT) {
581 if (vpf == VideoPixelFormat::NV12) {
582 surfacePixelFmt = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_P010;
583 } else {
584 surfacePixelFmt = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_P010;
585 }
586 } else {
587 surfacePixelFmt = TranslateSurfaceFormat(vpf);
588 }
589 std::lock_guard<std::mutex> sLock(surfaceMutex_);
590 sInfo_.requestConfig.format = surfacePixelFmt;
591 } else if (formatKey == MediaDescriptionKey::MD_KEY_ROTATION_ANGLE) {
592 VideoRotation sr = static_cast<VideoRotation>(val);
593 CHECK_AND_RETURN_LOG(sr == VideoRotation::VIDEO_ROTATION_0 || sr == VideoRotation::VIDEO_ROTATION_90 ||
594 sr == VideoRotation::VIDEO_ROTATION_180 || sr == VideoRotation::VIDEO_ROTATION_270,
595 "Set parameter failed: rotation angle value %{public}d invalid", val);
596 format_.PutIntValue(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE, val);
597 std::lock_guard<std::mutex> sLock(surfaceMutex_);
598 sInfo_.surface->SetTransform(TranslateSurfaceRotation(sr));
599 } else if (formatKey == MediaDescriptionKey::MD_KEY_SCALE_TYPE) {
600 ScalingMode scaleMode = static_cast<ScalingMode>(val);
601 CHECK_AND_RETURN_LOG(scaleMode == ScalingMode::SCALING_MODE_SCALE_TO_WINDOW ||
602 scaleMode == ScalingMode::SCALING_MODE_SCALE_CROP,
603 "Set parameter failed: scale type value %{public}d invalid", val);
604 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SCALE_TYPE, val);
605 std::lock_guard<std::mutex> sLock(surfaceMutex_);
606 sInfo_.scalingMode = scaleMode;
607 } else {
608 AVCODEC_LOGW("Set parameter failed: %{public}s", formatKey.data());
609 return;
610 }
611 AVCODEC_LOGI("Set parameter %{public}s success, val %{public}d", formatKey.data(), val);
612 }
613
SetParameter(const Format & format)614 int32_t HevcDecoder::SetParameter(const Format &format)
615 {
616 AVCODEC_SYNC_TRACE;
617 for (auto &it : format.GetFormatMap()) {
618 if (sInfo_.surface != nullptr && it.second.type == FORMAT_TYPE_INT32) {
619 if (it.first == MediaDescriptionKey::MD_KEY_PIXEL_FORMAT ||
620 it.first == MediaDescriptionKey::MD_KEY_ROTATION_ANGLE ||
621 it.first == MediaDescriptionKey::MD_KEY_SCALE_TYPE) {
622 SetSurfaceParameter(format, it.first, it.second.type);
623 }
624 } else {
625 AVCODEC_LOGW("Current Version, %{public}s is not supported", it.first.data());
626 }
627 }
628 AVCODEC_LOGI("Set parameter successful");
629 return AVCS_ERR_OK;
630 }
631
GetOutputFormat(Format & format)632 int32_t HevcDecoder::GetOutputFormat(Format &format)
633 {
634 AVCODEC_SYNC_TRACE;
635 if ((!format_.ContainKey(MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE)) &&
636 hevcDecoderOutpusArgs_.uiDecStride != 0) {
637 int32_t stride = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride);
638 int32_t maxInputSize = static_cast<int32_t>(static_cast<UINT32>(stride * height_ * VIDEO_PIX_DEPTH_YUV) >> 1);
639 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_INPUT_SIZE, maxInputSize);
640 }
641
642 if (!format_.ContainKey(OHOS::Media::Tag::VIDEO_SLICE_HEIGHT)) {
643 format_.PutIntValue(OHOS::Media::Tag::VIDEO_SLICE_HEIGHT, height_);
644 }
645 if (!format_.ContainKey(OHOS::Media::Tag::VIDEO_PIC_WIDTH) ||
646 !format_.ContainKey(OHOS::Media::Tag::VIDEO_PIC_HEIGHT)) {
647 format_.PutIntValue(OHOS::Media::Tag::VIDEO_PIC_WIDTH, width_);
648 format_.PutIntValue(OHOS::Media::Tag::VIDEO_PIC_HEIGHT, height_);
649 }
650
651 if (!format_.ContainKey(OHOS::Media::Tag::VIDEO_CROP_RIGHT) ||
652 !format_.ContainKey(OHOS::Media::Tag::VIDEO_CROP_BOTTOM)) {
653 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_RIGHT, width_-1);
654 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_BOTTOM, height_-1);
655 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_LEFT, 0);
656 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_TOP, 0);
657 }
658
659 format = format_;
660 AVCODEC_LOGI("Get outputFormat successful");
661 return AVCS_ERR_OK;
662 }
663
CalculateBufferSize()664 void HevcDecoder::CalculateBufferSize()
665 {
666 if ((static_cast<UINT32>(width_ * height_ * VIDEO_PIX_DEPTH_YUV) >> 1) <= VIDEO_MIN_BUFFER_SIZE) {
667 inputBufferSize_ = VIDEO_MIN_BUFFER_SIZE;
668 } else {
669 inputBufferSize_ = VIDEO_MAX_BUFFER_SIZE;
670 }
671 AVCODEC_LOGI("width = %{public}d, height = %{public}d, Input buffer size = %{public}d",
672 width_, height_, inputBufferSize_);
673 }
674
AllocateInputBuffer(int32_t bufferCnt,int32_t inBufferSize)675 int32_t HevcDecoder::AllocateInputBuffer(int32_t bufferCnt, int32_t inBufferSize)
676 {
677 int32_t valBufferCnt = 0;
678 for (int32_t i = 0; i < bufferCnt; i++) {
679 std::shared_ptr<HBuffer> buf = std::make_shared<HBuffer>();
680 std::shared_ptr<AVAllocator> allocator =
681 AVAllocatorFactory::CreateSharedAllocator(MemoryFlag::MEMORY_READ_WRITE);
682 CHECK_AND_CONTINUE_LOG(allocator != nullptr, "input buffer %{public}d allocator is nullptr", i);
683 buf->avBuffer = AVBuffer::CreateAVBuffer(allocator, inBufferSize);
684 CHECK_AND_CONTINUE_LOG(buf->avBuffer != nullptr, "Allocate input buffer failed, index=%{public}d", i);
685 AVCODEC_LOGI("Allocate input buffer success: index=%{public}d, size=%{public}d", i,
686 buf->avBuffer->memory_->GetCapacity());
687
688 buffers_[INDEX_INPUT].emplace_back(buf);
689 valBufferCnt++;
690 }
691 if (valBufferCnt < DEFAULT_MIN_BUFFER_CNT) {
692 AVCODEC_LOGE("Allocate input buffer failed: only %{public}d buffer is allocated, no memory", valBufferCnt);
693 buffers_[INDEX_INPUT].clear();
694 return AVCS_ERR_NO_MEMORY;
695 }
696 return AVCS_ERR_OK;
697 }
698
SetSurfaceCfg()699 int32_t HevcDecoder::SetSurfaceCfg()
700 {
701 if (outputPixelFmt_ == VideoPixelFormat::UNKNOWN) {
702 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(VideoPixelFormat::NV12));
703 }
704 int32_t val32 = 0;
705 format_.GetIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, val32);
706 GraphicPixelFormat surfacePixelFmt = TranslateSurfaceFormat(static_cast<VideoPixelFormat>(val32));
707 CHECK_AND_RETURN_RET_LOG(surfacePixelFmt != GraphicPixelFormat::GRAPHIC_PIXEL_FMT_BUTT, AVCS_ERR_UNSUPPORT,
708 "Failed to allocate output buffer: unsupported surface format");
709 sInfo_.requestConfig.width = width_;
710 sInfo_.requestConfig.height = height_;
711 sInfo_.requestConfig.format = surfacePixelFmt;
712 if (sInfo_.surface != nullptr) {
713 CHECK_AND_RETURN_RET_LOG(format_.GetIntValue(MediaDescriptionKey::MD_KEY_SCALE_TYPE, val32) && val32 >= 0 &&
714 val32 <= static_cast<int32_t>(ScalingMode::SCALING_MODE_SCALE_FIT),
715 AVCS_ERR_INVALID_VAL, "Invalid scaling mode %{public}d", val32);
716 sInfo_.scalingMode = static_cast<ScalingMode>(val32);
717 CHECK_AND_RETURN_RET_LOG(format_.GetIntValue(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE, val32) && val32 >= 0 &&
718 val32 <= static_cast<int32_t>(VideoRotation::VIDEO_ROTATION_270),
719 AVCS_ERR_INVALID_VAL, "Invalid rotation angle %{public}d", val32);
720 sInfo_.surface->SetTransform(TranslateSurfaceRotation(static_cast<VideoRotation>(val32)));
721 }
722 return AVCS_ERR_OK;
723 }
724
RequestSurfaceBufferThread()725 void HevcDecoder::RequestSurfaceBufferThread()
726 {
727 while (!requestBufferThreadExit_.load()) {
728 std::unique_lock<std::mutex> lck(requestBufferMutex_);
729 requestBufferCV_.wait(lck, [this]() {
730 return requestBufferThreadExit_.load() || !requestBufferFinished_.load();
731 });
732 if (requestBufferThreadExit_.load()) {
733 requestBufferFinished_ = true;
734 requestBufferOnceDoneCV_.notify_one();
735 break;
736 }
737 auto index = requestSurfaceBufferQue_->Front();
738 requestSurfaceBufferQue_->Pop();
739 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][index];
740 std::shared_ptr<FSurfaceMemory> surfaceMemory = outputBuffer->sMemory;
741 sptr<SurfaceBuffer> surfaceBuffer = surfaceMemory->GetSurfaceBuffer();
742 if (surfaceBuffer == nullptr) {
743 AVCODEC_LOGE("Get surface buffer failed, index=%{public}u", index);
744 }
745 requestBufferFinished_ = true;
746 requestBufferOnceDoneCV_.notify_one();
747 }
748 AVCODEC_LOGI("RequestSurfaceBufferThread exit.");
749 }
750
StartRequestSurfaceBufferThread()751 void HevcDecoder::StartRequestSurfaceBufferThread()
752 {
753 if (!mRequestSurfaceBufferThread_.joinable()) {
754 requestBufferThreadExit_ = false;
755 requestBufferFinished_ = true;
756 mRequestSurfaceBufferThread_ = std::thread(&HevcDecoder::RequestSurfaceBufferThread, this);
757 }
758 }
759
StopRequestSurfaceBufferThread()760 void HevcDecoder::StopRequestSurfaceBufferThread()
761 {
762 if (mRequestSurfaceBufferThread_.joinable()) {
763 requestBufferThreadExit_ = true;
764 requestBufferFinished_ = false;
765 requestBufferCV_.notify_all();
766 requestBufferFinished_ = true;
767 requestBufferOnceDoneCV_.notify_all();
768 mRequestSurfaceBufferThread_.join();
769 }
770 }
771
RequestSurfaceBufferOnce(uint32_t index)772 bool HevcDecoder::RequestSurfaceBufferOnce(uint32_t index)
773 {
774 if (!requestBufferThreadExit_.load()) {
775 std::unique_lock<std::mutex> lck(requestBufferMutex_);
776 requestBufferFinished_ = false;
777 requestSurfaceBufferQue_->Push(index);
778 requestBufferCV_.notify_one();
779 requestBufferOnceDoneCV_.wait(lck, [this]() { return requestBufferFinished_.load(); });
780 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][index];
781 std::shared_ptr<FSurfaceMemory> surfaceMemory = outputBuffer->sMemory;
782 if (surfaceMemory == nullptr || surfaceMemory->GetBase() == nullptr) {
783 AVCODEC_LOGE("output surface memory %{public}u allocate fail", index);
784 return false;
785 }
786 return true;
787 }
788 return false;
789 }
790
AllocateOutputBuffer(int32_t bufferCnt)791 int32_t HevcDecoder::AllocateOutputBuffer(int32_t bufferCnt)
792 {
793 CHECK_AND_RETURN_RET_LOG(sInfo_.surface == nullptr, AVCS_ERR_UNKNOWN, "Not in buffer mode!");
794 int32_t ret = SetSurfaceCfg();
795 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Set surface cfg failed!");
796 int32_t valBufferCnt = 0;
797 for (int i = 0; i < bufferCnt; i++) {
798 std::shared_ptr<HBuffer> buf = std::make_shared<HBuffer>();
799 buf->width = width_;
800 buf->height = height_;
801 std::shared_ptr<AVAllocator> allocator = AVAllocatorFactory::CreateSurfaceAllocator(sInfo_.requestConfig);
802 CHECK_AND_CONTINUE_LOG(allocator != nullptr, "output buffer %{public}d allocator is nullptr", i);
803 buf->avBuffer = AVBuffer::CreateAVBuffer(allocator, 0);
804 if (buf->avBuffer != nullptr) {
805 AVCODEC_LOGI("Allocate output share buffer success: index=%{public}d, size=%{public}d", i,
806 buf->avBuffer->memory_->GetCapacity());
807 }
808 CHECK_AND_CONTINUE_LOG(buf->avBuffer != nullptr, "Allocate output buffer failed, index=%{public}d", i);
809 buffers_[INDEX_OUTPUT].emplace_back(buf);
810 valBufferCnt++;
811 }
812 if (valBufferCnt < DEFAULT_MIN_BUFFER_CNT) {
813 AVCODEC_LOGE("Allocate output buffer failed: only %{public}d buffer is allocated, no memory", valBufferCnt);
814 buffers_[INDEX_INPUT].clear();
815 buffers_[INDEX_OUTPUT].clear();
816 return AVCS_ERR_NO_MEMORY;
817 }
818 return AVCS_ERR_OK;
819 }
820
ClearSurfaceAndSetQueueSize(const sptr<Surface> & surface,int32_t bufferCnt)821 int32_t HevcDecoder::ClearSurfaceAndSetQueueSize(const sptr<Surface> &surface, int32_t bufferCnt)
822 {
823 surface->Connect();
824 surface->CleanCache(); // clean cache will work only if the surface is connected by us.
825 int32_t ret = SetQueueSize(surface, bufferCnt);
826 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Set surface queue size failed!");
827 ret = SetSurfaceCfg();
828 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Set surface cfg failed!");
829 CHECK_AND_RETURN_RET_LOGD(buffers_[INDEX_OUTPUT].size() > 0u, AVCS_ERR_OK, "Set surface cfg & queue size success.");
830 int32_t valBufferCnt = 0;
831 for (auto &it : buffers_[INDEX_OUTPUT]) {
832 std::shared_ptr<FSurfaceMemory> surfaceMemory = it->sMemory;
833 surfaceMemory->isAttached = false;
834 valBufferCnt++;
835 }
836 CHECK_AND_RETURN_RET_LOG(valBufferCnt == bufferCnt, AVCS_ERR_UNKNOWN, "Outbuf cnt(%{public}d) != %{public}d",
837 valBufferCnt, bufferCnt);
838 return AVCS_ERR_OK;
839 }
840
AllocateOutputBuffersFromSurface(int32_t bufferCnt)841 int32_t HevcDecoder::AllocateOutputBuffersFromSurface(int32_t bufferCnt)
842 {
843 CHECK_AND_RETURN_RET_LOG(sInfo_.surface != nullptr, AVCS_ERR_UNKNOWN, "Not in surface mode!");
844 int32_t ret = ClearSurfaceAndSetQueueSize(sInfo_.surface, bufferCnt);
845 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Clean surface and set queue size failed!");
846 requestSurfaceBufferQue_->Clear();
847 requestSurfaceBufferQue_->SetActive(true);
848 StartRequestSurfaceBufferThread();
849 for (int32_t i = 0; i < bufferCnt; i++) {
850 std::shared_ptr<FSurfaceMemory> surfaceMemory = std::make_shared<FSurfaceMemory>(&sInfo_);
851 CHECK_AND_RETURN_RET_LOG(surfaceMemory != nullptr, AVCS_ERR_UNKNOWN, "Creata surface memory failed!");
852 ret = surfaceMemory->AllocSurfaceBuffer();
853 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Alloc surface buffer failed!");
854 std::shared_ptr<HBuffer> buf = std::make_shared<HBuffer>();
855 CHECK_AND_RETURN_RET_LOG(buf != nullptr, AVCS_ERR_UNKNOWN, "Creata output buffer failed!");
856 buf->sMemory = surfaceMemory;
857 buf->height = height_;
858 buf->width = width_;
859 outAVBuffer4Surface_.emplace_back(AVBuffer::CreateAVBuffer());
860 buf->avBuffer = AVBuffer::CreateAVBuffer(buf->sMemory->GetBase(), buf->sMemory->GetSize());
861 AVCODEC_LOGI("Allocate output surface buffer success, index=%{public}d, size=%{public}d, stride=%{public}d", i,
862 buf->sMemory->GetSize(), buf->sMemory->GetSurfaceBufferStride());
863 buffers_[INDEX_OUTPUT].emplace_back(buf);
864 }
865 int32_t outputBufferNum = static_cast<int32_t>(buffers_[INDEX_OUTPUT].size());
866 CHECK_AND_RETURN_RET_LOG(outputBufferNum == bufferCnt, AVCS_ERR_UNKNOWN,
867 "Only alloc %{public}d buffers, less %{public}d", outputBufferNum, bufferCnt);
868 return AVCS_ERR_OK;
869 }
870
AllocateBuffers()871 int32_t HevcDecoder::AllocateBuffers()
872 {
873 AVCODEC_SYNC_TRACE;
874 CalculateBufferSize();
875 CHECK_AND_RETURN_RET_LOG(inputBufferSize_ > 0, AVCS_ERR_INVALID_VAL,
876 "Allocate buffer with input size=%{public}d failed", inputBufferSize_);
877 if (sInfo_.surface != nullptr && isOutBufSetted_ == false) {
878 format_.PutIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, DEFAULT_OUT_SURFACE_CNT);
879 }
880 format_.GetIntValue(MediaDescriptionKey::MD_KEY_MAX_INPUT_BUFFER_COUNT, inputBufferCnt_);
881 format_.GetIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, outputBufferCnt_);
882 inputAvailQue_ = std::make_shared<BlockQueue<uint32_t>>("inputAvailQue", inputBufferCnt_);
883 codecAvailQue_ = std::make_shared<BlockQueue<uint32_t>>("codecAvailQue", outputBufferCnt_);
884 if (sInfo_.surface != nullptr) {
885 renderAvailQue_ = std::make_shared<BlockQueue<uint32_t>>("renderAvailQue", outputBufferCnt_);
886 requestSurfaceBufferQue_ = std::make_shared<BlockQueue<uint32_t>>("requestSurfaceBufferQue", outputBufferCnt_);
887 }
888 int32_t ret = AllocateInputBuffer(inputBufferCnt_, inputBufferSize_);
889 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Allocate input buffers failed!");
890 ret = sInfo_.surface ? AllocateOutputBuffersFromSurface(outputBufferCnt_) : AllocateOutputBuffer(outputBufferCnt_);
891 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Allocate output buffers failed!");
892 return AVCS_ERR_OK;
893 }
894
UpdateOutputBuffer(uint32_t index)895 int32_t HevcDecoder::UpdateOutputBuffer(uint32_t index)
896 {
897 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][index];
898 if (width_ != outputBuffer->width || height_ != outputBuffer->height || bitDepth_ != outputBuffer->bitDepth) {
899 std::shared_ptr<AVAllocator> allocator =
900 AVAllocatorFactory::CreateSurfaceAllocator(sInfo_.requestConfig);
901 CHECK_AND_RETURN_RET_LOG(allocator != nullptr, AVCS_ERR_NO_MEMORY, "buffer %{public}d allocator is nullptr",
902 index);
903 outputBuffer->avBuffer = AVBuffer::CreateAVBuffer(allocator, 0);
904 CHECK_AND_RETURN_RET_LOG(outputBuffer->avBuffer != nullptr, AVCS_ERR_NO_MEMORY,
905 "Buffer allocate failed, index=%{public}d", index);
906 AVCODEC_LOGI("update output buffer success: index=%{public}d, size=%{public}d", index,
907 outputBuffer->avBuffer->memory_->GetCapacity());
908
909 outputBuffer->owner_ = Owner::OWNED_BY_CODEC;
910 outputBuffer->width = width_;
911 outputBuffer->height = height_;
912 outputBuffer->bitDepth = bitDepth_;
913 }
914 return AVCS_ERR_OK;
915 }
916
UpdateSurfaceMemory(uint32_t index)917 int32_t HevcDecoder::UpdateSurfaceMemory(uint32_t index)
918 {
919 AVCODEC_SYNC_TRACE;
920 std::unique_lock<std::mutex> oLock(outputMutex_);
921 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][index];
922 oLock.unlock();
923 if (width_ != outputBuffer->width || height_ != outputBuffer->height || bitDepth_ != outputBuffer->bitDepth) {
924 std::shared_ptr<FSurfaceMemory> surfaceMemory = outputBuffer->sMemory;
925 CHECK_AND_RETURN_RET_LOG(surfaceMemory != nullptr, AVCS_ERR_UNKNOWN, "Surface memory is nullptr!");
926 AVCODEC_LOGI("Update surface memory, width=%{public}d, height=%{public}d", width_, height_);
927 std::lock_guard<std::mutex> sLock(surfaceMutex_);
928 if (surfaceMemory->isAttached) {
929 sptr<SurfaceBuffer> surfaceBuffer = surfaceMemory->GetSurfaceBuffer();
930 CHECK_AND_RETURN_RET_LOG(surfaceBuffer != nullptr, AVCS_ERR_UNKNOWN, "Get surface buffer failed!");
931 int32_t ret = Detach(surfaceBuffer);
932 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Surface buffer detach failed!");
933 surfaceMemory->isAttached = false;
934 }
935 surfaceMemory->ReleaseSurfaceBuffer();
936 int32_t ret = surfaceMemory->AllocSurfaceBuffer();
937 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Alloc surface buffer failed!");
938 sptr<SurfaceBuffer> newSurfaceBuffer = surfaceMemory->GetSurfaceBuffer();
939 CHECK_AND_RETURN_RET_LOG(newSurfaceBuffer != nullptr, AVCS_ERR_UNKNOWN, "Alloc surface buffer failed!");
940 ret = Attach(newSurfaceBuffer);
941 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Surface buffer attach failed!");
942 surfaceMemory->isAttached = true;
943 outputBuffer->avBuffer =
944 AVBuffer::CreateAVBuffer(outputBuffer->sMemory->GetBase(), outputBuffer->sMemory->GetSize());
945 outputBuffer->width = width_;
946 outputBuffer->height = height_;
947 outputBuffer->bitDepth = bitDepth_;
948 }
949 return AVCS_ERR_OK;
950 }
951
CheckFormatChange(uint32_t index,int width,int height,int bitDepth)952 int32_t HevcDecoder::CheckFormatChange(uint32_t index, int width, int height, int bitDepth)
953 {
954 bool formatChanged = false;
955 if (width_ != width || height_ != height || bitDepth_ != bitDepth) {
956 AVCODEC_LOGI("format change, width: %{public}d->%{public}d, height: %{public}d->%{public}d, "
957 "bitDepth: %{public}d->%{public}d", width_, width, height_, height, bitDepth_, bitDepth);
958 width_ = width;
959 height_ = height;
960 bitDepth_ = bitDepth;
961 ResetData();
962 scale_ = nullptr;
963 std::unique_lock<std::mutex> sLock(surfaceMutex_);
964 sInfo_.requestConfig.width = width_;
965 sInfo_.requestConfig.height = height_;
966 if (bitDepth_ == BIT_DEPTH10BIT) {
967 if (outputPixelFmt_ == VideoPixelFormat::NV12 || outputPixelFmt_ == VideoPixelFormat::UNKNOWN) {
968 sInfo_.requestConfig.format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_P010;
969 } else {
970 sInfo_.requestConfig.format = GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_P010;
971 }
972 format_.PutIntValue("av_codec_event_info_bit_depth", 1); // format update key of bit depth
973 }
974 sLock.unlock();
975 formatChanged = true;
976 }
977 if (sInfo_.surface == nullptr) {
978 std::lock_guard<std::mutex> oLock(outputMutex_);
979 CHECK_AND_RETURN_RET_LOG((UpdateOutputBuffer(index) == AVCS_ERR_OK), AVCS_ERR_NO_MEMORY,
980 "Update output buffer failed, index=%{public}u", index);
981 } else {
982 CHECK_AND_RETURN_RET_LOG((UpdateSurfaceMemory(index) == AVCS_ERR_OK), AVCS_ERR_NO_MEMORY,
983 "Update buffer failed");
984 }
985 if (!format_.ContainKey(OHOS::Media::Tag::VIDEO_STRIDE) || formatChanged) {
986 int32_t stride = GetSurfaceBufferStride(buffers_[INDEX_OUTPUT][index]);
987 CHECK_AND_RETURN_RET_LOG(stride > 0, AVCS_ERR_NO_MEMORY, "get GetSurfaceBufferStride failed");
988 format_.PutIntValue(OHOS::Media::Tag::VIDEO_STRIDE, stride);
989 format_.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, width_);
990 format_.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height_);
991 format_.PutIntValue(OHOS::Media::Tag::VIDEO_SLICE_HEIGHT, height_);
992 format_.PutIntValue(OHOS::Media::Tag::VIDEO_PIC_WIDTH, width_);
993 format_.PutIntValue(OHOS::Media::Tag::VIDEO_PIC_HEIGHT, height_);
994 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_RIGHT, width_-1);
995 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_BOTTOM, height_-1);
996 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_LEFT, 0);
997 format_.PutIntValue(OHOS::Media::Tag::VIDEO_CROP_TOP, 0);
998 callback_->OnOutputFormatChanged(format_);
999 }
1000 return AVCS_ERR_OK;
1001 }
1002
GetSurfaceBufferStride(const std::shared_ptr<HBuffer> & frameBuffer)1003 int32_t HevcDecoder::GetSurfaceBufferStride(const std::shared_ptr<HBuffer> &frameBuffer)
1004 {
1005 int32_t surfaceBufferStride = 0;
1006 if (sInfo_.surface == nullptr) {
1007 auto surfaceBuffer = frameBuffer->avBuffer->memory_->GetSurfaceBuffer();
1008 CHECK_AND_RETURN_RET_LOG(surfaceBuffer != nullptr, -1, "surfaceBuffer is nullptr");
1009 auto bufferHandle = surfaceBuffer->GetBufferHandle();
1010 CHECK_AND_RETURN_RET_LOG(bufferHandle != nullptr, -1, "fail to get bufferHandle");
1011 surfaceBufferStride = bufferHandle->stride;
1012 } else {
1013 surfaceBufferStride = frameBuffer->sMemory->GetSurfaceBufferStride();
1014 }
1015 return surfaceBufferStride;
1016 }
1017
ReleaseBuffers()1018 void HevcDecoder::ReleaseBuffers()
1019 {
1020 ResetData();
1021 if (!isBufferAllocated_) {
1022 return;
1023 }
1024
1025 inputAvailQue_->Clear();
1026 buffers_[INDEX_INPUT].clear();
1027 inputBufferCnt_ = 0;
1028
1029 std::unique_lock<std::mutex> oLock(outputMutex_);
1030 codecAvailQue_->Clear();
1031 if (sInfo_.surface != nullptr) {
1032 StopRequestSurfaceBufferThread();
1033 renderAvailQue_->Clear();
1034 requestSurfaceBufferQue_->Clear();
1035 renderSurfaceBufferMap_.clear();
1036 for (uint32_t i = 0; i < buffers_[INDEX_OUTPUT].size(); i++) {
1037 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][i];
1038 if (outputBuffer->owner_ == Owner::OWNED_BY_CODEC) {
1039 std::shared_ptr<FSurfaceMemory> surfaceMemory = outputBuffer->sMemory;
1040 surfaceMemory->ReleaseSurfaceBuffer();
1041 outputBuffer->owner_ = Owner::OWNED_BY_SURFACE;
1042 }
1043 }
1044 sInfo_.surface->CleanCache();
1045 AVCODEC_LOGI("surface cleancache success");
1046 }
1047 buffers_[INDEX_OUTPUT].clear();
1048 outputBufferCnt_ = 0;
1049 outAVBuffer4Surface_.clear();
1050 oLock.unlock();
1051 isBufferAllocated_ = false;
1052 }
1053
QueueInputBuffer(uint32_t index)1054 int32_t HevcDecoder::QueueInputBuffer(uint32_t index)
1055 {
1056 AVCODEC_SYNC_TRACE;
1057 CHECK_AND_RETURN_RET_LOG(state_ == State::RUNNING, AVCS_ERR_INVALID_STATE,
1058 "Queue input buffer failed: not in Running state");
1059 CHECK_AND_RETURN_RET_LOG(index < buffers_[INDEX_INPUT].size(), AVCS_ERR_INVALID_VAL,
1060 "Queue input buffer failed with bad index, index=%{public}u, buffer_size=%{public}zu",
1061 index, buffers_[INDEX_INPUT].size());
1062 std::shared_ptr<HBuffer> inputBuffer = buffers_[INDEX_INPUT][index];
1063 CHECK_AND_RETURN_RET_LOG(inputBuffer->owner_ == Owner::OWNED_BY_USER, AVCS_ERR_INVALID_OPERATION,
1064 "Queue input buffer failed: buffer with index=%{public}u is not available", index);
1065
1066 inputBuffer->owner_ = Owner::OWNED_BY_CODEC;
1067 inputAvailQue_->Push(index);
1068 return AVCS_ERR_OK;
1069 }
1070
SendFrame()1071 void HevcDecoder::SendFrame()
1072 {
1073 if (state_ == State::STOPPING || state_ == State::FLUSHING) {
1074 return;
1075 } else if (state_ != State::RUNNING || isSendEos_) {
1076 std::this_thread::sleep_for(std::chrono::milliseconds(DEFAULT_TRY_DECODE_TIME));
1077 return;
1078 }
1079 uint32_t index = inputAvailQue_->Front();
1080 CHECK_AND_RETURN_LOG(state_ == State::RUNNING, "Not in running state");
1081 std::shared_ptr<HBuffer> &inputBuffer = buffers_[INDEX_INPUT][index];
1082 std::shared_ptr<AVBuffer> &inputAVBuffer = inputBuffer->avBuffer;
1083 if (inputAVBuffer->flag_ & AVCODEC_BUFFER_FLAG_EOS) {
1084 hevcDecoderInputArgs_.pStream = nullptr;
1085 isSendEos_ = true;
1086 AVCODEC_LOGI("Send eos end");
1087 } else {
1088 hevcDecoderInputArgs_.pStream = inputAVBuffer->memory_->GetAddr();
1089 hevcDecoderInputArgs_.uiStreamLen = static_cast<UINT32>(inputAVBuffer->memory_->GetSize());
1090 hevcDecoderInputArgs_.uiTimeStamp = static_cast<UINT64>(inputAVBuffer->pts_);
1091 }
1092
1093 #ifdef BUILD_ENG_VERSION
1094 if (dumpInFile_ && dumpInFile_->is_open() && !isSendEos_) {
1095 dumpInFile_->write(reinterpret_cast<char*>(inputAVBuffer->memory_->GetAddr()),
1096 static_cast<int32_t>(inputAVBuffer->memory_->GetSize()));
1097 }
1098 #endif
1099
1100 int32_t ret = 0;
1101 std::unique_lock<std::mutex> runLock(decRunMutex_);
1102 do {
1103 ret = DecodeFrameOnce();
1104 if (!isSendEos_) {
1105 hevcDecoderInputArgs_.uiStreamLen -= hevcDecoderOutpusArgs_.uiBytsConsumed;
1106 hevcDecoderInputArgs_.pStream += hevcDecoderOutpusArgs_.uiBytsConsumed;
1107 }
1108 } while ((ret != -1) && ((!isSendEos_ && hevcDecoderInputArgs_.uiStreamLen != 0) || (isSendEos_ && ret == 0)));
1109 runLock.unlock();
1110
1111 if (isSendEos_) {
1112 auto outIndex = codecAvailQue_->Front();
1113 std::shared_ptr<HBuffer> frameBuffer = buffers_[INDEX_OUTPUT][outIndex];
1114 frameBuffer->avBuffer->flag_ = AVCODEC_BUFFER_FLAG_EOS;
1115 FramePostProcess(buffers_[INDEX_OUTPUT][outIndex], outIndex, AVCS_ERR_OK, AVCS_ERR_OK);
1116 state_ = State::EOS;
1117 } else if (ret < 0) {
1118 AVCODEC_LOGE("decode frame error: ret = %{public}d", ret);
1119 }
1120
1121 inputAvailQue_->Pop();
1122 inputBuffer->owner_ = Owner::OWNED_BY_USER;
1123 callback_->OnInputBufferAvailable(index, inputAVBuffer);
1124 }
1125
DecodeFrameOnce()1126 int32_t HevcDecoder::DecodeFrameOnce()
1127 {
1128 int32_t ret = 0;
1129 if (hevcSDecoder_ != nullptr && hevcDecoderFlushFrameFunc_ != nullptr &&
1130 hevcDecoderDecodecFrameFunc_ != nullptr) {
1131 if (isSendEos_) {
1132 ret = hevcDecoderFlushFrameFunc_(hevcSDecoder_, &hevcDecoderOutpusArgs_);
1133 } else {
1134 ret = hevcDecoderDecodecFrameFunc_(hevcSDecoder_, &hevcDecoderInputArgs_, &hevcDecoderOutpusArgs_);
1135 }
1136 } else {
1137 AVCODEC_LOGW("hevcDecoderDecodecFrameFunc_ = nullptr || hevcSDecoder_ = nullptr || "
1138 "hevcDecoderFlushFrameFunc_ = nullptr, cannot call decoder");
1139 ret = -1;
1140 }
1141 int32_t bitDepth = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecBitDepth);
1142 if (ret == 0) {
1143 CHECK_AND_RETURN_RET_LOG(bitDepth == BIT_DEPTH8BIT || bitDepth == BIT_DEPTH10BIT, -1,
1144 "Unsupported bitDepth %{public}d", bitDepth);
1145 ConvertDecOutToAVFrame(bitDepth);
1146 #ifdef BUILD_ENG_VERSION
1147 DumpOutputBuffer(bitDepth);
1148 #endif
1149 auto index = codecAvailQue_->Front();
1150 CHECK_AND_RETURN_RET_LOG(state_ == State::RUNNING, -1, "Not in running state");
1151 std::shared_ptr<HBuffer> frameBuffer = buffers_[INDEX_OUTPUT][index];
1152 int32_t status = AVCS_ERR_OK;
1153 if (CheckFormatChange(index, cachedFrame_->width, cachedFrame_->height, bitDepth) == AVCS_ERR_OK) {
1154 CHECK_AND_RETURN_RET_LOG(state_ == State::RUNNING, -1, "Not in running state");
1155 frameBuffer = buffers_[INDEX_OUTPUT][index];
1156 status = FillFrameBuffer(frameBuffer);
1157 } else {
1158 CHECK_AND_RETURN_RET_LOG(state_ == State::RUNNING, -1, "Not in running state");
1159 callback_->OnError(AVCODEC_ERROR_EXTEND_START, AVCS_ERR_NO_MEMORY);
1160 return -1;
1161 }
1162 frameBuffer->avBuffer->flag_ = AVCODEC_BUFFER_FLAG_NONE;
1163 FramePostProcess(frameBuffer, index, status, AVCS_ERR_OK);
1164 }
1165 return ret;
1166 }
1167
FillFrameBuffer(const std::shared_ptr<HBuffer> & frameBuffer)1168 int32_t HevcDecoder::FillFrameBuffer(const std::shared_ptr<HBuffer> &frameBuffer)
1169 {
1170 VideoPixelFormat targetPixelFmt = outputPixelFmt_;
1171 if (outputPixelFmt_ == VideoPixelFormat::UNKNOWN) {
1172 targetPixelFmt = VideoPixelFormat::NV12;
1173 }
1174 AVPixelFormat ffmpegFormat;
1175 if (bitDepth_ == BIT_DEPTH10BIT) {
1176 ffmpegFormat = AVPixelFormat::AV_PIX_FMT_P010LE;
1177 } else {
1178 ffmpegFormat = ConvertPixelFormatToFFmpeg(targetPixelFmt);
1179 }
1180 // yuv420 -> nv12 or nv21
1181 int32_t ret = ConvertVideoFrame(&scale_, cachedFrame_, scaleData_, scaleLineSize_, ffmpegFormat);
1182 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Scale video frame failed: %{public}d", ret);
1183 isConverted_ = true;
1184
1185 format_.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(targetPixelFmt));
1186 std::shared_ptr<AVMemory> &bufferMemory = frameBuffer->avBuffer->memory_;
1187 CHECK_AND_RETURN_RET_LOG(bufferMemory != nullptr, AVCS_ERR_INVALID_VAL, "bufferMemory is nullptr");
1188 bufferMemory->SetSize(0);
1189 struct SurfaceInfo surfaceInfo;
1190 surfaceInfo.scaleData = scaleData_;
1191 surfaceInfo.scaleLineSize = scaleLineSize_;
1192 int32_t surfaceStride = GetSurfaceBufferStride(frameBuffer);
1193 CHECK_AND_RETURN_RET_LOG(surfaceStride > 0, AVCS_ERR_INVALID_VAL, "get GetSurfaceBufferStride failed");
1194 surfaceInfo.surfaceStride = static_cast<uint32_t>(surfaceStride);
1195 if (sInfo_.surface) {
1196 surfaceInfo.surfaceFence = frameBuffer->sMemory->GetFence();
1197 ret = WriteSurfaceData(bufferMemory, surfaceInfo, format_);
1198 } else {
1199 Format bufferFormat;
1200 bufferFormat.PutIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height_);
1201 bufferFormat.PutIntValue(MediaDescriptionKey::MD_KEY_WIDTH, surfaceStride);
1202 bufferFormat.PutIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, static_cast<int32_t>(targetPixelFmt));
1203 ret = WriteBufferData(bufferMemory, scaleData_, scaleLineSize_, bufferFormat);
1204 }
1205 #ifdef BUILD_ENG_VERSION
1206 DumpConvertOut(surfaceInfo);
1207 #endif
1208 frameBuffer->avBuffer->pts_ = cachedFrame_->pts;
1209 AVCODEC_LOGD("Fill frame buffer successful");
1210 return ret;
1211 }
1212
FramePostProcess(std::shared_ptr<HBuffer> & frameBuffer,uint32_t index,int32_t status,int ret)1213 void HevcDecoder::FramePostProcess(std::shared_ptr<HBuffer> &frameBuffer, uint32_t index, int32_t status, int ret)
1214 {
1215 if (status == AVCS_ERR_OK) {
1216 codecAvailQue_->Pop();
1217 frameBuffer->owner_ = Owner::OWNED_BY_USER;
1218 if (sInfo_.surface) {
1219 outAVBuffer4Surface_[index]->pts_ = frameBuffer->avBuffer->pts_;
1220 outAVBuffer4Surface_[index]->flag_ = frameBuffer->avBuffer->flag_;
1221 }
1222 callback_->OnOutputBufferAvailable(index, sInfo_.surface ?
1223 outAVBuffer4Surface_[index] : frameBuffer->avBuffer);
1224 } else if (status == AVCS_ERR_UNSUPPORT) {
1225 AVCODEC_LOGE("Recevie frame from codec failed: OnError");
1226 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, AVCodecServiceErrCode::AVCS_ERR_UNSUPPORT);
1227 state_ = State::ERROR;
1228 } else {
1229 AVCODEC_LOGE("Recevie frame from codec failed");
1230 callback_->OnError(AVCodecErrorType::AVCODEC_ERROR_INTERNAL, AVCodecServiceErrCode::AVCS_ERR_UNKNOWN);
1231 state_ = State::ERROR;
1232 }
1233 }
1234
ConvertDecOutToAVFrame(int32_t bitDepth)1235 void HevcDecoder::ConvertDecOutToAVFrame(int32_t bitDepth)
1236 {
1237 if (cachedFrame_ == nullptr) {
1238 cachedFrame_ = std::shared_ptr<AVFrame>(av_frame_alloc(), [](AVFrame *p) { av_frame_free(&p); });
1239 }
1240 cachedFrame_->data[0] = hevcDecoderOutpusArgs_.pucOutYUV[0];
1241 cachedFrame_->data[1] = hevcDecoderOutpusArgs_.pucOutYUV[1]; // 1 u channel
1242 cachedFrame_->data[2] = hevcDecoderOutpusArgs_.pucOutYUV[2]; // 2 v channel
1243 if (bitDepth == BIT_DEPTH8BIT) {
1244 cachedFrame_->format = static_cast<int>(AVPixelFormat::AV_PIX_FMT_YUV420P);
1245 cachedFrame_->linesize[0] = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride);
1246 cachedFrame_->linesize[1] = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride >> 1); // 1 u channel
1247 cachedFrame_->linesize[2] = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride >> 1); // 2 v channel
1248 } else {
1249 cachedFrame_->format = static_cast<int>(AVPixelFormat::AV_PIX_FMT_YUV420P10LE);
1250 cachedFrame_->linesize[0] =
1251 static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride * 2); // 2 10bit per pixel 2bytes
1252 cachedFrame_->linesize[1] = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride); // 1 u channel
1253 cachedFrame_->linesize[2] = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecStride); // 2 v channel
1254 if (outputPixelFmt_ == VideoPixelFormat::NV21) { // exchange uv channel
1255 cachedFrame_->data[1] = hevcDecoderOutpusArgs_.pucOutYUV[2]; // 2 u -> v
1256 cachedFrame_->data[2] = hevcDecoderOutpusArgs_.pucOutYUV[1]; // 2 v -> u
1257 }
1258 }
1259 cachedFrame_->width = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecWidth);
1260 cachedFrame_->height = static_cast<int32_t>(hevcDecoderOutpusArgs_.uiDecHeight);
1261 cachedFrame_->pts = static_cast<int64_t>(hevcDecoderOutpusArgs_.uiTimeStamp);
1262 }
1263
1264 #ifdef BUILD_ENG_VERSION
DumpOutputBuffer(int32_t bitDepth)1265 void HevcDecoder::DumpOutputBuffer(int32_t bitDepth)
1266 {
1267 if (!dumpOutFile_ || !dumpOutFile_->is_open()) {
1268 return;
1269 }
1270 int32_t pixelBytes = 1;
1271 if (bitDepth == BIT_DEPTH10BIT) {
1272 pixelBytes = 2; // 2
1273 }
1274 for (int32_t i = 0; i < cachedFrame_->height; i++) {
1275 dumpOutFile_->write(reinterpret_cast<char *>(cachedFrame_->data[0] + i * cachedFrame_->linesize[0]),
1276 static_cast<int32_t>(cachedFrame_->width * pixelBytes));
1277 }
1278 for (int32_t i = 0; i < cachedFrame_->height / 2; i++) { // 2
1279 dumpOutFile_->write(reinterpret_cast<char *>(cachedFrame_->data[1] + i * cachedFrame_->linesize[1]),
1280 static_cast<int32_t>(cachedFrame_->width * pixelBytes / 2)); // 2
1281 }
1282 for (int32_t i = 0; i < cachedFrame_->height / 2; i++) { // 2
1283 dumpOutFile_->write(reinterpret_cast<char *>(cachedFrame_->data[2] + i * cachedFrame_->linesize[2]),
1284 static_cast<int32_t>(cachedFrame_->width * pixelBytes / 2)); // 2
1285 }
1286 }
1287
DumpConvertOut(struct SurfaceInfo & surfaceInfo)1288 void HevcDecoder::DumpConvertOut(struct SurfaceInfo &surfaceInfo)
1289 {
1290 if (!dumpConvertFile_ || !dumpConvertFile_->is_open()) {
1291 return;
1292 }
1293 if (surfaceInfo.scaleData[0] != nullptr) {
1294 int32_t srcPos = 0;
1295 int32_t dataSize = surfaceInfo.scaleLineSize[0];
1296 int32_t writeSize = dataSize > static_cast<int32_t>(surfaceInfo.surfaceStride) ?
1297 static_cast<int32_t>(surfaceInfo.surfaceStride) : dataSize;
1298 for (int32_t i = 0; i < height_; i++) {
1299 dumpConvertFile_->write(reinterpret_cast<char *>(surfaceInfo.scaleData[0] + srcPos), writeSize);
1300 srcPos += dataSize;
1301 }
1302 srcPos = 0;
1303 dataSize = surfaceInfo.scaleLineSize[1];
1304 writeSize = dataSize > static_cast<int32_t>(surfaceInfo.surfaceStride) ?
1305 static_cast<int32_t>(surfaceInfo.surfaceStride) : dataSize;
1306 for (int32_t i = 0; i < height_ / 2; i++) { // 2
1307 dumpConvertFile_->write(reinterpret_cast<char *>(surfaceInfo.scaleData[1] + srcPos), writeSize);
1308 srcPos += dataSize;
1309 }
1310 }
1311 }
1312 #endif
1313
FindAvailIndex(uint32_t index)1314 void HevcDecoder::FindAvailIndex(uint32_t index)
1315 {
1316 uint32_t curQueSize = renderAvailQue_->Size();
1317 for (uint32_t i = 0u; i < curQueSize; i++) {
1318 uint32_t num = renderAvailQue_->Pop();
1319 if (num == index) {
1320 break;
1321 } else {
1322 renderAvailQue_->Push(num);
1323 }
1324 }
1325 }
1326
RequestBufferFromConsumer()1327 void HevcDecoder::RequestBufferFromConsumer()
1328 {
1329 auto index = renderAvailQue_->Front();
1330 if (!RequestSurfaceBufferOnce(index)) {
1331 AVCODEC_LOGE("get buffer failed.");
1332 return;
1333 }
1334 std::shared_ptr<HBuffer> outputBuffer = buffers_[INDEX_OUTPUT][index];
1335 std::shared_ptr<FSurfaceMemory> surfaceMemory = outputBuffer->sMemory;
1336 auto queSize = renderAvailQue_->Size();
1337 uint32_t curIndex = 0;
1338 uint32_t i = 0;
1339 for (i = 0; i < queSize; i++) {
1340 curIndex = renderAvailQue_->Pop();
1341 if (surfaceMemory->GetBase() == buffers_[INDEX_OUTPUT][curIndex]->avBuffer->memory_->GetAddr() &&
1342 surfaceMemory->GetSize() == buffers_[INDEX_OUTPUT][curIndex]->avBuffer->memory_->GetCapacity()) {
1343 buffers_[INDEX_OUTPUT][index]->sMemory = buffers_[INDEX_OUTPUT][curIndex]->sMemory;
1344 buffers_[INDEX_OUTPUT][curIndex]->sMemory = surfaceMemory;
1345 break;
1346 } else {
1347 renderAvailQue_->Push(curIndex);
1348 }
1349 }
1350 if (i == queSize) {
1351 curIndex = index;
1352 outputBuffer->avBuffer = AVBuffer::CreateAVBuffer(surfaceMemory->GetBase(), surfaceMemory->GetSize());
1353 outputBuffer->width = width_;
1354 outputBuffer->height = height_;
1355 FindAvailIndex(curIndex);
1356 }
1357 buffers_[INDEX_OUTPUT][curIndex]->owner_ = Owner::OWNED_BY_CODEC;
1358 codecAvailQue_->Push(curIndex);
1359 if (renderSurfaceBufferMap_.count(curIndex)) {
1360 renderSurfaceBufferMap_.erase(curIndex);
1361 }
1362 AVCODEC_LOGD("Request output buffer success, index = %{public}u, queSize=%{public}zu, i=%{public}d", curIndex,
1363 queSize, i);
1364 }
1365
BufferReleasedByConsumer(uint64_t surfaceId)1366 GSError HevcDecoder::BufferReleasedByConsumer(uint64_t surfaceId)
1367 {
1368 CHECK_AND_RETURN_RET_LOG(state_ == State::RUNNING || state_ == State::EOS, GSERROR_NO_PERMISSION,
1369 "In valid state");
1370 std::lock_guard<std::mutex> sLock(surfaceMutex_);
1371 CHECK_AND_RETURN_RET_LOG(renderAvailQue_->Size() > 0, GSERROR_NO_BUFFER, "No available buffer");
1372 CHECK_AND_RETURN_RET_LOG(surfaceId == sInfo_.surface->GetUniqueId(), GSERROR_INVALID_ARGUMENTS,
1373 "Ignore callback from old surface");
1374 RequestBufferFromConsumer();
1375 return GSERROR_OK;
1376 }
1377
UnRegisterListenerToSurface(const sptr<Surface> & surface)1378 int32_t HevcDecoder::UnRegisterListenerToSurface(const sptr<Surface> &surface)
1379 {
1380 CHECK_AND_RETURN_RET_LOGD(surface != nullptr, AVCS_ERR_OK, "Surface is null, not need to unregister listener.");
1381 uint64_t surfaceId = surface->GetUniqueId();
1382 std::lock_guard<std::mutex> gLock(g_surfaceMapMutex);
1383 if (g_surfaceCntMap.count(surfaceId) > 0) {
1384 if (g_surfaceCntMap[surfaceId] > 1) {
1385 g_surfaceCntMap[surfaceId] -= 1;
1386 AVCODEC_LOGI("Surface(%{public}" PRIu64 ") not need to unregister listener.", surfaceId);
1387 return AVCS_ERR_OK;
1388 }
1389 CHECK_AND_RETURN_RET_LOGD(g_surfaceCntMap[surfaceId] == 1, AVCS_ERR_OK,
1390 "Surface(%{public}" PRIu64 ") not need to unregister listener.", surfaceId);
1391 GSError err = surface->UnRegisterReleaseListener();
1392 CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, err,
1393 "Surface(%{public}" PRIu64 ") UnRegisterReleaseListener failed, GSError=%{public}d",
1394 surfaceId, err);
1395 g_surfaceCntMap.erase(surfaceId);
1396 AVCODEC_LOGI("Surface(%{public}" PRIu64 ") UnRegisterReleaseListener success.", surfaceId);
1397 }
1398 return AVCS_ERR_OK;
1399 }
1400
RegisterListenerToSurface(const sptr<Surface> & surface)1401 GSError HevcDecoder::RegisterListenerToSurface(const sptr<Surface> &surface)
1402 {
1403 uint64_t surfaceId = surface->GetUniqueId();
1404 wptr<HevcDecoder> wp = this;
1405 GSError err = surface->RegisterReleaseListener([wp, surfaceId](sptr<SurfaceBuffer> &) {
1406 sptr<HevcDecoder> codec = wp.promote();
1407 if (!codec) {
1408 AVCODEC_LOGD("decoder is gone");
1409 return GSERROR_OK;
1410 }
1411 return codec->BufferReleasedByConsumer(surfaceId);
1412 });
1413 if (err == GSERROR_OK) {
1414 StartRequestSurfaceBufferThread();
1415 }
1416 std::lock_guard<std::mutex> gLock(g_surfaceMapMutex);
1417 if (g_surfaceCntMap.count(surfaceId) == 0) {
1418 g_surfaceCntMap.emplace(surfaceId, 1);
1419 } else {
1420 g_surfaceCntMap[surfaceId] += 1;
1421 }
1422 return err;
1423 }
1424
ReleaseOutputBuffer(uint32_t index)1425 int32_t HevcDecoder::ReleaseOutputBuffer(uint32_t index)
1426 {
1427 AVCODEC_SYNC_TRACE;
1428 std::unique_lock<std::mutex> oLock(outputMutex_);
1429 CHECK_AND_RETURN_RET_LOG(index < buffers_[INDEX_OUTPUT].size(), AVCS_ERR_INVALID_VAL,
1430 "Failed to release output buffer: invalid index");
1431 std::shared_ptr<HBuffer> frameBuffer = buffers_[INDEX_OUTPUT][index];
1432 oLock.unlock();
1433 if (frameBuffer->owner_ == Owner::OWNED_BY_USER) {
1434 frameBuffer->owner_ = Owner::OWNED_BY_CODEC;
1435 codecAvailQue_->Push(index);
1436 return AVCS_ERR_OK;
1437 } else {
1438 AVCODEC_LOGE("Release output buffer failed: check your index=%{public}u", index);
1439 return AVCS_ERR_INVALID_VAL;
1440 }
1441 }
1442
Attach(sptr<SurfaceBuffer> surfaceBuffer)1443 int32_t HevcDecoder::Attach(sptr<SurfaceBuffer> surfaceBuffer)
1444 {
1445 int32_t err = sInfo_.surface->AttachBufferToQueue(surfaceBuffer);
1446 CHECK_AND_RETURN_RET_LOG(
1447 err == 0, err, "Surface(%{public}" PRIu64 "), attach buffer(%{public}u) to queue failed, GSError=%{public}d",
1448 sInfo_.surface->GetUniqueId(), surfaceBuffer->GetSeqNum(), err);
1449 return AVCS_ERR_OK;
1450 }
1451
Detach(sptr<SurfaceBuffer> surfaceBuffer)1452 int32_t HevcDecoder::Detach(sptr<SurfaceBuffer> surfaceBuffer)
1453 {
1454 int32_t err = sInfo_.surface->DetachBufferFromQueue(surfaceBuffer);
1455 CHECK_AND_RETURN_RET_LOG(
1456 err == 0, err, "Surface(%{public}" PRIu64 "), detach buffer(%{public}u) to queue failed, GSError=%{public}d",
1457 sInfo_.surface->GetUniqueId(), surfaceBuffer->GetSeqNum(), err);
1458 return AVCS_ERR_OK;
1459 }
1460
FlushSurfaceMemory(std::shared_ptr<FSurfaceMemory> & surfaceMemory,uint32_t index)1461 int32_t HevcDecoder::FlushSurfaceMemory(std::shared_ptr<FSurfaceMemory> &surfaceMemory, uint32_t index)
1462 {
1463 sptr<SurfaceBuffer> surfaceBuffer = surfaceMemory->GetSurfaceBuffer();
1464 CHECK_AND_RETURN_RET_LOG(surfaceBuffer != nullptr, AVCS_ERR_UNKNOWN, "Get surface buffer failed!");
1465 if (!surfaceMemory->isAttached) {
1466 int32_t ret = Attach(surfaceBuffer);
1467 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Surface buffer attach failed!");
1468 surfaceMemory->isAttached = true;
1469 }
1470 OHOS::BufferFlushConfig flushConfig = {{0, 0, surfaceBuffer->GetWidth(), surfaceBuffer->GetHeight()},
1471 outAVBuffer4Surface_[index]->pts_, -1};
1472 surfaceMemory->UpdateSurfaceBufferScaleMode();
1473 if (outAVBuffer4Surface_[index]->meta_->Find(OHOS::Media::Tag::VIDEO_DECODER_DESIRED_PRESENT_TIMESTAMP) !=
1474 outAVBuffer4Surface_[index]->meta_->end()) {
1475 outAVBuffer4Surface_[index]->meta_->Get<OHOS::Media::Tag::VIDEO_DECODER_DESIRED_PRESENT_TIMESTAMP>(
1476 flushConfig.desiredPresentTimestamp);
1477 outAVBuffer4Surface_[index]->meta_->Remove(OHOS::Media::Tag::VIDEO_DECODER_DESIRED_PRESENT_TIMESTAMP);
1478 }
1479 auto res = sInfo_.surface->FlushBuffer(surfaceBuffer, -1, flushConfig);
1480 if (res == GSERROR_BUFFER_NOT_INCACHE) {
1481 AVCODEC_LOGW("Surface(%{public}" PRIu64 "), flush buffer(seq=%{public}u) failed, try to recover",
1482 sInfo_.surface->GetUniqueId(), surfaceBuffer->GetSeqNum());
1483 int32_t ret = ClearSurfaceAndSetQueueSize(sInfo_.surface, outputBufferCnt_);
1484 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Clean surface and set queue size failed!");
1485 ret = Attach(surfaceBuffer);
1486 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Surface buffer attach failed!");
1487 surfaceMemory->isAttached = true;
1488 res = sInfo_.surface->FlushBuffer(surfaceBuffer, -1, flushConfig);
1489 }
1490 surfaceMemory->owner = Owner::OWNED_BY_SURFACE;
1491 if (res != OHOS::SurfaceError::SURFACE_ERROR_OK) {
1492 AVCODEC_LOGW("Failed to update surface memory: %{public}d", res);
1493 return AVCS_ERR_UNKNOWN;
1494 }
1495 renderSurfaceBufferMap_[index] = std::make_pair(surfaceBuffer, flushConfig);
1496 return AVCS_ERR_OK;
1497 }
1498
RenderOutputBuffer(uint32_t index)1499 int32_t HevcDecoder::RenderOutputBuffer(uint32_t index)
1500 {
1501 AVCODEC_SYNC_TRACE;
1502 CHECK_AND_RETURN_RET_LOG(sInfo_.surface != nullptr, AVCS_ERR_UNSUPPORT,
1503 "Render output buffer failed, surface is nullptr!");
1504 std::unique_lock<std::mutex> oLock(outputMutex_);
1505 CHECK_AND_RETURN_RET_LOG(index < buffers_[INDEX_OUTPUT].size(), AVCS_ERR_INVALID_VAL,
1506 "Failed to render output buffer: invalid index");
1507 std::shared_ptr<HBuffer> frameBuffer = buffers_[INDEX_OUTPUT][index];
1508 oLock.unlock();
1509 std::lock_guard<std::mutex> sLock(surfaceMutex_);
1510 if (frameBuffer->owner_ == Owner::OWNED_BY_USER) {
1511 std::shared_ptr<FSurfaceMemory> surfaceMemory = frameBuffer->sMemory;
1512 int32_t ret = FlushSurfaceMemory(surfaceMemory, index);
1513 if (ret != AVCS_ERR_OK) {
1514 AVCODEC_LOGW("Flush surface memory(index=%{public}u) failed: %{public}d", index, ret);
1515 } else {
1516 AVCODEC_LOGD("Flush surface memory(index=%{public}u) successful.", index);
1517 }
1518 frameBuffer->owner_ = Owner::OWNED_BY_SURFACE;
1519 renderAvailQue_->Push(index);
1520 AVCODEC_LOGD("render output buffer with index, index=%{public}u", index);
1521 return AVCS_ERR_OK;
1522 } else {
1523 AVCODEC_LOGE("Failed to render output buffer with bad index, index=%{public}u", index);
1524 return AVCS_ERR_INVALID_VAL;
1525 }
1526 }
1527
ReplaceOutputSurfaceWhenRunning(sptr<Surface> newSurface)1528 int32_t HevcDecoder::ReplaceOutputSurfaceWhenRunning(sptr<Surface> newSurface)
1529 {
1530 CHECK_AND_RETURN_RET_LOG(sInfo_.surface != nullptr, AV_ERR_OPERATE_NOT_PERMIT,
1531 "Not support convert from AVBuffer Mode to Surface Mode");
1532 sptr<Surface> curSurface = sInfo_.surface;
1533 uint64_t oldId = curSurface->GetUniqueId();
1534 uint64_t newId = newSurface->GetUniqueId();
1535 AVCODEC_LOGI("Begin to switch surface %{public}" PRIu64 " -> %{public}" PRIu64 ".", oldId, newId);
1536 if (oldId == newId) {
1537 return AVCS_ERR_OK;
1538 }
1539 GSError err = RegisterListenerToSurface(newSurface);
1540 CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, err,
1541 "surface %{public}" PRIu64 ", RegisterListenerToSurface failed, GSError=%{public}d", newId, err);
1542 int32_t outputBufferCnt = 0;
1543 format_.GetIntValue(MediaDescriptionKey::MD_KEY_MAX_OUTPUT_BUFFER_COUNT, outputBufferCnt);
1544 int32_t ret = SetQueueSize(newSurface, outputBufferCnt);
1545 if (ret != AVCS_ERR_OK) {
1546 UnRegisterListenerToSurface(newSurface);
1547 return ret;
1548 }
1549 std::unique_lock<std::mutex> sLock(surfaceMutex_);
1550 ret = SwitchBetweenSurface(newSurface);
1551 if (ret != AVCS_ERR_OK) {
1552 UnRegisterListenerToSurface(newSurface);
1553 sInfo_.surface = curSurface;
1554 CombineConsumerUsage();
1555 return ret;
1556 }
1557 sLock.unlock();
1558 AVCODEC_LOGI("Switch surface %{public}" PRIu64 " -> %{public}" PRIu64 ".", oldId, newId);
1559 return AVCS_ERR_OK;
1560 }
1561
SetQueueSize(const sptr<Surface> & surface,uint32_t targetSize)1562 int32_t HevcDecoder::SetQueueSize(const sptr<Surface> &surface, uint32_t targetSize)
1563 {
1564 uint64_t surfaceId = surface->GetUniqueId();
1565 int32_t err = surface->SetQueueSize(targetSize);
1566 CHECK_AND_RETURN_RET_LOG(err == 0, err,
1567 "Surface(%{public}" PRIu64 ") set queue size %{public}u failed, GSError=%{public}d",
1568 surfaceId, targetSize, err);
1569 AVCODEC_LOGI("Surface(%{public}" PRIu64 ") set queue size %{public}u succss.", surfaceId, targetSize);
1570 return AVCS_ERR_OK;
1571 }
1572
SwitchBetweenSurface(const sptr<Surface> & newSurface)1573 int32_t HevcDecoder::SwitchBetweenSurface(const sptr<Surface> &newSurface)
1574 {
1575 sptr<Surface> curSurface = sInfo_.surface;
1576 newSurface->Connect(); // cleancache will work only if the surface is connected by us
1577 newSurface->CleanCache(); // make sure new surface is empty
1578 std::vector<uint32_t> ownedBySurfaceBufferIndex;
1579 uint64_t newId = newSurface->GetUniqueId();
1580 for (uint32_t index = 0; index < buffers_[INDEX_OUTPUT].size(); index++) {
1581 auto surfaceMemory = buffers_[INDEX_OUTPUT][index]->sMemory;
1582 if (surfaceMemory == nullptr) {
1583 continue;
1584 }
1585 sptr<SurfaceBuffer> surfaceBuffer = nullptr;
1586 if (buffers_[INDEX_OUTPUT][index]->owner_ == Owner::OWNED_BY_SURFACE) {
1587 if (renderSurfaceBufferMap_.count(index)) {
1588 surfaceBuffer = renderSurfaceBufferMap_[index].first;
1589 ownedBySurfaceBufferIndex.push_back(index);
1590 }
1591 } else {
1592 RequestSurfaceBufferOnce(index);
1593 surfaceBuffer = surfaceMemory->GetSurfaceBuffer();
1594 }
1595 if (surfaceBuffer == nullptr) {
1596 AVCODEC_LOGE("Get old surface buffer error!");
1597 return AVCS_ERR_UNKNOWN;
1598 }
1599 int32_t err = newSurface->AttachBufferToQueue(surfaceBuffer);
1600 if (err != 0) {
1601 AVCODEC_LOGE("surface %{public}" PRIu64 ", AttachBufferToQueue(seq=%{public}u) failed, GSError=%{public}d",
1602 newId, surfaceBuffer->GetSeqNum(), err);
1603 return AVCS_ERR_UNKNOWN;
1604 }
1605 buffers_[INDEX_OUTPUT][index]->sMemory->isAttached = true;
1606 }
1607 int32_t videoRotation = 0;
1608 format_.GetIntValue(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE, videoRotation);
1609 newSurface->SetTransform(TranslateSurfaceRotation(static_cast<VideoRotation>(videoRotation)));
1610 sInfo_.surface = newSurface;
1611 CombineConsumerUsage();
1612 for (uint32_t index: ownedBySurfaceBufferIndex) {
1613 int32_t ret = RenderNewSurfaceWithOldBuffer(newSurface, index);
1614 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Old surface buffer render failed!");
1615 }
1616 int32_t ret = UnRegisterListenerToSurface(curSurface);
1617 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Unregister old surface listener failed!");
1618 curSurface->CleanCache(true); // make sure old surface is empty and go black
1619 return AVCS_ERR_OK;
1620 }
1621
RenderNewSurfaceWithOldBuffer(const sptr<Surface> & newSurface,uint32_t index)1622 int32_t HevcDecoder::RenderNewSurfaceWithOldBuffer(const sptr<Surface> &newSurface, uint32_t index)
1623 {
1624 std::shared_ptr<FSurfaceMemory> surfaceMemory = buffers_[INDEX_OUTPUT][index]->sMemory;
1625 sptr<SurfaceBuffer> surfaceBuffer = renderSurfaceBufferMap_[index].first;
1626 OHOS::BufferFlushConfig flushConfig = renderSurfaceBufferMap_[index].second;
1627 newSurface->SetScalingMode(surfaceBuffer->GetSeqNum(), sInfo_.scalingMode);
1628 auto res = newSurface->FlushBuffer(surfaceBuffer, -1, flushConfig);
1629 if (res != OHOS::SurfaceError::SURFACE_ERROR_OK) {
1630 AVCODEC_LOGE("Failed to update surface memory: %{public}d", res);
1631 return AVCS_ERR_UNKNOWN;
1632 }
1633 return AVCS_ERR_OK;
1634 }
1635
CombineConsumerUsage()1636 void HevcDecoder::CombineConsumerUsage()
1637 {
1638 uint64_t defaultUsage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
1639 uint64_t consumerUsage = sInfo_.surface->GetDefaultUsage();
1640 uint64_t cfgedUsage = sInfo_.requestConfig.usage;
1641 uint64_t finalUsage = defaultUsage | consumerUsage | cfgedUsage;
1642 sInfo_.requestConfig.usage = finalUsage;
1643 AVCODEC_LOGI("Usage: default(0x%{public}" PRIu64 ") | consumer(0x%{public}" PRIu64 ") | cfged(0x%{public}" PRIu64
1644 ") -> final(0x%{public}" PRIu64 ").",
1645 defaultUsage, consumerUsage, cfgedUsage, finalUsage);
1646 }
1647
SetOutputSurface(sptr<Surface> surface)1648 int32_t HevcDecoder::SetOutputSurface(sptr<Surface> surface)
1649 {
1650 AVCODEC_SYNC_TRACE;
1651 CHECK_AND_RETURN_RET_LOG(state_ != State::UNINITIALIZED, AV_ERR_INVALID_VAL,
1652 "set output surface fail: not initialized or configured");
1653 CHECK_AND_RETURN_RET_LOG((state_ == State::CONFIGURED || state_ == State::FLUSHED ||
1654 state_ == State::RUNNING || state_ == State::EOS), AVCS_ERR_INVALID_STATE,
1655 "set output surface fail: state %{public}d not support set output surface",
1656 static_cast<int32_t>(state_.load()));
1657 if (surface == nullptr || surface->IsConsumer()) {
1658 AVCODEC_LOGE("Set surface fail");
1659 return AVCS_ERR_INVALID_VAL;
1660 }
1661 if (state_ == State::FLUSHED || state_ == State::RUNNING || state_ == State::EOS) {
1662 return ReplaceOutputSurfaceWhenRunning(surface);
1663 }
1664 int32_t ret = UnRegisterListenerToSurface(sInfo_.surface);
1665 CHECK_AND_RETURN_RET_LOG(ret == AVCS_ERR_OK, ret, "Unregister listener to surface failed, ret=%{public}d", ret);
1666 uint64_t surfaceId = surface->GetUniqueId();
1667 sInfo_.surface = surface;
1668 CombineConsumerUsage();
1669 GSError err = RegisterListenerToSurface(sInfo_.surface);
1670 CHECK_AND_RETURN_RET_LOG(err == GSERROR_OK, err,
1671 "surface(%{public}" PRIu64 ") register listener to surface failed, GSError=%{public}d",
1672 sInfo_.surface->GetUniqueId(), err);
1673 if (!format_.ContainKey(MediaDescriptionKey::MD_KEY_SCALE_TYPE)) {
1674 format_.PutIntValue(MediaDescriptionKey::MD_KEY_SCALE_TYPE,
1675 static_cast<int32_t>(ScalingMode::SCALING_MODE_SCALE_TO_WINDOW));
1676 }
1677 if (!format_.ContainKey(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE)) {
1678 format_.PutIntValue(MediaDescriptionKey::MD_KEY_ROTATION_ANGLE,
1679 static_cast<int32_t>(VideoRotation::VIDEO_ROTATION_0));
1680 }
1681 AVCODEC_LOGI("Set surface(%{public}" PRIu64 ") success.", surfaceId);
1682 return AVCS_ERR_OK;
1683 }
1684
SetCallback(const std::shared_ptr<MediaCodecCallback> & callback)1685 int32_t HevcDecoder::SetCallback(const std::shared_ptr<MediaCodecCallback> &callback)
1686 {
1687 AVCODEC_SYNC_TRACE;
1688 CHECK_AND_RETURN_RET_LOG(callback != nullptr, AVCS_ERR_INVALID_VAL, "Set callback failed: callback is NULL");
1689 callback_ = callback;
1690 return AVCS_ERR_OK;
1691 }
1692
CheckHevcDecLibStatus()1693 int32_t HevcDecoder::CheckHevcDecLibStatus()
1694 {
1695 void* handle = dlopen(HEVC_DEC_LIB_PATH, RTLD_LAZY);
1696 if (handle != nullptr) {
1697 auto hevcDecoderCreateFunc = reinterpret_cast<CreateHevcDecoderFuncType>(
1698 dlsym(handle, HEVC_DEC_CREATE_FUNC_NAME));
1699 auto hevcDecoderDecodecFrameFunc = reinterpret_cast<DecodeFuncType>(
1700 dlsym(handle, HEVC_DEC_DECODE_FRAME_FUNC_NAME));
1701 auto hevcDecoderFlushFrameFunc = reinterpret_cast<FlushFuncType>(dlsym(handle, HEVC_DEC_FLUSH_FRAME_FUNC_NAME));
1702 auto hevcDecoderDeleteFunc = reinterpret_cast<DeleteFuncType>(dlsym(handle, HEVC_DEC_DELETE_FUNC_NAME));
1703 if (hevcDecoderCreateFunc == nullptr || hevcDecoderDecodecFrameFunc == nullptr ||
1704 hevcDecoderDeleteFunc == nullptr || hevcDecoderFlushFrameFunc == nullptr) {
1705 AVCODEC_LOGE("HevcDecoder hevcFuncMatch_ failed!");
1706 hevcDecoderCreateFunc = nullptr;
1707 hevcDecoderDecodecFrameFunc = nullptr;
1708 hevcDecoderFlushFrameFunc = nullptr;
1709 hevcDecoderDeleteFunc = nullptr;
1710 dlclose(handle);
1711 handle = nullptr;
1712 }
1713 }
1714
1715 if (handle == nullptr) {
1716 return AVCS_ERR_UNSUPPORT;
1717 }
1718 dlclose(handle);
1719 handle = nullptr;
1720
1721 return AVCS_ERR_OK;
1722 }
1723
GetCodecCapability(std::vector<CapabilityData> & capaArray)1724 int32_t HevcDecoder::GetCodecCapability(std::vector<CapabilityData> &capaArray)
1725 {
1726 CHECK_AND_RETURN_RET_LOG(CheckHevcDecLibStatus() == AVCS_ERR_OK, AVCS_ERR_UNSUPPORT,
1727 "hevc decoder libs not available");
1728
1729 for (uint32_t i = 0; i < SUPPORT_HEVC_DECODER_NUM; ++i) {
1730 CapabilityData capsData;
1731 capsData.codecName = static_cast<std::string>(SUPPORT_HEVC_DECODER[i].codecName);
1732 capsData.mimeType = static_cast<std::string>(SUPPORT_HEVC_DECODER[i].mimeType);
1733 capsData.codecType = AVCODEC_TYPE_VIDEO_DECODER;
1734 capsData.isVendor = false;
1735 capsData.maxInstance = VIDEO_INSTANCE_SIZE;
1736 capsData.alignment.width = VIDEO_ALIGNMENT_SIZE;
1737 capsData.alignment.height = VIDEO_ALIGNMENT_SIZE;
1738 capsData.width.minVal = VIDEO_MIN_SIZE;
1739 capsData.width.maxVal = VIDEO_MAX_WIDTH_SIZE;
1740 capsData.height.minVal = VIDEO_MIN_SIZE;
1741 capsData.height.maxVal = VIDEO_MAX_HEIGHT_SIZE;
1742 capsData.blockPerFrame.minVal = 1;
1743 capsData.blockPerFrame.maxVal = VIDEO_BLOCKPERFRAME_SIZE;
1744 capsData.blockPerSecond.minVal = 1;
1745 capsData.blockPerSecond.maxVal = VIDEO_BLOCKPERSEC_SIZE;
1746 capsData.blockSize.width = VIDEO_ALIGN_SIZE;
1747 capsData.blockSize.height = VIDEO_ALIGN_SIZE;
1748 capsData.pixFormat = {static_cast<int32_t>(VideoPixelFormat::NV12),
1749 static_cast<int32_t>(VideoPixelFormat::NV21)};
1750 capsData.profiles = {static_cast<int32_t>(HEVC_PROFILE_MAIN), static_cast<int32_t>(HEVC_PROFILE_MAIN_10)};
1751
1752 std::vector<int32_t> levels;
1753 for (int32_t j = 0; j <= static_cast<int32_t>(HEVCLevel::HEVC_LEVEL_62); ++j) {
1754 levels.emplace_back(j);
1755 }
1756 capsData.profileLevelsMap.insert(std::make_pair(static_cast<int32_t>(HEVC_PROFILE_MAIN), levels));
1757 capsData.profileLevelsMap.insert(std::make_pair(static_cast<int32_t>(HEVC_PROFILE_MAIN_10), levels));
1758 capaArray.emplace_back(capsData);
1759 }
1760 return AVCS_ERR_OK;
1761 }
1762
HevcDecLog(UINT32 channelId,IHW265VIDEO_ALG_LOG_LEVEL eLevel,INT8 * pMsg,...)1763 void HevcDecLog(UINT32 channelId, IHW265VIDEO_ALG_LOG_LEVEL eLevel, INT8 *pMsg, ...)
1764 {
1765 va_list args;
1766 int32_t maxSize = 1024; // 1024 max size of one log
1767 std::vector<char> buf(maxSize);
1768 va_start(args, reinterpret_cast<const char*>(pMsg));
1769 int32_t size = vsnprintf_s(buf.data(), buf.size(), buf.size()-1, reinterpret_cast<const char*>(pMsg), args);
1770 va_end(args);
1771 if (size >= maxSize) {
1772 size = maxSize - 1;
1773 }
1774
1775 auto msg = std::string(buf.data(), size);
1776
1777 if (eLevel <= IHW265VIDEO_ALG_LOG_ERROR) {
1778 switch (eLevel) {
1779 case IHW265VIDEO_ALG_LOG_ERROR: {
1780 AVCODEC_LOGE("%{public}s", msg.c_str());
1781 break;
1782 }
1783 case IHW265VIDEO_ALG_LOG_WARNING: {
1784 AVCODEC_LOGW("%{public}s", msg.c_str());
1785 break;
1786 }
1787 case IHW265VIDEO_ALG_LOG_INFO: {
1788 AVCODEC_LOGI("%{public}s", msg.c_str());
1789 break;
1790 }
1791 case IHW265VIDEO_ALG_LOG_DEBUG: {
1792 AVCODEC_LOGD("%{public}s", msg.c_str());
1793 break;
1794 }
1795 default: {
1796 AVCODEC_LOGI("%{public}s", msg.c_str());
1797 break;
1798 }
1799 }
1800 }
1801
1802 return;
1803 }
1804
1805 std::mutex HevcDecoder::decoderCountMutex_;
1806 std::vector<uint32_t> HevcDecoder::decInstanceIDSet_;
1807 std::vector<uint32_t> HevcDecoder::freeIDSet_;
1808
1809 } // namespace Codec
1810 } // namespace MediaAVCodec
1811 } // namespace OHOS
1812