1 /*
2  * Copyright (c) 2022-2023 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 "avsession_pixel_map_adapter.h"
17 #include "avsession_log.h"
18 #include "securec.h"
19 
20 using namespace OHOS::Media;
21 
22 namespace OHOS::AVSession {
23 namespace {
24     constexpr int32_t MAX_PIXEL_BUFFER_SIZE = 1 * 1024 * 1024;
25     constexpr int32_t LIMITED_PIXEL_BUFFER_SIZE = 500 * 1024; // ipc max 1m at the same time
26     constexpr uint8_t IMAGE_BYTE_SIZE = 2;
27     constexpr uint8_t DATA_BYTE_SIZE = 4;
28     constexpr uint8_t OFFSET_BYTE = 8;
29 }
30 
31 int32_t AVSessionPixelMapAdapter::originalPixelMapBytes_ = 0;
32 int32_t AVSessionPixelMapAdapter::originalWidth_ = 0;
33 int32_t AVSessionPixelMapAdapter::originalHeight_ = 0;
34 std::mutex AVSessionPixelMapAdapter::pixelMapLock_;
35 
ConvertFromInner(const std::shared_ptr<AVSessionPixelMap> & innerPixelMap)36 std::shared_ptr<Media::PixelMap> AVSessionPixelMapAdapter::ConvertFromInner(
37     const std::shared_ptr<AVSessionPixelMap>& innerPixelMap)
38 {
39     CHECK_AND_RETURN_RET_LOG(innerPixelMap != nullptr, nullptr, "invalid parameter");
40     CHECK_AND_RETURN_RET_LOG(innerPixelMap->GetInnerImgBuffer().size() > IMAGE_BYTE_SIZE, nullptr,
41         "innerPixelMap innerImgBuffer size less than 2");
42 
43     std::vector<uint8_t> innerImgBuffer = innerPixelMap->GetInnerImgBuffer();
44     uint16_t imgBufferSize = static_cast<uint16_t>(innerImgBuffer[0]);
45     imgBufferSize = (imgBufferSize << OFFSET_BYTE) + innerImgBuffer[1];
46     CHECK_AND_RETURN_RET_LOG(imgBufferSize == sizeof(Media::ImageInfo), nullptr,
47         "imgBufferSize not equal to %{public}zu", sizeof(Media::ImageInfo));
48 
49     Media::ImageInfo imageInfo;
50     std::copy(innerImgBuffer.data() + IMAGE_BYTE_SIZE,
51         innerImgBuffer.data() + IMAGE_BYTE_SIZE + imgBufferSize, reinterpret_cast<uint8_t*>(&imageInfo));
52 
53     const std::shared_ptr<Media::PixelMap>& pixelMap = std::make_shared<Media::PixelMap>();
54     pixelMap->SetImageInfo(imageInfo);
55 
56     uint32_t imgByteSizeExist = innerImgBuffer.size() - IMAGE_BYTE_SIZE - imgBufferSize - DATA_BYTE_SIZE;
57     uint32_t imgByteSizeInner = static_cast<uint32_t>(pixelMap->GetByteCount());
58     CHECK_AND_RETURN_RET_LOG(imgByteSizeInner == imgByteSizeExist, nullptr, "imageInfo size error");
59 
60     uint32_t dataSize = 0;
61     for (uint8_t i = 0; i < DATA_BYTE_SIZE; i++) {
62         uint32_t tmpValue = innerImgBuffer[IMAGE_BYTE_SIZE + imgBufferSize + i];
63         dataSize += (tmpValue << (OFFSET_BYTE * (DATA_BYTE_SIZE - i - 1)));
64     }
65     CHECK_AND_RETURN_RET_LOG(dataSize == imgByteSizeExist, nullptr, "dataSize error");
66     void* dataAddr = static_cast<void*>(innerImgBuffer.data() + IMAGE_BYTE_SIZE + imgBufferSize + DATA_BYTE_SIZE);
67     pixelMap->SetPixelsAddr(dataAddr, nullptr, dataSize, Media::AllocatorType::CUSTOM_ALLOC, nullptr);
68     SLOGI("ConvertFromInner without scalemode srcSize=[%{public}d, %{public}d}], dstSize=[%{public}d, %{public}d}]",
69         pixelMap->GetWidth(), pixelMap->GetHeight(), originalWidth_, originalHeight_);
70     Media::InitializationOptions options;
71     options.alphaType = imageInfo.alphaType;
72     options.pixelFormat = imageInfo.pixelFormat;
73     options.size.width = originalWidth_;
74     options.size.height = originalHeight_;
75     options.editable = true;
76     auto result = Media::PixelMap::Create(*pixelMap, options);
77     return std::move(result);
78 }
79 
CopyPixMapToDst(Media::PixelMap & source,void * dstPixels,uint32_t bufferSize)80 bool AVSessionPixelMapAdapter::CopyPixMapToDst(Media::PixelMap &source, void* dstPixels, uint32_t bufferSize)
81 {
82     if (source.GetAllocatorType() == AllocatorType::DMA_ALLOC) {
83         SLOGD("CopyPixMapToDst in dma");
84         ImageInfo imageInfo;
85         source.GetImageInfo(imageInfo);
86         for (int i = 0; i < imageInfo.size.height; ++i) {
87             if (memcpy_s(dstPixels, source.GetRowBytes(),
88                 source.GetPixels() + i * source.GetRowStride(), source.GetRowBytes()) != 0) {
89                 SLOGE("copy source memory size %{public}u fail", bufferSize);
90                 return false;
91             }
92             // Move the destination buffer pointer to the next row
93             dstPixels = reinterpret_cast<uint8_t *>(dstPixels) + source.GetRowBytes();
94         }
95     } else  {
96         SLOGI("CopyPixMapToDst in normal way with bufferSize %{public}u", bufferSize);
97         if (memcpy_s(dstPixels, bufferSize, source.GetPixels(), bufferSize) != 0) {
98             SLOGE("copy source memory size %{public}u fail", bufferSize);
99             return false;
100         }
101     }
102     return true;
103 }
104 
ConvertToInner(const std::shared_ptr<Media::PixelMap> & pixelMap)105 std::shared_ptr<AVSessionPixelMap> AVSessionPixelMapAdapter::ConvertToInner(
106     const std::shared_ptr<Media::PixelMap>& pixelMap)
107 {
108     std::lock_guard<std::mutex> lockGuard(pixelMapLock_);
109     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, nullptr, "invalid parameter");
110     originalPixelMapBytes_ = pixelMap->GetByteCount();
111     originalWidth_ = pixelMap->GetWidth();
112     originalHeight_ = pixelMap->GetHeight();
113     Media::ImageInfo imageInfoTemp;
114     pixelMap->GetImageInfo(imageInfoTemp);
115     const std::shared_ptr<Media::PixelMap>& pixelMapTemp = std::make_shared<Media::PixelMap>();
116     pixelMapTemp->SetImageInfo(imageInfoTemp);
117     uint32_t dataSize = static_cast<uint32_t>(originalPixelMapBytes_);
118     void* dataAddr = malloc(dataSize);
119     CHECK_AND_RETURN_RET_LOG(dataAddr != nullptr, nullptr, "create dataSize with null, return");
120 
121     CHECK_AND_RETURN_RET_LOG(CopyPixMapToDst(*pixelMap, dataAddr, dataSize), nullptr, "CopyPixMapToDst failed");
122     pixelMapTemp->SetPixelsAddr(dataAddr, nullptr, dataSize, Media::AllocatorType::CUSTOM_ALLOC, nullptr);
123     if (originalPixelMapBytes_ > MAX_PIXEL_BUFFER_SIZE) {
124         int32_t originSize = originalPixelMapBytes_;
125         float scaleRatio = sqrt(static_cast<float>(MAX_PIXEL_BUFFER_SIZE) / static_cast<float>(originalPixelMapBytes_));
126         pixelMapTemp->scale(scaleRatio, scaleRatio);
127         originalPixelMapBytes_ = pixelMapTemp->GetByteCount();
128         SLOGI("imgBufferSize exceeds limited: %{public}d scaled to %{public}d", originSize, originalPixelMapBytes_);
129     }
130     std::shared_ptr<AVSessionPixelMap> innerPixelMap = std::make_shared<AVSessionPixelMap>();
131     std::vector<uint8_t> imgBuffer;
132     Media::ImageInfo imageInfo;
133     pixelMapTemp->GetImageInfo(imageInfo);
134     const auto* buffer = reinterpret_cast<uint8_t*>(&imageInfo);
135     uint16_t imageInfoSize = static_cast<uint16_t>(sizeof(Media::ImageInfo));
136     uint32_t pixelDataSize = static_cast<uint32_t>(pixelMapTemp->GetByteCount());
137     size_t bufferSize = static_cast<size_t>(IMAGE_BYTE_SIZE + imageInfoSize + DATA_BYTE_SIZE + pixelDataSize);
138     imgBuffer.reserve(bufferSize);
139     imgBuffer.insert(imgBuffer.begin(), (imageInfoSize & 0xFF00) >> OFFSET_BYTE);
140     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), (imageInfoSize & 0x00FF));
141     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), buffer, buffer + imageInfoSize);
142     uint32_t computedValue = 0xFF000000;
143     for (uint8_t i = 0; i < DATA_BYTE_SIZE; i++) {
144         uint8_t tmpValue = ((pixelDataSize & computedValue) >> (OFFSET_BYTE * (DATA_BYTE_SIZE - i - 1)));
145         imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), tmpValue);
146         computedValue = computedValue >> OFFSET_BYTE;
147     }
148     SLOGI("insert with size: %{public}hu, %{public}u, %{public}d",
149         imageInfoSize, pixelDataSize, static_cast<int>(imgBuffer.size()));
150     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), pixelMapTemp->GetPixels(),
151         pixelMapTemp->GetPixels() + pixelDataSize);
152     innerPixelMap->SetInnerImgBuffer(imgBuffer);
153     imgBuffer.clear();
154     free(dataAddr);
155     return innerPixelMap;
156 }
157 
ConvertToInnerWithLimitedSize(const std::shared_ptr<Media::PixelMap> & pixelMap)158 std::shared_ptr<AVSessionPixelMap> AVSessionPixelMapAdapter::ConvertToInnerWithLimitedSize(
159     const std::shared_ptr<Media::PixelMap>& pixelMap)
160 {
161     std::lock_guard<std::mutex> lockGuard(pixelMapLock_);
162     CHECK_AND_RETURN_RET_LOG(pixelMap != nullptr, nullptr, "invalid parameter");
163     originalPixelMapBytes_ = pixelMap->GetByteCount();
164     originalWidth_ = pixelMap->GetWidth();
165     originalHeight_ = pixelMap->GetHeight();
166     Media::ImageInfo imageInfoTemp;
167     pixelMap->GetImageInfo(imageInfoTemp);
168     const std::shared_ptr<Media::PixelMap>& pixelMapTemp = std::make_shared<Media::PixelMap>();
169     pixelMapTemp->SetImageInfo(imageInfoTemp);
170     uint32_t dataSize = static_cast<uint32_t>(originalPixelMapBytes_);
171     void* dataAddr = malloc(dataSize);
172     CHECK_AND_RETURN_RET_LOG(dataAddr != nullptr, nullptr, "create dataSize with null, return");
173 
174     CHECK_AND_RETURN_RET_LOG(CopyPixMapToDst(*pixelMap, dataAddr, dataSize), nullptr, "CopyPixMapToDst failed");
175     pixelMapTemp->SetPixelsAddr(dataAddr, nullptr, dataSize, Media::AllocatorType::CUSTOM_ALLOC, nullptr);
176     if (originalPixelMapBytes_ > LIMITED_PIXEL_BUFFER_SIZE) {
177         int32_t originSize = originalPixelMapBytes_;
178         float scaleRatio =
179             sqrt(static_cast<float>(LIMITED_PIXEL_BUFFER_SIZE) / static_cast<float>(originalPixelMapBytes_));
180         pixelMapTemp->scale(scaleRatio, scaleRatio);
181         originalPixelMapBytes_ = pixelMapTemp->GetByteCount();
182         SLOGI("imgBufferSize exceeds limited: %{public}d scaled to %{public}d", originSize, originalPixelMapBytes_);
183     }
184     std::shared_ptr<AVSessionPixelMap> innerPixelMap = std::make_shared<AVSessionPixelMap>();
185     std::vector<uint8_t> imgBuffer;
186     Media::ImageInfo imageInfo;
187     pixelMapTemp->GetImageInfo(imageInfo);
188     const auto* buffer = reinterpret_cast<uint8_t*>(&imageInfo);
189     uint16_t imageInfoSize = static_cast<uint16_t>(sizeof(Media::ImageInfo));
190     uint32_t pixelDataSize = static_cast<uint32_t>(pixelMapTemp->GetByteCount());
191     size_t bufferSize = static_cast<size_t>(IMAGE_BYTE_SIZE + imageInfoSize + DATA_BYTE_SIZE + pixelDataSize);
192     imgBuffer.reserve(bufferSize);
193     imgBuffer.insert(imgBuffer.begin(), (imageInfoSize & 0xFF00) >> OFFSET_BYTE);
194     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), (imageInfoSize & 0x00FF));
195     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), buffer, buffer + imageInfoSize);
196     uint32_t computedValue = 0xFF000000;
197     for (uint8_t i = 0; i < DATA_BYTE_SIZE; i++) {
198         uint8_t tmpValue = ((pixelDataSize & computedValue) >> (OFFSET_BYTE * (DATA_BYTE_SIZE - i - 1)));
199         imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), tmpValue);
200         computedValue = computedValue >> OFFSET_BYTE;
201     }
202     SLOGI("insert with size: %{public}hu, %{public}u, %{public}d",
203         imageInfoSize, pixelDataSize, static_cast<int>(imgBuffer.size()));
204     imgBuffer.insert(imgBuffer.begin() + imgBuffer.size(), pixelMapTemp->GetPixels(),
205         pixelMapTemp->GetPixels() + pixelDataSize);
206     innerPixelMap->SetInnerImgBuffer(imgBuffer);
207     imgBuffer.clear();
208     free(dataAddr);
209     return innerPixelMap;
210 }
211 } // namespace OHOS::AVSession