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
PackToDataFromPicture(OHOS::Media::PackOption * option,struct OH_PictureNative * picture,uint8_t * outData,int64_t * size)106 int32_t OH_ImagePackerNative::PackToDataFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
107 uint8_t *outData, int64_t *size)
108 {
109 if (option == nullptr || picture == nullptr) {
110 return IMAGE_BAD_PARAMETER;
111 }
112 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
113 OHOS::Media::Picture *picturePtr = picture->GetInnerPicture().get();
114
115 int64_t packedSize = 0;
116 uint32_t ret = IMAGE_ENCODE_FAILED;
117 const int64_t DEFAULT_BUFFER_SIZE = defaultBufferSize;
118 int64_t bufferSize = (*size <= 0) ? DEFAULT_BUFFER_SIZE : (*size);
119 ret = imagePacker->StartPacking(outData, bufferSize, *option);
120 if (ret != IMAGE_SUCCESS) {
121 return ret;
122 }
123 ret = imagePacker->AddPicture(*picturePtr);
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
PackToFileFromImageSource(OHOS::Media::PackOption * option,OH_ImageSourceNative * imageSource,const int fd)138 int32_t OH_ImagePackerNative::PackToFileFromImageSource(OHOS::Media::PackOption *option,
139 OH_ImageSourceNative *imageSource, const int fd)
140 {
141 if (option == nullptr || imageSource == nullptr) {
142 return IMAGE_BAD_PARAMETER;
143 }
144 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
145 OHOS::Media::ImageSource *imageSourcePtr = imageSource->GetInnerImageSource().get();
146 int64_t packedSize = 0;
147 uint32_t ret = IMAGE_SUCCESS;
148 ret = imagePacker->StartPacking(fd, *option);
149 if (ret != IMAGE_SUCCESS) {
150 return ret;
151 }
152 ret = imagePacker->AddImage(*imageSourcePtr);
153 if (ret != IMAGE_SUCCESS) {
154 return ret;
155 }
156 return imagePacker->FinalizePacking(packedSize);
157 }
158
PackToFileFromPixelmap(OHOS::Media::PackOption * option,OH_PixelmapNative * pixelmap,int32_t fd)159 int32_t OH_ImagePackerNative::PackToFileFromPixelmap(OHOS::Media::PackOption *option, OH_PixelmapNative *pixelmap,
160 int32_t fd)
161 {
162 if (option == nullptr || pixelmap == nullptr) {
163 return IMAGE_BAD_PARAMETER;
164 }
165 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
166 OHOS::Media::PixelMap *pixelmapPtr = pixelmap->GetInnerPixelmap().get();
167 int64_t packedSize = 0;
168 uint32_t ret = IMAGE_SUCCESS;
169 ret = imagePacker->StartPacking(fd, *option);
170 if (ret != IMAGE_SUCCESS) {
171 return ret;
172 }
173 ret = imagePacker->AddImage(*pixelmapPtr);
174 if (ret != IMAGE_SUCCESS) {
175 return ret;
176 }
177 return imagePacker->FinalizePacking(packedSize);
178 }
179
PackToFileFromPicture(OHOS::Media::PackOption * option,struct OH_PictureNative * picture,const int32_t fd)180 int32_t OH_ImagePackerNative::PackToFileFromPicture(OHOS::Media::PackOption *option, struct OH_PictureNative *picture,
181 const int32_t fd)
182 {
183 if (option == nullptr || picture == nullptr) {
184 return IMAGE_BAD_PARAMETER;
185 }
186 OHOS::Media::ImagePacker *imagePacker = imagePacker_.get();
187 OHOS::Media::Picture *picturePtr = picture->GetInnerPicture().get();
188 int64_t packedSize = 0;
189 uint32_t ret = IMAGE_ENCODE_FAILED;
190 ret = imagePacker->StartPacking(fd, *option);
191 if (ret != IMAGE_SUCCESS) {
192 return ret;
193 }
194 ret = imagePacker->AddPicture(*picturePtr);
195 if (ret != IMAGE_SUCCESS) {
196 return ret;
197 }
198 return imagePacker->FinalizePacking(packedSize);
199 }
200
GetInnerImagePacker()201 std::shared_ptr<OHOS::Media::ImagePacker> OH_ImagePackerNative::GetInnerImagePacker()
202 {
203 return imagePacker_;
204 }
205
206 #ifdef __cplusplus
207 };
208 #endif