1 /* 2 * Copyright (c) 2023-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 #ifndef HISTREAMER_FOUNDATION_LOG_H 17 #define HISTREAMER_FOUNDATION_LOG_H 18 19 #include <cinttypes> 20 #include <string> 21 22 #ifdef MEDIA_OHOS 23 #include "hilog/log.h" 24 #else 25 #include "log_adapter.h" 26 #endif 27 28 // If file name and line number is need, #define HST_DEBUG at the beginning of the cpp file. 29 #define HST_DEBUG 30 31 #ifdef MEDIA_OHOS 32 #undef LOG_DOMAIN_SYSTEM_PLAYER 33 #define LOG_DOMAIN_SYSTEM_PLAYER 0xD002B22 34 #undef LOG_DOMAIN_STREAM_SOURCE 35 #define LOG_DOMAIN_STREAM_SOURCE 0xD002B23 36 #undef LOG_DOMAIN_FOUNDATION 37 #define LOG_DOMAIN_FOUNDATION 0xD002B24 38 #undef LOG_DOMAIN_DEMUXER 39 #define LOG_DOMAIN_DEMUXER 0xD002B3A 40 #undef LOG_DOMAIN_MUXER 41 #define LOG_DOMAIN_MUXER 0xD002B3B 42 #undef LOG_DOMAIN_AUDIO 43 #define LOG_DOMAIN_AUDIO 0xD002B31 44 #undef LOG_DOMAIN_PLAYER 45 #define LOG_DOMAIN_PLAYER 0xD002B2B 46 #undef LOG_DOMAIN_RECORDER 47 #define LOG_DOMAIN_RECORDER 0xD002B2C 48 #undef LOG_DOMAIN_SCREENCAPTURE 49 #define LOG_DOMAIN_SCREENCAPTURE 0xD002B2E 50 #undef LOG_DOMAIN_HIPLAYER 51 #define LOG_DOMAIN_HIPLAYER 0xD002B2D 52 #undef LOG_DOMAIN_METADATA 53 #define LOG_DOMAIN_METADATA 0xD002B2C 54 #define PUBLIC_LOG "%{public}" 55 #else 56 #define PUBLIC_LOG "%" 57 #endif 58 59 #ifndef HST_LOG_TAG 60 #define HST_LOG_TAG "NULL" 61 #endif 62 63 #define PUBLIC_LOG_C PUBLIC_LOG "c" 64 #define PUBLIC_LOG_S PUBLIC_LOG "s" 65 #define PUBLIC_LOG_D8 PUBLIC_LOG PRId8 66 #define PUBLIC_LOG_D16 PUBLIC_LOG PRId16 67 #define PUBLIC_LOG_D32 PUBLIC_LOG PRId32 68 #define PUBLIC_LOG_D64 PUBLIC_LOG PRId64 69 #define PUBLIC_LOG_U8 PUBLIC_LOG PRIu8 70 #define PUBLIC_LOG_U16 PUBLIC_LOG PRIu16 71 #define PUBLIC_LOG_U32 PUBLIC_LOG PRIu32 72 #define PUBLIC_LOG_U64 PUBLIC_LOG PRIu64 73 #define PUBLIC_LOG_F PUBLIC_LOG "f" 74 #define PUBLIC_LOG_P PUBLIC_LOG "p" 75 #define PUBLIC_LOG_ZU PUBLIC_LOG "zu" 76 77 #undef LOG_TAG 78 #define LOG_TAG LABEL.tag 79 #undef LOG_DOMAIN 80 #define LOG_DOMAIN LABEL.domain 81 #undef LOG_TYPE 82 #define LOG_TYPE LABEL.type 83 84 85 #ifdef MEDIA_OHOS 86 #ifndef HST_DEBUG 87 #define HST_HILOG(op, fmt, args...) \ 88 do { \ 89 op(LOG_TYPE, PUBLIC_LOG_S ":" fmt, HST_LOG_TAG, ##args); \ 90 } while (0) 91 #else 92 #define HST_HILOG(op, fmt, args...) \ 93 do { \ 94 op(LOG_TYPE, "(" PUBLIC_LOG_S "(), " PUBLIC_LOG_D32 "): " fmt, __FUNCTION__, __LINE__, ##args); \ 95 } while (0) 96 #define HST_HILOG_SHORT(op, fmt, args...) \ 97 do { \ 98 op(LOG_TYPE, "#" PUBLIC_LOG_D32 " " fmt, __LINE__, ##args); \ 99 } while (0) 100 #define HST_HILOG_NO_RELEASE(op, fmt, args...) \ 101 do { \ 102 op(LOG_ONLY_PRERELEASE, "(" PUBLIC_LOG_S "(), " PUBLIC_LOG_D32 "): " fmt, __FUNCTION__, __LINE__, ##args); \ 103 } while (0) 104 105 #define HST_HILOG_TAG(op, fmt, args...) \ 106 do { \ 107 op(LOG_TYPE, "[" PUBLIC_LOG_S "]:" fmt, HST_LOG_TAG, ##args); \ 108 } while (0) 109 110 #define HST_HILOG_WITH_LEVEL_JUDGE(op1, op2, con, fmt, args...) \ 111 do { \ 112 if (!con) { \ 113 op2(LOG_TYPE, "(" PUBLIC_LOG_S "(), " PUBLIC_LOG_D32 "): " fmt, __FUNCTION__, __LINE__, ##args); \ 114 } else { \ 115 op1(LOG_TYPE, "(" PUBLIC_LOG_S "(), " PUBLIC_LOG_D32 "): " fmt, __FUNCTION__, __LINE__, ##args); \ 116 } \ 117 } while (0) 118 #endif 119 120 #define MEDIA_LOG_D(fmt, ...) HST_HILOG(HILOG_DEBUG, fmt, ##__VA_ARGS__) 121 #define MEDIA_LOG_I(fmt, ...) HST_HILOG(HILOG_INFO, fmt, ##__VA_ARGS__) 122 #define MEDIA_LOG_W(fmt, ...) HST_HILOG(HILOG_WARN, fmt, ##__VA_ARGS__) 123 #define MEDIA_LOG_E(fmt, ...) HST_HILOG(HILOG_ERROR, fmt, ##__VA_ARGS__) 124 #define MEDIA_LOG_F(fmt, ...) HST_HILOG(HILOG_FATAL, fmt, ##__VA_ARGS__) 125 #define MEDIA_LOG_I_NO_RELEASE(fmt, ...) HST_HILOG_NO_RELEASE(HILOG_INFO, fmt, ##__VA_ARGS__) 126 #define MEDIA_LOG_W_NO_RELEASE(fmt, ...) HST_HILOG_NO_RELEASE(HILOG_WARN, fmt, ##__VA_ARGS__) 127 #define MEDIA_LOG_E_NO_RELEASE(fmt, ...) HST_HILOG_NO_RELEASE(HILOG_ERROR, fmt, ##__VA_ARGS__) 128 #define MEDIA_LOG_F_NO_RELEASE(fmt, ...) HST_HILOG_NO_RELEASE(HILOG_FATAL, fmt, ##__VA_ARGS__) 129 #define MEDIA_LOG_D_SHORT(fmt, ...) HST_HILOG_SHORT(HILOG_DEBUG, fmt, ##__VA_ARGS__) 130 #define MEDIA_LOG_I_SHORT(fmt, ...) HST_HILOG_SHORT(HILOG_INFO, fmt, ##__VA_ARGS__) 131 #define MEDIA_LOG_W_SHORT(fmt, ...) HST_HILOG_SHORT(HILOG_WARN, fmt, ##__VA_ARGS__) 132 #define MEDIA_LOG_E_SHORT(fmt, ...) HST_HILOG_SHORT(HILOG_ERROR, fmt, ##__VA_ARGS__) 133 #define MEDIA_LOG_F_SHORT(fmt, ...) HST_HILOG_SHORT(HILOG_FATAL, fmt, ##__VA_ARGS__) 134 #define MEDIA_LOG_I_FALSE_D(con, fmt, ...) \ 135 HST_HILOG_WITH_LEVEL_JUDGE(HILOG_INFO, HILOG_DEBUG, con, fmt, ##__VA_ARGS__) 136 137 #define HST_HILOG_T_WITH_LEVEL_JUDGE(op1, op2, con, fmt, args...) \ 138 do { \ 139 if (!con) { \ 140 op2(LOG_TYPE, "[" PUBLIC_LOG_S "]:" fmt, HST_LOG_TAG, ##args); \ 141 } else { \ 142 op1(LOG_TYPE, "[" PUBLIC_LOG_S "]:" fmt, HST_LOG_TAG, ##args); \ 143 } \ 144 } while (0) 145 146 #define MEDIA_LOG_D_T(fmt, ...) HST_HILOG_TAG(HILOG_DEBUG, fmt, ##__VA_ARGS__) 147 #define MEDIA_LOG_I_T(fmt, ...) HST_HILOG_TAG(HILOG_INFO, fmt, ##__VA_ARGS__) 148 #define MEDIA_LOG_W_T(fmt, ...) HST_HILOG_TAG(HILOG_WARN, fmt, ##__VA_ARGS__) 149 #define MEDIA_LOG_E_T(fmt, ...) HST_HILOG_TAG(HILOG_ERROR, fmt, ##__VA_ARGS__) 150 #define MEDIA_LOG_F_T(fmt, ...) HST_HILOG_TAG(HILOG_FATAL, fmt, ##__VA_ARGS__) 151 #define MEDIA_LOG_I_FALSE_D_T(con, fmt, ...) \ 152 HST_HILOG_T_WITH_LEVEL_JUDGE(HILOG_INFO, HILOG_DEBUG, con, fmt, ##__VA_ARGS__) 153 154 #define MEDIA_LOG_LIMIT(op, frequency, fmt, ...) \ 155 do { \ 156 static uint64_t currentTimes = 0; \ 157 if (currentTimes++ % ((uint32_t)(frequency)) == 0) { \ 158 op(fmt, ##__VA_ARGS__); \ 159 } \ 160 } while (0) 161 162 #define MEDIA_LOGE_LIMIT(frequency, fmt, ...) MEDIA_LOG_LIMIT(MEDIA_LOG_E, frequency, fmt, ##__VA_ARGS__) 163 #define MEDIA_LOGW_LIMIT(frequency, fmt, ...) MEDIA_LOG_LIMIT(MEDIA_LOG_W, frequency, fmt, ##__VA_ARGS__) 164 #define MEDIA_LOGI_LIMIT(frequency, fmt, ...) MEDIA_LOG_LIMIT(MEDIA_LOG_I, frequency, fmt, ##__VA_ARGS__) 165 #define MEDIA_LOGD_LIMIT(frequency, fmt, ...) MEDIA_LOG_LIMIT(MEDIA_LOG_D, frequency, fmt, ##__VA_ARGS__) 166 #endif 167 168 // Control the MEDIA_LOG_D. 169 // If MEDIA_LOG_D is needed, #define MEDIA_LOG_DEBUG 1 at the beginning of the cpp file. 170 #ifndef MEDIA_LOG_DEBUG 171 #define MEDIA_LOG_DEBUG 1 172 #endif 173 174 #if !MEDIA_LOG_DEBUG 175 #undef MEDIA_LOG_D 176 #define MEDIA_LOG_D(msg, ...) ((void)0) 177 #endif 178 179 // Control the debug detail logs MEDIA_LOG_DD. 180 // If MEDIA_LOG_DD is needed, #define MEDIA_LOG_DEBUG_DETAIL 1 at the beginning of the cpp file. 181 #ifndef MEDIA_LOG_DEBUG_DETAIL 182 #define MEDIA_LOG_DEBUG_DETAIL 0 183 #endif 184 185 #if !MEDIA_LOG_DEBUG_DETAIL 186 #undef MEDIA_LOG_DD 187 #define MEDIA_LOG_DD(msg, ...) ((void)0) 188 #else 189 #undef MEDIA_LOG_DD 190 #define MEDIA_LOG_DD MEDIA_LOG_D 191 #endif 192 193 #ifndef NOK_RETURN 194 #define NOK_RETURN(exec) \ 195 do { \ 196 Status returnValue = (exec); \ 197 if (returnValue != Status::OK) { \ 198 MEDIA_LOG_E("NOK_RETURN on Status(" PUBLIC_LOG_D32 ").", returnValue); \ 199 return returnValue; \ 200 } \ 201 } while (0) 202 #endif 203 204 #ifndef NOK_LOG 205 #define NOK_LOG(exec) \ 206 do { \ 207 Status returnValue = (exec); \ 208 if (returnValue != Status::OK) { \ 209 MEDIA_LOG_E("NOK_LOG on Status(" PUBLIC_LOG_D32 ").", returnValue); \ 210 } \ 211 } while (0) 212 #endif 213 214 // If exec not return zero, then record the error code, especially when call system C function. 215 #ifndef NZERO_LOG 216 #define NZERO_LOG(exec) \ 217 do { \ 218 int returnValue = (exec); \ 219 if (returnValue != 0) { \ 220 MEDIA_LOG_E("NZERO_LOG when call (" #exec "), return " PUBLIC_LOG_D32, returnValue); \ 221 } \ 222 } while (0) 223 #endif 224 225 #ifndef NZERO_RETURN 226 #define NZERO_RETURN(exec) \ 227 do { \ 228 int returnValue = (exec); \ 229 if (returnValue != 0) { \ 230 MEDIA_LOG_E("NZERO_RETURN when call (" #exec "), return " PUBLIC_LOG_D32, returnValue); \ 231 return returnValue; \ 232 } \ 233 } while (0) 234 #endif 235 236 #ifndef NZERO_RETURN_V 237 #define NZERO_RETURN_V(exec, ret) \ 238 do { \ 239 int returnValue = (exec); \ 240 if (returnValue != 0) { \ 241 MEDIA_LOG_E("NZERO_RETURN_V when call (" #exec "), return " PUBLIC_LOG_D32, returnValue); \ 242 return ret; \ 243 } \ 244 } while (0) 245 #endif 246 247 #ifndef FALSE_RETURN 248 #define FALSE_RETURN(exec) \ 249 do { \ 250 bool returnValue = (exec); \ 251 if (!returnValue) { \ 252 MEDIA_LOG_E_NO_RELEASE("FALSE_RETURN " #exec); \ 253 return; \ 254 } \ 255 } while (0) 256 #endif 257 258 #ifndef FALSE_RETURN_NOLOG 259 #define FALSE_RETURN_NOLOG(exec) \ 260 do { \ 261 bool returnValue = (exec); \ 262 if (!returnValue) { \ 263 return; \ 264 } \ 265 } while (0) 266 #endif 267 268 #ifndef FALSE_RETURN_W 269 #define FALSE_RETURN_W(exec) \ 270 do { \ 271 bool returnValue = (exec); \ 272 if (!returnValue) { \ 273 MEDIA_LOG_W("FALSE_RETURN " #exec); \ 274 return; \ 275 } \ 276 } while (0) 277 #endif 278 279 #ifndef FALSE_RETURN_V 280 #define FALSE_RETURN_V(exec, ret) \ 281 do { \ 282 bool returnValue = (exec); \ 283 if (!returnValue) { \ 284 MEDIA_LOG_E_NO_RELEASE("FALSE_RETURN_V " #exec); \ 285 return ret; \ 286 } \ 287 } while (0) 288 #endif 289 290 #ifndef FALSE_RETURN_V_NOLOG 291 #define FALSE_RETURN_V_NOLOG(exec, ret) \ 292 do { \ 293 bool returnValue = (exec); \ 294 if (!returnValue) { \ 295 return ret; \ 296 } \ 297 } while (0) 298 #endif 299 300 #ifndef FALSE_RETURN_V_W 301 #define FALSE_RETURN_V_W(exec, ret) \ 302 do { \ 303 bool returnValue = (exec); \ 304 if (!returnValue) { \ 305 MEDIA_LOG_W("FALSE_RETURN_V_W " #exec); \ 306 return ret; \ 307 } \ 308 } while (0) 309 #endif 310 311 #ifndef FALSE_RETURN_MSG 312 #define FALSE_RETURN_MSG(exec, fmt, args...) \ 313 do { \ 314 bool returnValue = (exec); \ 315 if (!returnValue) { \ 316 MEDIA_LOG_E(fmt, ##args); \ 317 return; \ 318 } \ 319 } while (0) 320 #endif 321 322 #ifndef FALSE_RETURN_V_MSG_IMPL 323 #define FALSE_RETURN_V_MSG_IMPL(loglevel, exec, ret, fmt, args...) \ 324 do { \ 325 bool returnValue = (exec); \ 326 if (!returnValue) { \ 327 loglevel(fmt, ##args); \ 328 return ret; \ 329 } \ 330 } while (0) 331 #endif 332 333 #ifndef FALSE_RETURN_V_MSG 334 #define FALSE_RETURN_V_MSG(exec, ret, fmt, args...) FALSE_RETURN_V_MSG_IMPL(MEDIA_LOG_E, exec, ret, fmt, ##args) 335 #endif 336 337 #ifndef FALSE_RETURN_V_MSG_D 338 #define FALSE_RETURN_V_MSG_D(exec, ret, fmt, args...) FALSE_RETURN_V_MSG_IMPL(MEDIA_LOG_D, exec, ret, fmt, ##args) 339 #endif 340 341 #ifndef FALSE_RETURN_V_MSG_W 342 #define FALSE_RETURN_V_MSG_W(exec, ret, fmt, args...) FALSE_RETURN_V_MSG_IMPL(MEDIA_LOG_W, exec, ret, fmt, ##args) 343 #endif 344 345 #ifndef FALSE_RETURN_V_MSG_E 346 #define FALSE_RETURN_V_MSG_E(exec, ret, fmt, args...) FALSE_RETURN_V_MSG_IMPL(MEDIA_LOG_E, exec, ret, fmt, ##args) 347 #endif 348 349 #ifndef FALSE_LOG 350 #define FALSE_LOG(exec) \ 351 do { \ 352 bool returnValue = (exec); \ 353 if (!returnValue) { \ 354 MEDIA_LOG_E("FALSE_LOG: " #exec); \ 355 } \ 356 } while (0) 357 #endif 358 359 #ifndef FALSE_LOG_MSG_IMPL 360 #define FALSE_LOG_MSG_IMPL(loglevel, exec, fmt, args...) \ 361 do { \ 362 bool returnValue = (exec); \ 363 if (!returnValue) { \ 364 loglevel(fmt, ##args); \ 365 } \ 366 } while (0) 367 #endif 368 369 #ifndef FALSE_LOG_MSG 370 #define FALSE_LOG_MSG(exec, fmt, args...) FALSE_LOG_MSG_IMPL(MEDIA_LOG_E, exec, fmt, ##args) 371 #endif 372 373 #ifndef FALSE_LOG_MSG_W 374 #define FALSE_LOG_MSG_W(exec, fmt, args...) FALSE_LOG_MSG_IMPL(MEDIA_LOG_W, exec, fmt, ##args) 375 #endif 376 377 #define POINTER_MASK 0x00FFFFFF 378 #define FAKE_POINTER(addr) (POINTER_MASK & reinterpret_cast<uintptr_t>(addr)) 379 #endif // HISTREAMER_FOUNDATION_LOG_H