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