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/webm_tracks_parser.h" 6 7 #include "base/logging.h" 8 #include "base/strings/string_number_conversions.h" 9 #include "base/strings/string_util.h" 10 #include "media/base/buffers.h" 11 #include "media/formats/webm/webm_constants.h" 12 #include "media/formats/webm/webm_content_encodings.h" 13 14 namespace media { 15 16 static TextKind CodecIdToTextKind(const std::string& codec_id) { 17 if (codec_id == kWebMCodecSubtitles) 18 return kTextSubtitles; 19 20 if (codec_id == kWebMCodecCaptions) 21 return kTextCaptions; 22 23 if (codec_id == kWebMCodecDescriptions) 24 return kTextDescriptions; 25 26 if (codec_id == kWebMCodecMetadata) 27 return kTextMetadata; 28 29 return kTextNone; 30 } 31 32 static base::TimeDelta PrecisionCappedDefaultDuration( 33 const double timecode_scale_in_us, const int64 duration_in_ns) { 34 if (duration_in_ns <= 0) 35 return kNoTimestamp(); 36 37 int64 mult = duration_in_ns / 1000; 38 mult /= timecode_scale_in_us; 39 if (mult == 0) 40 return kNoTimestamp(); 41 42 mult = static_cast<double>(mult) * timecode_scale_in_us; 43 return base::TimeDelta::FromMicroseconds(mult); 44 } 45 46 WebMTracksParser::WebMTracksParser(const LogCB& log_cb, bool ignore_text_tracks) 47 : track_type_(-1), 48 track_num_(-1), 49 seek_preroll_(-1), 50 codec_delay_(-1), 51 default_duration_(-1), 52 audio_track_num_(-1), 53 audio_default_duration_(-1), 54 video_track_num_(-1), 55 video_default_duration_(-1), 56 ignore_text_tracks_(ignore_text_tracks), 57 log_cb_(log_cb), 58 audio_client_(log_cb), 59 video_client_(log_cb) { 60 } 61 62 WebMTracksParser::~WebMTracksParser() {} 63 64 int WebMTracksParser::Parse(const uint8* buf, int size) { 65 track_type_ =-1; 66 track_num_ = -1; 67 default_duration_ = -1; 68 track_name_.clear(); 69 track_language_.clear(); 70 audio_track_num_ = -1; 71 audio_default_duration_ = -1; 72 audio_decoder_config_ = AudioDecoderConfig(); 73 video_track_num_ = -1; 74 video_default_duration_ = -1; 75 video_decoder_config_ = VideoDecoderConfig(); 76 text_tracks_.clear(); 77 ignored_tracks_.clear(); 78 79 WebMListParser parser(kWebMIdTracks, this); 80 int result = parser.Parse(buf, size); 81 82 if (result <= 0) 83 return result; 84 85 // For now we do all or nothing parsing. 86 return parser.IsParsingComplete() ? result : 0; 87 } 88 89 base::TimeDelta WebMTracksParser::GetAudioDefaultDuration( 90 const double timecode_scale_in_us) const { 91 return PrecisionCappedDefaultDuration(timecode_scale_in_us, 92 audio_default_duration_); 93 } 94 95 base::TimeDelta WebMTracksParser::GetVideoDefaultDuration( 96 const double timecode_scale_in_us) const { 97 return PrecisionCappedDefaultDuration(timecode_scale_in_us, 98 video_default_duration_); 99 } 100 101 WebMParserClient* WebMTracksParser::OnListStart(int id) { 102 if (id == kWebMIdContentEncodings) { 103 DCHECK(!track_content_encodings_client_.get()); 104 track_content_encodings_client_.reset( 105 new WebMContentEncodingsClient(log_cb_)); 106 return track_content_encodings_client_->OnListStart(id); 107 } 108 109 if (id == kWebMIdTrackEntry) { 110 track_type_ = -1; 111 track_num_ = -1; 112 default_duration_ = -1; 113 track_name_.clear(); 114 track_language_.clear(); 115 codec_id_ = ""; 116 codec_private_.clear(); 117 audio_client_.Reset(); 118 video_client_.Reset(); 119 return this; 120 } 121 122 if (id == kWebMIdAudio) 123 return &audio_client_; 124 125 if (id == kWebMIdVideo) 126 return &video_client_; 127 128 return this; 129 } 130 131 bool WebMTracksParser::OnListEnd(int id) { 132 if (id == kWebMIdContentEncodings) { 133 DCHECK(track_content_encodings_client_.get()); 134 return track_content_encodings_client_->OnListEnd(id); 135 } 136 137 if (id == kWebMIdTrackEntry) { 138 if (track_type_ == -1 || track_num_ == -1) { 139 MEDIA_LOG(log_cb_) << "Missing TrackEntry data for " 140 << " TrackType " << track_type_ 141 << " TrackNum " << track_num_; 142 return false; 143 } 144 145 if (track_type_ != kWebMTrackTypeAudio && 146 track_type_ != kWebMTrackTypeVideo && 147 track_type_ != kWebMTrackTypeSubtitlesOrCaptions && 148 track_type_ != kWebMTrackTypeDescriptionsOrMetadata) { 149 MEDIA_LOG(log_cb_) << "Unexpected TrackType " << track_type_; 150 return false; 151 } 152 153 TextKind text_track_kind = kTextNone; 154 if (track_type_ == kWebMTrackTypeSubtitlesOrCaptions) { 155 text_track_kind = CodecIdToTextKind(codec_id_); 156 if (text_track_kind == kTextNone) { 157 MEDIA_LOG(log_cb_) << "Missing TrackEntry CodecID" 158 << " TrackNum " << track_num_; 159 return false; 160 } 161 162 if (text_track_kind != kTextSubtitles && 163 text_track_kind != kTextCaptions) { 164 MEDIA_LOG(log_cb_) << "Wrong TrackEntry CodecID" 165 << " TrackNum " << track_num_; 166 return false; 167 } 168 } else if (track_type_ == kWebMTrackTypeDescriptionsOrMetadata) { 169 text_track_kind = CodecIdToTextKind(codec_id_); 170 if (text_track_kind == kTextNone) { 171 MEDIA_LOG(log_cb_) << "Missing TrackEntry CodecID" 172 << " TrackNum " << track_num_; 173 return false; 174 } 175 176 if (text_track_kind != kTextDescriptions && 177 text_track_kind != kTextMetadata) { 178 MEDIA_LOG(log_cb_) << "Wrong TrackEntry CodecID" 179 << " TrackNum " << track_num_; 180 return false; 181 } 182 } 183 184 std::string encryption_key_id; 185 if (track_content_encodings_client_) { 186 DCHECK(!track_content_encodings_client_->content_encodings().empty()); 187 // If we have multiple ContentEncoding in one track. Always choose the 188 // key id in the first ContentEncoding as the key id of the track. 189 encryption_key_id = track_content_encodings_client_-> 190 content_encodings()[0]->encryption_key_id(); 191 } 192 193 if (track_type_ == kWebMTrackTypeAudio) { 194 if (audio_track_num_ == -1) { 195 audio_track_num_ = track_num_; 196 audio_encryption_key_id_ = encryption_key_id; 197 198 if (default_duration_ == 0) { 199 MEDIA_LOG(log_cb_) << "Illegal 0ns audio TrackEntry DefaultDuration"; 200 return false; 201 } 202 audio_default_duration_ = default_duration_; 203 204 DCHECK(!audio_decoder_config_.IsValidConfig()); 205 if (!audio_client_.InitializeConfig( 206 codec_id_, codec_private_, seek_preroll_, codec_delay_, 207 !audio_encryption_key_id_.empty(), &audio_decoder_config_)) { 208 return false; 209 } 210 } else { 211 MEDIA_LOG(log_cb_) << "Ignoring audio track " << track_num_; 212 ignored_tracks_.insert(track_num_); 213 } 214 } else if (track_type_ == kWebMTrackTypeVideo) { 215 if (video_track_num_ == -1) { 216 video_track_num_ = track_num_; 217 video_encryption_key_id_ = encryption_key_id; 218 219 if (default_duration_ == 0) { 220 MEDIA_LOG(log_cb_) << "Illegal 0ns video TrackEntry DefaultDuration"; 221 return false; 222 } 223 video_default_duration_ = default_duration_; 224 225 DCHECK(!video_decoder_config_.IsValidConfig()); 226 if (!video_client_.InitializeConfig( 227 codec_id_, codec_private_, !video_encryption_key_id_.empty(), 228 &video_decoder_config_)) { 229 return false; 230 } 231 } else { 232 MEDIA_LOG(log_cb_) << "Ignoring video track " << track_num_; 233 ignored_tracks_.insert(track_num_); 234 } 235 } else if (track_type_ == kWebMTrackTypeSubtitlesOrCaptions || 236 track_type_ == kWebMTrackTypeDescriptionsOrMetadata) { 237 if (ignore_text_tracks_) { 238 MEDIA_LOG(log_cb_) << "Ignoring text track " << track_num_; 239 ignored_tracks_.insert(track_num_); 240 } else { 241 std::string track_num = base::Int64ToString(track_num_); 242 text_tracks_[track_num_] = TextTrackConfig( 243 text_track_kind, track_name_, track_language_, track_num); 244 } 245 } else { 246 MEDIA_LOG(log_cb_) << "Unexpected TrackType " << track_type_; 247 return false; 248 } 249 250 track_type_ = -1; 251 track_num_ = -1; 252 default_duration_ = -1; 253 track_name_.clear(); 254 track_language_.clear(); 255 codec_id_ = ""; 256 codec_private_.clear(); 257 track_content_encodings_client_.reset(); 258 259 audio_client_.Reset(); 260 video_client_.Reset(); 261 return true; 262 } 263 264 return true; 265 } 266 267 bool WebMTracksParser::OnUInt(int id, int64 val) { 268 int64* dst = NULL; 269 270 switch (id) { 271 case kWebMIdTrackNumber: 272 dst = &track_num_; 273 break; 274 case kWebMIdTrackType: 275 dst = &track_type_; 276 break; 277 case kWebMIdSeekPreRoll: 278 dst = &seek_preroll_; 279 break; 280 case kWebMIdCodecDelay: 281 dst = &codec_delay_; 282 break; 283 case kWebMIdDefaultDuration: 284 dst = &default_duration_; 285 break; 286 default: 287 return true; 288 } 289 290 if (*dst != -1) { 291 MEDIA_LOG(log_cb_) << "Multiple values for id " << std::hex << id 292 << " specified"; 293 return false; 294 } 295 296 *dst = val; 297 return true; 298 } 299 300 bool WebMTracksParser::OnFloat(int id, double val) { 301 return true; 302 } 303 304 bool WebMTracksParser::OnBinary(int id, const uint8* data, int size) { 305 if (id == kWebMIdCodecPrivate) { 306 if (!codec_private_.empty()) { 307 MEDIA_LOG(log_cb_) << "Multiple CodecPrivate fields in a track."; 308 return false; 309 } 310 codec_private_.assign(data, data + size); 311 return true; 312 } 313 return true; 314 } 315 316 bool WebMTracksParser::OnString(int id, const std::string& str) { 317 if (id == kWebMIdCodecID) { 318 if (!codec_id_.empty()) { 319 MEDIA_LOG(log_cb_) << "Multiple CodecID fields in a track"; 320 return false; 321 } 322 323 codec_id_ = str; 324 return true; 325 } 326 327 if (id == kWebMIdName) { 328 track_name_ = str; 329 return true; 330 } 331 332 if (id == kWebMIdLanguage) { 333 track_language_ = str; 334 return true; 335 } 336 337 return true; 338 } 339 340 } // namespace media 341
