1 /*
2 * Copyright (C) 2021 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_common.h"
17 #include "media_errors.h"
18 #include "media_log.h"
19
20 namespace {
21 constexpr OHOS::HiviewDFX::HiLogLabel LABEL = {LOG_CORE, LOG_DOMAIN, "CodecCommon"};
22 }
23
24 namespace OHOS {
25 namespace Media {
26 const std::map<VideoPixelFormat, std::string> PIXEL_TO_STRING = {
27 {YUVI420, "I420"},
28 {NV12, "NV12"},
29 {NV21, "NV21"},
30 {SURFACE_FORMAT, "NV21"},
31 {RGBA, "RGBA"},
32 };
33
34 const std::map<AudioStandard::AudioSampleFormat, std::string> PCM_TO_STRING = {
35 {AudioStandard::SAMPLE_U8, "U8"},
36 {AudioStandard::SAMPLE_S16LE, "S16LE"},
37 {AudioStandard::SAMPLE_S24LE, "S24LE"},
38 {AudioStandard::SAMPLE_S32LE, "S32LE"},
39 };
40
41 const std::map<MPEG4Profile, std::string> MPEG4_PROFILE_TO_STRING = {
42 {MPEG4_PROFILE_ADVANCED_CODING, "advanced-coding-efficiency"},
43 {MPEG4_PROFILE_ADVANCED_CORE, "advanced-core"},
44 {MPEG4_PROFILE_ADVANCED_REAL_TIME, "advanced-real-time"},
45 {MPEG4_PROFILE_ADVANCED_SCALABLE, "advanced-scalable-texture"},
46 {MPEG4_PROFILE_ADVANCED_SIMPLE, "advanced-simple"},
47 {MPEG4_PROFILE_BASIC_ANIMATED, "basic-animated-texture"},
48 {MPEG4_PROFILE_CORE, "core"},
49 {MPEG4_PROFILE_CORE_SCALABLE, "core-scalable"},
50 {MPEG4_PROFILE_HYBRID, "hybrid"},
51 {MPEG4_PROFILE_MAIN, "main"},
52 {MPEG4_PROFILE_NBIT, "n-bit"},
53 {MPEG4_PROFILE_SCALABLE_TEXTURE, "scalable"},
54 {MPEG4_PROFILE_SIMPLE, "simple"},
55 {MPEG4_PROFILE_SIMPLE_FBA, "simple-fba"},
56 {MPEG4_PROFILE_SIMPLE_FACE, "simple-face"},
57 {MPEG4_PROFILE_SIMPLE_SCALABLE, "simple-scalable"},
58 };
59
60 const std::map<AVCProfile, std::string> AVC_PROFILE_TO_STRING = {
61 {AVC_PROFILE_BASELINE, "baseline"},
62 {AVC_PROFILE_CONSTRAINED_BASELINE, "constrained-baseline"},
63 {AVC_PROFILE_CONSTRAINED_HIGH, "constrained-high"},
64 {AVC_PROFILE_EXTENDED, "extended"},
65 {AVC_PROFILE_HIGH, "high"},
66 {AVC_PROFILE_HIGH_10, "high-10"},
67 {AVC_PROFILE_HIGH_422, "high-4:2:2"},
68 {AVC_PROFILE_HIGH_444, "high-4:4:4"},
69 {AVC_PROFILE_MAIN, "main"},
70 };
71
72 const std::map<HEVCProfile, std::string> HEVC_PROFILE_TO_STRING = {
73 {HEVC_PROFILE_MAIN, "main"},
74 {HEVC_PROFILE_MAIN_10, "main-10"},
75 {HEVC_PROFILE_MAIN_STILL, "main-still-picture"},
76 };
77
78 const std::map<std::string_view, InnerCodecMimeType> MIME_TO_CODEC_NAME = {
79 {CodecMimeType::VIDEO_H263, CODEC_MIME_TYPE_VIDEO_H263},
80 {CodecMimeType::VIDEO_AVC, CODEC_MIME_TYPE_VIDEO_AVC},
81 {CodecMimeType::VIDEO_HEVC, CODEC_MIME_TYPE_VIDEO_HEVC},
82 {CodecMimeType::VIDEO_MPEG2, CODEC_MIME_TYPE_VIDEO_MPEG2},
83 {CodecMimeType::VIDEO_MPEG4, CODEC_MIME_TYPE_VIDEO_MPEG4},
84 {CodecMimeType::AUDIO_VORBIS, CODEC_MIME_TYPE_AUDIO_VORBIS},
85 {CodecMimeType::AUDIO_MPEG, CODEC_MIME_TYPE_AUDIO_MPEG},
86 {CodecMimeType::AUDIO_AAC, CODEC_MIME_TYPE_AUDIO_AAC},
87 {CodecMimeType::AUDIO_FLAC, CODEC_MIME_TYPE_AUDIO_FLAC},
88 {CodecMimeType::AUDIO_OPUS, CODEC_MIME_TYPE_AUDIO_OPUS},
89 };
90
PixelFormatToGst(VideoPixelFormat pixel)91 std::string PixelFormatToGst(VideoPixelFormat pixel)
92 {
93 CHECK_AND_RETURN_RET(PIXEL_TO_STRING.count(pixel) != 0, "Invalid");
94 return PIXEL_TO_STRING.at(pixel);
95 }
96
MPEG4ProfileToGst(MPEG4Profile profile)97 std::string MPEG4ProfileToGst(MPEG4Profile profile)
98 {
99 CHECK_AND_RETURN_RET(MPEG4_PROFILE_TO_STRING.count(profile) != 0, "Invalid");
100 return MPEG4_PROFILE_TO_STRING.at(profile);
101 }
102
AVCProfileToGst(AVCProfile profile)103 std::string AVCProfileToGst(AVCProfile profile)
104 {
105 CHECK_AND_RETURN_RET(AVC_PROFILE_TO_STRING.count(profile) != 0, "Invalid");
106 return AVC_PROFILE_TO_STRING.at(profile);
107 }
108
HEVCProfileToGst(HEVCProfile profile)109 std::string HEVCProfileToGst(HEVCProfile profile)
110 {
111 CHECK_AND_RETURN_RET(HEVC_PROFILE_TO_STRING.count(profile) != 0, "Invalid");
112 return HEVC_PROFILE_TO_STRING.at(profile);
113 }
114
RawAudioFormatToGst(AudioStandard::AudioSampleFormat format)115 std::string RawAudioFormatToGst(AudioStandard::AudioSampleFormat format)
116 {
117 CHECK_AND_RETURN_RET(PCM_TO_STRING.count(format) != 0, "Invalid");
118 return PCM_TO_STRING.at(format);
119 }
120
MapCodecMime(const std::string & mime,InnerCodecMimeType & name)121 int32_t MapCodecMime(const std::string &mime, InnerCodecMimeType &name)
122 {
123 if (MIME_TO_CODEC_NAME.count(mime) != 0) {
124 name = MIME_TO_CODEC_NAME.at(mime);
125 return MSERR_OK;
126 }
127 return MSERR_INVALID_VAL;
128 }
129
CapsToFormat(GstCaps * caps,Format & format)130 int32_t CapsToFormat(GstCaps *caps, Format &format)
131 {
132 GstStructure *structure = gst_caps_get_structure(caps, 0);
133 CHECK_AND_RETURN_RET(structure != nullptr, MSERR_UNKNOWN);
134 auto mediaType = gst_structure_get_name(structure);
135 bool isVideo = g_str_has_prefix(mediaType, "video/");
136
137 gint ret = 0;
138 if (isVideo) {
139 (void)gst_structure_get(structure, "width", G_TYPE_INT, &ret, nullptr);
140 (void)format.PutIntValue("width", ret);
141 (void)gst_structure_get(structure, "height", G_TYPE_INT, &ret, nullptr);
142 (void)format.PutIntValue("height", ret);
143 } else {
144 (void)gst_structure_get(structure, "rate", G_TYPE_INT, &ret, nullptr);
145 (void)format.PutIntValue("sample_rate", ret);
146 (void)gst_structure_get(structure, "channels", G_TYPE_INT, &ret, nullptr);
147 (void)format.PutIntValue("channel_count", ret);
148 }
149 return MSERR_OK;
150 }
151
PixelBufferSize(VideoPixelFormat pixel,uint32_t width,uint32_t height,uint32_t alignment)152 uint32_t PixelBufferSize(VideoPixelFormat pixel, uint32_t width, uint32_t height, uint32_t alignment)
153 {
154 uint32_t size = 0;
155 CHECK_AND_RETURN_RET(width != 0 && height != 0 && alignment != 0, size);
156
157 switch (pixel) {
158 case YUVI420:
159 // fall-through
160 case NV12:
161 // fall-through
162 case SURFACE_FORMAT:
163 // fall-through
164 case NV21:
165 size = width * height * 3 / 2;
166 break;
167 case RGBA:
168 size = width * height * 4;
169 break;
170 default:
171 break;
172 }
173
174 if (size > 0) {
175 size = (size + alignment - 1) & ~(alignment - 1);
176 }
177
178 return size;
179 }
180 } // namespace Media
181 } // namespace OHOS