OLD | NEW |
(Empty) | |
| 1 // Copyright 2015 The Chromium Authors. All rights reserved. |
| 2 // Use of this source code is governed by a BSD-style license that can be |
| 3 // found in the LICENSE file. |
| 4 |
| 5 #include "media/formats/mp2t/descriptors.h" |
| 6 |
| 7 #include <vector> |
| 8 |
| 9 #include "base/logging.h" |
| 10 #include "media/base/bit_reader.h" |
| 11 #include "media/formats/mp2t/mp2t_common.h" |
| 12 |
| 13 namespace media { |
| 14 namespace mp2t { |
| 15 |
| 16 namespace { |
| 17 |
| 18 // Tag values for various kinds of descriptors for which there is specific |
| 19 // parsing support herein. |
| 20 enum DescriptorTag { |
| 21 kDescriptorTagRegistration = 5, |
| 22 kDescriptorTagCA = 9, |
| 23 kDescriptorTagPrivateDataIndicator = 15, |
| 24 }; |
| 25 |
| 26 const int kCASystemIdCenc = 0x6365; // 'ce' |
| 27 |
| 28 class StringBitReader : public BitReader { |
| 29 public: |
| 30 StringBitReader(const std::string& input); |
| 31 ~StringBitReader() override; |
| 32 }; |
| 33 |
| 34 StringBitReader::StringBitReader(const std::string& input) |
| 35 : BitReader(reinterpret_cast<const uint8_t*>(input.data()), input.size()) {} |
| 36 |
| 37 StringBitReader::~StringBitReader() {} |
| 38 |
| 39 } // namespace |
| 40 |
| 41 Descriptors::Descriptors() {} |
| 42 |
| 43 Descriptors::~Descriptors() {} |
| 44 |
| 45 bool Descriptors::Read(BitReader* reader, int size) { |
| 46 DCHECK(reader); |
| 47 descriptors_.clear(); |
| 48 if (!size) |
| 49 return true; |
| 50 int initial_bits_read = reader->bits_read(); |
| 51 int bits_read = 0; |
| 52 int bits_available = reader->bits_available(); |
| 53 if (size > 0) { |
| 54 int size_in_bits = 8 * size; |
| 55 if (size_in_bits > bits_available) |
| 56 return false; |
| 57 bits_available = size_in_bits; |
| 58 } |
| 59 do { |
| 60 int tag; |
| 61 size_t length; |
| 62 RCHECK(reader->ReadBits(8, &tag)); |
| 63 RCHECK(reader->ReadBits(8, &length)); |
| 64 char data[256]; |
| 65 for (size_t i = 0; i < length; i++) { |
| 66 RCHECK(reader->ReadBits(8, &data[i])); |
| 67 } |
| 68 descriptors_.insert(Descriptor(tag, std::string(data, length))); |
| 69 bits_read = reader->bits_read() - initial_bits_read; |
| 70 } while (bits_read < bits_available); |
| 71 return bits_read == bits_available; |
| 72 } |
| 73 |
| 74 bool Descriptors::HasRegistrationDescriptor( |
| 75 int64* format_identifier, |
| 76 std::string* additional_info) const { |
| 77 DCHECK(format_identifier); |
| 78 auto search = descriptors_.find(kDescriptorTagRegistration); |
| 79 if (search == descriptors_.end()) |
| 80 return false; |
| 81 const std::string& data = search->second; |
| 82 StringBitReader reader(data); |
| 83 RCHECK(reader.ReadBits(32, format_identifier)); |
| 84 size_t extra_bits = reader.bits_available(); |
| 85 RCHECK(extra_bits % 8 == 0); |
| 86 RCHECK(reader.ReadString(extra_bits, additional_info)); |
| 87 return true; |
| 88 } |
| 89 |
| 90 bool Descriptors::HasCADescriptor(int* system_id, |
| 91 int* pid, |
| 92 std::string* private_data) const { |
| 93 DCHECK(system_id); |
| 94 DCHECK(pid); |
| 95 DCHECK(private_data); |
| 96 auto search = descriptors_.find(kDescriptorTagCA); |
| 97 if (search == descriptors_.end()) |
| 98 return false; |
| 99 const std::string& data = search->second; |
| 100 StringBitReader reader(data); |
| 101 RCHECK(reader.ReadBits(16, system_id)); |
| 102 RCHECK(reader.SkipBits(3)); |
| 103 RCHECK(reader.ReadBits(13, pid)); |
| 104 size_t extra_bits = reader.bits_available(); |
| 105 RCHECK(extra_bits % 8 == 0); |
| 106 RCHECK(reader.ReadString(extra_bits, private_data)); |
| 107 return true; |
| 108 } |
| 109 |
| 110 bool Descriptors::HasCADescriptorCenc(int* ca_pid, int* pssh_pid) const { |
| 111 int system_id; |
| 112 std::string private_data; |
| 113 if (!HasCADescriptor(&system_id, ca_pid, &private_data)) |
| 114 return false; |
| 115 if (system_id != kCASystemIdCenc) |
| 116 return false; |
| 117 StringBitReader reader(private_data); |
| 118 int64 scheme_type; |
| 119 int64 scheme_version; |
| 120 int num_systems; |
| 121 int encryption_algorithm; |
| 122 char pssh_system_id[16]; |
| 123 // TODO(dougsteed). Currently we don't check many of the following values. |
| 124 // When we flesh out this implementation to cover all of ISO/IEC 23001-9 we |
| 125 // will need to use and check these values. |
| 126 RCHECK(reader.ReadBits(32, &scheme_type)); |
| 127 RCHECK(reader.ReadBits(32, &scheme_version)); |
| 128 RCHECK(reader.ReadBits(8, &num_systems)); |
| 129 RCHECK(num_systems == 1); |
| 130 RCHECK(reader.ReadBits(24, &encryption_algorithm)); |
| 131 for (size_t i = 0; i < 16; i++) { |
| 132 RCHECK(reader.ReadBits(8, &pssh_system_id[i])); |
| 133 } |
| 134 RCHECK(reader.ReadBits(13, pssh_pid)); |
| 135 return true; |
| 136 } |
| 137 |
| 138 bool Descriptors::HasPrivateDataIndicator(int64 value) const { |
| 139 int64 private_data_indicator; |
| 140 auto search = descriptors_.find(kDescriptorTagPrivateDataIndicator); |
| 141 if (search == descriptors_.end()) |
| 142 return false; |
| 143 const std::string& data = search->second; |
| 144 StringBitReader reader(data); |
| 145 RCHECK(reader.ReadBits(32, &private_data_indicator)); |
| 146 RCHECK(reader.bits_available() == 0); |
| 147 return private_data_indicator = value; |
| 148 } |
| 149 |
| 150 } // namespace mp2t |
| 151 } // namespace media |
OLD | NEW |