1 // Copyright 2014 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/webm/tracks_builder.h" 6 7 #include "base/logging.h" 8 #include "media/formats/webm/webm_constants.h" 9 10 namespace media { 11 12 // Returns size of an integer, formatted using Matroska serialization. 13 static int GetUIntMkvSize(uint64 value) { 14 if (value < 0x07FULL) 15 return 1; 16 if (value < 0x03FFFULL) 17 return 2; 18 if (value < 0x01FFFFFULL) 19 return 3; 20 if (value < 0x0FFFFFFFULL) 21 return 4; 22 if (value < 0x07FFFFFFFFULL) 23 return 5; 24 if (value < 0x03FFFFFFFFFFULL) 25 return 6; 26 if (value < 0x01FFFFFFFFFFFFULL) 27 return 7; 28 return 8; 29 } 30 31 // Returns the minimium size required to serialize an integer value. 32 static int GetUIntSize(uint64 value) { 33 if (value < 0x0100ULL) 34 return 1; 35 if (value < 0x010000ULL) 36 return 2; 37 if (value < 0x01000000ULL) 38 return 3; 39 if (value < 0x0100000000ULL) 40 return 4; 41 if (value < 0x010000000000ULL) 42 return 5; 43 if (value < 0x01000000000000ULL) 44 return 6; 45 if (value < 0x0100000000000000ULL) 46 return 7; 47 return 8; 48 } 49 50 static int MasterElementSize(int element_id, int payload_size) { 51 return GetUIntSize(element_id) + GetUIntMkvSize(payload_size) + payload_size; 52 } 53 54 static int UIntElementSize(int element_id, uint64 value) { 55 return GetUIntSize(element_id) + 1 + GetUIntSize(value); 56 } 57 58 static int DoubleElementSize(int element_id) { 59 return GetUIntSize(element_id) + 1 + 8; 60 } 61 62 static int StringElementSize(int element_id, const std::string& value) { 63 return GetUIntSize(element_id) + 64 GetUIntMkvSize(value.length()) + 65 value.length(); 66 } 67 68 static void SerializeInt(uint8** buf_ptr, int* buf_size_ptr, 69 int64 value, int size) { 70 uint8*& buf = *buf_ptr; 71 int& buf_size = *buf_size_ptr; 72 73 for (int idx = 1; idx <= size; ++idx) { 74 *buf++ = static_cast<uint8>(value >> ((size - idx) * 8)); 75 --buf_size; 76 } 77 } 78 79 static void SerializeDouble(uint8** buf_ptr, int* buf_size_ptr, 80 double value) { 81 // Use a union to convert |value| to native endian integer bit pattern. 82 union { 83 double src; 84 int64 dst; 85 } tmp; 86 tmp.src = value; 87 88 // Write the bytes from native endian |tmp.dst| to big-endian form in |buf|. 89 SerializeInt(buf_ptr, buf_size_ptr, tmp.dst, 8); 90 } 91 92 static void WriteElementId(uint8** buf, int* buf_size, int element_id) { 93 SerializeInt(buf, buf_size, element_id, GetUIntSize(element_id)); 94 } 95 96 static void WriteUInt(uint8** buf, int* buf_size, uint64 value) { 97 const int size = GetUIntMkvSize(value); 98 value |= (1ULL << (size * 7)); // Matroska formatting 99 SerializeInt(buf, buf_size, value, size); 100 } 101 102 static void WriteMasterElement(uint8** buf, int* buf_size, 103 int element_id, int payload_size) { 104 WriteElementId(buf, buf_size, element_id); 105 WriteUInt(buf, buf_size, payload_size); 106 } 107 108 static void WriteUIntElement(uint8** buf, 109 int* buf_size, 110 int element_id, 111 uint64 value) { 112 WriteElementId(buf, buf_size, element_id); 113 114 const int size = GetUIntSize(value); 115 WriteUInt(buf, buf_size, size); 116 117 SerializeInt(buf, buf_size, value, size); 118 } 119 120 static void WriteDoubleElement(uint8** buf, int* buf_size, 121 int element_id, double value) { 122 WriteElementId(buf, buf_size, element_id); 123 WriteUInt(buf, buf_size, 8); 124 SerializeDouble(buf, buf_size, value); 125 } 126 127 static void WriteStringElement(uint8** buf_ptr, int* buf_size_ptr, 128 int element_id, const std::string& value) { 129 uint8*& buf = *buf_ptr; 130 int& buf_size = *buf_size_ptr; 131 132 WriteElementId(&buf, &buf_size, element_id); 133 134 const uint64 size = value.length(); 135 WriteUInt(&buf, &buf_size, size); 136 137 memcpy(buf, value.data(), size); 138 buf += size; 139 buf_size -= size; 140 } 141 142 TracksBuilder::TracksBuilder(bool allow_invalid_values) 143 : allow_invalid_values_(allow_invalid_values) {} 144 TracksBuilder::TracksBuilder() 145 : allow_invalid_values_(false) {} 146 TracksBuilder::~TracksBuilder() {} 147 148 void TracksBuilder::AddVideoTrack(int track_num, 149 uint64 track_uid, 150 const std::string& codec_id, 151 const std::string& name, 152 const std::string& language, 153 int default_duration, 154 int video_pixel_width, 155 int video_pixel_height) { 156 AddTrackInternal(track_num, kWebMTrackTypeVideo, track_uid, codec_id, name, 157 language, default_duration, video_pixel_width, 158 video_pixel_height, -1, -1); 159 } 160 161 void TracksBuilder::AddAudioTrack(int track_num, 162 uint64 track_uid, 163 const std::string& codec_id, 164 const std::string& name, 165 const std::string& language, 166 int default_duration, 167 int audio_channels, 168 double audio_sampling_frequency) { 169 AddTrackInternal(track_num, kWebMTrackTypeAudio, track_uid, codec_id, name, 170 language, default_duration, -1, -1, audio_channels, 171 audio_sampling_frequency); 172 } 173 174 void TracksBuilder::AddTextTrack(int track_num, 175 uint64 track_uid, 176 const std::string& codec_id, 177 const std::string& name, 178 const std::string& language) { 179 AddTrackInternal(track_num, kWebMTrackTypeSubtitlesOrCaptions, track_uid, 180 codec_id, name, language, -1, -1, -1, -1, -1); 181 } 182 183 std::vector<uint8> TracksBuilder::Finish() { 184 // Allocate the storage 185 std::vector<uint8> buffer; 186 buffer.resize(GetTracksSize()); 187 188 // Populate the storage with a tracks header 189 WriteTracks(&buffer[0], buffer.size()); 190 191 return buffer; 192 } 193 194 void TracksBuilder::AddTrackInternal(int track_num, 195 int track_type, 196 uint64 track_uid, 197 const std::string& codec_id, 198 const std::string& name, 199 const std::string& language, 200 int default_duration, 201 int video_pixel_width, 202 int video_pixel_height, 203 int audio_channels, 204 double audio_sampling_frequency) { 205 tracks_.push_back(Track(track_num, track_type, track_uid, codec_id, name, 206 language, default_duration, video_pixel_width, 207 video_pixel_height, audio_channels, 208 audio_sampling_frequency, allow_invalid_values_)); 209 } 210 211 int TracksBuilder::GetTracksSize() const { 212 return MasterElementSize(kWebMIdTracks, GetTracksPayloadSize()); 213 } 214 215 int TracksBuilder::GetTracksPayloadSize() const { 216 int payload_size = 0; 217 218 for (TrackList::const_iterator itr = tracks_.begin(); 219 itr != tracks_.end(); ++itr) { 220 payload_size += itr->GetSize(); 221 } 222 223 return payload_size; 224 } 225 226 void TracksBuilder::WriteTracks(uint8* buf, int buf_size) const { 227 WriteMasterElement(&buf, &buf_size, kWebMIdTracks, GetTracksPayloadSize()); 228 229 for (TrackList::const_iterator itr = tracks_.begin(); 230 itr != tracks_.end(); ++itr) { 231 itr->Write(&buf, &buf_size); 232 } 233 } 234 235 TracksBuilder::Track::Track(int track_num, 236 int track_type, 237 uint64 track_uid, 238 const std::string& codec_id, 239 const std::string& name, 240 const std::string& language, 241 int default_duration, 242 int video_pixel_width, 243 int video_pixel_height, 244 int audio_channels, 245 double audio_sampling_frequency, 246 bool allow_invalid_values) 247 : track_num_(track_num), 248 track_type_(track_type), 249 track_uid_(track_uid), 250 codec_id_(codec_id), 251 name_(name), 252 language_(language), 253 default_duration_(default_duration), 254 video_pixel_width_(video_pixel_width), 255 video_pixel_height_(video_pixel_height), 256 audio_channels_(audio_channels), 257 audio_sampling_frequency_(audio_sampling_frequency) { 258 if (!allow_invalid_values) { 259 CHECK_GT(track_num_, 0); 260 CHECK_GT(track_type_, 0); 261 CHECK_LT(track_type_, 255); 262 CHECK_GT(track_uid_, 0); 263 if (track_type != kWebMTrackTypeVideo && 264 track_type != kWebMTrackTypeAudio) { 265 CHECK_EQ(default_duration_, -1); 266 } else { 267 CHECK(default_duration_ == -1 || default_duration_ > 0); 268 } 269 270 if (track_type == kWebMTrackTypeVideo) { 271 CHECK_GT(video_pixel_width_, 0); 272 CHECK_GT(video_pixel_height_, 0); 273 } else { 274 CHECK_EQ(video_pixel_width_, -1); 275 CHECK_EQ(video_pixel_height_, -1); 276 } 277 278 if (track_type == kWebMTrackTypeAudio) { 279 CHECK_GT(audio_channels_, 0); 280 CHECK_GT(audio_sampling_frequency_, 0.0); 281 } else { 282 CHECK_EQ(audio_channels_, -1); 283 CHECK_EQ(audio_sampling_frequency_, -1.0); 284 } 285 } 286 } 287 288 int TracksBuilder::Track::GetSize() const { 289 return MasterElementSize(kWebMIdTrackEntry, GetPayloadSize()); 290 } 291 292 int TracksBuilder::Track::GetVideoPayloadSize() const { 293 int payload_size = 0; 294 295 if (video_pixel_width_ >= 0) 296 payload_size += UIntElementSize(kWebMIdPixelWidth, video_pixel_width_); 297 if (video_pixel_height_ >= 0) 298 payload_size += UIntElementSize(kWebMIdPixelHeight, video_pixel_height_); 299 300 return payload_size; 301 } 302 303 int TracksBuilder::Track::GetAudioPayloadSize() const { 304 int payload_size = 0; 305 306 if (audio_channels_ >= 0) 307 payload_size += UIntElementSize(kWebMIdChannels, audio_channels_); 308 if (audio_sampling_frequency_ >= 0) 309 payload_size += DoubleElementSize(kWebMIdSamplingFrequency); 310 311 return payload_size; 312 } 313 314 int TracksBuilder::Track::GetPayloadSize() const { 315 int size = 0; 316 317 size += UIntElementSize(kWebMIdTrackNumber, track_num_); 318 size += UIntElementSize(kWebMIdTrackType, track_type_); 319 size += UIntElementSize(kWebMIdTrackUID, track_uid_); 320 321 if (default_duration_ >= 0) 322 size += UIntElementSize(kWebMIdDefaultDuration, default_duration_); 323 324 if (!codec_id_.empty()) 325 size += StringElementSize(kWebMIdCodecID, codec_id_); 326 327 if (!name_.empty()) 328 size += StringElementSize(kWebMIdName, name_); 329 330 if (!language_.empty()) 331 size += StringElementSize(kWebMIdLanguage, language_); 332 333 if (GetVideoPayloadSize() > 0) { 334 size += MasterElementSize(kWebMIdVideo, GetVideoPayloadSize()); 335 } 336 337 if (GetAudioPayloadSize() > 0) { 338 size += MasterElementSize(kWebMIdAudio, GetAudioPayloadSize()); 339 } 340 341 return size; 342 } 343 344 void TracksBuilder::Track::Write(uint8** buf, int* buf_size) const { 345 WriteMasterElement(buf, buf_size, kWebMIdTrackEntry, GetPayloadSize()); 346 347 WriteUIntElement(buf, buf_size, kWebMIdTrackNumber, track_num_); 348 WriteUIntElement(buf, buf_size, kWebMIdTrackType, track_type_); 349 WriteUIntElement(buf, buf_size, kWebMIdTrackUID, track_uid_); 350 351 if (default_duration_ >= 0) 352 WriteUIntElement(buf, buf_size, kWebMIdDefaultDuration, default_duration_); 353 354 if (!codec_id_.empty()) 355 WriteStringElement(buf, buf_size, kWebMIdCodecID, codec_id_); 356 357 if (!name_.empty()) 358 WriteStringElement(buf, buf_size, kWebMIdName, name_); 359 360 if (!language_.empty()) 361 WriteStringElement(buf, buf_size, kWebMIdLanguage, language_); 362 363 if (GetVideoPayloadSize() > 0) { 364 WriteMasterElement(buf, buf_size, kWebMIdVideo, GetVideoPayloadSize()); 365 366 if (video_pixel_width_ >= 0) 367 WriteUIntElement(buf, buf_size, kWebMIdPixelWidth, video_pixel_width_); 368 369 if (video_pixel_height_ >= 0) 370 WriteUIntElement(buf, buf_size, kWebMIdPixelHeight, video_pixel_height_); 371 } 372 373 if (GetAudioPayloadSize() > 0) { 374 WriteMasterElement(buf, buf_size, kWebMIdAudio, GetAudioPayloadSize()); 375 376 if (audio_channels_ >= 0) 377 WriteUIntElement(buf, buf_size, kWebMIdChannels, audio_channels_); 378 379 if (audio_sampling_frequency_ >= 0) { 380 WriteDoubleElement(buf, buf_size, kWebMIdSamplingFrequency, 381 audio_sampling_frequency_); 382 } 383 } 384 } 385 386 } // namespace media 387
