1 /* 2 * Copyright (c) 2024-2024 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 AVCODEC_SAMPLE_SAMPLE_INFO_H 17 #define AVCODEC_SAMPLE_SAMPLE_INFO_H 18 #include <cstdint> 19 #include <securec.h> 20 #include <string> 21 #include <condition_variable> 22 #include <queue> 23 #include "camera_log.h" 24 #include "native_avcodec_base.h" 25 #include "native_avbuffer.h" 26 #include "native_audio_channel_layout.h" 27 #include <refbase.h> 28 29 namespace OHOS { 30 namespace CameraStandard { 31 constexpr std::string_view MIME_VIDEO_AVC = "video/avc"; 32 constexpr std::string_view MIME_VIDEO_HEVC = "video/hevc"; 33 34 constexpr int32_t BITRATE_10M = 10 * 1000 * 1000; // 10Mbps 35 constexpr int32_t BITRATE_20M = 20 * 1000 * 1000; // 20Mbps 36 constexpr int32_t BITRATE_22M = 22 * 1000 * 1000; // 22Mbps 37 constexpr int32_t BITRATE_30M = 30 * 1000 * 1000; // 30Mbps 38 constexpr uint32_t DEFAULT_SAMPLERATE = 48000; 39 constexpr uint64_t DEFAULT_BITRATE = 48000; 40 constexpr uint32_t DEFAULT_CHANNEL_COUNT = 1; 41 constexpr int32_t AUDIO_ENCODE_EXPIREATION_TIME = 2; 42 constexpr OH_AudioChannelLayout CHANNEL_LAYOUT = OH_AudioChannelLayout::CH_LAYOUT_MONO; 43 constexpr OH_BitsPerSample SAMPLE_FORMAT = OH_BitsPerSample::SAMPLE_S16LE; 44 constexpr int32_t COMPLIANCE_LEVEL = 0; 45 constexpr OH_BitsPerSample BITS_PER_CODED_SAMPLE = OH_BitsPerSample::SAMPLE_S16LE; 46 constexpr uint32_t DEFAULT_MAX_INPUT_SIZE = 1024 * DEFAULT_CHANNEL_COUNT * sizeof(short); 47 constexpr int32_t VIDEO_FRAME_INTERVAL = 33333; 48 constexpr float VIDEO_FRAME_INTERVAL_MS = 33.33333; 49 constexpr int32_t AUDIO_FRAME_INTERVAL = 21333; 50 constexpr double VIDEO_FRAME_RATE = 30.0; 51 constexpr int32_t CACHE_FRAME_COUNT = 45; 52 constexpr size_t MAX_AUDIO_FRAME_COUNT = 140; 53 constexpr int32_t BUFFER_RELEASE_EXPIREATION_TIME = 150; 54 constexpr int32_t BUFFER_ENCODE_EXPIREATION_TIME = 10; 55 constexpr int32_t ROTATION_360 = 360; 56 constexpr OH_AVPixelFormat VIDOE_PIXEL_FORMAT = AV_PIXEL_FORMAT_NV21; 57 constexpr int32_t IDR_FRAME_COUNT = 2; 58 const std::string TIMED_METADATA_TRACK_MIMETYPE = "meta/timed-metadata"; 59 const std::string TIMED_METADATA_KEY = "com.openharmony.timed_metadata.movingphoto"; 60 constexpr int32_t KEY_FRAME_INTERVAL = 10; 61 constexpr int32_t DEFAULT_SIZE = 1920 * 1440; 62 constexpr float VIDEO_BITRATE_CONSTANT = 0.7; 63 constexpr float HEVC_TO_AVC_FACTOR = 1.5; 64 65 class CodecAVBufferInfo : public RefBase { 66 public: CodecAVBufferInfo(uint32_t argBufferIndex,OH_AVBuffer * argBuffer)67 explicit CodecAVBufferInfo(uint32_t argBufferIndex, OH_AVBuffer *argBuffer) 68 : bufferIndex(argBufferIndex), buffer(argBuffer) 69 { 70 // get output buffer attr 71 OH_AVBuffer_GetBufferAttr(argBuffer, &attr); 72 }; 73 ~CodecAVBufferInfo() = default; 74 uint32_t bufferIndex = 0; 75 OH_AVBuffer *buffer = nullptr; 76 OH_AVCodecBufferAttr attr = {0, 0, 0, AVCODEC_BUFFER_FLAGS_NONE}; 77 GetCopyAVBuffer()78 OH_AVBuffer *GetCopyAVBuffer() 79 { 80 MEDIA_INFO_LOG("CodecBufferInfo OH_AVBuffer_Create with size: %{public}d", attr.size); 81 OH_AVBuffer *destBuffer = OH_AVBuffer_Create(attr.size); 82 auto sourceAddr = OH_AVBuffer_GetAddr(buffer); 83 auto destAddr = OH_AVBuffer_GetAddr(destBuffer); 84 errno_t cpyRet = memcpy_s(reinterpret_cast<void *>(destAddr), attr.size, 85 reinterpret_cast<void *>(sourceAddr), attr.size); 86 if (cpyRet != 0) { 87 MEDIA_ERR_LOG("CodecBufferInfo memcpy_s failed. %{public}d", cpyRet); 88 } 89 OH_AVErrCode errorCode = OH_AVBuffer_SetBufferAttr(destBuffer, &attr); 90 if (errorCode != 0) { 91 MEDIA_ERR_LOG("CodecBufferInfo OH_AVBuffer_SetBufferAttr failed. %{public}d", errorCode); 92 } 93 return destBuffer; 94 } 95 AddCopyAVBuffer(OH_AVBuffer * IDRBuffer)96 OH_AVBuffer *AddCopyAVBuffer(OH_AVBuffer *IDRBuffer) 97 { 98 if (IDRBuffer == nullptr) { 99 MEDIA_WARNING_LOG("AddCopyAVBuffer without IDRBuffer!"); 100 return IDRBuffer; 101 } 102 OH_AVCodecBufferAttr IDRAttr = {0, 0, 0, AVCODEC_BUFFER_FLAGS_NONE}; 103 OH_AVCodecBufferAttr destAttr = {0, 0, 0, AVCODEC_BUFFER_FLAGS_NONE}; 104 OH_AVBuffer_GetBufferAttr(IDRBuffer, &IDRAttr); 105 int32_t destBufferSize = IDRAttr.size + attr.size; 106 OH_AVBuffer *destBuffer = OH_AVBuffer_Create(destBufferSize); 107 auto destAddr = OH_AVBuffer_GetAddr(destBuffer); 108 auto sourceIDRAddr = OH_AVBuffer_GetAddr(IDRBuffer); 109 110 errno_t cpyRet = memcpy_s(reinterpret_cast<void *>(destAddr), destBufferSize, 111 reinterpret_cast<void *>(sourceIDRAddr), IDRAttr.size); 112 if (cpyRet != 0) { 113 MEDIA_ERR_LOG("CodecBufferInfo memcpy_s IDR frame failed. %{public}d", cpyRet); 114 } 115 destAddr = destAddr + IDRAttr.size; 116 auto sourceAddr = OH_AVBuffer_GetAddr(buffer); 117 cpyRet = memcpy_s(reinterpret_cast<void *>(destAddr), attr.size, 118 reinterpret_cast<void *>(sourceAddr), attr.size); 119 if (cpyRet != 0) { 120 MEDIA_ERR_LOG("CodecBufferInfo memcpy_s I frame failed. %{public}d", cpyRet); 121 } 122 OH_AVBuffer_Destroy(IDRBuffer); 123 destAttr.size = destBufferSize; 124 destAttr.flags = IDRAttr.flags | attr.flags; 125 MEDIA_INFO_LOG("CodecBufferInfo deep copy with size: %{public}d, %{public}d", destBufferSize, destAttr.flags); 126 OH_AVBuffer_SetBufferAttr(destBuffer, &destAttr); 127 return destBuffer; 128 } 129 }; 130 131 class CodecUserData : public RefBase { 132 public: 133 CodecUserData() = default; ~CodecUserData()134 ~CodecUserData() 135 { 136 inputMutex_.lock(); 137 while (!inputBufferInfoQueue_.empty()) { 138 inputBufferInfoQueue_.pop(); 139 } 140 inputMutex_.unlock(); 141 outputMutex_.lock(); 142 while (!outputBufferInfoQueue_.empty()) { 143 outputBufferInfoQueue_.pop(); 144 } 145 outputMutex_.unlock(); 146 }; 147 uint32_t inputFrameCount_ = 0; 148 std::mutex inputMutex_; 149 std::condition_variable inputCond_; 150 std::queue<sptr<CodecAVBufferInfo>> inputBufferInfoQueue_; 151 152 uint32_t outputFrameCount_ = 0; 153 std::mutex outputMutex_; 154 std::condition_variable outputCond_; 155 std::queue<sptr<CodecAVBufferInfo>> outputBufferInfoQueue_; 156 }; 157 } // CameraStandard 158 } // OHOS 159 #endif // AVCODEC_SAMPLE_SAMPLE_INFO_H