1 /*
2 * Copyright (C) 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 "codec_utils.h"
17 #include "avcodec_log.h"
18 #include "media_description.h"
19 namespace OHOS {
20 namespace MediaAVCodec {
21 namespace Codec {
22 namespace {
23 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "FCodec"};
24 constexpr uint32_t INDEX_ARRAY = 2;
25 std::map<VideoPixelFormat, AVPixelFormat> g_pixelFormatMap = {
26 {VideoPixelFormat::YUV420P, AV_PIX_FMT_YUV420P},
27 {VideoPixelFormat::NV12, AV_PIX_FMT_NV12},
28 {VideoPixelFormat::NV21, AV_PIX_FMT_NV21},
29 {VideoPixelFormat::RGBA, AV_PIX_FMT_RGBA},
30 };
31 } // namespace
32
33 using namespace OHOS::Media;
ConvertVideoFrame(std::shared_ptr<Scale> * scale,std::shared_ptr<AVFrame> frame,uint8_t ** dstData,int32_t * dstLineSize,AVPixelFormat dstPixFmt)34 int32_t ConvertVideoFrame(std::shared_ptr<Scale> *scale, std::shared_ptr<AVFrame> frame, uint8_t **dstData,
35 int32_t *dstLineSize, AVPixelFormat dstPixFmt)
36 {
37 if (*scale == nullptr) {
38 *scale = std::make_shared<Scale>();
39 ScalePara scalePara{static_cast<int32_t>(frame->width), static_cast<int32_t>(frame->height),
40 static_cast<AVPixelFormat>(frame->format), static_cast<int32_t>(frame->width),
41 static_cast<int32_t>(frame->height), dstPixFmt};
42 CHECK_AND_RETURN_RET_LOG((*scale)->Init(scalePara, dstData, dstLineSize) == AVCS_ERR_OK, AVCS_ERR_UNKNOWN,
43 "Scale init error");
44 }
45 return (*scale)->Convert(frame->data, frame->linesize, dstData, dstLineSize);
46 }
47
WriteYuvDataStride(const std::shared_ptr<AVMemory> & memory,uint8_t ** scaleData,const int32_t * scaleLineSize,int32_t stride,const Format & format)48 int32_t WriteYuvDataStride(const std::shared_ptr<AVMemory> &memory, uint8_t **scaleData, const int32_t *scaleLineSize,
49 int32_t stride, const Format &format)
50 {
51 int32_t height;
52 int32_t fmt;
53 format.GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height);
54 format.GetIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, fmt);
55 VideoPixelFormat pixFmt = static_cast<VideoPixelFormat>(fmt);
56 CHECK_AND_RETURN_RET_LOG(pixFmt == VideoPixelFormat::YUV420P || pixFmt == VideoPixelFormat::NV12 ||
57 pixFmt == VideoPixelFormat::NV21,
58 AVCS_ERR_UNSUPPORT, "pixFmt: %{public}d do not support", pixFmt);
59 int32_t srcPos = 0;
60 int32_t dstPos = 0;
61 int32_t dataSize = scaleLineSize[0];
62 int32_t writeSize = dataSize > stride ? stride : dataSize;
63 for (int32_t colNum = 0; colNum < height; colNum++) {
64 memory->Write(scaleData[0] + srcPos, writeSize, dstPos);
65 dstPos += stride;
66 srcPos += dataSize;
67 }
68 srcPos = 0;
69 if (pixFmt == VideoPixelFormat::YUV420P) {
70 dataSize = scaleLineSize[1];
71 writeSize = dataSize > (stride >> 1) ? (stride >> 1) : dataSize;
72 for (int32_t colNum = 0; colNum < (height >> 1); colNum++) {
73 memory->Write(scaleData[1] + srcPos, writeSize, dstPos);
74 dstPos += (stride >> 1);
75 srcPos += dataSize;
76 }
77 srcPos = 0;
78 for (int32_t colNum = 0; colNum < (height >> 1); colNum++) {
79 memory->Write(scaleData[INDEX_ARRAY] + srcPos, writeSize, dstPos);
80 dstPos += (stride >> 1);
81 srcPos += dataSize;
82 }
83 } else if ((pixFmt == VideoPixelFormat::NV12) || (pixFmt == VideoPixelFormat::NV21)) {
84 dataSize = scaleLineSize[1];
85 writeSize = dataSize > stride ? stride : dataSize;
86 for (int32_t colNum = 0; colNum < (height >> 1); colNum++) {
87 memory->Write(scaleData[1] + srcPos, writeSize, dstPos);
88 dstPos += stride;
89 srcPos += dataSize;
90 }
91 }
92 AVCODEC_LOGD("WriteYuvDataStride success");
93 return AVCS_ERR_OK;
94 }
95
WriteRgbDataStride(const std::shared_ptr<AVMemory> & memory,uint8_t ** scaleData,const int32_t * scaleLineSize,int32_t stride,const Format & format)96 int32_t WriteRgbDataStride(const std::shared_ptr<AVMemory> &memory, uint8_t **scaleData, const int32_t *scaleLineSize,
97 int32_t stride, const Format &format)
98 {
99 int32_t height;
100 format.GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height);
101 int32_t srcPos = 0;
102 int32_t dstPos = 0;
103 int32_t dataSize = scaleLineSize[0];
104 int32_t writeSize = dataSize > stride ? stride : dataSize;
105 for (int32_t colNum = 0; colNum < height; colNum++) {
106 memory->Write(scaleData[0] + srcPos, writeSize, dstPos);
107 dstPos += stride;
108 srcPos += dataSize;
109 }
110
111 AVCODEC_LOGD("WriteRgbDataStride success");
112 return AVCS_ERR_OK;
113 }
114
WriteYuvData(const std::shared_ptr<AVMemory> & memory,uint8_t ** scaleData,const int32_t * scaleLineSize,int32_t & height,VideoPixelFormat & pixFmt)115 int32_t WriteYuvData(const std::shared_ptr<AVMemory> &memory, uint8_t **scaleData, const int32_t *scaleLineSize,
116 int32_t &height, VideoPixelFormat &pixFmt)
117 {
118 int32_t ySize = static_cast<int32_t>(scaleLineSize[0] * height); // yuv420: 411 nv21
119 int32_t uvSize = static_cast<int32_t>(scaleLineSize[1] * height / 2); // 2
120 int32_t frameSize = 0;
121 if (pixFmt == VideoPixelFormat::YUV420P) {
122 frameSize = ySize + (uvSize * 2); // 2
123 } else if (pixFmt == VideoPixelFormat::NV21 || pixFmt == VideoPixelFormat::NV12) {
124 frameSize = ySize + uvSize;
125 }
126 CHECK_AND_RETURN_RET_LOG(memory->GetCapacity() >= frameSize, AVCS_ERR_NO_MEMORY,
127 "output buffer size is not enough: real[%{public}d], need[%{public}u]",
128 memory->GetCapacity(), frameSize);
129 if (pixFmt == VideoPixelFormat::YUV420P) {
130 memory->Write(scaleData[0], ySize);
131 memory->Write(scaleData[1], uvSize);
132 memory->Write(scaleData[2], uvSize); // 2
133 } else if ((pixFmt == VideoPixelFormat::NV12) || (pixFmt == VideoPixelFormat::NV21)) {
134 memory->Write(scaleData[0], ySize);
135 memory->Write(scaleData[1], uvSize);
136 } else {
137 return AVCS_ERR_UNSUPPORT;
138 }
139 return AVCS_ERR_OK;
140 }
141
WriteRgbData(const std::shared_ptr<AVMemory> & memory,uint8_t ** scaleData,const int32_t * scaleLineSize,int32_t & height)142 int32_t WriteRgbData(const std::shared_ptr<AVMemory> &memory, uint8_t **scaleData, const int32_t *scaleLineSize,
143 int32_t &height)
144 {
145 int32_t frameSize = static_cast<int32_t>(scaleLineSize[0] * height);
146 CHECK_AND_RETURN_RET_LOG(memory->GetCapacity() >= frameSize, AVCS_ERR_NO_MEMORY,
147 "output buffer size is not enough: real[%{public}d], need[%{public}u]",
148 memory->GetCapacity(), frameSize);
149 memory->Write(scaleData[0], frameSize);
150 return AVCS_ERR_OK;
151 }
152
WriteSurfaceData(const std::shared_ptr<AVMemory> & memory,struct SurfaceInfo & surfaceInfo,const Format & format)153 int32_t WriteSurfaceData(const std::shared_ptr<AVMemory> &memory, struct SurfaceInfo &surfaceInfo, const Format &format)
154 {
155 int32_t width;
156 int32_t height;
157 int32_t fmt;
158 format.GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, width);
159 format.GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height);
160 format.GetIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, fmt);
161 VideoPixelFormat pixFmt = static_cast<VideoPixelFormat>(fmt);
162
163 sptr<SyncFence> autoFence = new (std::nothrow) SyncFence(surfaceInfo.surfaceFence);
164 if (autoFence != nullptr) {
165 autoFence->Wait(100); // 100ms
166 }
167
168 if (IsYuvFormat(pixFmt)) {
169 if (surfaceInfo.surfaceStride % width) {
170 return WriteYuvDataStride(memory, surfaceInfo.scaleData, surfaceInfo.scaleLineSize,
171 surfaceInfo.surfaceStride, format);
172 }
173 WriteYuvData(memory, surfaceInfo.scaleData, surfaceInfo.scaleLineSize, height, pixFmt);
174 } else if (IsRgbFormat(pixFmt)) {
175 if (surfaceInfo.surfaceStride % width) {
176 return WriteRgbDataStride(memory, surfaceInfo.scaleData, surfaceInfo.scaleLineSize,
177 surfaceInfo.surfaceStride, format);
178 }
179 WriteRgbData(memory, surfaceInfo.scaleData, surfaceInfo.scaleLineSize, height);
180 } else {
181 AVCODEC_LOGE("Fill frame buffer failed : unsupported pixel format: %{public}d", pixFmt);
182 return AVCS_ERR_UNSUPPORT;
183 }
184 return AVCS_ERR_OK;
185 }
186
WriteBufferData(const std::shared_ptr<AVMemory> & memory,uint8_t ** scaleData,int32_t * scaleLineSize,const Format & format)187 int32_t WriteBufferData(const std::shared_ptr<AVMemory> &memory, uint8_t **scaleData, int32_t *scaleLineSize,
188 const Format &format)
189 {
190 int32_t height;
191 int32_t width;
192 int32_t fmt;
193 format.GetIntValue(MediaDescriptionKey::MD_KEY_HEIGHT, height);
194 format.GetIntValue(MediaDescriptionKey::MD_KEY_WIDTH, width);
195 format.GetIntValue(MediaDescriptionKey::MD_KEY_PIXEL_FORMAT, fmt);
196 VideoPixelFormat pixFmt = static_cast<VideoPixelFormat>(fmt);
197
198 if (IsYuvFormat(pixFmt)) {
199 if (scaleLineSize[0] > width) {
200 return WriteYuvDataStride(memory, scaleData, scaleLineSize, width, format);
201 }
202 WriteYuvData(memory, scaleData, scaleLineSize, height, pixFmt);
203 } else if (IsRgbFormat(pixFmt)) {
204 if (scaleLineSize[0] > width) {
205 return WriteRgbDataStride(memory, scaleData, scaleLineSize, width, format);
206 }
207 WriteRgbData(memory, scaleData, scaleLineSize, height);
208 } else {
209 AVCODEC_LOGE("Fill frame buffer failed : unsupported pixel format: %{public}d", pixFmt);
210 return AVCS_ERR_UNSUPPORT;
211 }
212 return AVCS_ERR_OK;
213 }
214
AVStrError(int errnum)215 std::string AVStrError(int errnum)
216 {
217 char errbuf[AV_ERROR_MAX_STRING_SIZE] = {0};
218 av_strerror(errnum, errbuf, AV_ERROR_MAX_STRING_SIZE);
219 return std::string(errbuf);
220 }
221
TranslateSurfaceRotation(const VideoRotation & rotation)222 GraphicTransformType TranslateSurfaceRotation(const VideoRotation &rotation)
223 {
224 switch (rotation) {
225 case VideoRotation::VIDEO_ROTATION_90: {
226 return GRAPHIC_ROTATE_270;
227 }
228 case VideoRotation::VIDEO_ROTATION_180: {
229 return GRAPHIC_ROTATE_180;
230 }
231 case VideoRotation::VIDEO_ROTATION_270: {
232 return GRAPHIC_ROTATE_90;
233 }
234 default:
235 return GRAPHIC_ROTATE_NONE;
236 }
237 }
238
TranslateSurfaceFormat(const VideoPixelFormat & surfaceFormat)239 GraphicPixelFormat TranslateSurfaceFormat(const VideoPixelFormat &surfaceFormat)
240 {
241 switch (surfaceFormat) {
242 case VideoPixelFormat::YUV420P: {
243 return GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_P;
244 }
245 case VideoPixelFormat::RGBA: {
246 return GraphicPixelFormat::GRAPHIC_PIXEL_FMT_RGBA_8888;
247 }
248 case VideoPixelFormat::NV12: {
249 return GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCBCR_420_SP;
250 }
251 case VideoPixelFormat::NV21: {
252 return GraphicPixelFormat::GRAPHIC_PIXEL_FMT_YCRCB_420_SP;
253 }
254 default:
255 return GraphicPixelFormat::GRAPHIC_PIXEL_FMT_BUTT;
256 }
257 }
258
ConvertPixelFormatFromFFmpeg(int32_t ffmpegPixelFormat)259 VideoPixelFormat ConvertPixelFormatFromFFmpeg(int32_t ffmpegPixelFormat)
260 {
261 auto iter = std::find_if(
262 g_pixelFormatMap.begin(), g_pixelFormatMap.end(),
263 [&](const std::pair<VideoPixelFormat, AVPixelFormat> &tmp) -> bool { return tmp.second == ffmpegPixelFormat; });
264 return iter == g_pixelFormatMap.end() ? VideoPixelFormat::UNKNOWN : iter->first;
265 }
266
ConvertPixelFormatToFFmpeg(VideoPixelFormat pixelFormat)267 AVPixelFormat ConvertPixelFormatToFFmpeg(VideoPixelFormat pixelFormat)
268 {
269 auto iter = std::find_if(
270 g_pixelFormatMap.begin(), g_pixelFormatMap.end(),
271 [&](const std::pair<VideoPixelFormat, AVPixelFormat> &tmp) -> bool { return tmp.first == pixelFormat; });
272 return iter == g_pixelFormatMap.end() ? AV_PIX_FMT_NONE : iter->second;
273 }
274
IsYuvFormat(VideoPixelFormat & format)275 bool IsYuvFormat(VideoPixelFormat &format)
276 {
277 return (format == VideoPixelFormat::YUV420P || format == VideoPixelFormat::NV12 ||
278 format == VideoPixelFormat::NV21);
279 }
280
IsRgbFormat(VideoPixelFormat & format)281 bool IsRgbFormat(VideoPixelFormat &format)
282 {
283 return (format == VideoPixelFormat::RGBA);
284 }
285
Init(const ScalePara & scalePara,uint8_t ** dstData,int32_t * dstLineSize)286 int32_t Scale::Init(const ScalePara &scalePara, uint8_t **dstData, int32_t *dstLineSize)
287 {
288 scalePara_ = scalePara;
289 if (swsCtx_ != nullptr) {
290 return AVCS_ERR_OK;
291 }
292 auto swsContext =
293 sws_getContext(scalePara_.srcWidth, scalePara_.srcHeight, scalePara_.srcFfFmt, scalePara_.dstWidth,
294 scalePara_.dstHeight, scalePara_.dstFfFmt, SWS_FAST_BILINEAR, nullptr, nullptr, nullptr);
295 if (swsContext == nullptr) {
296 return AVCS_ERR_UNKNOWN;
297 }
298 swsCtx_ = std::shared_ptr<SwsContext>(swsContext, [](struct SwsContext *ptr) {
299 if (ptr != nullptr) {
300 sws_freeContext(ptr);
301 }
302 });
303 auto ret = av_image_alloc(dstData, dstLineSize, scalePara_.dstWidth, scalePara_.dstHeight, scalePara_.dstFfFmt,
304 scalePara_.align);
305 if (ret < 0) {
306 return AVCS_ERR_UNKNOWN;
307 }
308 for (int32_t i = 0; dstLineSize[i] > 0; i++) {
309 if (dstData[i] && !dstLineSize[i]) {
310 return AVCS_ERR_UNKNOWN;
311 }
312 }
313 return AVCS_ERR_OK;
314 }
315
Convert(uint8_t ** srcData,const int32_t * srcLineSize,uint8_t ** dstData,int32_t * dstLineSize)316 int32_t Scale::Convert(uint8_t **srcData, const int32_t *srcLineSize, uint8_t **dstData, int32_t *dstLineSize)
317 {
318 auto res = sws_scale(swsCtx_.get(), srcData, srcLineSize, 0, scalePara_.srcHeight, dstData, dstLineSize);
319 if (res < 0) {
320 return AVCS_ERR_UNKNOWN;
321 }
322 return AVCS_ERR_OK;
323 }
324 } // namespace Codec
325 } // namespace MediaAVCodec
326 } // namespace OHOS