1 /*
2 * Copyright (C) 2022 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 "AVMuxerDemo.h"
17 #include <iostream>
18 #include <fstream>
19 #include <cstdio>
20 #include <unistd.h>
21 #include <fcntl.h>
22 #include <dlfcn.h>
23
24 using namespace OHOS;
25 using namespace OHOS::MediaAVCodec;
26 using namespace OHOS::Media;
27 using namespace std;
28 using namespace Plugins;
29
GetFdByMode(OH_AVOutputFormat format)30 int32_t AVMuxerDemo::GetFdByMode(OH_AVOutputFormat format)
31 {
32 if (format == AV_OUTPUT_FORMAT_MPEG_4) {
33 filename = "output.mp4";
34 } else if (format == AV_OUTPUT_FORMAT_M4A) {
35 filename = "output.m4a";
36 } else {
37 filename = "output.bin";
38 }
39 int32_t fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
40 if (fd < 0) {
41 std::cout << "Open file failed! filePath is: " << filename << std::endl;
42 return -1;
43 }
44 return fd;
45 }
46
GetErrorFd()47 int32_t AVMuxerDemo::GetErrorFd()
48 {
49 filename = "output.bin";
50 int32_t fd = open(filename.c_str(), O_CREAT | O_WRONLY, S_IRUSR | S_IWUSR);
51 if (fd < 0) {
52 std::cout << "Open file failed! filePath is: " << filename << std::endl;
53 return -1;
54 }
55 return fd;
56 }
57
GetFdByName(OH_AVOutputFormat format,string fileName)58 int32_t AVMuxerDemo::GetFdByName(OH_AVOutputFormat format, string fileName)
59 {
60 if (format == AV_OUTPUT_FORMAT_MPEG_4) {
61 filename = fileName + ".mp4";
62 } else if (format == AV_OUTPUT_FORMAT_M4A) {
63 filename = fileName + ".m4a";
64 } else {
65 filename = fileName + ".bin";
66 }
67 int32_t fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
68 if (fd < 0) {
69 std::cout << "Open file failed! filePath is: " << filename << std::endl;
70 return -1;
71 }
72 return fd;
73 }
74
InnerGetFdByMode(OutputFormat format)75 int32_t AVMuxerDemo::InnerGetFdByMode(OutputFormat format)
76 {
77 if (format == OutputFormat::MPEG_4) {
78 filename = "output.mp4";
79 } else if (format == OutputFormat::M4A) {
80 filename = "output.m4a";
81 } else {
82 filename = "output.bin";
83 }
84 int32_t fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
85 if (fd < 0) {
86 std::cout << "Open file failed! filePath is: " << filename << std::endl;
87 return -1;
88 }
89 return fd;
90 }
91
InnerGetFdByName(OutputFormat format,string fileName)92 int32_t AVMuxerDemo::InnerGetFdByName(OutputFormat format, string fileName)
93 {
94 if (format == OutputFormat::MPEG_4) {
95 filename = fileName + ".mp4";
96 } else if (format == OutputFormat::M4A) {
97 filename = fileName + ".m4a";
98 } else {
99 filename = fileName + ".bin";
100 }
101 int32_t fd = open(filename.c_str(), O_CREAT | O_RDWR | O_TRUNC, S_IRUSR | S_IWUSR);
102 if (fd < 0) {
103 std::cout << "Open file failed! filePath is: " << filename << std::endl;
104 return -1;
105 }
106 return fd;
107 }
NativeCreate(int32_t fd,OH_AVOutputFormat format)108 OH_AVMuxer* AVMuxerDemo::NativeCreate(int32_t fd, OH_AVOutputFormat format)
109 {
110 return OH_AVMuxer_Create(fd, format);
111 }
112
NativeSetRotation(OH_AVMuxer * muxer,int32_t rotation)113 OH_AVErrCode AVMuxerDemo::NativeSetRotation(OH_AVMuxer* muxer, int32_t rotation)
114 {
115 return OH_AVMuxer_SetRotation(muxer, rotation);
116 }
117
NativeAddTrack(OH_AVMuxer * muxer,int32_t * trackIndex,OH_AVFormat * trackFormat)118 OH_AVErrCode AVMuxerDemo::NativeAddTrack(OH_AVMuxer* muxer, int32_t* trackIndex, OH_AVFormat* trackFormat)
119 {
120 return OH_AVMuxer_AddTrack(muxer, trackIndex, trackFormat);
121 }
122
NativeStart(OH_AVMuxer * muxer)123 OH_AVErrCode AVMuxerDemo::NativeStart(OH_AVMuxer* muxer)
124 {
125 return OH_AVMuxer_Start(muxer);
126 }
127
NativeWriteSampleBuffer(OH_AVMuxer * muxer,uint32_t trackIndex,OH_AVMemory * sampleBuffer,OH_AVCodecBufferAttr info)128 OH_AVErrCode AVMuxerDemo::NativeWriteSampleBuffer(OH_AVMuxer* muxer, uint32_t trackIndex,
129 OH_AVMemory* sampleBuffer, OH_AVCodecBufferAttr info)
130 {
131 return OH_AVMuxer_WriteSample(muxer, trackIndex, sampleBuffer, info);
132 }
133
NativeWriteSampleBuffer(OH_AVMuxer * muxer,uint32_t trackIndex,OH_AVBuffer * sampleBuffer)134 OH_AVErrCode AVMuxerDemo::NativeWriteSampleBuffer(OH_AVMuxer* muxer, uint32_t trackIndex,
135 OH_AVBuffer* sampleBuffer)
136 {
137 return OH_AVMuxer_WriteSampleBuffer(muxer, trackIndex, sampleBuffer);
138 }
139
NativeStop(OH_AVMuxer * muxer)140 OH_AVErrCode AVMuxerDemo::NativeStop(OH_AVMuxer* muxer)
141 {
142 return OH_AVMuxer_Stop(muxer);
143 }
144
NativeDestroy(OH_AVMuxer * muxer)145 OH_AVErrCode AVMuxerDemo::NativeDestroy(OH_AVMuxer* muxer)
146 {
147 return OH_AVMuxer_Destroy(muxer);
148 }
149
InnerCreate(int32_t fd,OutputFormat format)150 int32_t AVMuxerDemo::InnerCreate(int32_t fd, OutputFormat format)
151 {
152 cout << "InnerCreate" << endl;
153 avmuxer_ = AVMuxerFactory::CreateAVMuxer(fd, format);
154 if (avmuxer_ == nullptr) {
155 std::cout << "InnerMuxer create failed!" << std::endl;
156 return AVCS_ERR_NO_MEMORY;
157 }
158 return AV_ERR_OK;
159 }
160
InnerSetRotation(int32_t rotation)161 int32_t AVMuxerDemo::InnerSetRotation(int32_t rotation)
162 {
163 cout << "InnerSetRotation" << endl;
164 if (avmuxer_ == nullptr) {
165 std::cout << "InnerMuxer create failed!" << std::endl;
166 return AVCS_ERR_NO_MEMORY;
167 }
168 std::shared_ptr<Meta> param = std::make_shared<Meta>();
169 param->Set<Tag::VIDEO_ROTATION>(static_cast<Plugins::VideoRotation>(rotation));
170 return avmuxer_->SetParameter(param);
171 }
172
InnerAddTrack(int32_t & trackIndex,std::shared_ptr<Meta> trackDesc)173 int32_t AVMuxerDemo::InnerAddTrack(int32_t& trackIndex, std::shared_ptr<Meta> trackDesc)
174 {
175 cout << "InnerAddTrack" << endl;
176 if (avmuxer_ == nullptr) {
177 std::cout << "InnerMuxer create failed!" << std::endl;
178 return AVCS_ERR_NO_MEMORY;
179 }
180 return avmuxer_->AddTrack(trackIndex, trackDesc);
181 }
182
InnerStart()183 int32_t AVMuxerDemo::InnerStart()
184 {
185 cout << "InnerStart" << endl;
186 if (avmuxer_ == nullptr) {
187 std::cout << "InnerMuxer create failed!" << std::endl;
188 return AVCS_ERR_NO_MEMORY;
189 }
190 return avmuxer_->Start();
191 }
192
InnerWriteSample(uint32_t trackIndex,std::shared_ptr<AVBuffer> sample)193 int32_t AVMuxerDemo::InnerWriteSample(uint32_t trackIndex, std::shared_ptr<AVBuffer> sample)
194 {
195 cout << "InnerWriteSample" << endl;
196 if (avmuxer_ == nullptr) {
197 std::cout << "InnerMuxer create failed!" << std::endl;
198 return AVCS_ERR_NO_MEMORY;
199 }
200 return avmuxer_->WriteSample(trackIndex, sample);
201 }
202
InnerStop()203 int32_t AVMuxerDemo::InnerStop()
204 {
205 cout << "InnerStop" << endl;
206 if (avmuxer_ == nullptr) {
207 std::cout << "InnerMuxer create failed!" << std::endl;
208 return AVCS_ERR_NO_MEMORY;
209 }
210 return avmuxer_->Stop();
211 }
212
InnerDestroy()213 int32_t AVMuxerDemo::InnerDestroy()
214 {
215 cout << "InnerDestroy" << endl;
216 if (avmuxer_ == nullptr) {
217 std::cout << "InnerMuxer create failed!" << std::endl;
218 return AVCS_ERR_NO_MEMORY;
219 }
220 avmuxer_->~AVMuxer();
221 avmuxer_ = nullptr;
222 return AV_ERR_OK;
223 }