| 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, TestReadSingleNalu3ByteHeader) { | |
| 91 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x01, 0xAA}; | |
| 92 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 93 const uint8_t* nalu = nullptr; | |
| 94 size_t nalu_length = 0; | |
| 95 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); | |
| 96 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 97 EXPECT_EQ(annex_b_test_data + 3, nalu); | |
| 98 EXPECT_EQ(1u, nalu_length); | |
| 99 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 100 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 101 EXPECT_EQ(nullptr, nalu); | |
| 102 EXPECT_EQ(0u, nalu_length); | |
| 103 } | |
| 104 | |
| 105 TEST(AnnexBBufferReaderTest, TestReadMissingNalu) { | |
| 106 // clang-format off | |
| 107 const uint8_t annex_b_test_data[] = {0x01, | |
| 108 0x00, 0x01, | |
| 109 0x00, 0x00, 0x00, 0xFF}; | |
| 110 // clang-format on | |
| 111 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 112 const uint8_t* nalu = nullptr; | |
| 113 size_t nalu_length = 0; | |
| 114 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 115 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 116 EXPECT_EQ(nullptr, nalu); | |
| 117 EXPECT_EQ(0u, nalu_length); | |
| 118 } | |
| 119 | |
| 120 TEST(AnnexBBufferReaderTest, TestReadMultipleNalus) { | |
| 121 // clang-format off | |
| 122 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x00, 0x01, 0xFF, | |
| 123 0x01, | |
| 124 0x00, 0x01, | |
| 125 0x00, 0x00, 0x00, 0xFF, | |
| 126 0x00, 0x00, 0x01, 0xAA, 0xBB}; | |
| 127 // clang-format on | |
| 128 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); | |
| 129 const uint8_t* nalu = nullptr; | |
| 130 size_t nalu_length = 0; | |
| 131 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); | |
| 132 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 133 EXPECT_EQ(annex_b_test_data + 4, nalu); | |
| 134 EXPECT_EQ(8u, nalu_length); | |
| 135 EXPECT_EQ(6u, reader.BytesRemaining()); | |
| 136 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 137 EXPECT_EQ(annex_b_test_data + 16, nalu); | |
| 138 EXPECT_EQ(2u, nalu_length); | |
| 139 EXPECT_EQ(0u, reader.BytesRemaining()); | |
| 140 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); | |
| 141 EXPECT_EQ(nullptr, nalu); | |
| 142 EXPECT_EQ(0u, nalu_length); | |
| 143 } | |
| 144 | |
| 145 TEST(AvccBufferWriterTest, TestEmptyOutputBuffer) { | |
| 146 const uint8_t expected_buffer[] = {0x00}; | |
| 147 const size_t buffer_size = 1; | |
| 148 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 149 memset(buffer.get(), 0, buffer_size); | |
| 150 AvccBufferWriter writer(buffer.get(), 0); | |
| 151 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 152 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 153 EXPECT_EQ(0, | |
| 154 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 155 } | |
| 156 | |
| 157 TEST(AvccBufferWriterTest, TestWriteSingleNalu) { | |
| 158 const uint8_t expected_buffer[] = { | |
| 159 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, | |
| 160 }; | |
| 161 const size_t buffer_size = arraysize(NALU_TEST_DATA_0) + 4; | |
| 162 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 163 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 164 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 165 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 166 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 167 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); | |
| 168 EXPECT_EQ(0, | |
| 169 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 170 } | |
| 171 | |
| 172 TEST(AvccBufferWriterTest, TestWriteMultipleNalus) { | |
| 173 // clang-format off | |
| 174 const uint8_t expected_buffer[] = { | |
| 175 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, | |
| 176 0x00, 0x00, 0x00, 0x04, 0xDE, 0xAD, 0xBE, 0xEF | |
| 177 }; | |
| 178 // clang-format on | |
| 179 const size_t buffer_size = | |
| 180 arraysize(NALU_TEST_DATA_0) + arraysize(NALU_TEST_DATA_1) + 8; | |
| 181 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 182 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 183 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 184 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 185 EXPECT_EQ(buffer_size - (arraysize(NALU_TEST_DATA_0) + 4), | |
| 186 writer.BytesRemaining()); | |
| 187 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); | |
| 188 EXPECT_EQ(0u, writer.BytesRemaining()); | |
| 189 EXPECT_EQ(0, | |
| 190 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 191 } | |
| 192 | |
| 193 TEST(AvccBufferWriterTest, TestOverflow) { | |
| 194 const uint8_t expected_buffer[] = {0x00, 0x00, 0x00}; | |
| 195 const size_t buffer_size = arraysize(NALU_TEST_DATA_0); | |
| 196 std::unique_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); | |
| 197 memset(buffer.get(), 0, buffer_size); | |
| 198 AvccBufferWriter writer(buffer.get(), buffer_size); | |
| 199 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 200 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); | |
| 201 EXPECT_EQ(buffer_size, writer.BytesRemaining()); | |
| 202 EXPECT_EQ(0, | |
| 203 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); | |
| 204 } | |
| 205 | |
| 206 } // namespace webrtc | |
| 207 | |
| 208 #endif // WEBRTC_VIDEO_TOOLBOX_SUPPORTED | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 2487723004:
Reland of Add a webrtc{en,de}coderfactory implementation for VideoToolbox (Closed)
