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 "testing/gtest/include/gtest/gtest.h" |
| 13 |
| 14 #include "webrtc/base/arraysize.h" |
| 15 #include "webrtc/modules/video_coding/codecs/h264/h264_video_toolbox_nalu.h" |
| 16 |
| 17 namespace webrtc { |
| 18 |
| 19 static const uint8_t NALU_TEST_DATA_0[] = {0xAA, 0xBB, 0xCC}; |
| 20 static const uint8_t NALU_TEST_DATA_1[] = {0xDE, 0xAD, 0xBE, 0xEF}; |
| 21 |
| 22 TEST(AnnexBBufferReaderTest, TestReadEmptyInput) { |
| 23 const uint8_t annex_b_test_data[] = {0x00}; |
| 24 AnnexBBufferReader reader(annex_b_test_data, 0); |
| 25 const uint8_t* nalu = nullptr; |
| 26 size_t nalu_length = 0; |
| 27 EXPECT_EQ(0u, reader.BytesRemaining()); |
| 28 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); |
| 29 EXPECT_EQ(nullptr, nalu); |
| 30 EXPECT_EQ(0u, nalu_length); |
| 31 } |
| 32 |
| 33 TEST(AnnexBBufferReaderTest, TestReadSingleNalu) { |
| 34 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x00, 0x01, 0xAA}; |
| 35 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); |
| 36 const uint8_t* nalu = nullptr; |
| 37 size_t nalu_length = 0; |
| 38 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); |
| 39 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); |
| 40 EXPECT_EQ(annex_b_test_data + 4, nalu); |
| 41 EXPECT_EQ(1u, nalu_length); |
| 42 EXPECT_EQ(0u, reader.BytesRemaining()); |
| 43 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); |
| 44 EXPECT_EQ(nullptr, nalu); |
| 45 EXPECT_EQ(0u, nalu_length); |
| 46 } |
| 47 |
| 48 TEST(AnnexBBufferReaderTest, TestReadMissingNalu) { |
| 49 // clang-format off |
| 50 const uint8_t annex_b_test_data[] = {0x01, |
| 51 0x00, 0x01, |
| 52 0x00, 0x00, 0x01, |
| 53 0x00, 0x00, 0x00, 0xFF}; |
| 54 // clang-format on |
| 55 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); |
| 56 const uint8_t* nalu = nullptr; |
| 57 size_t nalu_length = 0; |
| 58 EXPECT_EQ(0u, reader.BytesRemaining()); |
| 59 EXPECT_FALSE(reader.ReadNalu(&nalu, &nalu_length)); |
| 60 EXPECT_EQ(nullptr, nalu); |
| 61 EXPECT_EQ(0u, nalu_length); |
| 62 } |
| 63 |
| 64 TEST(AnnexBBufferReaderTest, TestReadMultipleNalus) { |
| 65 // clang-format off |
| 66 const uint8_t annex_b_test_data[] = {0x00, 0x00, 0x00, 0x01, 0xFF, |
| 67 0x01, |
| 68 0x00, 0x01, |
| 69 0x00, 0x00, 0x01, |
| 70 0x00, 0x00, 0x00, 0xFF, |
| 71 0x00, 0x00, 0x00, 0x01, 0xAA, 0xBB}; |
| 72 // clang-format on |
| 73 AnnexBBufferReader reader(annex_b_test_data, arraysize(annex_b_test_data)); |
| 74 const uint8_t* nalu = nullptr; |
| 75 size_t nalu_length = 0; |
| 76 EXPECT_EQ(arraysize(annex_b_test_data), reader.BytesRemaining()); |
| 77 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); |
| 78 EXPECT_EQ(annex_b_test_data + 4, nalu); |
| 79 EXPECT_EQ(11u, nalu_length); |
| 80 EXPECT_EQ(6u, reader.BytesRemaining()); |
| 81 EXPECT_TRUE(reader.ReadNalu(&nalu, &nalu_length)); |
| 82 EXPECT_EQ(annex_b_test_data + 19, nalu); |
| 83 EXPECT_EQ(2u, 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(AvccBufferWriterTest, TestEmptyOutputBuffer) { |
| 91 const uint8_t expected_buffer[] = {0x00}; |
| 92 const size_t buffer_size = 1; |
| 93 rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); |
| 94 memset(buffer.get(), 0, buffer_size); |
| 95 AvccBufferWriter writer(buffer.get(), 0); |
| 96 EXPECT_EQ(0u, writer.BytesRemaining()); |
| 97 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); |
| 98 EXPECT_EQ(0, |
| 99 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); |
| 100 } |
| 101 |
| 102 TEST(AvccBufferWriterTest, TestWriteSingleNalu) { |
| 103 const uint8_t expected_buffer[] = { |
| 104 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, |
| 105 }; |
| 106 const size_t buffer_size = arraysize(NALU_TEST_DATA_0) + 4; |
| 107 rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); |
| 108 AvccBufferWriter writer(buffer.get(), buffer_size); |
| 109 EXPECT_EQ(buffer_size, writer.BytesRemaining()); |
| 110 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); |
| 111 EXPECT_EQ(0u, writer.BytesRemaining()); |
| 112 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); |
| 113 EXPECT_EQ(0, |
| 114 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); |
| 115 } |
| 116 |
| 117 TEST(AvccBufferWriterTest, TestWriteMultipleNalus) { |
| 118 // clang-format off |
| 119 const uint8_t expected_buffer[] = { |
| 120 0x00, 0x00, 0x00, 0x03, 0xAA, 0xBB, 0xCC, |
| 121 0x00, 0x00, 0x00, 0x04, 0xDE, 0xAD, 0xBE, 0xEF |
| 122 }; |
| 123 // clang-format on |
| 124 const size_t buffer_size = |
| 125 arraysize(NALU_TEST_DATA_0) + arraysize(NALU_TEST_DATA_1) + 8; |
| 126 rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); |
| 127 AvccBufferWriter writer(buffer.get(), buffer_size); |
| 128 EXPECT_EQ(buffer_size, writer.BytesRemaining()); |
| 129 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); |
| 130 EXPECT_EQ(buffer_size - (arraysize(NALU_TEST_DATA_0) + 4), |
| 131 writer.BytesRemaining()); |
| 132 EXPECT_TRUE(writer.WriteNalu(NALU_TEST_DATA_1, arraysize(NALU_TEST_DATA_1))); |
| 133 EXPECT_EQ(0u, writer.BytesRemaining()); |
| 134 EXPECT_EQ(0, |
| 135 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); |
| 136 } |
| 137 |
| 138 TEST(AvccBufferWriterTest, TestOverflow) { |
| 139 const uint8_t expected_buffer[] = {0x00, 0x00, 0x00}; |
| 140 const size_t buffer_size = arraysize(NALU_TEST_DATA_0); |
| 141 rtc::scoped_ptr<uint8_t[]> buffer(new uint8_t[buffer_size]); |
| 142 memset(buffer.get(), 0, buffer_size); |
| 143 AvccBufferWriter writer(buffer.get(), buffer_size); |
| 144 EXPECT_EQ(buffer_size, writer.BytesRemaining()); |
| 145 EXPECT_FALSE(writer.WriteNalu(NALU_TEST_DATA_0, arraysize(NALU_TEST_DATA_0))); |
| 146 EXPECT_EQ(buffer_size, writer.BytesRemaining()); |
| 147 EXPECT_EQ(0, |
| 148 memcmp(expected_buffer, buffer.get(), arraysize(expected_buffer))); |
| 149 } |
| 150 |
| 151 } // namespace webrtc |
OLD | NEW |