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 "input.h"
17
18 namespace OHOS {
19 namespace Rosen {
DoProcess(ProcessData & data)20 void Input::DoProcess(ProcessData& data)
21 {
22 if (format_ == "image/jpg" || format_ == "image/png") {
23 DecodeFromFile(data);
24 } else if (format_ == "pixelMap") {
25 DecodeFromPixelMap(data);
26 } else if (format_ == "buffer") {
27 DecodeFromBuffer(data);
28 }
29 }
30
DecodeFromFile(ProcessData & data)31 void Input::DecodeFromFile(ProcessData& data)
32 {
33 uint32_t errorCode = 0;
34 OHOS::Media::SourceOptions sourceOpts;
35 sourceOpts.formatHint = format_;
36 std::unique_ptr<OHOS::Media::ImageSource> imageSource =
37 OHOS::Media::ImageSource::CreateImageSource(srcImagePath_, sourceOpts, errorCode);
38 OHOS::Media::DecodeOptions decodeOpts;
39 if (imageSource == nullptr) {
40 LOGD("Failed to create imageSource!");
41 return;
42 }
43 pixelMap_ = imageSource->CreatePixelMap(decodeOpts, errorCode);
44 DecodeFromPixelMap(data);
45 }
46
DecodeFromPixelMap(ProcessData & data)47 void Input::DecodeFromPixelMap(ProcessData& data)
48 {
49 if (pixelMap_ == nullptr) {
50 LOGD("Failed to create PixelMap!");
51 return;
52 }
53 data.textureWidth = pixelMap_->GetWidth();
54 data.textureHeight = pixelMap_->GetHeight();
55
56 glBindTexture(GL_TEXTURE_2D, data.srcTextureID);
57 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
58 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data.textureWidth, data.textureHeight,
59 0, GL_RGBA, GL_UNSIGNED_BYTE, pixelMap_->GetPixels());
60 glGenerateMipmap(GL_TEXTURE_2D);
61 }
62
DecodeFromBuffer(ProcessData & data)63 void Input::DecodeFromBuffer(ProcessData& data)
64 {
65 if (buffer_ == nullptr) {
66 return;
67 }
68 data.textureWidth = bufferWidth_;
69 data.textureHeight = bufferHeight_;
70 glBindTexture(GL_TEXTURE_2D, data.srcTextureID);
71 glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
72 glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, data.textureWidth, data.textureHeight,
73 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer_.get());
74 glGenerateMipmap(GL_TEXTURE_2D);
75 }
GetFilterType()76 FILTER_TYPE Input::GetFilterType()
77 {
78 return FILTER_TYPE::INPUT;
79 }
80
SetValue(const std::string & key,std::shared_ptr<void> value,int size)81 void Input::SetValue(const std::string& key, std::shared_ptr<void> value, int size)
82 {
83 if (key == "format" && size > 0) {
84 std::shared_ptr<std::string> format = std::static_pointer_cast<std::string>(value);
85 format_ = *(format.get());
86 if (format_ == "jpg" || format_ == "jpeg") {
87 format_ = "image/jpg";
88 } else if (format_ == "png") {
89 format_ = "image/png";
90 } else if (format_ == "pixelMap") {
91 format_ = "pixelMap";
92 } else if (format_ == "buffer") {
93 format_ = "buffer";
94 }
95 LOGD("The input format is %{public}s.", format_.c_str());
96 } else if (key == "src" && size > 0) {
97 if (format_ == "image/jpg" || format_ == "image/png") {
98 std::shared_ptr<std::string> srcImagePath = std::static_pointer_cast<std::string>(value);
99 srcImagePath_ = *(srcImagePath.get());
100 LOGD("The input source image path is %{public}s.", srcImagePath_.c_str());
101 } else if (format_ == "pixelMap") {
102 pixelMap_ = std::static_pointer_cast<OHOS::Media::PixelMap>(value);
103 } else if (format_ == "buffer") {
104 buffer_ = std::static_pointer_cast<uint8_t>(value);
105 }
106 } else if (key == "bufferWidth" && size > 0) {
107 std::shared_ptr<int> bufferWidth = std::static_pointer_cast<int>(value);
108 bufferWidth_ = *(bufferWidth.get());
109 } else if (key == "bufferHeight" && size > 0) {
110 std::shared_ptr<int> bufferHeight = std::static_pointer_cast<int>(value);
111 bufferHeight_ = *(bufferHeight.get());
112 }
113 }
114 } // namespcae Rosen
115 } // namespace OHOS