1 // Copyright 2013 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/mp3/mp3_stream_parser.h"
6
7 #include "base/bind.h"
8 #include "base/callback_helpers.h"
9 #include "base/message_loop/message_loop.h"
10 #include "media/base/bit_reader.h"
11 #include "media/base/buffers.h"
12 #include "media/base/stream_parser_buffer.h"
13 #include "media/base/text_track_config.h"
14 #include "media/base/video_decoder_config.h"
15 #include "net/http/http_util.h"
16
17 namespace media {
18
19 static const uint32 kMP3StartCodeMask = 0xffe00000;
20 static const uint32 kICYStartCode = 0x49435920; // 'ICY '
21
22 // Arbitrary upper bound on the size of an IceCast header before it
23 // triggers an error.
24 static const int kMaxIcecastHeaderSize = 4096;
25
26 static const uint32 kID3StartCodeMask = 0xffffff00;
27 static const uint32 kID3v1StartCode = 0x54414700; // 'TAG\0'
28 static const int kID3v1Size = 128;
29 static const int kID3v1ExtendedSize = 227;
30 static const uint32 kID3v2StartCode = 0x49443300; // 'ID3\0'
31
32 // Map that determines which bitrate_index & channel_mode combinations
33 // are allowed.
34 // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
35 static const bool kIsAllowed[17][4] = {
36 { true, true, true, true }, // free
37 { true, false, false, false }, // 32
38 { true, false, false, false }, // 48
39 { true, false, false, false }, // 56
40 { true, true, true, true }, // 64
41 { true, false, false, false }, // 80
42 { true, true, true, true }, // 96
43 { true, true, true, true }, // 112
44 { true, true, true, true }, // 128
45 { true, true, true, true }, // 160
46 { true, true, true, true }, // 192
47 { false, true, true, true }, // 224
48 { false, true, true, true }, // 256
49 { false, true, true, true }, // 320
50 { false, true, true, true }, // 384
51 { false, false, false, false } // bad
52 };
53
54 // Maps version and layer information in the frame header
55 // into an index for the |kBitrateMap|.
56 // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
57 static const int kVersionLayerMap[4][4] = {
58 // { reserved, L3, L2, L1 }
59 { 5, 4, 4, 3 }, // MPEG 2.5
60 { 5, 5, 5, 5 }, // reserved
61 { 5, 4, 4, 3 }, // MPEG 2
62 { 5, 2, 1, 0 } // MPEG 1
63 };
64
65 // Maps the bitrate index field in the header and an index
66 // from |kVersionLayerMap| to a frame bitrate.
67 // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
68 static const int kBitrateMap[16][6] = {
69 // { V1L1, V1L2, V1L3, V2L1, V2L2 & V2L3, reserved }
70 { 0, 0, 0, 0, 0, 0 },
71 { 32, 32, 32, 32, 8, 0 },
72 { 64, 48, 40, 48, 16, 0 },
73 { 96, 56, 48, 56, 24, 0 },
74 { 128, 64, 56, 64, 32, 0 },
75 { 160, 80, 64, 80, 40, 0 },
76 { 192, 96, 80, 96, 48, 0 },
77 { 224, 112, 96, 112, 56, 0 },
78 { 256, 128, 112, 128, 64, 0 },
79 { 288, 160, 128, 144, 80, 0 },
80 { 320, 192, 160, 160, 96, 0 },
81 { 352, 224, 192, 176, 112, 0 },
82 { 384, 256, 224, 192, 128, 0 },
83 { 416, 320, 256, 224, 144, 0 },
84 { 448, 384, 320, 256, 160, 0 },
85 { 0, 0, 0, 0, 0}
86 };
87
88 // Maps the sample rate index and version fields from the frame header
89 // to a sample rate.
90 // Derived from: http://mpgedit.org/mpgedit/mpeg_format/MP3Format.html
91 static const int kSampleRateMap[4][4] = {
92 // { V2.5, reserved, V2, V1 }
93 { 11025, 0, 22050, 44100 },
94 { 12000, 0, 24000, 48000 },
95 { 8000, 0, 16000, 32000 },
96 { 0, 0, 0, 0 }
97 };
98
99 // Frame header field constants.
100 static const int kVersion2 = 2;
101 static const int kVersionReserved = 1;
102 static const int kVersion2_5 = 0;
103 static const int kLayerReserved = 0;
104 static const int kLayer1 = 3;
105 static const int kLayer2 = 2;
106 static const int kLayer3 = 1;
107 static const int kBitrateFree = 0;
108 static const int kBitrateBad = 0xf;
109 static const int kSampleRateReserved = 3;
110
MP3StreamParser()111 MP3StreamParser::MP3StreamParser()
112 : state_(UNINITIALIZED),
113 in_media_segment_(false) {
114 }
115
~MP3StreamParser()116 MP3StreamParser::~MP3StreamParser() {}
117
Init(const InitCB & init_cb,const NewConfigCB & config_cb,const NewBuffersCB & new_buffers_cb,const NewTextBuffersCB & text_cb,const NeedKeyCB & need_key_cb,const NewMediaSegmentCB & new_segment_cb,const base::Closure & end_of_segment_cb,const LogCB & log_cb)118 void MP3StreamParser::Init(const InitCB& init_cb,
119 const NewConfigCB& config_cb,
120 const NewBuffersCB& new_buffers_cb,
121 const NewTextBuffersCB& text_cb,
122 const NeedKeyCB& need_key_cb,
123 const NewMediaSegmentCB& new_segment_cb,
124 const base::Closure& end_of_segment_cb,
125 const LogCB& log_cb) {
126 DVLOG(1) << __FUNCTION__;
127 DCHECK_EQ(state_, UNINITIALIZED);
128 init_cb_ = init_cb;
129 config_cb_ = config_cb;
130 new_buffers_cb_ = new_buffers_cb;
131 new_segment_cb_ = new_segment_cb;
132 end_of_segment_cb_ = end_of_segment_cb;
133 log_cb_ = log_cb;
134
135 ChangeState(INITIALIZED);
136 }
137
Flush()138 void MP3StreamParser::Flush() {
139 DVLOG(1) << __FUNCTION__;
140 DCHECK_NE(state_, UNINITIALIZED);
141 queue_.Reset();
142 timestamp_helper_->SetBaseTimestamp(base::TimeDelta());
143 in_media_segment_ = false;
144 }
145
Parse(const uint8 * buf,int size)146 bool MP3StreamParser::Parse(const uint8* buf, int size) {
147 DVLOG(1) << __FUNCTION__ << "(" << size << ")";
148 DCHECK(buf);
149 DCHECK_GT(size, 0);
150 DCHECK_NE(state_, UNINITIALIZED);
151
152 if (state_ == PARSE_ERROR)
153 return false;
154
155 DCHECK_EQ(state_, INITIALIZED);
156
157 queue_.Push(buf, size);
158
159 bool end_of_segment = true;
160 BufferQueue buffers;
161 for (;;) {
162 const uint8* data;
163 int data_size;
164 queue_.Peek(&data, &data_size);
165
166 if (data_size < 4)
167 break;
168
169 uint32 start_code = data[0] << 24 | data[1] << 16 | data[2] << 8 | data[3];
170 int bytes_read = 0;
171 bool parsed_metadata = true;
172 if ((start_code & kMP3StartCodeMask) == kMP3StartCodeMask) {
173 bytes_read = ParseMP3Frame(data, data_size, &buffers);
174
175 // Only allow the current segment to end if a full frame has been parsed.
176 end_of_segment = bytes_read > 0;
177 parsed_metadata = false;
178 } else if (start_code == kICYStartCode) {
179 bytes_read = ParseIcecastHeader(data, data_size);
180 } else if ((start_code & kID3StartCodeMask) == kID3v1StartCode) {
181 bytes_read = ParseID3v1(data, data_size);
182 } else if ((start_code & kID3StartCodeMask) == kID3v2StartCode) {
183 bytes_read = ParseID3v2(data, data_size);
184 } else {
185 bytes_read = FindNextValidStartCode(data, data_size);
186
187 if (bytes_read > 0) {
188 DVLOG(1) << "Unexpected start code 0x" << std::hex << start_code;
189 DVLOG(1) << "SKIPPING " << bytes_read << " bytes of garbage.";
190 }
191 }
192
193 CHECK_LE(bytes_read, data_size);
194
195 if (bytes_read < 0) {
196 ChangeState(PARSE_ERROR);
197 return false;
198 } else if (bytes_read == 0) {
199 // Need more data.
200 break;
201 }
202
203 // Send pending buffers if we have encountered metadata.
204 if (parsed_metadata && !buffers.empty() && !SendBuffers(&buffers, true))
205 return false;
206
207 queue_.Pop(bytes_read);
208 end_of_segment = true;
209 }
210
211 if (buffers.empty())
212 return true;
213
214 // Send buffers collected in this append that haven't been sent yet.
215 return SendBuffers(&buffers, end_of_segment);
216 }
217
ChangeState(State state)218 void MP3StreamParser::ChangeState(State state) {
219 DVLOG(1) << __FUNCTION__ << "() : " << state_ << " -> " << state;
220 state_ = state;
221 }
222
ParseFrameHeader(const uint8 * data,int size,int * frame_size,int * sample_rate,ChannelLayout * channel_layout,int * sample_count) const223 int MP3StreamParser::ParseFrameHeader(const uint8* data, int size,
224 int* frame_size,
225 int* sample_rate,
226 ChannelLayout* channel_layout,
227 int* sample_count) const {
228 DCHECK(data);
229 DCHECK_GE(size, 0);
230 DCHECK(frame_size);
231
232 if (size < 4)
233 return 0;
234
235 BitReader reader(data, size);
236 int sync;
237 int version;
238 int layer;
239 int is_protected;
240 int bitrate_index;
241 int sample_rate_index;
242 int has_padding;
243 int is_private;
244 int channel_mode;
245 int other_flags;
246
247 if (!reader.ReadBits(11, &sync) ||
248 !reader.ReadBits(2, &version) ||
249 !reader.ReadBits(2, &layer) ||
250 !reader.ReadBits(1, &is_protected) ||
251 !reader.ReadBits(4, &bitrate_index) ||
252 !reader.ReadBits(2, &sample_rate_index) ||
253 !reader.ReadBits(1, &has_padding) ||
254 !reader.ReadBits(1, &is_private) ||
255 !reader.ReadBits(2, &channel_mode) ||
256 !reader.ReadBits(6, &other_flags)) {
257 return -1;
258 }
259
260 DVLOG(2) << "Header data :" << std::hex
261 << " sync 0x" << sync
262 << " version 0x" << version
263 << " layer 0x" << layer
264 << " bitrate_index 0x" << bitrate_index
265 << " sample_rate_index 0x" << sample_rate_index
266 << " channel_mode 0x" << channel_mode;
267
268 if (sync != 0x7ff ||
269 version == kVersionReserved ||
270 layer == kLayerReserved ||
271 bitrate_index == kBitrateFree || bitrate_index == kBitrateBad ||
272 sample_rate_index == kSampleRateReserved) {
273 MEDIA_LOG(log_cb_) << "Invalid header data :" << std::hex
274 << " sync 0x" << sync
275 << " version 0x" << version
276 << " layer 0x" << layer
277 << " bitrate_index 0x" << bitrate_index
278 << " sample_rate_index 0x" << sample_rate_index
279 << " channel_mode 0x" << channel_mode;
280 return -1;
281 }
282
283 if (layer == kLayer2 && kIsAllowed[bitrate_index][channel_mode]) {
284 MEDIA_LOG(log_cb_) << "Invalid (bitrate_index, channel_mode) combination :"
285 << std::hex
286 << " bitrate_index " << bitrate_index
287 << " channel_mode " << channel_mode;
288 return -1;
289 }
290
291 int bitrate = kBitrateMap[bitrate_index][kVersionLayerMap[version][layer]];
292
293 if (bitrate == 0) {
294 MEDIA_LOG(log_cb_) << "Invalid bitrate :" << std::hex
295 << " version " << version
296 << " layer " << layer
297 << " bitrate_index " << bitrate_index;
298 return -1;
299 }
300
301 DVLOG(2) << " bitrate " << bitrate;
302
303 int frame_sample_rate = kSampleRateMap[sample_rate_index][version];
304 if (frame_sample_rate == 0) {
305 MEDIA_LOG(log_cb_) << "Invalid sample rate :" << std::hex
306 << " version " << version
307 << " sample_rate_index " << sample_rate_index;
308 return -1;
309 }
310
311 if (sample_rate)
312 *sample_rate = frame_sample_rate;
313
314 // http://teslabs.com/openplayer/docs/docs/specs/mp3_structure2.pdf
315 // Table 2.1.5
316 int samples_per_frame;
317 switch (layer) {
318 case kLayer1:
319 samples_per_frame = 384;
320 break;
321
322 case kLayer2:
323 samples_per_frame = 1152;
324 break;
325
326 case kLayer3:
327 if (version == kVersion2 || version == kVersion2_5)
328 samples_per_frame = 576;
329 else
330 samples_per_frame = 1152;
331 break;
332
333 default:
334 return -1;
335 }
336
337 if (sample_count)
338 *sample_count = samples_per_frame;
339
340 // http://teslabs.com/openplayer/docs/docs/specs/mp3_structure2.pdf
341 // Text just below Table 2.1.5.
342 if (layer == kLayer1) {
343 // This formulation is a slight variation on the equation below,
344 // but has slightly different truncation characteristics to deal
345 // with the fact that Layer 1 has 4 byte "slots" instead of single
346 // byte ones.
347 *frame_size = 4 * (12 * bitrate * 1000 / frame_sample_rate);
348 } else {
349 *frame_size =
350 ((samples_per_frame / 8) * bitrate * 1000) / frame_sample_rate;
351 }
352
353 if (has_padding)
354 *frame_size += (layer == kLayer1) ? 4 : 1;
355
356 if (channel_layout) {
357 // Map Stereo(0), Joint Stereo(1), and Dual Channel (2) to
358 // CHANNEL_LAYOUT_STEREO and Single Channel (3) to CHANNEL_LAYOUT_MONO.
359 *channel_layout =
360 (channel_mode == 3) ? CHANNEL_LAYOUT_MONO : CHANNEL_LAYOUT_STEREO;
361 }
362
363 return 4;
364 }
365
ParseMP3Frame(const uint8 * data,int size,BufferQueue * buffers)366 int MP3StreamParser::ParseMP3Frame(const uint8* data,
367 int size,
368 BufferQueue* buffers) {
369 DVLOG(2) << __FUNCTION__ << "(" << size << ")";
370
371 int sample_rate;
372 ChannelLayout channel_layout;
373 int frame_size;
374 int sample_count;
375 int bytes_read = ParseFrameHeader(
376 data, size, &frame_size, &sample_rate, &channel_layout, &sample_count);
377
378 if (bytes_read <= 0)
379 return bytes_read;
380
381 // Make sure data contains the entire frame.
382 if (size < frame_size)
383 return 0;
384
385 DVLOG(2) << " sample_rate " << sample_rate
386 << " channel_layout " << channel_layout
387 << " frame_size " << frame_size;
388
389 if (config_.IsValidConfig() &&
390 (config_.samples_per_second() != sample_rate ||
391 config_.channel_layout() != channel_layout)) {
392 // Clear config data so that a config change is initiated.
393 config_ = AudioDecoderConfig();
394
395 // Send all buffers associated with the previous config.
396 if (!buffers->empty() && !SendBuffers(buffers, true))
397 return -1;
398 }
399
400 if (!config_.IsValidConfig()) {
401 config_.Initialize(kCodecMP3, kSampleFormatF32, channel_layout,
402 sample_rate, NULL, 0, false, false,
403 base::TimeDelta(), base::TimeDelta());
404
405 base::TimeDelta base_timestamp;
406 if (timestamp_helper_)
407 base_timestamp = timestamp_helper_->GetTimestamp();
408
409 timestamp_helper_.reset(new AudioTimestampHelper(sample_rate));
410 timestamp_helper_->SetBaseTimestamp(base_timestamp);
411
412 VideoDecoderConfig video_config;
413 bool success = config_cb_.Run(config_, video_config, TextTrackConfigMap());
414
415 if (!init_cb_.is_null())
416 base::ResetAndReturn(&init_cb_).Run(success, kInfiniteDuration());
417
418 if (!success)
419 return -1;
420 }
421
422 scoped_refptr<StreamParserBuffer> buffer =
423 StreamParserBuffer::CopyFrom(data, frame_size, true);
424 buffer->set_timestamp(timestamp_helper_->GetTimestamp());
425 buffer->set_duration(timestamp_helper_->GetFrameDuration(sample_count));
426 buffers->push_back(buffer);
427
428 timestamp_helper_->AddFrames(sample_count);
429
430 return frame_size;
431 }
432
ParseIcecastHeader(const uint8 * data,int size)433 int MP3StreamParser::ParseIcecastHeader(const uint8* data, int size) {
434 DVLOG(1) << __FUNCTION__ << "(" << size << ")";
435
436 if (size < 4)
437 return 0;
438
439 if (memcmp("ICY ", data, 4))
440 return -1;
441
442 int locate_size = std::min(size, kMaxIcecastHeaderSize);
443 int offset = net::HttpUtil::LocateEndOfHeaders(
444 reinterpret_cast<const char*>(data), locate_size, 4);
445 if (offset < 0) {
446 if (locate_size == kMaxIcecastHeaderSize) {
447 MEDIA_LOG(log_cb_) << "Icecast header is too large.";
448 return -1;
449 }
450
451 return 0;
452 }
453
454 return offset;
455 }
456
ParseID3v1(const uint8 * data,int size)457 int MP3StreamParser::ParseID3v1(const uint8* data, int size) {
458 DVLOG(1) << __FUNCTION__ << "(" << size << ")";
459
460 if (size < kID3v1Size)
461 return 0;
462
463 // TODO(acolwell): Add code to actually validate ID3v1 data and
464 // expose it as a metadata text track.
465 return !memcmp(data, "TAG+", 4) ? kID3v1ExtendedSize : kID3v1Size;
466 }
467
ParseID3v2(const uint8 * data,int size)468 int MP3StreamParser::ParseID3v2(const uint8* data, int size) {
469 DVLOG(1) << __FUNCTION__ << "(" << size << ")";
470
471 if (size < 10)
472 return 0;
473
474 BitReader reader(data, size);
475 int32 id;
476 int version;
477 uint8 flags;
478 int32 id3_size;
479
480 if (!reader.ReadBits(24, &id) ||
481 !reader.ReadBits(16, &version) ||
482 !reader.ReadBits(8, &flags) ||
483 !ParseSyncSafeInt(&reader, &id3_size)) {
484 return -1;
485 }
486
487 int32 actual_tag_size = 10 + id3_size;
488
489 // Increment size if 'Footer present' flag is set.
490 if (flags & 0x10)
491 actual_tag_size += 10;
492
493 // Make sure we have the entire tag.
494 if (size < actual_tag_size)
495 return 0;
496
497 // TODO(acolwell): Add code to actually validate ID3v2 data and
498 // expose it as a metadata text track.
499 return actual_tag_size;
500 }
501
ParseSyncSafeInt(BitReader * reader,int32 * value)502 bool MP3StreamParser::ParseSyncSafeInt(BitReader* reader, int32* value) {
503 *value = 0;
504 for (int i = 0; i < 4; ++i) {
505 uint8 tmp;
506 if (!reader->ReadBits(1, &tmp) || tmp != 0) {
507 MEDIA_LOG(log_cb_) << "ID3 syncsafe integer byte MSb is not 0!";
508 return false;
509 }
510
511 if (!reader->ReadBits(7, &tmp))
512 return false;
513
514 *value <<= 7;
515 *value += tmp;
516 }
517
518 return true;
519 }
520
FindNextValidStartCode(const uint8 * data,int size) const521 int MP3StreamParser::FindNextValidStartCode(const uint8* data, int size) const {
522 const uint8* start = data;
523 const uint8* end = data + size;
524
525 while (start < end) {
526 int bytes_left = end - start;
527 const uint8* candidate_start_code =
528 static_cast<const uint8*>(memchr(start, 0xff, bytes_left));
529
530 if (!candidate_start_code)
531 return 0;
532
533 bool parse_header_failed = false;
534 const uint8* sync = candidate_start_code;
535 // Try to find 3 valid frames in a row. 3 was selected to decrease
536 // the probability of false positives.
537 for (int i = 0; i < 3; ++i) {
538 int sync_size = end - sync;
539 int frame_size;
540 int sync_bytes = ParseFrameHeader(
541 sync, sync_size, &frame_size, NULL, NULL, NULL);
542
543 if (sync_bytes == 0)
544 return 0;
545
546 if (sync_bytes > 0) {
547 DCHECK_LT(sync_bytes, sync_size);
548
549 // Skip over this frame so we can check the next one.
550 sync += frame_size;
551
552 // Make sure the next frame starts inside the buffer.
553 if (sync >= end)
554 return 0;
555 } else {
556 DVLOG(1) << "ParseFrameHeader() " << i << " failed @" << (sync - data);
557 parse_header_failed = true;
558 break;
559 }
560 }
561
562 if (parse_header_failed) {
563 // One of the frame header parses failed so |candidate_start_code|
564 // did not point to the start of a real frame. Move |start| forward
565 // so we can find the next candidate.
566 start = candidate_start_code + 1;
567 continue;
568 }
569
570 return candidate_start_code - data;
571 }
572
573 return 0;
574 }
575
SendBuffers(BufferQueue * buffers,bool end_of_segment)576 bool MP3StreamParser::SendBuffers(BufferQueue* buffers, bool end_of_segment) {
577 DCHECK(!buffers->empty());
578
579 if (!in_media_segment_) {
580 in_media_segment_ = true;
581 new_segment_cb_.Run();
582 }
583
584 BufferQueue empty_video_buffers;
585 if (!new_buffers_cb_.Run(*buffers, empty_video_buffers))
586 return false;
587 buffers->clear();
588
589 if (end_of_segment) {
590 in_media_segment_ = false;
591 end_of_segment_cb_.Run();
592 }
593
594 return true;
595 }
596
597 } // namespace media
598