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