1 /*
2 * Copyright (c) 2022 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "encode_data_process.h"
17
18 #include <cmath>
19
20 #include "distributed_hardware_log.h"
21 #include "graphic_common_c.h"
22
23 #include "dcamera_hisysevent_adapter.h"
24 #include "dcamera_utils_tools.h"
25 #include "encode_video_callback.h"
26
27 #ifndef DH_LOG_TAG
28 #define DH_LOG_TAG "DCDP_NODE_ENCODEC"
29 #endif
30
31 namespace OHOS {
32 namespace DistributedHardware {
33 const std::map<int64_t, int32_t> EncodeDataProcess::ENCODER_BITRATE_TABLE = {
34 std::map<int64_t, int32_t>::value_type(WIDTH_320_HEIGHT_240, BITRATE_500000),
35 std::map<int64_t, int32_t>::value_type(WIDTH_480_HEIGHT_360, BITRATE_1110000),
36 std::map<int64_t, int32_t>::value_type(WIDTH_640_HEIGHT_360, BITRATE_1500000),
37 std::map<int64_t, int32_t>::value_type(WIDTH_640_HEIGHT_480, BITRATE_1800000),
38 std::map<int64_t, int32_t>::value_type(WIDTH_720_HEIGHT_540, BITRATE_2100000),
39 std::map<int64_t, int32_t>::value_type(WIDTH_960_HEIGHT_540, BITRATE_2300000),
40 std::map<int64_t, int32_t>::value_type(WIDTH_960_HEIGHT_720, BITRATE_2800000),
41 std::map<int64_t, int32_t>::value_type(WIDTH_1280_HEIGHT_720, BITRATE_3400000),
42 std::map<int64_t, int32_t>::value_type(WIDTH_1440_HEIGHT_1080, BITRATE_5000000),
43 std::map<int64_t, int32_t>::value_type(WIDTH_1920_HEIGHT_1080, BITRATE_6000000),
44 };
45 const string ENUM_VIDEOFORMAT_STRINGS[] = {
46 "YUVI420", "NV12", "NV21", "RGBA_8888"
47 };
48
~EncodeDataProcess()49 EncodeDataProcess::~EncodeDataProcess()
50 {
51 if (isEncoderProcess_.load()) {
52 DHLOGD("~EncodeDataProcess : ReleaseProcessNode.");
53 ReleaseProcessNode();
54 }
55 }
56
InitNode(const VideoConfigParams & sourceConfig,const VideoConfigParams & targetConfig,VideoConfigParams & processedConfig)57 int32_t EncodeDataProcess::InitNode(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig,
58 VideoConfigParams& processedConfig)
59 {
60 DHLOGD("Common Init DCamera EncodeNode start.");
61 if (!(IsInEncoderRange(sourceConfig) && IsInEncoderRange(targetConfig))) {
62 DHLOGE("Common Source config or target config are invalid.");
63 return DCAMERA_BAD_VALUE;
64 }
65 if (!IsConvertible(sourceConfig, targetConfig)) {
66 DHLOGE("Common The EncodeNode cannot convert source VideoCodecType %d to target VideoCodecType %d.",
67 sourceConfig.GetVideoCodecType(), targetConfig.GetVideoCodecType());
68 return DCAMERA_BAD_TYPE;
69 }
70
71 sourceConfig_ = sourceConfig;
72 targetConfig_ = targetConfig;
73 if (sourceConfig_.GetVideoCodecType() == targetConfig_.GetVideoCodecType()) {
74 DHLOGD("Common Disable EncodeNode. The target VideoCodecType %d is the same as the source VideoCodecType %d.",
75 sourceConfig_.GetVideoCodecType(), targetConfig_.GetVideoCodecType());
76 processedConfig_ = sourceConfig;
77 processedConfig = processedConfig_;
78 isEncoderProcess_.store(true);
79 return DCAMERA_OK;
80 }
81
82 int32_t err = InitEncoder();
83 if (err != DCAMERA_OK) {
84 DHLOGE("Common Init video encoder failed.");
85 ReleaseProcessNode();
86 return err;
87 }
88 processedConfig = processedConfig_;
89 isEncoderProcess_.store(true);
90 return DCAMERA_OK;
91 }
92
IsInEncoderRange(const VideoConfigParams & curConfig)93 bool EncodeDataProcess::IsInEncoderRange(const VideoConfigParams& curConfig)
94 {
95 return (curConfig.GetWidth() >= MIN_VIDEO_WIDTH || curConfig.GetWidth() <= MAX_VIDEO_WIDTH ||
96 curConfig.GetHeight() >= MIN_VIDEO_HEIGHT || curConfig.GetHeight() <= MAX_VIDEO_HEIGHT ||
97 curConfig.GetFrameRate() >= MIN_FRAME_RATE || curConfig.GetFrameRate() <= MAX_FRAME_RATE);
98 }
99
IsConvertible(const VideoConfigParams & sourceConfig,const VideoConfigParams & targetConfig)100 bool EncodeDataProcess::IsConvertible(const VideoConfigParams& sourceConfig, const VideoConfigParams& targetConfig)
101 {
102 return (sourceConfig.GetVideoCodecType() == targetConfig.GetVideoCodecType() ||
103 sourceConfig.GetVideoCodecType() == VideoCodecType::NO_CODEC);
104 }
105
InitEncoder()106 int32_t EncodeDataProcess::InitEncoder()
107 {
108 DHLOGD("Common Init video encoder.");
109 int32_t ret = ConfigureVideoEncoder();
110 if (ret != DCAMERA_OK) {
111 DHLOGE("Init video encoder metadata format failed. Error code %d.", ret);
112 return ret;
113 }
114
115 ret = StartVideoEncoder();
116 if (ret != DCAMERA_OK) {
117 DHLOGE("Start Video encoder failed.");
118 ReportDcamerOptFail(DCAMERA_OPT_FAIL, DCAMERA_ENCODE_ERROR,
119 CreateMsg("start video encoder failed, width: %d, height: %d, format: %s", sourceConfig_.GetWidth(),
120 sourceConfig_.GetHeight(),
121 ENUM_VIDEOFORMAT_STRINGS[static_cast<int32_t>(sourceConfig_.GetVideoformat())].c_str()));
122 return ret;
123 }
124
125 return DCAMERA_OK;
126 }
127
ConfigureVideoEncoder()128 int32_t EncodeDataProcess::ConfigureVideoEncoder()
129 {
130 int32_t ret = InitEncoderMetadataFormat();
131 if (ret != DCAMERA_OK) {
132 DHLOGE("Init video encoder metadata format failed. Error code %d.", ret);
133 return ret;
134 }
135 ret = InitEncoderBitrateFormat();
136 if (ret != DCAMERA_OK) {
137 DHLOGE("Init video encoder bitrate format failed. Error code %d.", ret);
138 return ret;
139 }
140
141 videoEncoder_ = Media::VideoEncoderFactory::CreateByMime(processType_);
142 if (videoEncoder_ == nullptr) {
143 DHLOGE("Create video encoder failed.");
144 return DCAMERA_INIT_ERR;
145 }
146 encodeVideoCallback_ = std::make_shared<EncodeVideoCallback>(shared_from_this());
147 ret = videoEncoder_->SetCallback(encodeVideoCallback_);
148 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
149 DHLOGE("Set video encoder callback failed. Error code %d.", ret);
150 return DCAMERA_INIT_ERR;
151 }
152
153 ret = videoEncoder_->Configure(metadataFormat_);
154 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
155 DHLOGE("Set video encoder metadata format failed. Error code %d.", ret);
156 return DCAMERA_INIT_ERR;
157 }
158
159 encodeProducerSurface_ = videoEncoder_->CreateInputSurface();
160 if (encodeProducerSurface_ == nullptr) {
161 DHLOGE("Get video encoder producer surface failed.");
162 return DCAMERA_INIT_ERR;
163 }
164
165 return DCAMERA_OK;
166 }
167
InitEncoderMetadataFormat()168 int32_t EncodeDataProcess::InitEncoderMetadataFormat()
169 {
170 DHLOGD("Common Init video encoder metadata format.");
171
172 processedConfig_ = sourceConfig_;
173
174 processType_ = "video/mp4v-es";
175 metadataFormat_.PutStringValue("codec_mime", processType_);
176 metadataFormat_.PutIntValue("codec_profile", Media::MPEG4Profile::MPEG4_PROFILE_ADVANCED_CODING);
177
178 processedConfig_.SetVideoCodecType(VideoCodecType::CODEC_MPEG4);
179
180 metadataFormat_.PutIntValue("pixel_format", Media::VideoPixelFormat::RGBA);
181 metadataFormat_.PutLongValue("max_input_size", NORM_RGB32_BUFFER_SIZE);
182 metadataFormat_.PutIntValue("width", sourceConfig_.GetWidth());
183 metadataFormat_.PutIntValue("height", sourceConfig_.GetHeight());
184 metadataFormat_.PutIntValue("frame_rate", MAX_FRAME_RATE);
185 return DCAMERA_OK;
186 }
187
InitEncoderBitrateFormat()188 int32_t EncodeDataProcess::InitEncoderBitrateFormat()
189 {
190 DHLOGD("Init video encoder bitrate format.");
191 if (!(IsInEncoderRange(sourceConfig_) && IsInEncoderRange(targetConfig_))) {
192 DHLOGE("Source config or target config are invalid.");
193 return DCAMERA_BAD_VALUE;
194 }
195 metadataFormat_.PutIntValue("i_frame_interval", IDR_FRAME_INTERVAL_MS);
196 metadataFormat_.PutIntValue("video_encode_bitrate_mode", Media::VideoEncodeBitrateMode::VBR);
197
198 if (ENCODER_BITRATE_TABLE.empty()) {
199 DHLOGD("ENCODER_BITRATE_TABLE is null, use the default bitrate of the encoder.");
200 return DCAMERA_OK;
201 }
202 int64_t pixelformat = static_cast<int64_t>(sourceConfig_.GetWidth() * sourceConfig_.GetHeight());
203 int32_t matchedBitrate = BITRATE_6000000;
204 int64_t minPixelformatDiff = WIDTH_1920_HEIGHT_1080 - pixelformat;
205 for (auto it = ENCODER_BITRATE_TABLE.begin(); it != ENCODER_BITRATE_TABLE.end(); it++) {
206 int64_t pixelformatDiff = abs(pixelformat - it->first);
207 if (pixelformatDiff == 0) {
208 matchedBitrate = it->second;
209 break;
210 }
211 if (minPixelformatDiff >= pixelformatDiff) {
212 minPixelformatDiff = pixelformatDiff;
213 matchedBitrate = it->second;
214 }
215 }
216 DHLOGD("Source config: width : %d, height : %d, matched bitrate %d.", sourceConfig_.GetWidth(),
217 sourceConfig_.GetHeight(), matchedBitrate);
218 metadataFormat_.PutIntValue("bitrate", matchedBitrate);
219 return DCAMERA_OK;
220 }
221
StartVideoEncoder()222 int32_t EncodeDataProcess::StartVideoEncoder()
223 {
224 if (videoEncoder_ == nullptr) {
225 DHLOGE("The video encoder does not exist before StopVideoEncoder.");
226 return DCAMERA_BAD_VALUE;
227 }
228
229 int32_t ret = videoEncoder_->Prepare();
230 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
231 DHLOGE("Video encoder prepare failed. Error code %d.", ret);
232 return DCAMERA_INIT_ERR;
233 }
234 ret = videoEncoder_->Start();
235 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
236 DHLOGE("Video encoder start failed. Error code %d.", ret);
237 return DCAMERA_INIT_ERR;
238 }
239 return DCAMERA_OK;
240 }
241
StopVideoEncoder()242 int32_t EncodeDataProcess::StopVideoEncoder()
243 {
244 if (videoEncoder_ == nullptr) {
245 DHLOGE("The video encoder does not exist before StopVideoEncoder.");
246 return DCAMERA_BAD_VALUE;
247 }
248
249 bool isSuccess = true;
250 int32_t ret = videoEncoder_->Flush();
251 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
252 DHLOGE("VideoEncoder flush failed. Error type: %d.", ret);
253 isSuccess = isSuccess && false;
254 }
255 ret = videoEncoder_->Stop();
256 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
257 DHLOGE("VideoEncoder stop failed. Error type: %d.", ret);
258 isSuccess = isSuccess && false;
259 }
260
261 if (!isSuccess) {
262 return DCAMERA_BAD_OPERATE;
263 }
264 return DCAMERA_OK;
265 }
266
ReleaseVideoEncoder()267 void EncodeDataProcess::ReleaseVideoEncoder()
268 {
269 std::lock_guard<std::mutex> lck(mtxEncoderState_);
270 DHLOGD("Start release videoEncoder.");
271 if (videoEncoder_ == nullptr) {
272 DHLOGE("The video encoder does not exist before ReleaseVideoEncoder.");
273 encodeProducerSurface_ = nullptr;
274 encodeVideoCallback_ = nullptr;
275 return;
276 }
277 int32_t ret = StopVideoEncoder();
278 if (ret != DCAMERA_OK) {
279 DHLOGE("StopVideoEncoder failed.");
280 }
281 ret = videoEncoder_->Release();
282 if (ret != Media::MediaServiceErrCode::MSERR_OK) {
283 DHLOGE("VideoEncoder release failed. Error type: %d.", ret);
284 }
285 encodeProducerSurface_ = nullptr;
286 videoEncoder_ = nullptr;
287 encodeVideoCallback_ = nullptr;
288 DHLOGD("Start release videoEncoder success.");
289 }
290
ReleaseProcessNode()291 void EncodeDataProcess::ReleaseProcessNode()
292 {
293 DHLOGD("Start release [%d] node : EncodeNode.", nodeRank_);
294 isEncoderProcess_.store(false);
295 ReleaseVideoEncoder();
296
297 waitEncoderOutputCount_ = 0;
298 lastFeedEncoderInputBufferTimeUs_ = 0;
299 inputTimeStampUs_ = 0;
300 processType_ = "";
301
302 if (nextDataProcess_ != nullptr) {
303 nextDataProcess_->ReleaseProcessNode();
304 nextDataProcess_ = nullptr;
305 }
306 DHLOGD("Release [%d] node : EncodeNode end.", nodeRank_);
307 }
308
ProcessData(std::vector<std::shared_ptr<DataBuffer>> & inputBuffers)309 int32_t EncodeDataProcess::ProcessData(std::vector<std::shared_ptr<DataBuffer>>& inputBuffers)
310 {
311 DHLOGD("Process data in EncodeDataProcess.");
312 if (inputBuffers.empty()) {
313 DHLOGE("The input data buffers is empty.");
314 return DCAMERA_BAD_VALUE;
315 }
316 if (sourceConfig_.GetVideoCodecType() == processedConfig_.GetVideoCodecType()) {
317 DHLOGD("The target VideoCodecType : %d is the same as the source VideoCodecType : %d.",
318 sourceConfig_.GetVideoCodecType(), processedConfig_.GetVideoCodecType());
319 return EncodeDone(inputBuffers);
320 }
321
322 if (videoEncoder_ == nullptr) {
323 DHLOGE("The video encoder does not exist before encoding data.");
324 return DCAMERA_INIT_ERR;
325 }
326
327 if (inputBuffers[0]->Size() > NORM_RGB32_BUFFER_SIZE) {
328 DHLOGE("EncodeNode input buffer size %d error.", inputBuffers[0]->Size());
329 return DCAMERA_MEMORY_OPT_ERROR;
330 }
331 if (!isEncoderProcess_.load()) {
332 DHLOGE("EncodeNode occurred error or start release.");
333 return DCAMERA_DISABLE_PROCESS;
334 }
335 int32_t err = FeedEncoderInputBuffer(inputBuffers[0]);
336 if (err != DCAMERA_OK) {
337 DHLOGE("Feed encoder input Buffer fail.");
338 return err;
339 }
340
341 IncreaseWaitEncodeCnt();
342 return DCAMERA_OK;
343 }
344
FeedEncoderInputBuffer(std::shared_ptr<DataBuffer> & inputBuffer)345 int32_t EncodeDataProcess::FeedEncoderInputBuffer(std::shared_ptr<DataBuffer>& inputBuffer)
346 {
347 std::lock_guard<std::mutex> lck(mtxEncoderState_);
348 DHLOGD("Feed encoder input buffer, buffer size %d.", inputBuffer->Size());
349 if (encodeProducerSurface_ == nullptr) {
350 DHLOGE("Get encoder input producer surface failed.");
351 return DCAMERA_INIT_ERR;
352 }
353
354 sptr<SurfaceBuffer> surfacebuffer = GetEncoderInputSurfaceBuffer();
355 if (surfacebuffer == nullptr) {
356 DHLOGE("Get encoder input producer surface buffer failed.");
357 return DCAMERA_BAD_OPERATE;
358 }
359 uint8_t *addr = static_cast<uint8_t *>(surfacebuffer->GetVirAddr());
360 if (addr == nullptr) {
361 DHLOGE("SurfaceBuffer address is nullptr");
362 encodeProducerSurface_->CancelBuffer(surfacebuffer);
363 return DCAMERA_BAD_OPERATE;
364 }
365 size_t size = static_cast<size_t>(surfacebuffer->GetSize());
366 errno_t err = memcpy_s(addr, size, inputBuffer->Data(), inputBuffer->Size());
367 if (err != EOK) {
368 DHLOGE("memcpy_s encoder input producer surface buffer failed, surBufSize %z.", size);
369 return DCAMERA_MEMORY_OPT_ERROR;
370 }
371
372 inputTimeStampUs_ = GetEncoderTimeStamp();
373 DHLOGD("Encoder input buffer size %d, timeStamp %lld.", inputBuffer->Size(), (long long)inputTimeStampUs_);
374 surfacebuffer->GetExtraData()->ExtraSet("timeStamp", inputTimeStampUs_);
375
376 BufferFlushConfig flushConfig = { {0, 0, sourceConfig_.GetWidth(), sourceConfig_.GetHeight()}, 0};
377 SurfaceError ret = encodeProducerSurface_->FlushBuffer(surfacebuffer, -1, flushConfig);
378 if (ret != SURFACE_ERROR_OK) {
379 DHLOGE("Flush encoder input producer surface buffer failed.");
380 return DCAMERA_BAD_OPERATE;
381 }
382 return DCAMERA_OK;
383 }
384
GetEncoderInputSurfaceBuffer()385 sptr<SurfaceBuffer> EncodeDataProcess::GetEncoderInputSurfaceBuffer()
386 {
387 BufferRequestConfig requestConfig;
388 requestConfig.width = sourceConfig_.GetWidth();
389 requestConfig.height = sourceConfig_.GetHeight();
390 requestConfig.usage = BUFFER_USAGE_CPU_READ | BUFFER_USAGE_CPU_WRITE | BUFFER_USAGE_MEM_DMA;
391 requestConfig.timeout = 0;
392 requestConfig.strideAlignment = ENCODER_STRIDE_ALIGNMENT;
393 requestConfig.format = PixelFormat::PIXEL_FMT_RGBA_8888;
394 sptr<SurfaceBuffer> surfacebuffer = nullptr;
395 int32_t flushFence = -1;
396 GSError err = encodeProducerSurface_->RequestBuffer(surfacebuffer, flushFence, requestConfig);
397 if (err != GSERROR_OK || surfacebuffer == nullptr) {
398 DHLOGE("Request encoder input producer surface buffer failed, error code: %d.", err);
399 }
400 return surfacebuffer;
401 }
402
GetEncoderTimeStamp()403 int64_t EncodeDataProcess::GetEncoderTimeStamp()
404 {
405 const int64_t nsPerUs = 1000L;
406 int64_t nowTimeUs = GetNowTimeStampUs() * nsPerUs;
407 return nowTimeUs;
408 }
409
IncreaseWaitEncodeCnt()410 void EncodeDataProcess::IncreaseWaitEncodeCnt()
411 {
412 std::lock_guard<std::mutex> lck(mtxHoldCount_);
413 if (inputTimeStampUs_ == 0) {
414 waitEncoderOutputCount_ += FIRST_FRAME_OUTPUT_NUM;
415 } else {
416 waitEncoderOutputCount_++;
417 }
418 DHLOGD("Wait encoder output frames number is %d.", waitEncoderOutputCount_);
419 }
420
ReduceWaitEncodeCnt()421 void EncodeDataProcess::ReduceWaitEncodeCnt()
422 {
423 std::lock_guard<std::mutex> lck(mtxHoldCount_);
424 if (waitEncoderOutputCount_ <= 0) {
425 DHLOGE("The waitEncoderOutputCount_ = %d.", waitEncoderOutputCount_);
426 }
427 waitEncoderOutputCount_--;
428 DHLOGD("Wait encoder output frames number is %d.", waitEncoderOutputCount_);
429 }
430
GetEncoderOutputBuffer(uint32_t index,Media::AVCodecBufferInfo info)431 int32_t EncodeDataProcess::GetEncoderOutputBuffer(uint32_t index, Media::AVCodecBufferInfo info)
432 {
433 DHLOGD("Get encoder output buffer.");
434 if (videoEncoder_ == nullptr) {
435 DHLOGE("The video encoder does not exist before output encoded data.");
436 return DCAMERA_BAD_VALUE;
437 }
438 std::shared_ptr<Media::AVSharedMemory> sharedMemoryOutput = videoEncoder_->GetOutputBuffer(index);
439 if (sharedMemoryOutput == nullptr) {
440 DHLOGE("Failed to get the output shared memory, index : %d", index);
441 return DCAMERA_BAD_OPERATE;
442 }
443
444 if (info.size <= 0 || info.size > DATABUFF_MAX_SIZE) {
445 DHLOGE("AVCodecBufferInfo error, buffer size : %d", info.size);
446 return DCAMERA_BAD_VALUE;
447 }
448
449 size_t outputMemoDataSize = static_cast<size_t>(info.size);
450 DHLOGD("Encoder output buffer size : %d", outputMemoDataSize);
451 std::shared_ptr<DataBuffer> bufferOutput = std::make_shared<DataBuffer>(outputMemoDataSize);
452 errno_t err = memcpy_s(bufferOutput->Data(), bufferOutput->Size(),
453 sharedMemoryOutput->GetBase(), outputMemoDataSize);
454 if (err != EOK) {
455 DHLOGE("memcpy_s buffer failed.");
456 return DCAMERA_MEMORY_OPT_ERROR;
457 }
458 bufferOutput->SetInt64("timeUs", info.presentationTimeUs);
459
460 std::vector<std::shared_ptr<DataBuffer>> nextInputBuffers;
461 nextInputBuffers.push_back(bufferOutput);
462 return EncodeDone(nextInputBuffers);
463 }
464
EncodeDone(std::vector<std::shared_ptr<DataBuffer>> & outputBuffers)465 int32_t EncodeDataProcess::EncodeDone(std::vector<std::shared_ptr<DataBuffer>>& outputBuffers)
466 {
467 DHLOGD("Encoder done.");
468 if (outputBuffers.empty()) {
469 DHLOGE("The received data buffers is empty.");
470 return DCAMERA_BAD_VALUE;
471 }
472
473 if (nextDataProcess_ != nullptr) {
474 DHLOGD("Send to the next node of the encoder for processing.");
475 int32_t err = nextDataProcess_->ProcessData(outputBuffers);
476 if (err != DCAMERA_OK) {
477 DHLOGE("Someone node after the encoder processes fail.");
478 }
479 return err;
480 }
481 DHLOGD("The current node is the last node, and Output the processed video buffer");
482 std::shared_ptr<DCameraPipelineSink> targetPipelineSink = callbackPipelineSink_.lock();
483 if (targetPipelineSink == nullptr) {
484 DHLOGE("callbackPipelineSink_ is nullptr.");
485 return DCAMERA_BAD_VALUE;
486 }
487 targetPipelineSink->OnProcessedVideoBuffer(outputBuffers[0]);
488 return DCAMERA_OK;
489 }
490
OnError()491 void EncodeDataProcess::OnError()
492 {
493 DHLOGD("EncodeDataProcess : OnError.");
494 isEncoderProcess_.store(false);
495 if (videoEncoder_ != nullptr) {
496 videoEncoder_->Flush();
497 videoEncoder_->Stop();
498 }
499 std::shared_ptr<DCameraPipelineSink> targetPipelineSink = callbackPipelineSink_.lock();
500 if (targetPipelineSink == nullptr) {
501 DHLOGE("callbackPipelineSink_ is nullptr.");
502 return;
503 }
504 targetPipelineSink->OnError(DataProcessErrorType::ERROR_PIPELINE_ENCODER);
505 }
506
OnInputBufferAvailable(uint32_t index)507 void EncodeDataProcess::OnInputBufferAvailable(uint32_t index)
508 {
509 DHLOGD("The available input buffer index : %d. No operation when using surface input.", index);
510 }
511
OnOutputFormatChanged(const Media::Format & format)512 void EncodeDataProcess::OnOutputFormatChanged(const Media::Format &format)
513 {
514 if (encodeOutputFormat_.GetFormatMap().empty()) {
515 DHLOGE("The first changed video encoder output format is null.");
516 return;
517 }
518 encodeOutputFormat_ = format;
519 }
520
OnOutputBufferAvailable(uint32_t index,Media::AVCodecBufferInfo info,Media::AVCodecBufferFlag flag)521 void EncodeDataProcess::OnOutputBufferAvailable(uint32_t index, Media::AVCodecBufferInfo info,
522 Media::AVCodecBufferFlag flag)
523 {
524 if (!isEncoderProcess_.load()) {
525 DHLOGE("EncodeNode occurred error or start release.");
526 return;
527 }
528 DHLOGD("Video encode buffer info: presentation TimeUs %lld, size %d, offset %d, flag %d",
529 info.presentationTimeUs, info.size, info.offset, flag);
530 int32_t err = GetEncoderOutputBuffer(index, info);
531 if (err != DCAMERA_OK) {
532 DHLOGE("Get encode output Buffer fail.");
533 return;
534 }
535 ReduceWaitEncodeCnt();
536
537 if (videoEncoder_ == nullptr) {
538 DHLOGE("The video encoder does not exist before release output buffer index.");
539 return;
540 }
541 int32_t errRelease = videoEncoder_->ReleaseOutputBuffer(index);
542 if (errRelease != Media::MediaServiceErrCode::MSERR_OK) {
543 DHLOGE("The video encoder release output buffer fail, index : [%d].", index);
544 }
545 }
GetSourceConfig() const546 VideoConfigParams EncodeDataProcess::GetSourceConfig() const
547 {
548 return sourceConfig_;
549 }
550
GetTargetConfig() const551 VideoConfigParams EncodeDataProcess::GetTargetConfig() const
552 {
553 return targetConfig_;
554 }
555 } // namespace DistributedHardware
556 } // namespace OHOS
557