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 #include "image_packer_native_impl.h"
16 #include "image_source_native_impl.h"
17 #include "pixelmap_native_impl.h"
18 #include "picture_native_impl.h"
19 using namespace OHOS;
20 using namespace Media;
21 #ifdef __cplusplus
22 extern "C" {
23 #endif
24
25 constexpr int32_t defaultBufferSize = 25 * 1024 * 1024;
26
OH_ImagePackerNative()27 OH_ImagePackerNative::OH_ImagePackerNative()
28 {
29 imagePacker_ = std::make_shared<OHOS::Media::ImagePacker>();
30 }
31
OH_ImagePackerNative(std::shared_ptr<OHOS::Media::ImagePacker> imagePacker)32 OH_ImagePackerNative::OH_ImagePackerNative(std::shared_ptr<OHOS::Media::ImagePacker> imagePacker)
33 {
34 imagePacker_ = imagePacker;
35 }
36
~OH_ImagePackerNative()37 OH_ImagePackerNative::~OH_ImagePackerNative()
38 {
39 if (imagePacker_) {
40 imagePacker_ = nullptr;
41 }
42 }
43
PackingFromImageSource(OHOS::Media::PackOption * option,OH_ImageSourceNative * imageSource,uint8_t * outData,int64_t * size)44 int32_t OH_ImagePackerNative::PackingFromImageSource(OHOS::Media::PackOption *option, OH_ImageSourceNative *imageSource,
45 uint8_t *outData, int64_t *size)
46 {
47 if (option == nullptr || imageSource == nullptr) {
48 return IMAGE_BAD_PARAMETER;
49 }
50 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
51 OHOS::Media::ImageSource *imageSourcePtr = imageSource->GetInnerImageSource().get();
52 int64_t packedSize = 0;
53 uint32_t ret = IMAGE_SUCCESS;
54 const int64_t DEFAULT_BUFFER_SIZE = 25 * 1024 * 1024;
55 int64_t bufferSize = (*size <= 0) ? DEFAULT_BUFFER_SIZE : (*size);
56 ret = imagePacker->StartPacking(outData, bufferSize, *option);
57 if (ret != IMAGE_SUCCESS) {
58 return ret;
59 }
60 ret = imagePacker->AddImage(*imageSourcePtr);
61 if (ret != IMAGE_SUCCESS) {
62 return ret;
63 }
64 ret = imagePacker->FinalizePacking(packedSize);
65 if (ret != IMAGE_SUCCESS) {
66 return ret;
67 }
68 if (packedSize > 0 && (packedSize < bufferSize)) {
69 *size = packedSize;
70 return IMAGE_SUCCESS;
71 }
72 return IMAGE_ENCODE_FAILED;
73 }
74
PackingFromPixelmap(OHOS::Media::PackOption * option,OH_PixelmapNative * pixelmap,uint8_t * outData,int64_t * size)75 int32_t OH_ImagePackerNative::PackingFromPixelmap(OHOS::Media::PackOption *option, OH_PixelmapNative *pixelmap,
76 uint8_t *outData, int64_t *size)
77 {
78 if (option == nullptr || pixelmap == nullptr) {
79 return IMAGE_BAD_PARAMETER;
80 }
81 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
82 OHOS::Media::PixelMap *pixelmapPtr = pixelmap->GetInnerPixelmap().get();
83 int64_t packedSize = 0;
84 uint32_t ret = IMAGE_SUCCESS;
85 const int64_t DEFAULT_BUFFER_SIZE = 25 * 1024 * 1024;
86 int64_t bufferSize = (*size <= 0) ? DEFAULT_BUFFER_SIZE : (*size);
87 ret = imagePacker->StartPacking(outData, bufferSize, *option);
88 if (ret != IMAGE_SUCCESS) {
89 return ret;
90 }
91 ret = imagePacker->AddImage(*pixelmapPtr);
92 if (ret != IMAGE_SUCCESS) {
93 return ret;
94 }
95 ret = imagePacker->FinalizePacking(packedSize);
96 if (ret != IMAGE_SUCCESS) {
97 return ret;
98 }
99 if (packedSize > 0 && (packedSize < bufferSize)) {
100 *size = packedSize;
101 return IMAGE_SUCCESS;
102 }
103 return IMAGE_ENCODE_FAILED;
104 }
105
PackToDataMultiFrames(OHOS::Media::PackOption * option,std::vector<OH_PixelmapNative * > & pixelmap,uint8_t * outData,int64_t * size)106 int32_t OH_ImagePackerNative::PackToDataMultiFrames(OHOS::Media::PackOption *option,
107 std::vector<OH_PixelmapNative*> &pixelmap, uint8_t *outData, int64_t *size)
108 {
109 if (option == nullptr || pixelmap.empty()) {
110 return IMAGE_BAD_PARAMETER;
111 }
112 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
113 int64_t packedSize = 0;
114 uint32_t ret = IMAGE_SUCCESS;
115 const int64_t DEFAULT_BUFFER_SIZE = 25 * 1024 * 1024;
116 int64_t bufferSize = (*size <= 0) ? DEFAULT_BUFFER_SIZE : (*size);
117 ret = imagePacker->StartPacking(outData, bufferSize, *option);
118 if (ret != IMAGE_SUCCESS) {
119 return ret;
120 }
121 for (int i = 0; i < static_cast<int>(pixelmap.size()); i++) {
122 ret = imagePacker->AddImage(*(pixelmap[i]->GetInnerPixelmap().get()));
123 }
124 if (ret != IMAGE_SUCCESS) {
125 return ret;
126 }
127 ret = imagePacker->FinalizePacking(packedSize);
128 if (ret != IMAGE_SUCCESS) {
129 return ret;
130 }
131 if (packedSize > 0 && (packedSize < bufferSize)) {
132 *size = packedSize;
133 return IMAGE_SUCCESS;
134 }
135 return IMAGE_ENCODE_FAILED;
136 }
137
PackToDataFromPicture(OHOS::Media::PackOption * option,struct OH_PictureNative * picture,uint8_t * outData,int64_t * size)138 int32_t OH_ImagePackerNative::PackToDataFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
139 uint8_t *outData, int64_t *size)
140 {
141 if (option == nullptr || picture == nullptr) {
142 return IMAGE_BAD_PARAMETER;
143 }
144 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
145 OHOS::Media::Picture *picturePtr = picture->GetInnerPicture().get();
146
147 int64_t packedSize = 0;
148 uint32_t ret = IMAGE_ENCODE_FAILED;
149 const int64_t DEFAULT_BUFFER_SIZE = defaultBufferSize;
150 int64_t bufferSize = (*size <= 0) ? DEFAULT_BUFFER_SIZE : (*size);
151 ret = imagePacker->StartPacking(outData, bufferSize, *option);
152 if (ret != IMAGE_SUCCESS) {
153 return ret;
154 }
155 ret = imagePacker->AddPicture(*picturePtr);
156 if (ret != IMAGE_SUCCESS) {
157 return ret;
158 }
159 ret = imagePacker->FinalizePacking(packedSize);
160 if (ret != IMAGE_SUCCESS) {
161 return ret;
162 }
163 if (packedSize > 0 && (packedSize < bufferSize)) {
164 *size = packedSize;
165 return IMAGE_SUCCESS;
166 }
167 return IMAGE_ENCODE_FAILED;
168 }
169
PackToFileFromImageSource(OHOS::Media::PackOption * option,OH_ImageSourceNative * imageSource,const int fd)170 int32_t OH_ImagePackerNative::PackToFileFromImageSource(OHOS::Media::PackOption *option,
171 OH_ImageSourceNative *imageSource, const int fd)
172 {
173 if (option == nullptr || imageSource == nullptr) {
174 return IMAGE_BAD_PARAMETER;
175 }
176 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
177 OHOS::Media::ImageSource *imageSourcePtr = imageSource->GetInnerImageSource().get();
178 int64_t packedSize = 0;
179 uint32_t ret = IMAGE_SUCCESS;
180 ret = imagePacker->StartPacking(fd, *option);
181 if (ret != IMAGE_SUCCESS) {
182 return ret;
183 }
184 ret = imagePacker->AddImage(*imageSourcePtr);
185 if (ret != IMAGE_SUCCESS) {
186 return ret;
187 }
188 return imagePacker->FinalizePacking(packedSize);
189 }
190
PackToFileFromPixelmap(OHOS::Media::PackOption * option,OH_PixelmapNative * pixelmap,int32_t fd)191 int32_t OH_ImagePackerNative::PackToFileFromPixelmap(OHOS::Media::PackOption *option, OH_PixelmapNative *pixelmap,
192 int32_t fd)
193 {
194 if (option == nullptr || pixelmap == nullptr) {
195 return IMAGE_BAD_PARAMETER;
196 }
197 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
198 OHOS::Media::PixelMap *pixelmapPtr = pixelmap->GetInnerPixelmap().get();
199 int64_t packedSize = 0;
200 uint32_t ret = IMAGE_SUCCESS;
201 ret = imagePacker->StartPacking(fd, *option);
202 if (ret != IMAGE_SUCCESS) {
203 return ret;
204 }
205 ret = imagePacker->AddImage(*pixelmapPtr);
206 if (ret != IMAGE_SUCCESS) {
207 return ret;
208 }
209 return imagePacker->FinalizePacking(packedSize);
210 }
211
PackToFileMultiFrames(OHOS::Media::PackOption * option,std::vector<OH_PixelmapNative * > & pixelmap,int32_t fd)212 int32_t OH_ImagePackerNative::PackToFileMultiFrames(OHOS::Media::PackOption *option,
213 std::vector<OH_PixelmapNative*> &pixelmap, int32_t fd)
214 {
215 if (option == nullptr || pixelmap.empty()) {
216 return IMAGE_BAD_PARAMETER;
217 }
218 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
219 int64_t packedSize = 0;
220 uint32_t ret = IMAGE_SUCCESS;
221 ret = imagePacker->StartPacking(fd, *option);
222 if (ret != IMAGE_SUCCESS) {
223 return ret;
224 }
225 for (int i = 0; i < static_cast<int>(pixelmap.size()); i++) {
226 if (pixelmap[i] == nullptr) {
227 return IMAGE_BAD_PARAMETER;
228 }
229 ret = imagePacker->AddImage(*(pixelmap[i]->GetInnerPixelmap().get()));
230 }
231 if (ret != IMAGE_SUCCESS) {
232 return ret;
233 }
234 return imagePacker->FinalizePacking(packedSize);
235 }
236
PackToFileFromPicture(OHOS::Media::PackOption * option,struct OH_PictureNative * picture,const int32_t fd)237 int32_t OH_ImagePackerNative::PackToFileFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
238 const int32_t fd)
239 {
240 if (option == nullptr || picture == nullptr) {
241 return IMAGE_BAD_PARAMETER;
242 }
243 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
244 OHOS::Media::Picture *picturePtr = picture->GetInnerPicture().get();
245 int64_t packedSize = 0;
246 uint32_t ret = IMAGE_ENCODE_FAILED;
247 ret = imagePacker->StartPacking(fd, *option);
248 if (ret != IMAGE_SUCCESS) {
249 return ret;
250 }
251 ret = imagePacker->AddPicture(*picturePtr);
252 if (ret != IMAGE_SUCCESS) {
253 return ret;
254 }
255 return imagePacker->FinalizePacking(packedSize);
256 }
257
GetInnerImagePacker()258 std::shared_ptr<OHOS::Media::ImagePacker> OH_ImagePackerNative::GetInnerImagePacker()
259 {
260 return imagePacker_;
261 }
262
263 #ifdef __cplusplus
264 };
265 #endif