| OLD | NEW |
|---|
| (Empty) |
| 1 /* | |
| 2 * Copyright (c) 2015 The WebRTC project authors. All Rights Reserved. | |
| 3 * | |
| 4 * Use of this source code is governed by a BSD-style license | |
| 5 * that can be found in the LICENSE file in the root of the source | |
| 6 * tree. An additional intellectual property rights grant can be found | |
| 7 * in the file PATENTS. All contributing project authors may | |
| 8 * be found in the AUTHORS file in the root of the source tree. | |
| 9 * | |
| 10 */ | |
| 11 | |
| 12 #include <memory> | |
| 13 | |
| 14 #include "webrtc/base/arraysize.h" | |
| 15 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.h" | |
| 16 #include "webrtc/test/gtest.h" | |
| 17 | |
| 18 #if defined(WEBRTC_VIDEO_TOOLBOX_SUPPORTED) | |
| 19 | |
| 20 namespace webrtc { | |
| 21 | |
| 22 static const uint8_t NALU_TEST_DATA_0[] = {0xAA, 0xBB, 0xCC}; | |
| 23 static const uint8_t NALU_TEST_DATA_1[] = {0xDE, 0xAD, 0xBE, 0xEF}; | |
| 24 | |
| 25 TEST(H264VideoToolboxNaluTest, TestHasVideoFormatDescription) { | |
| 26 const uint8_t sps_buffer[] = {0x00, 0x00, 0x00, 0x01, 0x27}; | |
| 27 EXPECT_TRUE(H264AnnexBBufferHasVideoFormatDescription(sps_buffer, | |
| 28 arraysize(sps_buffer))); | |
| 29 const uint8_t aud_sps_buffer[] = {0x00, 0x00, 0x00, 0x01, 0x29, 0x10, | |
| 30 0x00, 0x00, 0x00, 0x01, 0x27, 0xFF}; | |
| 31 EXPECT_TRUE(H264AnnexBBufferHasVideoFormatDescription( | |
| 32 aud_sps_buffer, arraysize(aud_sps_buffer))); | |
| 33 const uint8_t other_buffer[] = {0x00, 0x00, 0x00, 0x01, 0x28}; | |
| 34 EXPECT_FALSE(H264AnnexBBufferHasVideoFormatDescription( | |
| 35 other_buffer, arraysize(other_buffer))); | |
| 36 const uint8_t aud_other_buffer[] = {0x00, 0x00, 0x00, 0x01, 0x29, | |
| 37 0x00, 0x00, 0x00, 0x01, 0x28}; | |
| 38 EXPECT_FALSE(H264AnnexBBufferHasVideoFormatDescription( | |
| 39 aud_other_buffer, arraysize(aud_other_buffer))); | |
| 40 } | |
| 41 | |
| 42 TEST(H264VideoToolboxNaluTest, TestCreateVideoFormatDescription) { | |
| 43 const uint8_t sps_pps_buffer[] = { | |
| 44 // SPS nalu. | |
| 45 0x00, 0x00, 0x00, 0x01, | |
| 46 0x27, 0x42, 0x00, 0x1E, 0xAB, 0x40, 0xF0, 0x28, 0xD3, 0x70, 0x20, 0x20, | |
| 47 0x20, 0x20, | |
| 48 // PPS nalu. | |
| 49 0x00, 0x00, 0x00, 0x01, | |
| 50 0x28, 0xCE, 0x3C, 0x30 | |
| 51 }; | |
| 52 CMVideoFormatDescriptionRef description = | |
| 53 CreateVideoFormatDescription(sps_pps_buffer, arraysize(sps_pps_buffer)); | |
| 54 EXPECT_TRUE(description); | |
| 55 if (description) { | |
| 56 CFRelease(description); | |
| 57 description = nullptr; | |
| 58 } | |
| 59 const uint8_t other_buffer[] = {0x00, 0x00, 0x00, 0x01, 0x28}; | |
| 60 EXPECT_FALSE(CreateVideoFormatDescription(other_buffer, | |
| 61 arraysize(other_buffer))); | |
| 62 } | |
| 63 | |
| 64 TEST(AnnexBBufferReaderTest, TestReadEmptyInput) { | |
| 65 const uint8_t annex_b_test_data[] = {0x00}; | |
| 66 AnnexBBufferReader reader(annex_b_test_data, 0); | |
| 67 const uint8_t* nalu = nullptr; | |
| 68 size_t nalu_length = 0; | |
| 69 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 70 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 71 EXPECT_EQ(nullptr, nalu); | |
| 72 EXPECT_EQ(0u, nalu_length); | |
| 73 } | |
| 74 | |
| 75 TEST(AnnexBBufferReaderTest, TestReadSingleNalu) { | |
| 76 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x00, 0x01, 0xAA}; | |
| 77 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 78 const uint8_t* nalu = nullptr; | |
| 79 size_t nalu_length = 0; | |
| 80 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); | |
| 81 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 82 EXPECT_EQ(annex_b_test_data + 4, nalu); | |
| 83 EXPECT_EQ(1u, nalu_length); | |
| 84 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 85 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 86 EXPECT_EQ(nullptr, nalu); | |
| 87 EXPECT_EQ(0u, nalu_length); | |
| 88 } | |
| 89 | |
| 90 TEST(AnnexBBufferReaderTest, TestReadMissingNalu) { | |
| 91 // clang-format off | |
| 92 const uint8_t annex_b_test_data[] = {0x01, | |
| 93 0x00, 0x01, | |
| 94 0x00, 0x00, 0x01, | |
| 95 0x00, 0x00, 0x00, 0xFF}; | |
| 96 // clang-format on | |
| 97 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 98 const uint8_t* nalu = nullptr; | |
| 99 size_t nalu_length = 0; | |
| 100 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 101 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 102 EXPECT_EQ(nullptr, nalu); | |
| 103 EXPECT_EQ(0u, nalu_length); | |
| 104 } | |
| 105 | |
| 106 TEST(AnnexBBufferReaderTest, TestReadMultipleNalus) { | |
| 107 // clang-format off | |
| 108 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x00, 0x01, 0xFF, | |
| 109 0x01, | |
| 110 0x00, 0x01, | |
| 111 0x00, 0x00, 0x01, | |
| 112 0x00, 0x00, 0x00, 0xFF, | |
| 113 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB}; | |
| 114 // clang-format on | |
| 115 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 116 const uint8_t* nalu = nullptr; | |
| 117 size_t nalu_length = 0; | |
| 118 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); | |
| 119 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 120 EXPECT_EQ(annex_b_test_data + 4, nalu); | |
| 121 EXPECT_EQ(11u, nalu_length); | |
| 122 EXPECT_EQ(6u, reader.BytesRemaining()); | |
| 123 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 124 EXPECT_EQ(annex_b_test_data + 19, nalu); | |
| 125 EXPECT_EQ(2u, nalu_length); | |
| 126 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 127 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 128 EXPECT_EQ(nullptr, nalu); | |
| 129 EXPECT_EQ(0u, nalu_length); | |
| 130 } | |
| 131 | |
| 132 TEST(AvccBufferWriterTest, TestEmptyOutputBuffer) { | |
| 133 const uint8_t expected_buffer[] = {0x00}; | |
| 134 const size_t buffer_size = 1; | |
| 135 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 136 memset(buffer.get(), 0, buffer_size); | |
| 137 AvccBufferWriter writer(buffer.get(), 0); | |
| 138 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 139 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 140 EXPECT_EQ(0, | |
| 141 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 142 } | |
| 143 | |
| 144 TEST(AvccBufferWriterTest, TestWriteSingleNalu) { | |
| 145 const uint8_t expected_buffer[] = { | |
| 146 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, | |
| 147 }; | |
| 148 const size_t buffer_size = arraysize(NALU_TEST_DATA_0) + 4; | |
| 149 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 150 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 151 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 152 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 153 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 154 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); | |
| 155 EXPECT_EQ(0, | |
| 156 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 157 } | |
| 158 | |
| 159 TEST(AvccBufferWriterTest, TestWriteMultipleNalus) { | |
| 160 // clang-format off | |
| 161 const uint8_t expected_buffer[] = { | |
| 162 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, | |
| 163 0x00, 0x00, 0x00, 0x04, 0xDE, 0xAD, 0xBE, 0xEF | |
| 164 }; | |
| 165 // clang-format on | |
| 166 const size_t buffer_size = | |
| 167 arraysize(NALU_TEST_DATA_0) + arraysize(NALU_TEST_DATA_1) + 8; | |
| 168 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 169 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 170 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 171 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 172 EXPECT_EQ(buffer_size - (arraysize(NALU_TEST_DATA_0) + 4), | |
| 173 writer.BytesRemaining()); | |
| 174 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); | |
| 175 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 176 EXPECT_EQ(0, | |
| 177 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 178 } | |
| 179 | |
| 180 TEST(AvccBufferWriterTest, TestOverflow) { | |
| 181 const uint8_t expected_buffer[] = {0x00, 0x00, 0x00}; | |
| 182 const size_t buffer_size = arraysize(NALU_TEST_DATA_0); | |
| 183 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 184 memset(buffer.get(), 0, buffer_size); | |
| 185 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 186 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 187 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 188 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 189 EXPECT_EQ(0, | |
| 190 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 191 } | |
| 192 | |
| 193 } // namespace webrtc | |
| 194 | |
| 195 #endif // WEBRTC_VIDEO_TOOLBOX_SUPPORTED | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2463313002:
Add a webrtc{en,de}coderfactory implementation for VideoToolbox (Closed)
