1 /*
2  * Copyright (C) 2020 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 // Unit Test for VideoTrackTranscoder
18 
19 // #define LOG_NDEBUG 0
20 #define LOG_TAG "VideoTrackTranscoderTests"
21 
22 #include <android-base/logging.h>
23 #include <android/binder_process.h>
24 #include <fcntl.h>
25 #include <gtest/gtest.h>
26 #include <media/MediaSampleReaderNDK.h>
27 #include <media/NdkCommon.h>
28 #include <media/VideoTrackTranscoder.h>
29 #include <utils/Timers.h>
30 
31 #include "TranscoderTestUtils.h"
32 
33 namespace android {
34 
35 // TODO(b/155304421): Implement more advanced video specific tests:
36 //  - Codec conversions (HEVC -> AVC).
37 //  - Bitrate validation.
38 //  - Output frame validation through PSNR.
39 
40 class VideoTrackTranscoderTests : public ::testing::Test {
41 public:
VideoTrackTranscoderTests()42     VideoTrackTranscoderTests() { LOG(DEBUG) << "VideoTrackTranscoderTests created"; }
43 
SetUp()44     void SetUp() override {
45         LOG(DEBUG) << "VideoTrackTranscoderTests set up";
46         const char* sourcePath =
47                 "/data/local/tmp/TranscodingTestAssets/cubicle_avc_480x240_aac_24KHz.mp4";
48 
49         const int sourceFd = open(sourcePath, O_RDONLY);
50         ASSERT_GT(sourceFd, 0);
51 
52         const off_t fileSize = lseek(sourceFd, 0, SEEK_END);
53         lseek(sourceFd, 0, SEEK_SET);
54 
55         mMediaSampleReader = MediaSampleReaderNDK::createFromFd(sourceFd, 0, fileSize);
56         ASSERT_NE(mMediaSampleReader, nullptr);
57         close(sourceFd);
58 
59         for (size_t trackIndex = 0; trackIndex < mMediaSampleReader->getTrackCount();
60              ++trackIndex) {
61             AMediaFormat* trackFormat = mMediaSampleReader->getTrackFormat(trackIndex);
62             ASSERT_NE(trackFormat, nullptr);
63 
64             const char* mime = nullptr;
65             AMediaFormat_getString(trackFormat, AMEDIAFORMAT_KEY_MIME, &mime);
66             ASSERT_NE(mime, nullptr);
67 
68             if (strncmp(mime, "video/", 6) == 0) {
69                 mTrackIndex = trackIndex;
70 
71                 mSourceFormat = std::shared_ptr<AMediaFormat>(trackFormat, &AMediaFormat_delete);
72                 ASSERT_NE(mSourceFormat, nullptr);
73 
74                 mDestinationFormat =
75                         TrackTranscoderTestUtils::getDefaultVideoDestinationFormat(trackFormat);
76                 ASSERT_NE(mDestinationFormat, nullptr);
77                 break;
78             }
79 
80             AMediaFormat_delete(trackFormat);
81         }
82 
83         ASSERT_NE(mSourceFormat, nullptr);
84     }
85 
TearDown()86     void TearDown() override { LOG(DEBUG) << "VideoTrackTranscoderTests tear down"; }
87 
~VideoTrackTranscoderTests()88     ~VideoTrackTranscoderTests() { LOG(DEBUG) << "VideoTrackTranscoderTests destroyed"; }
89 
getConfiguredBitrate(const std::shared_ptr<VideoTrackTranscoder> & transcoder)90     static int32_t getConfiguredBitrate(const std::shared_ptr<VideoTrackTranscoder>& transcoder) {
91         return transcoder->mConfiguredBitrate;
92     }
93 
94     std::shared_ptr<MediaSampleReader> mMediaSampleReader;
95     int mTrackIndex;
96     std::shared_ptr<AMediaFormat> mSourceFormat;
97     std::shared_ptr<AMediaFormat> mDestinationFormat;
98 };
99 
TEST_F(VideoTrackTranscoderTests,SampleSoundness)100 TEST_F(VideoTrackTranscoderTests, SampleSoundness) {
101     LOG(DEBUG) << "Testing SampleSoundness";
102     auto callback = std::make_shared<TestTrackTranscoderCallback>();
103     auto transcoder = VideoTrackTranscoder::create(callback);
104 
105     EXPECT_EQ(mMediaSampleReader->selectTrack(mTrackIndex), AMEDIA_OK);
106     EXPECT_EQ(transcoder->configure(mMediaSampleReader, mTrackIndex, mDestinationFormat),
107               AMEDIA_OK);
108     ASSERT_TRUE(transcoder->start());
109 
110     bool eos = false;
111     uint64_t sampleCount = 0;
112     transcoder->setSampleConsumer([&sampleCount, &eos](const std::shared_ptr<MediaSample>& sample) {
113         ASSERT_NE(sample, nullptr);
114         const uint32_t flags = sample->info.flags;
115 
116         if (sampleCount == 0) {
117             // Expect first sample to be a codec config.
118             EXPECT_TRUE((flags & SAMPLE_FLAG_CODEC_CONFIG) != 0);
119             EXPECT_TRUE((flags & SAMPLE_FLAG_SYNC_SAMPLE) == 0);
120             EXPECT_TRUE((flags & SAMPLE_FLAG_END_OF_STREAM) == 0);
121             EXPECT_TRUE((flags & SAMPLE_FLAG_PARTIAL_FRAME) == 0);
122         } else if (sampleCount == 1) {
123             // Expect second sample to be a sync sample.
124             EXPECT_TRUE((flags & SAMPLE_FLAG_CODEC_CONFIG) == 0);
125             EXPECT_TRUE((flags & SAMPLE_FLAG_SYNC_SAMPLE) != 0);
126             EXPECT_TRUE((flags & SAMPLE_FLAG_END_OF_STREAM) == 0);
127         }
128 
129         if (!(flags & SAMPLE_FLAG_END_OF_STREAM)) {
130             // Expect a valid buffer unless it is EOS.
131             EXPECT_NE(sample->buffer, nullptr);
132             EXPECT_NE(sample->bufferId, 0xBAADF00D);
133             EXPECT_GT(sample->info.size, 0);
134         } else {
135             EXPECT_FALSE(eos);
136             eos = true;
137         }
138 
139         ++sampleCount;
140     });
141 
142     EXPECT_EQ(callback->waitUntilFinished(), AMEDIA_OK);
143 }
144 
TEST_F(VideoTrackTranscoderTests,PreserveBitrate)145 TEST_F(VideoTrackTranscoderTests, PreserveBitrate) {
146     LOG(DEBUG) << "Testing PreserveBitrate";
147     auto callback = std::make_shared<TestTrackTranscoderCallback>();
148     auto transcoder = VideoTrackTranscoder::create(callback);
149 
150     auto destFormat = TrackTranscoderTestUtils::getDefaultVideoDestinationFormat(
151             mSourceFormat.get(), false /* includeBitrate*/);
152     EXPECT_NE(destFormat, nullptr);
153 
154     EXPECT_EQ(mMediaSampleReader->selectTrack(mTrackIndex), AMEDIA_OK);
155 
156     int32_t srcBitrate;
157     EXPECT_EQ(mMediaSampleReader->getEstimatedBitrateForTrack(mTrackIndex, &srcBitrate), AMEDIA_OK);
158 
159     ASSERT_EQ(transcoder->configure(mMediaSampleReader, mTrackIndex, destFormat), AMEDIA_OK);
160     ASSERT_TRUE(transcoder->start());
161 
162     callback->waitUntilTrackFormatAvailable();
163     transcoder->stop();
164     EXPECT_EQ(callback->waitUntilFinished(), AMEDIA_OK);
165 
166     int32_t outBitrate = getConfiguredBitrate(transcoder);
167     ASSERT_GT(outBitrate, 0);
168 
169     EXPECT_EQ(srcBitrate, outBitrate);
170 }
171 
172 // VideoTrackTranscoder needs a valid destination format.
TEST_F(VideoTrackTranscoderTests,NullDestinationFormat)173 TEST_F(VideoTrackTranscoderTests, NullDestinationFormat) {
174     LOG(DEBUG) << "Testing NullDestinationFormat";
175     auto callback = std::make_shared<TestTrackTranscoderCallback>();
176     std::shared_ptr<AMediaFormat> nullFormat;
177 
178     auto transcoder = VideoTrackTranscoder::create(callback);
179     EXPECT_EQ(transcoder->configure(mMediaSampleReader, 0 /* trackIndex */, nullFormat),
180               AMEDIA_ERROR_INVALID_PARAMETER);
181 }
182 
TEST_F(VideoTrackTranscoderTests,LingeringEncoder)183 TEST_F(VideoTrackTranscoderTests, LingeringEncoder) {
184     OneShotSemaphore semaphore;
185     auto callback = std::make_shared<TestTrackTranscoderCallback>();
186     auto transcoder = VideoTrackTranscoder::create(callback);
187 
188     EXPECT_EQ(mMediaSampleReader->selectTrack(mTrackIndex), AMEDIA_OK);
189     EXPECT_EQ(transcoder->configure(mMediaSampleReader, mTrackIndex, mDestinationFormat),
190               AMEDIA_OK);
191     ASSERT_TRUE(transcoder->start());
192 
193     std::vector<std::shared_ptr<MediaSample>> samples;
194     transcoder->setSampleConsumer(
195             [&samples, &semaphore](const std::shared_ptr<MediaSample>& sample) {
196                 if (samples.size() >= 4) return;
197 
198                 ASSERT_NE(sample, nullptr);
199                 samples.push_back(sample);
200 
201                 if (samples.size() == 4 || sample->info.flags & SAMPLE_FLAG_END_OF_STREAM) {
202                     semaphore.signal();
203                 }
204             });
205 
206     // Wait for the encoder to output samples before stopping and releasing the transcoder.
207     semaphore.wait();
208 
209     transcoder->stop();
210     EXPECT_EQ(callback->waitUntilFinished(), AMEDIA_OK);
211     transcoder.reset();
212 
213     // Return buffers to the codec so that it can resume processing, but keep one buffer to avoid
214     // the codec being released.
215     samples.resize(1);
216 
217     // Wait for async codec events.
218     std::this_thread::sleep_for(std::chrono::seconds(1));
219 }
220 
221 }  // namespace android
222 
main(int argc,char ** argv)223 int main(int argc, char** argv) {
224     ::testing::InitGoogleTest(&argc, argv);
225     ABinderProcess_startThreadPool();
226     return RUN_ALL_TESTS();
227 }
228